Lines Matching refs:card
22 MODULE_DESCRIPTION("ISDN4Linux: Pseudo Driver that simulates an ISDN card");
26 MODULE_PARM_DESC(isdnloop_id, "ID-String of first card");
34 * card = pointer to card struct
38 isdnloop_free_queue(isdnloop_card * card, int channel)
40 struct sk_buff_head *queue = &card->bqueue[channel];
43 card->sndcount[channel] = 0;
47 * Send B-Channel data to another virtual card.
51 * card = pointer to card struct.
55 isdnloop_bchan_send(isdnloop_card * card, int ch)
57 isdnloop_card *rcard = card->rcard[ch];
58 int rch = card->rch[ch], len, ack;
62 while (card->sndcount[ch]) {
63 if ((skb = skb_dequeue(&card->bqueue[ch]))) {
65 card->sndcount[ch] -= len;
67 cmd.driver = card->myid;
78 card->interface.statcallb(&cmd);
80 card->sndcount[ch] = 0;
90 * data = pointer to card struct, set by kernel timer.data
95 isdnloop_card *card = (isdnloop_card *) data;
98 if (card->flags & ISDNLOOP_FLAGS_B1ACTIVE)
99 isdnloop_bchan_send(card, 0);
100 if (card->flags & ISDNLOOP_FLAGS_B2ACTIVE)
101 isdnloop_bchan_send(card, 1);
102 if (card->flags & (ISDNLOOP_FLAGS_B1ACTIVE | ISDNLOOP_FLAGS_B2ACTIVE)) {
104 spin_lock_irqsave(&card->isdnloop_lock, flags);
105 card->rb_timer.expires = jiffies + ISDNLOOP_TIMER_BCREAD;
106 add_timer(&card->rb_timer);
107 card->flags |= ISDNLOOP_FLAGS_RBTIMER;
108 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
110 card->flags &= ~ISDNLOOP_FLAGS_RBTIMER;
176 * Parse Status message-strings from virtual card.
183 * card = card where message comes from.
186 isdnloop_parse_status(u_char * status, int channel, isdnloop_card * card)
202 cmd.driver = card->myid;
207 card->flags |= (channel) ?
212 card->flags &= ~((channel) ?
214 isdnloop_free_queue(card, channel);
222 sprintf(cmd.parm.setup.phone, "LEASED%d", card->myid);
249 card->flags &= ~ISDNLOOP_FLAGS_B1ACTIVE;
250 isdnloop_free_queue(card, 0);
252 cmd.driver = card->myid;
253 card->interface.statcallb(&cmd);
256 cmd.driver = card->myid;
257 card->interface.statcallb(&cmd);
259 card->flags &= ~ISDNLOOP_FLAGS_B2ACTIVE;
260 isdnloop_free_queue(card, 1);
262 cmd.driver = card->myid;
263 card->interface.statcallb(&cmd);
266 cmd.driver = card->myid;
269 card->interface.statcallb(&cmd);
276 * card = pointer to card struct.
280 isdnloop_putmsg(isdnloop_card * card, unsigned char c)
284 spin_lock_irqsave(&card->isdnloop_lock, flags);
285 *card->msg_buf_write++ = (c == 0xff) ? '\n' : c;
286 if (card->msg_buf_write == card->msg_buf_read) {
287 if (++card->msg_buf_read > card->msg_buf_end)
288 card->msg_buf_read = card->msg_buf;
290 if (card->msg_buf_write > card->msg_buf_end)
291 card->msg_buf_write = card->msg_buf;
292 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
297 * If there are new status-replies from the card, copy them to
306 * data = pointer to card struct
311 isdnloop_card *card = (isdnloop_card *) data;
321 if ((skb = skb_dequeue(&card->dqueue)))
328 isdnloop_putmsg(card, c);
329 card->imsg[card->iptr] = c;
330 if (card->iptr < 59)
331 card->iptr++;
334 isdnloop_putmsg(card, '\n');
335 card->imsg[card->iptr] = 0;
336 card->iptr = 0;
337 if (card->imsg[0] == '0' && card->imsg[1] >= '0' &&
338 card->imsg[1] <= '2' && card->imsg[2] == ';') {
339 ch = (card->imsg[1] - '0') - 1;
340 p = &card->imsg[3];
341 isdnloop_parse_status(p, ch, card);
343 p = card->imsg;
347 card->ptype = ISDN_PTYPE_1TR6;
348 card->interface.features |= ISDN_FEATURE_P_1TR6;
353 card->ptype = ISDN_PTYPE_EURO;
354 card->interface.features |= ISDN_FEATURE_P_EURO;
366 cmd.driver = card->myid;
368 card->interface.statcallb(&cmd);
370 if (card->flags & (ISDNLOOP_FLAGS_B1ACTIVE | ISDNLOOP_FLAGS_B2ACTIVE))
371 if (!(card->flags & ISDNLOOP_FLAGS_RBTIMER)) {
373 card->flags |= ISDNLOOP_FLAGS_RBTIMER;
374 spin_lock_irqsave(&card->isdnloop_lock, flags);
375 del_timer(&card->rb_timer);
376 card->rb_timer.function = isdnloop_pollbchan;
377 card->rb_timer.data = (unsigned long) card;
378 card->rb_timer.expires = jiffies + ISDNLOOP_TIMER_BCREAD;
379 add_timer(&card->rb_timer);
380 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
383 spin_lock_irqsave(&card->isdnloop_lock, flags);
384 card->st_timer.expires = jiffies + ISDNLOOP_TIMER_DCREAD;
385 add_timer(&card->st_timer);
386 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
395 * card = pointer to card-struct
400 isdnloop_sendbuf(int channel, struct sk_buff *skb, isdnloop_card * card)
412 if (!(card->flags & (channel) ? ISDNLOOP_FLAGS_B2ACTIVE : ISDNLOOP_FLAGS_B1ACTIVE))
414 if (card->sndcount[channel] > ISDNLOOP_MAX_SQUEUE)
416 spin_lock_irqsave(&card->isdnloop_lock, flags);
421 skb_queue_tail(&card->bqueue[channel], nskb);
425 card->sndcount[channel] += len;
426 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
432 * Read the messages from the card's ringbuffer
438 * card = pointer to card struct.
443 isdnloop_readstatus(u_char __user *buf, int len, isdnloop_card * card)
449 if (card->msg_buf_read == card->msg_buf_write)
451 if (put_user(*card->msg_buf_read++, p))
453 if (card->msg_buf_read > card->msg_buf_end)
454 card->msg_buf_read = card->msg_buf;
460 * Simulate a card's response by appending it to the cards
464 * card = pointer to card struct.
471 isdnloop_fake(isdnloop_card * card, char *s, int ch)
483 skb_queue_tail(&card->dqueue, skb);
514 * Simulate an error-response from a card.
517 * card = pointer to card struct.
520 isdnloop_fake_err(isdnloop_card * card)
524 sprintf(buf, "E%s", card->omsg);
525 isdnloop_fake(card, buf, -1);
526 isdnloop_fake(card, "NAK", -1);
539 * card = pointer to card struct.
546 isdnloop_unicause(isdnloop_card * card, int loc, int cau)
550 switch (card->ptype) {
568 * card = pointer to card struct.
572 isdnloop_atimeout(isdnloop_card * card, int ch)
577 spin_lock_irqsave(&card->isdnloop_lock, flags);
578 if (card->rcard) {
579 isdnloop_fake(card->rcard[ch], "DDIS_I", card->rch[ch] + 1);
580 card->rcard[ch]->rcard[card->rch[ch]] = NULL;
581 card->rcard[ch] = NULL;
583 isdnloop_fake(card, "DDIS_I", ch + 1);
585 sprintf(buf, "CAU%s", isdnloop_unicause(card, 1, 3));
586 isdnloop_fake(card, buf, ch + 1);
587 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
596 isdnloop_card *card = (isdnloop_card *) data;
597 isdnloop_atimeout(card, 0);
606 isdnloop_card *card = (isdnloop_card *) data;
607 isdnloop_atimeout(card, 1);
614 * card = pointer to card struct.
618 isdnloop_start_ctimer(isdnloop_card * card, int ch)
622 spin_lock_irqsave(&card->isdnloop_lock, flags);
623 init_timer(&card->c_timer[ch]);
624 card->c_timer[ch].expires = jiffies + ISDNLOOP_TIMER_ALERTWAIT;
626 card->c_timer[ch].function = isdnloop_atimeout1;
628 card->c_timer[ch].function = isdnloop_atimeout0;
629 card->c_timer[ch].data = (unsigned long) card;
630 add_timer(&card->c_timer[ch]);
631 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
638 * card = pointer to card struct.
642 isdnloop_kill_ctimer(isdnloop_card * card, int ch)
646 spin_lock_irqsave(&card->isdnloop_lock, flags);
647 del_timer(&card->c_timer[ch]);
648 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
660 * card = pointer to calling card.
662 * lch = channel of calling card.
671 isdnloop_try_call(isdnloop_card * card, char *p, int lch, isdn_ctrl * cmd)
685 if ((cc == card) && (ch == lch))
704 spin_lock_irqsave(&card->isdnloop_lock, flags);
709 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
713 cc->rcard[ch] = card;
715 card->rcard[lch] = cc;
716 card->rch[lch] = ch;
717 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
720 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
737 * card = pointer to card struct.
744 isdnloop_vstphone(isdnloop_card * card, char *phone, int caller)
749 if (!card) {
753 switch (card->ptype) {
757 if (!(strcmp(card->s0num[i], phone)))
759 return (card->s0num[0]);
765 sprintf(nphone, "%s%c", card->s0num[0], phone[0]);
775 * Parse an ICN-type command string sent to the 'card'.
779 * card = pointer to card struct.
782 isdnloop_parse_cmd(isdnloop_card * card)
784 char *p = card->omsg;
792 if ((card->omsg[0] != '0') && (card->omsg[2] != ';')) {
793 isdnloop_fake_err(card);
796 ch = card->omsg[1] - '0';
798 isdnloop_fake_err(card);
806 isdnloop_fake_err(card);
818 if (card->rcard[ch - 1]) {
819 isdnloop_fake(card->rcard[ch - 1], "BCON_I",
820 card->rch[ch - 1] + 1);
821 isdnloop_fake(card, "BCON_C", ch);
826 if (card->rcard[ch - 1]) {
827 isdnloop_fake(card->rcard[ch - 1], "BCON_C",
828 card->rch[ch - 1] + 1);
833 isdnloop_fake(card, "BDIS_C", ch);
834 if (card->rcard[ch - 1]) {
835 isdnloop_fake(card->rcard[ch - 1], "BDIS_I",
836 card->rch[ch - 1] + 1);
841 isdnloop_kill_ctimer(card, ch - 1);
842 if (card->rcard[ch - 1]) {
843 isdnloop_kill_ctimer(card->rcard[ch - 1], card->rch[ch - 1]);
844 isdnloop_fake(card->rcard[ch - 1], "DCON_C",
845 card->rch[ch - 1] + 1);
846 isdnloop_fake(card, "DCON_C", ch);
851 isdnloop_kill_ctimer(card, ch - 1);
852 if (card->rcard[ch - 1]) {
853 isdnloop_kill_ctimer(card->rcard[ch - 1], card->rch[ch - 1]);
854 isdnloop_fake(card->rcard[ch - 1], "DDIS_I",
855 card->rch[ch - 1] + 1);
856 card->rcard[ch - 1] = NULL;
858 isdnloop_fake(card, "DDIS_C", ch);
862 if (card->ptype != ISDN_PTYPE_1TR6) {
863 isdnloop_fake_err(card);
870 switch (isdnloop_try_call(card, p, ch - 1, &cmd)) {
875 isdnloop_vstphone(card, cmd.parm.setup.eazmsn, 1),
878 isdnloop_vstphone(card->rcard[ch - 1],
880 isdnloop_fake(card->rcard[ch - 1], buf, card->rch[ch - 1] + 1);
884 isdnloop_start_ctimer(card, ch - 1);
888 isdnloop_fake(card, "DDIS_I", ch);
889 sprintf(buf, "CAU%s", isdnloop_unicause(card, 1, 1));
890 isdnloop_fake(card, buf, ch);
894 isdnloop_fake(card, "DDIS_I", ch);
895 sprintf(buf, "CAU%s", isdnloop_unicause(card, 1, 2));
896 isdnloop_fake(card, buf, ch);
902 card->eazlist[ch - 1][0] = '\0';
907 strcpy(card->eazlist[ch - 1], p);
911 sprintf(buf, "EAZ-LIST: %s", card->eazlist[ch - 1]);
912 isdnloop_fake(card, buf, ch + 1);
926 card->sil[ch - 1] |= si2bit[*p - '0'];
930 isdnloop_fake_err(card);
937 if (card->sil[ch - 1] & (1 << i))
939 isdnloop_fake(card, buf, ch + 1);
943 card->sil[ch - 1] = 0;
955 * Put command-strings into the of the 'card'. In reality, execute them
964 * card = pointer to card struct.
969 isdnloop_writecmd(const u_char * buf, int len, int user, isdnloop_card * card)
987 isdnloop_putmsg(card, '>');
991 isdnloop_putmsg(card, *p);
992 card->omsg[card->optr] = *p;
994 card->omsg[card->optr] = '\0';
995 card->optr = 0;
996 isdnloop_parse_cmd(card);
998 isdnloop_putmsg(card, '>');
1002 if (card->optr < 59)
1003 card->optr++;
1009 cmd.driver = card->myid;
1011 card->interface.statcallb(&cmd);
1016 * Delete card's pending timers, send STOP to linklevel
1019 isdnloop_stopcard(isdnloop_card * card)
1024 spin_lock_irqsave(&card->isdnloop_lock, flags);
1025 if (card->flags & ISDNLOOP_FLAGS_RUNNING) {
1026 card->flags &= ~ISDNLOOP_FLAGS_RUNNING;
1027 del_timer(&card->st_timer);
1028 del_timer(&card->rb_timer);
1029 del_timer(&card->c_timer[0]);
1030 del_timer(&card->c_timer[1]);
1032 cmd.driver = card->myid;
1033 card->interface.statcallb(&cmd);
1035 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
1053 * Start a 'card'. Simulate card's boot message and set the phone
1058 * card = pointer to card struct.
1064 isdnloop_start(isdnloop_card * card, isdnloop_sdef * sdefp)
1070 if (card->flags & ISDNLOOP_FLAGS_RUNNING)
1074 spin_lock_irqsave(&card->isdnloop_lock, flags);
1077 if (isdnloop_fake(card, "DRV1.23EC-Q.931-CAPI-CNS-BASIS-20.02.96",
1079 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
1082 card->sil[0] = card->sil[1] = 4;
1083 if (isdnloop_fake(card, "TEI OK", 0)) {
1084 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
1088 strcpy(card->s0num[i], sdef.num[i]);
1091 if (isdnloop_fake(card, "DRV1.04TC-1TR6-CAPI-CNS-BASIS-29.11.95",
1093 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
1096 card->sil[0] = card->sil[1] = 4;
1097 if (isdnloop_fake(card, "TEI OK", 0)) {
1098 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
1101 strcpy(card->s0num[0], sdef.num[0]);
1102 card->s0num[1][0] = '\0';
1103 card->s0num[2][0] = '\0';
1106 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
1111 init_timer(&card->st_timer);
1112 card->st_timer.expires = jiffies + ISDNLOOP_TIMER_DCREAD;
1113 card->st_timer.function = isdnloop_polldchan;
1114 card->st_timer.data = (unsigned long) card;
1115 add_timer(&card->st_timer);
1116 card->flags |= ISDNLOOP_FLAGS_RUNNING;
1117 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
1125 isdnloop_command(isdn_ctrl * c, isdnloop_card * card)
1138 return (ulong) card;
1142 return (isdnloop_start(card, (isdnloop_sdef *) a));
1153 if (!card->leased) {
1154 card->leased = 1;
1155 while (card->ptype == ISDN_PTYPE_UNKNOWN)
1159 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1164 cmd.driver = card->myid;
1166 card->interface.statcallb(&cmd);
1169 if (card->leased) {
1170 card->leased = 0;
1172 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1177 cmd.driver = card->myid;
1179 card->interface.statcallb(&cmd);
1188 if (!(card->flags & ISDNLOOP_FLAGS_RUNNING))
1190 if (card->leased)
1210 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1214 if (!(card->flags & ISDNLOOP_FLAGS_RUNNING))
1219 switch (card->l2_proto[a - 1]) {
1236 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1238 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1242 if (!(card->flags & ISDNLOOP_FLAGS_RUNNING))
1246 switch (card->l2_proto[a - 1]) {
1265 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1268 if (!(card->flags & ISDNLOOP_FLAGS_RUNNING))
1273 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1277 if (!(card->flags & ISDNLOOP_FLAGS_RUNNING))
1279 if (card->leased)
1283 if (card->ptype == ISDN_PTYPE_EURO) {
1289 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1293 if (!(card->flags & ISDNLOOP_FLAGS_RUNNING))
1295 if (card->leased)
1299 if (card->ptype == ISDN_PTYPE_EURO)
1303 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1307 if (!(card->flags & ISDNLOOP_FLAGS_RUNNING))
1332 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1333 card->l2_proto[a & 255] = (a >> 8);
1337 if (!(card->flags & ISDNLOOP_FLAGS_RUNNING))
1348 * Find card with given driverId
1369 isdnloop_card *card = isdnloop_findcard(c->driver);
1371 if (card)
1372 return (isdnloop_command(c, card));
1381 isdnloop_card *card = isdnloop_findcard(id);
1383 if (card) {
1384 if (!(card->flags & ISDNLOOP_FLAGS_RUNNING))
1386 return (isdnloop_writecmd(buf, len, 1, card));
1396 isdnloop_card *card = isdnloop_findcard(id);
1398 if (card) {
1399 if (!(card->flags & ISDNLOOP_FLAGS_RUNNING))
1401 return (isdnloop_readstatus(buf, len, card));
1411 isdnloop_card *card = isdnloop_findcard(id);
1413 if (card) {
1414 if (!(card->flags & ISDNLOOP_FLAGS_RUNNING))
1418 return (isdnloop_sendbuf(channel, skb, card));
1426 * Allocate a new card-struct, initialize it
1432 isdnloop_card *card;
1435 if (!(card = kzalloc(sizeof(isdnloop_card), GFP_KERNEL))) {
1437 "isdnloop: (%s) Could not allocate card-struct.\n", id);
1440 card->interface.owner = THIS_MODULE;
1441 card->interface.channels = ISDNLOOP_BCH;
1442 card->interface.hl_hdrlen = 1; /* scratch area for storing ack flag*/
1443 card->interface.maxbufsize = 4000;
1444 card->interface.command = if_command;
1445 card->interface.writebuf_skb = if_sendbuf;
1446 card->interface.writecmd = if_writecmd;
1447 card->interface.readstat = if_readstatus;
1448 card->interface.features = ISDN_FEATURE_L2_X75I |
1456 card->ptype = ISDN_PTYPE_UNKNOWN;
1457 strlcpy(card->interface.id, id, sizeof(card->interface.id));
1458 card->msg_buf_write = card->msg_buf;
1459 card->msg_buf_read = card->msg_buf;
1460 card->msg_buf_end = &card->msg_buf[sizeof(card->msg_buf) - 1];
1462 card->l2_proto[i] = ISDN_PROTO_L2_X75I;
1463 skb_queue_head_init(&card->bqueue[i]);
1465 skb_queue_head_init(&card->dqueue);
1466 spin_lock_init(&card->isdnloop_lock);
1467 card->next = cards;
1468 cards = card;
1469 if (!register_isdn(&card->interface)) {
1473 kfree(card);
1476 card->myid = card->interface.channels;
1477 return card;
1483 isdnloop_card *card;
1485 if (!(card = isdnloop_initcard(id1))) {
1489 "isdnloop: (%s) virtual card added\n",
1490 card->interface.id);
1518 isdnloop_card *card = cards;
1523 while (card) {
1525 cmd.driver = card->myid;
1526 card->interface.statcallb(&cmd);
1528 isdnloop_free_queue(card, i);
1529 card = card->next;
1531 card = cards;
1532 while (card) {
1533 last = card;
1534 skb_queue_purge(&card->dqueue);
1535 card = card->next;