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		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 */
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				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 */
182static void usb_int_complete(struct urb *urb)
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
235exit:
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
245int 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 */
329void 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 */
351void 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 */
391void 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
402static void
403fill_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	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_packets*packet_size;
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 = packet_size * k;
422		urb->iso_frame_desc[k].length = packet_size;
423		urb->iso_frame_desc[k].actual_length = 0;
424	}
425}
426
427int
428st5481_setup_isocpipes(struct urb* urb[2], struct usb_device *dev,
429			   unsigned int pipe, int num_packets,
430			   int packet_size, int buf_size,
431			   usb_complete_t complete, void *context)
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_packets, GFP_KERNEL);
439		if (!urb[j])
440			goto err;
441
442		// Allocate memory for 2000bytes/sec (16Kb/s)
443		buf = kmalloc(buf_size, GFP_KERNEL);
444		if (!buf)
445			goto err;
446
447		// Fill the isochronous URB
448		fill_isoc_urb(urb[j], dev, pipe, buf,
449			      num_packets, packet_size, complete,
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_buffer);
458			urb[j]->transfer_buffer = NULL;
459			usb_free_urb(urb[j]);
460			urb[j] = NULL;
461		}
462	}
463	return retval;
464}
465
466void st5481_release_isocpipes(struct urb* urb[2])
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 continously
481 * with 64Kbit/s / 16Kbit/s of data and hence it will be
482 * called 50 times per second with 20 ISOC descriptors.
483 * Called at interrupt.
484 */
485static 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 killed status %d", urb->status);
498				return; // Give up
499			default:
500				WARN("urb status %d",urb->status);
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, len);
512			status = len;
513			len = 0;
514		} else {
515			status = isdnhdlc_decode(&in->hdlc_state, ptr, len, &count,
516				in->rcvbuf, in->bufsize);
517			ptr += count;
518			len -= count;
519		}
520
521		if (status > 0) {
522			// Good frame received
523			DBG(4,"count=%d",status);
524			DBG_PACKET(0x400, in->rcvbuf, status);
525			if (!(skb = dev_alloc_skb(status))) {
526				WARN("receive out of memory\n");
527				break;
528			}
529			memcpy(skb_put(skb, status), in->rcvbuf, status);
530			in->hisax_if->l1l2(in->hisax_if, PH_DATA | INDICATION, skb);
531		} else if (status == -HDLC_CRC_ERROR) {
532			INFO("CRC error");
533		} else if (status == -HDLC_FRAMING_ERROR) {
534			INFO("framing error");
535		} else if (status == -HDLC_LENGTH_ERROR) {
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
547int st5481_setup_in(struct st5481_in *in)
548{
549	struct usb_device *dev = in->adapter->usb_dev;
550	int retval;
551
552	DBG(4,"");
553
554	in->rcvbuf = kmalloc(in->bufsize, GFP_KERNEL);
555	retval = -ENOMEM;
556	if (!in->rcvbuf)
557		goto err;
558
559	retval = st5481_setup_isocpipes(in->urb, dev,
560					usb_rcvisocpipe(dev, in->ep),
561					in->num_packets,  in->packet_size,
562					in->num_packets * in->packet_size,
563					usb_in_complete, 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
574void 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 necessary.
584 */
585static int st5481_isoc_flatten(struct urb *urb)
586{
587	struct usb_iso_packet_descriptor *pipd,*pend;
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_desc[urb->number_of_packets],
596		     dst = urb->transfer_buffer;
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+pipd->offset;
607
608		if (src != dst) {
609			// Need to copy since isoc buffers not full
610			while (len--) {
611				*dst++ = *src++;
612			}
613		} else {
614			// No need to copy, just update destination buffer
615			dst += len;
616		}
617	}
618	// Return size of flattened buffer
619	return (dst - (unsigned char *)urb->transfer_buffer);
620}
621
622static void st5481_start_rcv(void *context)
623{
624	struct st5481_in *in = context;
625	struct st5481_adapter *adapter = in->adapter;
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
636void st5481_in_mode(struct st5481_in *in, int mode)
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->hdlc_state,
649				in->mode == L1_MODE_HDLC_56K);
650
651		st5481_usb_pipe_reset(in->adapter, in->ep, NULL, NULL);
652		st5481_usb_device_ctrl_msg(in->adapter, in->counter,
653					   in->packet_size,
654					   NULL, NULL);
655		st5481_start_rcv(in);
656	} else {
657		st5481_usb_device_ctrl_msg(in->adapter, in->counter,
658					   0, NULL, NULL);
659	}
660}
661