]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/isdn/gigaset/i4l.c
2 * Stuff used by all variants of the driver
4 * Copyright (c) 2001 by Stefan Eilers,
5 * Hansjoerg Lipp <hjlipp@web.de>,
6 * Tilman Schmidt <tilman@imap.cc>.
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 * =====================================================================
17 #include <linux/isdnif.h>
19 #define HW_HDR_LEN 2 /* Header size used to store ack info */
21 /* == Handling of I4L IO =====================================================*/
24 * called by LL to transmit data on an open channel
25 * inserts the buffer data into the send queue and starts the transmission
26 * Note that this operation must not sleep!
27 * When the buffer is processed completely, gigaset_skb_sent() should be called.
29 * driverID driver ID as assigned by LL
30 * channel channel number
31 * ack if != 0 LL wants to be notified on completion via
32 * statcallb(ISDN_STAT_BSENT)
33 * skb skb containing data to send
35 * number of accepted bytes
36 * 0 if temporarily unable to accept data (out of buffer space)
37 * <0 on error (eg. -EINVAL)
39 static int writebuf_from_LL(int driverID
, int channel
, int ack
,
42 struct cardstate
*cs
= gigaset_get_cs_by_id(driverID
);
44 unsigned char *ack_header
;
48 pr_err("%s: invalid driver ID (%d)\n", __func__
, driverID
);
51 if (channel
< 0 || channel
>= cs
->channels
) {
52 dev_err(cs
->dev
, "%s: invalid channel ID (%d)\n",
56 bcs
= &cs
->bcs
[channel
];
58 /* can only handle linear sk_buffs */
59 if (skb_linearize(skb
) < 0) {
60 dev_err(cs
->dev
, "%s: skb_linearize failed\n", __func__
);
66 "Receiving data from LL (id: %d, ch: %d, ack: %d, sz: %d)",
67 driverID
, channel
, ack
, len
);
71 dev_notice(cs
->dev
, "%s: not ACKing empty packet\n",
75 if (len
> MAX_BUF_SIZE
) {
76 dev_err(cs
->dev
, "%s: packet too large (%d bytes)\n",
81 /* set up acknowledgement header */
82 if (skb_headroom(skb
) < HW_HDR_LEN
) {
83 /* should never happen */
84 dev_err(cs
->dev
, "%s: insufficient skb headroom\n", __func__
);
87 skb_set_mac_header(skb
, -HW_HDR_LEN
);
88 skb
->mac_len
= HW_HDR_LEN
;
89 ack_header
= skb_mac_header(skb
);
91 ack_header
[0] = len
& 0xff;
92 ack_header
[1] = len
>> 8;
94 ack_header
[0] = ack_header
[1] = 0;
96 gig_dbg(DEBUG_MCMD
, "skb: len=%u, ack=%d: %02x %02x",
97 len
, ack
, ack_header
[0], ack_header
[1]);
99 /* pass to device-specific module */
100 return cs
->ops
->send_skb(bcs
, skb
);
104 * gigaset_skb_sent() - acknowledge sending an skb
105 * @bcs: B channel descriptor structure.
108 * Called by hardware module {bas,ser,usb}_gigaset when the data in a
109 * skb has been successfully sent, for signalling completion to the LL.
111 void gigaset_skb_sent(struct bc_state
*bcs
, struct sk_buff
*skb
)
113 isdn_if
*iif
= bcs
->cs
->iif
;
114 unsigned char *ack_header
= skb_mac_header(skb
);
121 dev_warn(bcs
->cs
->dev
, "%s: skb->len==%d\n",
124 len
= ack_header
[0] + ((unsigned) ack_header
[1] << 8);
126 gig_dbg(DEBUG_MCMD
, "ACKing to LL (id: %d, ch: %d, sz: %u)",
127 bcs
->cs
->myid
, bcs
->channel
, len
);
129 response
.driver
= bcs
->cs
->myid
;
130 response
.command
= ISDN_STAT_BSENT
;
131 response
.arg
= bcs
->channel
;
132 response
.parm
.length
= len
;
133 iif
->statcallb(&response
);
136 EXPORT_SYMBOL_GPL(gigaset_skb_sent
);
139 * gigaset_skb_rcvd() - pass received skb to LL
140 * @bcs: B channel descriptor structure.
141 * @skb: received data.
143 * Called by hardware module {bas,ser,usb}_gigaset when user data has
144 * been successfully received, for passing to the LL.
145 * Warning: skb must not be accessed anymore!
147 void gigaset_skb_rcvd(struct bc_state
*bcs
, struct sk_buff
*skb
)
149 isdn_if
*iif
= bcs
->cs
->iif
;
151 iif
->rcvcallb_skb(bcs
->cs
->myid
, bcs
->channel
, skb
);
154 EXPORT_SYMBOL_GPL(gigaset_skb_rcvd
);
157 * gigaset_isdn_rcv_err() - signal receive error
158 * @bcs: B channel descriptor structure.
160 * Called by hardware module {bas,ser,usb}_gigaset when a receive error
161 * has occurred, for signalling to the LL.
163 void gigaset_isdn_rcv_err(struct bc_state
*bcs
)
165 isdn_if
*iif
= bcs
->cs
->iif
;
168 /* if currently ignoring packets, just count down */
174 /* update statistics */
178 gig_dbg(DEBUG_CMD
, "sending L1ERR");
179 response
.driver
= bcs
->cs
->myid
;
180 response
.command
= ISDN_STAT_L1ERR
;
181 response
.arg
= bcs
->channel
;
182 response
.parm
.errcode
= ISDN_STAT_L1ERR_RECV
;
183 iif
->statcallb(&response
);
185 EXPORT_SYMBOL_GPL(gigaset_isdn_rcv_err
);
187 /* This function will be called by LL to send commands
188 * NOTE: LL ignores the returned value, for commands other than ISDN_CMD_IOCTL,
189 * so don't put too much effort into it.
191 static int command_from_LL(isdn_ctrl
*cntrl
)
193 struct cardstate
*cs
;
194 struct bc_state
*bcs
;
201 gigaset_debugdrivers();
203 gig_dbg(DEBUG_CMD
, "driver: %d, command: %d, arg: 0x%lx",
204 cntrl
->driver
, cntrl
->command
, cntrl
->arg
);
206 cs
= gigaset_get_cs_by_id(cntrl
->driver
);
208 pr_err("%s: invalid driver ID (%d)\n", __func__
, cntrl
->driver
);
211 ch
= cntrl
->arg
& 0xff;
213 switch (cntrl
->command
) {
215 dev_warn(cs
->dev
, "ISDN_CMD_IOCTL not supported\n");
220 "ISDN_CMD_DIAL (phone: %s, msn: %s, si1: %d, si2: %d)",
221 cntrl
->parm
.setup
.phone
, cntrl
->parm
.setup
.eazmsn
,
222 cntrl
->parm
.setup
.si1
, cntrl
->parm
.setup
.si2
);
224 if (ch
>= cs
->channels
) {
226 "ISDN_CMD_DIAL: invalid channel (%d)\n", ch
);
230 if (!gigaset_get_channel(bcs
)) {
231 dev_err(cs
->dev
, "ISDN_CMD_DIAL: channel not free\n");
235 commands
= kzalloc(AT_NUM
*(sizeof *commands
), GFP_ATOMIC
);
237 gigaset_free_channel(bcs
);
238 dev_err(cs
->dev
, "ISDN_CMD_DIAL: out of memory\n");
242 l
= 3 + strlen(cntrl
->parm
.setup
.phone
);
243 commands
[AT_DIAL
] = kmalloc(l
, GFP_ATOMIC
);
244 if (!commands
[AT_DIAL
])
246 if (cntrl
->parm
.setup
.phone
[0] == '*' &&
247 cntrl
->parm
.setup
.phone
[1] == '*') {
248 /* internal call: translate ** prefix to CTP value */
249 commands
[AT_TYPE
] = kstrdup("^SCTP=0\r", GFP_ATOMIC
);
250 if (!commands
[AT_TYPE
])
252 snprintf(commands
[AT_DIAL
], l
,
253 "D%s\r", cntrl
->parm
.setup
.phone
+2);
255 commands
[AT_TYPE
] = kstrdup("^SCTP=1\r", GFP_ATOMIC
);
256 if (!commands
[AT_TYPE
])
258 snprintf(commands
[AT_DIAL
], l
,
259 "D%s\r", cntrl
->parm
.setup
.phone
);
262 l
= strlen(cntrl
->parm
.setup
.eazmsn
);
265 commands
[AT_MSN
] = kmalloc(l
, GFP_ATOMIC
);
266 if (!commands
[AT_MSN
])
268 snprintf(commands
[AT_MSN
], l
, "^SMSN=%s\r",
269 cntrl
->parm
.setup
.eazmsn
);
272 switch (cntrl
->parm
.setup
.si1
) {
274 /* BC = 9090A3: 3.1 kHz audio, A-law */
275 commands
[AT_BC
] = kstrdup("^SBC=9090A3\r", GFP_ATOMIC
);
276 if (!commands
[AT_BC
])
280 default: /* hope the app knows what it is doing */
281 /* BC = 8890: unrestricted digital information */
282 commands
[AT_BC
] = kstrdup("^SBC=8890\r", GFP_ATOMIC
);
283 if (!commands
[AT_BC
])
286 /* ToDo: other si1 values, inspect si2, set HLC/LLC */
288 commands
[AT_PROTO
] = kmalloc(9, GFP_ATOMIC
);
289 if (!commands
[AT_PROTO
])
291 snprintf(commands
[AT_PROTO
], 9, "^SBPR=%u\r", bcs
->proto2
);
293 commands
[AT_ISO
] = kmalloc(9, GFP_ATOMIC
);
294 if (!commands
[AT_ISO
])
296 snprintf(commands
[AT_ISO
], 9, "^SISO=%u\r",
297 (unsigned) bcs
->channel
+ 1);
299 if (!gigaset_add_event(cs
, &bcs
->at_state
, EV_DIAL
, commands
,
300 bcs
->at_state
.seq_index
, NULL
)) {
301 for (i
= 0; i
< AT_NUM
; ++i
)
304 gigaset_free_channel(bcs
);
308 gig_dbg(DEBUG_CMD
, "scheduling DIAL");
309 gigaset_schedule_event(cs
);
311 case ISDN_CMD_ACCEPTD
:
312 if (ch
>= cs
->channels
) {
314 "ISDN_CMD_ACCEPTD: invalid channel (%d)\n", ch
);
318 if (!gigaset_add_event(cs
, &bcs
->at_state
,
319 EV_ACCEPT
, NULL
, 0, NULL
))
322 gig_dbg(DEBUG_CMD
, "scheduling ACCEPT");
323 gigaset_schedule_event(cs
);
326 case ISDN_CMD_ACCEPTB
:
328 case ISDN_CMD_HANGUP
:
329 if (ch
>= cs
->channels
) {
331 "ISDN_CMD_HANGUP: invalid channel (%d)\n", ch
);
335 if (!gigaset_add_event(cs
, &bcs
->at_state
,
336 EV_HUP
, NULL
, 0, NULL
))
339 gig_dbg(DEBUG_CMD
, "scheduling HUP");
340 gigaset_schedule_event(cs
);
343 case ISDN_CMD_CLREAZ
: /* Do not signal incoming signals */
344 dev_info(cs
->dev
, "ignoring ISDN_CMD_CLREAZ\n");
346 case ISDN_CMD_SETEAZ
: /* Signal incoming calls for given MSN */
347 dev_info(cs
->dev
, "ignoring ISDN_CMD_SETEAZ (%s)\n",
350 case ISDN_CMD_SETL2
: /* Set L2 to given protocol */
351 if (ch
>= cs
->channels
) {
353 "ISDN_CMD_SETL2: invalid channel (%d)\n", ch
);
357 if (bcs
->chstate
& CHS_D_UP
) {
359 "ISDN_CMD_SETL2: channel active (%d)\n", ch
);
362 switch (cntrl
->arg
>> 8) {
363 case ISDN_PROTO_L2_HDLC
:
364 gig_dbg(DEBUG_CMD
, "ISDN_CMD_SETL2: setting L2_HDLC");
365 bcs
->proto2
= L2_HDLC
;
367 case ISDN_PROTO_L2_TRANS
:
368 gig_dbg(DEBUG_CMD
, "ISDN_CMD_SETL2: setting L2_VOICE");
369 bcs
->proto2
= L2_VOICE
;
373 "ISDN_CMD_SETL2: unsupported protocol (%lu)\n",
378 case ISDN_CMD_SETL3
: /* Set L3 to given protocol */
379 if (ch
>= cs
->channels
) {
381 "ISDN_CMD_SETL3: invalid channel (%d)\n", ch
);
385 if (cntrl
->arg
>> 8 != ISDN_PROTO_L3_TRANS
) {
387 "ISDN_CMD_SETL3: unsupported protocol (%lu)\n",
393 case ISDN_CMD_PROCEED
:
394 gig_dbg(DEBUG_ANY
, "ISDN_CMD_PROCEED");
397 gig_dbg(DEBUG_ANY
, "ISDN_CMD_ALERT");
398 if (cntrl
->arg
>= cs
->channels
) {
400 "ISDN_CMD_ALERT: invalid channel (%d)\n",
406 gig_dbg(DEBUG_ANY
, "ISDN_CMD_REDIR");
408 case ISDN_CMD_PROT_IO
:
409 gig_dbg(DEBUG_ANY
, "ISDN_CMD_PROT_IO");
411 case ISDN_CMD_FAXCMD
:
412 gig_dbg(DEBUG_ANY
, "ISDN_CMD_FAXCMD");
415 gig_dbg(DEBUG_ANY
, "ISDN_CMD_GETL2");
418 gig_dbg(DEBUG_ANY
, "ISDN_CMD_GETL3");
420 case ISDN_CMD_GETEAZ
:
421 gig_dbg(DEBUG_ANY
, "ISDN_CMD_GETEAZ");
423 case ISDN_CMD_SETSIL
:
424 gig_dbg(DEBUG_ANY
, "ISDN_CMD_SETSIL");
426 case ISDN_CMD_GETSIL
:
427 gig_dbg(DEBUG_ANY
, "ISDN_CMD_GETSIL");
430 dev_err(cs
->dev
, "unknown command %d from LL\n",
438 dev_err(bcs
->cs
->dev
, "out of memory\n");
439 for (i
= 0; i
< AT_NUM
; ++i
)
444 static void gigaset_i4l_cmd(struct cardstate
*cs
, int cmd
)
446 isdn_if
*iif
= cs
->iif
;
449 command
.driver
= cs
->myid
;
450 command
.command
= cmd
;
452 iif
->statcallb(&command
);
455 static void gigaset_i4l_channel_cmd(struct bc_state
*bcs
, int cmd
)
457 isdn_if
*iif
= bcs
->cs
->iif
;
460 command
.driver
= bcs
->cs
->myid
;
461 command
.command
= cmd
;
462 command
.arg
= bcs
->channel
;
463 iif
->statcallb(&command
);
467 * gigaset_isdn_icall() - signal incoming call
468 * @at_state: connection state structure.
470 * Called by main module to notify the LL that an incoming call has been
471 * received. @at_state contains the parameters of the call.
473 * Return value: call disposition (ICALL_*)
475 int gigaset_isdn_icall(struct at_state_t
*at_state
)
477 struct cardstate
*cs
= at_state
->cs
;
478 struct bc_state
*bcs
= at_state
->bcs
;
479 isdn_if
*iif
= cs
->iif
;
483 /* fill ICALL structure */
484 response
.parm
.setup
.si1
= 0; /* default: unknown */
485 response
.parm
.setup
.si2
= 0;
486 response
.parm
.setup
.screen
= 0;
487 response
.parm
.setup
.plan
= 0;
488 if (!at_state
->str_var
[STR_ZBC
]) {
489 /* no BC (internal call): assume speech, A-law */
490 response
.parm
.setup
.si1
= 1;
491 } else if (!strcmp(at_state
->str_var
[STR_ZBC
], "8890")) {
492 /* unrestricted digital information */
493 response
.parm
.setup
.si1
= 7;
494 } else if (!strcmp(at_state
->str_var
[STR_ZBC
], "8090A3")) {
496 response
.parm
.setup
.si1
= 1;
497 } else if (!strcmp(at_state
->str_var
[STR_ZBC
], "9090A3")) {
498 /* 3,1 kHz audio, A-law */
499 response
.parm
.setup
.si1
= 1;
500 response
.parm
.setup
.si2
= 2;
502 dev_warn(cs
->dev
, "RING ignored - unsupported BC %s\n",
503 at_state
->str_var
[STR_ZBC
]);
506 if (at_state
->str_var
[STR_NMBR
]) {
507 strlcpy(response
.parm
.setup
.phone
, at_state
->str_var
[STR_NMBR
],
508 sizeof response
.parm
.setup
.phone
);
510 response
.parm
.setup
.phone
[0] = 0;
511 if (at_state
->str_var
[STR_ZCPN
]) {
512 strlcpy(response
.parm
.setup
.eazmsn
, at_state
->str_var
[STR_ZCPN
],
513 sizeof response
.parm
.setup
.eazmsn
);
515 response
.parm
.setup
.eazmsn
[0] = 0;
518 dev_notice(cs
->dev
, "no channel for incoming call\n");
519 response
.command
= ISDN_STAT_ICALLW
;
522 gig_dbg(DEBUG_CMD
, "Sending ICALL");
523 response
.command
= ISDN_STAT_ICALL
;
524 response
.arg
= bcs
->channel
;
526 response
.driver
= cs
->myid
;
527 retval
= iif
->statcallb(&response
);
528 gig_dbg(DEBUG_CMD
, "Response: %d", retval
);
530 case 0: /* no takers */
532 case 1: /* alerting */
533 bcs
->chstate
|= CHS_NOTIFY_LL
;
537 case 3: /* incomplete */
539 "LL requested unsupported feature: Incomplete Number\n");
541 case 4: /* proceeding */
542 /* Gigaset will send ALERTING anyway.
543 * There doesn't seem to be a way to avoid this.
546 case 5: /* deflect */
548 "LL requested unsupported feature: Call Deflection\n");
551 dev_err(cs
->dev
, "LL error %d on ICALL\n", retval
);
557 * gigaset_isdn_connD() - signal D channel connect
558 * @bcs: B channel descriptor structure.
560 * Called by main module to notify the LL that the D channel connection has
563 void gigaset_isdn_connD(struct bc_state
*bcs
)
565 gig_dbg(DEBUG_CMD
, "sending DCONN");
566 gigaset_i4l_channel_cmd(bcs
, ISDN_STAT_DCONN
);
570 * gigaset_isdn_hupD() - signal D channel hangup
571 * @bcs: B channel descriptor structure.
573 * Called by main module to notify the LL that the D channel connection has
576 void gigaset_isdn_hupD(struct bc_state
*bcs
)
578 gig_dbg(DEBUG_CMD
, "sending DHUP");
579 gigaset_i4l_channel_cmd(bcs
, ISDN_STAT_DHUP
);
583 * gigaset_isdn_connB() - signal B channel connect
584 * @bcs: B channel descriptor structure.
586 * Called by main module to notify the LL that the B channel connection has
589 void gigaset_isdn_connB(struct bc_state
*bcs
)
591 gig_dbg(DEBUG_CMD
, "sending BCONN");
592 gigaset_i4l_channel_cmd(bcs
, ISDN_STAT_BCONN
);
596 * gigaset_isdn_hupB() - signal B channel hangup
597 * @bcs: B channel descriptor structure.
599 * Called by main module to notify the LL that the B channel connection has
602 void gigaset_isdn_hupB(struct bc_state
*bcs
)
604 gig_dbg(DEBUG_CMD
, "sending BHUP");
605 gigaset_i4l_channel_cmd(bcs
, ISDN_STAT_BHUP
);
609 * gigaset_isdn_start() - signal device availability
610 * @cs: device descriptor structure.
612 * Called by main module to notify the LL that the device is available for
615 void gigaset_isdn_start(struct cardstate
*cs
)
617 gig_dbg(DEBUG_CMD
, "sending RUN");
618 gigaset_i4l_cmd(cs
, ISDN_STAT_RUN
);
622 * gigaset_isdn_stop() - signal device unavailability
623 * @cs: device descriptor structure.
625 * Called by main module to notify the LL that the device is no longer
628 void gigaset_isdn_stop(struct cardstate
*cs
)
630 gig_dbg(DEBUG_CMD
, "sending STOP");
631 gigaset_i4l_cmd(cs
, ISDN_STAT_STOP
);
635 * gigaset_isdn_register() - register to LL
636 * @cs: device descriptor structure.
637 * @isdnid: device name.
639 * Called by main module to register the device with the LL.
641 * Return value: 1 for success, 0 for failure
643 int gigaset_isdn_register(struct cardstate
*cs
, const char *isdnid
)
647 pr_info("ISDN4Linux interface\n");
649 iif
= kmalloc(sizeof *iif
, GFP_KERNEL
);
651 pr_err("out of memory\n");
655 if (snprintf(iif
->id
, sizeof iif
->id
, "%s_%u", isdnid
, cs
->minor_index
)
657 pr_err("ID too long: %s\n", isdnid
);
662 iif
->owner
= THIS_MODULE
;
663 iif
->channels
= cs
->channels
;
664 iif
->maxbufsize
= MAX_BUF_SIZE
;
665 iif
->features
= ISDN_FEATURE_L2_TRANS
|
666 ISDN_FEATURE_L2_HDLC
|
668 ISDN_FEATURE_L2_X75I
|
670 ISDN_FEATURE_L3_TRANS
|
672 iif
->hl_hdrlen
= HW_HDR_LEN
; /* Area for storing ack */
673 iif
->command
= command_from_LL
;
674 iif
->writebuf_skb
= writebuf_from_LL
;
675 iif
->writecmd
= NULL
; /* Don't support isdnctrl */
676 iif
->readstat
= NULL
; /* Don't support isdnctrl */
677 iif
->rcvcallb_skb
= NULL
; /* Will be set by LL */
678 iif
->statcallb
= NULL
; /* Will be set by LL */
680 if (!register_isdn(iif
)) {
681 pr_err("register_isdn failed\n");
687 cs
->myid
= iif
->channels
; /* Set my device id */
688 cs
->hw_hdr_len
= HW_HDR_LEN
;
693 * gigaset_isdn_unregister() - unregister from LL
694 * @cs: device descriptor structure.
696 * Called by main module to unregister the device from the LL.
698 void gigaset_isdn_unregister(struct cardstate
*cs
)
700 gig_dbg(DEBUG_CMD
, "sending UNLOAD");
701 gigaset_i4l_cmd(cs
, ISDN_STAT_UNLOAD
);