Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 52253031 authored by Jan Kiszka's avatar Jan Kiszka Committed by David S. Miller
Browse files

CAPI: Call a controller 'controller', not 'card' 



At least for our internal use, fix the misnomers that refer to a CAPI
controller as 'card'. No functional changes.

Signed-off-by: default avatarJan Kiszka <jan.kiszka@web.de>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 88549d6b

drivers/isdn/capi/kcapi.c

+165 −155
Original line number Diff line number Diff line
@@ -67,24 +67,24 @@ static DEFINE_RWLOCK(application_lock); 
static DEFINE_MUTEX(controller_mutex);



struct capi20_appl *capi_applications[CAPI_MAXAPPL];

struct capi_ctr *capi_cards[CAPI_MAXCONTR];

struct capi_ctr *capi_controller[CAPI_MAXCONTR];



static int ncards;

static int ncontrollers;



/* -------- controller ref counting -------------------------------------- */



static inline struct capi_ctr *

capi_ctr_get(struct capi_ctr *card)

capi_ctr_get(struct capi_ctr *ctr)

{

	if (!try_module_get(card->owner))

	if (!try_module_get(ctr->owner))

		return NULL;

	return card;

	return ctr;

}



static inline void

capi_ctr_put(struct capi_ctr *card)

capi_ctr_put(struct capi_ctr *ctr)

{

	module_put(card->owner);

	module_put(ctr->owner);

}



/* ------------------------------------------------------------- */
@@ -94,7 +94,7 @@ static inline struct capi_ctr *get_capi_ctr_by_nr(u16 contr) 
	if (contr - 1 >= CAPI_MAXCONTR)

		return NULL;



	return capi_cards[contr - 1];

	return capi_controller[contr - 1];

}



static inline struct capi20_appl *get_capi_appl_by_nr(u16 applid)
@@ -144,46 +144,48 @@ static inline int capi_subcmd_valid(u8 subcmd) 


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



static void register_appl(struct capi_ctr *card, u16 applid, capi_register_params *rparam)

static void

register_appl(struct capi_ctr *ctr, u16 applid, capi_register_params *rparam)

{

	card = capi_ctr_get(card);

	ctr = capi_ctr_get(ctr);



	if (card)

		card->register_appl(card, applid, rparam);

	if (ctr)

		ctr->register_appl(ctr, applid, rparam);

	else

		printk(KERN_WARNING "%s: cannot get card resources\n", __func__);

		printk(KERN_WARNING "%s: cannot get controller resources\n",

		       __func__);

}





static void release_appl(struct capi_ctr *card, u16 applid)

static void release_appl(struct capi_ctr *ctr, u16 applid)

{

	DBG("applid %#x", applid);

	

	card->release_appl(card, applid);

	capi_ctr_put(card);

	ctr->release_appl(ctr, applid);

	capi_ctr_put(ctr);

}



/* -------- KCI_CONTRUP --------------------------------------- */



static void notify_up(u32 contr)

{

	struct capi_ctr *card = get_capi_ctr_by_nr(contr);

	struct capi_ctr *ctr = get_capi_ctr_by_nr(contr);

	struct capi20_appl *ap;

	u16 applid;



	if (showcapimsgs & 1) {

	        printk(KERN_DEBUG "kcapi: notify up contr %d\n", contr);

	}

	if (!card) {

	if (!ctr) {

		printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr);

		return;

	}

	for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {

		ap = get_capi_appl_by_nr(applid);

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

		register_appl(card, applid, &ap->rparam);

		register_appl(ctr, applid, &ap->rparam);

		if (ap->callback && !ap->release_in_progress)

			ap->callback(KCI_CONTRUP, contr, &card->profile);

			ap->callback(KCI_CONTRUP, contr, &ctr->profile);

	}

}
@@ -269,14 +271,15 @@ static void recv_handler(struct work_struct *work) 


/**

 * capi_ctr_handle_message() - handle incoming CAPI message

 * @card:	controller descriptor structure.

 * @ctr:	controller descriptor structure.

 * @appl:	application ID.

 * @skb:	message.

 *

 * Called by hardware driver to pass a CAPI message to the application.

 */



void capi_ctr_handle_message(struct capi_ctr * card, u16 appl, struct sk_buff *skb)

