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
18/* ======================================================================
19 * control pipe
20 */
21
22/*
23 * Send the next endpoint 0 request stored in the FIFO.
24 * Called either by the completion or by usb_ctrl_msg.
25 */
26static void usb_next_ctrl_msg(struct urb *urb,
27			      struct st5481_adapter *adapter)
28{
29	struct st5481_ctrl *ctrl = &adapter->ctrl;
30	int r_index;
31
32	if (test_and_set_bit(0, &ctrl->busy)) {
33		return;
34	}
35
36	if ((r_index = fifo_remove(&ctrl->msg_fifo.f)) < 0) {
37		test_and_clear_bit(0,&ctrl->busy);
38		return;
39	}
40	urb->setup_packet =
41		(unsigned char *)&ctrl->msg_fifo.data[r_index];
42
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);
47
48	// Prepare the URB
49	urb->dev = adapter->usb_dev;
50
51	SUBMIT_URB(urb);
52}
53
54/*
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.
57 */
58void usb_ctrl_msg(struct st5481_adapter *adapter,
59		  u8 request, u8 requesttype, u16 value, u16 index,
60		  ctrl_complete_t complete, void *context)
61{
62	struct st5481_ctrl *ctrl = &adapter->ctrl;
63	int w_index;
64	struct ctrl_msg *ctrl_msg;
65
66	if ((w_index = fifo_add(&ctrl->msg_fifo.f)) < 0) {
67		WARN("control msg FIFO full");
68		return;
69	}
70	ctrl_msg = &ctrl->msg_fifo.data[w_index];
71
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;
79
80	usb_next_ctrl_msg(ctrl->urb, adapter);
81}
82
83/*
84 * Asynchronous endpoint 0 device request.
85 */
86void st5481_usb_device_ctrl_msg(struct st5481_adapter *adapter,
87			 u8 request, u16 value,
88			 ctrl_complete_t complete, void *context)
89{
90	usb_ctrl_msg(adapter, request,
91		     USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
92		     value, 0, complete, context);
93}
94
95/*
96 * Asynchronous pipe reset (async version of usb_clear_halt).
97 */
98void st5481_usb_pipe_reset(struct st5481_adapter *adapter,
99		    u_char pipe,
100		    ctrl_complete_t complete, void *context)
101{
102	DBG(1,"pipe=%02x",pipe);
103
104	usb_ctrl_msg(adapter,
105		     USB_REQ_CLEAR_FEATURE, USB_DIR_OUT | USB_RECIP_ENDPOINT,
106		     0, pipe, complete, context);
107}
108
109
110/*
111  Physical level functions
112*/
113
114void st5481_ph_command(struct st5481_adapter *adapter, unsigned int command)
115{
116	DBG(8,"command=%s", ST5481_CMD_string(command));
117
118	st5481_usb_device_ctrl_msg(adapter, TXCI, command, NULL, NULL);
119}
120
121/*
122 * The request on endpoint 0 has completed.
123 * Call the user provided completion routine and try
124 * to send the next request.
125 */
126static void usb_ctrl_complete(struct urb *urb)
127{
128	struct st5481_adapter *adapter = urb->context;
129	struct st5481_ctrl *ctrl = &adapter->ctrl;
130	struct ctrl_msg *ctrl_msg;
131
132	if (urb->status < 0) {
133		if (urb->status != USB_ST_URB_KILLED) {
134			WARN("urb status %d",urb->status);
135		} else {
136			DBG(1,"urb killed");
137			return; // Give up
138		}
139	}
140
141	ctrl_msg = (struct ctrl_msg *)urb->setup_packet;
142
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);
149
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,
154			      0);
155
156
157	}
158
159	if (ctrl_msg->complete)
160		ctrl_msg->complete(ctrl_msg->context);
161
162	clear_bit(0, &ctrl->busy);
163
164	// Try to send next control message
165	usb_next_ctrl_msg(urb, adapter);
166	return;
167}
168
169/* ======================================================================
170 * interrupt pipe
171 */
172
173/*
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.
178 */
179static void usb_int_complete(struct urb *urb)
180{
181	u_char *data = urb->transfer_buffer;
182	u_char irqbyte;
183	struct st5481_adapter *adapter = urb->context;
184	int j;
185
186	if (urb->status < 0) {
187		if (urb->status != USB_ST_URB_KILLED) {
188			WARN("urb status %d",urb->status);
189			urb->actual_length = 0;
190		} else {
191			DBG(1,"urb killed");
192			return; // Give up
193		}
194	}
195
196	DBG_PACKET(1, data, INT_PKT_SIZE);
197
198	if (urb->actual_length == 0) {
199		return;
200	}
201
202	irqbyte = data[MPINT];
203	if (irqbyte & DEN_INT)
204		FsmEvent(&adapter->d_out.fsm, EV_DOUT_DEN, NULL);
205
206	if (irqbyte & DCOLL_INT)
207		FsmEvent(&adapter->d_out.fsm, EV_DOUT_COLL, NULL);
208
209	irqbyte = data[FFINT_D];
210	if (irqbyte & OUT_UNDERRUN)
211		FsmEvent(&adapter->d_out.fsm, EV_DOUT_UNDERRUN, NULL);
212
213	if (irqbyte & OUT_DOWN)
214;//		printk("OUT_DOWN\n");
215
216	irqbyte = data[MPINT];
217	if (irqbyte & RXCI_INT)
218		FsmEvent(&adapter->l1m, data[CCIST] & 0x0f, NULL);
219
220	for (j = 0; j < 2; j++)
221		adapter->bcs[j].b_out.flow_event |= data[FFINT_B1 + j];
222
223	urb->actual_length = 0;
224}
225
226/* ======================================================================
227 * initialization
228 */
229
230int __devinit st5481_setup_usb(struct st5481_adapter *adapter)
231{
232	struct usb_device *dev = adapter->usb_dev;
233	struct st5481_ctrl *ctrl = &adapter->ctrl;
234	struct st5481_intr *intr = &adapter->intr;
235	struct usb_interface_descriptor *altsetting;
236	struct usb_endpoint_descriptor *endpoint;
237	int status;
238	struct urb *urb;
239	u_char *buf;
240
241	DBG(1,"");
242
243	if ((status = usb_set_configuration (dev,dev->config[0].bConfigurationValue)) < 0) {
244		WARN("set_configuration failed,status=%d",status);
245		return status;
246	}
247
248
249	altsetting = &(dev->config->interface[0].altsetting[3]);
250
251	// Check if the config is sane
252	if ( altsetting->bNumEndpoints != 7 ) {
253		WARN("expecting 7 got %d endpoints!", altsetting->bNumEndpoints);
254		return -EINVAL;
255	}
256
257	// The descriptor is wrong for some early samples of the ST5481 chip
258	altsetting->endpoint[3].wMaxPacketSize = 32;
259	altsetting->endpoint[4].wMaxPacketSize = 32;
260
261	// Use alternative setting 3 on interface 0 to have 2B+D
262	if ((status = usb_set_interface (dev, 0, 3)) < 0) {
263		WARN("usb_set_interface failed,status=%d",status);
264		return status;
265	}
266
267	// Allocate URB for control endpoint
268	urb = usb_alloc_urb(0);
269	if (!urb) {
270		return -ENOMEM;
271	}
272	ctrl->urb = urb;
273
274	// Fill the control URB
275	FILL_CONTROL_URB (urb, dev,
276			  usb_sndctrlpipe(dev, 0),
277			  NULL, NULL, 0, usb_ctrl_complete, adapter);
278
279
280	fifo_init(&ctrl->msg_fifo.f, ARRAY_SIZE(ctrl->msg_fifo.data));
281
282	// Allocate URBs and buffers for interrupt endpoint
283	urb = usb_alloc_urb(0);
284	if (!urb) {
285		return -ENOMEM;
286	}
287	intr->urb = urb;
288
289	buf = kmalloc(INT_PKT_SIZE, GFP_KERNEL);
290	if (!buf) {
291		return -ENOMEM;
292	}
293
294	endpoint = &altsetting->endpoint[EP_INT-1];
295
296	// Fill the interrupt URB
297	FILL_INT_URB(urb, dev,
298		     usb_rcvintpipe(dev, endpoint->bEndpointAddress),
299		     buf, INT_PKT_SIZE,
300		     usb_int_complete, adapter,
301		     endpoint->bInterval);
302
303	return 0;
304}
305
306/*
307 * Release buffers and URBs for the interrupt and control
308 * endpoint.
309 */
310void st5481_release_usb(struct st5481_adapter *adapter)
311{
312	struct st5481_intr *intr = &adapter->intr;
313	struct st5481_ctrl *ctrl = &adapter->ctrl;
314
315	DBG(1,"");
316
317	// Stop and free Control and Interrupt URBs
318	usb_unlink_urb(ctrl->urb);
319	if (ctrl->urb->transfer_buffer)
320		kfree(ctrl->urb->transfer_buffer);
321	usb_free_urb(ctrl->urb);
322
323	usb_unlink_urb(intr->urb);
324	if (intr->urb->transfer_buffer)
325		kfree(intr->urb->transfer_buffer);
326	usb_free_urb(intr->urb);
327}
328
329/*
330 *  Initialize the adapter.
331 */
332void __devinit st5481_start(struct st5481_adapter *adapter)
333{
334	static const u8 init_cmd_table[]={
335		SET_DEFAULT,0,
336		STT,0,
337		SDA_MIN,0x0d,
338		SDA_MAX,0x29,
339		SDELAY_VALUE,0x14,
340		GPIO_DIR,0x01,
341		GPIO_OUT,RED_LED,
342//		FFCTRL_OUT_D,4,
343//		FFCTRH_OUT_D,12,
344		FFCTRL_OUT_B1,6,
345		FFCTRH_OUT_B1,20,
346		FFCTRL_OUT_B2,6,
347		FFCTRH_OUT_B2,20,
348		MPMSK,RXCI_INT+DEN_INT+DCOLL_INT,
349		0
350	};
351	struct st5481_intr *intr = &adapter->intr;
352	int i = 0;
353	u8 request,value;
354
355	DBG(8,"");
356
357	adapter->leds = RED_LED;
358
359	// Start receiving on the interrupt endpoint
360	SUBMIT_URB(intr->urb);
361
362	while ((request = init_cmd_table[i++])) {
363		value = init_cmd_table[i++];
364		st5481_usb_device_ctrl_msg(adapter, request, value, NULL, NULL);
365	}
366	st5481_ph_command(adapter, ST5481_CMD_PUP);
367}
368
369/*
370 * Reset the adapter to default values.
371 */
372void __devexit st5481_stop(struct st5481_adapter *adapter)
373{
374	DBG(8,"");
375
376	st5481_usb_device_ctrl_msg(adapter, SET_DEFAULT, 0, NULL, NULL);
377}
378
379/* ======================================================================
380 * isochronous USB  helpers
381 */
382
383static void __devinit
384fill_isoc_urb(struct urb *urb, struct usb_device *dev,
385	      unsigned int pipe, void *buf, int num_packets,
386	      int packet_size, usb_complete_t complete,
387	      void *context)
388{
389	int k;
390
391	spin_lock_init(&urb->lock);
392	urb->dev=dev;
393	urb->pipe=pipe;
394	urb->transfer_buffer=buf;
395	urb->number_of_packets = num_packets;
396	urb->transfer_buffer_length=num_packets*packet_size;
397	urb->actual_length = 0;
398	urb->complete=complete;
399	urb->context=context;
400	urb->transfer_flags=USB_ISO_ASAP;
401	for (k = 0; k < num_packets; k++) {
402		urb->iso_frame_desc[k].offset = packet_size * k;
403		urb->iso_frame_desc[k].length = packet_size;
404		urb->iso_frame_desc[k].actual_length = 0;
405	}
406}
407
408int __devinit
409st5481_setup_isocpipes(struct urb* urb[2], struct usb_device *dev,
410			   unsigned int pipe, int num_packets,
411			   int packet_size, int buf_size,
412			   usb_complete_t complete, void *context)
413{
414	int j, retval;
415	unsigned char *buf;
416
417	for (j = 0; j < 2; j++) {
418		retval = -ENOMEM;
419		urb[j] = usb_alloc_urb(num_packets);
420		if (!urb[j])
421			goto err;
422
423		// Allocate memory for 2000bytes/sec (16Kb/s)
424		buf = kmalloc(buf_size, GFP_KERNEL);
425		if (!buf)
426			goto err;
427
428		// Fill the isochronous URB
429		fill_isoc_urb(urb[j], dev, pipe, buf,
430			      num_packets, packet_size, complete,
431			      context);
432	}
433	return 0;
434
435 err:
436	for (j = 0; j < 2; j++) {
437		if (urb[j]) {
438			if (urb[j]->transfer_buffer)
439				kfree(urb[j]->transfer_buffer);
440			usb_free_urb(urb[j]);
441		}
442	}
443	return retval;
444}
445
446void st5481_release_isocpipes(struct urb* urb[2])
447{
448	int j;
449
450	for (j = 0; j < 2; j++) {
451		usb_unlink_urb(urb[j]);
452		if (urb[j]->transfer_buffer)
453			kfree(urb[j]->transfer_buffer);
454		usb_free_urb(urb[j]);
455	}
456}
457
458/*
459 * Decode frames received on the B/D channel.
460 * Note that this function will be called continously
461 * with 64Kbit/s / 16Kbit/s of data and hence it will be
462 * called 50 times per second with 20 ISOC descriptors.
463 * Called at interrupt.
464 */
465static void usb_in_complete(struct urb *urb)
466{
467	struct st5481_in *in = urb->context;
468	unsigned char *ptr;
469	struct sk_buff *skb;
470	int len, count, status;
471
472	if (urb->status < 0) {
473		if (urb->status != USB_ST_URB_KILLED) {
474			WARN("urb status %d",urb->status);
475		} else {
476			DBG(1,"urb killed");
477			return; // Give up
478		}
479	}
480
481	DBG_ISO_PACKET(0x80,urb);
482
483	len = st5481_isoc_flatten(urb);
484	ptr = urb->transfer_buffer;
485	while (len > 0) {
486		if (in->mode == L1_MODE_TRANS) {
487			memcpy(in->rcvbuf, ptr, len);
488			status = len;
489			len = 0;
490		} else {
491			status = hdlc_decode(&in->hdlc_state, ptr, len, &count,
492					     in->rcvbuf, in->bufsize);
493			ptr += count;
494			len -= count;
495		}
496
497		if (status > 0) {
498			// Good frame received
499			DBG(4,"count=%d",status);
500			DBG_PACKET(0x400, in->rcvbuf, status);
501			if (!(skb = dev_alloc_skb(status))) {
502				WARN("receive out of memory\n");
503				break;
504			}
505			memcpy(skb_put(skb, status), in->rcvbuf, status);
506			in->hisax_if->l1l2(in->hisax_if, PH_DATA | INDICATION, skb);
507		} else if (status == -HDLC_CRC_ERROR) {
508			INFO("CRC error");
509		} else if (status == -HDLC_FRAMING_ERROR) {
510			INFO("framing error");
511		} else if (status == -HDLC_LENGTH_ERROR) {
512			INFO("length error");
513		}
514	}
515
516	// Prepare URB for next transfer
517	urb->dev = in->adapter->usb_dev;
518	urb->actual_length = 0;
519
520	SUBMIT_URB(urb);
521}
522
523int __devinit st5481_setup_in(struct st5481_in *in)
524{
525	struct usb_device *dev = in->adapter->usb_dev;
526	int retval;
527
528	DBG(4,"");
529
530	in->rcvbuf = kmalloc(in->bufsize, GFP_KERNEL);
531	retval = -ENOMEM;
532	if (!in->rcvbuf)
533		goto err;
534
535	retval = st5481_setup_isocpipes(in->urb, dev,
536					usb_rcvisocpipe(dev, in->ep),
537					in->num_packets,  in->packet_size,
538					in->num_packets * in->packet_size,
539					usb_in_complete, in);
540	if (retval)
541		goto err_free;
542	return 0;
543
544 err_free:
545	kfree(in->rcvbuf);
546 err:
547	return retval;
548}
549
550void st5481_release_in(struct st5481_in *in)
551{
552	DBG(2,"");
553
554	st5481_release_isocpipes(in->urb);
555}
556
557/*
558 * Make the transfer_buffer contiguous by
559 * copying from the iso descriptors if necessary.
560 */
561int st5481_isoc_flatten(struct urb *urb)
562{
563	struct iso_packet_descriptor *pipd;
564	struct iso_packet_descriptor *pend;
565	unsigned char *src,*dst;
566	unsigned int len;
567
568	if (urb->status < 0) {
569		return urb->status;
570	}
571	for (pipd = &urb->iso_frame_desc[0],
572		     pend = &urb->iso_frame_desc[urb->number_of_packets],
573		     dst = urb->transfer_buffer;
574	     pipd < pend;
575	     pipd++) {
576
577		if (pipd->status < 0) {
578			return (pipd->status);
579		}
580
581		len = pipd->actual_length;
582		pipd->actual_length = 0;
583		src = urb->transfer_buffer+pipd->offset;
584
585		if (src != dst) {
586			// Need to copy since isoc buffers not full
587			while (len--) {
588				*dst++ = *src++;
589			}
590		} else {
591			// No need to copy, just update destination buffer
592			dst += len;
593		}
594	}
595	// Return size of flattened buffer
596	return (dst - (unsigned char *)urb->transfer_buffer);
597}
598
599static void st5481_start_rcv(void *context)
600{
601	struct st5481_in *in = context;
602	struct st5481_adapter *adapter = in->adapter;
603
604	DBG(4,"");
605
606	in->urb[0]->dev = adapter->usb_dev;
607	SUBMIT_URB(in->urb[0]);
608
609	in->urb[1]->dev = adapter->usb_dev;
610	SUBMIT_URB(in->urb[1]);
611}
612
613void st5481_in_mode(struct st5481_in *in, int mode)
614{
615	if (in->mode == mode)
616		return;
617
618	in->mode = mode;
619
620	usb_unlink_urb(in->urb[0]);
621	usb_unlink_urb(in->urb[1]);
622
623	if (in->mode != L1_MODE_NULL) {
624		if (in->mode != L1_MODE_TRANS)
625			hdlc_rcv_init(&in->hdlc_state,
626				      in->mode == L1_MODE_HDLC_56K);
627
628		st5481_usb_pipe_reset(in->adapter, in->ep, NULL, NULL);
629		st5481_usb_device_ctrl_msg(in->adapter, in->counter,
630					   in->packet_size,
631					   NULL, NULL);
632		st5481_start_rcv(in);
633	} else {
634		st5481_usb_device_ctrl_msg(in->adapter, in->counter,
635					   0, NULL, NULL);
636	}
637}
638
639