microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

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: Jan Kiszka <jan.kiszka@web.de>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Jan Kiszka 2010-02-08 10:12:10 +00:00 коммит произвёл David S. Miller
Родитель 88549d6b76
Коммит 522530311b
4 изменённых файлов: 176 добавлений и 167 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

316
drivers/isdn/capi/kcapi.c
Просмотреть файл

@ -67,24 +67,24 @@ static DEFINE_RWLOCK(application_lock);
static DEFINE_MUTEX(controller_mutex); static DEFINE_MUTEX(controller_mutex);
struct capi20_appl *capi_applications[CAPI_MAXAPPL]; 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 -------------------------------------- */ /* -------- controller ref counting -------------------------------------- */
static inline struct capi_ctr * 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 NULL;
return card; return ctr;
} }
static inline void 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) if (contr - 1 >= CAPI_MAXCONTR)
return NULL; return NULL;
return capi_cards[contr - 1]; return capi_controller[contr - 1];
} }
static inline struct capi20_appl *get_capi_appl_by_nr(u16 applid) 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) if (ctr)
card->register_appl(card, applid, rparam); ctr->register_appl(ctr, applid, rparam);
else 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); DBG("applid %#x", applid);
card->release_appl(card, applid); ctr->release_appl(ctr, applid);
capi_ctr_put(card); capi_ctr_put(ctr);
} }
/* -------- KCI_CONTRUP --------------------------------------- */ /* -------- KCI_CONTRUP --------------------------------------- */
static void notify_up(u32 contr) 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; struct capi20_appl *ap;
u16 applid; u16 applid;
if (showcapimsgs & 1) { if (showcapimsgs & 1) {
printk(KERN_DEBUG "kcapi: notify up contr %d\n", contr); printk(KERN_DEBUG "kcapi: notify up contr %d\n", contr);
} }
if (!card) { if (!ctr) {
printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr); printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr);
return; return;
} }
for (applid = 1; applid <= CAPI_MAXAPPL; applid++) { for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
ap = get_capi_appl_by_nr(applid); ap = get_capi_appl_by_nr(applid);
if (!ap || ap->release_in_progress) continue; 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) 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 * capi_ctr_handle_message() - handle incoming CAPI message
* @card: controller descriptor structure. * @ctr: controller descriptor structure.
* @appl: application ID. * @appl: application ID.
* @skb: message. * @skb: message.
* *
* Called by hardware driver to pass a CAPI message to the application. * 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; struct capi20_appl *ap;
int showctl = 0; 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; unsigned long flags;
_cdebbuf *cdb; _cdebbuf *cdb;
if (card->cardstate != CARD_RUNNING) { if (ctr->state != CAPI_CTR_RUNNING) {
cdb = capi_message2str(skb->data); cdb = capi_message2str(skb->data);
if (cdb) { if (cdb) {
printk(KERN_INFO "kcapi: controller [%03d] not active, got: %s", printk(KERN_INFO "kcapi: controller [%03d] not active, got: %s",
card->cnr, cdb->buf); ctr->cnr, cdb->buf);
cdebbuf_free(cdb); cdebbuf_free(cdb);
} else } else
printk(KERN_INFO "kcapi: controller [%03d] not active, cannot trace\n", printk(KERN_INFO "kcapi: controller [%03d] not active, cannot trace\n",
card->cnr); ctr->cnr);
goto error; goto error;
} }
cmd = CAPIMSG_COMMAND(skb->data); cmd = CAPIMSG_COMMAND(skb->data);
subcmd = CAPIMSG_SUBCOMMAND(skb->data); subcmd = CAPIMSG_SUBCOMMAND(skb->data);
if (cmd == CAPI_DATA_B3 && subcmd == CAPI_IND) { if (cmd == CAPI_DATA_B3 && subcmd == CAPI_IND) {
card->nrecvdatapkt++; ctr->nrecvdatapkt++;
if (card->traceflag > 2) showctl |= 2; if (ctr->traceflag > 2)
showctl |= 2;
} else { } else {
card->nrecvctlpkt++; ctr->nrecvctlpkt++;
if (card->traceflag) showctl |= 2; if (ctr->traceflag)
showctl |= 2;
} }
showctl |= (card->traceflag & 1); showctl |= (ctr->traceflag & 1);
if (showctl & 2) { if (showctl & 2) {
if (showctl & 1) { if (showctl & 1) {
printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u\n", 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), capi_cmd2str(cmd, subcmd),
CAPIMSG_LEN(skb->data)); CAPIMSG_LEN(skb->data));
} else { } else {
cdb = capi_message2str(skb->data); cdb = capi_message2str(skb->data);
if (cdb) { if (cdb) {
printk(KERN_DEBUG "kcapi: got [%03d] %s\n", printk(KERN_DEBUG "kcapi: got [%03d] %s\n",
card->cnr, cdb->buf); ctr->cnr, cdb->buf);
cdebbuf_free(cdb); cdebbuf_free(cdb);
} else } else
printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u, cannot trace\n", 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), capi_cmd2str(cmd, subcmd),
CAPIMSG_LEN(skb->data)); CAPIMSG_LEN(skb->data));
} }
@ -356,74 +361,75 @@ EXPORT_SYMBOL(capi_ctr_handle_message);
/** /**
* capi_ctr_ready() - signal CAPI controller ready * 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. * 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", printk(KERN_NOTICE "kcapi: controller [%03d] \"%s\" ready.\n",
card->cnr, card->name); 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); EXPORT_SYMBOL(capi_ctr_ready);
/** /**
* capi_ctr_down() - signal CAPI controller not 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 * Called by hardware driver to signal that the controller is down and
* unavailable for use. * unavailable for use.
*/ */
void capi_ctr_down(struct capi_ctr * card) void capi_ctr_down(struct capi_ctr *ctr)
{ {
u16 appl; u16 appl;
DBG(""); DBG("");
if (card->cardstate == CARD_DETECTED) if (ctr->state == CAPI_CTR_DETECTED)
return; return;
card->cardstate = CARD_DETECTED; ctr->state = CAPI_CTR_DETECTED;
memset(card->manu, 0, sizeof(card->manu)); memset(ctr->manu, 0, sizeof(ctr->manu));
memset(&card->version, 0, sizeof(card->version)); memset(&ctr->version, 0, sizeof(ctr->version));
memset(&card->profile, 0, sizeof(card->profile)); memset(&ctr->profile, 0, sizeof(ctr->profile));
memset(card->serial, 0, sizeof(card->serial)); memset(ctr->serial, 0, sizeof(ctr->serial));
for (appl = 1; appl <= CAPI_MAXAPPL; appl++) { for (appl = 1; appl <= CAPI_MAXAPPL; appl++) {
struct capi20_appl *ap = get_capi_appl_by_nr(appl); struct capi20_appl *ap = get_capi_appl_by_nr(appl);
if (!ap || ap->release_in_progress) if (!ap || ap->release_in_progress)
continue; 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); EXPORT_SYMBOL(capi_ctr_down);
/** /**
* capi_ctr_suspend_output() - suspend controller * capi_ctr_suspend_output() - suspend controller
* @card: controller descriptor structure. * @ctr: controller descriptor structure.
* *
* Called by hardware driver to stop data flow. * 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) { if (!ctr->blocked) {
printk(KERN_DEBUG "kcapi: card [%03d] suspend\n", card->cnr); printk(KERN_DEBUG "kcapi: controller [%03d] suspend\n",
card->blocked = 1; ctr->cnr);
ctr->blocked = 1;
} }
} }
@ -431,16 +437,17 @@ EXPORT_SYMBOL(capi_ctr_suspend_output);
/** /**
* capi_ctr_resume_output() - resume controller * capi_ctr_resume_output() - resume controller
* @card: controller descriptor structure. * @ctr: controller descriptor structure.
* *
* Called by hardware driver to resume data flow. * 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) { if (ctr->blocked) {
printk(KERN_DEBUG "kcapi: card [%03d] resume\n", card->cnr); printk(KERN_DEBUG "kcapi: controller [%03d] resumed\n",
card->blocked = 0; ctr->cnr);
ctr->blocked = 0;
} }
} }
@ -450,21 +457,20 @@ EXPORT_SYMBOL(capi_ctr_resume_output);
/** /**
* attach_capi_ctr() - register CAPI controller * 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. * Called by hardware driver to register a controller with the CAPI subsystem.
* Return value: 0 on success, error code < 0 on error * Return value: 0 on success, error code < 0 on error
*/ */
int int attach_capi_ctr(struct capi_ctr *ctr)
attach_capi_ctr(struct capi_ctr *card)
{ {
int i; int i;
mutex_lock(&controller_mutex); mutex_lock(&controller_mutex);
for (i = 0; i < CAPI_MAXCONTR; i++) { for (i = 0; i < CAPI_MAXCONTR; i++) {
if (capi_cards[i] == NULL) if (!capi_controller[i])
break; break;
} }
if (i == CAPI_MAXCONTR) { if (i == CAPI_MAXCONTR) {
@ -472,25 +478,25 @@ attach_capi_ctr(struct capi_ctr *card)
printk(KERN_ERR "kcapi: out of controller slots\n"); printk(KERN_ERR "kcapi: out of controller slots\n");
return -EBUSY; return -EBUSY;
} }
capi_cards[i] = card; capi_controller[i] = ctr;
mutex_unlock(&controller_mutex); mutex_unlock(&controller_mutex);
card->nrecvctlpkt = 0; ctr->nrecvctlpkt = 0;
card->nrecvdatapkt = 0; ctr->nrecvdatapkt = 0;
card->nsentctlpkt = 0; ctr->nsentctlpkt = 0;
card->nsentdatapkt = 0; ctr->nsentdatapkt = 0;
card->cnr = i + 1; ctr->cnr = i + 1;
card->cardstate = CARD_DETECTED; ctr->state = CAPI_CTR_DETECTED;
card->blocked = 0; ctr->blocked = 0;
card->traceflag = showcapimsgs; ctr->traceflag = showcapimsgs;
sprintf(card->procfn, "capi/controllers/%d", card->cnr); sprintf(ctr->procfn, "capi/controllers/%d", ctr->cnr);
card->procent = proc_create_data(card->procfn, 0, NULL, card->proc_fops, card); ctr->procent = proc_create_data(ctr->procfn, 0, NULL, ctr->proc_fops, ctr);
ncards++; ncontrollers++;
printk(KERN_NOTICE "kcapi: Controller [%03d]: %s attached\n", printk(KERN_NOTICE "kcapi: controller [%03d]: %s attached\n",
card->cnr, card->name); ctr->cnr, ctr->name);
return 0; return 0;
} }
@ -498,27 +504,27 @@ EXPORT_SYMBOL(attach_capi_ctr);
/** /**
* detach_capi_ctr() - unregister CAPI controller * 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 * Called by hardware driver to remove the registration of a controller
* with the CAPI subsystem. * with the CAPI subsystem.
* Return value: 0 on success, error code < 0 on error * 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) if (ctr->state != CAPI_CTR_DETECTED)
capi_ctr_down(card); capi_ctr_down(ctr);
ncards--; ncontrollers--;
if (card->procent) { if (ctr->procent) {
remove_proc_entry(card->procfn, NULL); remove_proc_entry(ctr->procfn, NULL);
card->procent = NULL; ctr->procent = NULL;
} }
capi_cards[card->cnr - 1] = NULL; capi_controller[ctr->cnr - 1] = NULL;
printk(KERN_NOTICE "kcapi: Controller [%03d]: %s unregistered\n", printk(KERN_NOTICE "kcapi: controller [%03d]: %s unregistered\n",
card->cnr, card->name); ctr->cnr, ctr->name);
return 0; return 0;
} }
@ -576,7 +582,8 @@ u16 capi20_isinstalled(void)
{ {
int i; int i;
for (i = 0; i < CAPI_MAXCONTR; 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_NOERROR;
} }
return CAPI_REGNOTINSTALLED; return CAPI_REGNOTINSTALLED;
@ -635,9 +642,10 @@ u16 capi20_register(struct capi20_appl *ap)
mutex_lock(&controller_mutex); mutex_lock(&controller_mutex);
for (i = 0; i < CAPI_MAXCONTR; 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)
continue; continue;
register_appl(capi_cards[i], applid, &ap->rparam); register_appl(capi_controller[i], applid, &ap->rparam);
} }
mutex_unlock(&controller_mutex); mutex_unlock(&controller_mutex);
@ -674,9 +682,10 @@ u16 capi20_release(struct capi20_appl *ap)
mutex_lock(&controller_mutex); mutex_lock(&controller_mutex);
for (i = 0; i < CAPI_MAXCONTR; 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)
continue; continue;
release_appl(capi_cards[i], ap->applid); release_appl(capi_controller[i], ap->applid);
} }
mutex_unlock(&controller_mutex); mutex_unlock(&controller_mutex);
@ -703,13 +712,13 @@ EXPORT_SYMBOL(capi20_release);
u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb) u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb)
{ {
struct capi_ctr *card; struct capi_ctr *ctr;
int showctl = 0; int showctl = 0;
u8 cmd, subcmd; u8 cmd, subcmd;
DBG("applid %#x", ap->applid); DBG("applid %#x", ap->applid);
if (ncards == 0) if (ncontrollers == 0)
return CAPI_REGNOTINSTALLED; return CAPI_REGNOTINSTALLED;
if ((ap->applid == 0) || ap->release_in_progress) if ((ap->applid == 0) || ap->release_in_progress)
return CAPI_ILLAPPNR; 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_cmd_valid(CAPIMSG_COMMAND(skb->data))
|| !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data))) || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data)))
return CAPI_ILLCMDORSUBCMDORMSGTOSMALL; return CAPI_ILLCMDORSUBCMDORMSGTOSMALL;
card = get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb->data)); ctr = get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb->data));
if (!card || card->cardstate != CARD_RUNNING) { if (!ctr || ctr->state != CAPI_CTR_RUNNING) {
card = get_capi_ctr_by_nr(1); // XXX why? ctr = get_capi_ctr_by_nr(1); /* XXX why? */
if (!card || card->cardstate != CARD_RUNNING) if (!ctr || ctr->state != CAPI_CTR_RUNNING)
return CAPI_REGNOTINSTALLED; return CAPI_REGNOTINSTALLED;
} }
if (card->blocked) if (ctr->blocked)
return CAPI_SENDQUEUEFULL; return CAPI_SENDQUEUEFULL;
cmd = CAPIMSG_COMMAND(skb->data); cmd = CAPIMSG_COMMAND(skb->data);
subcmd = CAPIMSG_SUBCOMMAND(skb->data); subcmd = CAPIMSG_SUBCOMMAND(skb->data);
if (cmd == CAPI_DATA_B3 && subcmd== CAPI_REQ) { if (cmd == CAPI_DATA_B3 && subcmd== CAPI_REQ) {
card->nsentdatapkt++; ctr->nsentdatapkt++;
ap->nsentdatapkt++; ap->nsentdatapkt++;
if (card->traceflag > 2) showctl |= 2; if (ctr->traceflag > 2)
showctl |= 2;
} else { } else {
card->nsentctlpkt++; ctr->nsentctlpkt++;
ap->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 & 2) {
if (showctl & 1) { if (showctl & 1) {
printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u\n", 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)); CAPIMSG_LEN(skb->data));
} }
} }
return card->send_message(card, skb); return ctr->send_message(ctr, skb);
} }
EXPORT_SYMBOL(capi20_put_message); EXPORT_SYMBOL(capi20_put_message);
@ -778,16 +789,16 @@ EXPORT_SYMBOL(capi20_put_message);
u16 capi20_get_manufacturer(u32 contr, u8 *buf) u16 capi20_get_manufacturer(u32 contr, u8 *buf)
{ {
struct capi_ctr *card; struct capi_ctr *ctr;
if (contr == 0) { if (contr == 0) {
strlcpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN); strlcpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN);
return CAPI_NOERROR; return CAPI_NOERROR;
} }
card = get_capi_ctr_by_nr(contr); ctr = get_capi_ctr_by_nr(contr);
if (!card || card->cardstate != CARD_RUNNING) if (!ctr || ctr->state != CAPI_CTR_RUNNING)
return CAPI_REGNOTINSTALLED; return CAPI_REGNOTINSTALLED;
strlcpy(buf, card->manu, CAPI_MANUFACTURER_LEN); strlcpy(buf, ctr->manu, CAPI_MANUFACTURER_LEN);
return CAPI_NOERROR; return CAPI_NOERROR;
} }
@ -805,17 +816,17 @@ EXPORT_SYMBOL(capi20_get_manufacturer);
u16 capi20_get_version(u32 contr, struct capi_version *verp) u16 capi20_get_version(u32 contr, struct capi_version *verp)
{ {
struct capi_ctr *card; struct capi_ctr *ctr;
if (contr == 0) { if (contr == 0) {
*verp = driver_version; *verp = driver_version;
return CAPI_NOERROR; return CAPI_NOERROR;
} }
card = get_capi_ctr_by_nr(contr); ctr = get_capi_ctr_by_nr(contr);
if (!card || card->cardstate != CARD_RUNNING) if (!ctr || ctr->state != CAPI_CTR_RUNNING)
return CAPI_REGNOTINSTALLED; return CAPI_REGNOTINSTALLED;
memcpy((void *) verp, &card->version, sizeof(capi_version)); memcpy(verp, &ctr->version, sizeof(capi_version));
return CAPI_NOERROR; return CAPI_NOERROR;
} }
@ -833,17 +844,17 @@ EXPORT_SYMBOL(capi20_get_version);
u16 capi20_get_serial(u32 contr, u8 *serial) u16 capi20_get_serial(u32 contr, u8 *serial)
{ {
struct capi_ctr *card; struct capi_ctr *ctr;
if (contr == 0) { if (contr == 0) {
strlcpy(serial, driver_serial, CAPI_SERIAL_LEN); strlcpy(serial, driver_serial, CAPI_SERIAL_LEN);
return CAPI_NOERROR; return CAPI_NOERROR;
} }
card = get_capi_ctr_by_nr(contr); ctr = get_capi_ctr_by_nr(contr);
if (!card || card->cardstate != CARD_RUNNING) if (!ctr || ctr->state != CAPI_CTR_RUNNING)
return CAPI_REGNOTINSTALLED; return CAPI_REGNOTINSTALLED;
strlcpy((void *) serial, card->serial, CAPI_SERIAL_LEN); strlcpy(serial, ctr->serial, CAPI_SERIAL_LEN);
return CAPI_NOERROR; return CAPI_NOERROR;
} }
@ -861,18 +872,17 @@ EXPORT_SYMBOL(capi20_get_serial);
u16 capi20_get_profile(u32 contr, struct capi_profile *profp) u16 capi20_get_profile(u32 contr, struct capi_profile *profp)
{ {
struct capi_ctr *card; struct capi_ctr *ctr;
if (contr == 0) { if (contr == 0) {
profp->ncontroller = ncards; profp->ncontroller = ncontrollers;
return CAPI_NOERROR; return CAPI_NOERROR;
} }
card = get_capi_ctr_by_nr(contr); ctr = get_capi_ctr_by_nr(contr);
if (!card || card->cardstate != CARD_RUNNING) if (!ctr || ctr->state != CAPI_CTR_RUNNING)
return CAPI_REGNOTINSTALLED; return CAPI_REGNOTINSTALLED;
memcpy((void *) profp, &card->profile, memcpy(profp, &ctr->profile, sizeof(struct capi_profile));
sizeof(struct capi_profile));
return CAPI_NOERROR; return CAPI_NOERROR;
} }
@ -885,7 +895,7 @@ static int old_capi_manufacturer(unsigned int cmd, void __user *data)
avmb1_extcarddef cdef; avmb1_extcarddef cdef;
avmb1_resetdef rdef; avmb1_resetdef rdef;
capicardparams cparams; capicardparams cparams;
struct capi_ctr *card; struct capi_ctr *ctr;
struct capi_driver *driver = NULL; struct capi_driver *driver = NULL;
capiloaddata ldata; capiloaddata ldata;
struct list_head *l; struct list_head *l;
@ -958,26 +968,26 @@ static int old_capi_manufacturer(unsigned int cmd, void __user *data)
sizeof(avmb1_loadandconfigdef))) sizeof(avmb1_loadandconfigdef)))
return -EFAULT; return -EFAULT;
} }
card = get_capi_ctr_by_nr(ldef.contr); ctr = get_capi_ctr_by_nr(ldef.contr);
if (!card) if (!ctr)
return -EINVAL; return -EINVAL;
card = capi_ctr_get(card); ctr = capi_ctr_get(ctr);
if (!card) if (!ctr)
return -ESRCH; return -ESRCH;
if (card->load_firmware == NULL) { if (ctr->load_firmware == NULL) {
printk(KERN_DEBUG "kcapi: load: no load function\n"); printk(KERN_DEBUG "kcapi: load: no load function\n");
capi_ctr_put(card); capi_ctr_put(ctr);
return -ESRCH; return -ESRCH;
} }
if (ldef.t4file.len <= 0) { if (ldef.t4file.len <= 0) {
printk(KERN_DEBUG "kcapi: load: invalid parameter: length of t4file is %d ?\n", ldef.t4file.len); 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; return -EINVAL;
} }
if (ldef.t4file.data == NULL) { if (ldef.t4file.data == NULL) {
printk(KERN_DEBUG "kcapi: load: invalid parameter: dataptr is 0\n"); printk(KERN_DEBUG "kcapi: load: invalid parameter: dataptr is 0\n");
capi_ctr_put(card); capi_ctr_put(ctr);
return -EINVAL; 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.data = ldef.t4config.data;
ldata.configuration.len = ldef.t4config.len; 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); printk(KERN_INFO "kcapi: load: contr=%d not in detect state\n", ldef.contr);
capi_ctr_put(card); capi_ctr_put(ctr);
return -EBUSY; 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) { if (retval) {
card->cardstate = CARD_DETECTED; ctr->state = CAPI_CTR_DETECTED;
capi_ctr_put(card); capi_ctr_put(ctr);
return retval; return retval;
} }
while (card->cardstate != CARD_RUNNING) { while (ctr->state != CAPI_CTR_RUNNING) {
msleep_interruptible(100); /* 0.1 sec */ msleep_interruptible(100); /* 0.1 sec */
if (signal_pending(current)) { if (signal_pending(current)) {
capi_ctr_put(card); capi_ctr_put(ctr);
return -EINTR; return -EINTR;
} }
} }
capi_ctr_put(card); capi_ctr_put(ctr);
return 0; return 0;
case AVMB1_RESETCARD: case AVMB1_RESETCARD:
if (copy_from_user(&rdef, data, sizeof(avmb1_resetdef))) if (copy_from_user(&rdef, data, sizeof(avmb1_resetdef)))
return -EFAULT; return -EFAULT;
card = get_capi_ctr_by_nr(rdef.contr); ctr = get_capi_ctr_by_nr(rdef.contr);
if (!card) if (!ctr)
return -ESRCH; return -ESRCH;
if (card->cardstate == CARD_DETECTED) if (ctr->state == CAPI_CTR_DETECTED)
return 0; 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 */ 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) int capi20_manufacturer(unsigned int cmd, void __user *data)
{ {
struct capi_ctr *card; struct capi_ctr *ctr;
switch (cmd) { switch (cmd) {
#ifdef AVMB1_COMPAT #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))) if (copy_from_user(&fdef, data, sizeof(kcapi_flagdef)))
return -EFAULT; return -EFAULT;
card = get_capi_ctr_by_nr(fdef.contr); ctr = get_capi_ctr_by_nr(fdef.contr);
if (!card) if (!ctr)
return -ESRCH; return -ESRCH;
card->traceflag = fdef.flag; ctr->traceflag = fdef.flag;
printk(KERN_INFO "kcapi: contr [%03d] set trace=%d\n", printk(KERN_INFO "kcapi: contr [%03d] set trace=%d\n",
card->cnr, card->traceflag); ctr->cnr, ctr->traceflag);
return 0; return 0;
} }
case KCAPI_CMD_ADDCARD: case KCAPI_CMD_ADDCARD:

8
drivers/isdn/capi/kcapi.h
Просмотреть файл

@ -24,16 +24,16 @@ printk(KERN_DEBUG "%s: " format "\n" , __func__ , ## arg); \
#endif #endif
enum { enum {
CARD_DETECTED = 1, CAPI_CTR_DETECTED = 1,
CARD_LOADING = 2, CAPI_CTR_LOADING = 2,
CARD_RUNNING = 3, CAPI_CTR_RUNNING = 3,
}; };
extern struct list_head capi_drivers; extern struct list_head capi_drivers;
extern rwlock_t capi_drivers_list_lock; extern rwlock_t capi_drivers_list_lock;
extern struct capi20_appl *capi_applications[CAPI_MAXAPPL]; 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 #ifdef CONFIG_PROC_FS

17
drivers/isdn/capi/kcapi_proc.c
Просмотреть файл

@ -15,13 +15,12 @@
#include <linux/seq_file.h> #include <linux/seq_file.h>
#include <linux/init.h> #include <linux/init.h>
static char * static char *state2str(unsigned short state)
cardstate2str(unsigned short cardstate)
{ {
switch (cardstate) { switch (state) {
case CARD_DETECTED: return "detected"; case CAPI_CTR_DETECTED: return "detected";
case CARD_LOADING: return "loading"; case CAPI_CTR_LOADING: return "loading";
case CARD_RUNNING: return "running"; case CAPI_CTR_RUNNING: return "running";
default: return "???"; default: return "???";
} }
} }
@ -38,7 +37,7 @@ cardstate2str(unsigned short cardstate)
static void *controller_start(struct seq_file *seq, loff_t *pos) static void *controller_start(struct seq_file *seq, loff_t *pos)
{ {
if (*pos < CAPI_MAXCONTR) if (*pos < CAPI_MAXCONTR)
return &capi_cards[*pos]; return &capi_controller[*pos];
return NULL; return NULL;
} }
@ -47,7 +46,7 @@ static void *controller_next(struct seq_file *seq, void *v, loff_t *pos)
{ {
++*pos; ++*pos;
if (*pos < CAPI_MAXCONTR) if (*pos < CAPI_MAXCONTR)
return &capi_cards[*pos]; return &capi_controller[*pos];
return NULL; 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", seq_printf(seq, "%d %-10s %-8s %-16s %s\n",
ctr->cnr, ctr->driver_name, ctr->cnr, ctr->driver_name,
cardstate2str(ctr->cardstate), state2str(ctr->state),
ctr->name, ctr->name,
ctr->procinfo ? ctr->procinfo(ctr) : ""); ctr->procinfo ? ctr->procinfo(ctr) : "");

2
include/linux/isdn/capilli.h
Просмотреть файл

@ -66,7 +66,7 @@ struct capi_ctr {
unsigned long nsentdatapkt; unsigned long nsentdatapkt;
int cnr; /* controller number */ int cnr; /* controller number */
volatile unsigned short cardstate; /* controller state */ volatile unsigned short state; /* controller state */
volatile int blocked; /* output blocked */ volatile int blocked; /* output blocked */
int traceflag; /* capi trace */ int traceflag; /* capi trace */