1/* 2 * Stuff used by all variants of the driver 3 * 4 * Copyright (c) 2001 by Stefan Eilers, 5 * Hansjoerg Lipp <hjlipp@web.de>, 6 * Tilman Schmidt <tilman@imap.cc>. 7 * 8 * ===================================================================== 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License as 11 * published by the Free Software Foundation; either version 2 of 12 * the License, or (at your option) any later version. 13 * ===================================================================== 14 */ 15 16#include "gigaset.h" 17 18/* == Handling of I4L IO =====================================================*/ 19 20/* writebuf_from_LL 21 * called by LL to transmit data on an open channel 22 * inserts the buffer data into the send queue and starts the transmission 23 * Note that this operation must not sleep! 24 * When the buffer is processed completely, gigaset_skb_sent() should be called. 25 * parameters: 26 * driverID driver ID as assigned by LL 27 * channel channel number 28 * ack if != 0 LL wants to be notified on completion via 29 * statcallb(ISDN_STAT_BSENT) 30 * skb skb containing data to send 31 * return value: 32 * number of accepted bytes 33 * 0 if temporarily unable to accept data (out of buffer space) 34 * <0 on error (eg. -EINVAL) 35 */ 36static int writebuf_from_LL(int driverID, int channel, int ack, 37 struct sk_buff *skb) 38{ 39 struct cardstate *cs; 40 struct bc_state *bcs; 41 unsigned len; 42 unsigned skblen; 43 44 if (!(cs = gigaset_get_cs_by_id(driverID))) { 45 err("%s: invalid driver ID (%d)", __func__, driverID); 46 return -ENODEV; 47 } 48 if (channel < 0 || channel >= cs->channels) { 49 err("%s: invalid channel ID (%d)", __func__, channel); 50 return -ENODEV; 51 } 52 bcs = &cs->bcs[channel]; 53 len = skb->len; 54 55 gig_dbg(DEBUG_LLDATA, 56 "Receiving data from LL (id: %d, ch: %d, ack: %d, sz: %d)", 57 driverID, channel, ack, len); 58 59 if (!len) { 60 if (ack) 61 notice("%s: not ACKing empty packet", __func__); 62 return 0; 63 } 64 if (len > MAX_BUF_SIZE) { 65 err("%s: packet too large (%d bytes)", __func__, len); 66 return -EINVAL; 67 } 68 69 skblen = ack ? len : 0; 70 skb->head[0] = skblen & 0xff; 71 skb->head[1] = skblen >> 8; 72 gig_dbg(DEBUG_MCMD, "skb: len=%u, skblen=%u: %02x %02x", 73 len, skblen, (unsigned) skb->head[0], (unsigned) skb->head[1]); 74 75 /* pass to device-specific module */ 76 return cs->ops->send_skb(bcs, skb); 77} 78 79void gigaset_skb_sent(struct bc_state *bcs, struct sk_buff *skb) 80{ 81 unsigned len; 82 isdn_ctrl response; 83 84 ++bcs->trans_up; 85 86 if (skb->len) 87 dev_warn(bcs->cs->dev, "%s: skb->len==%d\n", 88 __func__, skb->len); 89 90 len = (unsigned char) skb->head[0] | 91 (unsigned) (unsigned char) skb->head[1] << 8; 92 if (len) { 93 gig_dbg(DEBUG_MCMD, "ACKing to LL (id: %d, ch: %d, sz: %u)", 94 bcs->cs->myid, bcs->channel, len); 95 96 response.driver = bcs->cs->myid; 97 response.command = ISDN_STAT_BSENT; 98 response.arg = bcs->channel; 99 response.parm.length = len; 100 bcs->cs->iif.statcallb(&response); 101 } 102} 103EXPORT_SYMBOL_GPL(gigaset_skb_sent); 104 105/* This function will be called by LL to send commands 106 * NOTE: LL ignores the returned value, for commands other than ISDN_CMD_IOCTL, 107 * so don't put too much effort into it. 108 */ 109static int command_from_LL(isdn_ctrl *cntrl) 110{ 111 struct cardstate *cs = gigaset_get_cs_by_id(cntrl->driver); 112 //isdn_ctrl response; 113 //unsigned long flags; 114 struct bc_state *bcs; 115 int retval = 0; 116 struct setup_parm *sp; 117 unsigned param; 118 unsigned long flags; 119 120 gigaset_debugdrivers(); 121 122 if (!cs) { 123 warn("LL tried to access unknown device with nr. %d", 124 cntrl->driver); 125 return -ENODEV; 126 } 127 128 switch (cntrl->command) { 129 case ISDN_CMD_IOCTL: 130 gig_dbg(DEBUG_ANY, "ISDN_CMD_IOCTL (driver: %d, arg: %ld)", 131 cntrl->driver, cntrl->arg); 132 133 warn("ISDN_CMD_IOCTL is not supported."); 134 return -EINVAL; 135 136 case ISDN_CMD_DIAL: 137 gig_dbg(DEBUG_ANY, 138 "ISDN_CMD_DIAL (driver: %d, ch: %ld, " 139 "phone: %s, ownmsn: %s, si1: %d, si2: %d)", 140 cntrl->driver, cntrl->arg, 141 cntrl->parm.setup.phone, cntrl->parm.setup.eazmsn, 142 cntrl->parm.setup.si1, cntrl->parm.setup.si2); 143 144 if (cntrl->arg >= cs->channels) { 145 err("ISDN_CMD_DIAL: invalid channel (%d)", 146 (int) cntrl->arg); 147 return -EINVAL; 148 } 149 150 bcs = cs->bcs + cntrl->arg; 151 152 if (!gigaset_get_channel(bcs)) { 153 err("ISDN_CMD_DIAL: channel not free"); 154 return -EBUSY; 155 } 156 157 sp = kmalloc(sizeof *sp, GFP_ATOMIC); 158 if (!sp) { 159 gigaset_free_channel(bcs); 160 err("ISDN_CMD_DIAL: out of memory"); 161 return -ENOMEM; 162 } 163 *sp = cntrl->parm.setup; 164 165 spin_lock_irqsave(&cs->lock, flags); 166 param = bcs->at_state.seq_index; 167 spin_unlock_irqrestore(&cs->lock, flags); 168 169 if (!gigaset_add_event(cs, &bcs->at_state, EV_DIAL, sp, param, 170 NULL)) { 171 kfree(sp); 172 gigaset_free_channel(bcs); 173 return -ENOMEM; 174 } 175 176 gig_dbg(DEBUG_CMD, "scheduling DIAL"); 177 gigaset_schedule_event(cs); 178 break; 179 case ISDN_CMD_ACCEPTD: 180 gig_dbg(DEBUG_ANY, "ISDN_CMD_ACCEPTD"); 181 182 if (cntrl->arg >= cs->channels) { 183 err("ISDN_CMD_ACCEPTD: invalid channel (%d)", 184 (int) cntrl->arg); 185 return -EINVAL; 186 } 187 188 if (!gigaset_add_event(cs, &cs->bcs[cntrl->arg].at_state, 189 EV_ACCEPT, NULL, 0, NULL)) { 190 return -ENOMEM; 191 } 192 193 gig_dbg(DEBUG_CMD, "scheduling ACCEPT"); 194 gigaset_schedule_event(cs); 195 196 break; 197 case ISDN_CMD_ACCEPTB: 198 gig_dbg(DEBUG_ANY, "ISDN_CMD_ACCEPTB"); 199 break; 200 case ISDN_CMD_HANGUP: 201 gig_dbg(DEBUG_ANY, "ISDN_CMD_HANGUP (ch: %d)", 202 (int) cntrl->arg); 203 204 if (cntrl->arg >= cs->channels) { 205 err("ISDN_CMD_HANGUP: invalid channel (%u)", 206 (unsigned) cntrl->arg); 207 return -EINVAL; 208 } 209 210 if (!gigaset_add_event(cs, &cs->bcs[cntrl->arg].at_state, 211 EV_HUP, NULL, 0, NULL)) { 212 return -ENOMEM; 213 } 214 215 gig_dbg(DEBUG_CMD, "scheduling HUP"); 216 gigaset_schedule_event(cs); 217 218 break; 219 case ISDN_CMD_CLREAZ: /* Do not signal incoming signals */ 220 gig_dbg(DEBUG_ANY, "ISDN_CMD_CLREAZ"); 221 break; 222 case ISDN_CMD_SETEAZ: /* Signal incoming calls for given MSN */ 223 gig_dbg(DEBUG_ANY, 224 "ISDN_CMD_SETEAZ (id: %d, ch: %ld, number: %s)", 225 cntrl->driver, cntrl->arg, cntrl->parm.num); 226 break; 227 case ISDN_CMD_SETL2: /* Set L2 to given protocol */ 228 gig_dbg(DEBUG_ANY, "ISDN_CMD_SETL2 (ch: %ld, proto: %lx)", 229 cntrl->arg & 0xff, (cntrl->arg >> 8)); 230 231 if ((cntrl->arg & 0xff) >= cs->channels) { 232 err("ISDN_CMD_SETL2: invalid channel (%u)", 233 (unsigned) cntrl->arg & 0xff); 234 return -EINVAL; 235 } 236 237 if (!gigaset_add_event(cs, &cs->bcs[cntrl->arg & 0xff].at_state, 238 EV_PROTO_L2, NULL, cntrl->arg >> 8, 239 NULL)) { 240 return -ENOMEM; 241 } 242 243 gig_dbg(DEBUG_CMD, "scheduling PROTO_L2"); 244 gigaset_schedule_event(cs); 245 break; 246 case ISDN_CMD_SETL3: /* Set L3 to given protocol */ 247 gig_dbg(DEBUG_ANY, "ISDN_CMD_SETL3 (ch: %ld, proto: %lx)", 248 cntrl->arg & 0xff, (cntrl->arg >> 8)); 249 250 if ((cntrl->arg & 0xff) >= cs->channels) { 251 err("ISDN_CMD_SETL3: invalid channel (%u)", 252 (unsigned) cntrl->arg & 0xff); 253 return -EINVAL; 254 } 255 256 if (cntrl->arg >> 8 != ISDN_PROTO_L3_TRANS) { 257 err("ISDN_CMD_SETL3: invalid protocol %lu", 258 cntrl->arg >> 8); 259 return -EINVAL; 260 } 261 262 break; 263 case ISDN_CMD_PROCEED: 264 gig_dbg(DEBUG_ANY, "ISDN_CMD_PROCEED"); 265 break; 266 case ISDN_CMD_ALERT: 267 gig_dbg(DEBUG_ANY, "ISDN_CMD_ALERT"); 268 if (cntrl->arg >= cs->channels) { 269 err("ISDN_CMD_ALERT: invalid channel (%d)", 270 (int) cntrl->arg); 271 return -EINVAL; 272 } 273 //bcs = cs->bcs + cntrl->arg; 274 //bcs->proto2 = -1; 275 break; 276 case ISDN_CMD_REDIR: 277 gig_dbg(DEBUG_ANY, "ISDN_CMD_REDIR"); 278 break; 279 case ISDN_CMD_PROT_IO: 280 gig_dbg(DEBUG_ANY, "ISDN_CMD_PROT_IO"); 281 break; 282 case ISDN_CMD_FAXCMD: 283 gig_dbg(DEBUG_ANY, "ISDN_CMD_FAXCMD"); 284 break; 285 case ISDN_CMD_GETL2: 286 gig_dbg(DEBUG_ANY, "ISDN_CMD_GETL2"); 287 break; 288 case ISDN_CMD_GETL3: 289 gig_dbg(DEBUG_ANY, "ISDN_CMD_GETL3"); 290 break; 291 case ISDN_CMD_GETEAZ: 292 gig_dbg(DEBUG_ANY, "ISDN_CMD_GETEAZ"); 293 break; 294 case ISDN_CMD_SETSIL: 295 gig_dbg(DEBUG_ANY, "ISDN_CMD_SETSIL"); 296 break; 297 case ISDN_CMD_GETSIL: 298 gig_dbg(DEBUG_ANY, "ISDN_CMD_GETSIL"); 299 break; 300 default: 301 err("unknown command %d from LL", cntrl->command); 302 return -EINVAL; 303 } 304 305 return retval; 306} 307 308void gigaset_i4l_cmd(struct cardstate *cs, int cmd) 309{ 310 isdn_ctrl command; 311 312 command.driver = cs->myid; 313 command.command = cmd; 314 command.arg = 0; 315 cs->iif.statcallb(&command); 316} 317 318void gigaset_i4l_channel_cmd(struct bc_state *bcs, int cmd) 319{ 320 isdn_ctrl command; 321 322 command.driver = bcs->cs->myid; 323 command.command = cmd; 324 command.arg = bcs->channel; 325 bcs->cs->iif.statcallb(&command); 326} 327 328int gigaset_isdn_setup_dial(struct at_state_t *at_state, void *data) 329{ 330 struct bc_state *bcs = at_state->bcs; 331 unsigned proto; 332 const char *bc; 333 size_t length[AT_NUM]; 334 size_t l; 335 int i; 336 struct setup_parm *sp = data; 337 338 switch (bcs->proto2) { 339 case ISDN_PROTO_L2_HDLC: 340 proto = 1; /* 0: Bitsynchron, 1: HDLC, 2: voice */ 341 break; 342 case ISDN_PROTO_L2_TRANS: 343 proto = 2; /* 0: Bitsynchron, 1: HDLC, 2: voice */ 344 break; 345 default: 346 dev_err(bcs->cs->dev, "%s: invalid L2 protocol: %u\n", 347 __func__, bcs->proto2); 348 return -EINVAL; 349 } 350 351 switch (sp->si1) { 352 case 1: /* audio */ 353 bc = "9090A3"; /* 3.1 kHz audio, A-law */ 354 break; 355 case 7: /* data */ 356 default: /* hope the app knows what it is doing */ 357 bc = "8890"; /* unrestricted digital information */ 358 } 359 360 length[AT_DIAL ] = 1 + strlen(sp->phone) + 1 + 1; 361 l = strlen(sp->eazmsn); 362 length[AT_MSN ] = l ? 6 + l + 1 + 1 : 0; 363 length[AT_BC ] = 5 + strlen(bc) + 1 + 1; 364 length[AT_PROTO] = 6 + 1 + 1 + 1; /* proto: 1 character */ 365 length[AT_ISO ] = 6 + 1 + 1 + 1; /* channel: 1 character */ 366 length[AT_TYPE ] = 6 + 1 + 1 + 1; /* call type: 1 character */ 367 length[AT_HLC ] = 0; 368 369 for (i = 0; i < AT_NUM; ++i) { 370 kfree(bcs->commands[i]); 371 bcs->commands[i] = NULL; 372 if (length[i] && 373 !(bcs->commands[i] = kmalloc(length[i], GFP_ATOMIC))) { 374 dev_err(bcs->cs->dev, "out of memory\n"); 375 return -ENOMEM; 376 } 377 } 378 379 /* type = 1: extern, 0: intern, 2: recall, 3: door, 4: centrex */ 380 if (sp->phone[0] == '*' && sp->phone[1] == '*') { 381 /* internal call: translate ** prefix to CTP value */ 382 snprintf(bcs->commands[AT_DIAL], length[AT_DIAL], 383 "D%s\r", sp->phone+2); 384 strncpy(bcs->commands[AT_TYPE], "^SCTP=0\r", length[AT_TYPE]); 385 } else { 386 snprintf(bcs->commands[AT_DIAL], length[AT_DIAL], 387 "D%s\r", sp->phone); 388 strncpy(bcs->commands[AT_TYPE], "^SCTP=1\r", length[AT_TYPE]); 389 } 390 391 if (bcs->commands[AT_MSN]) 392 snprintf(bcs->commands[AT_MSN], length[AT_MSN], 393 "^SMSN=%s\r", sp->eazmsn); 394 snprintf(bcs->commands[AT_BC ], length[AT_BC ], 395 "^SBC=%s\r", bc); 396 snprintf(bcs->commands[AT_PROTO], length[AT_PROTO], 397 "^SBPR=%u\r", proto); 398 snprintf(bcs->commands[AT_ISO ], length[AT_ISO ], 399 "^SISO=%u\r", (unsigned)bcs->channel + 1); 400 401 return 0; 402} 403 404int gigaset_isdn_setup_accept(struct at_state_t *at_state) 405{ 406 unsigned proto; 407 size_t length[AT_NUM]; 408 int i; 409 struct bc_state *bcs = at_state->bcs; 410 411 switch (bcs->proto2) { 412 case ISDN_PROTO_L2_HDLC: 413 proto = 1; /* 0: Bitsynchron, 1: HDLC, 2: voice */ 414 break; 415 case ISDN_PROTO_L2_TRANS: 416 proto = 2; /* 0: Bitsynchron, 1: HDLC, 2: voice */ 417 break; 418 default: 419 dev_err(at_state->cs->dev, "%s: invalid protocol: %u\n", 420 __func__, bcs->proto2); 421 return -EINVAL; 422 } 423 424 length[AT_DIAL ] = 0; 425 length[AT_MSN ] = 0; 426 length[AT_BC ] = 0; 427 length[AT_PROTO] = 6 + 1 + 1 + 1; /* proto: 1 character */ 428 length[AT_ISO ] = 6 + 1 + 1 + 1; /* channel: 1 character */ 429 length[AT_TYPE ] = 0; 430 length[AT_HLC ] = 0; 431 432 for (i = 0; i < AT_NUM; ++i) { 433 kfree(bcs->commands[i]); 434 bcs->commands[i] = NULL; 435 if (length[i] && 436 !(bcs->commands[i] = kmalloc(length[i], GFP_ATOMIC))) { 437 dev_err(at_state->cs->dev, "out of memory\n"); 438 return -ENOMEM; 439 } 440 } 441 442 snprintf(bcs->commands[AT_PROTO], length[AT_PROTO], 443 "^SBPR=%u\r", proto); 444 snprintf(bcs->commands[AT_ISO ], length[AT_ISO ], 445 "^SISO=%u\r", (unsigned) bcs->channel + 1); 446 447 return 0; 448} 449 450int gigaset_isdn_icall(struct at_state_t *at_state) 451{ 452 struct cardstate *cs = at_state->cs; 453 struct bc_state *bcs = at_state->bcs; 454 isdn_ctrl response; 455 int retval; 456 457 /* fill ICALL structure */ 458 response.parm.setup.si1 = 0; /* default: unknown */ 459 response.parm.setup.si2 = 0; 460 response.parm.setup.screen = 0; 461 response.parm.setup.plan = 0; 462 if (!at_state->str_var[STR_ZBC]) { 463 /* no BC (internal call): assume speech, A-law */ 464 response.parm.setup.si1 = 1; 465 } else if (!strcmp(at_state->str_var[STR_ZBC], "8890")) { 466 /* unrestricted digital information */ 467 response.parm.setup.si1 = 7; 468 } else if (!strcmp(at_state->str_var[STR_ZBC], "8090A3")) { 469 /* speech, A-law */ 470 response.parm.setup.si1 = 1; 471 } else if (!strcmp(at_state->str_var[STR_ZBC], "9090A3")) { 472 /* 3,1 kHz audio, A-law */ 473 response.parm.setup.si1 = 1; 474 response.parm.setup.si2 = 2; 475 } else { 476 dev_warn(cs->dev, "RING ignored - unsupported BC %s\n", 477 at_state->str_var[STR_ZBC]); 478 return ICALL_IGNORE; 479 } 480 if (at_state->str_var[STR_NMBR]) { 481 strncpy(response.parm.setup.phone, at_state->str_var[STR_NMBR], 482 sizeof response.parm.setup.phone - 1); 483 response.parm.setup.phone[sizeof response.parm.setup.phone - 1] = 0; 484 } else 485 response.parm.setup.phone[0] = 0; 486 if (at_state->str_var[STR_ZCPN]) { 487 strncpy(response.parm.setup.eazmsn, at_state->str_var[STR_ZCPN], 488 sizeof response.parm.setup.eazmsn - 1); 489 response.parm.setup.eazmsn[sizeof response.parm.setup.eazmsn - 1] = 0; 490 } else 491 response.parm.setup.eazmsn[0] = 0; 492 493 if (!bcs) { 494 dev_notice(cs->dev, "no channel for incoming call\n"); 495 response.command = ISDN_STAT_ICALLW; 496 response.arg = 0; 497 } else { 498 gig_dbg(DEBUG_CMD, "Sending ICALL"); 499 response.command = ISDN_STAT_ICALL; 500 response.arg = bcs->channel; 501 } 502 response.driver = cs->myid; 503 retval = cs->iif.statcallb(&response); 504 gig_dbg(DEBUG_CMD, "Response: %d", retval); 505 switch (retval) { 506 case 0: /* no takers */ 507 return ICALL_IGNORE; 508 case 1: /* alerting */ 509 bcs->chstate |= CHS_NOTIFY_LL; 510 return ICALL_ACCEPT; 511 case 2: /* reject */ 512 return ICALL_REJECT; 513 case 3: /* incomplete */ 514 dev_warn(cs->dev, 515 "LL requested unsupported feature: Incomplete Number\n"); 516 return ICALL_IGNORE; 517 case 4: /* proceeding */ 518 /* Gigaset will send ALERTING anyway. 519 * There doesn't seem to be a way to avoid this. 520 */ 521 return ICALL_ACCEPT; 522 case 5: /* deflect */ 523 dev_warn(cs->dev, 524 "LL requested unsupported feature: Call Deflection\n"); 525 return ICALL_IGNORE; 526 default: 527 dev_err(cs->dev, "LL error %d on ICALL\n", retval); 528 return ICALL_IGNORE; 529 } 530} 531 532/* Set Callback function pointer */ 533int gigaset_register_to_LL(struct cardstate *cs, const char *isdnid) 534{ 535 isdn_if *iif = &cs->iif; 536 537 gig_dbg(DEBUG_ANY, "Register driver capabilities to LL"); 538 539 //iif->id[sizeof(iif->id) - 1]=0; 540 //strncpy(iif->id, isdnid, sizeof(iif->id) - 1); 541 if (snprintf(iif->id, sizeof iif->id, "%s_%u", isdnid, cs->minor_index) 542 >= sizeof iif->id) 543 return -ENOMEM; 544 545 iif->owner = THIS_MODULE; 546 iif->channels = cs->channels; 547 iif->maxbufsize = MAX_BUF_SIZE; 548 iif->features = ISDN_FEATURE_L2_TRANS | 549 ISDN_FEATURE_L2_HDLC | 550#ifdef GIG_X75 551 ISDN_FEATURE_L2_X75I | 552#endif 553 ISDN_FEATURE_L3_TRANS | 554 ISDN_FEATURE_P_EURO; 555 iif->hl_hdrlen = HW_HDR_LEN; /* Area for storing ack */ 556 iif->command = command_from_LL; 557 iif->writebuf_skb = writebuf_from_LL; 558 iif->writecmd = NULL; /* Don't support isdnctrl */ 559 iif->readstat = NULL; /* Don't support isdnctrl */ 560 iif->rcvcallb_skb = NULL; /* Will be set by LL */ 561 iif->statcallb = NULL; /* Will be set by LL */ 562 563 if (!register_isdn(iif)) 564 return 0; 565 566 cs->myid = iif->channels; /* Set my device id */ 567 return 1; 568} 569