kcapi.c 29.6 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12
/* $Id: kcapi.c,v 1.1.2.8 2004/03/26 19:57:20 armin Exp $
 * 
 * Kernel CAPI 2.0 Module
 * 
 * Copyright 1999 by Carsten Paeth <calle@calle.de>
 * Copyright 2002 by Kai Germaschewski <kai@germaschewski.name>
 * 
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 *
 */

13
#define AVMB1_COMPAT
L
Linus Torvalds 已提交
14 15 16 17 18 19 20

#include "kcapi.h"
#include <linux/module.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/ioport.h>
#include <linux/proc_fs.h>
21
#include <linux/sched.h>
L
Linus Torvalds 已提交
22 23 24 25 26 27 28 29 30 31 32
#include <linux/seq_file.h>
#include <linux/skbuff.h>
#include <linux/workqueue.h>
#include <linux/capi.h>
#include <linux/kernelcapi.h>
#include <linux/init.h>
#include <linux/moduleparam.h>
#include <linux/delay.h>
#include <asm/uaccess.h>
#include <linux/isdn/capicmd.h>
#include <linux/isdn/capiutil.h>
33
#ifdef AVMB1_COMPAT
L
Linus Torvalds 已提交
34 35
#include <linux/b1lli.h>
#endif
A
Arjan van de Ven 已提交
36
#include <linux/mutex.h>
L
Linus Torvalds 已提交
37 38 39 40 41 42 43 44 45 46

static int showcapimsgs = 0;

MODULE_DESCRIPTION("CAPI4Linux: kernel CAPI layer");
MODULE_AUTHOR("Carsten Paeth");
MODULE_LICENSE("GPL");
module_param(showcapimsgs, uint, 0);

/* ------------------------------------------------------------- */

47
struct capictr_event {
L
Linus Torvalds 已提交
48
	struct work_struct work;
49
	unsigned int type;
L
Linus Torvalds 已提交
50 51 52 53 54 55 56 57 58 59 60 61
	u32 controller;
};

/* ------------------------------------------------------------- */

static struct capi_version driver_version = {2, 0, 1, 1<<4};
static char driver_serial[CAPI_SERIAL_LEN] = "0004711";
static char capi_manufakturer[64] = "AVM Berlin";

#define NCCI2CTRL(ncci)    (((ncci) >> 24) & 0x7f)

LIST_HEAD(capi_drivers);
62
DEFINE_MUTEX(capi_drivers_lock);
L
Linus Torvalds 已提交
63

64 65 66
struct capi_ctr *capi_controller[CAPI_MAXCONTR];
DEFINE_MUTEX(capi_controller_lock);

L
Linus Torvalds 已提交
67 68 69 70
static DEFINE_RWLOCK(application_lock);

struct capi20_appl *capi_applications[CAPI_MAXAPPL];

71
static int ncontrollers;
L
Linus Torvalds 已提交
72

73 74
static BLOCKING_NOTIFIER_HEAD(ctr_notifier_list);

L
Linus Torvalds 已提交
75 76 77
/* -------- controller ref counting -------------------------------------- */

static inline struct capi_ctr *
78
capi_ctr_get(struct capi_ctr *ctr)
L
Linus Torvalds 已提交
79
{
80
	if (!try_module_get(ctr->owner))
L
Linus Torvalds 已提交
81
		return NULL;
82
	return ctr;
L
Linus Torvalds 已提交
83 84 85
}

static inline void
86
capi_ctr_put(struct capi_ctr *ctr)
L
Linus Torvalds 已提交
87
{
88
	module_put(ctr->owner);
L
Linus Torvalds 已提交
89 90 91 92 93 94 95 96 97
}

/* ------------------------------------------------------------- */

static inline struct capi_ctr *get_capi_ctr_by_nr(u16 contr)
{
	if (contr - 1 >= CAPI_MAXCONTR)
		return NULL;

98
	return capi_controller[contr - 1];
L
Linus Torvalds 已提交
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
}

static inline struct capi20_appl *get_capi_appl_by_nr(u16 applid)
{
	if (applid - 1 >= CAPI_MAXAPPL)
		return NULL;

	return capi_applications[applid - 1];
}

/* -------- util functions ------------------------------------ */

static inline int capi_cmd_valid(u8 cmd)
{
	switch (cmd) {
	case CAPI_ALERT:
	case CAPI_CONNECT:
	case CAPI_CONNECT_ACTIVE:
	case CAPI_CONNECT_B3_ACTIVE:
	case CAPI_CONNECT_B3:
	case CAPI_CONNECT_B3_T90_ACTIVE:
	case CAPI_DATA_B3:
	case CAPI_DISCONNECT_B3:
	case CAPI_DISCONNECT:
	case CAPI_FACILITY:
	case CAPI_INFO:
	case CAPI_LISTEN:
	case CAPI_MANUFACTURER:
	case CAPI_RESET_B3:
	case CAPI_SELECT_B_PROTOCOL:
		return 1;
	}
	return 0;
}

static inline int capi_subcmd_valid(u8 subcmd)
{
	switch (subcmd) {
	case CAPI_REQ:
	case CAPI_CONF:
	case CAPI_IND:
	case CAPI_RESP:
		return 1;
	}
	return 0;
}

/* ------------------------------------------------------------ */

148 149
static void
register_appl(struct capi_ctr *ctr, u16 applid, capi_register_params *rparam)
L
Linus Torvalds 已提交
150
{
151
	ctr = capi_ctr_get(ctr);
L
Linus Torvalds 已提交
152

153 154
	if (ctr)
		ctr->register_appl(ctr, applid, rparam);
L
Linus Torvalds 已提交
155
	else
156 157
		printk(KERN_WARNING "%s: cannot get controller resources\n",
		       __func__);
L
Linus Torvalds 已提交
158 159 160
}


161
static void release_appl(struct capi_ctr *ctr, u16 applid)
L
Linus Torvalds 已提交
162 163 164
{
	DBG("applid %#x", applid);
	
165 166
	ctr->release_appl(ctr, applid);
	capi_ctr_put(ctr);
L
Linus Torvalds 已提交
167 168 169 170 171
}

