1 /* $Id: hycapi.c,v 1.1.4.1 2001/11/20 14:19:37 kai Exp $
2 *
3 * Linux driver for HYSDN cards, CAPI2.0-Interface.
4 *
5 * Author Ulrich Albrecht <u.albrecht@hypercope.de> for Hypercope GmbH
6 * Copyright 2000 by Hypercope GmbH
7 *
8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
10 *
11 */
12
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
19
20 #define VER_DRIVER 0
21 #define VER_CARDTYPE 1
22 #define VER_HWID 2
23 #define VER_SERIAL 3
24 #define VER_OPTION 4
25 #define VER_PROTO 5
26 #define VER_PROFILE 6
27 #define VER_CAPI 7
28
29 #include "hysdn_defs.h"
30 #include <linux/kernelcapi.h>
31
32 static char hycapi_revision[]="$Revision: 1.1.4.1 $";
33
34 unsigned int hycapi_enable = 0xffffffff;
35 MODULE_PARM(hycapi_enable, "i");
36
37 typedef struct _hycapi_appl {
38 unsigned int ctrl_mask;
39 capi_register_params rp;
40 struct sk_buff *listen_req[CAPI_MAXCONTR];
41 } hycapi_appl;
42
43 static hycapi_appl hycapi_applications[CAPI_MAXAPPL];
44
_hycapi_appCheck(int app_id,int ctrl_no)45 static inline int _hycapi_appCheck(int app_id, int ctrl_no)
46 {
47 if((ctrl_no <= 0) || (ctrl_no > CAPI_MAXCONTR) || (app_id <= 0) ||
48 (app_id > CAPI_MAXAPPL))
49 {
50 printk(KERN_ERR "HYCAPI: Invalid request app_id %d for controller %d", app_id, ctrl_no);
51 return -1;
52 }
53 return ((hycapi_applications[app_id-1].ctrl_mask & (1 << (ctrl_no-1))) != 0);
54 }
55
56 struct capi_driver_interface *hy_di = NULL;
57
58 /******************************
59 Kernel-Capi callback reset_ctr
60 ******************************/
61
62 void
hycapi_reset_ctr(struct capi_ctr * ctrl)63 hycapi_reset_ctr(struct capi_ctr *ctrl)
64 {
65 #ifdef HYCAPI_PRINTFNAMES
66 printk(KERN_NOTICE "HYCAPI hycapi_reset_ctr\n");
67 #endif
68 ctrl->reseted(ctrl);
69 }
70
71 /******************************
72 Kernel-Capi callback remove_ctr
73 ******************************/
74
75 void
hycapi_remove_ctr(struct capi_ctr * ctrl)76 hycapi_remove_ctr(struct capi_ctr *ctrl)
77 {
78 int i;
79 hycapictrl_info *cinfo = NULL;
80 hysdn_card *card = NULL;
81 #ifdef HYCAPI_PRINTFNAMES
82 printk(KERN_NOTICE "HYCAPI hycapi_remove_ctr\n");
83 #endif
84 if(!hy_di) {
85 printk(KERN_ERR "No capi_driver_interface set!");
86 return;
87 }
88 cinfo = (hycapictrl_info *)(ctrl->driverdata);
89 if(!cinfo) {
90 printk(KERN_ERR "No hycapictrl_info set!");
91 return;
92 }
93 card = cinfo->card;
94 ctrl->suspend_output(ctrl);
95 for(i=0; i<CAPI_MAXAPPL;i++) {
96 if(hycapi_applications[i].listen_req[ctrl->cnr-1]) {
97 kfree_skb(hycapi_applications[i].listen_req[ctrl->cnr-1]);
98 hycapi_applications[i].listen_req[ctrl->cnr-1] = NULL;
99 }
100 }
101 hy_di->detach_ctr(ctrl);
102 ctrl->driverdata = 0;
103 kfree(card->hyctrlinfo);
104
105
106 card->hyctrlinfo = NULL;
107 }
108
109 /***********************************************************
110
111 Queue a CAPI-message to the controller.
112
113 ***********************************************************/
114
115 static void
hycapi_sendmsg_internal(struct capi_ctr * ctrl,struct sk_buff * skb)116 hycapi_sendmsg_internal(struct capi_ctr *ctrl, struct sk_buff *skb)
117 {
118 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
119 hysdn_card *card = cinfo->card;
120
121 spin_lock_irq(&cinfo->lock);
122 #ifdef HYCAPI_PRINTFNAMES
123 printk(KERN_NOTICE "hycapi_send_message\n");
124 #endif
125 cinfo->skbs[cinfo->in_idx++] = skb; /* add to buffer list */
126 if (cinfo->in_idx >= HYSDN_MAX_CAPI_SKB)
127 cinfo->in_idx = 0; /* wrap around */
128 cinfo->sk_count++; /* adjust counter */
129 if (cinfo->sk_count >= HYSDN_MAX_CAPI_SKB) {
130 /* inform upper layers we're full */
131 printk(KERN_ERR "HYSDN Card%d: CAPI-buffer overrun!\n",
132 card->myid);
133 ctrl->suspend_output(ctrl);
134 }
135 cinfo->tx_skb = skb;
136 spin_unlock_irq(&cinfo->lock);
137 queue_task(&card->irq_queue, &tq_immediate);
138 mark_bh(IMMEDIATE_BH);
139 }
140
141 /***********************************************************
142 hycapi_register_internal
143
144 Send down the CAPI_REGISTER-Command to the controller.
145 This functions will also be used if the adapter has been rebooted to
146 re-register any applications in the private list.
147
148 ************************************************************/
149
150 static void
hycapi_register_internal(struct capi_ctr * ctrl,__u16 appl,capi_register_params * rp)151 hycapi_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 hycapi_restart_internal
190
191 After an adapter has been rebootet, re-register all applications and
192 send a LISTEN_REQ (if there has been such a thing )
193
194 *************************************************************/
195
hycapi_restart_internal(struct capi_ctr * ctrl)196 static 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 Register an application.
217 Error-checking is done for CAPI-compliance.
218
219 The application is recorded in the internal list.
220 *************************************************************/
221
222 void
hycapi_register_appl(struct capi_ctr * ctrl,__u16 appl,capi_register_params * rp)223 hycapi_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 allready 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 /* MOD_INC_USE_COUNT; */
255 ctrl->appl_registered(ctrl, appl);
256 }
257
258 /*********************************************************************
259
260 hycapi_release_internal
261
262 Send down a CAPI_RELEASE to the controller.
263 *********************************************************************/
264
hycapi_release_internal(struct capi_ctr * ctrl,__u16 appl)265 static void hycapi_release_internal(struct capi_ctr *ctrl, __u16 appl)
266 {
267 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
268 hysdn_card *card = cinfo->card;
269 struct sk_buff *skb;
270 __u16 len;
271 __u8 _command = 0xa1, _subcommand = 0x80;
272 __u16 MessageNumber = 0x0000;
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 hycapi_release_appl
293
294 Release the application from the internal list an remove it's
295 registration at controller-level
296 ******************************************************************/
297
298 void
hycapi_release_appl(struct capi_ctr * ctrl,__u16 appl)299 hycapi_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 ctrl->appl_released(ctrl, appl);
317 /* MOD_DEC_USE_COUNT; */
318 }
319
320
321 /**************************************************************
322 Kill a single controller.
323 **************************************************************/
324
hycapi_capi_release(hysdn_card * card)325 int hycapi_capi_release(hysdn_card *card)
326 {
327 hycapictrl_info *cinfo = card->hyctrlinfo;
328 struct capi_ctr *ctrl;
329 #ifdef HYCAPI_PRINTFNAMES
330 printk(KERN_NOTICE "hycapi_capi_release\n");
331 #endif
332 if(cinfo) {
333 ctrl = cinfo->capi_ctrl;
334 hycapi_remove_ctr(ctrl);
335 }
336 return 0;
337 }
338
339 /**************************************************************
340 hycapi_capi_stop
341
342 Stop CAPI-Output on a card. (e.g. during reboot)
343 ***************************************************************/
344
hycapi_capi_stop(hysdn_card * card)345 int hycapi_capi_stop(hysdn_card *card)
346 {
347 hycapictrl_info *cinfo = card->hyctrlinfo;
348 struct capi_ctr *ctrl;
349 #ifdef HYCAPI_PRINTFNAMES
350 printk(KERN_NOTICE "hycapi_capi_stop\n");
351 #endif
352 if(cinfo) {
353 if(cinfo->capi_ctrl) {
354 ctrl = cinfo->capi_ctrl;
355 /* ctrl->suspend_output(ctrl); */
356 ctrl->reseted(ctrl);
357
358 } else {
359 printk(KERN_NOTICE "hycapi_capi_stop: cinfo but no capi_ctrl\n");
360 }
361 }
362 return 0;
363 }
364
365 /***************************************************************
366 hycapi_send_message
367
368 Send a message to the controller.
369
370 Messages are parsed for their Command/Subcommand-type, and appropriate
371 action's are performed.
372
373 Note that we have to muck around with a 64Bit-DATA_REQ as there are
374 firmware-releases that do not check the MsgLen-Indication!
375
376 ***************************************************************/
377
hycapi_send_message(struct capi_ctr * ctrl,struct sk_buff * skb)378 void hycapi_send_message(struct capi_ctr *ctrl, struct sk_buff *skb)
379 {
380 __u16 appl_id;
381 int _len, _len2;
382 __u8 msghead[64];
383
384 appl_id = CAPIMSG_APPID(skb->data);
385 switch(_hycapi_appCheck(appl_id, ctrl->cnr))
386 {
387 case 0:
388 /* printk(KERN_INFO "Need to register\n"); */
389 hycapi_register_internal(ctrl,
390 appl_id,
391 &(hycapi_applications[appl_id-1].rp));
392 break;
393 case 1:
394 break;
395 default:
396 printk(KERN_ERR "HYCAPI: Controller mixup!\n");
397 return;
398 }
399 switch(CAPIMSG_CMD(skb->data)) {
400 case CAPI_DISCONNECT_B3_RESP:
401 ctrl->free_ncci(ctrl, appl_id,
402 CAPIMSG_NCCI(skb->data));
403 break;
404 case CAPI_DATA_B3_REQ:
405 _len = CAPIMSG_LEN(skb->data);
406 if (_len > 22) {
407 _len2 = _len - 22;
408 memcpy(msghead, skb->data, 22);
409 memcpy(skb->data + _len2, msghead, 22);
410 skb_pull(skb, _len2);
411 CAPIMSG_SETLEN(skb->data, 22);
412 }
413 break;
414 case CAPI_LISTEN_REQ:
415 if(hycapi_applications[appl_id-1].listen_req[ctrl->cnr-1])
416 {
417 kfree_skb(hycapi_applications[appl_id-1].listen_req[ctrl->cnr-1]);
418 hycapi_applications[appl_id-1].listen_req[ctrl->cnr-1] = NULL;
419 }
420 if (!(hycapi_applications[appl_id-1].listen_req[ctrl->cnr-1] = skb_copy(skb, GFP_ATOMIC)))
421 {
422 printk(KERN_ERR "HYSDN: memory squeeze in private_listen\n");
423 }
424 break;
425 default:
426 break;
427 }
428 hycapi_sendmsg_internal(ctrl, skb);
429 }
430
431 /*********************************************************************
432 hycapi_read_proc
433
434 Informations provided in the /proc/capi-entries.
435
436 *********************************************************************/
437
hycapi_read_proc(char * page,char ** start,off_t off,int count,int * eof,struct capi_ctr * ctrl)438 int hycapi_read_proc(char *page, char **start, off_t off,
439 int count, int *eof, struct capi_ctr *ctrl)
440 {
441 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
442 hysdn_card *card = cinfo->card;
443 int len = 0;
444 char *s;
445 #ifdef HYCAPI_PRINTFNAMES
446 printk(KERN_NOTICE "hycapi_read_proc\n");
447 #endif
448 len += sprintf(page+len, "%-16s %s\n", "name", cinfo->cardname);
449 len += sprintf(page+len, "%-16s 0x%x\n", "io", card->iobase);
450 len += sprintf(page+len, "%-16s %d\n", "irq", card->irq);
451
452 switch (card->brdtype) {
453 case BD_PCCARD: s = "HYSDN Hycard"; break;
454 case BD_ERGO: s = "HYSDN Ergo2"; break;
455 case BD_METRO: s = "HYSDN Metro4"; break;
456 case BD_CHAMP2: s = "HYSDN Champ2"; break;
457 case BD_PLEXUS: s = "HYSDN Plexus30"; break;
458 default: s = "???"; break;
459 }
460 len += sprintf(page+len, "%-16s %s\n", "type", s);
461 if ((s = cinfo->version[VER_DRIVER]) != 0)
462 len += sprintf(page+len, "%-16s %s\n", "ver_driver", s);
463 if ((s = cinfo->version[VER_CARDTYPE]) != 0)
464 len += sprintf(page+len, "%-16s %s\n", "ver_cardtype", s);
465 if ((s = cinfo->version[VER_SERIAL]) != 0)
466 len += sprintf(page+len, "%-16s %s\n", "ver_serial", s);
467
468 len += sprintf(page+len, "%-16s %s\n", "cardname", cinfo->cardname);
469
470 if (off+count >= len)
471 *eof = 1;
472 if (len < off)
473 return 0;
474 *start = page + off;
475 return ((count < len-off) ? count : len-off);
476 }
477
478 /**************************************************************
479 hycapi_load_firmware
480
481 This does NOT load any firmware, but the callback somehow is needed
482 on capi-interface registration.
483
484 **************************************************************/
485
hycapi_load_firmware(struct capi_ctr * ctrl,capiloaddata * data)486 int hycapi_load_firmware(struct capi_ctr *ctrl, capiloaddata *data)
487 {
488 #ifdef HYCAPI_PRINTFNAMES
489 printk(KERN_NOTICE "hycapi_load_firmware\n");
490 #endif
491 return 0;
492 }
493
494
hycapi_procinfo(struct capi_ctr * ctrl)495 char *hycapi_procinfo(struct capi_ctr *ctrl)
496 {
497 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
498 #ifdef HYCAPI_PRINTFNAMES
499 printk(KERN_NOTICE "hycapi_proc_info\n");
500 #endif
501 if (!cinfo)
502 return "";
503 sprintf(cinfo->infobuf, "%s %s 0x%x %d %s",
504 cinfo->cardname[0] ? cinfo->cardname : "-",
505 cinfo->version[VER_DRIVER] ? cinfo->version[VER_DRIVER] : "-",
506 cinfo->card ? cinfo->card->iobase : 0x0,
507 cinfo->card ? cinfo->card->irq : 0,
508 hycapi_revision
509 );
510 return cinfo->infobuf;
511 }
512
513 /******************************************************************
514 hycapi_rx_capipkt
515
516 Receive a capi-message.
517
518 All B3_DATA_IND are converted to 64K-extension compatible format.
519 New nccis are created if neccessary.
520 *******************************************************************/
521
522 void
hycapi_rx_capipkt(hysdn_card * card,uchar * buf,word len)523 hycapi_rx_capipkt(hysdn_card * card, uchar * buf, word len)
524 {
525 struct sk_buff *skb;
526 hycapictrl_info *cinfo = card->hyctrlinfo;
527 struct capi_ctr *ctrl;
528 __u16 ApplId;
529 __u16 MsgLen, info;
530 __u16 len2, CapiCmd;
531 __u32 CP64[2] = {0,0};
532 #ifdef HYCAPI_PRINTFNAMES
533 printk(KERN_NOTICE "hycapi_rx_capipkt\n");
534 #endif
535 if(!cinfo) {
536 return;
537 }
538 ctrl = cinfo->capi_ctrl;
539 if(!ctrl)
540 {
541 return;
542 }
543 if(len < CAPI_MSG_BASELEN) {
544 printk(KERN_ERR "HYSDN Card%d: invalid CAPI-message, lenght %d!\n",
545 card->myid, len);
546 return;
547 }
548 MsgLen = CAPIMSG_LEN(buf);
549 ApplId = CAPIMSG_APPID(buf);
550 CapiCmd = CAPIMSG_CMD(buf);
551
552 if((CapiCmd == CAPI_DATA_B3_IND) && (MsgLen < 30)) {
553 len2 = len + (30 - MsgLen);
554 if (!(skb = alloc_skb(len2, GFP_ATOMIC))) {
555 printk(KERN_ERR "HYSDN Card%d: incoming packet dropped\n",
556 card->myid);
557 return;
558 }
559 memcpy(skb_put(skb, MsgLen), buf, MsgLen);
560 memcpy(skb_put(skb, 2*sizeof(__u32)), CP64, 2* sizeof(__u32));
561 memcpy(skb_put(skb, len - MsgLen), buf + MsgLen,
562 len - MsgLen);
563 CAPIMSG_SETLEN(skb->data, 30);
564 } else {
565 if (!(skb = alloc_skb(len, GFP_ATOMIC))) {
566 printk(KERN_ERR "HYSDN Card%d: incoming packet dropped\n",
567 card->myid);
568 return;
569 }
570 memcpy(skb_put(skb, len), buf, len);
571 }
572 switch(CAPIMSG_CMD(skb->data))
573 {
574 case CAPI_CONNECT_B3_CONF:
575 /* Check info-field for error-indication: */
576 info = CAPIMSG_U16(skb->data, 12);
577 switch(info)
578 {
579 case 0:
580 ctrl->new_ncci(ctrl, ApplId, CAPIMSG_NCCI(skb->data),
581 hycapi_applications[ApplId-1].rp.datablkcnt);
582
583 break;
584 case 0x0001:
585 printk(KERN_ERR "HYSDN Card%d: NCPI not supported by current "
586 "protocol. NCPI ignored.\n", card->myid);
587 break;
588 case 0x2001:
589 printk(KERN_ERR "HYSDN Card%d: Message not supported in"
590 " current state\n", card->myid);
591 break;
592 case 0x2002:
593 printk(KERN_ERR "HYSDN Card%d: illegal PLCI\n", card->myid);
594 break;
595 case 0x2004:
596 printk(KERN_ERR "HYSDN Card%d: out of NCCI\n", card->myid);
597 break;
598 case 0x3008:
599 printk(KERN_ERR "HYSDN Card%d: NCPI not supported\n",
600 card->myid);
601 break;
602 default:
603 printk(KERN_ERR "HYSDN Card%d: Info in CONNECT_B3_CONF: %d\n",
604 card->myid, info);
605 break;
606 }
607 break;
608 case CAPI_CONNECT_B3_IND:
609 ctrl->new_ncci(ctrl, ApplId,
610 CAPIMSG_NCCI(skb->data),
611 hycapi_applications[ApplId-1].rp.datablkcnt);
612 break;
613 default:
614 break;
615 }
616 ctrl->handle_capimsg(ctrl, ApplId, skb);
617 }
618
619 /******************************************************************
620 hycapi_tx_capiack
621
622 Internally acknowledge a msg sent. This will remove the msg from the
623 internal queue.
624
625 *******************************************************************/
626
hycapi_tx_capiack(hysdn_card * card)627 void hycapi_tx_capiack(hysdn_card * card)
628 {
629 hycapictrl_info *cinfo = card->hyctrlinfo;
630 #ifdef HYCAPI_PRINTFNAMES
631 printk(KERN_NOTICE "hycapi_tx_capiack\n");
632 #endif
633 if(!cinfo) {
634 return;
635 }
636 spin_lock_irq(&cinfo->lock);
637 kfree_skb(cinfo->skbs[cinfo->out_idx]); /* free skb */
638 cinfo->skbs[cinfo->out_idx++] = NULL;
639 if (cinfo->out_idx >= HYSDN_MAX_CAPI_SKB)
640 cinfo->out_idx = 0; /* wrap around */
641
642 if (cinfo->sk_count-- == HYSDN_MAX_CAPI_SKB) /* dec usage count */
643 cinfo->capi_ctrl->resume_output(cinfo->capi_ctrl);
644 spin_unlock_irq(&cinfo->lock);
645 }
646
647 /***************************************************************
648 hycapi_tx_capiget(hysdn_card *card)
649
650 This is called when polling for messages to SEND.
651
652 ****************************************************************/
653
654 struct sk_buff *
hycapi_tx_capiget(hysdn_card * card)655 hycapi_tx_capiget(hysdn_card *card)
656 {
657 hycapictrl_info *cinfo = card->hyctrlinfo;
658 if(!cinfo) {
659 return (struct sk_buff *)NULL;
660 }
661 if (!cinfo->sk_count)
662 return (struct sk_buff *)NULL; /* nothing available */
663
664 return (cinfo->skbs[cinfo->out_idx]); /* next packet to send */
665 }
666
667
668 static struct capi_driver hycapi_driver = {
669 "hysdn",
670 "0.0",
671 hycapi_load_firmware,
672 hycapi_reset_ctr,
673 hycapi_remove_ctr,
674 hycapi_register_appl,
675 hycapi_release_appl,
676 hycapi_send_message,
677 hycapi_procinfo,
678 hycapi_read_proc,
679 0, /* use standard driver_read_proc */
680 0, /* no add_card function */
681 };
682
683
684 /**********************************************************
685 int hycapi_init()
686
687 attach the capi-driver to the kernel-capi.
688
689 ***********************************************************/
690
hycapi_init()691 int hycapi_init()
692 {
693 struct capi_driver *driver;
694 int i;
695 if(hy_di) {
696 printk(KERN_NOTICE "HyDI allready set\n");
697 return 0;
698 }
699 driver = &hycapi_driver;
700 printk(KERN_NOTICE "HYSDN: Attaching capi-driver\n");
701 hy_di = attach_capi_driver(driver);
702 if (!hy_di) {
703 printk(KERN_ERR "HYCAPI: failed to attach capi_driver\n");
704 return(-1);
705 }
706 for(i=0;i<CAPI_MAXAPPL;i++) {
707 memset(&(hycapi_applications[i]), 0, sizeof(hycapi_appl));
708 }
709 return(0);
710 }
711
712 /**************************************************************
713 hycapi_cleanup(void)
714
715 detach the capi-driver to the kernel-capi. Actually this should
716 free some more ressources. Do that later.
717 **************************************************************/
718
719 void
hycapi_cleanup(void)720 hycapi_cleanup(void)
721 {
722 struct capi_driver *driver;
723 driver = &hycapi_driver;
724 if (!hy_di) {
725 printk(KERN_ERR "HYSDN: no capi-driver to detach (?)\n");
726 return;
727 }
728 printk(KERN_NOTICE "HYSDN: Detaching capi-driver\n");
729 detach_capi_driver(driver);
730 hy_di = 0;
731 return;
732 }
733
734 /********************************************************************
735 hycapi_capi_create(hysdn_card *card)
736
737 Attach the card with it's capi-ctrl.
738 *********************************************************************/
739
hycapi_fill_profile(hysdn_card * card)740 static void hycapi_fill_profile(hysdn_card *card)
741 {
742 hycapictrl_info *cinfo = NULL;
743 struct capi_ctr *ctrl = NULL;
744 cinfo = card->hyctrlinfo;
745 if(!cinfo) return;
746 ctrl = cinfo->capi_ctrl;
747 if(!ctrl) return;
748 strcpy(ctrl->manu, "Hypercope");
749 ctrl->version.majorversion = 2;
750 ctrl->version.minorversion = 0;
751 ctrl->version.majormanuversion = 3;
752 ctrl->version.minormanuversion = 2;
753 ctrl->profile.ncontroller = card->myid;
754 ctrl->profile.nbchannel = card->bchans;
755 ctrl->profile.goptions = GLOBAL_OPTION_INTERNAL_CONTROLLER |
756 GLOBAL_OPTION_B_CHANNEL_OPERATION;
757 ctrl->profile.support1 = B1_PROT_64KBIT_HDLC |
758 (card->faxchans ? B1_PROT_T30 : 0) |
759 B1_PROT_64KBIT_TRANSPARENT;
760 ctrl->profile.support2 = B2_PROT_ISO7776 |
761 (card->faxchans ? B2_PROT_T30 : 0) |
762 B2_PROT_TRANSPARENT;
763 ctrl->profile.support3 = B3_PROT_TRANSPARENT |
764 B3_PROT_T90NL |
765 (card->faxchans ? B3_PROT_T30 : 0) |
766 (card->faxchans ? B3_PROT_T30EXT : 0) |
767 B3_PROT_ISO8208;
768 }
769
770 int
hycapi_capi_create(hysdn_card * card)771 hycapi_capi_create(hysdn_card *card)
772 {
773 hycapictrl_info *cinfo = NULL;
774 struct capi_ctr *ctrl = NULL;
775 #ifdef HYCAPI_PRINTFNAMES
776 printk(KERN_NOTICE "hycapi_capi_create\n");
777 #endif
778 if((hycapi_enable & (1 << card->myid)) == 0) {
779 return 1;
780 }
781 if (!card->hyctrlinfo) {
782 cinfo = (hycapictrl_info *) kmalloc(sizeof(hycapictrl_info), GFP_ATOMIC);
783 if (!cinfo) {
784 printk(KERN_WARNING "HYSDN: no memory for capi-ctrl.\n");
785 return -ENOMEM;
786 }
787 memset(cinfo, 0, sizeof(hycapictrl_info));
788 card->hyctrlinfo = cinfo;
789 cinfo->card = card;
790 spin_lock_init(&cinfo->lock);
791
792 switch (card->brdtype) {
793 case BD_PCCARD: strcpy(cinfo->cardname,"HYSDN Hycard"); break;
794 case BD_ERGO: strcpy(cinfo->cardname,"HYSDN Ergo2"); break;
795 case BD_METRO: strcpy(cinfo->cardname,"HYSDN Metro4"); break;
796 case BD_CHAMP2: strcpy(cinfo->cardname,"HYSDN Champ2"); break;
797 case BD_PLEXUS: strcpy(cinfo->cardname,"HYSDN Plexus30"); break;
798 default: strcpy(cinfo->cardname,"HYSDN ???"); break;
799 }
800
801 cinfo->capi_ctrl = hy_di->attach_ctr(&hycapi_driver,
802 cinfo->cardname, cinfo);
803 ctrl = cinfo->capi_ctrl;
804 if (!ctrl) {
805 printk(KERN_ERR "%s: attach controller failed.\n",
806 hycapi_driver.name);
807 return -EBUSY;
808 }
809 /* fill in the blanks: */
810 hycapi_fill_profile(card);
811 ctrl->ready(ctrl);
812 } else {
813 /* resume output on stopped ctrl */
814 ctrl = card->hyctrlinfo->capi_ctrl;
815 if(ctrl) {
816 hycapi_fill_profile(card);
817 ctrl->ready(ctrl);
818 hycapi_restart_internal(ctrl);
819 /* ctrl->resume_output(ctrl); */
820 } else {
821 printk(KERN_WARNING "HYSDN: No ctrl???? How come?\n");
822 }
823 }
824 return 0;
825 }
826