static void notify_handler(void *dummy)
{
__u16 contr;
for (contr=1; VALID_CARD(contr); contr++)
if (test_and_clear_bit(contr, ¬ify_up_set))
notify_up(contr);
for (contr=1; VALID_CARD(contr); contr++)
if (test_and_clear_bit(contr, ¬ify_down_set))
notify_down(contr);
}
static __u16 capi_put_message(__u16 applid, struct sk_buff *skb)
{
avmb1_ncci *np;
int contr;
if (ncards == 0)
return CAPI_REGNOTINSTALLED;
if (!VALID_APPLID(applid))
return CAPI_ILLAPPNR;
if (skb->len < 12
|| !capi_cmd_valid(CAPIMSG_COMMAND(skb->data))
|| !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data)))
return CAPI_ILLCMDORSUBCMDORMSGTOSMALL;
contr = CAPIMSG_CONTROLLER(skb->data);
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING) {
contr = 1;
if (CARD(contr)->cardstate != CARD_RUNNING)
return CAPI_REGNOTINSTALLED;
}
if (CARD(contr)->blocked)
return CAPI_SENDQUEUEFULL;
if ( CAPIMSG_COMMAND(skb->data) == CAPI_DATA_B3
&& CAPIMSG_SUBCOMMAND(skb->data) == CAPI_REQ
&& (np = find_ncci(APPL(applid), CAPIMSG_NCCI(skb->data))) != 0
&& mq_enqueue(np, CAPIMSG_MSGID(skb->data)) == 0)
return CAPI_SENDQUEUEFULL;
B1_send_message(CARD(contr)->port, skb);
return CAPI_NOERROR;
}
static __u16 capi_put_message(__u16 applid, struct sk_buff *skb)
{
struct capi_ncci *np;
__u32 contr;
int showctl = 0;
__u8 cmd, subcmd;
if (ncards == 0)
return CAPI_REGNOTINSTALLED;
if (!VALID_APPLID(applid))
return CAPI_ILLAPPNR;
if (skb->len < 12
|| !capi_cmd_valid(CAPIMSG_COMMAND(skb->data))
|| !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data)))
return CAPI_ILLCMDORSUBCMDORMSGTOSMALL;
contr = CAPIMSG_CONTROLLER(skb->data);
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING) {
contr = 1;
if (CARD(contr)->cardstate != CARD_RUNNING)
return CAPI_REGNOTINSTALLED;
}
if (CARD(contr)->blocked)
return CAPI_SENDQUEUEFULL;
cmd = CAPIMSG_COMMAND(skb->data);
subcmd = CAPIMSG_SUBCOMMAND(skb->data);
if (cmd == CAPI_DATA_B3 && subcmd== CAPI_REQ) {
if ((np = find_ncci(APPL(applid), CAPIMSG_NCCI(skb->data))) != 0
&& mq_enqueue(np, CAPIMSG_MSGID(skb->data)) == 0)
return CAPI_SENDQUEUEFULL;
CARD(contr)->nsentdatapkt++;
APPL(applid)->nsentdatapkt++;
if (CARD(contr)->traceflag > 2) showctl |= 2;
} else {
CARD(contr)->nsentctlpkt++;
APPL(applid)->nsentctlpkt++;
if (CARD(contr)->traceflag) showctl |= 2;
}
showctl |= (CARD(contr)->traceflag & 1);
if (showctl & 2) {
if (showctl & 1) {
printk(KERN_DEBUG "kcapi: put [0x%lx] id#%d %s len=%u\n",
(unsigned long) contr,
CAPIMSG_APPID(skb->data),
capi_cmd2str(cmd, subcmd),
CAPIMSG_LEN(skb->data));
} else {
printk(KERN_DEBUG "kcapi: put [0x%lx] %s\n",
(unsigned long) contr,
capi_message2str(skb->data));
}
}
CARD(contr)->driver->send_message(CARD(contr), skb);
return CAPI_NOERROR;
}
static __u16 capi_get_serial(__u32 contr, __u8 serial[CAPI_SERIAL_LEN])
{
if (contr == 0) {
strncpy(serial, driver_serial, CAPI_SERIAL_LEN);
return CAPI_NOERROR;
}
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING)
return CAPI_REGNOTINSTALLED;
strncpy((void *) serial, CARD(contr)->serial, CAPI_SERIAL_LEN);
return CAPI_NOERROR;
}
static __u16 capi_get_version(__u32 contr, struct capi_version *verp)
{
if (contr == 0) {
*verp = driver_version;
return CAPI_NOERROR;
}
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING)
return CAPI_REGNOTINSTALLED;
memcpy((void *) verp, &CARD(contr)->version, sizeof(capi_version));
return CAPI_NOERROR;
}
static __u16 capi_get_manufacturer(__u32 contr, __u8 buf[CAPI_MANUFACTURER_LEN])
{
if (contr == 0) {
strncpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN);
return CAPI_NOERROR;
}
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING)
return CAPI_REGNOTINSTALLED;
strncpy(buf, CARD(contr)->manu, CAPI_MANUFACTURER_LEN);
return CAPI_NOERROR;
}
static __u16 capi_get_profile(__u32 contr, struct capi_profile *profp)
{
if (contr == 0) {
profp->ncontroller = ncards;
return CAPI_NOERROR;
}
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING)
return CAPI_REGNOTINSTALLED;
memcpy((void *) profp, &CARD(contr)->profile,
sizeof(struct capi_profile));
return CAPI_NOERROR;
}
static __u16 capi_get_profile(__u16 contr, struct capi_profile *profp)
{
if (contr == 0) {
profp->ncontroller = ncards;
return CAPI_NOERROR;
}
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING)
return 0x2002;
memcpy((void *) profp, CARD(contr)->version[VER_PROFILE],
sizeof(struct capi_profile));
return CAPI_NOERROR;
}
static __u16 capi_get_version(__u16 contr, struct capi_version *verp)
{
if (contr == 0) {
*verp = driver_version;
return CAPI_NOERROR;
}
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING)
return 0x2002;
memcpy((void *) verp, CARD(contr)->version[VER_SERIAL],
sizeof(capi_version));
return CAPI_NOERROR;
}
static __u16 capi_get_serial(__u16 contr, __u8 serial[CAPI_SERIAL_LEN])
{
if (contr == 0) {
strncpy(serial, driver_serial, 8);
return CAPI_NOERROR;
}
if (!VALID_CARD(contr) || CARD(contr)->cardstate != CARD_RUNNING)
return 0x2002;
memcpy((void *) serial, CARD(contr)->version[VER_SERIAL],
CAPI_SERIAL_LEN);
serial[CAPI_SERIAL_LEN - 1] = 0;
return CAPI_NOERROR;
}
int avmb1_unregistercard(int cnr, int freeio)
{
avmb1_card * card;
if (!VALID_CARD(cnr))
return -ESRCH;
card = CARD(cnr);
if (card->cardstate == CARD_FREE)
return -ESRCH;
if (card->cardstate == CARD_RUNNING)
avmb1_card_down(card, freeio);
free_irq(card->irq, card);
if (freeio)
release_region(card->port, AVMB1_PORTLEN);
card->cardstate = CARD_FREE;
return 0;
}
int avmb1_resetcard(int cnr)
{
avmb1_card * card;
if (!VALID_CARD(cnr))
return -ESRCH;
card = CARD(cnr);
if (card->cardstate == CARD_FREE)
return -ESRCH;
if (card->cardstate == CARD_RUNNING)
avmb1_card_down(card, 0);
B1_reset(card->port);
B1_reset(card->port);
card->cardstate = CARD_DETECTED;
return 0;
}
static int old_capi_manufacturer(unsigned int cmd, void *data)
{
avmb1_loadandconfigdef ldef;
avmb1_extcarddef cdef;
avmb1_resetdef rdef;
avmb1_getdef gdef;
struct capi_driver *driver;
struct capi_ctr *card;
capicardparams cparams;
capiloaddata ldata;
int retval;
switch (cmd) {
case AVMB1_ADDCARD:
case AVMB1_ADDCARD_WITH_TYPE:
if (cmd == AVMB1_ADDCARD) {
if ((retval = copy_from_user((void *) &cdef, data,
sizeof(avmb1_carddef))))
return retval;
cdef.cardtype = AVM_CARDTYPE_B1;
} else {
if ((retval = copy_from_user((void *) &cdef, data,
sizeof(avmb1_extcarddef))))
return retval;
}
cparams.port = cdef.port;
cparams.irq = cdef.irq;
cparams.cardnr = cdef.cardnr;
switch (cdef.cardtype) {
case AVM_CARDTYPE_B1:
driver = find_driver("b1isa");
break;
case AVM_CARDTYPE_T1:
driver = find_driver("t1isa");
break;
default:
driver = 0;
break;
}
if (!driver) {
printk(KERN_ERR "kcapi: driver not loaded.\n");
return -EIO;
}
if (!driver->add_card) {
printk(KERN_ERR "kcapi: driver has no add card function.\n");
return -EIO;
}
return driver->add_card(driver, &cparams);
case AVMB1_LOAD:
case AVMB1_LOAD_AND_CONFIG:
if (cmd == AVMB1_LOAD) {
if ((retval = copy_from_user((void *) &ldef, data,
sizeof(avmb1_loaddef))))
return retval;
ldef.t4config.len = 0;
ldef.t4config.data = 0;
} else {
if ((retval = copy_from_user((void *) &ldef, data,
sizeof(avmb1_loadandconfigdef))))
return retval;
}
if (!VALID_CARD(ldef.contr))
return -ESRCH;
card = CARD(ldef.contr);
if (card->cardstate == CARD_FREE)
return -ESRCH;
if (card->driver->load_firmware == 0) {
printk(KERN_DEBUG "kcapi: load: driver \%s\" has no load function\n", card->driver->name);
return -ESRCH;
}
if (ldef.t4file.len <= 0) {
printk(KERN_DEBUG "kcapi: load: invalid parameter: length of t4file is %d ?\n", ldef.t4file.len);
return -EINVAL;
}
if (ldef.t4file.data == 0) {
printk(KERN_DEBUG "kcapi: load: invalid parameter: dataptr is 0\n");
return -EINVAL;
}
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;
if (card->cardstate != CARD_DETECTED) {
printk(KERN_INFO "kcapi: load: contr=%d not in detect state\n", ldef.contr);
return -EBUSY;
}
card->cardstate = CARD_LOADING;
retval = card->driver->load_firmware(card, &ldata);
if (retval) {
card->cardstate = CARD_DETECTED;
return retval;
}
while (card->cardstate != CARD_RUNNING) {
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(HZ/10); /* 0.1 sec */
if (signal_pending(current))
return -EINTR;
}
return 0;
case AVMB1_RESETCARD:
if ((retval = copy_from_user((void *) &rdef, data,
sizeof(avmb1_resetdef))))
return retval;
if (!VALID_CARD(rdef.contr))
return -ESRCH;
card = CARD(rdef.contr);
if (card->cardstate == CARD_FREE)
return -ESRCH;
if (card->cardstate == CARD_DETECTED)
return 0;
card->driver->reset_ctr(card);
while (card->cardstate > CARD_DETECTED) {
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(HZ/10); /* 0.1 sec */
if (signal_pending(current))
return -EINTR;
}
return 0;
case AVMB1_GET_CARDINFO:
if ((retval = copy_from_user((void *) &gdef, data,
sizeof(avmb1_getdef))))
return retval;
if (!VALID_CARD(gdef.contr))
return -ESRCH;
card = CARD(gdef.contr);
if (card->cardstate == CARD_FREE)
return -ESRCH;
gdef.cardstate = card->cardstate;
if (card->driver == find_driver("t1isa"))
gdef.cardtype = AVM_CARDTYPE_T1;
else gdef.cardtype = AVM_CARDTYPE_B1;
if ((retval = copy_to_user(data, (void *) &gdef,
sizeof(avmb1_getdef))))
return retval;
return 0;
case AVMB1_REMOVECARD:
if ((retval = copy_from_user((void *) &rdef, data,
sizeof(avmb1_resetdef))))
return retval;
if (!VALID_CARD(rdef.contr))
return -ESRCH;
card = CARD(rdef.contr);
if (card->cardstate == CARD_FREE)
return -ESRCH;
if (card->cardstate != CARD_DETECTED)
return -EBUSY;
card->driver->remove_ctr(card);
while (card->cardstate != CARD_FREE) {
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(HZ/10); /* 0.1 sec */
if (signal_pending(current))
return -EINTR;
}
return 0;
}
static int capi_manufacturer(unsigned int cmd, void *data)
{
unsigned long flags;
avmb1_loadandconfigdef ldef;
avmb1_extcarddef cdef;
avmb1_resetdef rdef;
avmb1_getdef gdef;
avmb1_card *card;
int rc;
switch (cmd) {
case AVMB1_ADDCARD:
case AVMB1_ADDCARD_WITH_TYPE:
if (cmd == AVMB1_ADDCARD) {
if ((rc = copy_from_user((void *) &cdef, data,
sizeof(avmb1_carddef))))
return rc;
cdef.cardtype = AVM_CARDTYPE_B1;
} else {
if ((rc = copy_from_user((void *) &cdef, data,
sizeof(avmb1_extcarddef))))
return rc;
}
if ((rc = avmb1_probecard(cdef.port, cdef.irq, cdef.cardtype)) != 0)
return rc;
return avmb1_addcard(cdef.port, cdef.irq, cdef.cardtype);
case AVMB1_LOAD:
case AVMB1_LOAD_AND_CONFIG:
if (cmd == AVMB1_LOAD) {
if ((rc = copy_from_user((void *) &ldef, data,
sizeof(avmb1_loaddef))))
return rc;
ldef.t4config.len = 0;
ldef.t4config.data = 0;
} else {
if ((rc = copy_from_user((void *) &ldef, data,
sizeof(avmb1_loadandconfigdef))))
return rc;
}
if (!VALID_CARD(ldef.contr))
return -ESRCH;
if (ldef.t4file.len <= 0) {
if (loaddebug)
printk(KERN_DEBUG "b1capi: load: invalid parameter length of t4file is %d ?\n", ldef.t4file.len);
return -EINVAL;
}
card = CARD(ldef.contr);
save_flags(flags);
cli();
if (card->cardstate != CARD_DETECTED) {
restore_flags(flags);
if (loaddebug)
printk(KERN_DEBUG "b1capi: load: contr=%d not in detect state\n", ldef.contr);
return -EBUSY;
}
card->cardstate = CARD_LOADING;
restore_flags(flags);
if (loaddebug) {
printk(KERN_DEBUG "b1capi: load: reseting contr %d\n",
ldef.contr);
}
B1_reset(card->port);
if ((rc = B1_load_t4file(card->port, &ldef.t4file))) {
B1_reset(card->port);
printk(KERN_ERR "b1capi: failed to load t4file!!\n");
card->cardstate = CARD_DETECTED;
return rc;
}
B1_disable_irq(card->port);
if (ldef.t4config.len > 0) { /* load config */
if (loaddebug) {
printk(KERN_DEBUG "b1capi: loading config to contr %d\n",
ldef.contr);
}
if ((rc = B1_load_config(card->port, &ldef.t4config))) {
B1_reset(card->port);
printk(KERN_ERR "b1capi: failed to load config!!\n");
card->cardstate = CARD_DETECTED;
return rc;
}
}
if (loaddebug) {
printk(KERN_DEBUG "b1capi: load: ready contr %d: checking\n",
ldef.contr);
}
if (!B1_loaded(card->port)) {
card->cardstate = CARD_DETECTED;
printk(KERN_ERR "b1capi: failed to load t4file.\n");
return -EIO;
}
/*
* enable interrupt
*/
card->cardstate = CARD_INITSTATE;
save_flags(flags);
cli();
B1_assign_irq(card->port, card->irq, card->cardtype);
B1_enable_irq(card->port);
restore_flags(flags);
if (loaddebug) {
printk(KERN_DEBUG "b1capi: load: irq enabled contr %d\n",
ldef.contr);
}
/*
* init card
*/
B1_send_init(card->port, AVM_NAPPS, AVM_NNCCI, card->cnr - 1);
if (loaddebug) {
printk(KERN_DEBUG "b1capi: load: waiting for init reply contr %d\n",
ldef.contr);
}
while (card->cardstate != CARD_RUNNING) {
current->state = TASK_INTERRUPTIBLE;
schedule_timeout(HZ/10); /* 0.1 sec */
if (signal_pending(current))
return -EINTR;
}
return 0;
case AVMB1_RESETCARD:
if ((rc = copy_from_user((void *) &rdef, data,
sizeof(avmb1_resetdef))))
return rc;
return avmb1_resetcard(rdef.contr);
case AVMB1_GET_CARDINFO:
if ((rc = copy_from_user((void *) &gdef, data,
sizeof(avmb1_getdef))))
return rc;
if (!VALID_CARD(gdef.contr))
return -ESRCH;
card = CARD(gdef.contr);
gdef.cardstate = card->cardstate;
gdef.cardtype = card->cardtype;
if ((rc = copy_to_user(data, (void *) &gdef,
sizeof(avmb1_getdef))))
return rc;
return 0;
}
return -EINVAL;
}
static int capi_manufacturer(unsigned int cmd, void *data)
{
unsigned long flags;
avmb1_loaddef ldef;
avmb1_carddef cdef;
avmb1_resetdef rdef;
avmb1_card *card;
int rc;
switch (cmd) {
case AVMB1_ADDCARD:
if ((rc = copy_from_user((void *) &cdef, data,
sizeof(avmb1_carddef))))
return rc;
if (!B1_valid_irq(cdef.irq))
return -EINVAL;
if ((rc = avmb1_probecard(cdef.port, cdef.irq)) != 0)
return rc;
return avmb1_addcard(cdef.port, cdef.irq);
case AVMB1_LOAD:
if ((rc = copy_from_user((void *) &ldef, data,
sizeof(avmb1_loaddef))))
return rc;
if (!VALID_CARD(ldef.contr) || ldef.t4file.len <= 0) {
if (loaddebug)
printk(KERN_DEBUG "b1capi: load: invalid parameter contr=%d len=%d\n", ldef.contr, ldef.t4file.len);
return -EINVAL;
}
card = CARD(ldef.contr);
save_flags(flags);
cli();
if (card->cardstate != CARD_DETECTED) {
restore_flags(flags);
if (loaddebug)
printk(KERN_DEBUG "b1capi: load: contr=%d not in detect state\n", ldef.contr);
return -EBUSY;
}
card->cardstate = CARD_LOADING;
restore_flags(flags);
if (loaddebug) {
printk(KERN_DEBUG "b1capi: load: reseting contr %d\n",
ldef.contr);
}
B1_reset(card->port);
if ((rc = B1_load_t4file(card->port, &ldef.t4file))) {
B1_reset(card->port);
printk(KERN_ERR "b1capi: failed to load t4file!!\n");
card->cardstate = CARD_DETECTED;
return rc;
}
B1_disable_irq(card->port);
if (loaddebug) {
printk(KERN_DEBUG "b1capi: load: ready contr %d: checking\n",
ldef.contr);
}
if (!B1_loaded(card->port)) {
card->cardstate = CARD_DETECTED;
printk(KERN_ERR "b1capi: failed to load t4file.\n");
return -EIO;
}
/*
* enable interrupt
*/
card->cardstate = CARD_INITSTATE;
save_flags(flags);
cli();
B1_assign_irq(card->port, card->irq);
B1_enable_irq(card->port);
restore_flags(flags);
if (loaddebug) {
printk(KERN_DEBUG "b1capi: load: irq enabled contr %d\n",
ldef.contr);
}
/*
* init card
*/
B1_send_init(card->port, AVM_NAPPS, AVM_NNCCI, card->cnr - 1);
if (loaddebug) {
printk(KERN_DEBUG "b1capi: load: waiting for init reply contr %d\n",
ldef.contr);
}
while (card->cardstate != CARD_RUNNING) {
current->timeout = jiffies + HZ / 10; /* 0.1 sec */
current->state = TASK_INTERRUPTIBLE;
schedule();
if (current->signal & ~current->blocked)
return -EINTR;
}
return 0;
case AVMB1_RESETCARD:
if ((rc = copy_from_user((void *) &rdef, data,
sizeof(avmb1_resetdef))))
return rc;
if (!VALID_CARD(rdef.contr))
return -EINVAL;
card = CARD(rdef.contr);
if (card->cardstate == CARD_RUNNING)
avmb1_card_down(card);
card->cardstate = CARD_DETECTED;
B1_reset(card->port);
B1_reset(card->port);
return 0;
}
return -EINVAL;
}
