1 /* $Id: hycapi.c,v 1.8.6.4 2001/09/23 22:24:54 kai Exp $
3 * Linux driver for HYSDN cards, CAPI2.0-Interface.
5 * Author Ulrich Albrecht <u.albrecht@hypercope.de> for Hypercope GmbH
6 * Copyright 2000 by Hypercope GmbH
8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
13 #include <linux/module.h>
14 #include <linux/version.h>
15 #include <linux/signal.h>
16 #include <linux/kernel.h>
17 #include <linux/skbuff.h>
18 #include <linux/netdevice.h>
21 #define VER_CARDTYPE 1
29 #include "hysdn_defs.h"
30 #include <linux/kernelcapi.h>
32 static char hycapi_revision[]="$Revision: 1.8.6.4 $";
34 unsigned int hycapi_enable = 0xffffffff;
35 MODULE_PARM(hycapi_enable, "i");
37 typedef struct _hycapi_appl {
38 unsigned int ctrl_mask;
39 capi_register_params rp;
40 struct sk_buff *listen_req[CAPI_MAXCONTR];
43 static hycapi_appl hycapi_applications[CAPI_MAXAPPL];
45 static inline int _hycapi_appCheck(int app_id, int ctrl_no)
47 if((ctrl_no <= 0) || (ctrl_no > CAPI_MAXCONTR) || (app_id <= 0) ||
48 (app_id > CAPI_MAXAPPL))
50 printk(KERN_ERR "HYCAPI: Invalid request app_id %d for controller %d", app_id, ctrl_no);
53 return ((hycapi_applications[app_id-1].ctrl_mask & (1 << (ctrl_no-1))) != 0);
56 /******************************
57 Kernel-Capi callback reset_ctr
58 ******************************/
61 hycapi_reset_ctr(struct capi_ctr *ctrl)
63 hycapictrl_info *cinfo = ctrl->driverdata;
65 #ifdef HYCAPI_PRINTFNAMES
66 printk(KERN_NOTICE "HYCAPI hycapi_reset_ctr\n");
68 capilib_release(&cinfo->ncci_head);
69 capi_ctr_reseted(ctrl);
72 /******************************
73 Kernel-Capi callback remove_ctr
74 ******************************/
77 hycapi_remove_ctr(struct capi_ctr *ctrl)
80 hycapictrl_info *cinfo = NULL;
81 hysdn_card *card = NULL;
82 #ifdef HYCAPI_PRINTFNAMES
83 printk(KERN_NOTICE "HYCAPI hycapi_remove_ctr\n");
85 cinfo = (hycapictrl_info *)(ctrl->driverdata);
87 printk(KERN_ERR "No hycapictrl_info set!");
91 capi_ctr_suspend_output(ctrl);
92 for(i=0; i<CAPI_MAXAPPL;i++) {
93 if(hycapi_applications[i].listen_req[ctrl->cnr-1]) {
94 kfree_skb(hycapi_applications[i].listen_req[ctrl->cnr-1]);
95 hycapi_applications[i].listen_req[ctrl->cnr-1] = NULL;
98 detach_capi_ctr(ctrl);
100 kfree(card->hyctrlinfo);
103 card->hyctrlinfo = NULL;
106 /***********************************************************
108 Queue a CAPI-message to the controller.
110 ***********************************************************/
113 hycapi_sendmsg_internal(struct capi_ctr *ctrl, struct sk_buff *skb)
115 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
116 hysdn_card *card = cinfo->card;
118 spin_lock_irq(&cinfo->lock);
119 #ifdef HYCAPI_PRINTFNAMES
120 printk(KERN_NOTICE "hycapi_send_message\n");
122 cinfo->skbs[cinfo->in_idx++] = skb; /* add to buffer list */
123 if (cinfo->in_idx >= HYSDN_MAX_CAPI_SKB)
124 cinfo->in_idx = 0; /* wrap around */
125 cinfo->sk_count++; /* adjust counter */
126 if (cinfo->sk_count >= HYSDN_MAX_CAPI_SKB) {
127 /* inform upper layers we're full */
128 printk(KERN_ERR "HYSDN Card%d: CAPI-buffer overrun!\n",
130 capi_ctr_suspend_output(ctrl);
133 spin_unlock_irq(&cinfo->lock);
134 schedule_work(&card->irq_queue);
137 /***********************************************************
138 hycapi_register_internal
140 Send down the CAPI_REGISTER-Command to the controller.
141 This functions will also be used if the adapter has been rebooted to
142 re-register any applications in the private list.
144 ************************************************************/
147 hycapi_register_internal(struct capi_ctr *ctrl, __u16 appl,
148 capi_register_params *rp)
150 char ExtFeatureDefaults[] = "49 /0/0/0/0,*/1,*/2,*/3,*/4,*/5,*/6,*/7,*/8,*/9,*";
151 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
152 hysdn_card *card = cinfo->card;
155 __u8 _command = 0xa0, _subcommand = 0x80;
156 __u16 MessageNumber = 0x0000;
157 __u16 MessageBufferSize = 0;
158 int slen = strlen(ExtFeatureDefaults);
159 #ifdef HYCAPI_PRINTFNAMES
160 printk(KERN_NOTICE "hycapi_register_appl\n");
162 MessageBufferSize = rp->level3cnt * rp->datablkcnt * rp->datablklen;
164 len = CAPI_MSG_BASELEN + 8 + slen + 1;
165 if (!(skb = alloc_skb(len, GFP_ATOMIC))) {
166 printk(KERN_ERR "HYSDN card%d: memory squeeze in hycapi_register_appl\n",
170 memcpy(skb_put(skb,sizeof(__u16)), &len, sizeof(__u16));
171 memcpy(skb_put(skb,sizeof(__u16)), &appl, sizeof(__u16));
172 memcpy(skb_put(skb,sizeof(__u8)), &_command, sizeof(_command));
173 memcpy(skb_put(skb,sizeof(__u8)), &_subcommand, sizeof(_subcommand));
174 memcpy(skb_put(skb,sizeof(__u16)), &MessageNumber, sizeof(__u16));
175 memcpy(skb_put(skb,sizeof(__u16)), &MessageBufferSize, sizeof(__u16));
176 memcpy(skb_put(skb,sizeof(__u16)), &(rp->level3cnt), sizeof(__u16));
177 memcpy(skb_put(skb,sizeof(__u16)), &(rp->datablkcnt), sizeof(__u16));
178 memcpy(skb_put(skb,sizeof(__u16)), &(rp->datablklen), sizeof(__u16));
179 memcpy(skb_put(skb,slen), ExtFeatureDefaults, slen);
180 hycapi_applications[appl-1].ctrl_mask |= (1 << (ctrl->cnr-1));
181 hycapi_send_message(ctrl, skb);
184 /************************************************************
185 hycapi_restart_internal
187 After an adapter has been rebootet, re-register all applications and
188 send a LISTEN_REQ (if there has been such a thing )
190 *************************************************************/
192 static void hycapi_restart_internal(struct capi_ctr *ctrl)
196 #ifdef HYCAPI_PRINTFNAMES
197 printk(KERN_WARNING "HYSDN: hycapi_restart_internal");
199 for(i=0; i<CAPI_MAXAPPL; i++) {
200 if(_hycapi_appCheck(i+1, ctrl->cnr) == 1) {
201 hycapi_register_internal(ctrl, i+1,
202 &hycapi_applications[i].rp);
203 if(hycapi_applications[i].listen_req[ctrl->cnr-1]) {
204 skb = skb_copy(hycapi_applications[i].listen_req[ctrl->cnr-1], GFP_ATOMIC);
205 hycapi_sendmsg_internal(ctrl, skb);
211 /*************************************************************
212 Register an application.
213 Error-checking is done for CAPI-compliance.
215 The application is recorded in the internal list.
216 *************************************************************/
219 hycapi_register_appl(struct capi_ctr *ctrl, __u16 appl,
220 capi_register_params *rp)
222 int MaxLogicalConnections = 0, MaxBDataBlocks = 0, MaxBDataLen = 0;
223 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
224 hysdn_card *card = cinfo->card;
225 int chk = _hycapi_appCheck(appl, ctrl->cnr);
230 printk(KERN_INFO "HYSDN: apl %d already registered\n", appl);
233 MaxBDataBlocks = rp->datablkcnt > CAPI_MAXDATAWINDOW ? CAPI_MAXDATAWINDOW : rp->datablkcnt;
234 rp->datablkcnt = MaxBDataBlocks;
235 MaxBDataLen = rp->datablklen < 1024 ? 1024 : rp->datablklen ;
236 rp->datablklen = MaxBDataLen;
238 MaxLogicalConnections = rp->level3cnt;
239 if (MaxLogicalConnections < 0) {
240 MaxLogicalConnections = card->bchans * -MaxLogicalConnections;
242 if (MaxLogicalConnections == 0) {
243 MaxLogicalConnections = card->bchans;
246 rp->level3cnt = MaxLogicalConnections;
247 memcpy(&hycapi_applications[appl-1].rp,
248 rp, sizeof(capi_register_params));
250 /* MOD_INC_USE_COUNT; */
253 /*********************************************************************
255 hycapi_release_internal
257 Send down a CAPI_RELEASE to the controller.
258 *********************************************************************/
260 static void hycapi_release_internal(struct capi_ctr *ctrl, __u16 appl)
262 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
263 hysdn_card *card = cinfo->card;
266 __u8 _command = 0xa1, _subcommand = 0x80;
267 __u16 MessageNumber = 0x0000;
269 capilib_release_appl(&cinfo->ncci_head, appl);
271 #ifdef HYCAPI_PRINTFNAMES
272 printk(KERN_NOTICE "hycapi_release_appl\n");
274 len = CAPI_MSG_BASELEN;
275 if (!(skb = alloc_skb(len, GFP_ATOMIC))) {
276 printk(KERN_ERR "HYSDN card%d: memory squeeze in hycapi_register_appl\n",
280 memcpy(skb_put(skb,sizeof(__u16)), &len, sizeof(__u16));
281 memcpy(skb_put(skb,sizeof(__u16)), &appl, sizeof(__u16));
282 memcpy(skb_put(skb,sizeof(__u8)), &_command, sizeof(_command));
283 memcpy(skb_put(skb,sizeof(__u8)), &_subcommand, sizeof(_subcommand));
284 memcpy(skb_put(skb,sizeof(__u16)), &MessageNumber, sizeof(__u16));
285 hycapi_send_message(ctrl, skb);
286 hycapi_applications[appl-1].ctrl_mask &= ~(1 << (ctrl->cnr-1));
289 /******************************************************************
292 Release the application from the internal list an remove it's
293 registration at controller-level
294 ******************************************************************/
297 hycapi_release_appl(struct capi_ctr *ctrl, __u16 appl)
301 chk = _hycapi_appCheck(appl, ctrl->cnr);
303 printk(KERN_ERR "HYCAPI: Releasing invalid appl %d on controller %d\n", appl, ctrl->cnr);
306 if(hycapi_applications[appl-1].listen_req[ctrl->cnr-1]) {
307 kfree_skb(hycapi_applications[appl-1].listen_req[ctrl->cnr-1]);
308 hycapi_applications[appl-1].listen_req[ctrl->cnr-1] = NULL;
312 hycapi_release_internal(ctrl, appl);
314 /* MOD_DEC_USE_COUNT; */
318 /**************************************************************
319 Kill a single controller.
320 **************************************************************/
322 int hycapi_capi_release(hysdn_card *card)
324 hycapictrl_info *cinfo = card->hyctrlinfo;
325 struct capi_ctr *ctrl;
326 #ifdef HYCAPI_PRINTFNAMES
327 printk(KERN_NOTICE "hycapi_capi_release\n");
330 ctrl = &cinfo->capi_ctrl;
331 hycapi_remove_ctr(ctrl);
336 /**************************************************************
339 Stop CAPI-Output on a card. (e.g. during reboot)
340 ***************************************************************/
342 int hycapi_capi_stop(hysdn_card *card)
344 hycapictrl_info *cinfo = card->hyctrlinfo;
345 struct capi_ctr *ctrl;
346 #ifdef HYCAPI_PRINTFNAMES
347 printk(KERN_NOTICE "hycapi_capi_stop\n");
350 ctrl = &cinfo->capi_ctrl;
351 /* ctrl->suspend_output(ctrl); */
352 capi_ctr_reseted(ctrl);
357 /***************************************************************
360 Send a message to the controller.
362 Messages are parsed for their Command/Subcommand-type, and appropriate
363 action's are performed.
365 Note that we have to muck around with a 64Bit-DATA_REQ as there are
366 firmware-releases that do not check the MsgLen-Indication!
368 ***************************************************************/
370 u16 hycapi_send_message(struct capi_ctr *ctrl, struct sk_buff *skb)
375 hycapictrl_info *cinfo = ctrl->driverdata;
376 u16 retval = CAPI_NOERROR;
378 appl_id = CAPIMSG_APPID(skb->data);
379 switch(_hycapi_appCheck(appl_id, ctrl->cnr))
382 /* printk(KERN_INFO "Need to register\n"); */
383 hycapi_register_internal(ctrl,
385 &(hycapi_applications[appl_id-1].rp));
390 printk(KERN_ERR "HYCAPI: Controller mixup!\n");
391 retval = CAPI_ILLAPPNR;
394 switch(CAPIMSG_CMD(skb->data)) {
395 case CAPI_DISCONNECT_B3_RESP:
396 capilib_free_ncci(&cinfo->ncci_head, appl_id,
397 CAPIMSG_NCCI(skb->data));
399 case CAPI_DATA_B3_REQ:
400 _len = CAPIMSG_LEN(skb->data);
403 memcpy(msghead, skb->data, 22);
404 memcpy(skb->data + _len2, msghead, 22);
405 skb_pull(skb, _len2);
406 CAPIMSG_SETLEN(skb->data, 22);
407 retval = capilib_data_b3_req(&cinfo->ncci_head,
408 CAPIMSG_APPID(skb->data),
409 CAPIMSG_NCCI(skb->data),
410 CAPIMSG_MSGID(skb->data));
413 case CAPI_LISTEN_REQ:
414 if(hycapi_applications[appl_id-1].listen_req[ctrl->cnr-1])
416 kfree_skb(hycapi_applications[appl_id-1].listen_req[ctrl->cnr-1]);
417 hycapi_applications[appl_id-1].listen_req[ctrl->cnr-1] = NULL;
419 if (!(hycapi_applications[appl_id-1].listen_req[ctrl->cnr-1] = skb_copy(skb, GFP_ATOMIC)))
421 printk(KERN_ERR "HYSDN: memory squeeze in private_listen\n");
428 if (retval == CAPI_NOERROR)
429 hycapi_sendmsg_internal(ctrl, skb);
431 dev_kfree_skb_any(skb);
436 /*********************************************************************
439 Informations provided in the /proc/capi-entries.
441 *********************************************************************/
443 int hycapi_read_proc(char *page, char **start, off_t off,
444 int count, int *eof, struct capi_ctr *ctrl)
446 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
447 hysdn_card *card = cinfo->card;
450 #ifdef HYCAPI_PRINTFNAMES
451 printk(KERN_NOTICE "hycapi_read_proc\n");
453 len += sprintf(page+len, "%-16s %s\n", "name", cinfo->cardname);
454 len += sprintf(page+len, "%-16s 0x%x\n", "io", card->iobase);
455 len += sprintf(page+len, "%-16s %d\n", "irq", card->irq);
457 switch (card->brdtype) {
458 case BD_PCCARD: s = "HYSDN Hycard"; break;
459 case BD_ERGO: s = "HYSDN Ergo2"; break;
460 case BD_METRO: s = "HYSDN Metro4"; break;
461 case BD_CHAMP2: s = "HYSDN Champ2"; break;
462 case BD_PLEXUS: s = "HYSDN Plexus30"; break;
463 default: s = "???"; break;
465 len += sprintf(page+len, "%-16s %s\n", "type", s);
466 if ((s = cinfo->version[VER_DRIVER]) != 0)
467 len += sprintf(page+len, "%-16s %s\n", "ver_driver", s);
468 if ((s = cinfo->version[VER_CARDTYPE]) != 0)
469 len += sprintf(page+len, "%-16s %s\n", "ver_cardtype", s);
470 if ((s = cinfo->version[VER_SERIAL]) != 0)
471 len += sprintf(page+len, "%-16s %s\n", "ver_serial", s);
473 len += sprintf(page+len, "%-16s %s\n", "cardname", cinfo->cardname);
475 if (off+count >= len)
480 return ((count < len-off) ? count : len-off);
483 /**************************************************************
486 This does NOT load any firmware, but the callback somehow is needed
487 on capi-interface registration.
489 **************************************************************/
491 int hycapi_load_firmware(struct capi_ctr *ctrl, capiloaddata *data)
493 #ifdef HYCAPI_PRINTFNAMES
494 printk(KERN_NOTICE "hycapi_load_firmware\n");
500 char *hycapi_procinfo(struct capi_ctr *ctrl)
502 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
503 #ifdef HYCAPI_PRINTFNAMES
504 printk(KERN_NOTICE "hycapi_proc_info\n");
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,
515 return cinfo->infobuf;
518 /******************************************************************
521 Receive a capi-message.
523 All B3_DATA_IND are converted to 64K-extension compatible format.
524 New nccis are created if necessary.
525 *******************************************************************/
528 hycapi_rx_capipkt(hysdn_card * card, uchar * buf, word len)
531 hycapictrl_info *cinfo = card->hyctrlinfo;
532 struct capi_ctr *ctrl;
536 __u32 CP64[2] = {0,0};
537 #ifdef HYCAPI_PRINTFNAMES
538 printk(KERN_NOTICE "hycapi_rx_capipkt\n");
543 ctrl = &cinfo->capi_ctrl;
544 if(len < CAPI_MSG_BASELEN) {
545 printk(KERN_ERR "HYSDN Card%d: invalid CAPI-message, lenght %d!\n",
549 MsgLen = CAPIMSG_LEN(buf);
550 ApplId = CAPIMSG_APPID(buf);
551 CapiCmd = CAPIMSG_CMD(buf);
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",
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,
564 CAPIMSG_SETLEN(skb->data, 30);
566 if (!(skb = alloc_skb(len, GFP_ATOMIC))) {
567 printk(KERN_ERR "HYSDN Card%d: incoming packet dropped\n",
571 memcpy(skb_put(skb, len), buf, len);
573 switch(CAPIMSG_CMD(skb->data))
575 case CAPI_CONNECT_B3_CONF:
576 /* Check info-field for error-indication: */
577 info = CAPIMSG_U16(skb->data, 12);
581 capilib_new_ncci(&cinfo->ncci_head, ApplId, CAPIMSG_NCCI(skb->data),
582 hycapi_applications[ApplId-1].rp.datablkcnt);
586 printk(KERN_ERR "HYSDN Card%d: NCPI not supported by current "
587 "protocol. NCPI ignored.\n", card->myid);
590 printk(KERN_ERR "HYSDN Card%d: Message not supported in"
591 " current state\n", card->myid);
594 printk(KERN_ERR "HYSDN Card%d: invalid PLCI\n", card->myid);
597 printk(KERN_ERR "HYSDN Card%d: out of NCCI\n", card->myid);
600 printk(KERN_ERR "HYSDN Card%d: NCPI not supported\n",
604 printk(KERN_ERR "HYSDN Card%d: Info in CONNECT_B3_CONF: %d\n",
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);
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));
622 capi_ctr_handle_message(ctrl, ApplId, skb);
625 /******************************************************************
628 Internally acknowledge a msg sent. This will remove the msg from the
631 *******************************************************************/
633 void hycapi_tx_capiack(hysdn_card * card)
635 hycapictrl_info *cinfo = card->hyctrlinfo;
636 #ifdef HYCAPI_PRINTFNAMES
637 printk(KERN_NOTICE "hycapi_tx_capiack\n");
642 spin_lock_irq(&cinfo->lock);
643 kfree_skb(cinfo->skbs[cinfo->out_idx]); /* free skb */
644 cinfo->skbs[cinfo->out_idx++] = NULL;
645 if (cinfo->out_idx >= HYSDN_MAX_CAPI_SKB)
646 cinfo->out_idx = 0; /* wrap around */
648 if (cinfo->sk_count-- == HYSDN_MAX_CAPI_SKB) /* dec usage count */
649 capi_ctr_resume_output(&cinfo->capi_ctrl);
650 spin_unlock_irq(&cinfo->lock);
653 /***************************************************************
654 hycapi_tx_capiget(hysdn_card *card)
656 This is called when polling for messages to SEND.
658 ****************************************************************/
661 hycapi_tx_capiget(hysdn_card *card)
663 hycapictrl_info *cinfo = card->hyctrlinfo;
665 return (struct sk_buff *)NULL;
667 if (!cinfo->sk_count)
668 return (struct sk_buff *)NULL; /* nothing available */
670 return (cinfo->skbs[cinfo->out_idx]); /* next packet to send */
674 /**********************************************************
677 attach the capi-driver to the kernel-capi.
679 ***********************************************************/
684 for(i=0;i<CAPI_MAXAPPL;i++) {
685 memset(&(hycapi_applications[i]), 0, sizeof(hycapi_appl));
690 /**************************************************************
693 detach the capi-driver to the kernel-capi. Actually this should
694 free some more ressources. Do that later.
695 **************************************************************/
702 /********************************************************************
703 hycapi_capi_create(hysdn_card *card)
705 Attach the card with its capi-ctrl.
706 *********************************************************************/
708 static void hycapi_fill_profile(hysdn_card *card)
710 hycapictrl_info *cinfo = NULL;
711 struct capi_ctr *ctrl = NULL;
712 cinfo = card->hyctrlinfo;
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) |
730 ctrl->profile.support3 = B3_PROT_TRANSPARENT |
732 (card->faxchans ? B3_PROT_T30 : 0) |
733 (card->faxchans ? B3_PROT_T30EXT : 0) |
738 hycapi_capi_create(hysdn_card *card)
740 hycapictrl_info *cinfo = NULL;
741 struct capi_ctr *ctrl = NULL;
743 #ifdef HYCAPI_PRINTFNAMES
744 printk(KERN_NOTICE "hycapi_capi_create\n");
746 if((hycapi_enable & (1 << card->myid)) == 0) {
749 if (!card->hyctrlinfo) {
750 cinfo = (hycapictrl_info *) kmalloc(sizeof(hycapictrl_info), GFP_ATOMIC);
752 printk(KERN_WARNING "HYSDN: no memory for capi-ctrl.\n");
755 memset(cinfo, 0, sizeof(hycapictrl_info));
756 card->hyctrlinfo = cinfo;
758 spin_lock_init(&cinfo->lock);
759 INIT_LIST_HEAD(&cinfo->ncci_head);
761 switch (card->brdtype) {
762 case BD_PCCARD: strcpy(cinfo->cardname,"HYSDN Hycard"); break;
763 case BD_ERGO: strcpy(cinfo->cardname,"HYSDN Ergo2"); break;
764 case BD_METRO: strcpy(cinfo->cardname,"HYSDN Metro4"); break;
765 case BD_CHAMP2: strcpy(cinfo->cardname,"HYSDN Champ2"); break;
766 case BD_PLEXUS: strcpy(cinfo->cardname,"HYSDN Plexus30"); break;
767 default: strcpy(cinfo->cardname,"HYSDN ???"); break;
770 ctrl = &cinfo->capi_ctrl;
771 ctrl->driver_name = "hycapi";
772 ctrl->driverdata = cinfo;
773 ctrl->register_appl = hycapi_register_appl;
774 ctrl->release_appl = hycapi_release_appl;
775 ctrl->send_message = hycapi_send_message;
776 ctrl->load_firmware = hycapi_load_firmware;
777 ctrl->reset_ctr = hycapi_reset_ctr;
778 ctrl->procinfo = hycapi_procinfo;
779 ctrl->ctr_read_proc = hycapi_read_proc;
780 strcpy(ctrl->name, cinfo->cardname);
781 ctrl->owner = THIS_MODULE;
783 retval = attach_capi_ctr(ctrl);
785 printk(KERN_ERR "hycapi: attach controller failed.\n");
788 /* fill in the blanks: */
789 hycapi_fill_profile(card);
790 capi_ctr_ready(ctrl);
792 /* resume output on stopped ctrl */
793 ctrl = &card->hyctrlinfo->capi_ctrl;
794 hycapi_fill_profile(card);
795 capi_ctr_ready(ctrl);
796 hycapi_restart_internal(ctrl);
797 /* ctrl->resume_output(ctrl); */