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 47static 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" 55static u_int debug; 56module_param(debug, uint, 0); 57static int hfc_debug; 58 59 60/* private vendor specific data */ 61typedef 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 */ 68static 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) */ 139struct usb_fifo; /* forward definition */ 140typedef 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 146struct hfcusb_data; /* forward definition */ 147 148typedef 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 */ 169typedef 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 209static void collect_rx_frame(usb_fifo *fifo, __u8 *data, int len, 210 int finish); 211 212static inline const char * 213symbolic(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 222static void 223ctrl_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 239static int 240queue_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 257static void 258ctrl_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 */ 273static void 274write_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 282static void 283set_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 */ 299static void 300handle_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 */ 345static void 346l1_timer_expire_t3(hfcusb_data *hfc) 347{ 348 hfc->d_if.ifc.l1l2(&hfc->d_if.ifc, PH_DEACTIVATE | INDICATION, 349 NULL); 350 351 DBG(HFCUSB_DBG_STATES, 352 "HFC-S USB: PH_DEACTIVATE | INDICATION sent (T3 expire)"); 353 354 hfc->l1_activated = 0; 355 handle_led(hfc, LED_S0_OFF); 356 /* deactivate : */ 357 queue_control_request(hfc, HFCUSB_STATES, 0x10, 1); 358 queue_control_request(hfc, HFCUSB_STATES, 3, 1); 359} 360 361/* ISDN l1 timer T4 expires */ 362static void 363l1_timer_expire_t4(hfcusb_data *hfc) 364{ 365 hfc->d_if.ifc.l1l2(&hfc->d_if.ifc, PH_DEACTIVATE | INDICATION, 366 NULL); 367 368 DBG(HFCUSB_DBG_STATES, 369 "HFC-S USB: PH_DEACTIVATE | INDICATION sent (T4 expire)"); 370 371 hfc->l1_activated = 0; 372 handle_led(hfc, LED_S0_OFF); 373} 374 375/* S0 state changed */ 376static void 377s0_state_handler(hfcusb_data *hfc, __u8 state) 378{ 379 __u8 old_state; 380 381 old_state = hfc->l1_state; 382 if (state == old_state || state < 1 || state > 8) 383 return; 384 385 DBG(HFCUSB_DBG_STATES, "HFC-S USB: S0 statechange(%d -> %d)", 386 old_state, state); 387 388 if (state < 4 || state == 7 || state == 8) { 389 if (timer_pending(&hfc->t3_timer)) 390 del_timer(&hfc->t3_timer); 391 DBG(HFCUSB_DBG_STATES, "HFC-S USB: T3 deactivated"); 392 } 393 if (state >= 7) { 394 if (timer_pending(&hfc->t4_timer)) 395 del_timer(&hfc->t4_timer); 396 DBG(HFCUSB_DBG_STATES, "HFC-S USB: T4 deactivated"); 397 } 398 399 if (state == 7 && !hfc->l1_activated) { 400 hfc->d_if.ifc.l1l2(&hfc->d_if.ifc, 401 PH_ACTIVATE | INDICATION, NULL); 402 DBG(HFCUSB_DBG_STATES, "HFC-S USB: PH_ACTIVATE | INDICATION sent"); 403 hfc->l1_activated = 1; 404 handle_led(hfc, LED_S0_ON); 405 } else if (state <= 3 /* && activated */) { 406 if (old_state == 7 || old_state == 8) { 407 DBG(HFCUSB_DBG_STATES, "HFC-S USB: T4 activated"); 408 if (!timer_pending(&hfc->t4_timer)) { 409 hfc->t4_timer.expires = 410 jiffies + (HFC_TIMER_T4 * HZ) / 1000; 411 add_timer(&hfc->t4_timer); 412 } 413 } else { 414 hfc->d_if.ifc.l1l2(&hfc->d_if.ifc, 415 PH_DEACTIVATE | INDICATION, 416 NULL); 417 DBG(HFCUSB_DBG_STATES, 418 "HFC-S USB: PH_DEACTIVATE | INDICATION sent"); 419 hfc->l1_activated = 0; 420 handle_led(hfc, LED_S0_OFF); 421 } 422 } 423 hfc->l1_state = state; 424} 425 426static void 427fill_isoc_urb(struct urb *urb, struct usb_device *dev, unsigned int pipe, 428 void *buf, int num_packets, int packet_size, int interval, 429 usb_complete_t complete, void *context) 430{ 431 int k; 432 433 urb->dev = dev; 434 urb->pipe = pipe; 435 urb->complete = complete; 436 urb->number_of_packets = num_packets; 437 urb->transfer_buffer_length = packet_size * num_packets; 438 urb->context = context; 439 urb->transfer_buffer = buf; 440 urb->transfer_flags = URB_ISO_ASAP; 441 urb->actual_length = 0; 442 urb->interval = interval; 443 for (k = 0; k < num_packets; k++) { 444 urb->iso_frame_desc[k].offset = packet_size * k; 445 urb->iso_frame_desc[k].length = packet_size; 446 urb->iso_frame_desc[k].actual_length = 0; 447 } 448} 449 450/* allocs urbs and start isoc transfer with two pending urbs to avoid 451 * gaps in the transfer chain 452 */ 453static int 454start_isoc_chain(usb_fifo *fifo, int num_packets_per_urb, 455 usb_complete_t complete, int packet_size) 456{ 457 int i, k, errcode; 458 459 DBG(HFCUSB_DBG_INIT, "HFC-S USB: starting ISO-URBs for fifo:%d\n", 460 fifo->fifonum); 461 462 /* allocate Memory for Iso out Urbs */ 463 for (i = 0; i < 2; i++) { 464 if (!(fifo->iso[i].purb)) { 465 fifo->iso[i].purb = 466 usb_alloc_urb(num_packets_per_urb, GFP_KERNEL); 467 if (!(fifo->iso[i].purb)) { 468 printk(KERN_INFO 469 "alloc urb for fifo %i failed!!!", 470 fifo->fifonum); 471 } 472 fifo->iso[i].owner_fifo = (struct usb_fifo *) fifo; 473 474 /* Init the first iso */ 475 if (ISO_BUFFER_SIZE >= 476 (fifo->usb_packet_maxlen * 477 num_packets_per_urb)) { 478 fill_isoc_urb(fifo->iso[i].purb, 479 fifo->hfc->dev, fifo->pipe, 480 fifo->iso[i].buffer, 481 num_packets_per_urb, 482 fifo->usb_packet_maxlen, 483 fifo->intervall, complete, 484 &fifo->iso[i]); 485 memset(fifo->iso[i].buffer, 0, 486 sizeof(fifo->iso[i].buffer)); 487 /* defining packet delimeters in fifo->buffer */ 488 for (k = 0; k < num_packets_per_urb; k++) { 489 fifo->iso[i].purb-> 490 iso_frame_desc[k].offset = 491 k * packet_size; 492 fifo->iso[i].purb-> 493 iso_frame_desc[k].length = 494 packet_size; 495 } 496 } else { 497 printk(KERN_INFO 498 "HFC-S USB: ISO Buffer size to small!\n"); 499 } 500 } 501 fifo->bit_line = BITLINE_INF; 502 503 errcode = usb_submit_urb(fifo->iso[i].purb, GFP_KERNEL); 504 fifo->active = (errcode >= 0) ? 1 : 0; 505 if (errcode < 0) 506 printk(KERN_INFO "HFC-S USB: usb_submit_urb URB nr:%d, error(%i): '%s'\n", 507 i, errcode, symbolic(urb_errlist, errcode)); 508 } 509 return (fifo->active); 510} 511 512/* stops running iso chain and frees their pending urbs */ 513static void 514stop_isoc_chain(usb_fifo *fifo) 515{ 516 int i; 517 518 for (i = 0; i < 2; i++) { 519 if (fifo->iso[i].purb) { 520 DBG(HFCUSB_DBG_INIT, 521 "HFC-S USB: Stopping iso chain for fifo %i.%i", 522 fifo->fifonum, i); 523 usb_kill_urb(fifo->iso[i].purb); 524 usb_free_urb(fifo->iso[i].purb); 525 fifo->iso[i].purb = NULL; 526 } 527 } 528 529 usb_kill_urb(fifo->urb); 530 usb_free_urb(fifo->urb); 531 fifo->urb = NULL; 532 fifo->active = 0; 533} 534 535/* defines how much ISO packets are handled in one URB */ 536static int iso_packets[8] = 537{ ISOC_PACKETS_B, ISOC_PACKETS_B, ISOC_PACKETS_B, ISOC_PACKETS_B, 538 ISOC_PACKETS_D, ISOC_PACKETS_D, ISOC_PACKETS_D, ISOC_PACKETS_D 539}; 540 541static void 542tx_iso_complete(struct urb *urb) 543{ 544 iso_urb_struct *context_iso_urb = (iso_urb_struct *) urb->context; 545 usb_fifo *fifo = context_iso_urb->owner_fifo; 546 hfcusb_data *hfc = fifo->hfc; 547 int k, tx_offset, num_isoc_packets, sink, len, current_len, 548 errcode; 549 int frame_complete, transp_mode, fifon, status; 550 __u8 threshbit; 551 552 fifon = fifo->fifonum; 553 status = urb->status; 554 555 tx_offset = 0; 556 557 /* ISO transfer only partially completed, 558 look at individual frame status for details */ 559 if (status == -EXDEV) { 560 DBG(HFCUSB_DBG_VERBOSE_USB, "HFC-S USB: tx_iso_complete with -EXDEV" 561 ", urb->status %d, fifonum %d\n", 562 status, fifon); 563 564 for (k = 0; k < iso_packets[fifon]; ++k) { 565 errcode = urb->iso_frame_desc[k].status; 566 if (errcode) 567 DBG(HFCUSB_DBG_VERBOSE_USB, "HFC-S USB: tx_iso_complete " 568 "packet %i, status: %i\n", 569 k, errcode); 570 } 571 572 // clear status, so go on with ISO transfers 573 status = 0; 574 } 575 576 if (fifo->active && !status) { 577 transp_mode = 0; 578 if (fifon < 4 && hfc->b_mode[fifon / 2] == L1_MODE_TRANS) 579 transp_mode = 1; 580 581 /* is FifoFull-threshold set for our channel? */ 582 threshbit = (hfc->threshold_mask & (1 << fifon)); 583 num_isoc_packets = iso_packets[fifon]; 584 585 /* predict dataflow to avoid fifo overflow */ 586 if (fifon >= HFCUSB_D_TX) { 587 sink = (threshbit) ? SINK_DMIN : SINK_DMAX; 588 } else { 589 sink = (threshbit) ? SINK_MIN : SINK_MAX; 590 } 591 fill_isoc_urb(urb, fifo->hfc->dev, fifo->pipe, 592 context_iso_urb->buffer, num_isoc_packets, 593 fifo->usb_packet_maxlen, fifo->intervall, 594 tx_iso_complete, urb->context); 595 memset(context_iso_urb->buffer, 0, 596 sizeof(context_iso_urb->buffer)); 597 frame_complete = 0; 598 599 /* Generate next ISO Packets */ 600 for (k = 0; k < num_isoc_packets; ++k) { 601 if (fifo->skbuff) { 602 len = fifo->skbuff->len; 603 /* we lower data margin every msec */ 604 fifo->bit_line -= sink; 605 current_len = (0 - fifo->bit_line) / 8; 606 /* maximum 15 byte for every ISO packet makes our life easier */ 607 if (current_len > 14) 608 current_len = 14; 609 current_len = 610 (len <= 611 current_len) ? len : current_len; 612 /* how much bit do we put on the line? */ 613 fifo->bit_line += current_len * 8; 614 615 context_iso_urb->buffer[tx_offset] = 0; 616 if (current_len == len) { 617 if (!transp_mode) { 618 /* here frame completion */ 619 context_iso_urb-> 620 buffer[tx_offset] = 1; 621 /* add 2 byte flags and 16bit CRC at end of ISDN frame */ 622 fifo->bit_line += 32; 623 } 624 frame_complete = 1; 625 } 626 627 memcpy(context_iso_urb->buffer + 628 tx_offset + 1, fifo->skbuff->data, 629 current_len); 630 skb_pull(fifo->skbuff, current_len); 631 632 /* define packet delimeters within the URB buffer */ 633 urb->iso_frame_desc[k].offset = tx_offset; 634 urb->iso_frame_desc[k].length = 635 current_len + 1; 636 637 tx_offset += (current_len + 1); 638 } else { 639 urb->iso_frame_desc[k].offset = 640 tx_offset++; 641 642 urb->iso_frame_desc[k].length = 1; 643 fifo->bit_line -= sink; /* we lower data margin every msec */ 644 645 if (fifo->bit_line < BITLINE_INF) { 646 fifo->bit_line = BITLINE_INF; 647 } 648 } 649 650 if (frame_complete) { 651 fifo->delete_flg = 1; 652 fifo->hif->l1l2(fifo->hif, 653 PH_DATA | CONFIRM, 654 (void *) (unsigned long) fifo->skbuff-> 655 truesize); 656 if (fifo->skbuff && fifo->delete_flg) { 657 dev_kfree_skb_any(fifo->skbuff); 658 fifo->skbuff = NULL; 659 fifo->delete_flg = 0; 660 } 661 frame_complete = 0; 662 } 663 } 664 errcode = usb_submit_urb(urb, GFP_ATOMIC); 665 if (errcode < 0) { 666 printk(KERN_INFO 667 "HFC-S USB: error submitting ISO URB: %d\n", 668 errcode); 669 } 670 } else { 671 if (status && !hfc->disc_flag) { 672 printk(KERN_INFO 673 "HFC-S USB: tx_iso_complete: error(%i): '%s', fifonum=%d\n", 674 status, symbolic(urb_errlist, status), fifon); 675 } 676 } 677} 678 679static void 680rx_iso_complete(struct urb *urb) 681{ 682 iso_urb_struct *context_iso_urb = (iso_urb_struct *) urb->context; 683 usb_fifo *fifo = context_iso_urb->owner_fifo; 684 hfcusb_data *hfc = fifo->hfc; 685 int k, len, errcode, offset, num_isoc_packets, fifon, maxlen, 686 status; 687 unsigned int iso_status; 688 __u8 *buf; 689 static __u8 eof[8]; 690 691 fifon = fifo->fifonum; 692 status = urb->status; 693 694 if (urb->status == -EOVERFLOW) { 695 DBG(HFCUSB_DBG_VERBOSE_USB, 696 "HFC-USB: ignoring USB DATAOVERRUN fifo(%i)", fifon); 697 status = 0; 698 } 699 700 /* ISO transfer only partially completed, 701 look at individual frame status for details */ 702 if (status == -EXDEV) { 703 DBG(HFCUSB_DBG_VERBOSE_USB, "HFC-S USB: rx_iso_complete with -EXDEV " 704 "urb->status %d, fifonum %d\n", 705 status, fifon); 706 status = 0; 707 } 708 709 if (fifo->active && !status) { 710 num_isoc_packets = iso_packets[fifon]; 711 maxlen = fifo->usb_packet_maxlen; 712 for (k = 0; k < num_isoc_packets; ++k) { 713 len = urb->iso_frame_desc[k].actual_length; 714 offset = urb->iso_frame_desc[k].offset; 715 buf = context_iso_urb->buffer + offset; 716 iso_status = urb->iso_frame_desc[k].status; 717 718 if (iso_status && !hfc->disc_flag) 719 DBG(HFCUSB_DBG_VERBOSE_USB, 720 "HFC-S USB: rx_iso_complete " 721 "ISO packet %i, status: %i\n", 722 k, iso_status); 723 724 if (fifon == HFCUSB_D_RX) { 725 DBG(HFCUSB_DBG_VERBOSE_USB, 726 "HFC-S USB: ISO-D-RX lst_urblen:%2d " 727 "act_urblen:%2d max-urblen:%2d EOF:0x%0x", 728 fifo->last_urblen, len, maxlen, 729 eof[5]); 730 731 DBG_PACKET(HFCUSB_DBG_VERBOSE_USB, buf, len); 732 } 733 734 if (fifo->last_urblen != maxlen) { 735 /* the threshold mask is in the 2nd status byte */ 736 hfc->threshold_mask = buf[1]; 737 /* care for L1 state only for D-Channel 738 to avoid overlapped iso completions */ 739 if (fifon == HFCUSB_D_RX) { 740 /* the S0 state is in the upper half 741 of the 1st status byte */ 742 s0_state_handler(hfc, buf[0] >> 4); 743 } 744 eof[fifon] = buf[0] & 1; 745 if (len > 2) 746 collect_rx_frame(fifo, buf + 2, 747 len - 2, 748 (len < maxlen) ? 749 eof[fifon] : 0); 750 } else { 751 collect_rx_frame(fifo, buf, len, 752 (len < 753 maxlen) ? eof[fifon] : 754 0); 755 } 756 fifo->last_urblen = len; 757 } 758 759 fill_isoc_urb(urb, fifo->hfc->dev, fifo->pipe, 760 context_iso_urb->buffer, num_isoc_packets, 761 fifo->usb_packet_maxlen, fifo->intervall, 762 rx_iso_complete, urb->context); 763 errcode = usb_submit_urb(urb, GFP_ATOMIC); 764 if (errcode < 0) { 765 printk(KERN_ERR 766 "HFC-S USB: error submitting ISO URB: %d\n", 767 errcode); 768 } 769 } else { 770 if (status && !hfc->disc_flag) { 771 printk(KERN_ERR 772 "HFC-S USB: rx_iso_complete : " 773 "urb->status %d, fifonum %d\n", 774 status, fifon); 775 } 776 } 777} 778 779/* collect rx data from INT- and ISO-URBs */ 780static void 781collect_rx_frame(usb_fifo *fifo, __u8 *data, int len, int finish) 782{ 783 hfcusb_data *hfc = fifo->hfc; 784 int transp_mode, fifon; 785 786 fifon = fifo->fifonum; 787 transp_mode = 0; 788 if (fifon < 4 && hfc->b_mode[fifon / 2] == L1_MODE_TRANS) 789 transp_mode = 1; 790 791 if (!fifo->skbuff) { 792 fifo->skbuff = dev_alloc_skb(fifo->max_size + 3); 793 if (!fifo->skbuff) { 794 printk(KERN_ERR 795 "HFC-S USB: cannot allocate buffer for fifo(%d)\n", 796 fifon); 797 return; 798 } 799 } 800 if (len) { 801 if (fifo->skbuff->len + len < fifo->max_size) { 802 memcpy(skb_put(fifo->skbuff, len), data, len); 803 } else { 804 DBG(HFCUSB_DBG_FIFO_ERR, 805 "HCF-USB: got frame exceeded fifo->max_size(%d) fifo(%d)", 806 fifo->max_size, fifon); 807 DBG_SKB(HFCUSB_DBG_VERBOSE_USB, fifo->skbuff); 808 skb_trim(fifo->skbuff, 0); 809 } 810 } 811 if (transp_mode && fifo->skbuff->len >= 128) { 812 fifo->hif->l1l2(fifo->hif, PH_DATA | INDICATION, 813 fifo->skbuff); 814 fifo->skbuff = NULL; 815 return; 816 } 817 /* we have a complete hdlc packet */ 818 if (finish) { 819 if (fifo->skbuff->len > 3 && 820 !fifo->skbuff->data[fifo->skbuff->len - 1]) { 821 822 if (fifon == HFCUSB_D_RX) { 823 DBG(HFCUSB_DBG_DCHANNEL, 824 "HFC-S USB: D-RX len(%d)", fifo->skbuff->len); 825 DBG_SKB(HFCUSB_DBG_DCHANNEL, fifo->skbuff); 826 } 827 828 /* remove CRC & status */ 829 skb_trim(fifo->skbuff, fifo->skbuff->len - 3); 830 if (fifon == HFCUSB_PCM_RX) { 831 fifo->hif->l1l2(fifo->hif, 832 PH_DATA_E | INDICATION, 833 fifo->skbuff); 834 } else 835 fifo->hif->l1l2(fifo->hif, 836 PH_DATA | INDICATION, 837 fifo->skbuff); 838 fifo->skbuff = NULL; /* buffer was freed from upper layer */ 839 } else { 840 DBG(HFCUSB_DBG_FIFO_ERR, 841 "HFC-S USB: ERROR frame len(%d) fifo(%d)", 842 fifo->skbuff->len, fifon); 843 DBG_SKB(HFCUSB_DBG_VERBOSE_USB, fifo->skbuff); 844 skb_trim(fifo->skbuff, 0); 845 } 846 } 847} 848 849static void 850rx_int_complete(struct urb *urb) 851{ 852 int len; 853 int status; 854 __u8 *buf, maxlen, fifon; 855 usb_fifo *fifo = (usb_fifo *) urb->context; 856 hfcusb_data *hfc = fifo->hfc; 857 static __u8 eof[8]; 858 859 urb->dev = hfc->dev; /* security init */ 860 861 fifon = fifo->fifonum; 862 if ((!fifo->active) || (urb->status)) { 863 DBG(HFCUSB_DBG_INIT, "HFC-S USB: RX-Fifo %i is going down (%i)", 864 fifon, urb->status); 865 866 fifo->urb->interval = 0; /* cancel automatic rescheduling */ 867 if (fifo->skbuff) { 868 dev_kfree_skb_any(fifo->skbuff); 869 fifo->skbuff = NULL; 870 } 871 return; 872 } 873 len = urb->actual_length; 874 buf = fifo->buffer; 875 maxlen = fifo->usb_packet_maxlen; 876 877 if (fifon == HFCUSB_D_RX) { 878 DBG(HFCUSB_DBG_VERBOSE_USB, 879 "HFC-S USB: INT-D-RX lst_urblen:%2d " 880 "act_urblen:%2d max-urblen:%2d EOF:0x%0x", 881 fifo->last_urblen, len, maxlen, 882 eof[5]); 883 DBG_PACKET(HFCUSB_DBG_VERBOSE_USB, buf, len); 884 } 885 886 if (fifo->last_urblen != fifo->usb_packet_maxlen) { 887 /* the threshold mask is in the 2nd status byte */ 888 hfc->threshold_mask = buf[1]; 889 /* the S0 state is in the upper half of the 1st status byte */ 890 s0_state_handler(hfc, buf[0] >> 4); 891 eof[fifon] = buf[0] & 1; 892 /* if we have more than the 2 status bytes -> collect data */ 893 if (len > 2) 894 collect_rx_frame(fifo, buf + 2, 895 urb->actual_length - 2, 896 (len < maxlen) ? eof[fifon] : 0); 897 } else { 898 collect_rx_frame(fifo, buf, urb->actual_length, 899 (len < maxlen) ? eof[fifon] : 0); 900 } 901 fifo->last_urblen = urb->actual_length; 902 status = usb_submit_urb(urb, GFP_ATOMIC); 903 if (status) { 904 printk(KERN_INFO 905 "HFC-S USB: %s error resubmitting URB fifo(%d)\n", 906 __func__, fifon); 907 } 908} 909 910/* start initial INT-URB for certain fifo */ 911static void 912start_int_fifo(usb_fifo *fifo) 913{ 914 int errcode; 915 916 DBG(HFCUSB_DBG_INIT, "HFC-S USB: starting RX INT-URB for fifo:%d\n", 917 fifo->fifonum); 918 919 if (!fifo->urb) { 920 fifo->urb = usb_alloc_urb(0, GFP_KERNEL); 921 if (!fifo->urb) 922 return; 923 } 924 usb_fill_int_urb(fifo->urb, fifo->hfc->dev, fifo->pipe, 925 fifo->buffer, fifo->usb_packet_maxlen, 926 rx_int_complete, fifo, fifo->intervall); 927 fifo->active = 1; /* must be marked active */ 928 errcode = usb_submit_urb(fifo->urb, GFP_KERNEL); 929 if (errcode) { 930 printk(KERN_ERR "HFC-S USB: submit URB error(%s): status:%i\n", 931 __func__, errcode); 932 fifo->active = 0; 933 fifo->skbuff = NULL; 934 } 935} 936 937static void 938setup_bchannel(hfcusb_data *hfc, int channel, int mode) 939{ 940 __u8 val, idx_table[2] = { 0, 2 }; 941 942 if (hfc->disc_flag) { 943 return; 944 } 945 DBG(HFCUSB_DBG_STATES, "HFC-S USB: setting channel %d to mode %d", 946 channel, mode); 947 hfc->b_mode[channel] = mode; 948 949 /* setup CON_HDLC */ 950 val = 0; 951 if (mode != L1_MODE_NULL) 952 val = 8; /* enable fifo? */ 953 if (mode == L1_MODE_TRANS) 954 val |= 2; /* set transparent bit */ 955 956 /* set FIFO to transmit register */ 957 queue_control_request(hfc, HFCUSB_FIFO, idx_table[channel], 1); 958 queue_control_request(hfc, HFCUSB_CON_HDLC, val, 1); 959 /* reset fifo */ 960 queue_control_request(hfc, HFCUSB_INC_RES_F, 2, 1); 961 /* set FIFO to receive register */ 962 queue_control_request(hfc, HFCUSB_FIFO, idx_table[channel] + 1, 1); 963 queue_control_request(hfc, HFCUSB_CON_HDLC, val, 1); 964 /* reset fifo */ 965 queue_control_request(hfc, HFCUSB_INC_RES_F, 2, 1); 966 967 val = 0x40; 968 if (hfc->b_mode[0]) 969 val |= 1; 970 if (hfc->b_mode[1]) 971 val |= 2; 972 queue_control_request(hfc, HFCUSB_SCTRL, val, 1); 973 974 val = 0; 975 if (hfc->b_mode[0]) 976 val |= 1; 977 if (hfc->b_mode[1]) 978 val |= 2; 979 queue_control_request(hfc, HFCUSB_SCTRL_R, val, 1); 980 981 if (mode == L1_MODE_NULL) { 982 if (channel) 983 handle_led(hfc, LED_B2_OFF); 984 else 985 handle_led(hfc, LED_B1_OFF); 986 } else { 987 if (channel) 988 handle_led(hfc, LED_B2_ON); 989 else 990 handle_led(hfc, LED_B1_ON); 991 } 992} 993 994static void 995hfc_usb_l2l1(struct hisax_if *my_hisax_if, int pr, void *arg) 996{ 997 usb_fifo *fifo = my_hisax_if->priv; 998 hfcusb_data *hfc = fifo->hfc; 999 1000 switch (pr) { 1001 case PH_ACTIVATE | REQUEST: 1002 if (fifo->fifonum == HFCUSB_D_TX) { 1003 DBG(HFCUSB_DBG_STATES, 1004 "HFC_USB: hfc_usb_d_l2l1 D-chan: PH_ACTIVATE | REQUEST"); 1005 1006 if (hfc->l1_state != 3 1007 && hfc->l1_state != 7) { 1008 hfc->d_if.ifc.l1l2(&hfc->d_if.ifc, 1009 PH_DEACTIVATE | 1010 INDICATION, 1011 NULL); 1012 DBG(HFCUSB_DBG_STATES, 1013 "HFC-S USB: PH_DEACTIVATE | INDICATION sent (not state 3 or 7)"); 1014 } else { 1015 if (hfc->l1_state == 7) { /* l1 already active */ 1016 hfc->d_if.ifc.l1l2(&hfc-> 1017 d_if. 1018 ifc, 1019 PH_ACTIVATE 1020 | 1021 INDICATION, 1022 NULL); 1023 DBG(HFCUSB_DBG_STATES, 1024 "HFC-S USB: PH_ACTIVATE | INDICATION sent again ;)"); 1025 } else { 1026 /* force sending sending INFO1 */ 1027 queue_control_request(hfc, 1028 HFCUSB_STATES, 1029 0x14, 1030 1); 1031 mdelay(1); 1032 /* start l1 activation */ 1033 queue_control_request(hfc, 1034 HFCUSB_STATES, 1035 0x04, 1036 1); 1037 if (!timer_pending 1038 (&hfc->t3_timer)) { 1039 hfc->t3_timer. 1040 expires = 1041 jiffies + 1042 (HFC_TIMER_T3 * 1043 HZ) / 1000; 1044 add_timer(&hfc-> 1045 t3_timer); 1046 } 1047 } 1048 } 1049 } else { 1050 DBG(HFCUSB_DBG_STATES, 1051 "HFC_USB: hfc_usb_d_l2l1 B-chan: PH_ACTIVATE | REQUEST"); 1052 setup_bchannel(hfc, 1053 (fifo->fifonum == 1054 HFCUSB_B1_TX) ? 0 : 1, 1055 (long) arg); 1056 fifo->hif->l1l2(fifo->hif, 1057 PH_ACTIVATE | INDICATION, 1058 NULL); 1059 } 1060 break; 1061 case PH_DEACTIVATE | REQUEST: 1062 if (fifo->fifonum == HFCUSB_D_TX) { 1063 DBG(HFCUSB_DBG_STATES, 1064 "HFC_USB: hfc_usb_d_l2l1 D-chan: PH_DEACTIVATE | REQUEST"); 1065 } else { 1066 DBG(HFCUSB_DBG_STATES, 1067 "HFC_USB: hfc_usb_d_l2l1 Bx-chan: PH_DEACTIVATE | REQUEST"); 1068 setup_bchannel(hfc, 1069 (fifo->fifonum == 1070 HFCUSB_B1_TX) ? 0 : 1, 1071 (int) L1_MODE_NULL); 1072 fifo->hif->l1l2(fifo->hif, 1073 PH_DEACTIVATE | INDICATION, 1074 NULL); 1075 } 1076 break; 1077 case PH_DATA | REQUEST: 1078 if (fifo->skbuff && fifo->delete_flg) { 1079 dev_kfree_skb_any(fifo->skbuff); 1080 fifo->skbuff = NULL; 1081 fifo->delete_flg = 0; 1082 } 1083 fifo->skbuff = arg; /* we have a new buffer */ 1084 break; 1085 default: 1086 DBG(HFCUSB_DBG_STATES, 1087 "HFC_USB: hfc_usb_d_l2l1: unknown state : %#x", pr); 1088 break; 1089 } 1090} 1091 1092/* initial init HFC-S USB chip registers, HiSax interface, USB URBs */ 1093static int 1094hfc_usb_init(hfcusb_data *hfc) 1095{ 1096 usb_fifo *fifo; 1097 int i; 1098 u_char b; 1099 struct hisax_b_if *p_b_if[2]; 1100 1101 /* check the chip id */ 1102 if (read_usb(hfc, HFCUSB_CHIP_ID, &b) != 1) { 1103 printk(KERN_INFO "HFC-USB: cannot read chip id\n"); 1104 return (1); 1105 } 1106 if (b != HFCUSB_CHIPID) { 1107 printk(KERN_INFO "HFC-S USB: Invalid chip id 0x%02x\n", b); 1108 return (1); 1109 } 1110 1111 /* first set the needed config, interface and alternate */ 1112 usb_set_interface(hfc->dev, hfc->if_used, hfc->alt_used); 1113 1114 /* do Chip reset */ 1115 write_usb(hfc, HFCUSB_CIRM, 8); 1116 /* aux = output, reset off */ 1117 write_usb(hfc, HFCUSB_CIRM, 0x10); 1118 1119 /* set USB_SIZE to match wMaxPacketSize for INT or BULK transfers */ 1120 write_usb(hfc, HFCUSB_USB_SIZE, 1121 (hfc->packet_size / 8) | ((hfc->packet_size / 8) << 4)); 1122 1123 /* set USB_SIZE_I to match wMaxPacketSize for ISO transfers */ 1124 write_usb(hfc, HFCUSB_USB_SIZE_I, hfc->iso_packet_size); 1125 1126 /* enable PCM/GCI master mode */ 1127 write_usb(hfc, HFCUSB_MST_MODE1, 0); /* set default values */ 1128 write_usb(hfc, HFCUSB_MST_MODE0, 1); /* enable master mode */ 1129 1130 /* init the fifos */ 1131 write_usb(hfc, HFCUSB_F_THRES, 1132 (HFCUSB_TX_THRESHOLD / 1133 8) | ((HFCUSB_RX_THRESHOLD / 8) << 4)); 1134 1135 fifo = hfc->fifos; 1136 for (i = 0; i < HFCUSB_NUM_FIFOS; i++) { 1137 write_usb(hfc, HFCUSB_FIFO, i); /* select the desired fifo */ 1138 fifo[i].skbuff = NULL; /* init buffer pointer */ 1139 fifo[i].max_size = 1140 (i <= HFCUSB_B2_RX) ? MAX_BCH_SIZE : MAX_DFRAME_LEN; 1141 fifo[i].last_urblen = 0; 1142 /* set 2 bit for D- & E-channel */ 1143 write_usb(hfc, HFCUSB_HDLC_PAR, 1144 ((i <= HFCUSB_B2_RX) ? 0 : 2)); 1145 /* rx hdlc, enable IFF for D-channel */ 1146 write_usb(hfc, HFCUSB_CON_HDLC, 1147 ((i == HFCUSB_D_TX) ? 0x09 : 0x08)); 1148 write_usb(hfc, HFCUSB_INC_RES_F, 2); /* reset the fifo */ 1149 } 1150 1151 write_usb(hfc, HFCUSB_CLKDEL, 0x0f); /* clock delay value */ 1152 write_usb(hfc, HFCUSB_STATES, 3 | 0x10); /* set deactivated mode */ 1153 write_usb(hfc, HFCUSB_STATES, 3); /* enable state machine */ 1154 1155 write_usb(hfc, HFCUSB_SCTRL_R, 0); /* disable both B receivers */ 1156 write_usb(hfc, HFCUSB_SCTRL, 0x40); /* disable B transmitters + capacitive mode */ 1157 1158 /* set both B-channel to not connected */ 1159 hfc->b_mode[0] = L1_MODE_NULL; 1160 hfc->b_mode[1] = L1_MODE_NULL; 1161 1162 hfc->l1_activated = 0; 1163 hfc->disc_flag = 0; 1164 hfc->led_state = 0; 1165 hfc->old_led_state = 0; 1166 1167 /* init the t3 timer */ 1168 init_timer(&hfc->t3_timer); 1169 hfc->t3_timer.data = (long) hfc; 1170 hfc->t3_timer.function = (void *) l1_timer_expire_t3; 1171 1172 /* init the t4 timer */ 1173 init_timer(&hfc->t4_timer); 1174 hfc->t4_timer.data = (long) hfc; 1175 hfc->t4_timer.function = (void *) l1_timer_expire_t4; 1176 1177 /* init the background machinery for control requests */ 1178 hfc->ctrl_read.bRequestType = 0xc0; 1179 hfc->ctrl_read.bRequest = 1; 1180 hfc->ctrl_read.wLength = cpu_to_le16(1); 1181 hfc->ctrl_write.bRequestType = 0x40; 1182 hfc->ctrl_write.bRequest = 0; 1183 hfc->ctrl_write.wLength = 0; 1184 usb_fill_control_urb(hfc->ctrl_urb, 1185 hfc->dev, 1186 hfc->ctrl_out_pipe, 1187 (u_char *)&hfc->ctrl_write, 1188 NULL, 0, ctrl_complete, hfc); 1189 /* Init All Fifos */ 1190 for (i = 0; i < HFCUSB_NUM_FIFOS; i++) { 1191 hfc->fifos[i].iso[0].purb = NULL; 1192 hfc->fifos[i].iso[1].purb = NULL; 1193 hfc->fifos[i].active = 0; 1194 } 1195 /* register Modul to upper Hisax Layers */ 1196 hfc->d_if.owner = THIS_MODULE; 1197 hfc->d_if.ifc.priv = &hfc->fifos[HFCUSB_D_TX]; 1198 hfc->d_if.ifc.l2l1 = hfc_usb_l2l1; 1199 for (i = 0; i < 2; i++) { 1200 hfc->b_if[i].ifc.priv = &hfc->fifos[HFCUSB_B1_TX + i * 2]; 1201 hfc->b_if[i].ifc.l2l1 = hfc_usb_l2l1; 1202 p_b_if[i] = &hfc->b_if[i]; 1203 } 1204 /* default Prot: EURO ISDN, should be a module_param */ 1205 hfc->protocol = 2; 1206 i = hisax_register(&hfc->d_if, p_b_if, "hfc_usb", hfc->protocol); 1207 if (i) { 1208 printk(KERN_INFO "HFC-S USB: hisax_register -> %d\n", i); 1209 return i; 1210 } 1211 1212#ifdef CONFIG_HISAX_DEBUG 1213 hfc_debug = debug; 1214#endif 1215 1216 for (i = 0; i < 4; i++) 1217 hfc->fifos[i].hif = &p_b_if[i / 2]->ifc; 1218 for (i = 4; i < 8; i++) 1219 hfc->fifos[i].hif = &hfc->d_if.ifc; 1220 1221 /* 3 (+1) INT IN + 3 ISO OUT */ 1222 if (hfc->cfg_used == CNF_3INT3ISO || hfc->cfg_used == CNF_4INT3ISO) { 1223 start_int_fifo(hfc->fifos + HFCUSB_D_RX); 1224 if (hfc->fifos[HFCUSB_PCM_RX].pipe) 1225 start_int_fifo(hfc->fifos + HFCUSB_PCM_RX); 1226 start_int_fifo(hfc->fifos + HFCUSB_B1_RX); 1227 start_int_fifo(hfc->fifos + HFCUSB_B2_RX); 1228 } 1229 /* 3 (+1) ISO IN + 3 ISO OUT */ 1230 if (hfc->cfg_used == CNF_3ISO3ISO || hfc->cfg_used == CNF_4ISO3ISO) { 1231 start_isoc_chain(hfc->fifos + HFCUSB_D_RX, ISOC_PACKETS_D, 1232 rx_iso_complete, 16); 1233 if (hfc->fifos[HFCUSB_PCM_RX].pipe) 1234 start_isoc_chain(hfc->fifos + HFCUSB_PCM_RX, 1235 ISOC_PACKETS_D, rx_iso_complete, 1236 16); 1237 start_isoc_chain(hfc->fifos + HFCUSB_B1_RX, ISOC_PACKETS_B, 1238 rx_iso_complete, 16); 1239 start_isoc_chain(hfc->fifos + HFCUSB_B2_RX, ISOC_PACKETS_B, 1240 rx_iso_complete, 16); 1241 } 1242 1243 start_isoc_chain(hfc->fifos + HFCUSB_D_TX, ISOC_PACKETS_D, 1244 tx_iso_complete, 1); 1245 start_isoc_chain(hfc->fifos + HFCUSB_B1_TX, ISOC_PACKETS_B, 1246 tx_iso_complete, 1); 1247 start_isoc_chain(hfc->fifos + HFCUSB_B2_TX, ISOC_PACKETS_B, 1248 tx_iso_complete, 1); 1249 1250 handle_led(hfc, LED_POWER_ON); 1251 1252 return (0); 1253} 1254 1255/* initial callback for each plugged USB device */ 1256static int 1257hfc_usb_probe(struct usb_interface *intf, const struct usb_device_id *id) 1258{ 1259 struct usb_device *dev = interface_to_usbdev(intf); 1260 hfcusb_data *context; 1261 struct usb_host_interface *iface = intf->cur_altsetting; 1262 struct usb_host_interface *iface_used = NULL; 1263 struct usb_host_endpoint *ep; 1264 int ifnum = iface->desc.bInterfaceNumber; 1265 int i, idx, alt_idx, probe_alt_setting, vend_idx, cfg_used, *vcf, 1266 attr, cfg_found, cidx, ep_addr; 1267 int cmptbl[16], small_match, iso_packet_size, packet_size, 1268 alt_used = 0; 1269 hfcsusb_vdata *driver_info; 1270 1271 vend_idx = 0xffff; 1272 for (i = 0; hfcusb_idtab[i].idVendor; i++) { 1273 if ((le16_to_cpu(dev->descriptor.idVendor) == hfcusb_idtab[i].idVendor) 1274 && (le16_to_cpu(dev->descriptor.idProduct) == hfcusb_idtab[i].idProduct)) { 1275 vend_idx = i; 1276 continue; 1277 } 1278 } 1279 1280 printk(KERN_INFO 1281 "HFC-S USB: probing interface(%d) actalt(%d) minor(%d)\n", 1282 ifnum, iface->desc.bAlternateSetting, intf->minor); 1283 1284 if (vend_idx != 0xffff) { 1285 /* if vendor and product ID is OK, start probing alternate settings */ 1286 alt_idx = 0; 1287 small_match = 0xffff; 1288 1289 /* default settings */ 1290 iso_packet_size = 16; 1291 packet_size = 64; 1292 1293 while (alt_idx < intf->num_altsetting) { 1294 iface = intf->altsetting + alt_idx; 1295 probe_alt_setting = iface->desc.bAlternateSetting; 1296 cfg_used = 0; 1297 1298 /* check for config EOL element */ 1299 while (validconf[cfg_used][0]) { 1300 cfg_found = 1; 1301 vcf = validconf[cfg_used]; 1302 /* first endpoint descriptor */ 1303 ep = iface->endpoint; 1304 1305 memcpy(cmptbl, vcf, 16 * sizeof(int)); 1306 1307 /* check for all endpoints in this alternate setting */ 1308 for (i = 0; i < iface->desc.bNumEndpoints; 1309 i++) { 1310 ep_addr = 1311 ep->desc.bEndpointAddress; 1312 /* get endpoint base */ 1313 idx = ((ep_addr & 0x7f) - 1) * 2; 1314 if (ep_addr & 0x80) 1315 idx++; 1316 attr = ep->desc.bmAttributes; 1317 if (cmptbl[idx] == EP_NUL) { 1318 cfg_found = 0; 1319 } 1320 if (attr == USB_ENDPOINT_XFER_INT 1321 && cmptbl[idx] == EP_INT) 1322 cmptbl[idx] = EP_NUL; 1323 if (attr == USB_ENDPOINT_XFER_BULK 1324 && cmptbl[idx] == EP_BLK) 1325 cmptbl[idx] = EP_NUL; 1326 if (attr == USB_ENDPOINT_XFER_ISOC 1327 && cmptbl[idx] == EP_ISO) 1328 cmptbl[idx] = EP_NUL; 1329 1330 /* check if all INT endpoints match minimum interval */ 1331 if ((attr == USB_ENDPOINT_XFER_INT) 1332 && (ep->desc.bInterval < vcf[17])) { 1333 cfg_found = 0; 1334 } 1335 ep++; 1336 } 1337 for (i = 0; i < 16; i++) { 1338 /* all entries must be EP_NOP or EP_NUL for a valid config */ 1339 if (cmptbl[i] != EP_NOP 1340 && cmptbl[i] != EP_NUL) 1341 cfg_found = 0; 1342 } 1343 if (cfg_found) { 1344 if (cfg_used < small_match) { 1345 small_match = cfg_used; 1346 alt_used = 1347 probe_alt_setting; 1348 iface_used = iface; 1349 } 1350 } 1351 cfg_used++; 1352 } 1353 alt_idx++; 1354 } /* (alt_idx < intf->num_altsetting) */ 1355 1356 /* found a valid USB Ta Endpint config */ 1357 if (small_match != 0xffff) { 1358 iface = iface_used; 1359 if (!(context = kzalloc(sizeof(hfcusb_data), GFP_KERNEL))) 1360 return (-ENOMEM); /* got no mem */ 1361 1362 ep = iface->endpoint; 1363 vcf = validconf[small_match]; 1364 1365 for (i = 0; i < iface->desc.bNumEndpoints; i++) { 1366 ep_addr = ep->desc.bEndpointAddress; 1367 /* get endpoint base */ 1368 idx = ((ep_addr & 0x7f) - 1) * 2; 1369 if (ep_addr & 0x80) 1370 idx++; 1371 cidx = idx & 7; 1372 attr = ep->desc.bmAttributes; 1373 1374 /* init Endpoints */ 1375 if (vcf[idx] != EP_NOP 1376 && vcf[idx] != EP_NUL) { 1377 switch (attr) { 1378 case USB_ENDPOINT_XFER_INT: 1379 context-> 1380 fifos[cidx]. 1381 pipe = 1382 usb_rcvintpipe 1383 (dev, 1384 ep->desc. 1385 bEndpointAddress); 1386 context-> 1387 fifos[cidx]. 1388 usb_transfer_mode 1389 = USB_INT; 1390 packet_size = 1391 le16_to_cpu(ep->desc.wMaxPacketSize); 1392 break; 1393 case USB_ENDPOINT_XFER_BULK: 1394 if (ep_addr & 0x80) 1395 context-> 1396 fifos 1397 [cidx]. 1398 pipe = 1399 usb_rcvbulkpipe 1400 (dev, 1401 ep-> 1402 desc. 1403 bEndpointAddress); 1404 else 1405 context-> 1406 fifos 1407 [cidx]. 1408 pipe = 1409 usb_sndbulkpipe 1410 (dev, 1411 ep-> 1412 desc. 1413 bEndpointAddress); 1414 context-> 1415 fifos[cidx]. 1416 usb_transfer_mode 1417 = USB_BULK; 1418 packet_size = 1419 le16_to_cpu(ep->desc.wMaxPacketSize); 1420 break; 1421 case USB_ENDPOINT_XFER_ISOC: 1422 if (ep_addr & 0x80) 1423 context-> 1424 fifos 1425 [cidx]. 1426 pipe = 1427 usb_rcvisocpipe 1428 (dev, 1429 ep-> 1430 desc. 1431 bEndpointAddress); 1432 else 1433 context-> 1434 fifos 1435 [cidx]. 1436 pipe = 1437 usb_sndisocpipe 1438 (dev, 1439 ep-> 1440 desc. 1441 bEndpointAddress); 1442 context-> 1443 fifos[cidx]. 1444 usb_transfer_mode 1445 = USB_ISOC; 1446 iso_packet_size = 1447 le16_to_cpu(ep->desc.wMaxPacketSize); 1448 break; 1449 default: 1450 context-> 1451 fifos[cidx]. 1452 pipe = 0; 1453 } /* switch attribute */ 1454 1455 if (context->fifos[cidx].pipe) { 1456 context->fifos[cidx]. 1457 fifonum = cidx; 1458 context->fifos[cidx].hfc = 1459 context; 1460 context->fifos[cidx].usb_packet_maxlen = 1461 le16_to_cpu(ep->desc.wMaxPacketSize); 1462 context->fifos[cidx]. 1463 intervall = 1464 ep->desc.bInterval; 1465 context->fifos[cidx]. 1466 skbuff = NULL; 1467 } 1468 } 1469 ep++; 1470 } 1471 context->dev = dev; /* save device */ 1472 context->if_used = ifnum; /* save used interface */ 1473 context->alt_used = alt_used; /* and alternate config */ 1474 context->ctrl_paksize = dev->descriptor.bMaxPacketSize0; /* control size */ 1475 context->cfg_used = vcf[16]; /* store used config */ 1476 context->vend_idx = vend_idx; /* store found vendor */ 1477 context->packet_size = packet_size; 1478 context->iso_packet_size = iso_packet_size; 1479 1480 /* create the control pipes needed for register access */ 1481 context->ctrl_in_pipe = 1482 usb_rcvctrlpipe(context->dev, 0); 1483 context->ctrl_out_pipe = 1484 usb_sndctrlpipe(context->dev, 0); 1485 1486 driver_info = (hfcsusb_vdata *) 1487 hfcusb_idtab[vend_idx].driver_info; 1488 1489 context->ctrl_urb = usb_alloc_urb(0, GFP_KERNEL); 1490 1491 if (!context->ctrl_urb) { 1492 pr_warn("%s: No memory for control urb\n", 1493 driver_info->vend_name); 1494 kfree(context); 1495 return -ENOMEM; 1496 } 1497 1498 pr_info("HFC-S USB: detected \"%s\"\n", 1499 driver_info->vend_name); 1500 1501 DBG(HFCUSB_DBG_INIT, 1502 "HFC-S USB: Endpoint-Config: %s (if=%d alt=%d), E-Channel(%d)", 1503 conf_str[small_match], context->if_used, 1504 context->alt_used, 1505 validconf[small_match][18]); 1506 1507 /* init the chip and register the driver */ 1508 if (hfc_usb_init(context)) { 1509 usb_kill_urb(context->ctrl_urb); 1510 usb_free_urb(context->ctrl_urb); 1511 context->ctrl_urb = NULL; 1512 kfree(context); 1513 return (-EIO); 1514 } 1515 usb_set_intfdata(intf, context); 1516 return (0); 1517 } 1518 } else { 1519 printk(KERN_INFO 1520 "HFC-S USB: no valid vendor found in USB descriptor\n"); 1521 } 1522 return (-EIO); 1523} 1524 1525/* callback for unplugged USB device */ 1526static void 1527hfc_usb_disconnect(struct usb_interface *intf) 1528{ 1529 hfcusb_data *context = usb_get_intfdata(intf); 1530 int i; 1531 1532 handle_led(context, LED_POWER_OFF); 1533 schedule_timeout(HZ / 100); 1534 1535 printk(KERN_INFO "HFC-S USB: device disconnect\n"); 1536 context->disc_flag = 1; 1537 usb_set_intfdata(intf, NULL); 1538 1539 if (timer_pending(&context->t3_timer)) 1540 del_timer(&context->t3_timer); 1541 if (timer_pending(&context->t4_timer)) 1542 del_timer(&context->t4_timer); 1543 1544 /* tell all fifos to terminate */ 1545 for (i = 0; i < HFCUSB_NUM_FIFOS; i++) { 1546 if (context->fifos[i].usb_transfer_mode == USB_ISOC) { 1547 if (context->fifos[i].active > 0) { 1548 stop_isoc_chain(&context->fifos[i]); 1549 DBG(HFCUSB_DBG_INIT, 1550 "HFC-S USB: %s stopping ISOC chain Fifo(%i)", 1551 __func__, i); 1552 } 1553 } else { 1554 if (context->fifos[i].active > 0) { 1555 context->fifos[i].active = 0; 1556 DBG(HFCUSB_DBG_INIT, 1557 "HFC-S USB: %s unlinking URB for Fifo(%i)", 1558 __func__, i); 1559 } 1560 usb_kill_urb(context->fifos[i].urb); 1561 usb_free_urb(context->fifos[i].urb); 1562 context->fifos[i].urb = NULL; 1563 } 1564 context->fifos[i].active = 0; 1565 } 1566 usb_kill_urb(context->ctrl_urb); 1567 usb_free_urb(context->ctrl_urb); 1568 context->ctrl_urb = NULL; 1569 hisax_unregister(&context->d_if); 1570 kfree(context); /* free our structure again */ 1571} 1572 1573static struct usb_driver hfc_drv = { 1574 .name = "hfc_usb", 1575 .id_table = hfcusb_idtab, 1576 .probe = hfc_usb_probe, 1577 .disconnect = hfc_usb_disconnect, 1578 .disable_hub_initiated_lpm = 1, 1579}; 1580 1581static void __exit 1582hfc_usb_mod_exit(void) 1583{ 1584 usb_deregister(&hfc_drv); /* release our driver */ 1585 printk(KERN_INFO "HFC-S USB: module removed\n"); 1586} 1587 1588static int __init 1589hfc_usb_mod_init(void) 1590{ 1591 char revstr[30], datestr[30], dummy[30]; 1592#ifndef CONFIG_HISAX_DEBUG 1593 hfc_debug = debug; 1594#endif 1595 sscanf(hfcusb_revision, 1596 "%s %s $ %s %s %s $ ", dummy, revstr, 1597 dummy, datestr, dummy); 1598 printk(KERN_INFO 1599 "HFC-S USB: driver module revision %s date %s loaded, (debug=%i)\n", 1600 revstr, datestr, debug); 1601 if (usb_register(&hfc_drv)) { 1602 printk(KERN_INFO 1603 "HFC-S USB: Unable to register HFC-S USB module at usb stack\n"); 1604 return (-1); /* unable to register */ 1605 } 1606 return (0); 1607} 1608 1609module_init(hfc_usb_mod_init); 1610module_exit(hfc_usb_mod_exit); 1611MODULE_AUTHOR(DRIVER_AUTHOR); 1612MODULE_DESCRIPTION(DRIVER_DESC); 1613MODULE_LICENSE("GPL"); 1614MODULE_DEVICE_TABLE(usb, hfcusb_idtab); 1615