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