| Linux kernel & device driver programming |
| [ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] |
1 /* 1
2 * Driver for ST5481 USB ISDN modem
3 *
4 * Author Frode Isaksen
5 * Copyright 2001 by Frode Isaksen <fi
6 * 2001 by Kai Germaschewski <ka
7 *
8 * This software may be used and distributed a
9 * of the GNU General Public License, incorpor
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
26 * Called either by the completion or by usb_c
27 */
28 static void usb_next_ctrl_msg(struct urb *urb,
29 struct st5481_ad
30 {
31 struct st5481_ctrl *ctrl = &adapter->c
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_
39 test_and_clear_bit(0,&ctrl->bu
40 return;
41 }
42 urb->setup_packet =
43 (unsigned char *)&ctrl->msg_fi
44
45 DBG(1,"request=0x%02x,value=0x%04x,ind
46 ((struct ctrl_msg *)urb->setup_pac
47 ((struct ctrl_msg *)urb->setup_pac
48 ((struct ctrl_msg *)urb->setup_pac
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 vers
58 * The request will be queued up in a FIFO if
59 */
60 static void usb_ctrl_msg(struct st5481_adapter
61 u8 request, u8 reques
62 ctrl_complete_t compl
63 {
64 struct st5481_ctrl *ctrl = &adapter->c
65 int w_index;
66 struct ctrl_msg *ctrl_msg;
67
68 if ((w_index = fifo_add(&ctrl->msg_fif
69 WARN("control msg FIFO full");
70 return;
71 }
72 ctrl_msg = &ctrl->msg_fifo.data[w_inde
73
74 ctrl_msg->dr.bRequestType = requesttyp
75 ctrl_msg->dr.bRequest = request;
76 ctrl_msg->dr.wValue = cpu_to_le16p(&va
77 ctrl_msg->dr.wIndex = cpu_to_le16p(&in
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_
89 u8 request, u16 value
90 ctrl_complete_t compl
91 {
92 usb_ctrl_msg(adapter, request,
93 USB_DIR_OUT | USB_TYPE_VE
94 value, 0, complete, conte
95 }
96
97 /*
98 * Asynchronous pipe reset (async version of u
99 */
100 void st5481_usb_pipe_reset(struct st5481_adapt
101 u_char pipe,
102 ctrl_complete_t complete,
103 {
104 DBG(1,"pipe=%02x",pipe);
105
106 usb_ctrl_msg(adapter,
107 USB_REQ_CLEAR_FEATURE, US
108 0, pipe, complete, contex
109 }
110
111
112 /*
113 Physical level functions
114 */
115
116 void st5481_ph_command(struct st5481_adapter *
117 {
118 DBG(8,"command=%s", ST5481_CMD_string(
119
120 st5481_usb_device_ctrl_msg(adapter, TX
121 }
122
123 /*
124 * The request on endpoint 0 has completed.
125 * Call the user provided completion routine a
126 * to send the next request.
127 */
128 static void usb_ctrl_complete(struct urb *urb)
129 {
130 struct st5481_adapter *adapter = urb->
131 struct st5481_ctrl *ctrl = &adapter->c
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 kil
140 return; // Giv
141 default:
142 WARN("urb stat
143 break;
144 }
145 }
146
147 ctrl_msg = (struct ctrl_msg *)urb->set
148
149 if (ctrl_msg->dr.bRequest == USB_REQ_C
150 /* Special case handling for p
151 le16_to_cpus(&ctrl_msg->dr.wIn
152
153 /* toggle is reset on clear */
154 usb_settoggle(adapter->usb_dev
155 ctrl_msg->dr.wIn
156 (ctrl_msg->dr.wI
157 0);
158
159
160 }
161
162 if (ctrl_msg->complete)
163 ctrl_msg->complete(ctrl_msg->c
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
178 * of the 6 registers changes state (depending
179 * Decode the register values and schedule a p
180 * Called at interrupt.
181 */
182 static void usb_int_complete(struct urb *urb)
183 {
184 u8 *data = urb->transfer_buffer;
185 u8 irqbyte;
186 struct st5481_adapter *adapter = urb->
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 termina
198 DBG(2, "urb shutting d
199 return;
200 default:
201 WARN("nonzero urb stat
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,
215
216 if (irqbyte & DCOLL_INT)
217 FsmEvent(&adapter->d_out.fsm,
218
219 irqbyte = data[FFINT_D];
220 if (irqbyte & OUT_UNDERRUN)
221 FsmEvent(&adapter->d_out.fsm,
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[C
229
230 for (j = 0; j < 2; j++)
231 adapter->bcs[j].b_out.flow_eve
232
233 urb->actual_length = 0;
234
235 exit:
236 status = usb_submit_urb (urb, GFP_ATOM
237 if (status)
238 WARN("usb_submit_urb failed wi
239 }
240
241 /* ===========================================
242 * initialization
243 */
244
245 int st5481_setup_usb(struct st5481_adapter *ad
246 {
247 struct usb_device *dev = adapter->usb_
248 struct st5481_ctrl *ctrl = &adapter->c
249 struct st5481_intr *intr = &adapter->i
250 struct usb_interface *intf;
251 struct usb_host_interface *altsetting
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
260 WARN("reset_configuration fail
261 return status;
262 }
263
264 intf = usb_ifnum_to_if(dev, 0);
265 if (intf)
266 altsetting = usb_altnum_to_alt
267 if (!altsetting)
268 return -ENXIO;
269
270 // Check if the config is sane
271 if ( altsetting->desc.bNumEndpoints !=
272 WARN("expecting 7 got %d endpo
273 return -EINVAL;
274 }
275
276 // The descriptor is wrong for some ea
277 altsetting->endpoint[3].desc.wMaxPacke
278 altsetting->endpoint[4].desc.wMaxPacke
279
280 // Use alternative setting 3 on interf
281 if ((status = usb_set_interface (dev,
282 WARN("usb_set_interface failed
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,
296 NULL, NULL, 0, usb_c
297
298
299 fifo_init(&ctrl->msg_fifo.f, ARRAY_SIZ
300
301 // Allocate URBs and buffers for inter
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_IN
314
315 // Fill the interrupt URB
316 usb_fill_int_urb(urb, dev,
317 usb_rcvintpipe(dev, endpo
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
327 * endpoint.
328 */
329 void st5481_release_usb(struct st5481_adapter
330 {
331 struct st5481_intr *intr = &adapter->i
332 struct st5481_ctrl *ctrl = &adapter->c
333
334 DBG(1,"");
335
336 // Stop and free Control and Interrupt
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 *adapt
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_I
368 0
369 };
370 struct st5481_intr *intr = &adapter->i
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 en
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(ada
384 }
385 st5481_ph_command(adapter, ST5481_CMD_
386 }
387
388 /*
389 * Reset the adapter to default values.
390 */
391 void st5481_stop(struct st5481_adapter *adapte
392 {
393 DBG(8,"");
394
395 st5481_usb_device_ctrl_msg(adapter, SE
396 }
397
398 /* ===========================================
399 * isochronous USB helpers
400 */
401
402 static void
403 fill_isoc_urb(struct urb *urb, struct usb_devi
404 unsigned int pipe, void *buf, in
405 int packet_size, usb_complete_t
406 void *context)
407 {
408 int k;
409
410 urb->dev=dev;
411 urb->pipe=pipe;
412 urb->interval = 1;
413 urb->transfer_buffer=buf;
414 urb->number_of_packets = num_packets;
415 urb->transfer_buffer_length=num_packet
416 urb->actual_length = 0;
417 urb->complete=complete;
418 urb->context=context;
419 urb->transfer_flags=URB_ISO_ASAP;
420 for (k = 0; k < num_packets; k++) {
421 urb->iso_frame_desc[k].offset
422 urb->iso_frame_desc[k].length
423 urb->iso_frame_desc[k].actual_
424 }
425 }
426
427 int
428 st5481_setup_isocpipes(struct urb* urb[2], str
429 unsigned int pipe,
430 int packet_size, in
431 usb_complete_t comp
432 {
433 int j, retval;
434 unsigned char *buf;
435
436 for (j = 0; j < 2; j++) {
437 retval = -ENOMEM;
438 urb[j] = usb_alloc_urb(num_pac
439 if (!urb[j])
440 goto err;
441
442 // Allocate memory for 2000byt
443 buf = kmalloc(buf_size, GFP_KE
444 if (!buf)
445 goto err;
446
447 // Fill the isochronous URB
448 fill_isoc_urb(urb[j], dev, pip
449 num_packets, pac
450 context);
451 }
452 return 0;
453
454 err:
455 for (j = 0; j < 2; j++) {
456 if (urb[j]) {
457 kfree(urb[j]->transfer
458 urb[j]->transfer_buffe
459 usb_free_urb(urb[j]);
460 urb[j] = NULL;
461 }
462 }
463 return retval;
464 }
465
466 void st5481_release_isocpipes(struct urb* urb[
467 {
468 int j;
469
470 for (j = 0; j < 2; j++) {
471 usb_kill_urb(urb[j]);
472 kfree(urb[j]->transfer_buffer)
473 usb_free_urb(urb[j]);
474 urb[j] = NULL;
475 }
476 }
477
478 /*
479 * Decode frames received on the B/D channel.
480 * Note that this function will be called cont
481 * with 64Kbit/s / 16Kbit/s of data and hence
482 * called 50 times per second with 20 ISOC des
483 * Called at interrupt.
484 */
485 static void usb_in_complete(struct urb *urb)
486 {
487 struct st5481_in *in = urb->context;
488 unsigned char *ptr;
489 struct sk_buff *skb;
490 int len, count, status;
491
492 if (unlikely(urb->status < 0)) {
493 switch (urb->status) {
494 case -ENOENT:
495 case -ESHUTDOWN:
496 case -ECONNRESET:
497 DBG(1,"urb kil
498 return; // Giv
499 default:
500 WARN("urb stat
501 break;
502 }
503 }
504
505 DBG_ISO_PACKET(0x80,urb);
506
507 len = st5481_isoc_flatten(urb);
508 ptr = urb->transfer_buffer;
509 while (len > 0) {
510 if (in->mode == L1_MODE_TRANS)
511 memcpy(in->rcvbuf, ptr
512 status = len;
513 len = 0;
514 } else {
515 status = isdnhdlc_deco
516 in->rcvbuf, in
517 ptr += count;
518 len -= count;
519 }
520
521 if (status > 0) {
522 // Good frame received
523 DBG(4,"count=%d",statu
524 DBG_PACKET(0x400, in->
525 if (!(skb = dev_alloc_
526 WARN("receive
527 break;
528 }
529 memcpy(skb_put(skb, st
530 in->hisax_if->l1l2(in-
531 } else if (status == -HDLC_CRC
532 INFO("CRC error");
533 } else if (status == -HDLC_FRA
534 INFO("framing error");
535 } else if (status == -HDLC_LEN
536 INFO("length error");
537 }
538 }
539
540 // Prepare URB for next transfer
541 urb->dev = in->adapter->usb_dev;
542 urb->actual_length = 0;
543
544 SUBMIT_URB(urb, GFP_ATOMIC);
545 }
546
547 int st5481_setup_in(struct st5481_in *in)
548 {
549 struct usb_device *dev = in->adapter->
550 int retval;
551
552 DBG(4,"");
553
554 in->rcvbuf = kmalloc(in->bufsize, GFP_
555 retval = -ENOMEM;
556 if (!in->rcvbuf)
557 goto err;
558
559 retval = st5481_setup_isocpipes(in->ur
560 usb_rc
561 in->nu
562 in->nu
563 usb_in
564 if (retval)
565 goto err_free;
566 return 0;
567
568 err_free:
569 kfree(in->rcvbuf);
570 err:
571 return retval;
572 }
573
574 void st5481_release_in(struct st5481_in *in)
575 {
576 DBG(2,"");
577
578 st5481_release_isocpipes(in->urb);
579 }
580
581 /*
582 * Make the transfer_buffer contiguous by
583 * copying from the iso descriptors if necessa
584 */
585 static int st5481_isoc_flatten(struct urb *urb
586 {
587 struct usb_iso_packet_descriptor *pipd
588 unsigned char *src,*dst;
589 unsigned int len;
590
591 if (urb->status < 0) {
592 return urb->status;
593 }
594 for (pipd = &urb->iso_frame_desc[0],
595 pend = &urb->iso_frame_de
596 dst = urb->transfer_buffe
597 pipd < pend;
598 pipd++) {
599
600 if (pipd->status < 0) {
601 return (pipd->status);
602 }
603
604 len = pipd->actual_length;
605 pipd->actual_length = 0;
606 src = urb->transfer_buffer+pip
607
608 if (src != dst) {
609 // Need to copy since
610 while (len--) {
611 *dst++ = *src+
612 }
613 } else {
614 // No need to copy, ju
615 dst += len;
616 }
617 }
618 // Return size of flattened buffer
619 return (dst - (unsigned char *)urb->tr
620 }
621
622 static void st5481_start_rcv(void *context)
623 {
624 struct st5481_in *in = context;
625 struct st5481_adapter *adapter = in->a
626
627 DBG(4,"");
628
629 in->urb[0]->dev = adapter->usb_dev;
630 SUBMIT_URB(in->urb[0], GFP_KERNEL);
631
632 in->urb[1]->dev = adapter->usb_dev;
633 SUBMIT_URB(in->urb[1], GFP_KERNEL);
634 }
635
636 void st5481_in_mode(struct st5481_in *in, int
637 {
638 if (in->mode == mode)
639 return;
640
641 in->mode = mode;
642
643 usb_unlink_urb(in->urb[0]);
644 usb_unlink_urb(in->urb[1]);
645
646 if (in->mode != L1_MODE_NULL) {
647 if (in->mode != L1_MODE_TRANS)
648 isdnhdlc_rcv_init(&in-
649 in->mode == L1
650
651 st5481_usb_pipe_reset(in->adap
652 st5481_usb_device_ctrl_msg(in-
653 in-
654 NUL
655 st5481_start_rcv(in);
656 } else {
657 st5481_usb_device_ctrl_msg(in-
658 0,
659 }
660 }
661
662
| This page was automatically generated by the LXR engine. |