static void notify_up(u32 contr)
{
	struct capi20_appl *ap;
J
Jan Kiszka 已提交
172
	struct capi_ctr *ctr;
L
Linus Torvalds 已提交
173 174
	u16 applid;

175 176
	mutex_lock(&capi_controller_lock);

J
Jan Kiszka 已提交
177
	if (showcapimsgs & 1)
L
Linus Torvalds 已提交
178
	        printk(KERN_DEBUG "kcapi: notify up contr %d\n", contr);
J
Jan Kiszka 已提交
179 180 181 182

	ctr = get_capi_ctr_by_nr(contr);
	if (ctr) {
		if (ctr->state == CAPI_CTR_RUNNING)
183
			goto unlock_out;
J
Jan Kiszka 已提交
184 185 186 187 188 189 190 191 192

		ctr->state = CAPI_CTR_RUNNING;

		for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
			ap = get_capi_appl_by_nr(applid);
			if (!ap || ap->release_in_progress)
				continue;
			register_appl(ctr, applid, &ap->rparam);
		}
193 194

		wake_up_interruptible_all(&ctr->state_wait_queue);
J
Jan Kiszka 已提交
195
	} else
196
		printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr);
197 198 199

unlock_out:
	mutex_unlock(&capi_controller_lock);
L
Linus Torvalds 已提交
200 201
}

202
static void ctr_down(struct capi_ctr *ctr, int new_state)
L
Linus Torvalds 已提交
203 204 205 206
{
	struct capi20_appl *ap;
	u16 applid;

207
	if (ctr->state == CAPI_CTR_DETECTED || ctr->state == CAPI_CTR_DETACHED)
J
Jan Kiszka 已提交
208 209
		return;

210
	ctr->state = new_state;
J
Jan Kiszka 已提交
211 212 213 214 215

	memset(ctr->manu, 0, sizeof(ctr->manu));
	memset(&ctr->version, 0, sizeof(ctr->version));
	memset(&ctr->profile, 0, sizeof(ctr->profile));
	memset(ctr->serial, 0, sizeof(ctr->serial));
L
Linus Torvalds 已提交
216 217 218

	for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
		ap = get_capi_appl_by_nr(applid);
219
		if (ap && !ap->release_in_progress)
J
Jan Kiszka 已提交
220
			capi_ctr_put(ctr);
L
Linus Torvalds 已提交
221
	}
222 223

	wake_up_interruptible_all(&ctr->state_wait_queue);
L
Linus Torvalds 已提交
224 225
}

J
Jan Kiszka 已提交
226 227 228 229
static void notify_down(u32 contr)
{
	struct capi_ctr *ctr;

230 231
	mutex_lock(&capi_controller_lock);

J
Jan Kiszka 已提交
232 233 234 235 236
	if (showcapimsgs & 1)
		printk(KERN_DEBUG "kcapi: notify down contr %d\n", contr);

	ctr = get_capi_ctr_by_nr(contr);
	if (ctr)
237
		ctr_down(ctr, CAPI_CTR_DETECTED);
J
Jan Kiszka 已提交
238 239
	else
		printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr);
240 241

	mutex_unlock(&capi_controller_lock);
J
Jan Kiszka 已提交
242 243
}

244 245
static int
notify_handler(struct notifier_block *nb, unsigned long val, void *v)
L
Linus Torvalds 已提交
246
{
247
	u32 contr = (long)v;
L
Linus Torvalds 已提交
248

249 250 251
	switch (val) {
	case CAPICTR_UP:
		notify_up(contr);
L
Linus Torvalds 已提交
252
		break;
253 254
	case CAPICTR_DOWN:
		notify_down(contr);
L
Linus Torvalds 已提交
255 256
		break;
	}
257 258 259 260 261 262 263
	return NOTIFY_OK;
}

static void do_notify_work(struct work_struct *work)
{
	struct capictr_event *event =
		container_of(work, struct capictr_event, work);
L
Linus Torvalds 已提交
264

265 266 267
	blocking_notifier_call_chain(&ctr_notifier_list, event->type,
				     (void *)(long)event->controller);
	kfree(event);
L
Linus Torvalds 已提交
268 269 270 271 272 273
}

/*
 * The notifier will result in adding/deleteing of devices. Devices can
 * only removed in user process, not in bh.
 */
274
static int notify_push(unsigned int event_type, u32 controller)
L
Linus Torvalds 已提交
275
{
276
	struct capictr_event *event = kmalloc(sizeof(*event), GFP_ATOMIC);
L
Linus Torvalds 已提交
277

278
	if (!event)
L
Linus Torvalds 已提交
279 280
		return -ENOMEM;

281 282 283
	INIT_WORK(&event->work, do_notify_work);
	event->type = event_type;
	event->controller = controller;
L
Linus Torvalds 已提交
284

285
	schedule_work(&event->work);
L
Linus Torvalds 已提交
286 287 288
	return 0;
}

289 290 291 292 293 294 295 296 297 298 299 300
int register_capictr_notifier(struct notifier_block *nb)
{
	return blocking_notifier_chain_register(&ctr_notifier_list, nb);
}
EXPORT_SYMBOL_GPL(register_capictr_notifier);

int unregister_capictr_notifier(struct notifier_block *nb)
{
	return blocking_notifier_chain_unregister(&ctr_notifier_list, nb);
}
EXPORT_SYMBOL_GPL(unregister_capictr_notifier);

L
Linus Torvalds 已提交
301 302
/* -------- Receiver ------------------------------------------ */

D
David Howells 已提交
303
static void recv_handler(struct work_struct *work)
L
Linus Torvalds 已提交
304 305
{
	struct sk_buff *skb;
D
David Howells 已提交
306 307
	struct capi20_appl *ap =
		container_of(work, struct capi20_appl, recv_work);
L
Linus Torvalds 已提交
308 309 310 311

	if ((!ap) || (ap->release_in_progress))
		return;

312
	mutex_lock(&ap->recv_mtx);
L
Linus Torvalds 已提交
313 314 315 316 317 318 319 320
	while ((skb = skb_dequeue(&ap->recv_queue))) {
		if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_IND)
			ap->nrecvdatapkt++;
		else
			ap->nrecvctlpkt++;

		ap->recv_message(ap, skb);
	}
321
	mutex_unlock(&ap->recv_mtx);
L
Linus Torvalds 已提交
322 323
}

324 325
/**
 * capi_ctr_handle_message() - handle incoming CAPI message
326
 * @ctr:	controller descriptor structure.
327 328 329 330 331 332
 * @appl:	application ID.
 * @skb:	message.
 *
 * Called by hardware driver to pass a CAPI message to the application.
 */

333 334
void capi_ctr_handle_message(struct capi_ctr *ctr, u16 appl,
			     struct sk_buff *skb)
