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