2 * mISDN driver for Colognechip HFC-S USB chip
4 * Copyright 2001 by Peter Sprenger (sprenger@moving-bytes.de)
5 * Copyright 2008 by Martin Bachem (info@bachem-it.com)
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)
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.
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.
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
27 * poll=<n>, default 128
28 * n : burst size of PH_DATA_IND at transparent rx data
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>
39 static const char *hfcsusb_rev = "Revision: 0.3.3 (socket), 2008-11-05";
41 static unsigned int debug;
42 static int poll = DEFAULT_TRANSP_BURST_SZ;
44 static LIST_HEAD(HFClist);
45 static DEFINE_RWLOCK(HFClock);
48 MODULE_AUTHOR("Martin Bachem");
49 MODULE_LICENSE("GPL");
50 module_param(debug, uint, S_IRUGO | S_IWUSR);
51 module_param(poll, int, 0);
53 static int hfcsusb_cnt;
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);
66 /* start next background transfer for control channel */
68 ctrl_start_transfer(struct hfcsusb *hw)
70 if (debug & DBG_HFC_CALL_TRACE)
71 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
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);
83 usb_submit_urb(hw->ctrl_urb, GFP_ATOMIC);
88 * queue a control transfer request to write HFC-S USB
89 * chip register using CTRL resuest queue
91 static int write_reg(struct hfcsusb *hw, __u8 reg, __u8 val)
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);
99 spin_lock(&hw->ctrl_lock);
100 if (hw->ctrl_cnt >= HFC_CTRL_BUFSIZE) {
101 spin_unlock(&hw->ctrl_lock);
104 buf = &hw->ctrl_buff[hw->ctrl_in_idx];
107 if (++hw->ctrl_in_idx >= HFC_CTRL_BUFSIZE)
109 if (++hw->ctrl_cnt == 1)
110 ctrl_start_transfer(hw);
111 spin_unlock(&hw->ctrl_lock);
116 /* control completion routine handling background control cmds */
118 ctrl_complete(struct urb *urb)
120 struct hfcsusb *hw = (struct hfcsusb *) urb->context;
121 struct ctrl_buf *buf;
123 if (debug & DBG_HFC_CALL_TRACE)
124 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
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 */
133 ctrl_start_transfer(hw); /* start next transfer */
137 /* handle LED bits */
139 set_led_bit(struct hfcsusb *hw, signed short led_bits, int set_on)
143 hw->led_state &= ~abs(led_bits);
145 hw->led_state |= led_bits;
148 hw->led_state |= abs(led_bits);
150 hw->led_state &= ~led_bits;
154 /* handle LED requests */
156 handle_led(struct hfcsusb *hw, int event)
158 struct hfcsusb_vdata *driver_info = (struct hfcsusb_vdata *)
159 hfcsusb_idtab[hw->vend_idx].driver_info;
162 if (driver_info->led_scheme == LED_OFF)
164 tmpled = hw->led_state;
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);
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);
180 set_led_bit(hw, driver_info->led_bits[1], 1);
183 set_led_bit(hw, driver_info->led_bits[1], 0);
186 set_led_bit(hw, driver_info->led_bits[2], 1);
189 set_led_bit(hw, driver_info->led_bits[2], 0);
192 set_led_bit(hw, driver_info->led_bits[3], 1);
195 set_led_bit(hw, driver_info->led_bits[3], 0);
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",
203 HFCUSB_P_DATA, hw->led_state);
205 write_reg(hw, HFCUSB_P_DATA, hw->led_state);
210 * Layer2 -> Layer 1 Bchannel data
213 hfcusb_l2l1B(struct mISDNchannel *ch, struct sk_buff *skb)
215 struct bchannel *bch = container_of(ch, struct bchannel, ch);
216 struct hfcsusb *hw = bch->hw;
218 struct mISDNhead *hh = mISDN_HEAD_P(skb);
221 if (debug & DBG_HFC_CALL_TRACE)
222 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
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);
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()
238 queue_ch_frame(ch, PH_DATA_CNF, hh->id, NULL);
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);
249 _queue_data(ch, PH_ACTIVATE_IND, MISDN_ID_ANY,
250 0, NULL, GFP_KERNEL);
252 case PH_DEACTIVATE_REQ:
253 deactivate_bchannel(bch);
254 _queue_data(ch, PH_DEACTIVATE_IND, MISDN_ID_ANY,
255 0, NULL, GFP_KERNEL);
265 * send full D/B channel status information
266 * as MPH_INFORMATION_IND
269 hfcsusb_ph_info(struct hfcsusb *hw)
272 struct dchannel *dch = &hw->dch;
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;
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);
291 * Layer2 -> Layer 1 Dchannel data
294 hfcusb_l2l1D(struct mISDNchannel *ch, struct sk_buff *skb)
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;
305 if (debug & DBG_HFC_CALL_TRACE)
306 printk(KERN_DEBUG "%s: %s: PH_DATA_REQ\n",
309 spin_lock_irqsave(&hw->lock, flags);
310 ret = dchannel_senddata(dch, skb);
311 spin_unlock_irqrestore(&hw->lock, flags);
314 queue_ch_frame(ch, PH_DATA_CNF, hh->id, NULL);
318 case PH_ACTIVATE_REQ:
319 if (debug & DBG_HFC_CALL_TRACE)
320 printk(KERN_DEBUG "%s: %s: PH_ACTIVATE_REQ %s\n",
322 (hw->protocol == ISDN_P_NT_S0) ? "NT" : "TE");
324 if (hw->protocol == ISDN_P_NT_S0) {
326 if (test_bit(FLG_ACTIVE, &dch->Flags)) {
327 _queue_data(&dch->dev.D,
328 PH_ACTIVATE_IND, MISDN_ID_ANY, 0,
331 hfcsusb_ph_command(hw,
333 test_and_set_bit(FLG_L2_ACTIVATED,
337 hfcsusb_ph_command(hw, HFC_L1_ACTIVATE_TE);
338 ret = l1_event(dch->l1, hh->prim);
342 case PH_DEACTIVATE_REQ:
343 if (debug & DBG_HFC_CALL_TRACE)
344 printk(KERN_DEBUG "%s: %s: PH_DEACTIVATE_REQ\n",
346 test_and_clear_bit(FLG_L2_ACTIVATED, &dch->Flags);
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);
353 dev_kfree_skb(dch->tx_skb);
358 dev_kfree_skb(dch->rx_skb);
361 test_and_clear_bit(FLG_TX_BUSY, &dch->Flags);
362 spin_unlock_irqrestore(&hw->lock, flags);
364 if (test_and_clear_bit(FLG_L1_BUSY, &dch->Flags))
365 dchannel_sched_event(&hc->dch, D_CLEARBUSY);
369 ret = l1_event(dch->l1, hh->prim);
371 case MPH_INFORMATION_REQ:
381 * Layer 1 callback function
384 hfc_l1callback(struct dchannel *dch, u_int cmd)
386 struct hfcsusb *hw = dch->hw;
388 if (debug & DBG_HFC_CALL_TRACE)
389 printk(KERN_DEBUG "%s: %s cmd 0x%x\n",
390 hw->name, __func__, cmd);
400 skb_queue_purge(&dch->squeue);
402 dev_kfree_skb(dch->tx_skb);
407 dev_kfree_skb(dch->rx_skb);
410 test_and_clear_bit(FLG_TX_BUSY, &dch->Flags);
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,
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,
423 if (dch->debug & DEBUG_HW)
424 printk(KERN_DEBUG "%s: %s: unknown cmd %x\n",
425 hw->name, __func__, cmd);
433 open_dchannel(struct hfcsusb *hw, struct mISDNchannel *ch,
434 struct channel_req *rq)
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)
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);
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);
461 hw->protocol = rq->protocol;
462 if (rq->protocol == ISDN_P_TE_S0) {
463 err = create_l1(&hw->dch, hfc_l1callback);
468 ch->protocol = rq->protocol;
471 if (rq->protocol != ch->protocol)
472 return -EPROTONOSUPPORT;
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);
480 if (!try_module_get(THIS_MODULE))
481 printk(KERN_WARNING "%s: %s: cannot get module\n",
487 open_bchannel(struct hfcsusb *hw, struct channel_req *rq)
489 struct bchannel *bch;
491 if (rq->adr.channel > 2)
493 if (rq->protocol == ISDN_P_NONE)
496 if (debug & DBG_HFC_CALL_TRACE)
497 printk(KERN_DEBUG "%s: %s B%i\n",
498 hw->name, __func__, rq->adr.channel);
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;
507 /* start USB endpoint for bchannel */
508 if (rq->adr.channel == 1)
509 hfcsusb_start_endpoint(hw, HFC_CHAN_B1);
511 hfcsusb_start_endpoint(hw, HFC_CHAN_B2);
513 if (!try_module_get(THIS_MODULE))
514 printk(KERN_WARNING "%s: %s:cannot get module\n",
520 channel_ctrl(struct hfcsusb *hw, struct mISDN_ctrl_req *cq)
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));
529 case MISDN_CTRL_GETOP:
530 cq->op = MISDN_CTRL_LOOP | MISDN_CTRL_CONNECT |
531 MISDN_CTRL_DISCONNECT;
534 printk(KERN_WARNING "%s: %s: unknown Op %x\n",
535 hw->name, __func__, cq->op);
543 * device control function
546 hfc_dctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
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;
554 if (dch->debug & DEBUG_HW)
555 printk(KERN_DEBUG "%s: %s: cmd:%x %p\n",
556 hw->name, __func__, cmd, arg);
560 if ((rq->protocol == ISDN_P_TE_S0) ||
561 (rq->protocol == ISDN_P_NT_S0))
562 err = open_dchannel(hw, ch, rq);
564 err = open_bchannel(hw, rq);
570 if (debug & DEBUG_HW_OPEN)
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);
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);
581 module_put(THIS_MODULE);
583 case CONTROL_CHANNEL:
584 err = channel_ctrl(hw, arg);
587 if (dch->debug & DEBUG_HW)
588 printk(KERN_DEBUG "%s: %s: unknown command %x\n",
589 hw->name, __func__, cmd);
596 * S0 TE state change event handler
599 ph_state_te(struct dchannel *dch)
601 struct hfcsusb *hw = dch->hw;
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]);
608 printk(KERN_DEBUG "%s: %s: TE F%d\n",
609 hw->name, __func__, dch->state);
612 switch (dch->state) {
614 l1_event(dch->l1, HW_RESET_IND);
617 l1_event(dch->l1, HW_DEACT_IND);
621 l1_event(dch->l1, ANYSIGNAL);
624 l1_event(dch->l1, INFO2);
627 l1_event(dch->l1, INFO4_P8);
631 handle_led(hw, LED_S0_ON);
633 handle_led(hw, LED_S0_OFF);
637 * S0 NT state change event handler
640 ph_state_nt(struct dchannel *dch)
642 struct hfcsusb *hw = dch->hw;
644 if (debug & DEBUG_HW) {
645 if (dch->state <= HFC_MAX_NT_LAYER1_STATE)
646 printk(KERN_DEBUG "%s: %s: %s\n",
648 HFC_NT_LAYER1_STATES[dch->state]);
651 printk(KERN_INFO DRIVER_NAME "%s: %s: NT G%d\n",
652 hw->name, __func__, dch->state);
655 switch (dch->state) {
657 test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
658 test_and_clear_bit(FLG_L2_ACTIVATED, &dch->Flags);
660 hw->timers &= ~NT_ACTIVATION_TIMER;
661 handle_led(hw, LED_S0_OFF);
665 if (hw->nt_timer < 0) {
667 hw->timers &= ~NT_ACTIVATION_TIMER;
668 hfcsusb_ph_command(dch->hw, HFC_L1_DEACTIVATE_NT);
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);
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);
686 hw->timers &= ~NT_ACTIVATION_TIMER;
695 ph_state(struct dchannel *dch)
697 struct hfcsusb *hw = dch->hw;
699 if (hw->protocol == ISDN_P_NT_S0)
701 else if (hw->protocol == ISDN_P_TE_S0)
706 * disable/enable BChannel for desired protocoll
709 hfcsusb_setup_bch(struct bchannel *bch, int protocol)
711 struct hfcsusb *hw = bch->hw;
712 __u8 conhdlc, sctrl, sctrl_r;
714 if (debug & DEBUG_HW)
715 printk(KERN_DEBUG "%s: %s: protocol %x-->%x B%d\n",
716 hw->name, __func__, bch->state, protocol,
719 /* setup val for CON_HDLC */
721 if (protocol > ISDN_P_NONE)
722 conhdlc = 8; /* enable FIFO */
725 case (-1): /* used for init */
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);
737 bch->state = protocol;
738 set_bit(FLG_TRANSPARENT, &bch->Flags);
740 case (ISDN_P_B_HDLC):
741 bch->state = protocol;
742 set_bit(FLG_HDLC, &bch->Flags);
745 if (debug & DEBUG_HW)
746 printk(KERN_DEBUG "%s: %s: prot not known %x\n",
747 hw->name, __func__, protocol);
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);
759 sctrl = 0x40 + ((hw->protocol == ISDN_P_TE_S0) ? 0x00 : 0x04);
761 if (test_bit(FLG_ACTIVE, &hw->bch[0].Flags)) {
765 if (test_bit(FLG_ACTIVE, &hw->bch[1].Flags)) {
769 write_reg(hw, HFCUSB_SCTRL, sctrl);
770 write_reg(hw, HFCUSB_SCTRL_R, sctrl_r);
772 if (protocol > ISDN_P_NONE)
773 handle_led(hw, (bch->nr == 1) ? LED_B1_ON : LED_B2_ON);
775 handle_led(hw, (bch->nr == 1) ? LED_B1_OFF :
783 hfcsusb_ph_command(struct hfcsusb *hw, u_char command)
785 if (debug & DEBUG_HW)
786 printk(KERN_DEBUG "%s: %s: %x\n",
787 hw->name, __func__, 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);
797 case HFC_L1_FORCE_DEACTIVATE_TE:
798 write_reg(hw, HFCUSB_STATES, 0x10);
799 write_reg(hw, HFCUSB_STATES, 0x03);
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);
807 write_reg(hw, HFCUSB_STATES, HFCUSB_ACTIVATE |
808 HFCUSB_DO_ACTION | HFCUSB_NT_G2_G3);
811 case HFC_L1_DEACTIVATE_NT:
812 write_reg(hw, HFCUSB_STATES,
819 * Layer 1 B-channel hardware access
822 channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq)
827 case MISDN_CTRL_GETOP:
828 cq->op = MISDN_CTRL_FILL_EMPTY;
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);
837 printk(KERN_WARNING "%s: unknown Op %x\n", __func__, cq->op);
844 /* collect data from incoming interrupt or isochron USB data */
846 hfcsusb_rx_frame(struct usb_fifo *fifo, __u8 *data, unsigned int len,
849 struct hfcsusb *hw = fifo->hw;
850 struct sk_buff *rx_skb = NULL;
852 int fifon = fifo->fifonum;
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);
865 if ((!!fifo->dch + !!fifo->bch + !!fifo->ech) != 1) {
866 printk(KERN_DEBUG "%s: %s: undefined channel\n",
871 spin_lock(&hw->lock);
873 rx_skb = fifo->dch->rx_skb;
874 maxlen = fifo->dch->maxlen;
878 rx_skb = fifo->bch->rx_skb;
879 maxlen = fifo->bch->maxlen;
880 hdlc = test_bit(FLG_HDLC, &fifo->bch->Flags);
883 rx_skb = fifo->ech->rx_skb;
884 maxlen = fifo->ech->maxlen;
889 rx_skb = mI_alloc_skb(maxlen, GFP_ATOMIC);
892 fifo->dch->rx_skb = rx_skb;
894 fifo->bch->rx_skb = rx_skb;
896 fifo->ech->rx_skb = rx_skb;
899 printk(KERN_DEBUG "%s: %s: No mem for rx_skb\n",
901 spin_unlock(&hw->lock);
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);
913 spin_unlock(&hw->lock);
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);
923 spin_unlock(&hw->lock);
928 memcpy(skb_put(rx_skb, len), data, len);
931 /* we have a complete hdlc packet */
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)"
938 hw->name, __func__, fifon,
941 while (i < rx_skb->len)
947 /* remove CRC & status */
948 skb_trim(rx_skb, rx_skb->len - 3);
951 recv_Dchannel(fifo->dch);
953 recv_Bchannel(fifo->bch, MISDN_ID_ANY);
955 recv_Echannel(fifo->ech,
958 if (debug & DBG_HFC_FIFO_VERBOSE) {
960 "%s: CRC or minlen ERROR fifon(%i) "
962 hw->name, fifon, rx_skb->len);
964 while (i < rx_skb->len)
973 /* deliver transparent data to layer2 */
974 if (rx_skb->len >= poll)
975 recv_Bchannel(fifo->bch, MISDN_ID_ANY);
977 spin_unlock(&hw->lock);
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)
987 usb_fill_bulk_urb(urb, dev, pipe, buf, packet_size * num_packets,
990 urb->number_of_packets = num_packets;
991 urb->transfer_flags = URB_ISO_ASAP;
992 urb->actual_length = 0;
993 urb->interval = interval;
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;
1002 /* receive completion routine for all ISO tx fifos */
1004 rx_iso_complete(struct urb *urb)
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;
1015 fifon = fifo->fifonum;
1016 status = urb->status;
1018 spin_lock(&hw->lock);
1019 if (fifo->stop_gracefull) {
1020 fifo->stop_gracefull = 0;
1022 spin_unlock(&hw->lock);
1025 spin_unlock(&hw->lock);
1028 * ISO transfer only partially completed,
1029 * look at individual frame status for details
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);
1037 /* clear status, so go on with ISO transfers */
1042 if (fifo->active && !status) {
1043 num_isoc_packets = iso_packets[fifon];
1044 maxlen = fifo->usb_packet_maxlen;
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;
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);
1058 /* USB data log for every D ISO in */
1059 if ((fifon == HFCUSB_D_RX) &&
1060 (debug & DBG_HFC_USB_VERBOSE)) {
1062 "%s: %s: %d (%d/%d) len(%d) ",
1063 hw->name, __func__, urb->start_frame,
1064 k, num_isoc_packets-1,
1066 for (i = 0; i < len; i++)
1067 printk("%x ", buf[i]);
1072 if (fifo->last_urblen != maxlen) {
1074 * save fifo fill-level threshold bits
1075 * to use them later in TX ISO URB
1078 hw->threshold_mask = buf[1];
1080 if (fifon == HFCUSB_D_RX)
1081 s0_state = (buf[0] >> 4);
1083 eof[fifon] = buf[0] & 1;
1085 hfcsusb_rx_frame(fifo, buf + 2,
1086 len - 2, (len < maxlen)
1089 hfcsusb_rx_frame(fifo, buf, len,
1092 fifo->last_urblen = len;
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);
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);
1109 if (debug & DEBUG_HW)
1110 printk(KERN_DEBUG "%s: %s: error submitting "
1112 hw->name, __func__, errcode);
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);
1122 /* receive completion routine for all interrupt rx fifos */
1124 rx_int_complete(struct urb *urb)
1127 __u8 *buf, maxlen, fifon;
1128 struct usb_fifo *fifo = (struct usb_fifo *) urb->context;
1129 struct hfcsusb *hw = fifo->hw;
1132 spin_lock(&hw->lock);
1133 if (fifo->stop_gracefull) {
1134 fifo->stop_gracefull = 0;
1136 spin_unlock(&hw->lock);
1139 spin_unlock(&hw->lock);
1141 fifon = fifo->fifonum;
1142 if ((!fifo->active) || (urb->status)) {
1143 if (debug & DBG_HFC_URB_ERROR)
1145 "%s: %s: RX-Fifo %i is going down (%i)\n",
1146 hw->name, __func__, fifon, urb->status);
1148 fifo->urb->interval = 0; /* cancel automatic rescheduling */
1151 len = urb->actual_length;
1153 maxlen = fifo->usb_packet_maxlen;
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]);
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];
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);
1174 eof[fifon] = buf[0] & 1;
1175 /* if we have more than the 2 status bytes -> collect data */
1177 hfcsusb_rx_frame(fifo, buf + 2,
1178 urb->actual_length - 2,
1179 (len < maxlen) ? eof[fifon] : 0);
1181 hfcsusb_rx_frame(fifo, buf, urb->actual_length,
1182 (len < maxlen) ? eof[fifon] : 0);
1184 fifo->last_urblen = urb->actual_length;
1186 status = usb_submit_urb(urb, GFP_ATOMIC);
1188 if (debug & DEBUG_HW)
1189 printk(KERN_DEBUG "%s: %s: error resubmitting USB\n",
1190 hw->name, __func__);
1194 /* transmit completion routine for all ISO tx fifos */
1196 tx_iso_complete(struct urb *urb)
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,
1205 int frame_complete, fifon, status;
1208 spin_lock(&hw->lock);
1209 if (fifo->stop_gracefull) {
1210 fifo->stop_gracefull = 0;
1212 spin_unlock(&hw->lock);
1217 tx_skb = fifo->dch->tx_skb;
1218 tx_idx = &fifo->dch->tx_idx;
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);
1225 printk(KERN_DEBUG "%s: %s: neither BCH nor DCH\n",
1226 hw->name, __func__);
1227 spin_unlock(&hw->lock);
1231 fifon = fifo->fifonum;
1232 status = urb->status;
1237 * ISO transfer only partially completed,
1238 * look at individual frame status for details
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);
1246 /* clear status, so go on with ISO transfers */
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];
1255 /* predict dataflow to avoid fifo overflow */
1256 if (fifon >= HFCUSB_D_TX)
1257 sink = (threshbit) ? SINK_DMIN : SINK_DMAX;
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));
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;
1273 printk(KERN_DEBUG "%s: %s: "
1274 "ISO packet %i, status: %i\n",
1275 hw->name, __func__, k, errcode);
1279 /* Generate next ISO Packets */
1281 remain = tx_skb->len - *tx_idx;
1286 fifo->bit_line -= sink;
1287 current_len = (0 - fifo->bit_line) / 8;
1288 if (current_len > 14)
1290 if (current_len < 0)
1292 if (remain < current_len)
1293 current_len = remain;
1295 /* how much bit do we put on the line? */
1296 fifo->bit_line += current_len * 8;
1298 context_iso_urb->buffer[tx_offset] = 0;
1299 if (current_len == remain) {
1301 /* signal frame completion */
1303 buffer[tx_offset] = 1;
1304 /* add 2 byte flags and 16bit
1305 * CRC at end of ISDN frame */
1306 fifo->bit_line += 32;
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;
1316 urb->iso_frame_desc[k].offset = tx_offset;
1317 urb->iso_frame_desc[k].length = current_len + 1;
1319 /* USB data log for every D ISO out */
1320 if ((fifon == HFCUSB_D_RX) &&
1321 (debug & DBG_HFC_USB_VERBOSE)) {
1323 "%s: %s (%d/%d) offs(%d) len(%d) ",
1325 k, num_isoc_packets-1,
1326 urb->iso_frame_desc[k].offset,
1327 urb->iso_frame_desc[k].length);
1329 for (i = urb->iso_frame_desc[k].offset;
1330 i < (urb->iso_frame_desc[k].offset
1331 + urb->iso_frame_desc[k].length);
1334 context_iso_urb->buffer[i]);
1336 printk(" skb->len(%i) tx-idx(%d)\n",
1337 tx_skb->len, *tx_idx);
1340 tx_offset += (current_len + 1);
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;
1350 if (frame_complete) {
1353 if (debug & DBG_HFC_FIFO_VERBOSE) {
1354 printk(KERN_DEBUG "%s: %s: "
1355 "fifon(%i) new TX len(%i): ",
1357 fifon, tx_skb->len);
1359 while (i < tx_skb->len)
1365 dev_kfree_skb(tx_skb);
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,
1373 confirm_Bsend(fifo->bch);
1374 tx_skb = fifo->bch->tx_skb;
1378 errcode = usb_submit_urb(urb, GFP_ATOMIC);
1380 if (debug & DEBUG_HW)
1382 "%s: %s: error submitting ISO URB: %d \n",
1383 hw->name, __func__, errcode);
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)
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);
1398 if (status && (debug & DBG_HFC_URB_ERROR))
1399 printk(KERN_DEBUG "%s: %s: urb->status %s (%i)"
1402 symbolic(urb_errlist, status), status, fifon);
1404 spin_unlock(&hw->lock);
1408 * allocs urbs and start isoc transfer with two pending urbs to avoid
1409 * gaps in the transfer chain
1412 start_isoc_chain(struct usb_fifo *fifo, int num_packets_per_urb,
1413 usb_complete_t complete, int packet_size)
1415 struct hfcsusb *hw = fifo->hw;
1419 printk(KERN_DEBUG "%s: %s: fifo %i\n",
1420 hw->name, __func__, fifo->fifonum);
1422 /* allocate Memory for Iso out Urbs */
1423 for (i = 0; i < 2; i++) {
1424 if (!(fifo->iso[i].urb)) {
1426 usb_alloc_urb(num_packets_per_urb, GFP_KERNEL);
1427 if (!(fifo->iso[i].urb)) {
1429 "%s: %s: alloc urb for fifo %i failed",
1430 hw->name, __func__, fifo->fifonum);
1432 fifo->iso[i].owner_fifo = (struct usb_fifo *) fifo;
1433 fifo->iso[i].indx = i;
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,
1446 memset(fifo->iso[i].buffer, 0,
1447 sizeof(fifo->iso[i].buffer));
1449 for (k = 0; k < num_packets_per_urb; k++) {
1451 iso_frame_desc[k].offset =
1454 iso_frame_desc[k].length =
1459 "%s: %s: ISO Buffer size to small!\n",
1460 hw->name, __func__);
1463 fifo->bit_line = BITLINE_INF;
1465 errcode = usb_submit_urb(fifo->iso[i].urb, GFP_KERNEL);
1466 fifo->active = (errcode >= 0) ? 1 : 0;
1467 fifo->stop_gracefull = 0;
1469 printk(KERN_DEBUG "%s: %s: %s URB nr:%d\n",
1471 symbolic(urb_errlist, errcode), i);
1474 return fifo->active;
1478 stop_iso_gracefull(struct usb_fifo *fifo)
1480 struct hfcsusb *hw = fifo->hw;
1484 for (i = 0; i < 2; i++) {
1485 spin_lock_irqsave(&hw->lock, flags);
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);
1493 for (i = 0; i < 2; i++) {
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);
1504 stop_int_gracefull(struct usb_fifo *fifo)
1506 struct hfcsusb *hw = fifo->hw;
1510 spin_lock_irqsave(&hw->lock, flags);
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);
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);
1525 /* start the interrupt transfer for the given fifo */
1527 start_int_fifo(struct usb_fifo *fifo)
1529 struct hfcsusb *hw = fifo->hw;
1533 printk(KERN_DEBUG "%s: %s: INT IN fifo:%d\n",
1534 hw->name, __func__, fifo->fifonum);
1537 fifo->urb = usb_alloc_urb(0, GFP_KERNEL);
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);
1545 fifo->stop_gracefull = 0;
1546 errcode = usb_submit_urb(fifo->urb, GFP_KERNEL);
1548 printk(KERN_DEBUG "%s: %s: submit URB: status:%i\n",
1549 hw->name, __func__, errcode);
1555 setPortMode(struct hfcsusb *hw)
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");
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);
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);
1577 reset_hfcsusb(struct hfcsusb *hw)
1579 struct usb_fifo *fifo;
1582 if (debug & DEBUG_HW)
1583 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
1586 write_reg(hw, HFCUSB_CIRM, 8);
1588 /* aux = output, reset off */
1589 write_reg(hw, HFCUSB_CIRM, 0x10);
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));
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);
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 */
1602 /* init the fifos */
1603 write_reg(hw, HFCUSB_F_THRES,
1604 (HFCUSB_TX_THRESHOLD / 8) | ((HFCUSB_RX_THRESHOLD / 8) << 4));
1607 for (i = 0; i < HFCUSB_NUM_FIFOS; i++) {
1608 write_reg(hw, HFCUSB_FIFO, i); /* select the desired fifo */
1610 (i <= HFCUSB_B2_RX) ? MAX_BCH_SIZE : MAX_DFRAME_LEN;
1611 fifo[i].last_urblen = 0;
1613 /* set 2 bit for D- & E-channel */
1614 write_reg(hw, HFCUSB_HDLC_PAR, ((i <= HFCUSB_B2_RX) ? 0 : 2));
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);
1621 write_reg(hw, HFCUSB_CON_HDLC, 0x08);
1622 write_reg(hw, HFCUSB_INC_RES_F, 2); /* reset the fifo */
1625 write_reg(hw, HFCUSB_SCTRL_R, 0); /* disable both B receivers */
1626 handle_led(hw, LED_POWER_ON);
1629 /* start USB data pipes dependand on device's endpoint configuration */
1631 hfcsusb_start_endpoint(struct hfcsusb *hw, int channel)
1633 /* quick check if endpoint already running */
1634 if ((channel == HFC_CHAN_D) && (hw->fifos[HFCUSB_D_RX].active))
1636 if ((channel == HFC_CHAN_B1) && (hw->fifos[HFCUSB_B1_RX].active))
1638 if ((channel == HFC_CHAN_B2) && (hw->fifos[HFCUSB_B2_RX].active))
1640 if ((channel == HFC_CHAN_E) && (hw->fifos[HFCUSB_PCM_RX].active))
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);
1647 /* start rx endpoints using USB ISO IN method */
1648 if (hw->cfg_used == CNF_3ISO3ISO || hw->cfg_used == CNF_4ISO3ISO) {
1651 start_isoc_chain(hw->fifos + HFCUSB_D_RX,
1653 (usb_complete_t)rx_iso_complete,
1657 start_isoc_chain(hw->fifos + HFCUSB_PCM_RX,
1659 (usb_complete_t)rx_iso_complete,
1663 start_isoc_chain(hw->fifos + HFCUSB_B1_RX,
1665 (usb_complete_t)rx_iso_complete,
1669 start_isoc_chain(hw->fifos + HFCUSB_B2_RX,
1671 (usb_complete_t)rx_iso_complete,
1677 /* start tx endpoints using USB ISO OUT method */
1680 start_isoc_chain(hw->fifos + HFCUSB_D_TX,
1682 (usb_complete_t)tx_iso_complete, 1);
1685 start_isoc_chain(hw->fifos + HFCUSB_B1_TX,
1687 (usb_complete_t)tx_iso_complete, 1);
1690 start_isoc_chain(hw->fifos + HFCUSB_B2_TX,
1692 (usb_complete_t)tx_iso_complete, 1);
1697 /* stop USB data pipes dependand on device's endpoint configuration */
1699 hfcsusb_stop_endpoint(struct hfcsusb *hw, int channel)
1701 /* quick check if endpoint currently running */
1702 if ((channel == HFC_CHAN_D) && (!hw->fifos[HFCUSB_D_RX].active))
1704 if ((channel == HFC_CHAN_B1) && (!hw->fifos[HFCUSB_B1_RX].active))
1706 if ((channel == HFC_CHAN_B2) && (!hw->fifos[HFCUSB_B2_RX].active))
1708 if ((channel == HFC_CHAN_E) && (!hw->fifos[HFCUSB_PCM_RX].active))
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);
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);
1719 /* tx endpoints using USB ISO OUT method */
1720 if (channel != HFC_CHAN_E)
1721 stop_iso_gracefull(hw->fifos + channel*2);
1725 /* Hardware Initialization */
1727 setup_hfcsusb(struct hfcsusb *hw)
1732 if (debug & DBG_HFC_CALL_TRACE)
1733 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
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__);
1741 if (b != HFCUSB_CHIPID) {
1742 printk(KERN_DEBUG "%s: %s: Invalid chip id 0x%02x\n",
1743 hw->name, __func__, b);
1747 /* first set the needed config, interface and alternate */
1748 err = usb_set_interface(hw->dev, hw->if_used, hw->alt_used);
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);
1768 release_hw(struct hfcsusb *hw)
1770 if (debug & DBG_HFC_CALL_TRACE)
1771 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
1774 * stop all endpoints gracefully
1775 * TODO: mISDN_core should generate CLOSE_CHANNEL
1776 * signals after calling mISDN_unregister_device()
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);
1786 mISDN_unregister_device(&hw->dch.dev);
1787 mISDN_freebchannel(&hw->bch[1]);
1788 mISDN_freebchannel(&hw->bch[0]);
1789 mISDN_freedchannel(&hw->dch);
1792 usb_kill_urb(hw->ctrl_urb);
1793 usb_free_urb(hw->ctrl_urb);
1794 hw->ctrl_urb = NULL;
1798 usb_set_intfdata(hw->intf, NULL);
1799 list_del(&hw->list);
1805 deactivate_bchannel(struct bchannel *bch)
1807 struct hfcsusb *hw = bch->hw;
1810 if (bch->debug & DEBUG_HW)
1811 printk(KERN_DEBUG "%s: %s: bch->nr(%i)\n",
1812 hw->name, __func__, bch->nr);
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);
1822 * Layer 1 B-channel hardware access
1825 hfc_bctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
1827 struct bchannel *bch = container_of(ch, struct bchannel, ch);
1830 if (bch->debug & DEBUG_HW)
1831 printk(KERN_DEBUG "%s: cmd:%x %p\n", __func__, cmd, arg);
1835 case HW_TESTRX_HDLC:
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;
1846 module_put(THIS_MODULE);
1849 case CONTROL_CHANNEL:
1850 ret = channel_bctrl(bch, arg);
1853 printk(KERN_WARNING "%s: unknown prim(%x)\n",
1860 setup_instance(struct hfcsusb *hw, struct device *parent)
1865 if (debug & DBG_HFC_CALL_TRACE)
1866 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
1868 spin_lock_init(&hw->ctrl_lock);
1869 spin_lock_init(&hw->lock);
1871 mISDN_initdchannel(&hw->dch, MAX_DFRAME_LEN_L1, ph_state);
1872 hw->dch.debug = debug & 0xFFFF;
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;
1878 /* enable E-Channel logging */
1879 if (hw->fifos[HFCUSB_PCM_RX].pipe)
1880 mISDN_initdchannel(&hw->ech, MAX_DFRAME_LEN_L1, NULL);
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);
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);
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;
1906 err = setup_hfcsusb(hw);
1910 snprintf(hw->name, MISDN_MAX_IDLEN - 1, "%s.%d", DRIVER_NAME,
1912 printk(KERN_INFO "%s: registered as '%s'\n",
1913 DRIVER_NAME, hw->name);
1915 err = mISDN_register_device(&hw->dch.dev, parent, hw->name);
1920 write_lock_irqsave(&HFClock, flags);
1921 list_add_tail(&hw->list, &HFClist);
1922 write_unlock_irqrestore(&HFClock, flags);
1926 mISDN_freebchannel(&hw->bch[1]);
1927 mISDN_freebchannel(&hw->bch[0]);
1928 mISDN_freedchannel(&hw->dch);
1934 hfcsusb_probe(struct usb_interface *intf, const struct usb_device_id *id)
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,
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)) {
1959 "%s: interface(%d) actalt(%d) minor(%d) vend_idx(%d)\n",
1960 __func__, ifnum, iface->desc.bAlternateSetting,
1961 intf->minor, vend_idx);
1963 if (vend_idx == 0xffff) {
1965 "%s: no valid vendor found in USB descriptor\n",
1969 /* if vendor and product ID is OK, start probing alternate settings */
1973 /* default settings */
1974 iso_packet_size = 16;
1977 while (alt_idx < intf->num_altsetting) {
1978 iface = intf->altsetting + alt_idx;
1979 probe_alt_setting = iface->desc.bAlternateSetting;
1982 while (validconf[cfg_used][0]) {
1984 vcf = validconf[cfg_used];
1985 ep = iface->endpoint;
1986 memcpy(cmptbl, vcf, 16 * sizeof(int));
1988 /* check for all endpoints in this alternate setting */
1989 for (i = 0; i < iface->desc.bNumEndpoints; i++) {
1990 ep_addr = ep->desc.bEndpointAddress;
1992 /* get endpoint base */
1993 idx = ((ep_addr & 0x7f) - 1) * 2;
1996 attr = ep->desc.bmAttributes;
1998 if (cmptbl[idx] != EP_NOP) {
1999 if (cmptbl[idx] == EP_NUL)
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;
2011 if (attr == USB_ENDPOINT_XFER_INT &&
2012 ep->desc.bInterval < vcf[17]) {
2019 for (i = 0; i < 16; i++)
2020 if (cmptbl[i] != EP_NOP && cmptbl[i] != EP_NUL)
2024 if (small_match < cfg_used) {
2025 small_match = cfg_used;
2026 alt_used = probe_alt_setting;
2033 } /* (alt_idx < intf->num_altsetting) */
2035 /* not found a valid USB Ta Endpoint config */
2036 if (small_match == -1)
2040 hw = kzalloc(sizeof(struct hfcsusb), GFP_KERNEL);
2042 return -ENOMEM; /* got no mem */
2043 snprintf(hw->name, MISDN_MAX_IDLEN - 1, "%s", DRIVER_NAME);
2045 ep = iface->endpoint;
2046 vcf = validconf[small_match];
2048 for (i = 0; i < iface->desc.bNumEndpoints; i++) {
2051 ep_addr = ep->desc.bEndpointAddress;
2052 /* get endpoint base */
2053 idx = ((ep_addr & 0x7f) - 1) * 2;
2056 f = &hw->fifos[idx & 7];
2058 /* init Endpoints */
2059 if (vcf[idx] == EP_NOP || vcf[idx] == EP_NUL) {
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);
2070 case USB_ENDPOINT_XFER_BULK:
2072 f->pipe = usb_rcvbulkpipe(dev,
2073 ep->desc.bEndpointAddress);
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);
2080 case USB_ENDPOINT_XFER_ISOC:
2082 f->pipe = usb_rcvisocpipe(dev,
2083 ep->desc.bEndpointAddress);
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);
2095 f->fifonum = idx & 7;
2097 f->usb_packet_maxlen =
2098 le16_to_cpu(ep->desc.wMaxPacketSize);
2099 f->intervall = ep->desc.bInterval;
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;
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);
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);
2123 if (setup_instance(hw, dev->dev.parent))
2127 usb_set_intfdata(hw->intf, hw);
2131 /* function called when an active device is removed */
2133 hfcsusb_disconnect(struct usb_interface *intf)
2135 struct hfcsusb *hw = usb_get_intfdata(intf);
2136 struct hfcsusb *next;
2139 printk(KERN_INFO "%s: device disconnected\n", hw->name);
2141 handle_led(hw, LED_POWER_OFF);
2144 list_for_each_entry_safe(hw, next, &HFClist, list)
2149 usb_set_intfdata(intf, NULL);
2152 static struct usb_driver hfcsusb_drv = {
2153 .name = DRIVER_NAME,
2154 .id_table = hfcsusb_idtab,
2155 .probe = hfcsusb_probe,
2156 .disconnect = hfcsusb_disconnect,
2162 printk(KERN_INFO DRIVER_NAME " driver Rev. %s debug(0x%x) poll(%i)\n",
2163 hfcsusb_rev, debug, poll);
2165 if (usb_register(&hfcsusb_drv)) {
2166 printk(KERN_INFO DRIVER_NAME
2167 ": Unable to register hfcsusb module at usb stack\n");
2175 hfcsusb_cleanup(void)
2177 if (debug & DBG_HFC_CALL_TRACE)
2178 printk(KERN_INFO DRIVER_NAME ": %s\n", __func__);
2180 /* unregister Hardware */
2181 usb_deregister(&hfcsusb_drv); /* release our driver */
2184 module_init(hfcsusb_init);
2185 module_exit(hfcsusb_cleanup);