L
Linus Torvalds 已提交
335 336 337 338 339
{
	struct capi20_appl *ap;
	int showctl = 0;
	u8 cmd, subcmd;
	unsigned long flags;
340
	_cdebbuf *cdb;
L
Linus Torvalds 已提交
341

342
	if (ctr->state != CAPI_CTR_RUNNING) {
343 344 345
		cdb = capi_message2str(skb->data);
		if (cdb) {
			printk(KERN_INFO "kcapi: controller [%03d] not active, got: %s",
346
				ctr->cnr, cdb->buf);
347 348 349
			cdebbuf_free(cdb);
		} else
			printk(KERN_INFO "kcapi: controller [%03d] not active, cannot trace\n",
350
				ctr->cnr);
L
Linus Torvalds 已提交
351 352 353 354 355 356
		goto error;
	}

	cmd = CAPIMSG_COMMAND(skb->data);
        subcmd = CAPIMSG_SUBCOMMAND(skb->data);
	if (cmd == CAPI_DATA_B3 && subcmd == CAPI_IND) {
357 358 359
		ctr->nrecvdatapkt++;
		if (ctr->traceflag > 2)
			showctl |= 2;
L
Linus Torvalds 已提交
360
	} else {
361 362 363
		ctr->nrecvctlpkt++;
		if (ctr->traceflag)
			showctl |= 2;
L
Linus Torvalds 已提交
364
	}
365
	showctl |= (ctr->traceflag & 1);
L
Linus Torvalds 已提交
366 367
	if (showctl & 2) {
		if (showctl & 1) {
368
			printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u\n",
369
			       ctr->cnr, CAPIMSG_APPID(skb->data),
L
Linus Torvalds 已提交
370 371 372
			       capi_cmd2str(cmd, subcmd),
			       CAPIMSG_LEN(skb->data));
		} else {
373 374 375
			cdb = capi_message2str(skb->data);
			if (cdb) {
				printk(KERN_DEBUG "kcapi: got [%03d] %s\n",
376
					ctr->cnr, cdb->buf);
377 378 379
				cdebbuf_free(cdb);
			} else
				printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u, cannot trace\n",
380
					ctr->cnr, CAPIMSG_APPID(skb->data),
381 382
					capi_cmd2str(cmd, subcmd),
					CAPIMSG_LEN(skb->data));
L
Linus Torvalds 已提交
383 384 385 386 387 388 389 390
		}

	}

	read_lock_irqsave(&application_lock, flags);
	ap = get_capi_appl_by_nr(CAPIMSG_APPID(skb->data));
	if ((!ap) || (ap->release_in_progress)) {
		read_unlock_irqrestore(&application_lock, flags);
391 392 393 394 395 396 397 398 399
		cdb = capi_message2str(skb->data);
		if (cdb) {
			printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s)\n",
			CAPIMSG_APPID(skb->data), cdb->buf);
			cdebbuf_free(cdb);
		} else
			printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s) cannot trace\n",
				CAPIMSG_APPID(skb->data),
				capi_cmd2str(cmd, subcmd));
L
Linus Torvalds 已提交
400 401 402 403 404 405 406 407 408 409 410 411 412 413
		goto error;
	}
	skb_queue_tail(&ap->recv_queue, skb);
	schedule_work(&ap->recv_work);
	read_unlock_irqrestore(&application_lock, flags);

	return;

error:
	kfree_skb(skb);
}

EXPORT_SYMBOL(capi_ctr_handle_message);

414 415
/**
 * capi_ctr_ready() - signal CAPI controller ready
416
 * @ctr:	controller descriptor structure.
417 418 419 420
 *
 * Called by hardware driver to signal that the controller is up and running.
 */

421
void capi_ctr_ready(struct capi_ctr *ctr)
L
Linus Torvalds 已提交
422
{
423 424
	printk(KERN_NOTICE "kcapi: controller [%03d] \"%s\" ready.\n",
	       ctr->cnr, ctr->name);
L
Linus Torvalds 已提交
425

426
	notify_push(CAPICTR_UP, ctr->cnr);
L
Linus Torvalds 已提交
427 428 429 430
}

EXPORT_SYMBOL(capi_ctr_ready);

431
/**
432
 * capi_ctr_down() - signal CAPI controller not ready
433
 * @ctr:	controller descriptor structure.
434 435 436 437 438
 *
 * Called by hardware driver to signal that the controller is down and
 * unavailable for use.
 */

439
void capi_ctr_down(struct capi_ctr *ctr)
L
Linus Torvalds 已提交
440
{
441
	printk(KERN_NOTICE "kcapi: controller [%03d] down.\n", ctr->cnr);
L
Linus Torvalds 已提交
442

443
	notify_push(CAPICTR_DOWN, ctr->cnr);
L
Linus Torvalds 已提交
444 445
}

446
EXPORT_SYMBOL(capi_ctr_down);
L
Linus Torvalds 已提交
447

448 449
/**
 * capi_ctr_suspend_output() - suspend controller
450
 * @ctr:	controller descriptor structure.
451 452
 *
 * Called by hardware driver to stop data flow.
453 454 455
 *
 * Note: The caller is responsible for synchronizing concurrent state changes
 * as well as invocations of capi_ctr_handle_message.
456 457
 */

458
void capi_ctr_suspend_output(struct capi_ctr *ctr)
L
Linus Torvalds 已提交
459
{
460 461 462 463
	if (!ctr->blocked) {
		printk(KERN_DEBUG "kcapi: controller [%03d] suspend\n",
		       ctr->cnr);
		ctr->blocked = 1;
L
Linus Torvalds 已提交
464 465 466 467 468
	}
}

EXPORT_SYMBOL(capi_ctr_suspend_output);

469 470
/**
 * capi_ctr_resume_output() - resume controller
471
 * @ctr:	controller descriptor structure.
472 473
 *
 * Called by hardware driver to resume data flow.
474 475 476
 *
 * Note: The caller is responsible for synchronizing concurrent state changes
 * as well as invocations of capi_ctr_handle_message.
477 478
 */

479
void capi_ctr_resume_output(struct capi_ctr *ctr)
L
Linus Torvalds 已提交
480
{
481 482 483 484
	if (ctr->blocked) {
		printk(KERN_DEBUG "kcapi: controller [%03d] resumed\n",
		       ctr->cnr);
		ctr->blocked = 0;
L
Linus Torvalds 已提交
485 486 487 488 489 490 491
	}
}