void capi_ctr_handle_message(struct capi_ctr *ctr, u16 appl,

			     struct sk_buff *skb)

{

	struct capi20_appl *ap;

	int showctl = 0;
@@ -284,43 +287,45 @@ void capi_ctr_handle_message(struct capi_ctr * card, u16 appl, struct sk_buff *s 
	unsigned long flags;

	_cdebbuf *cdb;



	if (card->cardstate != CARD_RUNNING) {

	if (ctr->state != CAPI_CTR_RUNNING) {

		cdb = capi_message2str(skb->data);

		if (cdb) {

			printk(KERN_INFO "kcapi: controller [%03d] not active, got: %s",

				card->cnr, cdb->buf);

				ctr->cnr, cdb->buf);

			cdebbuf_free(cdb);

		} else

			printk(KERN_INFO "kcapi: controller [%03d] not active, cannot trace\n",

				card->cnr);

				ctr->cnr);

		goto error;

	}



	cmd = CAPIMSG_COMMAND(skb->data);

        subcmd = CAPIMSG_SUBCOMMAND(skb->data);

	if (cmd == CAPI_DATA_B3 && subcmd == CAPI_IND) {

		card->nrecvdatapkt++;

	        if (card->traceflag > 2) showctl |= 2;

		ctr->nrecvdatapkt++;

		if (ctr->traceflag > 2)

			showctl |= 2;

	} else {

		card->nrecvctlpkt++;

	        if (card->traceflag) showctl |= 2;

		ctr->nrecvctlpkt++;

		if (ctr->traceflag)

			showctl |= 2;

	}

	showctl |= (card->traceflag & 1);

	showctl |= (ctr->traceflag & 1);

	if (showctl & 2) {

		if (showctl & 1) {

			printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u\n",

			       card->cnr, CAPIMSG_APPID(skb->data),

			       ctr->cnr, CAPIMSG_APPID(skb->data),

			       capi_cmd2str(cmd, subcmd),

			       CAPIMSG_LEN(skb->data));

		} else {

			cdb = capi_message2str(skb->data);

			if (cdb) {

				printk(KERN_DEBUG "kcapi: got [%03d] %s\n",

					card->cnr, cdb->buf);

					ctr->cnr, cdb->buf);

				cdebbuf_free(cdb);

			} else

				printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u, cannot trace\n",

					card->cnr, CAPIMSG_APPID(skb->data),

					ctr->cnr, CAPIMSG_APPID(skb->data),

					capi_cmd2str(cmd, subcmd),

					CAPIMSG_LEN(skb->data));

		}
@@ -356,74 +361,75 @@ EXPORT_SYMBOL(capi_ctr_handle_message); 


/**

 * capi_ctr_ready() - signal CAPI controller ready

 * @card:	controller descriptor structure.

 * @ctr:	controller descriptor structure.

 *

 * Called by hardware driver to signal that the controller is up and running.

 */



void capi_ctr_ready(struct capi_ctr * card)

void capi_ctr_ready(struct capi_ctr *ctr)

{

	card->cardstate = CARD_RUNNING;

	ctr->state = CAPI_CTR_RUNNING;



        printk(KERN_NOTICE "kcapi: card [%03d] \"%s\" ready.\n",

	       card->cnr, card->name);

	printk(KERN_NOTICE "kcapi: controller [%03d] \"%s\" ready.\n",

	       ctr->cnr, ctr->name);



	notify_push(KCI_CONTRUP, card->cnr, 0, 0);

	notify_push(KCI_CONTRUP, ctr->cnr, 0, 0);

}



EXPORT_SYMBOL(capi_ctr_ready);



/**

 * capi_ctr_down() - signal CAPI controller not ready

 * @card:	controller descriptor structure.

 * @ctr:	controller descriptor structure.

 *

 * Called by hardware driver to signal that the controller is down and

 * unavailable for use.

 */



void capi_ctr_down(struct capi_ctr * card)

void capi_ctr_down(struct capi_ctr *ctr)

