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 int 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 struct_size(phi
, bch
, dch
->dev
.nrbchan
), phi
, GFP_ATOMIC
);
271 * Layer2 -> Layer 1 Dchannel data
274 hfcusb_l2l1D(struct mISDNchannel
*ch
, struct sk_buff
*skb
)
276 struct mISDNdevice
*dev
= container_of(ch
, struct mISDNdevice
, D
);
277 struct dchannel
*dch
= container_of(dev
, struct dchannel
, dev
);
278 struct mISDNhead
*hh
= mISDN_HEAD_P(skb
);
279 struct hfcsusb
*hw
= dch
->hw
;
285 if (debug
& DBG_HFC_CALL_TRACE
)
286 printk(KERN_DEBUG
"%s: %s: PH_DATA_REQ\n",
289 spin_lock_irqsave(&hw
->lock
, flags
);
290 ret
= dchannel_senddata(dch
, skb
);
291 spin_unlock_irqrestore(&hw
->lock
, flags
);
294 queue_ch_frame(ch
, PH_DATA_CNF
, hh
->id
, NULL
);
298 case PH_ACTIVATE_REQ
:
299 if (debug
& DBG_HFC_CALL_TRACE
)
300 printk(KERN_DEBUG
"%s: %s: PH_ACTIVATE_REQ %s\n",
302 (hw
->protocol
== ISDN_P_NT_S0
) ? "NT" : "TE");
304 if (hw
->protocol
== ISDN_P_NT_S0
) {
306 if (test_bit(FLG_ACTIVE
, &dch
->Flags
)) {
307 _queue_data(&dch
->dev
.D
,
308 PH_ACTIVATE_IND
, MISDN_ID_ANY
, 0,
311 hfcsusb_ph_command(hw
,
313 test_and_set_bit(FLG_L2_ACTIVATED
,
317 hfcsusb_ph_command(hw
, HFC_L1_ACTIVATE_TE
);
318 ret
= l1_event(dch
->l1
, hh
->prim
);
322 case PH_DEACTIVATE_REQ
:
323 if (debug
& DBG_HFC_CALL_TRACE
)
324 printk(KERN_DEBUG
"%s: %s: PH_DEACTIVATE_REQ\n",
326 test_and_clear_bit(FLG_L2_ACTIVATED
, &dch
->Flags
);
328 if (hw
->protocol
== ISDN_P_NT_S0
) {
329 struct sk_buff_head free_queue
;
331 __skb_queue_head_init(&free_queue
);
332 hfcsusb_ph_command(hw
, HFC_L1_DEACTIVATE_NT
);
333 spin_lock_irqsave(&hw
->lock
, flags
);
334 skb_queue_splice_init(&dch
->squeue
, &free_queue
);
336 __skb_queue_tail(&free_queue
, dch
->tx_skb
);
341 __skb_queue_tail(&free_queue
, dch
->rx_skb
);
344 test_and_clear_bit(FLG_TX_BUSY
, &dch
->Flags
);
345 spin_unlock_irqrestore(&hw
->lock
, flags
);
346 __skb_queue_purge(&free_queue
);
348 if (test_and_clear_bit(FLG_L1_BUSY
, &dch
->Flags
))
349 dchannel_sched_event(&hc
->dch
, D_CLEARBUSY
);
353 ret
= l1_event(dch
->l1
, hh
->prim
);
355 case MPH_INFORMATION_REQ
:
356 ret
= hfcsusb_ph_info(hw
);
364 * Layer 1 callback function
367 hfc_l1callback(struct dchannel
*dch
, u_int cmd
)
369 struct hfcsusb
*hw
= dch
->hw
;
371 if (debug
& DBG_HFC_CALL_TRACE
)
372 printk(KERN_DEBUG
"%s: %s cmd 0x%x\n",
373 hw
->name
, __func__
, cmd
);
383 skb_queue_purge(&dch
->squeue
);
385 dev_kfree_skb(dch
->tx_skb
);
390 dev_kfree_skb(dch
->rx_skb
);
393 test_and_clear_bit(FLG_TX_BUSY
, &dch
->Flags
);
395 case PH_ACTIVATE_IND
:
396 test_and_set_bit(FLG_ACTIVE
, &dch
->Flags
);
397 _queue_data(&dch
->dev
.D
, cmd
, MISDN_ID_ANY
, 0, NULL
,
400 case PH_DEACTIVATE_IND
:
401 test_and_clear_bit(FLG_ACTIVE
, &dch
->Flags
);
402 _queue_data(&dch
->dev
.D
, cmd
, MISDN_ID_ANY
, 0, NULL
,
406 if (dch
->debug
& DEBUG_HW
)
407 printk(KERN_DEBUG
"%s: %s: unknown cmd %x\n",
408 hw
->name
, __func__
, cmd
);
411 return hfcsusb_ph_info(hw
);
415 open_dchannel(struct hfcsusb
*hw
, struct mISDNchannel
*ch
,
416 struct channel_req
*rq
)
420 if (debug
& DEBUG_HW_OPEN
)
421 printk(KERN_DEBUG
"%s: %s: dev(%d) open addr(%i) from %p\n",
422 hw
->name
, __func__
, hw
->dch
.dev
.id
, rq
->adr
.channel
,
423 __builtin_return_address(0));
424 if (rq
->protocol
== ISDN_P_NONE
)
427 test_and_clear_bit(FLG_ACTIVE
, &hw
->dch
.Flags
);
428 test_and_clear_bit(FLG_ACTIVE
, &hw
->ech
.Flags
);
429 hfcsusb_start_endpoint(hw
, HFC_CHAN_D
);
431 /* E-Channel logging */
432 if (rq
->adr
.channel
== 1) {
433 if (hw
->fifos
[HFCUSB_PCM_RX
].pipe
) {
434 hfcsusb_start_endpoint(hw
, HFC_CHAN_E
);
435 set_bit(FLG_ACTIVE
, &hw
->ech
.Flags
);
436 _queue_data(&hw
->ech
.dev
.D
, PH_ACTIVATE_IND
,
437 MISDN_ID_ANY
, 0, NULL
, GFP_ATOMIC
);
443 hw
->protocol
= rq
->protocol
;
444 if (rq
->protocol
== ISDN_P_TE_S0
) {
445 err
= create_l1(&hw
->dch
, hfc_l1callback
);
450 ch
->protocol
= rq
->protocol
;
453 if (rq
->protocol
!= ch
->protocol
)
454 return -EPROTONOSUPPORT
;
457 if (((ch
->protocol
== ISDN_P_NT_S0
) && (hw
->dch
.state
== 3)) ||
458 ((ch
->protocol
== ISDN_P_TE_S0
) && (hw
->dch
.state
== 7)))
459 _queue_data(ch
, PH_ACTIVATE_IND
, MISDN_ID_ANY
,
460 0, NULL
, GFP_KERNEL
);
462 if (!try_module_get(THIS_MODULE
))
463 printk(KERN_WARNING
"%s: %s: cannot get module\n",
469 open_bchannel(struct hfcsusb
*hw
, struct channel_req
*rq
)
471 struct bchannel
*bch
;
473 if (rq
->adr
.channel
== 0 || rq
->adr
.channel
> 2)
475 if (rq
->protocol
== ISDN_P_NONE
)
478 if (debug
& DBG_HFC_CALL_TRACE
)
479 printk(KERN_DEBUG
"%s: %s B%i\n",
480 hw
->name
, __func__
, rq
->adr
.channel
);
482 bch
= &hw
->bch
[rq
->adr
.channel
- 1];
483 if (test_and_set_bit(FLG_OPEN
, &bch
->Flags
))
484 return -EBUSY
; /* b-channel can be only open once */
485 bch
->ch
.protocol
= rq
->protocol
;
488 if (!try_module_get(THIS_MODULE
))
489 printk(KERN_WARNING
"%s: %s:cannot get module\n",
495 channel_ctrl(struct hfcsusb
*hw
, struct mISDN_ctrl_req
*cq
)
499 if (debug
& DBG_HFC_CALL_TRACE
)
500 printk(KERN_DEBUG
"%s: %s op(0x%x) channel(0x%x)\n",
501 hw
->name
, __func__
, (cq
->op
), (cq
->channel
));
504 case MISDN_CTRL_GETOP
:
505 cq
->op
= MISDN_CTRL_LOOP
| MISDN_CTRL_CONNECT
|
506 MISDN_CTRL_DISCONNECT
;
509 printk(KERN_WARNING
"%s: %s: unknown Op %x\n",
510 hw
->name
, __func__
, cq
->op
);
518 * device control function
521 hfc_dctrl(struct mISDNchannel
*ch
, u_int cmd
, void *arg
)
523 struct mISDNdevice
*dev
= container_of(ch
, struct mISDNdevice
, D
);
524 struct dchannel
*dch
= container_of(dev
, struct dchannel
, dev
);
525 struct hfcsusb
*hw
= dch
->hw
;
526 struct channel_req
*rq
;
529 if (dch
->debug
& DEBUG_HW
)
530 printk(KERN_DEBUG
"%s: %s: cmd:%x %p\n",
531 hw
->name
, __func__
, cmd
, arg
);
535 if ((rq
->protocol
== ISDN_P_TE_S0
) ||
536 (rq
->protocol
== ISDN_P_NT_S0
))
537 err
= open_dchannel(hw
, ch
, rq
);
539 err
= open_bchannel(hw
, rq
);
545 if (debug
& DEBUG_HW_OPEN
)
547 "%s: %s: dev(%d) close from %p (open %d)\n",
548 hw
->name
, __func__
, hw
->dch
.dev
.id
,
549 __builtin_return_address(0), hw
->open
);
551 hfcsusb_stop_endpoint(hw
, HFC_CHAN_D
);
552 if (hw
->fifos
[HFCUSB_PCM_RX
].pipe
)
553 hfcsusb_stop_endpoint(hw
, HFC_CHAN_E
);
554 handle_led(hw
, LED_POWER_ON
);
556 module_put(THIS_MODULE
);
558 case CONTROL_CHANNEL
:
559 err
= channel_ctrl(hw
, arg
);
562 if (dch
->debug
& DEBUG_HW
)
563 printk(KERN_DEBUG
"%s: %s: unknown command %x\n",
564 hw
->name
, __func__
, cmd
);
571 * S0 TE state change event handler
574 ph_state_te(struct dchannel
*dch
)
576 struct hfcsusb
*hw
= dch
->hw
;
578 if (debug
& DEBUG_HW
) {
579 if (dch
->state
<= HFC_MAX_TE_LAYER1_STATE
)
580 printk(KERN_DEBUG
"%s: %s: %s\n", hw
->name
, __func__
,
581 HFC_TE_LAYER1_STATES
[dch
->state
]);
583 printk(KERN_DEBUG
"%s: %s: TE F%d\n",
584 hw
->name
, __func__
, dch
->state
);
587 switch (dch
->state
) {
589 l1_event(dch
->l1
, HW_RESET_IND
);
592 l1_event(dch
->l1
, HW_DEACT_IND
);
596 l1_event(dch
->l1
, ANYSIGNAL
);
599 l1_event(dch
->l1
, INFO2
);
602 l1_event(dch
->l1
, INFO4_P8
);
606 handle_led(hw
, LED_S0_ON
);
608 handle_led(hw
, LED_S0_OFF
);
612 * S0 NT state change event handler
615 ph_state_nt(struct dchannel
*dch
)
617 struct hfcsusb
*hw
= dch
->hw
;
619 if (debug
& DEBUG_HW
) {
620 if (dch
->state
<= HFC_MAX_NT_LAYER1_STATE
)
621 printk(KERN_DEBUG
"%s: %s: %s\n",
623 HFC_NT_LAYER1_STATES
[dch
->state
]);
626 printk(KERN_INFO DRIVER_NAME
"%s: %s: NT G%d\n",
627 hw
->name
, __func__
, dch
->state
);
630 switch (dch
->state
) {
632 test_and_clear_bit(FLG_ACTIVE
, &dch
->Flags
);
633 test_and_clear_bit(FLG_L2_ACTIVATED
, &dch
->Flags
);
635 hw
->timers
&= ~NT_ACTIVATION_TIMER
;
636 handle_led(hw
, LED_S0_OFF
);
640 if (hw
->nt_timer
< 0) {
642 hw
->timers
&= ~NT_ACTIVATION_TIMER
;
643 hfcsusb_ph_command(dch
->hw
, HFC_L1_DEACTIVATE_NT
);
645 hw
->timers
|= NT_ACTIVATION_TIMER
;
646 hw
->nt_timer
= NT_T1_COUNT
;
647 /* allow G2 -> G3 transition */
648 write_reg(hw
, HFCUSB_STATES
, 2 | HFCUSB_NT_G2_G3
);
653 hw
->timers
&= ~NT_ACTIVATION_TIMER
;
654 test_and_set_bit(FLG_ACTIVE
, &dch
->Flags
);
655 _queue_data(&dch
->dev
.D
, PH_ACTIVATE_IND
,
656 MISDN_ID_ANY
, 0, NULL
, GFP_ATOMIC
);
657 handle_led(hw
, LED_S0_ON
);
661 hw
->timers
&= ~NT_ACTIVATION_TIMER
;
670 ph_state(struct dchannel
*dch
)
672 struct hfcsusb
*hw
= dch
->hw
;
674 if (hw
->protocol
== ISDN_P_NT_S0
)
676 else if (hw
->protocol
== ISDN_P_TE_S0
)
681 * disable/enable BChannel for desired protocol
684 hfcsusb_setup_bch(struct bchannel
*bch
, int protocol
)
686 struct hfcsusb
*hw
= bch
->hw
;
687 __u8 conhdlc
, sctrl
, sctrl_r
;
689 if (debug
& DEBUG_HW
)
690 printk(KERN_DEBUG
"%s: %s: protocol %x-->%x B%d\n",
691 hw
->name
, __func__
, bch
->state
, protocol
,
694 /* setup val for CON_HDLC */
696 if (protocol
> ISDN_P_NONE
)
697 conhdlc
= 8; /* enable FIFO */
700 case (-1): /* used for init */
704 if (bch
->state
== ISDN_P_NONE
)
705 return 0; /* already in idle state */
706 bch
->state
= ISDN_P_NONE
;
707 clear_bit(FLG_HDLC
, &bch
->Flags
);
708 clear_bit(FLG_TRANSPARENT
, &bch
->Flags
);
712 bch
->state
= protocol
;
713 set_bit(FLG_TRANSPARENT
, &bch
->Flags
);
715 case (ISDN_P_B_HDLC
):
716 bch
->state
= protocol
;
717 set_bit(FLG_HDLC
, &bch
->Flags
);
720 if (debug
& DEBUG_HW
)
721 printk(KERN_DEBUG
"%s: %s: prot not known %x\n",
722 hw
->name
, __func__
, protocol
);
726 if (protocol
>= ISDN_P_NONE
) {
727 write_reg(hw
, HFCUSB_FIFO
, (bch
->nr
== 1) ? 0 : 2);
728 write_reg(hw
, HFCUSB_CON_HDLC
, conhdlc
);
729 write_reg(hw
, HFCUSB_INC_RES_F
, 2);
730 write_reg(hw
, HFCUSB_FIFO
, (bch
->nr
== 1) ? 1 : 3);
731 write_reg(hw
, HFCUSB_CON_HDLC
, conhdlc
);
732 write_reg(hw
, HFCUSB_INC_RES_F
, 2);
734 sctrl
= 0x40 + ((hw
->protocol
== ISDN_P_TE_S0
) ? 0x00 : 0x04);
736 if (test_bit(FLG_ACTIVE
, &hw
->bch
[0].Flags
)) {
740 if (test_bit(FLG_ACTIVE
, &hw
->bch
[1].Flags
)) {
744 write_reg(hw
, HFCUSB_SCTRL
, sctrl
);
745 write_reg(hw
, HFCUSB_SCTRL_R
, sctrl_r
);
747 if (protocol
> ISDN_P_NONE
)
748 handle_led(hw
, (bch
->nr
== 1) ? LED_B1_ON
: LED_B2_ON
);
750 handle_led(hw
, (bch
->nr
== 1) ? LED_B1_OFF
:
753 return hfcsusb_ph_info(hw
);
757 hfcsusb_ph_command(struct hfcsusb
*hw
, u_char command
)
759 if (debug
& DEBUG_HW
)
760 printk(KERN_DEBUG
"%s: %s: %x\n",
761 hw
->name
, __func__
, command
);
764 case HFC_L1_ACTIVATE_TE
:
765 /* force sending sending INFO1 */
766 write_reg(hw
, HFCUSB_STATES
, 0x14);
767 /* start l1 activation */
768 write_reg(hw
, HFCUSB_STATES
, 0x04);
771 case HFC_L1_FORCE_DEACTIVATE_TE
:
772 write_reg(hw
, HFCUSB_STATES
, 0x10);
773 write_reg(hw
, HFCUSB_STATES
, 0x03);
776 case HFC_L1_ACTIVATE_NT
:
777 if (hw
->dch
.state
== 3)
778 _queue_data(&hw
->dch
.dev
.D
, PH_ACTIVATE_IND
,
779 MISDN_ID_ANY
, 0, NULL
, GFP_ATOMIC
);
781 write_reg(hw
, HFCUSB_STATES
, HFCUSB_ACTIVATE
|
782 HFCUSB_DO_ACTION
| HFCUSB_NT_G2_G3
);
785 case HFC_L1_DEACTIVATE_NT
:
786 write_reg(hw
, HFCUSB_STATES
,
793 * Layer 1 B-channel hardware access
796 channel_bctrl(struct bchannel
*bch
, struct mISDN_ctrl_req
*cq
)
798 return mISDN_ctrl_bchannel(bch
, cq
);
801 /* collect data from incoming interrupt or isochron USB data */
803 hfcsusb_rx_frame(struct usb_fifo
*fifo
, __u8
*data
, unsigned int len
,
806 struct hfcsusb
*hw
= fifo
->hw
;
807 struct sk_buff
*rx_skb
= NULL
;
809 int fifon
= fifo
->fifonum
;
814 if (debug
& DBG_HFC_CALL_TRACE
)
815 printk(KERN_DEBUG
"%s: %s: fifo(%i) len(%i) "
816 "dch(%p) bch(%p) ech(%p)\n",
817 hw
->name
, __func__
, fifon
, len
,
818 fifo
->dch
, fifo
->bch
, fifo
->ech
);
823 if ((!!fifo
->dch
+ !!fifo
->bch
+ !!fifo
->ech
) != 1) {
824 printk(KERN_DEBUG
"%s: %s: undefined channel\n",
829 spin_lock_irqsave(&hw
->lock
, flags
);
831 rx_skb
= fifo
->dch
->rx_skb
;
832 maxlen
= fifo
->dch
->maxlen
;
836 if (test_bit(FLG_RX_OFF
, &fifo
->bch
->Flags
)) {
837 fifo
->bch
->dropcnt
+= len
;
838 spin_unlock_irqrestore(&hw
->lock
, flags
);
841 maxlen
= bchannel_get_rxbuf(fifo
->bch
, len
);
842 rx_skb
= fifo
->bch
->rx_skb
;
846 pr_warn("%s.B%d: No bufferspace for %d bytes\n",
847 hw
->name
, fifo
->bch
->nr
, len
);
848 spin_unlock_irqrestore(&hw
->lock
, flags
);
851 maxlen
= fifo
->bch
->maxlen
;
852 hdlc
= test_bit(FLG_HDLC
, &fifo
->bch
->Flags
);
855 rx_skb
= fifo
->ech
->rx_skb
;
856 maxlen
= fifo
->ech
->maxlen
;
860 if (fifo
->dch
|| fifo
->ech
) {
862 rx_skb
= mI_alloc_skb(maxlen
, GFP_ATOMIC
);
865 fifo
->dch
->rx_skb
= rx_skb
;
867 fifo
->ech
->rx_skb
= rx_skb
;
870 printk(KERN_DEBUG
"%s: %s: No mem for rx_skb\n",
872 spin_unlock_irqrestore(&hw
->lock
, flags
);
876 /* D/E-Channel SKB range check */
877 if ((rx_skb
->len
+ len
) >= MAX_DFRAME_LEN_L1
) {
878 printk(KERN_DEBUG
"%s: %s: sbk mem exceeded "
879 "for fifo(%d) HFCUSB_D_RX\n",
880 hw
->name
, __func__
, fifon
);
882 spin_unlock_irqrestore(&hw
->lock
, flags
);
887 skb_put_data(rx_skb
, data
, len
);
890 /* we have a complete hdlc packet */
892 if ((rx_skb
->len
> 3) &&
893 (!(rx_skb
->data
[rx_skb
->len
- 1]))) {
894 if (debug
& DBG_HFC_FIFO_VERBOSE
) {
895 printk(KERN_DEBUG
"%s: %s: fifon(%i)"
897 hw
->name
, __func__
, fifon
,
900 while (i
< rx_skb
->len
)
906 /* remove CRC & status */
907 skb_trim(rx_skb
, rx_skb
->len
- 3);
910 recv_Dchannel(fifo
->dch
);
912 recv_Bchannel(fifo
->bch
, MISDN_ID_ANY
,
915 recv_Echannel(fifo
->ech
,
918 if (debug
& DBG_HFC_FIFO_VERBOSE
) {
920 "%s: CRC or minlen ERROR fifon(%i) "
922 hw
->name
, fifon
, rx_skb
->len
);
924 while (i
< rx_skb
->len
)
933 /* deliver transparent data to layer2 */
934 recv_Bchannel(fifo
->bch
, MISDN_ID_ANY
, false);
936 spin_unlock_irqrestore(&hw
->lock
, flags
);
940 fill_isoc_urb(struct urb
*urb
, struct usb_device
*dev
, unsigned int pipe
,
941 void *buf
, int num_packets
, int packet_size
, int interval
,
942 usb_complete_t complete
, void *context
)
946 usb_fill_bulk_urb(urb
, dev
, pipe
, buf
, packet_size
* num_packets
,
949 urb
->number_of_packets
= num_packets
;
950 urb
->transfer_flags
= URB_ISO_ASAP
;
951 urb
->actual_length
= 0;
952 urb
->interval
= interval
;
954 for (k
= 0; k
< num_packets
; k
++) {
955 urb
->iso_frame_desc
[k
].offset
= packet_size
* k
;
956 urb
->iso_frame_desc
[k
].length
= packet_size
;
957 urb
->iso_frame_desc
[k
].actual_length
= 0;
961 /* receive completion routine for all ISO tx fifos */
963 rx_iso_complete(struct urb
*urb
)
965 struct iso_urb
*context_iso_urb
= (struct iso_urb
*) urb
->context
;
966 struct usb_fifo
*fifo
= context_iso_urb
->owner_fifo
;
967 struct hfcsusb
*hw
= fifo
->hw
;
968 int k
, len
, errcode
, offset
, num_isoc_packets
, fifon
, maxlen
,
969 status
, iso_status
, i
;
975 fifon
= fifo
->fifonum
;
976 status
= urb
->status
;
978 spin_lock_irqsave(&hw
->lock
, flags
);
979 if (fifo
->stop_gracefull
) {
980 fifo
->stop_gracefull
= 0;
982 spin_unlock_irqrestore(&hw
->lock
, flags
);
985 spin_unlock_irqrestore(&hw
->lock
, flags
);
988 * ISO transfer only partially completed,
989 * look at individual frame status for details
991 if (status
== -EXDEV
) {
992 if (debug
& DEBUG_HW
)
993 printk(KERN_DEBUG
"%s: %s: with -EXDEV "
994 "urb->status %d, fifonum %d\n",
995 hw
->name
, __func__
, status
, fifon
);
997 /* clear status, so go on with ISO transfers */
1002 if (fifo
->active
&& !status
) {
1003 num_isoc_packets
= iso_packets
[fifon
];
1004 maxlen
= fifo
->usb_packet_maxlen
;
1006 for (k
= 0; k
< num_isoc_packets
; ++k
) {
1007 len
= urb
->iso_frame_desc
[k
].actual_length
;
1008 offset
= urb
->iso_frame_desc
[k
].offset
;
1009 buf
= context_iso_urb
->buffer
+ offset
;
1010 iso_status
= urb
->iso_frame_desc
[k
].status
;
1012 if (iso_status
&& (debug
& DBG_HFC_FIFO_VERBOSE
)) {
1013 printk(KERN_DEBUG
"%s: %s: "
1014 "ISO packet %i, status: %i\n",
1015 hw
->name
, __func__
, k
, iso_status
);
1018 /* USB data log for every D ISO in */
1019 if ((fifon
== HFCUSB_D_RX
) &&
1020 (debug
& DBG_HFC_USB_VERBOSE
)) {
1022 "%s: %s: %d (%d/%d) len(%d) ",
1023 hw
->name
, __func__
, urb
->start_frame
,
1024 k
, num_isoc_packets
- 1,
1026 for (i
= 0; i
< len
; i
++)
1027 printk("%x ", buf
[i
]);
1032 if (fifo
->last_urblen
!= maxlen
) {
1034 * save fifo fill-level threshold bits
1035 * to use them later in TX ISO URB
1038 hw
->threshold_mask
= buf
[1];
1040 if (fifon
== HFCUSB_D_RX
)
1041 s0_state
= (buf
[0] >> 4);
1043 eof
[fifon
] = buf
[0] & 1;
1045 hfcsusb_rx_frame(fifo
, buf
+ 2,
1046 len
- 2, (len
< maxlen
)
1049 hfcsusb_rx_frame(fifo
, buf
, len
,
1052 fifo
->last_urblen
= len
;
1056 /* signal S0 layer1 state change */
1057 if ((s0_state
) && (hw
->initdone
) &&
1058 (s0_state
!= hw
->dch
.state
)) {
1059 hw
->dch
.state
= s0_state
;
1060 schedule_event(&hw
->dch
, FLG_PHCHANGE
);
1063 fill_isoc_urb(urb
, fifo
->hw
->dev
, fifo
->pipe
,
1064 context_iso_urb
->buffer
, num_isoc_packets
,
1065 fifo
->usb_packet_maxlen
, fifo
->intervall
,
1066 (usb_complete_t
)rx_iso_complete
, urb
->context
);
1067 errcode
= usb_submit_urb(urb
, GFP_ATOMIC
);
1069 if (debug
& DEBUG_HW
)
1070 printk(KERN_DEBUG
"%s: %s: error submitting "
1072 hw
->name
, __func__
, errcode
);
1075 if (status
&& (debug
& DBG_HFC_URB_INFO
))
1076 printk(KERN_DEBUG
"%s: %s: rx_iso_complete : "
1077 "urb->status %d, fifonum %d\n",
1078 hw
->name
, __func__
, status
, fifon
);
1082 /* receive completion routine for all interrupt rx fifos */
1084 rx_int_complete(struct urb
*urb
)
1087 __u8
*buf
, maxlen
, fifon
;
1088 struct usb_fifo
*fifo
= (struct usb_fifo
*) urb
->context
;
1089 struct hfcsusb
*hw
= fifo
->hw
;
1091 unsigned long flags
;
1093 spin_lock_irqsave(&hw
->lock
, flags
);
1094 if (fifo
->stop_gracefull
) {
1095 fifo
->stop_gracefull
= 0;
1097 spin_unlock_irqrestore(&hw
->lock
, flags
);
1100 spin_unlock_irqrestore(&hw
->lock
, flags
);
1102 fifon
= fifo
->fifonum
;
1103 if ((!fifo
->active
) || (urb
->status
)) {
1104 if (debug
& DBG_HFC_URB_ERROR
)
1106 "%s: %s: RX-Fifo %i is going down (%i)\n",
1107 hw
->name
, __func__
, fifon
, urb
->status
);
1109 fifo
->urb
->interval
= 0; /* cancel automatic rescheduling */
1112 len
= urb
->actual_length
;
1114 maxlen
= fifo
->usb_packet_maxlen
;
1116 /* USB data log for every D INT in */
1117 if ((fifon
== HFCUSB_D_RX
) && (debug
& DBG_HFC_USB_VERBOSE
)) {
1118 printk(KERN_DEBUG
"%s: %s: D RX INT len(%d) ",
1119 hw
->name
, __func__
, len
);
1120 for (i
= 0; i
< len
; i
++)
1121 printk("%02x ", buf
[i
]);
1125 if (fifo
->last_urblen
!= fifo
->usb_packet_maxlen
) {
1126 /* the threshold mask is in the 2nd status byte */
1127 hw
->threshold_mask
= buf
[1];
1129 /* signal S0 layer1 state change */
1130 if (hw
->initdone
&& ((buf
[0] >> 4) != hw
->dch
.state
)) {
1131 hw
->dch
.state
= (buf
[0] >> 4);
1132 schedule_event(&hw
->dch
, FLG_PHCHANGE
);
1135 eof
[fifon
] = buf
[0] & 1;
1136 /* if we have more than the 2 status bytes -> collect data */
1138 hfcsusb_rx_frame(fifo
, buf
+ 2,
1139 urb
->actual_length
- 2,
1140 (len
< maxlen
) ? eof
[fifon
] : 0);
1142 hfcsusb_rx_frame(fifo
, buf
, urb
->actual_length
,
1143 (len
< maxlen
) ? eof
[fifon
] : 0);
1145 fifo
->last_urblen
= urb
->actual_length
;
1147 status
= usb_submit_urb(urb
, GFP_ATOMIC
);
1149 if (debug
& DEBUG_HW
)
1150 printk(KERN_DEBUG
"%s: %s: error resubmitting USB\n",
1151 hw
->name
, __func__
);
1155 /* transmit completion routine for all ISO tx fifos */
1157 tx_iso_complete(struct urb
*urb
)
1159 struct iso_urb
*context_iso_urb
= (struct iso_urb
*) urb
->context
;
1160 struct usb_fifo
*fifo
= context_iso_urb
->owner_fifo
;
1161 struct hfcsusb
*hw
= fifo
->hw
;
1162 struct sk_buff
*tx_skb
;
1163 int k
, tx_offset
, num_isoc_packets
, sink
, remain
, current_len
,
1166 int frame_complete
, fifon
, status
, fillempty
= 0;
1168 unsigned long flags
;
1170 spin_lock_irqsave(&hw
->lock
, flags
);
1171 if (fifo
->stop_gracefull
) {
1172 fifo
->stop_gracefull
= 0;
1174 spin_unlock_irqrestore(&hw
->lock
, flags
);
1179 tx_skb
= fifo
->dch
->tx_skb
;
1180 tx_idx
= &fifo
->dch
->tx_idx
;
1182 } else if (fifo
->bch
) {
1183 tx_skb
= fifo
->bch
->tx_skb
;
1184 tx_idx
= &fifo
->bch
->tx_idx
;
1185 hdlc
= test_bit(FLG_HDLC
, &fifo
->bch
->Flags
);
1186 if (!tx_skb
&& !hdlc
&&
1187 test_bit(FLG_FILLEMPTY
, &fifo
->bch
->Flags
))
1190 printk(KERN_DEBUG
"%s: %s: neither BCH nor DCH\n",
1191 hw
->name
, __func__
);
1192 spin_unlock_irqrestore(&hw
->lock
, flags
);
1196 fifon
= fifo
->fifonum
;
1197 status
= urb
->status
;
1202 * ISO transfer only partially completed,
1203 * look at individual frame status for details
1205 if (status
== -EXDEV
) {
1206 if (debug
& DBG_HFC_URB_ERROR
)
1207 printk(KERN_DEBUG
"%s: %s: "
1208 "-EXDEV (%i) fifon (%d)\n",
1209 hw
->name
, __func__
, status
, fifon
);
1211 /* clear status, so go on with ISO transfers */
1215 if (fifo
->active
&& !status
) {
1216 /* is FifoFull-threshold set for our channel? */
1217 threshbit
= (hw
->threshold_mask
& (1 << fifon
));
1218 num_isoc_packets
= iso_packets
[fifon
];
1220 /* predict dataflow to avoid fifo overflow */
1221 if (fifon
>= HFCUSB_D_TX
)
1222 sink
= (threshbit
) ? SINK_DMIN
: SINK_DMAX
;
1224 sink
= (threshbit
) ? SINK_MIN
: SINK_MAX
;
1225 fill_isoc_urb(urb
, fifo
->hw
->dev
, fifo
->pipe
,
1226 context_iso_urb
->buffer
, num_isoc_packets
,
1227 fifo
->usb_packet_maxlen
, fifo
->intervall
,
1228 (usb_complete_t
)tx_iso_complete
, urb
->context
);
1229 memset(context_iso_urb
->buffer
, 0,
1230 sizeof(context_iso_urb
->buffer
));
1233 for (k
= 0; k
< num_isoc_packets
; ++k
) {
1234 /* analyze tx success of previous ISO packets */
1235 if (debug
& DBG_HFC_URB_ERROR
) {
1236 errcode
= urb
->iso_frame_desc
[k
].status
;
1238 printk(KERN_DEBUG
"%s: %s: "
1239 "ISO packet %i, status: %i\n",
1240 hw
->name
, __func__
, k
, errcode
);
1244 /* Generate next ISO Packets */
1246 remain
= tx_skb
->len
- *tx_idx
;
1248 remain
= 15; /* > not complete */
1253 fifo
->bit_line
-= sink
;
1254 current_len
= (0 - fifo
->bit_line
) / 8;
1255 if (current_len
> 14)
1257 if (current_len
< 0)
1259 if (remain
< current_len
)
1260 current_len
= remain
;
1262 /* how much bit do we put on the line? */
1263 fifo
->bit_line
+= current_len
* 8;
1265 context_iso_urb
->buffer
[tx_offset
] = 0;
1266 if (current_len
== remain
) {
1268 /* signal frame completion */
1270 buffer
[tx_offset
] = 1;
1271 /* add 2 byte flags and 16bit
1272 * CRC at end of ISDN frame */
1273 fifo
->bit_line
+= 32;
1278 /* copy tx data to iso-urb buffer */
1279 p
= context_iso_urb
->buffer
+ tx_offset
+ 1;
1281 memset(p
, fifo
->bch
->fill
[0],
1284 memcpy(p
, (tx_skb
->data
+ *tx_idx
),
1286 *tx_idx
+= current_len
;
1288 urb
->iso_frame_desc
[k
].offset
= tx_offset
;
1289 urb
->iso_frame_desc
[k
].length
= current_len
+ 1;
1291 /* USB data log for every D ISO out */
1292 if ((fifon
== HFCUSB_D_RX
) && !fillempty
&&
1293 (debug
& DBG_HFC_USB_VERBOSE
)) {
1295 "%s: %s (%d/%d) offs(%d) len(%d) ",
1297 k
, num_isoc_packets
- 1,
1298 urb
->iso_frame_desc
[k
].offset
,
1299 urb
->iso_frame_desc
[k
].length
);
1301 for (i
= urb
->iso_frame_desc
[k
].offset
;
1302 i
< (urb
->iso_frame_desc
[k
].offset
1303 + urb
->iso_frame_desc
[k
].length
);
1306 context_iso_urb
->buffer
[i
]);
1308 printk(" skb->len(%i) tx-idx(%d)\n",
1309 tx_skb
->len
, *tx_idx
);
1312 tx_offset
+= (current_len
+ 1);
1314 urb
->iso_frame_desc
[k
].offset
= tx_offset
++;
1315 urb
->iso_frame_desc
[k
].length
= 1;
1316 /* we lower data margin every msec */
1317 fifo
->bit_line
-= sink
;
1318 if (fifo
->bit_line
< BITLINE_INF
)
1319 fifo
->bit_line
= BITLINE_INF
;
1322 if (frame_complete
) {
1325 if (debug
& DBG_HFC_FIFO_VERBOSE
) {
1326 printk(KERN_DEBUG
"%s: %s: "
1327 "fifon(%i) new TX len(%i): ",
1329 fifon
, tx_skb
->len
);
1331 while (i
< tx_skb
->len
)
1337 dev_consume_skb_irq(tx_skb
);
1339 if (fifo
->dch
&& get_next_dframe(fifo
->dch
))
1340 tx_skb
= fifo
->dch
->tx_skb
;
1341 else if (fifo
->bch
&&
1342 get_next_bframe(fifo
->bch
))
1343 tx_skb
= fifo
->bch
->tx_skb
;
1346 errcode
= usb_submit_urb(urb
, GFP_ATOMIC
);
1348 if (debug
& DEBUG_HW
)
1350 "%s: %s: error submitting ISO URB: %d \n",
1351 hw
->name
, __func__
, errcode
);
1355 * abuse DChannel tx iso completion to trigger NT mode state
1356 * changes tx_iso_complete is assumed to be called every
1357 * fifo->intervall (ms)
1359 if ((fifon
== HFCUSB_D_TX
) && (hw
->protocol
== ISDN_P_NT_S0
)
1360 && (hw
->timers
& NT_ACTIVATION_TIMER
)) {
1361 if ((--hw
->nt_timer
) < 0)
1362 schedule_event(&hw
->dch
, FLG_PHCHANGE
);
1366 if (status
&& (debug
& DBG_HFC_URB_ERROR
))
1367 printk(KERN_DEBUG
"%s: %s: urb->status %s (%i)"
1370 symbolic(urb_errlist
, status
), status
, fifon
);
1372 spin_unlock_irqrestore(&hw
->lock
, flags
);
1376 * allocs urbs and start isoc transfer with two pending urbs to avoid
1377 * gaps in the transfer chain
1380 start_isoc_chain(struct usb_fifo
*fifo
, int num_packets_per_urb
,
1381 usb_complete_t complete
, int packet_size
)
1383 struct hfcsusb
*hw
= fifo
->hw
;
1387 printk(KERN_DEBUG
"%s: %s: fifo %i\n",
1388 hw
->name
, __func__
, fifo
->fifonum
);
1390 /* allocate Memory for Iso out Urbs */
1391 for (i
= 0; i
< 2; i
++) {
1392 if (!(fifo
->iso
[i
].urb
)) {
1394 usb_alloc_urb(num_packets_per_urb
, GFP_KERNEL
);
1395 if (!(fifo
->iso
[i
].urb
)) {
1397 "%s: %s: alloc urb for fifo %i failed",
1398 hw
->name
, __func__
, fifo
->fifonum
);
1401 fifo
->iso
[i
].owner_fifo
= (struct usb_fifo
*) fifo
;
1402 fifo
->iso
[i
].indx
= i
;
1404 /* Init the first iso */
1405 if (ISO_BUFFER_SIZE
>=
1406 (fifo
->usb_packet_maxlen
*
1407 num_packets_per_urb
)) {
1408 fill_isoc_urb(fifo
->iso
[i
].urb
,
1409 fifo
->hw
->dev
, fifo
->pipe
,
1410 fifo
->iso
[i
].buffer
,
1411 num_packets_per_urb
,
1412 fifo
->usb_packet_maxlen
,
1413 fifo
->intervall
, complete
,
1415 memset(fifo
->iso
[i
].buffer
, 0,
1416 sizeof(fifo
->iso
[i
].buffer
));
1418 for (k
= 0; k
< num_packets_per_urb
; k
++) {
1420 iso_frame_desc
[k
].offset
=
1423 iso_frame_desc
[k
].length
=
1428 "%s: %s: ISO Buffer size to small!\n",
1429 hw
->name
, __func__
);
1432 fifo
->bit_line
= BITLINE_INF
;
1434 errcode
= usb_submit_urb(fifo
->iso
[i
].urb
, GFP_KERNEL
);
1435 fifo
->active
= (errcode
>= 0) ? 1 : 0;
1436 fifo
->stop_gracefull
= 0;
1438 printk(KERN_DEBUG
"%s: %s: %s URB nr:%d\n",
1440 symbolic(urb_errlist
, errcode
), i
);
1443 return fifo
->active
;
1447 stop_iso_gracefull(struct usb_fifo
*fifo
)
1449 struct hfcsusb
*hw
= fifo
->hw
;
1453 for (i
= 0; i
< 2; i
++) {
1454 spin_lock_irqsave(&hw
->lock
, flags
);
1456 printk(KERN_DEBUG
"%s: %s for fifo %i.%i\n",
1457 hw
->name
, __func__
, fifo
->fifonum
, i
);
1458 fifo
->stop_gracefull
= 1;
1459 spin_unlock_irqrestore(&hw
->lock
, flags
);
1462 for (i
= 0; i
< 2; i
++) {
1464 while (fifo
->stop_gracefull
&& timeout
--)
1465 schedule_timeout_interruptible((HZ
/ 1000) * 16);
1466 if (debug
&& fifo
->stop_gracefull
)
1467 printk(KERN_DEBUG
"%s: ERROR %s for fifo %i.%i\n",
1468 hw
->name
, __func__
, fifo
->fifonum
, i
);
1473 stop_int_gracefull(struct usb_fifo
*fifo
)
1475 struct hfcsusb
*hw
= fifo
->hw
;
1479 spin_lock_irqsave(&hw
->lock
, flags
);
1481 printk(KERN_DEBUG
"%s: %s for fifo %i\n",
1482 hw
->name
, __func__
, fifo
->fifonum
);
1483 fifo
->stop_gracefull
= 1;
1484 spin_unlock_irqrestore(&hw
->lock
, flags
);
1487 while (fifo
->stop_gracefull
&& timeout
--)
1488 schedule_timeout_interruptible((HZ
/ 1000) * 3);
1489 if (debug
&& fifo
->stop_gracefull
)
1490 printk(KERN_DEBUG
"%s: ERROR %s for fifo %i\n",
1491 hw
->name
, __func__
, fifo
->fifonum
);
1494 /* start the interrupt transfer for the given fifo */
1496 start_int_fifo(struct usb_fifo
*fifo
)
1498 struct hfcsusb
*hw
= fifo
->hw
;
1502 printk(KERN_DEBUG
"%s: %s: INT IN fifo:%d\n",
1503 hw
->name
, __func__
, fifo
->fifonum
);
1506 fifo
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
1510 usb_fill_int_urb(fifo
->urb
, fifo
->hw
->dev
, fifo
->pipe
,
1511 fifo
->buffer
, fifo
->usb_packet_maxlen
,
1512 (usb_complete_t
)rx_int_complete
, fifo
, fifo
->intervall
);
1514 fifo
->stop_gracefull
= 0;
1515 errcode
= usb_submit_urb(fifo
->urb
, GFP_KERNEL
);
1517 printk(KERN_DEBUG
"%s: %s: submit URB: status:%i\n",
1518 hw
->name
, __func__
, errcode
);
1524 setPortMode(struct hfcsusb
*hw
)
1526 if (debug
& DEBUG_HW
)
1527 printk(KERN_DEBUG
"%s: %s %s\n", hw
->name
, __func__
,
1528 (hw
->protocol
== ISDN_P_TE_S0
) ? "TE" : "NT");
1530 if (hw
->protocol
== ISDN_P_TE_S0
) {
1531 write_reg(hw
, HFCUSB_SCTRL
, 0x40);
1532 write_reg(hw
, HFCUSB_SCTRL_E
, 0x00);
1533 write_reg(hw
, HFCUSB_CLKDEL
, CLKDEL_TE
);
1534 write_reg(hw
, HFCUSB_STATES
, 3 | 0x10);
1535 write_reg(hw
, HFCUSB_STATES
, 3);
1537 write_reg(hw
, HFCUSB_SCTRL
, 0x44);
1538 write_reg(hw
, HFCUSB_SCTRL_E
, 0x09);
1539 write_reg(hw
, HFCUSB_CLKDEL
, CLKDEL_NT
);
1540 write_reg(hw
, HFCUSB_STATES
, 1 | 0x10);
1541 write_reg(hw
, HFCUSB_STATES
, 1);
1546 reset_hfcsusb(struct hfcsusb
*hw
)
1548 struct usb_fifo
*fifo
;
1551 if (debug
& DEBUG_HW
)
1552 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
1555 write_reg(hw
, HFCUSB_CIRM
, 8);
1557 /* aux = output, reset off */
1558 write_reg(hw
, HFCUSB_CIRM
, 0x10);
1560 /* set USB_SIZE to match the wMaxPacketSize for INT or BULK transfers */
1561 write_reg(hw
, HFCUSB_USB_SIZE
, (hw
->packet_size
/ 8) |
1562 ((hw
->packet_size
/ 8) << 4));
1564 /* set USB_SIZE_I to match the wMaxPacketSize for ISO transfers */
1565 write_reg(hw
, HFCUSB_USB_SIZE_I
, hw
->iso_packet_size
);
1567 /* enable PCM/GCI master mode */
1568 write_reg(hw
, HFCUSB_MST_MODE1
, 0); /* set default values */
1569 write_reg(hw
, HFCUSB_MST_MODE0
, 1); /* enable master mode */
1571 /* init the fifos */
1572 write_reg(hw
, HFCUSB_F_THRES
,
1573 (HFCUSB_TX_THRESHOLD
/ 8) | ((HFCUSB_RX_THRESHOLD
/ 8) << 4));
1576 for (i
= 0; i
< HFCUSB_NUM_FIFOS
; i
++) {
1577 write_reg(hw
, HFCUSB_FIFO
, i
); /* select the desired fifo */
1579 (i
<= HFCUSB_B2_RX
) ? MAX_BCH_SIZE
: MAX_DFRAME_LEN
;
1580 fifo
[i
].last_urblen
= 0;
1582 /* set 2 bit for D- & E-channel */
1583 write_reg(hw
, HFCUSB_HDLC_PAR
, ((i
<= HFCUSB_B2_RX
) ? 0 : 2));
1585 /* enable all fifos */
1586 if (i
== HFCUSB_D_TX
)
1587 write_reg(hw
, HFCUSB_CON_HDLC
,
1588 (hw
->protocol
== ISDN_P_NT_S0
) ? 0x08 : 0x09);
1590 write_reg(hw
, HFCUSB_CON_HDLC
, 0x08);
1591 write_reg(hw
, HFCUSB_INC_RES_F
, 2); /* reset the fifo */
1594 write_reg(hw
, HFCUSB_SCTRL_R
, 0); /* disable both B receivers */
1595 handle_led(hw
, LED_POWER_ON
);
1598 /* start USB data pipes dependand on device's endpoint configuration */
1600 hfcsusb_start_endpoint(struct hfcsusb
*hw
, int channel
)
1602 /* quick check if endpoint already running */
1603 if ((channel
== HFC_CHAN_D
) && (hw
->fifos
[HFCUSB_D_RX
].active
))
1605 if ((channel
== HFC_CHAN_B1
) && (hw
->fifos
[HFCUSB_B1_RX
].active
))
1607 if ((channel
== HFC_CHAN_B2
) && (hw
->fifos
[HFCUSB_B2_RX
].active
))
1609 if ((channel
== HFC_CHAN_E
) && (hw
->fifos
[HFCUSB_PCM_RX
].active
))
1612 /* start rx endpoints using USB INT IN method */
1613 if (hw
->cfg_used
== CNF_3INT3ISO
|| hw
->cfg_used
== CNF_4INT3ISO
)
1614 start_int_fifo(hw
->fifos
+ channel
* 2 + 1);
1616 /* start rx endpoints using USB ISO IN method */
1617 if (hw
->cfg_used
== CNF_3ISO3ISO
|| hw
->cfg_used
== CNF_4ISO3ISO
) {
1620 start_isoc_chain(hw
->fifos
+ HFCUSB_D_RX
,
1622 (usb_complete_t
)rx_iso_complete
,
1626 start_isoc_chain(hw
->fifos
+ HFCUSB_PCM_RX
,
1628 (usb_complete_t
)rx_iso_complete
,
1632 start_isoc_chain(hw
->fifos
+ HFCUSB_B1_RX
,
1634 (usb_complete_t
)rx_iso_complete
,
1638 start_isoc_chain(hw
->fifos
+ HFCUSB_B2_RX
,
1640 (usb_complete_t
)rx_iso_complete
,
1646 /* start tx endpoints using USB ISO OUT method */
1649 start_isoc_chain(hw
->fifos
+ HFCUSB_D_TX
,
1651 (usb_complete_t
)tx_iso_complete
, 1);
1654 start_isoc_chain(hw
->fifos
+ HFCUSB_B1_TX
,
1656 (usb_complete_t
)tx_iso_complete
, 1);
1659 start_isoc_chain(hw
->fifos
+ HFCUSB_B2_TX
,
1661 (usb_complete_t
)tx_iso_complete
, 1);
1666 /* stop USB data pipes dependand on device's endpoint configuration */
1668 hfcsusb_stop_endpoint(struct hfcsusb
*hw
, int channel
)
1670 /* quick check if endpoint currently running */
1671 if ((channel
== HFC_CHAN_D
) && (!hw
->fifos
[HFCUSB_D_RX
].active
))
1673 if ((channel
== HFC_CHAN_B1
) && (!hw
->fifos
[HFCUSB_B1_RX
].active
))
1675 if ((channel
== HFC_CHAN_B2
) && (!hw
->fifos
[HFCUSB_B2_RX
].active
))
1677 if ((channel
== HFC_CHAN_E
) && (!hw
->fifos
[HFCUSB_PCM_RX
].active
))
1680 /* rx endpoints using USB INT IN method */
1681 if (hw
->cfg_used
== CNF_3INT3ISO
|| hw
->cfg_used
== CNF_4INT3ISO
)
1682 stop_int_gracefull(hw
->fifos
+ channel
* 2 + 1);
1684 /* rx endpoints using USB ISO IN method */
1685 if (hw
->cfg_used
== CNF_3ISO3ISO
|| hw
->cfg_used
== CNF_4ISO3ISO
)
1686 stop_iso_gracefull(hw
->fifos
+ channel
* 2 + 1);
1688 /* tx endpoints using USB ISO OUT method */
1689 if (channel
!= HFC_CHAN_E
)
1690 stop_iso_gracefull(hw
->fifos
+ channel
* 2);
1694 /* Hardware Initialization */
1696 setup_hfcsusb(struct hfcsusb
*hw
)
1698 void *dmabuf
= kmalloc(sizeof(u_char
), GFP_KERNEL
);
1702 if (debug
& DBG_HFC_CALL_TRACE
)
1703 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
1708 ret
= read_reg_atomic(hw
, HFCUSB_CHIP_ID
, dmabuf
);
1710 memcpy(&b
, dmabuf
, sizeof(u_char
));
1713 /* check the chip id */
1715 printk(KERN_DEBUG
"%s: %s: cannot read chip id\n",
1716 hw
->name
, __func__
);
1719 if (b
!= HFCUSB_CHIPID
) {
1720 printk(KERN_DEBUG
"%s: %s: Invalid chip id 0x%02x\n",
1721 hw
->name
, __func__
, b
);
1725 /* first set the needed config, interface and alternate */
1726 (void) usb_set_interface(hw
->dev
, hw
->if_used
, hw
->alt_used
);
1730 /* init the background machinery for control requests */
1731 hw
->ctrl_read
.bRequestType
= 0xc0;
1732 hw
->ctrl_read
.bRequest
= 1;
1733 hw
->ctrl_read
.wLength
= cpu_to_le16(1);
1734 hw
->ctrl_write
.bRequestType
= 0x40;
1735 hw
->ctrl_write
.bRequest
= 0;
1736 hw
->ctrl_write
.wLength
= 0;
1737 usb_fill_control_urb(hw
->ctrl_urb
, hw
->dev
, hw
->ctrl_out_pipe
,
1738 (u_char
*)&hw
->ctrl_write
, NULL
, 0,
1739 (usb_complete_t
)ctrl_complete
, hw
);
1746 release_hw(struct hfcsusb
*hw
)
1748 if (debug
& DBG_HFC_CALL_TRACE
)
1749 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
1752 * stop all endpoints gracefully
1753 * TODO: mISDN_core should generate CLOSE_CHANNEL
1754 * signals after calling mISDN_unregister_device()
1756 hfcsusb_stop_endpoint(hw
, HFC_CHAN_D
);
1757 hfcsusb_stop_endpoint(hw
, HFC_CHAN_B1
);
1758 hfcsusb_stop_endpoint(hw
, HFC_CHAN_B2
);
1759 if (hw
->fifos
[HFCUSB_PCM_RX
].pipe
)
1760 hfcsusb_stop_endpoint(hw
, HFC_CHAN_E
);
1761 if (hw
->protocol
== ISDN_P_TE_S0
)
1762 l1_event(hw
->dch
.l1
, CLOSE_CHANNEL
);
1764 mISDN_unregister_device(&hw
->dch
.dev
);
1765 mISDN_freebchannel(&hw
->bch
[1]);
1766 mISDN_freebchannel(&hw
->bch
[0]);
1767 mISDN_freedchannel(&hw
->dch
);
1770 usb_kill_urb(hw
->ctrl_urb
);
1771 usb_free_urb(hw
->ctrl_urb
);
1772 hw
->ctrl_urb
= NULL
;
1776 usb_set_intfdata(hw
->intf
, NULL
);
1777 list_del(&hw
->list
);
1783 deactivate_bchannel(struct bchannel
*bch
)
1785 struct hfcsusb
*hw
= bch
->hw
;
1788 if (bch
->debug
& DEBUG_HW
)
1789 printk(KERN_DEBUG
"%s: %s: bch->nr(%i)\n",
1790 hw
->name
, __func__
, bch
->nr
);
1792 spin_lock_irqsave(&hw
->lock
, flags
);
1793 mISDN_clear_bchannel(bch
);
1794 spin_unlock_irqrestore(&hw
->lock
, flags
);
1795 hfcsusb_setup_bch(bch
, ISDN_P_NONE
);
1796 hfcsusb_stop_endpoint(hw
, bch
->nr
- 1);
1800 * Layer 1 B-channel hardware access
1803 hfc_bctrl(struct mISDNchannel
*ch
, u_int cmd
, void *arg
)
1805 struct bchannel
*bch
= container_of(ch
, struct bchannel
, ch
);
1808 if (bch
->debug
& DEBUG_HW
)
1809 printk(KERN_DEBUG
"%s: cmd:%x %p\n", __func__
, cmd
, arg
);
1813 case HW_TESTRX_HDLC
:
1819 test_and_clear_bit(FLG_OPEN
, &bch
->Flags
);
1820 deactivate_bchannel(bch
);
1821 ch
->protocol
= ISDN_P_NONE
;
1823 module_put(THIS_MODULE
);
1826 case CONTROL_CHANNEL
:
1827 ret
= channel_bctrl(bch
, arg
);
1830 printk(KERN_WARNING
"%s: unknown prim(%x)\n",
1837 setup_instance(struct hfcsusb
*hw
, struct device
*parent
)
1842 if (debug
& DBG_HFC_CALL_TRACE
)
1843 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
1845 spin_lock_init(&hw
->ctrl_lock
);
1846 spin_lock_init(&hw
->lock
);
1848 mISDN_initdchannel(&hw
->dch
, MAX_DFRAME_LEN_L1
, ph_state
);
1849 hw
->dch
.debug
= debug
& 0xFFFF;
1851 hw
->dch
.dev
.Dprotocols
= (1 << ISDN_P_TE_S0
) | (1 << ISDN_P_NT_S0
);
1852 hw
->dch
.dev
.D
.send
= hfcusb_l2l1D
;
1853 hw
->dch
.dev
.D
.ctrl
= hfc_dctrl
;
1855 /* enable E-Channel logging */
1856 if (hw
->fifos
[HFCUSB_PCM_RX
].pipe
)
1857 mISDN_initdchannel(&hw
->ech
, MAX_DFRAME_LEN_L1
, NULL
);
1859 hw
->dch
.dev
.Bprotocols
= (1 << (ISDN_P_B_RAW
& ISDN_P_B_MASK
)) |
1860 (1 << (ISDN_P_B_HDLC
& ISDN_P_B_MASK
));
1861 hw
->dch
.dev
.nrbchan
= 2;
1862 for (i
= 0; i
< 2; i
++) {
1863 hw
->bch
[i
].nr
= i
+ 1;
1864 set_channelmap(i
+ 1, hw
->dch
.dev
.channelmap
);
1865 hw
->bch
[i
].debug
= debug
;
1866 mISDN_initbchannel(&hw
->bch
[i
], MAX_DATA_MEM
, poll
>> 1);
1868 hw
->bch
[i
].ch
.send
= hfcusb_l2l1B
;
1869 hw
->bch
[i
].ch
.ctrl
= hfc_bctrl
;
1870 hw
->bch
[i
].ch
.nr
= i
+ 1;
1871 list_add(&hw
->bch
[i
].ch
.list
, &hw
->dch
.dev
.bchannels
);
1874 hw
->fifos
[HFCUSB_B1_TX
].bch
= &hw
->bch
[0];
1875 hw
->fifos
[HFCUSB_B1_RX
].bch
= &hw
->bch
[0];
1876 hw
->fifos
[HFCUSB_B2_TX
].bch
= &hw
->bch
[1];
1877 hw
->fifos
[HFCUSB_B2_RX
].bch
= &hw
->bch
[1];
1878 hw
->fifos
[HFCUSB_D_TX
].dch
= &hw
->dch
;
1879 hw
->fifos
[HFCUSB_D_RX
].dch
= &hw
->dch
;
1880 hw
->fifos
[HFCUSB_PCM_RX
].ech
= &hw
->ech
;
1881 hw
->fifos
[HFCUSB_PCM_TX
].ech
= &hw
->ech
;
1883 err
= setup_hfcsusb(hw
);
1887 snprintf(hw
->name
, MISDN_MAX_IDLEN
- 1, "%s.%d", DRIVER_NAME
,
1889 printk(KERN_INFO
"%s: registered as '%s'\n",
1890 DRIVER_NAME
, hw
->name
);
1892 err
= mISDN_register_device(&hw
->dch
.dev
, parent
, hw
->name
);
1897 write_lock_irqsave(&HFClock
, flags
);
1898 list_add_tail(&hw
->list
, &HFClist
);
1899 write_unlock_irqrestore(&HFClock
, flags
);
1903 mISDN_freebchannel(&hw
->bch
[1]);
1904 mISDN_freebchannel(&hw
->bch
[0]);
1905 mISDN_freedchannel(&hw
->dch
);
1911 hfcsusb_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
1914 struct usb_device
*dev
= interface_to_usbdev(intf
);
1915 struct usb_host_interface
*iface
= intf
->cur_altsetting
;
1916 struct usb_host_interface
*iface_used
= NULL
;
1917 struct usb_host_endpoint
*ep
;
1918 struct hfcsusb_vdata
*driver_info
;
1919 int ifnum
= iface
->desc
.bInterfaceNumber
, i
, idx
, alt_idx
,
1920 probe_alt_setting
, vend_idx
, cfg_used
, *vcf
, attr
, cfg_found
,
1921 ep_addr
, cmptbl
[16], small_match
, iso_packet_size
, packet_size
,
1925 for (i
= 0; hfcsusb_idtab
[i
].idVendor
; i
++) {
1926 if ((le16_to_cpu(dev
->descriptor
.idVendor
)
1927 == hfcsusb_idtab
[i
].idVendor
) &&
1928 (le16_to_cpu(dev
->descriptor
.idProduct
)
1929 == hfcsusb_idtab
[i
].idProduct
)) {
1936 "%s: interface(%d) actalt(%d) minor(%d) vend_idx(%d)\n",
1937 __func__
, ifnum
, iface
->desc
.bAlternateSetting
,
1938 intf
->minor
, vend_idx
);
1940 if (vend_idx
== 0xffff) {
1942 "%s: no valid vendor found in USB descriptor\n",
1946 /* if vendor and product ID is OK, start probing alternate settings */
1950 /* default settings */
1951 iso_packet_size
= 16;
1954 while (alt_idx
< intf
->num_altsetting
) {
1955 iface
= intf
->altsetting
+ alt_idx
;
1956 probe_alt_setting
= iface
->desc
.bAlternateSetting
;
1959 while (validconf
[cfg_used
][0]) {
1961 vcf
= validconf
[cfg_used
];
1962 ep
= iface
->endpoint
;
1963 memcpy(cmptbl
, vcf
, 16 * sizeof(int));
1965 /* check for all endpoints in this alternate setting */
1966 for (i
= 0; i
< iface
->desc
.bNumEndpoints
; i
++) {
1967 ep_addr
= ep
->desc
.bEndpointAddress
;
1969 /* get endpoint base */
1970 idx
= ((ep_addr
& 0x7f) - 1) * 2;
1976 attr
= ep
->desc
.bmAttributes
;
1978 if (cmptbl
[idx
] != EP_NOP
) {
1979 if (cmptbl
[idx
] == EP_NUL
)
1981 if (attr
== USB_ENDPOINT_XFER_INT
1982 && cmptbl
[idx
] == EP_INT
)
1983 cmptbl
[idx
] = EP_NUL
;
1984 if (attr
== USB_ENDPOINT_XFER_BULK
1985 && cmptbl
[idx
] == EP_BLK
)
1986 cmptbl
[idx
] = EP_NUL
;
1987 if (attr
== USB_ENDPOINT_XFER_ISOC
1988 && cmptbl
[idx
] == EP_ISO
)
1989 cmptbl
[idx
] = EP_NUL
;
1991 if (attr
== USB_ENDPOINT_XFER_INT
&&
1992 ep
->desc
.bInterval
< vcf
[17]) {
1999 for (i
= 0; i
< 16; i
++)
2000 if (cmptbl
[i
] != EP_NOP
&& cmptbl
[i
] != EP_NUL
)
2004 if (small_match
< cfg_used
) {
2005 small_match
= cfg_used
;
2006 alt_used
= probe_alt_setting
;
2013 } /* (alt_idx < intf->num_altsetting) */
2015 /* not found a valid USB Ta Endpoint config */
2016 if (small_match
== -1)
2020 hw
= kzalloc(sizeof(struct hfcsusb
), GFP_KERNEL
);
2022 return -ENOMEM
; /* got no mem */
2023 snprintf(hw
->name
, MISDN_MAX_IDLEN
- 1, "%s", DRIVER_NAME
);
2025 ep
= iface
->endpoint
;
2026 vcf
= validconf
[small_match
];
2028 for (i
= 0; i
< iface
->desc
.bNumEndpoints
; i
++) {
2031 ep_addr
= ep
->desc
.bEndpointAddress
;
2032 /* get endpoint base */
2033 idx
= ((ep_addr
& 0x7f) - 1) * 2;
2036 f
= &hw
->fifos
[idx
& 7];
2038 /* init Endpoints */
2039 if (vcf
[idx
] == EP_NOP
|| vcf
[idx
] == EP_NUL
) {
2043 switch (ep
->desc
.bmAttributes
) {
2044 case USB_ENDPOINT_XFER_INT
:
2045 f
->pipe
= usb_rcvintpipe(dev
,
2046 ep
->desc
.bEndpointAddress
);
2047 f
->usb_transfer_mode
= USB_INT
;
2048 packet_size
= le16_to_cpu(ep
->desc
.wMaxPacketSize
);
2050 case USB_ENDPOINT_XFER_BULK
:
2052 f
->pipe
= usb_rcvbulkpipe(dev
,
2053 ep
->desc
.bEndpointAddress
);
2055 f
->pipe
= usb_sndbulkpipe(dev
,
2056 ep
->desc
.bEndpointAddress
);
2057 f
->usb_transfer_mode
= USB_BULK
;
2058 packet_size
= le16_to_cpu(ep
->desc
.wMaxPacketSize
);
2060 case USB_ENDPOINT_XFER_ISOC
:
2062 f
->pipe
= usb_rcvisocpipe(dev
,
2063 ep
->desc
.bEndpointAddress
);
2065 f
->pipe
= usb_sndisocpipe(dev
,
2066 ep
->desc
.bEndpointAddress
);
2067 f
->usb_transfer_mode
= USB_ISOC
;
2068 iso_packet_size
= le16_to_cpu(ep
->desc
.wMaxPacketSize
);
2075 f
->fifonum
= idx
& 7;
2077 f
->usb_packet_maxlen
=
2078 le16_to_cpu(ep
->desc
.wMaxPacketSize
);
2079 f
->intervall
= ep
->desc
.bInterval
;
2083 hw
->dev
= dev
; /* save device */
2084 hw
->if_used
= ifnum
; /* save used interface */
2085 hw
->alt_used
= alt_used
; /* and alternate config */
2086 hw
->ctrl_paksize
= dev
->descriptor
.bMaxPacketSize0
; /* control size */
2087 hw
->cfg_used
= vcf
[16]; /* store used config */
2088 hw
->vend_idx
= vend_idx
; /* store found vendor */
2089 hw
->packet_size
= packet_size
;
2090 hw
->iso_packet_size
= iso_packet_size
;
2092 /* create the control pipes needed for register access */
2093 hw
->ctrl_in_pipe
= usb_rcvctrlpipe(hw
->dev
, 0);
2094 hw
->ctrl_out_pipe
= usb_sndctrlpipe(hw
->dev
, 0);
2096 driver_info
= (struct hfcsusb_vdata
*)
2097 hfcsusb_idtab
[vend_idx
].driver_info
;
2099 hw
->ctrl_urb
= usb_alloc_urb(0, GFP_KERNEL
);
2100 if (!hw
->ctrl_urb
) {
2101 pr_warn("%s: No memory for control urb\n",
2102 driver_info
->vend_name
);
2107 pr_info("%s: %s: detected \"%s\" (%s, if=%d alt=%d)\n",
2108 hw
->name
, __func__
, driver_info
->vend_name
,
2109 conf_str
[small_match
], ifnum
, alt_used
);
2111 if (setup_instance(hw
, dev
->dev
.parent
))
2115 usb_set_intfdata(hw
->intf
, hw
);
2119 /* function called when an active device is removed */
2121 hfcsusb_disconnect(struct usb_interface
*intf
)
2123 struct hfcsusb
*hw
= usb_get_intfdata(intf
);
2124 struct hfcsusb
*next
;
2127 printk(KERN_INFO
"%s: device disconnected\n", hw
->name
);
2129 handle_led(hw
, LED_POWER_OFF
);
2132 list_for_each_entry_safe(hw
, next
, &HFClist
, list
)
2137 usb_set_intfdata(intf
, NULL
);
2140 static struct usb_driver hfcsusb_drv
= {
2141 .name
= DRIVER_NAME
,
2142 .id_table
= hfcsusb_idtab
,
2143 .probe
= hfcsusb_probe
,
2144 .disconnect
= hfcsusb_disconnect
,
2145 .disable_hub_initiated_lpm
= 1,
2148 module_usb_driver(hfcsusb_drv
);