Lines Matching refs:card
21 MODULE_DESCRIPTION("ISDN4Linux: Pseudo Driver that simulates an ISDN card");
25 MODULE_PARM_DESC(isdnloop_id, "ID-String of first card");
33 * card = pointer to card struct
37 isdnloop_free_queue(isdnloop_card * card, int channel)
39 struct sk_buff_head *queue = &card->bqueue[channel];
42 card->sndcount[channel] = 0;
46 * Send B-Channel data to another virtual card.
50 * card = pointer to card struct.
54 isdnloop_bchan_send(isdnloop_card * card, int ch)
56 isdnloop_card *rcard = card->rcard[ch];
57 int rch = card->rch[ch], len, ack;
61 while (card->sndcount[ch]) {
62 if ((skb = skb_dequeue(&card->bqueue[ch]))) {
64 card->sndcount[ch] -= len;
66 cmd.driver = card->myid;
77 card->interface.statcallb(&cmd);
79 card->sndcount[ch] = 0;
89 * data = pointer to card struct, set by kernel timer.data
94 isdnloop_card *card = (isdnloop_card *) data;
97 if (card->flags & ISDNLOOP_FLAGS_B1ACTIVE)
98 isdnloop_bchan_send(card, 0);
99 if (card->flags & ISDNLOOP_FLAGS_B2ACTIVE)
100 isdnloop_bchan_send(card, 1);
101 if (card->flags & (ISDNLOOP_FLAGS_B1ACTIVE | ISDNLOOP_FLAGS_B2ACTIVE)) {
103 spin_lock_irqsave(&card->isdnloop_lock, flags);
104 card->rb_timer.expires = jiffies + ISDNLOOP_TIMER_BCREAD;
105 add_timer(&card->rb_timer);
106 card->flags |= ISDNLOOP_FLAGS_RBTIMER;
107 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
109 card->flags &= ~ISDNLOOP_FLAGS_RBTIMER;
175 * Parse Status message-strings from virtual card.
182 * card = card where message comes from.
185 isdnloop_parse_status(u_char * status, int channel, isdnloop_card * card)
201 cmd.driver = card->myid;
206 card->flags |= (channel) ?
211 card->flags &= ~((channel) ?
213 isdnloop_free_queue(card, channel);
221 sprintf(cmd.parm.setup.phone, "LEASED%d", card->myid);
248 card->flags &= ~ISDNLOOP_FLAGS_B1ACTIVE;
249 isdnloop_free_queue(card, 0);
251 cmd.driver = card->myid;
252 card->interface.statcallb(&cmd);
255 cmd.driver = card->myid;
256 card->interface.statcallb(&cmd);
258 card->flags &= ~ISDNLOOP_FLAGS_B2ACTIVE;
259 isdnloop_free_queue(card, 1);
261 cmd.driver = card->myid;
262 card->interface.statcallb(&cmd);
265 cmd.driver = card->myid;
268 card->interface.statcallb(&cmd);
275 * card = pointer to card struct.
279 isdnloop_putmsg(isdnloop_card * card, unsigned char c)
283 spin_lock_irqsave(&card->isdnloop_lock, flags);
284 *card->msg_buf_write++ = (c == 0xff) ? '\n' : c;
285 if (card->msg_buf_write == card->msg_buf_read) {
286 if (++card->msg_buf_read > card->msg_buf_end)
287 card->msg_buf_read = card->msg_buf;
289 if (card->msg_buf_write > card->msg_buf_end)
290 card->msg_buf_write = card->msg_buf;
291 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
296 * If there are new status-replies from the card, copy them to
305 * data = pointer to card struct
310 isdnloop_card *card = (isdnloop_card *) data;
320 if ((skb = skb_dequeue(&card->dqueue)))
327 isdnloop_putmsg(card, c);
328 card->imsg[card->iptr] = c;
329 if (card->iptr < 59)
330 card->iptr++;
333 isdnloop_putmsg(card, '\n');
334 card->imsg[card->iptr] = 0;
335 card->iptr = 0;
336 if (card->imsg[0] == '0' && card->imsg[1] >= '0' &&
337 card->imsg[1] <= '2' && card->imsg[2] == ';') {
338 ch = (card->imsg[1] - '0') - 1;
339 p = &card->imsg[3];
340 isdnloop_parse_status(p, ch, card);
342 p = card->imsg;
346 card->ptype = ISDN_PTYPE_1TR6;
347 card->interface.features |= ISDN_FEATURE_P_1TR6;
352 card->ptype = ISDN_PTYPE_EURO;
353 card->interface.features |= ISDN_FEATURE_P_EURO;
365 cmd.driver = card->myid;
367 card->interface.statcallb(&cmd);
369 if (card->flags & (ISDNLOOP_FLAGS_B1ACTIVE | ISDNLOOP_FLAGS_B2ACTIVE))
370 if (!(card->flags & ISDNLOOP_FLAGS_RBTIMER)) {
372 card->flags |= ISDNLOOP_FLAGS_RBTIMER;
373 spin_lock_irqsave(&card->isdnloop_lock, flags);
374 del_timer(&card->rb_timer);
375 card->rb_timer.function = isdnloop_pollbchan;
376 card->rb_timer.data = (unsigned long) card;
377 card->rb_timer.expires = jiffies + ISDNLOOP_TIMER_BCREAD;
378 add_timer(&card->rb_timer);
379 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
382 spin_lock_irqsave(&card->isdnloop_lock, flags);
383 card->st_timer.expires = jiffies + ISDNLOOP_TIMER_DCREAD;
384 add_timer(&card->st_timer);
385 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
394 * card = pointer to card-struct
399 isdnloop_sendbuf(int channel, struct sk_buff *skb, isdnloop_card * card)
411 if (!(card->flags & (channel) ? ISDNLOOP_FLAGS_B2ACTIVE : ISDNLOOP_FLAGS_B1ACTIVE))
413 if (card->sndcount[channel] > ISDNLOOP_MAX_SQUEUE)
415 spin_lock_irqsave(&card->isdnloop_lock, flags);
420 skb_queue_tail(&card->bqueue[channel], nskb);
424 card->sndcount[channel] += len;
425 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
431 * Read the messages from the card's ringbuffer
437 * card = pointer to card struct.
442 isdnloop_readstatus(u_char __user *buf, int len, isdnloop_card * card)
448 if (card->msg_buf_read == card->msg_buf_write)
450 if (put_user(*card->msg_buf_read++, p))
452 if (card->msg_buf_read > card->msg_buf_end)
453 card->msg_buf_read = card->msg_buf;
459 * Simulate a card's response by appending it to the cards
463 * card = pointer to card struct.
470 isdnloop_fake(isdnloop_card * card, char *s, int ch)
482 skb_queue_tail(&card->dqueue, skb);
513 * Simulate an error-response from a card.
516 * card = pointer to card struct.
519 isdnloop_fake_err(isdnloop_card * card)
523 sprintf(buf, "E%s", card->omsg);
524 isdnloop_fake(card, buf, -1);
525 isdnloop_fake(card, "NAK", -1);
538 * card = pointer to card struct.
545 isdnloop_unicause(isdnloop_card * card, int loc, int cau)
549 switch (card->ptype) {
567 * card = pointer to card struct.
571 isdnloop_atimeout(isdnloop_card * card, int ch)
576 spin_lock_irqsave(&card->isdnloop_lock, flags);
577 if (card->rcard) {
578 isdnloop_fake(card->rcard[ch], "DDIS_I", card->rch[ch] + 1);
579 card->rcard[ch]->rcard[card->rch[ch]] = NULL;
580 card->rcard[ch] = NULL;
582 isdnloop_fake(card, "DDIS_I", ch + 1);
584 sprintf(buf, "CAU%s", isdnloop_unicause(card, 1, 3));
585 isdnloop_fake(card, buf, ch + 1);
586 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
595 isdnloop_card *card = (isdnloop_card *) data;
596 isdnloop_atimeout(card, 0);
605 isdnloop_card *card = (isdnloop_card *) data;
606 isdnloop_atimeout(card, 1);
613 * card = pointer to card struct.
617 isdnloop_start_ctimer(isdnloop_card * card, int ch)
621 spin_lock_irqsave(&card->isdnloop_lock, flags);
622 init_timer(&card->c_timer[ch]);
623 card->c_timer[ch].expires = jiffies + ISDNLOOP_TIMER_ALERTWAIT;
625 card->c_timer[ch].function = isdnloop_atimeout1;
627 card->c_timer[ch].function = isdnloop_atimeout0;
628 card->c_timer[ch].data = (unsigned long) card;
629 add_timer(&card->c_timer[ch]);
630 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
637 * card = pointer to card struct.
641 isdnloop_kill_ctimer(isdnloop_card * card, int ch)
645 spin_lock_irqsave(&card->isdnloop_lock, flags);
646 del_timer(&card->c_timer[ch]);
647 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
659 * card = pointer to calling card.
661 * lch = channel of calling card.
670 isdnloop_try_call(isdnloop_card * card, char *p, int lch, isdn_ctrl * cmd)
684 if ((cc == card) && (ch == lch))
703 spin_lock_irqsave(&card->isdnloop_lock, flags);
708 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
712 cc->rcard[ch] = card;
714 card->rcard[lch] = cc;
715 card->rch[lch] = ch;
716 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
719 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
736 * card = pointer to card struct.
743 isdnloop_vstphone(isdnloop_card * card, char *phone, int caller)
748 if (!card) {
752 switch (card->ptype) {
756 if (!(strcmp(card->s0num[i], phone)))
758 return (card->s0num[0]);
764 sprintf(nphone, "%s%c", card->s0num[0], phone[0]);
774 * Parse an ICN-type command string sent to the 'card'.
778 * card = pointer to card struct.
781 isdnloop_parse_cmd(isdnloop_card * card)
783 char *p = card->omsg;
791 if ((card->omsg[0] != '0') && (card->omsg[2] != ';')) {
792 isdnloop_fake_err(card);
795 ch = card->omsg[1] - '0';
797 isdnloop_fake_err(card);
805 isdnloop_fake_err(card);
817 if (card->rcard[ch - 1]) {
818 isdnloop_fake(card->rcard[ch - 1], "BCON_I",
819 card->rch[ch - 1] + 1);
820 isdnloop_fake(card, "BCON_C", ch);
825 if (card->rcard[ch - 1]) {
826 isdnloop_fake(card->rcard[ch - 1], "BCON_C",
827 card->rch[ch - 1] + 1);
832 isdnloop_fake(card, "BDIS_C", ch);
833 if (card->rcard[ch - 1]) {
834 isdnloop_fake(card->rcard[ch - 1], "BDIS_I",
835 card->rch[ch - 1] + 1);
840 isdnloop_kill_ctimer(card, ch - 1);
841 if (card->rcard[ch - 1]) {
842 isdnloop_kill_ctimer(card->rcard[ch - 1], card->rch[ch - 1]);
843 isdnloop_fake(card->rcard[ch - 1], "DCON_C",
844 card->rch[ch - 1] + 1);
845 isdnloop_fake(card, "DCON_C", ch);
850 isdnloop_kill_ctimer(card, ch - 1);
851 if (card->rcard[ch - 1]) {
852 isdnloop_kill_ctimer(card->rcard[ch - 1], card->rch[ch - 1]);
853 isdnloop_fake(card->rcard[ch - 1], "DDIS_I",
854 card->rch[ch - 1] + 1);
855 card->rcard[ch - 1] = NULL;
857 isdnloop_fake(card, "DDIS_C", ch);
861 if (card->ptype != ISDN_PTYPE_1TR6) {
862 isdnloop_fake_err(card);
869 switch (isdnloop_try_call(card, p, ch - 1, &cmd)) {
874 isdnloop_vstphone(card, cmd.parm.setup.eazmsn, 1),
877 isdnloop_vstphone(card->rcard[ch - 1],
879 isdnloop_fake(card->rcard[ch - 1], buf, card->rch[ch - 1] + 1);
883 isdnloop_start_ctimer(card, ch - 1);
887 isdnloop_fake(card, "DDIS_I", ch);
888 sprintf(buf, "CAU%s", isdnloop_unicause(card, 1, 1));
889 isdnloop_fake(card, buf, ch);
893 isdnloop_fake(card, "DDIS_I", ch);
894 sprintf(buf, "CAU%s", isdnloop_unicause(card, 1, 2));
895 isdnloop_fake(card, buf, ch);
901 card->eazlist[ch - 1][0] = '\0';
906 strcpy(card->eazlist[ch - 1], p);
910 sprintf(buf, "EAZ-LIST: %s", card->eazlist[ch - 1]);
911 isdnloop_fake(card, buf, ch + 1);
925 card->sil[ch - 1] |= si2bit[*p - '0'];
929 isdnloop_fake_err(card);
936 if (card->sil[ch - 1] & (1 << i))
938 isdnloop_fake(card, buf, ch + 1);
942 card->sil[ch - 1] = 0;
954 * Put command-strings into the of the 'card'. In reality, execute them
963 * card = pointer to card struct.
968 isdnloop_writecmd(const u_char * buf, int len, int user, isdnloop_card * card)
986 isdnloop_putmsg(card, '>');
990 isdnloop_putmsg(card, *p);
991 card->omsg[card->optr] = *p;
993 card->omsg[card->optr] = '\0';
994 card->optr = 0;
995 isdnloop_parse_cmd(card);
997 isdnloop_putmsg(card, '>');
1001 if (card->optr < 59)
1002 card->optr++;
1008 cmd.driver = card->myid;
1010 card->interface.statcallb(&cmd);
1015 * Delete card's pending timers, send STOP to linklevel
1018 isdnloop_stopcard(isdnloop_card * card)
1023 spin_lock_irqsave(&card->isdnloop_lock, flags);
1024 if (card->flags & ISDNLOOP_FLAGS_RUNNING) {
1025 card->flags &= ~ISDNLOOP_FLAGS_RUNNING;
1026 del_timer(&card->st_timer);
1027 del_timer(&card->rb_timer);
1028 del_timer(&card->c_timer[0]);
1029 del_timer(&card->c_timer[1]);
1031 cmd.driver = card->myid;
1032 card->interface.statcallb(&cmd);
1034 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
1052 * Start a 'card'. Simulate card's boot message and set the phone
1057 * card = pointer to card struct.
1063 isdnloop_start(isdnloop_card * card, isdnloop_sdef * sdefp)
1069 if (card->flags & ISDNLOOP_FLAGS_RUNNING)
1073 spin_lock_irqsave(&card->isdnloop_lock, flags);
1076 if (isdnloop_fake(card, "DRV1.23EC-Q.931-CAPI-CNS-BASIS-20.02.96",
1078 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
1081 card->sil[0] = card->sil[1] = 4;
1082 if (isdnloop_fake(card, "TEI OK", 0)) {
1083 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
1087 strcpy(card->s0num[i], sdef.num[i]);
1090 if (isdnloop_fake(card, "DRV1.04TC-1TR6-CAPI-CNS-BASIS-29.11.95",
1092 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
1095 card->sil[0] = card->sil[1] = 4;
1096 if (isdnloop_fake(card, "TEI OK", 0)) {
1097 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
1100 strcpy(card->s0num[0], sdef.num[0]);
1101 card->s0num[1][0] = '\0';
1102 card->s0num[2][0] = '\0';
1105 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
1110 init_timer(&card->st_timer);
1111 card->st_timer.expires = jiffies + ISDNLOOP_TIMER_DCREAD;
1112 card->st_timer.function = isdnloop_polldchan;
1113 card->st_timer.data = (unsigned long) card;
1114 add_timer(&card->st_timer);
1115 card->flags |= ISDNLOOP_FLAGS_RUNNING;
1116 spin_unlock_irqrestore(&card->isdnloop_lock, flags);
1124 isdnloop_command(isdn_ctrl * c, isdnloop_card * card)
1137 return (ulong) card;
1141 return (isdnloop_start(card, (isdnloop_sdef *) a));
1152 if (!card->leased) {
1153 card->leased = 1;
1154 while (card->ptype == ISDN_PTYPE_UNKNOWN)
1158 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1163 cmd.driver = card->myid;
1165 card->interface.statcallb(&cmd);
1168 if (card->leased) {
1169 card->leased = 0;
1171 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1176 cmd.driver = card->myid;
1178 card->interface.statcallb(&cmd);
1187 if (!card->flags & ISDNLOOP_FLAGS_RUNNING)
1189 if (card->leased)
1209 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1213 if (!card->flags & ISDNLOOP_FLAGS_RUNNING)
1218 switch (card->l2_proto[a - 1]) {
1235 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1237 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1241 if (!card->flags & ISDNLOOP_FLAGS_RUNNING)
1245 switch (card->l2_proto[a - 1]) {
1264 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1267 if (!card->flags & ISDNLOOP_FLAGS_RUNNING)
1272 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1276 if (!card->flags & ISDNLOOP_FLAGS_RUNNING)
1278 if (card->leased)
1282 if (card->ptype == ISDN_PTYPE_EURO) {
1288 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1292 if (!card->flags & ISDNLOOP_FLAGS_RUNNING)
1294 if (card->leased)
1298 if (card->ptype == ISDN_PTYPE_EURO)
1302 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1306 if (!card->flags & ISDNLOOP_FLAGS_RUNNING)
1331 i = isdnloop_writecmd(cbuf, strlen(cbuf), 0, card);
1332 card->l2_proto[a & 255] = (a >> 8);
1336 if (!card->flags & ISDNLOOP_FLAGS_RUNNING)
1347 * Find card with given driverId
1368 isdnloop_card *card = isdnloop_findcard(c->driver);
1370 if (card)
1371 return (isdnloop_command(c, card));
1380 isdnloop_card *card = isdnloop_findcard(id);
1382 if (card) {
1383 if (!card->flags & ISDNLOOP_FLAGS_RUNNING)
1385 return (isdnloop_writecmd(buf, len, 1, card));
1395 isdnloop_card *card = isdnloop_findcard(id);
1397 if (card) {
1398 if (!card->flags & ISDNLOOP_FLAGS_RUNNING)
1400 return (isdnloop_readstatus(buf, len, card));
1410 isdnloop_card *card = isdnloop_findcard(id);
1412 if (card) {
1413 if (!card->flags & ISDNLOOP_FLAGS_RUNNING)
1417 return (isdnloop_sendbuf(channel, skb, card));
1425 * Allocate a new card-struct, initialize it
1431 isdnloop_card *card;
1434 if (!(card = kzalloc(sizeof(isdnloop_card), GFP_KERNEL))) {
1436 "isdnloop: (%s) Could not allocate card-struct.\n", id);
1439 card->interface.owner = THIS_MODULE;
1440 card->interface.channels = ISDNLOOP_BCH;
1441 card->interface.hl_hdrlen = 1; /* scratch area for storing ack flag*/
1442 card->interface.maxbufsize = 4000;
1443 card->interface.command = if_command;
1444 card->interface.writebuf_skb = if_sendbuf;
1445 card->interface.writecmd = if_writecmd;
1446 card->interface.readstat = if_readstatus;
1447 card->interface.features = ISDN_FEATURE_L2_X75I |
1455 card->ptype = ISDN_PTYPE_UNKNOWN;
1456 strlcpy(card->interface.id, id, sizeof(card->interface.id));
1457 card->msg_buf_write = card->msg_buf;
1458 card->msg_buf_read = card->msg_buf;
1459 card->msg_buf_end = &card->msg_buf[sizeof(card->msg_buf) - 1];
1461 card->l2_proto[i] = ISDN_PROTO_L2_X75I;
1462 skb_queue_head_init(&card->bqueue[i]);
1464 skb_queue_head_init(&card->dqueue);
1465 spin_lock_init(&card->isdnloop_lock);
1466 card->next = cards;
1467 cards = card;
1468 if (!register_isdn(&card->interface)) {
1472 kfree(card);
1475 card->myid = card->interface.channels;
1476 return card;
1482 isdnloop_card *card;
1484 if (!(card = isdnloop_initcard(id1))) {
1488 "isdnloop: (%s) virtual card added\n",
1489 card->interface.id);
1517 isdnloop_card *card = cards;
1522 while (card) {
1524 cmd.driver = card->myid;
1525 card->interface.statcallb(&cmd);
1527 isdnloop_free_queue(card, i);
1528 card = card->next;
1530 card = cards;
1531 while (card) {
1532 last = card;
1533 skb_queue_purge(&card->dqueue);
1534 card = card->next;