1 /* hfcsusb.c 2 * mISDN driver for Colognechip HFC-S USB chip 3 * 4 * Copyright 2001 by Peter Sprenger (sprenger@moving-bytes.de) 5 * Copyright 2008 by Martin Bachem (info@bachem-it.com) 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2, or (at your option) 10 * any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * 21 * 22 * module params 23 * debug=<n>, default=0, with n=0xHHHHGGGG 24 * H - l1 driver flags described in hfcsusb.h 25 * G - common mISDN debug flags described at mISDNhw.h 26 * 27 * poll=<n>, default 128 28 * n : burst size of PH_DATA_IND at transparent rx data 29 * 30 * Revision: 0.3.3 (socket), 2008-11-05 31 */ 32 33 #include <linux/module.h> 34 #include <linux/delay.h> 35 #include <linux/usb.h> 36 #include <linux/mISDNhw.h> 37 #include <linux/slab.h> 38 #include "hfcsusb.h" 39 40 static unsigned int debug; 41 static int poll = DEFAULT_TRANSP_BURST_SZ; 42 43 static LIST_HEAD(HFClist); 44 static DEFINE_RWLOCK(HFClock); 45 46 47 MODULE_AUTHOR("Martin Bachem"); 48 MODULE_LICENSE("GPL"); 49 module_param(debug, uint, S_IRUGO | S_IWUSR); 50 module_param(poll, int, 0); 51 52 static int hfcsusb_cnt; 53 54 /* some function prototypes */ 55 static void hfcsusb_ph_command(struct hfcsusb *hw, u_char command); 56 static void release_hw(struct hfcsusb *hw); 57 static void reset_hfcsusb(struct hfcsusb *hw); 58 static void setPortMode(struct hfcsusb *hw); 59 static void hfcsusb_start_endpoint(struct hfcsusb *hw, int channel); 60 static void hfcsusb_stop_endpoint(struct hfcsusb *hw, int channel); 61 static int hfcsusb_setup_bch(struct bchannel *bch, int protocol); 62 static void deactivate_bchannel(struct bchannel *bch); 63 static void hfcsusb_ph_info(struct hfcsusb *hw); 64 65 /* start next background transfer for control channel */ 66 static void 67 ctrl_start_transfer(struct hfcsusb *hw) 68 { 69 if (debug & DBG_HFC_CALL_TRACE) 70 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__); 71 72 if (hw->ctrl_cnt) { 73 hw->ctrl_urb->pipe = hw->ctrl_out_pipe; 74 hw->ctrl_urb->setup_packet = (u_char *)&hw->ctrl_write; 75 hw->ctrl_urb->transfer_buffer = NULL; 76 hw->ctrl_urb->transfer_buffer_length = 0; 77 hw->ctrl_write.wIndex = 78 cpu_to_le16(hw->ctrl_buff[hw->ctrl_out_idx].hfcs_reg); 79 hw->ctrl_write.wValue = 80 cpu_to_le16(hw->ctrl_buff[hw->ctrl_out_idx].reg_val); 81 82 usb_submit_urb(hw->ctrl_urb, GFP_ATOMIC); 83 } 84 } 85 86 /* 87 * queue a control transfer request to write HFC-S USB 88 * chip register using CTRL resuest queue 89 */ 90 static int write_reg(struct hfcsusb *hw, __u8 reg, __u8 val) 91 { 92 struct ctrl_buf *buf; 93 94 if (debug & DBG_HFC_CALL_TRACE) 95 printk(KERN_DEBUG "%s: %s reg(0x%02x) val(0x%02x)\n", 96 hw->name, __func__, reg, val); 97 98 spin_lock(&hw->ctrl_lock); 99 if (hw->ctrl_cnt >= HFC_CTRL_BUFSIZE) { 100 spin_unlock(&hw->ctrl_lock); 101 return 1; 102 } 103 buf = &hw->ctrl_buff[hw->ctrl_in_idx]; 104 buf->hfcs_reg = reg; 105 buf->reg_val = val; 106 if (++hw->ctrl_in_idx >= HFC_CTRL_BUFSIZE) 107 hw->ctrl_in_idx = 0; 108 if (++hw->ctrl_cnt == 1) 109 ctrl_start_transfer(hw); 110 spin_unlock(&hw->ctrl_lock); 111 112 return 0; 113 } 114 115 /* control completion routine handling background control cmds */ 116 static void 117 ctrl_complete(struct urb *urb) 118 { 119 struct hfcsusb *hw = (struct hfcsusb *) urb->context; 120 121 if (debug & DBG_HFC_CALL_TRACE) 122 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__); 123 124 urb->dev = hw->dev; 125 if (hw->ctrl_cnt) { 126 hw->ctrl_cnt--; /* decrement actual count */ 127 if (++hw->ctrl_out_idx >= HFC_CTRL_BUFSIZE) 128 hw->ctrl_out_idx = 0; /* pointer wrap */ 129 130 ctrl_start_transfer(hw); /* start next transfer */ 131 } 132 } 133 134 /* handle LED bits */ 135 static void 136 set_led_bit(struct hfcsusb *hw, signed short led_bits, int set_on) 137 { 138 if (set_on) { 139 if (led_bits < 0) 140 hw->led_state &= ~abs(led_bits); 141 else 142 hw->led_state |= led_bits; 143 } else { 144 if (led_bits < 0) 145 hw->led_state |= abs(led_bits); 146 else 147 hw->led_state &= ~led_bits; 148 } 149 } 150 151 /* handle LED requests */ 152 static void 153 handle_led(struct hfcsusb *hw, int event) 154 { 155 struct hfcsusb_vdata *driver_info = (struct hfcsusb_vdata *) 156 hfcsusb_idtab[hw->vend_idx].driver_info; 157 __u8 tmpled; 158 159 if (driver_info->led_scheme == LED_OFF) 160 return; 161 tmpled = hw->led_state; 162 163 switch (event) { 164 case LED_POWER_ON: 165 set_led_bit(hw, driver_info->led_bits[0], 1); 166 set_led_bit(hw, driver_info->led_bits[1], 0); 167 set_led_bit(hw, driver_info->led_bits[2], 0); 168 set_led_bit(hw, driver_info->led_bits[3], 0); 169 break; 170 case LED_POWER_OFF: 171 set_led_bit(hw, driver_info->led_bits[0], 0); 172 set_led_bit(hw, driver_info->led_bits[1], 0); 173 set_led_bit(hw, driver_info->led_bits[2], 0); 174 set_led_bit(hw, driver_info->led_bits[3], 0); 175 break; 176 case LED_S0_ON: 177 set_led_bit(hw, driver_info->led_bits[1], 1); 178 break; 179 case LED_S0_OFF: 180 set_led_bit(hw, driver_info->led_bits[1], 0); 181 break; 182 case LED_B1_ON: 183 set_led_bit(hw, driver_info->led_bits[2], 1); 184 break; 185 case LED_B1_OFF: 186 set_led_bit(hw, driver_info->led_bits[2], 0); 187 break; 188 case LED_B2_ON: 189 set_led_bit(hw, driver_info->led_bits[3], 1); 190 break; 191 case LED_B2_OFF: 192 set_led_bit(hw, driver_info->led_bits[3], 0); 193 break; 194 } 195 196 if (hw->led_state != tmpled) { 197 if (debug & DBG_HFC_CALL_TRACE) 198 printk(KERN_DEBUG "%s: %s reg(0x%02x) val(x%02x)\n", 199 hw->name, __func__, 200 HFCUSB_P_DATA, hw->led_state); 201 202 write_reg(hw, HFCUSB_P_DATA, hw->led_state); 203 } 204 } 205 206 /* 207 * Layer2 -> Layer 1 Bchannel data 208 */ 209 static int 210 hfcusb_l2l1B(struct mISDNchannel *ch, struct sk_buff *skb) 211 { 212 struct bchannel *bch = container_of(ch, struct bchannel, ch); 213 struct hfcsusb *hw = bch->hw; 214 int ret = -EINVAL; 215 struct mISDNhead *hh = mISDN_HEAD_P(skb); 216 u_long flags; 217 218 if (debug & DBG_HFC_CALL_TRACE) 219 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__); 220 221 switch (hh->prim) { 222 case PH_DATA_REQ: 223 spin_lock_irqsave(&hw->lock, flags); 224 ret = bchannel_senddata(bch, skb); 225 spin_unlock_irqrestore(&hw->lock, flags); 226 if (debug & DBG_HFC_CALL_TRACE) 227 printk(KERN_DEBUG "%s: %s PH_DATA_REQ ret(%i)\n", 228 hw->name, __func__, ret); 229 if (ret > 0) 230 ret = 0; 231 return ret; 232 case PH_ACTIVATE_REQ: 233 if (!test_and_set_bit(FLG_ACTIVE, &bch->Flags)) { 234 hfcsusb_start_endpoint(hw, bch->nr - 1); 235 ret = hfcsusb_setup_bch(bch, ch->protocol); 236 } else 237 ret = 0; 238 if (!ret) 239 _queue_data(ch, PH_ACTIVATE_IND, MISDN_ID_ANY, 240 0, NULL, GFP_KERNEL); 241 break; 242 case PH_DEACTIVATE_REQ: 243 deactivate_bchannel(bch); 244 _queue_data(ch, PH_DEACTIVATE_IND, MISDN_ID_ANY, 245 0, NULL, GFP_KERNEL); 246 ret = 0; 247 break; 248 } 249 if (!ret) 250 dev_kfree_skb(skb); 251 return ret; 252 } 253 254 /* 255 * send full D/B channel status information 256 * as MPH_INFORMATION_IND 257 */ 258 static void 259 hfcsusb_ph_info(struct hfcsusb *hw) 260 { 261 struct ph_info *phi; 262 struct dchannel *dch = &hw->dch; 263 int i; 264 265 phi = kzalloc(sizeof(struct ph_info) + 266 dch->dev.nrbchan * sizeof(struct ph_info_ch), GFP_ATOMIC); 267 phi->dch.ch.protocol = hw->protocol; 268 phi->dch.ch.Flags = dch->Flags; 269 phi->dch.state = dch->state; 270 phi->dch.num_bch = dch->dev.nrbchan; 271 for (i = 0; i < dch->dev.nrbchan; i++) { 272 phi->bch[i].protocol = hw->bch[i].ch.protocol; 273 phi->bch[i].Flags = hw->bch[i].Flags; 274 } 275 _queue_data(&dch->dev.D, MPH_INFORMATION_IND, MISDN_ID_ANY, 276 sizeof(struct ph_info_dch) + dch->dev.nrbchan * 277 sizeof(struct ph_info_ch), phi, GFP_ATOMIC); 278 kfree(phi); 279 } 280 281 /* 282 * Layer2 -> Layer 1 Dchannel data 283 */ 284 static int 285 hfcusb_l2l1D(struct mISDNchannel *ch, struct sk_buff *skb) 286 { 287 struct mISDNdevice *dev = container_of(ch, struct mISDNdevice, D); 288 struct dchannel *dch = container_of(dev, struct dchannel, dev); 289 struct mISDNhead *hh = mISDN_HEAD_P(skb); 290 struct hfcsusb *hw = dch->hw; 291 int ret = -EINVAL; 292 u_long flags; 293 294 switch (hh->prim) { 295 case PH_DATA_REQ: 296 if (debug & DBG_HFC_CALL_TRACE) 297 printk(KERN_DEBUG "%s: %s: PH_DATA_REQ\n", 298 hw->name, __func__); 299 300 spin_lock_irqsave(&hw->lock, flags); 301 ret = dchannel_senddata(dch, skb); 302 spin_unlock_irqrestore(&hw->lock, flags); 303 if (ret > 0) { 304 ret = 0; 305 queue_ch_frame(ch, PH_DATA_CNF, hh->id, NULL); 306 } 307 break; 308 309 case PH_ACTIVATE_REQ: 310 if (debug & DBG_HFC_CALL_TRACE) 311 printk(KERN_DEBUG "%s: %s: PH_ACTIVATE_REQ %s\n", 312 hw->name, __func__, 313 (hw->protocol == ISDN_P_NT_S0) ? "NT" : "TE"); 314 315 if (hw->protocol == ISDN_P_NT_S0) { 316 ret = 0; 317 if (test_bit(FLG_ACTIVE, &dch->Flags)) { 318 _queue_data(&dch->dev.D, 319 PH_ACTIVATE_IND, MISDN_ID_ANY, 0, 320 NULL, GFP_ATOMIC); 321 } else { 322 hfcsusb_ph_command(hw, 323 HFC_L1_ACTIVATE_NT); 324 test_and_set_bit(FLG_L2_ACTIVATED, 325 &dch->Flags); 326 } 327 } else { 328 hfcsusb_ph_command(hw, HFC_L1_ACTIVATE_TE); 329 ret = l1_event(dch->l1, hh->prim); 330 } 331 break; 332 333 case PH_DEACTIVATE_REQ: 334 if (debug & DBG_HFC_CALL_TRACE) 335 printk(KERN_DEBUG "%s: %s: PH_DEACTIVATE_REQ\n", 336 hw->name, __func__); 337 test_and_clear_bit(FLG_L2_ACTIVATED, &dch->Flags); 338 339 if (hw->protocol == ISDN_P_NT_S0) { 340 hfcsusb_ph_command(hw, HFC_L1_DEACTIVATE_NT); 341 spin_lock_irqsave(&hw->lock, flags); 342 skb_queue_purge(&dch->squeue); 343 if (dch->tx_skb) { 344 dev_kfree_skb(dch->tx_skb); 345 dch->tx_skb = NULL; 346 } 347 dch->tx_idx = 0; 348 if (dch->rx_skb) { 349 dev_kfree_skb(dch->rx_skb); 350 dch->rx_skb = NULL; 351 } 352 test_and_clear_bit(FLG_TX_BUSY, &dch->Flags); 353 spin_unlock_irqrestore(&hw->lock, flags); 354 #ifdef FIXME 355 if (test_and_clear_bit(FLG_L1_BUSY, &dch->Flags)) 356 dchannel_sched_event(&hc->dch, D_CLEARBUSY); 357 #endif 358 ret = 0; 359 } else 360 ret = l1_event(dch->l1, hh->prim); 361 break; 362 case MPH_INFORMATION_REQ: 363 hfcsusb_ph_info(hw); 364 ret = 0; 365 break; 366 } 367 368 return ret; 369 } 370 371 /* 372 * Layer 1 callback function 373 */ 374 static int 375 hfc_l1callback(struct dchannel *dch, u_int cmd) 376 { 377 struct hfcsusb *hw = dch->hw; 378 379 if (debug & DBG_HFC_CALL_TRACE) 380 printk(KERN_DEBUG "%s: %s cmd 0x%x\n", 381 hw->name, __func__, cmd); 382 383 switch (cmd) { 384 case INFO3_P8: 385 case INFO3_P10: 386 case HW_RESET_REQ: 387 case HW_POWERUP_REQ: 388 break; 389 390 case HW_DEACT_REQ: 391 skb_queue_purge(&dch->squeue); 392 if (dch->tx_skb) { 393 dev_kfree_skb(dch->tx_skb); 394 dch->tx_skb = NULL; 395 } 396 dch->tx_idx = 0; 397 if (dch->rx_skb) { 398 dev_kfree_skb(dch->rx_skb); 399 dch->rx_skb = NULL; 400 } 401 test_and_clear_bit(FLG_TX_BUSY, &dch->Flags); 402 break; 403 case PH_ACTIVATE_IND: 404 test_and_set_bit(FLG_ACTIVE, &dch->Flags); 405 _queue_data(&dch->dev.D, cmd, MISDN_ID_ANY, 0, NULL, 406 GFP_ATOMIC); 407 break; 408 case PH_DEACTIVATE_IND: 409 test_and_clear_bit(FLG_ACTIVE, &dch->Flags); 410 _queue_data(&dch->dev.D, cmd, MISDN_ID_ANY, 0, NULL, 411 GFP_ATOMIC); 412 break; 413 default: 414 if (dch->debug & DEBUG_HW) 415 printk(KERN_DEBUG "%s: %s: unknown cmd %x\n", 416 hw->name, __func__, cmd); 417 return -1; 418 } 419 hfcsusb_ph_info(hw); 420 return 0; 421 } 422 423 static int 424 open_dchannel(struct hfcsusb *hw, struct mISDNchannel *ch, 425 struct channel_req *rq) 426 { 427 int err = 0; 428 429 if (debug & DEBUG_HW_OPEN) 430 printk(KERN_DEBUG "%s: %s: dev(%d) open addr(%i) from %p\n", 431 hw->name, __func__, hw->dch.dev.id, rq->adr.channel, 432 __builtin_return_address(0)); 433 if (rq->protocol == ISDN_P_NONE) 434 return -EINVAL; 435 436 test_and_clear_bit(FLG_ACTIVE, &hw->dch.Flags); 437 test_and_clear_bit(FLG_ACTIVE, &hw->ech.Flags); 438 hfcsusb_start_endpoint(hw, HFC_CHAN_D); 439 440 /* E-Channel logging */ 441 if (rq->adr.channel == 1) { 442 if (hw->fifos[HFCUSB_PCM_RX].pipe) { 443 hfcsusb_start_endpoint(hw, HFC_CHAN_E); 444 set_bit(FLG_ACTIVE, &hw->ech.Flags); 445 _queue_data(&hw->ech.dev.D, PH_ACTIVATE_IND, 446 MISDN_ID_ANY, 0, NULL, GFP_ATOMIC); 447 } else 448 return -EINVAL; 449 } 450 451 if (!hw->initdone) { 452 hw->protocol = rq->protocol; 453 if (rq->protocol == ISDN_P_TE_S0) { 454 err = create_l1(&hw->dch, hfc_l1callback); 455 if (err) 456 return err; 457 } 458 setPortMode(hw); 459 ch->protocol = rq->protocol; 460 hw->initdone = 1; 461 } else { 462 if (rq->protocol != ch->protocol) 463 return -EPROTONOSUPPORT; 464 } 465 466 if (((ch->protocol == ISDN_P_NT_S0) && (hw->dch.state == 3)) || 467 ((ch->protocol == ISDN_P_TE_S0) && (hw->dch.state == 7))) 468 _queue_data(ch, PH_ACTIVATE_IND, MISDN_ID_ANY, 469 0, NULL, GFP_KERNEL); 470 rq->ch = ch; 471 if (!try_module_get(THIS_MODULE)) 472 printk(KERN_WARNING "%s: %s: cannot get module\n", 473 hw->name, __func__); 474 return 0; 475 } 476 477 static int 478 open_bchannel(struct hfcsusb *hw, struct channel_req *rq) 479 { 480 struct bchannel *bch; 481 482 if (rq->adr.channel == 0 || rq->adr.channel > 2) 483 return -EINVAL; 484 if (rq->protocol == ISDN_P_NONE) 485 return -EINVAL; 486 487 if (debug & DBG_HFC_CALL_TRACE) 488 printk(KERN_DEBUG "%s: %s B%i\n", 489 hw->name, __func__, rq->adr.channel); 490 491 bch = &hw->bch[rq->adr.channel - 1]; 492 if (test_and_set_bit(FLG_OPEN, &bch->Flags)) 493 return -EBUSY; /* b-channel can be only open once */ 494 bch->ch.protocol = rq->protocol; 495 rq->ch = &bch->ch; 496 497 if (!try_module_get(THIS_MODULE)) 498 printk(KERN_WARNING "%s: %s:cannot get module\n", 499 hw->name, __func__); 500 return 0; 501 } 502 503 static int 504 channel_ctrl(struct hfcsusb *hw, struct mISDN_ctrl_req *cq) 505 { 506 int ret = 0; 507 508 if (debug & DBG_HFC_CALL_TRACE) 509 printk(KERN_DEBUG "%s: %s op(0x%x) channel(0x%x)\n", 510 hw->name, __func__, (cq->op), (cq->channel)); 511 512 switch (cq->op) { 513 case MISDN_CTRL_GETOP: 514 cq->op = MISDN_CTRL_LOOP | MISDN_CTRL_CONNECT | 515 MISDN_CTRL_DISCONNECT; 516 break; 517 default: 518 printk(KERN_WARNING "%s: %s: unknown Op %x\n", 519 hw->name, __func__, cq->op); 520 ret = -EINVAL; 521 break; 522 } 523 return ret; 524 } 525 526 /* 527 * device control function 528 */ 529 static int 530 hfc_dctrl(struct mISDNchannel *ch, u_int cmd, void *arg) 531 { 532 struct mISDNdevice *dev = container_of(ch, struct mISDNdevice, D); 533 struct dchannel *dch = container_of(dev, struct dchannel, dev); 534 struct hfcsusb *hw = dch->hw; 535 struct channel_req *rq; 536 int err = 0; 537 538 if (dch->debug & DEBUG_HW) 539 printk(KERN_DEBUG "%s: %s: cmd:%x %p\n", 540 hw->name, __func__, cmd, arg); 541 switch (cmd) { 542 case OPEN_CHANNEL: 543 rq = arg; 544 if ((rq->protocol == ISDN_P_TE_S0) || 545 (rq->protocol == ISDN_P_NT_S0)) 546 err = open_dchannel(hw, ch, rq); 547 else 548 err = open_bchannel(hw, rq); 549 if (!err) 550 hw->open++; 551 break; 552 case CLOSE_CHANNEL: 553 hw->open--; 554 if (debug & DEBUG_HW_OPEN) 555 printk(KERN_DEBUG 556 "%s: %s: dev(%d) close from %p (open %d)\n", 557 hw->name, __func__, hw->dch.dev.id, 558 __builtin_return_address(0), hw->open); 559 if (!hw->open) { 560 hfcsusb_stop_endpoint(hw, HFC_CHAN_D); 561 if (hw->fifos[HFCUSB_PCM_RX].pipe) 562 hfcsusb_stop_endpoint(hw, HFC_CHAN_E); 563 handle_led(hw, LED_POWER_ON); 564 } 565 module_put(THIS_MODULE); 566 break; 567 case CONTROL_CHANNEL: 568 err = channel_ctrl(hw, arg); 569 break; 570 default: 571 if (dch->debug & DEBUG_HW) 572 printk(KERN_DEBUG "%s: %s: unknown command %x\n", 573 hw->name, __func__, cmd); 574 return -EINVAL; 575 } 576 return err; 577 } 578 579 /* 580 * S0 TE state change event handler 581 */ 582 static void 583 ph_state_te(struct dchannel *dch) 584 { 585 struct hfcsusb *hw = dch->hw; 586 587 if (debug & DEBUG_HW) { 588 if (dch->state <= HFC_MAX_TE_LAYER1_STATE) 589 printk(KERN_DEBUG "%s: %s: %s\n", hw->name, __func__, 590 HFC_TE_LAYER1_STATES[dch->state]); 591 else 592 printk(KERN_DEBUG "%s: %s: TE F%d\n", 593 hw->name, __func__, dch->state); 594 } 595 596 switch (dch->state) { 597 case 0: 598 l1_event(dch->l1, HW_RESET_IND); 599 break; 600 case 3: 601 l1_event(dch->l1, HW_DEACT_IND); 602 break; 603 case 5: 604 case 8: 605 l1_event(dch->l1, ANYSIGNAL); 606 break; 607 case 6: 608 l1_event(dch->l1, INFO2); 609 break; 610 case 7: 611 l1_event(dch->l1, INFO4_P8); 612 break; 613 } 614 if (dch->state == 7) 615 handle_led(hw, LED_S0_ON); 616 else 617 handle_led(hw, LED_S0_OFF); 618 } 619 620 /* 621 * S0 NT state change event handler 622 */ 623 static void 624 ph_state_nt(struct dchannel *dch) 625 { 626 struct hfcsusb *hw = dch->hw; 627 628 if (debug & DEBUG_HW) { 629 if (dch->state <= HFC_MAX_NT_LAYER1_STATE) 630 printk(KERN_DEBUG "%s: %s: %s\n", 631 hw->name, __func__, 632 HFC_NT_LAYER1_STATES[dch->state]); 633 634 else 635 printk(KERN_INFO DRIVER_NAME "%s: %s: NT G%d\n", 636 hw->name, __func__, dch->state); 637 } 638 639 switch (dch->state) { 640 case (1): 641 test_and_clear_bit(FLG_ACTIVE, &dch->Flags); 642 test_and_clear_bit(FLG_L2_ACTIVATED, &dch->Flags); 643 hw->nt_timer = 0; 644 hw->timers &= ~NT_ACTIVATION_TIMER; 645 handle_led(hw, LED_S0_OFF); 646 break; 647 648 case (2): 649 if (hw->nt_timer < 0) { 650 hw->nt_timer = 0; 651 hw->timers &= ~NT_ACTIVATION_TIMER; 652 hfcsusb_ph_command(dch->hw, HFC_L1_DEACTIVATE_NT); 653 } else { 654 hw->timers |= NT_ACTIVATION_TIMER; 655 hw->nt_timer = NT_T1_COUNT; 656 /* allow G2 -> G3 transition */ 657 write_reg(hw, HFCUSB_STATES, 2 | HFCUSB_NT_G2_G3); 658 } 659 break; 660 case (3): 661 hw->nt_timer = 0; 662 hw->timers &= ~NT_ACTIVATION_TIMER; 663 test_and_set_bit(FLG_ACTIVE, &dch->Flags); 664 _queue_data(&dch->dev.D, PH_ACTIVATE_IND, 665 MISDN_ID_ANY, 0, NULL, GFP_ATOMIC); 666 handle_led(hw, LED_S0_ON); 667 break; 668 case (4): 669 hw->nt_timer = 0; 670 hw->timers &= ~NT_ACTIVATION_TIMER; 671 break; 672 default: 673 break; 674 } 675 hfcsusb_ph_info(hw); 676 } 677 678 static void 679 ph_state(struct dchannel *dch) 680 { 681 struct hfcsusb *hw = dch->hw; 682 683 if (hw->protocol == ISDN_P_NT_S0) 684 ph_state_nt(dch); 685 else if (hw->protocol == ISDN_P_TE_S0) 686 ph_state_te(dch); 687 } 688 689 /* 690 * disable/enable BChannel for desired protocoll 691 */ 692 static int 693 hfcsusb_setup_bch(struct bchannel *bch, int protocol) 694 { 695 struct hfcsusb *hw = bch->hw; 696 __u8 conhdlc, sctrl, sctrl_r; 697 698 if (debug & DEBUG_HW) 699 printk(KERN_DEBUG "%s: %s: protocol %x-->%x B%d\n", 700 hw->name, __func__, bch->state, protocol, 701 bch->nr); 702 703 /* setup val for CON_HDLC */ 704 conhdlc = 0; 705 if (protocol > ISDN_P_NONE) 706 conhdlc = 8; /* enable FIFO */ 707 708 switch (protocol) { 709 case (-1): /* used for init */ 710 bch->state = -1; 711 /* fall through */ 712 case (ISDN_P_NONE): 713 if (bch->state == ISDN_P_NONE) 714 return 0; /* already in idle state */ 715 bch->state = ISDN_P_NONE; 716 clear_bit(FLG_HDLC, &bch->Flags); 717 clear_bit(FLG_TRANSPARENT, &bch->Flags); 718 break; 719 case (ISDN_P_B_RAW): 720 conhdlc |= 2; 721 bch->state = protocol; 722 set_bit(FLG_TRANSPARENT, &bch->Flags); 723 break; 724 case (ISDN_P_B_HDLC): 725 bch->state = protocol; 726 set_bit(FLG_HDLC, &bch->Flags); 727 break; 728 default: 729 if (debug & DEBUG_HW) 730 printk(KERN_DEBUG "%s: %s: prot not known %x\n", 731 hw->name, __func__, protocol); 732 return -ENOPROTOOPT; 733 } 734 735 if (protocol >= ISDN_P_NONE) { 736 write_reg(hw, HFCUSB_FIFO, (bch->nr == 1) ? 0 : 2); 737 write_reg(hw, HFCUSB_CON_HDLC, conhdlc); 738 write_reg(hw, HFCUSB_INC_RES_F, 2); 739 write_reg(hw, HFCUSB_FIFO, (bch->nr == 1) ? 1 : 3); 740 write_reg(hw, HFCUSB_CON_HDLC, conhdlc); 741 write_reg(hw, HFCUSB_INC_RES_F, 2); 742 743 sctrl = 0x40 + ((hw->protocol == ISDN_P_TE_S0) ? 0x00 : 0x04); 744 sctrl_r = 0x0; 745 if (test_bit(FLG_ACTIVE, &hw->bch[0].Flags)) { 746 sctrl |= 1; 747 sctrl_r |= 1; 748 } 749 if (test_bit(FLG_ACTIVE, &hw->bch[1].Flags)) { 750 sctrl |= 2; 751 sctrl_r |= 2; 752 } 753 write_reg(hw, HFCUSB_SCTRL, sctrl); 754 write_reg(hw, HFCUSB_SCTRL_R, sctrl_r); 755 756 if (protocol > ISDN_P_NONE) 757 handle_led(hw, (bch->nr == 1) ? LED_B1_ON : LED_B2_ON); 758 else 759 handle_led(hw, (bch->nr == 1) ? LED_B1_OFF : 760 LED_B2_OFF); 761 } 762 hfcsusb_ph_info(hw); 763 return 0; 764 } 765 766 static void 767 hfcsusb_ph_command(struct hfcsusb *hw, u_char command) 768 { 769 if (debug & DEBUG_HW) 770 printk(KERN_DEBUG "%s: %s: %x\n", 771 hw->name, __func__, command); 772 773 switch (command) { 774 case HFC_L1_ACTIVATE_TE: 775 /* force sending sending INFO1 */ 776 write_reg(hw, HFCUSB_STATES, 0x14); 777 /* start l1 activation */ 778 write_reg(hw, HFCUSB_STATES, 0x04); 779 break; 780 781 case HFC_L1_FORCE_DEACTIVATE_TE: 782 write_reg(hw, HFCUSB_STATES, 0x10); 783 write_reg(hw, HFCUSB_STATES, 0x03); 784 break; 785 786 case HFC_L1_ACTIVATE_NT: 787 if (hw->dch.state == 3) 788 _queue_data(&hw->dch.dev.D, PH_ACTIVATE_IND, 789 MISDN_ID_ANY, 0, NULL, GFP_ATOMIC); 790 else 791 write_reg(hw, HFCUSB_STATES, HFCUSB_ACTIVATE | 792 HFCUSB_DO_ACTION | HFCUSB_NT_G2_G3); 793 break; 794 795 case HFC_L1_DEACTIVATE_NT: 796 write_reg(hw, HFCUSB_STATES, 797 HFCUSB_DO_ACTION); 798 break; 799 } 800 } 801 802 /* 803 * Layer 1 B-channel hardware access 804 */ 805 static int 806 channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq) 807 { 808 return mISDN_ctrl_bchannel(bch, cq); 809 } 810 811 /* collect data from incoming interrupt or isochron USB data */ 812 static void 813 hfcsusb_rx_frame(struct usb_fifo *fifo, __u8 *data, unsigned int len, 814 int finish) 815 { 816 struct hfcsusb *hw = fifo->hw; 817 struct sk_buff *rx_skb = NULL; 818 int maxlen = 0; 819 int fifon = fifo->fifonum; 820 int i; 821 int hdlc = 0; 822 823 if (debug & DBG_HFC_CALL_TRACE) 824 printk(KERN_DEBUG "%s: %s: fifo(%i) len(%i) " 825 "dch(%p) bch(%p) ech(%p)\n", 826 hw->name, __func__, fifon, len, 827 fifo->dch, fifo->bch, fifo->ech); 828 829 if (!len) 830 return; 831 832 if ((!!fifo->dch + !!fifo->bch + !!fifo->ech) != 1) { 833 printk(KERN_DEBUG "%s: %s: undefined channel\n", 834 hw->name, __func__); 835 return; 836 } 837 838 spin_lock(&hw->lock); 839 if (fifo->dch) { 840 rx_skb = fifo->dch->rx_skb; 841 maxlen = fifo->dch->maxlen; 842 hdlc = 1; 843 } 844 if (fifo->bch) { 845 if (test_bit(FLG_RX_OFF, &fifo->bch->Flags)) { 846 fifo->bch->dropcnt += len; 847 spin_unlock(&hw->lock); 848 return; 849 } 850 maxlen = bchannel_get_rxbuf(fifo->bch, len); 851 rx_skb = fifo->bch->rx_skb; 852 if (maxlen < 0) { 853 if (rx_skb) 854 skb_trim(rx_skb, 0); 855 pr_warning("%s.B%d: No bufferspace for %d bytes\n", 856 hw->name, fifo->bch->nr, len); 857 spin_unlock(&hw->lock); 858 return; 859 } 860 maxlen = fifo->bch->maxlen; 861 hdlc = test_bit(FLG_HDLC, &fifo->bch->Flags); 862 } 863 if (fifo->ech) { 864 rx_skb = fifo->ech->rx_skb; 865 maxlen = fifo->ech->maxlen; 866 hdlc = 1; 867 } 868 869 if (fifo->dch || fifo->ech) { 870 if (!rx_skb) { 871 rx_skb = mI_alloc_skb(maxlen, GFP_ATOMIC); 872 if (rx_skb) { 873 if (fifo->dch) 874 fifo->dch->rx_skb = rx_skb; 875 if (fifo->ech) 876 fifo->ech->rx_skb = rx_skb; 877 skb_trim(rx_skb, 0); 878 } else { 879 printk(KERN_DEBUG "%s: %s: No mem for rx_skb\n", 880 hw->name, __func__); 881 spin_unlock(&hw->lock); 882 return; 883 } 884 } 885 /* D/E-Channel SKB range check */ 886 if ((rx_skb->len + len) >= MAX_DFRAME_LEN_L1) { 887 printk(KERN_DEBUG "%s: %s: sbk mem exceeded " 888 "for fifo(%d) HFCUSB_D_RX\n", 889 hw->name, __func__, fifon); 890 skb_trim(rx_skb, 0); 891 spin_unlock(&hw->lock); 892 return; 893 } 894 } 895 896 memcpy(skb_put(rx_skb, len), data, len); 897 898 if (hdlc) { 899 /* we have a complete hdlc packet */ 900 if (finish) { 901 if ((rx_skb->len > 3) && 902 (!(rx_skb->data[rx_skb->len - 1]))) { 903 if (debug & DBG_HFC_FIFO_VERBOSE) { 904 printk(KERN_DEBUG "%s: %s: fifon(%i)" 905 " new RX len(%i): ", 906 hw->name, __func__, fifon, 907 rx_skb->len); 908 i = 0; 909 while (i < rx_skb->len) 910 printk("%02x ", 911 rx_skb->data[i++]); 912 printk("\n"); 913 } 914 915 /* remove CRC & status */ 916 skb_trim(rx_skb, rx_skb->len - 3); 917 918 if (fifo->dch) 919 recv_Dchannel(fifo->dch); 920 if (fifo->bch) 921 recv_Bchannel(fifo->bch, MISDN_ID_ANY, 922 0); 923 if (fifo->ech) 924 recv_Echannel(fifo->ech, 925 &hw->dch); 926 } else { 927 if (debug & DBG_HFC_FIFO_VERBOSE) { 928 printk(KERN_DEBUG 929 "%s: CRC or minlen ERROR fifon(%i) " 930 "RX len(%i): ", 931 hw->name, fifon, rx_skb->len); 932 i = 0; 933 while (i < rx_skb->len) 934 printk("%02x ", 935 rx_skb->data[i++]); 936 printk("\n"); 937 } 938 skb_trim(rx_skb, 0); 939 } 940 } 941 } else { 942 /* deliver transparent data to layer2 */ 943 recv_Bchannel(fifo->bch, MISDN_ID_ANY, false); 944 } 945 spin_unlock(&hw->lock); 946 } 947 948 static void 949 fill_isoc_urb(struct urb *urb, struct usb_device *dev, unsigned int pipe, 950 void *buf, int num_packets, int packet_size, int interval, 951 usb_complete_t complete, void *context) 952 { 953 int k; 954 955 usb_fill_bulk_urb(urb, dev, pipe, buf, packet_size * num_packets, 956 complete, context); 957 958 urb->number_of_packets = num_packets; 959 urb->transfer_flags = URB_ISO_ASAP; 960 urb->actual_length = 0; 961 urb->interval = interval; 962 963 for (k = 0; k < num_packets; k++) { 964 urb->iso_frame_desc[k].offset = packet_size * k; 965 urb->iso_frame_desc[k].length = packet_size; 966 urb->iso_frame_desc[k].actual_length = 0; 967 } 968 } 969 970 /* receive completion routine for all ISO tx fifos */ 971 static void 972 rx_iso_complete(struct urb *urb) 973 { 974 struct iso_urb *context_iso_urb = (struct iso_urb *) urb->context; 975 struct usb_fifo *fifo = context_iso_urb->owner_fifo; 976 struct hfcsusb *hw = fifo->hw; 977 int k, len, errcode, offset, num_isoc_packets, fifon, maxlen, 978 status, iso_status, i; 979 __u8 *buf; 980 static __u8 eof[8]; 981 __u8 s0_state; 982 983 fifon = fifo->fifonum; 984 status = urb->status; 985 986 spin_lock(&hw->lock); 987 if (fifo->stop_gracefull) { 988 fifo->stop_gracefull = 0; 989 fifo->active = 0; 990 spin_unlock(&hw->lock); 991 return; 992 } 993 spin_unlock(&hw->lock); 994 995 /* 996 * ISO transfer only partially completed, 997 * look at individual frame status for details 998 */ 999 if (status == -EXDEV) { 1000 if (debug & DEBUG_HW) 1001 printk(KERN_DEBUG "%s: %s: with -EXDEV " 1002 "urb->status %d, fifonum %d\n", 1003 hw->name, __func__, status, fifon); 1004 1005 /* clear status, so go on with ISO transfers */ 1006 status = 0; 1007 } 1008 1009 s0_state = 0; 1010 if (fifo->active && !status) { 1011 num_isoc_packets = iso_packets[fifon]; 1012 maxlen = fifo->usb_packet_maxlen; 1013 1014 for (k = 0; k < num_isoc_packets; ++k) { 1015 len = urb->iso_frame_desc[k].actual_length; 1016 offset = urb->iso_frame_desc[k].offset; 1017 buf = context_iso_urb->buffer + offset; 1018 iso_status = urb->iso_frame_desc[k].status; 1019 1020 if (iso_status && (debug & DBG_HFC_FIFO_VERBOSE)) { 1021 printk(KERN_DEBUG "%s: %s: " 1022 "ISO packet %i, status: %i\n", 1023 hw->name, __func__, k, iso_status); 1024 } 1025 1026 /* USB data log for every D ISO in */ 1027 if ((fifon == HFCUSB_D_RX) && 1028 (debug & DBG_HFC_USB_VERBOSE)) { 1029 printk(KERN_DEBUG 1030 "%s: %s: %d (%d/%d) len(%d) ", 1031 hw->name, __func__, urb->start_frame, 1032 k, num_isoc_packets - 1, 1033 len); 1034 for (i = 0; i < len; i++) 1035 printk("%x ", buf[i]); 1036 printk("\n"); 1037 } 1038 1039 if (!iso_status) { 1040 if (fifo->last_urblen != maxlen) { 1041 /* 1042 * save fifo fill-level threshold bits 1043 * to use them later in TX ISO URB 1044 * completions 1045 */ 1046 hw->threshold_mask = buf[1]; 1047 1048 if (fifon == HFCUSB_D_RX) 1049 s0_state = (buf[0] >> 4); 1050 1051 eof[fifon] = buf[0] & 1; 1052 if (len > 2) 1053 hfcsusb_rx_frame(fifo, buf + 2, 1054 len - 2, (len < maxlen) 1055 ? eof[fifon] : 0); 1056 } else 1057 hfcsusb_rx_frame(fifo, buf, len, 1058 (len < maxlen) ? 1059 eof[fifon] : 0); 1060 fifo->last_urblen = len; 1061 } 1062 } 1063 1064 /* signal S0 layer1 state change */ 1065 if ((s0_state) && (hw->initdone) && 1066 (s0_state != hw->dch.state)) { 1067 hw->dch.state = s0_state; 1068 schedule_event(&hw->dch, FLG_PHCHANGE); 1069 } 1070 1071 fill_isoc_urb(urb, fifo->hw->dev, fifo->pipe, 1072 context_iso_urb->buffer, num_isoc_packets, 1073 fifo->usb_packet_maxlen, fifo->intervall, 1074 (usb_complete_t)rx_iso_complete, urb->context); 1075 errcode = usb_submit_urb(urb, GFP_ATOMIC); 1076 if (errcode < 0) { 1077 if (debug & DEBUG_HW) 1078 printk(KERN_DEBUG "%s: %s: error submitting " 1079 "ISO URB: %d\n", 1080 hw->name, __func__, errcode); 1081 } 1082 } else { 1083 if (status && (debug & DBG_HFC_URB_INFO)) 1084 printk(KERN_DEBUG "%s: %s: rx_iso_complete : " 1085 "urb->status %d, fifonum %d\n", 1086 hw->name, __func__, status, fifon); 1087 } 1088 } 1089 1090 /* receive completion routine for all interrupt rx fifos */ 1091 static void 1092 rx_int_complete(struct urb *urb) 1093 { 1094 int len, status, i; 1095 __u8 *buf, maxlen, fifon; 1096 struct usb_fifo *fifo = (struct usb_fifo *) urb->context; 1097 struct hfcsusb *hw = fifo->hw; 1098 static __u8 eof[8]; 1099 1100 spin_lock(&hw->lock); 1101 if (fifo->stop_gracefull) { 1102 fifo->stop_gracefull = 0; 1103 fifo->active = 0; 1104 spin_unlock(&hw->lock); 1105 return; 1106 } 1107 spin_unlock(&hw->lock); 1108 1109 fifon = fifo->fifonum; 1110 if ((!fifo->active) || (urb->status)) { 1111 if (debug & DBG_HFC_URB_ERROR) 1112 printk(KERN_DEBUG 1113 "%s: %s: RX-Fifo %i is going down (%i)\n", 1114 hw->name, __func__, fifon, urb->status); 1115 1116 fifo->urb->interval = 0; /* cancel automatic rescheduling */ 1117 return; 1118 } 1119 len = urb->actual_length; 1120 buf = fifo->buffer; 1121 maxlen = fifo->usb_packet_maxlen; 1122 1123 /* USB data log for every D INT in */ 1124 if ((fifon == HFCUSB_D_RX) && (debug & DBG_HFC_USB_VERBOSE)) { 1125 printk(KERN_DEBUG "%s: %s: D RX INT len(%d) ", 1126 hw->name, __func__, len); 1127 for (i = 0; i < len; i++) 1128 printk("%02x ", buf[i]); 1129 printk("\n"); 1130 } 1131 1132 if (fifo->last_urblen != fifo->usb_packet_maxlen) { 1133 /* the threshold mask is in the 2nd status byte */ 1134 hw->threshold_mask = buf[1]; 1135 1136 /* signal S0 layer1 state change */ 1137 if (hw->initdone && ((buf[0] >> 4) != hw->dch.state)) { 1138 hw->dch.state = (buf[0] >> 4); 1139 schedule_event(&hw->dch, FLG_PHCHANGE); 1140 } 1141 1142 eof[fifon] = buf[0] & 1; 1143 /* if we have more than the 2 status bytes -> collect data */ 1144 if (len > 2) 1145 hfcsusb_rx_frame(fifo, buf + 2, 1146 urb->actual_length - 2, 1147 (len < maxlen) ? eof[fifon] : 0); 1148 } else { 1149 hfcsusb_rx_frame(fifo, buf, urb->actual_length, 1150 (len < maxlen) ? eof[fifon] : 0); 1151 } 1152 fifo->last_urblen = urb->actual_length; 1153 1154 status = usb_submit_urb(urb, GFP_ATOMIC); 1155 if (status) { 1156 if (debug & DEBUG_HW) 1157 printk(KERN_DEBUG "%s: %s: error resubmitting USB\n", 1158 hw->name, __func__); 1159 } 1160 } 1161 1162 /* transmit completion routine for all ISO tx fifos */ 1163 static void 1164 tx_iso_complete(struct urb *urb) 1165 { 1166 struct iso_urb *context_iso_urb = (struct iso_urb *) urb->context; 1167 struct usb_fifo *fifo = context_iso_urb->owner_fifo; 1168 struct hfcsusb *hw = fifo->hw; 1169 struct sk_buff *tx_skb; 1170 int k, tx_offset, num_isoc_packets, sink, remain, current_len, 1171 errcode, hdlc, i; 1172 int *tx_idx; 1173 int frame_complete, fifon, status, fillempty = 0; 1174 __u8 threshbit, *p; 1175 1176 spin_lock(&hw->lock); 1177 if (fifo->stop_gracefull) { 1178 fifo->stop_gracefull = 0; 1179 fifo->active = 0; 1180 spin_unlock(&hw->lock); 1181 return; 1182 } 1183 1184 if (fifo->dch) { 1185 tx_skb = fifo->dch->tx_skb; 1186 tx_idx = &fifo->dch->tx_idx; 1187 hdlc = 1; 1188 } else if (fifo->bch) { 1189 tx_skb = fifo->bch->tx_skb; 1190 tx_idx = &fifo->bch->tx_idx; 1191 hdlc = test_bit(FLG_HDLC, &fifo->bch->Flags); 1192 if (!tx_skb && !hdlc && 1193 test_bit(FLG_FILLEMPTY, &fifo->bch->Flags)) 1194 fillempty = 1; 1195 } else { 1196 printk(KERN_DEBUG "%s: %s: neither BCH nor DCH\n", 1197 hw->name, __func__); 1198 spin_unlock(&hw->lock); 1199 return; 1200 } 1201 1202 fifon = fifo->fifonum; 1203 status = urb->status; 1204 1205 tx_offset = 0; 1206 1207 /* 1208 * ISO transfer only partially completed, 1209 * look at individual frame status for details 1210 */ 1211 if (status == -EXDEV) { 1212 if (debug & DBG_HFC_URB_ERROR) 1213 printk(KERN_DEBUG "%s: %s: " 1214 "-EXDEV (%i) fifon (%d)\n", 1215 hw->name, __func__, status, fifon); 1216 1217 /* clear status, so go on with ISO transfers */ 1218 status = 0; 1219 } 1220 1221 if (fifo->active && !status) { 1222 /* is FifoFull-threshold set for our channel? */ 1223 threshbit = (hw->threshold_mask & (1 << fifon)); 1224 num_isoc_packets = iso_packets[fifon]; 1225 1226 /* predict dataflow to avoid fifo overflow */ 1227 if (fifon >= HFCUSB_D_TX) 1228 sink = (threshbit) ? SINK_DMIN : SINK_DMAX; 1229 else 1230 sink = (threshbit) ? SINK_MIN : SINK_MAX; 1231 fill_isoc_urb(urb, fifo->hw->dev, fifo->pipe, 1232 context_iso_urb->buffer, num_isoc_packets, 1233 fifo->usb_packet_maxlen, fifo->intervall, 1234 (usb_complete_t)tx_iso_complete, urb->context); 1235 memset(context_iso_urb->buffer, 0, 1236 sizeof(context_iso_urb->buffer)); 1237 frame_complete = 0; 1238 1239 for (k = 0; k < num_isoc_packets; ++k) { 1240 /* analyze tx success of previous ISO packets */ 1241 if (debug & DBG_HFC_URB_ERROR) { 1242 errcode = urb->iso_frame_desc[k].status; 1243 if (errcode) { 1244 printk(KERN_DEBUG "%s: %s: " 1245 "ISO packet %i, status: %i\n", 1246 hw->name, __func__, k, errcode); 1247 } 1248 } 1249 1250 /* Generate next ISO Packets */ 1251 if (tx_skb) 1252 remain = tx_skb->len - *tx_idx; 1253 else if (fillempty) 1254 remain = 15; /* > not complete */ 1255 else 1256 remain = 0; 1257 1258 if (remain > 0) { 1259 fifo->bit_line -= sink; 1260 current_len = (0 - fifo->bit_line) / 8; 1261 if (current_len > 14) 1262 current_len = 14; 1263 if (current_len < 0) 1264 current_len = 0; 1265 if (remain < current_len) 1266 current_len = remain; 1267 1268 /* how much bit do we put on the line? */ 1269 fifo->bit_line += current_len * 8; 1270 1271 context_iso_urb->buffer[tx_offset] = 0; 1272 if (current_len == remain) { 1273 if (hdlc) { 1274 /* signal frame completion */ 1275 context_iso_urb-> 1276 buffer[tx_offset] = 1; 1277 /* add 2 byte flags and 16bit 1278 * CRC at end of ISDN frame */ 1279 fifo->bit_line += 32; 1280 } 1281 frame_complete = 1; 1282 } 1283 1284 /* copy tx data to iso-urb buffer */ 1285 p = context_iso_urb->buffer + tx_offset + 1; 1286 if (fillempty) { 1287 memset(p, fifo->bch->fill[0], 1288 current_len); 1289 } else { 1290 memcpy(p, (tx_skb->data + *tx_idx), 1291 current_len); 1292 *tx_idx += current_len; 1293 } 1294 urb->iso_frame_desc[k].offset = tx_offset; 1295 urb->iso_frame_desc[k].length = current_len + 1; 1296 1297 /* USB data log for every D ISO out */ 1298 if ((fifon == HFCUSB_D_RX) && !fillempty && 1299 (debug & DBG_HFC_USB_VERBOSE)) { 1300 printk(KERN_DEBUG 1301 "%s: %s (%d/%d) offs(%d) len(%d) ", 1302 hw->name, __func__, 1303 k, num_isoc_packets - 1, 1304 urb->iso_frame_desc[k].offset, 1305 urb->iso_frame_desc[k].length); 1306 1307 for (i = urb->iso_frame_desc[k].offset; 1308 i < (urb->iso_frame_desc[k].offset 1309 + urb->iso_frame_desc[k].length); 1310 i++) 1311 printk("%x ", 1312 context_iso_urb->buffer[i]); 1313 1314 printk(" skb->len(%i) tx-idx(%d)\n", 1315 tx_skb->len, *tx_idx); 1316 } 1317 1318 tx_offset += (current_len + 1); 1319 } else { 1320 urb->iso_frame_desc[k].offset = tx_offset++; 1321 urb->iso_frame_desc[k].length = 1; 1322 /* we lower data margin every msec */ 1323 fifo->bit_line -= sink; 1324 if (fifo->bit_line < BITLINE_INF) 1325 fifo->bit_line = BITLINE_INF; 1326 } 1327 1328 if (frame_complete) { 1329 frame_complete = 0; 1330 1331 if (debug & DBG_HFC_FIFO_VERBOSE) { 1332 printk(KERN_DEBUG "%s: %s: " 1333 "fifon(%i) new TX len(%i): ", 1334 hw->name, __func__, 1335 fifon, tx_skb->len); 1336 i = 0; 1337 while (i < tx_skb->len) 1338 printk("%02x ", 1339 tx_skb->data[i++]); 1340 printk("\n"); 1341 } 1342 1343 dev_kfree_skb(tx_skb); 1344 tx_skb = NULL; 1345 if (fifo->dch && get_next_dframe(fifo->dch)) 1346 tx_skb = fifo->dch->tx_skb; 1347 else if (fifo->bch && 1348 get_next_bframe(fifo->bch)) 1349 tx_skb = fifo->bch->tx_skb; 1350 } 1351 } 1352 errcode = usb_submit_urb(urb, GFP_ATOMIC); 1353 if (errcode < 0) { 1354 if (debug & DEBUG_HW) 1355 printk(KERN_DEBUG 1356 "%s: %s: error submitting ISO URB: %d \n", 1357 hw->name, __func__, errcode); 1358 } 1359 1360 /* 1361 * abuse DChannel tx iso completion to trigger NT mode state 1362 * changes tx_iso_complete is assumed to be called every 1363 * fifo->intervall (ms) 1364 */ 1365 if ((fifon == HFCUSB_D_TX) && (hw->protocol == ISDN_P_NT_S0) 1366 && (hw->timers & NT_ACTIVATION_TIMER)) { 1367 if ((--hw->nt_timer) < 0) 1368 schedule_event(&hw->dch, FLG_PHCHANGE); 1369 } 1370 1371 } else { 1372 if (status && (debug & DBG_HFC_URB_ERROR)) 1373 printk(KERN_DEBUG "%s: %s: urb->status %s (%i)" 1374 "fifonum=%d\n", 1375 hw->name, __func__, 1376 symbolic(urb_errlist, status), status, fifon); 1377 } 1378 spin_unlock(&hw->lock); 1379 } 1380 1381 /* 1382 * allocs urbs and start isoc transfer with two pending urbs to avoid 1383 * gaps in the transfer chain 1384 */ 1385 static int 1386 start_isoc_chain(struct usb_fifo *fifo, int num_packets_per_urb, 1387 usb_complete_t complete, int packet_size) 1388 { 1389 struct hfcsusb *hw = fifo->hw; 1390 int i, k, errcode; 1391 1392 if (debug) 1393 printk(KERN_DEBUG "%s: %s: fifo %i\n", 1394 hw->name, __func__, fifo->fifonum); 1395 1396 /* allocate Memory for Iso out Urbs */ 1397 for (i = 0; i < 2; i++) { 1398 if (!(fifo->iso[i].urb)) { 1399 fifo->iso[i].urb = 1400 usb_alloc_urb(num_packets_per_urb, GFP_KERNEL); 1401 if (!(fifo->iso[i].urb)) { 1402 printk(KERN_DEBUG 1403 "%s: %s: alloc urb for fifo %i failed", 1404 hw->name, __func__, fifo->fifonum); 1405 } 1406 fifo->iso[i].owner_fifo = (struct usb_fifo *) fifo; 1407 fifo->iso[i].indx = i; 1408 1409 /* Init the first iso */ 1410 if (ISO_BUFFER_SIZE >= 1411 (fifo->usb_packet_maxlen * 1412 num_packets_per_urb)) { 1413 fill_isoc_urb(fifo->iso[i].urb, 1414 fifo->hw->dev, fifo->pipe, 1415 fifo->iso[i].buffer, 1416 num_packets_per_urb, 1417 fifo->usb_packet_maxlen, 1418 fifo->intervall, complete, 1419 &fifo->iso[i]); 1420 memset(fifo->iso[i].buffer, 0, 1421 sizeof(fifo->iso[i].buffer)); 1422 1423 for (k = 0; k < num_packets_per_urb; k++) { 1424 fifo->iso[i].urb-> 1425 iso_frame_desc[k].offset = 1426 k * packet_size; 1427 fifo->iso[i].urb-> 1428 iso_frame_desc[k].length = 1429 packet_size; 1430 } 1431 } else { 1432 printk(KERN_DEBUG 1433 "%s: %s: ISO Buffer size to small!\n", 1434 hw->name, __func__); 1435 } 1436 } 1437 fifo->bit_line = BITLINE_INF; 1438 1439 errcode = usb_submit_urb(fifo->iso[i].urb, GFP_KERNEL); 1440 fifo->active = (errcode >= 0) ? 1 : 0; 1441 fifo->stop_gracefull = 0; 1442 if (errcode < 0) { 1443 printk(KERN_DEBUG "%s: %s: %s URB nr:%d\n", 1444 hw->name, __func__, 1445 symbolic(urb_errlist, errcode), i); 1446 } 1447 } 1448 return fifo->active; 1449 } 1450 1451 static void 1452 stop_iso_gracefull(struct usb_fifo *fifo) 1453 { 1454 struct hfcsusb *hw = fifo->hw; 1455 int i, timeout; 1456 u_long flags; 1457 1458 for (i = 0; i < 2; i++) { 1459 spin_lock_irqsave(&hw->lock, flags); 1460 if (debug) 1461 printk(KERN_DEBUG "%s: %s for fifo %i.%i\n", 1462 hw->name, __func__, fifo->fifonum, i); 1463 fifo->stop_gracefull = 1; 1464 spin_unlock_irqrestore(&hw->lock, flags); 1465 } 1466 1467 for (i = 0; i < 2; i++) { 1468 timeout = 3; 1469 while (fifo->stop_gracefull && timeout--) 1470 schedule_timeout_interruptible((HZ / 1000) * 16); 1471 if (debug && fifo->stop_gracefull) 1472 printk(KERN_DEBUG "%s: ERROR %s for fifo %i.%i\n", 1473 hw->name, __func__, fifo->fifonum, i); 1474 } 1475 } 1476 1477 static void 1478 stop_int_gracefull(struct usb_fifo *fifo) 1479 { 1480 struct hfcsusb *hw = fifo->hw; 1481 int timeout; 1482 u_long flags; 1483 1484 spin_lock_irqsave(&hw->lock, flags); 1485 if (debug) 1486 printk(KERN_DEBUG "%s: %s for fifo %i\n", 1487 hw->name, __func__, fifo->fifonum); 1488 fifo->stop_gracefull = 1; 1489 spin_unlock_irqrestore(&hw->lock, flags); 1490 1491 timeout = 3; 1492 while (fifo->stop_gracefull && timeout--) 1493 schedule_timeout_interruptible((HZ / 1000) * 3); 1494 if (debug && fifo->stop_gracefull) 1495 printk(KERN_DEBUG "%s: ERROR %s for fifo %i\n", 1496 hw->name, __func__, fifo->fifonum); 1497 } 1498 1499 /* start the interrupt transfer for the given fifo */ 1500 static void 1501 start_int_fifo(struct usb_fifo *fifo) 1502 { 1503 struct hfcsusb *hw = fifo->hw; 1504 int errcode; 1505 1506 if (debug) 1507 printk(KERN_DEBUG "%s: %s: INT IN fifo:%d\n", 1508 hw->name, __func__, fifo->fifonum); 1509 1510 if (!fifo->urb) { 1511 fifo->urb = usb_alloc_urb(0, GFP_KERNEL); 1512 if (!fifo->urb) 1513 return; 1514 } 1515 usb_fill_int_urb(fifo->urb, fifo->hw->dev, fifo->pipe, 1516 fifo->buffer, fifo->usb_packet_maxlen, 1517 (usb_complete_t)rx_int_complete, fifo, fifo->intervall); 1518 fifo->active = 1; 1519 fifo->stop_gracefull = 0; 1520 errcode = usb_submit_urb(fifo->urb, GFP_KERNEL); 1521 if (errcode) { 1522 printk(KERN_DEBUG "%s: %s: submit URB: status:%i\n", 1523 hw->name, __func__, errcode); 1524 fifo->active = 0; 1525 } 1526 } 1527 1528 static void 1529 setPortMode(struct hfcsusb *hw) 1530 { 1531 if (debug & DEBUG_HW) 1532 printk(KERN_DEBUG "%s: %s %s\n", hw->name, __func__, 1533 (hw->protocol == ISDN_P_TE_S0) ? "TE" : "NT"); 1534 1535 if (hw->protocol == ISDN_P_TE_S0) { 1536 write_reg(hw, HFCUSB_SCTRL, 0x40); 1537 write_reg(hw, HFCUSB_SCTRL_E, 0x00); 1538 write_reg(hw, HFCUSB_CLKDEL, CLKDEL_TE); 1539 write_reg(hw, HFCUSB_STATES, 3 | 0x10); 1540 write_reg(hw, HFCUSB_STATES, 3); 1541 } else { 1542 write_reg(hw, HFCUSB_SCTRL, 0x44); 1543 write_reg(hw, HFCUSB_SCTRL_E, 0x09); 1544 write_reg(hw, HFCUSB_CLKDEL, CLKDEL_NT); 1545 write_reg(hw, HFCUSB_STATES, 1 | 0x10); 1546 write_reg(hw, HFCUSB_STATES, 1); 1547 } 1548 } 1549 1550 static void 1551 reset_hfcsusb(struct hfcsusb *hw) 1552 { 1553 struct usb_fifo *fifo; 1554 int i; 1555 1556 if (debug & DEBUG_HW) 1557 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__); 1558 1559 /* do Chip reset */ 1560 write_reg(hw, HFCUSB_CIRM, 8); 1561 1562 /* aux = output, reset off */ 1563 write_reg(hw, HFCUSB_CIRM, 0x10); 1564 1565 /* set USB_SIZE to match the wMaxPacketSize for INT or BULK transfers */ 1566 write_reg(hw, HFCUSB_USB_SIZE, (hw->packet_size / 8) | 1567 ((hw->packet_size / 8) << 4)); 1568 1569 /* set USB_SIZE_I to match the the wMaxPacketSize for ISO transfers */ 1570 write_reg(hw, HFCUSB_USB_SIZE_I, hw->iso_packet_size); 1571 1572 /* enable PCM/GCI master mode */ 1573 write_reg(hw, HFCUSB_MST_MODE1, 0); /* set default values */ 1574 write_reg(hw, HFCUSB_MST_MODE0, 1); /* enable master mode */ 1575 1576 /* init the fifos */ 1577 write_reg(hw, HFCUSB_F_THRES, 1578 (HFCUSB_TX_THRESHOLD / 8) | ((HFCUSB_RX_THRESHOLD / 8) << 4)); 1579 1580 fifo = hw->fifos; 1581 for (i = 0; i < HFCUSB_NUM_FIFOS; i++) { 1582 write_reg(hw, HFCUSB_FIFO, i); /* select the desired fifo */ 1583 fifo[i].max_size = 1584 (i <= HFCUSB_B2_RX) ? MAX_BCH_SIZE : MAX_DFRAME_LEN; 1585 fifo[i].last_urblen = 0; 1586 1587 /* set 2 bit for D- & E-channel */ 1588 write_reg(hw, HFCUSB_HDLC_PAR, ((i <= HFCUSB_B2_RX) ? 0 : 2)); 1589 1590 /* enable all fifos */ 1591 if (i == HFCUSB_D_TX) 1592 write_reg(hw, HFCUSB_CON_HDLC, 1593 (hw->protocol == ISDN_P_NT_S0) ? 0x08 : 0x09); 1594 else 1595 write_reg(hw, HFCUSB_CON_HDLC, 0x08); 1596 write_reg(hw, HFCUSB_INC_RES_F, 2); /* reset the fifo */ 1597 } 1598 1599 write_reg(hw, HFCUSB_SCTRL_R, 0); /* disable both B receivers */ 1600 handle_led(hw, LED_POWER_ON); 1601 } 1602 1603 /* start USB data pipes dependand on device's endpoint configuration */ 1604 static void 1605 hfcsusb_start_endpoint(struct hfcsusb *hw, int channel) 1606 { 1607 /* quick check if endpoint already running */ 1608 if ((channel == HFC_CHAN_D) && (hw->fifos[HFCUSB_D_RX].active)) 1609 return; 1610 if ((channel == HFC_CHAN_B1) && (hw->fifos[HFCUSB_B1_RX].active)) 1611 return; 1612 if ((channel == HFC_CHAN_B2) && (hw->fifos[HFCUSB_B2_RX].active)) 1613 return; 1614 if ((channel == HFC_CHAN_E) && (hw->fifos[HFCUSB_PCM_RX].active)) 1615 return; 1616 1617 /* start rx endpoints using USB INT IN method */ 1618 if (hw->cfg_used == CNF_3INT3ISO || hw->cfg_used == CNF_4INT3ISO) 1619 start_int_fifo(hw->fifos + channel * 2 + 1); 1620 1621 /* start rx endpoints using USB ISO IN method */ 1622 if (hw->cfg_used == CNF_3ISO3ISO || hw->cfg_used == CNF_4ISO3ISO) { 1623 switch (channel) { 1624 case HFC_CHAN_D: 1625 start_isoc_chain(hw->fifos + HFCUSB_D_RX, 1626 ISOC_PACKETS_D, 1627 (usb_complete_t)rx_iso_complete, 1628 16); 1629 break; 1630 case HFC_CHAN_E: 1631 start_isoc_chain(hw->fifos + HFCUSB_PCM_RX, 1632 ISOC_PACKETS_D, 1633 (usb_complete_t)rx_iso_complete, 1634 16); 1635 break; 1636 case HFC_CHAN_B1: 1637 start_isoc_chain(hw->fifos + HFCUSB_B1_RX, 1638 ISOC_PACKETS_B, 1639 (usb_complete_t)rx_iso_complete, 1640 16); 1641 break; 1642 case HFC_CHAN_B2: 1643 start_isoc_chain(hw->fifos + HFCUSB_B2_RX, 1644 ISOC_PACKETS_B, 1645 (usb_complete_t)rx_iso_complete, 1646 16); 1647 break; 1648 } 1649 } 1650 1651 /* start tx endpoints using USB ISO OUT method */ 1652 switch (channel) { 1653 case HFC_CHAN_D: 1654 start_isoc_chain(hw->fifos + HFCUSB_D_TX, 1655 ISOC_PACKETS_B, 1656 (usb_complete_t)tx_iso_complete, 1); 1657 break; 1658 case HFC_CHAN_B1: 1659 start_isoc_chain(hw->fifos + HFCUSB_B1_TX, 1660 ISOC_PACKETS_D, 1661 (usb_complete_t)tx_iso_complete, 1); 1662 break; 1663 case HFC_CHAN_B2: 1664 start_isoc_chain(hw->fifos + HFCUSB_B2_TX, 1665 ISOC_PACKETS_B, 1666 (usb_complete_t)tx_iso_complete, 1); 1667 break; 1668 } 1669 } 1670 1671 /* stop USB data pipes dependand on device's endpoint configuration */ 1672 static void 1673 hfcsusb_stop_endpoint(struct hfcsusb *hw, int channel) 1674 { 1675 /* quick check if endpoint currently running */ 1676 if ((channel == HFC_CHAN_D) && (!hw->fifos[HFCUSB_D_RX].active)) 1677 return; 1678 if ((channel == HFC_CHAN_B1) && (!hw->fifos[HFCUSB_B1_RX].active)) 1679 return; 1680 if ((channel == HFC_CHAN_B2) && (!hw->fifos[HFCUSB_B2_RX].active)) 1681 return; 1682 if ((channel == HFC_CHAN_E) && (!hw->fifos[HFCUSB_PCM_RX].active)) 1683 return; 1684 1685 /* rx endpoints using USB INT IN method */ 1686 if (hw->cfg_used == CNF_3INT3ISO || hw->cfg_used == CNF_4INT3ISO) 1687 stop_int_gracefull(hw->fifos + channel * 2 + 1); 1688 1689 /* rx endpoints using USB ISO IN method */ 1690 if (hw->cfg_used == CNF_3ISO3ISO || hw->cfg_used == CNF_4ISO3ISO) 1691 stop_iso_gracefull(hw->fifos + channel * 2 + 1); 1692 1693 /* tx endpoints using USB ISO OUT method */ 1694 if (channel != HFC_CHAN_E) 1695 stop_iso_gracefull(hw->fifos + channel * 2); 1696 } 1697 1698 1699 /* Hardware Initialization */ 1700 static int 1701 setup_hfcsusb(struct hfcsusb *hw) 1702 { 1703 u_char b; 1704 1705 if (debug & DBG_HFC_CALL_TRACE) 1706 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__); 1707 1708 /* check the chip id */ 1709 if (read_reg_atomic(hw, HFCUSB_CHIP_ID, &b) != 1) { 1710 printk(KERN_DEBUG "%s: %s: cannot read chip id\n", 1711 hw->name, __func__); 1712 return 1; 1713 } 1714 if (b != HFCUSB_CHIPID) { 1715 printk(KERN_DEBUG "%s: %s: Invalid chip id 0x%02x\n", 1716 hw->name, __func__, b); 1717 return 1; 1718 } 1719 1720 /* first set the needed config, interface and alternate */ 1721 (void) usb_set_interface(hw->dev, hw->if_used, hw->alt_used); 1722 1723 hw->led_state = 0; 1724 1725 /* init the background machinery for control requests */ 1726 hw->ctrl_read.bRequestType = 0xc0; 1727 hw->ctrl_read.bRequest = 1; 1728 hw->ctrl_read.wLength = cpu_to_le16(1); 1729 hw->ctrl_write.bRequestType = 0x40; 1730 hw->ctrl_write.bRequest = 0; 1731 hw->ctrl_write.wLength = 0; 1732 usb_fill_control_urb(hw->ctrl_urb, hw->dev, hw->ctrl_out_pipe, 1733 (u_char *)&hw->ctrl_write, NULL, 0, 1734 (usb_complete_t)ctrl_complete, hw); 1735 1736 reset_hfcsusb(hw); 1737 return 0; 1738 } 1739 1740 static void 1741 release_hw(struct hfcsusb *hw) 1742 { 1743 if (debug & DBG_HFC_CALL_TRACE) 1744 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__); 1745 1746 /* 1747 * stop all endpoints gracefully 1748 * TODO: mISDN_core should generate CLOSE_CHANNEL 1749 * signals after calling mISDN_unregister_device() 1750 */ 1751 hfcsusb_stop_endpoint(hw, HFC_CHAN_D); 1752 hfcsusb_stop_endpoint(hw, HFC_CHAN_B1); 1753 hfcsusb_stop_endpoint(hw, HFC_CHAN_B2); 1754 if (hw->fifos[HFCUSB_PCM_RX].pipe) 1755 hfcsusb_stop_endpoint(hw, HFC_CHAN_E); 1756 if (hw->protocol == ISDN_P_TE_S0) 1757 l1_event(hw->dch.l1, CLOSE_CHANNEL); 1758 1759 mISDN_unregister_device(&hw->dch.dev); 1760 mISDN_freebchannel(&hw->bch[1]); 1761 mISDN_freebchannel(&hw->bch[0]); 1762 mISDN_freedchannel(&hw->dch); 1763 1764 if (hw->ctrl_urb) { 1765 usb_kill_urb(hw->ctrl_urb); 1766 usb_free_urb(hw->ctrl_urb); 1767 hw->ctrl_urb = NULL; 1768 } 1769 1770 if (hw->intf) 1771 usb_set_intfdata(hw->intf, NULL); 1772 list_del(&hw->list); 1773 kfree(hw); 1774 hw = NULL; 1775 } 1776 1777 static void 1778 deactivate_bchannel(struct bchannel *bch) 1779 { 1780 struct hfcsusb *hw = bch->hw; 1781 u_long flags; 1782 1783 if (bch->debug & DEBUG_HW) 1784 printk(KERN_DEBUG "%s: %s: bch->nr(%i)\n", 1785 hw->name, __func__, bch->nr); 1786 1787 spin_lock_irqsave(&hw->lock, flags); 1788 mISDN_clear_bchannel(bch); 1789 spin_unlock_irqrestore(&hw->lock, flags); 1790 hfcsusb_setup_bch(bch, ISDN_P_NONE); 1791 hfcsusb_stop_endpoint(hw, bch->nr - 1); 1792 } 1793 1794 /* 1795 * Layer 1 B-channel hardware access 1796 */ 1797 static int 1798 hfc_bctrl(struct mISDNchannel *ch, u_int cmd, void *arg) 1799 { 1800 struct bchannel *bch = container_of(ch, struct bchannel, ch); 1801 int ret = -EINVAL; 1802 1803 if (bch->debug & DEBUG_HW) 1804 printk(KERN_DEBUG "%s: cmd:%x %p\n", __func__, cmd, arg); 1805 1806 switch (cmd) { 1807 case HW_TESTRX_RAW: 1808 case HW_TESTRX_HDLC: 1809 case HW_TESTRX_OFF: 1810 ret = -EINVAL; 1811 break; 1812 1813 case CLOSE_CHANNEL: 1814 test_and_clear_bit(FLG_OPEN, &bch->Flags); 1815 deactivate_bchannel(bch); 1816 ch->protocol = ISDN_P_NONE; 1817 ch->peer = NULL; 1818 module_put(THIS_MODULE); 1819 ret = 0; 1820 break; 1821 case CONTROL_CHANNEL: 1822 ret = channel_bctrl(bch, arg); 1823 break; 1824 default: 1825 printk(KERN_WARNING "%s: unknown prim(%x)\n", 1826 __func__, cmd); 1827 } 1828 return ret; 1829 } 1830 1831 static int 1832 setup_instance(struct hfcsusb *hw, struct device *parent) 1833 { 1834 u_long flags; 1835 int err, i; 1836 1837 if (debug & DBG_HFC_CALL_TRACE) 1838 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__); 1839 1840 spin_lock_init(&hw->ctrl_lock); 1841 spin_lock_init(&hw->lock); 1842 1843 mISDN_initdchannel(&hw->dch, MAX_DFRAME_LEN_L1, ph_state); 1844 hw->dch.debug = debug & 0xFFFF; 1845 hw->dch.hw = hw; 1846 hw->dch.dev.Dprotocols = (1 << ISDN_P_TE_S0) | (1 << ISDN_P_NT_S0); 1847 hw->dch.dev.D.send = hfcusb_l2l1D; 1848 hw->dch.dev.D.ctrl = hfc_dctrl; 1849 1850 /* enable E-Channel logging */ 1851 if (hw->fifos[HFCUSB_PCM_RX].pipe) 1852 mISDN_initdchannel(&hw->ech, MAX_DFRAME_LEN_L1, NULL); 1853 1854 hw->dch.dev.Bprotocols = (1 << (ISDN_P_B_RAW & ISDN_P_B_MASK)) | 1855 (1 << (ISDN_P_B_HDLC & ISDN_P_B_MASK)); 1856 hw->dch.dev.nrbchan = 2; 1857 for (i = 0; i < 2; i++) { 1858 hw->bch[i].nr = i + 1; 1859 set_channelmap(i + 1, hw->dch.dev.channelmap); 1860 hw->bch[i].debug = debug; 1861 mISDN_initbchannel(&hw->bch[i], MAX_DATA_MEM, poll >> 1); 1862 hw->bch[i].hw = hw; 1863 hw->bch[i].ch.send = hfcusb_l2l1B; 1864 hw->bch[i].ch.ctrl = hfc_bctrl; 1865 hw->bch[i].ch.nr = i + 1; 1866 list_add(&hw->bch[i].ch.list, &hw->dch.dev.bchannels); 1867 } 1868 1869 hw->fifos[HFCUSB_B1_TX].bch = &hw->bch[0]; 1870 hw->fifos[HFCUSB_B1_RX].bch = &hw->bch[0]; 1871 hw->fifos[HFCUSB_B2_TX].bch = &hw->bch[1]; 1872 hw->fifos[HFCUSB_B2_RX].bch = &hw->bch[1]; 1873 hw->fifos[HFCUSB_D_TX].dch = &hw->dch; 1874 hw->fifos[HFCUSB_D_RX].dch = &hw->dch; 1875 hw->fifos[HFCUSB_PCM_RX].ech = &hw->ech; 1876 hw->fifos[HFCUSB_PCM_TX].ech = &hw->ech; 1877 1878 err = setup_hfcsusb(hw); 1879 if (err) 1880 goto out; 1881 1882 snprintf(hw->name, MISDN_MAX_IDLEN - 1, "%s.%d", DRIVER_NAME, 1883 hfcsusb_cnt + 1); 1884 printk(KERN_INFO "%s: registered as '%s'\n", 1885 DRIVER_NAME, hw->name); 1886 1887 err = mISDN_register_device(&hw->dch.dev, parent, hw->name); 1888 if (err) 1889 goto out; 1890 1891 hfcsusb_cnt++; 1892 write_lock_irqsave(&HFClock, flags); 1893 list_add_tail(&hw->list, &HFClist); 1894 write_unlock_irqrestore(&HFClock, flags); 1895 return 0; 1896 1897 out: 1898 mISDN_freebchannel(&hw->bch[1]); 1899 mISDN_freebchannel(&hw->bch[0]); 1900 mISDN_freedchannel(&hw->dch); 1901 kfree(hw); 1902 return err; 1903 } 1904 1905 static int 1906 hfcsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) 1907 { 1908 struct hfcsusb *hw; 1909 struct usb_device *dev = interface_to_usbdev(intf); 1910 struct usb_host_interface *iface = intf->cur_altsetting; 1911 struct usb_host_interface *iface_used = NULL; 1912 struct usb_host_endpoint *ep; 1913 struct hfcsusb_vdata *driver_info; 1914 int ifnum = iface->desc.bInterfaceNumber, i, idx, alt_idx, 1915 probe_alt_setting, vend_idx, cfg_used, *vcf, attr, cfg_found, 1916 ep_addr, cmptbl[16], small_match, iso_packet_size, packet_size, 1917 alt_used = 0; 1918 1919 vend_idx = 0xffff; 1920 for (i = 0; hfcsusb_idtab[i].idVendor; i++) { 1921 if ((le16_to_cpu(dev->descriptor.idVendor) 1922 == hfcsusb_idtab[i].idVendor) && 1923 (le16_to_cpu(dev->descriptor.idProduct) 1924 == hfcsusb_idtab[i].idProduct)) { 1925 vend_idx = i; 1926 continue; 1927 } 1928 } 1929 1930 printk(KERN_DEBUG 1931 "%s: interface(%d) actalt(%d) minor(%d) vend_idx(%d)\n", 1932 __func__, ifnum, iface->desc.bAlternateSetting, 1933 intf->minor, vend_idx); 1934 1935 if (vend_idx == 0xffff) { 1936 printk(KERN_WARNING 1937 "%s: no valid vendor found in USB descriptor\n", 1938 __func__); 1939 return -EIO; 1940 } 1941 /* if vendor and product ID is OK, start probing alternate settings */ 1942 alt_idx = 0; 1943 small_match = -1; 1944 1945 /* default settings */ 1946 iso_packet_size = 16; 1947 packet_size = 64; 1948 1949 while (alt_idx < intf->num_altsetting) { 1950 iface = intf->altsetting + alt_idx; 1951 probe_alt_setting = iface->desc.bAlternateSetting; 1952 cfg_used = 0; 1953 1954 while (validconf[cfg_used][0]) { 1955 cfg_found = 1; 1956 vcf = validconf[cfg_used]; 1957 ep = iface->endpoint; 1958 memcpy(cmptbl, vcf, 16 * sizeof(int)); 1959 1960 /* check for all endpoints in this alternate setting */ 1961 for (i = 0; i < iface->desc.bNumEndpoints; i++) { 1962 ep_addr = ep->desc.bEndpointAddress; 1963 1964 /* get endpoint base */ 1965 idx = ((ep_addr & 0x7f) - 1) * 2; 1966 if (ep_addr & 0x80) 1967 idx++; 1968 attr = ep->desc.bmAttributes; 1969 1970 if (cmptbl[idx] != EP_NOP) { 1971 if (cmptbl[idx] == EP_NUL) 1972 cfg_found = 0; 1973 if (attr == USB_ENDPOINT_XFER_INT 1974 && cmptbl[idx] == EP_INT) 1975 cmptbl[idx] = EP_NUL; 1976 if (attr == USB_ENDPOINT_XFER_BULK 1977 && cmptbl[idx] == EP_BLK) 1978 cmptbl[idx] = EP_NUL; 1979 if (attr == USB_ENDPOINT_XFER_ISOC 1980 && cmptbl[idx] == EP_ISO) 1981 cmptbl[idx] = EP_NUL; 1982 1983 if (attr == USB_ENDPOINT_XFER_INT && 1984 ep->desc.bInterval < vcf[17]) { 1985 cfg_found = 0; 1986 } 1987 } 1988 ep++; 1989 } 1990 1991 for (i = 0; i < 16; i++) 1992 if (cmptbl[i] != EP_NOP && cmptbl[i] != EP_NUL) 1993 cfg_found = 0; 1994 1995 if (cfg_found) { 1996 if (small_match < cfg_used) { 1997 small_match = cfg_used; 1998 alt_used = probe_alt_setting; 1999 iface_used = iface; 2000 } 2001 } 2002 cfg_used++; 2003 } 2004 alt_idx++; 2005 } /* (alt_idx < intf->num_altsetting) */ 2006 2007 /* not found a valid USB Ta Endpoint config */ 2008 if (small_match == -1) 2009 return -EIO; 2010 2011 iface = iface_used; 2012 hw = kzalloc(sizeof(struct hfcsusb), GFP_KERNEL); 2013 if (!hw) 2014 return -ENOMEM; /* got no mem */ 2015 snprintf(hw->name, MISDN_MAX_IDLEN - 1, "%s", DRIVER_NAME); 2016 2017 ep = iface->endpoint; 2018 vcf = validconf[small_match]; 2019 2020 for (i = 0; i < iface->desc.bNumEndpoints; i++) { 2021 struct usb_fifo *f; 2022 2023 ep_addr = ep->desc.bEndpointAddress; 2024 /* get endpoint base */ 2025 idx = ((ep_addr & 0x7f) - 1) * 2; 2026 if (ep_addr & 0x80) 2027 idx++; 2028 f = &hw->fifos[idx & 7]; 2029 2030 /* init Endpoints */ 2031 if (vcf[idx] == EP_NOP || vcf[idx] == EP_NUL) { 2032 ep++; 2033 continue; 2034 } 2035 switch (ep->desc.bmAttributes) { 2036 case USB_ENDPOINT_XFER_INT: 2037 f->pipe = usb_rcvintpipe(dev, 2038 ep->desc.bEndpointAddress); 2039 f->usb_transfer_mode = USB_INT; 2040 packet_size = le16_to_cpu(ep->desc.wMaxPacketSize); 2041 break; 2042 case USB_ENDPOINT_XFER_BULK: 2043 if (ep_addr & 0x80) 2044 f->pipe = usb_rcvbulkpipe(dev, 2045 ep->desc.bEndpointAddress); 2046 else 2047 f->pipe = usb_sndbulkpipe(dev, 2048 ep->desc.bEndpointAddress); 2049 f->usb_transfer_mode = USB_BULK; 2050 packet_size = le16_to_cpu(ep->desc.wMaxPacketSize); 2051 break; 2052 case USB_ENDPOINT_XFER_ISOC: 2053 if (ep_addr & 0x80) 2054 f->pipe = usb_rcvisocpipe(dev, 2055 ep->desc.bEndpointAddress); 2056 else 2057 f->pipe = usb_sndisocpipe(dev, 2058 ep->desc.bEndpointAddress); 2059 f->usb_transfer_mode = USB_ISOC; 2060 iso_packet_size = le16_to_cpu(ep->desc.wMaxPacketSize); 2061 break; 2062 default: 2063 f->pipe = 0; 2064 } 2065 2066 if (f->pipe) { 2067 f->fifonum = idx & 7; 2068 f->hw = hw; 2069 f->usb_packet_maxlen = 2070 le16_to_cpu(ep->desc.wMaxPacketSize); 2071 f->intervall = ep->desc.bInterval; 2072 } 2073 ep++; 2074 } 2075 hw->dev = dev; /* save device */ 2076 hw->if_used = ifnum; /* save used interface */ 2077 hw->alt_used = alt_used; /* and alternate config */ 2078 hw->ctrl_paksize = dev->descriptor.bMaxPacketSize0; /* control size */ 2079 hw->cfg_used = vcf[16]; /* store used config */ 2080 hw->vend_idx = vend_idx; /* store found vendor */ 2081 hw->packet_size = packet_size; 2082 hw->iso_packet_size = iso_packet_size; 2083 2084 /* create the control pipes needed for register access */ 2085 hw->ctrl_in_pipe = usb_rcvctrlpipe(hw->dev, 0); 2086 hw->ctrl_out_pipe = usb_sndctrlpipe(hw->dev, 0); 2087 2088 driver_info = (struct hfcsusb_vdata *) 2089 hfcsusb_idtab[vend_idx].driver_info; 2090 2091 hw->ctrl_urb = usb_alloc_urb(0, GFP_KERNEL); 2092 if (!hw->ctrl_urb) { 2093 pr_warn("%s: No memory for control urb\n", 2094 driver_info->vend_name); 2095 kfree(hw); 2096 return -ENOMEM; 2097 } 2098 2099 pr_info("%s: %s: detected \"%s\" (%s, if=%d alt=%d)\n", 2100 hw->name, __func__, driver_info->vend_name, 2101 conf_str[small_match], ifnum, alt_used); 2102 2103 if (setup_instance(hw, dev->dev.parent)) 2104 return -EIO; 2105 2106 hw->intf = intf; 2107 usb_set_intfdata(hw->intf, hw); 2108 return 0; 2109 } 2110 2111 /* function called when an active device is removed */ 2112 static void 2113 hfcsusb_disconnect(struct usb_interface *intf) 2114 { 2115 struct hfcsusb *hw = usb_get_intfdata(intf); 2116 struct hfcsusb *next; 2117 int cnt = 0; 2118 2119 printk(KERN_INFO "%s: device disconnected\n", hw->name); 2120 2121 handle_led(hw, LED_POWER_OFF); 2122 release_hw(hw); 2123 2124 list_for_each_entry_safe(hw, next, &HFClist, list) 2125 cnt++; 2126 if (!cnt) 2127 hfcsusb_cnt = 0; 2128 2129 usb_set_intfdata(intf, NULL); 2130 } 2131 2132 static struct usb_driver hfcsusb_drv = { 2133 .name = DRIVER_NAME, 2134 .id_table = hfcsusb_idtab, 2135 .probe = hfcsusb_probe, 2136 .disconnect = hfcsusb_disconnect, 2137 .disable_hub_initiated_lpm = 1, 2138 }; 2139 2140 module_usb_driver(hfcsusb_drv); 2141