{

	u16 appl;



	DBG("");



        if (card->cardstate == CARD_DETECTED)

	if (ctr->state == CAPI_CTR_DETECTED)

		return;



        card->cardstate = CARD_DETECTED;

	ctr->state = CAPI_CTR_DETECTED;



	memset(card->manu, 0, sizeof(card->manu));

	memset(&card->version, 0, sizeof(card->version));

	memset(&card->profile, 0, sizeof(card->profile));

	memset(card->serial, 0, sizeof(card->serial));

	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));



	for (appl = 1; appl <= CAPI_MAXAPPL; appl++) {

		struct capi20_appl *ap = get_capi_appl_by_nr(appl);

		if (!ap || ap->release_in_progress)

			continue;



		capi_ctr_put(card);

		capi_ctr_put(ctr);

	}



	printk(KERN_NOTICE "kcapi: card [%03d] down.\n", card->cnr);

	printk(KERN_NOTICE "kcapi: controller [%03d] down.\n", ctr->cnr);



	notify_push(KCI_CONTRDOWN, card->cnr, 0, 0);

	notify_push(KCI_CONTRDOWN, ctr->cnr, 0, 0);

}



EXPORT_SYMBOL(capi_ctr_down);



/**

 * capi_ctr_suspend_output() - suspend controller

 * @card:	controller descriptor structure.

 * @ctr:	controller descriptor structure.

 *

 * Called by hardware driver to stop data flow.

 */



void capi_ctr_suspend_output(struct capi_ctr *card)

void capi_ctr_suspend_output(struct capi_ctr *ctr)

