?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 5.1.15
[linux/fpc-iii.git] / drivers / isdn / hisax / hfc_usb.c
blob1d4cd01d46851027776fac05f92c88f91dbb883d
1 /*
2 * hfc_usb.c
3 *
4 * $Id: hfc_usb.c,v 2.3.2.24 2007/10/14 08:40:29 mbachem Exp $
5 *
6 * modular HiSax ISDN driver for Colognechip HFC-S USB chip
7 *
8 * Authors : Peter Sprenger (sprenger@moving-bytes.de)
9 * Martin Bachem (m.bachem@gmx.de, info@colognechip.com)
10 *
11 * based on the first hfc_usb driver of
12 * Werner Cornelius (werner@isdn-development.de)
13 *
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2, or (at your option)
17 * any later version.
18 *
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, write to the Free Software
26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 *
28 * See Version Histroy at the bottom of this file
29 *
30 */
31
32 #include <linux/types.h>
33 #include <linux/stddef.h>
34 #include <linux/timer.h>
35 #include <linux/init.h>
36 #include <linux/module.h>
37 #include <linux/kernel_stat.h>
38 #include <linux/usb.h>
39 #include <linux/kernel.h>
40 #include <linux/sched.h>
41 #include <linux/moduleparam.h>
42 #include <linux/slab.h>
43 #include "hisax.h"
44 #include "hisax_if.h"
45 #include "hfc_usb.h"
46
47 static const char *hfcusb_revision =
48 "$Revision: 2.3.2.24 $ $Date: 2007/10/14 08:40:29 $ ";
49
50 /* Hisax debug support
51 * debug flags defined in hfc_usb.h as HFCUSB_DBG_[*]
52 */
53 #define __debug_variable hfc_debug
54 #include "hisax_debug.h"
55 static u_int debug;
56 module_param(debug, uint, 0);
57 static int hfc_debug;
58
59
60 /* private vendor specific data */
61 typedef struct {
62 __u8 led_scheme; // led display scheme
63 signed short led_bits[8]; // array of 8 possible LED bitmask settings
64 char *vend_name; // device name
65 } hfcsusb_vdata;
66
67 /* VID/PID device list */
68 static const struct usb_device_id hfcusb_idtab[] = {
69 {
70 USB_DEVICE(0x0959, 0x2bd0),
71 .driver_info = (unsigned long) &((hfcsusb_vdata)
72 {LED_OFF, {4, 0, 2, 1},
73 "ISDN USB TA (Cologne Chip HFC-S USB based)"}),
74 },
75 {
76 USB_DEVICE(0x0675, 0x1688),
77 .driver_info = (unsigned long) &((hfcsusb_vdata)
78 {LED_SCHEME1, {1, 2, 0, 0},
79 "DrayTek miniVigor 128 USB ISDN TA"}),
80 },
81 {
82 USB_DEVICE(0x07b0, 0x0007),
83 .driver_info = (unsigned long) &((hfcsusb_vdata)
84 {LED_SCHEME1, {0x80, -64, -32, -16},
85 "Billion tiny USB ISDN TA 128"}),
86 },
87 {
88 USB_DEVICE(0x0742, 0x2008),
89 .driver_info = (unsigned long) &((hfcsusb_vdata)
90 {LED_SCHEME1, {4, 0, 2, 1},
91 "Stollmann USB TA"}),
92 },
93 {
94 USB_DEVICE(0x0742, 0x2009),
95 .driver_info = (unsigned long) &((hfcsusb_vdata)
96 {LED_SCHEME1, {4, 0, 2, 1},
97 "Aceex USB ISDN TA"}),
98 },
99 {
100 USB_DEVICE(0x0742, 0x200A),
101 .driver_info = (unsigned long) &((hfcsusb_vdata)
102 {LED_SCHEME1, {4, 0, 2, 1},
103 "OEM USB ISDN TA"}),
104 },
105 {
106 USB_DEVICE(0x08e3, 0x0301),
107 .driver_info = (unsigned long) &((hfcsusb_vdata)
108 {LED_SCHEME1, {2, 0, 1, 4},
109 "Olitec USB RNIS"}),
110 },
111 {
112 USB_DEVICE(0x07fa, 0x0846),
113 .driver_info = (unsigned long) &((hfcsusb_vdata)
114 {LED_SCHEME1, {0x80, -64, -32, -16},
115 "Bewan Modem RNIS USB"}),
116 },
117 {
118 USB_DEVICE(0x07fa, 0x0847),
119 .driver_info = (unsigned long) &((hfcsusb_vdata)
120 {LED_SCHEME1, {0x80, -64, -32, -16},
121 "Djinn Numeris USB"}),
122 },
123 {
124 USB_DEVICE(0x07b0, 0x0006),
125 .driver_info = (unsigned long) &((hfcsusb_vdata)
126 {LED_SCHEME1, {0x80, -64, -32, -16},
127 "Twister ISDN TA"}),
128 },
129 {
130 USB_DEVICE(0x071d, 0x1005),
131 .driver_info = (unsigned long) &((hfcsusb_vdata)
132 {LED_SCHEME1, {0x02, 0, 0x01, 0x04},
133 "Eicon DIVA USB 4.0"}),
134 },
135 { }
136 };
137
138 /* structure defining input+output fifos (interrupt/bulk mode) */
139 struct usb_fifo; /* forward definition */
140 typedef struct iso_urb_struct {
141 struct urb *purb;
142 __u8 buffer[ISO_BUFFER_SIZE]; /* buffer incoming/outgoing data */
143 struct usb_fifo *owner_fifo; /* pointer to owner fifo */
144 } iso_urb_struct;
145
146 struct hfcusb_data; /* forward definition */
147
148 typedef struct usb_fifo {
149 int fifonum; /* fifo index attached to this structure */
150 int active; /* fifo is currently active */
151 struct hfcusb_data *hfc; /* pointer to main structure */
152 int pipe; /* address of endpoint */
153 __u8 usb_packet_maxlen; /* maximum length for usb transfer */
154 unsigned int max_size; /* maximum size of receive/send packet */
155 __u8 intervall; /* interrupt interval */
156 struct sk_buff *skbuff; /* actual used buffer */
157 struct urb *urb; /* transfer structure for usb routines */
158 __u8 buffer[128]; /* buffer incoming/outgoing data */
159 int bit_line; /* how much bits are in the fifo? */
160
161 volatile __u8 usb_transfer_mode; /* switched between ISO and INT */
162 iso_urb_struct iso[2]; /* need two urbs to have one always for pending */
163 struct hisax_if *hif; /* hisax interface */
164 int delete_flg; /* only delete skbuff once */
165 int last_urblen; /* remember length of last packet */
166 } usb_fifo;
167
168 /* structure holding all data for one device */
169 typedef struct hfcusb_data {
170 /* HiSax Interface for loadable Layer1 drivers */
171 struct hisax_d_if d_if; /* see hisax_if.h */
172 struct hisax_b_if b_if[2]; /* see hisax_if.h */
173 int protocol;
174
175 struct usb_device *dev; /* our device */
176 int if_used; /* used interface number */
177 int alt_used; /* used alternate config */
178 int ctrl_paksize; /* control pipe packet size */
179 int ctrl_in_pipe, /* handles for control pipe */
180 ctrl_out_pipe;
181 int cfg_used; /* configuration index used */
182 int vend_idx; /* vendor found */
183 int b_mode[2]; /* B-channel mode */
184 int l1_activated; /* layer 1 activated */
185 int disc_flag; /* TRUE if device was disonnected to avoid some USB actions */
186 int packet_size, iso_packet_size;
187
188 /* control pipe background handling */
189 ctrl_buft ctrl_buff[HFC_CTRL_BUFSIZE]; /* buffer holding queued data */
190 volatile int ctrl_in_idx, ctrl_out_idx, ctrl_cnt; /* input/output pointer + count */
191 struct urb *ctrl_urb; /* transfer structure for control channel */
192
193 struct usb_ctrlrequest ctrl_write; /* buffer for control write request */
194 struct usb_ctrlrequest ctrl_read; /* same for read request */
195
196 __u8 old_led_state, led_state;
197
198 volatile __u8 threshold_mask; /* threshold actually reported */
199 volatile __u8 bch_enables; /* or mask for sctrl_r and sctrl register values */
200
201 usb_fifo fifos[HFCUSB_NUM_FIFOS]; /* structure holding all fifo data */
202
203 volatile __u8 l1_state; /* actual l1 state */
204 struct timer_list t3_timer; /* timer 3 for activation/deactivation */
205 struct timer_list t4_timer; /* timer 4 for activation/deactivation */
206 } hfcusb_data;
207
208
209 static void collect_rx_frame(usb_fifo *fifo, __u8 *data, int len,
210 int finish);
211
212 static inline const char *
213 symbolic(struct hfcusb_symbolic_list list[], const int num)
214 {
215 int i;
216 for (i = 0; list[i].name != NULL; i++)
217 if (list[i].num == num)
218 return (list[i].name);
219 return "<unknown ERROR>";
220 }
221
222 static void
223 ctrl_start_transfer(hfcusb_data *hfc)
224 {
225 if (hfc->ctrl_cnt) {
226 hfc->ctrl_urb->pipe = hfc->ctrl_out_pipe;
227 hfc->ctrl_urb->setup_packet = (u_char *)&hfc->ctrl_write;
228 hfc->ctrl_urb->transfer_buffer = NULL;
229 hfc->ctrl_urb->transfer_buffer_length = 0;
230 hfc->ctrl_write.wIndex =
231 cpu_to_le16(hfc->ctrl_buff[hfc->ctrl_out_idx].hfc_reg);
232 hfc->ctrl_write.wValue =
233 cpu_to_le16(hfc->ctrl_buff[hfc->ctrl_out_idx].reg_val);
234
235 usb_submit_urb(hfc->ctrl_urb, GFP_ATOMIC); /* start transfer */
236 }
237 } /* ctrl_start_transfer */
238
239 static int
240 queue_control_request(hfcusb_data *hfc, __u8 reg, __u8 val, int action)
241 {
242 ctrl_buft *buf;
243
244 if (hfc->ctrl_cnt >= HFC_CTRL_BUFSIZE)
245 return (1); /* no space left */
246 buf = &hfc->ctrl_buff[hfc->ctrl_in_idx]; /* pointer to new index */
247 buf->hfc_reg = reg;
248 buf->reg_val = val;
249 buf->action = action;
250 if (++hfc->ctrl_in_idx >= HFC_CTRL_BUFSIZE)
251 hfc->ctrl_in_idx = 0; /* pointer wrap */
252 if (++hfc->ctrl_cnt == 1)
253 ctrl_start_transfer(hfc);
254 return (0);
255 }
256
257 static void
258 ctrl_complete(struct urb *urb)
259 {
260 hfcusb_data *hfc = (hfcusb_data *) urb->context;
261
262 urb->dev = hfc->dev;
263 if (hfc->ctrl_cnt) {
264 hfc->ctrl_cnt--; /* decrement actual count */
265 if (++hfc->ctrl_out_idx >= HFC_CTRL_BUFSIZE)
266 hfc->ctrl_out_idx = 0; /* pointer wrap */
267
268 ctrl_start_transfer(hfc); /* start next transfer */
269 }
270 }
271
272 /* write led data to auxport & invert if necessary */
273 static void
274 write_led(hfcusb_data *hfc, __u8 led_state)
275 {
276 if (led_state != hfc->old_led_state) {
277 hfc->old_led_state = led_state;
278 queue_control_request(hfc, HFCUSB_P_DATA, led_state, 1);
279 }
280 }
281
282 static void
283 set_led_bit(hfcusb_data *hfc, signed short led_bits, int on)
284 {
285 if (on) {
286 if (led_bits < 0)
287 hfc->led_state &= ~abs(led_bits);
288 else
289 hfc->led_state |= led_bits;
290 } else {
291 if (led_bits < 0)
292 hfc->led_state |= abs(led_bits);
293 else
294 hfc->led_state &= ~led_bits;
295 }
296 }
297
298 /* handle LED requests */
299 static void
300 handle_led(hfcusb_data *hfc, int event)
301 {
302 hfcsusb_vdata *driver_info =
303 (hfcsusb_vdata *) hfcusb_idtab[hfc->vend_idx].driver_info;
304
305 /* if no scheme -> no LED action */
306 if (driver_info->led_scheme == LED_OFF)
307 return;
308
309 switch (event) {
310 case LED_POWER_ON:
311 set_led_bit(hfc, driver_info->led_bits[0], 1);
312 set_led_bit(hfc, driver_info->led_bits[1], 0);
313 set_led_bit(hfc, driver_info->led_bits[2], 0);
314 set_led_bit(hfc, driver_info->led_bits[3], 0);
315 break;
316 case LED_POWER_OFF:
317 set_led_bit(hfc, driver_info->led_bits[0], 0);
318 set_led_bit(hfc, driver_info->led_bits[1], 0);
319 set_led_bit(hfc, driver_info->led_bits[2], 0);
320 set_led_bit(hfc, driver_info->led_bits[3], 0);
321 break;
322 case LED_S0_ON:
323 set_led_bit(hfc, driver_info->led_bits[1], 1);
324 break;
325 case LED_S0_OFF:
326 set_led_bit(hfc, driver_info->led_bits[1], 0);
327 break;
328 case LED_B1_ON:
329 set_led_bit(hfc, driver_info->led_bits[2], 1);
330 break;
331 case LED_B1_OFF:
332 set_led_bit(hfc, driver_info->led_bits[2], 0);
333 break;
334 case LED_B2_ON:
335 set_led_bit(hfc, driver_info->led_bits[3], 1);
336 break;
337 case LED_B2_OFF:
338 set_led_bit(hfc, driver_info->led_bits[3], 0);
339 break;
340 }
341 write_led(hfc, hfc->led_state);
342 }
343
344 /* ISDN l1 timer T3 expires */
345 static void
346 l1_timer_expire_t3(struct timer_list *t)
347 {
348 hfcusb_data *hfc = from_timer(hfc, t, t3_timer);
349 hfc->d_if.ifc.l1l2(&hfc->d_if.ifc, PH_DEACTIVATE | INDICATION,
350 NULL);
351
352 DBG(HFCUSB_DBG_STATES,
353 "HFC-S USB: PH_DEACTIVATE | INDICATION sent (T3 expire)");
354
355 hfc->l1_activated = 0;
356 handle_led(hfc, LED_S0_OFF);
357 /* deactivate : */
358 queue_control_request(hfc, HFCUSB_STATES, 0x10, 1);
359 queue_control_request(hfc, HFCUSB_STATES, 3, 1);
360 }
361
362 /* ISDN l1 timer T4 expires */
363 static void
364 l1_timer_expire_t4(struct timer_list *t)
365 {
366 hfcusb_data *hfc = from_timer(hfc, t, t4_timer);
367 hfc->d_if.ifc.l1l2(&hfc->d_if.ifc, PH_DEACTIVATE | INDICATION,
368 NULL);
369
370 DBG(HFCUSB_DBG_STATES,
371 "HFC-S USB: PH_DEACTIVATE | INDICATION sent (T4 expire)");
372
373 hfc->l1_activated = 0;
374 handle_led(hfc, LED_S0_OFF);
375 }
376
377 /* S0 state changed */
378 static void
379 s0_state_handler(hfcusb_data *hfc, __u8 state)
380 {
381 __u8 old_state;
382
383 old_state = hfc->l1_state;
384 if (state == old_state || state < 1 || state > 8)
385 return;
386
387 DBG(HFCUSB_DBG_STATES, "HFC-S USB: S0 statechange(%d -> %d)",
388 old_state, state);
389
390 if (state < 4 || state == 7 || state == 8) {
391 if (timer_pending(&hfc->t3_timer))
392 del_timer(&hfc->t3_timer);
393 DBG(HFCUSB_DBG_STATES, "HFC-S USB: T3 deactivated");
394 }
395 if (state >= 7) {
396 if (timer_pending(&hfc->t4_timer))
397 del_timer(&hfc->t4_timer);
398 DBG(HFCUSB_DBG_STATES, "HFC-S USB: T4 deactivated");
399 }
400
401 if (state == 7 && !hfc->l1_activated) {
402 hfc->d_if.ifc.l1l2(&hfc->d_if.ifc,
403 PH_ACTIVATE | INDICATION, NULL);
404 DBG(HFCUSB_DBG_STATES, "HFC-S USB: PH_ACTIVATE | INDICATION sent");
405 hfc->l1_activated = 1;
406 handle_led(hfc, LED_S0_ON);
407 } else if (state <= 3 /* && activated */) {
408 if (old_state == 7 || old_state == 8) {
409 DBG(HFCUSB_DBG_STATES, "HFC-S USB: T4 activated");
410 if (!timer_pending(&hfc->t4_timer)) {
411 hfc->t4_timer.expires =
412 jiffies + (HFC_TIMER_T4 * HZ) / 1000;
413 add_timer(&hfc->t4_timer);
414 }
415 } else {
416 hfc->d_if.ifc.l1l2(&hfc->d_if.ifc,
417 PH_DEACTIVATE | INDICATION,
418 NULL);
419 DBG(HFCUSB_DBG_STATES,
420 "HFC-S USB: PH_DEACTIVATE | INDICATION sent");
421 hfc->l1_activated = 0;
422 handle_led(hfc, LED_S0_OFF);
423 }
424 }
425 hfc->l1_state = state;
426 }
427
428 static void
429 fill_isoc_urb(struct urb *urb, struct usb_device *dev, unsigned int pipe,
430 void *buf, int num_packets, int packet_size, int interval,
431 usb_complete_t complete, void *context)
432 {
433 int k;
434
435 usb_fill_int_urb(urb, dev, pipe, buf, packet_size * num_packets,
436 complete, context, interval);
437
438 urb->number_of_packets = num_packets;
439 urb->transfer_flags = URB_ISO_ASAP;
440 urb->actual_length = 0;
441 for (k = 0; k < num_packets; k++) {
442 urb->iso_frame_desc[k].offset = packet_size * k;
443 urb->iso_frame_desc[k].length = packet_size;
444 urb->iso_frame_desc[k].actual_length = 0;
445 }
446 }
447
448 /* allocs urbs and start isoc transfer with two pending urbs to avoid
449 * gaps in the transfer chain
450 */
451 static int
452 start_isoc_chain(usb_fifo *fifo, int num_packets_per_urb,
453 usb_complete_t complete, int packet_size)
454 {
455 int i, k, errcode;
456
457 DBG(HFCUSB_DBG_INIT, "HFC-S USB: starting ISO-URBs for fifo:%d\n",
458 fifo->fifonum);
459
460 /* allocate Memory for Iso out Urbs */
461 for (i = 0; i < 2; i++) {
462 if (!(fifo->iso[i].purb)) {
463 fifo->iso[i].purb =
464 usb_alloc_urb(num_packets_per_urb, GFP_KERNEL);
465 if (!(fifo->iso[i].purb)) {
466 printk(KERN_INFO
467 "alloc urb for fifo %i failed!!!",
468 fifo->fifonum);
469 }
470 fifo->iso[i].owner_fifo = (struct usb_fifo *) fifo;
471
472 /* Init the first iso */
473 if (ISO_BUFFER_SIZE >=
474 (fifo->usb_packet_maxlen *
475 num_packets_per_urb)) {
476 fill_isoc_urb(fifo->iso[i].purb,
477 fifo->hfc->dev, fifo->pipe,
478 fifo->iso[i].buffer,
479 num_packets_per_urb,
480 fifo->usb_packet_maxlen,
481 fifo->intervall, complete,
482 &fifo->iso[i]);
483 memset(fifo->iso[i].buffer, 0,
484 sizeof(fifo->iso[i].buffer));
485 /* defining packet delimeters in fifo->buffer */
486 for (k = 0; k < num_packets_per_urb; k++) {
487 fifo->iso[i].purb->
488 iso_frame_desc[k].offset =
489 k * packet_size;
490 fifo->iso[i].purb->
491 iso_frame_desc[k].length =
492 packet_size;
493 }
494 } else {
495 printk(KERN_INFO
496 "HFC-S USB: ISO Buffer size to small!\n");
497 }
498 }
499 fifo->bit_line = BITLINE_INF;
500
501 errcode = usb_submit_urb(fifo->iso[i].purb, GFP_KERNEL);
502 fifo->active = (errcode >= 0) ? 1 : 0;
503 if (errcode < 0)
504 printk(KERN_INFO "HFC-S USB: usb_submit_urb URB nr:%d, error(%i): '%s'\n",
505 i, errcode, symbolic(urb_errlist, errcode));
506 }
507 return (fifo->active);
508 }
509
510 /* stops running iso chain and frees their pending urbs */
511 static void
512 stop_isoc_chain(usb_fifo *fifo)
513 {
514 int i;
515
516 for (i = 0; i < 2; i++) {
517 if (fifo->iso[i].purb) {
518 DBG(HFCUSB_DBG_INIT,
519 "HFC-S USB: Stopping iso chain for fifo %i.%i",
520 fifo->fifonum, i);
521 usb_kill_urb(fifo->iso[i].purb);
522 usb_free_urb(fifo->iso[i].purb);
523 fifo->iso[i].purb = NULL;
524 }
525 }
526
527 usb_kill_urb(fifo->urb);
528 usb_free_urb(fifo->urb);
529 fifo->urb = NULL;
530 fifo->active = 0;
531 }
532
533 /* defines how much ISO packets are handled in one URB */
534 static int iso_packets[8] =
535 { ISOC_PACKETS_B, ISOC_PACKETS_B, ISOC_PACKETS_B, ISOC_PACKETS_B,
536 ISOC_PACKETS_D, ISOC_PACKETS_D, ISOC_PACKETS_D, ISOC_PACKETS_D
537 };
538
539 static void
540 tx_iso_complete(struct urb *urb)
541 {
542 iso_urb_struct *context_iso_urb = (iso_urb_struct *) urb->context;
543 usb_fifo *fifo = context_iso_urb->owner_fifo;
544 hfcusb_data *hfc = fifo->hfc;
545 int k, tx_offset, num_isoc_packets, sink, len, current_len,
546 errcode;
547 int frame_complete, transp_mode, fifon, status;
548 __u8 threshbit;
549
550 fifon = fifo->fifonum;
551 status = urb->status;
552
553 tx_offset = 0;
554
555 /* ISO transfer only partially completed,
556 look at individual frame status for details */
557 if (status == -EXDEV) {
558 DBG(HFCUSB_DBG_VERBOSE_USB, "HFC-S USB: tx_iso_complete with -EXDEV"
559 ", urb->status %d, fifonum %d\n",
560 status, fifon);
561
562 for (k = 0; k < iso_packets[fifon]; ++k) {
563 errcode = urb->iso_frame_desc[k].status;
564 if (errcode)
565 DBG(HFCUSB_DBG_VERBOSE_USB, "HFC-S USB: tx_iso_complete "
566 "packet %i, status: %i\n",
567 k, errcode);
568 }
569
570 // clear status, so go on with ISO transfers
571 status = 0;
572 }
573
574 if (fifo->active && !status) {
575 transp_mode = 0;
576 if (fifon < 4 && hfc->b_mode[fifon / 2] == L1_MODE_TRANS)
577 transp_mode = 1;
578
579 /* is FifoFull-threshold set for our channel? */
580 threshbit = (hfc->threshold_mask & (1 << fifon));
581 num_isoc_packets = iso_packets[fifon];
582
583 /* predict dataflow to avoid fifo overflow */
584 if (fifon >= HFCUSB_D_TX) {
585 sink = (threshbit) ? SINK_DMIN : SINK_DMAX;
586 } else {
587 sink = (threshbit) ? SINK_MIN : SINK_MAX;
588 }
589 fill_isoc_urb(urb, fifo->hfc->dev, fifo->pipe,
590 context_iso_urb->buffer, num_isoc_packets,
591 fifo->usb_packet_maxlen, fifo->intervall,
592 tx_iso_complete, urb->context);
593 memset(context_iso_urb->buffer, 0,
594 sizeof(context_iso_urb->buffer));
595 frame_complete = 0;
596
597 /* Generate next ISO Packets */
598 for (k = 0; k < num_isoc_packets; ++k) {
599 if (fifo->skbuff) {
600 len = fifo->skbuff->len;
601 /* we lower data margin every msec */
602 fifo->bit_line -= sink;
603 current_len = (0 - fifo->bit_line) / 8;
604 /* maximum 15 byte for every ISO packet makes our life easier */
605 if (current_len > 14)
606 current_len = 14;
607 current_len =
608 (len <=
609 current_len) ? len : current_len;
610 /* how much bit do we put on the line? */
611 fifo->bit_line += current_len * 8;
612
613 context_iso_urb->buffer[tx_offset] = 0;
614 if (current_len == len) {
615 if (!transp_mode) {
616 /* here frame completion */
617 context_iso_urb->
618 buffer[tx_offset] = 1;
619 /* add 2 byte flags and 16bit CRC at end of ISDN frame */
620 fifo->bit_line += 32;
621 }
622 frame_complete = 1;
623 }
624
625 memcpy(context_iso_urb->buffer +
626 tx_offset + 1, fifo->skbuff->data,
627 current_len);
628 skb_pull(fifo->skbuff, current_len);
629
630 /* define packet delimeters within the URB buffer */
631 urb->iso_frame_desc[k].offset = tx_offset;
632 urb->iso_frame_desc[k].length =
633 current_len + 1;
634
635 tx_offset += (current_len + 1);
636 } else {
637 urb->iso_frame_desc[k].offset =
638 tx_offset++;
639
640 urb->iso_frame_desc[k].length = 1;
641 fifo->bit_line -= sink; /* we lower data margin every msec */
642
643 if (fifo->bit_line < BITLINE_INF) {
644 fifo->bit_line = BITLINE_INF;
645 }
646 }
647
648 if (frame_complete) {
649 fifo->delete_flg = 1;
650 fifo->hif->l1l2(fifo->hif,
651 PH_DATA | CONFIRM,
652 (void *) (unsigned long) fifo->skbuff->
653 truesize);
654 if (fifo->skbuff && fifo->delete_flg) {
655 dev_kfree_skb_any(fifo->skbuff);
656 fifo->skbuff = NULL;
657 fifo->delete_flg = 0;
658 }
659 frame_complete = 0;
660 }
661 }
662 errcode = usb_submit_urb(urb, GFP_ATOMIC);
663 if (errcode < 0) {
664 printk(KERN_INFO
665 "HFC-S USB: error submitting ISO URB: %d\n",
666 errcode);
667 }
668 } else {
669 if (status && !hfc->disc_flag) {
670 printk(KERN_INFO
671 "HFC-S USB: tx_iso_complete: error(%i): '%s', fifonum=%d\n",
672 status, symbolic(urb_errlist, status), fifon);
673 }
674 }
675 }
676
677 static void
678 rx_iso_complete(struct urb *urb)
679 {
680 iso_urb_struct *context_iso_urb = (iso_urb_struct *) urb->context;
681 usb_fifo *fifo = context_iso_urb->owner_fifo;
682 hfcusb_data *hfc = fifo->hfc;
683 int k, len, errcode, offset, num_isoc_packets, fifon, maxlen,
684 status;
685 unsigned int iso_status;
686 __u8 *buf;
687 static __u8 eof[8];
688
689 fifon = fifo->fifonum;
690 status = urb->status;
691
692 if (urb->status == -EOVERFLOW) {
693 DBG(HFCUSB_DBG_VERBOSE_USB,
694 "HFC-USB: ignoring USB DATAOVERRUN fifo(%i)", fifon);
695 status = 0;
696 }
697
698 /* ISO transfer only partially completed,
699 look at individual frame status for details */
700 if (status == -EXDEV) {
701 DBG(HFCUSB_DBG_VERBOSE_USB, "HFC-S USB: rx_iso_complete with -EXDEV "
702 "urb->status %d, fifonum %d\n",
703 status, fifon);
704 status = 0;
705 }
706
707 if (fifo->active && !status) {
708 num_isoc_packets = iso_packets[fifon];
709 maxlen = fifo->usb_packet_maxlen;
710 for (k = 0; k < num_isoc_packets; ++k) {
711 len = urb->iso_frame_desc[k].actual_length;
712 offset = urb->iso_frame_desc[k].offset;
713 buf = context_iso_urb->buffer + offset;
714 iso_status = urb->iso_frame_desc[k].status;
715
716 if (iso_status && !hfc->disc_flag)
717 DBG(HFCUSB_DBG_VERBOSE_USB,
718 "HFC-S USB: rx_iso_complete "
719 "ISO packet %i, status: %i\n",
720 k, iso_status);
721
722 if (fifon == HFCUSB_D_RX) {
723 DBG(HFCUSB_DBG_VERBOSE_USB,
724 "HFC-S USB: ISO-D-RX lst_urblen:%2d "
725 "act_urblen:%2d max-urblen:%2d EOF:0x%0x",
726 fifo->last_urblen, len, maxlen,
727 eof[5]);
728
729 DBG_PACKET(HFCUSB_DBG_VERBOSE_USB, buf, len);
730 }
731
732 if (fifo->last_urblen != maxlen) {
733 /* the threshold mask is in the 2nd status byte */
734 hfc->threshold_mask = buf[1];
735 /* care for L1 state only for D-Channel
736 to avoid overlapped iso completions */
737 if (fifon == HFCUSB_D_RX) {
738 /* the S0 state is in the upper half
739 of the 1st status byte */
740 s0_state_handler(hfc, buf[0] >> 4);
741 }
742 eof[fifon] = buf[0] & 1;
743 if (len > 2)
744 collect_rx_frame(fifo, buf + 2,
745 len - 2,
746 (len < maxlen) ?
747 eof[fifon] : 0);
748 } else {
749 collect_rx_frame(fifo, buf, len,
750 (len <
751 maxlen) ? eof[fifon] :
752 0);
753 }
754 fifo->last_urblen = len;
755 }
756
757 fill_isoc_urb(urb, fifo->hfc->dev, fifo->pipe,
758 context_iso_urb->buffer, num_isoc_packets,
759 fifo->usb_packet_maxlen, fifo->intervall,
760 rx_iso_complete, urb->context);
761 errcode = usb_submit_urb(urb, GFP_ATOMIC);
762 if (errcode < 0) {
763 printk(KERN_ERR
764 "HFC-S USB: error submitting ISO URB: %d\n",
765 errcode);
766 }
767 } else {
768 if (status && !hfc->disc_flag) {
769 printk(KERN_ERR
770 "HFC-S USB: rx_iso_complete : "
771 "urb->status %d, fifonum %d\n",
772 status, fifon);
773 }
774 }
775 }
776
777 /* collect rx data from INT- and ISO-URBs */
778 static void
779 collect_rx_frame(usb_fifo *fifo, __u8 *data, int len, int finish)
780 {
781 hfcusb_data *hfc = fifo->hfc;
782 int transp_mode, fifon;
783
784 fifon = fifo->fifonum;
785 transp_mode = 0;
786 if (fifon < 4 && hfc->b_mode[fifon / 2] == L1_MODE_TRANS)
787 transp_mode = 1;
788
789 if (!fifo->skbuff) {
790 fifo->skbuff = dev_alloc_skb(fifo->max_size + 3);
791 if (!fifo->skbuff) {
792 printk(KERN_ERR
793 "HFC-S USB: cannot allocate buffer for fifo(%d)\n",
794 fifon);
795 return;
796 }
797 }
798 if (len) {
799 if (fifo->skbuff->len + len < fifo->max_size) {
800 skb_put_data(fifo->skbuff, data, len);
801 } else {
802 DBG(HFCUSB_DBG_FIFO_ERR,
803 "HCF-USB: got frame exceeded fifo->max_size(%d) fifo(%d)",
804 fifo->max_size, fifon);
805 DBG_SKB(HFCUSB_DBG_VERBOSE_USB, fifo->skbuff);
806 skb_trim(fifo->skbuff, 0);
807 }
808 }
809 if (transp_mode && fifo->skbuff->len >= 128) {
810 fifo->hif->l1l2(fifo->hif, PH_DATA | INDICATION,
811 fifo->skbuff);
812 fifo->skbuff = NULL;
813 return;
814 }
815 /* we have a complete hdlc packet */
816 if (finish) {
817 if (fifo->skbuff->len > 3 &&
818 !fifo->skbuff->data[fifo->skbuff->len - 1]) {
819
820 if (fifon == HFCUSB_D_RX) {
821 DBG(HFCUSB_DBG_DCHANNEL,
822 "HFC-S USB: D-RX len(%d)", fifo->skbuff->len);
823 DBG_SKB(HFCUSB_DBG_DCHANNEL, fifo->skbuff);
824 }
825
826 /* remove CRC & status */
827 skb_trim(fifo->skbuff, fifo->skbuff->len - 3);
828 if (fifon == HFCUSB_PCM_RX) {
829 fifo->hif->l1l2(fifo->hif,
830 PH_DATA_E | INDICATION,
831 fifo->skbuff);
832 } else
833 fifo->hif->l1l2(fifo->hif,
834 PH_DATA | INDICATION,
835 fifo->skbuff);
836 fifo->skbuff = NULL; /* buffer was freed from upper layer */
837 } else {
838 DBG(HFCUSB_DBG_FIFO_ERR,
839 "HFC-S USB: ERROR frame len(%d) fifo(%d)",
840 fifo->skbuff->len, fifon);
841 DBG_SKB(HFCUSB_DBG_VERBOSE_USB, fifo->skbuff);
842 skb_trim(fifo->skbuff, 0);
843 }
844 }
845 }
846
847 static void
848 rx_int_complete(struct urb *urb)
849 {
850 int len;
851 int status;
852 __u8 *buf, maxlen, fifon;
853 usb_fifo *fifo = (usb_fifo *) urb->context;
854 hfcusb_data *hfc = fifo->hfc;
855 static __u8 eof[8];
856
857 urb->dev = hfc->dev; /* security init */
858
859 fifon = fifo->fifonum;
860 if ((!fifo->active) || (urb->status)) {
861 DBG(HFCUSB_DBG_INIT, "HFC-S USB: RX-Fifo %i is going down (%i)",
862 fifon, urb->status);
863
864 fifo->urb->interval = 0; /* cancel automatic rescheduling */
865 if (fifo->skbuff) {
866 dev_kfree_skb_any(fifo->skbuff);
867 fifo->skbuff = NULL;
868 }
869 return;
870 }
871 len = urb->actual_length;
872 buf = fifo->buffer;
873 maxlen = fifo->usb_packet_maxlen;
874
875 if (fifon == HFCUSB_D_RX) {
876 DBG(HFCUSB_DBG_VERBOSE_USB,
877 "HFC-S USB: INT-D-RX lst_urblen:%2d "
878 "act_urblen:%2d max-urblen:%2d EOF:0x%0x",
879 fifo->last_urblen, len, maxlen,
880 eof[5]);
881 DBG_PACKET(HFCUSB_DBG_VERBOSE_USB, buf, len);
882 }
883
884 if (fifo->last_urblen != fifo->usb_packet_maxlen) {
885 /* the threshold mask is in the 2nd status byte */
886 hfc->threshold_mask = buf[1];
887 /* the S0 state is in the upper half of the 1st status byte */
888 s0_state_handler(hfc, buf[0] >> 4);
889 eof[fifon] = buf[0] & 1;
890 /* if we have more than the 2 status bytes -> collect data */
891 if (len > 2)
892 collect_rx_frame(fifo, buf + 2,
893 urb->actual_length - 2,
894 (len < maxlen) ? eof[fifon] : 0);
895 } else {
896 collect_rx_frame(fifo, buf, urb->actual_length,
897 (len < maxlen) ? eof[fifon] : 0);
898 }
899 fifo->last_urblen = urb->actual_length;
900 status = usb_submit_urb(urb, GFP_ATOMIC);
901 if (status) {
902 printk(KERN_INFO
903 "HFC-S USB: %s error resubmitting URB fifo(%d)\n",
904 __func__, fifon);
905 }
906 }
907
908 /* start initial INT-URB for certain fifo */
909 static void
910 start_int_fifo(usb_fifo *fifo)
911 {
912 int errcode;
913
914 DBG(HFCUSB_DBG_INIT, "HFC-S USB: starting RX INT-URB for fifo:%d\n",
915 fifo->fifonum);
916
917 if (!fifo->urb) {
918 fifo->urb = usb_alloc_urb(0, GFP_KERNEL);
919 if (!fifo->urb)
920 return;
921 }
922 usb_fill_int_urb(fifo->urb, fifo->hfc->dev, fifo->pipe,
923 fifo->buffer, fifo->usb_packet_maxlen,
924 rx_int_complete, fifo, fifo->intervall);
925 fifo->active = 1; /* must be marked active */
926 errcode = usb_submit_urb(fifo->urb, GFP_KERNEL);
927 if (errcode) {
928 printk(KERN_ERR "HFC-S USB: submit URB error(%s): status:%i\n",
929 __func__, errcode);
930 fifo->active = 0;
931 fifo->skbuff = NULL;
932 }
933 }
934
935 static void
936 setup_bchannel(hfcusb_data *hfc, int channel, int mode)
937 {
938 __u8 val, idx_table[2] = { 0, 2 };
939
940 if (hfc->disc_flag) {
941 return;
942 }
943 DBG(HFCUSB_DBG_STATES, "HFC-S USB: setting channel %d to mode %d",
944 channel, mode);
945 hfc->b_mode[channel] = mode;
946
947 /* setup CON_HDLC */
948 val = 0;
949 if (mode != L1_MODE_NULL)
950 val = 8; /* enable fifo? */
951 if (mode == L1_MODE_TRANS)
952 val |= 2; /* set transparent bit */
953
954 /* set FIFO to transmit register */
955 queue_control_request(hfc, HFCUSB_FIFO, idx_table[channel], 1);
956 queue_control_request(hfc, HFCUSB_CON_HDLC, val, 1);
957 /* reset fifo */
958 queue_control_request(hfc, HFCUSB_INC_RES_F, 2, 1);
959 /* set FIFO to receive register */
960 queue_control_request(hfc, HFCUSB_FIFO, idx_table[channel] + 1, 1);
961 queue_control_request(hfc, HFCUSB_CON_HDLC, val, 1);
962 /* reset fifo */
963 queue_control_request(hfc, HFCUSB_INC_RES_F, 2, 1);
964
965 val = 0x40;
966 if (hfc->b_mode[0])
967 val |= 1;
968 if (hfc->b_mode[1])
969 val |= 2;
970 queue_control_request(hfc, HFCUSB_SCTRL, val, 1);
971
972 val = 0;
973 if (hfc->b_mode[0])
974 val |= 1;
975 if (hfc->b_mode[1])
976 val |= 2;
977 queue_control_request(hfc, HFCUSB_SCTRL_R, val, 1);
978
979 if (mode == L1_MODE_NULL) {
980 if (channel)
981 handle_led(hfc, LED_B2_OFF);
982 else
983 handle_led(hfc, LED_B1_OFF);
984 } else {
985 if (channel)
986 handle_led(hfc, LED_B2_ON);
987 else
988 handle_led(hfc, LED_B1_ON);
989 }
990 }
991
992 static void
993 hfc_usb_l2l1(struct hisax_if *my_hisax_if, int pr, void *arg)
994 {
995 usb_fifo *fifo = my_hisax_if->priv;
996 hfcusb_data *hfc = fifo->hfc;
997
998 switch (pr) {
999 case PH_ACTIVATE | REQUEST:
1000 if (fifo->fifonum == HFCUSB_D_TX) {
1001 DBG(HFCUSB_DBG_STATES,
1002 "HFC_USB: hfc_usb_d_l2l1 D-chan: PH_ACTIVATE | REQUEST");
1003
1004 if (hfc->l1_state != 3
1005 && hfc->l1_state != 7) {
1006 hfc->d_if.ifc.l1l2(&hfc->d_if.ifc,
1007 PH_DEACTIVATE |
1008 INDICATION,
1009 NULL);
1010 DBG(HFCUSB_DBG_STATES,
1011 "HFC-S USB: PH_DEACTIVATE | INDICATION sent (not state 3 or 7)");
1012 } else {
1013 if (hfc->l1_state == 7) { /* l1 already active */
1014 hfc->d_if.ifc.l1l2(&hfc->
1015 d_if.
1016 ifc,
1017 PH_ACTIVATE
1018 |
1019 INDICATION,
1020 NULL);
1021 DBG(HFCUSB_DBG_STATES,
1022 "HFC-S USB: PH_ACTIVATE | INDICATION sent again ;)");
1023 } else {
1024 /* force sending sending INFO1 */
1025 queue_control_request(hfc,
1026 HFCUSB_STATES,
1027 0x14,
1028 1);
1029 mdelay(1);
1030 /* start l1 activation */
1031 queue_control_request(hfc,
1032 HFCUSB_STATES,
1033 0x04,
1034 1);
1035 if (!timer_pending
1036 (&hfc->t3_timer)) {
1037 hfc->t3_timer.
1038 expires =
1039 jiffies +
1040 (HFC_TIMER_T3 *
1041 HZ) / 1000;
1042 add_timer(&hfc->
1043 t3_timer);
1044 }
1045 }
1046 }
1047 } else {
1048 DBG(HFCUSB_DBG_STATES,
1049 "HFC_USB: hfc_usb_d_l2l1 B-chan: PH_ACTIVATE | REQUEST");
1050 setup_bchannel(hfc,
1051 (fifo->fifonum ==
1052 HFCUSB_B1_TX) ? 0 : 1,
1053 (long) arg);
1054 fifo->hif->l1l2(fifo->hif,
1055 PH_ACTIVATE | INDICATION,
1056 NULL);
1057 }
1058 break;
1059 case PH_DEACTIVATE | REQUEST:
1060 if (fifo->fifonum == HFCUSB_D_TX) {
1061 DBG(HFCUSB_DBG_STATES,
1062 "HFC_USB: hfc_usb_d_l2l1 D-chan: PH_DEACTIVATE | REQUEST");
1063 } else {
1064 DBG(HFCUSB_DBG_STATES,
1065 "HFC_USB: hfc_usb_d_l2l1 Bx-chan: PH_DEACTIVATE | REQUEST");
1066 setup_bchannel(hfc,
1067 (fifo->fifonum ==
1068 HFCUSB_B1_TX) ? 0 : 1,
1069 (int) L1_MODE_NULL);
1070 fifo->hif->l1l2(fifo->hif,
1071 PH_DEACTIVATE | INDICATION,
1072 NULL);
1073 }
1074 break;
1075 case PH_DATA | REQUEST:
1076 if (fifo->skbuff && fifo->delete_flg) {
1077 dev_kfree_skb_any(fifo->skbuff);
1078 fifo->skbuff = NULL;
1079 fifo->delete_flg = 0;
1080 }
1081 fifo->skbuff = arg; /* we have a new buffer */
1082 break;
1083 default:
1084 DBG(HFCUSB_DBG_STATES,
1085 "HFC_USB: hfc_usb_d_l2l1: unknown state : %#x", pr);
1086 break;
1087 }
1088 }
1089
1090 /* initial init HFC-S USB chip registers, HiSax interface, USB URBs */
1091 static int
1092 hfc_usb_init(hfcusb_data *hfc)
1093 {
1094 usb_fifo *fifo;
1095 int i;
1096 u_char b;
1097 struct hisax_b_if *p_b_if[2];
1098
1099 /* check the chip id */
1100 if (read_usb(hfc, HFCUSB_CHIP_ID, &b) != 1) {
1101 printk(KERN_INFO "HFC-USB: cannot read chip id\n");
1102 return (1);
1103 }
1104 if (b != HFCUSB_CHIPID) {
1105 printk(KERN_INFO "HFC-S USB: Invalid chip id 0x%02x\n", b);
1106 return (1);
1107 }
1108
1109 /* first set the needed config, interface and alternate */
1110 usb_set_interface(hfc->dev, hfc->if_used, hfc->alt_used);
1111
1112 /* do Chip reset */
1113 write_usb(hfc, HFCUSB_CIRM, 8);
1114 /* aux = output, reset off */
1115 write_usb(hfc, HFCUSB_CIRM, 0x10);
1116
1117 /* set USB_SIZE to match wMaxPacketSize for INT or BULK transfers */
1118 write_usb(hfc, HFCUSB_USB_SIZE,
1119 (hfc->packet_size / 8) | ((hfc->packet_size / 8) << 4));
1120
1121 /* set USB_SIZE_I to match wMaxPacketSize for ISO transfers */
1122 write_usb(hfc, HFCUSB_USB_SIZE_I, hfc->iso_packet_size);
1123
1124 /* enable PCM/GCI master mode */
1125 write_usb(hfc, HFCUSB_MST_MODE1, 0); /* set default values */
1126 write_usb(hfc, HFCUSB_MST_MODE0, 1); /* enable master mode */
1127
1128 /* init the fifos */
1129 write_usb(hfc, HFCUSB_F_THRES,
1130 (HFCUSB_TX_THRESHOLD /
1131 8) | ((HFCUSB_RX_THRESHOLD / 8) << 4));
1132
1133 fifo = hfc->fifos;
1134 for (i = 0; i < HFCUSB_NUM_FIFOS; i++) {
1135 write_usb(hfc, HFCUSB_FIFO, i); /* select the desired fifo */
1136 fifo[i].skbuff = NULL; /* init buffer pointer */
1137 fifo[i].max_size =
1138 (i <= HFCUSB_B2_RX) ? MAX_BCH_SIZE : MAX_DFRAME_LEN;
1139 fifo[i].last_urblen = 0;
1140 /* set 2 bit for D- & E-channel */
1141 write_usb(hfc, HFCUSB_HDLC_PAR,
1142 ((i <= HFCUSB_B2_RX) ? 0 : 2));
1143 /* rx hdlc, enable IFF for D-channel */
1144 write_usb(hfc, HFCUSB_CON_HDLC,
1145 ((i == HFCUSB_D_TX) ? 0x09 : 0x08));
1146 write_usb(hfc, HFCUSB_INC_RES_F, 2); /* reset the fifo */
1147 }
1148
1149 write_usb(hfc, HFCUSB_CLKDEL, 0x0f); /* clock delay value */
1150 write_usb(hfc, HFCUSB_STATES, 3 | 0x10); /* set deactivated mode */
1151 write_usb(hfc, HFCUSB_STATES, 3); /* enable state machine */
1152
1153 write_usb(hfc, HFCUSB_SCTRL_R, 0); /* disable both B receivers */
1154 write_usb(hfc, HFCUSB_SCTRL, 0x40); /* disable B transmitters + capacitive mode */
1155
1156 /* set both B-channel to not connected */
1157 hfc->b_mode[0] = L1_MODE_NULL;
1158 hfc->b_mode[1] = L1_MODE_NULL;
1159
1160 hfc->l1_activated = 0;
1161 hfc->disc_flag = 0;
1162 hfc->led_state = 0;
1163 hfc->old_led_state = 0;
1164
1165 /* init the t3 timer */
1166 timer_setup(&hfc->t3_timer, l1_timer_expire_t3, 0);
1167
1168 /* init the t4 timer */
1169 timer_setup(&hfc->t4_timer, l1_timer_expire_t4, 0);
1170
1171 /* init the background machinery for control requests */
1172 hfc->ctrl_read.bRequestType = 0xc0;
1173 hfc->ctrl_read.bRequest = 1;
1174 hfc->ctrl_read.wLength = cpu_to_le16(1);
1175 hfc->ctrl_write.bRequestType = 0x40;
1176 hfc->ctrl_write.bRequest = 0;
1177 hfc->ctrl_write.wLength = 0;
1178 usb_fill_control_urb(hfc->ctrl_urb,
1179 hfc->dev,
1180 hfc->ctrl_out_pipe,
1181 (u_char *)&hfc->ctrl_write,
1182 NULL, 0, ctrl_complete, hfc);
1183 /* Init All Fifos */
1184 for (i = 0; i < HFCUSB_NUM_FIFOS; i++) {
1185 hfc->fifos[i].iso[0].purb = NULL;
1186 hfc->fifos[i].iso[1].purb = NULL;
1187 hfc->fifos[i].active = 0;
1188 }
1189 /* register Modul to upper Hisax Layers */
1190 hfc->d_if.owner = THIS_MODULE;
1191 hfc->d_if.ifc.priv = &hfc->fifos[HFCUSB_D_TX];
1192 hfc->d_if.ifc.l2l1 = hfc_usb_l2l1;
1193 for (i = 0; i < 2; i++) {
1194 hfc->b_if[i].ifc.priv = &hfc->fifos[HFCUSB_B1_TX + i * 2];
1195 hfc->b_if[i].ifc.l2l1 = hfc_usb_l2l1;
1196 p_b_if[i] = &hfc->b_if[i];
1197 }
1198 /* default Prot: EURO ISDN, should be a module_param */
1199 hfc->protocol = 2;
1200 i = hisax_register(&hfc->d_if, p_b_if, "hfc_usb", hfc->protocol);
1201 if (i) {
1202 printk(KERN_INFO "HFC-S USB: hisax_register -> %d\n", i);
1203 return i;
1204 }
1205
1206 #ifdef CONFIG_HISAX_DEBUG
1207 hfc_debug = debug;
1208 #endif
1209
1210 for (i = 0; i < 4; i++)
1211 hfc->fifos[i].hif = &p_b_if[i / 2]->ifc;
1212 for (i = 4; i < 8; i++)
1213 hfc->fifos[i].hif = &hfc->d_if.ifc;
1214
1215 /* 3 (+1) INT IN + 3 ISO OUT */
1216 if (hfc->cfg_used == CNF_3INT3ISO || hfc->cfg_used == CNF_4INT3ISO) {
1217 start_int_fifo(hfc->fifos + HFCUSB_D_RX);
1218 if (hfc->fifos[HFCUSB_PCM_RX].pipe)
1219 start_int_fifo(hfc->fifos + HFCUSB_PCM_RX);
1220 start_int_fifo(hfc->fifos + HFCUSB_B1_RX);
1221 start_int_fifo(hfc->fifos + HFCUSB_B2_RX);
1222 }
1223 /* 3 (+1) ISO IN + 3 ISO OUT */
1224 if (hfc->cfg_used == CNF_3ISO3ISO || hfc->cfg_used == CNF_4ISO3ISO) {
1225 start_isoc_chain(hfc->fifos + HFCUSB_D_RX, ISOC_PACKETS_D,
1226 rx_iso_complete, 16);
1227 if (hfc->fifos[HFCUSB_PCM_RX].pipe)
1228 start_isoc_chain(hfc->fifos + HFCUSB_PCM_RX,
1229 ISOC_PACKETS_D, rx_iso_complete,
1230 16);
1231 start_isoc_chain(hfc->fifos + HFCUSB_B1_RX, ISOC_PACKETS_B,
1232 rx_iso_complete, 16);
1233 start_isoc_chain(hfc->fifos + HFCUSB_B2_RX, ISOC_PACKETS_B,
1234 rx_iso_complete, 16);
1235 }
1236
1237 start_isoc_chain(hfc->fifos + HFCUSB_D_TX, ISOC_PACKETS_D,
1238 tx_iso_complete, 1);
1239 start_isoc_chain(hfc->fifos + HFCUSB_B1_TX, ISOC_PACKETS_B,
1240 tx_iso_complete, 1);
1241 start_isoc_chain(hfc->fifos + HFCUSB_B2_TX, ISOC_PACKETS_B,
1242 tx_iso_complete, 1);
1243
1244 handle_led(hfc, LED_POWER_ON);
1245
1246 return (0);
1247 }
1248
1249 /* initial callback for each plugged USB device */
1250 static int
1251 hfc_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
1252 {
1253 struct usb_device *dev = interface_to_usbdev(intf);
1254 hfcusb_data *context;
1255 struct usb_host_interface *iface = intf->cur_altsetting;
1256 struct usb_host_interface *iface_used = NULL;
1257 struct usb_host_endpoint *ep;
1258 int ifnum = iface->desc.bInterfaceNumber;
1259 int i, idx, alt_idx, probe_alt_setting, vend_idx, cfg_used, *vcf,
1260 attr, cfg_found, cidx, ep_addr;
1261 int cmptbl[16], small_match, iso_packet_size, packet_size,
1262 alt_used = 0;
1263 hfcsusb_vdata *driver_info;
1264
1265 vend_idx = 0xffff;
1266 for (i = 0; hfcusb_idtab[i].idVendor; i++) {
1267 if ((le16_to_cpu(dev->descriptor.idVendor) == hfcusb_idtab[i].idVendor)
1268 && (le16_to_cpu(dev->descriptor.idProduct) == hfcusb_idtab[i].idProduct)) {
1269 vend_idx = i;
1270 continue;
1271 }
1272 }
1273
1274 printk(KERN_INFO
1275 "HFC-S USB: probing interface(%d) actalt(%d) minor(%d)\n",
1276 ifnum, iface->desc.bAlternateSetting, intf->minor);
1277
1278 if (vend_idx != 0xffff) {
1279 /* if vendor and product ID is OK, start probing alternate settings */
1280 alt_idx = 0;
1281 small_match = 0xffff;
1282
1283 /* default settings */
1284 iso_packet_size = 16;
1285 packet_size = 64;
1286
1287 while (alt_idx < intf->num_altsetting) {
1288 iface = intf->altsetting + alt_idx;
1289 probe_alt_setting = iface->desc.bAlternateSetting;
1290 cfg_used = 0;
1291
1292 /* check for config EOL element */
1293 while (validconf[cfg_used][0]) {
1294 cfg_found = 1;
1295 vcf = validconf[cfg_used];
1296 /* first endpoint descriptor */
1297 ep = iface->endpoint;
1298
1299 memcpy(cmptbl, vcf, 16 * sizeof(int));
1300
1301 /* check for all endpoints in this alternate setting */
1302 for (i = 0; i < iface->desc.bNumEndpoints;
1303 i++) {
1304 ep_addr =
1305 ep->desc.bEndpointAddress;
1306 /* get endpoint base */
1307 idx = ((ep_addr & 0x7f) - 1) * 2;
1308 if (ep_addr & 0x80)
1309 idx++;
1310 attr = ep->desc.bmAttributes;
1311 if (cmptbl[idx] == EP_NUL) {
1312 cfg_found = 0;
1313 }
1314 if (attr == USB_ENDPOINT_XFER_INT
1315 && cmptbl[idx] == EP_INT)
1316 cmptbl[idx] = EP_NUL;
1317 if (attr == USB_ENDPOINT_XFER_BULK
1318 && cmptbl[idx] == EP_BLK)
1319 cmptbl[idx] = EP_NUL;
1320 if (attr == USB_ENDPOINT_XFER_ISOC
1321 && cmptbl[idx] == EP_ISO)
1322 cmptbl[idx] = EP_NUL;
1323
1324 /* check if all INT endpoints match minimum interval */
1325 if ((attr == USB_ENDPOINT_XFER_INT)
1326 && (ep->desc.bInterval < vcf[17])) {
1327 cfg_found = 0;
1328 }
1329 ep++;
1330 }
1331 for (i = 0; i < 16; i++) {
1332 /* all entries must be EP_NOP or EP_NUL for a valid config */
1333 if (cmptbl[i] != EP_NOP
1334 && cmptbl[i] != EP_NUL)
1335 cfg_found = 0;
1336 }
1337 if (cfg_found) {
1338 if (cfg_used < small_match) {
1339 small_match = cfg_used;
1340 alt_used =
1341 probe_alt_setting;
1342 iface_used = iface;
1343 }
1344 }
1345 cfg_used++;
1346 }
1347 alt_idx++;
1348 } /* (alt_idx < intf->num_altsetting) */
1349
1350 /* found a valid USB Ta Endpint config */
1351 if (small_match != 0xffff) {
1352 iface = iface_used;
1353 if (!(context = kzalloc(sizeof(hfcusb_data), GFP_KERNEL)))
1354 return (-ENOMEM); /* got no mem */
1355
1356 ep = iface->endpoint;
1357 vcf = validconf[small_match];
1358
1359 for (i = 0; i < iface->desc.bNumEndpoints; i++) {
1360 ep_addr = ep->desc.bEndpointAddress;
1361 /* get endpoint base */
1362 idx = ((ep_addr & 0x7f) - 1) * 2;
1363 if (ep_addr & 0x80)
1364 idx++;
1365 cidx = idx & 7;
1366 attr = ep->desc.bmAttributes;
1367
1368 /* init Endpoints */
1369 if (vcf[idx] != EP_NOP
1370 && vcf[idx] != EP_NUL) {
1371 switch (attr) {
1372 case USB_ENDPOINT_XFER_INT:
1373 context->
1374 fifos[cidx].
1375 pipe =
1376 usb_rcvintpipe
1377 (dev,
1378 ep->desc.
1379 bEndpointAddress);
1380 context->
1381 fifos[cidx].
1382 usb_transfer_mode
1383 = USB_INT;
1384 packet_size =
1385 le16_to_cpu(ep->desc.wMaxPacketSize);
1386 break;
1387 case USB_ENDPOINT_XFER_BULK:
1388 if (ep_addr & 0x80)
1389 context->
1390 fifos
1391 [cidx].
1392 pipe =
1393 usb_rcvbulkpipe
1394 (dev,
1395 ep->
1396 desc.
1397 bEndpointAddress);
1398 else
1399 context->
1400 fifos
1401 [cidx].
1402 pipe =
1403 usb_sndbulkpipe
1404 (dev,
1405 ep->
1406 desc.
1407 bEndpointAddress);
1408 context->
1409 fifos[cidx].
1410 usb_transfer_mode
1411 = USB_BULK;
1412 packet_size =
1413 le16_to_cpu(ep->desc.wMaxPacketSize);
1414 break;
1415 case USB_ENDPOINT_XFER_ISOC:
1416 if (ep_addr & 0x80)
1417 context->
1418 fifos
1419 [cidx].
1420 pipe =
1421 usb_rcvisocpipe
1422 (dev,
1423 ep->
1424 desc.
1425 bEndpointAddress);
1426 else
1427 context->
1428 fifos
1429 [cidx].
1430 pipe =
1431 usb_sndisocpipe
1432 (dev,
1433 ep->
1434 desc.
1435 bEndpointAddress);
1436 context->
1437 fifos[cidx].
1438 usb_transfer_mode
1439 = USB_ISOC;
1440 iso_packet_size =
1441 le16_to_cpu(ep->desc.wMaxPacketSize);
1442 break;
1443 default:
1444 context->
1445 fifos[cidx].
1446 pipe = 0;
1447 } /* switch attribute */
1448
1449 if (context->fifos[cidx].pipe) {
1450 context->fifos[cidx].
1451 fifonum = cidx;
1452 context->fifos[cidx].hfc =
1453 context;
1454 context->fifos[cidx].usb_packet_maxlen =
1455 le16_to_cpu(ep->desc.wMaxPacketSize);
1456 context->fifos[cidx].
1457 intervall =
1458 ep->desc.bInterval;
1459 context->fifos[cidx].
1460 skbuff = NULL;
1461 }
1462 }
1463 ep++;
1464 }
1465 context->dev = dev; /* save device */
1466 context->if_used = ifnum; /* save used interface */
1467 context->alt_used = alt_used; /* and alternate config */
1468 context->ctrl_paksize = dev->descriptor.bMaxPacketSize0; /* control size */
1469 context->cfg_used = vcf[16]; /* store used config */
1470 context->vend_idx = vend_idx; /* store found vendor */
1471 context->packet_size = packet_size;
1472 context->iso_packet_size = iso_packet_size;
1473
1474 /* create the control pipes needed for register access */
1475 context->ctrl_in_pipe =
1476 usb_rcvctrlpipe(context->dev, 0);
1477 context->ctrl_out_pipe =
1478 usb_sndctrlpipe(context->dev, 0);
1479
1480 driver_info = (hfcsusb_vdata *)
1481 hfcusb_idtab[vend_idx].driver_info;
1482
1483 context->ctrl_urb = usb_alloc_urb(0, GFP_KERNEL);
1484
1485 if (!context->ctrl_urb) {
1486 pr_warn("%s: No memory for control urb\n",
1487 driver_info->vend_name);
1488 kfree(context);
1489 return -ENOMEM;
1490 }
1491
1492 pr_info("HFC-S USB: detected \"%s\"\n",
1493 driver_info->vend_name);
1494
1495 DBG(HFCUSB_DBG_INIT,
1496 "HFC-S USB: Endpoint-Config: %s (if=%d alt=%d), E-Channel(%d)",
1497 conf_str[small_match], context->if_used,
1498 context->alt_used,
1499 validconf[small_match][18]);
1500
1501 /* init the chip and register the driver */
1502 if (hfc_usb_init(context)) {
1503 usb_kill_urb(context->ctrl_urb);
1504 usb_free_urb(context->ctrl_urb);
1505 context->ctrl_urb = NULL;
1506 kfree(context);
1507 return (-EIO);
1508 }
1509 usb_set_intfdata(intf, context);
1510 return (0);
1511 }
1512 } else {
1513 printk(KERN_INFO
1514 "HFC-S USB: no valid vendor found in USB descriptor\n");
1515 }
1516 return (-EIO);
1517 }
1518
1519 /* callback for unplugged USB device */
1520 static void
1521 hfc_usb_disconnect(struct usb_interface *intf)
1522 {
1523 hfcusb_data *context = usb_get_intfdata(intf);
1524 int i;
1525
1526 handle_led(context, LED_POWER_OFF);
1527 schedule_timeout(HZ / 100);
1528
1529 printk(KERN_INFO "HFC-S USB: device disconnect\n");
1530 context->disc_flag = 1;
1531 usb_set_intfdata(intf, NULL);
1532
1533 if (timer_pending(&context->t3_timer))
1534 del_timer(&context->t3_timer);
1535 if (timer_pending(&context->t4_timer))
1536 del_timer(&context->t4_timer);
1537
1538 /* tell all fifos to terminate */
1539 for (i = 0; i < HFCUSB_NUM_FIFOS; i++) {
1540 if (context->fifos[i].usb_transfer_mode == USB_ISOC) {
1541 if (context->fifos[i].active > 0) {
1542 stop_isoc_chain(&context->fifos[i]);
1543 DBG(HFCUSB_DBG_INIT,
1544 "HFC-S USB: %s stopping ISOC chain Fifo(%i)",
1545 __func__, i);
1546 }
1547 } else {
1548 if (context->fifos[i].active > 0) {
1549 context->fifos[i].active = 0;
1550 DBG(HFCUSB_DBG_INIT,
1551 "HFC-S USB: %s unlinking URB for Fifo(%i)",
1552 __func__, i);
1553 }
1554 usb_kill_urb(context->fifos[i].urb);
1555 usb_free_urb(context->fifos[i].urb);
1556 context->fifos[i].urb = NULL;
1557 }
1558 context->fifos[i].active = 0;
1559 }
1560 usb_kill_urb(context->ctrl_urb);
1561 usb_free_urb(context->ctrl_urb);
1562 context->ctrl_urb = NULL;
1563 hisax_unregister(&context->d_if);
1564 kfree(context); /* free our structure again */
1565 }
1566
1567 static struct usb_driver hfc_drv = {
1568 .name = "hfc_usb",
1569 .id_table = hfcusb_idtab,
1570 .probe = hfc_usb_probe,
1571 .disconnect = hfc_usb_disconnect,
1572 .disable_hub_initiated_lpm = 1,
1573 };
1574
1575 static void __exit
1576 hfc_usb_mod_exit(void)
1577 {
1578 usb_deregister(&hfc_drv); /* release our driver */
1579 printk(KERN_INFO "HFC-S USB: module removed\n");
1580 }
1581
1582 static int __init
1583 hfc_usb_mod_init(void)
1584 {
1585 char revstr[30], datestr[30], dummy[30];
1586 #ifndef CONFIG_HISAX_DEBUG
1587 hfc_debug = debug;
1588 #endif
1589 sscanf(hfcusb_revision,
1590 "%s %s $ %s %s %s $ ", dummy, revstr,
1591 dummy, datestr, dummy);
1592 printk(KERN_INFO
1593 "HFC-S USB: driver module revision %s date %s loaded, (debug=%i)\n",
1594 revstr, datestr, debug);
1595 if (usb_register(&hfc_drv)) {
1596 printk(KERN_INFO
1597 "HFC-S USB: Unable to register HFC-S USB module at usb stack\n");
1598 return (-1); /* unable to register */
1599 }
1600 return (0);
1601 }
1602
1603 module_init(hfc_usb_mod_init);
1604 module_exit(hfc_usb_mod_exit);
1605 MODULE_AUTHOR(DRIVER_AUTHOR);
1606 MODULE_DESCRIPTION(DRIVER_DESC);
1607 MODULE_LICENSE("GPL");
1608 MODULE_DEVICE_TABLE(usb, hfcusb_idtab);
Linux with added FPC-III support