void avmb1_card_ready(avmb1_card * card)
{
__u16 appl;
card->cversion.majorversion = 2;
card->cversion.minorversion = 0;
card->cversion.majormanuversion = (card->version[VER_DRIVER][0] - '0') << 4;
card->cversion.majormanuversion |= (card->version[VER_DRIVER][2] - '0');
card->cversion.minormanuversion = (card->version[VER_DRIVER][3] - '0') << 4;
card->cversion.minormanuversion |= (card->version[VER_DRIVER][5] - '0') * 10;
card->cversion.minormanuversion |= (card->version[VER_DRIVER][6] - '0');
card->cardstate = CARD_RUNNING;
for (appl = 1; appl <= CAPI_MAXAPPL; appl++) {
if (VALID_APPLID(appl) && !APPL(appl)->releasing) {
B1_send_register(card->port, appl,
1024 * (APPL(appl)->rparam.level3cnt+1),
APPL(appl)->rparam.level3cnt,
APPL(appl)->rparam.datablkcnt,
APPL(appl)->rparam.datablklen);
}
}
set_bit(CARDNR(card), ¬ify_up_set);
queue_task(&tq_state_notify, &tq_scheduler);
printk(KERN_NOTICE "b1capi: card %d ready.\n", CARDNR(card));
}
static void controllercb_ready(struct capi_ctr * card)
{
card->cardstate = CARD_RUNNING;
printk(KERN_NOTICE "kcapi: card %d \"%s\" ready.\n",
CARDNR(card), card->name);
notify_push(KCI_CONTRUP, CARDNR(card), 0, 0);
}
static void controllercb_resume_output(struct capi_ctr *card)
{
if (card->blocked) {
printk(KERN_DEBUG "kcapi: card %d resume\n", CARDNR(card));
card->blocked = 0;
}
}
static void controllercb_suspend_output(struct capi_ctr *card)
{
if (!card->blocked) {
printk(KERN_DEBUG "kcapi: card %d suspend\n", CARDNR(card));
card->blocked = 1;
}
}
static void controllercb_new_ncci(struct capi_ctr * card,
__u16 appl, __u32 ncci, __u32 winsize)
{
struct capi_ncci *np;
if (!VALID_APPLID(appl)) {
printk(KERN_ERR "avmb1_handle_new_ncci: illegal appl %d\n", appl);
return;
}
if ((np = (struct capi_ncci *) kmalloc(sizeof(struct capi_ncci), GFP_ATOMIC)) == 0) {
printk(KERN_ERR "capi_new_ncci: alloc failed ncci 0x%x\n", ncci);
return;
}
if (winsize > CAPI_MAXDATAWINDOW) {
printk(KERN_ERR "capi_new_ncci: winsize %d too big, set to %d\n",
winsize, CAPI_MAXDATAWINDOW);
winsize = CAPI_MAXDATAWINDOW;
}
np->applid = appl;
np->ncci = ncci;
np->winsize = winsize;
mq_init(np);
np->next = APPL(appl)->nccilist;
APPL(appl)->nccilist = np;
APPL(appl)->nncci++;
printk(KERN_INFO "kcapi: appl %d ncci 0x%x up\n", appl, ncci);
notify_push(KCI_NCCIUP, CARDNR(card), appl, ncci);
}
static void controllercb_ready(struct capi_ctr * card)
{
__u16 appl;
card->cardstate = CARD_RUNNING;
for (appl = 1; appl <= CAPI_MAXAPPL; appl++) {
if (!VALID_APPLID(appl)) continue;
if (APPL(appl)->releasing) continue;
card->driver->register_appl(card, appl, &APPL(appl)->rparam);
}
printk(KERN_NOTICE "kcapi: card %d \"%s\" ready.\n",
CARDNR(card), card->name);
notify_push(KCI_CONTRUP, CARDNR(card), 0, 0);
}
struct capi_ctr *
drivercb_attach_ctr(struct capi_driver *driver, char *name, void *driverdata)
{
struct capi_ctr *card, **pp;
int i;
for (i=0; i < CAPI_MAXCONTR && cards[i].cardstate != CARD_FREE; i++) ;
if (i == CAPI_MAXCONTR) {
printk(KERN_ERR "kcapi: out of controller slots\n");
return 0;
}
card = &cards[i];
memset(card, 0, sizeof(struct capi_ctr));
card->driver = driver;
card->cnr = CARDNR(card);
strncpy(card->name, name, sizeof(card->name));
card->cardstate = CARD_DETECTED;
card->blocked = 0;
card->driverdata = driverdata;
card->traceflag = showcapimsgs;
card->ready = controllercb_ready;
card->reseted = controllercb_reseted;
card->suspend_output = controllercb_suspend_output;
card->resume_output = controllercb_resume_output;
card->handle_capimsg = controllercb_handle_capimsg;
card->appl_registered = controllercb_appl_registered;
card->appl_released = controllercb_appl_released;
card->new_ncci = controllercb_new_ncci;
card->free_ncci = controllercb_free_ncci;
for (pp = &driver->controller; *pp; pp = &(*pp)->next) ;
card->next = 0;
*pp = card;
driver->ncontroller++;
sprintf(card->procfn, "capi/controllers/%d", card->cnr);
card->procent = create_proc_entry(card->procfn, 0, 0);
if (card->procent) {
card->procent->read_proc =
(int (*)(char *,char **,off_t,int,int *,void *))
driver->ctr_read_proc;
card->procent->data = card;
}
ncards++;
printk(KERN_NOTICE "kcapi: Controller %d: %s attached\n",
card->cnr, card->name);
return card;
}
static void controllercb_reseted(struct capi_ctr * card)
{
__u16 appl;
if (card->cardstate == CARD_FREE)
return;
if (card->cardstate == CARD_DETECTED)
return;
card->cardstate = CARD_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));
for (appl = 1; appl <= CAPI_MAXAPPL; appl++) {
struct capi_ncci **pp, **nextpp;
for (pp = &APPL(appl)->nccilist; *pp; pp = nextpp) {
if (NCCI2CTRL((*pp)->ncci) == card->cnr) {
struct capi_ncci *np = *pp;
*pp = np->next;
printk(KERN_INFO "kcapi: appl %d ncci 0x%x forced down!\n", appl, np->ncci);
notify_push(KCI_NCCIDOWN, CARDNR(card), appl, np->ncci);
kfree(np);
nextpp = pp;
} else {
nextpp = &(*pp)->next;
}
}
}
printk(KERN_NOTICE "kcapi: card %d down.\n", CARDNR(card));
notify_push(KCI_CONTRDOWN, CARDNR(card), 0, 0);
}
int avmb1_registercard(int port, int irq, int cardtype, int allocio)
{
struct avmb1_card *card;
int irqval,i;
for (i=0; i < CAPI_MAXCONTR && cards[i].cardstate != CARD_FREE; i++) ;
if (i == CAPI_MAXCONTR) {
printk(KERN_ERR "b1capi: out of controller slots\n");
return -ENFILE;
}
card = &cards[i];
memset(card, 0, sizeof(avmb1_card));
sprintf(card->name, "avmb1-%d", CARDNR(card));
if (allocio)
request_region(port, AVMB1_PORTLEN, card->name);
if ((irqval = request_irq(irq, avmb1_interrupt,
SA_SHIRQ, card->name, card)) != 0) {
printk(KERN_ERR "b1capi: unable to get IRQ %d (irqval=%d).\n",
irq, irqval);
release_region((unsigned short) port, AVMB1_PORTLEN);
return -EIO;
}
card->cardstate = CARD_DETECTED;
ncards++;
card->cnr = CARDNR(card);
card->port = port;
card->irq = irq;
card->cardtype = cardtype;
return card->cnr;
}
static void avmb1_card_down(avmb1_card * card, int notify)
{
__u16 appl;
card->cardstate = CARD_DETECTED;
for (appl = 1; appl <= CAPI_MAXAPPL; appl++) {
avmb1_ncci **pp, **nextpp;
for (pp = &APPL(appl)->nccilist; *pp; pp = nextpp) {
if (NCCI2CTRL((*pp)->ncci) == card->cnr) {
avmb1_ncci *np = *pp;
*pp = np->next;
printk(KERN_INFO "b1capi: appl %d ncci 0x%x forced down!\n", appl, np->ncci);
kfree(np);
nextpp = pp;
} else {
nextpp = &(*pp)->next;
}
}
}
set_bit(CARDNR(card), ¬ify_down_set);
queue_task(&tq_state_notify, &tq_scheduler);
printk(KERN_NOTICE "b1capi: card %d down.\n", CARDNR(card));
}
static void controllercb_free_ncci(struct capi_ctr * card,
__u16 appl, __u32 ncci)
{
struct capi_ncci **pp;
if (!VALID_APPLID(appl)) {
printk(KERN_ERR "free_ncci: illegal appl %d\n", appl);
return;
}
for (pp = &APPL(appl)->nccilist; *pp; pp = &(*pp)->next) {
if ((*pp)->ncci == ncci) {
struct capi_ncci *np = *pp;
*pp = np->next;
kfree(np);
APPL(appl)->nncci--;
printk(KERN_INFO "kcapi: appl %d ncci 0x%x down\n", appl, ncci);
notify_push(KCI_NCCIDOWN, CARDNR(card), appl, ncci);
return;
}
}
printk(KERN_ERR "free_ncci: ncci 0x%x not found\n", ncci);
}
void avmb1_card_ready(avmb1_card * card)
{
struct capi_profile *profp =
(struct capi_profile *)card->version[VER_PROFILE];
char *dversion = card->version[VER_DRIVER];
__u16 appl;
char *cardname, cname[20];
__u32 flag;
card->cversion.majorversion = 2;
card->cversion.minorversion = 0;
card->cversion.majormanuversion = (((dversion[0] - '0') & 0xf) << 4);
card->cversion.majormanuversion |= ((dversion[2] - '0') & 0xf);
card->cversion.minormanuversion = (dversion[3] - '0') << 4;
card->cversion.minormanuversion |=
(dversion[5] - '0') * 10 + ((dversion[6] - '0') & 0xf);
card->cardstate = CARD_RUNNING;
for (appl = 1; appl <= CAPI_MAXAPPL; appl++) {
if (VALID_APPLID(appl) && !APPL(appl)->releasing) {
B1_send_register(card->port, appl,
1024 * (APPL(appl)->rparam.level3cnt+1),
APPL(appl)->rparam.level3cnt,
APPL(appl)->rparam.datablkcnt,
APPL(appl)->rparam.datablklen);
}
}
set_bit(CARDNR(card), ¬ify_up_set);
queue_task(&tq_state_notify, &tq_scheduler);
flag = ((__u8 *)(profp->manu))[1];
switch (flag) {
case 0: cardname = cardtype2str(card->cardtype); break;
case 3: cardname = "PCMCIA B"; break;
case 4: cardname = "PCMCIA M1"; break;
case 5: cardname = "PCMCIA M2"; break;
case 6: cardname = "B1 V3.0"; break;
case 7: cardname = "B1 PCI"; break;
default: cardname = cname; break;
sprintf(cname, "AVM?%u", (unsigned int)flag);
break;
}
printk(KERN_NOTICE "b1capi: card %d \"%s\" ready.\n",
CARDNR(card), cardname);
flag = ((__u8 *)(profp->manu))[3];
if (flag)
printk(KERN_NOTICE "b1capi: card %d Protocol:%s%s%s%s%s%s%s\n",
CARDNR(card),
(flag & 0x01) ? " DSS1" : "",
(flag & 0x02) ? " CT1" : "",
(flag & 0x04) ? " VN3" : "",
(flag & 0x08) ? " NI1" : "",
(flag & 0x10) ? " AUSTEL" : "",
(flag & 0x20) ? " ESS" : "",
(flag & 0x40) ? " 1TR6" : ""
);
flag = ((__u8 *)(profp->manu))[5];
if (flag)
printk(KERN_NOTICE "b1capi: card %d Linetype:%s%s%s%s\n",
CARDNR(card),
(flag & 0x01) ? " point to point" : "",
(flag & 0x02) ? " point to multipoint" : "",
(flag & 0x08) ? " leased line without D-channel" : "",
(flag & 0x04) ? " leased line with D-channel" : ""
);
}