{

	if (!card->blocked) {

		printk(KERN_DEBUG "kcapi: card [%03d] suspend\n", card->cnr);

		card->blocked = 1;

	if (!ctr->blocked) {

		printk(KERN_DEBUG "kcapi: controller [%03d] suspend\n",

		       ctr->cnr);

		ctr->blocked = 1;

	}

}
@@ -431,16 +437,17 @@ EXPORT_SYMBOL(capi_ctr_suspend_output); 


/**

 * capi_ctr_resume_output() - resume controller

 * @card:	controller descriptor structure.

 * @ctr:	controller descriptor structure.

 *

 * Called by hardware driver to resume data flow.

 */



void capi_ctr_resume_output(struct capi_ctr *card)

void capi_ctr_resume_output(struct capi_ctr *ctr)

{

	if (card->blocked) {

		printk(KERN_DEBUG "kcapi: card [%03d] resume\n", card->cnr);

		card->blocked = 0;

	if (ctr->blocked) {

		printk(KERN_DEBUG "kcapi: controller [%03d] resumed\n",

		       ctr->cnr);

		ctr->blocked = 0;

	}

}
@@ -450,21 +457,20 @@ EXPORT_SYMBOL(capi_ctr_resume_output); 


/**

 * attach_capi_ctr() - register CAPI controller

 * @card:	controller descriptor structure.

 * @ctr:	controller descriptor structure.

 *

 * Called by hardware driver to register a controller with the CAPI subsystem.

 * Return value: 0 on success, error code < 0 on error

 */



int

attach_capi_ctr(struct capi_ctr *card)

int attach_capi_ctr(struct capi_ctr *ctr)

{

	int i;



	mutex_lock(&controller_mutex);



	for (i = 0; i < CAPI_MAXCONTR; i++) {

		if (capi_cards[i] == NULL)

		if (!capi_controller[i])

			break;

	}

	if (i == CAPI_MAXCONTR) {
@@ -472,25 +478,25 @@ attach_capi_ctr(struct capi_ctr *card) 
		printk(KERN_ERR "kcapi: out of controller slots\n");

	   	return -EBUSY;

	}

	capi_cards[i] = card;

	capi_controller[i] = ctr;



	mutex_unlock(&controller_mutex);



	card->nrecvctlpkt = 0;

	card->nrecvdatapkt = 0;

	card->nsentctlpkt = 0;

	card->nsentdatapkt = 0;

	card->cnr = i + 1;

	card->cardstate = CARD_DETECTED;

	card->blocked = 0;

	card->traceflag = showcapimsgs;



	sprintf(card->procfn, "capi/controllers/%d", card->cnr);

	card->procent = proc_create_data(card->procfn, 0, NULL, card->proc_fops, card);



	ncards++;

	printk(KERN_NOTICE "kcapi: Controller [%03d]: %s attached\n",

			card->cnr, card->name);

	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;



	sprintf(ctr->procfn, "capi/controllers/%d", ctr->cnr);

	ctr->procent = proc_create_data(ctr->procfn, 0, NULL, ctr->proc_fops, ctr);



	ncontrollers++;

	printk(KERN_NOTICE "kcapi: controller [%03d]: %s attached\n",

			ctr->cnr, ctr->name);

	return 0;

}
@@ -498,27 +504,27 @@ EXPORT_SYMBOL(attach_capi_ctr); 


/**

 * detach_capi_ctr() - unregister CAPI controller

 * @card:	controller descriptor structure.

 * @ctr:	controller descriptor structure.

 *

 * 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

 */



int detach_capi_ctr(struct capi_ctr *card)

int detach_capi_ctr(struct capi_ctr *ctr)

{

        if (card->cardstate != CARD_DETECTED)

		capi_ctr_down(card);

	if (ctr->state != CAPI_CTR_DETECTED)

		capi_ctr_down(ctr);



	ncards--;

	ncontrollers--;



	if (card->procent) {

	   remove_proc_entry(card->procfn, NULL);

	   card->procent = NULL;

	if (ctr->procent) {

		remove_proc_entry(ctr->procfn, NULL);

		ctr->procent = NULL;

	}

	capi_cards[card->cnr - 1] = NULL;

	printk(KERN_NOTICE "kcapi: Controller [%03d]: %s unregistered\n",

			card->cnr, card->name);

	capi_controller[ctr->cnr - 1] = NULL;

	printk(KERN_NOTICE "kcapi: controller [%03d]: %s unregistered\n",

	       ctr->cnr, ctr->name);



	return 0;

}
@@ -576,7 +582,8 @@ u16 capi20_isinstalled(void) 
{

	int i;

	for (i = 0; i < CAPI_MAXCONTR; i++) {

		if (capi_cards[i] && capi_cards[i]->cardstate == CARD_RUNNING)

		if (capi_controller[i] &&

		    capi_controller[i]->state == CAPI_CTR_RUNNING)

			return CAPI_NOERROR;

	}

	return CAPI_REGNOTINSTALLED;
@@ -635,9 +642,10 @@ u16 capi20_register(struct capi20_appl *ap) 
	

	mutex_lock(&controller_mutex);

	for (i = 0; i < CAPI_MAXCONTR; i++) {

		if (!capi_cards[i] || capi_cards[i]->cardstate != CARD_RUNNING)

		if (!capi_controller[i] ||

		    capi_controller[i]->state != CAPI_CTR_RUNNING)

			continue;

		register_appl(capi_cards[i], applid, &ap->rparam);

		register_appl(capi_controller[i], applid, &ap->rparam);

	}

	mutex_unlock(&controller_mutex);
@@ -674,9 +682,10 @@ u16 capi20_release(struct capi20_appl *ap) 


	mutex_lock(&controller_mutex);

	for (i = 0; i < CAPI_MAXCONTR; i++) {

		if (!capi_cards[i] || capi_cards[i]->cardstate != CARD_RUNNING)

		if (!capi_controller[i] ||

		    capi_controller[i]->state != CAPI_CTR_RUNNING)

			continue;

		release_appl(capi_cards[i], ap->applid);

		release_appl(capi_controller[i], ap->applid);

	}

	mutex_unlock(&controller_mutex);
@@ -703,13 +712,13 @@ EXPORT_SYMBOL(capi20_release); 


u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb)

{

	struct capi_ctr *card;

	struct capi_ctr *ctr;

	int showctl = 0;

	u8 cmd, subcmd;



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

 

	if (ncards == 0)

	if (ncontrollers == 0)

		return CAPI_REGNOTINSTALLED;

	if ((ap->applid == 0) || ap->release_in_progress)

		return CAPI_ILLAPPNR;
@@ -717,28 +726,30 @@ u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb) 
	    || !capi_cmd_valid(CAPIMSG_COMMAND(skb->data))

	    || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data)))

		return CAPI_ILLCMDORSUBCMDORMSGTOSMALL;

	card = get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb->data));

	if (!card || card->cardstate != CARD_RUNNING) {

		card = get_capi_ctr_by_nr(1); // XXX why?

	        if (!card || card->cardstate != CARD_RUNNING) 

	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)

			return CAPI_REGNOTINSTALLED;

	}

	if (card->blocked)

	if (ctr->blocked)

		return CAPI_SENDQUEUEFULL;



	cmd = CAPIMSG_COMMAND(skb->data);

        subcmd = CAPIMSG_SUBCOMMAND(skb->data);



	if (cmd == CAPI_DATA_B3 && subcmd== CAPI_REQ) {

		card->nsentdatapkt++;

		ctr->nsentdatapkt++;

		ap->nsentdatapkt++;

	        if (card->traceflag > 2) showctl |= 2;

		if (ctr->traceflag > 2)

			showctl |= 2;

	} else {

		card->nsentctlpkt++;

		ctr->nsentctlpkt++;

		ap->nsentctlpkt++;

	        if (card->traceflag) showctl |= 2;

		if (ctr->traceflag)

			showctl |= 2;

	}

	showctl |= (card->traceflag & 1);

	showctl |= (ctr->traceflag & 1);

	if (showctl & 2) {

		if (showctl & 1) {

			printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u\n",
@@ -761,7 +772,7 @@ u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb) 
					CAPIMSG_LEN(skb->data));

		}

	}

	return card->send_message(card, skb);

	return ctr->send_message(ctr, skb);

}



