« back to all changes in this revision
Viewing changes to debian/patches/lirc_dev-2.6.33.patch
- browse files at revision 131
- compare with another revision
- compare with revision 128
- download diff
- download tarball
- view history from revision 131
- Committer: Jon Raiford
- Date: 2010-04-10 22:44:59 UTC
- mfrom: (129.1.8 lirc)
- Revision ID: jon@raiford.org-20100410224459-pf4qy9gtxlft2upn
updated to latest sources
added
removed
debian/patches/lirc_dev-2.6.33.patch
1
## Description: add some description
2
## Origin/Author: add some origin or author
3
## Bug: bug URL
4
Index: lirc/drivers/lirc_dev/lirc_dev.h
5
===================================================================
6
--- lirc.orig/drivers/lirc_dev/lirc_dev.h 2010-03-27 23:44:10.259225130 -0500
7
+++ lirc/drivers/lirc_dev/lirc_dev.h 2010-03-27 23:44:08.163236533 -0500
8
@@ -4,7 +4,7 @@
9
* (L) by Artur Lipowski <alipowski@interia.pl>
10
* This code is licensed under GNU GPL
11
*
12
- * $Id: lirc_dev.h,v 1.37 2009/03/15 09:34:00 lirc Exp $
13
+ * $Id: lirc_dev.h,v 1.39 2010/01/23 16:28:07 lirc Exp $
14
*
15
*/
16
17
@@ -30,14 +30,19 @@
18
19
struct lirc_buffer {
20
wait_queue_head_t wait_poll;
21
- spinlock_t lock;
22
+ spinlock_t fifo_lock;
23
unsigned int chunk_size;
24
unsigned int size; /* in chunks */
25
/* Using chunks instead of bytes pretends to simplify boundary checking
26
* And should allow for some performance fine tunning later */
27
#ifdef LIRC_HAVE_KFIFO
28
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)
29
struct kfifo *fifo;
30
#else
31
+ struct kfifo fifo;
32
+ u8 fifo_initialized;
33
+#endif
34
+#else
35
unsigned int fill; /* in chunks */
36
int head, tail; /* in chunks */
37
unsigned char *data;
38
@@ -47,12 +52,12 @@
39
static inline void lirc_buffer_lock(struct lirc_buffer *buf,
40
unsigned long *flags)
41
{
42
- spin_lock_irqsave(&buf->lock, *flags);
43
+ spin_lock_irqsave(&buf->fifo_lock, *flags);
44
}
45
static inline void lirc_buffer_unlock(struct lirc_buffer *buf,
46
unsigned long *flags)
47
{
48
- spin_unlock_irqrestore(&buf->lock, *flags);
49
+ spin_unlock_irqrestore(&buf->fifo_lock, *flags);
50
}
51
static inline void _lirc_buffer_clear(struct lirc_buffer *buf)
52
{
53
@@ -64,10 +69,21 @@
54
static inline void lirc_buffer_clear(struct lirc_buffer *buf)
55
{
56
#ifdef LIRC_HAVE_KFIFO
57
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)
58
if (buf->fifo)
59
kfifo_reset(buf->fifo);
60
#else
61
unsigned long flags;
62
+
63
+ if (buf->fifo_initialized) {
64
+ spin_lock_irqsave(&buf->fifo_lock, flags);
65
+ kfifo_reset(&buf->fifo);
66
+ spin_unlock_irqrestore(&buf->fifo_lock, flags);
67
+ }
68
+#endif
69
+#else
70
+ unsigned long flags;
71
+
72
lirc_buffer_lock(buf, &flags);
73
_lirc_buffer_clear(buf);
74
lirc_buffer_unlock(buf, &flags);
75
@@ -77,31 +93,47 @@
76
unsigned int chunk_size,
77
unsigned int size)
78
{
79
+ int ret = 0;
80
+
81
init_waitqueue_head(&buf->wait_poll);
82
- spin_lock_init(&buf->lock);
83
+ spin_lock_init(&buf->fifo_lock);
84
#ifndef LIRC_HAVE_KFIFO
85
_lirc_buffer_clear(buf);
86
#endif
87
buf->chunk_size = chunk_size;
88
buf->size = size;
89
#ifdef LIRC_HAVE_KFIFO
90
- buf->fifo = kfifo_alloc(size*chunk_size, GFP_KERNEL, &buf->lock);
91
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)
92
+ buf->fifo = kfifo_alloc(size*chunk_size, GFP_KERNEL, &buf->fifo_lock);
93
if (!buf->fifo)
94
return -ENOMEM;
95
#else
96
+ ret = kfifo_alloc(&buf->fifo, size * chunk_size, GFP_KERNEL);
97
+ if (ret == 0)
98
+ buf->fifo_initialized = 1;
99
+#endif
100
+#else
101
buf->data = kmalloc(size*chunk_size, GFP_KERNEL);
102
if (buf->data == NULL)
103
return -ENOMEM;
104
memset(buf->data, 0, size*chunk_size);
105
#endif
106
- return 0;
107
+
108
+ return ret;
109
}
110
static inline void lirc_buffer_free(struct lirc_buffer *buf)
111
{
112
#ifdef LIRC_HAVE_KFIFO
113
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)
114
if (buf->fifo)
115
kfifo_free(buf->fifo);
116
#else
117
+ if (buf->fifo_initialized) {
118
+ kfifo_free(&buf->fifo);
119
+ buf->fifo_initialized = 0;
120
+ }
121
+#endif
122
+#else
123
kfree(buf->data);
124
buf->data = NULL;
125
buf->head = 0;
126
@@ -111,6 +143,25 @@
127
buf->size = 0;
128
#endif
129
}
130
+
131
+#ifdef LIRC_HAVE_KFIFO
132
+static inline int lirc_buffer_len(struct lirc_buffer *buf)
133
+{
134
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)
135
+ return kfifo_len(buf->fifo);
136
+#else
137
+ int len;
138
+ unsigned long flags;
139
+
140
+ spin_lock_irqsave(&buf->fifo_lock, flags);
141
+ len = kfifo_len(&buf->fifo);
142
+ spin_unlock_irqrestore(&buf->fifo_lock, flags);
143
+
144
+ return len;
145
+#endif
146
+}
147
+#endif
148
+
149
#ifndef LIRC_HAVE_KFIFO
150
static inline int _lirc_buffer_full(struct lirc_buffer *buf)
151
{
152
@@ -120,7 +171,7 @@
153
static inline int lirc_buffer_full(struct lirc_buffer *buf)
154
{
155
#ifdef LIRC_HAVE_KFIFO
156
- return kfifo_len(buf->fifo) == buf->size * buf->chunk_size;
157
+ return lirc_buffer_len(buf) == buf->size * buf->chunk_size;
158
#else
159
unsigned long flags;
160
int ret;
161
@@ -139,7 +190,7 @@
162
static inline int lirc_buffer_empty(struct lirc_buffer *buf)
163
{
164
#ifdef LIRC_HAVE_KFIFO
165
- return !kfifo_len(buf->fifo);
166
+ return !lirc_buffer_len(buf);
167
#else
168
unsigned long flags;
169
int ret;
170
@@ -158,7 +209,7 @@
171
static inline int lirc_buffer_available(struct lirc_buffer *buf)
172
{
173
#ifdef LIRC_HAVE_KFIFO
174
- return buf->size - (kfifo_len(buf->fifo) / buf->chunk_size);
175
+ return buf->size - (lirc_buffer_len(buf) / buf->chunk_size);
176
#else
177
unsigned long flags;
178
int ret;
179
@@ -177,21 +228,30 @@
180
buf->fill -= 1;
181
}
182
#endif
183
-static inline void lirc_buffer_read(struct lirc_buffer *buf,
184
- unsigned char *dest)
185
+static inline unsigned int lirc_buffer_read(struct lirc_buffer *buf,
186
+ unsigned char *dest)
187
{
188
+ unsigned int ret = 0;
189
+
190
#ifdef LIRC_HAVE_KFIFO
191
- if (kfifo_len(buf->fifo) >= buf->chunk_size)
192
- kfifo_get(buf->fifo, dest, buf->chunk_size);
193
+ if (lirc_buffer_len(buf) >= buf->chunk_size)
194
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)
195
+ ret = kfifo_get(buf->fifo, dest, buf->chunk_size);
196
+#else
197
+ ret = kfifo_out_locked(&buf->fifo, dest, buf->chunk_size,
198
+ &buf->fifo_lock);
199
+#endif
200
#else
201
unsigned long flags;
202
lirc_buffer_lock(buf, &flags);
203
_lirc_buffer_read_1(buf, dest);
204
lirc_buffer_unlock(buf, &flags);
205
#endif
206
+
207
+ return ret;
208
}
209
#ifndef LIRC_HAVE_KFIFO
210
-static inline void _lirc_buffer_write_1(struct lirc_buffer *buf,
211
+static inline _lirc_buffer_write_1(struct lirc_buffer *buf,
212
unsigned char *orig)
213
{
214
memcpy(&buf->data[buf->tail*buf->chunk_size], orig, buf->chunk_size);
215
@@ -199,17 +259,26 @@
216
buf->fill++;
217
}
218
#endif
219
-static inline void lirc_buffer_write(struct lirc_buffer *buf,
220
- unsigned char *orig)
221
+static inline unsigned int lirc_buffer_write(struct lirc_buffer *buf,
222
+ unsigned char *orig)
223
{
224
+ unsigned int ret = 0;
225
+
226
#ifdef LIRC_HAVE_KFIFO
227
- kfifo_put(buf->fifo, orig, buf->chunk_size);
228
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)
229
+ ret = kfifo_put(buf->fifo, orig, buf->chunk_size);
230
+#else
231
+ ret = kfifo_in_locked(&buf->fifo, orig, buf->chunk_size,
232
+ &buf->fifo_lock);
233
+#endif
234
#else
235
unsigned long flags;
236
lirc_buffer_lock(buf, &flags);
237
_lirc_buffer_write_1(buf, orig);
238
lirc_buffer_unlock(buf, &flags);
239
#endif
240
+
241
+ return ret;
242
}
243
#ifndef LIRC_HAVE_KFIFO
244
static inline void _lirc_buffer_write_n(struct lirc_buffer *buf,
245
@@ -234,17 +303,26 @@
246
buf->fill += count;
247
}
248
#endif
249
-static inline void lirc_buffer_write_n(struct lirc_buffer *buf,
250
- unsigned char *orig, int count)
251
+static inline unsigned int lirc_buffer_write_n(struct lirc_buffer *buf,
252
+ unsigned char *orig, int count)
253
{
254
+ unsigned int ret = 0;
255
+
256
#ifdef LIRC_HAVE_KFIFO
257
- kfifo_put(buf->fifo, orig, count * buf->chunk_size);
258
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)
259
+ ret = kfifo_put(buf->fifo, orig, count * buf->chunk_size);
260
+#else
261
+ ret = kfifo_in_locked(&buf->fifo, orig, count * buf->chunk_size,
262
+ &buf->fifo_lock);
263
+#endif
264
#else
265
unsigned long flags;
266
lirc_buffer_lock(buf, &flags);
267
_lirc_buffer_write_n(buf, orig, count);
268
lirc_buffer_unlock(buf, &flags);
269
#endif
270
+
271
+ return ret;
272
}
273
274
struct lirc_driver {
Loggerhead is a web-based interface for Breezy
Version: 2.0.1