EXPORT_SYMBOL(capi_ctr_resume_output);

/* ------------------------------------------------------------- */

492 493
/**
 * attach_capi_ctr() - register CAPI controller
494
 * @ctr:	controller descriptor structure.
495 496 497 498 499
 *
 * Called by hardware driver to register a controller with the CAPI subsystem.
 * Return value: 0 on success, error code < 0 on error
 */

500
int attach_capi_ctr(struct capi_ctr *ctr)
L
Linus Torvalds 已提交
501 502 503
{
	int i;

504
	mutex_lock(&capi_controller_lock);
L
Linus Torvalds 已提交
505 506

	for (i = 0; i < CAPI_MAXCONTR; i++) {
507
		if (!capi_controller[i])
L
Linus Torvalds 已提交
508 509 510
			break;
	}
	if (i == CAPI_MAXCONTR) {
511
		mutex_unlock(&capi_controller_lock);
L
Linus Torvalds 已提交
512 513 514
		printk(KERN_ERR "kcapi: out of controller slots\n");
	   	return -EBUSY;
	}
515
	capi_controller[i] = ctr;
L
Linus Torvalds 已提交
516

517 518 519 520 521 522 523 524
	ctr->nrecvctlpkt = 0;
	ctr->nrecvdatapkt = 0;
	ctr->nsentctlpkt = 0;
	ctr->nsentdatapkt = 0;
	ctr->cnr = i + 1;
	ctr->state = CAPI_CTR_DETECTED;
	ctr->blocked = 0;
	ctr->traceflag = showcapimsgs;
525
	init_waitqueue_head(&ctr->state_wait_queue);
526 527 528 529 530

	sprintf(ctr->procfn, "capi/controllers/%d", ctr->cnr);
	ctr->procent = proc_create_data(ctr->procfn, 0, NULL, ctr->proc_fops, ctr);

	ncontrollers++;
531 532 533

	mutex_unlock(&capi_controller_lock);

534 535
	printk(KERN_NOTICE "kcapi: controller [%03d]: %s attached\n",
			ctr->cnr, ctr->name);
L
Linus Torvalds 已提交
536 537 538 539 540
	return 0;
}

EXPORT_SYMBOL(attach_capi_ctr);

541 542
/**
 * detach_capi_ctr() - unregister CAPI controller
543
 * @ctr:	controller descriptor structure.
544 545 546 547 548 549
 *
 * Called by hardware driver to remove the registration of a controller
 * with the CAPI subsystem.
 * Return value: 0 on success, error code < 0 on error
 */

550
int detach_capi_ctr(struct capi_ctr *ctr)
L
Linus Torvalds 已提交
551
{
552
	int err = 0;
L
Linus Torvalds 已提交
553

554
	mutex_lock(&capi_controller_lock);
L
Linus Torvalds 已提交
555

556 557 558 559 560
	ctr_down(ctr, CAPI_CTR_DETACHED);

	if (capi_controller[ctr->cnr - 1] != ctr) {
		err = -EINVAL;
		goto unlock_out;
L
Linus Torvalds 已提交
561
	}
562
	capi_controller[ctr->cnr - 1] = NULL;
563 564 565 566 567
	ncontrollers--;

	if (ctr->procent)
		remove_proc_entry(ctr->procfn, NULL);

568 569
	printk(KERN_NOTICE "kcapi: controller [%03d]: %s unregistered\n",
	       ctr->cnr, ctr->name);
L
Linus Torvalds 已提交
570

571 572 573 574
unlock_out:
	mutex_unlock(&capi_controller_lock);

	return err;
L
Linus Torvalds 已提交
575 576 577 578
}

EXPORT_SYMBOL(detach_capi_ctr);

579 580 581 582 583 584 585
/**
 * register_capi_driver() - register CAPI driver
 * @driver:	driver descriptor structure.
 *
 * Called by hardware driver to register itself with the CAPI subsystem.
 */

L
Linus Torvalds 已提交
586 587
void register_capi_driver(struct capi_driver *driver)
{
588
	mutex_lock(&capi_drivers_lock);
L
Linus Torvalds 已提交
589
	list_add_tail(&driver->list, &capi_drivers);
590
	mutex_unlock(&capi_drivers_lock);
L
Linus Torvalds 已提交
591 592 593 594
}

EXPORT_SYMBOL(register_capi_driver);

595 596 597 598 599 600 601
/**
 * unregister_capi_driver() - unregister CAPI driver
 * @driver:	driver descriptor structure.
 *
 * Called by hardware driver to unregister itself from the CAPI subsystem.
 */

L
Linus Torvalds 已提交
602 603
void unregister_capi_driver(struct capi_driver *driver)
{
604
	mutex_lock(&capi_drivers_lock);
L
Linus Torvalds 已提交
605
	list_del(&driver->list);
606
	mutex_unlock(&capi_drivers_lock);
L
Linus Torvalds 已提交
607 608 609 610 611 612 613 614
}

EXPORT_SYMBOL(unregister_capi_driver);

/* ------------------------------------------------------------- */
/* -------- CAPI2.0 Interface ---------------------------------- */
/* ------------------------------------------------------------- */

615 616 617 618 619 620 621
/**
 * capi20_isinstalled() - CAPI 2.0 operation CAPI_INSTALLED
 *
 * Return value: CAPI result code (CAPI_NOERROR if at least one ISDN controller
 *	is ready for use, CAPI_REGNOTINSTALLED otherwise)
 */

L
Linus Torvalds 已提交
622 623
u16 capi20_isinstalled(void)
{
624
	u16 ret = CAPI_REGNOTINSTALLED;
L
Linus Torvalds 已提交
625
	int i;
626 627 628 629

	mutex_lock(&capi_controller_lock);

	for (i = 0; i < CAPI_MAXCONTR; i++)
630
		if (capi_controller[i] &&
631 632 633 634 635 636 637 638
		    capi_controller[i]->state == CAPI_CTR_RUNNING) {
			ret = CAPI_NOERROR;
			break;
		}

	mutex_unlock(&capi_controller_lock);

	return ret;
L
Linus Torvalds 已提交
639 640 641 642
}

EXPORT_SYMBOL(capi20_isinstalled);

