drivers/isdn/hardware/mISDN/hfcsusb.c

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