EXPORT_SYMBOL(capi20_put_message);
@@ -778,16 +789,16 @@ EXPORT_SYMBOL(capi20_put_message); 


u16 capi20_get_manufacturer(u32 contr, u8 *buf)

{

	struct capi_ctr *card;

	struct capi_ctr *ctr;



	if (contr == 0) {

		strlcpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN);

		return CAPI_NOERROR;

	}

	card = get_capi_ctr_by_nr(contr);

	if (!card || card->cardstate != CARD_RUNNING) 

	ctr = get_capi_ctr_by_nr(contr);

	if (!ctr || ctr->state != CAPI_CTR_RUNNING)

		return CAPI_REGNOTINSTALLED;

	strlcpy(buf, card->manu, CAPI_MANUFACTURER_LEN);

	strlcpy(buf, ctr->manu, CAPI_MANUFACTURER_LEN);

	return CAPI_NOERROR;

}
@@ -805,17 +816,17 @@ EXPORT_SYMBOL(capi20_get_manufacturer); 


u16 capi20_get_version(u32 contr, struct capi_version *verp)

{

	struct capi_ctr *card;

	struct capi_ctr *ctr;



	if (contr == 0) {

		*verp = driver_version;

		return CAPI_NOERROR;

	}

	card = get_capi_ctr_by_nr(contr);

	if (!card || card->cardstate != CARD_RUNNING) 

	ctr = get_capi_ctr_by_nr(contr);

	if (!ctr || ctr->state != CAPI_CTR_RUNNING)

		return CAPI_REGNOTINSTALLED;



	memcpy((void *) verp, &card->version, sizeof(capi_version));

	memcpy(verp, &ctr->version, sizeof(capi_version));

	return CAPI_NOERROR;

}
@@ -833,17 +844,17 @@ EXPORT_SYMBOL(capi20_get_version); 


u16 capi20_get_serial(u32 contr, u8 *serial)

{

	struct capi_ctr *card;

	struct capi_ctr *ctr;



	if (contr == 0) {

		strlcpy(serial, driver_serial, CAPI_SERIAL_LEN);

		return CAPI_NOERROR;

	}

	card = get_capi_ctr_by_nr(contr);

	if (!card || card->cardstate != CARD_RUNNING) 

	ctr = get_capi_ctr_by_nr(contr);

	if (!ctr || ctr->state != CAPI_CTR_RUNNING)

		return CAPI_REGNOTINSTALLED;



	strlcpy((void *) serial, card->serial, CAPI_SERIAL_LEN);

	strlcpy(serial, ctr->serial, CAPI_SERIAL_LEN);

	return CAPI_NOERROR;

}
@@ -861,18 +872,17 @@ EXPORT_SYMBOL(capi20_get_serial); 


u16 capi20_get_profile(u32 contr, struct capi_profile *profp)

