1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * mISDN driver for Colognechip HFC-S USB chip
5 * Copyright 2001 by Peter Sprenger (sprenger@moving-bytes.de)
6 * Copyright 2008 by Martin Bachem (info@bachem-it.com)
9 * debug=<n>, default=0, with n=0xHHHHGGGG
10 * H - l1 driver flags described in hfcsusb.h
11 * G - common mISDN debug flags described at mISDNhw.h
13 * poll=<n>, default 128
14 * n : burst size of PH_DATA_IND at transparent rx data
16 * Revision: 0.3.3 (socket), 2008-11-05
19 #include <linux/module.h>
20 #include <linux/delay.h>
21 #include <linux/usb.h>
22 #include <linux/mISDNhw.h>
23 #include <linux/slab.h>
26 static unsigned int debug
;
27 static int poll
= DEFAULT_TRANSP_BURST_SZ
;
29 static LIST_HEAD(HFClist
);
30 static DEFINE_RWLOCK(HFClock
);
33 MODULE_AUTHOR("Martin Bachem");
34 MODULE_LICENSE("GPL");
35 module_param(debug
, uint
, S_IRUGO
| S_IWUSR
);
36 module_param(poll
, int, 0);
38 static int hfcsusb_cnt
;
40 /* some function prototypes */
41 static void hfcsusb_ph_command(struct hfcsusb
*hw
, u_char command
);
42 static void release_hw(struct hfcsusb
*hw
);
43 static void reset_hfcsusb(struct hfcsusb
*hw
);
44 static void setPortMode(struct hfcsusb
*hw
);
45 static void hfcsusb_start_endpoint(struct hfcsusb
*hw
, int channel
);
46 static void hfcsusb_stop_endpoint(struct hfcsusb
*hw
, int channel
);
47 static int hfcsusb_setup_bch(struct bchannel
*bch
, int protocol
);
48 static void deactivate_bchannel(struct bchannel
*bch
);
49 static void hfcsusb_ph_info(struct hfcsusb
*hw
);
51 /* start next background transfer for control channel */
53 ctrl_start_transfer(struct hfcsusb
*hw
)
55 if (debug
& DBG_HFC_CALL_TRACE
)
56 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
59 hw
->ctrl_urb
->pipe
= hw
->ctrl_out_pipe
;
60 hw
->ctrl_urb
->setup_packet
= (u_char
*)&hw
->ctrl_write
;
61 hw
->ctrl_urb
->transfer_buffer
= NULL
;
62 hw
->ctrl_urb
->transfer_buffer_length
= 0;
63 hw
->ctrl_write
.wIndex
=
64 cpu_to_le16(hw
->ctrl_buff
[hw
->ctrl_out_idx
].hfcs_reg
);
65 hw
->ctrl_write
.wValue
=
66 cpu_to_le16(hw
->ctrl_buff
[hw
->ctrl_out_idx
].reg_val
);
68 usb_submit_urb(hw
->ctrl_urb
, GFP_ATOMIC
);
73 * queue a control transfer request to write HFC-S USB
74 * chip register using CTRL resuest queue
76 static int write_reg(struct hfcsusb
*hw
, __u8 reg
, __u8 val
)
80 if (debug
& DBG_HFC_CALL_TRACE
)
81 printk(KERN_DEBUG
"%s: %s reg(0x%02x) val(0x%02x)\n",
82 hw
->name
, __func__
, reg
, val
);
84 spin_lock(&hw
->ctrl_lock
);
85 if (hw
->ctrl_cnt
>= HFC_CTRL_BUFSIZE
) {
86 spin_unlock(&hw
->ctrl_lock
);
89 buf
= &hw
->ctrl_buff
[hw
->ctrl_in_idx
];
92 if (++hw
->ctrl_in_idx
>= HFC_CTRL_BUFSIZE
)
94 if (++hw
->ctrl_cnt
== 1)
95 ctrl_start_transfer(hw
);
96 spin_unlock(&hw
->ctrl_lock
);
101 /* control completion routine handling background control cmds */
103 ctrl_complete(struct urb
*urb
)
105 struct hfcsusb
*hw
= (struct hfcsusb
*) urb
->context
;
107 if (debug
& DBG_HFC_CALL_TRACE
)
108 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
112 hw
->ctrl_cnt
--; /* decrement actual count */
113 if (++hw
->ctrl_out_idx
>= HFC_CTRL_BUFSIZE
)
114 hw
->ctrl_out_idx
= 0; /* pointer wrap */
116 ctrl_start_transfer(hw
); /* start next transfer */
120 /* handle LED bits */
122 set_led_bit(struct hfcsusb
*hw
, signed short led_bits
, int set_on
)
126 hw
->led_state
&= ~abs(led_bits
);
128 hw
->led_state
|= led_bits
;
131 hw
->led_state
|= abs(led_bits
);
133 hw
->led_state
&= ~led_bits
;
137 /* handle LED requests */
139 handle_led(struct hfcsusb
*hw
, int event
)
141 struct hfcsusb_vdata
*driver_info
= (struct hfcsusb_vdata
*)
142 hfcsusb_idtab
[hw
->vend_idx
].driver_info
;
145 if (driver_info
->led_scheme
== LED_OFF
)
147 tmpled
= hw
->led_state
;
151 set_led_bit(hw
, driver_info
->led_bits
[0], 1);
152 set_led_bit(hw
, driver_info
->led_bits
[1], 0);
153 set_led_bit(hw
, driver_info
->led_bits
[2], 0);
154 set_led_bit(hw
, driver_info
->led_bits
[3], 0);
157 set_led_bit(hw
, driver_info
->led_bits
[0], 0);
158 set_led_bit(hw
, driver_info
->led_bits
[1], 0);
159 set_led_bit(hw
, driver_info
->led_bits
[2], 0);
160 set_led_bit(hw
, driver_info
->led_bits
[3], 0);
163 set_led_bit(hw
, driver_info
->led_bits
[1], 1);
166 set_led_bit(hw
, driver_info
->led_bits
[1], 0);
169 set_led_bit(hw
, driver_info
->led_bits
[2], 1);
172 set_led_bit(hw
, driver_info
->led_bits
[2], 0);
175 set_led_bit(hw
, driver_info
->led_bits
[3], 1);
178 set_led_bit(hw
, driver_info
->led_bits
[3], 0);
182 if (hw
->led_state
!= tmpled
) {
183 if (debug
& DBG_HFC_CALL_TRACE
)
184 printk(KERN_DEBUG
"%s: %s reg(0x%02x) val(x%02x)\n",
186 HFCUSB_P_DATA
, hw
->led_state
);
188 write_reg(hw
, HFCUSB_P_DATA
, hw
->led_state
);
193 * Layer2 -> Layer 1 Bchannel data
196 hfcusb_l2l1B(struct mISDNchannel
*ch
, struct sk_buff
*skb
)
198 struct bchannel
*bch
= container_of(ch
, struct bchannel
, ch
);
199 struct hfcsusb
*hw
= bch
->hw
;
201 struct mISDNhead
*hh
= mISDN_HEAD_P(skb
);
204 if (debug
& DBG_HFC_CALL_TRACE
)
205 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
209 spin_lock_irqsave(&hw
->lock
, flags
);
210 ret
= bchannel_senddata(bch
, skb
);
211 spin_unlock_irqrestore(&hw
->lock
, flags
);
212 if (debug
& DBG_HFC_CALL_TRACE
)
213 printk(KERN_DEBUG
"%s: %s PH_DATA_REQ ret(%i)\n",
214 hw
->name
, __func__
, ret
);
218 case PH_ACTIVATE_REQ
:
219 if (!test_and_set_bit(FLG_ACTIVE
, &bch
->Flags
)) {
220 hfcsusb_start_endpoint(hw
, bch
->nr
- 1);
221 ret
= hfcsusb_setup_bch(bch
, ch
->protocol
);
225 _queue_data(ch
, PH_ACTIVATE_IND
, MISDN_ID_ANY
,
226 0, NULL
, GFP_KERNEL
);
228 case PH_DEACTIVATE_REQ
:
229 deactivate_bchannel(bch
);
230 _queue_data(ch
, PH_DEACTIVATE_IND
, MISDN_ID_ANY
,
231 0, NULL
, GFP_KERNEL
);
241 * send full D/B channel status information
242 * as MPH_INFORMATION_IND
245 hfcsusb_ph_info(struct hfcsusb
*hw
)
248 struct dchannel
*dch
= &hw
->dch
;
251 phi
= kzalloc(struct_size(phi
, bch
, dch
->dev
.nrbchan
), GFP_ATOMIC
);
255 phi
->dch
.ch
.protocol
= hw
->protocol
;
256 phi
->dch
.ch
.Flags
= dch
->Flags
;
257 phi
->dch
.state
= dch
->state
;
258 phi
->dch
.num_bch
= dch
->dev
.nrbchan
;
259 for (i
= 0; i
< dch
->dev
.nrbchan
; i
++) {
260 phi
->bch
[i
].protocol
= hw
->bch
[i
].ch
.protocol
;
261 phi
->bch
[i
].Flags
= hw
->bch
[i
].Flags
;
263 _queue_data(&dch
->dev
.D
, MPH_INFORMATION_IND
, MISDN_ID_ANY
,
264 sizeof(struct ph_info_dch
) + dch
->dev
.nrbchan
*
265 sizeof(struct ph_info_ch
), phi
, GFP_ATOMIC
);
270 * Layer2 -> Layer 1 Dchannel data
273 hfcusb_l2l1D(struct mISDNchannel
*ch
, struct sk_buff
*skb
)
275 struct mISDNdevice
*dev
= container_of(ch
, struct mISDNdevice
, D
);
276 struct dchannel
*dch
= container_of(dev
, struct dchannel
, dev
);
277 struct mISDNhead
*hh
= mISDN_HEAD_P(skb
);
278 struct hfcsusb
*hw
= dch
->hw
;
284 if (debug
& DBG_HFC_CALL_TRACE
)
285 printk(KERN_DEBUG
"%s: %s: PH_DATA_REQ\n",
288 spin_lock_irqsave(&hw
->lock
, flags
);
289 ret
= dchannel_senddata(dch
, skb
);
290 spin_unlock_irqrestore(&hw
->lock
, flags
);
293 queue_ch_frame(ch
, PH_DATA_CNF
, hh
->id
, NULL
);
297 case PH_ACTIVATE_REQ
:
298 if (debug
& DBG_HFC_CALL_TRACE
)
299 printk(KERN_DEBUG
"%s: %s: PH_ACTIVATE_REQ %s\n",
301 (hw
->protocol
== ISDN_P_NT_S0
) ? "NT" : "TE");
303 if (hw
->protocol
== ISDN_P_NT_S0
) {
305 if (test_bit(FLG_ACTIVE
, &dch
->Flags
)) {
306 _queue_data(&dch
->dev
.D
,
307 PH_ACTIVATE_IND
, MISDN_ID_ANY
, 0,
310 hfcsusb_ph_command(hw
,
312 test_and_set_bit(FLG_L2_ACTIVATED
,
316 hfcsusb_ph_command(hw
, HFC_L1_ACTIVATE_TE
);
317 ret
= l1_event(dch
->l1
, hh
->prim
);
321 case PH_DEACTIVATE_REQ
:
322 if (debug
& DBG_HFC_CALL_TRACE
)
323 printk(KERN_DEBUG
"%s: %s: PH_DEACTIVATE_REQ\n",
325 test_and_clear_bit(FLG_L2_ACTIVATED
, &dch
->Flags
);
327 if (hw
->protocol
== ISDN_P_NT_S0
) {
328 hfcsusb_ph_command(hw
, HFC_L1_DEACTIVATE_NT
);
329 spin_lock_irqsave(&hw
->lock
, flags
);
330 skb_queue_purge(&dch
->squeue
);
332 dev_kfree_skb(dch
->tx_skb
);
337 dev_kfree_skb(dch
->rx_skb
);
340 test_and_clear_bit(FLG_TX_BUSY
, &dch
->Flags
);
341 spin_unlock_irqrestore(&hw
->lock
, flags
);
343 if (test_and_clear_bit(FLG_L1_BUSY
, &dch
->Flags
))
344 dchannel_sched_event(&hc
->dch
, D_CLEARBUSY
);
348 ret
= l1_event(dch
->l1
, hh
->prim
);
350 case MPH_INFORMATION_REQ
:
360 * Layer 1 callback function
363 hfc_l1callback(struct dchannel
*dch
, u_int cmd
)
365 struct hfcsusb
*hw
= dch
->hw
;
367 if (debug
& DBG_HFC_CALL_TRACE
)
368 printk(KERN_DEBUG
"%s: %s cmd 0x%x\n",
369 hw
->name
, __func__
, cmd
);
379 skb_queue_purge(&dch
->squeue
);
381 dev_kfree_skb(dch
->tx_skb
);
386 dev_kfree_skb(dch
->rx_skb
);
389 test_and_clear_bit(FLG_TX_BUSY
, &dch
->Flags
);
391 case PH_ACTIVATE_IND
:
392 test_and_set_bit(FLG_ACTIVE
, &dch
->Flags
);
393 _queue_data(&dch
->dev
.D
, cmd
, MISDN_ID_ANY
, 0, NULL
,
396 case PH_DEACTIVATE_IND
:
397 test_and_clear_bit(FLG_ACTIVE
, &dch
->Flags
);
398 _queue_data(&dch
->dev
.D
, cmd
, MISDN_ID_ANY
, 0, NULL
,
402 if (dch
->debug
& DEBUG_HW
)
403 printk(KERN_DEBUG
"%s: %s: unknown cmd %x\n",
404 hw
->name
, __func__
, cmd
);
412 open_dchannel(struct hfcsusb
*hw
, struct mISDNchannel
*ch
,
413 struct channel_req
*rq
)
417 if (debug
& DEBUG_HW_OPEN
)
418 printk(KERN_DEBUG
"%s: %s: dev(%d) open addr(%i) from %p\n",
419 hw
->name
, __func__
, hw
->dch
.dev
.id
, rq
->adr
.channel
,
420 __builtin_return_address(0));
421 if (rq
->protocol
== ISDN_P_NONE
)
424 test_and_clear_bit(FLG_ACTIVE
, &hw
->dch
.Flags
);
425 test_and_clear_bit(FLG_ACTIVE
, &hw
->ech
.Flags
);
426 hfcsusb_start_endpoint(hw
, HFC_CHAN_D
);
428 /* E-Channel logging */
429 if (rq
->adr
.channel
== 1) {
430 if (hw
->fifos
[HFCUSB_PCM_RX
].pipe
) {
431 hfcsusb_start_endpoint(hw
, HFC_CHAN_E
);
432 set_bit(FLG_ACTIVE
, &hw
->ech
.Flags
);
433 _queue_data(&hw
->ech
.dev
.D
, PH_ACTIVATE_IND
,
434 MISDN_ID_ANY
, 0, NULL
, GFP_ATOMIC
);
440 hw
->protocol
= rq
->protocol
;
441 if (rq
->protocol
== ISDN_P_TE_S0
) {
442 err
= create_l1(&hw
->dch
, hfc_l1callback
);
447 ch
->protocol
= rq
->protocol
;
450 if (rq
->protocol
!= ch
->protocol
)
451 return -EPROTONOSUPPORT
;
454 if (((ch
->protocol
== ISDN_P_NT_S0
) && (hw
->dch
.state
== 3)) ||
455 ((ch
->protocol
== ISDN_P_TE_S0
) && (hw
->dch
.state
== 7)))
456 _queue_data(ch
, PH_ACTIVATE_IND
, MISDN_ID_ANY
,
457 0, NULL
, GFP_KERNEL
);
459 if (!try_module_get(THIS_MODULE
))
460 printk(KERN_WARNING
"%s: %s: cannot get module\n",
466 open_bchannel(struct hfcsusb
*hw
, struct channel_req
*rq
)
468 struct bchannel
*bch
;
470 if (rq
->adr
.channel
== 0 || rq
->adr
.channel
> 2)
472 if (rq
->protocol
== ISDN_P_NONE
)
475 if (debug
& DBG_HFC_CALL_TRACE
)
476 printk(KERN_DEBUG
"%s: %s B%i\n",
477 hw
->name
, __func__
, rq
->adr
.channel
);
479 bch
= &hw
->bch
[rq
->adr
.channel
- 1];
480 if (test_and_set_bit(FLG_OPEN
, &bch
->Flags
))
481 return -EBUSY
; /* b-channel can be only open once */
482 bch
->ch
.protocol
= rq
->protocol
;
485 if (!try_module_get(THIS_MODULE
))
486 printk(KERN_WARNING
"%s: %s:cannot get module\n",
492 channel_ctrl(struct hfcsusb
*hw
, struct mISDN_ctrl_req
*cq
)
496 if (debug
& DBG_HFC_CALL_TRACE
)
497 printk(KERN_DEBUG
"%s: %s op(0x%x) channel(0x%x)\n",
498 hw
->name
, __func__
, (cq
->op
), (cq
->channel
));
501 case MISDN_CTRL_GETOP
:
502 cq
->op
= MISDN_CTRL_LOOP
| MISDN_CTRL_CONNECT
|
503 MISDN_CTRL_DISCONNECT
;
506 printk(KERN_WARNING
"%s: %s: unknown Op %x\n",
507 hw
->name
, __func__
, cq
->op
);
515 * device control function
518 hfc_dctrl(struct mISDNchannel
*ch
, u_int cmd
, void *arg
)
520 struct mISDNdevice
*dev
= container_of(ch
, struct mISDNdevice
, D
);
521 struct dchannel
*dch
= container_of(dev
, struct dchannel
, dev
);
522 struct hfcsusb
*hw
= dch
->hw
;
523 struct channel_req
*rq
;
526 if (dch
->debug
& DEBUG_HW
)
527 printk(KERN_DEBUG
"%s: %s: cmd:%x %p\n",
528 hw
->name
, __func__
, cmd
, arg
);
532 if ((rq
->protocol
== ISDN_P_TE_S0
) ||
533 (rq
->protocol
== ISDN_P_NT_S0
))
534 err
= open_dchannel(hw
, ch
, rq
);
536 err
= open_bchannel(hw
, rq
);
542 if (debug
& DEBUG_HW_OPEN
)
544 "%s: %s: dev(%d) close from %p (open %d)\n",
545 hw
->name
, __func__
, hw
->dch
.dev
.id
,
546 __builtin_return_address(0), hw
->open
);
548 hfcsusb_stop_endpoint(hw
, HFC_CHAN_D
);
549 if (hw
->fifos
[HFCUSB_PCM_RX
].pipe
)
550 hfcsusb_stop_endpoint(hw
, HFC_CHAN_E
);
551 handle_led(hw
, LED_POWER_ON
);
553 module_put(THIS_MODULE
);
555 case CONTROL_CHANNEL
:
556 err
= channel_ctrl(hw
, arg
);
559 if (dch
->debug
& DEBUG_HW
)
560 printk(KERN_DEBUG
"%s: %s: unknown command %x\n",
561 hw
->name
, __func__
, cmd
);
568 * S0 TE state change event handler
571 ph_state_te(struct dchannel
*dch
)
573 struct hfcsusb
*hw
= dch
->hw
;
575 if (debug
& DEBUG_HW
) {
576 if (dch
->state
<= HFC_MAX_TE_LAYER1_STATE
)
577 printk(KERN_DEBUG
"%s: %s: %s\n", hw
->name
, __func__
,
578 HFC_TE_LAYER1_STATES
[dch
->state
]);
580 printk(KERN_DEBUG
"%s: %s: TE F%d\n",
581 hw
->name
, __func__
, dch
->state
);
584 switch (dch
->state
) {
586 l1_event(dch
->l1
, HW_RESET_IND
);
589 l1_event(dch
->l1
, HW_DEACT_IND
);
593 l1_event(dch
->l1
, ANYSIGNAL
);
596 l1_event(dch
->l1
, INFO2
);
599 l1_event(dch
->l1
, INFO4_P8
);
603 handle_led(hw
, LED_S0_ON
);
605 handle_led(hw
, LED_S0_OFF
);
609 * S0 NT state change event handler
612 ph_state_nt(struct dchannel
*dch
)
614 struct hfcsusb
*hw
= dch
->hw
;
616 if (debug
& DEBUG_HW
) {
617 if (dch
->state
<= HFC_MAX_NT_LAYER1_STATE
)
618 printk(KERN_DEBUG
"%s: %s: %s\n",
620 HFC_NT_LAYER1_STATES
[dch
->state
]);
623 printk(KERN_INFO DRIVER_NAME
"%s: %s: NT G%d\n",
624 hw
->name
, __func__
, dch
->state
);
627 switch (dch
->state
) {
629 test_and_clear_bit(FLG_ACTIVE
, &dch
->Flags
);
630 test_and_clear_bit(FLG_L2_ACTIVATED
, &dch
->Flags
);
632 hw
->timers
&= ~NT_ACTIVATION_TIMER
;
633 handle_led(hw
, LED_S0_OFF
);
637 if (hw
->nt_timer
< 0) {
639 hw
->timers
&= ~NT_ACTIVATION_TIMER
;
640 hfcsusb_ph_command(dch
->hw
, HFC_L1_DEACTIVATE_NT
);
642 hw
->timers
|= NT_ACTIVATION_TIMER
;
643 hw
->nt_timer
= NT_T1_COUNT
;
644 /* allow G2 -> G3 transition */
645 write_reg(hw
, HFCUSB_STATES
, 2 | HFCUSB_NT_G2_G3
);
650 hw
->timers
&= ~NT_ACTIVATION_TIMER
;
651 test_and_set_bit(FLG_ACTIVE
, &dch
->Flags
);
652 _queue_data(&dch
->dev
.D
, PH_ACTIVATE_IND
,
653 MISDN_ID_ANY
, 0, NULL
, GFP_ATOMIC
);
654 handle_led(hw
, LED_S0_ON
);
658 hw
->timers
&= ~NT_ACTIVATION_TIMER
;
667 ph_state(struct dchannel
*dch
)
669 struct hfcsusb
*hw
= dch
->hw
;
671 if (hw
->protocol
== ISDN_P_NT_S0
)
673 else if (hw
->protocol
== ISDN_P_TE_S0
)
678 * disable/enable BChannel for desired protocoll
681 hfcsusb_setup_bch(struct bchannel
*bch
, int protocol
)
683 struct hfcsusb
*hw
= bch
->hw
;
684 __u8 conhdlc
, sctrl
, sctrl_r
;
686 if (debug
& DEBUG_HW
)
687 printk(KERN_DEBUG
"%s: %s: protocol %x-->%x B%d\n",
688 hw
->name
, __func__
, bch
->state
, protocol
,
691 /* setup val for CON_HDLC */
693 if (protocol
> ISDN_P_NONE
)
694 conhdlc
= 8; /* enable FIFO */
697 case (-1): /* used for init */
701 if (bch
->state
== ISDN_P_NONE
)
702 return 0; /* already in idle state */
703 bch
->state
= ISDN_P_NONE
;
704 clear_bit(FLG_HDLC
, &bch
->Flags
);
705 clear_bit(FLG_TRANSPARENT
, &bch
->Flags
);
709 bch
->state
= protocol
;
710 set_bit(FLG_TRANSPARENT
, &bch
->Flags
);
712 case (ISDN_P_B_HDLC
):
713 bch
->state
= protocol
;
714 set_bit(FLG_HDLC
, &bch
->Flags
);
717 if (debug
& DEBUG_HW
)
718 printk(KERN_DEBUG
"%s: %s: prot not known %x\n",
719 hw
->name
, __func__
, protocol
);
723 if (protocol
>= ISDN_P_NONE
) {
724 write_reg(hw
, HFCUSB_FIFO
, (bch
->nr
== 1) ? 0 : 2);
725 write_reg(hw
, HFCUSB_CON_HDLC
, conhdlc
);
726 write_reg(hw
, HFCUSB_INC_RES_F
, 2);
727 write_reg(hw
, HFCUSB_FIFO
, (bch
->nr
== 1) ? 1 : 3);
728 write_reg(hw
, HFCUSB_CON_HDLC
, conhdlc
);
729 write_reg(hw
, HFCUSB_INC_RES_F
, 2);
731 sctrl
= 0x40 + ((hw
->protocol
== ISDN_P_TE_S0
) ? 0x00 : 0x04);
733 if (test_bit(FLG_ACTIVE
, &hw
->bch
[0].Flags
)) {
737 if (test_bit(FLG_ACTIVE
, &hw
->bch
[1].Flags
)) {
741 write_reg(hw
, HFCUSB_SCTRL
, sctrl
);
742 write_reg(hw
, HFCUSB_SCTRL_R
, sctrl_r
);
744 if (protocol
> ISDN_P_NONE
)
745 handle_led(hw
, (bch
->nr
== 1) ? LED_B1_ON
: LED_B2_ON
);
747 handle_led(hw
, (bch
->nr
== 1) ? LED_B1_OFF
:
755 hfcsusb_ph_command(struct hfcsusb
*hw
, u_char command
)
757 if (debug
& DEBUG_HW
)
758 printk(KERN_DEBUG
"%s: %s: %x\n",
759 hw
->name
, __func__
, command
);
762 case HFC_L1_ACTIVATE_TE
:
763 /* force sending sending INFO1 */
764 write_reg(hw
, HFCUSB_STATES
, 0x14);
765 /* start l1 activation */
766 write_reg(hw
, HFCUSB_STATES
, 0x04);
769 case HFC_L1_FORCE_DEACTIVATE_TE
:
770 write_reg(hw
, HFCUSB_STATES
, 0x10);
771 write_reg(hw
, HFCUSB_STATES
, 0x03);
774 case HFC_L1_ACTIVATE_NT
:
775 if (hw
->dch
.state
== 3)
776 _queue_data(&hw
->dch
.dev
.D
, PH_ACTIVATE_IND
,
777 MISDN_ID_ANY
, 0, NULL
, GFP_ATOMIC
);
779 write_reg(hw
, HFCUSB_STATES
, HFCUSB_ACTIVATE
|
780 HFCUSB_DO_ACTION
| HFCUSB_NT_G2_G3
);
783 case HFC_L1_DEACTIVATE_NT
:
784 write_reg(hw
, HFCUSB_STATES
,
791 * Layer 1 B-channel hardware access
794 channel_bctrl(struct bchannel
*bch
, struct mISDN_ctrl_req
*cq
)
796 return mISDN_ctrl_bchannel(bch
, cq
);
799 /* collect data from incoming interrupt or isochron USB data */
801 hfcsusb_rx_frame(struct usb_fifo
*fifo
, __u8
*data
, unsigned int len
,
804 struct hfcsusb
*hw
= fifo
->hw
;
805 struct sk_buff
*rx_skb
= NULL
;
807 int fifon
= fifo
->fifonum
;
812 if (debug
& DBG_HFC_CALL_TRACE
)
813 printk(KERN_DEBUG
"%s: %s: fifo(%i) len(%i) "
814 "dch(%p) bch(%p) ech(%p)\n",
815 hw
->name
, __func__
, fifon
, len
,
816 fifo
->dch
, fifo
->bch
, fifo
->ech
);
821 if ((!!fifo
->dch
+ !!fifo
->bch
+ !!fifo
->ech
) != 1) {
822 printk(KERN_DEBUG
"%s: %s: undefined channel\n",
827 spin_lock_irqsave(&hw
->lock
, flags
);
829 rx_skb
= fifo
->dch
->rx_skb
;
830 maxlen
= fifo
->dch
->maxlen
;
834 if (test_bit(FLG_RX_OFF
, &fifo
->bch
->Flags
)) {
835 fifo
->bch
->dropcnt
+= len
;
836 spin_unlock_irqrestore(&hw
->lock
, flags
);
839 maxlen
= bchannel_get_rxbuf(fifo
->bch
, len
);
840 rx_skb
= fifo
->bch
->rx_skb
;
844 pr_warning("%s.B%d: No bufferspace for %d bytes\n",
845 hw
->name
, fifo
->bch
->nr
, len
);
846 spin_unlock_irqrestore(&hw
->lock
, flags
);
849 maxlen
= fifo
->bch
->maxlen
;
850 hdlc
= test_bit(FLG_HDLC
, &fifo
->bch
->Flags
);
853 rx_skb
= fifo
->ech
->rx_skb
;
854 maxlen
= fifo
->ech
->maxlen
;
858 if (fifo
->dch
|| fifo
->ech
) {
860 rx_skb
= mI_alloc_skb(maxlen
, GFP_ATOMIC
);
863 fifo
->dch
->rx_skb
= rx_skb
;
865 fifo
->ech
->rx_skb
= rx_skb
;
868 printk(KERN_DEBUG
"%s: %s: No mem for rx_skb\n",
870 spin_unlock_irqrestore(&hw
->lock
, flags
);
874 /* D/E-Channel SKB range check */
875 if ((rx_skb
->len
+ len
) >= MAX_DFRAME_LEN_L1
) {
876 printk(KERN_DEBUG
"%s: %s: sbk mem exceeded "
877 "for fifo(%d) HFCUSB_D_RX\n",
878 hw
->name
, __func__
, fifon
);
880 spin_unlock_irqrestore(&hw
->lock
, flags
);
885 skb_put_data(rx_skb
, data
, len
);
888 /* we have a complete hdlc packet */
890 if ((rx_skb
->len
> 3) &&
891 (!(rx_skb
->data
[rx_skb
->len
- 1]))) {
892 if (debug
& DBG_HFC_FIFO_VERBOSE
) {
893 printk(KERN_DEBUG
"%s: %s: fifon(%i)"
895 hw
->name
, __func__
, fifon
,
898 while (i
< rx_skb
->len
)
904 /* remove CRC & status */
905 skb_trim(rx_skb
, rx_skb
->len
- 3);
908 recv_Dchannel(fifo
->dch
);
910 recv_Bchannel(fifo
->bch
, MISDN_ID_ANY
,
913 recv_Echannel(fifo
->ech
,
916 if (debug
& DBG_HFC_FIFO_VERBOSE
) {
918 "%s: CRC or minlen ERROR fifon(%i) "
920 hw
->name
, fifon
, rx_skb
->len
);
922 while (i
< rx_skb
->len
)
931 /* deliver transparent data to layer2 */
932 recv_Bchannel(fifo
->bch
, MISDN_ID_ANY
, false);
934 spin_unlock_irqrestore(&hw
->lock
, flags
);
938 fill_isoc_urb(struct urb
*urb
, struct usb_device
*dev
, unsigned int pipe
,
939 void *buf
, int num_packets
, int packet_size
, int interval
,
940 usb_complete_t complete
, void *context
)
944 usb_fill_bulk_urb(urb
, dev
, pipe
, buf
, packet_size
* num_packets
,
947 urb
->number_of_packets
= num_packets
;
948 urb
->transfer_flags
= URB_ISO_ASAP
;
949 urb
->actual_length
= 0;
950 urb
->interval
= interval
;
952 for (k
= 0; k
< num_packets
; k
++) {
953 urb
->iso_frame_desc
[k
].offset
= packet_size
* k
;
954 urb
->iso_frame_desc
[k
].length
= packet_size
;
955 urb
->iso_frame_desc
[k
].actual_length
= 0;
959 /* receive completion routine for all ISO tx fifos */
961 rx_iso_complete(struct urb
*urb
)
963 struct iso_urb
*context_iso_urb
= (struct iso_urb
*) urb
->context
;
964 struct usb_fifo
*fifo
= context_iso_urb
->owner_fifo
;
965 struct hfcsusb
*hw
= fifo
->hw
;
966 int k
, len
, errcode
, offset
, num_isoc_packets
, fifon
, maxlen
,
967 status
, iso_status
, i
;
973 fifon
= fifo
->fifonum
;
974 status
= urb
->status
;
976 spin_lock_irqsave(&hw
->lock
, flags
);
977 if (fifo
->stop_gracefull
) {
978 fifo
->stop_gracefull
= 0;
980 spin_unlock_irqrestore(&hw
->lock
, flags
);
983 spin_unlock_irqrestore(&hw
->lock
, flags
);
986 * ISO transfer only partially completed,
987 * look at individual frame status for details
989 if (status
== -EXDEV
) {
990 if (debug
& DEBUG_HW
)
991 printk(KERN_DEBUG
"%s: %s: with -EXDEV "
992 "urb->status %d, fifonum %d\n",
993 hw
->name
, __func__
, status
, fifon
);
995 /* clear status, so go on with ISO transfers */
1000 if (fifo
->active
&& !status
) {
1001 num_isoc_packets
= iso_packets
[fifon
];
1002 maxlen
= fifo
->usb_packet_maxlen
;
1004 for (k
= 0; k
< num_isoc_packets
; ++k
) {
1005 len
= urb
->iso_frame_desc
[k
].actual_length
;
1006 offset
= urb
->iso_frame_desc
[k
].offset
;
1007 buf
= context_iso_urb
->buffer
+ offset
;
1008 iso_status
= urb
->iso_frame_desc
[k
].status
;
1010 if (iso_status
&& (debug
& DBG_HFC_FIFO_VERBOSE
)) {
1011 printk(KERN_DEBUG
"%s: %s: "
1012 "ISO packet %i, status: %i\n",
1013 hw
->name
, __func__
, k
, iso_status
);
1016 /* USB data log for every D ISO in */
1017 if ((fifon
== HFCUSB_D_RX
) &&
1018 (debug
& DBG_HFC_USB_VERBOSE
)) {
1020 "%s: %s: %d (%d/%d) len(%d) ",
1021 hw
->name
, __func__
, urb
->start_frame
,
1022 k
, num_isoc_packets
- 1,
1024 for (i
= 0; i
< len
; i
++)
1025 printk("%x ", buf
[i
]);
1030 if (fifo
->last_urblen
!= maxlen
) {
1032 * save fifo fill-level threshold bits
1033 * to use them later in TX ISO URB
1036 hw
->threshold_mask
= buf
[1];
1038 if (fifon
== HFCUSB_D_RX
)
1039 s0_state
= (buf
[0] >> 4);
1041 eof
[fifon
] = buf
[0] & 1;
1043 hfcsusb_rx_frame(fifo
, buf
+ 2,
1044 len
- 2, (len
< maxlen
)
1047 hfcsusb_rx_frame(fifo
, buf
, len
,
1050 fifo
->last_urblen
= len
;
1054 /* signal S0 layer1 state change */
1055 if ((s0_state
) && (hw
->initdone
) &&
1056 (s0_state
!= hw
->dch
.state
)) {
1057 hw
->dch
.state
= s0_state
;
1058 schedule_event(&hw
->dch
, FLG_PHCHANGE
);
1061 fill_isoc_urb(urb
, fifo
->hw
->dev
, fifo
->pipe
,
1062 context_iso_urb
->buffer
, num_isoc_packets
,
1063 fifo
->usb_packet_maxlen
, fifo
->intervall
,
1064 (usb_complete_t
)rx_iso_complete
, urb
->context
);
1065 errcode
= usb_submit_urb(urb
, GFP_ATOMIC
);
1067 if (debug
& DEBUG_HW
)
1068 printk(KERN_DEBUG
"%s: %s: error submitting "
1070 hw
->name
, __func__
, errcode
);
1073 if (status
&& (debug
& DBG_HFC_URB_INFO
))
1074 printk(KERN_DEBUG
"%s: %s: rx_iso_complete : "
1075 "urb->status %d, fifonum %d\n",
1076 hw
->name
, __func__
, status
, fifon
);
1080 /* receive completion routine for all interrupt rx fifos */
1082 rx_int_complete(struct urb
*urb
)
1085 __u8
*buf
, maxlen
, fifon
;
1086 struct usb_fifo
*fifo
= (struct usb_fifo
*) urb
->context
;
1087 struct hfcsusb
*hw
= fifo
->hw
;
1089 unsigned long flags
;
1091 spin_lock_irqsave(&hw
->lock
, flags
);
1092 if (fifo
->stop_gracefull
) {
1093 fifo
->stop_gracefull
= 0;
1095 spin_unlock_irqrestore(&hw
->lock
, flags
);
1098 spin_unlock_irqrestore(&hw
->lock
, flags
);
1100 fifon
= fifo
->fifonum
;
1101 if ((!fifo
->active
) || (urb
->status
)) {
1102 if (debug
& DBG_HFC_URB_ERROR
)
1104 "%s: %s: RX-Fifo %i is going down (%i)\n",
1105 hw
->name
, __func__
, fifon
, urb
->status
);
1107 fifo
->urb
->interval
= 0; /* cancel automatic rescheduling */
1110 len
= urb
->actual_length
;
1112 maxlen
= fifo
->usb_packet_maxlen
;
1114 /* USB data log for every D INT in */
1115 if ((fifon
== HFCUSB_D_RX
) && (debug
& DBG_HFC_USB_VERBOSE
)) {
1116 printk(KERN_DEBUG
"%s: %s: D RX INT len(%d) ",
1117 hw
->name
, __func__
, len
);
1118 for (i
= 0; i
< len
; i
++)
1119 printk("%02x ", buf
[i
]);
1123 if (fifo
->last_urblen
!= fifo
->usb_packet_maxlen
) {
1124 /* the threshold mask is in the 2nd status byte */
1125 hw
->threshold_mask
= buf
[1];
1127 /* signal S0 layer1 state change */
1128 if (hw
->initdone
&& ((buf
[0] >> 4) != hw
->dch
.state
)) {
1129 hw
->dch
.state
= (buf
[0] >> 4);
1130 schedule_event(&hw
->dch
, FLG_PHCHANGE
);
1133 eof
[fifon
] = buf
[0] & 1;
1134 /* if we have more than the 2 status bytes -> collect data */
1136 hfcsusb_rx_frame(fifo
, buf
+ 2,
1137 urb
->actual_length
- 2,
1138 (len
< maxlen
) ? eof
[fifon
] : 0);
1140 hfcsusb_rx_frame(fifo
, buf
, urb
->actual_length
,
1141 (len
< maxlen
) ? eof
[fifon
] : 0);
1143 fifo
->last_urblen
= urb
->actual_length
;
1145 status
= usb_submit_urb(urb
, GFP_ATOMIC
);
1147 if (debug
& DEBUG_HW
)
1148 printk(KERN_DEBUG
"%s: %s: error resubmitting USB\n",
1149 hw
->name
, __func__
);
1153 /* transmit completion routine for all ISO tx fifos */
1155 tx_iso_complete(struct urb
*urb
)
1157 struct iso_urb
*context_iso_urb
= (struct iso_urb
*) urb
->context
;
1158 struct usb_fifo
*fifo
= context_iso_urb
->owner_fifo
;
1159 struct hfcsusb
*hw
= fifo
->hw
;
1160 struct sk_buff
*tx_skb
;
1161 int k
, tx_offset
, num_isoc_packets
, sink
, remain
, current_len
,
1164 int frame_complete
, fifon
, status
, fillempty
= 0;
1166 unsigned long flags
;
1168 spin_lock_irqsave(&hw
->lock
, flags
);
1169 if (fifo
->stop_gracefull
) {
1170 fifo
->stop_gracefull
= 0;
1172 spin_unlock_irqrestore(&hw
->lock
, flags
);
1177 tx_skb
= fifo
->dch
->tx_skb
;
1178 tx_idx
= &fifo
->dch
->tx_idx
;
1180 } else if (fifo
->bch
) {
1181 tx_skb
= fifo
->bch
->tx_skb
;
1182 tx_idx
= &fifo
->bch
->tx_idx
;
1183 hdlc
= test_bit(FLG_HDLC
, &fifo
->bch
->Flags
);
1184 if (!tx_skb
&& !hdlc
&&
1185 test_bit(FLG_FILLEMPTY
, &fifo
->bch
->Flags
))
1188 printk(KERN_DEBUG
"%s: %s: neither BCH nor DCH\n",
1189 hw
->name
, __func__
);
1190 spin_unlock_irqrestore(&hw
->lock
, flags
);
1194 fifon
= fifo
->fifonum
;
1195 status
= urb
->status
;
1200 * ISO transfer only partially completed,
1201 * look at individual frame status for details
1203 if (status
== -EXDEV
) {
1204 if (debug
& DBG_HFC_URB_ERROR
)
1205 printk(KERN_DEBUG
"%s: %s: "
1206 "-EXDEV (%i) fifon (%d)\n",
1207 hw
->name
, __func__
, status
, fifon
);
1209 /* clear status, so go on with ISO transfers */
1213 if (fifo
->active
&& !status
) {
1214 /* is FifoFull-threshold set for our channel? */
1215 threshbit
= (hw
->threshold_mask
& (1 << fifon
));
1216 num_isoc_packets
= iso_packets
[fifon
];
1218 /* predict dataflow to avoid fifo overflow */
1219 if (fifon
>= HFCUSB_D_TX
)
1220 sink
= (threshbit
) ? SINK_DMIN
: SINK_DMAX
;
1222 sink
= (threshbit
) ? SINK_MIN
: SINK_MAX
;
1223 fill_isoc_urb(urb
, fifo
->hw
->dev
, fifo
->pipe
,
1224 context_iso_urb
->buffer
, num_isoc_packets
,
1225 fifo
->usb_packet_maxlen
, fifo
->intervall
,
1226 (usb_complete_t
)tx_iso_complete
, urb
->context
);
1227 memset(context_iso_urb
->buffer
, 0,
1228 sizeof(context_iso_urb
->buffer
));
1231 for (k
= 0; k
< num_isoc_packets
; ++k
) {
1232 /* analyze tx success of previous ISO packets */
1233 if (debug
& DBG_HFC_URB_ERROR
) {
1234 errcode
= urb
->iso_frame_desc
[k
].status
;
1236 printk(KERN_DEBUG
"%s: %s: "
1237 "ISO packet %i, status: %i\n",
1238 hw
->name
, __func__
, k
, errcode
);
1242 /* Generate next ISO Packets */
1244 remain
= tx_skb
->len
- *tx_idx
;
1246 remain
= 15; /* > not complete */
1251 fifo
->bit_line
-= sink
;
1252 current_len
= (0 - fifo
->bit_line
) / 8;
1253 if (current_len
> 14)
1255 if (current_len
< 0)
1257 if (remain
< current_len
)
1258 current_len
= remain
;
1260 /* how much bit do we put on the line? */
1261 fifo
->bit_line
+= current_len
* 8;
1263 context_iso_urb
->buffer
[tx_offset
] = 0;
1264 if (current_len
== remain
) {
1266 /* signal frame completion */
1268 buffer
[tx_offset
] = 1;
1269 /* add 2 byte flags and 16bit
1270 * CRC at end of ISDN frame */
1271 fifo
->bit_line
+= 32;
1276 /* copy tx data to iso-urb buffer */
1277 p
= context_iso_urb
->buffer
+ tx_offset
+ 1;
1279 memset(p
, fifo
->bch
->fill
[0],
1282 memcpy(p
, (tx_skb
->data
+ *tx_idx
),
1284 *tx_idx
+= current_len
;
1286 urb
->iso_frame_desc
[k
].offset
= tx_offset
;
1287 urb
->iso_frame_desc
[k
].length
= current_len
+ 1;
1289 /* USB data log for every D ISO out */
1290 if ((fifon
== HFCUSB_D_RX
) && !fillempty
&&
1291 (debug
& DBG_HFC_USB_VERBOSE
)) {
1293 "%s: %s (%d/%d) offs(%d) len(%d) ",
1295 k
, num_isoc_packets
- 1,
1296 urb
->iso_frame_desc
[k
].offset
,
1297 urb
->iso_frame_desc
[k
].length
);
1299 for (i
= urb
->iso_frame_desc
[k
].offset
;
1300 i
< (urb
->iso_frame_desc
[k
].offset
1301 + urb
->iso_frame_desc
[k
].length
);
1304 context_iso_urb
->buffer
[i
]);
1306 printk(" skb->len(%i) tx-idx(%d)\n",
1307 tx_skb
->len
, *tx_idx
);
1310 tx_offset
+= (current_len
+ 1);
1312 urb
->iso_frame_desc
[k
].offset
= tx_offset
++;
1313 urb
->iso_frame_desc
[k
].length
= 1;
1314 /* we lower data margin every msec */
1315 fifo
->bit_line
-= sink
;
1316 if (fifo
->bit_line
< BITLINE_INF
)
1317 fifo
->bit_line
= BITLINE_INF
;
1320 if (frame_complete
) {
1323 if (debug
& DBG_HFC_FIFO_VERBOSE
) {
1324 printk(KERN_DEBUG
"%s: %s: "
1325 "fifon(%i) new TX len(%i): ",
1327 fifon
, tx_skb
->len
);
1329 while (i
< tx_skb
->len
)
1335 dev_kfree_skb(tx_skb
);
1337 if (fifo
->dch
&& get_next_dframe(fifo
->dch
))
1338 tx_skb
= fifo
->dch
->tx_skb
;
1339 else if (fifo
->bch
&&
1340 get_next_bframe(fifo
->bch
))
1341 tx_skb
= fifo
->bch
->tx_skb
;
1344 errcode
= usb_submit_urb(urb
, GFP_ATOMIC
);
1346 if (debug
& DEBUG_HW
)
1348 "%s: %s: error submitting ISO URB: %d \n",
1349 hw
->name
, __func__
, errcode
);
1353 * abuse DChannel tx iso completion to trigger NT mode state
1354 * changes tx_iso_complete is assumed to be called every
1355 * fifo->intervall (ms)
1357 if ((fifon
== HFCUSB_D_TX
) && (hw
->protocol
== ISDN_P_NT_S0
)
1358 && (hw
->timers
& NT_ACTIVATION_TIMER
)) {
1359 if ((--hw
->nt_timer
) < 0)
1360 schedule_event(&hw
->dch
, FLG_PHCHANGE
);
1364 if (status
&& (debug
& DBG_HFC_URB_ERROR
))
1365 printk(KERN_DEBUG
"%s: %s: urb->status %s (%i)"
1368 symbolic(urb_errlist
, status
), status
, fifon
);
1370 spin_unlock_irqrestore(&hw
->lock
, flags
);
1374 * allocs urbs and start isoc transfer with two pending urbs to avoid
1375 * gaps in the transfer chain
1378 start_isoc_chain(struct usb_fifo
*fifo
, int num_packets_per_urb
,
1379 usb_complete_t complete
, int packet_size
)
1381 struct hfcsusb
*hw
= fifo
->hw
;
1385 printk(KERN_DEBUG
"%s: %s: fifo %i\n",
1386 hw
->name
, __func__
, fifo
->fifonum
);
1388 /* allocate Memory for Iso out Urbs */
1389 for (i
= 0; i
< 2; i
++) {
1390 if (!(fifo
->iso
[i
].urb
)) {
1392 usb_alloc_urb(num_packets_per_urb
, GFP_KERNEL
);
1393 if (!(fifo
->iso
[i
].urb
)) {
1395 "%s: %s: alloc urb for fifo %i failed",
1396 hw
->name
, __func__
, fifo
->fifonum
);
1398 fifo
->iso
[i
].owner_fifo
= (struct usb_fifo
*) fifo
;
1399 fifo
->iso
[i
].indx
= i
;
1401 /* Init the first iso */
1402 if (ISO_BUFFER_SIZE
>=
1403 (fifo
->usb_packet_maxlen
*
1404 num_packets_per_urb
)) {
1405 fill_isoc_urb(fifo
->iso
[i
].urb
,
1406 fifo
->hw
->dev
, fifo
->pipe
,
1407 fifo
->iso
[i
].buffer
,
1408 num_packets_per_urb
,
1409 fifo
->usb_packet_maxlen
,
1410 fifo
->intervall
, complete
,
1412 memset(fifo
->iso
[i
].buffer
, 0,
1413 sizeof(fifo
->iso
[i
].buffer
));
1415 for (k
= 0; k
< num_packets_per_urb
; k
++) {
1417 iso_frame_desc
[k
].offset
=
1420 iso_frame_desc
[k
].length
=
1425 "%s: %s: ISO Buffer size to small!\n",
1426 hw
->name
, __func__
);
1429 fifo
->bit_line
= BITLINE_INF
;
1431 errcode
= usb_submit_urb(fifo
->iso
[i
].urb
, GFP_KERNEL
);
1432 fifo
->active
= (errcode
>= 0) ? 1 : 0;
1433 fifo
->stop_gracefull
= 0;
1435 printk(KERN_DEBUG
"%s: %s: %s URB nr:%d\n",
1437 symbolic(urb_errlist
, errcode
), i
);
1440 return fifo
->active
;
1444 stop_iso_gracefull(struct usb_fifo
*fifo
)
1446 struct hfcsusb
*hw
= fifo
->hw
;
1450 for (i
= 0; i
< 2; i
++) {
1451 spin_lock_irqsave(&hw
->lock
, flags
);
1453 printk(KERN_DEBUG
"%s: %s for fifo %i.%i\n",
1454 hw
->name
, __func__
, fifo
->fifonum
, i
);
1455 fifo
->stop_gracefull
= 1;
1456 spin_unlock_irqrestore(&hw
->lock
, flags
);
1459 for (i
= 0; i
< 2; i
++) {
1461 while (fifo
->stop_gracefull
&& timeout
--)
1462 schedule_timeout_interruptible((HZ
/ 1000) * 16);
1463 if (debug
&& fifo
->stop_gracefull
)
1464 printk(KERN_DEBUG
"%s: ERROR %s for fifo %i.%i\n",
1465 hw
->name
, __func__
, fifo
->fifonum
, i
);
1470 stop_int_gracefull(struct usb_fifo
*fifo
)
1472 struct hfcsusb
*hw
= fifo
->hw
;
1476 spin_lock_irqsave(&hw
->lock
, flags
);
1478 printk(KERN_DEBUG
"%s: %s for fifo %i\n",
1479 hw
->name
, __func__
, fifo
->fifonum
);
1480 fifo
->stop_gracefull
= 1;
1481 spin_unlock_irqrestore(&hw
->lock
, flags
);
1484 while (fifo
->stop_gracefull
&& timeout
--)
1485 schedule_timeout_interruptible((HZ
/ 1000) * 3);
1486 if (debug
&& fifo
->stop_gracefull
)
1487 printk(KERN_DEBUG
"%s: ERROR %s for fifo %i\n",
1488 hw
->name
, __func__
, fifo
->fifonum
);
1491 /* start the interrupt transfer for the given fifo */
1493 start_int_fifo(struct usb_fifo
*fifo
)
1495 struct hfcsusb
*hw
= fifo
->hw
;
1499 printk(KERN_DEBUG
"%s: %s: INT IN fifo:%d\n",
1500 hw
->name
, __func__
, fifo
->fifonum
);
1503 fifo
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
1507 usb_fill_int_urb(fifo
->urb
, fifo
->hw
->dev
, fifo
->pipe
,
1508 fifo
->buffer
, fifo
->usb_packet_maxlen
,
1509 (usb_complete_t
)rx_int_complete
, fifo
, fifo
->intervall
);
1511 fifo
->stop_gracefull
= 0;
1512 errcode
= usb_submit_urb(fifo
->urb
, GFP_KERNEL
);
1514 printk(KERN_DEBUG
"%s: %s: submit URB: status:%i\n",
1515 hw
->name
, __func__
, errcode
);
1521 setPortMode(struct hfcsusb
*hw
)
1523 if (debug
& DEBUG_HW
)
1524 printk(KERN_DEBUG
"%s: %s %s\n", hw
->name
, __func__
,
1525 (hw
->protocol
== ISDN_P_TE_S0
) ? "TE" : "NT");
1527 if (hw
->protocol
== ISDN_P_TE_S0
) {
1528 write_reg(hw
, HFCUSB_SCTRL
, 0x40);
1529 write_reg(hw
, HFCUSB_SCTRL_E
, 0x00);
1530 write_reg(hw
, HFCUSB_CLKDEL
, CLKDEL_TE
);
1531 write_reg(hw
, HFCUSB_STATES
, 3 | 0x10);
1532 write_reg(hw
, HFCUSB_STATES
, 3);
1534 write_reg(hw
, HFCUSB_SCTRL
, 0x44);
1535 write_reg(hw
, HFCUSB_SCTRL_E
, 0x09);
1536 write_reg(hw
, HFCUSB_CLKDEL
, CLKDEL_NT
);
1537 write_reg(hw
, HFCUSB_STATES
, 1 | 0x10);
1538 write_reg(hw
, HFCUSB_STATES
, 1);
1543 reset_hfcsusb(struct hfcsusb
*hw
)
1545 struct usb_fifo
*fifo
;
1548 if (debug
& DEBUG_HW
)
1549 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
1552 write_reg(hw
, HFCUSB_CIRM
, 8);
1554 /* aux = output, reset off */
1555 write_reg(hw
, HFCUSB_CIRM
, 0x10);
1557 /* set USB_SIZE to match the wMaxPacketSize for INT or BULK transfers */
1558 write_reg(hw
, HFCUSB_USB_SIZE
, (hw
->packet_size
/ 8) |
1559 ((hw
->packet_size
/ 8) << 4));
1561 /* set USB_SIZE_I to match the the wMaxPacketSize for ISO transfers */
1562 write_reg(hw
, HFCUSB_USB_SIZE_I
, hw
->iso_packet_size
);
1564 /* enable PCM/GCI master mode */
1565 write_reg(hw
, HFCUSB_MST_MODE1
, 0); /* set default values */
1566 write_reg(hw
, HFCUSB_MST_MODE0
, 1); /* enable master mode */
1568 /* init the fifos */
1569 write_reg(hw
, HFCUSB_F_THRES
,
1570 (HFCUSB_TX_THRESHOLD
/ 8) | ((HFCUSB_RX_THRESHOLD
/ 8) << 4));
1573 for (i
= 0; i
< HFCUSB_NUM_FIFOS
; i
++) {
1574 write_reg(hw
, HFCUSB_FIFO
, i
); /* select the desired fifo */
1576 (i
<= HFCUSB_B2_RX
) ? MAX_BCH_SIZE
: MAX_DFRAME_LEN
;
1577 fifo
[i
].last_urblen
= 0;
1579 /* set 2 bit for D- & E-channel */
1580 write_reg(hw
, HFCUSB_HDLC_PAR
, ((i
<= HFCUSB_B2_RX
) ? 0 : 2));
1582 /* enable all fifos */
1583 if (i
== HFCUSB_D_TX
)
1584 write_reg(hw
, HFCUSB_CON_HDLC
,
1585 (hw
->protocol
== ISDN_P_NT_S0
) ? 0x08 : 0x09);
1587 write_reg(hw
, HFCUSB_CON_HDLC
, 0x08);
1588 write_reg(hw
, HFCUSB_INC_RES_F
, 2); /* reset the fifo */
1591 write_reg(hw
, HFCUSB_SCTRL_R
, 0); /* disable both B receivers */
1592 handle_led(hw
, LED_POWER_ON
);
1595 /* start USB data pipes dependand on device's endpoint configuration */
1597 hfcsusb_start_endpoint(struct hfcsusb
*hw
, int channel
)
1599 /* quick check if endpoint already running */
1600 if ((channel
== HFC_CHAN_D
) && (hw
->fifos
[HFCUSB_D_RX
].active
))
1602 if ((channel
== HFC_CHAN_B1
) && (hw
->fifos
[HFCUSB_B1_RX
].active
))
1604 if ((channel
== HFC_CHAN_B2
) && (hw
->fifos
[HFCUSB_B2_RX
].active
))
1606 if ((channel
== HFC_CHAN_E
) && (hw
->fifos
[HFCUSB_PCM_RX
].active
))
1609 /* start rx endpoints using USB INT IN method */
1610 if (hw
->cfg_used
== CNF_3INT3ISO
|| hw
->cfg_used
== CNF_4INT3ISO
)
1611 start_int_fifo(hw
->fifos
+ channel
* 2 + 1);
1613 /* start rx endpoints using USB ISO IN method */
1614 if (hw
->cfg_used
== CNF_3ISO3ISO
|| hw
->cfg_used
== CNF_4ISO3ISO
) {
1617 start_isoc_chain(hw
->fifos
+ HFCUSB_D_RX
,
1619 (usb_complete_t
)rx_iso_complete
,
1623 start_isoc_chain(hw
->fifos
+ HFCUSB_PCM_RX
,
1625 (usb_complete_t
)rx_iso_complete
,
1629 start_isoc_chain(hw
->fifos
+ HFCUSB_B1_RX
,
1631 (usb_complete_t
)rx_iso_complete
,
1635 start_isoc_chain(hw
->fifos
+ HFCUSB_B2_RX
,
1637 (usb_complete_t
)rx_iso_complete
,
1643 /* start tx endpoints using USB ISO OUT method */
1646 start_isoc_chain(hw
->fifos
+ HFCUSB_D_TX
,
1648 (usb_complete_t
)tx_iso_complete
, 1);
1651 start_isoc_chain(hw
->fifos
+ HFCUSB_B1_TX
,
1653 (usb_complete_t
)tx_iso_complete
, 1);
1656 start_isoc_chain(hw
->fifos
+ HFCUSB_B2_TX
,
1658 (usb_complete_t
)tx_iso_complete
, 1);
1663 /* stop USB data pipes dependand on device's endpoint configuration */
1665 hfcsusb_stop_endpoint(struct hfcsusb
*hw
, int channel
)
1667 /* quick check if endpoint currently running */
1668 if ((channel
== HFC_CHAN_D
) && (!hw
->fifos
[HFCUSB_D_RX
].active
))
1670 if ((channel
== HFC_CHAN_B1
) && (!hw
->fifos
[HFCUSB_B1_RX
].active
))
1672 if ((channel
== HFC_CHAN_B2
) && (!hw
->fifos
[HFCUSB_B2_RX
].active
))
1674 if ((channel
== HFC_CHAN_E
) && (!hw
->fifos
[HFCUSB_PCM_RX
].active
))
1677 /* rx endpoints using USB INT IN method */
1678 if (hw
->cfg_used
== CNF_3INT3ISO
|| hw
->cfg_used
== CNF_4INT3ISO
)
1679 stop_int_gracefull(hw
->fifos
+ channel
* 2 + 1);
1681 /* rx endpoints using USB ISO IN method */
1682 if (hw
->cfg_used
== CNF_3ISO3ISO
|| hw
->cfg_used
== CNF_4ISO3ISO
)
1683 stop_iso_gracefull(hw
->fifos
+ channel
* 2 + 1);
1685 /* tx endpoints using USB ISO OUT method */
1686 if (channel
!= HFC_CHAN_E
)
1687 stop_iso_gracefull(hw
->fifos
+ channel
* 2);
1691 /* Hardware Initialization */
1693 setup_hfcsusb(struct hfcsusb
*hw
)
1697 if (debug
& DBG_HFC_CALL_TRACE
)
1698 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
1700 /* check the chip id */
1701 if (read_reg_atomic(hw
, HFCUSB_CHIP_ID
, &b
) != 1) {
1702 printk(KERN_DEBUG
"%s: %s: cannot read chip id\n",
1703 hw
->name
, __func__
);
1706 if (b
!= HFCUSB_CHIPID
) {
1707 printk(KERN_DEBUG
"%s: %s: Invalid chip id 0x%02x\n",
1708 hw
->name
, __func__
, b
);
1712 /* first set the needed config, interface and alternate */
1713 (void) usb_set_interface(hw
->dev
, hw
->if_used
, hw
->alt_used
);
1717 /* init the background machinery for control requests */
1718 hw
->ctrl_read
.bRequestType
= 0xc0;
1719 hw
->ctrl_read
.bRequest
= 1;
1720 hw
->ctrl_read
.wLength
= cpu_to_le16(1);
1721 hw
->ctrl_write
.bRequestType
= 0x40;
1722 hw
->ctrl_write
.bRequest
= 0;
1723 hw
->ctrl_write
.wLength
= 0;
1724 usb_fill_control_urb(hw
->ctrl_urb
, hw
->dev
, hw
->ctrl_out_pipe
,
1725 (u_char
*)&hw
->ctrl_write
, NULL
, 0,
1726 (usb_complete_t
)ctrl_complete
, hw
);
1733 release_hw(struct hfcsusb
*hw
)
1735 if (debug
& DBG_HFC_CALL_TRACE
)
1736 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
1739 * stop all endpoints gracefully
1740 * TODO: mISDN_core should generate CLOSE_CHANNEL
1741 * signals after calling mISDN_unregister_device()
1743 hfcsusb_stop_endpoint(hw
, HFC_CHAN_D
);
1744 hfcsusb_stop_endpoint(hw
, HFC_CHAN_B1
);
1745 hfcsusb_stop_endpoint(hw
, HFC_CHAN_B2
);
1746 if (hw
->fifos
[HFCUSB_PCM_RX
].pipe
)
1747 hfcsusb_stop_endpoint(hw
, HFC_CHAN_E
);
1748 if (hw
->protocol
== ISDN_P_TE_S0
)
1749 l1_event(hw
->dch
.l1
, CLOSE_CHANNEL
);
1751 mISDN_unregister_device(&hw
->dch
.dev
);
1752 mISDN_freebchannel(&hw
->bch
[1]);
1753 mISDN_freebchannel(&hw
->bch
[0]);
1754 mISDN_freedchannel(&hw
->dch
);
1757 usb_kill_urb(hw
->ctrl_urb
);
1758 usb_free_urb(hw
->ctrl_urb
);
1759 hw
->ctrl_urb
= NULL
;
1763 usb_set_intfdata(hw
->intf
, NULL
);
1764 list_del(&hw
->list
);
1770 deactivate_bchannel(struct bchannel
*bch
)
1772 struct hfcsusb
*hw
= bch
->hw
;
1775 if (bch
->debug
& DEBUG_HW
)
1776 printk(KERN_DEBUG
"%s: %s: bch->nr(%i)\n",
1777 hw
->name
, __func__
, bch
->nr
);
1779 spin_lock_irqsave(&hw
->lock
, flags
);
1780 mISDN_clear_bchannel(bch
);
1781 spin_unlock_irqrestore(&hw
->lock
, flags
);
1782 hfcsusb_setup_bch(bch
, ISDN_P_NONE
);
1783 hfcsusb_stop_endpoint(hw
, bch
->nr
- 1);
1787 * Layer 1 B-channel hardware access
1790 hfc_bctrl(struct mISDNchannel
*ch
, u_int cmd
, void *arg
)
1792 struct bchannel
*bch
= container_of(ch
, struct bchannel
, ch
);
1795 if (bch
->debug
& DEBUG_HW
)
1796 printk(KERN_DEBUG
"%s: cmd:%x %p\n", __func__
, cmd
, arg
);
1800 case HW_TESTRX_HDLC
:
1806 test_and_clear_bit(FLG_OPEN
, &bch
->Flags
);
1807 deactivate_bchannel(bch
);
1808 ch
->protocol
= ISDN_P_NONE
;
1810 module_put(THIS_MODULE
);
1813 case CONTROL_CHANNEL
:
1814 ret
= channel_bctrl(bch
, arg
);
1817 printk(KERN_WARNING
"%s: unknown prim(%x)\n",
1824 setup_instance(struct hfcsusb
*hw
, struct device
*parent
)
1829 if (debug
& DBG_HFC_CALL_TRACE
)
1830 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
1832 spin_lock_init(&hw
->ctrl_lock
);
1833 spin_lock_init(&hw
->lock
);
1835 mISDN_initdchannel(&hw
->dch
, MAX_DFRAME_LEN_L1
, ph_state
);
1836 hw
->dch
.debug
= debug
& 0xFFFF;
1838 hw
->dch
.dev
.Dprotocols
= (1 << ISDN_P_TE_S0
) | (1 << ISDN_P_NT_S0
);
1839 hw
->dch
.dev
.D
.send
= hfcusb_l2l1D
;
1840 hw
->dch
.dev
.D
.ctrl
= hfc_dctrl
;
1842 /* enable E-Channel logging */
1843 if (hw
->fifos
[HFCUSB_PCM_RX
].pipe
)
1844 mISDN_initdchannel(&hw
->ech
, MAX_DFRAME_LEN_L1
, NULL
);
1846 hw
->dch
.dev
.Bprotocols
= (1 << (ISDN_P_B_RAW
& ISDN_P_B_MASK
)) |
1847 (1 << (ISDN_P_B_HDLC
& ISDN_P_B_MASK
));
1848 hw
->dch
.dev
.nrbchan
= 2;
1849 for (i
= 0; i
< 2; i
++) {
1850 hw
->bch
[i
].nr
= i
+ 1;
1851 set_channelmap(i
+ 1, hw
->dch
.dev
.channelmap
);
1852 hw
->bch
[i
].debug
= debug
;
1853 mISDN_initbchannel(&hw
->bch
[i
], MAX_DATA_MEM
, poll
>> 1);
1855 hw
->bch
[i
].ch
.send
= hfcusb_l2l1B
;
1856 hw
->bch
[i
].ch
.ctrl
= hfc_bctrl
;
1857 hw
->bch
[i
].ch
.nr
= i
+ 1;
1858 list_add(&hw
->bch
[i
].ch
.list
, &hw
->dch
.dev
.bchannels
);
1861 hw
->fifos
[HFCUSB_B1_TX
].bch
= &hw
->bch
[0];
1862 hw
->fifos
[HFCUSB_B1_RX
].bch
= &hw
->bch
[0];
1863 hw
->fifos
[HFCUSB_B2_TX
].bch
= &hw
->bch
[1];
1864 hw
->fifos
[HFCUSB_B2_RX
].bch
= &hw
->bch
[1];
1865 hw
->fifos
[HFCUSB_D_TX
].dch
= &hw
->dch
;
1866 hw
->fifos
[HFCUSB_D_RX
].dch
= &hw
->dch
;
1867 hw
->fifos
[HFCUSB_PCM_RX
].ech
= &hw
->ech
;
1868 hw
->fifos
[HFCUSB_PCM_TX
].ech
= &hw
->ech
;
1870 err
= setup_hfcsusb(hw
);
1874 snprintf(hw
->name
, MISDN_MAX_IDLEN
- 1, "%s.%d", DRIVER_NAME
,
1876 printk(KERN_INFO
"%s: registered as '%s'\n",
1877 DRIVER_NAME
, hw
->name
);
1879 err
= mISDN_register_device(&hw
->dch
.dev
, parent
, hw
->name
);
1884 write_lock_irqsave(&HFClock
, flags
);
1885 list_add_tail(&hw
->list
, &HFClist
);
1886 write_unlock_irqrestore(&HFClock
, flags
);
1890 mISDN_freebchannel(&hw
->bch
[1]);
1891 mISDN_freebchannel(&hw
->bch
[0]);
1892 mISDN_freedchannel(&hw
->dch
);
1898 hfcsusb_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
1901 struct usb_device
*dev
= interface_to_usbdev(intf
);
1902 struct usb_host_interface
*iface
= intf
->cur_altsetting
;
1903 struct usb_host_interface
*iface_used
= NULL
;
1904 struct usb_host_endpoint
*ep
;
1905 struct hfcsusb_vdata
*driver_info
;
1906 int ifnum
= iface
->desc
.bInterfaceNumber
, i
, idx
, alt_idx
,
1907 probe_alt_setting
, vend_idx
, cfg_used
, *vcf
, attr
, cfg_found
,
1908 ep_addr
, cmptbl
[16], small_match
, iso_packet_size
, packet_size
,
1912 for (i
= 0; hfcsusb_idtab
[i
].idVendor
; i
++) {
1913 if ((le16_to_cpu(dev
->descriptor
.idVendor
)
1914 == hfcsusb_idtab
[i
].idVendor
) &&
1915 (le16_to_cpu(dev
->descriptor
.idProduct
)
1916 == hfcsusb_idtab
[i
].idProduct
)) {
1923 "%s: interface(%d) actalt(%d) minor(%d) vend_idx(%d)\n",
1924 __func__
, ifnum
, iface
->desc
.bAlternateSetting
,
1925 intf
->minor
, vend_idx
);
1927 if (vend_idx
== 0xffff) {
1929 "%s: no valid vendor found in USB descriptor\n",
1933 /* if vendor and product ID is OK, start probing alternate settings */
1937 /* default settings */
1938 iso_packet_size
= 16;
1941 while (alt_idx
< intf
->num_altsetting
) {
1942 iface
= intf
->altsetting
+ alt_idx
;
1943 probe_alt_setting
= iface
->desc
.bAlternateSetting
;
1946 while (validconf
[cfg_used
][0]) {
1948 vcf
= validconf
[cfg_used
];
1949 ep
= iface
->endpoint
;
1950 memcpy(cmptbl
, vcf
, 16 * sizeof(int));
1952 /* check for all endpoints in this alternate setting */
1953 for (i
= 0; i
< iface
->desc
.bNumEndpoints
; i
++) {
1954 ep_addr
= ep
->desc
.bEndpointAddress
;
1956 /* get endpoint base */
1957 idx
= ((ep_addr
& 0x7f) - 1) * 2;
1960 attr
= ep
->desc
.bmAttributes
;
1962 if (cmptbl
[idx
] != EP_NOP
) {
1963 if (cmptbl
[idx
] == EP_NUL
)
1965 if (attr
== USB_ENDPOINT_XFER_INT
1966 && cmptbl
[idx
] == EP_INT
)
1967 cmptbl
[idx
] = EP_NUL
;
1968 if (attr
== USB_ENDPOINT_XFER_BULK
1969 && cmptbl
[idx
] == EP_BLK
)
1970 cmptbl
[idx
] = EP_NUL
;
1971 if (attr
== USB_ENDPOINT_XFER_ISOC
1972 && cmptbl
[idx
] == EP_ISO
)
1973 cmptbl
[idx
] = EP_NUL
;
1975 if (attr
== USB_ENDPOINT_XFER_INT
&&
1976 ep
->desc
.bInterval
< vcf
[17]) {
1983 for (i
= 0; i
< 16; i
++)
1984 if (cmptbl
[i
] != EP_NOP
&& cmptbl
[i
] != EP_NUL
)
1988 if (small_match
< cfg_used
) {
1989 small_match
= cfg_used
;
1990 alt_used
= probe_alt_setting
;
1997 } /* (alt_idx < intf->num_altsetting) */
1999 /* not found a valid USB Ta Endpoint config */
2000 if (small_match
== -1)
2004 hw
= kzalloc(sizeof(struct hfcsusb
), GFP_KERNEL
);
2006 return -ENOMEM
; /* got no mem */
2007 snprintf(hw
->name
, MISDN_MAX_IDLEN
- 1, "%s", DRIVER_NAME
);
2009 ep
= iface
->endpoint
;
2010 vcf
= validconf
[small_match
];
2012 for (i
= 0; i
< iface
->desc
.bNumEndpoints
; i
++) {
2015 ep_addr
= ep
->desc
.bEndpointAddress
;
2016 /* get endpoint base */
2017 idx
= ((ep_addr
& 0x7f) - 1) * 2;
2020 f
= &hw
->fifos
[idx
& 7];
2022 /* init Endpoints */
2023 if (vcf
[idx
] == EP_NOP
|| vcf
[idx
] == EP_NUL
) {
2027 switch (ep
->desc
.bmAttributes
) {
2028 case USB_ENDPOINT_XFER_INT
:
2029 f
->pipe
= usb_rcvintpipe(dev
,
2030 ep
->desc
.bEndpointAddress
);
2031 f
->usb_transfer_mode
= USB_INT
;
2032 packet_size
= le16_to_cpu(ep
->desc
.wMaxPacketSize
);
2034 case USB_ENDPOINT_XFER_BULK
:
2036 f
->pipe
= usb_rcvbulkpipe(dev
,
2037 ep
->desc
.bEndpointAddress
);
2039 f
->pipe
= usb_sndbulkpipe(dev
,
2040 ep
->desc
.bEndpointAddress
);
2041 f
->usb_transfer_mode
= USB_BULK
;
2042 packet_size
= le16_to_cpu(ep
->desc
.wMaxPacketSize
);
2044 case USB_ENDPOINT_XFER_ISOC
:
2046 f
->pipe
= usb_rcvisocpipe(dev
,
2047 ep
->desc
.bEndpointAddress
);
2049 f
->pipe
= usb_sndisocpipe(dev
,
2050 ep
->desc
.bEndpointAddress
);
2051 f
->usb_transfer_mode
= USB_ISOC
;
2052 iso_packet_size
= le16_to_cpu(ep
->desc
.wMaxPacketSize
);
2059 f
->fifonum
= idx
& 7;
2061 f
->usb_packet_maxlen
=
2062 le16_to_cpu(ep
->desc
.wMaxPacketSize
);
2063 f
->intervall
= ep
->desc
.bInterval
;
2067 hw
->dev
= dev
; /* save device */
2068 hw
->if_used
= ifnum
; /* save used interface */
2069 hw
->alt_used
= alt_used
; /* and alternate config */
2070 hw
->ctrl_paksize
= dev
->descriptor
.bMaxPacketSize0
; /* control size */
2071 hw
->cfg_used
= vcf
[16]; /* store used config */
2072 hw
->vend_idx
= vend_idx
; /* store found vendor */
2073 hw
->packet_size
= packet_size
;
2074 hw
->iso_packet_size
= iso_packet_size
;
2076 /* create the control pipes needed for register access */
2077 hw
->ctrl_in_pipe
= usb_rcvctrlpipe(hw
->dev
, 0);
2078 hw
->ctrl_out_pipe
= usb_sndctrlpipe(hw
->dev
, 0);
2080 driver_info
= (struct hfcsusb_vdata
*)
2081 hfcsusb_idtab
[vend_idx
].driver_info
;
2083 hw
->ctrl_urb
= usb_alloc_urb(0, GFP_KERNEL
);
2084 if (!hw
->ctrl_urb
) {
2085 pr_warn("%s: No memory for control urb\n",
2086 driver_info
->vend_name
);
2091 pr_info("%s: %s: detected \"%s\" (%s, if=%d alt=%d)\n",
2092 hw
->name
, __func__
, driver_info
->vend_name
,
2093 conf_str
[small_match
], ifnum
, alt_used
);
2095 if (setup_instance(hw
, dev
->dev
.parent
))
2099 usb_set_intfdata(hw
->intf
, hw
);
2103 /* function called when an active device is removed */
2105 hfcsusb_disconnect(struct usb_interface
*intf
)
2107 struct hfcsusb
*hw
= usb_get_intfdata(intf
);
2108 struct hfcsusb
*next
;
2111 printk(KERN_INFO
"%s: device disconnected\n", hw
->name
);
2113 handle_led(hw
, LED_POWER_OFF
);
2116 list_for_each_entry_safe(hw
, next
, &HFClist
, list
)
2121 usb_set_intfdata(intf
, NULL
);
2124 static struct usb_driver hfcsusb_drv
= {
2125 .name
= DRIVER_NAME
,
2126 .id_table
= hfcsusb_idtab
,
2127 .probe
= hfcsusb_probe
,
2128 .disconnect
= hfcsusb_disconnect
,
2129 .disable_hub_initiated_lpm
= 1,
2132 module_usb_driver(hfcsusb_drv
);