Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* $Id: kcapi.c,v 1.1.2.8 2004/03/26 19:57:20 armin Exp $ |
2 | * | |
3 | * Kernel CAPI 2.0 Module | |
4 | * | |
5 | * Copyright 1999 by Carsten Paeth <calle@calle.de> | |
6 | * Copyright 2002 by Kai Germaschewski <kai@germaschewski.name> | |
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 | ||
37772ac0 | 13 | #define AVMB1_COMPAT |
1da177e4 LT |
14 | |
15 | #include "kcapi.h" | |
16 | #include <linux/module.h> | |
17 | #include <linux/mm.h> | |
18 | #include <linux/interrupt.h> | |
19 | #include <linux/ioport.h> | |
20 | #include <linux/proc_fs.h> | |
21 | #include <linux/seq_file.h> | |
22 | #include <linux/skbuff.h> | |
23 | #include <linux/workqueue.h> | |
24 | #include <linux/capi.h> | |
25 | #include <linux/kernelcapi.h> | |
26 | #include <linux/init.h> | |
27 | #include <linux/moduleparam.h> | |
28 | #include <linux/delay.h> | |
29 | #include <asm/uaccess.h> | |
30 | #include <linux/isdn/capicmd.h> | |
31 | #include <linux/isdn/capiutil.h> | |
37772ac0 | 32 | #ifdef AVMB1_COMPAT |
1da177e4 LT |
33 | #include <linux/b1lli.h> |
34 | #endif | |
9cdf1827 | 35 | #include <linux/mutex.h> |
1da177e4 LT |
36 | |
37 | static char *revision = "$Revision: 1.1.2.8 $"; | |
38 | ||
39 | /* ------------------------------------------------------------- */ | |
40 | ||
41 | static int showcapimsgs = 0; | |
42 | ||
43 | MODULE_DESCRIPTION("CAPI4Linux: kernel CAPI layer"); | |
44 | MODULE_AUTHOR("Carsten Paeth"); | |
45 | MODULE_LICENSE("GPL"); | |
46 | module_param(showcapimsgs, uint, 0); | |
47 | ||
48 | /* ------------------------------------------------------------- */ | |
49 | ||
50 | struct capi_notifier { | |
51 | struct work_struct work; | |
52 | unsigned int cmd; | |
53 | u32 controller; | |
54 | u16 applid; | |
55 | u32 ncci; | |
56 | }; | |
57 | ||
58 | /* ------------------------------------------------------------- */ | |
59 | ||
60 | static struct capi_version driver_version = {2, 0, 1, 1<<4}; | |
61 | static char driver_serial[CAPI_SERIAL_LEN] = "0004711"; | |
62 | static char capi_manufakturer[64] = "AVM Berlin"; | |
63 | ||
64 | #define NCCI2CTRL(ncci) (((ncci) >> 24) & 0x7f) | |
65 | ||
66 | LIST_HEAD(capi_drivers); | |
67 | DEFINE_RWLOCK(capi_drivers_list_lock); | |
68 | ||
69 | static DEFINE_RWLOCK(application_lock); | |
9cdf1827 | 70 | static DEFINE_MUTEX(controller_mutex); |
1da177e4 LT |
71 | |
72 | struct capi20_appl *capi_applications[CAPI_MAXAPPL]; | |
73 | struct capi_ctr *capi_cards[CAPI_MAXCONTR]; | |
74 | ||
75 | static int ncards; | |
76 | ||
77 | /* -------- controller ref counting -------------------------------------- */ | |
78 | ||
79 | static inline struct capi_ctr * | |
80 | capi_ctr_get(struct capi_ctr *card) | |
81 | { | |
82 | if (!try_module_get(card->owner)) | |
83 | return NULL; | |
84 | return card; | |
85 | } | |
86 | ||
87 | static inline void | |
88 | capi_ctr_put(struct capi_ctr *card) | |
89 | { | |
90 | module_put(card->owner); | |
91 | } | |
92 | ||
93 | /* ------------------------------------------------------------- */ | |
94 | ||
95 | static inline struct capi_ctr *get_capi_ctr_by_nr(u16 contr) | |
96 | { | |
97 | if (contr - 1 >= CAPI_MAXCONTR) | |
98 | return NULL; | |
99 | ||
100 | return capi_cards[contr - 1]; | |
101 | } | |
102 | ||
103 | static inline struct capi20_appl *get_capi_appl_by_nr(u16 applid) | |
104 | { | |
105 | if (applid - 1 >= CAPI_MAXAPPL) | |
106 | return NULL; | |
107 | ||
108 | return capi_applications[applid - 1]; | |
109 | } | |
110 | ||
111 | /* -------- util functions ------------------------------------ */ | |
112 | ||
113 | static inline int capi_cmd_valid(u8 cmd) | |
114 | { | |
115 | switch (cmd) { | |
116 | case CAPI_ALERT: | |
117 | case CAPI_CONNECT: | |
118 | case CAPI_CONNECT_ACTIVE: | |
119 | case CAPI_CONNECT_B3_ACTIVE: | |
120 | case CAPI_CONNECT_B3: | |
121 | case CAPI_CONNECT_B3_T90_ACTIVE: | |
122 | case CAPI_DATA_B3: | |
123 | case CAPI_DISCONNECT_B3: | |
124 | case CAPI_DISCONNECT: | |
125 | case CAPI_FACILITY: | |
126 | case CAPI_INFO: | |
127 | case CAPI_LISTEN: | |
128 | case CAPI_MANUFACTURER: | |
129 | case CAPI_RESET_B3: | |
130 | case CAPI_SELECT_B_PROTOCOL: | |
131 | return 1; | |
132 | } | |
133 | return 0; | |
134 | } | |
135 | ||
136 | static inline int capi_subcmd_valid(u8 subcmd) | |
137 | { | |
138 | switch (subcmd) { | |
139 | case CAPI_REQ: | |
140 | case CAPI_CONF: | |
141 | case CAPI_IND: | |
142 | case CAPI_RESP: | |
143 | return 1; | |
144 | } | |
145 | return 0; | |
146 | } | |
147 | ||
148 | /* ------------------------------------------------------------ */ | |
149 | ||
150 | static void register_appl(struct capi_ctr *card, u16 applid, capi_register_params *rparam) | |
151 | { | |
152 | card = capi_ctr_get(card); | |
153 | ||
154 | if (card) | |
155 | card->register_appl(card, applid, rparam); | |
156 | else | |
156f1ed6 | 157 | printk(KERN_WARNING "%s: cannot get card resources\n", __func__); |
1da177e4 LT |
158 | } |
159 | ||
160 | ||
161 | static void release_appl(struct capi_ctr *card, u16 applid) | |
162 | { | |
163 | DBG("applid %#x", applid); | |
164 | ||
165 | card->release_appl(card, applid); | |
166 | capi_ctr_put(card); | |
167 | } | |
168 | ||
169 | /* -------- KCI_CONTRUP --------------------------------------- */ | |
170 | ||
171 | static void notify_up(u32 contr) | |
172 | { | |
173 | struct capi_ctr *card = get_capi_ctr_by_nr(contr); | |
174 | struct capi20_appl *ap; | |
175 | u16 applid; | |
176 | ||
177 | if (showcapimsgs & 1) { | |
178 | printk(KERN_DEBUG "kcapi: notify up contr %d\n", contr); | |
179 | } | |
180 | if (!card) { | |
156f1ed6 | 181 | printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr); |
1da177e4 LT |
182 | return; |
183 | } | |
184 | for (applid = 1; applid <= CAPI_MAXAPPL; applid++) { | |
185 | ap = get_capi_appl_by_nr(applid); | |
186 | if (!ap || ap->release_in_progress) continue; | |
187 | register_appl(card, applid, &ap->rparam); | |
188 | if (ap->callback && !ap->release_in_progress) | |
189 | ap->callback(KCI_CONTRUP, contr, &card->profile); | |
190 | } | |
191 | } | |
192 | ||
193 | /* -------- KCI_CONTRDOWN ------------------------------------- */ | |
194 | ||
195 | static void notify_down(u32 contr) | |
196 | { | |
197 | struct capi20_appl *ap; | |
198 | u16 applid; | |
199 | ||
200 | if (showcapimsgs & 1) { | |
201 | printk(KERN_DEBUG "kcapi: notify down contr %d\n", contr); | |
202 | } | |
203 | ||
204 | for (applid = 1; applid <= CAPI_MAXAPPL; applid++) { | |
205 | ap = get_capi_appl_by_nr(applid); | |
206 | if (ap && ap->callback && !ap->release_in_progress) | |
207 | ap->callback(KCI_CONTRDOWN, contr, NULL); | |
208 | } | |
209 | } | |
210 | ||
c4028958 | 211 | static void notify_handler(struct work_struct *work) |
1da177e4 | 212 | { |
c4028958 DH |
213 | struct capi_notifier *np = |
214 | container_of(work, struct capi_notifier, work); | |
1da177e4 LT |
215 | |
216 | switch (np->cmd) { | |
217 | case KCI_CONTRUP: | |
218 | notify_up(np->controller); | |
219 | break; | |
220 | case KCI_CONTRDOWN: | |
221 | notify_down(np->controller); | |
222 | break; | |
223 | } | |
224 | ||
225 | kfree(np); | |
226 | } | |
227 | ||
228 | /* | |
229 | * The notifier will result in adding/deleteing of devices. Devices can | |
230 | * only removed in user process, not in bh. | |
231 | */ | |
232 | static int notify_push(unsigned int cmd, u32 controller, u16 applid, u32 ncci) | |
233 | { | |
234 | struct capi_notifier *np = kmalloc(sizeof(*np), GFP_ATOMIC); | |
235 | ||
236 | if (!np) | |
237 | return -ENOMEM; | |
238 | ||
c4028958 | 239 | INIT_WORK(&np->work, notify_handler); |
1da177e4 LT |
240 | np->cmd = cmd; |
241 | np->controller = controller; | |
242 | np->applid = applid; | |
243 | np->ncci = ncci; | |
244 | ||
245 | schedule_work(&np->work); | |
246 | return 0; | |
247 | } | |
248 | ||
249 | ||
250 | /* -------- Receiver ------------------------------------------ */ | |
251 | ||
c4028958 | 252 | static void recv_handler(struct work_struct *work) |
1da177e4 LT |
253 | { |
254 | struct sk_buff *skb; | |
c4028958 DH |
255 | struct capi20_appl *ap = |
256 | container_of(work, struct capi20_appl, recv_work); | |
1da177e4 LT |
257 | |
258 | if ((!ap) || (ap->release_in_progress)) | |
259 | return; | |
260 | ||
67837f23 | 261 | mutex_lock(&ap->recv_mtx); |
1da177e4 LT |
262 | while ((skb = skb_dequeue(&ap->recv_queue))) { |
263 | if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_IND) | |
264 | ap->nrecvdatapkt++; | |
265 | else | |
266 | ap->nrecvctlpkt++; | |
267 | ||
268 | ap->recv_message(ap, skb); | |
269 | } | |
67837f23 | 270 | mutex_unlock(&ap->recv_mtx); |
1da177e4 LT |
271 | } |
272 | ||
554f200e TS |
273 | /** |
274 | * capi_ctr_handle_message() - handle incoming CAPI message | |
275 | * @card: controller descriptor structure. | |
276 | * @appl: application ID. | |
277 | * @skb: message. | |
278 | * | |
279 | * Called by hardware driver to pass a CAPI message to the application. | |
280 | */ | |
281 | ||
1da177e4 LT |
282 | void capi_ctr_handle_message(struct capi_ctr * card, u16 appl, struct sk_buff *skb) |
283 | { | |
284 | struct capi20_appl *ap; | |
285 | int showctl = 0; | |
286 | u8 cmd, subcmd; | |
287 | unsigned long flags; | |
17f0cd2f | 288 | _cdebbuf *cdb; |
1da177e4 LT |
289 | |
290 | if (card->cardstate != CARD_RUNNING) { | |
17f0cd2f KK |
291 | cdb = capi_message2str(skb->data); |
292 | if (cdb) { | |
293 | printk(KERN_INFO "kcapi: controller [%03d] not active, got: %s", | |
294 | card->cnr, cdb->buf); | |
295 | cdebbuf_free(cdb); | |
296 | } else | |
297 | printk(KERN_INFO "kcapi: controller [%03d] not active, cannot trace\n", | |
298 | card->cnr); | |
1da177e4 LT |
299 | goto error; |
300 | } | |
301 | ||
302 | cmd = CAPIMSG_COMMAND(skb->data); | |
303 | subcmd = CAPIMSG_SUBCOMMAND(skb->data); | |
304 | if (cmd == CAPI_DATA_B3 && subcmd == CAPI_IND) { | |
305 | card->nrecvdatapkt++; | |
306 | if (card->traceflag > 2) showctl |= 2; | |
307 | } else { | |
308 | card->nrecvctlpkt++; | |
309 | if (card->traceflag) showctl |= 2; | |
310 | } | |
311 | showctl |= (card->traceflag & 1); | |
312 | if (showctl & 2) { | |
313 | if (showctl & 1) { | |
17f0cd2f KK |
314 | printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u\n", |
315 | card->cnr, CAPIMSG_APPID(skb->data), | |
1da177e4 LT |
316 | capi_cmd2str(cmd, subcmd), |
317 | CAPIMSG_LEN(skb->data)); | |
318 | } else { | |
17f0cd2f KK |
319 | cdb = capi_message2str(skb->data); |
320 | if (cdb) { | |
321 | printk(KERN_DEBUG "kcapi: got [%03d] %s\n", | |
322 | card->cnr, cdb->buf); | |
323 | cdebbuf_free(cdb); | |
324 | } else | |
325 | printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u, cannot trace\n", | |
326 | card->cnr, CAPIMSG_APPID(skb->data), | |
327 | capi_cmd2str(cmd, subcmd), | |
328 | CAPIMSG_LEN(skb->data)); | |
1da177e4 LT |
329 | } |
330 | ||
331 | } | |
332 | ||
333 | read_lock_irqsave(&application_lock, flags); | |
334 | ap = get_capi_appl_by_nr(CAPIMSG_APPID(skb->data)); | |
335 | if ((!ap) || (ap->release_in_progress)) { | |
336 | read_unlock_irqrestore(&application_lock, flags); | |
17f0cd2f KK |
337 | cdb = capi_message2str(skb->data); |
338 | if (cdb) { | |
339 | printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s)\n", | |
340 | CAPIMSG_APPID(skb->data), cdb->buf); | |
341 | cdebbuf_free(cdb); | |
342 | } else | |
343 | printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s) cannot trace\n", | |
344 | CAPIMSG_APPID(skb->data), | |
345 | capi_cmd2str(cmd, subcmd)); | |
1da177e4 LT |
346 | goto error; |
347 | } | |
348 | skb_queue_tail(&ap->recv_queue, skb); | |
349 | schedule_work(&ap->recv_work); | |
350 | read_unlock_irqrestore(&application_lock, flags); | |
351 | ||
352 | return; | |
353 | ||
354 | error: | |
355 | kfree_skb(skb); | |
356 | } | |
357 | ||
358 | EXPORT_SYMBOL(capi_ctr_handle_message); | |
359 | ||
554f200e TS |
360 | /** |
361 | * capi_ctr_ready() - signal CAPI controller ready | |
362 | * @card: controller descriptor structure. | |
363 | * | |
364 | * Called by hardware driver to signal that the controller is up and running. | |
365 | */ | |
366 | ||
1da177e4 LT |
367 | void capi_ctr_ready(struct capi_ctr * card) |
368 | { | |
369 | card->cardstate = CARD_RUNNING; | |
370 | ||
17f0cd2f | 371 | printk(KERN_NOTICE "kcapi: card [%03d] \"%s\" ready.\n", |
1da177e4 LT |
372 | card->cnr, card->name); |
373 | ||
374 | notify_push(KCI_CONTRUP, card->cnr, 0, 0); | |
375 | } | |
376 | ||
377 | EXPORT_SYMBOL(capi_ctr_ready); | |
378 | ||
554f200e | 379 | /** |
4e329972 | 380 | * capi_ctr_down() - signal CAPI controller not ready |
554f200e TS |
381 | * @card: controller descriptor structure. |
382 | * | |
383 | * Called by hardware driver to signal that the controller is down and | |
384 | * unavailable for use. | |
385 | */ | |
386 | ||
4e329972 | 387 | void capi_ctr_down(struct capi_ctr * card) |
1da177e4 LT |
388 | { |
389 | u16 appl; | |
390 | ||
391 | DBG(""); | |
392 | ||
393 | if (card->cardstate == CARD_DETECTED) | |
394 | return; | |
395 | ||
396 | card->cardstate = CARD_DETECTED; | |
397 | ||
398 | memset(card->manu, 0, sizeof(card->manu)); | |
399 | memset(&card->version, 0, sizeof(card->version)); | |
400 | memset(&card->profile, 0, sizeof(card->profile)); | |
401 | memset(card->serial, 0, sizeof(card->serial)); | |
402 | ||
403 | for (appl = 1; appl <= CAPI_MAXAPPL; appl++) { | |
404 | struct capi20_appl *ap = get_capi_appl_by_nr(appl); | |
405 | if (!ap || ap->release_in_progress) | |
406 | continue; | |
407 | ||
408 | capi_ctr_put(card); | |
409 | } | |
410 | ||
17f0cd2f | 411 | printk(KERN_NOTICE "kcapi: card [%03d] down.\n", card->cnr); |
1da177e4 LT |
412 | |
413 | notify_push(KCI_CONTRDOWN, card->cnr, 0, 0); | |
414 | } | |
415 | ||
4e329972 | 416 | EXPORT_SYMBOL(capi_ctr_down); |
1da177e4 | 417 | |
554f200e TS |
418 | /** |
419 | * capi_ctr_suspend_output() - suspend controller | |
420 | * @card: controller descriptor structure. | |
421 | * | |
422 | * Called by hardware driver to stop data flow. | |
423 | */ | |
424 | ||
1da177e4 LT |
425 | void capi_ctr_suspend_output(struct capi_ctr *card) |
426 | { | |
427 | if (!card->blocked) { | |
17f0cd2f | 428 | printk(KERN_DEBUG "kcapi: card [%03d] suspend\n", card->cnr); |
1da177e4 LT |
429 | card->blocked = 1; |
430 | } | |
431 | } | |
432 | ||
433 | EXPORT_SYMBOL(capi_ctr_suspend_output); | |
434 | ||
554f200e TS |
435 | /** |
436 | * capi_ctr_resume_output() - resume controller | |
437 | * @card: controller descriptor structure. | |
438 | * | |
439 | * Called by hardware driver to resume data flow. | |
440 | */ | |
441 | ||
1da177e4 LT |
442 | void capi_ctr_resume_output(struct capi_ctr *card) |
443 | { | |
444 | if (card->blocked) { | |
17f0cd2f | 445 | printk(KERN_DEBUG "kcapi: card [%03d] resume\n", card->cnr); |
1da177e4 LT |
446 | card->blocked = 0; |
447 | } | |
448 | } | |
449 | ||
450 | EXPORT_SYMBOL(capi_ctr_resume_output); | |
451 | ||
452 | /* ------------------------------------------------------------- */ | |
453 | ||
554f200e TS |
454 | /** |
455 | * attach_capi_ctr() - register CAPI controller | |
456 | * @card: controller descriptor structure. | |
457 | * | |
458 | * Called by hardware driver to register a controller with the CAPI subsystem. | |
459 | * Return value: 0 on success, error code < 0 on error | |
460 | */ | |
461 | ||
1da177e4 LT |
462 | int |
463 | attach_capi_ctr(struct capi_ctr *card) | |
464 | { | |
465 | int i; | |
466 | ||
9cdf1827 | 467 | mutex_lock(&controller_mutex); |
1da177e4 LT |
468 | |
469 | for (i = 0; i < CAPI_MAXCONTR; i++) { | |
470 | if (capi_cards[i] == NULL) | |
471 | break; | |
472 | } | |
473 | if (i == CAPI_MAXCONTR) { | |
9cdf1827 | 474 | mutex_unlock(&controller_mutex); |
1da177e4 LT |
475 | printk(KERN_ERR "kcapi: out of controller slots\n"); |
476 | return -EBUSY; | |
477 | } | |
478 | capi_cards[i] = card; | |
479 | ||
9cdf1827 | 480 | mutex_unlock(&controller_mutex); |
1da177e4 LT |
481 | |
482 | card->nrecvctlpkt = 0; | |
483 | card->nrecvdatapkt = 0; | |
484 | card->nsentctlpkt = 0; | |
485 | card->nsentdatapkt = 0; | |
486 | card->cnr = i + 1; | |
487 | card->cardstate = CARD_DETECTED; | |
488 | card->blocked = 0; | |
489 | card->traceflag = showcapimsgs; | |
490 | ||
491 | sprintf(card->procfn, "capi/controllers/%d", card->cnr); | |
492 | card->procent = create_proc_entry(card->procfn, 0, NULL); | |
493 | if (card->procent) { | |
494 | card->procent->read_proc = | |
495 | (int (*)(char *,char **,off_t,int,int *,void *)) | |
496 | card->ctr_read_proc; | |
497 | card->procent->data = card; | |
498 | } | |
499 | ||
500 | ncards++; | |
17f0cd2f | 501 | printk(KERN_NOTICE "kcapi: Controller [%03d]: %s attached\n", |
1da177e4 LT |
502 | card->cnr, card->name); |
503 | return 0; | |
504 | } | |
505 | ||
506 | EXPORT_SYMBOL(attach_capi_ctr); | |
507 | ||
554f200e TS |
508 | /** |
509 | * detach_capi_ctr() - unregister CAPI controller | |
510 | * @card: controller descriptor structure. | |
511 | * | |
512 | * Called by hardware driver to remove the registration of a controller | |
513 | * with the CAPI subsystem. | |
514 | * Return value: 0 on success, error code < 0 on error | |
515 | */ | |
516 | ||
1da177e4 LT |
517 | int detach_capi_ctr(struct capi_ctr *card) |
518 | { | |
519 | if (card->cardstate != CARD_DETECTED) | |
4e329972 | 520 | capi_ctr_down(card); |
1da177e4 LT |
521 | |
522 | ncards--; | |
523 | ||
524 | if (card->procent) { | |
525 | remove_proc_entry(card->procfn, NULL); | |
526 | card->procent = NULL; | |
527 | } | |
528 | capi_cards[card->cnr - 1] = NULL; | |
17f0cd2f | 529 | printk(KERN_NOTICE "kcapi: Controller [%03d]: %s unregistered\n", |
1da177e4 LT |
530 | card->cnr, card->name); |
531 | ||
532 | return 0; | |
533 | } | |
534 | ||
535 | EXPORT_SYMBOL(detach_capi_ctr); | |
536 | ||
554f200e TS |
537 | /** |
538 | * register_capi_driver() - register CAPI driver | |
539 | * @driver: driver descriptor structure. | |
540 | * | |
541 | * Called by hardware driver to register itself with the CAPI subsystem. | |
542 | */ | |
543 | ||
1da177e4 LT |
544 | void register_capi_driver(struct capi_driver *driver) |
545 | { | |
546 | unsigned long flags; | |
547 | ||
548 | write_lock_irqsave(&capi_drivers_list_lock, flags); | |
549 | list_add_tail(&driver->list, &capi_drivers); | |
550 | write_unlock_irqrestore(&capi_drivers_list_lock, flags); | |
551 | } | |
552 | ||
553 | EXPORT_SYMBOL(register_capi_driver); | |
554 | ||
554f200e TS |
555 | /** |
556 | * unregister_capi_driver() - unregister CAPI driver | |
557 | * @driver: driver descriptor structure. | |
558 | * | |
559 | * Called by hardware driver to unregister itself from the CAPI subsystem. | |
560 | */ | |
561 | ||
1da177e4 LT |
562 | void unregister_capi_driver(struct capi_driver *driver) |
563 | { | |
564 | unsigned long flags; | |
565 | ||
566 | write_lock_irqsave(&capi_drivers_list_lock, flags); | |
567 | list_del(&driver->list); | |
568 | write_unlock_irqrestore(&capi_drivers_list_lock, flags); | |
569 | } | |
570 | ||
571 | EXPORT_SYMBOL(unregister_capi_driver); | |
572 | ||
573 | /* ------------------------------------------------------------- */ | |
574 | /* -------- CAPI2.0 Interface ---------------------------------- */ | |
575 | /* ------------------------------------------------------------- */ | |
576 | ||
554f200e TS |
577 | /** |
578 | * capi20_isinstalled() - CAPI 2.0 operation CAPI_INSTALLED | |
579 | * | |
580 | * Return value: CAPI result code (CAPI_NOERROR if at least one ISDN controller | |
581 | * is ready for use, CAPI_REGNOTINSTALLED otherwise) | |
582 | */ | |
583 | ||
1da177e4 LT |
584 | u16 capi20_isinstalled(void) |
585 | { | |
586 | int i; | |
587 | for (i = 0; i < CAPI_MAXCONTR; i++) { | |
588 | if (capi_cards[i] && capi_cards[i]->cardstate == CARD_RUNNING) | |
589 | return CAPI_NOERROR; | |
590 | } | |
591 | return CAPI_REGNOTINSTALLED; | |
592 | } | |
593 | ||
594 | EXPORT_SYMBOL(capi20_isinstalled); | |
595 | ||
554f200e TS |
596 | /** |
597 | * capi20_register() - CAPI 2.0 operation CAPI_REGISTER | |
598 | * @ap: CAPI application descriptor structure. | |
599 | * | |
600 | * Register an application's presence with CAPI. | |
601 | * A unique application ID is assigned and stored in @ap->applid. | |
602 | * After this function returns successfully, the message receive | |
603 | * callback function @ap->recv_message() may be called at any time | |
604 | * until capi20_release() has been called for the same @ap. | |
605 | * Return value: CAPI result code | |
606 | */ | |
607 | ||
1da177e4 LT |
608 | u16 capi20_register(struct capi20_appl *ap) |
609 | { | |
610 | int i; | |
611 | u16 applid; | |
612 | unsigned long flags; | |
613 | ||
614 | DBG(""); | |
615 | ||
616 | if (ap->rparam.datablklen < 128) | |
617 | return CAPI_LOGBLKSIZETOSMALL; | |
618 | ||
619 | write_lock_irqsave(&application_lock, flags); | |
620 | ||
621 | for (applid = 1; applid <= CAPI_MAXAPPL; applid++) { | |
622 | if (capi_applications[applid - 1] == NULL) | |
623 | break; | |
624 | } | |
625 | if (applid > CAPI_MAXAPPL) { | |
626 | write_unlock_irqrestore(&application_lock, flags); | |
627 | return CAPI_TOOMANYAPPLS; | |
628 | } | |
629 | ||
630 | ap->applid = applid; | |
631 | capi_applications[applid - 1] = ap; | |
632 | ||
633 | ap->nrecvctlpkt = 0; | |
634 | ap->nrecvdatapkt = 0; | |
635 | ap->nsentctlpkt = 0; | |
636 | ap->nsentdatapkt = 0; | |
637 | ap->callback = NULL; | |
67837f23 | 638 | mutex_init(&ap->recv_mtx); |
1da177e4 | 639 | skb_queue_head_init(&ap->recv_queue); |
c4028958 | 640 | INIT_WORK(&ap->recv_work, recv_handler); |
1da177e4 LT |
641 | ap->release_in_progress = 0; |
642 | ||
643 | write_unlock_irqrestore(&application_lock, flags); | |
644 | ||
9cdf1827 | 645 | mutex_lock(&controller_mutex); |
1da177e4 LT |
646 | for (i = 0; i < CAPI_MAXCONTR; i++) { |
647 | if (!capi_cards[i] || capi_cards[i]->cardstate != CARD_RUNNING) | |
648 | continue; | |
649 | register_appl(capi_cards[i], applid, &ap->rparam); | |
650 | } | |
9cdf1827 | 651 | mutex_unlock(&controller_mutex); |
1da177e4 LT |
652 | |
653 | if (showcapimsgs & 1) { | |
654 | printk(KERN_DEBUG "kcapi: appl %d up\n", applid); | |
655 | } | |
656 | ||
657 | return CAPI_NOERROR; | |
658 | } | |
659 | ||
660 | EXPORT_SYMBOL(capi20_register); | |
661 | ||
554f200e TS |
662 | /** |
663 | * capi20_release() - CAPI 2.0 operation CAPI_RELEASE | |
664 | * @ap: CAPI application descriptor structure. | |
665 | * | |
666 | * Terminate an application's registration with CAPI. | |
667 | * After this function returns successfully, the message receive | |
668 | * callback function @ap->recv_message() will no longer be called. | |
669 | * Return value: CAPI result code | |
670 | */ | |
671 | ||
1da177e4 LT |
672 | u16 capi20_release(struct capi20_appl *ap) |
673 | { | |
674 | int i; | |
675 | unsigned long flags; | |
676 | ||
677 | DBG("applid %#x", ap->applid); | |
678 | ||
679 | write_lock_irqsave(&application_lock, flags); | |
680 | ap->release_in_progress = 1; | |
681 | capi_applications[ap->applid - 1] = NULL; | |
682 | write_unlock_irqrestore(&application_lock, flags); | |
683 | ||
9cdf1827 | 684 | mutex_lock(&controller_mutex); |
1da177e4 LT |
685 | for (i = 0; i < CAPI_MAXCONTR; i++) { |
686 | if (!capi_cards[i] || capi_cards[i]->cardstate != CARD_RUNNING) | |
687 | continue; | |
688 | release_appl(capi_cards[i], ap->applid); | |
689 | } | |
9cdf1827 | 690 | mutex_unlock(&controller_mutex); |
1da177e4 LT |
691 | |
692 | flush_scheduled_work(); | |
693 | skb_queue_purge(&ap->recv_queue); | |
694 | ||
695 | if (showcapimsgs & 1) { | |
696 | printk(KERN_DEBUG "kcapi: appl %d down\n", ap->applid); | |
697 | } | |
698 | ||
699 | return CAPI_NOERROR; | |
700 | } | |
701 | ||
702 | EXPORT_SYMBOL(capi20_release); | |
703 | ||
554f200e TS |
704 | /** |
705 | * capi20_put_message() - CAPI 2.0 operation CAPI_PUT_MESSAGE | |
706 | * @ap: CAPI application descriptor structure. | |
707 | * @skb: CAPI message. | |
708 | * | |
709 | * Transfer a single message to CAPI. | |
710 | * Return value: CAPI result code | |
711 | */ | |
712 | ||
1da177e4 LT |
713 | u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb) |
714 | { | |
715 | struct capi_ctr *card; | |
716 | int showctl = 0; | |
717 | u8 cmd, subcmd; | |
718 | ||
719 | DBG("applid %#x", ap->applid); | |
720 | ||
721 | if (ncards == 0) | |
722 | return CAPI_REGNOTINSTALLED; | |
723 | if ((ap->applid == 0) || ap->release_in_progress) | |
724 | return CAPI_ILLAPPNR; | |
725 | if (skb->len < 12 | |
726 | || !capi_cmd_valid(CAPIMSG_COMMAND(skb->data)) | |
727 | || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data))) | |
728 | return CAPI_ILLCMDORSUBCMDORMSGTOSMALL; | |
729 | card = get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb->data)); | |
730 | if (!card || card->cardstate != CARD_RUNNING) { | |
731 | card = get_capi_ctr_by_nr(1); // XXX why? | |
732 | if (!card || card->cardstate != CARD_RUNNING) | |
733 | return CAPI_REGNOTINSTALLED; | |
734 | } | |
735 | if (card->blocked) | |
736 | return CAPI_SENDQUEUEFULL; | |
737 | ||
738 | cmd = CAPIMSG_COMMAND(skb->data); | |
739 | subcmd = CAPIMSG_SUBCOMMAND(skb->data); | |
740 | ||
741 | if (cmd == CAPI_DATA_B3 && subcmd== CAPI_REQ) { | |
742 | card->nsentdatapkt++; | |
743 | ap->nsentdatapkt++; | |
744 | if (card->traceflag > 2) showctl |= 2; | |
745 | } else { | |
746 | card->nsentctlpkt++; | |
747 | ap->nsentctlpkt++; | |
748 | if (card->traceflag) showctl |= 2; | |
749 | } | |
750 | showctl |= (card->traceflag & 1); | |
751 | if (showctl & 2) { | |
752 | if (showctl & 1) { | |
17f0cd2f | 753 | printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u\n", |
1da177e4 LT |
754 | CAPIMSG_CONTROLLER(skb->data), |
755 | CAPIMSG_APPID(skb->data), | |
756 | capi_cmd2str(cmd, subcmd), | |
757 | CAPIMSG_LEN(skb->data)); | |
758 | } else { | |
17f0cd2f KK |
759 | _cdebbuf *cdb = capi_message2str(skb->data); |
760 | if (cdb) { | |
761 | printk(KERN_DEBUG "kcapi: put [%03d] %s\n", | |
762 | CAPIMSG_CONTROLLER(skb->data), | |
763 | cdb->buf); | |
764 | cdebbuf_free(cdb); | |
765 | } else | |
766 | printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u cannot trace\n", | |
767 | CAPIMSG_CONTROLLER(skb->data), | |
768 | CAPIMSG_APPID(skb->data), | |
769 | capi_cmd2str(cmd, subcmd), | |
770 | CAPIMSG_LEN(skb->data)); | |
1da177e4 | 771 | } |
1da177e4 LT |
772 | } |
773 | return card->send_message(card, skb); | |
774 | } | |
775 | ||
776 | EXPORT_SYMBOL(capi20_put_message); | |
777 | ||
554f200e TS |
778 | /** |
779 | * capi20_get_manufacturer() - CAPI 2.0 operation CAPI_GET_MANUFACTURER | |
780 | * @contr: controller number. | |
781 | * @buf: result buffer (64 bytes). | |
782 | * | |
783 | * Retrieve information about the manufacturer of the specified ISDN controller | |
784 | * or (for @contr == 0) the driver itself. | |
785 | * Return value: CAPI result code | |
786 | */ | |
787 | ||
1da177e4 LT |
788 | u16 capi20_get_manufacturer(u32 contr, u8 *buf) |
789 | { | |
790 | struct capi_ctr *card; | |
791 | ||
792 | if (contr == 0) { | |
793 | strlcpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN); | |
794 | return CAPI_NOERROR; | |
795 | } | |
796 | card = get_capi_ctr_by_nr(contr); | |
797 | if (!card || card->cardstate != CARD_RUNNING) | |
798 | return CAPI_REGNOTINSTALLED; | |
799 | strlcpy(buf, card->manu, CAPI_MANUFACTURER_LEN); | |
800 | return CAPI_NOERROR; | |
801 | } | |
802 | ||
803 | EXPORT_SYMBOL(capi20_get_manufacturer); | |
804 | ||
554f200e TS |
805 | /** |
806 | * capi20_get_version() - CAPI 2.0 operation CAPI_GET_VERSION | |
807 | * @contr: controller number. | |
808 | * @verp: result structure. | |
809 | * | |
810 | * Retrieve version information for the specified ISDN controller | |
811 | * or (for @contr == 0) the driver itself. | |
812 | * Return value: CAPI result code | |
813 | */ | |
814 | ||
1da177e4 LT |
815 | u16 capi20_get_version(u32 contr, struct capi_version *verp) |
816 | { | |
817 | struct capi_ctr *card; | |
818 | ||
819 | if (contr == 0) { | |
820 | *verp = driver_version; | |
821 | return CAPI_NOERROR; | |
822 | } | |
823 | card = get_capi_ctr_by_nr(contr); | |
824 | if (!card || card->cardstate != CARD_RUNNING) | |
825 | return CAPI_REGNOTINSTALLED; | |
826 | ||
827 | memcpy((void *) verp, &card->version, sizeof(capi_version)); | |
828 | return CAPI_NOERROR; | |
829 | } | |
830 | ||
831 | EXPORT_SYMBOL(capi20_get_version); | |
832 | ||
554f200e TS |
833 | /** |
834 | * capi20_get_serial() - CAPI 2.0 operation CAPI_GET_SERIAL_NUMBER | |
835 | * @contr: controller number. | |
836 | * @serial: result buffer (8 bytes). | |
837 | * | |
838 | * Retrieve the serial number of the specified ISDN controller | |
839 | * or (for @contr == 0) the driver itself. | |
840 | * Return value: CAPI result code | |
841 | */ | |
842 | ||
1da177e4 LT |
843 | u16 capi20_get_serial(u32 contr, u8 *serial) |
844 | { | |
845 | struct capi_ctr *card; | |
846 | ||
847 | if (contr == 0) { | |
848 | strlcpy(serial, driver_serial, CAPI_SERIAL_LEN); | |
849 | return CAPI_NOERROR; | |
850 | } | |
851 | card = get_capi_ctr_by_nr(contr); | |
852 | if (!card || card->cardstate != CARD_RUNNING) | |
853 | return CAPI_REGNOTINSTALLED; | |
854 | ||
855 | strlcpy((void *) serial, card->serial, CAPI_SERIAL_LEN); | |
856 | return CAPI_NOERROR; | |
857 | } | |
858 | ||
859 | EXPORT_SYMBOL(capi20_get_serial); | |
860 | ||
554f200e TS |
861 | /** |
862 | * capi20_get_profile() - CAPI 2.0 operation CAPI_GET_PROFILE | |
863 | * @contr: controller number. | |
864 | * @profp: result structure. | |
865 | * | |
866 | * Retrieve capability information for the specified ISDN controller | |
867 | * or (for @contr == 0) the number of installed controllers. | |
868 | * Return value: CAPI result code | |
869 | */ | |
870 | ||
1da177e4 LT |
871 | u16 capi20_get_profile(u32 contr, struct capi_profile *profp) |
872 | { | |
873 | struct capi_ctr *card; | |
874 | ||
875 | if (contr == 0) { | |
876 | profp->ncontroller = ncards; | |
877 | return CAPI_NOERROR; | |
878 | } | |
879 | card = get_capi_ctr_by_nr(contr); | |
880 | if (!card || card->cardstate != CARD_RUNNING) | |
881 | return CAPI_REGNOTINSTALLED; | |
882 | ||
883 | memcpy((void *) profp, &card->profile, | |
884 | sizeof(struct capi_profile)); | |
885 | return CAPI_NOERROR; | |
886 | } | |
887 | ||
888 | EXPORT_SYMBOL(capi20_get_profile); | |
889 | ||
37772ac0 | 890 | #ifdef AVMB1_COMPAT |
1da177e4 LT |
891 | static int old_capi_manufacturer(unsigned int cmd, void __user *data) |
892 | { | |
893 | avmb1_loadandconfigdef ldef; | |
894 | avmb1_extcarddef cdef; | |
895 | avmb1_resetdef rdef; | |
896 | capicardparams cparams; | |
897 | struct capi_ctr *card; | |
898 | struct capi_driver *driver = NULL; | |
899 | capiloaddata ldata; | |
900 | struct list_head *l; | |
901 | unsigned long flags; | |
902 | int retval; | |
903 | ||
904 | switch (cmd) { | |
905 | case AVMB1_ADDCARD: | |
906 | case AVMB1_ADDCARD_WITH_TYPE: | |
907 | if (cmd == AVMB1_ADDCARD) { | |
908 | if ((retval = copy_from_user(&cdef, data, | |
909 | sizeof(avmb1_carddef)))) | |
910 | return retval; | |
911 | cdef.cardtype = AVM_CARDTYPE_B1; | |
912 | } else { | |
913 | if ((retval = copy_from_user(&cdef, data, | |
914 | sizeof(avmb1_extcarddef)))) | |
915 | return retval; | |
916 | } | |
917 | cparams.port = cdef.port; | |
918 | cparams.irq = cdef.irq; | |
919 | cparams.cardnr = cdef.cardnr; | |
920 | ||
921 | read_lock_irqsave(&capi_drivers_list_lock, flags); | |
922 | switch (cdef.cardtype) { | |
923 | case AVM_CARDTYPE_B1: | |
924 | list_for_each(l, &capi_drivers) { | |
925 | driver = list_entry(l, struct capi_driver, list); | |
926 | if (strcmp(driver->name, "b1isa") == 0) | |
927 | break; | |
928 | } | |
929 | break; | |
930 | case AVM_CARDTYPE_T1: | |
931 | list_for_each(l, &capi_drivers) { | |
932 | driver = list_entry(l, struct capi_driver, list); | |
933 | if (strcmp(driver->name, "t1isa") == 0) | |
934 | break; | |
935 | } | |
936 | break; | |
937 | default: | |
938 | driver = NULL; | |
939 | break; | |
940 | } | |
941 | if (!driver) { | |
942 | read_unlock_irqrestore(&capi_drivers_list_lock, flags); | |
943 | printk(KERN_ERR "kcapi: driver not loaded.\n"); | |
944 | return -EIO; | |
945 | } | |
946 | if (!driver->add_card) { | |
947 | read_unlock_irqrestore(&capi_drivers_list_lock, flags); | |
948 | printk(KERN_ERR "kcapi: driver has no add card function.\n"); | |
949 | return -EIO; | |
950 | } | |
951 | ||
952 | retval = driver->add_card(driver, &cparams); | |
953 | read_unlock_irqrestore(&capi_drivers_list_lock, flags); | |
954 | return retval; | |
955 | ||
956 | case AVMB1_LOAD: | |
957 | case AVMB1_LOAD_AND_CONFIG: | |
958 | ||
959 | if (cmd == AVMB1_LOAD) { | |
960 | if (copy_from_user(&ldef, data, | |
961 | sizeof(avmb1_loaddef))) | |
962 | return -EFAULT; | |
963 | ldef.t4config.len = 0; | |
964 | ldef.t4config.data = NULL; | |
965 | } else { | |
966 | if (copy_from_user(&ldef, data, | |
967 | sizeof(avmb1_loadandconfigdef))) | |
968 | return -EFAULT; | |
969 | } | |
970 | card = get_capi_ctr_by_nr(ldef.contr); | |
e8a285b7 JJ |
971 | if (!card) |
972 | return -EINVAL; | |
1da177e4 LT |
973 | card = capi_ctr_get(card); |
974 | if (!card) | |
975 | return -ESRCH; | |
2f9e9b6d | 976 | if (card->load_firmware == NULL) { |
1da177e4 | 977 | printk(KERN_DEBUG "kcapi: load: no load function\n"); |
4d5392cc | 978 | capi_ctr_put(card); |
1da177e4 LT |
979 | return -ESRCH; |
980 | } | |
981 | ||
982 | if (ldef.t4file.len <= 0) { | |
983 | printk(KERN_DEBUG "kcapi: load: invalid parameter: length of t4file is %d ?\n", ldef.t4file.len); | |
4d5392cc | 984 | capi_ctr_put(card); |
1da177e4 LT |
985 | return -EINVAL; |
986 | } | |
2f9e9b6d | 987 | if (ldef.t4file.data == NULL) { |
1da177e4 | 988 | printk(KERN_DEBUG "kcapi: load: invalid parameter: dataptr is 0\n"); |
4d5392cc | 989 | capi_ctr_put(card); |
1da177e4 LT |
990 | return -EINVAL; |
991 | } | |
992 | ||
993 | ldata.firmware.user = 1; | |
994 | ldata.firmware.data = ldef.t4file.data; | |
995 | ldata.firmware.len = ldef.t4file.len; | |
996 | ldata.configuration.user = 1; | |
997 | ldata.configuration.data = ldef.t4config.data; | |
998 | ldata.configuration.len = ldef.t4config.len; | |
999 | ||
1000 | if (card->cardstate != CARD_DETECTED) { | |
1001 | printk(KERN_INFO "kcapi: load: contr=%d not in detect state\n", ldef.contr); | |
4d5392cc | 1002 | capi_ctr_put(card); |
1da177e4 LT |
1003 | return -EBUSY; |
1004 | } | |
1005 | card->cardstate = CARD_LOADING; | |
1006 | ||
1007 | retval = card->load_firmware(card, &ldata); | |
1008 | ||
1009 | if (retval) { | |
1010 | card->cardstate = CARD_DETECTED; | |
1011 | capi_ctr_put(card); | |
1012 | return retval; | |
1013 | } | |
1014 | ||
1015 | while (card->cardstate != CARD_RUNNING) { | |
1016 | ||
1017 | msleep_interruptible(100); /* 0.1 sec */ | |
1018 | ||
1019 | if (signal_pending(current)) { | |
1020 | capi_ctr_put(card); | |
1021 | return -EINTR; | |
1022 | } | |
1023 | } | |
1024 | capi_ctr_put(card); | |
1025 | return 0; | |
1026 | ||
1027 | case AVMB1_RESETCARD: | |
1028 | if (copy_from_user(&rdef, data, sizeof(avmb1_resetdef))) | |
1029 | return -EFAULT; | |
1030 | card = get_capi_ctr_by_nr(rdef.contr); | |
1031 | if (!card) | |
1032 | return -ESRCH; | |
1033 | ||
1034 | if (card->cardstate == CARD_DETECTED) | |
1035 | return 0; | |
1036 | ||
1037 | card->reset_ctr(card); | |
1038 | ||
1039 | while (card->cardstate > CARD_DETECTED) { | |
1040 | ||
1041 | msleep_interruptible(100); /* 0.1 sec */ | |
1042 | ||
1043 | if (signal_pending(current)) | |
1044 | return -EINTR; | |
1045 | } | |
1046 | return 0; | |
1047 | ||
1048 | } | |
1049 | return -EINVAL; | |
1050 | } | |
1051 | #endif | |
1052 | ||
554f200e TS |
1053 | /** |
1054 | * capi20_manufacturer() - CAPI 2.0 operation CAPI_MANUFACTURER | |
1055 | * @cmd: command. | |
1056 | * @data: parameter. | |
1057 | * | |
1058 | * Perform manufacturer specific command. | |
1059 | * Return value: CAPI result code | |
1060 | */ | |
1061 | ||
1da177e4 LT |
1062 | int capi20_manufacturer(unsigned int cmd, void __user *data) |
1063 | { | |
1064 | struct capi_ctr *card; | |
1065 | ||
1066 | switch (cmd) { | |
37772ac0 | 1067 | #ifdef AVMB1_COMPAT |
1da177e4 LT |
1068 | case AVMB1_LOAD: |
1069 | case AVMB1_LOAD_AND_CONFIG: | |
1070 | case AVMB1_RESETCARD: | |
1071 | case AVMB1_GET_CARDINFO: | |
1072 | case AVMB1_REMOVECARD: | |
1073 | return old_capi_manufacturer(cmd, data); | |
1074 | #endif | |
1075 | case KCAPI_CMD_TRACE: | |
1076 | { | |
1077 | kcapi_flagdef fdef; | |
1078 | ||
1079 | if (copy_from_user(&fdef, data, sizeof(kcapi_flagdef))) | |
1080 | return -EFAULT; | |
1081 | ||
1082 | card = get_capi_ctr_by_nr(fdef.contr); | |
1083 | if (!card) | |
1084 | return -ESRCH; | |
1085 | ||
1086 | card->traceflag = fdef.flag; | |
17f0cd2f | 1087 | printk(KERN_INFO "kcapi: contr [%03d] set trace=%d\n", |
1da177e4 LT |
1088 | card->cnr, card->traceflag); |
1089 | return 0; | |
1090 | } | |
1091 | case KCAPI_CMD_ADDCARD: | |
1092 | { | |
1093 | struct list_head *l; | |
1094 | struct capi_driver *driver = NULL; | |
1095 | capicardparams cparams; | |
1096 | kcapi_carddef cdef; | |
1097 | int retval; | |
1098 | ||
1099 | if ((retval = copy_from_user(&cdef, data, sizeof(cdef)))) | |
1100 | return retval; | |
1101 | ||
1102 | cparams.port = cdef.port; | |
1103 | cparams.irq = cdef.irq; | |
1104 | cparams.membase = cdef.membase; | |
1105 | cparams.cardnr = cdef.cardnr; | |
1106 | cparams.cardtype = 0; | |
1107 | cdef.driver[sizeof(cdef.driver)-1] = 0; | |
1108 | ||
1109 | list_for_each(l, &capi_drivers) { | |
1110 | driver = list_entry(l, struct capi_driver, list); | |
1111 | if (strcmp(driver->name, cdef.driver) == 0) | |
1112 | break; | |
1113 | } | |
2f9e9b6d | 1114 | if (driver == NULL) { |
1da177e4 LT |
1115 | printk(KERN_ERR "kcapi: driver \"%s\" not loaded.\n", |
1116 | cdef.driver); | |
1117 | return -ESRCH; | |
1118 | } | |
1119 | ||
1120 | if (!driver->add_card) { | |
1121 | printk(KERN_ERR "kcapi: driver \"%s\" has no add card function.\n", cdef.driver); | |
1122 | return -EIO; | |
1123 | } | |
1124 | ||
1125 | return driver->add_card(driver, &cparams); | |
1126 | } | |
1127 | ||
1128 | default: | |
1129 | printk(KERN_ERR "kcapi: manufacturer command %d unknown.\n", | |
1130 | cmd); | |
1131 | break; | |
1132 | ||
1133 | } | |
1134 | return -EINVAL; | |
1135 | } | |
1136 | ||
1137 | EXPORT_SYMBOL(capi20_manufacturer); | |
1138 | ||
1139 | /* temporary hack */ | |
554f200e TS |
1140 | |
1141 | /** | |
1142 | * capi20_set_callback() - set CAPI application notification callback function | |
1143 | * @ap: CAPI application descriptor structure. | |
1144 | * @callback: callback function (NULL to remove). | |
1145 | * | |
1146 | * If not NULL, the callback function will be called to notify the | |
1147 | * application of the addition or removal of a controller. | |
1148 | * The first argument (cmd) will tell whether the controller was added | |
1149 | * (KCI_CONTRUP) or removed (KCI_CONTRDOWN). | |
1150 | * The second argument (contr) will be the controller number. | |
1151 | * For cmd==KCI_CONTRUP the third argument (data) will be a pointer to the | |
1152 | * new controller's capability profile structure. | |
1153 | */ | |
1154 | ||
1da177e4 LT |
1155 | void capi20_set_callback(struct capi20_appl *ap, |
1156 | void (*callback) (unsigned int cmd, __u32 contr, void *data)) | |
1157 | { | |
1158 | ap->callback = callback; | |
1159 | } | |
1160 | ||
1161 | EXPORT_SYMBOL(capi20_set_callback); | |
1162 | ||
1163 | /* ------------------------------------------------------------- */ | |
1164 | /* -------- Init & Cleanup ------------------------------------- */ | |
1165 | /* ------------------------------------------------------------- */ | |
1166 | ||
1167 | /* | |
1168 | * init / exit functions | |
1169 | */ | |
1170 | ||
1171 | static int __init kcapi_init(void) | |
1172 | { | |
1173 | char *p; | |
1174 | char rev[32]; | |
17f0cd2f | 1175 | int ret; |
1da177e4 | 1176 | |
17f0cd2f KK |
1177 | ret = cdebug_init(); |
1178 | if (ret) | |
1179 | return ret; | |
1da177e4 LT |
1180 | kcapi_proc_init(); |
1181 | ||
2f9e9b6d | 1182 | if ((p = strchr(revision, ':')) != NULL && p[1]) { |
1da177e4 | 1183 | strlcpy(rev, p + 2, sizeof(rev)); |
2f9e9b6d | 1184 | if ((p = strchr(rev, '$')) != NULL && p > rev) |
1da177e4 LT |
1185 | *(p-1) = 0; |
1186 | } else | |
1187 | strcpy(rev, "1.0"); | |
1188 | ||
1189 | printk(KERN_NOTICE "CAPI Subsystem Rev %s\n", rev); | |
1190 | ||
1191 | return 0; | |
1192 | } | |
1193 | ||
1194 | static void __exit kcapi_exit(void) | |
1195 | { | |
1196 | kcapi_proc_exit(); | |
1197 | ||
1198 | /* make sure all notifiers are finished */ | |
1199 | flush_scheduled_work(); | |
17f0cd2f | 1200 | cdebug_exit(); |
1da177e4 LT |
1201 | } |
1202 | ||
1203 | module_init(kcapi_init); | |
1204 | module_exit(kcapi_exit); |