blob: 823f6985b2603198ff7b7ea7c8869db6032ba168 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* $Id: kcapi.c,v 1.1.2.8 2004/03/26 19:57:20 armin Exp $
Joe Perches475be4d2012-02-19 19:52:38 -08002 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * Kernel CAPI 2.0 Module
Joe Perches475be4d2012-02-19 19:52:38 -08004 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Copyright 1999 by Carsten Paeth <calle@calle.de>
6 * Copyright 2002 by Kai Germaschewski <kai@germaschewski.name>
Joe Perches475be4d2012-02-19 19:52:38 -08007 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * 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
Robert P. J. Day37772ac2008-04-28 02:14:42 -070013#define AVMB1_COMPAT
Linus Torvalds1da177e2005-04-16 15:20:36 -070014
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>
Alexey Dobriyand43c36d2009-10-07 17:09:06 +040021#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/seq_file.h>
23#include <linux/skbuff.h>
24#include <linux/workqueue.h>
25#include <linux/capi.h>
26#include <linux/kernelcapi.h>
27#include <linux/init.h>
28#include <linux/moduleparam.h>
29#include <linux/delay.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090030#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <asm/uaccess.h>
32#include <linux/isdn/capicmd.h>
33#include <linux/isdn/capiutil.h>
Robert P. J. Day37772ac2008-04-28 02:14:42 -070034#ifdef AVMB1_COMPAT
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/b1lli.h>
36#endif
Arjan van de Ven9cdf1822006-03-23 03:00:21 -080037#include <linux/mutex.h>
Jan Kiszka88c896e2010-02-08 10:12:15 +000038#include <linux/rcupdate.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Linus Torvalds1da177e2005-04-16 15:20:36 -070040static int showcapimsgs = 0;
Tejun Heo158fa672010-12-24 15:59:06 +010041static struct workqueue_struct *kcapi_wq;
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43MODULE_DESCRIPTION("CAPI4Linux: kernel CAPI layer");
44MODULE_AUTHOR("Carsten Paeth");
45MODULE_LICENSE("GPL");
46module_param(showcapimsgs, uint, 0);
47
48/* ------------------------------------------------------------- */
49
Jan Kiszkaef69bb22010-02-08 10:12:13 +000050struct capictr_event {
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 struct work_struct work;
Jan Kiszkaef69bb22010-02-08 10:12:13 +000052 unsigned int type;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 u32 controller;
Linus Torvalds1da177e2005-04-16 15:20:36 -070054};
55
56/* ------------------------------------------------------------- */
57
Joe Perches475be4d2012-02-19 19:52:38 -080058static struct capi_version driver_version = {2, 0, 1, 1 << 4};
Linus Torvalds1da177e2005-04-16 15:20:36 -070059static char driver_serial[CAPI_SERIAL_LEN] = "0004711";
60static char capi_manufakturer[64] = "AVM Berlin";
61
62#define NCCI2CTRL(ncci) (((ncci) >> 24) & 0x7f)
63
64LIST_HEAD(capi_drivers);
Jan Kiszka9717fb82010-02-08 10:12:11 +000065DEFINE_MUTEX(capi_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
Jan Kiszka0ca3a012010-02-08 10:12:14 +000067struct capi_ctr *capi_controller[CAPI_MAXCONTR];
68DEFINE_MUTEX(capi_controller_lock);
69
Linus Torvalds1da177e2005-04-16 15:20:36 -070070struct capi20_appl *capi_applications[CAPI_MAXAPPL];
Linus Torvalds1da177e2005-04-16 15:20:36 -070071
Jan Kiszka52253032010-02-08 10:12:10 +000072static int ncontrollers;
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
Jan Kiszkaef69bb22010-02-08 10:12:13 +000074static BLOCKING_NOTIFIER_HEAD(ctr_notifier_list);
75
Linus Torvalds1da177e2005-04-16 15:20:36 -070076/* -------- controller ref counting -------------------------------------- */
77
78static inline struct capi_ctr *
Jan Kiszka52253032010-02-08 10:12:10 +000079capi_ctr_get(struct capi_ctr *ctr)
Linus Torvalds1da177e2005-04-16 15:20:36 -070080{
Jan Kiszka52253032010-02-08 10:12:10 +000081 if (!try_module_get(ctr->owner))
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 return NULL;
Jan Kiszka52253032010-02-08 10:12:10 +000083 return ctr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084}
85
86static inline void
Jan Kiszka52253032010-02-08 10:12:10 +000087capi_ctr_put(struct capi_ctr *ctr)
Linus Torvalds1da177e2005-04-16 15:20:36 -070088{
Jan Kiszka52253032010-02-08 10:12:10 +000089 module_put(ctr->owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090}
91
92/* ------------------------------------------------------------- */
93
94static inline struct capi_ctr *get_capi_ctr_by_nr(u16 contr)
95{
Dan Carpenter25dff942013-05-19 08:36:36 +000096 if (contr < 1 || contr - 1 >= CAPI_MAXCONTR)
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 return NULL;
98
Jan Kiszka52253032010-02-08 10:12:10 +000099 return capi_controller[contr - 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100}
101
Jan Kiszkab003f4e2010-10-17 05:18:15 +0000102static inline struct capi20_appl *__get_capi_appl_by_nr(u16 applid)
103{
104 lockdep_assert_held(&capi_controller_lock);
105
Dan Carpenter25dff942013-05-19 08:36:36 +0000106 if (applid < 1 || applid - 1 >= CAPI_MAXAPPL)
Jan Kiszkab003f4e2010-10-17 05:18:15 +0000107 return NULL;
108
109 return capi_applications[applid - 1];
110}
111
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112static inline struct capi20_appl *get_capi_appl_by_nr(u16 applid)
113{
Dan Carpenter25dff942013-05-19 08:36:36 +0000114 if (applid < 1 || applid - 1 >= CAPI_MAXAPPL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 return NULL;
116
Jan Kiszka88c896e2010-02-08 10:12:15 +0000117 return rcu_dereference(capi_applications[applid - 1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118}
119
120/* -------- util functions ------------------------------------ */
121
122static inline int capi_cmd_valid(u8 cmd)
123{
124 switch (cmd) {
125 case CAPI_ALERT:
126 case CAPI_CONNECT:
127 case CAPI_CONNECT_ACTIVE:
128 case CAPI_CONNECT_B3_ACTIVE:
129 case CAPI_CONNECT_B3:
130 case CAPI_CONNECT_B3_T90_ACTIVE:
131 case CAPI_DATA_B3:
132 case CAPI_DISCONNECT_B3:
133 case CAPI_DISCONNECT:
134 case CAPI_FACILITY:
135 case CAPI_INFO:
136 case CAPI_LISTEN:
137 case CAPI_MANUFACTURER:
138 case CAPI_RESET_B3:
139 case CAPI_SELECT_B_PROTOCOL:
140 return 1;
141 }
142 return 0;
143}
144
145static inline int capi_subcmd_valid(u8 subcmd)
146{
147 switch (subcmd) {
148 case CAPI_REQ:
149 case CAPI_CONF:
150 case CAPI_IND:
151 case CAPI_RESP:
152 return 1;
153 }
154 return 0;
155}
156
157/* ------------------------------------------------------------ */
158
Jan Kiszka52253032010-02-08 10:12:10 +0000159static void
160register_appl(struct capi_ctr *ctr, u16 applid, capi_register_params *rparam)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161{
Jan Kiszka52253032010-02-08 10:12:10 +0000162 ctr = capi_ctr_get(ctr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163
Jan Kiszka52253032010-02-08 10:12:10 +0000164 if (ctr)
165 ctr->register_appl(ctr, applid, rparam);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 else
Jan Kiszka52253032010-02-08 10:12:10 +0000167 printk(KERN_WARNING "%s: cannot get controller resources\n",
168 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169}
170
171
Jan Kiszka52253032010-02-08 10:12:10 +0000172static void release_appl(struct capi_ctr *ctr, u16 applid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173{
174 DBG("applid %#x", applid);
Joe Perches475be4d2012-02-19 19:52:38 -0800175
Jan Kiszka52253032010-02-08 10:12:10 +0000176 ctr->release_appl(ctr, applid);
177 capi_ctr_put(ctr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178}
179
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180static void notify_up(u32 contr)
181{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 struct capi20_appl *ap;
Jan Kiszka3efecf72010-02-08 10:12:12 +0000183 struct capi_ctr *ctr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 u16 applid;
185
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000186 mutex_lock(&capi_controller_lock);
187
Jan Kiszka3efecf72010-02-08 10:12:12 +0000188 if (showcapimsgs & 1)
Joe Perches475be4d2012-02-19 19:52:38 -0800189 printk(KERN_DEBUG "kcapi: notify up contr %d\n", contr);
Jan Kiszka3efecf72010-02-08 10:12:12 +0000190
191 ctr = get_capi_ctr_by_nr(contr);
192 if (ctr) {
193 if (ctr->state == CAPI_CTR_RUNNING)
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000194 goto unlock_out;
Jan Kiszka3efecf72010-02-08 10:12:12 +0000195
196 ctr->state = CAPI_CTR_RUNNING;
197
198 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
Jan Kiszkab003f4e2010-10-17 05:18:15 +0000199 ap = __get_capi_appl_by_nr(applid);
200 if (ap)
201 register_appl(ctr, applid, &ap->rparam);
Jan Kiszka3efecf72010-02-08 10:12:12 +0000202 }
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000203
204 wake_up_interruptible_all(&ctr->state_wait_queue);
Jan Kiszka3efecf72010-02-08 10:12:12 +0000205 } else
Harvey Harrison156f1ed2008-04-28 02:14:40 -0700206 printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr);
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000207
208unlock_out:
209 mutex_unlock(&capi_controller_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210}
211
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000212static void ctr_down(struct capi_ctr *ctr, int new_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213{
214 struct capi20_appl *ap;
215 u16 applid;
216
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000217 if (ctr->state == CAPI_CTR_DETECTED || ctr->state == CAPI_CTR_DETACHED)
Jan Kiszka3efecf72010-02-08 10:12:12 +0000218 return;
219
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000220 ctr->state = new_state;
Jan Kiszka3efecf72010-02-08 10:12:12 +0000221
222 memset(ctr->manu, 0, sizeof(ctr->manu));
223 memset(&ctr->version, 0, sizeof(ctr->version));
224 memset(&ctr->profile, 0, sizeof(ctr->profile));
225 memset(ctr->serial, 0, sizeof(ctr->serial));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226
227 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
Jan Kiszkab003f4e2010-10-17 05:18:15 +0000228 ap = __get_capi_appl_by_nr(applid);
Jan Kiszka88c896e2010-02-08 10:12:15 +0000229 if (ap)
Jan Kiszka3efecf72010-02-08 10:12:12 +0000230 capi_ctr_put(ctr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 }
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000232
233 wake_up_interruptible_all(&ctr->state_wait_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234}
235
Jan Kiszka3efecf72010-02-08 10:12:12 +0000236static void notify_down(u32 contr)
237{
238 struct capi_ctr *ctr;
239
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000240 mutex_lock(&capi_controller_lock);
241
Jan Kiszka3efecf72010-02-08 10:12:12 +0000242 if (showcapimsgs & 1)
243 printk(KERN_DEBUG "kcapi: notify down contr %d\n", contr);
244
245 ctr = get_capi_ctr_by_nr(contr);
246 if (ctr)
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000247 ctr_down(ctr, CAPI_CTR_DETECTED);
Jan Kiszka3efecf72010-02-08 10:12:12 +0000248 else
249 printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr);
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000250
251 mutex_unlock(&capi_controller_lock);
Jan Kiszka3efecf72010-02-08 10:12:12 +0000252}
253
Jan Kiszkaef69bb22010-02-08 10:12:13 +0000254static int
255notify_handler(struct notifier_block *nb, unsigned long val, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256{
Jan Kiszkaef69bb22010-02-08 10:12:13 +0000257 u32 contr = (long)v;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
Jan Kiszkaef69bb22010-02-08 10:12:13 +0000259 switch (val) {
260 case CAPICTR_UP:
261 notify_up(contr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 break;
Jan Kiszkaef69bb22010-02-08 10:12:13 +0000263 case CAPICTR_DOWN:
264 notify_down(contr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 break;
266 }
Jan Kiszkaef69bb22010-02-08 10:12:13 +0000267 return NOTIFY_OK;
268}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
Jan Kiszkaef69bb22010-02-08 10:12:13 +0000270static void do_notify_work(struct work_struct *work)
271{
272 struct capictr_event *event =
273 container_of(work, struct capictr_event, work);
274
275 blocking_notifier_call_chain(&ctr_notifier_list, event->type,
276 (void *)(long)event->controller);
277 kfree(event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278}
279
280/*
281 * The notifier will result in adding/deleteing of devices. Devices can
282 * only removed in user process, not in bh.
283 */
Jan Kiszkaef69bb22010-02-08 10:12:13 +0000284static int notify_push(unsigned int event_type, u32 controller)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285{
Jan Kiszkaef69bb22010-02-08 10:12:13 +0000286 struct capictr_event *event = kmalloc(sizeof(*event), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Jan Kiszkaef69bb22010-02-08 10:12:13 +0000288 if (!event)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 return -ENOMEM;
290
Jan Kiszkaef69bb22010-02-08 10:12:13 +0000291 INIT_WORK(&event->work, do_notify_work);
292 event->type = event_type;
293 event->controller = controller;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
Tejun Heo158fa672010-12-24 15:59:06 +0100295 queue_work(kcapi_wq, &event->work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 return 0;
297}
298
Jan Kiszkaef69bb22010-02-08 10:12:13 +0000299int register_capictr_notifier(struct notifier_block *nb)
300{
301 return blocking_notifier_chain_register(&ctr_notifier_list, nb);
302}
303EXPORT_SYMBOL_GPL(register_capictr_notifier);
304
305int unregister_capictr_notifier(struct notifier_block *nb)
306{
307 return blocking_notifier_chain_unregister(&ctr_notifier_list, nb);
308}
309EXPORT_SYMBOL_GPL(unregister_capictr_notifier);
310
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311/* -------- Receiver ------------------------------------------ */
312
David Howellsc4028952006-11-22 14:57:56 +0000313static void recv_handler(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314{
315 struct sk_buff *skb;
David Howellsc4028952006-11-22 14:57:56 +0000316 struct capi20_appl *ap =
317 container_of(work, struct capi20_appl, recv_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318
319 if ((!ap) || (ap->release_in_progress))
320 return;
321
Matthias Kaehlcke67837f22007-07-17 04:04:16 -0700322 mutex_lock(&ap->recv_mtx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 while ((skb = skb_dequeue(&ap->recv_queue))) {
324 if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_IND)
325 ap->nrecvdatapkt++;
326 else
327 ap->nrecvctlpkt++;
328
329 ap->recv_message(ap, skb);
330 }
Matthias Kaehlcke67837f22007-07-17 04:04:16 -0700331 mutex_unlock(&ap->recv_mtx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332}
333
Tilman Schmidt554f2002009-04-23 02:24:21 +0000334/**
335 * capi_ctr_handle_message() - handle incoming CAPI message
Jan Kiszka52253032010-02-08 10:12:10 +0000336 * @ctr: controller descriptor structure.
Tilman Schmidt554f2002009-04-23 02:24:21 +0000337 * @appl: application ID.
338 * @skb: message.
339 *
340 * Called by hardware driver to pass a CAPI message to the application.
341 */
342
Jan Kiszka52253032010-02-08 10:12:10 +0000343void capi_ctr_handle_message(struct capi_ctr *ctr, u16 appl,
344 struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345{
346 struct capi20_appl *ap;
347 int showctl = 0;
348 u8 cmd, subcmd;
Karsten Keil17f0cd22007-02-28 20:13:50 -0800349 _cdebbuf *cdb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350
Jan Kiszka52253032010-02-08 10:12:10 +0000351 if (ctr->state != CAPI_CTR_RUNNING) {
Karsten Keil17f0cd22007-02-28 20:13:50 -0800352 cdb = capi_message2str(skb->data);
353 if (cdb) {
354 printk(KERN_INFO "kcapi: controller [%03d] not active, got: %s",
Joe Perches475be4d2012-02-19 19:52:38 -0800355 ctr->cnr, cdb->buf);
Karsten Keil17f0cd22007-02-28 20:13:50 -0800356 cdebbuf_free(cdb);
357 } else
358 printk(KERN_INFO "kcapi: controller [%03d] not active, cannot trace\n",
Joe Perches475be4d2012-02-19 19:52:38 -0800359 ctr->cnr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 goto error;
361 }
362
363 cmd = CAPIMSG_COMMAND(skb->data);
Joe Perches475be4d2012-02-19 19:52:38 -0800364 subcmd = CAPIMSG_SUBCOMMAND(skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 if (cmd == CAPI_DATA_B3 && subcmd == CAPI_IND) {
Jan Kiszka52253032010-02-08 10:12:10 +0000366 ctr->nrecvdatapkt++;
367 if (ctr->traceflag > 2)
368 showctl |= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 } else {
Jan Kiszka52253032010-02-08 10:12:10 +0000370 ctr->nrecvctlpkt++;
371 if (ctr->traceflag)
372 showctl |= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 }
Jan Kiszka52253032010-02-08 10:12:10 +0000374 showctl |= (ctr->traceflag & 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 if (showctl & 2) {
376 if (showctl & 1) {
Karsten Keil17f0cd22007-02-28 20:13:50 -0800377 printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u\n",
Jan Kiszka52253032010-02-08 10:12:10 +0000378 ctr->cnr, CAPIMSG_APPID(skb->data),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 capi_cmd2str(cmd, subcmd),
380 CAPIMSG_LEN(skb->data));
381 } else {
Karsten Keil17f0cd22007-02-28 20:13:50 -0800382 cdb = capi_message2str(skb->data);
383 if (cdb) {
384 printk(KERN_DEBUG "kcapi: got [%03d] %s\n",
Joe Perches475be4d2012-02-19 19:52:38 -0800385 ctr->cnr, cdb->buf);
Karsten Keil17f0cd22007-02-28 20:13:50 -0800386 cdebbuf_free(cdb);
387 } else
388 printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u, cannot trace\n",
Joe Perches475be4d2012-02-19 19:52:38 -0800389 ctr->cnr, CAPIMSG_APPID(skb->data),
390 capi_cmd2str(cmd, subcmd),
391 CAPIMSG_LEN(skb->data));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 }
393
394 }
395
Jan Kiszka88c896e2010-02-08 10:12:15 +0000396 rcu_read_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 ap = get_capi_appl_by_nr(CAPIMSG_APPID(skb->data));
Jan Kiszka88c896e2010-02-08 10:12:15 +0000398 if (!ap) {
399 rcu_read_unlock();
Karsten Keil17f0cd22007-02-28 20:13:50 -0800400 cdb = capi_message2str(skb->data);
401 if (cdb) {
402 printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s)\n",
Joe Perches475be4d2012-02-19 19:52:38 -0800403 CAPIMSG_APPID(skb->data), cdb->buf);
Karsten Keil17f0cd22007-02-28 20:13:50 -0800404 cdebbuf_free(cdb);
405 } else
406 printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s) cannot trace\n",
Joe Perches475be4d2012-02-19 19:52:38 -0800407 CAPIMSG_APPID(skb->data),
408 capi_cmd2str(cmd, subcmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 goto error;
410 }
411 skb_queue_tail(&ap->recv_queue, skb);
Tejun Heo158fa672010-12-24 15:59:06 +0100412 queue_work(kcapi_wq, &ap->recv_work);
Jan Kiszka88c896e2010-02-08 10:12:15 +0000413 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414
415 return;
416
417error:
418 kfree_skb(skb);
419}
420
421EXPORT_SYMBOL(capi_ctr_handle_message);
422
Tilman Schmidt554f2002009-04-23 02:24:21 +0000423/**
424 * capi_ctr_ready() - signal CAPI controller ready
Jan Kiszka52253032010-02-08 10:12:10 +0000425 * @ctr: controller descriptor structure.
Tilman Schmidt554f2002009-04-23 02:24:21 +0000426 *
427 * Called by hardware driver to signal that the controller is up and running.
428 */
429
Jan Kiszka52253032010-02-08 10:12:10 +0000430void capi_ctr_ready(struct capi_ctr *ctr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431{
Jan Kiszka52253032010-02-08 10:12:10 +0000432 printk(KERN_NOTICE "kcapi: controller [%03d] \"%s\" ready.\n",
433 ctr->cnr, ctr->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
Jan Kiszkaef69bb22010-02-08 10:12:13 +0000435 notify_push(CAPICTR_UP, ctr->cnr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436}
437
438EXPORT_SYMBOL(capi_ctr_ready);
439
Tilman Schmidt554f2002009-04-23 02:24:21 +0000440/**
Tilman Schmidt4e329972009-06-07 09:09:23 +0000441 * capi_ctr_down() - signal CAPI controller not ready
Jan Kiszka52253032010-02-08 10:12:10 +0000442 * @ctr: controller descriptor structure.
Tilman Schmidt554f2002009-04-23 02:24:21 +0000443 *
444 * Called by hardware driver to signal that the controller is down and
445 * unavailable for use.
446 */
447
Jan Kiszka52253032010-02-08 10:12:10 +0000448void capi_ctr_down(struct capi_ctr *ctr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449{
Jan Kiszka52253032010-02-08 10:12:10 +0000450 printk(KERN_NOTICE "kcapi: controller [%03d] down.\n", ctr->cnr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
Jan Kiszkaef69bb22010-02-08 10:12:13 +0000452 notify_push(CAPICTR_DOWN, ctr->cnr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453}
454
Tilman Schmidt4e329972009-06-07 09:09:23 +0000455EXPORT_SYMBOL(capi_ctr_down);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
Tilman Schmidt554f2002009-04-23 02:24:21 +0000457/**
458 * capi_ctr_suspend_output() - suspend controller
Jan Kiszka52253032010-02-08 10:12:10 +0000459 * @ctr: controller descriptor structure.
Tilman Schmidt554f2002009-04-23 02:24:21 +0000460 *
461 * Called by hardware driver to stop data flow.
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000462 *
463 * Note: The caller is responsible for synchronizing concurrent state changes
464 * as well as invocations of capi_ctr_handle_message.
Tilman Schmidt554f2002009-04-23 02:24:21 +0000465 */
466
Jan Kiszka52253032010-02-08 10:12:10 +0000467void capi_ctr_suspend_output(struct capi_ctr *ctr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468{
Jan Kiszka52253032010-02-08 10:12:10 +0000469 if (!ctr->blocked) {
470 printk(KERN_DEBUG "kcapi: controller [%03d] suspend\n",
471 ctr->cnr);
472 ctr->blocked = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 }
474}
475
476EXPORT_SYMBOL(capi_ctr_suspend_output);
477
Tilman Schmidt554f2002009-04-23 02:24:21 +0000478/**
479 * capi_ctr_resume_output() - resume controller
Jan Kiszka52253032010-02-08 10:12:10 +0000480 * @ctr: controller descriptor structure.
Tilman Schmidt554f2002009-04-23 02:24:21 +0000481 *
482 * Called by hardware driver to resume data flow.
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000483 *
484 * Note: The caller is responsible for synchronizing concurrent state changes
485 * as well as invocations of capi_ctr_handle_message.
Tilman Schmidt554f2002009-04-23 02:24:21 +0000486 */
487
Jan Kiszka52253032010-02-08 10:12:10 +0000488void capi_ctr_resume_output(struct capi_ctr *ctr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489{
Jan Kiszka52253032010-02-08 10:12:10 +0000490 if (ctr->blocked) {
491 printk(KERN_DEBUG "kcapi: controller [%03d] resumed\n",
492 ctr->cnr);
493 ctr->blocked = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 }
495}
496
497EXPORT_SYMBOL(capi_ctr_resume_output);
498
499/* ------------------------------------------------------------- */
500
Tilman Schmidt554f2002009-04-23 02:24:21 +0000501/**
502 * attach_capi_ctr() - register CAPI controller
Jan Kiszka52253032010-02-08 10:12:10 +0000503 * @ctr: controller descriptor structure.
Tilman Schmidt554f2002009-04-23 02:24:21 +0000504 *
505 * Called by hardware driver to register a controller with the CAPI subsystem.
506 * Return value: 0 on success, error code < 0 on error
507 */
508
Jan Kiszka52253032010-02-08 10:12:10 +0000509int attach_capi_ctr(struct capi_ctr *ctr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510{
511 int i;
512
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000513 mutex_lock(&capi_controller_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
515 for (i = 0; i < CAPI_MAXCONTR; i++) {
Jan Kiszka52253032010-02-08 10:12:10 +0000516 if (!capi_controller[i])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 break;
518 }
519 if (i == CAPI_MAXCONTR) {
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000520 mutex_unlock(&capi_controller_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 printk(KERN_ERR "kcapi: out of controller slots\n");
Joe Perches475be4d2012-02-19 19:52:38 -0800522 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 }
Jan Kiszka52253032010-02-08 10:12:10 +0000524 capi_controller[i] = ctr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
Jan Kiszka52253032010-02-08 10:12:10 +0000526 ctr->nrecvctlpkt = 0;
527 ctr->nrecvdatapkt = 0;
528 ctr->nsentctlpkt = 0;
529 ctr->nsentdatapkt = 0;
530 ctr->cnr = i + 1;
531 ctr->state = CAPI_CTR_DETECTED;
532 ctr->blocked = 0;
533 ctr->traceflag = showcapimsgs;
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000534 init_waitqueue_head(&ctr->state_wait_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535
Jan Kiszka52253032010-02-08 10:12:10 +0000536 sprintf(ctr->procfn, "capi/controllers/%d", ctr->cnr);
537 ctr->procent = proc_create_data(ctr->procfn, 0, NULL, ctr->proc_fops, ctr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
Jan Kiszka52253032010-02-08 10:12:10 +0000539 ncontrollers++;
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000540
541 mutex_unlock(&capi_controller_lock);
542
Jan Kiszka52253032010-02-08 10:12:10 +0000543 printk(KERN_NOTICE "kcapi: controller [%03d]: %s attached\n",
Joe Perches475be4d2012-02-19 19:52:38 -0800544 ctr->cnr, ctr->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 return 0;
546}
547
548EXPORT_SYMBOL(attach_capi_ctr);
549
Tilman Schmidt554f2002009-04-23 02:24:21 +0000550/**
551 * detach_capi_ctr() - unregister CAPI controller
Jan Kiszka52253032010-02-08 10:12:10 +0000552 * @ctr: controller descriptor structure.
Tilman Schmidt554f2002009-04-23 02:24:21 +0000553 *
554 * Called by hardware driver to remove the registration of a controller
555 * with the CAPI subsystem.
556 * Return value: 0 on success, error code < 0 on error
557 */
558
Jan Kiszka52253032010-02-08 10:12:10 +0000559int detach_capi_ctr(struct capi_ctr *ctr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560{
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000561 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000563 mutex_lock(&capi_controller_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000565 ctr_down(ctr, CAPI_CTR_DETACHED);
566
567 if (capi_controller[ctr->cnr - 1] != ctr) {
568 err = -EINVAL;
569 goto unlock_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 }
Jan Kiszka52253032010-02-08 10:12:10 +0000571 capi_controller[ctr->cnr - 1] = NULL;
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000572 ncontrollers--;
573
574 if (ctr->procent)
575 remove_proc_entry(ctr->procfn, NULL);
576
Jan Kiszka52253032010-02-08 10:12:10 +0000577 printk(KERN_NOTICE "kcapi: controller [%03d]: %s unregistered\n",
578 ctr->cnr, ctr->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000580unlock_out:
581 mutex_unlock(&capi_controller_lock);
582
583 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584}
585
586EXPORT_SYMBOL(detach_capi_ctr);
587
Tilman Schmidt554f2002009-04-23 02:24:21 +0000588/**
589 * register_capi_driver() - register CAPI driver
590 * @driver: driver descriptor structure.
591 *
592 * Called by hardware driver to register itself with the CAPI subsystem.
593 */
594
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595void register_capi_driver(struct capi_driver *driver)
596{
Jan Kiszka9717fb82010-02-08 10:12:11 +0000597 mutex_lock(&capi_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 list_add_tail(&driver->list, &capi_drivers);
Jan Kiszka9717fb82010-02-08 10:12:11 +0000599 mutex_unlock(&capi_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600}
601
602EXPORT_SYMBOL(register_capi_driver);
603
Tilman Schmidt554f2002009-04-23 02:24:21 +0000604/**
605 * unregister_capi_driver() - unregister CAPI driver
606 * @driver: driver descriptor structure.
607 *
608 * Called by hardware driver to unregister itself from the CAPI subsystem.
609 */
610
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611void unregister_capi_driver(struct capi_driver *driver)
612{
Jan Kiszka9717fb82010-02-08 10:12:11 +0000613 mutex_lock(&capi_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 list_del(&driver->list);
Jan Kiszka9717fb82010-02-08 10:12:11 +0000615 mutex_unlock(&capi_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616}
617
618EXPORT_SYMBOL(unregister_capi_driver);
619
620/* ------------------------------------------------------------- */
621/* -------- CAPI2.0 Interface ---------------------------------- */
622/* ------------------------------------------------------------- */
623
Tilman Schmidt554f2002009-04-23 02:24:21 +0000624/**
625 * capi20_isinstalled() - CAPI 2.0 operation CAPI_INSTALLED
626 *
627 * Return value: CAPI result code (CAPI_NOERROR if at least one ISDN controller
628 * is ready for use, CAPI_REGNOTINSTALLED otherwise)
629 */
630
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631u16 capi20_isinstalled(void)
632{
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000633 u16 ret = CAPI_REGNOTINSTALLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 int i;
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000635
636 mutex_lock(&capi_controller_lock);
637
638 for (i = 0; i < CAPI_MAXCONTR; i++)
Jan Kiszka52253032010-02-08 10:12:10 +0000639 if (capi_controller[i] &&
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000640 capi_controller[i]->state == CAPI_CTR_RUNNING) {
641 ret = CAPI_NOERROR;
642 break;
643 }
644
645 mutex_unlock(&capi_controller_lock);
646
647 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648}
649
650EXPORT_SYMBOL(capi20_isinstalled);
651
Tilman Schmidt554f2002009-04-23 02:24:21 +0000652/**
653 * capi20_register() - CAPI 2.0 operation CAPI_REGISTER
654 * @ap: CAPI application descriptor structure.
655 *
656 * Register an application's presence with CAPI.
657 * A unique application ID is assigned and stored in @ap->applid.
658 * After this function returns successfully, the message receive
659 * callback function @ap->recv_message() may be called at any time
660 * until capi20_release() has been called for the same @ap.
661 * Return value: CAPI result code
662 */
663
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664u16 capi20_register(struct capi20_appl *ap)
665{
666 int i;
667 u16 applid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668
669 DBG("");
670
671 if (ap->rparam.datablklen < 128)
672 return CAPI_LOGBLKSIZETOSMALL;
673
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 ap->nrecvctlpkt = 0;
675 ap->nrecvdatapkt = 0;
676 ap->nsentctlpkt = 0;
677 ap->nsentdatapkt = 0;
Matthias Kaehlcke67837f22007-07-17 04:04:16 -0700678 mutex_init(&ap->recv_mtx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 skb_queue_head_init(&ap->recv_queue);
David Howellsc4028952006-11-22 14:57:56 +0000680 INIT_WORK(&ap->recv_work, recv_handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 ap->release_in_progress = 0;
682
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000683 mutex_lock(&capi_controller_lock);
684
Jan Kiszka88c896e2010-02-08 10:12:15 +0000685 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
686 if (capi_applications[applid - 1] == NULL)
687 break;
688 }
689 if (applid > CAPI_MAXAPPL) {
690 mutex_unlock(&capi_controller_lock);
691 return CAPI_TOOMANYAPPLS;
692 }
693
694 ap->applid = applid;
695 capi_applications[applid - 1] = ap;
696
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 for (i = 0; i < CAPI_MAXCONTR; i++) {
Jan Kiszka52253032010-02-08 10:12:10 +0000698 if (!capi_controller[i] ||
699 capi_controller[i]->state != CAPI_CTR_RUNNING)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 continue;
Jan Kiszka52253032010-02-08 10:12:10 +0000701 register_appl(capi_controller[i], applid, &ap->rparam);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 }
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000703
704 mutex_unlock(&capi_controller_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705
706 if (showcapimsgs & 1) {
707 printk(KERN_DEBUG "kcapi: appl %d up\n", applid);
708 }
709
710 return CAPI_NOERROR;
711}
712
713EXPORT_SYMBOL(capi20_register);
714
Tilman Schmidt554f2002009-04-23 02:24:21 +0000715/**
716 * capi20_release() - CAPI 2.0 operation CAPI_RELEASE
717 * @ap: CAPI application descriptor structure.
718 *
719 * Terminate an application's registration with CAPI.
720 * After this function returns successfully, the message receive
721 * callback function @ap->recv_message() will no longer be called.
722 * Return value: CAPI result code
723 */
724
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725u16 capi20_release(struct capi20_appl *ap)
726{
727 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
729 DBG("applid %#x", ap->applid);
730
Jan Kiszka88c896e2010-02-08 10:12:15 +0000731 mutex_lock(&capi_controller_lock);
732
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 ap->release_in_progress = 1;
734 capi_applications[ap->applid - 1] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
Jan Kiszka88c896e2010-02-08 10:12:15 +0000736 synchronize_rcu();
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000737
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 for (i = 0; i < CAPI_MAXCONTR; i++) {
Jan Kiszka52253032010-02-08 10:12:10 +0000739 if (!capi_controller[i] ||
740 capi_controller[i]->state != CAPI_CTR_RUNNING)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 continue;
Jan Kiszka52253032010-02-08 10:12:10 +0000742 release_appl(capi_controller[i], ap->applid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 }
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000744
745 mutex_unlock(&capi_controller_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746
Tejun Heo158fa672010-12-24 15:59:06 +0100747 flush_workqueue(kcapi_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 skb_queue_purge(&ap->recv_queue);
749
750 if (showcapimsgs & 1) {
751 printk(KERN_DEBUG "kcapi: appl %d down\n", ap->applid);
752 }
753
754 return CAPI_NOERROR;
755}
756
757EXPORT_SYMBOL(capi20_release);
758
Tilman Schmidt554f2002009-04-23 02:24:21 +0000759/**
760 * capi20_put_message() - CAPI 2.0 operation CAPI_PUT_MESSAGE
761 * @ap: CAPI application descriptor structure.
762 * @skb: CAPI message.
763 *
764 * Transfer a single message to CAPI.
765 * Return value: CAPI result code
766 */
767
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb)
769{
Jan Kiszka52253032010-02-08 10:12:10 +0000770 struct capi_ctr *ctr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 int showctl = 0;
772 u8 cmd, subcmd;
773
774 DBG("applid %#x", ap->applid);
Joe Perches475be4d2012-02-19 19:52:38 -0800775
Jan Kiszka52253032010-02-08 10:12:10 +0000776 if (ncontrollers == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 return CAPI_REGNOTINSTALLED;
778 if ((ap->applid == 0) || ap->release_in_progress)
779 return CAPI_ILLAPPNR;
780 if (skb->len < 12
781 || !capi_cmd_valid(CAPIMSG_COMMAND(skb->data))
782 || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data)))
783 return CAPI_ILLCMDORSUBCMDORMSGTOSMALL;
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000784
785 /*
786 * The controller reference is protected by the existence of the
787 * application passed to us. We assume that the caller properly
788 * synchronizes this service with capi20_release.
789 */
Jan Kiszka52253032010-02-08 10:12:10 +0000790 ctr = get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb->data));
Jan Kiszkac6af0432010-02-08 10:12:43 +0000791 if (!ctr || ctr->state != CAPI_CTR_RUNNING)
792 return CAPI_REGNOTINSTALLED;
Jan Kiszka52253032010-02-08 10:12:10 +0000793 if (ctr->blocked)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 return CAPI_SENDQUEUEFULL;
795
796 cmd = CAPIMSG_COMMAND(skb->data);
Joe Perches475be4d2012-02-19 19:52:38 -0800797 subcmd = CAPIMSG_SUBCOMMAND(skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
Joe Perches475be4d2012-02-19 19:52:38 -0800799 if (cmd == CAPI_DATA_B3 && subcmd == CAPI_REQ) {
Jan Kiszka52253032010-02-08 10:12:10 +0000800 ctr->nsentdatapkt++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 ap->nsentdatapkt++;
Jan Kiszka52253032010-02-08 10:12:10 +0000802 if (ctr->traceflag > 2)
803 showctl |= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 } else {
Jan Kiszka52253032010-02-08 10:12:10 +0000805 ctr->nsentctlpkt++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 ap->nsentctlpkt++;
Jan Kiszka52253032010-02-08 10:12:10 +0000807 if (ctr->traceflag)
808 showctl |= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 }
Jan Kiszka52253032010-02-08 10:12:10 +0000810 showctl |= (ctr->traceflag & 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 if (showctl & 2) {
812 if (showctl & 1) {
Karsten Keil17f0cd22007-02-28 20:13:50 -0800813 printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 CAPIMSG_CONTROLLER(skb->data),
815 CAPIMSG_APPID(skb->data),
816 capi_cmd2str(cmd, subcmd),
817 CAPIMSG_LEN(skb->data));
818 } else {
Karsten Keil17f0cd22007-02-28 20:13:50 -0800819 _cdebbuf *cdb = capi_message2str(skb->data);
820 if (cdb) {
821 printk(KERN_DEBUG "kcapi: put [%03d] %s\n",
Joe Perches475be4d2012-02-19 19:52:38 -0800822 CAPIMSG_CONTROLLER(skb->data),
823 cdb->buf);
Karsten Keil17f0cd22007-02-28 20:13:50 -0800824 cdebbuf_free(cdb);
825 } else
826 printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u cannot trace\n",
Joe Perches475be4d2012-02-19 19:52:38 -0800827 CAPIMSG_CONTROLLER(skb->data),
828 CAPIMSG_APPID(skb->data),
829 capi_cmd2str(cmd, subcmd),
830 CAPIMSG_LEN(skb->data));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 }
Jan Kiszka52253032010-02-08 10:12:10 +0000833 return ctr->send_message(ctr, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834}
835
836EXPORT_SYMBOL(capi20_put_message);
837
Tilman Schmidt554f2002009-04-23 02:24:21 +0000838/**
839 * capi20_get_manufacturer() - CAPI 2.0 operation CAPI_GET_MANUFACTURER
840 * @contr: controller number.
841 * @buf: result buffer (64 bytes).
842 *
843 * Retrieve information about the manufacturer of the specified ISDN controller
844 * or (for @contr == 0) the driver itself.
845 * Return value: CAPI result code
846 */
847
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848u16 capi20_get_manufacturer(u32 contr, u8 *buf)
849{
Jan Kiszka52253032010-02-08 10:12:10 +0000850 struct capi_ctr *ctr;
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000851 u16 ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
853 if (contr == 0) {
854 strlcpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN);
855 return CAPI_NOERROR;
856 }
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000857
858 mutex_lock(&capi_controller_lock);
859
Jan Kiszka52253032010-02-08 10:12:10 +0000860 ctr = get_capi_ctr_by_nr(contr);
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000861 if (ctr && ctr->state == CAPI_CTR_RUNNING) {
862 strlcpy(buf, ctr->manu, CAPI_MANUFACTURER_LEN);
863 ret = CAPI_NOERROR;
864 } else
865 ret = CAPI_REGNOTINSTALLED;
866
867 mutex_unlock(&capi_controller_lock);
868 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869}
870
871EXPORT_SYMBOL(capi20_get_manufacturer);
872
Tilman Schmidt554f2002009-04-23 02:24:21 +0000873/**
874 * capi20_get_version() - CAPI 2.0 operation CAPI_GET_VERSION
875 * @contr: controller number.
876 * @verp: result structure.
877 *
878 * Retrieve version information for the specified ISDN controller
879 * or (for @contr == 0) the driver itself.
880 * Return value: CAPI result code
881 */
882
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883u16 capi20_get_version(u32 contr, struct capi_version *verp)
884{
Jan Kiszka52253032010-02-08 10:12:10 +0000885 struct capi_ctr *ctr;
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000886 u16 ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887
888 if (contr == 0) {
889 *verp = driver_version;
890 return CAPI_NOERROR;
891 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000893 mutex_lock(&capi_controller_lock);
894
895 ctr = get_capi_ctr_by_nr(contr);
896 if (ctr && ctr->state == CAPI_CTR_RUNNING) {
897 memcpy(verp, &ctr->version, sizeof(capi_version));
898 ret = CAPI_NOERROR;
899 } else
900 ret = CAPI_REGNOTINSTALLED;
901
902 mutex_unlock(&capi_controller_lock);
903 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904}
905
906EXPORT_SYMBOL(capi20_get_version);
907
Tilman Schmidt554f2002009-04-23 02:24:21 +0000908/**
909 * capi20_get_serial() - CAPI 2.0 operation CAPI_GET_SERIAL_NUMBER
910 * @contr: controller number.
911 * @serial: result buffer (8 bytes).
912 *
913 * Retrieve the serial number of the specified ISDN controller
914 * or (for @contr == 0) the driver itself.
915 * Return value: CAPI result code
916 */
917
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918u16 capi20_get_serial(u32 contr, u8 *serial)
919{
Jan Kiszka52253032010-02-08 10:12:10 +0000920 struct capi_ctr *ctr;
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000921 u16 ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922
923 if (contr == 0) {
924 strlcpy(serial, driver_serial, CAPI_SERIAL_LEN);
925 return CAPI_NOERROR;
926 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000928 mutex_lock(&capi_controller_lock);
929
930 ctr = get_capi_ctr_by_nr(contr);
931 if (ctr && ctr->state == CAPI_CTR_RUNNING) {
932 strlcpy(serial, ctr->serial, CAPI_SERIAL_LEN);
933 ret = CAPI_NOERROR;
934 } else
935 ret = CAPI_REGNOTINSTALLED;
936
937 mutex_unlock(&capi_controller_lock);
938 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939}
940
941EXPORT_SYMBOL(capi20_get_serial);
942
Tilman Schmidt554f2002009-04-23 02:24:21 +0000943/**
944 * capi20_get_profile() - CAPI 2.0 operation CAPI_GET_PROFILE
945 * @contr: controller number.
946 * @profp: result structure.
947 *
948 * Retrieve capability information for the specified ISDN controller
949 * or (for @contr == 0) the number of installed controllers.
950 * Return value: CAPI result code
951 */
952
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953u16 capi20_get_profile(u32 contr, struct capi_profile *profp)
954{
Jan Kiszka52253032010-02-08 10:12:10 +0000955 struct capi_ctr *ctr;
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000956 u16 ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957
958 if (contr == 0) {
Jan Kiszka52253032010-02-08 10:12:10 +0000959 profp->ncontroller = ncontrollers;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 return CAPI_NOERROR;
961 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000963 mutex_lock(&capi_controller_lock);
964
965 ctr = get_capi_ctr_by_nr(contr);
966 if (ctr && ctr->state == CAPI_CTR_RUNNING) {
967 memcpy(profp, &ctr->profile, sizeof(struct capi_profile));
968 ret = CAPI_NOERROR;
969 } else
970 ret = CAPI_REGNOTINSTALLED;
971
972 mutex_unlock(&capi_controller_lock);
973 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974}
975
976EXPORT_SYMBOL(capi20_get_profile);
977
Jan Kiszka0ca3a012010-02-08 10:12:14 +0000978/* Must be called with capi_controller_lock held. */
979static int wait_on_ctr_state(struct capi_ctr *ctr, unsigned int state)
980{
981 DEFINE_WAIT(wait);
982 int retval = 0;
983
984 ctr = capi_ctr_get(ctr);
985 if (!ctr)
986 return -ESRCH;
987
988 for (;;) {
989 prepare_to_wait(&ctr->state_wait_queue, &wait,
990 TASK_INTERRUPTIBLE);
991
992 if (ctr->state == state)
993 break;
994 if (ctr->state == CAPI_CTR_DETACHED) {
995 retval = -ESRCH;
996 break;
997 }
998 if (signal_pending(current)) {
999 retval = -EINTR;
1000 break;
1001 }
1002
1003 mutex_unlock(&capi_controller_lock);
1004 schedule();
1005 mutex_lock(&capi_controller_lock);
1006 }
1007 finish_wait(&ctr->state_wait_queue, &wait);
1008
1009 capi_ctr_put(ctr);
1010
1011 return retval;
1012}
1013
Robert P. J. Day37772ac2008-04-28 02:14:42 -07001014#ifdef AVMB1_COMPAT
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015static int old_capi_manufacturer(unsigned int cmd, void __user *data)
1016{
1017 avmb1_loadandconfigdef ldef;
1018 avmb1_extcarddef cdef;
1019 avmb1_resetdef rdef;
1020 capicardparams cparams;
Jan Kiszka52253032010-02-08 10:12:10 +00001021 struct capi_ctr *ctr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 struct capi_driver *driver = NULL;
1023 capiloaddata ldata;
1024 struct list_head *l;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 int retval;
1026
1027 switch (cmd) {
1028 case AVMB1_ADDCARD:
1029 case AVMB1_ADDCARD_WITH_TYPE:
1030 if (cmd == AVMB1_ADDCARD) {
Joe Perches475be4d2012-02-19 19:52:38 -08001031 if ((retval = copy_from_user(&cdef, data,
1032 sizeof(avmb1_carddef))))
1033 return -EFAULT;
1034 cdef.cardtype = AVM_CARDTYPE_B1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 } else {
Joe Perches475be4d2012-02-19 19:52:38 -08001036 if ((retval = copy_from_user(&cdef, data,
1037 sizeof(avmb1_extcarddef))))
1038 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 }
1040 cparams.port = cdef.port;
1041 cparams.irq = cdef.irq;
1042 cparams.cardnr = cdef.cardnr;
1043
Jan Kiszka9717fb82010-02-08 10:12:11 +00001044 mutex_lock(&capi_drivers_lock);
1045
Joe Perches475be4d2012-02-19 19:52:38 -08001046 switch (cdef.cardtype) {
1047 case AVM_CARDTYPE_B1:
1048 list_for_each(l, &capi_drivers) {
1049 driver = list_entry(l, struct capi_driver, list);
1050 if (strcmp(driver->name, "b1isa") == 0)
1051 break;
1052 }
1053 break;
1054 case AVM_CARDTYPE_T1:
1055 list_for_each(l, &capi_drivers) {
1056 driver = list_entry(l, struct capi_driver, list);
1057 if (strcmp(driver->name, "t1isa") == 0)
1058 break;
1059 }
1060 break;
1061 default:
1062 driver = NULL;
1063 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 }
1065 if (!driver) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 printk(KERN_ERR "kcapi: driver not loaded.\n");
Jan Kiszka9717fb82010-02-08 10:12:11 +00001067 retval = -EIO;
1068 } else if (!driver->add_card) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 printk(KERN_ERR "kcapi: driver has no add card function.\n");
Jan Kiszka9717fb82010-02-08 10:12:11 +00001070 retval = -EIO;
1071 } else
1072 retval = driver->add_card(driver, &cparams);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073
Jan Kiszka9717fb82010-02-08 10:12:11 +00001074 mutex_unlock(&capi_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 return retval;
1076
1077 case AVMB1_LOAD:
1078 case AVMB1_LOAD_AND_CONFIG:
1079
1080 if (cmd == AVMB1_LOAD) {
1081 if (copy_from_user(&ldef, data,
1082 sizeof(avmb1_loaddef)))
1083 return -EFAULT;
1084 ldef.t4config.len = 0;
1085 ldef.t4config.data = NULL;
1086 } else {
1087 if (copy_from_user(&ldef, data,
1088 sizeof(avmb1_loadandconfigdef)))
1089 return -EFAULT;
1090 }
Jan Kiszka0ca3a012010-02-08 10:12:14 +00001091
1092 mutex_lock(&capi_controller_lock);
1093
Jan Kiszka52253032010-02-08 10:12:10 +00001094 ctr = get_capi_ctr_by_nr(ldef.contr);
Jan Kiszka0ca3a012010-02-08 10:12:14 +00001095 if (!ctr) {
1096 retval = -EINVAL;
1097 goto load_unlock_out;
1098 }
1099
Jan Kiszka52253032010-02-08 10:12:10 +00001100 if (ctr->load_firmware == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 printk(KERN_DEBUG "kcapi: load: no load function\n");
Jan Kiszka0ca3a012010-02-08 10:12:14 +00001102 retval = -ESRCH;
1103 goto load_unlock_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 }
1105
1106 if (ldef.t4file.len <= 0) {
1107 printk(KERN_DEBUG "kcapi: load: invalid parameter: length of t4file is %d ?\n", ldef.t4file.len);
Jan Kiszka0ca3a012010-02-08 10:12:14 +00001108 retval = -EINVAL;
1109 goto load_unlock_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 }
Harvey Harrison2f9e9b62008-04-28 02:14:37 -07001111 if (ldef.t4file.data == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 printk(KERN_DEBUG "kcapi: load: invalid parameter: dataptr is 0\n");
Jan Kiszka0ca3a012010-02-08 10:12:14 +00001113 retval = -EINVAL;
1114 goto load_unlock_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 }
1116
1117 ldata.firmware.user = 1;
1118 ldata.firmware.data = ldef.t4file.data;
1119 ldata.firmware.len = ldef.t4file.len;
1120 ldata.configuration.user = 1;
1121 ldata.configuration.data = ldef.t4config.data;
1122 ldata.configuration.len = ldef.t4config.len;
1123
Jan Kiszka52253032010-02-08 10:12:10 +00001124 if (ctr->state != CAPI_CTR_DETECTED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 printk(KERN_INFO "kcapi: load: contr=%d not in detect state\n", ldef.contr);
Jan Kiszka0ca3a012010-02-08 10:12:14 +00001126 retval = -EBUSY;
1127 goto load_unlock_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 }
Jan Kiszka52253032010-02-08 10:12:10 +00001129 ctr->state = CAPI_CTR_LOADING;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130
Jan Kiszka52253032010-02-08 10:12:10 +00001131 retval = ctr->load_firmware(ctr, &ldata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 if (retval) {
Jan Kiszka52253032010-02-08 10:12:10 +00001133 ctr->state = CAPI_CTR_DETECTED;
Jan Kiszka0ca3a012010-02-08 10:12:14 +00001134 goto load_unlock_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135 }
1136
Jan Kiszka0ca3a012010-02-08 10:12:14 +00001137 retval = wait_on_ctr_state(ctr, CAPI_CTR_RUNNING);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
Joe Perches475be4d2012-02-19 19:52:38 -08001139 load_unlock_out:
Jan Kiszka0ca3a012010-02-08 10:12:14 +00001140 mutex_unlock(&capi_controller_lock);
1141 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142
1143 case AVMB1_RESETCARD:
1144 if (copy_from_user(&rdef, data, sizeof(avmb1_resetdef)))
1145 return -EFAULT;
Jan Kiszka0ca3a012010-02-08 10:12:14 +00001146
1147 retval = 0;
1148
1149 mutex_lock(&capi_controller_lock);
1150
Jan Kiszka52253032010-02-08 10:12:10 +00001151 ctr = get_capi_ctr_by_nr(rdef.contr);
Jan Kiszka0ca3a012010-02-08 10:12:14 +00001152 if (!ctr) {
1153 retval = -ESRCH;
1154 goto reset_unlock_out;
1155 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156
Jan Kiszka52253032010-02-08 10:12:10 +00001157 if (ctr->state == CAPI_CTR_DETECTED)
Jan Kiszka0ca3a012010-02-08 10:12:14 +00001158 goto reset_unlock_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159
Tilman Schmidt85a83562010-05-23 01:02:08 +00001160 if (ctr->reset_ctr == NULL) {
1161 printk(KERN_DEBUG "kcapi: reset: no reset function\n");
1162 retval = -ESRCH;
1163 goto reset_unlock_out;
1164 }
1165
Jan Kiszka52253032010-02-08 10:12:10 +00001166 ctr->reset_ctr(ctr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167
Jan Kiszka0ca3a012010-02-08 10:12:14 +00001168 retval = wait_on_ctr_state(ctr, CAPI_CTR_DETECTED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169
Joe Perches475be4d2012-02-19 19:52:38 -08001170 reset_unlock_out:
Jan Kiszka0ca3a012010-02-08 10:12:14 +00001171 mutex_unlock(&capi_controller_lock);
1172 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 }
1174 return -EINVAL;
1175}
1176#endif
1177
Tilman Schmidt554f2002009-04-23 02:24:21 +00001178/**
1179 * capi20_manufacturer() - CAPI 2.0 operation CAPI_MANUFACTURER
1180 * @cmd: command.
1181 * @data: parameter.
1182 *
1183 * Perform manufacturer specific command.
1184 * Return value: CAPI result code
1185 */
1186
Tilman Schmidt9ea8aa82014-10-11 13:46:30 +02001187int capi20_manufacturer(unsigned long cmd, void __user *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188{
Jan Kiszka52253032010-02-08 10:12:10 +00001189 struct capi_ctr *ctr;
Jan Kiszka0ca3a012010-02-08 10:12:14 +00001190 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191
1192 switch (cmd) {
Robert P. J. Day37772ac2008-04-28 02:14:42 -07001193#ifdef AVMB1_COMPAT
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 case AVMB1_LOAD:
1195 case AVMB1_LOAD_AND_CONFIG:
1196 case AVMB1_RESETCARD:
1197 case AVMB1_GET_CARDINFO:
1198 case AVMB1_REMOVECARD:
1199 return old_capi_manufacturer(cmd, data);
1200#endif
1201 case KCAPI_CMD_TRACE:
1202 {
1203 kcapi_flagdef fdef;
1204
1205 if (copy_from_user(&fdef, data, sizeof(kcapi_flagdef)))
1206 return -EFAULT;
1207
Jan Kiszka0ca3a012010-02-08 10:12:14 +00001208 mutex_lock(&capi_controller_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209
Jan Kiszka0ca3a012010-02-08 10:12:14 +00001210 ctr = get_capi_ctr_by_nr(fdef.contr);
1211 if (ctr) {
1212 ctr->traceflag = fdef.flag;
1213 printk(KERN_INFO "kcapi: contr [%03d] set trace=%d\n",
1214 ctr->cnr, ctr->traceflag);
1215 retval = 0;
1216 } else
1217 retval = -ESRCH;
1218
1219 mutex_unlock(&capi_controller_lock);
1220
1221 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 }
1223 case KCAPI_CMD_ADDCARD:
1224 {
1225 struct list_head *l;
1226 struct capi_driver *driver = NULL;
1227 capicardparams cparams;
1228 kcapi_carddef cdef;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229
1230 if ((retval = copy_from_user(&cdef, data, sizeof(cdef))))
Dan Carpenter60a57112010-06-02 23:56:13 +00001231 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232
1233 cparams.port = cdef.port;
1234 cparams.irq = cdef.irq;
1235 cparams.membase = cdef.membase;
1236 cparams.cardnr = cdef.cardnr;
1237 cparams.cardtype = 0;
Joe Perches475be4d2012-02-19 19:52:38 -08001238 cdef.driver[sizeof(cdef.driver) - 1] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239
Jan Kiszka9717fb82010-02-08 10:12:11 +00001240 mutex_lock(&capi_drivers_lock);
1241
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 list_for_each(l, &capi_drivers) {
1243 driver = list_entry(l, struct capi_driver, list);
1244 if (strcmp(driver->name, cdef.driver) == 0)
1245 break;
1246 }
Harvey Harrison2f9e9b62008-04-28 02:14:37 -07001247 if (driver == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 printk(KERN_ERR "kcapi: driver \"%s\" not loaded.\n",
Joe Perches475be4d2012-02-19 19:52:38 -08001249 cdef.driver);
Jan Kiszka9717fb82010-02-08 10:12:11 +00001250 retval = -ESRCH;
1251 } else if (!driver->add_card) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 printk(KERN_ERR "kcapi: driver \"%s\" has no add card function.\n", cdef.driver);
Jan Kiszka9717fb82010-02-08 10:12:11 +00001253 retval = -EIO;
1254 } else
1255 retval = driver->add_card(driver, &cparams);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256
Jan Kiszka9717fb82010-02-08 10:12:11 +00001257 mutex_unlock(&capi_drivers_lock);
1258 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 }
1260
1261 default:
Tilman Schmidt9ea8aa82014-10-11 13:46:30 +02001262 printk(KERN_ERR "kcapi: manufacturer command %lu unknown.\n",
Joe Perches475be4d2012-02-19 19:52:38 -08001263 cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 break;
1265
1266 }
1267 return -EINVAL;
1268}
1269
1270EXPORT_SYMBOL(capi20_manufacturer);
1271
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272/* ------------------------------------------------------------- */
1273/* -------- Init & Cleanup ------------------------------------- */
1274/* ------------------------------------------------------------- */
1275
1276/*
1277 * init / exit functions
1278 */
1279
Jan Kiszkaef69bb22010-02-08 10:12:13 +00001280static struct notifier_block capictr_nb = {
1281 .notifier_call = notify_handler,
1282 .priority = INT_MAX,
1283};
1284
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285static int __init kcapi_init(void)
1286{
Jan Kiszka88549d62010-02-08 10:12:09 +00001287 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288
Tejun Heo158fa672010-12-24 15:59:06 +01001289 kcapi_wq = alloc_workqueue("kcapi", 0, 0);
1290 if (!kcapi_wq)
1291 return -ENOMEM;
1292
Jan Kiszkaef69bb22010-02-08 10:12:13 +00001293 register_capictr_notifier(&capictr_nb);
1294
Jan Kiszka88549d62010-02-08 10:12:09 +00001295 err = cdebug_init();
Tejun Heo158fa672010-12-24 15:59:06 +01001296 if (err) {
1297 unregister_capictr_notifier(&capictr_nb);
1298 destroy_workqueue(kcapi_wq);
1299 return err;
1300 }
1301
1302 kcapi_proc_init();
1303 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304}
1305
1306static void __exit kcapi_exit(void)
1307{
Joe Perches475be4d2012-02-19 19:52:38 -08001308 kcapi_proc_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309
Tejun Heo158fa672010-12-24 15:59:06 +01001310 unregister_capictr_notifier(&capictr_nb);
Karsten Keil17f0cd22007-02-28 20:13:50 -08001311 cdebug_exit();
Tejun Heo158fa672010-12-24 15:59:06 +01001312 destroy_workqueue(kcapi_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313}
1314
1315module_init(kcapi_init);
1316module_exit(kcapi_exit);