1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/module.h>
14#include <linux/proc_fs.h>
15#include <linux/seq_file.h>
16#include <linux/signal.h>
17#include <linux/kernel.h>
18#include <linux/skbuff.h>
19#include <linux/netdevice.h>
20#include <linux/slab.h>
21
22#define VER_DRIVER 0
23#define VER_CARDTYPE 1
24#define VER_HWID 2
25#define VER_SERIAL 3
26#define VER_OPTION 4
27#define VER_PROTO 5
28#define VER_PROFILE 6
29#define VER_CAPI 7
30
31#include "hysdn_defs.h"
32#include <linux/kernelcapi.h>
33
34static char hycapi_revision[]="$Revision: 1.8.6.4 $";
35
36unsigned int hycapi_enable = 0xffffffff;
37module_param(hycapi_enable, uint, 0);
38
39typedef struct _hycapi_appl {
40 unsigned int ctrl_mask;
41 capi_register_params rp;
42 struct sk_buff *listen_req[CAPI_MAXCONTR];
43} hycapi_appl;
44
45static hycapi_appl hycapi_applications[CAPI_MAXAPPL];
46
47static u16 hycapi_send_message(struct capi_ctr *ctrl, struct sk_buff *skb);
48
49static inline int _hycapi_appCheck(int app_id, int ctrl_no)
50{
51 if((ctrl_no <= 0) || (ctrl_no > CAPI_MAXCONTR) || (app_id <= 0) ||
52 (app_id > CAPI_MAXAPPL))
53 {
54 printk(KERN_ERR "HYCAPI: Invalid request app_id %d for controller %d", app_id, ctrl_no);
55 return -1;
56 }
57 return ((hycapi_applications[app_id-1].ctrl_mask & (1 << (ctrl_no-1))) != 0);
58}
59
60
61
62
63
64static void
65hycapi_reset_ctr(struct capi_ctr *ctrl)
66{
67 hycapictrl_info *cinfo = ctrl->driverdata;
68
69#ifdef HYCAPI_PRINTFNAMES
70 printk(KERN_NOTICE "HYCAPI hycapi_reset_ctr\n");
71#endif
72 capilib_release(&cinfo->ncci_head);
73 capi_ctr_down(ctrl);
74}
75
76
77
78
79
80static void
81hycapi_remove_ctr(struct capi_ctr *ctrl)
82{
83 int i;
84 hycapictrl_info *cinfo = NULL;
85 hysdn_card *card = NULL;
86#ifdef HYCAPI_PRINTFNAMES
87 printk(KERN_NOTICE "HYCAPI hycapi_remove_ctr\n");
88#endif
89 cinfo = (hycapictrl_info *)(ctrl->driverdata);
90 if(!cinfo) {
91 printk(KERN_ERR "No hycapictrl_info set!");
92 return;
93 }
94 card = cinfo->card;
95 capi_ctr_suspend_output(ctrl);
96 for(i=0; i<CAPI_MAXAPPL;i++) {
97 if(hycapi_applications[i].listen_req[ctrl->cnr-1]) {
98 kfree_skb(hycapi_applications[i].listen_req[ctrl->cnr-1]);
99 hycapi_applications[i].listen_req[ctrl->cnr-1] = NULL;
100 }
101 }
102 detach_capi_ctr(ctrl);
103 ctrl->driverdata = NULL;
104 kfree(card->hyctrlinfo);
105
106
107 card->hyctrlinfo = NULL;
108}
109
110
111
112
113
114
115
116static void
117hycapi_sendmsg_internal(struct capi_ctr *ctrl, struct sk_buff *skb)
118{
119 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
120 hysdn_card *card = cinfo->card;
121
122 spin_lock_irq(&cinfo->lock);
123#ifdef HYCAPI_PRINTFNAMES
124 printk(KERN_NOTICE "hycapi_send_message\n");
125#endif
126 cinfo->skbs[cinfo->in_idx++] = skb;
127 if (cinfo->in_idx >= HYSDN_MAX_CAPI_SKB)
128 cinfo->in_idx = 0;
129 cinfo->sk_count++;
130 if (cinfo->sk_count >= HYSDN_MAX_CAPI_SKB) {
131
132 printk(KERN_ERR "HYSDN Card%d: CAPI-buffer overrun!\n",
133 card->myid);
134 capi_ctr_suspend_output(ctrl);
135 }
136 cinfo->tx_skb = skb;
137 spin_unlock_irq(&cinfo->lock);
138 schedule_work(&card->irq_queue);
139}
140
141
142
143
144
145
146
147
148
149
150static void
151hycapi_register_internal(struct capi_ctr *ctrl, __u16 appl,
152 capi_register_params *rp)
153{
154 char ExtFeatureDefaults[] = "49 /0/0/0/0,*/1,*/2,*/3,*/4,*/5,*/6,*/7,*/8,*/9,*";
155 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
156 hysdn_card *card = cinfo->card;
157 struct sk_buff *skb;
158 __u16 len;
159 __u8 _command = 0xa0, _subcommand = 0x80;
160 __u16 MessageNumber = 0x0000;
161 __u16 MessageBufferSize = 0;
162 int slen = strlen(ExtFeatureDefaults);
163#ifdef HYCAPI_PRINTFNAMES
164 printk(KERN_NOTICE "hycapi_register_appl\n");
165#endif
166 MessageBufferSize = rp->level3cnt * rp->datablkcnt * rp->datablklen;
167
168 len = CAPI_MSG_BASELEN + 8 + slen + 1;
169 if (!(skb = alloc_skb(len, GFP_ATOMIC))) {
170 printk(KERN_ERR "HYSDN card%d: memory squeeze in hycapi_register_appl\n",
171 card->myid);
172 return;
173 }
174 memcpy(skb_put(skb,sizeof(__u16)), &len, sizeof(__u16));
175 memcpy(skb_put(skb,sizeof(__u16)), &appl, sizeof(__u16));
176 memcpy(skb_put(skb,sizeof(__u8)), &_command, sizeof(_command));
177 memcpy(skb_put(skb,sizeof(__u8)), &_subcommand, sizeof(_subcommand));
178 memcpy(skb_put(skb,sizeof(__u16)), &MessageNumber, sizeof(__u16));
179 memcpy(skb_put(skb,sizeof(__u16)), &MessageBufferSize, sizeof(__u16));
180 memcpy(skb_put(skb,sizeof(__u16)), &(rp->level3cnt), sizeof(__u16));
181 memcpy(skb_put(skb,sizeof(__u16)), &(rp->datablkcnt), sizeof(__u16));
182 memcpy(skb_put(skb,sizeof(__u16)), &(rp->datablklen), sizeof(__u16));
183 memcpy(skb_put(skb,slen), ExtFeatureDefaults, slen);
184 hycapi_applications[appl-1].ctrl_mask |= (1 << (ctrl->cnr-1));
185 hycapi_send_message(ctrl, skb);
186}
187
188
189
190
191
192
193
194
195
196static void hycapi_restart_internal(struct capi_ctr *ctrl)
197{
198 int i;
199 struct sk_buff *skb;
200#ifdef HYCAPI_PRINTFNAMES
201 printk(KERN_WARNING "HYSDN: hycapi_restart_internal");
202#endif
203 for(i=0; i<CAPI_MAXAPPL; i++) {
204 if(_hycapi_appCheck(i+1, ctrl->cnr) == 1) {
205 hycapi_register_internal(ctrl, i+1,
206 &hycapi_applications[i].rp);
207 if(hycapi_applications[i].listen_req[ctrl->cnr-1]) {
208 skb = skb_copy(hycapi_applications[i].listen_req[ctrl->cnr-1], GFP_ATOMIC);
209 hycapi_sendmsg_internal(ctrl, skb);
210 }
211 }
212 }
213}
214
215
216
217
218
219
220
221
222static void
223hycapi_register_appl(struct capi_ctr *ctrl, __u16 appl,
224 capi_register_params *rp)
225{
226 int MaxLogicalConnections = 0, MaxBDataBlocks = 0, MaxBDataLen = 0;
227 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
228 hysdn_card *card = cinfo->card;
229 int chk = _hycapi_appCheck(appl, ctrl->cnr);
230 if(chk < 0) {
231 return;
232 }
233 if(chk == 1) {
234 printk(KERN_INFO "HYSDN: apl %d already registered\n", appl);
235 return;
236 }
237 MaxBDataBlocks = rp->datablkcnt > CAPI_MAXDATAWINDOW ? CAPI_MAXDATAWINDOW : rp->datablkcnt;
238 rp->datablkcnt = MaxBDataBlocks;
239 MaxBDataLen = rp->datablklen < 1024 ? 1024 : rp->datablklen ;
240 rp->datablklen = MaxBDataLen;
241
242 MaxLogicalConnections = rp->level3cnt;
243 if (MaxLogicalConnections < 0) {
244 MaxLogicalConnections = card->bchans * -MaxLogicalConnections;
245 }
246 if (MaxLogicalConnections == 0) {
247 MaxLogicalConnections = card->bchans;
248 }
249
250 rp->level3cnt = MaxLogicalConnections;
251 memcpy(&hycapi_applications[appl-1].rp,
252 rp, sizeof(capi_register_params));
253}
254
255
256
257
258
259
260
261
262static void hycapi_release_internal(struct capi_ctr *ctrl, __u16 appl)
263{
264 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
265 hysdn_card *card = cinfo->card;
266 struct sk_buff *skb;
267 __u16 len;
268 __u8 _command = 0xa1, _subcommand = 0x80;
269 __u16 MessageNumber = 0x0000;
270
271 capilib_release_appl(&cinfo->ncci_head, appl);
272
273#ifdef HYCAPI_PRINTFNAMES
274 printk(KERN_NOTICE "hycapi_release_appl\n");
275#endif
276 len = CAPI_MSG_BASELEN;
277 if (!(skb = alloc_skb(len, GFP_ATOMIC))) {
278 printk(KERN_ERR "HYSDN card%d: memory squeeze in hycapi_register_appl\n",
279 card->myid);
280 return;
281 }
282 memcpy(skb_put(skb,sizeof(__u16)), &len, sizeof(__u16));
283 memcpy(skb_put(skb,sizeof(__u16)), &appl, sizeof(__u16));
284 memcpy(skb_put(skb,sizeof(__u8)), &_command, sizeof(_command));
285 memcpy(skb_put(skb,sizeof(__u8)), &_subcommand, sizeof(_subcommand));
286 memcpy(skb_put(skb,sizeof(__u16)), &MessageNumber, sizeof(__u16));
287 hycapi_send_message(ctrl, skb);
288 hycapi_applications[appl-1].ctrl_mask &= ~(1 << (ctrl->cnr-1));
289}
290
291
292
293
294
295
296
297
298static void
299hycapi_release_appl(struct capi_ctr *ctrl, __u16 appl)
300{
301 int chk;
302
303 chk = _hycapi_appCheck(appl, ctrl->cnr);
304 if(chk<0) {
305 printk(KERN_ERR "HYCAPI: Releasing invalid appl %d on controller %d\n", appl, ctrl->cnr);
306 return;
307 }
308 if(hycapi_applications[appl-1].listen_req[ctrl->cnr-1]) {
309 kfree_skb(hycapi_applications[appl-1].listen_req[ctrl->cnr-1]);
310 hycapi_applications[appl-1].listen_req[ctrl->cnr-1] = NULL;
311 }
312 if(chk == 1)
313 {
314 hycapi_release_internal(ctrl, appl);
315 }
316}
317
318
319
320
321
322
323int hycapi_capi_release(hysdn_card *card)
324{
325 hycapictrl_info *cinfo = card->hyctrlinfo;
326 struct capi_ctr *ctrl;
327#ifdef HYCAPI_PRINTFNAMES
328 printk(KERN_NOTICE "hycapi_capi_release\n");
329#endif
330 if(cinfo) {
331 ctrl = &cinfo->capi_ctrl;
332 hycapi_remove_ctr(ctrl);
333 }
334 return 0;
335}
336
337
338
339
340
341
342
343int hycapi_capi_stop(hysdn_card *card)
344{
345 hycapictrl_info *cinfo = card->hyctrlinfo;
346 struct capi_ctr *ctrl;
347#ifdef HYCAPI_PRINTFNAMES
348 printk(KERN_NOTICE "hycapi_capi_stop\n");
349#endif
350 if(cinfo) {
351 ctrl = &cinfo->capi_ctrl;
352
353 capi_ctr_down(ctrl);
354 }
355 return 0;
356}
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371static u16 hycapi_send_message(struct capi_ctr *ctrl, struct sk_buff *skb)
372{
373 __u16 appl_id;
374 int _len, _len2;
375 __u8 msghead[64];
376 hycapictrl_info *cinfo = ctrl->driverdata;
377 u16 retval = CAPI_NOERROR;
378
379 appl_id = CAPIMSG_APPID(skb->data);
380 switch(_hycapi_appCheck(appl_id, ctrl->cnr))
381 {
382 case 0:
383
384 hycapi_register_internal(ctrl,
385 appl_id,
386 &(hycapi_applications[appl_id-1].rp));
387 break;
388 case 1:
389 break;
390 default:
391 printk(KERN_ERR "HYCAPI: Controller mixup!\n");
392 retval = CAPI_ILLAPPNR;
393 goto out;
394 }
395 switch(CAPIMSG_CMD(skb->data)) {
396 case CAPI_DISCONNECT_B3_RESP:
397 capilib_free_ncci(&cinfo->ncci_head, appl_id,
398 CAPIMSG_NCCI(skb->data));
399 break;
400 case CAPI_DATA_B3_REQ:
401 _len = CAPIMSG_LEN(skb->data);
402 if (_len > 22) {
403 _len2 = _len - 22;
404 skb_copy_from_linear_data(skb, msghead, 22);
405 skb_copy_to_linear_data_offset(skb, _len2,
406 msghead, 22);
407 skb_pull(skb, _len2);
408 CAPIMSG_SETLEN(skb->data, 22);
409 retval = capilib_data_b3_req(&cinfo->ncci_head,
410 CAPIMSG_APPID(skb->data),
411 CAPIMSG_NCCI(skb->data),
412 CAPIMSG_MSGID(skb->data));
413 }
414 break;
415 case CAPI_LISTEN_REQ:
416 if(hycapi_applications[appl_id-1].listen_req[ctrl->cnr-1])
417 {
418 kfree_skb(hycapi_applications[appl_id-1].listen_req[ctrl->cnr-1]);
419 hycapi_applications[appl_id-1].listen_req[ctrl->cnr-1] = NULL;
420 }
421 if (!(hycapi_applications[appl_id-1].listen_req[ctrl->cnr-1] = skb_copy(skb, GFP_ATOMIC)))
422 {
423 printk(KERN_ERR "HYSDN: memory squeeze in private_listen\n");
424 }
425 break;
426 default:
427 break;
428 }
429 out:
430 if (retval == CAPI_NOERROR)
431 hycapi_sendmsg_internal(ctrl, skb);
432 else
433 dev_kfree_skb_any(skb);
434
435 return retval;
436}
437
438static int hycapi_proc_show(struct seq_file *m, void *v)
439{
440 struct capi_ctr *ctrl = m->private;
441 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
442 hysdn_card *card = cinfo->card;
443 char *s;
444
445 seq_printf(m, "%-16s %s\n", "name", cinfo->cardname);
446 seq_printf(m, "%-16s 0x%x\n", "io", card->iobase);
447 seq_printf(m, "%-16s %d\n", "irq", card->irq);
448
449 switch (card->brdtype) {
450 case BD_PCCARD: s = "HYSDN Hycard"; break;
451 case BD_ERGO: s = "HYSDN Ergo2"; break;
452 case BD_METRO: s = "HYSDN Metro4"; break;
453 case BD_CHAMP2: s = "HYSDN Champ2"; break;
454 case BD_PLEXUS: s = "HYSDN Plexus30"; break;
455 default: s = "???"; break;
456 }
457 seq_printf(m, "%-16s %s\n", "type", s);
458 if ((s = cinfo->version[VER_DRIVER]) != NULL)
459 seq_printf(m, "%-16s %s\n", "ver_driver", s);
460 if ((s = cinfo->version[VER_CARDTYPE]) != NULL)
461 seq_printf(m, "%-16s %s\n", "ver_cardtype", s);
462 if ((s = cinfo->version[VER_SERIAL]) != NULL)
463 seq_printf(m, "%-16s %s\n", "ver_serial", s);
464
465 seq_printf(m, "%-16s %s\n", "cardname", cinfo->cardname);
466
467 return 0;
468}
469
470static int hycapi_proc_open(struct inode *inode, struct file *file)
471{
472 return single_open(file, hycapi_proc_show, PDE(inode)->data);
473}
474
475static const struct file_operations hycapi_proc_fops = {
476 .owner = THIS_MODULE,
477 .open = hycapi_proc_open,
478 .read = seq_read,
479 .llseek = seq_lseek,
480 .release = single_release,
481};
482
483
484
485
486
487
488
489
490
491static int hycapi_load_firmware(struct capi_ctr *ctrl, capiloaddata *data)
492{
493#ifdef HYCAPI_PRINTFNAMES
494 printk(KERN_NOTICE "hycapi_load_firmware\n");
495#endif
496 return 0;
497}
498
499
500static char *hycapi_procinfo(struct capi_ctr *ctrl)
501{
502 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
503#ifdef HYCAPI_PRINTFNAMES
504 printk(KERN_NOTICE "hycapi_proc_info\n");
505#endif
506 if (!cinfo)
507 return "";
508 sprintf(cinfo->infobuf, "%s %s 0x%x %d %s",
509 cinfo->cardname[0] ? cinfo->cardname : "-",
510 cinfo->version[VER_DRIVER] ? cinfo->version[VER_DRIVER] : "-",
511 cinfo->card ? cinfo->card->iobase : 0x0,
512 cinfo->card ? cinfo->card->irq : 0,
513 hycapi_revision
514 );
515 return cinfo->infobuf;
516}
517
518
519
520
521
522
523
524
525
526
527void
528hycapi_rx_capipkt(hysdn_card * card, unsigned char *buf, unsigned short len)
529{
530 struct sk_buff *skb;
531 hycapictrl_info *cinfo = card->hyctrlinfo;
532 struct capi_ctr *ctrl;
533 __u16 ApplId;
534 __u16 MsgLen, info;
535 __u16 len2, CapiCmd;
536 __u32 CP64[2] = {0,0};
537#ifdef HYCAPI_PRINTFNAMES
538 printk(KERN_NOTICE "hycapi_rx_capipkt\n");
539#endif
540 if(!cinfo) {
541 return;
542 }
543 ctrl = &cinfo->capi_ctrl;
544 if(len < CAPI_MSG_BASELEN) {
545 printk(KERN_ERR "HYSDN Card%d: invalid CAPI-message, length %d!\n",
546 card->myid, len);
547 return;
548 }
549 MsgLen = CAPIMSG_LEN(buf);
550 ApplId = CAPIMSG_APPID(buf);
551 CapiCmd = CAPIMSG_CMD(buf);
552
553 if((CapiCmd == CAPI_DATA_B3_IND) && (MsgLen < 30)) {
554 len2 = len + (30 - MsgLen);
555 if (!(skb = alloc_skb(len2, GFP_ATOMIC))) {
556 printk(KERN_ERR "HYSDN Card%d: incoming packet dropped\n",
557 card->myid);
558 return;
559 }
560 memcpy(skb_put(skb, MsgLen), buf, MsgLen);
561 memcpy(skb_put(skb, 2*sizeof(__u32)), CP64, 2* sizeof(__u32));
562 memcpy(skb_put(skb, len - MsgLen), buf + MsgLen,
563 len - MsgLen);
564 CAPIMSG_SETLEN(skb->data, 30);
565 } else {
566 if (!(skb = alloc_skb(len, GFP_ATOMIC))) {
567 printk(KERN_ERR "HYSDN Card%d: incoming packet dropped\n",
568 card->myid);
569 return;
570 }
571 memcpy(skb_put(skb, len), buf, len);
572 }
573 switch(CAPIMSG_CMD(skb->data))
574 {
575 case CAPI_CONNECT_B3_CONF:
576
577 info = CAPIMSG_U16(skb->data, 12);
578 switch(info)
579 {
580 case 0:
581 capilib_new_ncci(&cinfo->ncci_head, ApplId, CAPIMSG_NCCI(skb->data),
582 hycapi_applications[ApplId-1].rp.datablkcnt);
583
584 break;
585 case 0x0001:
586 printk(KERN_ERR "HYSDN Card%d: NCPI not supported by current "
587 "protocol. NCPI ignored.\n", card->myid);
588 break;
589 case 0x2001:
590 printk(KERN_ERR "HYSDN Card%d: Message not supported in"
591 " current state\n", card->myid);
592 break;
593 case 0x2002:
594 printk(KERN_ERR "HYSDN Card%d: invalid PLCI\n", card->myid);
595 break;
596 case 0x2004:
597 printk(KERN_ERR "HYSDN Card%d: out of NCCI\n", card->myid);
598 break;
599 case 0x3008:
600 printk(KERN_ERR "HYSDN Card%d: NCPI not supported\n",
601 card->myid);
602 break;
603 default:
604 printk(KERN_ERR "HYSDN Card%d: Info in CONNECT_B3_CONF: %d\n",
605 card->myid, info);
606 break;
607 }
608 break;
609 case CAPI_CONNECT_B3_IND:
610 capilib_new_ncci(&cinfo->ncci_head, ApplId,
611 CAPIMSG_NCCI(skb->data),
612 hycapi_applications[ApplId-1].rp.datablkcnt);
613 break;
614 case CAPI_DATA_B3_CONF:
615 capilib_data_b3_conf(&cinfo->ncci_head, ApplId,
616 CAPIMSG_NCCI(skb->data),
617 CAPIMSG_MSGID(skb->data));
618 break;
619 default:
620 break;
621 }
622 capi_ctr_handle_message(ctrl, ApplId, skb);
623}
624
625
626
627
628
629
630
631
632
633void hycapi_tx_capiack(hysdn_card * card)
634{
635 hycapictrl_info *cinfo = card->hyctrlinfo;
636#ifdef HYCAPI_PRINTFNAMES
637 printk(KERN_NOTICE "hycapi_tx_capiack\n");
638#endif
639 if(!cinfo) {
640 return;
641 }
642 spin_lock_irq(&cinfo->lock);
643 kfree_skb(cinfo->skbs[cinfo->out_idx]);
644 cinfo->skbs[cinfo->out_idx++] = NULL;
645 if (cinfo->out_idx >= HYSDN_MAX_CAPI_SKB)
646 cinfo->out_idx = 0;
647
648 if (cinfo->sk_count-- == HYSDN_MAX_CAPI_SKB)
649 capi_ctr_resume_output(&cinfo->capi_ctrl);
650 spin_unlock_irq(&cinfo->lock);
651}
652
653
654
655
656
657
658
659
660struct sk_buff *
661hycapi_tx_capiget(hysdn_card *card)
662{
663 hycapictrl_info *cinfo = card->hyctrlinfo;
664 if(!cinfo) {
665 return (struct sk_buff *)NULL;
666 }
667 if (!cinfo->sk_count)
668 return (struct sk_buff *)NULL;
669
670 return (cinfo->skbs[cinfo->out_idx]);
671}
672
673
674
675
676
677
678
679
680
681int hycapi_init(void)
682{
683 int i;
684 for(i=0;i<CAPI_MAXAPPL;i++) {
685 memset(&(hycapi_applications[i]), 0, sizeof(hycapi_appl));
686 }
687 return(0);
688}
689
690
691
692
693
694
695
696
697void
698hycapi_cleanup(void)
699{
700}
701
702
703
704
705
706
707
708static void hycapi_fill_profile(hysdn_card *card)
709{
710 hycapictrl_info *cinfo = NULL;
711 struct capi_ctr *ctrl = NULL;
712 cinfo = card->hyctrlinfo;
713 if(!cinfo) return;
714 ctrl = &cinfo->capi_ctrl;
715 strcpy(ctrl->manu, "Hypercope");
716 ctrl->version.majorversion = 2;
717 ctrl->version.minorversion = 0;
718 ctrl->version.majormanuversion = 3;
719 ctrl->version.minormanuversion = 2;
720 ctrl->profile.ncontroller = card->myid;
721 ctrl->profile.nbchannel = card->bchans;
722 ctrl->profile.goptions = GLOBAL_OPTION_INTERNAL_CONTROLLER |
723 GLOBAL_OPTION_B_CHANNEL_OPERATION;
724 ctrl->profile.support1 = B1_PROT_64KBIT_HDLC |
725 (card->faxchans ? B1_PROT_T30 : 0) |
726 B1_PROT_64KBIT_TRANSPARENT;
727 ctrl->profile.support2 = B2_PROT_ISO7776 |
728 (card->faxchans ? B2_PROT_T30 : 0) |
729 B2_PROT_TRANSPARENT;
730 ctrl->profile.support3 = B3_PROT_TRANSPARENT |
731 B3_PROT_T90NL |
732 (card->faxchans ? B3_PROT_T30 : 0) |
733 (card->faxchans ? B3_PROT_T30EXT : 0) |
734 B3_PROT_ISO8208;
735}
736
737int
738hycapi_capi_create(hysdn_card *card)
739{
740 hycapictrl_info *cinfo = NULL;
741 struct capi_ctr *ctrl = NULL;
742 int retval;
743#ifdef HYCAPI_PRINTFNAMES
744 printk(KERN_NOTICE "hycapi_capi_create\n");
745#endif
746 if((hycapi_enable & (1 << card->myid)) == 0) {
747 return 1;
748 }
749 if (!card->hyctrlinfo) {
750 cinfo = kzalloc(sizeof(hycapictrl_info), GFP_ATOMIC);
751 if (!cinfo) {
752 printk(KERN_WARNING "HYSDN: no memory for capi-ctrl.\n");
753 return -ENOMEM;
754 }
755 card->hyctrlinfo = cinfo;
756 cinfo->card = card;
757 spin_lock_init(&cinfo->lock);
758 INIT_LIST_HEAD(&cinfo->ncci_head);
759
760 switch (card->brdtype) {
761 case BD_PCCARD: strcpy(cinfo->cardname,"HYSDN Hycard"); break;
762 case BD_ERGO: strcpy(cinfo->cardname,"HYSDN Ergo2"); break;
763 case BD_METRO: strcpy(cinfo->cardname,"HYSDN Metro4"); break;
764 case BD_CHAMP2: strcpy(cinfo->cardname,"HYSDN Champ2"); break;
765 case BD_PLEXUS: strcpy(cinfo->cardname,"HYSDN Plexus30"); break;
766 default: strcpy(cinfo->cardname,"HYSDN ???"); break;
767 }
768
769 ctrl = &cinfo->capi_ctrl;
770 ctrl->driver_name = "hycapi";
771 ctrl->driverdata = cinfo;
772 ctrl->register_appl = hycapi_register_appl;
773 ctrl->release_appl = hycapi_release_appl;
774 ctrl->send_message = hycapi_send_message;
775 ctrl->load_firmware = hycapi_load_firmware;
776 ctrl->reset_ctr = hycapi_reset_ctr;
777 ctrl->procinfo = hycapi_procinfo;
778 ctrl->proc_fops = &hycapi_proc_fops;
779 strcpy(ctrl->name, cinfo->cardname);
780 ctrl->owner = THIS_MODULE;
781
782 retval = attach_capi_ctr(ctrl);
783 if (retval) {
784 printk(KERN_ERR "hycapi: attach controller failed.\n");
785 return -EBUSY;
786 }
787
788 hycapi_fill_profile(card);
789 capi_ctr_ready(ctrl);
790 } else {
791
792 ctrl = &card->hyctrlinfo->capi_ctrl;
793 hycapi_fill_profile(card);
794 capi_ctr_ready(ctrl);
795 hycapi_restart_internal(ctrl);
796
797 }
798 return 0;
799}
800
