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 931 "HFC-S USB: submit URB error(start_int_info): status:%i\n", 932 errcode); 933 fifo->active = 0; 934 fifo->skbuff = NULL; 935 } 936} 937 938static void 939setup_bchannel(hfcusb_data *hfc, int channel, int mode) 940{ 941 __u8 val, idx_table[2] = { 0, 2 }; 942 943 if (hfc->disc_flag) { 944 return; 945 } 946 DBG(HFCUSB_DBG_STATES, "HFC-S USB: setting channel %d to mode %d", 947 channel, mode); 948 hfc->b_mode[channel] = mode; 949 950 /* setup CON_HDLC */ 951 val = 0; 952 if (mode != L1_MODE_NULL) 953 val = 8; /* enable fifo? */ 954 if (mode == L1_MODE_TRANS) 955 val |= 2; /* set transparent bit */ 956 957 /* set FIFO to transmit register */ 958 queue_control_request(hfc, HFCUSB_FIFO, idx_table[channel], 1); 959 queue_control_request(hfc, HFCUSB_CON_HDLC, val, 1); 960 /* reset fifo */ 961 queue_control_request(hfc, HFCUSB_INC_RES_F, 2, 1); 962 /* set FIFO to receive register */ 963 queue_control_request(hfc, HFCUSB_FIFO, idx_table[channel] + 1, 1); 964 queue_control_request(hfc, HFCUSB_CON_HDLC, val, 1); 965 /* reset fifo */ 966 queue_control_request(hfc, HFCUSB_INC_RES_F, 2, 1); 967 968 val = 0x40; 969 if (hfc->b_mode[0]) 970 val |= 1; 971 if (hfc->b_mode[1]) 972 val |= 2; 973 queue_control_request(hfc, HFCUSB_SCTRL, val, 1); 974 975 val = 0; 976 if (hfc->b_mode[0]) 977 val |= 1; 978 if (hfc->b_mode[1]) 979 val |= 2; 980 queue_control_request(hfc, HFCUSB_SCTRL_R, val, 1); 981 982 if (mode == L1_MODE_NULL) { 983 if (channel) 984 handle_led(hfc, LED_B2_OFF); 985 else 986 handle_led(hfc, LED_B1_OFF); 987 } else { 988 if (channel) 989 handle_led(hfc, LED_B2_ON); 990 else 991 handle_led(hfc, LED_B1_ON); 992 } 993} 994 995static void 996hfc_usb_l2l1(struct hisax_if *my_hisax_if, int pr, void *arg) 997{ 998 usb_fifo *fifo = my_hisax_if->priv; 999 hfcusb_data *hfc = fifo->hfc; 1000 1001 switch (pr) { 1002 case PH_ACTIVATE | REQUEST: 1003 if (fifo->fifonum == HFCUSB_D_TX) { 1004 DBG(HFCUSB_DBG_STATES, 1005 "HFC_USB: hfc_usb_d_l2l1 D-chan: PH_ACTIVATE | REQUEST"); 1006 1007 if (hfc->l1_state != 3 1008 && hfc->l1_state != 7) { 1009 hfc->d_if.ifc.l1l2(&hfc->d_if.ifc, 1010 PH_DEACTIVATE | 1011 INDICATION, 1012 NULL); 1013 DBG(HFCUSB_DBG_STATES, 1014 "HFC-S USB: PH_DEACTIVATE | INDICATION sent (not state 3 or 7)"); 1015 } else { 1016 if (hfc->l1_state == 7) { /* l1 already active */ 1017 hfc->d_if.ifc.l1l2(&hfc-> 1018 d_if. 1019 ifc, 1020 PH_ACTIVATE 1021 | 1022 INDICATION, 1023 NULL); 1024 DBG(HFCUSB_DBG_STATES, 1025 "HFC-S USB: PH_ACTIVATE | INDICATION sent again ;)"); 1026 } else { 1027 /* force sending sending INFO1 */ 1028 queue_control_request(hfc, 1029 HFCUSB_STATES, 1030 0x14, 1031 1); 1032 mdelay(1); 1033 /* start l1 activation */ 1034 queue_control_request(hfc, 1035 HFCUSB_STATES, 1036 0x04, 1037 1); 1038 if (!timer_pending 1039 (&hfc->t3_timer)) { 1040 hfc->t3_timer. 1041 expires = 1042 jiffies + 1043 (HFC_TIMER_T3 * 1044 HZ) / 1000; 1045 add_timer(&hfc-> 1046 t3_timer); 1047 } 1048 } 1049 } 1050 } else { 1051 DBG(HFCUSB_DBG_STATES, 1052 "HFC_USB: hfc_usb_d_l2l1 B-chan: PH_ACTIVATE | REQUEST"); 1053 setup_bchannel(hfc, 1054 (fifo->fifonum == 1055 HFCUSB_B1_TX) ? 0 : 1, 1056 (long) arg); 1057 fifo->hif->l1l2(fifo->hif, 1058 PH_ACTIVATE | INDICATION, 1059 NULL); 1060 } 1061 break; 1062 case PH_DEACTIVATE | REQUEST: 1063 if (fifo->fifonum == HFCUSB_D_TX) { 1064 DBG(HFCUSB_DBG_STATES, 1065 "HFC_USB: hfc_usb_d_l2l1 D-chan: PH_DEACTIVATE | REQUEST"); 1066 } else { 1067 DBG(HFCUSB_DBG_STATES, 1068 "HFC_USB: hfc_usb_d_l2l1 Bx-chan: PH_DEACTIVATE | REQUEST"); 1069 setup_bchannel(hfc, 1070 (fifo->fifonum == 1071 HFCUSB_B1_TX) ? 0 : 1, 1072 (int) L1_MODE_NULL); 1073 fifo->hif->l1l2(fifo->hif, 1074 PH_DEACTIVATE | INDICATION, 1075 NULL); 1076 } 1077 break; 1078 case PH_DATA | REQUEST: 1079 if (fifo->skbuff && fifo->delete_flg) { 1080 dev_kfree_skb_any(fifo->skbuff); 1081 fifo->skbuff = NULL; 1082 fifo->delete_flg = 0; 1083 } 1084 fifo->skbuff = arg; /* we have a new buffer */ 1085 break; 1086 default: 1087 DBG(HFCUSB_DBG_STATES, 1088 "HFC_USB: hfc_usb_d_l2l1: unknown state : %#x", pr); 1089 break; 1090 } 1091} 1092 1093/* initial init HFC-S USB chip registers, HiSax interface, USB URBs */ 1094static int 1095hfc_usb_init(hfcusb_data *hfc) 1096{ 1097 usb_fifo *fifo; 1098 int i; 1099 u_char b; 1100 struct hisax_b_if *p_b_if[2]; 1101 1102 /* check the chip id */ 1103 if (read_usb(hfc, HFCUSB_CHIP_ID, &b) != 1) { 1104 printk(KERN_INFO "HFC-USB: cannot read chip id\n"); 1105 return (1); 1106 } 1107 if (b != HFCUSB_CHIPID) { 1108 printk(KERN_INFO "HFC-S USB: Invalid chip id 0x%02x\n", b); 1109 return (1); 1110 } 1111 1112 /* first set the needed config, interface and alternate */ 1113 usb_set_interface(hfc->dev, hfc->if_used, hfc->alt_used); 1114 1115 /* do Chip reset */ 1116 write_usb(hfc, HFCUSB_CIRM, 8); 1117 /* aux = output, reset off */ 1118 write_usb(hfc, HFCUSB_CIRM, 0x10); 1119 1120 /* set USB_SIZE to match wMaxPacketSize for INT or BULK transfers */ 1121 write_usb(hfc, HFCUSB_USB_SIZE, 1122 (hfc->packet_size / 8) | ((hfc->packet_size / 8) << 4)); 1123 1124 /* set USB_SIZE_I to match wMaxPacketSize for ISO transfers */ 1125 write_usb(hfc, HFCUSB_USB_SIZE_I, hfc->iso_packet_size); 1126 1127 /* enable PCM/GCI master mode */ 1128 write_usb(hfc, HFCUSB_MST_MODE1, 0); /* set default values */ 1129 write_usb(hfc, HFCUSB_MST_MODE0, 1); /* enable master mode */ 1130 1131 /* init the fifos */ 1132 write_usb(hfc, HFCUSB_F_THRES, 1133 (HFCUSB_TX_THRESHOLD / 1134 8) | ((HFCUSB_RX_THRESHOLD / 8) << 4)); 1135 1136 fifo = hfc->fifos; 1137 for (i = 0; i < HFCUSB_NUM_FIFOS; i++) { 1138 write_usb(hfc, HFCUSB_FIFO, i); /* select the desired fifo */ 1139 fifo[i].skbuff = NULL; /* init buffer pointer */ 1140 fifo[i].max_size = 1141 (i <= HFCUSB_B2_RX) ? MAX_BCH_SIZE : MAX_DFRAME_LEN; 1142 fifo[i].last_urblen = 0; 1143 /* set 2 bit for D- & E-channel */ 1144 write_usb(hfc, HFCUSB_HDLC_PAR, 1145 ((i <= HFCUSB_B2_RX) ? 0 : 2)); 1146 /* rx hdlc, enable IFF for D-channel */ 1147 write_usb(hfc, HFCUSB_CON_HDLC, 1148 ((i == HFCUSB_D_TX) ? 0x09 : 0x08)); 1149 write_usb(hfc, HFCUSB_INC_RES_F, 2); /* reset the fifo */ 1150 } 1151 1152 write_usb(hfc, HFCUSB_CLKDEL, 0x0f); /* clock delay value */ 1153 write_usb(hfc, HFCUSB_STATES, 3 | 0x10); /* set deactivated mode */ 1154 write_usb(hfc, HFCUSB_STATES, 3); /* enable state machine */ 1155 1156 write_usb(hfc, HFCUSB_SCTRL_R, 0); /* disable both B receivers */ 1157 write_usb(hfc, HFCUSB_SCTRL, 0x40); /* disable B transmitters + capacitive mode */ 1158 1159 /* set both B-channel to not connected */ 1160 hfc->b_mode[0] = L1_MODE_NULL; 1161 hfc->b_mode[1] = L1_MODE_NULL; 1162 1163 hfc->l1_activated = 0; 1164 hfc->disc_flag = 0; 1165 hfc->led_state = 0; 1166 hfc->old_led_state = 0; 1167 1168 /* init the t3 timer */ 1169 init_timer(&hfc->t3_timer); 1170 hfc->t3_timer.data = (long) hfc; 1171 hfc->t3_timer.function = (void *) l1_timer_expire_t3; 1172 1173 /* init the t4 timer */ 1174 init_timer(&hfc->t4_timer); 1175 hfc->t4_timer.data = (long) hfc; 1176 hfc->t4_timer.function = (void *) l1_timer_expire_t4; 1177 1178 /* init the background machinery for control requests */ 1179 hfc->ctrl_read.bRequestType = 0xc0; 1180 hfc->ctrl_read.bRequest = 1; 1181 hfc->ctrl_read.wLength = cpu_to_le16(1); 1182 hfc->ctrl_write.bRequestType = 0x40; 1183 hfc->ctrl_write.bRequest = 0; 1184 hfc->ctrl_write.wLength = 0; 1185 usb_fill_control_urb(hfc->ctrl_urb, 1186 hfc->dev, 1187 hfc->ctrl_out_pipe, 1188 (u_char *)&hfc->ctrl_write, 1189 NULL, 0, ctrl_complete, hfc); 1190 /* Init All Fifos */ 1191 for (i = 0; i < HFCUSB_NUM_FIFOS; i++) { 1192 hfc->fifos[i].iso[0].purb = NULL; 1193 hfc->fifos[i].iso[1].purb = NULL; 1194 hfc->fifos[i].active = 0; 1195 } 1196 /* register Modul to upper Hisax Layers */ 1197 hfc->d_if.owner = THIS_MODULE; 1198 hfc->d_if.ifc.priv = &hfc->fifos[HFCUSB_D_TX]; 1199 hfc->d_if.ifc.l2l1 = hfc_usb_l2l1; 1200 for (i = 0; i < 2; i++) { 1201 hfc->b_if[i].ifc.priv = &hfc->fifos[HFCUSB_B1_TX + i * 2]; 1202 hfc->b_if[i].ifc.l2l1 = hfc_usb_l2l1; 1203 p_b_if[i] = &hfc->b_if[i]; 1204 } 1205 /* default Prot: EURO ISDN, should be a module_param */ 1206 hfc->protocol = 2; 1207 i = hisax_register(&hfc->d_if, p_b_if, "hfc_usb", hfc->protocol); 1208 if (i) { 1209 printk(KERN_INFO "HFC-S USB: hisax_register -> %d\n", i); 1210 return i; 1211 } 1212 1213#ifdef CONFIG_HISAX_DEBUG 1214 hfc_debug = debug; 1215#endif 1216 1217 for (i = 0; i < 4; i++) 1218 hfc->fifos[i].hif = &p_b_if[i / 2]->ifc; 1219 for (i = 4; i < 8; i++) 1220 hfc->fifos[i].hif = &hfc->d_if.ifc; 1221 1222 /* 3 (+1) INT IN + 3 ISO OUT */ 1223 if (hfc->cfg_used == CNF_3INT3ISO || hfc->cfg_used == CNF_4INT3ISO) { 1224 start_int_fifo(hfc->fifos + HFCUSB_D_RX); 1225 if (hfc->fifos[HFCUSB_PCM_RX].pipe) 1226 start_int_fifo(hfc->fifos + HFCUSB_PCM_RX); 1227 start_int_fifo(hfc->fifos + HFCUSB_B1_RX); 1228 start_int_fifo(hfc->fifos + HFCUSB_B2_RX); 1229 } 1230 /* 3 (+1) ISO IN + 3 ISO OUT */ 1231 if (hfc->cfg_used == CNF_3ISO3ISO || hfc->cfg_used == CNF_4ISO3ISO) { 1232 start_isoc_chain(hfc->fifos + HFCUSB_D_RX, ISOC_PACKETS_D, 1233 rx_iso_complete, 16); 1234 if (hfc->fifos[HFCUSB_PCM_RX].pipe) 1235 start_isoc_chain(hfc->fifos + HFCUSB_PCM_RX, 1236 ISOC_PACKETS_D, rx_iso_complete, 1237 16); 1238 start_isoc_chain(hfc->fifos + HFCUSB_B1_RX, ISOC_PACKETS_B, 1239 rx_iso_complete, 16); 1240 start_isoc_chain(hfc->fifos + HFCUSB_B2_RX, ISOC_PACKETS_B, 1241 rx_iso_complete, 16); 1242 } 1243 1244 start_isoc_chain(hfc->fifos + HFCUSB_D_TX, ISOC_PACKETS_D, 1245 tx_iso_complete, 1); 1246 start_isoc_chain(hfc->fifos + HFCUSB_B1_TX, ISOC_PACKETS_B, 1247 tx_iso_complete, 1); 1248 start_isoc_chain(hfc->fifos + HFCUSB_B2_TX, ISOC_PACKETS_B, 1249 tx_iso_complete, 1); 1250 1251 handle_led(hfc, LED_POWER_ON); 1252 1253 return (0); 1254} 1255 1256/* initial callback for each plugged USB device */ 1257static int 1258hfc_usb_probe(struct usb_interface *intf, const struct usb_device_id *id) 1259{ 1260 struct usb_device *dev = interface_to_usbdev(intf); 1261 hfcusb_data *context; 1262 struct usb_host_interface *iface = intf->cur_altsetting; 1263 struct usb_host_interface *iface_used = NULL; 1264 struct usb_host_endpoint *ep; 1265 int ifnum = iface->desc.bInterfaceNumber; 1266 int i, idx, alt_idx, probe_alt_setting, vend_idx, cfg_used, *vcf, 1267 attr, cfg_found, cidx, ep_addr; 1268 int cmptbl[16], small_match, iso_packet_size, packet_size, 1269 alt_used = 0; 1270 hfcsusb_vdata *driver_info; 1271 1272 vend_idx = 0xffff; 1273 for (i = 0; hfcusb_idtab[i].idVendor; i++) { 1274 if ((le16_to_cpu(dev->descriptor.idVendor) == hfcusb_idtab[i].idVendor) 1275 && (le16_to_cpu(dev->descriptor.idProduct) == hfcusb_idtab[i].idProduct)) { 1276 vend_idx = i; 1277 continue; 1278 } 1279 } 1280 1281 printk(KERN_INFO 1282 "HFC-S USB: probing interface(%d) actalt(%d) minor(%d)\n", 1283 ifnum, iface->desc.bAlternateSetting, intf->minor); 1284 1285 if (vend_idx != 0xffff) { 1286 /* if vendor and product ID is OK, start probing alternate settings */ 1287 alt_idx = 0; 1288 small_match = 0xffff; 1289 1290 /* default settings */ 1291 iso_packet_size = 16; 1292 packet_size = 64; 1293 1294 while (alt_idx < intf->num_altsetting) { 1295 iface = intf->altsetting + alt_idx; 1296 probe_alt_setting = iface->desc.bAlternateSetting; 1297 cfg_used = 0; 1298 1299 /* check for config EOL element */ 1300 while (validconf[cfg_used][0]) { 1301 cfg_found = 1; 1302 vcf = validconf[cfg_used]; 1303 /* first endpoint descriptor */ 1304 ep = iface->endpoint; 1305 1306 memcpy(cmptbl, vcf, 16 * sizeof(int)); 1307 1308 /* check for all endpoints in this alternate setting */ 1309 for (i = 0; i < iface->desc.bNumEndpoints; 1310 i++) { 1311 ep_addr = 1312 ep->desc.bEndpointAddress; 1313 /* get endpoint base */ 1314 idx = ((ep_addr & 0x7f) - 1) * 2; 1315 if (ep_addr & 0x80) 1316 idx++; 1317 attr = ep->desc.bmAttributes; 1318 if (cmptbl[idx] == EP_NUL) { 1319 cfg_found = 0; 1320 } 1321 if (attr == USB_ENDPOINT_XFER_INT 1322 && cmptbl[idx] == EP_INT) 1323 cmptbl[idx] = EP_NUL; 1324 if (attr == USB_ENDPOINT_XFER_BULK 1325 && cmptbl[idx] == EP_BLK) 1326 cmptbl[idx] = EP_NUL; 1327 if (attr == USB_ENDPOINT_XFER_ISOC 1328 && cmptbl[idx] == EP_ISO) 1329 cmptbl[idx] = EP_NUL; 1330 1331 /* check if all INT endpoints match minimum interval */ 1332 if ((attr == USB_ENDPOINT_XFER_INT) 1333 && (ep->desc.bInterval < vcf[17])) { 1334 cfg_found = 0; 1335 } 1336 ep++; 1337 } 1338 for (i = 0; i < 16; i++) { 1339 /* all entries must be EP_NOP or EP_NUL for a valid config */ 1340 if (cmptbl[i] != EP_NOP 1341 && cmptbl[i] != EP_NUL) 1342 cfg_found = 0; 1343 } 1344 if (cfg_found) { 1345 if (cfg_used < small_match) { 1346 small_match = cfg_used; 1347 alt_used = 1348 probe_alt_setting; 1349 iface_used = iface; 1350 } 1351 } 1352 cfg_used++; 1353 } 1354 alt_idx++; 1355 } /* (alt_idx < intf->num_altsetting) */ 1356 1357 /* found a valid USB Ta Endpint config */ 1358 if (small_match != 0xffff) { 1359 iface = iface_used; 1360 if (!(context = kzalloc(sizeof(hfcusb_data), GFP_KERNEL))) 1361 return (-ENOMEM); /* got no mem */ 1362 1363 ep = iface->endpoint; 1364 vcf = validconf[small_match]; 1365 1366 for (i = 0; i < iface->desc.bNumEndpoints; i++) { 1367 ep_addr = ep->desc.bEndpointAddress; 1368 /* get endpoint base */ 1369 idx = ((ep_addr & 0x7f) - 1) * 2; 1370 if (ep_addr & 0x80) 1371 idx++; 1372 cidx = idx & 7; 1373 attr = ep->desc.bmAttributes; 1374 1375 /* init Endpoints */ 1376 if (vcf[idx] != EP_NOP 1377 && vcf[idx] != EP_NUL) { 1378 switch (attr) { 1379 case USB_ENDPOINT_XFER_INT: 1380 context-> 1381 fifos[cidx]. 1382 pipe = 1383 usb_rcvintpipe 1384 (dev, 1385 ep->desc. 1386 bEndpointAddress); 1387 context-> 1388 fifos[cidx]. 1389 usb_transfer_mode 1390 = USB_INT; 1391 packet_size = 1392 le16_to_cpu(ep->desc.wMaxPacketSize); 1393 break; 1394 case USB_ENDPOINT_XFER_BULK: 1395 if (ep_addr & 0x80) 1396 context-> 1397 fifos 1398 [cidx]. 1399 pipe = 1400 usb_rcvbulkpipe 1401 (dev, 1402 ep-> 1403 desc. 1404 bEndpointAddress); 1405 else 1406 context-> 1407 fifos 1408 [cidx]. 1409 pipe = 1410 usb_sndbulkpipe 1411 (dev, 1412 ep-> 1413 desc. 1414 bEndpointAddress); 1415 context-> 1416 fifos[cidx]. 1417 usb_transfer_mode 1418 = USB_BULK; 1419 packet_size = 1420 le16_to_cpu(ep->desc.wMaxPacketSize); 1421 break; 1422 case USB_ENDPOINT_XFER_ISOC: 1423 if (ep_addr & 0x80) 1424 context-> 1425 fifos 1426 [cidx]. 1427 pipe = 1428 usb_rcvisocpipe 1429 (dev, 1430 ep-> 1431 desc. 1432 bEndpointAddress); 1433 else 1434 context-> 1435 fifos 1436 [cidx]. 1437 pipe = 1438 usb_sndisocpipe 1439 (dev, 1440 ep-> 1441 desc. 1442 bEndpointAddress); 1443 context-> 1444 fifos[cidx]. 1445 usb_transfer_mode 1446 = USB_ISOC; 1447 iso_packet_size = 1448 le16_to_cpu(ep->desc.wMaxPacketSize); 1449 break; 1450 default: 1451 context-> 1452 fifos[cidx]. 1453 pipe = 0; 1454 } /* switch attribute */ 1455 1456 if (context->fifos[cidx].pipe) { 1457 context->fifos[cidx]. 1458 fifonum = cidx; 1459 context->fifos[cidx].hfc = 1460 context; 1461 context->fifos[cidx].usb_packet_maxlen = 1462 le16_to_cpu(ep->desc.wMaxPacketSize); 1463 context->fifos[cidx]. 1464 intervall = 1465 ep->desc.bInterval; 1466 context->fifos[cidx]. 1467 skbuff = NULL; 1468 } 1469 } 1470 ep++; 1471 } 1472 context->dev = dev; /* save device */ 1473 context->if_used = ifnum; /* save used interface */ 1474 context->alt_used = alt_used; /* and alternate config */ 1475 context->ctrl_paksize = dev->descriptor.bMaxPacketSize0; /* control size */ 1476 context->cfg_used = vcf[16]; /* store used config */ 1477 context->vend_idx = vend_idx; /* store found vendor */ 1478 context->packet_size = packet_size; 1479 context->iso_packet_size = iso_packet_size; 1480 1481 /* create the control pipes needed for register access */ 1482 context->ctrl_in_pipe = 1483 usb_rcvctrlpipe(context->dev, 0); 1484 context->ctrl_out_pipe = 1485 usb_sndctrlpipe(context->dev, 0); 1486 context->ctrl_urb = usb_alloc_urb(0, GFP_KERNEL); 1487 1488 driver_info = 1489 (hfcsusb_vdata *) hfcusb_idtab[vend_idx]. 1490 driver_info; 1491 printk(KERN_INFO "HFC-S USB: detected \"%s\"\n", 1492 driver_info->vend_name); 1493 1494 DBG(HFCUSB_DBG_INIT, 1495 "HFC-S USB: Endpoint-Config: %s (if=%d alt=%d), E-Channel(%d)", 1496 conf_str[small_match], context->if_used, 1497 context->alt_used, 1498 validconf[small_match][18]); 1499 1500 /* init the chip and register the driver */ 1501 if (hfc_usb_init(context)) { 1502 usb_kill_urb(context->ctrl_urb); 1503 usb_free_urb(context->ctrl_urb); 1504 context->ctrl_urb = NULL; 1505 kfree(context); 1506 return (-EIO); 1507 } 1508 usb_set_intfdata(intf, context); 1509 return (0); 1510 } 1511 } else { 1512 printk(KERN_INFO 1513 "HFC-S USB: no valid vendor found in USB descriptor\n"); 1514 } 1515 return (-EIO); 1516} 1517 1518/* callback for unplugged USB device */ 1519static void 1520hfc_usb_disconnect(struct usb_interface *intf) 1521{ 1522 hfcusb_data *context = usb_get_intfdata(intf); 1523 int i; 1524 1525 handle_led(context, LED_POWER_OFF); 1526 schedule_timeout(HZ / 100); 1527 1528 printk(KERN_INFO "HFC-S USB: device disconnect\n"); 1529 context->disc_flag = 1; 1530 usb_set_intfdata(intf, NULL); 1531 1532 if (timer_pending(&context->t3_timer)) 1533 del_timer(&context->t3_timer); 1534 if (timer_pending(&context->t4_timer)) 1535 del_timer(&context->t4_timer); 1536 1537 /* tell all fifos to terminate */ 1538 for (i = 0; i < HFCUSB_NUM_FIFOS; i++) { 1539 if (context->fifos[i].usb_transfer_mode == USB_ISOC) { 1540 if (context->fifos[i].active > 0) { 1541 stop_isoc_chain(&context->fifos[i]); 1542 DBG(HFCUSB_DBG_INIT, 1543 "HFC-S USB: %s stopping ISOC chain Fifo(%i)", 1544 __func__, i); 1545 } 1546 } else { 1547 if (context->fifos[i].active > 0) { 1548 context->fifos[i].active = 0; 1549 DBG(HFCUSB_DBG_INIT, 1550 "HFC-S USB: %s unlinking URB for Fifo(%i)", 1551 __func__, i); 1552 } 1553 usb_kill_urb(context->fifos[i].urb); 1554 usb_free_urb(context->fifos[i].urb); 1555 context->fifos[i].urb = NULL; 1556 } 1557 context->fifos[i].active = 0; 1558 } 1559 usb_kill_urb(context->ctrl_urb); 1560 usb_free_urb(context->ctrl_urb); 1561 context->ctrl_urb = NULL; 1562 hisax_unregister(&context->d_if); 1563 kfree(context); /* free our structure again */ 1564} 1565 1566static struct usb_driver hfc_drv = { 1567 .name = "hfc_usb", 1568 .id_table = hfcusb_idtab, 1569 .probe = hfc_usb_probe, 1570 .disconnect = hfc_usb_disconnect, 1571}; 1572 1573static void __exit 1574hfc_usb_mod_exit(void) 1575{ 1576 usb_deregister(&hfc_drv); /* release our driver */ 1577 printk(KERN_INFO "HFC-S USB: module removed\n"); 1578} 1579 1580static int __init 1581hfc_usb_mod_init(void) 1582{ 1583 char revstr[30], datestr[30], dummy[30]; 1584#ifndef CONFIG_HISAX_DEBUG 1585 hfc_debug = debug; 1586#endif 1587 sscanf(hfcusb_revision, 1588 "%s %s $ %s %s %s $ ", dummy, revstr, 1589 dummy, datestr, dummy); 1590 printk(KERN_INFO 1591 "HFC-S USB: driver module revision %s date %s loaded, (debug=%i)\n", 1592 revstr, datestr, debug); 1593 if (usb_register(&hfc_drv)) { 1594 printk(KERN_INFO 1595 "HFC-S USB: Unable to register HFC-S USB module at usb stack\n"); 1596 return (-1); /* unable to register */ 1597 } 1598 return (0); 1599} 1600 1601module_init(hfc_usb_mod_init); 1602module_exit(hfc_usb_mod_exit); 1603MODULE_AUTHOR(DRIVER_AUTHOR); 1604MODULE_DESCRIPTION(DRIVER_DESC); 1605MODULE_LICENSE("GPL"); 1606MODULE_DEVICE_TABLE(usb, hfcusb_idtab); 1607