2 * Driver for ST5481 USB ISDN modem
5 * Copyright 2001 by Frode Isaksen <fisaksen@bewan.com>
6 * 2001 by Kai Germaschewski <kai.germaschewski@gmx.de>
8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
13 #include <linux/init.h>
14 #include <linux/usb.h>
15 #include <linux/slab.h>
18 /* ======================================================================
23 * Send the next endpoint 0 request stored in the FIFO.
24 * Called either by the completion or by usb_ctrl_msg.
26 static void usb_next_ctrl_msg(struct urb *urb,
27 struct st5481_adapter *adapter)
29 struct st5481_ctrl *ctrl = &adapter->ctrl;
32 if (test_and_set_bit(0, &ctrl->busy)) {
36 if ((r_index = fifo_remove(&ctrl->msg_fifo.f)) < 0) {
37 test_and_clear_bit(0,&ctrl->busy);
41 (unsigned char *)&ctrl->msg_fifo.data[r_index];
43 DBG(1,"request=0x%02x,value=0x%04x,index=%x",
44 ((struct ctrl_msg *)urb->setup_packet)->dr.bRequest,
45 ((struct ctrl_msg *)urb->setup_packet)->dr.wValue,
46 ((struct ctrl_msg *)urb->setup_packet)->dr.wIndex);
49 urb->dev = adapter->usb_dev;
51 SUBMIT_URB(urb, GFP_ATOMIC);
55 * Asynchronous endpoint 0 request (async version of usb_control_msg).
56 * The request will be queued up in a FIFO if the endpoint is busy.
58 void usb_ctrl_msg(struct st5481_adapter *adapter,
59 u8 request, u8 requesttype, u16 value, u16 index,
60 ctrl_complete_t complete, void *context)
62 struct st5481_ctrl *ctrl = &adapter->ctrl;
64 struct ctrl_msg *ctrl_msg;
66 if ((w_index = fifo_add(&ctrl->msg_fifo.f)) < 0) {
67 WARN("control msg FIFO full");
70 ctrl_msg = &ctrl->msg_fifo.data[w_index];
72 ctrl_msg->dr.bRequestType = requesttype;
73 ctrl_msg->dr.bRequest = request;
74 ctrl_msg->dr.wValue = cpu_to_le16p(&value);
75 ctrl_msg->dr.wIndex = cpu_to_le16p(&index);
76 ctrl_msg->dr.wLength = 0;
77 ctrl_msg->complete = complete;
78 ctrl_msg->context = context;
80 usb_next_ctrl_msg(ctrl->urb, adapter);
84 * Asynchronous endpoint 0 device request.
86 void st5481_usb_device_ctrl_msg(struct st5481_adapter *adapter,
87 u8 request, u16 value,
88 ctrl_complete_t complete, void *context)
90 usb_ctrl_msg(adapter, request,
91 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
92 value, 0, complete, context);
96 * Asynchronous pipe reset (async version of usb_clear_halt).
98 void st5481_usb_pipe_reset(struct st5481_adapter *adapter,
100 ctrl_complete_t complete, void *context)
102 DBG(1,"pipe=%02x",pipe);
104 usb_ctrl_msg(adapter,
105 USB_REQ_CLEAR_FEATURE, USB_DIR_OUT | USB_RECIP_ENDPOINT,
106 0, pipe, complete, context);
111 Physical level functions
114 void st5481_ph_command(struct st5481_adapter *adapter, unsigned int command)
116 DBG(8,"command=%s", ST5481_CMD_string(command));
118 st5481_usb_device_ctrl_msg(adapter, TXCI, command, NULL, NULL);
122 * The request on endpoint 0 has completed.
123 * Call the user provided completion routine and try
124 * to send the next request.
126 static void usb_ctrl_complete(struct urb *urb, struct pt_regs *regs)
128 struct st5481_adapter *adapter = urb->context;
129 struct st5481_ctrl *ctrl = &adapter->ctrl;
130 struct ctrl_msg *ctrl_msg;
132 if (unlikely(urb->status < 0)) {
133 if (urb->status != -ENOENT && urb->status != -ESHUTDOWN) {
134 WARN("urb status %d",urb->status);
141 ctrl_msg = (struct ctrl_msg *)urb->setup_packet;
143 if (ctrl_msg->dr.bRequest == USB_REQ_CLEAR_FEATURE) {
144 /* Special case handling for pipe reset */
145 le16_to_cpus(&ctrl_msg->dr.wIndex);
146 usb_endpoint_running(adapter->usb_dev,
147 ctrl_msg->dr.wIndex & ~USB_DIR_IN,
148 (ctrl_msg->dr.wIndex & USB_DIR_IN) == 0);
150 /* toggle is reset on clear */
151 usb_settoggle(adapter->usb_dev,
152 ctrl_msg->dr.wIndex & ~USB_DIR_IN,
153 (ctrl_msg->dr.wIndex & USB_DIR_IN) == 0,
159 if (ctrl_msg->complete)
160 ctrl_msg->complete(ctrl_msg->context);
162 clear_bit(0, &ctrl->busy);
164 // Try to send next control message
165 usb_next_ctrl_msg(urb, adapter);
169 /* ======================================================================
174 * The interrupt endpoint will be called when any
175 * of the 6 registers changes state (depending on masks).
176 * Decode the register values and schedule a private event.
177 * Called at interrupt.
179 static void usb_int_complete(struct urb *urb, struct pt_regs *regs)
181 u8 *data = urb->transfer_buffer;
183 struct st5481_adapter *adapter = urb->context;
187 switch (urb->status) {
194 /* this urb is terminated, clean up */
195 DBG(1, "urb shutting down with status: %d", urb->status);
198 WARN("nonzero urb status received: %d", urb->status);
203 DBG_PACKET(1, data, INT_PKT_SIZE);
205 if (urb->actual_length == 0) {
209 irqbyte = data[MPINT];
210 if (irqbyte & DEN_INT)
211 FsmEvent(&adapter->d_out.fsm, EV_DOUT_DEN, NULL);
213 if (irqbyte & DCOLL_INT)
214 FsmEvent(&adapter->d_out.fsm, EV_DOUT_COLL, NULL);
216 irqbyte = data[FFINT_D];
217 if (irqbyte & OUT_UNDERRUN)
218 FsmEvent(&adapter->d_out.fsm, EV_DOUT_UNDERRUN, NULL);
220 if (irqbyte & OUT_DOWN)
221 ;// printk("OUT_DOWN\n");
223 irqbyte = data[MPINT];
224 if (irqbyte & RXCI_INT)
225 FsmEvent(&adapter->l1m, data[CCIST] & 0x0f, NULL);
227 for (j = 0; j < 2; j++)
228 adapter->bcs[j].b_out.flow_event |= data[FFINT_B1 + j];
230 urb->actual_length = 0;
233 status = usb_submit_urb (urb, GFP_ATOMIC);
235 WARN("usb_submit_urb failed with result %d", status);
238 /* ======================================================================
242 int st5481_setup_usb(struct st5481_adapter *adapter)
244 struct usb_device *dev = adapter->usb_dev;
245 struct st5481_ctrl *ctrl = &adapter->ctrl;
246 struct st5481_intr *intr = &adapter->intr;
247 struct usb_interface *intf;
248 struct usb_host_interface *altsetting = NULL;
249 struct usb_host_endpoint *endpoint;
256 if ((status = usb_reset_configuration (dev)) < 0) {
257 WARN("reset_configuration failed,status=%d",status);
261 intf = usb_ifnum_to_if(dev, 0);
263 altsetting = usb_altnum_to_altsetting(intf, 3);
267 // Check if the config is sane
268 if ( altsetting->desc.bNumEndpoints != 7 ) {
269 WARN("expecting 7 got %d endpoints!", altsetting->desc.bNumEndpoints);
273 // The descriptor is wrong for some early samples of the ST5481 chip
274 altsetting->endpoint[3].desc.wMaxPacketSize = 32;
275 altsetting->endpoint[4].desc.wMaxPacketSize = 32;
277 // Use alternative setting 3 on interface 0 to have 2B+D
278 if ((status = usb_set_interface (dev, 0, 3)) < 0) {
279 WARN("usb_set_interface failed,status=%d",status);
283 // Allocate URB for control endpoint
284 urb = usb_alloc_urb(0, GFP_KERNEL);
290 // Fill the control URB
291 usb_fill_control_urb (urb, dev,
292 usb_sndctrlpipe(dev, 0),
293 NULL, NULL, 0, usb_ctrl_complete, adapter);
296 fifo_init(&ctrl->msg_fifo.f, ARRAY_SIZE(ctrl->msg_fifo.data));
298 // Allocate URBs and buffers for interrupt endpoint
299 urb = usb_alloc_urb(0, GFP_KERNEL);
305 buf = kmalloc(INT_PKT_SIZE, GFP_KERNEL);
310 endpoint = &altsetting->endpoint[EP_INT-1];
312 // Fill the interrupt URB
313 usb_fill_int_urb(urb, dev,
314 usb_rcvintpipe(dev, endpoint->desc.bEndpointAddress),
316 usb_int_complete, adapter,
317 endpoint->desc.bInterval);
323 * Release buffers and URBs for the interrupt and control
326 void st5481_release_usb(struct st5481_adapter *adapter)
328 struct st5481_intr *intr = &adapter->intr;
329 struct st5481_ctrl *ctrl = &adapter->ctrl;
333 // Stop and free Control and Interrupt URBs
334 usb_unlink_urb(ctrl->urb);
335 if (ctrl->urb->transfer_buffer)
336 kfree(ctrl->urb->transfer_buffer);
337 usb_free_urb(ctrl->urb);
339 usb_unlink_urb(intr->urb);
340 if (intr->urb->transfer_buffer)
341 kfree(intr->urb->transfer_buffer);
342 usb_free_urb(intr->urb);
346 * Initialize the adapter.
348 void st5481_start(struct st5481_adapter *adapter)
350 static const u8 init_cmd_table[]={
364 MPMSK,RXCI_INT+DEN_INT+DCOLL_INT,
367 struct st5481_intr *intr = &adapter->intr;
373 adapter->leds = RED_LED;
375 // Start receiving on the interrupt endpoint
376 SUBMIT_URB(intr->urb, GFP_KERNEL);
378 while ((request = init_cmd_table[i++])) {
379 value = init_cmd_table[i++];
380 st5481_usb_device_ctrl_msg(adapter, request, value, NULL, NULL);
382 st5481_ph_command(adapter, ST5481_CMD_PUP);
386 * Reset the adapter to default values.
388 void st5481_stop(struct st5481_adapter *adapter)
392 st5481_usb_device_ctrl_msg(adapter, SET_DEFAULT, 0, NULL, NULL);
395 /* ======================================================================
396 * isochronous USB helpers
400 fill_isoc_urb(struct urb *urb, struct usb_device *dev,
401 unsigned int pipe, void *buf, int num_packets,
402 int packet_size, usb_complete_t complete,
407 spin_lock_init(&urb->lock);
410 urb->transfer_buffer=buf;
411 urb->number_of_packets = num_packets;
412 urb->transfer_buffer_length=num_packets*packet_size;
413 urb->actual_length = 0;
414 urb->complete=complete;
415 urb->context=context;
416 urb->transfer_flags=URB_ISO_ASAP;
417 for (k = 0; k < num_packets; k++) {
418 urb->iso_frame_desc[k].offset = packet_size * k;
419 urb->iso_frame_desc[k].length = packet_size;
420 urb->iso_frame_desc[k].actual_length = 0;
425 st5481_setup_isocpipes(struct urb* urb[2], struct usb_device *dev,
426 unsigned int pipe, int num_packets,
427 int packet_size, int buf_size,
428 usb_complete_t complete, void *context)
433 for (j = 0; j < 2; j++) {
435 urb[j] = usb_alloc_urb(num_packets, GFP_KERNEL);
439 // Allocate memory for 2000bytes/sec (16Kb/s)
440 buf = kmalloc(buf_size, GFP_KERNEL);
444 // Fill the isochronous URB
445 fill_isoc_urb(urb[j], dev, pipe, buf,
446 num_packets, packet_size, complete,
452 for (j = 0; j < 2; j++) {
454 if (urb[j]->transfer_buffer)
455 kfree(urb[j]->transfer_buffer);
456 usb_free_urb(urb[j]);
462 void st5481_release_isocpipes(struct urb* urb[2])
466 for (j = 0; j < 2; j++) {
467 usb_unlink_urb(urb[j]);
468 if (urb[j]->transfer_buffer)
469 kfree(urb[j]->transfer_buffer);
470 usb_free_urb(urb[j]);
475 * Decode frames received on the B/D channel.
476 * Note that this function will be called continously
477 * with 64Kbit/s / 16Kbit/s of data and hence it will be
478 * called 50 times per second with 20 ISOC descriptors.
479 * Called at interrupt.
481 static void usb_in_complete(struct urb *urb, struct pt_regs *regs)
483 struct st5481_in *in = urb->context;
486 int len, count, status;
488 if (unlikely(urb->status < 0)) {
489 if (urb->status != -ENOENT && urb->status != -ESHUTDOWN) {
490 WARN("urb status %d",urb->status);
497 DBG_ISO_PACKET(0x80,urb);
499 len = st5481_isoc_flatten(urb);
500 ptr = urb->transfer_buffer;
502 if (in->mode == L1_MODE_TRANS) {
503 memcpy(in->rcvbuf, ptr, len);
507 status = isdnhdlc_decode(&in->hdlc_state, ptr, len, &count,
508 in->rcvbuf, in->bufsize);
514 // Good frame received
515 DBG(4,"count=%d",status);
516 DBG_PACKET(0x400, in->rcvbuf, status);
517 if (!(skb = dev_alloc_skb(status))) {
518 WARN("receive out of memory\n");
521 memcpy(skb_put(skb, status), in->rcvbuf, status);
522 in->hisax_if->l1l2(in->hisax_if, PH_DATA | INDICATION, skb);
523 } else if (status == -HDLC_CRC_ERROR) {
525 } else if (status == -HDLC_FRAMING_ERROR) {
526 INFO("framing error");
527 } else if (status == -HDLC_LENGTH_ERROR) {
528 INFO("length error");
532 // Prepare URB for next transfer
533 urb->dev = in->adapter->usb_dev;
534 urb->actual_length = 0;
536 SUBMIT_URB(urb, GFP_ATOMIC);
539 int st5481_setup_in(struct st5481_in *in)
541 struct usb_device *dev = in->adapter->usb_dev;
546 in->rcvbuf = kmalloc(in->bufsize, GFP_KERNEL);
551 retval = st5481_setup_isocpipes(in->urb, dev,
552 usb_rcvisocpipe(dev, in->ep),
553 in->num_packets, in->packet_size,
554 in->num_packets * in->packet_size,
555 usb_in_complete, in);
566 void st5481_release_in(struct st5481_in *in)
570 st5481_release_isocpipes(in->urb);
574 * Make the transfer_buffer contiguous by
575 * copying from the iso descriptors if necessary.
577 int st5481_isoc_flatten(struct urb *urb)
579 struct usb_iso_packet_descriptor *pipd,*pend;
580 unsigned char *src,*dst;
583 if (urb->status < 0) {
586 for (pipd = &urb->iso_frame_desc[0],
587 pend = &urb->iso_frame_desc[urb->number_of_packets],
588 dst = urb->transfer_buffer;
592 if (pipd->status < 0) {
593 return (pipd->status);
596 len = pipd->actual_length;
597 pipd->actual_length = 0;
598 src = urb->transfer_buffer+pipd->offset;
601 // Need to copy since isoc buffers not full
606 // No need to copy, just update destination buffer
610 // Return size of flattened buffer
611 return (dst - (unsigned char *)urb->transfer_buffer);
614 static void st5481_start_rcv(void *context)
616 struct st5481_in *in = context;
617 struct st5481_adapter *adapter = in->adapter;
621 in->urb[0]->dev = adapter->usb_dev;
622 SUBMIT_URB(in->urb[0], GFP_KERNEL);
624 in->urb[1]->dev = adapter->usb_dev;
625 SUBMIT_URB(in->urb[1], GFP_KERNEL);
628 void st5481_in_mode(struct st5481_in *in, int mode)
630 if (in->mode == mode)
635 usb_unlink_urb(in->urb[0]);
636 usb_unlink_urb(in->urb[1]);
638 if (in->mode != L1_MODE_NULL) {
639 if (in->mode != L1_MODE_TRANS)
640 isdnhdlc_rcv_init(&in->hdlc_state,
641 in->mode == L1_MODE_HDLC_56K);
643 st5481_usb_pipe_reset(in->adapter, in->ep, NULL, NULL);
644 st5481_usb_device_ctrl_msg(in->adapter, in->counter,
647 st5481_start_rcv(in);
649 st5481_usb_device_ctrl_msg(in->adapter, in->counter,