{

	struct capi_ctr *card;

	struct capi_ctr *ctr;



	if (contr == 0) {

		profp->ncontroller = ncards;

		profp->ncontroller = ncontrollers;

		return CAPI_NOERROR;

	}

	card = get_capi_ctr_by_nr(contr);

	if (!card || card->cardstate != CARD_RUNNING) 

	ctr = get_capi_ctr_by_nr(contr);

	if (!ctr || ctr->state != CAPI_CTR_RUNNING)

		return CAPI_REGNOTINSTALLED;



	memcpy((void *) profp, &card->profile,

			sizeof(struct capi_profile));

	memcpy(profp, &ctr->profile, sizeof(struct capi_profile));

	return CAPI_NOERROR;

}
@@ -885,7 +895,7 @@ static int old_capi_manufacturer(unsigned int cmd, void __user *data) 
	avmb1_extcarddef cdef;

	avmb1_resetdef rdef;

	capicardparams cparams;

	struct capi_ctr *card;

	struct capi_ctr *ctr;

	struct capi_driver *driver = NULL;

	capiloaddata ldata;

	struct list_head *l;
@@ -958,26 +968,26 @@ static int old_capi_manufacturer(unsigned int cmd, void __user *data) 
					   sizeof(avmb1_loadandconfigdef)))

				return -EFAULT;

		}

		card = get_capi_ctr_by_nr(ldef.contr);

		if (!card)

		ctr = get_capi_ctr_by_nr(ldef.contr);

		if (!ctr)

			return -EINVAL;

		card = capi_ctr_get(card);

		if (!card)

		ctr = capi_ctr_get(ctr);

		if (!ctr)

			return -ESRCH;

		if (card->load_firmware == NULL) {

		if (ctr->load_firmware == NULL) {

			printk(KERN_DEBUG "kcapi: load: no load function\n");

			capi_ctr_put(card);

			capi_ctr_put(ctr);

			return -ESRCH;

		}



		if (ldef.t4file.len <= 0) {

			printk(KERN_DEBUG "kcapi: load: invalid parameter: length of t4file is %d ?\n", ldef.t4file.len);

			capi_ctr_put(card);

			capi_ctr_put(ctr);

			return -EINVAL;

		}

		if (ldef.t4file.data == NULL) {

			printk(KERN_DEBUG "kcapi: load: invalid parameter: dataptr is 0\n");

			capi_ctr_put(card);

			capi_ctr_put(ctr);

			return -EINVAL;

		}
@@ -988,46 +998,46 @@ static int old_capi_manufacturer(unsigned int cmd, void __user *data) 
		ldata.configuration.data = ldef.t4config.data;

		ldata.configuration.len = ldef.t4config.len;



		if (card->cardstate != CARD_DETECTED) {

		if (ctr->state != CAPI_CTR_DETECTED) {

			printk(KERN_INFO "kcapi: load: contr=%d not in detect state\n", ldef.contr);

			capi_ctr_put(card);

			capi_ctr_put(ctr);

			return -EBUSY;

		}

		card->cardstate = CARD_LOADING;

		ctr->state = CAPI_CTR_LOADING;



		retval = card->load_firmware(card, &ldata);

		retval = ctr->load_firmware(ctr, &ldata);



		if (retval) {

			card->cardstate = CARD_DETECTED;

			capi_ctr_put(card);

			ctr->state = CAPI_CTR_DETECTED;

			capi_ctr_put(ctr);

			return retval;

		}



		while (card->cardstate != CARD_RUNNING) {

		while (ctr->state != CAPI_CTR_RUNNING) {



			msleep_interruptible(100);	/* 0.1 sec */



			if (signal_pending(current)) {

				capi_ctr_put(card);

				capi_ctr_put(ctr);

				return -EINTR;

			}

		}

		capi_ctr_put(card);

		capi_ctr_put(ctr);

		return 0;



	case AVMB1_RESETCARD:

		if (copy_from_user(&rdef, data, sizeof(avmb1_resetdef)))

			return -EFAULT;

		card = get_capi_ctr_by_nr(rdef.contr);

		if (!card)

		ctr = get_capi_ctr_by_nr(rdef.contr);

		if (!ctr)

			return -ESRCH;



		if (card->cardstate == CARD_DETECTED)

		if (ctr->state == CAPI_CTR_DETECTED)

			return 0;



		card->reset_ctr(card);

		ctr->reset_ctr(ctr);



		while (card->cardstate > CARD_DETECTED) {

		while (ctr->state > CAPI_CTR_DETECTED) {



			msleep_interruptible(100);	/* 0.1 sec */
@@ -1052,7 +1062,7 @@ static int old_capi_manufacturer(unsigned int cmd, void __user *data) 


int capi20_manufacturer(unsigned int cmd, void __user *data)

{

        struct capi_ctr *card;

	struct capi_ctr *ctr;



	switch (cmd) {

#ifdef AVMB1_COMPAT
@@ -1070,13 +1080,13 @@ int capi20_manufacturer(unsigned int cmd, void __user *data) 
		if (copy_from_user(&fdef, data, sizeof(kcapi_flagdef)))

			return -EFAULT;



		card = get_capi_ctr_by_nr(fdef.contr);

		if (!card)

		ctr = get_capi_ctr_by_nr(fdef.contr);

		if (!ctr)

			return -ESRCH;



		card->traceflag = fdef.flag;

		ctr->traceflag = fdef.flag;

		printk(KERN_INFO "kcapi: contr [%03d] set trace=%d\n",

			card->cnr, card->traceflag);

		       ctr->cnr, ctr->traceflag);

		return 0;

	}

	case KCAPI_CMD_ADDCARD:

drivers/isdn/capi/kcapi.h

+4 −4
Original line number Diff line number Diff line
@@ -24,16 +24,16 @@ printk(KERN_DEBUG "%s: " format "\n" , __func__ , ## arg); \ 
#endif



enum {

	CARD_DETECTED = 1,

	CARD_LOADING  =	2,

	CARD_RUNNING  = 3,

	CAPI_CTR_DETECTED = 1,

	CAPI_CTR_LOADING  = 2,

	CAPI_CTR_RUNNING  = 3,

};



extern struct list_head capi_drivers;

extern rwlock_t capi_drivers_list_lock;



extern struct capi20_appl *capi_applications[CAPI_MAXAPPL];

extern struct capi_ctr *capi_cards[CAPI_MAXCONTR];

extern struct capi_ctr *capi_controller[CAPI_MAXCONTR];



#ifdef CONFIG_PROC_FS

drivers/isdn/capi/kcapi_proc.c

+8 −9
Original line number Diff line number Diff line
@@ -15,13 +15,12 @@ 
#include <linux/seq_file.h>

#include <linux/init.h>



static char *

cardstate2str(unsigned short cardstate)

static char *state2str(unsigned short state)

{

	switch (cardstate) {

	case CARD_DETECTED:	return "detected";

	case CARD_LOADING:	return "loading";

	case CARD_RUNNING:	return "running";

	switch (state) {

	case CAPI_CTR_DETECTED:	return "detected";

	case CAPI_CTR_LOADING:	return "loading";

	case CAPI_CTR_RUNNING:	return "running";

	default:	        return "???";

	}

}
@@ -38,7 +37,7 @@ cardstate2str(unsigned short cardstate) 
static void *controller_start(struct seq_file *seq, loff_t *pos)

{

	if (*pos < CAPI_MAXCONTR)

		return &capi_cards[*pos];

		return &capi_controller[*pos];



	return NULL;

}
@@ -47,7 +46,7 @@ static void *controller_next(struct seq_file *seq, void *v, loff_t *pos) 
{

	++*pos;

	if (*pos < CAPI_MAXCONTR)

		return &capi_cards[*pos];

		return &capi_controller[*pos];



	return NULL;

}
@@ -65,7 +64,7 @@ static int controller_show(struct seq_file *seq, void *v) 


	seq_printf(seq, "%d %-10s %-8s %-16s %s\n",

		   ctr->cnr, ctr->driver_name,

		   cardstate2str(ctr->cardstate),

		   state2str(ctr->state),

		   ctr->name,

		   ctr->procinfo ?  ctr->procinfo(ctr) : "");

include/linux/isdn/capilli.h

+1 −1
Original line number Diff line number Diff line
@@ -66,7 +66,7 @@ struct capi_ctr { 
	unsigned long nsentdatapkt;



	int cnr;				/* controller number */

	volatile unsigned short cardstate;	/* controller state */

	volatile unsigned short state;		/* controller state */

	volatile int blocked;			/* output blocked */

	int traceflag;				/* capi trace */