Merge branch 'upstream-fixes' into upstream
[linux-2.6] / drivers / isdn / hisax / st5481_usb.c
1 /*
2  * Driver for ST5481 USB ISDN modem
3  *
4  * Author       Frode Isaksen
5  * Copyright    2001 by Frode Isaksen      <fisaksen@bewan.com>
6  *              2001 by Kai Germaschewski  <kai.germaschewski@gmx.de>
7  * 
8  * This software may be used and distributed according to the terms
9  * of the GNU General Public License, incorporated herein by reference.
10  *
11  */
12
13 #include <linux/init.h>
14 #include <linux/usb.h>
15 #include <linux/slab.h>
16 #include "st5481.h"
17
18 static int st5481_isoc_flatten(struct urb *urb);
19
20 /* ======================================================================
21  * control pipe
22  */
23
24 /*
25  * Send the next endpoint 0 request stored in the FIFO.
26  * Called either by the completion or by usb_ctrl_msg.
27  */
28 static void usb_next_ctrl_msg(struct urb *urb,
29                               struct st5481_adapter *adapter)
30 {
31         struct st5481_ctrl *ctrl = &adapter->ctrl;
32         int r_index;
33
34         if (test_and_set_bit(0, &ctrl->busy)) {
35                 return;
36         }
37
38         if ((r_index = fifo_remove(&ctrl->msg_fifo.f)) < 0) {
39                 test_and_clear_bit(0,&ctrl->busy);
40                 return;
41         } 
42         urb->setup_packet = 
43                 (unsigned char *)&ctrl->msg_fifo.data[r_index];
44         
45         DBG(1,"request=0x%02x,value=0x%04x,index=%x",
46             ((struct ctrl_msg *)urb->setup_packet)->dr.bRequest,
47             ((struct ctrl_msg *)urb->setup_packet)->dr.wValue,
48             ((struct ctrl_msg *)urb->setup_packet)->dr.wIndex);
49
50         // Prepare the URB
51         urb->dev = adapter->usb_dev;
52
53         SUBMIT_URB(urb, GFP_ATOMIC);
54 }
55
56 /*
57  * Asynchronous endpoint 0 request (async version of usb_control_msg).
58  * The request will be queued up in a FIFO if the endpoint is busy.
59  */
60 static void usb_ctrl_msg(struct st5481_adapter *adapter,
61                          u8 request, u8 requesttype, u16 value, u16 index,
62                          ctrl_complete_t complete, void *context)
63 {
64         struct st5481_ctrl *ctrl = &adapter->ctrl;
65         int w_index;
66         struct ctrl_msg *ctrl_msg;
67         
68         if ((w_index = fifo_add(&ctrl->msg_fifo.f)) < 0) {
69                 WARN("control msg FIFO full");
70                 return;
71         }
72         ctrl_msg = &ctrl->msg_fifo.data[w_index]; 
73    
74         ctrl_msg->dr.bRequestType = requesttype;
75         ctrl_msg->dr.bRequest = request;
76         ctrl_msg->dr.wValue = cpu_to_le16p(&value);
77         ctrl_msg->dr.wIndex = cpu_to_le16p(&index);
78         ctrl_msg->dr.wLength = 0;
79         ctrl_msg->complete = complete;
80         ctrl_msg->context = context;
81
82         usb_next_ctrl_msg(ctrl->urb, adapter);
83 }
84
85 /*
86  * Asynchronous endpoint 0 device request.
87  */
88 void st5481_usb_device_ctrl_msg(struct st5481_adapter *adapter,
89                          u8 request, u16 value,
90                          ctrl_complete_t complete, void *context)
91 {
92         usb_ctrl_msg(adapter, request, 
93                      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 
94                      value, 0, complete, context);
95 }
96
97 /*
98  * Asynchronous pipe reset (async version of usb_clear_halt).
99  */
100 void st5481_usb_pipe_reset(struct st5481_adapter *adapter,
101                     u_char pipe,
102                     ctrl_complete_t complete, void *context)
103 {
104         DBG(1,"pipe=%02x",pipe);
105
106         usb_ctrl_msg(adapter,
107                      USB_REQ_CLEAR_FEATURE, USB_DIR_OUT | USB_RECIP_ENDPOINT,
108                      0, pipe, complete, context);
109 }
110
111
112 /*
113   Physical level functions
114 */
115
116 void st5481_ph_command(struct st5481_adapter *adapter, unsigned int command)
117 {
118         DBG(8,"command=%s", ST5481_CMD_string(command));
119
120         st5481_usb_device_ctrl_msg(adapter, TXCI, command, NULL, NULL);
121 }
122
123 /*
124  * The request on endpoint 0 has completed.
125  * Call the user provided completion routine and try
126  * to send the next request.
127  */
128 static void usb_ctrl_complete(struct urb *urb, struct pt_regs *regs)
129 {
130         struct st5481_adapter *adapter = urb->context;
131         struct st5481_ctrl *ctrl = &adapter->ctrl;
132         struct ctrl_msg *ctrl_msg;
133         
134         if (unlikely(urb->status < 0)) {
135                 switch (urb->status) {
136                         case -ENOENT:
137                         case -ESHUTDOWN:
138                         case -ECONNRESET:
139                                 DBG(1,"urb killed status %d", urb->status);
140                                 return; // Give up
141                         default: 
142                                 WARN("urb status %d",urb->status);
143                                 break;
144                 }
145         }
146
147         ctrl_msg = (struct ctrl_msg *)urb->setup_packet;
148         
149         if (ctrl_msg->dr.bRequest == USB_REQ_CLEAR_FEATURE) {
150                 /* Special case handling for pipe reset */
151                 le16_to_cpus(&ctrl_msg->dr.wIndex);
152
153                 /* toggle is reset on clear */
154                 usb_settoggle(adapter->usb_dev, 
155                               ctrl_msg->dr.wIndex & ~USB_DIR_IN, 
156                               (ctrl_msg->dr.wIndex & USB_DIR_IN) == 0,
157                               0);
158
159
160         }
161         
162         if (ctrl_msg->complete)
163                 ctrl_msg->complete(ctrl_msg->context);
164
165         clear_bit(0, &ctrl->busy);
166         
167         // Try to send next control message
168         usb_next_ctrl_msg(urb, adapter);
169         return;
170 }
171
172 /* ======================================================================
173  * interrupt pipe
174  */
175
176 /*
177  * The interrupt endpoint will be called when any
178  * of the 6 registers changes state (depending on masks).
179  * Decode the register values and schedule a private event.
180  * Called at interrupt.
181  */
182 static void usb_int_complete(struct urb *urb, struct pt_regs *regs)
183 {
184         u8 *data = urb->transfer_buffer;
185         u8 irqbyte;
186         struct st5481_adapter *adapter = urb->context;
187         int j;
188         int status;
189
190         switch (urb->status) {
191                 case 0:
192                         /* success */
193                         break;
194                 case -ECONNRESET:
195                 case -ENOENT:
196                 case -ESHUTDOWN:
197                         /* this urb is terminated, clean up */
198                         DBG(2, "urb shutting down with status: %d", urb->status);
199                         return;
200                 default:
201                         WARN("nonzero urb status received: %d", urb->status);
202                         goto exit;
203         }
204
205         
206         DBG_PACKET(2, data, INT_PKT_SIZE);
207                 
208         if (urb->actual_length == 0) {
209                 goto exit;
210         }
211
212         irqbyte = data[MPINT];
213         if (irqbyte & DEN_INT)
214                 FsmEvent(&adapter->d_out.fsm, EV_DOUT_DEN, NULL);
215
216         if (irqbyte & DCOLL_INT)
217                 FsmEvent(&adapter->d_out.fsm, EV_DOUT_COLL, NULL);
218
219         irqbyte = data[FFINT_D];
220         if (irqbyte & OUT_UNDERRUN)
221                 FsmEvent(&adapter->d_out.fsm, EV_DOUT_UNDERRUN, NULL);
222
223         if (irqbyte & OUT_DOWN)
224 ;//             printk("OUT_DOWN\n");
225
226         irqbyte = data[MPINT];
227         if (irqbyte & RXCI_INT)
228                 FsmEvent(&adapter->l1m, data[CCIST] & 0x0f, NULL);
229
230         for (j = 0; j < 2; j++)
231                 adapter->bcs[j].b_out.flow_event |= data[FFINT_B1 + j];
232
233         urb->actual_length = 0;
234
235 exit:
236         status = usb_submit_urb (urb, GFP_ATOMIC);
237         if (status)
238                 WARN("usb_submit_urb failed with result %d", status);
239 }
240
241 /* ======================================================================
242  * initialization
243  */
244
245 int st5481_setup_usb(struct st5481_adapter *adapter)
246 {
247         struct usb_device *dev = adapter->usb_dev;
248         struct st5481_ctrl *ctrl = &adapter->ctrl;
249         struct st5481_intr *intr = &adapter->intr;
250         struct usb_interface *intf;
251         struct usb_host_interface *altsetting = NULL;
252         struct usb_host_endpoint *endpoint;
253         int status;
254         struct urb *urb;
255         u8 *buf;
256         
257         DBG(2,"");
258         
259         if ((status = usb_reset_configuration (dev)) < 0) {
260                 WARN("reset_configuration failed,status=%d",status);
261                 return status;
262         }
263
264         intf = usb_ifnum_to_if(dev, 0);
265         if (intf)
266                 altsetting = usb_altnum_to_altsetting(intf, 3);
267         if (!altsetting)
268                 return -ENXIO;
269
270         // Check if the config is sane
271         if ( altsetting->desc.bNumEndpoints != 7 ) {
272                 WARN("expecting 7 got %d endpoints!", altsetting->desc.bNumEndpoints);
273                 return -EINVAL;
274         }
275
276         // The descriptor is wrong for some early samples of the ST5481 chip
277         altsetting->endpoint[3].desc.wMaxPacketSize = __constant_cpu_to_le16(32);
278         altsetting->endpoint[4].desc.wMaxPacketSize = __constant_cpu_to_le16(32);
279
280         // Use alternative setting 3 on interface 0 to have 2B+D
281         if ((status = usb_set_interface (dev, 0, 3)) < 0) {
282                 WARN("usb_set_interface failed,status=%d",status);
283                 return status;
284         }
285
286         // Allocate URB for control endpoint
287         urb = usb_alloc_urb(0, GFP_KERNEL);
288         if (!urb) {
289                 return -ENOMEM;
290         }
291         ctrl->urb = urb;
292         
293         // Fill the control URB
294         usb_fill_control_urb (urb, dev, 
295                           usb_sndctrlpipe(dev, 0),
296                           NULL, NULL, 0, usb_ctrl_complete, adapter);
297
298                 
299         fifo_init(&ctrl->msg_fifo.f, ARRAY_SIZE(ctrl->msg_fifo.data));
300
301         // Allocate URBs and buffers for interrupt endpoint
302         urb = usb_alloc_urb(0, GFP_KERNEL);
303         if (!urb) { 
304                 return -ENOMEM;
305         }
306         intr->urb = urb;
307         
308         buf = kmalloc(INT_PKT_SIZE, GFP_KERNEL);
309         if (!buf) {
310                 return -ENOMEM;
311         }
312
313         endpoint = &altsetting->endpoint[EP_INT-1];
314                                 
315         // Fill the interrupt URB
316         usb_fill_int_urb(urb, dev,
317                      usb_rcvintpipe(dev, endpoint->desc.bEndpointAddress),
318                      buf, INT_PKT_SIZE,
319                      usb_int_complete, adapter,
320                      endpoint->desc.bInterval);
321                 
322         return 0;
323 }
324
325 /*
326  * Release buffers and URBs for the interrupt and control
327  * endpoint.
328  */
329 void st5481_release_usb(struct st5481_adapter *adapter)
330 {
331         struct st5481_intr *intr = &adapter->intr;
332         struct st5481_ctrl *ctrl = &adapter->ctrl;
333
334         DBG(1,"");
335
336         // Stop and free Control and Interrupt URBs
337         usb_kill_urb(ctrl->urb);
338         kfree(ctrl->urb->transfer_buffer);
339         usb_free_urb(ctrl->urb);
340         ctrl->urb = NULL;
341
342         usb_kill_urb(intr->urb);
343         kfree(intr->urb->transfer_buffer);
344         usb_free_urb(intr->urb);
345         ctrl->urb = NULL;
346 }
347
348 /*
349  *  Initialize the adapter.
350  */
351 void st5481_start(struct st5481_adapter *adapter)
352 {
353         static const u8 init_cmd_table[]={
354                 SET_DEFAULT,0,
355                 STT,0,
356                 SDA_MIN,0x0d,
357                 SDA_MAX,0x29,
358                 SDELAY_VALUE,0x14,
359                 GPIO_DIR,0x01,          
360                 GPIO_OUT,RED_LED,
361 //              FFCTRL_OUT_D,4,
362 //              FFCTRH_OUT_D,12,
363                 FFCTRL_OUT_B1,6,
364                 FFCTRH_OUT_B1,20,
365                 FFCTRL_OUT_B2,6,
366                 FFCTRH_OUT_B2,20,
367                 MPMSK,RXCI_INT+DEN_INT+DCOLL_INT,
368                 0
369         };      
370         struct st5481_intr *intr = &adapter->intr;
371         int i = 0;
372         u8 request,value;
373
374         DBG(8,"");
375
376         adapter->leds = RED_LED; 
377
378         // Start receiving on the interrupt endpoint
379         SUBMIT_URB(intr->urb, GFP_KERNEL); 
380
381         while ((request = init_cmd_table[i++])) {
382                 value = init_cmd_table[i++];
383                 st5481_usb_device_ctrl_msg(adapter, request, value, NULL, NULL);
384         }
385         st5481_ph_command(adapter, ST5481_CMD_PUP);
386 }
387
388 /*
389  * Reset the adapter to default values.
390  */
391 void st5481_stop(struct st5481_adapter *adapter)
392 {
393         DBG(8,"");
394
395         st5481_usb_device_ctrl_msg(adapter, SET_DEFAULT, 0, NULL, NULL);
396 }
397
398 /* ======================================================================
399  * isochronous USB  helpers
400  */
401
402 static void
403 fill_isoc_urb(struct urb *urb, struct usb_device *dev,
404               unsigned int pipe, void *buf, int num_packets, 
405               int packet_size, usb_complete_t complete,
406               void *context) 
407 {
408         int k;
409
410         spin_lock_init(&urb->lock);
411         urb->dev=dev;
412         urb->pipe=pipe;
413         urb->interval = 1;
414         urb->transfer_buffer=buf;
415         urb->number_of_packets = num_packets;
416         urb->transfer_buffer_length=num_packets*packet_size;
417         urb->actual_length = 0;
418         urb->complete=complete;
419         urb->context=context;
420         urb->transfer_flags=URB_ISO_ASAP;
421         for (k = 0; k < num_packets; k++) {
422                 urb->iso_frame_desc[k].offset = packet_size * k;
423                 urb->iso_frame_desc[k].length = packet_size;
424                 urb->iso_frame_desc[k].actual_length = 0;
425         }
426 }
427
428 int
429 st5481_setup_isocpipes(struct urb* urb[2], struct usb_device *dev, 
430                            unsigned int pipe, int num_packets,
431                            int packet_size, int buf_size,
432                            usb_complete_t complete, void *context)
433 {
434         int j, retval;
435         unsigned char *buf;
436
437         for (j = 0; j < 2; j++) {
438                 retval = -ENOMEM;
439                 urb[j] = usb_alloc_urb(num_packets, GFP_KERNEL);
440                 if (!urb[j])
441                         goto err;
442
443                 // Allocate memory for 2000bytes/sec (16Kb/s)
444                 buf = kmalloc(buf_size, GFP_KERNEL);
445                 if (!buf)
446                         goto err;
447                         
448                 // Fill the isochronous URB
449                 fill_isoc_urb(urb[j], dev, pipe, buf, 
450                               num_packets, packet_size, complete,
451                               context);
452         }
453         return 0;
454
455  err:
456         for (j = 0; j < 2; j++) {
457                 if (urb[j]) {
458                         kfree(urb[j]->transfer_buffer);
459                         urb[j]->transfer_buffer = NULL;
460                         usb_free_urb(urb[j]);
461                         urb[j] = NULL;
462                 }
463         }
464         return retval;
465 }
466
467 void st5481_release_isocpipes(struct urb* urb[2])
468 {
469         int j;
470
471         for (j = 0; j < 2; j++) {
472                 usb_kill_urb(urb[j]);
473                 kfree(urb[j]->transfer_buffer);
474                 usb_free_urb(urb[j]);
475                 urb[j] = NULL;
476         }
477 }
478
479 /*
480  * Decode frames received on the B/D channel.
481  * Note that this function will be called continously
482  * with 64Kbit/s / 16Kbit/s of data and hence it will be 
483  * called 50 times per second with 20 ISOC descriptors. 
484  * Called at interrupt.
485  */
486 static void usb_in_complete(struct urb *urb, struct pt_regs *regs)
487 {
488         struct st5481_in *in = urb->context;
489         unsigned char *ptr;
490         struct sk_buff *skb;
491         int len, count, status;
492
493         if (unlikely(urb->status < 0)) {
494                 switch (urb->status) {
495                         case -ENOENT:
496                         case -ESHUTDOWN:
497                         case -ECONNRESET:
498                                 DBG(1,"urb killed status %d", urb->status);
499                                 return; // Give up
500                         default: 
501                                 WARN("urb status %d",urb->status);
502                                 break;
503                 }
504         }
505
506         DBG_ISO_PACKET(0x80,urb);
507
508         len = st5481_isoc_flatten(urb);
509         ptr = urb->transfer_buffer;
510         while (len > 0) {
511                 if (in->mode == L1_MODE_TRANS) {
512                         memcpy(in->rcvbuf, ptr, len);
513                         status = len;
514                         len = 0;
515                 } else {
516                         status = isdnhdlc_decode(&in->hdlc_state, ptr, len, &count,
517                                 in->rcvbuf, in->bufsize);
518                         ptr += count;
519                         len -= count;
520                 }
521                 
522                 if (status > 0) {
523                         // Good frame received
524                         DBG(4,"count=%d",status);
525                         DBG_PACKET(0x400, in->rcvbuf, status);
526                         if (!(skb = dev_alloc_skb(status))) {
527                                 WARN("receive out of memory\n");
528                                 break;
529                         }
530                         memcpy(skb_put(skb, status), in->rcvbuf, status);
531                         in->hisax_if->l1l2(in->hisax_if, PH_DATA | INDICATION, skb);
532                 } else if (status == -HDLC_CRC_ERROR) {
533                         INFO("CRC error");
534                 } else if (status == -HDLC_FRAMING_ERROR) {
535                         INFO("framing error");
536                 } else if (status == -HDLC_LENGTH_ERROR) {
537                         INFO("length error");
538                 }
539         }
540
541         // Prepare URB for next transfer
542         urb->dev = in->adapter->usb_dev;
543         urb->actual_length = 0;
544
545         SUBMIT_URB(urb, GFP_ATOMIC);
546 }
547
548 int st5481_setup_in(struct st5481_in *in)
549 {
550         struct usb_device *dev = in->adapter->usb_dev;
551         int retval;
552
553         DBG(4,"");
554
555         in->rcvbuf = kmalloc(in->bufsize, GFP_KERNEL);
556         retval = -ENOMEM;
557         if (!in->rcvbuf)
558                 goto err;
559
560         retval = st5481_setup_isocpipes(in->urb, dev, 
561                                         usb_rcvisocpipe(dev, in->ep),
562                                         in->num_packets,  in->packet_size,
563                                         in->num_packets * in->packet_size,
564                                         usb_in_complete, in);
565         if (retval)
566                 goto err_free;
567         return 0;
568
569  err_free:
570         kfree(in->rcvbuf);
571  err:
572         return retval;
573 }
574
575 void st5481_release_in(struct st5481_in *in)
576 {
577         DBG(2,"");
578
579         st5481_release_isocpipes(in->urb);
580 }
581
582 /*
583  * Make the transfer_buffer contiguous by
584  * copying from the iso descriptors if necessary. 
585  */
586 static int st5481_isoc_flatten(struct urb *urb)
587 {
588         struct usb_iso_packet_descriptor *pipd,*pend;
589         unsigned char *src,*dst;
590         unsigned int len;
591         
592         if (urb->status < 0) {
593                 return urb->status;
594         }
595         for (pipd = &urb->iso_frame_desc[0],
596                      pend = &urb->iso_frame_desc[urb->number_of_packets],
597                      dst = urb->transfer_buffer; 
598              pipd < pend; 
599              pipd++) {
600                 
601                 if (pipd->status < 0) {
602                         return (pipd->status);
603                 }
604         
605                 len = pipd->actual_length;
606                 pipd->actual_length = 0;
607                 src = urb->transfer_buffer+pipd->offset;
608
609                 if (src != dst) {
610                         // Need to copy since isoc buffers not full
611                         while (len--) {
612                                 *dst++ = *src++;
613                         }                       
614                 } else {
615                         // No need to copy, just update destination buffer
616                         dst += len;
617                 }
618         }
619         // Return size of flattened buffer
620         return (dst - (unsigned char *)urb->transfer_buffer);
621 }
622
623 static void st5481_start_rcv(void *context)
624 {
625         struct st5481_in *in = context;
626         struct st5481_adapter *adapter = in->adapter;
627
628         DBG(4,"");
629
630         in->urb[0]->dev = adapter->usb_dev;
631         SUBMIT_URB(in->urb[0], GFP_KERNEL);
632
633         in->urb[1]->dev = adapter->usb_dev;
634         SUBMIT_URB(in->urb[1], GFP_KERNEL);
635 }
636
637 void st5481_in_mode(struct st5481_in *in, int mode)
638 {
639         if (in->mode == mode)
640                 return;
641
642         in->mode = mode;
643
644         usb_unlink_urb(in->urb[0]);
645         usb_unlink_urb(in->urb[1]);
646
647         if (in->mode != L1_MODE_NULL) {
648                 if (in->mode != L1_MODE_TRANS)
649                         isdnhdlc_rcv_init(&in->hdlc_state,
650                                 in->mode == L1_MODE_HDLC_56K);
651                 
652                 st5481_usb_pipe_reset(in->adapter, in->ep, NULL, NULL);
653                 st5481_usb_device_ctrl_msg(in->adapter, in->counter,
654                                            in->packet_size,
655                                            NULL, NULL);
656                 st5481_start_rcv(in);
657         } else {
658                 st5481_usb_device_ctrl_msg(in->adapter, in->counter,
659                                            0, NULL, NULL);
660         }
661 }
662