643 644 645 646 647 648 649 650 651 652 653 654
/**
 * capi20_register() - CAPI 2.0 operation CAPI_REGISTER
 * @ap:		CAPI application descriptor structure.
 *
 * Register an application's presence with CAPI.
 * A unique application ID is assigned and stored in @ap->applid.
 * After this function returns successfully, the message receive
 * callback function @ap->recv_message() may be called at any time
 * until capi20_release() has been called for the same @ap.
 * Return value: CAPI result code
 */

L
Linus Torvalds 已提交
655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683
u16 capi20_register(struct capi20_appl *ap)
{
	int i;
	u16 applid;
	unsigned long flags;

	DBG("");

	if (ap->rparam.datablklen < 128)
		return CAPI_LOGBLKSIZETOSMALL;

	write_lock_irqsave(&application_lock, flags);

	for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
		if (capi_applications[applid - 1] == NULL)
			break;
	}
	if (applid > CAPI_MAXAPPL) {
		write_unlock_irqrestore(&application_lock, flags);
		return CAPI_TOOMANYAPPLS;
	}

	ap->applid = applid;
	capi_applications[applid - 1] = ap;

	ap->nrecvctlpkt = 0;
	ap->nrecvdatapkt = 0;
	ap->nsentctlpkt = 0;
	ap->nsentdatapkt = 0;
684
	mutex_init(&ap->recv_mtx);
L
Linus Torvalds 已提交
685
	skb_queue_head_init(&ap->recv_queue);
D
David Howells 已提交
686
	INIT_WORK(&ap->recv_work, recv_handler);
L
Linus Torvalds 已提交
687 688 689 690
	ap->release_in_progress = 0;

	write_unlock_irqrestore(&application_lock, flags);
	
691 692
	mutex_lock(&capi_controller_lock);

L
Linus Torvalds 已提交
693
	for (i = 0; i < CAPI_MAXCONTR; i++) {
694 695
		if (!capi_controller[i] ||
		    capi_controller[i]->state != CAPI_CTR_RUNNING)
L
Linus Torvalds 已提交
696
			continue;
697
		register_appl(capi_controller[i], applid, &ap->rparam);
L
Linus Torvalds 已提交
698
	}
699 700

	mutex_unlock(&capi_controller_lock);
L
Linus Torvalds 已提交
701 702 703 704 705 706 707 708 709 710

	if (showcapimsgs & 1) {
		printk(KERN_DEBUG "kcapi: appl %d up\n", applid);
	}

	return CAPI_NOERROR;
}

EXPORT_SYMBOL(capi20_register);

711 712 713 714 715 716 717 718 719 720
/**
 * capi20_release() - CAPI 2.0 operation CAPI_RELEASE
 * @ap:		CAPI application descriptor structure.
 *
 * Terminate an application's registration with CAPI.
 * After this function returns successfully, the message receive
 * callback function @ap->recv_message() will no longer be called.
 * Return value: CAPI result code
 */

L
Linus Torvalds 已提交
721 722 723 724 725 726 727 728 729 730 731 732
u16 capi20_release(struct capi20_appl *ap)
{
	int i;
	unsigned long flags;

	DBG("applid %#x", ap->applid);

	write_lock_irqsave(&application_lock, flags);
	ap->release_in_progress = 1;
	capi_applications[ap->applid - 1] = NULL;
	write_unlock_irqrestore(&application_lock, flags);

733 734
	mutex_lock(&capi_controller_lock);

L
Linus Torvalds 已提交
735
	for (i = 0; i < CAPI_MAXCONTR; i++) {
736 737
		if (!capi_controller[i] ||
		    capi_controller[i]->state != CAPI_CTR_RUNNING)
L
Linus Torvalds 已提交
738
			continue;
739
		release_appl(capi_controller[i], ap->applid);
L
Linus Torvalds 已提交
740
	}
741 742

	mutex_unlock(&capi_controller_lock);
L
Linus Torvalds 已提交
743 744 745 746 747 748 749 750 751 752 753 754 755

	flush_scheduled_work();
	skb_queue_purge(&ap->recv_queue);

	if (showcapimsgs & 1) {
		printk(KERN_DEBUG "kcapi: appl %d down\n", ap->applid);
	}

	return CAPI_NOERROR;
}

EXPORT_SYMBOL(capi20_release);

756 757 758 759 760 761 762 763 764
/**
 * capi20_put_message() - CAPI 2.0 operation CAPI_PUT_MESSAGE
 * @ap:		CAPI application descriptor structure.
 * @skb:	CAPI message.
 *
 * Transfer a single message to CAPI.
 * Return value: CAPI result code
 */

L
Linus Torvalds 已提交
765 766
u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb)
{
767
	struct capi_ctr *ctr;
L
Linus Torvalds 已提交
768 769 770 771 772
	int showctl = 0;
	u8 cmd, subcmd;

	DBG("applid %#x", ap->applid);
 
773
	if (ncontrollers == 0)
L
Linus Torvalds 已提交
774 775 776 777 778 779 780
		return CAPI_REGNOTINSTALLED;
	if ((ap->applid == 0) || ap->release_in_progress)
		return CAPI_ILLAPPNR;
	if (skb->len < 12
	    || !capi_cmd_valid(CAPIMSG_COMMAND(skb->data))
	    || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data)))
		return CAPI_ILLCMDORSUBCMDORMSGTOSMALL;
781 782 783 784 785 786

	/*
	 * The controller reference is protected by the existence of the
	 * application passed to us. We assume that the caller properly
	 * synchronizes this service with capi20_release.
	 */
787 788 789 790
	ctr = get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb->data));
	if (!ctr || ctr->state != CAPI_CTR_RUNNING) {
		ctr = get_capi_ctr_by_nr(1); /* XXX why? */
		if (!ctr || ctr->state != CAPI_CTR_RUNNING)
L
Linus Torvalds 已提交
791 792
			return CAPI_REGNOTINSTALLED;
	}
793
	if (ctr->blocked)
L
Linus Torvalds 已提交
794 795 796 797 798 799
		return CAPI_SENDQUEUEFULL;

	cmd = CAPIMSG_COMMAND(skb->data);
        subcmd = CAPIMSG_SUBCOMMAND(skb->data);

	if (cmd == CAPI_DATA_B3 && subcmd== CAPI_REQ) {
800
		ctr->nsentdatapkt++;
L
Linus Torvalds 已提交
801
		ap->nsentdatapkt++;
802 803
		if (ctr->traceflag > 2)
			showctl |= 2;
L
Linus Torvalds 已提交
804
	} else {
805
		ctr->nsentctlpkt++;
L
Linus Torvalds 已提交
806
		ap->nsentctlpkt++;
807 808
		if (ctr->traceflag)
			showctl |= 2;
L
Linus Torvalds 已提交
809
	}
