1/* 2 * Siemens Gigaset 307x driver 3 * Common header file for all connection variants 4 * 5 * Written by Stefan Eilers 6 * and Hansjoerg Lipp <hjlipp@web.de> 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#ifndef GIGASET_H 17#define GIGASET_H 18 19/* define global prefix for pr_ macros in linux/kernel.h */ 20#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 21 22#include <linux/kernel.h> 23#include <linux/sched.h> 24#include <linux/compiler.h> 25#include <linux/types.h> 26#include <linux/ctype.h> 27#include <linux/slab.h> 28#include <linux/spinlock.h> 29#include <linux/skbuff.h> 30#include <linux/netdevice.h> 31#include <linux/ppp_defs.h> 32#include <linux/timer.h> 33#include <linux/interrupt.h> 34#include <linux/tty.h> 35#include <linux/tty_driver.h> 36#include <linux/list.h> 37#include <linux/atomic.h> 38 39#define GIG_VERSION {0, 5, 0, 0} 40#define GIG_COMPAT {0, 4, 0, 0} 41 42#define MAX_REC_PARAMS 10 /* Max. number of params in response string */ 43#define MAX_RESP_SIZE 511 /* Max. size of a response string */ 44 45#define MAX_EVENTS 64 /* size of event queue */ 46 47#define RBUFSIZE 8192 48 49#define GIG_TICK 100 /* in milliseconds */ 50 51/* timeout values (unit: 1 sec) */ 52#define INIT_TIMEOUT 1 53 54/* timeout values (unit: 0.1 sec) */ 55#define RING_TIMEOUT 3 /* for additional parameters to RING */ 56#define BAS_TIMEOUT 20 /* for response to Base USB ops */ 57#define ATRDY_TIMEOUT 3 /* for HD_READY_SEND_ATDATA */ 58 59#define BAS_RETRY 3 /* max. retries for base USB ops */ 60 61#define MAXACT 3 62 63extern int gigaset_debuglevel; /* "needs" cast to (enum debuglevel) */ 64 65/* debug flags, combine by adding/bitwise OR */ 66enum debuglevel { 67 DEBUG_INTR = 0x00008, /* interrupt processing */ 68 DEBUG_CMD = 0x00020, /* sent/received LL commands */ 69 DEBUG_STREAM = 0x00040, /* application data stream I/O events */ 70 DEBUG_STREAM_DUMP = 0x00080, /* application data stream content */ 71 DEBUG_LLDATA = 0x00100, /* sent/received LL data */ 72 DEBUG_EVENT = 0x00200, /* event processing */ 73 DEBUG_HDLC = 0x00800, /* M10x HDLC processing */ 74 DEBUG_CHANNEL = 0x01000, /* channel allocation/deallocation */ 75 DEBUG_TRANSCMD = 0x02000, /* AT-COMMANDS+RESPONSES */ 76 DEBUG_MCMD = 0x04000, /* COMMANDS THAT ARE SENT VERY OFTEN */ 77 DEBUG_INIT = 0x08000, /* (de)allocation+initialization of data 78 structures */ 79 DEBUG_SUSPEND = 0x10000, /* suspend/resume processing */ 80 DEBUG_OUTPUT = 0x20000, /* output to device */ 81 DEBUG_ISO = 0x40000, /* isochronous transfers */ 82 DEBUG_IF = 0x80000, /* character device operations */ 83 DEBUG_USBREQ = 0x100000, /* USB communication (except payload 84 data) */ 85 DEBUG_LOCKCMD = 0x200000, /* AT commands and responses when 86 MS_LOCKED */ 87 88 DEBUG_ANY = 0x3fffff, /* print message if any of the others is 89 activated */ 90}; 91 92#ifdef CONFIG_GIGASET_DEBUG 93 94#define gig_dbg(level, format, arg...) \ 95 do { \ 96 if (unlikely(((enum debuglevel)gigaset_debuglevel) & (level))) \ 97 printk(KERN_DEBUG KBUILD_MODNAME ": " format "\n", \ 98 ## arg); \ 99 } while (0) 100#define DEBUG_DEFAULT (DEBUG_TRANSCMD | DEBUG_CMD | DEBUG_USBREQ) 101 102#else 103 104#define gig_dbg(level, format, arg...) do {} while (0) 105#define DEBUG_DEFAULT 0 106 107#endif 108 109void gigaset_dbg_buffer(enum debuglevel level, const unsigned char *msg, 110 size_t len, const unsigned char *buf); 111 112/* connection state */ 113#define ZSAU_NONE 0 114#define ZSAU_DISCONNECT_IND 4 115#define ZSAU_OUTGOING_CALL_PROCEEDING 1 116#define ZSAU_PROCEEDING 1 117#define ZSAU_CALL_DELIVERED 2 118#define ZSAU_ACTIVE 3 119#define ZSAU_NULL 5 120#define ZSAU_DISCONNECT_REQ 6 121#define ZSAU_UNKNOWN -1 122 123/* USB control transfer requests */ 124#define OUT_VENDOR_REQ (USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT) 125#define IN_VENDOR_REQ (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT) 126 127/* interrupt pipe messages */ 128#define HD_B1_FLOW_CONTROL 0x80 129#define HD_B2_FLOW_CONTROL 0x81 130#define HD_RECEIVEATDATA_ACK (0x35) /* 3070 */ 131#define HD_READY_SEND_ATDATA (0x36) /* 3070 */ 132#define HD_OPEN_ATCHANNEL_ACK (0x37) /* 3070 */ 133#define HD_CLOSE_ATCHANNEL_ACK (0x38) /* 3070 */ 134#define HD_DEVICE_INIT_OK (0x11) /* ISurf USB + 3070 */ 135#define HD_OPEN_B1CHANNEL_ACK (0x51) /* ISurf USB + 3070 */ 136#define HD_OPEN_B2CHANNEL_ACK (0x52) /* ISurf USB + 3070 */ 137#define HD_CLOSE_B1CHANNEL_ACK (0x53) /* ISurf USB + 3070 */ 138#define HD_CLOSE_B2CHANNEL_ACK (0x54) /* ISurf USB + 3070 */ 139#define HD_SUSPEND_END (0x61) /* ISurf USB */ 140#define HD_RESET_INTERRUPT_PIPE_ACK (0xFF) /* ISurf USB + 3070 */ 141 142/* control requests */ 143#define HD_OPEN_B1CHANNEL (0x23) /* ISurf USB + 3070 */ 144#define HD_CLOSE_B1CHANNEL (0x24) /* ISurf USB + 3070 */ 145#define HD_OPEN_B2CHANNEL (0x25) /* ISurf USB + 3070 */ 146#define HD_CLOSE_B2CHANNEL (0x26) /* ISurf USB + 3070 */ 147#define HD_RESET_INTERRUPT_PIPE (0x27) /* ISurf USB + 3070 */ 148#define HD_DEVICE_INIT_ACK (0x34) /* ISurf USB + 3070 */ 149#define HD_WRITE_ATMESSAGE (0x12) /* 3070 */ 150#define HD_READ_ATMESSAGE (0x13) /* 3070 */ 151#define HD_OPEN_ATCHANNEL (0x28) /* 3070 */ 152#define HD_CLOSE_ATCHANNEL (0x29) /* 3070 */ 153 154/* number of B channels supported by base driver */ 155#define BAS_CHANNELS 2 156 157/* USB frames for isochronous transfer */ 158#define BAS_FRAMETIME 1 /* number of milliseconds between frames */ 159#define BAS_NUMFRAMES 8 /* number of frames per URB */ 160#define BAS_MAXFRAME 16 /* allocated bytes per frame */ 161#define BAS_NORMFRAME 8 /* send size without flow control */ 162#define BAS_HIGHFRAME 10 /* " " with positive flow control */ 163#define BAS_LOWFRAME 5 /* " " with negative flow control */ 164#define BAS_CORRFRAMES 4 /* flow control multiplicator */ 165 166#define BAS_INBUFSIZE (BAS_MAXFRAME * BAS_NUMFRAMES) 167/* size of isoc in buf per URB */ 168#define BAS_OUTBUFSIZE 4096 /* size of common isoc out buffer */ 169#define BAS_OUTBUFPAD BAS_MAXFRAME /* size of pad area for isoc out buf */ 170 171#define BAS_INURBS 3 172#define BAS_OUTURBS 3 173 174/* variable commands in struct bc_state */ 175#define AT_ISO 0 176#define AT_DIAL 1 177#define AT_MSN 2 178#define AT_BC 3 179#define AT_PROTO 4 180#define AT_TYPE 5 181#define AT_CLIP 6 182/* total number */ 183#define AT_NUM 7 184 185/* variables in struct at_state_t */ 186#define VAR_ZSAU 0 187#define VAR_ZDLE 1 188#define VAR_ZCTP 2 189#define VAR_NUM 3 190 191#define STR_NMBR 0 192#define STR_ZCPN 1 193#define STR_ZCON 2 194#define STR_ZBC 3 195#define STR_ZHLC 4 196#define STR_NUM 5 197 198#define EV_TIMEOUT -105 199#define EV_IF_VER -106 200#define EV_PROC_CIDMODE -107 201#define EV_SHUTDOWN -108 202#define EV_START -110 203#define EV_STOP -111 204#define EV_IF_LOCK -112 205#define EV_ACCEPT -114 206#define EV_DIAL -115 207#define EV_HUP -116 208#define EV_BC_OPEN -117 209#define EV_BC_CLOSED -118 210 211/* input state */ 212#define INS_command 0x0001 /* receiving messages (not payload data) */ 213#define INS_DLE_char 0x0002 /* DLE flag received (in DLE mode) */ 214#define INS_byte_stuff 0x0004 215#define INS_have_data 0x0008 216#define INS_DLE_command 0x0020 /* DLE message start (<DLE> X) received */ 217#define INS_flag_hunt 0x0040 218 219/* channel state */ 220#define CHS_D_UP 0x01 221#define CHS_B_UP 0x02 222#define CHS_NOTIFY_LL 0x04 223 224#define ICALL_REJECT 0 225#define ICALL_ACCEPT 1 226#define ICALL_IGNORE 2 227 228/* device state */ 229#define MS_UNINITIALIZED 0 230#define MS_INIT 1 231#define MS_LOCKED 2 232#define MS_SHUTDOWN 3 233#define MS_RECOVER 4 234#define MS_READY 5 235 236/* mode */ 237#define M_UNKNOWN 0 238#define M_CONFIG 1 239#define M_UNIMODEM 2 240#define M_CID 3 241 242/* start mode */ 243#define SM_LOCKED 0 244#define SM_ISDN 1 /* default */ 245 246/* layer 2 protocols (AT^SBPR=...) */ 247#define L2_BITSYNC 0 248#define L2_HDLC 1 249#define L2_VOICE 2 250 251struct gigaset_ops; 252struct gigaset_driver; 253 254struct usb_cardstate; 255struct ser_cardstate; 256struct bas_cardstate; 257 258struct bc_state; 259struct usb_bc_state; 260struct ser_bc_state; 261struct bas_bc_state; 262 263struct reply_t { 264 int resp_code; /* RSP_XXXX */ 265 int min_ConState; /* <0 => ignore */ 266 int max_ConState; /* <0 => ignore */ 267 int parameter; /* e.g. ZSAU_XXXX <0: ignore*/ 268 int new_ConState; /* <0 => ignore */ 269 int timeout; /* >0 => *HZ; <=0 => TOUT_XXXX*/ 270 int action[MAXACT]; /* ACT_XXXX */ 271 char *command; /* NULL==none */ 272}; 273 274extern struct reply_t gigaset_tab_cid[]; 275extern struct reply_t gigaset_tab_nocid[]; 276 277struct inbuf_t { 278 struct cardstate *cs; 279 int inputstate; 280 int head, tail; 281 unsigned char data[RBUFSIZE]; 282}; 283 284/* isochronous write buffer structure 285 * circular buffer with pad area for extraction of complete USB frames 286 * - data[read..nextread-1] is valid data already submitted to the USB subsystem 287 * - data[nextread..write-1] is valid data yet to be sent 288 * - data[write] is the next byte to write to 289 * - in byte-oriented L2 procotols, it is completely free 290 * - in bit-oriented L2 procotols, it may contain a partial byte of valid data 291 * - data[write+1..read-1] is free 292 * - wbits is the number of valid data bits in data[write], starting at the LSB 293 * - writesem is the semaphore for writing to the buffer: 294 * if writesem <= 0, data[write..read-1] is currently being written to 295 * - idle contains the byte value to repeat when the end of valid data is 296 * reached; if nextread==write (buffer contains no data to send), either the 297 * BAS_OUTBUFPAD bytes immediately before data[write] (if 298 * write>=BAS_OUTBUFPAD) or those of the pad area (if write<BAS_OUTBUFPAD) 299 * are also filled with that value 300 */ 301struct isowbuf_t { 302 int read; 303 int nextread; 304 int write; 305 atomic_t writesem; 306 int wbits; 307 unsigned char data[BAS_OUTBUFSIZE + BAS_OUTBUFPAD]; 308 unsigned char idle; 309}; 310 311/* isochronous write URB context structure 312 * data to be stored along with the URB and retrieved when it is returned 313 * as completed by the USB subsystem 314 * - urb: pointer to the URB itself 315 * - bcs: pointer to the B Channel control structure 316 * - limit: end of write buffer area covered by this URB 317 * - status: URB completion status 318 */ 319struct isow_urbctx_t { 320 struct urb *urb; 321 struct bc_state *bcs; 322 int limit; 323 int status; 324}; 325 326/* AT state structure 327 * data associated with the state of an ISDN connection, whether or not 328 * it is currently assigned a B channel 329 */ 330struct at_state_t { 331 struct list_head list; 332 int waiting; 333 int getstring; 334 unsigned timer_index; 335 unsigned long timer_expires; 336 int timer_active; 337 unsigned int ConState; /* State of connection */ 338 struct reply_t *replystruct; 339 int cid; 340 int int_var[VAR_NUM]; /* see VAR_XXXX */ 341 char *str_var[STR_NUM]; /* see STR_XXXX */ 342 unsigned pending_commands; /* see PC_XXXX */ 343 unsigned seq_index; 344 345 struct cardstate *cs; 346 struct bc_state *bcs; 347}; 348 349struct event_t { 350 int type; 351 void *ptr, *arg; 352 int parameter; 353 int cid; 354 struct at_state_t *at_state; 355}; 356 357/* This buffer holds all information about the used B-Channel */ 358struct bc_state { 359 struct sk_buff *tx_skb; /* Current transfer buffer to modem */ 360 struct sk_buff_head squeue; /* B-Channel send Queue */ 361 362 /* Variables for debugging .. */ 363 int corrupted; /* Counter for corrupted packages */ 364 int trans_down; /* Counter of packages (downstream) */ 365 int trans_up; /* Counter of packages (upstream) */ 366 367 struct at_state_t at_state; 368 369 /* receive buffer */ 370 unsigned rx_bufsize; /* max size accepted by application */ 371 struct sk_buff *rx_skb; 372 __u16 rx_fcs; 373 int inputstate; /* see INS_XXXX */ 374 375 int channel; 376 377 struct cardstate *cs; 378 379 unsigned chstate; /* bitmap (CHS_*) */ 380 int ignore; 381 unsigned proto2; /* layer 2 protocol (L2_*) */ 382 char *commands[AT_NUM]; /* see AT_XXXX */ 383 384#ifdef CONFIG_GIGASET_DEBUG 385 int emptycount; 386#endif 387 int busy; 388 int use_count; 389 390 /* private data of hardware drivers */ 391 union { 392 struct ser_bc_state *ser; /* serial hardware driver */ 393 struct usb_bc_state *usb; /* usb hardware driver (m105) */ 394 struct bas_bc_state *bas; /* usb hardware driver (base) */ 395 } hw; 396 397 void *ap; /* associated LL application */ 398 int apconnstate; /* LL application connection state */ 399 spinlock_t aplock; 400}; 401 402struct cardstate { 403 struct gigaset_driver *driver; 404 unsigned minor_index; 405 struct device *dev; 406 struct device *tty_dev; 407 unsigned flags; 408 409 const struct gigaset_ops *ops; 410 411 /* Stuff to handle communication */ 412 wait_queue_head_t waitqueue; 413 int waiting; 414 int mode; /* see M_XXXX */ 415 int mstate; /* Modem state: see MS_XXXX */ 416 /* only changed by the event layer */ 417 int cmd_result; 418 419 int channels; 420 struct bc_state *bcs; /* Array of struct bc_state */ 421 422 int onechannel; /* data and commands transmitted in one 423 stream (M10x) */ 424 425 spinlock_t lock; 426 struct at_state_t at_state; /* at_state_t for cid == 0 */ 427 struct list_head temp_at_states;/* list of temporary "struct 428 at_state_t"s without B channel */ 429 430 struct inbuf_t *inbuf; 431 432 struct cmdbuf_t *cmdbuf, *lastcmdbuf; 433 spinlock_t cmdlock; 434 unsigned curlen, cmdbytes; 435 436 struct tty_port port; 437 struct tasklet_struct if_wake_tasklet; 438 unsigned control_state; 439 440 unsigned fwver[4]; 441 int gotfwver; 442 443 unsigned running; /* !=0 if events are handled */ 444 unsigned connected; /* !=0 if hardware is connected */ 445 unsigned isdn_up; /* !=0 after gigaset_isdn_start() */ 446 447 unsigned cidmode; 448 449 int myid; /* id for communication with LL */ 450 void *iif; /* LL interface structure */ 451 unsigned short hw_hdr_len; /* headroom needed in data skbs */ 452 453 struct reply_t *tabnocid; 454 struct reply_t *tabcid; 455 int cs_init; 456 int ignoreframes; /* frames to ignore after setting up the 457 B channel */ 458 struct mutex mutex; /* locks this structure: 459 * connected is not changed, 460 * hardware_up is not changed, 461 * MState is not changed to or from 462 * MS_LOCKED */ 463 464 struct timer_list timer; 465 int retry_count; 466 int dle; /* !=0 if DLE mode is active 467 (ZDLE=1 received -- M10x only) */ 468 int cur_at_seq; /* sequence of AT commands being 469 processed */ 470 int curchannel; /* channel those commands are meant 471 for */ 472 int commands_pending; /* flag(s) in xxx.commands_pending have 473 been set */ 474 struct tasklet_struct event_tasklet; 475 /* tasklet for serializing AT commands. 476 * Scheduled 477 * -> for modem reponses (and 478 * incoming data for M10x) 479 * -> on timeout 480 * -> after setting bits in 481 * xxx.at_state.pending_command 482 * (e.g. command from LL) */ 483 struct tasklet_struct write_tasklet; 484 /* tasklet for serial output 485 * (not used in base driver) */ 486 487 /* event queue */ 488 struct event_t events[MAX_EVENTS]; 489 unsigned ev_tail, ev_head; 490 spinlock_t ev_lock; 491 492 /* current modem response */ 493 unsigned char respdata[MAX_RESP_SIZE + 1]; 494 unsigned cbytes; 495 496 /* private data of hardware drivers */ 497 union { 498 struct usb_cardstate *usb; /* USB hardware driver (m105) */ 499 struct ser_cardstate *ser; /* serial hardware driver */ 500 struct bas_cardstate *bas; /* USB hardware driver (base) */ 501 } hw; 502}; 503 504struct gigaset_driver { 505 struct list_head list; 506 spinlock_t lock; /* locks minor tables and blocked */ 507 struct tty_driver *tty; 508 unsigned have_tty; 509 unsigned minor; 510 unsigned minors; 511 struct cardstate *cs; 512 int blocked; 513 514 const struct gigaset_ops *ops; 515 struct module *owner; 516}; 517 518struct cmdbuf_t { 519 struct cmdbuf_t *next, *prev; 520 int len, offset; 521 struct tasklet_struct *wake_tasklet; 522 unsigned char buf[0]; 523}; 524 525struct bas_bc_state { 526 /* isochronous output state */ 527 int running; 528 atomic_t corrbytes; 529 spinlock_t isooutlock; 530 struct isow_urbctx_t isoouturbs[BAS_OUTURBS]; 531 struct isow_urbctx_t *isooutdone, *isooutfree, *isooutovfl; 532 struct isowbuf_t *isooutbuf; 533 unsigned numsub; /* submitted URB counter 534 (for diagnostic messages only) */ 535 struct tasklet_struct sent_tasklet; 536 537 /* isochronous input state */ 538 spinlock_t isoinlock; 539 struct urb *isoinurbs[BAS_INURBS]; 540 unsigned char isoinbuf[BAS_INBUFSIZE * BAS_INURBS]; 541 struct urb *isoindone; /* completed isoc read URB */ 542 int isoinstatus; /* status of completed URB */ 543 int loststatus; /* status of dropped URB */ 544 unsigned isoinlost; /* number of bytes lost */ 545 /* state of bit unstuffing algorithm 546 (in addition to BC_state.inputstate) */ 547 unsigned seqlen; /* number of '1' bits not yet 548 unstuffed */ 549 unsigned inbyte, inbits; /* collected bits for next byte */ 550 /* statistics */ 551 unsigned goodbytes; /* bytes correctly received */ 552 unsigned alignerrs; /* frames with incomplete byte at end */ 553 unsigned fcserrs; /* FCS errors */ 554 unsigned frameerrs; /* framing errors */ 555 unsigned giants; /* long frames */ 556 unsigned runts; /* short frames */ 557 unsigned aborts; /* HDLC aborts */ 558 unsigned shared0s; /* '0' bits shared between flags */ 559 unsigned stolen0s; /* '0' stuff bits also serving as 560 leading flag bits */ 561 struct tasklet_struct rcvd_tasklet; 562}; 563 564struct gigaset_ops { 565 /* Called from ev-layer.c/interface.c for sending AT commands to the 566 device */ 567 int (*write_cmd)(struct cardstate *cs, struct cmdbuf_t *cb); 568 569 /* Called from interface.c for additional device control */ 570 int (*write_room)(struct cardstate *cs); 571 int (*chars_in_buffer)(struct cardstate *cs); 572 int (*brkchars)(struct cardstate *cs, const unsigned char buf[6]); 573 574 /* Called from ev-layer.c after setting up connection 575 * Should call gigaset_bchannel_up(), when finished. */ 576 int (*init_bchannel)(struct bc_state *bcs); 577 578 /* Called from ev-layer.c after hanging up 579 * Should call gigaset_bchannel_down(), when finished. */ 580 int (*close_bchannel)(struct bc_state *bcs); 581 582 /* Called by gigaset_initcs() for setting up bcs->hw.xxx */ 583 int (*initbcshw)(struct bc_state *bcs); 584 585 /* Called by gigaset_freecs() for freeing bcs->hw.xxx */ 586 int (*freebcshw)(struct bc_state *bcs); 587 588 /* Called by gigaset_bchannel_down() for resetting bcs->hw.xxx */ 589 void (*reinitbcshw)(struct bc_state *bcs); 590 591 /* Called by gigaset_initcs() for setting up cs->hw.xxx */ 592 int (*initcshw)(struct cardstate *cs); 593 594 /* Called by gigaset_freecs() for freeing cs->hw.xxx */ 595 void (*freecshw)(struct cardstate *cs); 596 597 /* Called from common.c/interface.c for additional serial port 598 control */ 599 int (*set_modem_ctrl)(struct cardstate *cs, unsigned old_state, 600 unsigned new_state); 601 int (*baud_rate)(struct cardstate *cs, unsigned cflag); 602 int (*set_line_ctrl)(struct cardstate *cs, unsigned cflag); 603 604 /* Called from LL interface to put an skb into the send-queue. 605 * After sending is completed, gigaset_skb_sent() must be called 606 * with the skb's link layer header preserved. */ 607 int (*send_skb)(struct bc_state *bcs, struct sk_buff *skb); 608 609 /* Called from ev-layer.c to process a block of data 610 * received through the common/control channel. */ 611 void (*handle_input)(struct inbuf_t *inbuf); 612 613}; 614 615/* = Common structures and definitions ======================================= 616 */ 617 618/* Parser states for DLE-Event: 619 * <DLE-EVENT>: <DLE_FLAG> "X" <EVENT> <DLE_FLAG> "." 620 * <DLE_FLAG>: 0x10 621 * <EVENT>: ((a-z)* | (A-Z)* | (0-10)*)+ 622 */ 623#define DLE_FLAG 0x10 624 625/* =========================================================================== 626 * Functions implemented in asyncdata.c 627 */ 628 629/* Called from LL interface to put an skb into the send queue. */ 630int gigaset_m10x_send_skb(struct bc_state *bcs, struct sk_buff *skb); 631 632/* Called from ev-layer.c to process a block of data 633 * received through the common/control channel. */ 634void gigaset_m10x_input(struct inbuf_t *inbuf); 635 636/* =========================================================================== 637 * Functions implemented in isocdata.c 638 */ 639 640/* Called from LL interface to put an skb into the send queue. */ 641int gigaset_isoc_send_skb(struct bc_state *bcs, struct sk_buff *skb); 642 643/* Called from ev-layer.c to process a block of data 644 * received through the common/control channel. */ 645void gigaset_isoc_input(struct inbuf_t *inbuf); 646 647/* Called from bas-gigaset.c to process a block of data 648 * received through the isochronous channel */ 649void gigaset_isoc_receive(unsigned char *src, unsigned count, 650 struct bc_state *bcs); 651 652/* Called from bas-gigaset.c to put a block of data 653 * into the isochronous output buffer */ 654int gigaset_isoc_buildframe(struct bc_state *bcs, unsigned char *in, int len); 655 656/* Called from bas-gigaset.c to initialize the isochronous output buffer */ 657void gigaset_isowbuf_init(struct isowbuf_t *iwb, unsigned char idle); 658 659/* Called from bas-gigaset.c to retrieve a block of bytes for sending */ 660int gigaset_isowbuf_getbytes(struct isowbuf_t *iwb, int size); 661 662/* =========================================================================== 663 * Functions implemented in LL interface 664 */ 665 666/* Called from common.c for setting up/shutting down with the ISDN subsystem */ 667void gigaset_isdn_regdrv(void); 668void gigaset_isdn_unregdrv(void); 669int gigaset_isdn_regdev(struct cardstate *cs, const char *isdnid); 670void gigaset_isdn_unregdev(struct cardstate *cs); 671 672/* Called from hardware module to indicate completion of an skb */ 673void gigaset_skb_sent(struct bc_state *bcs, struct sk_buff *skb); 674void gigaset_skb_rcvd(struct bc_state *bcs, struct sk_buff *skb); 675void gigaset_isdn_rcv_err(struct bc_state *bcs); 676 677/* Called from common.c/ev-layer.c to indicate events relevant to the LL */ 678void gigaset_isdn_start(struct cardstate *cs); 679void gigaset_isdn_stop(struct cardstate *cs); 680int gigaset_isdn_icall(struct at_state_t *at_state); 681void gigaset_isdn_connD(struct bc_state *bcs); 682void gigaset_isdn_hupD(struct bc_state *bcs); 683void gigaset_isdn_connB(struct bc_state *bcs); 684void gigaset_isdn_hupB(struct bc_state *bcs); 685 686/* =========================================================================== 687 * Functions implemented in ev-layer.c 688 */ 689 690/* tasklet called from common.c to process queued events */ 691void gigaset_handle_event(unsigned long data); 692 693/* called from isocdata.c / asyncdata.c 694 * when a complete modem response line has been received */ 695void gigaset_handle_modem_response(struct cardstate *cs); 696 697/* =========================================================================== 698 * Functions implemented in proc.c 699 */ 700 701/* initialize sysfs for device */ 702void gigaset_init_dev_sysfs(struct cardstate *cs); 703void gigaset_free_dev_sysfs(struct cardstate *cs); 704 705/* =========================================================================== 706 * Functions implemented in common.c/gigaset.h 707 */ 708 709void gigaset_bcs_reinit(struct bc_state *bcs); 710void gigaset_at_init(struct at_state_t *at_state, struct bc_state *bcs, 711 struct cardstate *cs, int cid); 712int gigaset_get_channel(struct bc_state *bcs); 713struct bc_state *gigaset_get_free_channel(struct cardstate *cs); 714void gigaset_free_channel(struct bc_state *bcs); 715int gigaset_get_channels(struct cardstate *cs); 716void gigaset_free_channels(struct cardstate *cs); 717void gigaset_block_channels(struct cardstate *cs); 718 719/* Allocate and initialize driver structure. */ 720struct gigaset_driver *gigaset_initdriver(unsigned minor, unsigned minors, 721 const char *procname, 722 const char *devname, 723 const struct gigaset_ops *ops, 724 struct module *owner); 725 726/* Deallocate driver structure. */ 727void gigaset_freedriver(struct gigaset_driver *drv); 728 729struct cardstate *gigaset_get_cs_by_tty(struct tty_struct *tty); 730struct cardstate *gigaset_get_cs_by_id(int id); 731void gigaset_blockdriver(struct gigaset_driver *drv); 732 733/* Allocate and initialize card state. Calls hardware dependent 734 gigaset_init[b]cs(). */ 735struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels, 736 int onechannel, int ignoreframes, 737 int cidmode, const char *modulename); 738 739/* Free card state. Calls hardware dependent gigaset_free[b]cs(). */ 740void gigaset_freecs(struct cardstate *cs); 741 742/* Tell common.c that hardware and driver are ready. */ 743int gigaset_start(struct cardstate *cs); 744 745/* Tell common.c that the device is not present any more. */ 746void gigaset_stop(struct cardstate *cs); 747 748/* Tell common.c that the driver is being unloaded. */ 749int gigaset_shutdown(struct cardstate *cs); 750 751/* Tell common.c that an skb has been sent. */ 752void gigaset_skb_sent(struct bc_state *bcs, struct sk_buff *skb); 753 754/* Append event to the queue. 755 * Returns NULL on failure or a pointer to the event on success. 756 * ptr must be kmalloc()ed (and not be freed by the caller). 757 */ 758struct event_t *gigaset_add_event(struct cardstate *cs, 759 struct at_state_t *at_state, int type, 760 void *ptr, int parameter, void *arg); 761 762/* Called on CONFIG1 command from frontend. */ 763int gigaset_enterconfigmode(struct cardstate *cs); 764 765/* cs->lock must not be locked */ 766static inline void gigaset_schedule_event(struct cardstate *cs) 767{ 768 unsigned long flags; 769 spin_lock_irqsave(&cs->lock, flags); 770 if (cs->running) 771 tasklet_schedule(&cs->event_tasklet); 772 spin_unlock_irqrestore(&cs->lock, flags); 773} 774 775/* Tell common.c that B channel has been closed. */ 776/* cs->lock must not be locked */ 777static inline void gigaset_bchannel_down(struct bc_state *bcs) 778{ 779 gigaset_add_event(bcs->cs, &bcs->at_state, EV_BC_CLOSED, NULL, 0, NULL); 780 gigaset_schedule_event(bcs->cs); 781} 782 783/* Tell common.c that B channel has been opened. */ 784/* cs->lock must not be locked */ 785static inline void gigaset_bchannel_up(struct bc_state *bcs) 786{ 787 gigaset_add_event(bcs->cs, &bcs->at_state, EV_BC_OPEN, NULL, 0, NULL); 788 gigaset_schedule_event(bcs->cs); 789} 790 791/* set up next receive skb for data mode */ 792static inline struct sk_buff *gigaset_new_rx_skb(struct bc_state *bcs) 793{ 794 struct cardstate *cs = bcs->cs; 795 unsigned short hw_hdr_len = cs->hw_hdr_len; 796 797 if (bcs->ignore) { 798 bcs->rx_skb = NULL; 799 } else { 800 bcs->rx_skb = dev_alloc_skb(bcs->rx_bufsize + hw_hdr_len); 801 if (bcs->rx_skb == NULL) 802 dev_warn(cs->dev, "could not allocate skb\n"); 803 else 804 skb_reserve(bcs->rx_skb, hw_hdr_len); 805 } 806 return bcs->rx_skb; 807} 808 809/* append received bytes to inbuf */ 810int gigaset_fill_inbuf(struct inbuf_t *inbuf, const unsigned char *src, 811 unsigned numbytes); 812 813/* =========================================================================== 814 * Functions implemented in interface.c 815 */ 816 817/* initialize interface */ 818void gigaset_if_initdriver(struct gigaset_driver *drv, const char *procname, 819 const char *devname); 820/* release interface */ 821void gigaset_if_freedriver(struct gigaset_driver *drv); 822/* add minor */ 823void gigaset_if_init(struct cardstate *cs); 824/* remove minor */ 825void gigaset_if_free(struct cardstate *cs); 826/* device received data */ 827void gigaset_if_receive(struct cardstate *cs, 828 unsigned char *buffer, size_t len); 829 830#endif 831