1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/init.h>
14#include <linux/usb.h>
15#include <linux/slab.h>
16#include "st5481.h"
17
18static int st5481_isoc_flatten(struct urb *urb);
19
20
21
22
23
24
25
26
27
28static 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
51 urb->dev = adapter->usb_dev;
52
53 SUBMIT_URB(urb, GFP_ATOMIC);
54}
55
56
57
58
59
60static 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 WARNING("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
87
88void 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
99
100void 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
114
115
116void 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
125
126
127
128static void usb_ctrl_complete(struct urb *urb)
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;
141 default:
142 WARNING("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
151 le16_to_cpus(&ctrl_msg->dr.wIndex);
152 usb_reset_endpoint(adapter->usb_dev, ctrl_msg->dr.wIndex);
153 }
154
155 if (ctrl_msg->complete)
156 ctrl_msg->complete(ctrl_msg->context);
157
158 clear_bit(0, &ctrl->busy);
159
160
161 usb_next_ctrl_msg(urb, adapter);
162 return;
163}
164
165
166
167
168
169
170
171
172
173
174
175static void usb_int_complete(struct urb *urb)
176{
177 u8 *data = urb->transfer_buffer;
178 u8 irqbyte;
179 struct st5481_adapter *adapter = urb->context;
180 int j;
181 int status;
182
183 switch (urb->status) {
184 case 0:
185
186 break;
187 case -ECONNRESET:
188 case -ENOENT:
189 case -ESHUTDOWN:
190
191 DBG(2, "urb shutting down with status: %d", urb->status);
192 return;
193 default:
194 WARNING("nonzero urb status received: %d", urb->status);
195 goto exit;
196 }
197
198
199 DBG_PACKET(2, data, INT_PKT_SIZE);
200
201 if (urb->actual_length == 0) {
202 goto exit;
203 }
204
205 irqbyte = data[MPINT];
206 if (irqbyte & DEN_INT)
207 FsmEvent(&adapter->d_out.fsm, EV_DOUT_DEN, NULL);
208
209 if (irqbyte & DCOLL_INT)
210 FsmEvent(&adapter->d_out.fsm, EV_DOUT_COLL, NULL);
211
212 irqbyte = data[FFINT_D];
213 if (irqbyte & OUT_UNDERRUN)
214 FsmEvent(&adapter->d_out.fsm, EV_DOUT_UNDERRUN, NULL);
215
216 if (irqbyte & OUT_DOWN)
217 ;
218
219 irqbyte = data[MPINT];
220 if (irqbyte & RXCI_INT)
221 FsmEvent(&adapter->l1m, data[CCIST] & 0x0f, NULL);
222
223 for (j = 0; j < 2; j++)
224 adapter->bcs[j].b_out.flow_event |= data[FFINT_B1 + j];
225
226 urb->actual_length = 0;
227
228exit:
229 status = usb_submit_urb(urb, GFP_ATOMIC);
230 if (status)
231 WARNING("usb_submit_urb failed with result %d", status);
232}
233
234
235
236
237
238int st5481_setup_usb(struct st5481_adapter *adapter)
239{
240 struct usb_device *dev = adapter->usb_dev;
241 struct st5481_ctrl *ctrl = &adapter->ctrl;
242 struct st5481_intr *intr = &adapter->intr;
243 struct usb_interface *intf;
244 struct usb_host_interface *altsetting = NULL;
245 struct usb_host_endpoint *endpoint;
246 int status;
247 struct urb *urb;
248 u8 *buf;
249
250 DBG(2, "");
251
252 if ((status = usb_reset_configuration(dev)) < 0) {
253 WARNING("reset_configuration failed,status=%d", status);
254 return status;
255 }
256
257 intf = usb_ifnum_to_if(dev, 0);
258 if (intf)
259 altsetting = usb_altnum_to_altsetting(intf, 3);
260 if (!altsetting)
261 return -ENXIO;
262
263
264 if (altsetting->desc.bNumEndpoints != 7) {
265 WARNING("expecting 7 got %d endpoints!", altsetting->desc.bNumEndpoints);
266 return -EINVAL;
267 }
268
269
270 altsetting->endpoint[3].desc.wMaxPacketSize = cpu_to_le16(32);
271 altsetting->endpoint[4].desc.wMaxPacketSize = cpu_to_le16(32);
272
273
274 if ((status = usb_set_interface(dev, 0, 3)) < 0) {
275 WARNING("usb_set_interface failed,status=%d", status);
276 return status;
277 }
278
279
280 urb = usb_alloc_urb(0, GFP_KERNEL);
281 if (!urb) {
282 return -ENOMEM;
283 }
284 ctrl->urb = urb;
285
286
287 usb_fill_control_urb(urb, dev,
288 usb_sndctrlpipe(dev, 0),
289 NULL, NULL, 0, usb_ctrl_complete, adapter);
290
291
292 fifo_init(&ctrl->msg_fifo.f, ARRAY_SIZE(ctrl->msg_fifo.data));
293
294
295 urb = usb_alloc_urb(0, GFP_KERNEL);
296 if (!urb) {
297 goto err1;
298 }
299 intr->urb = urb;
300
301 buf = kmalloc(INT_PKT_SIZE, GFP_KERNEL);
302 if (!buf) {
303 goto err2;
304 }
305
306 endpoint = &altsetting->endpoint[EP_INT-1];
307
308
309 usb_fill_int_urb(urb, dev,
310 usb_rcvintpipe(dev, endpoint->desc.bEndpointAddress),
311 buf, INT_PKT_SIZE,
312 usb_int_complete, adapter,
313 endpoint->desc.bInterval);
314
315 return 0;
316err2:
317 usb_free_urb(intr->urb);
318 intr->urb = NULL;
319err1:
320 usb_free_urb(ctrl->urb);
321 ctrl->urb = NULL;
322
323 return -ENOMEM;
324}
325
326
327
328
329
330void st5481_release_usb(struct st5481_adapter *adapter)
331{
332 struct st5481_intr *intr = &adapter->intr;
333 struct st5481_ctrl *ctrl = &adapter->ctrl;
334
335 DBG(1, "");
336
337
338 usb_kill_urb(ctrl->urb);
339 kfree(ctrl->urb->transfer_buffer);
340 usb_free_urb(ctrl->urb);
341 ctrl->urb = NULL;
342
343 usb_kill_urb(intr->urb);
344 kfree(intr->urb->transfer_buffer);
345 usb_free_urb(intr->urb);
346 intr->urb = NULL;
347}
348
349
350
351
352void st5481_start(struct st5481_adapter *adapter)
353{
354 static const u8 init_cmd_table[] = {
355 SET_DEFAULT, 0,
356 STT, 0,
357 SDA_MIN, 0x0d,
358 SDA_MAX, 0x29,
359 SDELAY_VALUE, 0x14,
360 GPIO_DIR, 0x01,
361 GPIO_OUT, RED_LED,
362
363
364 FFCTRL_OUT_B1, 6,
365 FFCTRH_OUT_B1, 20,
366 FFCTRL_OUT_B2, 6,
367 FFCTRH_OUT_B2, 20,
368 MPMSK, RXCI_INT + DEN_INT + DCOLL_INT,
369 0
370 };
371 struct st5481_intr *intr = &adapter->intr;
372 int i = 0;
373 u8 request, value;
374
375 DBG(8, "");
376
377 adapter->leds = RED_LED;
378
379
380 SUBMIT_URB(intr->urb, GFP_KERNEL);
381
382 while ((request = init_cmd_table[i++])) {
383 value = init_cmd_table[i++];
384 st5481_usb_device_ctrl_msg(adapter, request, value, NULL, NULL);
385 }
386 st5481_ph_command(adapter, ST5481_CMD_PUP);
387}
388
389
390
391
392void st5481_stop(struct st5481_adapter *adapter)
393{
394 DBG(8, "");
395
396 st5481_usb_device_ctrl_msg(adapter, SET_DEFAULT, 0, NULL, NULL);
397}
398
399
400
401
402
403static void
404fill_isoc_urb(struct urb *urb, struct usb_device *dev,
405 unsigned int pipe, void *buf, int num_packets,
406 int packet_size, usb_complete_t complete,
407 void *context)
408{
409 int k;
410
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
428int
429st5481_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
444 buf = kmalloc(buf_size, GFP_KERNEL);
445 if (!buf)
446 goto err;
447
448
449 fill_isoc_urb(urb[j], dev, pipe, buf,
450 num_packets, packet_size, complete,
451 context);
452 }
453 return 0;
454
455err:
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
467void 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
481
482
483
484
485
486static void usb_in_complete(struct urb *urb)
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;
500 default:
501 WARNING("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
524 DBG(4, "count=%d", status);
525 DBG_PACKET(0x400, in->rcvbuf, status);
526 if (!(skb = dev_alloc_skb(status))) {
527 WARNING("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
542 urb->dev = in->adapter->usb_dev;
543 urb->actual_length = 0;
544
545 SUBMIT_URB(urb, GFP_ATOMIC);
546}
547
548int 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
569err_free:
570 kfree(in->rcvbuf);
571err:
572 return retval;
573}
574
575void st5481_release_in(struct st5481_in *in)
576{
577 DBG(2, "");
578
579 st5481_release_isocpipes(in->urb);
580}
581
582
583
584
585
586static 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
611 while (len--) {
612 *dst++ = *src++;
613 }
614 } else {
615
616 dst += len;
617 }
618 }
619
620 return (dst - (unsigned char *)urb->transfer_buffer);
621}
622
623static 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
637void 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 u32 features = HDLC_BITREVERSE;
650
651 if (in->mode == L1_MODE_HDLC_56K)
652 features |= HDLC_56KBIT;
653 isdnhdlc_rcv_init(&in->hdlc_state, features);
654 }
655 st5481_usb_pipe_reset(in->adapter, in->ep, NULL, NULL);
656 st5481_usb_device_ctrl_msg(in->adapter, in->counter,
657 in->packet_size,
658 NULL, NULL);
659 st5481_start_rcv(in);
660 } else {
661 st5481_usb_device_ctrl_msg(in->adapter, in->counter,
662 0, NULL, NULL);
663 }
664}
665