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/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
34 static char hycapi_revision[] = "$Revision: 1.8.6.4 $";
35
36 unsigned int hycapi_enable = 0xffffffff;
37 module_param(hycapi_enable, uint, 0);
38
39 typedef 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
45 static hycapi_appl hycapi_applications[CAPI_MAXAPPL];
46
47 static u16 hycapi_send_message(struct capi_ctr *ctrl, struct sk_buff *skb);
48
_hycapi_appCheck(int app_id,int ctrl_no)49 static 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 Kernel-Capi callback reset_ctr
62 ******************************/
63
64 static void
hycapi_reset_ctr(struct capi_ctr * ctrl)65 hycapi_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 Kernel-Capi callback remove_ctr
78 ******************************/
79
80 static void
hycapi_remove_ctr(struct capi_ctr * ctrl)81 hycapi_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 Queue a CAPI-message to the controller.
113
114 ***********************************************************/
115
116 static void
hycapi_sendmsg_internal(struct capi_ctr * ctrl,struct sk_buff * skb)117 hycapi_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; /* add to buffer list */
127 if (cinfo->in_idx >= HYSDN_MAX_CAPI_SKB)
128 cinfo->in_idx = 0; /* wrap around */
129 cinfo->sk_count++; /* adjust counter */
130 if (cinfo->sk_count >= HYSDN_MAX_CAPI_SKB) {
131 /* inform upper layers we're full */
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 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 skb_put_data(skb, &len, sizeof(__u16));
175 skb_put_data(skb, &appl, sizeof(__u16));
176 skb_put_data(skb, &_command, sizeof(__u8));
177 skb_put_data(skb, &_subcommand, sizeof(__u8));
178 skb_put_data(skb, &MessageNumber, sizeof(__u16));
179 skb_put_data(skb, &MessageBufferSize, sizeof(__u16));
180 skb_put_data(skb, &(rp->level3cnt), sizeof(__u16));
181 skb_put_data(skb, &(rp->datablkcnt), sizeof(__u16));
182 skb_put_data(skb, &(rp->datablklen), sizeof(__u16));
183 skb_put_data(skb, 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 static 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 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 hycapi_release_internal
258
259 Send down a CAPI_RELEASE to the controller.
260 *********************************************************************/
261
hycapi_release_internal(struct capi_ctr * ctrl,__u16 appl)262 static 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 skb_put_data(skb, &len, sizeof(__u16));
283 skb_put_data(skb, &appl, sizeof(__u16));
284 skb_put_data(skb, &_command, sizeof(__u8));
285 skb_put_data(skb, &_subcommand, sizeof(__u8));
286 skb_put_data(skb, &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 static 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 }
317
318
319 /**************************************************************
320 Kill a single controller.
321 **************************************************************/
322
hycapi_capi_release(hysdn_card * card)323 int 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 hycapi_capi_stop
339
340 Stop CAPI-Output on a card. (e.g. during reboot)
341 ***************************************************************/
342
hycapi_capi_stop(hysdn_card * card)343 int 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 /* ctrl->suspend_output(ctrl); */
353 capi_ctr_down(ctrl);
354 }
355 return 0;
356 }
357
358 /***************************************************************
359 hycapi_send_message
360
361 Send a message to the controller.
362
363 Messages are parsed for their Command/Subcommand-type, and appropriate
364 action's are performed.
365
366 Note that we have to muck around with a 64Bit-DATA_REQ as there are
367 firmware-releases that do not check the MsgLen-Indication!
368
369 ***************************************************************/
370
hycapi_send_message(struct capi_ctr * ctrl,struct sk_buff * skb)371 static 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 /* printk(KERN_INFO "Need to register\n"); */
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
hycapi_proc_show(struct seq_file * m,void * v)438 static 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
470 /**************************************************************
471 hycapi_load_firmware
472
473 This does NOT load any firmware, but the callback somehow is needed
474 on capi-interface registration.
475
476 **************************************************************/
477
hycapi_load_firmware(struct capi_ctr * ctrl,capiloaddata * data)478 static int hycapi_load_firmware(struct capi_ctr *ctrl, capiloaddata *data)
479 {
480 #ifdef HYCAPI_PRINTFNAMES
481 printk(KERN_NOTICE "hycapi_load_firmware\n");
482 #endif
483 return 0;
484 }
485
486
hycapi_procinfo(struct capi_ctr * ctrl)487 static char *hycapi_procinfo(struct capi_ctr *ctrl)
488 {
489 hycapictrl_info *cinfo = (hycapictrl_info *)(ctrl->driverdata);
490 #ifdef HYCAPI_PRINTFNAMES
491 printk(KERN_NOTICE "%s\n", __func__);
492 #endif
493 if (!cinfo)
494 return "";
495 sprintf(cinfo->infobuf, "%s %s 0x%x %d %s",
496 cinfo->cardname[0] ? cinfo->cardname : "-",
497 cinfo->version[VER_DRIVER] ? cinfo->version[VER_DRIVER] : "-",
498 cinfo->card ? cinfo->card->iobase : 0x0,
499 cinfo->card ? cinfo->card->irq : 0,
500 hycapi_revision
501 );
502 return cinfo->infobuf;
503 }
504
505 /******************************************************************
506 hycapi_rx_capipkt
507
508 Receive a capi-message.
509
510 All B3_DATA_IND are converted to 64K-extension compatible format.
511 New nccis are created if necessary.
512 *******************************************************************/
513
514 void
hycapi_rx_capipkt(hysdn_card * card,unsigned char * buf,unsigned short len)515 hycapi_rx_capipkt(hysdn_card *card, unsigned char *buf, unsigned short len)
516 {
517 struct sk_buff *skb;
518 hycapictrl_info *cinfo = card->hyctrlinfo;
519 struct capi_ctr *ctrl;
520 __u16 ApplId;
521 __u16 MsgLen, info;
522 __u16 len2, CapiCmd;
523 __u32 CP64[2] = {0, 0};
524 #ifdef HYCAPI_PRINTFNAMES
525 printk(KERN_NOTICE "hycapi_rx_capipkt\n");
526 #endif
527 if (!cinfo) {
528 return;
529 }
530 ctrl = &cinfo->capi_ctrl;
531 if (len < CAPI_MSG_BASELEN) {
532 printk(KERN_ERR "HYSDN Card%d: invalid CAPI-message, length %d!\n",
533 card->myid, len);
534 return;
535 }
536 MsgLen = CAPIMSG_LEN(buf);
537 ApplId = CAPIMSG_APPID(buf);
538 CapiCmd = CAPIMSG_CMD(buf);
539
540 if ((CapiCmd == CAPI_DATA_B3_IND) && (MsgLen < 30)) {
541 len2 = len + (30 - MsgLen);
542 if (!(skb = alloc_skb(len2, GFP_ATOMIC))) {
543 printk(KERN_ERR "HYSDN Card%d: incoming packet dropped\n",
544 card->myid);
545 return;
546 }
547 skb_put_data(skb, buf, MsgLen);
548 skb_put_data(skb, CP64, 2 * sizeof(__u32));
549 skb_put_data(skb, buf + MsgLen, len - MsgLen);
550 CAPIMSG_SETLEN(skb->data, 30);
551 } else {
552 if (!(skb = alloc_skb(len, GFP_ATOMIC))) {
553 printk(KERN_ERR "HYSDN Card%d: incoming packet dropped\n",
554 card->myid);
555 return;
556 }
557 skb_put_data(skb, buf, len);
558 }
559 switch (CAPIMSG_CMD(skb->data))
560 {
561 case CAPI_CONNECT_B3_CONF:
562 /* Check info-field for error-indication: */
563 info = CAPIMSG_U16(skb->data, 12);
564 switch (info)
565 {
566 case 0:
567 capilib_new_ncci(&cinfo->ncci_head, ApplId, CAPIMSG_NCCI(skb->data),
568 hycapi_applications[ApplId - 1].rp.datablkcnt);
569
570 break;
571 case 0x0001:
572 printk(KERN_ERR "HYSDN Card%d: NCPI not supported by current "
573 "protocol. NCPI ignored.\n", card->myid);
574 break;
575 case 0x2001:
576 printk(KERN_ERR "HYSDN Card%d: Message not supported in"
577 " current state\n", card->myid);
578 break;
579 case 0x2002:
580 printk(KERN_ERR "HYSDN Card%d: invalid PLCI\n", card->myid);
581 break;
582 case 0x2004:
583 printk(KERN_ERR "HYSDN Card%d: out of NCCI\n", card->myid);
584 break;
585 case 0x3008:
586 printk(KERN_ERR "HYSDN Card%d: NCPI not supported\n",
587 card->myid);
588 break;
589 default:
590 printk(KERN_ERR "HYSDN Card%d: Info in CONNECT_B3_CONF: %d\n",
591 card->myid, info);
592 break;
593 }
594 break;
595 case CAPI_CONNECT_B3_IND:
596 capilib_new_ncci(&cinfo->ncci_head, ApplId,
597 CAPIMSG_NCCI(skb->data),
598 hycapi_applications[ApplId - 1].rp.datablkcnt);
599 break;
600 case CAPI_DATA_B3_CONF:
601 capilib_data_b3_conf(&cinfo->ncci_head, ApplId,
602 CAPIMSG_NCCI(skb->data),
603 CAPIMSG_MSGID(skb->data));
604 break;
605 default:
606 break;
607 }
608 capi_ctr_handle_message(ctrl, ApplId, skb);
609 }
610
611 /******************************************************************
612 hycapi_tx_capiack
613
614 Internally acknowledge a msg sent. This will remove the msg from the
615 internal queue.
616
617 *******************************************************************/
618
hycapi_tx_capiack(hysdn_card * card)619 void hycapi_tx_capiack(hysdn_card *card)
620 {
621 hycapictrl_info *cinfo = card->hyctrlinfo;
622 #ifdef HYCAPI_PRINTFNAMES
623 printk(KERN_NOTICE "hycapi_tx_capiack\n");
624 #endif
625 if (!cinfo) {
626 return;
627 }
628 spin_lock_irq(&cinfo->lock);
629 kfree_skb(cinfo->skbs[cinfo->out_idx]); /* free skb */
630 cinfo->skbs[cinfo->out_idx++] = NULL;
631 if (cinfo->out_idx >= HYSDN_MAX_CAPI_SKB)
632 cinfo->out_idx = 0; /* wrap around */
633
634 if (cinfo->sk_count-- == HYSDN_MAX_CAPI_SKB) /* dec usage count */
635 capi_ctr_resume_output(&cinfo->capi_ctrl);
636 spin_unlock_irq(&cinfo->lock);
637 }
638
639 /***************************************************************
640 hycapi_tx_capiget(hysdn_card *card)
641
642 This is called when polling for messages to SEND.
643
644 ****************************************************************/
645
646 struct sk_buff *
hycapi_tx_capiget(hysdn_card * card)647 hycapi_tx_capiget(hysdn_card *card)
648 {
649 hycapictrl_info *cinfo = card->hyctrlinfo;
650 if (!cinfo) {
651 return (struct sk_buff *)NULL;
652 }
653 if (!cinfo->sk_count)
654 return (struct sk_buff *)NULL; /* nothing available */
655
656 return (cinfo->skbs[cinfo->out_idx]); /* next packet to send */
657 }
658
659
660 /**********************************************************
661 int hycapi_init()
662
663 attach the capi-driver to the kernel-capi.
664
665 ***********************************************************/
666
hycapi_init(void)667 int hycapi_init(void)
668 {
669 int i;
670 for (i = 0; i < CAPI_MAXAPPL; i++) {
671 memset(&(hycapi_applications[i]), 0, sizeof(hycapi_appl));
672 }
673 return (0);
674 }
675
676 /**************************************************************
677 hycapi_cleanup(void)
678
679 detach the capi-driver to the kernel-capi. Actually this should
680 free some more ressources. Do that later.
681 **************************************************************/
682
683 void
hycapi_cleanup(void)684 hycapi_cleanup(void)
685 {
686 }
687
688 /********************************************************************
689 hycapi_capi_create(hysdn_card *card)
690
691 Attach the card with its capi-ctrl.
692 *********************************************************************/
693
hycapi_fill_profile(hysdn_card * card)694 static void hycapi_fill_profile(hysdn_card *card)
695 {
696 hycapictrl_info *cinfo = NULL;
697 struct capi_ctr *ctrl = NULL;
698 cinfo = card->hyctrlinfo;
699 if (!cinfo) return;
700 ctrl = &cinfo->capi_ctrl;
701 strcpy(ctrl->manu, "Hypercope");
702 ctrl->version.majorversion = 2;
703 ctrl->version.minorversion = 0;
704 ctrl->version.majormanuversion = 3;
705 ctrl->version.minormanuversion = 2;
706 ctrl->profile.ncontroller = card->myid;
707 ctrl->profile.nbchannel = card->bchans;
708 ctrl->profile.goptions = GLOBAL_OPTION_INTERNAL_CONTROLLER |
709 GLOBAL_OPTION_B_CHANNEL_OPERATION;
710 ctrl->profile.support1 = B1_PROT_64KBIT_HDLC |
711 (card->faxchans ? B1_PROT_T30 : 0) |
712 B1_PROT_64KBIT_TRANSPARENT;
713 ctrl->profile.support2 = B2_PROT_ISO7776 |
714 (card->faxchans ? B2_PROT_T30 : 0) |
715 B2_PROT_TRANSPARENT;
716 ctrl->profile.support3 = B3_PROT_TRANSPARENT |
717 B3_PROT_T90NL |
718 (card->faxchans ? B3_PROT_T30 : 0) |
719 (card->faxchans ? B3_PROT_T30EXT : 0) |
720 B3_PROT_ISO8208;
721 }
722
723 int
hycapi_capi_create(hysdn_card * card)724 hycapi_capi_create(hysdn_card *card)
725 {
726 hycapictrl_info *cinfo = NULL;
727 struct capi_ctr *ctrl = NULL;
728 int retval;
729 #ifdef HYCAPI_PRINTFNAMES
730 printk(KERN_NOTICE "hycapi_capi_create\n");
731 #endif
732 if ((hycapi_enable & (1 << card->myid)) == 0) {
733 return 1;
734 }
735 if (!card->hyctrlinfo) {
736 cinfo = kzalloc(sizeof(hycapictrl_info), GFP_ATOMIC);
737 if (!cinfo) {
738 printk(KERN_WARNING "HYSDN: no memory for capi-ctrl.\n");
739 return -ENOMEM;
740 }
741 card->hyctrlinfo = cinfo;
742 cinfo->card = card;
743 spin_lock_init(&cinfo->lock);
744 INIT_LIST_HEAD(&cinfo->ncci_head);
745
746 switch (card->brdtype) {
747 case BD_PCCARD: strcpy(cinfo->cardname, "HYSDN Hycard"); break;
748 case BD_ERGO: strcpy(cinfo->cardname, "HYSDN Ergo2"); break;
749 case BD_METRO: strcpy(cinfo->cardname, "HYSDN Metro4"); break;
750 case BD_CHAMP2: strcpy(cinfo->cardname, "HYSDN Champ2"); break;
751 case BD_PLEXUS: strcpy(cinfo->cardname, "HYSDN Plexus30"); break;
752 default: strcpy(cinfo->cardname, "HYSDN ???"); break;
753 }
754
755 ctrl = &cinfo->capi_ctrl;
756 ctrl->driver_name = "hycapi";
757 ctrl->driverdata = cinfo;
758 ctrl->register_appl = hycapi_register_appl;
759 ctrl->release_appl = hycapi_release_appl;
760 ctrl->send_message = hycapi_send_message;
761 ctrl->load_firmware = hycapi_load_firmware;
762 ctrl->reset_ctr = hycapi_reset_ctr;
763 ctrl->procinfo = hycapi_procinfo;
764 ctrl->proc_show = hycapi_proc_show;
765 strcpy(ctrl->name, cinfo->cardname);
766 ctrl->owner = THIS_MODULE;
767
768 retval = attach_capi_ctr(ctrl);
769 if (retval) {
770 printk(KERN_ERR "hycapi: attach controller failed.\n");
771 return -EBUSY;
772 }
773 /* fill in the blanks: */
774 hycapi_fill_profile(card);
775 capi_ctr_ready(ctrl);
776 } else {
777 /* resume output on stopped ctrl */
778 ctrl = &card->hyctrlinfo->capi_ctrl;
779 hycapi_fill_profile(card);
780 capi_ctr_ready(ctrl);
781 hycapi_restart_internal(ctrl);
782 /* ctrl->resume_output(ctrl); */
783 }
784 return 0;
785 }
786