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/gfp.h>
15#include <linux/usb.h>
16#include <linux/netdevice.h>
17#include <linux/bitrev.h>
18#include "st5481.h"
19
20static inline void B_L1L2(struct st5481_bcs *bcs, int pr, void *arg)
21{
22	struct hisax_if *ifc = (struct hisax_if *) &bcs->b_if;
23
24	ifc->l1l2(ifc, pr, arg);
25}
26
27/*
28 * Encode and transmit next frame.
29 */
30static void usb_b_out(struct st5481_bcs *bcs, int buf_nr)
31{
32	struct st5481_b_out *b_out = &bcs->b_out;
33	struct st5481_adapter *adapter = bcs->adapter;
34	struct urb *urb;
35	unsigned int packet_size, offset;
36	int len, buf_size, bytes_sent;
37	int i;
38	struct sk_buff *skb;
39
40	if (test_and_set_bit(buf_nr, &b_out->busy)) {
41		DBG(4, "ep %d urb %d busy", (bcs->channel + 1) * 2, buf_nr);
42		return;
43	}
44	urb = b_out->urb[buf_nr];
45
46	// Adjust isoc buffer size according to flow state
47	if (b_out->flow_event & (OUT_DOWN | OUT_UNDERRUN)) {
48		buf_size = NUM_ISO_PACKETS_B * SIZE_ISO_PACKETS_B_OUT + B_FLOW_ADJUST;
49		packet_size = SIZE_ISO_PACKETS_B_OUT + B_FLOW_ADJUST;
50		DBG(4, "B%d,adjust flow,add %d bytes", bcs->channel + 1, B_FLOW_ADJUST);
51	} else if (b_out->flow_event & OUT_UP) {
52		buf_size = NUM_ISO_PACKETS_B * SIZE_ISO_PACKETS_B_OUT - B_FLOW_ADJUST;
53		packet_size = SIZE_ISO_PACKETS_B_OUT - B_FLOW_ADJUST;
54		DBG(4, "B%d,adjust flow,remove %d bytes", bcs->channel + 1, B_FLOW_ADJUST);
55	} else {
56		buf_size = NUM_ISO_PACKETS_B * SIZE_ISO_PACKETS_B_OUT;
57		packet_size = 8;
58	}
59	b_out->flow_event = 0;
60
61	len = 0;
62	while (len < buf_size) {
63		if ((skb = b_out->tx_skb)) {
64			DBG_SKB(0x100, skb);
65			DBG(4, "B%d,len=%d", bcs->channel + 1, skb->len);
66
67			if (bcs->mode == L1_MODE_TRANS) {
68				bytes_sent = buf_size - len;
69				if (skb->len < bytes_sent)
70					bytes_sent = skb->len;
71				{	/* swap tx bytes to get hearable audio data */
72					register unsigned char *src  = skb->data;
73					register unsigned char *dest = urb->transfer_buffer + len;
74					register unsigned int count;
75					for (count = 0; count < bytes_sent; count++)
76						*dest++ = bitrev8(*src++);
77				}
78				len += bytes_sent;
79			} else {
80				len += isdnhdlc_encode(&b_out->hdlc_state,
81						       skb->data, skb->len, &bytes_sent,
82						       urb->transfer_buffer + len, buf_size-len);
83			}
84
85			skb_pull(skb, bytes_sent);
86
87			if (!skb->len) {
88				// Frame sent
89				b_out->tx_skb = NULL;
90				B_L1L2(bcs, PH_DATA | CONFIRM, (void *)(unsigned long) skb->truesize);
91				dev_kfree_skb_any(skb);
92
93/*				if (!(bcs->tx_skb = skb_dequeue(&bcs->sq))) { */
94/*					st5481B_sched_event(bcs, B_XMTBUFREADY); */
95/*				} */
96			}
97		} else {
98			if (bcs->mode == L1_MODE_TRANS) {
99				memset(urb->transfer_buffer + len, 0xff, buf_size-len);
100				len = buf_size;
101			} else {
102				// Send flags
103				len += isdnhdlc_encode(&b_out->hdlc_state,
104						       NULL, 0, &bytes_sent,
105						       urb->transfer_buffer + len, buf_size-len);
106			}
107		}
108	}
109
110	// Prepare the URB
111	for (i = 0, offset = 0; offset < len; i++) {
112		urb->iso_frame_desc[i].offset = offset;
113		urb->iso_frame_desc[i].length = packet_size;
114		offset += packet_size;
115		packet_size = SIZE_ISO_PACKETS_B_OUT;
116	}
117	urb->transfer_buffer_length = len;
118	urb->number_of_packets = i;
119	urb->dev = adapter->usb_dev;
120
121	DBG_ISO_PACKET(0x200, urb);
122
123	SUBMIT_URB(urb, GFP_NOIO);
124}
125
126/*
127 * Start transferring (flags or data) on the B channel, since
128 * FIFO counters has been set to a non-zero value.
129 */
130static void st5481B_start_xfer(void *context)
131{
132	struct st5481_bcs *bcs = context;
133
134	DBG(4, "B%d", bcs->channel + 1);
135
136	// Start transmitting (flags or data) on B channel
137
138	usb_b_out(bcs, 0);
139	usb_b_out(bcs, 1);
140}
141
142/*
143 * If the adapter has only 2 LEDs, the green
144 * LED will blink with a rate depending
145 * on the number of channels opened.
146 */
147static void led_blink(struct st5481_adapter *adapter)
148{
149	u_char leds = adapter->leds;
150
151	// 50 frames/sec for each channel
152	if (++adapter->led_counter % 50) {
153		return;
154	}
155
156	if (adapter->led_counter % 100) {
157		leds |= GREEN_LED;
158	} else {
159		leds &= ~GREEN_LED;
160	}
161
162	st5481_usb_device_ctrl_msg(adapter, GPIO_OUT, leds, NULL, NULL);
163}
164
165static void usb_b_out_complete(struct urb *urb)
166{
167	struct st5481_bcs *bcs = urb->context;
168	struct st5481_b_out *b_out = &bcs->b_out;
169	struct st5481_adapter *adapter = bcs->adapter;
170	int buf_nr;
171
172	buf_nr = get_buf_nr(b_out->urb, urb);
173	test_and_clear_bit(buf_nr, &b_out->busy);
174
175	if (unlikely(urb->status < 0)) {
176		switch (urb->status) {
177		case -ENOENT:
178		case -ESHUTDOWN:
179		case -ECONNRESET:
180			DBG(4, "urb killed status %d", urb->status);
181			return; // Give up
182		default:
183			WARNING("urb status %d", urb->status);
184			if (b_out->busy == 0) {
185				st5481_usb_pipe_reset(adapter, (bcs->channel + 1) * 2 | USB_DIR_OUT, NULL, NULL);
186			}
187			break;
188		}
189	}
190
191	usb_b_out(bcs, buf_nr);
192
193	if (adapter->number_of_leds == 2)
194		led_blink(adapter);
195}
196
197/*
198 * Start or stop the transfer on the B channel.
199 */
200static void st5481B_mode(struct st5481_bcs *bcs, int mode)
201{
202	struct st5481_b_out *b_out = &bcs->b_out;
203	struct st5481_adapter *adapter = bcs->adapter;
204
205	DBG(4, "B%d,mode=%d", bcs->channel + 1, mode);
206
207	if (bcs->mode == mode)
208		return;
209
210	bcs->mode = mode;
211
212	// Cancel all USB transfers on this B channel
213	usb_unlink_urb(b_out->urb[0]);
214	usb_unlink_urb(b_out->urb[1]);
215	b_out->busy = 0;
216
217	st5481_in_mode(&bcs->b_in, mode);
218	if (bcs->mode != L1_MODE_NULL) {
219		// Open the B channel
220		if (bcs->mode != L1_MODE_TRANS) {
221			u32 features = HDLC_BITREVERSE;
222			if (bcs->mode == L1_MODE_HDLC_56K)
223				features |= HDLC_56KBIT;
224			isdnhdlc_out_init(&b_out->hdlc_state, features);
225		}
226		st5481_usb_pipe_reset(adapter, (bcs->channel + 1) * 2, NULL, NULL);
227
228		// Enable B channel interrupts
229		st5481_usb_device_ctrl_msg(adapter, FFMSK_B1 + (bcs->channel * 2),
230					   OUT_UP + OUT_DOWN + OUT_UNDERRUN, NULL, NULL);
231
232		// Enable B channel FIFOs
233		st5481_usb_device_ctrl_msg(adapter, OUT_B1_COUNTER+(bcs->channel * 2), 32, st5481B_start_xfer, bcs);
234		if (adapter->number_of_leds == 4) {
235			if (bcs->channel == 0) {
236				adapter->leds |= B1_LED;
237			} else {
238				adapter->leds |= B2_LED;
239			}
240		}
241	} else {
242		// Disble B channel interrupts
243		st5481_usb_device_ctrl_msg(adapter, FFMSK_B1+(bcs->channel * 2), 0, NULL, NULL);
244
245		// Disable B channel FIFOs
246		st5481_usb_device_ctrl_msg(adapter, OUT_B1_COUNTER+(bcs->channel * 2), 0, NULL, NULL);
247
248		if (adapter->number_of_leds == 4) {
249			if (bcs->channel == 0) {
250				adapter->leds &= ~B1_LED;
251			} else {
252				adapter->leds &= ~B2_LED;
253			}
254		} else {
255			st5481_usb_device_ctrl_msg(adapter, GPIO_OUT, adapter->leds, NULL, NULL);
256		}
257		if (b_out->tx_skb) {
258			dev_kfree_skb_any(b_out->tx_skb);
259			b_out->tx_skb = NULL;
260		}
261
262	}
263}
264
265static int st5481_setup_b_out(struct st5481_bcs *bcs)
266{
267	struct usb_device *dev = bcs->adapter->usb_dev;
268	struct usb_interface *intf;
269	struct usb_host_interface *altsetting = NULL;
270	struct usb_host_endpoint *endpoint;
271	struct st5481_b_out *b_out = &bcs->b_out;
272
273	DBG(4, "");
274
275	intf = usb_ifnum_to_if(dev, 0);
276	if (intf)
277		altsetting = usb_altnum_to_altsetting(intf, 3);
278	if (!altsetting)
279		return -ENXIO;
280
281	// Allocate URBs and buffers for the B channel out
282	endpoint = &altsetting->endpoint[EP_B1_OUT - 1 + bcs->channel * 2];
283
284	DBG(4, "endpoint address=%02x,packet size=%d",
285	    endpoint->desc.bEndpointAddress, le16_to_cpu(endpoint->desc.wMaxPacketSize));
286
287	// Allocate memory for 8000bytes/sec + extra bytes if underrun
288	return st5481_setup_isocpipes(b_out->urb, dev,
289				      usb_sndisocpipe(dev, endpoint->desc.bEndpointAddress),
290				      NUM_ISO_PACKETS_B, SIZE_ISO_PACKETS_B_OUT,
291				      NUM_ISO_PACKETS_B * SIZE_ISO_PACKETS_B_OUT + B_FLOW_ADJUST,
292				      usb_b_out_complete, bcs);
293}
294
295static void st5481_release_b_out(struct st5481_bcs *bcs)
296{
297	struct st5481_b_out *b_out = &bcs->b_out;
298
299	DBG(4, "");
300
301	st5481_release_isocpipes(b_out->urb);
302}
303
304int st5481_setup_b(struct st5481_bcs *bcs)
305{
306	int retval;
307
308	DBG(4, "");
309
310	retval = st5481_setup_b_out(bcs);
311	if (retval)
312		goto err;
313	bcs->b_in.bufsize = HSCX_BUFMAX;
314	bcs->b_in.num_packets = NUM_ISO_PACKETS_B;
315	bcs->b_in.packet_size = SIZE_ISO_PACKETS_B_IN;
316	bcs->b_in.ep = (bcs->channel ? EP_B2_IN : EP_B1_IN) | USB_DIR_IN;
317	bcs->b_in.counter = bcs->channel ? IN_B2_COUNTER : IN_B1_COUNTER;
318	bcs->b_in.adapter = bcs->adapter;
319	bcs->b_in.hisax_if = &bcs->b_if.ifc;
320	retval = st5481_setup_in(&bcs->b_in);
321	if (retval)
322		goto err_b_out;
323
324
325	return 0;
326
327err_b_out:
328	st5481_release_b_out(bcs);
329err:
330	return retval;
331}
332
333/*
334 * Release buffers and URBs for the B channels
335 */
336void st5481_release_b(struct st5481_bcs *bcs)
337{
338	DBG(4, "");
339
340	st5481_release_in(&bcs->b_in);
341	st5481_release_b_out(bcs);
342}
343
344/*
345 * st5481_b_l2l1 is the entry point for upper layer routines that want to
346 * transmit on the B channel.  PH_DATA | REQUEST is a normal packet that
347 * we either start transmitting (if idle) or queue (if busy).
348 * PH_PULL | REQUEST can be called to request a callback message
349 * (PH_PULL | CONFIRM)
350 * once the link is idle.  After a "pull" callback, the upper layer
351 * routines can use PH_PULL | INDICATION to send data.
352 */
353void st5481_b_l2l1(struct hisax_if *ifc, int pr, void *arg)
354{
355	struct st5481_bcs *bcs = ifc->priv;
356	struct sk_buff *skb = arg;
357	long mode;
358
359	DBG(4, "");
360
361	switch (pr) {
362	case PH_DATA | REQUEST:
363		BUG_ON(bcs->b_out.tx_skb);
364		bcs->b_out.tx_skb = skb;
365		break;
366	case PH_ACTIVATE | REQUEST:
367		mode = (long) arg;
368		DBG(4, "B%d,PH_ACTIVATE_REQUEST %ld", bcs->channel + 1, mode);
369		st5481B_mode(bcs, mode);
370		B_L1L2(bcs, PH_ACTIVATE | INDICATION, NULL);
371		break;
372	case PH_DEACTIVATE | REQUEST:
373		DBG(4, "B%d,PH_DEACTIVATE_REQUEST", bcs->channel + 1);
374		st5481B_mode(bcs, L1_MODE_NULL);
375		B_L1L2(bcs, PH_DEACTIVATE | INDICATION, NULL);
376		break;
377	default:
378		WARNING("pr %#x\n", pr);
379	}
380}
381