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