810
	showctl |= (ctr->traceflag & 1);
L
Linus Torvalds 已提交
811 812
	if (showctl & 2) {
		if (showctl & 1) {
813
			printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u\n",
L
Linus Torvalds 已提交
814 815 816 817 818
			       CAPIMSG_CONTROLLER(skb->data),
			       CAPIMSG_APPID(skb->data),
			       capi_cmd2str(cmd, subcmd),
			       CAPIMSG_LEN(skb->data));
		} else {
819 820 821 822 823 824 825 826 827 828 829 830
			_cdebbuf *cdb = capi_message2str(skb->data);
			if (cdb) {
				printk(KERN_DEBUG "kcapi: put [%03d] %s\n",
					CAPIMSG_CONTROLLER(skb->data),
					cdb->buf);
				cdebbuf_free(cdb);
			} else
				printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u cannot trace\n",
					CAPIMSG_CONTROLLER(skb->data),
					CAPIMSG_APPID(skb->data),
					capi_cmd2str(cmd, subcmd),
					CAPIMSG_LEN(skb->data));
L
Linus Torvalds 已提交
831 832
		}
	}
833
	return ctr->send_message(ctr, skb);
L
Linus Torvalds 已提交
834 835 836 837
}

EXPORT_SYMBOL(capi20_put_message);

838 839 840 841 842 843 844 845 846 847
/**
 * capi20_get_manufacturer() - CAPI 2.0 operation CAPI_GET_MANUFACTURER
 * @contr:	controller number.
 * @buf:	result buffer (64 bytes).
 *
 * Retrieve information about the manufacturer of the specified ISDN controller
 * or (for @contr == 0) the driver itself.
 * Return value: CAPI result code
 */

L
Linus Torvalds 已提交
848 849
u16 capi20_get_manufacturer(u32 contr, u8 *buf)
{
850
	struct capi_ctr *ctr;
851
	u16 ret;
L
Linus Torvalds 已提交
852 853 854 855 856

	if (contr == 0) {
		strlcpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN);
		return CAPI_NOERROR;
	}
857 858 859

	mutex_lock(&capi_controller_lock);

860
	ctr = get_capi_ctr_by_nr(contr);
861 862 863 864 865 866 867 868
	if (ctr && ctr->state == CAPI_CTR_RUNNING) {
		strlcpy(buf, ctr->manu, CAPI_MANUFACTURER_LEN);
		ret = CAPI_NOERROR;
	} else
		ret = CAPI_REGNOTINSTALLED;

	mutex_unlock(&capi_controller_lock);
	return ret;
L
Linus Torvalds 已提交
869 870 871 872
}

EXPORT_SYMBOL(capi20_get_manufacturer);

873 874 875 876 877 878 879 880 881 882
/**
 * capi20_get_version() - CAPI 2.0 operation CAPI_GET_VERSION
 * @contr:	controller number.
 * @verp:	result structure.
 *
 * Retrieve version information for the specified ISDN controller
 * or (for @contr == 0) the driver itself.
 * Return value: CAPI result code
 */

L
Linus Torvalds 已提交
883 884
u16 capi20_get_version(u32 contr, struct capi_version *verp)
{
885
	struct capi_ctr *ctr;
886
	u16 ret;
L
Linus Torvalds 已提交
887 888 889 890 891

	if (contr == 0) {
		*verp = driver_version;
		return CAPI_NOERROR;
	}
892 893 894

	mutex_lock(&capi_controller_lock);

895
	ctr = get_capi_ctr_by_nr(contr);
896 897 898 899 900
	if (ctr && ctr->state == CAPI_CTR_RUNNING) {
		memcpy(verp, &ctr->version, sizeof(capi_version));
		ret = CAPI_NOERROR;
	} else
		ret = CAPI_REGNOTINSTALLED;
L
Linus Torvalds 已提交
901

902 903
	mutex_unlock(&capi_controller_lock);
	return ret;
L
Linus Torvalds 已提交
904 905 906 907
}

EXPORT_SYMBOL(capi20_get_version);

908 909 910 911 912 913 914 915 916 917
/**
 * capi20_get_serial() - CAPI 2.0 operation CAPI_GET_SERIAL_NUMBER
 * @contr:	controller number.
 * @serial:	result buffer (8 bytes).
 *
 * Retrieve the serial number of the specified ISDN controller
 * or (for @contr == 0) the driver itself.
 * Return value: CAPI result code
 */

L
Linus Torvalds 已提交
918 919
u16 capi20_get_serial(u32 contr, u8 *serial)
{
920
	struct capi_ctr *ctr;
921
	u16 ret;
L
Linus Torvalds 已提交
922 923 924 925 926

	if (contr == 0) {
		strlcpy(serial, driver_serial, CAPI_SERIAL_LEN);
		return CAPI_NOERROR;
	}
927 928 929

	mutex_lock(&capi_controller_lock);

930
	ctr = get_capi_ctr_by_nr(contr);
931 932 933 934 935
	if (ctr && ctr->state == CAPI_CTR_RUNNING) {
		strlcpy(serial, ctr->serial, CAPI_SERIAL_LEN);
		ret = CAPI_NOERROR;
	} else
		ret = CAPI_REGNOTINSTALLED;
L
Linus Torvalds 已提交
936

937 938
	mutex_unlock(&capi_controller_lock);
	return ret;
L
Linus Torvalds 已提交
939 940 941 942
}

EXPORT_SYMBOL(capi20_get_serial);

943 944 945 946 947 948 949 950 951 952
/**
 * capi20_get_profile() - CAPI 2.0 operation CAPI_GET_PROFILE
 * @contr:	controller number.
 * @profp:	result structure.
 *
 * Retrieve capability information for the specified ISDN controller
 * or (for @contr == 0) the number of installed controllers.
 * Return value: CAPI result code
 */

