2 * mISDN driver for Colognechip HFC-S USB chip
4 * Copyright 2001 by Peter Sprenger (sprenger@moving-bytes.de)
5 * Copyright 2008 by Martin Bachem (info@bachem-it.com)
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2, or (at your option)
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 * debug=<n>, default=0, with n=0xHHHHGGGG
24 * H - l1 driver flags described in hfcsusb.h
25 * G - common mISDN debug flags described at mISDNhw.h
27 * poll=<n>, default 128
28 * n : burst size of PH_DATA_IND at transparent rx data
32 #include <linux/module.h>
33 #include <linux/delay.h>
34 #include <linux/usb.h>
35 #include <linux/mISDNhw.h>
36 #include <linux/slab.h>
39 static const char *hfcsusb_rev
= "Revision: 0.3.3 (socket), 2008-11-05";
41 static unsigned int debug
;
42 static int poll
= DEFAULT_TRANSP_BURST_SZ
;
44 static LIST_HEAD(HFClist
);
45 static DEFINE_RWLOCK(HFClock
);
48 MODULE_AUTHOR("Martin Bachem");
49 MODULE_LICENSE("GPL");
50 module_param(debug
, uint
, S_IRUGO
| S_IWUSR
);
51 module_param(poll
, int, 0);
53 static int hfcsusb_cnt
;
55 /* some function prototypes */
56 static void hfcsusb_ph_command(struct hfcsusb
*hw
, u_char command
);
57 static void release_hw(struct hfcsusb
*hw
);
58 static void reset_hfcsusb(struct hfcsusb
*hw
);
59 static void setPortMode(struct hfcsusb
*hw
);
60 static void hfcsusb_start_endpoint(struct hfcsusb
*hw
, int channel
);
61 static void hfcsusb_stop_endpoint(struct hfcsusb
*hw
, int channel
);
62 static int hfcsusb_setup_bch(struct bchannel
*bch
, int protocol
);
63 static void deactivate_bchannel(struct bchannel
*bch
);
64 static void hfcsusb_ph_info(struct hfcsusb
*hw
);
66 /* start next background transfer for control channel */
68 ctrl_start_transfer(struct hfcsusb
*hw
)
70 if (debug
& DBG_HFC_CALL_TRACE
)
71 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
74 hw
->ctrl_urb
->pipe
= hw
->ctrl_out_pipe
;
75 hw
->ctrl_urb
->setup_packet
= (u_char
*)&hw
->ctrl_write
;
76 hw
->ctrl_urb
->transfer_buffer
= NULL
;
77 hw
->ctrl_urb
->transfer_buffer_length
= 0;
78 hw
->ctrl_write
.wIndex
=
79 cpu_to_le16(hw
->ctrl_buff
[hw
->ctrl_out_idx
].hfcs_reg
);
80 hw
->ctrl_write
.wValue
=
81 cpu_to_le16(hw
->ctrl_buff
[hw
->ctrl_out_idx
].reg_val
);
83 usb_submit_urb(hw
->ctrl_urb
, GFP_ATOMIC
);
88 * queue a control transfer request to write HFC-S USB
89 * chip register using CTRL resuest queue
91 static int write_reg(struct hfcsusb
*hw
, __u8 reg
, __u8 val
)
95 if (debug
& DBG_HFC_CALL_TRACE
)
96 printk(KERN_DEBUG
"%s: %s reg(0x%02x) val(0x%02x)\n",
97 hw
->name
, __func__
, reg
, val
);
99 spin_lock(&hw
->ctrl_lock
);
100 if (hw
->ctrl_cnt
>= HFC_CTRL_BUFSIZE
) {
101 spin_unlock(&hw
->ctrl_lock
);
104 buf
= &hw
->ctrl_buff
[hw
->ctrl_in_idx
];
107 if (++hw
->ctrl_in_idx
>= HFC_CTRL_BUFSIZE
)
109 if (++hw
->ctrl_cnt
== 1)
110 ctrl_start_transfer(hw
);
111 spin_unlock(&hw
->ctrl_lock
);
116 /* control completion routine handling background control cmds */
118 ctrl_complete(struct urb
*urb
)
120 struct hfcsusb
*hw
= (struct hfcsusb
*) urb
->context
;
122 if (debug
& DBG_HFC_CALL_TRACE
)
123 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
127 hw
->ctrl_cnt
--; /* decrement actual count */
128 if (++hw
->ctrl_out_idx
>= HFC_CTRL_BUFSIZE
)
129 hw
->ctrl_out_idx
= 0; /* pointer wrap */
131 ctrl_start_transfer(hw
); /* start next transfer */
135 /* handle LED bits */
137 set_led_bit(struct hfcsusb
*hw
, signed short led_bits
, int set_on
)
141 hw
->led_state
&= ~abs(led_bits
);
143 hw
->led_state
|= led_bits
;
146 hw
->led_state
|= abs(led_bits
);
148 hw
->led_state
&= ~led_bits
;
152 /* handle LED requests */
154 handle_led(struct hfcsusb
*hw
, int event
)
156 struct hfcsusb_vdata
*driver_info
= (struct hfcsusb_vdata
*)
157 hfcsusb_idtab
[hw
->vend_idx
].driver_info
;
160 if (driver_info
->led_scheme
== LED_OFF
)
162 tmpled
= hw
->led_state
;
166 set_led_bit(hw
, driver_info
->led_bits
[0], 1);
167 set_led_bit(hw
, driver_info
->led_bits
[1], 0);
168 set_led_bit(hw
, driver_info
->led_bits
[2], 0);
169 set_led_bit(hw
, driver_info
->led_bits
[3], 0);
172 set_led_bit(hw
, driver_info
->led_bits
[0], 0);
173 set_led_bit(hw
, driver_info
->led_bits
[1], 0);
174 set_led_bit(hw
, driver_info
->led_bits
[2], 0);
175 set_led_bit(hw
, driver_info
->led_bits
[3], 0);
178 set_led_bit(hw
, driver_info
->led_bits
[1], 1);
181 set_led_bit(hw
, driver_info
->led_bits
[1], 0);
184 set_led_bit(hw
, driver_info
->led_bits
[2], 1);
187 set_led_bit(hw
, driver_info
->led_bits
[2], 0);
190 set_led_bit(hw
, driver_info
->led_bits
[3], 1);
193 set_led_bit(hw
, driver_info
->led_bits
[3], 0);
197 if (hw
->led_state
!= tmpled
) {
198 if (debug
& DBG_HFC_CALL_TRACE
)
199 printk(KERN_DEBUG
"%s: %s reg(0x%02x) val(x%02x)\n",
201 HFCUSB_P_DATA
, hw
->led_state
);
203 write_reg(hw
, HFCUSB_P_DATA
, hw
->led_state
);
208 * Layer2 -> Layer 1 Bchannel data
211 hfcusb_l2l1B(struct mISDNchannel
*ch
, struct sk_buff
*skb
)
213 struct bchannel
*bch
= container_of(ch
, struct bchannel
, ch
);
214 struct hfcsusb
*hw
= bch
->hw
;
216 struct mISDNhead
*hh
= mISDN_HEAD_P(skb
);
219 if (debug
& DBG_HFC_CALL_TRACE
)
220 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
224 spin_lock_irqsave(&hw
->lock
, flags
);
225 ret
= bchannel_senddata(bch
, skb
);
226 spin_unlock_irqrestore(&hw
->lock
, flags
);
227 if (debug
& DBG_HFC_CALL_TRACE
)
228 printk(KERN_DEBUG
"%s: %s PH_DATA_REQ ret(%i)\n",
229 hw
->name
, __func__
, ret
);
232 * other l1 drivers don't send early confirms on
233 * transp data, but hfcsusb does because tx_next
234 * skb is needed in tx_iso_complete()
236 queue_ch_frame(ch
, PH_DATA_CNF
, hh
->id
, NULL
);
240 case PH_ACTIVATE_REQ
:
241 if (!test_and_set_bit(FLG_ACTIVE
, &bch
->Flags
)) {
242 hfcsusb_start_endpoint(hw
, bch
->nr
);
243 ret
= hfcsusb_setup_bch(bch
, ch
->protocol
);
247 _queue_data(ch
, PH_ACTIVATE_IND
, MISDN_ID_ANY
,
248 0, NULL
, GFP_KERNEL
);
250 case PH_DEACTIVATE_REQ
:
251 deactivate_bchannel(bch
);
252 _queue_data(ch
, PH_DEACTIVATE_IND
, MISDN_ID_ANY
,
253 0, NULL
, GFP_KERNEL
);
263 * send full D/B channel status information
264 * as MPH_INFORMATION_IND
267 hfcsusb_ph_info(struct hfcsusb
*hw
)
270 struct dchannel
*dch
= &hw
->dch
;
273 phi
= kzalloc(sizeof(struct ph_info
) +
274 dch
->dev
.nrbchan
* sizeof(struct ph_info_ch
), GFP_ATOMIC
);
275 phi
->dch
.ch
.protocol
= hw
->protocol
;
276 phi
->dch
.ch
.Flags
= dch
->Flags
;
277 phi
->dch
.state
= dch
->state
;
278 phi
->dch
.num_bch
= dch
->dev
.nrbchan
;
279 for (i
= 0; i
< dch
->dev
.nrbchan
; i
++) {
280 phi
->bch
[i
].protocol
= hw
->bch
[i
].ch
.protocol
;
281 phi
->bch
[i
].Flags
= hw
->bch
[i
].Flags
;
283 _queue_data(&dch
->dev
.D
, MPH_INFORMATION_IND
, MISDN_ID_ANY
,
284 sizeof(struct ph_info_dch
) + dch
->dev
.nrbchan
*
285 sizeof(struct ph_info_ch
), phi
, GFP_ATOMIC
);
289 * Layer2 -> Layer 1 Dchannel data
292 hfcusb_l2l1D(struct mISDNchannel
*ch
, struct sk_buff
*skb
)
294 struct mISDNdevice
*dev
= container_of(ch
, struct mISDNdevice
, D
);
295 struct dchannel
*dch
= container_of(dev
, struct dchannel
, dev
);
296 struct mISDNhead
*hh
= mISDN_HEAD_P(skb
);
297 struct hfcsusb
*hw
= dch
->hw
;
303 if (debug
& DBG_HFC_CALL_TRACE
)
304 printk(KERN_DEBUG
"%s: %s: PH_DATA_REQ\n",
307 spin_lock_irqsave(&hw
->lock
, flags
);
308 ret
= dchannel_senddata(dch
, skb
);
309 spin_unlock_irqrestore(&hw
->lock
, flags
);
312 queue_ch_frame(ch
, PH_DATA_CNF
, hh
->id
, NULL
);
316 case PH_ACTIVATE_REQ
:
317 if (debug
& DBG_HFC_CALL_TRACE
)
318 printk(KERN_DEBUG
"%s: %s: PH_ACTIVATE_REQ %s\n",
320 (hw
->protocol
== ISDN_P_NT_S0
) ? "NT" : "TE");
322 if (hw
->protocol
== ISDN_P_NT_S0
) {
324 if (test_bit(FLG_ACTIVE
, &dch
->Flags
)) {
325 _queue_data(&dch
->dev
.D
,
326 PH_ACTIVATE_IND
, MISDN_ID_ANY
, 0,
329 hfcsusb_ph_command(hw
,
331 test_and_set_bit(FLG_L2_ACTIVATED
,
335 hfcsusb_ph_command(hw
, HFC_L1_ACTIVATE_TE
);
336 ret
= l1_event(dch
->l1
, hh
->prim
);
340 case PH_DEACTIVATE_REQ
:
341 if (debug
& DBG_HFC_CALL_TRACE
)
342 printk(KERN_DEBUG
"%s: %s: PH_DEACTIVATE_REQ\n",
344 test_and_clear_bit(FLG_L2_ACTIVATED
, &dch
->Flags
);
346 if (hw
->protocol
== ISDN_P_NT_S0
) {
347 hfcsusb_ph_command(hw
, HFC_L1_DEACTIVATE_NT
);
348 spin_lock_irqsave(&hw
->lock
, flags
);
349 skb_queue_purge(&dch
->squeue
);
351 dev_kfree_skb(dch
->tx_skb
);
356 dev_kfree_skb(dch
->rx_skb
);
359 test_and_clear_bit(FLG_TX_BUSY
, &dch
->Flags
);
360 spin_unlock_irqrestore(&hw
->lock
, flags
);
362 if (test_and_clear_bit(FLG_L1_BUSY
, &dch
->Flags
))
363 dchannel_sched_event(&hc
->dch
, D_CLEARBUSY
);
367 ret
= l1_event(dch
->l1
, hh
->prim
);
369 case MPH_INFORMATION_REQ
:
379 * Layer 1 callback function
382 hfc_l1callback(struct dchannel
*dch
, u_int cmd
)
384 struct hfcsusb
*hw
= dch
->hw
;
386 if (debug
& DBG_HFC_CALL_TRACE
)
387 printk(KERN_DEBUG
"%s: %s cmd 0x%x\n",
388 hw
->name
, __func__
, cmd
);
398 skb_queue_purge(&dch
->squeue
);
400 dev_kfree_skb(dch
->tx_skb
);
405 dev_kfree_skb(dch
->rx_skb
);
408 test_and_clear_bit(FLG_TX_BUSY
, &dch
->Flags
);
410 case PH_ACTIVATE_IND
:
411 test_and_set_bit(FLG_ACTIVE
, &dch
->Flags
);
412 _queue_data(&dch
->dev
.D
, cmd
, MISDN_ID_ANY
, 0, NULL
,
415 case PH_DEACTIVATE_IND
:
416 test_and_clear_bit(FLG_ACTIVE
, &dch
->Flags
);
417 _queue_data(&dch
->dev
.D
, cmd
, MISDN_ID_ANY
, 0, NULL
,
421 if (dch
->debug
& DEBUG_HW
)
422 printk(KERN_DEBUG
"%s: %s: unknown cmd %x\n",
423 hw
->name
, __func__
, cmd
);
431 open_dchannel(struct hfcsusb
*hw
, struct mISDNchannel
*ch
,
432 struct channel_req
*rq
)
436 if (debug
& DEBUG_HW_OPEN
)
437 printk(KERN_DEBUG
"%s: %s: dev(%d) open addr(%i) from %p\n",
438 hw
->name
, __func__
, hw
->dch
.dev
.id
, rq
->adr
.channel
,
439 __builtin_return_address(0));
440 if (rq
->protocol
== ISDN_P_NONE
)
443 test_and_clear_bit(FLG_ACTIVE
, &hw
->dch
.Flags
);
444 test_and_clear_bit(FLG_ACTIVE
, &hw
->ech
.Flags
);
445 hfcsusb_start_endpoint(hw
, HFC_CHAN_D
);
447 /* E-Channel logging */
448 if (rq
->adr
.channel
== 1) {
449 if (hw
->fifos
[HFCUSB_PCM_RX
].pipe
) {
450 hfcsusb_start_endpoint(hw
, HFC_CHAN_E
);
451 set_bit(FLG_ACTIVE
, &hw
->ech
.Flags
);
452 _queue_data(&hw
->ech
.dev
.D
, PH_ACTIVATE_IND
,
453 MISDN_ID_ANY
, 0, NULL
, GFP_ATOMIC
);
459 hw
->protocol
= rq
->protocol
;
460 if (rq
->protocol
== ISDN_P_TE_S0
) {
461 err
= create_l1(&hw
->dch
, hfc_l1callback
);
466 ch
->protocol
= rq
->protocol
;
469 if (rq
->protocol
!= ch
->protocol
)
470 return -EPROTONOSUPPORT
;
473 if (((ch
->protocol
== ISDN_P_NT_S0
) && (hw
->dch
.state
== 3)) ||
474 ((ch
->protocol
== ISDN_P_TE_S0
) && (hw
->dch
.state
== 7)))
475 _queue_data(ch
, PH_ACTIVATE_IND
, MISDN_ID_ANY
,
476 0, NULL
, GFP_KERNEL
);
478 if (!try_module_get(THIS_MODULE
))
479 printk(KERN_WARNING
"%s: %s: cannot get module\n",
485 open_bchannel(struct hfcsusb
*hw
, struct channel_req
*rq
)
487 struct bchannel
*bch
;
489 if (rq
->adr
.channel
> 2)
491 if (rq
->protocol
== ISDN_P_NONE
)
494 if (debug
& DBG_HFC_CALL_TRACE
)
495 printk(KERN_DEBUG
"%s: %s B%i\n",
496 hw
->name
, __func__
, rq
->adr
.channel
);
498 bch
= &hw
->bch
[rq
->adr
.channel
- 1];
499 if (test_and_set_bit(FLG_OPEN
, &bch
->Flags
))
500 return -EBUSY
; /* b-channel can be only open once */
501 test_and_clear_bit(FLG_FILLEMPTY
, &bch
->Flags
);
502 bch
->ch
.protocol
= rq
->protocol
;
505 /* start USB endpoint for bchannel */
506 if (rq
->adr
.channel
== 1)
507 hfcsusb_start_endpoint(hw
, HFC_CHAN_B1
);
509 hfcsusb_start_endpoint(hw
, HFC_CHAN_B2
);
511 if (!try_module_get(THIS_MODULE
))
512 printk(KERN_WARNING
"%s: %s:cannot get module\n",
518 channel_ctrl(struct hfcsusb
*hw
, struct mISDN_ctrl_req
*cq
)
522 if (debug
& DBG_HFC_CALL_TRACE
)
523 printk(KERN_DEBUG
"%s: %s op(0x%x) channel(0x%x)\n",
524 hw
->name
, __func__
, (cq
->op
), (cq
->channel
));
527 case MISDN_CTRL_GETOP
:
528 cq
->op
= MISDN_CTRL_LOOP
| MISDN_CTRL_CONNECT
|
529 MISDN_CTRL_DISCONNECT
;
532 printk(KERN_WARNING
"%s: %s: unknown Op %x\n",
533 hw
->name
, __func__
, cq
->op
);
541 * device control function
544 hfc_dctrl(struct mISDNchannel
*ch
, u_int cmd
, void *arg
)
546 struct mISDNdevice
*dev
= container_of(ch
, struct mISDNdevice
, D
);
547 struct dchannel
*dch
= container_of(dev
, struct dchannel
, dev
);
548 struct hfcsusb
*hw
= dch
->hw
;
549 struct channel_req
*rq
;
552 if (dch
->debug
& DEBUG_HW
)
553 printk(KERN_DEBUG
"%s: %s: cmd:%x %p\n",
554 hw
->name
, __func__
, cmd
, arg
);
558 if ((rq
->protocol
== ISDN_P_TE_S0
) ||
559 (rq
->protocol
== ISDN_P_NT_S0
))
560 err
= open_dchannel(hw
, ch
, rq
);
562 err
= open_bchannel(hw
, rq
);
568 if (debug
& DEBUG_HW_OPEN
)
570 "%s: %s: dev(%d) close from %p (open %d)\n",
571 hw
->name
, __func__
, hw
->dch
.dev
.id
,
572 __builtin_return_address(0), hw
->open
);
574 hfcsusb_stop_endpoint(hw
, HFC_CHAN_D
);
575 if (hw
->fifos
[HFCUSB_PCM_RX
].pipe
)
576 hfcsusb_stop_endpoint(hw
, HFC_CHAN_E
);
577 handle_led(hw
, LED_POWER_ON
);
579 module_put(THIS_MODULE
);
581 case CONTROL_CHANNEL
:
582 err
= channel_ctrl(hw
, arg
);
585 if (dch
->debug
& DEBUG_HW
)
586 printk(KERN_DEBUG
"%s: %s: unknown command %x\n",
587 hw
->name
, __func__
, cmd
);
594 * S0 TE state change event handler
597 ph_state_te(struct dchannel
*dch
)
599 struct hfcsusb
*hw
= dch
->hw
;
601 if (debug
& DEBUG_HW
) {
602 if (dch
->state
<= HFC_MAX_TE_LAYER1_STATE
)
603 printk(KERN_DEBUG
"%s: %s: %s\n", hw
->name
, __func__
,
604 HFC_TE_LAYER1_STATES
[dch
->state
]);
606 printk(KERN_DEBUG
"%s: %s: TE F%d\n",
607 hw
->name
, __func__
, dch
->state
);
610 switch (dch
->state
) {
612 l1_event(dch
->l1
, HW_RESET_IND
);
615 l1_event(dch
->l1
, HW_DEACT_IND
);
619 l1_event(dch
->l1
, ANYSIGNAL
);
622 l1_event(dch
->l1
, INFO2
);
625 l1_event(dch
->l1
, INFO4_P8
);
629 handle_led(hw
, LED_S0_ON
);
631 handle_led(hw
, LED_S0_OFF
);
635 * S0 NT state change event handler
638 ph_state_nt(struct dchannel
*dch
)
640 struct hfcsusb
*hw
= dch
->hw
;
642 if (debug
& DEBUG_HW
) {
643 if (dch
->state
<= HFC_MAX_NT_LAYER1_STATE
)
644 printk(KERN_DEBUG
"%s: %s: %s\n",
646 HFC_NT_LAYER1_STATES
[dch
->state
]);
649 printk(KERN_INFO DRIVER_NAME
"%s: %s: NT G%d\n",
650 hw
->name
, __func__
, dch
->state
);
653 switch (dch
->state
) {
655 test_and_clear_bit(FLG_ACTIVE
, &dch
->Flags
);
656 test_and_clear_bit(FLG_L2_ACTIVATED
, &dch
->Flags
);
658 hw
->timers
&= ~NT_ACTIVATION_TIMER
;
659 handle_led(hw
, LED_S0_OFF
);
663 if (hw
->nt_timer
< 0) {
665 hw
->timers
&= ~NT_ACTIVATION_TIMER
;
666 hfcsusb_ph_command(dch
->hw
, HFC_L1_DEACTIVATE_NT
);
668 hw
->timers
|= NT_ACTIVATION_TIMER
;
669 hw
->nt_timer
= NT_T1_COUNT
;
670 /* allow G2 -> G3 transition */
671 write_reg(hw
, HFCUSB_STATES
, 2 | HFCUSB_NT_G2_G3
);
676 hw
->timers
&= ~NT_ACTIVATION_TIMER
;
677 test_and_set_bit(FLG_ACTIVE
, &dch
->Flags
);
678 _queue_data(&dch
->dev
.D
, PH_ACTIVATE_IND
,
679 MISDN_ID_ANY
, 0, NULL
, GFP_ATOMIC
);
680 handle_led(hw
, LED_S0_ON
);
684 hw
->timers
&= ~NT_ACTIVATION_TIMER
;
693 ph_state(struct dchannel
*dch
)
695 struct hfcsusb
*hw
= dch
->hw
;
697 if (hw
->protocol
== ISDN_P_NT_S0
)
699 else if (hw
->protocol
== ISDN_P_TE_S0
)
704 * disable/enable BChannel for desired protocoll
707 hfcsusb_setup_bch(struct bchannel
*bch
, int protocol
)
709 struct hfcsusb
*hw
= bch
->hw
;
710 __u8 conhdlc
, sctrl
, sctrl_r
;
712 if (debug
& DEBUG_HW
)
713 printk(KERN_DEBUG
"%s: %s: protocol %x-->%x B%d\n",
714 hw
->name
, __func__
, bch
->state
, protocol
,
717 /* setup val for CON_HDLC */
719 if (protocol
> ISDN_P_NONE
)
720 conhdlc
= 8; /* enable FIFO */
723 case (-1): /* used for init */
727 if (bch
->state
== ISDN_P_NONE
)
728 return 0; /* already in idle state */
729 bch
->state
= ISDN_P_NONE
;
730 clear_bit(FLG_HDLC
, &bch
->Flags
);
731 clear_bit(FLG_TRANSPARENT
, &bch
->Flags
);
735 bch
->state
= protocol
;
736 set_bit(FLG_TRANSPARENT
, &bch
->Flags
);
738 case (ISDN_P_B_HDLC
):
739 bch
->state
= protocol
;
740 set_bit(FLG_HDLC
, &bch
->Flags
);
743 if (debug
& DEBUG_HW
)
744 printk(KERN_DEBUG
"%s: %s: prot not known %x\n",
745 hw
->name
, __func__
, protocol
);
749 if (protocol
>= ISDN_P_NONE
) {
750 write_reg(hw
, HFCUSB_FIFO
, (bch
->nr
== 1) ? 0 : 2);
751 write_reg(hw
, HFCUSB_CON_HDLC
, conhdlc
);
752 write_reg(hw
, HFCUSB_INC_RES_F
, 2);
753 write_reg(hw
, HFCUSB_FIFO
, (bch
->nr
== 1) ? 1 : 3);
754 write_reg(hw
, HFCUSB_CON_HDLC
, conhdlc
);
755 write_reg(hw
, HFCUSB_INC_RES_F
, 2);
757 sctrl
= 0x40 + ((hw
->protocol
== ISDN_P_TE_S0
) ? 0x00 : 0x04);
759 if (test_bit(FLG_ACTIVE
, &hw
->bch
[0].Flags
)) {
763 if (test_bit(FLG_ACTIVE
, &hw
->bch
[1].Flags
)) {
767 write_reg(hw
, HFCUSB_SCTRL
, sctrl
);
768 write_reg(hw
, HFCUSB_SCTRL_R
, sctrl_r
);
770 if (protocol
> ISDN_P_NONE
)
771 handle_led(hw
, (bch
->nr
== 1) ? LED_B1_ON
: LED_B2_ON
);
773 handle_led(hw
, (bch
->nr
== 1) ? LED_B1_OFF
:
781 hfcsusb_ph_command(struct hfcsusb
*hw
, u_char command
)
783 if (debug
& DEBUG_HW
)
784 printk(KERN_DEBUG
"%s: %s: %x\n",
785 hw
->name
, __func__
, command
);
788 case HFC_L1_ACTIVATE_TE
:
789 /* force sending sending INFO1 */
790 write_reg(hw
, HFCUSB_STATES
, 0x14);
791 /* start l1 activation */
792 write_reg(hw
, HFCUSB_STATES
, 0x04);
795 case HFC_L1_FORCE_DEACTIVATE_TE
:
796 write_reg(hw
, HFCUSB_STATES
, 0x10);
797 write_reg(hw
, HFCUSB_STATES
, 0x03);
800 case HFC_L1_ACTIVATE_NT
:
801 if (hw
->dch
.state
== 3)
802 _queue_data(&hw
->dch
.dev
.D
, PH_ACTIVATE_IND
,
803 MISDN_ID_ANY
, 0, NULL
, GFP_ATOMIC
);
805 write_reg(hw
, HFCUSB_STATES
, HFCUSB_ACTIVATE
|
806 HFCUSB_DO_ACTION
| HFCUSB_NT_G2_G3
);
809 case HFC_L1_DEACTIVATE_NT
:
810 write_reg(hw
, HFCUSB_STATES
,
817 * Layer 1 B-channel hardware access
820 channel_bctrl(struct bchannel
*bch
, struct mISDN_ctrl_req
*cq
)
825 case MISDN_CTRL_GETOP
:
826 cq
->op
= MISDN_CTRL_FILL_EMPTY
;
828 case MISDN_CTRL_FILL_EMPTY
: /* fill fifo, if empty */
829 test_and_set_bit(FLG_FILLEMPTY
, &bch
->Flags
);
830 if (debug
& DEBUG_HW_OPEN
)
831 printk(KERN_DEBUG
"%s: FILL_EMPTY request (nr=%d "
832 "off=%d)\n", __func__
, bch
->nr
, !!cq
->p1
);
835 printk(KERN_WARNING
"%s: unknown Op %x\n", __func__
, cq
->op
);
842 /* collect data from incoming interrupt or isochron USB data */
844 hfcsusb_rx_frame(struct usb_fifo
*fifo
, __u8
*data
, unsigned int len
,
847 struct hfcsusb
*hw
= fifo
->hw
;
848 struct sk_buff
*rx_skb
= NULL
;
850 int fifon
= fifo
->fifonum
;
854 if (debug
& DBG_HFC_CALL_TRACE
)
855 printk(KERN_DEBUG
"%s: %s: fifo(%i) len(%i) "
856 "dch(%p) bch(%p) ech(%p)\n",
857 hw
->name
, __func__
, fifon
, len
,
858 fifo
->dch
, fifo
->bch
, fifo
->ech
);
863 if ((!!fifo
->dch
+ !!fifo
->bch
+ !!fifo
->ech
) != 1) {
864 printk(KERN_DEBUG
"%s: %s: undefined channel\n",
869 spin_lock(&hw
->lock
);
871 rx_skb
= fifo
->dch
->rx_skb
;
872 maxlen
= fifo
->dch
->maxlen
;
876 rx_skb
= fifo
->bch
->rx_skb
;
877 maxlen
= fifo
->bch
->maxlen
;
878 hdlc
= test_bit(FLG_HDLC
, &fifo
->bch
->Flags
);
881 rx_skb
= fifo
->ech
->rx_skb
;
882 maxlen
= fifo
->ech
->maxlen
;
887 rx_skb
= mI_alloc_skb(maxlen
, GFP_ATOMIC
);
890 fifo
->dch
->rx_skb
= rx_skb
;
892 fifo
->bch
->rx_skb
= rx_skb
;
894 fifo
->ech
->rx_skb
= rx_skb
;
897 printk(KERN_DEBUG
"%s: %s: No mem for rx_skb\n",
899 spin_unlock(&hw
->lock
);
904 if (fifo
->dch
|| fifo
->ech
) {
905 /* D/E-Channel SKB range check */
906 if ((rx_skb
->len
+ len
) >= MAX_DFRAME_LEN_L1
) {
907 printk(KERN_DEBUG
"%s: %s: sbk mem exceeded "
908 "for fifo(%d) HFCUSB_D_RX\n",
909 hw
->name
, __func__
, fifon
);
911 spin_unlock(&hw
->lock
);
914 } else if (fifo
->bch
) {
915 /* B-Channel SKB range check */
916 if ((rx_skb
->len
+ len
) >= (MAX_BCH_SIZE
+ 3)) {
917 printk(KERN_DEBUG
"%s: %s: sbk mem exceeded "
918 "for fifo(%d) HFCUSB_B_RX\n",
919 hw
->name
, __func__
, fifon
);
921 spin_unlock(&hw
->lock
);
926 memcpy(skb_put(rx_skb
, len
), data
, len
);
929 /* we have a complete hdlc packet */
931 if ((rx_skb
->len
> 3) &&
932 (!(rx_skb
->data
[rx_skb
->len
- 1]))) {
933 if (debug
& DBG_HFC_FIFO_VERBOSE
) {
934 printk(KERN_DEBUG
"%s: %s: fifon(%i)"
936 hw
->name
, __func__
, fifon
,
939 while (i
< rx_skb
->len
)
945 /* remove CRC & status */
946 skb_trim(rx_skb
, rx_skb
->len
- 3);
949 recv_Dchannel(fifo
->dch
);
951 recv_Bchannel(fifo
->bch
, MISDN_ID_ANY
);
953 recv_Echannel(fifo
->ech
,
956 if (debug
& DBG_HFC_FIFO_VERBOSE
) {
958 "%s: CRC or minlen ERROR fifon(%i) "
960 hw
->name
, fifon
, rx_skb
->len
);
962 while (i
< rx_skb
->len
)
971 /* deliver transparent data to layer2 */
972 if (rx_skb
->len
>= poll
)
973 recv_Bchannel(fifo
->bch
, MISDN_ID_ANY
);
975 spin_unlock(&hw
->lock
);
979 fill_isoc_urb(struct urb
*urb
, struct usb_device
*dev
, unsigned int pipe
,
980 void *buf
, int num_packets
, int packet_size
, int interval
,
981 usb_complete_t complete
, void *context
)
985 usb_fill_bulk_urb(urb
, dev
, pipe
, buf
, packet_size
* num_packets
,
988 urb
->number_of_packets
= num_packets
;
989 urb
->transfer_flags
= URB_ISO_ASAP
;
990 urb
->actual_length
= 0;
991 urb
->interval
= interval
;
993 for (k
= 0; k
< num_packets
; k
++) {
994 urb
->iso_frame_desc
[k
].offset
= packet_size
* k
;
995 urb
->iso_frame_desc
[k
].length
= packet_size
;
996 urb
->iso_frame_desc
[k
].actual_length
= 0;
1000 /* receive completion routine for all ISO tx fifos */
1002 rx_iso_complete(struct urb
*urb
)
1004 struct iso_urb
*context_iso_urb
= (struct iso_urb
*) urb
->context
;
1005 struct usb_fifo
*fifo
= context_iso_urb
->owner_fifo
;
1006 struct hfcsusb
*hw
= fifo
->hw
;
1007 int k
, len
, errcode
, offset
, num_isoc_packets
, fifon
, maxlen
,
1008 status
, iso_status
, i
;
1013 fifon
= fifo
->fifonum
;
1014 status
= urb
->status
;
1016 spin_lock(&hw
->lock
);
1017 if (fifo
->stop_gracefull
) {
1018 fifo
->stop_gracefull
= 0;
1020 spin_unlock(&hw
->lock
);
1023 spin_unlock(&hw
->lock
);
1026 * ISO transfer only partially completed,
1027 * look at individual frame status for details
1029 if (status
== -EXDEV
) {
1030 if (debug
& DEBUG_HW
)
1031 printk(KERN_DEBUG
"%s: %s: with -EXDEV "
1032 "urb->status %d, fifonum %d\n",
1033 hw
->name
, __func__
, status
, fifon
);
1035 /* clear status, so go on with ISO transfers */
1040 if (fifo
->active
&& !status
) {
1041 num_isoc_packets
= iso_packets
[fifon
];
1042 maxlen
= fifo
->usb_packet_maxlen
;
1044 for (k
= 0; k
< num_isoc_packets
; ++k
) {
1045 len
= urb
->iso_frame_desc
[k
].actual_length
;
1046 offset
= urb
->iso_frame_desc
[k
].offset
;
1047 buf
= context_iso_urb
->buffer
+ offset
;
1048 iso_status
= urb
->iso_frame_desc
[k
].status
;
1050 if (iso_status
&& (debug
& DBG_HFC_FIFO_VERBOSE
)) {
1051 printk(KERN_DEBUG
"%s: %s: "
1052 "ISO packet %i, status: %i\n",
1053 hw
->name
, __func__
, k
, iso_status
);
1056 /* USB data log for every D ISO in */
1057 if ((fifon
== HFCUSB_D_RX
) &&
1058 (debug
& DBG_HFC_USB_VERBOSE
)) {
1060 "%s: %s: %d (%d/%d) len(%d) ",
1061 hw
->name
, __func__
, urb
->start_frame
,
1062 k
, num_isoc_packets
-1,
1064 for (i
= 0; i
< len
; i
++)
1065 printk("%x ", buf
[i
]);
1070 if (fifo
->last_urblen
!= maxlen
) {
1072 * save fifo fill-level threshold bits
1073 * to use them later in TX ISO URB
1076 hw
->threshold_mask
= buf
[1];
1078 if (fifon
== HFCUSB_D_RX
)
1079 s0_state
= (buf
[0] >> 4);
1081 eof
[fifon
] = buf
[0] & 1;
1083 hfcsusb_rx_frame(fifo
, buf
+ 2,
1084 len
- 2, (len
< maxlen
)
1087 hfcsusb_rx_frame(fifo
, buf
, len
,
1090 fifo
->last_urblen
= len
;
1094 /* signal S0 layer1 state change */
1095 if ((s0_state
) && (hw
->initdone
) &&
1096 (s0_state
!= hw
->dch
.state
)) {
1097 hw
->dch
.state
= s0_state
;
1098 schedule_event(&hw
->dch
, FLG_PHCHANGE
);
1101 fill_isoc_urb(urb
, fifo
->hw
->dev
, fifo
->pipe
,
1102 context_iso_urb
->buffer
, num_isoc_packets
,
1103 fifo
->usb_packet_maxlen
, fifo
->intervall
,
1104 (usb_complete_t
)rx_iso_complete
, urb
->context
);
1105 errcode
= usb_submit_urb(urb
, GFP_ATOMIC
);
1107 if (debug
& DEBUG_HW
)
1108 printk(KERN_DEBUG
"%s: %s: error submitting "
1110 hw
->name
, __func__
, errcode
);
1113 if (status
&& (debug
& DBG_HFC_URB_INFO
))
1114 printk(KERN_DEBUG
"%s: %s: rx_iso_complete : "
1115 "urb->status %d, fifonum %d\n",
1116 hw
->name
, __func__
, status
, fifon
);
1120 /* receive completion routine for all interrupt rx fifos */
1122 rx_int_complete(struct urb
*urb
)
1125 __u8
*buf
, maxlen
, fifon
;
1126 struct usb_fifo
*fifo
= (struct usb_fifo
*) urb
->context
;
1127 struct hfcsusb
*hw
= fifo
->hw
;
1130 spin_lock(&hw
->lock
);
1131 if (fifo
->stop_gracefull
) {
1132 fifo
->stop_gracefull
= 0;
1134 spin_unlock(&hw
->lock
);
1137 spin_unlock(&hw
->lock
);
1139 fifon
= fifo
->fifonum
;
1140 if ((!fifo
->active
) || (urb
->status
)) {
1141 if (debug
& DBG_HFC_URB_ERROR
)
1143 "%s: %s: RX-Fifo %i is going down (%i)\n",
1144 hw
->name
, __func__
, fifon
, urb
->status
);
1146 fifo
->urb
->interval
= 0; /* cancel automatic rescheduling */
1149 len
= urb
->actual_length
;
1151 maxlen
= fifo
->usb_packet_maxlen
;
1153 /* USB data log for every D INT in */
1154 if ((fifon
== HFCUSB_D_RX
) && (debug
& DBG_HFC_USB_VERBOSE
)) {
1155 printk(KERN_DEBUG
"%s: %s: D RX INT len(%d) ",
1156 hw
->name
, __func__
, len
);
1157 for (i
= 0; i
< len
; i
++)
1158 printk("%02x ", buf
[i
]);
1162 if (fifo
->last_urblen
!= fifo
->usb_packet_maxlen
) {
1163 /* the threshold mask is in the 2nd status byte */
1164 hw
->threshold_mask
= buf
[1];
1166 /* signal S0 layer1 state change */
1167 if (hw
->initdone
&& ((buf
[0] >> 4) != hw
->dch
.state
)) {
1168 hw
->dch
.state
= (buf
[0] >> 4);
1169 schedule_event(&hw
->dch
, FLG_PHCHANGE
);
1172 eof
[fifon
] = buf
[0] & 1;
1173 /* if we have more than the 2 status bytes -> collect data */
1175 hfcsusb_rx_frame(fifo
, buf
+ 2,
1176 urb
->actual_length
- 2,
1177 (len
< maxlen
) ? eof
[fifon
] : 0);
1179 hfcsusb_rx_frame(fifo
, buf
, urb
->actual_length
,
1180 (len
< maxlen
) ? eof
[fifon
] : 0);
1182 fifo
->last_urblen
= urb
->actual_length
;
1184 status
= usb_submit_urb(urb
, GFP_ATOMIC
);
1186 if (debug
& DEBUG_HW
)
1187 printk(KERN_DEBUG
"%s: %s: error resubmitting USB\n",
1188 hw
->name
, __func__
);
1192 /* transmit completion routine for all ISO tx fifos */
1194 tx_iso_complete(struct urb
*urb
)
1196 struct iso_urb
*context_iso_urb
= (struct iso_urb
*) urb
->context
;
1197 struct usb_fifo
*fifo
= context_iso_urb
->owner_fifo
;
1198 struct hfcsusb
*hw
= fifo
->hw
;
1199 struct sk_buff
*tx_skb
;
1200 int k
, tx_offset
, num_isoc_packets
, sink
, remain
, current_len
,
1203 int frame_complete
, fifon
, status
;
1206 spin_lock(&hw
->lock
);
1207 if (fifo
->stop_gracefull
) {
1208 fifo
->stop_gracefull
= 0;
1210 spin_unlock(&hw
->lock
);
1215 tx_skb
= fifo
->dch
->tx_skb
;
1216 tx_idx
= &fifo
->dch
->tx_idx
;
1218 } else if (fifo
->bch
) {
1219 tx_skb
= fifo
->bch
->tx_skb
;
1220 tx_idx
= &fifo
->bch
->tx_idx
;
1221 hdlc
= test_bit(FLG_HDLC
, &fifo
->bch
->Flags
);
1223 printk(KERN_DEBUG
"%s: %s: neither BCH nor DCH\n",
1224 hw
->name
, __func__
);
1225 spin_unlock(&hw
->lock
);
1229 fifon
= fifo
->fifonum
;
1230 status
= urb
->status
;
1235 * ISO transfer only partially completed,
1236 * look at individual frame status for details
1238 if (status
== -EXDEV
) {
1239 if (debug
& DBG_HFC_URB_ERROR
)
1240 printk(KERN_DEBUG
"%s: %s: "
1241 "-EXDEV (%i) fifon (%d)\n",
1242 hw
->name
, __func__
, status
, fifon
);
1244 /* clear status, so go on with ISO transfers */
1248 if (fifo
->active
&& !status
) {
1249 /* is FifoFull-threshold set for our channel? */
1250 threshbit
= (hw
->threshold_mask
& (1 << fifon
));
1251 num_isoc_packets
= iso_packets
[fifon
];
1253 /* predict dataflow to avoid fifo overflow */
1254 if (fifon
>= HFCUSB_D_TX
)
1255 sink
= (threshbit
) ? SINK_DMIN
: SINK_DMAX
;
1257 sink
= (threshbit
) ? SINK_MIN
: SINK_MAX
;
1258 fill_isoc_urb(urb
, fifo
->hw
->dev
, fifo
->pipe
,
1259 context_iso_urb
->buffer
, num_isoc_packets
,
1260 fifo
->usb_packet_maxlen
, fifo
->intervall
,
1261 (usb_complete_t
)tx_iso_complete
, urb
->context
);
1262 memset(context_iso_urb
->buffer
, 0,
1263 sizeof(context_iso_urb
->buffer
));
1266 for (k
= 0; k
< num_isoc_packets
; ++k
) {
1267 /* analyze tx success of previous ISO packets */
1268 if (debug
& DBG_HFC_URB_ERROR
) {
1269 errcode
= urb
->iso_frame_desc
[k
].status
;
1271 printk(KERN_DEBUG
"%s: %s: "
1272 "ISO packet %i, status: %i\n",
1273 hw
->name
, __func__
, k
, errcode
);
1277 /* Generate next ISO Packets */
1279 remain
= tx_skb
->len
- *tx_idx
;
1284 fifo
->bit_line
-= sink
;
1285 current_len
= (0 - fifo
->bit_line
) / 8;
1286 if (current_len
> 14)
1288 if (current_len
< 0)
1290 if (remain
< current_len
)
1291 current_len
= remain
;
1293 /* how much bit do we put on the line? */
1294 fifo
->bit_line
+= current_len
* 8;
1296 context_iso_urb
->buffer
[tx_offset
] = 0;
1297 if (current_len
== remain
) {
1299 /* signal frame completion */
1301 buffer
[tx_offset
] = 1;
1302 /* add 2 byte flags and 16bit
1303 * CRC at end of ISDN frame */
1304 fifo
->bit_line
+= 32;
1309 /* copy tx data to iso-urb buffer */
1310 memcpy(context_iso_urb
->buffer
+ tx_offset
+ 1,
1311 (tx_skb
->data
+ *tx_idx
), current_len
);
1312 *tx_idx
+= current_len
;
1314 urb
->iso_frame_desc
[k
].offset
= tx_offset
;
1315 urb
->iso_frame_desc
[k
].length
= current_len
+ 1;
1317 /* USB data log for every D ISO out */
1318 if ((fifon
== HFCUSB_D_RX
) &&
1319 (debug
& DBG_HFC_USB_VERBOSE
)) {
1321 "%s: %s (%d/%d) offs(%d) len(%d) ",
1323 k
, num_isoc_packets
-1,
1324 urb
->iso_frame_desc
[k
].offset
,
1325 urb
->iso_frame_desc
[k
].length
);
1327 for (i
= urb
->iso_frame_desc
[k
].offset
;
1328 i
< (urb
->iso_frame_desc
[k
].offset
1329 + urb
->iso_frame_desc
[k
].length
);
1332 context_iso_urb
->buffer
[i
]);
1334 printk(" skb->len(%i) tx-idx(%d)\n",
1335 tx_skb
->len
, *tx_idx
);
1338 tx_offset
+= (current_len
+ 1);
1340 urb
->iso_frame_desc
[k
].offset
= tx_offset
++;
1341 urb
->iso_frame_desc
[k
].length
= 1;
1342 /* we lower data margin every msec */
1343 fifo
->bit_line
-= sink
;
1344 if (fifo
->bit_line
< BITLINE_INF
)
1345 fifo
->bit_line
= BITLINE_INF
;
1348 if (frame_complete
) {
1351 if (debug
& DBG_HFC_FIFO_VERBOSE
) {
1352 printk(KERN_DEBUG
"%s: %s: "
1353 "fifon(%i) new TX len(%i): ",
1355 fifon
, tx_skb
->len
);
1357 while (i
< tx_skb
->len
)
1363 dev_kfree_skb(tx_skb
);
1365 if (fifo
->dch
&& get_next_dframe(fifo
->dch
))
1366 tx_skb
= fifo
->dch
->tx_skb
;
1367 else if (fifo
->bch
&&
1368 get_next_bframe(fifo
->bch
)) {
1369 if (test_bit(FLG_TRANSPARENT
,
1371 confirm_Bsend(fifo
->bch
);
1372 tx_skb
= fifo
->bch
->tx_skb
;
1376 errcode
= usb_submit_urb(urb
, GFP_ATOMIC
);
1378 if (debug
& DEBUG_HW
)
1380 "%s: %s: error submitting ISO URB: %d \n",
1381 hw
->name
, __func__
, errcode
);
1385 * abuse DChannel tx iso completion to trigger NT mode state
1386 * changes tx_iso_complete is assumed to be called every
1387 * fifo->intervall (ms)
1389 if ((fifon
== HFCUSB_D_TX
) && (hw
->protocol
== ISDN_P_NT_S0
)
1390 && (hw
->timers
& NT_ACTIVATION_TIMER
)) {
1391 if ((--hw
->nt_timer
) < 0)
1392 schedule_event(&hw
->dch
, FLG_PHCHANGE
);
1396 if (status
&& (debug
& DBG_HFC_URB_ERROR
))
1397 printk(KERN_DEBUG
"%s: %s: urb->status %s (%i)"
1400 symbolic(urb_errlist
, status
), status
, fifon
);
1402 spin_unlock(&hw
->lock
);
1406 * allocs urbs and start isoc transfer with two pending urbs to avoid
1407 * gaps in the transfer chain
1410 start_isoc_chain(struct usb_fifo
*fifo
, int num_packets_per_urb
,
1411 usb_complete_t complete
, int packet_size
)
1413 struct hfcsusb
*hw
= fifo
->hw
;
1417 printk(KERN_DEBUG
"%s: %s: fifo %i\n",
1418 hw
->name
, __func__
, fifo
->fifonum
);
1420 /* allocate Memory for Iso out Urbs */
1421 for (i
= 0; i
< 2; i
++) {
1422 if (!(fifo
->iso
[i
].urb
)) {
1424 usb_alloc_urb(num_packets_per_urb
, GFP_KERNEL
);
1425 if (!(fifo
->iso
[i
].urb
)) {
1427 "%s: %s: alloc urb for fifo %i failed",
1428 hw
->name
, __func__
, fifo
->fifonum
);
1430 fifo
->iso
[i
].owner_fifo
= (struct usb_fifo
*) fifo
;
1431 fifo
->iso
[i
].indx
= i
;
1433 /* Init the first iso */
1434 if (ISO_BUFFER_SIZE
>=
1435 (fifo
->usb_packet_maxlen
*
1436 num_packets_per_urb
)) {
1437 fill_isoc_urb(fifo
->iso
[i
].urb
,
1438 fifo
->hw
->dev
, fifo
->pipe
,
1439 fifo
->iso
[i
].buffer
,
1440 num_packets_per_urb
,
1441 fifo
->usb_packet_maxlen
,
1442 fifo
->intervall
, complete
,
1444 memset(fifo
->iso
[i
].buffer
, 0,
1445 sizeof(fifo
->iso
[i
].buffer
));
1447 for (k
= 0; k
< num_packets_per_urb
; k
++) {
1449 iso_frame_desc
[k
].offset
=
1452 iso_frame_desc
[k
].length
=
1457 "%s: %s: ISO Buffer size to small!\n",
1458 hw
->name
, __func__
);
1461 fifo
->bit_line
= BITLINE_INF
;
1463 errcode
= usb_submit_urb(fifo
->iso
[i
].urb
, GFP_KERNEL
);
1464 fifo
->active
= (errcode
>= 0) ? 1 : 0;
1465 fifo
->stop_gracefull
= 0;
1467 printk(KERN_DEBUG
"%s: %s: %s URB nr:%d\n",
1469 symbolic(urb_errlist
, errcode
), i
);
1472 return fifo
->active
;
1476 stop_iso_gracefull(struct usb_fifo
*fifo
)
1478 struct hfcsusb
*hw
= fifo
->hw
;
1482 for (i
= 0; i
< 2; i
++) {
1483 spin_lock_irqsave(&hw
->lock
, flags
);
1485 printk(KERN_DEBUG
"%s: %s for fifo %i.%i\n",
1486 hw
->name
, __func__
, fifo
->fifonum
, i
);
1487 fifo
->stop_gracefull
= 1;
1488 spin_unlock_irqrestore(&hw
->lock
, flags
);
1491 for (i
= 0; i
< 2; i
++) {
1493 while (fifo
->stop_gracefull
&& timeout
--)
1494 schedule_timeout_interruptible((HZ
/1000)*16);
1495 if (debug
&& fifo
->stop_gracefull
)
1496 printk(KERN_DEBUG
"%s: ERROR %s for fifo %i.%i\n",
1497 hw
->name
, __func__
, fifo
->fifonum
, i
);
1502 stop_int_gracefull(struct usb_fifo
*fifo
)
1504 struct hfcsusb
*hw
= fifo
->hw
;
1508 spin_lock_irqsave(&hw
->lock
, flags
);
1510 printk(KERN_DEBUG
"%s: %s for fifo %i\n",
1511 hw
->name
, __func__
, fifo
->fifonum
);
1512 fifo
->stop_gracefull
= 1;
1513 spin_unlock_irqrestore(&hw
->lock
, flags
);
1516 while (fifo
->stop_gracefull
&& timeout
--)
1517 schedule_timeout_interruptible((HZ
/1000)*3);
1518 if (debug
&& fifo
->stop_gracefull
)
1519 printk(KERN_DEBUG
"%s: ERROR %s for fifo %i\n",
1520 hw
->name
, __func__
, fifo
->fifonum
);
1523 /* start the interrupt transfer for the given fifo */
1525 start_int_fifo(struct usb_fifo
*fifo
)
1527 struct hfcsusb
*hw
= fifo
->hw
;
1531 printk(KERN_DEBUG
"%s: %s: INT IN fifo:%d\n",
1532 hw
->name
, __func__
, fifo
->fifonum
);
1535 fifo
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
1539 usb_fill_int_urb(fifo
->urb
, fifo
->hw
->dev
, fifo
->pipe
,
1540 fifo
->buffer
, fifo
->usb_packet_maxlen
,
1541 (usb_complete_t
)rx_int_complete
, fifo
, fifo
->intervall
);
1543 fifo
->stop_gracefull
= 0;
1544 errcode
= usb_submit_urb(fifo
->urb
, GFP_KERNEL
);
1546 printk(KERN_DEBUG
"%s: %s: submit URB: status:%i\n",
1547 hw
->name
, __func__
, errcode
);
1553 setPortMode(struct hfcsusb
*hw
)
1555 if (debug
& DEBUG_HW
)
1556 printk(KERN_DEBUG
"%s: %s %s\n", hw
->name
, __func__
,
1557 (hw
->protocol
== ISDN_P_TE_S0
) ? "TE" : "NT");
1559 if (hw
->protocol
== ISDN_P_TE_S0
) {
1560 write_reg(hw
, HFCUSB_SCTRL
, 0x40);
1561 write_reg(hw
, HFCUSB_SCTRL_E
, 0x00);
1562 write_reg(hw
, HFCUSB_CLKDEL
, CLKDEL_TE
);
1563 write_reg(hw
, HFCUSB_STATES
, 3 | 0x10);
1564 write_reg(hw
, HFCUSB_STATES
, 3);
1566 write_reg(hw
, HFCUSB_SCTRL
, 0x44);
1567 write_reg(hw
, HFCUSB_SCTRL_E
, 0x09);
1568 write_reg(hw
, HFCUSB_CLKDEL
, CLKDEL_NT
);
1569 write_reg(hw
, HFCUSB_STATES
, 1 | 0x10);
1570 write_reg(hw
, HFCUSB_STATES
, 1);
1575 reset_hfcsusb(struct hfcsusb
*hw
)
1577 struct usb_fifo
*fifo
;
1580 if (debug
& DEBUG_HW
)
1581 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
1584 write_reg(hw
, HFCUSB_CIRM
, 8);
1586 /* aux = output, reset off */
1587 write_reg(hw
, HFCUSB_CIRM
, 0x10);
1589 /* set USB_SIZE to match the wMaxPacketSize for INT or BULK transfers */
1590 write_reg(hw
, HFCUSB_USB_SIZE
, (hw
->packet_size
/ 8) |
1591 ((hw
->packet_size
/ 8) << 4));
1593 /* set USB_SIZE_I to match the the wMaxPacketSize for ISO transfers */
1594 write_reg(hw
, HFCUSB_USB_SIZE_I
, hw
->iso_packet_size
);
1596 /* enable PCM/GCI master mode */
1597 write_reg(hw
, HFCUSB_MST_MODE1
, 0); /* set default values */
1598 write_reg(hw
, HFCUSB_MST_MODE0
, 1); /* enable master mode */
1600 /* init the fifos */
1601 write_reg(hw
, HFCUSB_F_THRES
,
1602 (HFCUSB_TX_THRESHOLD
/ 8) | ((HFCUSB_RX_THRESHOLD
/ 8) << 4));
1605 for (i
= 0; i
< HFCUSB_NUM_FIFOS
; i
++) {
1606 write_reg(hw
, HFCUSB_FIFO
, i
); /* select the desired fifo */
1608 (i
<= HFCUSB_B2_RX
) ? MAX_BCH_SIZE
: MAX_DFRAME_LEN
;
1609 fifo
[i
].last_urblen
= 0;
1611 /* set 2 bit for D- & E-channel */
1612 write_reg(hw
, HFCUSB_HDLC_PAR
, ((i
<= HFCUSB_B2_RX
) ? 0 : 2));
1614 /* enable all fifos */
1615 if (i
== HFCUSB_D_TX
)
1616 write_reg(hw
, HFCUSB_CON_HDLC
,
1617 (hw
->protocol
== ISDN_P_NT_S0
) ? 0x08 : 0x09);
1619 write_reg(hw
, HFCUSB_CON_HDLC
, 0x08);
1620 write_reg(hw
, HFCUSB_INC_RES_F
, 2); /* reset the fifo */
1623 write_reg(hw
, HFCUSB_SCTRL_R
, 0); /* disable both B receivers */
1624 handle_led(hw
, LED_POWER_ON
);
1627 /* start USB data pipes dependand on device's endpoint configuration */
1629 hfcsusb_start_endpoint(struct hfcsusb
*hw
, int channel
)
1631 /* quick check if endpoint already running */
1632 if ((channel
== HFC_CHAN_D
) && (hw
->fifos
[HFCUSB_D_RX
].active
))
1634 if ((channel
== HFC_CHAN_B1
) && (hw
->fifos
[HFCUSB_B1_RX
].active
))
1636 if ((channel
== HFC_CHAN_B2
) && (hw
->fifos
[HFCUSB_B2_RX
].active
))
1638 if ((channel
== HFC_CHAN_E
) && (hw
->fifos
[HFCUSB_PCM_RX
].active
))
1641 /* start rx endpoints using USB INT IN method */
1642 if (hw
->cfg_used
== CNF_3INT3ISO
|| hw
->cfg_used
== CNF_4INT3ISO
)
1643 start_int_fifo(hw
->fifos
+ channel
*2 + 1);
1645 /* start rx endpoints using USB ISO IN method */
1646 if (hw
->cfg_used
== CNF_3ISO3ISO
|| hw
->cfg_used
== CNF_4ISO3ISO
) {
1649 start_isoc_chain(hw
->fifos
+ HFCUSB_D_RX
,
1651 (usb_complete_t
)rx_iso_complete
,
1655 start_isoc_chain(hw
->fifos
+ HFCUSB_PCM_RX
,
1657 (usb_complete_t
)rx_iso_complete
,
1661 start_isoc_chain(hw
->fifos
+ HFCUSB_B1_RX
,
1663 (usb_complete_t
)rx_iso_complete
,
1667 start_isoc_chain(hw
->fifos
+ HFCUSB_B2_RX
,
1669 (usb_complete_t
)rx_iso_complete
,
1675 /* start tx endpoints using USB ISO OUT method */
1678 start_isoc_chain(hw
->fifos
+ HFCUSB_D_TX
,
1680 (usb_complete_t
)tx_iso_complete
, 1);
1683 start_isoc_chain(hw
->fifos
+ HFCUSB_B1_TX
,
1685 (usb_complete_t
)tx_iso_complete
, 1);
1688 start_isoc_chain(hw
->fifos
+ HFCUSB_B2_TX
,
1690 (usb_complete_t
)tx_iso_complete
, 1);
1695 /* stop USB data pipes dependand on device's endpoint configuration */
1697 hfcsusb_stop_endpoint(struct hfcsusb
*hw
, int channel
)
1699 /* quick check if endpoint currently running */
1700 if ((channel
== HFC_CHAN_D
) && (!hw
->fifos
[HFCUSB_D_RX
].active
))
1702 if ((channel
== HFC_CHAN_B1
) && (!hw
->fifos
[HFCUSB_B1_RX
].active
))
1704 if ((channel
== HFC_CHAN_B2
) && (!hw
->fifos
[HFCUSB_B2_RX
].active
))
1706 if ((channel
== HFC_CHAN_E
) && (!hw
->fifos
[HFCUSB_PCM_RX
].active
))
1709 /* rx endpoints using USB INT IN method */
1710 if (hw
->cfg_used
== CNF_3INT3ISO
|| hw
->cfg_used
== CNF_4INT3ISO
)
1711 stop_int_gracefull(hw
->fifos
+ channel
*2 + 1);
1713 /* rx endpoints using USB ISO IN method */
1714 if (hw
->cfg_used
== CNF_3ISO3ISO
|| hw
->cfg_used
== CNF_4ISO3ISO
)
1715 stop_iso_gracefull(hw
->fifos
+ channel
*2 + 1);
1717 /* tx endpoints using USB ISO OUT method */
1718 if (channel
!= HFC_CHAN_E
)
1719 stop_iso_gracefull(hw
->fifos
+ channel
*2);
1723 /* Hardware Initialization */
1725 setup_hfcsusb(struct hfcsusb
*hw
)
1729 if (debug
& DBG_HFC_CALL_TRACE
)
1730 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
1732 /* check the chip id */
1733 if (read_reg_atomic(hw
, HFCUSB_CHIP_ID
, &b
) != 1) {
1734 printk(KERN_DEBUG
"%s: %s: cannot read chip id\n",
1735 hw
->name
, __func__
);
1738 if (b
!= HFCUSB_CHIPID
) {
1739 printk(KERN_DEBUG
"%s: %s: Invalid chip id 0x%02x\n",
1740 hw
->name
, __func__
, b
);
1744 /* first set the needed config, interface and alternate */
1745 (void) usb_set_interface(hw
->dev
, hw
->if_used
, hw
->alt_used
);
1749 /* init the background machinery for control requests */
1750 hw
->ctrl_read
.bRequestType
= 0xc0;
1751 hw
->ctrl_read
.bRequest
= 1;
1752 hw
->ctrl_read
.wLength
= cpu_to_le16(1);
1753 hw
->ctrl_write
.bRequestType
= 0x40;
1754 hw
->ctrl_write
.bRequest
= 0;
1755 hw
->ctrl_write
.wLength
= 0;
1756 usb_fill_control_urb(hw
->ctrl_urb
, hw
->dev
, hw
->ctrl_out_pipe
,
1757 (u_char
*)&hw
->ctrl_write
, NULL
, 0,
1758 (usb_complete_t
)ctrl_complete
, hw
);
1765 release_hw(struct hfcsusb
*hw
)
1767 if (debug
& DBG_HFC_CALL_TRACE
)
1768 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
1771 * stop all endpoints gracefully
1772 * TODO: mISDN_core should generate CLOSE_CHANNEL
1773 * signals after calling mISDN_unregister_device()
1775 hfcsusb_stop_endpoint(hw
, HFC_CHAN_D
);
1776 hfcsusb_stop_endpoint(hw
, HFC_CHAN_B1
);
1777 hfcsusb_stop_endpoint(hw
, HFC_CHAN_B2
);
1778 if (hw
->fifos
[HFCUSB_PCM_RX
].pipe
)
1779 hfcsusb_stop_endpoint(hw
, HFC_CHAN_E
);
1780 if (hw
->protocol
== ISDN_P_TE_S0
)
1781 l1_event(hw
->dch
.l1
, CLOSE_CHANNEL
);
1783 mISDN_unregister_device(&hw
->dch
.dev
);
1784 mISDN_freebchannel(&hw
->bch
[1]);
1785 mISDN_freebchannel(&hw
->bch
[0]);
1786 mISDN_freedchannel(&hw
->dch
);
1789 usb_kill_urb(hw
->ctrl_urb
);
1790 usb_free_urb(hw
->ctrl_urb
);
1791 hw
->ctrl_urb
= NULL
;
1795 usb_set_intfdata(hw
->intf
, NULL
);
1796 list_del(&hw
->list
);
1802 deactivate_bchannel(struct bchannel
*bch
)
1804 struct hfcsusb
*hw
= bch
->hw
;
1807 if (bch
->debug
& DEBUG_HW
)
1808 printk(KERN_DEBUG
"%s: %s: bch->nr(%i)\n",
1809 hw
->name
, __func__
, bch
->nr
);
1811 spin_lock_irqsave(&hw
->lock
, flags
);
1812 mISDN_clear_bchannel(bch
);
1813 spin_unlock_irqrestore(&hw
->lock
, flags
);
1814 hfcsusb_setup_bch(bch
, ISDN_P_NONE
);
1815 hfcsusb_stop_endpoint(hw
, bch
->nr
);
1819 * Layer 1 B-channel hardware access
1822 hfc_bctrl(struct mISDNchannel
*ch
, u_int cmd
, void *arg
)
1824 struct bchannel
*bch
= container_of(ch
, struct bchannel
, ch
);
1827 if (bch
->debug
& DEBUG_HW
)
1828 printk(KERN_DEBUG
"%s: cmd:%x %p\n", __func__
, cmd
, arg
);
1832 case HW_TESTRX_HDLC
:
1838 test_and_clear_bit(FLG_OPEN
, &bch
->Flags
);
1839 if (test_bit(FLG_ACTIVE
, &bch
->Flags
))
1840 deactivate_bchannel(bch
);
1841 ch
->protocol
= ISDN_P_NONE
;
1843 module_put(THIS_MODULE
);
1846 case CONTROL_CHANNEL
:
1847 ret
= channel_bctrl(bch
, arg
);
1850 printk(KERN_WARNING
"%s: unknown prim(%x)\n",
1857 setup_instance(struct hfcsusb
*hw
, struct device
*parent
)
1862 if (debug
& DBG_HFC_CALL_TRACE
)
1863 printk(KERN_DEBUG
"%s: %s\n", hw
->name
, __func__
);
1865 spin_lock_init(&hw
->ctrl_lock
);
1866 spin_lock_init(&hw
->lock
);
1868 mISDN_initdchannel(&hw
->dch
, MAX_DFRAME_LEN_L1
, ph_state
);
1869 hw
->dch
.debug
= debug
& 0xFFFF;
1871 hw
->dch
.dev
.Dprotocols
= (1 << ISDN_P_TE_S0
) | (1 << ISDN_P_NT_S0
);
1872 hw
->dch
.dev
.D
.send
= hfcusb_l2l1D
;
1873 hw
->dch
.dev
.D
.ctrl
= hfc_dctrl
;
1875 /* enable E-Channel logging */
1876 if (hw
->fifos
[HFCUSB_PCM_RX
].pipe
)
1877 mISDN_initdchannel(&hw
->ech
, MAX_DFRAME_LEN_L1
, NULL
);
1879 hw
->dch
.dev
.Bprotocols
= (1 << (ISDN_P_B_RAW
& ISDN_P_B_MASK
)) |
1880 (1 << (ISDN_P_B_HDLC
& ISDN_P_B_MASK
));
1881 hw
->dch
.dev
.nrbchan
= 2;
1882 for (i
= 0; i
< 2; i
++) {
1883 hw
->bch
[i
].nr
= i
+ 1;
1884 set_channelmap(i
+ 1, hw
->dch
.dev
.channelmap
);
1885 hw
->bch
[i
].debug
= debug
;
1886 mISDN_initbchannel(&hw
->bch
[i
], MAX_DATA_MEM
);
1888 hw
->bch
[i
].ch
.send
= hfcusb_l2l1B
;
1889 hw
->bch
[i
].ch
.ctrl
= hfc_bctrl
;
1890 hw
->bch
[i
].ch
.nr
= i
+ 1;
1891 list_add(&hw
->bch
[i
].ch
.list
, &hw
->dch
.dev
.bchannels
);
1894 hw
->fifos
[HFCUSB_B1_TX
].bch
= &hw
->bch
[0];
1895 hw
->fifos
[HFCUSB_B1_RX
].bch
= &hw
->bch
[0];
1896 hw
->fifos
[HFCUSB_B2_TX
].bch
= &hw
->bch
[1];
1897 hw
->fifos
[HFCUSB_B2_RX
].bch
= &hw
->bch
[1];
1898 hw
->fifos
[HFCUSB_D_TX
].dch
= &hw
->dch
;
1899 hw
->fifos
[HFCUSB_D_RX
].dch
= &hw
->dch
;
1900 hw
->fifos
[HFCUSB_PCM_RX
].ech
= &hw
->ech
;
1901 hw
->fifos
[HFCUSB_PCM_TX
].ech
= &hw
->ech
;
1903 err
= setup_hfcsusb(hw
);
1907 snprintf(hw
->name
, MISDN_MAX_IDLEN
- 1, "%s.%d", DRIVER_NAME
,
1909 printk(KERN_INFO
"%s: registered as '%s'\n",
1910 DRIVER_NAME
, hw
->name
);
1912 err
= mISDN_register_device(&hw
->dch
.dev
, parent
, hw
->name
);
1917 write_lock_irqsave(&HFClock
, flags
);
1918 list_add_tail(&hw
->list
, &HFClist
);
1919 write_unlock_irqrestore(&HFClock
, flags
);
1923 mISDN_freebchannel(&hw
->bch
[1]);
1924 mISDN_freebchannel(&hw
->bch
[0]);
1925 mISDN_freedchannel(&hw
->dch
);
1931 hfcsusb_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
1934 struct usb_device
*dev
= interface_to_usbdev(intf
);
1935 struct usb_host_interface
*iface
= intf
->cur_altsetting
;
1936 struct usb_host_interface
*iface_used
= NULL
;
1937 struct usb_host_endpoint
*ep
;
1938 struct hfcsusb_vdata
*driver_info
;
1939 int ifnum
= iface
->desc
.bInterfaceNumber
, i
, idx
, alt_idx
,
1940 probe_alt_setting
, vend_idx
, cfg_used
, *vcf
, attr
, cfg_found
,
1941 ep_addr
, cmptbl
[16], small_match
, iso_packet_size
, packet_size
,
1945 for (i
= 0; hfcsusb_idtab
[i
].idVendor
; i
++) {
1946 if ((le16_to_cpu(dev
->descriptor
.idVendor
)
1947 == hfcsusb_idtab
[i
].idVendor
) &&
1948 (le16_to_cpu(dev
->descriptor
.idProduct
)
1949 == hfcsusb_idtab
[i
].idProduct
)) {
1956 "%s: interface(%d) actalt(%d) minor(%d) vend_idx(%d)\n",
1957 __func__
, ifnum
, iface
->desc
.bAlternateSetting
,
1958 intf
->minor
, vend_idx
);
1960 if (vend_idx
== 0xffff) {
1962 "%s: no valid vendor found in USB descriptor\n",
1966 /* if vendor and product ID is OK, start probing alternate settings */
1970 /* default settings */
1971 iso_packet_size
= 16;
1974 while (alt_idx
< intf
->num_altsetting
) {
1975 iface
= intf
->altsetting
+ alt_idx
;
1976 probe_alt_setting
= iface
->desc
.bAlternateSetting
;
1979 while (validconf
[cfg_used
][0]) {
1981 vcf
= validconf
[cfg_used
];
1982 ep
= iface
->endpoint
;
1983 memcpy(cmptbl
, vcf
, 16 * sizeof(int));
1985 /* check for all endpoints in this alternate setting */
1986 for (i
= 0; i
< iface
->desc
.bNumEndpoints
; i
++) {
1987 ep_addr
= ep
->desc
.bEndpointAddress
;
1989 /* get endpoint base */
1990 idx
= ((ep_addr
& 0x7f) - 1) * 2;
1993 attr
= ep
->desc
.bmAttributes
;
1995 if (cmptbl
[idx
] != EP_NOP
) {
1996 if (cmptbl
[idx
] == EP_NUL
)
1998 if (attr
== USB_ENDPOINT_XFER_INT
1999 && cmptbl
[idx
] == EP_INT
)
2000 cmptbl
[idx
] = EP_NUL
;
2001 if (attr
== USB_ENDPOINT_XFER_BULK
2002 && cmptbl
[idx
] == EP_BLK
)
2003 cmptbl
[idx
] = EP_NUL
;
2004 if (attr
== USB_ENDPOINT_XFER_ISOC
2005 && cmptbl
[idx
] == EP_ISO
)
2006 cmptbl
[idx
] = EP_NUL
;
2008 if (attr
== USB_ENDPOINT_XFER_INT
&&
2009 ep
->desc
.bInterval
< vcf
[17]) {
2016 for (i
= 0; i
< 16; i
++)
2017 if (cmptbl
[i
] != EP_NOP
&& cmptbl
[i
] != EP_NUL
)
2021 if (small_match
< cfg_used
) {
2022 small_match
= cfg_used
;
2023 alt_used
= probe_alt_setting
;
2030 } /* (alt_idx < intf->num_altsetting) */
2032 /* not found a valid USB Ta Endpoint config */
2033 if (small_match
== -1)
2037 hw
= kzalloc(sizeof(struct hfcsusb
), GFP_KERNEL
);
2039 return -ENOMEM
; /* got no mem */
2040 snprintf(hw
->name
, MISDN_MAX_IDLEN
- 1, "%s", DRIVER_NAME
);
2042 ep
= iface
->endpoint
;
2043 vcf
= validconf
[small_match
];
2045 for (i
= 0; i
< iface
->desc
.bNumEndpoints
; i
++) {
2048 ep_addr
= ep
->desc
.bEndpointAddress
;
2049 /* get endpoint base */
2050 idx
= ((ep_addr
& 0x7f) - 1) * 2;
2053 f
= &hw
->fifos
[idx
& 7];
2055 /* init Endpoints */
2056 if (vcf
[idx
] == EP_NOP
|| vcf
[idx
] == EP_NUL
) {
2060 switch (ep
->desc
.bmAttributes
) {
2061 case USB_ENDPOINT_XFER_INT
:
2062 f
->pipe
= usb_rcvintpipe(dev
,
2063 ep
->desc
.bEndpointAddress
);
2064 f
->usb_transfer_mode
= USB_INT
;
2065 packet_size
= le16_to_cpu(ep
->desc
.wMaxPacketSize
);
2067 case USB_ENDPOINT_XFER_BULK
:
2069 f
->pipe
= usb_rcvbulkpipe(dev
,
2070 ep
->desc
.bEndpointAddress
);
2072 f
->pipe
= usb_sndbulkpipe(dev
,
2073 ep
->desc
.bEndpointAddress
);
2074 f
->usb_transfer_mode
= USB_BULK
;
2075 packet_size
= le16_to_cpu(ep
->desc
.wMaxPacketSize
);
2077 case USB_ENDPOINT_XFER_ISOC
:
2079 f
->pipe
= usb_rcvisocpipe(dev
,
2080 ep
->desc
.bEndpointAddress
);
2082 f
->pipe
= usb_sndisocpipe(dev
,
2083 ep
->desc
.bEndpointAddress
);
2084 f
->usb_transfer_mode
= USB_ISOC
;
2085 iso_packet_size
= le16_to_cpu(ep
->desc
.wMaxPacketSize
);
2092 f
->fifonum
= idx
& 7;
2094 f
->usb_packet_maxlen
=
2095 le16_to_cpu(ep
->desc
.wMaxPacketSize
);
2096 f
->intervall
= ep
->desc
.bInterval
;
2100 hw
->dev
= dev
; /* save device */
2101 hw
->if_used
= ifnum
; /* save used interface */
2102 hw
->alt_used
= alt_used
; /* and alternate config */
2103 hw
->ctrl_paksize
= dev
->descriptor
.bMaxPacketSize0
; /* control size */
2104 hw
->cfg_used
= vcf
[16]; /* store used config */
2105 hw
->vend_idx
= vend_idx
; /* store found vendor */
2106 hw
->packet_size
= packet_size
;
2107 hw
->iso_packet_size
= iso_packet_size
;
2109 /* create the control pipes needed for register access */
2110 hw
->ctrl_in_pipe
= usb_rcvctrlpipe(hw
->dev
, 0);
2111 hw
->ctrl_out_pipe
= usb_sndctrlpipe(hw
->dev
, 0);
2112 hw
->ctrl_urb
= usb_alloc_urb(0, GFP_KERNEL
);
2115 (struct hfcsusb_vdata
*)hfcsusb_idtab
[vend_idx
].driver_info
;
2116 printk(KERN_DEBUG
"%s: %s: detected \"%s\" (%s, if=%d alt=%d)\n",
2117 hw
->name
, __func__
, driver_info
->vend_name
,
2118 conf_str
[small_match
], ifnum
, alt_used
);
2120 if (setup_instance(hw
, dev
->dev
.parent
))
2124 usb_set_intfdata(hw
->intf
, hw
);
2128 /* function called when an active device is removed */
2130 hfcsusb_disconnect(struct usb_interface
*intf
)
2132 struct hfcsusb
*hw
= usb_get_intfdata(intf
);
2133 struct hfcsusb
*next
;
2136 printk(KERN_INFO
"%s: device disconnected\n", hw
->name
);
2138 handle_led(hw
, LED_POWER_OFF
);
2141 list_for_each_entry_safe(hw
, next
, &HFClist
, list
)
2146 usb_set_intfdata(intf
, NULL
);
2149 static struct usb_driver hfcsusb_drv
= {
2150 .name
= DRIVER_NAME
,
2151 .id_table
= hfcsusb_idtab
,
2152 .probe
= hfcsusb_probe
,
2153 .disconnect
= hfcsusb_disconnect
,
2159 printk(KERN_INFO DRIVER_NAME
" driver Rev. %s debug(0x%x) poll(%i)\n",
2160 hfcsusb_rev
, debug
, poll
);
2162 if (usb_register(&hfcsusb_drv
)) {
2163 printk(KERN_INFO DRIVER_NAME
2164 ": Unable to register hfcsusb module at usb stack\n");
2172 hfcsusb_cleanup(void)
2174 if (debug
& DBG_HFC_CALL_TRACE
)
2175 printk(KERN_INFO DRIVER_NAME
": %s\n", __func__
);
2177 /* unregister Hardware */
2178 usb_deregister(&hfcsusb_drv
); /* release our driver */
2181 module_init(hfcsusb_init
);
2182 module_exit(hfcsusb_cleanup
);