Lines Matching refs:card
23 MODULE_DESCRIPTION("ISDN4Linux: Driver for ICN active ISDN card");
27 MODULE_PARM_DESC(portbase, "Port address of first card");
31 MODULE_PARM_DESC(icn_id, "ID-String of first card");
33 MODULE_PARM_DESC(icn_id2, "ID-String of first card, second S0 (4B only)");
53 * card = pointer to card struct
57 icn_free_queue(icn_card * card, int channel)
59 struct sk_buff_head *queue = &card->spqueue[channel];
63 card->xlen[channel] = 0;
64 card->sndcount[channel] = 0;
65 if ((skb = card->xskb[channel])) {
66 card->xskb[channel] = NULL;
96 icn_disable_ram(icn_card * card)
105 icn_enable_ram(icn_card * card)
116 icn_map_channel(icn_card * card, int channel)
121 if ((channel == dev.channel) && (card == dev.mcard))
126 icn_enable_ram(card);
127 dev.mcard = card;
136 * Return 0 if requested card/channel is unmapped (failure).
142 icn_lock_channel(icn_card * card, int channel)
149 if ((dev.channel == channel) && (card == dev.mcard)) {
165 * Release current card/channel lock
180 * Release current card/channel lock
197 icn_trymaplock_channel(icn_card * card, int channel)
207 ((dev.channel == channel) && (dev.mcard == card))) {
209 icn_map_channel(card, channel);
224 * Release current card/channel lock,
228 icn_maprelease_channel(icn_card * card, int channel)
239 icn_map_channel(card, channel);
249 icn_pollbchan_receive(int channel, icn_card * card)
251 int mch = channel + ((card->secondhalf) ? 2 : 0);
256 if (icn_trymaplock_channel(card, mch)) {
259 if ((card->rcvidx[channel] + cnt) > 4000) {
264 card->rcvidx[channel] = 0;
267 memcpy_fromio(&card->rcvbuf[channel][card->rcvidx[channel]],
269 card->rcvidx[channel] += cnt;
273 icn_maprelease_channel(card, mch & 2);
275 if ((cnt = card->rcvidx[channel])) {
280 memcpy(skb_put(skb, cnt), card->rcvbuf[channel], cnt);
281 card->rcvidx[channel] = 0;
282 card->interface.rcvcallb_skb(card->myid, channel, skb);
285 if (!icn_trymaplock_channel(card, mch))
288 icn_maprelease_channel(card, mch & 2);
300 icn_pollbchan_send(int channel, icn_card * card)
302 int mch = channel + ((card->secondhalf) ? 2 : 0);
308 if (!(card->sndcount[channel] || card->xskb[channel] ||
309 !skb_queue_empty(&card->spqueue[channel])))
311 if (icn_trymaplock_channel(card, mch)) {
313 (card->sndcount[channel] ||
314 !skb_queue_empty(&card->spqueue[channel]) ||
315 card->xskb[channel])) {
316 spin_lock_irqsave(&card->lock, flags);
317 if (card->xmit_lock[channel]) {
318 spin_unlock_irqrestore(&card->lock, flags);
321 card->xmit_lock[channel]++;
322 spin_unlock_irqrestore(&card->lock, flags);
323 skb = card->xskb[channel];
325 skb = skb_dequeue(&card->spqueue[channel]);
331 card->xlen[channel] = skb->len;
333 card->xlen[channel] = 0;
349 icn_maprelease_channel(card, mch & 2);
350 spin_lock_irqsave(&card->lock, flags);
351 card->sndcount[channel] -= cnt;
353 if (card->xskb[channel])
354 card->xskb[channel] = NULL;
355 card->xmit_lock[channel] = 0;
356 spin_unlock_irqrestore(&card->lock, flags);
358 if (card->xlen[channel]) {
360 cmd.driver = card->myid;
362 cmd.parm.length = card->xlen[channel];
363 card->interface.statcallb(&cmd);
366 card->xskb[channel] = skb;
367 card->xmit_lock[channel] = 0;
368 spin_unlock_irqrestore(&card->lock, flags);
370 if (!icn_trymaplock_channel(card, mch))
373 icn_maprelease_channel(card, mch & 2);
385 icn_card *card = (icn_card *) data;
388 if (card->flags & ICN_FLAGS_B1ACTIVE) {
389 icn_pollbchan_receive(0, card);
390 icn_pollbchan_send(0, card);
392 if (card->flags & ICN_FLAGS_B2ACTIVE) {
393 icn_pollbchan_receive(1, card);
394 icn_pollbchan_send(1, card);
396 if (card->flags & (ICN_FLAGS_B1ACTIVE | ICN_FLAGS_B2ACTIVE)) {
398 spin_lock_irqsave(&card->lock, flags);
399 mod_timer(&card->rb_timer, jiffies+ICN_TIMER_BCREAD);
400 card->flags |= ICN_FLAGS_RBTIMER;
401 spin_unlock_irqrestore(&card->lock, flags);
403 card->flags &= ~ICN_FLAGS_RBTIMER;
448 icn_parse_status(u_char * status, int channel, icn_card * card)
465 cmd.driver = card->myid;
469 spin_lock_irqsave(&card->lock, flags);
470 icn_free_queue(card,channel);
471 card->rcvidx[channel] = 0;
473 if (card->flags &
478 card->flags &= ~((channel)?
483 ncmd.driver = card->myid;
486 spin_unlock_irqrestore(&card->lock, flags);
487 card->interface.statcallb(&cmd);
489 spin_unlock_irqrestore(&card->lock, flags);
492 spin_lock_irqsave(&card->lock, flags);
493 icn_free_queue(card,channel);
494 card->flags |= (channel) ?
496 spin_unlock_irqrestore(&card->lock, flags);
499 spin_lock_irqsave(&card->lock, flags);
500 card->flags &= ~((channel) ?
502 icn_free_queue(card, channel);
503 card->rcvidx[channel] = 0;
504 spin_unlock_irqrestore(&card->lock, flags);
535 sprintf(cmd.parm.setup.phone, "LEASED%d", card->myid);
558 spin_lock_irqsave(&card->lock, flags);
559 card->flags &= ~ICN_FLAGS_B1ACTIVE;
560 icn_free_queue(card, 0);
561 card->rcvidx[0] = 0;
562 spin_unlock_irqrestore(&card->lock, flags);
564 cmd.driver = card->myid;
565 card->interface.statcallb(&cmd);
568 cmd.driver = card->myid;
569 card->interface.statcallb(&cmd);
571 spin_lock_irqsave(&card->lock, flags);
572 card->flags &= ~ICN_FLAGS_B2ACTIVE;
573 icn_free_queue(card, 1);
574 card->rcvidx[1] = 0;
575 spin_unlock_irqrestore(&card->lock, flags);
577 cmd.driver = card->myid;
578 card->interface.statcallb(&cmd);
581 cmd.driver = card->myid;
584 card->interface.statcallb(&cmd);
589 icn_putmsg(icn_card * card, unsigned char c)
593 spin_lock_irqsave(&card->lock, flags);
594 *card->msg_buf_write++ = (c == 0xff) ? '\n' : c;
595 if (card->msg_buf_write == card->msg_buf_read) {
596 if (++card->msg_buf_read > card->msg_buf_end)
597 card->msg_buf_read = card->msg_buf;
599 if (card->msg_buf_write > card->msg_buf_end)
600 card->msg_buf_write = card->msg_buf;
601 spin_unlock_irqrestore(&card->lock, flags);
607 icn_card *card = (icn_card *) data;
608 int mch = card->secondhalf ? 2 : 0;
618 if (icn_trymaplock_channel(card, mch)) {
622 icn_putmsg(card, c);
624 card->imsg[card->iptr] = 0;
625 card->iptr = 0;
626 if (card->imsg[0] == '0' && card->imsg[1] >= '0' &&
627 card->imsg[1] <= '2' && card->imsg[2] == ';') {
628 ch = (card->imsg[1] - '0') - 1;
629 p = &card->imsg[3];
630 icn_parse_status(p, ch, card);
632 p = card->imsg;
639 card->ptype = ISDN_PTYPE_1TR6;
640 card->interface.features |= ISDN_FEATURE_P_1TR6;
645 card->ptype = ISDN_PTYPE_EURO;
646 card->interface.features |= ISDN_FEATURE_P_EURO;
650 p = strstr(card->imsg, "BRV") + 3;
659 card->fw_rev = (int) simple_strtoul(vstr, NULL, 10);
665 card->imsg[card->iptr] = c;
666 if (card->iptr < 59)
667 card->iptr++;
675 cmd.driver = card->myid;
677 card->interface.statcallb(&cmd);
679 spin_lock_irqsave(&card->lock, flags);
680 if (card->flags & (ICN_FLAGS_B1ACTIVE | ICN_FLAGS_B2ACTIVE))
681 if (!(card->flags & ICN_FLAGS_RBTIMER)) {
683 card->flags |= ICN_FLAGS_RBTIMER;
684 del_timer(&card->rb_timer);
685 card->rb_timer.function = icn_pollbchan;
686 card->rb_timer.data = (unsigned long) card;
687 card->rb_timer.expires = jiffies + ICN_TIMER_BCREAD;
688 add_timer(&card->rb_timer);
691 mod_timer(&card->st_timer, jiffies+ICN_TIMER_DCREAD);
692 spin_unlock_irqrestore(&card->lock, flags);
699 * card = pointer to card-struct
705 icn_sendbuf(int channel, int ack, struct sk_buff *skb, icn_card * card)
717 if (!(card->flags & (channel) ? ICN_FLAGS_B2ACTIVE : ICN_FLAGS_B1ACTIVE))
719 if (card->sndcount[channel] > ICN_MAX_SQUEUE)
728 skb_queue_tail(&card->spqueue[channel], nskb);
732 spin_lock_irqsave(&card->lock, flags);
733 card->sndcount[channel] += len;
734 spin_unlock_irqrestore(&card->lock, flags);
740 * Check card's status after starting the bootstrap loader.
741 * On entry, the card's shared memory has already to be mapped.
778 /* Load the boot-code into the interface-card's memory and start it.
801 icn_loadboot(u_char __user * buffer, icn_card * card)
819 if (!card->rvalid) {
820 if (!request_region(card->port, ICN_PORTLEN, card->regname)) {
824 card->port,
825 card->port + ICN_PORTLEN);
829 card->rvalid = 1;
830 if (card->doubleS0)
831 card->other->rvalid = 1;
855 icn_map_channel(card, 0); /* Select Bank 0 */
856 icn_lock_channel(card, 0); /* Lock Bank 0 */
863 if (card->doubleS0) {
870 icn_map_channel(card, 2); /* Select Bank 8 */
871 icn_lock_channel(card, 2); /* Lock Bank 8 */
881 if ((ret = icn_check_loader(card->doubleS0 ? 2 : 1))) {
884 if (!card->doubleS0) {
893 icn_map_channel(card, 0); /* Select Bank 0 */
894 icn_lock_channel(card, 0); /* Lock Bank 0 */
906 icn_loadproto(u_char __user * buffer, icn_card * card)
922 if (card->secondhalf) {
923 icn_map_channel(card, 2);
924 icn_lock_channel(card, 2);
926 icn_map_channel(card, 0);
927 icn_lock_channel(card, 0);
936 icn_maprelease_channel(card, 0);
949 icn_maprelease_channel(card, 0);
969 icn_maprelease_channel(card, 0);
977 if ((card->secondhalf) || (!card->doubleS0)) {
980 card->secondhalf);
982 spin_lock_irqsave(&card->lock, flags);
983 init_timer(&card->st_timer);
984 card->st_timer.expires = jiffies + ICN_TIMER_DCREAD;
985 card->st_timer.function = icn_polldchan;
986 card->st_timer.data = (unsigned long) card;
987 add_timer(&card->st_timer);
988 card->flags |= ICN_FLAGS_RUNNING;
989 if (card->doubleS0) {
990 init_timer(&card->other->st_timer);
991 card->other->st_timer.expires = jiffies + ICN_TIMER_DCREAD;
992 card->other->st_timer.function = icn_polldchan;
993 card->other->st_timer.data = (unsigned long) card->other;
994 add_timer(&card->other->st_timer);
995 card->other->flags |= ICN_FLAGS_RUNNING;
997 spin_unlock_irqrestore(&card->lock, flags);
999 icn_maprelease_channel(card, 0);
1007 icn_readstatus(u_char __user *buf, int len, icn_card * card)
1013 if (card->msg_buf_read == card->msg_buf_write)
1015 if (put_user(*card->msg_buf_read++, p))
1017 if (card->msg_buf_read > card->msg_buf_end)
1018 card->msg_buf_read = card->msg_buf;
1025 icn_writecmd(const u_char * buf, int len, int user, icn_card * card)
1027 int mch = card->secondhalf ? 2 : 0;
1056 icn_map_channel(card, mch);
1058 icn_putmsg(card, '>');
1065 icn_putmsg(card, *p);
1067 icn_putmsg(card, '>');
1086 cmd.driver = card->myid;
1088 card->interface.statcallb(&cmd);
1093 * Delete card's pending timers, send STOP to linklevel
1096 icn_stopcard(icn_card * card)
1101 spin_lock_irqsave(&card->lock, flags);
1102 if (card->flags & ICN_FLAGS_RUNNING) {
1103 card->flags &= ~ICN_FLAGS_RUNNING;
1104 del_timer(&card->st_timer);
1105 del_timer(&card->rb_timer);
1106 spin_unlock_irqrestore(&card->lock, flags);
1108 cmd.driver = card->myid;
1109 card->interface.statcallb(&cmd);
1110 if (card->doubleS0)
1111 icn_stopcard(card->other);
1113 spin_unlock_irqrestore(&card->lock, flags);
1134 icn_card *card = cards;
1136 while (card) {
1137 if (!request_region(card->port, ICN_PORTLEN, "icn-isdn")) {
1141 card->port,
1142 card->port + ICN_PORTLEN);
1146 release_region(card->port, ICN_PORTLEN);
1148 card = card->next;
1153 icn_command(isdn_ctrl * c, icn_card * card)
1178 spin_lock_irqsave(&card->lock, flags);
1185 spin_unlock_irqrestore(&card->lock, flags);
1199 if (card->port != (unsigned short) a) {
1207 icn_stopcard(card);
1208 spin_lock_irqsave(&card->lock, flags);
1209 if (card->rvalid)
1210 release_region(card->port, ICN_PORTLEN);
1211 card->port = (unsigned short) a;
1212 card->rvalid = 0;
1213 if (card->doubleS0) {
1214 card->other->port = (unsigned short) a;
1215 card->other->rvalid = 0;
1217 spin_unlock_irqrestore(&card->lock, flags);
1220 CID, card->port);
1226 return (int) card->port;
1228 return (int) card->doubleS0;
1231 &card,
1248 icn_stopcard(card);
1249 return (icn_loadboot(arg, card));
1251 icn_stopcard(card);
1252 if ((i = (icn_loadproto(arg, card))))
1254 if (card->doubleS0)
1255 i = icn_loadproto(arg + ICN_CODE_STAGE2, card->other);
1269 if (!card->leased) {
1270 card->leased = 1;
1271 while (card->ptype == ISDN_PTYPE_UNKNOWN) {
1277 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1282 cmd.driver = card->myid;
1284 card->interface.statcallb(&cmd);
1287 if (card->leased) {
1288 card->leased = 0;
1290 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1295 cmd.driver = card->myid;
1297 card->interface.statcallb(&cmd);
1306 if (!(card->flags & ICN_FLAGS_RUNNING))
1308 if (card->leased)
1328 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1332 if (!(card->flags & ICN_FLAGS_RUNNING))
1336 if (card->fw_rev >= 300) {
1337 switch (card->l2_proto[a - 1]) {
1345 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1348 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1352 if (!(card->flags & ICN_FLAGS_RUNNING))
1356 if (card->fw_rev >= 300)
1357 switch (card->l2_proto[a - 1]) {
1366 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1370 if (!(card->flags & ICN_FLAGS_RUNNING))
1375 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1379 if (!(card->flags & ICN_FLAGS_RUNNING))
1381 if (card->leased)
1385 if (card->ptype == ISDN_PTYPE_EURO) {
1391 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1395 if (!(card->flags & ICN_FLAGS_RUNNING))
1397 if (card->leased)
1401 if (card->ptype == ISDN_PTYPE_EURO)
1405 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1409 if (!(card->flags & ICN_FLAGS_RUNNING))
1423 i = icn_writecmd(cbuf, strlen(cbuf), 0, card);
1424 card->l2_proto[a & 255] = (a >> 8);
1428 if (!(card->flags & ICN_FLAGS_RUNNING))
1438 * Find card with given driverId
1459 icn_card *card = icn_findcard(c->driver);
1461 if (card)
1462 return (icn_command(c, card));
1472 icn_card *card = icn_findcard(id);
1474 if (card) {
1475 if (!(card->flags & ICN_FLAGS_RUNNING))
1477 return (icn_writecmd(buf, len, 1, card));
1487 icn_card *card = icn_findcard(id);
1489 if (card) {
1490 if (!(card->flags & ICN_FLAGS_RUNNING))
1492 return (icn_readstatus(buf, len, card));
1502 icn_card *card = icn_findcard(id);
1504 if (card) {
1505 if (!(card->flags & ICN_FLAGS_RUNNING))
1507 return (icn_sendbuf(channel, ack, skb, card));
1515 * Allocate a new card-struct, initialize it
1521 icn_card *card;
1524 if (!(card = kzalloc(sizeof(icn_card), GFP_KERNEL))) {
1526 "icn: (%s) Could not allocate card-struct.\n", id);
1529 spin_lock_init(&card->lock);
1530 card->port = port;
1531 card->interface.owner = THIS_MODULE;
1532 card->interface.hl_hdrlen = 1;
1533 card->interface.channels = ICN_BCH;
1534 card->interface.maxbufsize = 4000;
1535 card->interface.command = if_command;
1536 card->interface.writebuf_skb = if_sendbuf;
1537 card->interface.writecmd = if_writecmd;
1538 card->interface.readstat = if_readstatus;
1539 card->interface.features = ISDN_FEATURE_L2_X75I |
1543 card->ptype = ISDN_PTYPE_UNKNOWN;
1544 strlcpy(card->interface.id, id, sizeof(card->interface.id));
1545 card->msg_buf_write = card->msg_buf;
1546 card->msg_buf_read = card->msg_buf;
1547 card->msg_buf_end = &card->msg_buf[sizeof(card->msg_buf) - 1];
1549 card->l2_proto[i] = ISDN_PROTO_L2_X75I;
1550 skb_queue_head_init(&card->spqueue[i]);
1552 card->next = cards;
1553 cards = card;
1554 if (!register_isdn(&card->interface)) {
1558 kfree(card);
1561 card->myid = card->interface.channels;
1562 sprintf(card->regname, "icn-isdn (%s)", card->interface.id);
1563 return card;
1569 icn_card *card;
1572 if (!(card = icn_initcard(port, id1))) {
1578 card->interface.id, port);
1587 card->doubleS0 = 1;
1588 card->secondhalf = 0;
1589 card->other = card2;
1592 card2->other = card;
1595 card->interface.id, card2->interface.id, port);
1653 icn_card *card = cards;
1659 while (card) {
1661 cmd.driver = card->myid;
1662 card->interface.statcallb(&cmd);
1663 spin_lock_irqsave(&card->lock, flags);
1664 if (card->rvalid) {
1667 if (card->secondhalf || (!card->doubleS0)) {
1668 release_region(card->port, ICN_PORTLEN);
1669 card->rvalid = 0;
1672 icn_free_queue(card, i);
1674 tmpcard = card->next;
1675 spin_unlock_irqrestore(&card->lock, flags);
1676 card = tmpcard;
1678 card = cards;
1680 while (card) {
1681 last = card;
1682 card = card->next;