L
Linus Torvalds 已提交
953 954
u16 capi20_get_profile(u32 contr, struct capi_profile *profp)
{
955
	struct capi_ctr *ctr;
956
	u16 ret;
L
Linus Torvalds 已提交
957 958

	if (contr == 0) {
959
		profp->ncontroller = ncontrollers;
L
Linus Torvalds 已提交
960 961
		return CAPI_NOERROR;
	}
962 963 964

	mutex_lock(&capi_controller_lock);

965
	ctr = get_capi_ctr_by_nr(contr);
966 967 968 969 970
	if (ctr && ctr->state == CAPI_CTR_RUNNING) {
		memcpy(profp, &ctr->profile, sizeof(struct capi_profile));
		ret = CAPI_NOERROR;
	} else
		ret = CAPI_REGNOTINSTALLED;
L
Linus Torvalds 已提交
971

972 973
	mutex_unlock(&capi_controller_lock);
	return ret;
L
Linus Torvalds 已提交
974 975 976 977
}

EXPORT_SYMBOL(capi20_get_profile);

978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
/* Must be called with capi_controller_lock held. */
static int wait_on_ctr_state(struct capi_ctr *ctr, unsigned int state)
{
	DEFINE_WAIT(wait);
	int retval = 0;

	ctr = capi_ctr_get(ctr);
	if (!ctr)
		return -ESRCH;

	for (;;) {
		prepare_to_wait(&ctr->state_wait_queue, &wait,
				TASK_INTERRUPTIBLE);

		if (ctr->state == state)
			break;
		if (ctr->state == CAPI_CTR_DETACHED) {
			retval = -ESRCH;
			break;
		}
		if (signal_pending(current)) {
			retval = -EINTR;
			break;
		}

		mutex_unlock(&capi_controller_lock);
		schedule();
		mutex_lock(&capi_controller_lock);
	}
	finish_wait(&ctr->state_wait_queue, &wait);

	capi_ctr_put(ctr);

	return retval;
}

1014
#ifdef AVMB1_COMPAT
L
Linus Torvalds 已提交
1015 1016 1017 1018 1019 1020
static int old_capi_manufacturer(unsigned int cmd, void __user *data)
{
	avmb1_loadandconfigdef ldef;
	avmb1_extcarddef cdef;
	avmb1_resetdef rdef;
	capicardparams cparams;
1021
	struct capi_ctr *ctr;
L
Linus Torvalds 已提交
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
	struct capi_driver *driver = NULL;
	capiloaddata ldata;
	struct list_head *l;
	int retval;

	switch (cmd) {
	case AVMB1_ADDCARD:
	case AVMB1_ADDCARD_WITH_TYPE:
		if (cmd == AVMB1_ADDCARD) {
		   if ((retval = copy_from_user(&cdef, data,
					    sizeof(avmb1_carddef))))
			   return retval;
		   cdef.cardtype = AVM_CARDTYPE_B1;
		} else {
		   if ((retval = copy_from_user(&cdef, data,
					    sizeof(avmb1_extcarddef))))
			   return retval;
		}
		cparams.port = cdef.port;
		cparams.irq = cdef.irq;
		cparams.cardnr = cdef.cardnr;

1044 1045
		mutex_lock(&capi_drivers_lock);

L
Linus Torvalds 已提交
1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066
                switch (cdef.cardtype) {
			case AVM_CARDTYPE_B1:
				list_for_each(l, &capi_drivers) {
					driver = list_entry(l, struct capi_driver, list);
					if (strcmp(driver->name, "b1isa") == 0)
						break;
				}
				break;
			case AVM_CARDTYPE_T1:
				list_for_each(l, &capi_drivers) {
					driver = list_entry(l, struct capi_driver, list);
					if (strcmp(driver->name, "t1isa") == 0)
						break;
				}
				break;
			default:
				driver = NULL;
				break;
		}
		if (!driver) {
			printk(KERN_ERR "kcapi: driver not loaded.\n");
1067 1068
			retval = -EIO;
		} else if (!driver->add_card) {
L
Linus Torvalds 已提交
1069
			printk(KERN_ERR "kcapi: driver has no add card function.\n");
1070 1071 1072
			retval = -EIO;
		} else
			retval = driver->add_card(driver, &cparams);
L
Linus Torvalds 已提交
1073

1074
		mutex_unlock(&capi_drivers_lock);
L
Linus Torvalds 已提交
1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
		return retval;

	case AVMB1_LOAD:
	case AVMB1_LOAD_AND_CONFIG:

		if (cmd == AVMB1_LOAD) {
			if (copy_from_user(&ldef, data,
					   sizeof(avmb1_loaddef)))
				return -EFAULT;
			ldef.t4config.len = 0;
			ldef.t4config.data = NULL;
		} else {
			if (copy_from_user(&ldef, data,
					   sizeof(avmb1_loadandconfigdef)))
				return -EFAULT;
		}
1091 1092 1093

		mutex_lock(&capi_controller_lock);

1094
		ctr = get_capi_ctr_by_nr(ldef.contr);
1095 1096 1097 1098 1099
		if (!ctr) {
			retval = -EINVAL;
			goto load_unlock_out;
		}

1100
		if (ctr->load_firmware == NULL) {
L
Linus Torvalds 已提交
1101
			printk(KERN_DEBUG "kcapi: load: no load function\n");
1102 1103
			retval = -ESRCH;
			goto load_unlock_out;
L
Linus Torvalds 已提交
1104 1105 1106 1107
		}

		if (ldef.t4file.len <= 0) {
			printk(KERN_DEBUG "kcapi: load: invalid parameter: length of t4file is %d ?\n", ldef.t4file.len);
1108 1109
			retval = -EINVAL;
			goto load_unlock_out;
L
Linus Torvalds 已提交
1110
		}
1111
		if (ldef.t4file.data == NULL) {
L
Linus Torvalds 已提交
1112
			printk(KERN_DEBUG "kcapi: load: invalid parameter: dataptr is 0\n");
1113 1114
			retval = -EINVAL;
			goto load_unlock_out;
L
Linus Torvalds 已提交
1115 1116 1117 1118 1119 1120 1121 1122 1123
		}

		ldata.firmware.user = 1;
		ldata.firmware.data = ldef.t4file.data;
		ldata.firmware.len = ldef.t4file.len;
		ldata.configuration.user = 1;
		ldata.configuration.data = ldef.t4config.data;
		ldata.configuration.len = ldef.t4config.len;

1124
		if (ctr->state != CAPI_CTR_DETECTED) {
L
Linus Torvalds 已提交
1125
			printk(KERN_INFO "kcapi: load: contr=%d not in detect state\n", ldef.contr);
1126 1127
			retval = -EBUSY;
			goto load_unlock_out;
L
Linus Torvalds 已提交
1128
		}
1129
		ctr->state = CAPI_CTR_LOADING;
L
Linus Torvalds 已提交
1130

1131
		retval = ctr->load_firmware(ctr, &ldata);
L
Linus Torvalds 已提交
1132
		if (retval) {
1133
			ctr->state = CAPI_CTR_DETECTED;
1134
			goto load_unlock_out;
L
Linus Torvalds 已提交
1135 1136
		}

1137
		retval = wait_on_ctr_state(ctr, CAPI_CTR_RUNNING);
L
Linus Torvalds 已提交
1138

1139 1140 1141
load_unlock_out:
		mutex_unlock(&capi_controller_lock);
		return retval;
L
Linus Torvalds 已提交
1142 1143 1144 1145

	case AVMB1_RESETCARD:
		if (copy_from_user(&rdef, data, sizeof(avmb1_resetdef)))
			return -EFAULT;
1146 1147 1148 1149 1150

		retval = 0;

		mutex_lock(&capi_controller_lock);

1151
		ctr = get_capi_ctr_by_nr(rdef.contr);
1152 1153 1154 1155
		if (!ctr) {
			retval = -ESRCH;
			goto reset_unlock_out;
		}
L
Linus Torvalds 已提交
1156

1157
		if (ctr->state == CAPI_CTR_DETECTED)
1158
			goto reset_unlock_out;
L
Linus Torvalds 已提交
1159

1160
		ctr->reset_ctr(ctr);
L
Linus Torvalds 已提交
1161

1162
		retval = wait_on_ctr_state(ctr, CAPI_CTR_DETECTED);
L
Linus Torvalds 已提交
1163

1164 1165 1166
reset_unlock_out:
		mutex_unlock(&capi_controller_lock);
		return retval;
L
Linus Torvalds 已提交
1167 1168 1169 1170 1171
	}
	return -EINVAL;
}
#endif

