PageRenderTime 61ms CodeModel.GetById 19ms app.highlight 35ms RepoModel.GetById 2ms app.codeStats 0ms

/drivers/isdn/hisax/st5481_usb.c

http://github.com/mirrors/linux
C | 664 lines | 461 code | 108 blank | 95 comment | 70 complexity | d34bb2fe0aaac4a418c8fe5d2e28412a MD5 | raw file
  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
 18static 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 */
 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	// 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 */
 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 * Asynchronous endpoint 0 device request.
 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 * Asynchronous pipe reset (async version of usb_clear_halt).
 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  Physical level functions
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 * The request on endpoint 0 has completed.
125 * Call the user provided completion routine and try
126 * to send the next request.
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; // Give up
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		/* Special case handling for pipe reset */
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	// Try to send next control message
161	usb_next_ctrl_msg(urb, adapter);
162	return;
163}
164
165/* ======================================================================
166 * interrupt pipe
167 */
168
169/*
170 * The interrupt endpoint will be called when any
171 * of the 6 registers changes state (depending on masks).
172 * Decode the register values and schedule a private event.
173 * Called at interrupt.
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		/* success */
186		break;
187	case -ECONNRESET:
188	case -ENOENT:
189	case -ESHUTDOWN:
190		/* this urb is terminated, clean up */
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		;//		printk("OUT_DOWN\n");
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 * initialization
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	// Check if the config is sane
264	if (altsetting->desc.bNumEndpoints != 7) {
265		WARNING("expecting 7 got %d endpoints!", altsetting->desc.bNumEndpoints);
266		return -EINVAL;
267	}
268
269	// The descriptor is wrong for some early samples of the ST5481 chip
270	altsetting->endpoint[3].desc.wMaxPacketSize = cpu_to_le16(32);
271	altsetting->endpoint[4].desc.wMaxPacketSize = cpu_to_le16(32);
272
273	// Use alternative setting 3 on interface 0 to have 2B+D
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	// Allocate URB for control endpoint
280	urb = usb_alloc_urb(0, GFP_KERNEL);
281	if (!urb) {
282		return -ENOMEM;
283	}
284	ctrl->urb = urb;
285
286	// Fill the control URB
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	// Allocate URBs and buffers for interrupt endpoint
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	// Fill the interrupt URB
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 * Release buffers and URBs for the interrupt and control
328 * endpoint.
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	// Stop and free Control and Interrupt URBs
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 *  Initialize the adapter.
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//		FFCTRL_OUT_D,4,
363//		FFCTRH_OUT_D,12,
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	// Start receiving on the interrupt endpoint
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 * Reset the adapter to default values.
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 * isochronous USB  helpers
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		// 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
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 * Decode frames received on the B/D channel.
481 * Note that this function will be called continuously
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 */
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; // Give up
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			// Good frame received
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	// 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
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 * Make the transfer_buffer contiguous by
584 * copying from the iso descriptors if necessary.
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			// 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
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}