V4L/DVB (3573): Cxusb: remove FIXME: comment in bluebird_patch_dvico_firmware_download
[linux-2.6] / drivers / ieee1394 / iso.c
1 /*
2  * IEEE 1394 for Linux
3  *
4  * kernel ISO transmission/reception
5  *
6  * Copyright (C) 2002 Maas Digital LLC
7  *
8  * This code is licensed under the GPL.  See the file COPYING in the root
9  * directory of the kernel sources for details.
10  */
11
12 #include <linux/slab.h>
13 #include <linux/sched.h>
14 #include "iso.h"
15
16 void hpsb_iso_stop(struct hpsb_iso *iso)
17 {
18         if (!(iso->flags & HPSB_ISO_DRIVER_STARTED))
19                 return;
20
21         iso->host->driver->isoctl(iso, iso->type == HPSB_ISO_XMIT ?
22                                   XMIT_STOP : RECV_STOP, 0);
23         iso->flags &= ~HPSB_ISO_DRIVER_STARTED;
24 }
25
26 void hpsb_iso_shutdown(struct hpsb_iso *iso)
27 {
28         if (iso->flags & HPSB_ISO_DRIVER_INIT) {
29                 hpsb_iso_stop(iso);
30                 iso->host->driver->isoctl(iso, iso->type == HPSB_ISO_XMIT ?
31                                           XMIT_SHUTDOWN : RECV_SHUTDOWN, 0);
32                 iso->flags &= ~HPSB_ISO_DRIVER_INIT;
33         }
34
35         dma_region_free(&iso->data_buf);
36         kfree(iso);
37 }
38
39 static struct hpsb_iso *hpsb_iso_common_init(struct hpsb_host *host,
40                                              enum hpsb_iso_type type,
41                                              unsigned int data_buf_size,
42                                              unsigned int buf_packets,
43                                              int channel, int dma_mode,
44                                              int irq_interval,
45                                              void (*callback) (struct hpsb_iso
46                                                                *))
47 {
48         struct hpsb_iso *iso;
49         int dma_direction;
50
51         /* make sure driver supports the ISO API */
52         if (!host->driver->isoctl) {
53                 printk(KERN_INFO
54                        "ieee1394: host driver '%s' does not support the rawiso API\n",
55                        host->driver->name);
56                 return NULL;
57         }
58
59         /* sanitize parameters */
60
61         if (buf_packets < 2)
62                 buf_packets = 2;
63
64         if ((dma_mode < HPSB_ISO_DMA_DEFAULT)
65             || (dma_mode > HPSB_ISO_DMA_PACKET_PER_BUFFER))
66                 dma_mode = HPSB_ISO_DMA_DEFAULT;
67
68         if ((irq_interval < 0) || (irq_interval > buf_packets / 4))
69                 irq_interval = buf_packets / 4;
70         if (irq_interval == 0)  /* really interrupt for each packet */
71                 irq_interval = 1;
72
73         if (channel < -1 || channel >= 64)
74                 return NULL;
75
76         /* channel = -1 is OK for multi-channel recv but not for xmit */
77         if (type == HPSB_ISO_XMIT && channel < 0)
78                 return NULL;
79
80         /* allocate and write the struct hpsb_iso */
81
82         iso =
83             kmalloc(sizeof(*iso) +
84                     buf_packets * sizeof(struct hpsb_iso_packet_info),
85                     GFP_KERNEL);
86         if (!iso)
87                 return NULL;
88
89         iso->infos = (struct hpsb_iso_packet_info *)(iso + 1);
90
91         iso->type = type;
92         iso->host = host;
93         iso->hostdata = NULL;
94         iso->callback = callback;
95         init_waitqueue_head(&iso->waitq);
96         iso->channel = channel;
97         iso->irq_interval = irq_interval;
98         iso->dma_mode = dma_mode;
99         dma_region_init(&iso->data_buf);
100         iso->buf_size = PAGE_ALIGN(data_buf_size);
101         iso->buf_packets = buf_packets;
102         iso->pkt_dma = 0;
103         iso->first_packet = 0;
104         spin_lock_init(&iso->lock);
105
106         if (iso->type == HPSB_ISO_XMIT) {
107                 iso->n_ready_packets = iso->buf_packets;
108                 dma_direction = PCI_DMA_TODEVICE;
109         } else {
110                 iso->n_ready_packets = 0;
111                 dma_direction = PCI_DMA_FROMDEVICE;
112         }
113
114         atomic_set(&iso->overflows, 0);
115         iso->bytes_discarded = 0;
116         iso->flags = 0;
117         iso->prebuffer = 0;
118
119         /* allocate the packet buffer */
120         if (dma_region_alloc
121             (&iso->data_buf, iso->buf_size, host->pdev, dma_direction))
122                 goto err;
123
124         return iso;
125
126       err:
127         hpsb_iso_shutdown(iso);
128         return NULL;
129 }
130
131 int hpsb_iso_n_ready(struct hpsb_iso *iso)
132 {
133         unsigned long flags;
134         int val;
135
136         spin_lock_irqsave(&iso->lock, flags);
137         val = iso->n_ready_packets;
138         spin_unlock_irqrestore(&iso->lock, flags);
139
140         return val;
141 }
142
143 struct hpsb_iso *hpsb_iso_xmit_init(struct hpsb_host *host,
144                                     unsigned int data_buf_size,
145                                     unsigned int buf_packets,
146                                     int channel,
147                                     int speed,
148                                     int irq_interval,
149                                     void (*callback) (struct hpsb_iso *))
150 {
151         struct hpsb_iso *iso = hpsb_iso_common_init(host, HPSB_ISO_XMIT,
152                                                     data_buf_size, buf_packets,
153                                                     channel,
154                                                     HPSB_ISO_DMA_DEFAULT,
155                                                     irq_interval, callback);
156         if (!iso)
157                 return NULL;
158
159         iso->speed = speed;
160
161         /* tell the driver to start working */
162         if (host->driver->isoctl(iso, XMIT_INIT, 0))
163                 goto err;
164
165         iso->flags |= HPSB_ISO_DRIVER_INIT;
166         return iso;
167
168       err:
169         hpsb_iso_shutdown(iso);
170         return NULL;
171 }
172
173 struct hpsb_iso *hpsb_iso_recv_init(struct hpsb_host *host,
174                                     unsigned int data_buf_size,
175                                     unsigned int buf_packets,
176                                     int channel,
177                                     int dma_mode,
178                                     int irq_interval,
179                                     void (*callback) (struct hpsb_iso *))
180 {
181         struct hpsb_iso *iso = hpsb_iso_common_init(host, HPSB_ISO_RECV,
182                                                     data_buf_size, buf_packets,
183                                                     channel, dma_mode,
184                                                     irq_interval, callback);
185         if (!iso)
186                 return NULL;
187
188         /* tell the driver to start working */
189         if (host->driver->isoctl(iso, RECV_INIT, 0))
190                 goto err;
191
192         iso->flags |= HPSB_ISO_DRIVER_INIT;
193         return iso;
194
195       err:
196         hpsb_iso_shutdown(iso);
197         return NULL;
198 }
199
200 int hpsb_iso_recv_listen_channel(struct hpsb_iso *iso, unsigned char channel)
201 {
202         if (iso->type != HPSB_ISO_RECV || iso->channel != -1 || channel >= 64)
203                 return -EINVAL;
204         return iso->host->driver->isoctl(iso, RECV_LISTEN_CHANNEL, channel);
205 }
206
207 int hpsb_iso_recv_unlisten_channel(struct hpsb_iso *iso, unsigned char channel)
208 {
209         if (iso->type != HPSB_ISO_RECV || iso->channel != -1 || channel >= 64)
210                 return -EINVAL;
211         return iso->host->driver->isoctl(iso, RECV_UNLISTEN_CHANNEL, channel);
212 }
213
214 int hpsb_iso_recv_set_channel_mask(struct hpsb_iso *iso, u64 mask)
215 {
216         if (iso->type != HPSB_ISO_RECV || iso->channel != -1)
217                 return -EINVAL;
218         return iso->host->driver->isoctl(iso, RECV_SET_CHANNEL_MASK,
219                                          (unsigned long)&mask);
220 }
221
222 int hpsb_iso_recv_flush(struct hpsb_iso *iso)
223 {
224         if (iso->type != HPSB_ISO_RECV)
225                 return -EINVAL;
226         return iso->host->driver->isoctl(iso, RECV_FLUSH, 0);
227 }
228
229 static int do_iso_xmit_start(struct hpsb_iso *iso, int cycle)
230 {
231         int retval = iso->host->driver->isoctl(iso, XMIT_START, cycle);
232         if (retval)
233                 return retval;
234
235         iso->flags |= HPSB_ISO_DRIVER_STARTED;
236         return retval;
237 }
238
239 int hpsb_iso_xmit_start(struct hpsb_iso *iso, int cycle, int prebuffer)
240 {
241         if (iso->type != HPSB_ISO_XMIT)
242                 return -1;
243
244         if (iso->flags & HPSB_ISO_DRIVER_STARTED)
245                 return 0;
246
247         if (cycle < -1)
248                 cycle = -1;
249         else if (cycle >= 8000)
250                 cycle %= 8000;
251
252         iso->xmit_cycle = cycle;
253
254         if (prebuffer < 0)
255                 prebuffer = iso->buf_packets - 1;
256         else if (prebuffer == 0)
257                 prebuffer = 1;
258
259         if (prebuffer >= iso->buf_packets)
260                 prebuffer = iso->buf_packets - 1;
261
262         iso->prebuffer = prebuffer;
263
264         /* remember the starting cycle; DMA will commence from xmit_queue_packets()
265            once enough packets have been buffered */
266         iso->start_cycle = cycle;
267
268         return 0;
269 }
270
271 int hpsb_iso_recv_start(struct hpsb_iso *iso, int cycle, int tag_mask, int sync)
272 {
273         int retval = 0;
274         int isoctl_args[3];
275
276         if (iso->type != HPSB_ISO_RECV)
277                 return -1;
278
279         if (iso->flags & HPSB_ISO_DRIVER_STARTED)
280                 return 0;
281
282         if (cycle < -1)
283                 cycle = -1;
284         else if (cycle >= 8000)
285                 cycle %= 8000;
286
287         isoctl_args[0] = cycle;
288
289         if (tag_mask < 0)
290                 /* match all tags */
291                 tag_mask = 0xF;
292         isoctl_args[1] = tag_mask;
293
294         isoctl_args[2] = sync;
295
296         retval =
297             iso->host->driver->isoctl(iso, RECV_START,
298                                       (unsigned long)&isoctl_args[0]);
299         if (retval)
300                 return retval;
301
302         iso->flags |= HPSB_ISO_DRIVER_STARTED;
303         return retval;
304 }
305
306 /* check to make sure the user has not supplied bogus values of offset/len
307    that would cause the kernel to access memory outside the buffer */
308
309 static int hpsb_iso_check_offset_len(struct hpsb_iso *iso,
310                                      unsigned int offset, unsigned short len,
311                                      unsigned int *out_offset,
312                                      unsigned short *out_len)
313 {
314         if (offset >= iso->buf_size)
315                 return -EFAULT;
316
317         /* make sure the packet does not go beyond the end of the buffer */
318         if (offset + len > iso->buf_size)
319                 return -EFAULT;
320
321         /* check for wrap-around */
322         if (offset + len < offset)
323                 return -EFAULT;
324
325         /* now we can trust 'offset' and 'length' */
326         *out_offset = offset;
327         *out_len = len;
328
329         return 0;
330 }
331
332 int hpsb_iso_xmit_queue_packet(struct hpsb_iso *iso, u32 offset, u16 len,
333                                u8 tag, u8 sy)
334 {
335         struct hpsb_iso_packet_info *info;
336         unsigned long flags;
337         int rv;
338
339         if (iso->type != HPSB_ISO_XMIT)
340                 return -EINVAL;
341
342         /* is there space in the buffer? */
343         if (iso->n_ready_packets <= 0) {
344                 return -EBUSY;
345         }
346
347         info = &iso->infos[iso->first_packet];
348
349         /* check for bogus offset/length */
350         if (hpsb_iso_check_offset_len
351             (iso, offset, len, &info->offset, &info->len))
352                 return -EFAULT;
353
354         info->tag = tag;
355         info->sy = sy;
356
357         spin_lock_irqsave(&iso->lock, flags);
358
359         rv = iso->host->driver->isoctl(iso, XMIT_QUEUE, (unsigned long)info);
360         if (rv)
361                 goto out;
362
363         /* increment cursors */
364         iso->first_packet = (iso->first_packet + 1) % iso->buf_packets;
365         iso->xmit_cycle = (iso->xmit_cycle + 1) % 8000;
366         iso->n_ready_packets--;
367
368         if (iso->prebuffer != 0) {
369                 iso->prebuffer--;
370                 if (iso->prebuffer <= 0) {
371                         iso->prebuffer = 0;
372                         rv = do_iso_xmit_start(iso, iso->start_cycle);
373                 }
374         }
375
376       out:
377         spin_unlock_irqrestore(&iso->lock, flags);
378         return rv;
379 }
380
381 int hpsb_iso_xmit_sync(struct hpsb_iso *iso)
382 {
383         if (iso->type != HPSB_ISO_XMIT)
384                 return -EINVAL;
385
386         return wait_event_interruptible(iso->waitq,
387                                         hpsb_iso_n_ready(iso) ==
388                                         iso->buf_packets);
389 }
390
391 void hpsb_iso_packet_sent(struct hpsb_iso *iso, int cycle, int error)
392 {
393         unsigned long flags;
394         spin_lock_irqsave(&iso->lock, flags);
395
396         /* predict the cycle of the next packet to be queued */
397
398         /* jump ahead by the number of packets that are already buffered */
399         cycle += iso->buf_packets - iso->n_ready_packets;
400         cycle %= 8000;
401
402         iso->xmit_cycle = cycle;
403         iso->n_ready_packets++;
404         iso->pkt_dma = (iso->pkt_dma + 1) % iso->buf_packets;
405
406         if (iso->n_ready_packets == iso->buf_packets || error != 0) {
407                 /* the buffer has run empty! */
408                 atomic_inc(&iso->overflows);
409         }
410
411         spin_unlock_irqrestore(&iso->lock, flags);
412 }
413
414 void hpsb_iso_packet_received(struct hpsb_iso *iso, u32 offset, u16 len,
415                               u16 total_len, u16 cycle, u8 channel, u8 tag,
416                               u8 sy)
417 {
418         unsigned long flags;
419         spin_lock_irqsave(&iso->lock, flags);
420
421         if (iso->n_ready_packets == iso->buf_packets) {
422                 /* overflow! */
423                 atomic_inc(&iso->overflows);
424                 /* Record size of this discarded packet */
425                 iso->bytes_discarded += total_len;
426         } else {
427                 struct hpsb_iso_packet_info *info = &iso->infos[iso->pkt_dma];
428                 info->offset = offset;
429                 info->len = len;
430                 info->total_len = total_len;
431                 info->cycle = cycle;
432                 info->channel = channel;
433                 info->tag = tag;
434                 info->sy = sy;
435
436                 iso->pkt_dma = (iso->pkt_dma + 1) % iso->buf_packets;
437                 iso->n_ready_packets++;
438         }
439
440         spin_unlock_irqrestore(&iso->lock, flags);
441 }
442
443 int hpsb_iso_recv_release_packets(struct hpsb_iso *iso, unsigned int n_packets)
444 {
445         unsigned long flags;
446         unsigned int i;
447         int rv = 0;
448
449         if (iso->type != HPSB_ISO_RECV)
450                 return -1;
451
452         spin_lock_irqsave(&iso->lock, flags);
453         for (i = 0; i < n_packets; i++) {
454                 rv = iso->host->driver->isoctl(iso, RECV_RELEASE,
455                                                (unsigned long)&iso->infos[iso->
456                                                                           first_packet]);
457                 if (rv)
458                         break;
459
460                 iso->first_packet = (iso->first_packet + 1) % iso->buf_packets;
461                 iso->n_ready_packets--;
462
463                 /* release memory from packets discarded when queue was full  */
464                 if (iso->n_ready_packets == 0) {        /* Release only after all prior packets handled */
465                         if (iso->bytes_discarded != 0) {
466                                 struct hpsb_iso_packet_info inf;
467                                 inf.total_len = iso->bytes_discarded;
468                                 iso->host->driver->isoctl(iso, RECV_RELEASE,
469                                                           (unsigned long)&inf);
470                                 iso->bytes_discarded = 0;
471                         }
472                 }
473         }
474         spin_unlock_irqrestore(&iso->lock, flags);
475         return rv;
476 }
477
478 void hpsb_iso_wake(struct hpsb_iso *iso)
479 {
480         wake_up_interruptible(&iso->waitq);
481
482         if (iso->callback)
483                 iso->callback(iso);
484 }