1172 1173 1174 1175 1176 1177 1178 1179 1180
/**
 * capi20_manufacturer() - CAPI 2.0 operation CAPI_MANUFACTURER
 * @cmd:	command.
 * @data:	parameter.
 *
 * Perform manufacturer specific command.
 * Return value: CAPI result code
 */

L
Linus Torvalds 已提交
1181 1182
int capi20_manufacturer(unsigned int cmd, void __user *data)
{
1183
	struct capi_ctr *ctr;
1184
	int retval;
L
Linus Torvalds 已提交
1185 1186

	switch (cmd) {
1187
#ifdef AVMB1_COMPAT
L
Linus Torvalds 已提交
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201
	case AVMB1_LOAD:
	case AVMB1_LOAD_AND_CONFIG:
	case AVMB1_RESETCARD:
	case AVMB1_GET_CARDINFO:
	case AVMB1_REMOVECARD:
		return old_capi_manufacturer(cmd, data);
#endif
	case KCAPI_CMD_TRACE:
	{
		kcapi_flagdef fdef;

		if (copy_from_user(&fdef, data, sizeof(kcapi_flagdef)))
			return -EFAULT;

1202 1203
		mutex_lock(&capi_controller_lock);

1204
		ctr = get_capi_ctr_by_nr(fdef.contr);
1205 1206 1207 1208 1209 1210 1211 1212 1213
		if (ctr) {
			ctr->traceflag = fdef.flag;
			printk(KERN_INFO "kcapi: contr [%03d] set trace=%d\n",
			       ctr->cnr, ctr->traceflag);
			retval = 0;
		} else
			retval = -ESRCH;

		mutex_unlock(&capi_controller_lock);
L
Linus Torvalds 已提交
1214

1215
		return retval;
L
Linus Torvalds 已提交
1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233
	}
	case KCAPI_CMD_ADDCARD:
	{
		struct list_head *l;
		struct capi_driver *driver = NULL;
		capicardparams cparams;
		kcapi_carddef cdef;

		if ((retval = copy_from_user(&cdef, data, sizeof(cdef))))
			return retval;

		cparams.port = cdef.port;
		cparams.irq = cdef.irq;
		cparams.membase = cdef.membase;
		cparams.cardnr = cdef.cardnr;
		cparams.cardtype = 0;
		cdef.driver[sizeof(cdef.driver)-1] = 0;

1234 1235
		mutex_lock(&capi_drivers_lock);

L
Linus Torvalds 已提交
1236 1237 1238 1239 1240
		list_for_each(l, &capi_drivers) {
			driver = list_entry(l, struct capi_driver, list);
			if (strcmp(driver->name, cdef.driver) == 0)
				break;
		}
1241
		if (driver == NULL) {
L
Linus Torvalds 已提交
1242 1243
			printk(KERN_ERR "kcapi: driver \"%s\" not loaded.\n",
					cdef.driver);
1244 1245
			retval = -ESRCH;
		} else if (!driver->add_card) {
L
Linus Torvalds 已提交
1246
			printk(KERN_ERR "kcapi: driver \"%s\" has no add card function.\n", cdef.driver);
1247 1248 1249
			retval = -EIO;
		} else
			retval = driver->add_card(driver, &cparams);
L
Linus Torvalds 已提交
1250

1251 1252
		mutex_unlock(&capi_drivers_lock);
		return retval;
L
Linus Torvalds 已提交
1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273
	}

	default:
		printk(KERN_ERR "kcapi: manufacturer command %d unknown.\n",
					cmd);
		break;

	}
	return -EINVAL;
}

EXPORT_SYMBOL(capi20_manufacturer);

/* ------------------------------------------------------------- */
/* -------- Init & Cleanup ------------------------------------- */
/* ------------------------------------------------------------- */

/*
 * init / exit functions
 */

1274 1275 1276 1277 1278
static struct notifier_block capictr_nb = {
	.notifier_call = notify_handler,
	.priority = INT_MAX,
};

L
Linus Torvalds 已提交
1279 1280
static int __init kcapi_init(void)
{
1281
	int err;
L
Linus Torvalds 已提交
1282

1283 1284
	register_capictr_notifier(&capictr_nb);

1285 1286 1287 1288
	err = cdebug_init();
	if (!err)
		kcapi_proc_init();
	return err;
L
Linus Torvalds 已提交
1289 1290 1291 1292 1293 1294 1295 1296
}

static void __exit kcapi_exit(void)
{
        kcapi_proc_exit();

	/* make sure all notifiers are finished */
	flush_scheduled_work();
1297
	cdebug_exit();
L
Linus Torvalds 已提交
1298 1299 1300 1301
}

module_init(kcapi_init);
module_exit(kcapi_exit);