1 /* $Id: hycapi.c,v 1.8.6.4 2001/09/23 22:24:54 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/signal.h>
15 #include <linux/kernel.h>
16 #include <linux/skbuff.h>
17 #include <linux/netdevice.h>
18
19 #define VER_DRIVER 0
20 #define VER_CARDTYPE 1
21 #define VER_HWID 2
22 #define VER_SERIAL 3
23 #define VER_OPTION 4
24 #define VER_PROTO 5
25 #define VER_PROFILE 6
26 #define VER_CAPI 7
27
28 #include "hysdn_defs.h"
29 #include <linux/kernelcapi.h>
30
31 static char hycapi_revision[]="$Revision: 1.8.6.4 $";
32
33 unsigned int hycapi_enable = 0xffffffff;
34 module_param(hycapi_enable, uint, 0);
35
36 typedef struct _hycapi_appl {
37 unsigned int ctrl_mask;
38 capi_register_params rp;
39 struct sk_buff *listen_req[CAPI_MAXCONTR];
40 } hycapi_appl;
41
42 static hycapi_appl hycapi_applications[CAPI_MAXAPPL];
43
44 static u16 hycapi_send_message(struct capi_ctr *ctrl, struct sk_buff *skb);
45
_hycapi_appCheck(int app_id,int ctrl_no)46 static inline int _hycapi_appCheck(int app_id, int ctrl_no)
47 {
48 if((ctrl_no <= 0) || (ctrl_no > CAPI_MAXCONTR) || (app_id <= 0) ||
49 (app_id > CAPI_MAXAPPL))
50 {
51 printk(KERN_ERR "HYCAPI: Invalid request app_id %d for controller %d", app_id, ctrl_no);
52 return -1;
53 }
54 return ((hycapi_applications[app_id-1].ctrl_mask & (1 << (ctrl_no-1))) != 0);
55 }
56
57 /******************************
58 Kernel-Capi callback reset_ctr
59 ******************************/
60
61 static void
hycapi_reset_ctr(struct capi_ctr * ctrl)62 hycapi_reset_ctr(struct capi_ctr *ctrl)
63 {
64 hycapictrl_info *cinfo = ctrl->driverdata;
65
66 #ifdef HYCAPI_PRINTFNAMES
67 printk(KERN_NOTICE "HYCAPI hycapi_reset_ctr\n");
68 #endif
69 capilib_release(&cinfo->ncci_head);
70 capi_ctr_reseted(ctrl);
71 }
72
73 /******************************
74 Kernel-Capi callback remove_ctr
75 ******************************/
76
77 static void
hycapi_remove_ctr(struct capi_ctr * ctrl)78 hycapi_remove_ctr(struct capi_ctr *ctrl)
79 {
80 int i;
81 hycapictrl_info *cinfo = NULL;
82 hysdn_card *card = NULL;
83 #ifdef HYCAPI_PRINTFNAMES
84 printk(KERN_NOTICE "HYCAPI hycapi_remove_ctr\n");
85 #endif
86 cinfo = (hycapictrl_info *)(ctrl->driverdata);
87 if(!cinfo) {
88 printk(KERN_ERR "No hycapictrl_info set!");
89 return;
90 }
91 card = cinfo->card;
92 capi_ctr_suspend_output(ctrl);
93 for(i=0; i<CAPI_MAXAPPL;i++) {
94 if(hycapi_applications[i].listen_req[ctrl->cnr-1]) {
95 kfree_skb(hycapi_applications[i].listen_req[ctrl->cnr-1]);
96 hycapi_applications[i].listen_req[ctrl->cnr-1] = NULL;
97 }
98 }
99 detach_capi_ctr(ctrl);
100 ctrl->driverdata = NULL;
101 kfree(card->hyctrlinfo);
102
103
104 card->hyctrlinfo = NULL;
105 }
106
107 /***********************************************************
108
109 Queue a CAPI-message to the controller.
110
111 ***********************************************************/
112
113 static void
hycapi_sendmsg_internal(struct capi_ctr * ctrl,struct sk_buff * skb)114 hycapi_sendmsg_internal(struct capi_ctr *ctrl, struct sk_buff *skb)
115 {
116 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
117 hysdn_card *card = cinfo->card;
118
119 spin_lock_irq(&cinfo->lock);
120 #ifdef HYCAPI_PRINTFNAMES
121 printk(KERN_NOTICE "hycapi_send_message\n");
122 #endif
123 cinfo->skbs[cinfo->in_idx++] = skb; /* add to buffer list */
124 if (cinfo->in_idx >= HYSDN_MAX_CAPI_SKB)
125 cinfo->in_idx = 0; /* wrap around */
126 cinfo->sk_count++; /* adjust counter */
127 if (cinfo->sk_count >= HYSDN_MAX_CAPI_SKB) {
128 /* inform upper layers we're full */
129 printk(KERN_ERR "HYSDN Card%d: CAPI-buffer overrun!\n",
130 card->myid);
131 capi_ctr_suspend_output(ctrl);
132 }
133 cinfo->tx_skb = skb;
134 spin_unlock_irq(&cinfo->lock);
135 schedule_work(&card->irq_queue);
136 }
137
138 /***********************************************************
139 hycapi_register_internal
140
141 Send down the CAPI_REGISTER-Command to the controller.
142 This functions will also be used if the adapter has been rebooted to
143 re-register any applications in the private list.
144
145 ************************************************************/
146
147 static void
hycapi_register_internal(struct capi_ctr * ctrl,__u16 appl,capi_register_params * rp)148 hycapi_register_internal(struct capi_ctr *ctrl, __u16 appl,
149 capi_register_params *rp)
150 {
151 char ExtFeatureDefaults[] = "49 /0/0/0/0,*/1,*/2,*/3,*/4,*/5,*/6,*/7,*/8,*/9,*";
152 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
153 hysdn_card *card = cinfo->card;
154 struct sk_buff *skb;
155 __u16 len;
156 __u8 _command = 0xa0, _subcommand = 0x80;
157 __u16 MessageNumber = 0x0000;
158 __u16 MessageBufferSize = 0;
159 int slen = strlen(ExtFeatureDefaults);
160 #ifdef HYCAPI_PRINTFNAMES
161 printk(KERN_NOTICE "hycapi_register_appl\n");
162 #endif
163 MessageBufferSize = rp->level3cnt * rp->datablkcnt * rp->datablklen;
164
165 len = CAPI_MSG_BASELEN + 8 + slen + 1;
166 if (!(skb = alloc_skb(len, GFP_ATOMIC))) {
167 printk(KERN_ERR "HYSDN card%d: memory squeeze in hycapi_register_appl\n",
168 card->myid);
169 return;
170 }
171 memcpy(skb_put(skb,sizeof(__u16)), &len, sizeof(__u16));
172 memcpy(skb_put(skb,sizeof(__u16)), &appl, sizeof(__u16));
173 memcpy(skb_put(skb,sizeof(__u8)), &_command, sizeof(_command));
174 memcpy(skb_put(skb,sizeof(__u8)), &_subcommand, sizeof(_subcommand));
175 memcpy(skb_put(skb,sizeof(__u16)), &MessageNumber, sizeof(__u16));
176 memcpy(skb_put(skb,sizeof(__u16)), &MessageBufferSize, sizeof(__u16));
177 memcpy(skb_put(skb,sizeof(__u16)), &(rp->level3cnt), sizeof(__u16));
178 memcpy(skb_put(skb,sizeof(__u16)), &(rp->datablkcnt), sizeof(__u16));
179 memcpy(skb_put(skb,sizeof(__u16)), &(rp->datablklen), sizeof(__u16));
180 memcpy(skb_put(skb,slen), ExtFeatureDefaults, slen);
181 hycapi_applications[appl-1].ctrl_mask |= (1 << (ctrl->cnr-1));
182 hycapi_send_message(ctrl, skb);
183 }
184
185 /************************************************************
186 hycapi_restart_internal
187
188 After an adapter has been rebootet, re-register all applications and
189 send a LISTEN_REQ (if there has been such a thing )
190
191 *************************************************************/
192
hycapi_restart_internal(struct capi_ctr * ctrl)193 static void hycapi_restart_internal(struct capi_ctr *ctrl)
194 {
195 int i;
196 struct sk_buff *skb;
197 #ifdef HYCAPI_PRINTFNAMES
198 printk(KERN_WARNING "HYSDN: hycapi_restart_internal");
199 #endif
200 for(i=0; i<CAPI_MAXAPPL; i++) {
201 if(_hycapi_appCheck(i+1, ctrl->cnr) == 1) {
202 hycapi_register_internal(ctrl, i+1,
203 &hycapi_applications[i].rp);
204 if(hycapi_applications[i].listen_req[ctrl->cnr-1]) {
205 skb = skb_copy(hycapi_applications[i].listen_req[ctrl->cnr-1], GFP_ATOMIC);
206 hycapi_sendmsg_internal(ctrl, skb);
207 }
208 }
209 }
210 }
211
212 /*************************************************************
213 Register an application.
214 Error-checking is done for CAPI-compliance.
215
216 The application is recorded in the internal list.
217 *************************************************************/
218
219 static void
hycapi_register_appl(struct capi_ctr * ctrl,__u16 appl,capi_register_params * rp)220 hycapi_register_appl(struct capi_ctr *ctrl, __u16 appl,
221 capi_register_params *rp)
222 {
223 int MaxLogicalConnections = 0, MaxBDataBlocks = 0, MaxBDataLen = 0;
224 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
225 hysdn_card *card = cinfo->card;
226 int chk = _hycapi_appCheck(appl, ctrl->cnr);
227 if(chk < 0) {
228 return;
229 }
230 if(chk == 1) {
231 printk(KERN_INFO "HYSDN: apl %d already registered\n", appl);
232 return;
233 }
234 MaxBDataBlocks = rp->datablkcnt > CAPI_MAXDATAWINDOW ? CAPI_MAXDATAWINDOW : rp->datablkcnt;
235 rp->datablkcnt = MaxBDataBlocks;
236 MaxBDataLen = rp->datablklen < 1024 ? 1024 : rp->datablklen ;
237 rp->datablklen = MaxBDataLen;
238
239 MaxLogicalConnections = rp->level3cnt;
240 if (MaxLogicalConnections < 0) {
241 MaxLogicalConnections = card->bchans * -MaxLogicalConnections;
242 }
243 if (MaxLogicalConnections == 0) {
244 MaxLogicalConnections = card->bchans;
245 }
246
247 rp->level3cnt = MaxLogicalConnections;
248 memcpy(&hycapi_applications[appl-1].rp,
249 rp, sizeof(capi_register_params));
250 }
251
252 /*********************************************************************
253
254 hycapi_release_internal
255
256 Send down a CAPI_RELEASE to the controller.
257 *********************************************************************/
258
hycapi_release_internal(struct capi_ctr * ctrl,__u16 appl)259 static void hycapi_release_internal(struct capi_ctr *ctrl, __u16 appl)
260 {
261 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
262 hysdn_card *card = cinfo->card;
263 struct sk_buff *skb;
264 __u16 len;
265 __u8 _command = 0xa1, _subcommand = 0x80;
266 __u16 MessageNumber = 0x0000;
267
268 capilib_release_appl(&cinfo->ncci_head, appl);
269
270 #ifdef HYCAPI_PRINTFNAMES
271 printk(KERN_NOTICE "hycapi_release_appl\n");
272 #endif
273 len = CAPI_MSG_BASELEN;
274 if (!(skb = alloc_skb(len, GFP_ATOMIC))) {
275 printk(KERN_ERR "HYSDN card%d: memory squeeze in hycapi_register_appl\n",
276 card->myid);
277 return;
278 }
279 memcpy(skb_put(skb,sizeof(__u16)), &len, sizeof(__u16));
280 memcpy(skb_put(skb,sizeof(__u16)), &appl, sizeof(__u16));
281 memcpy(skb_put(skb,sizeof(__u8)), &_command, sizeof(_command));
282 memcpy(skb_put(skb,sizeof(__u8)), &_subcommand, sizeof(_subcommand));
283 memcpy(skb_put(skb,sizeof(__u16)), &MessageNumber, sizeof(__u16));
284 hycapi_send_message(ctrl, skb);
285 hycapi_applications[appl-1].ctrl_mask &= ~(1 << (ctrl->cnr-1));
286 }
287
288 /******************************************************************
289 hycapi_release_appl
290
291 Release the application from the internal list an remove it's
292 registration at controller-level
293 ******************************************************************/
294
295 static void
hycapi_release_appl(struct capi_ctr * ctrl,__u16 appl)296 hycapi_release_appl(struct capi_ctr *ctrl, __u16 appl)
297 {
298 int chk;
299
300 chk = _hycapi_appCheck(appl, ctrl->cnr);
301 if(chk<0) {
302 printk(KERN_ERR "HYCAPI: Releasing invalid appl %d on controller %d\n", appl, ctrl->cnr);
303 return;
304 }
305 if(hycapi_applications[appl-1].listen_req[ctrl->cnr-1]) {
306 kfree_skb(hycapi_applications[appl-1].listen_req[ctrl->cnr-1]);
307 hycapi_applications[appl-1].listen_req[ctrl->cnr-1] = NULL;
308 }
309 if(chk == 1)
310 {
311 hycapi_release_internal(ctrl, appl);
312 }
313 }
314
315
316 /**************************************************************
317 Kill a single controller.
318 **************************************************************/
319
hycapi_capi_release(hysdn_card * card)320 int hycapi_capi_release(hysdn_card *card)
321 {
322 hycapictrl_info *cinfo = card->hyctrlinfo;
323 struct capi_ctr *ctrl;
324 #ifdef HYCAPI_PRINTFNAMES
325 printk(KERN_NOTICE "hycapi_capi_release\n");
326 #endif
327 if(cinfo) {
328 ctrl = &cinfo->capi_ctrl;
329 hycapi_remove_ctr(ctrl);
330 }
331 return 0;
332 }
333
334 /**************************************************************
335 hycapi_capi_stop
336
337 Stop CAPI-Output on a card. (e.g. during reboot)
338 ***************************************************************/
339
hycapi_capi_stop(hysdn_card * card)340 int hycapi_capi_stop(hysdn_card *card)
341 {
342 hycapictrl_info *cinfo = card->hyctrlinfo;
343 struct capi_ctr *ctrl;
344 #ifdef HYCAPI_PRINTFNAMES
345 printk(KERN_NOTICE "hycapi_capi_stop\n");
346 #endif
347 if(cinfo) {
348 ctrl = &cinfo->capi_ctrl;
349 /* ctrl->suspend_output(ctrl); */
350 capi_ctr_reseted(ctrl);
351 }
352 return 0;
353 }
354
355 /***************************************************************
356 hycapi_send_message
357
358 Send a message to the controller.
359
360 Messages are parsed for their Command/Subcommand-type, and appropriate
361 action's are performed.
362
363 Note that we have to muck around with a 64Bit-DATA_REQ as there are
364 firmware-releases that do not check the MsgLen-Indication!
365
366 ***************************************************************/
367
hycapi_send_message(struct capi_ctr * ctrl,struct sk_buff * skb)368 static u16 hycapi_send_message(struct capi_ctr *ctrl, struct sk_buff *skb)
369 {
370 __u16 appl_id;
371 int _len, _len2;
372 __u8 msghead[64];
373 hycapictrl_info *cinfo = ctrl->driverdata;
374 u16 retval = CAPI_NOERROR;
375
376 appl_id = CAPIMSG_APPID(skb->data);
377 switch(_hycapi_appCheck(appl_id, ctrl->cnr))
378 {
379 case 0:
380 /* printk(KERN_INFO "Need to register\n"); */
381 hycapi_register_internal(ctrl,
382 appl_id,
383 &(hycapi_applications[appl_id-1].rp));
384 break;
385 case 1:
386 break;
387 default:
388 printk(KERN_ERR "HYCAPI: Controller mixup!\n");
389 retval = CAPI_ILLAPPNR;
390 goto out;
391 }
392 switch(CAPIMSG_CMD(skb->data)) {
393 case CAPI_DISCONNECT_B3_RESP:
394 capilib_free_ncci(&cinfo->ncci_head, appl_id,
395 CAPIMSG_NCCI(skb->data));
396 break;
397 case CAPI_DATA_B3_REQ:
398 _len = CAPIMSG_LEN(skb->data);
399 if (_len > 22) {
400 _len2 = _len - 22;
401 skb_copy_from_linear_data(skb, msghead, 22);
402 skb_copy_to_linear_data_offset(skb, _len2,
403 msghead, 22);
404 skb_pull(skb, _len2);
405 CAPIMSG_SETLEN(skb->data, 22);
406 retval = capilib_data_b3_req(&cinfo->ncci_head,
407 CAPIMSG_APPID(skb->data),
408 CAPIMSG_NCCI(skb->data),
409 CAPIMSG_MSGID(skb->data));
410 }
411 break;
412 case CAPI_LISTEN_REQ:
413 if(hycapi_applications[appl_id-1].listen_req[ctrl->cnr-1])
414 {
415 kfree_skb(hycapi_applications[appl_id-1].listen_req[ctrl->cnr-1]);
416 hycapi_applications[appl_id-1].listen_req[ctrl->cnr-1] = NULL;
417 }
418 if (!(hycapi_applications[appl_id-1].listen_req[ctrl->cnr-1] = skb_copy(skb, GFP_ATOMIC)))
419 {
420 printk(KERN_ERR "HYSDN: memory squeeze in private_listen\n");
421 }
422 break;
423 default:
424 break;
425 }
426 out:
427 if (retval == CAPI_NOERROR)
428 hycapi_sendmsg_internal(ctrl, skb);
429 else
430 dev_kfree_skb_any(skb);
431
432 return retval;
433 }
434
435 /*********************************************************************
436 hycapi_read_proc
437
438 Informations provided in the /proc/capi-entries.
439
440 *********************************************************************/
441
hycapi_read_proc(char * page,char ** start,off_t off,int count,int * eof,struct capi_ctr * ctrl)442 static int hycapi_read_proc(char *page, char **start, off_t off,
443 int count, int *eof, struct capi_ctr *ctrl)
444 {
445 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
446 hysdn_card *card = cinfo->card;
447 int len = 0;
448 char *s;
449 #ifdef HYCAPI_PRINTFNAMES
450 printk(KERN_NOTICE "hycapi_read_proc\n");
451 #endif
452 len += sprintf(page+len, "%-16s %s\n", "name", cinfo->cardname);
453 len += sprintf(page+len, "%-16s 0x%x\n", "io", card->iobase);
454 len += sprintf(page+len, "%-16s %d\n", "irq", card->irq);
455
456 switch (card->brdtype) {
457 case BD_PCCARD: s = "HYSDN Hycard"; break;
458 case BD_ERGO: s = "HYSDN Ergo2"; break;
459 case BD_METRO: s = "HYSDN Metro4"; break;
460 case BD_CHAMP2: s = "HYSDN Champ2"; break;
461 case BD_PLEXUS: s = "HYSDN Plexus30"; break;
462 default: s = "???"; break;
463 }
464 len += sprintf(page+len, "%-16s %s\n", "type", s);
465 if ((s = cinfo->version[VER_DRIVER]) != NULL)
466 len += sprintf(page+len, "%-16s %s\n", "ver_driver", s);
467 if ((s = cinfo->version[VER_CARDTYPE]) != NULL)
468 len += sprintf(page+len, "%-16s %s\n", "ver_cardtype", s);
469 if ((s = cinfo->version[VER_SERIAL]) != NULL)
470 len += sprintf(page+len, "%-16s %s\n", "ver_serial", s);
471
472 len += sprintf(page+len, "%-16s %s\n", "cardname", cinfo->cardname);
473
474 if (off+count >= len)
475 *eof = 1;
476 if (len < off)
477 return 0;
478 *start = page + off;
479 return ((count < len-off) ? count : len-off);
480 }
481
482 /**************************************************************
483 hycapi_load_firmware
484
485 This does NOT load any firmware, but the callback somehow is needed
486 on capi-interface registration.
487
488 **************************************************************/
489
hycapi_load_firmware(struct capi_ctr * ctrl,capiloaddata * data)490 static int hycapi_load_firmware(struct capi_ctr *ctrl, capiloaddata *data)
491 {
492 #ifdef HYCAPI_PRINTFNAMES
493 printk(KERN_NOTICE "hycapi_load_firmware\n");
494 #endif
495 return 0;
496 }
497
498
hycapi_procinfo(struct capi_ctr * ctrl)499 static char *hycapi_procinfo(struct capi_ctr *ctrl)
500 {
501 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
502 #ifdef HYCAPI_PRINTFNAMES
503 printk(KERN_NOTICE "hycapi_proc_info\n");
504 #endif
505 if (!cinfo)
506 return "";
507 sprintf(cinfo->infobuf, "%s %s 0x%x %d %s",
508 cinfo->cardname[0] ? cinfo->cardname : "-",
509 cinfo->version[VER_DRIVER] ? cinfo->version[VER_DRIVER] : "-",
510 cinfo->card ? cinfo->card->iobase : 0x0,
511 cinfo->card ? cinfo->card->irq : 0,
512 hycapi_revision
513 );
514 return cinfo->infobuf;
515 }
516
517 /******************************************************************
518 hycapi_rx_capipkt
519
520 Receive a capi-message.
521
522 All B3_DATA_IND are converted to 64K-extension compatible format.
523 New nccis are created if necessary.
524 *******************************************************************/
525
526 void
hycapi_rx_capipkt(hysdn_card * card,unsigned char * buf,unsigned short len)527 hycapi_rx_capipkt(hysdn_card * card, unsigned char *buf, unsigned short len)
528 {
529 struct sk_buff *skb;
530 hycapictrl_info *cinfo = card->hyctrlinfo;
531 struct capi_ctr *ctrl;
532 __u16 ApplId;
533 __u16 MsgLen, info;
534 __u16 len2, CapiCmd;
535 __u32 CP64[2] = {0,0};
536 #ifdef HYCAPI_PRINTFNAMES
537 printk(KERN_NOTICE "hycapi_rx_capipkt\n");
538 #endif
539 if(!cinfo) {
540 return;
541 }
542 ctrl = &cinfo->capi_ctrl;
543 if(len < CAPI_MSG_BASELEN) {
544 printk(KERN_ERR "HYSDN Card%d: invalid CAPI-message, length %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 capilib_new_ncci(&cinfo->ncci_head, 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: invalid 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 capilib_new_ncci(&cinfo->ncci_head, ApplId,
610 CAPIMSG_NCCI(skb->data),
611 hycapi_applications[ApplId-1].rp.datablkcnt);
612 break;
613 case CAPI_DATA_B3_CONF:
614 capilib_data_b3_conf(&cinfo->ncci_head, ApplId,
615 CAPIMSG_NCCI(skb->data),
616 CAPIMSG_MSGID(skb->data));
617 break;
618 default:
619 break;
620 }
621 capi_ctr_handle_message(ctrl, ApplId, skb);
622 }
623
624 /******************************************************************
625 hycapi_tx_capiack
626
627 Internally acknowledge a msg sent. This will remove the msg from the
628 internal queue.
629
630 *******************************************************************/
631
hycapi_tx_capiack(hysdn_card * card)632 void hycapi_tx_capiack(hysdn_card * card)
633 {
634 hycapictrl_info *cinfo = card->hyctrlinfo;
635 #ifdef HYCAPI_PRINTFNAMES
636 printk(KERN_NOTICE "hycapi_tx_capiack\n");
637 #endif
638 if(!cinfo) {
639 return;
640 }
641 spin_lock_irq(&cinfo->lock);
642 kfree_skb(cinfo->skbs[cinfo->out_idx]); /* free skb */
643 cinfo->skbs[cinfo->out_idx++] = NULL;
644 if (cinfo->out_idx >= HYSDN_MAX_CAPI_SKB)
645 cinfo->out_idx = 0; /* wrap around */
646
647 if (cinfo->sk_count-- == HYSDN_MAX_CAPI_SKB) /* dec usage count */
648 capi_ctr_resume_output(&cinfo->capi_ctrl);
649 spin_unlock_irq(&cinfo->lock);
650 }
651
652 /***************************************************************
653 hycapi_tx_capiget(hysdn_card *card)
654
655 This is called when polling for messages to SEND.
656
657 ****************************************************************/
658
659 struct sk_buff *
hycapi_tx_capiget(hysdn_card * card)660 hycapi_tx_capiget(hysdn_card *card)
661 {
662 hycapictrl_info *cinfo = card->hyctrlinfo;
663 if(!cinfo) {
664 return (struct sk_buff *)NULL;
665 }
666 if (!cinfo->sk_count)
667 return (struct sk_buff *)NULL; /* nothing available */
668
669 return (cinfo->skbs[cinfo->out_idx]); /* next packet to send */
670 }
671
672
673 /**********************************************************
674 int hycapi_init()
675
676 attach the capi-driver to the kernel-capi.
677
678 ***********************************************************/
679
hycapi_init(void)680 int hycapi_init(void)
681 {
682 int i;
683 for(i=0;i<CAPI_MAXAPPL;i++) {
684 memset(&(hycapi_applications[i]), 0, sizeof(hycapi_appl));
685 }
686 return(0);
687 }
688
689 /**************************************************************
690 hycapi_cleanup(void)
691
692 detach the capi-driver to the kernel-capi. Actually this should
693 free some more ressources. Do that later.
694 **************************************************************/
695
696 void
hycapi_cleanup(void)697 hycapi_cleanup(void)
698 {
699 }
700
701 /********************************************************************
702 hycapi_capi_create(hysdn_card *card)
703
704 Attach the card with its capi-ctrl.
705 *********************************************************************/
706
hycapi_fill_profile(hysdn_card * card)707 static void hycapi_fill_profile(hysdn_card *card)
708 {
709 hycapictrl_info *cinfo = NULL;
710 struct capi_ctr *ctrl = NULL;
711 cinfo = card->hyctrlinfo;
712 if(!cinfo) return;
713 ctrl = &cinfo->capi_ctrl;
714 strcpy(ctrl->manu, "Hypercope");
715 ctrl->version.majorversion = 2;
716 ctrl->version.minorversion = 0;
717 ctrl->version.majormanuversion = 3;
718 ctrl->version.minormanuversion = 2;
719 ctrl->profile.ncontroller = card->myid;
720 ctrl->profile.nbchannel = card->bchans;
721 ctrl->profile.goptions = GLOBAL_OPTION_INTERNAL_CONTROLLER |
722 GLOBAL_OPTION_B_CHANNEL_OPERATION;
723 ctrl->profile.support1 = B1_PROT_64KBIT_HDLC |
724 (card->faxchans ? B1_PROT_T30 : 0) |
725 B1_PROT_64KBIT_TRANSPARENT;
726 ctrl->profile.support2 = B2_PROT_ISO7776 |
727 (card->faxchans ? B2_PROT_T30 : 0) |
728 B2_PROT_TRANSPARENT;
729 ctrl->profile.support3 = B3_PROT_TRANSPARENT |
730 B3_PROT_T90NL |
731 (card->faxchans ? B3_PROT_T30 : 0) |
732 (card->faxchans ? B3_PROT_T30EXT : 0) |
733 B3_PROT_ISO8208;
734 }
735
736 int
hycapi_capi_create(hysdn_card * card)737 hycapi_capi_create(hysdn_card *card)
738 {
739 hycapictrl_info *cinfo = NULL;
740 struct capi_ctr *ctrl = NULL;
741 int retval;
742 #ifdef HYCAPI_PRINTFNAMES
743 printk(KERN_NOTICE "hycapi_capi_create\n");
744 #endif
745 if((hycapi_enable & (1 << card->myid)) == 0) {
746 return 1;
747 }
748 if (!card->hyctrlinfo) {
749 cinfo = kzalloc(sizeof(hycapictrl_info), GFP_ATOMIC);
750 if (!cinfo) {
751 printk(KERN_WARNING "HYSDN: no memory for capi-ctrl.\n");
752 return -ENOMEM;
753 }
754 card->hyctrlinfo = cinfo;
755 cinfo->card = card;
756 spin_lock_init(&cinfo->lock);
757 INIT_LIST_HEAD(&cinfo->ncci_head);
758
759 switch (card->brdtype) {
760 case BD_PCCARD: strcpy(cinfo->cardname,"HYSDN Hycard"); break;
761 case BD_ERGO: strcpy(cinfo->cardname,"HYSDN Ergo2"); break;
762 case BD_METRO: strcpy(cinfo->cardname,"HYSDN Metro4"); break;
763 case BD_CHAMP2: strcpy(cinfo->cardname,"HYSDN Champ2"); break;
764 case BD_PLEXUS: strcpy(cinfo->cardname,"HYSDN Plexus30"); break;
765 default: strcpy(cinfo->cardname,"HYSDN ???"); break;
766 }
767
768 ctrl = &cinfo->capi_ctrl;
769 ctrl->driver_name = "hycapi";
770 ctrl->driverdata = cinfo;
771 ctrl->register_appl = hycapi_register_appl;
772 ctrl->release_appl = hycapi_release_appl;
773 ctrl->send_message = hycapi_send_message;
774 ctrl->load_firmware = hycapi_load_firmware;
775 ctrl->reset_ctr = hycapi_reset_ctr;
776 ctrl->procinfo = hycapi_procinfo;
777 ctrl->ctr_read_proc = hycapi_read_proc;
778 strcpy(ctrl->name, cinfo->cardname);
779 ctrl->owner = THIS_MODULE;
780
781 retval = attach_capi_ctr(ctrl);
782 if (retval) {
783 printk(KERN_ERR "hycapi: attach controller failed.\n");
784 return -EBUSY;
785 }
786 /* fill in the blanks: */
787 hycapi_fill_profile(card);
788 capi_ctr_ready(ctrl);
789 } else {
790 /* resume output on stopped ctrl */
791 ctrl = &card->hyctrlinfo->capi_ctrl;
792 hycapi_fill_profile(card);
793 capi_ctr_ready(ctrl);
794 hycapi_restart_internal(ctrl);
795 /* ctrl->resume_output(ctrl); */
796 }
797 return 0;
798 }
799