linux/drivers/tty/n_gsm.c
<<
>>
Prefs
   1/*
   2 * n_gsm.c GSM 0710 tty multiplexor
   3 * Copyright (c) 2009/10 Intel Corporation
   4 *
   5 * This program is free software; you can redistribute it and/or modify
   6 * it under the terms of the GNU General Public License version 2 as
   7 * published by the Free Software Foundation.
   8 *
   9 * This program is distributed in the hope that it will be useful,
  10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 * GNU General Public License for more details.
  13 *
  14 * You should have received a copy of the GNU General Public License
  15 * along with this program; if not, write to the Free Software
  16 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17 *
  18 *      * THIS IS A DEVELOPMENT SNAPSHOT IT IS NOT A FINAL RELEASE *
  19 *
  20 * TO DO:
  21 *      Mostly done:    ioctls for setting modes/timing
  22 *      Partly done:    hooks so you can pull off frames to non tty devs
  23 *      Restart DLCI 0 when it closes ?
  24 *      Improve the tx engine
  25 *      Resolve tx side locking by adding a queue_head and routing
  26 *              all control traffic via it
  27 *      General tidy/document
  28 *      Review the locking/move to refcounts more (mux now moved to an
  29 *              alloc/free model ready)
  30 *      Use newest tty open/close port helpers and install hooks
  31 *      What to do about power functions ?
  32 *      Termios setting and negotiation
  33 *      Do we need a 'which mux are you' ioctl to correlate mux and tty sets
  34 *
  35 */
  36
  37#include <linux/types.h>
  38#include <linux/major.h>
  39#include <linux/errno.h>
  40#include <linux/signal.h>
  41#include <linux/fcntl.h>
  42#include <linux/sched.h>
  43#include <linux/interrupt.h>
  44#include <linux/tty.h>
  45#include <linux/ctype.h>
  46#include <linux/mm.h>
  47#include <linux/string.h>
  48#include <linux/slab.h>
  49#include <linux/poll.h>
  50#include <linux/bitops.h>
  51#include <linux/file.h>
  52#include <linux/uaccess.h>
  53#include <linux/module.h>
  54#include <linux/timer.h>
  55#include <linux/tty_flip.h>
  56#include <linux/tty_driver.h>
  57#include <linux/serial.h>
  58#include <linux/kfifo.h>
  59#include <linux/skbuff.h>
  60#include <net/arp.h>
  61#include <linux/ip.h>
  62#include <linux/netdevice.h>
  63#include <linux/etherdevice.h>
  64#include <linux/gsmmux.h>
  65
  66static int debug;
  67module_param(debug, int, 0600);
  68
  69/* Defaults: these are from the specification */
  70
  71#define T1      10              /* 100mS */
  72#define T2      34              /* 333mS */
  73#define N2      3               /* Retry 3 times */
  74
  75/* Use long timers for testing at low speed with debug on */
  76#ifdef DEBUG_TIMING
  77#define T1      100
  78#define T2      200
  79#endif
  80
  81/*
  82 * Semi-arbitrary buffer size limits. 0710 is normally run with 32-64 byte
  83 * limits so this is plenty
  84 */
  85#define MAX_MRU 1500
  86#define MAX_MTU 1500
  87#define GSM_NET_TX_TIMEOUT (HZ*10)
  88
  89/**
  90 *      struct gsm_mux_net      -       network interface
  91 *      @struct gsm_dlci* dlci
  92 *      @struct net_device_stats stats;
  93 *
  94 *      Created when net interface is initialized.
  95 **/
  96struct gsm_mux_net {
  97        struct kref ref;
  98        struct gsm_dlci *dlci;
  99        struct net_device_stats stats;
 100};
 101
 102#define STATS(net) (((struct gsm_mux_net *)netdev_priv(net))->stats)
 103
 104/*
 105 *      Each block of data we have queued to go out is in the form of
 106 *      a gsm_msg which holds everything we need in a link layer independent
 107 *      format
 108 */
 109
 110struct gsm_msg {
 111        struct gsm_msg *next;
 112        u8 addr;                /* DLCI address + flags */
 113        u8 ctrl;                /* Control byte + flags */
 114        unsigned int len;       /* Length of data block (can be zero) */
 115        unsigned char *data;    /* Points into buffer but not at the start */
 116        unsigned char buffer[0];
 117};
 118
 119/*
 120 *      Each active data link has a gsm_dlci structure associated which ties
 121 *      the link layer to an optional tty (if the tty side is open). To avoid
 122 *      complexity right now these are only ever freed up when the mux is
 123 *      shut down.
 124 *
 125 *      At the moment we don't free DLCI objects until the mux is torn down
 126 *      this avoid object life time issues but might be worth review later.
 127 */
 128
 129struct gsm_dlci {
 130        struct gsm_mux *gsm;
 131        int addr;
 132        int state;
 133#define DLCI_CLOSED             0
 134#define DLCI_OPENING            1       /* Sending SABM not seen UA */
 135#define DLCI_OPEN               2       /* SABM/UA complete */
 136#define DLCI_CLOSING            3       /* Sending DISC not seen UA/DM */
 137        struct kref ref;                /* freed from port or mux close */
 138        struct mutex mutex;
 139
 140        /* Link layer */
 141        spinlock_t lock;        /* Protects the internal state */
 142        struct timer_list t1;   /* Retransmit timer for SABM and UA */
 143        int retries;
 144        /* Uplink tty if active */
 145        struct tty_port port;   /* The tty bound to this DLCI if there is one */
 146        struct kfifo *fifo;     /* Queue fifo for the DLCI */
 147        struct kfifo _fifo;     /* For new fifo API porting only */
 148        int adaption;           /* Adaption layer in use */
 149        int prev_adaption;
 150        u32 modem_rx;           /* Our incoming virtual modem lines */
 151        u32 modem_tx;           /* Our outgoing modem lines */
 152        int dead;               /* Refuse re-open */
 153        /* Flow control */
 154        int throttled;          /* Private copy of throttle state */
 155        int constipated;        /* Throttle status for outgoing */
 156        /* Packetised I/O */
 157        struct sk_buff *skb;    /* Frame being sent */
 158        struct sk_buff_head skb_list;   /* Queued frames */
 159        /* Data handling callback */
 160        void (*data)(struct gsm_dlci *dlci, u8 *data, int len);
 161        void (*prev_data)(struct gsm_dlci *dlci, u8 *data, int len);
 162        struct net_device *net; /* network interface, if created */
 163};
 164
 165/* DLCI 0, 62/63 are special or reseved see gsmtty_open */
 166
 167#define NUM_DLCI                64
 168
 169/*
 170 *      DLCI 0 is used to pass control blocks out of band of the data
 171 *      flow (and with a higher link priority). One command can be outstanding
 172 *      at a time and we use this structure to manage them. They are created
 173 *      and destroyed by the user context, and updated by the receive paths
 174 *      and timers
 175 */
 176
 177struct gsm_control {
 178        u8 cmd;         /* Command we are issuing */
 179        u8 *data;       /* Data for the command in case we retransmit */
 180        int len;        /* Length of block for retransmission */
 181        int done;       /* Done flag */
 182        int error;      /* Error if any */
 183};
 184
 185/*
 186 *      Each GSM mux we have is represented by this structure. If we are
 187 *      operating as an ldisc then we use this structure as our ldisc
 188 *      state. We need to sort out lifetimes and locking with respect
 189 *      to the gsm mux array. For now we don't free DLCI objects that
 190 *      have been instantiated until the mux itself is terminated.
 191 *
 192 *      To consider further: tty open versus mux shutdown.
 193 */
 194
 195struct gsm_mux {
 196        struct tty_struct *tty;         /* The tty our ldisc is bound to */
 197        spinlock_t lock;
 198        unsigned int num;
 199        struct kref ref;
 200
 201        /* Events on the GSM channel */
 202        wait_queue_head_t event;
 203
 204        /* Bits for GSM mode decoding */
 205
 206        /* Framing Layer */
 207        unsigned char *buf;
 208        int state;
 209#define GSM_SEARCH              0
 210#define GSM_START               1
 211#define GSM_ADDRESS             2
 212#define GSM_CONTROL             3
 213#define GSM_LEN                 4
 214#define GSM_DATA                5
 215#define GSM_FCS                 6
 216#define GSM_OVERRUN             7
 217#define GSM_LEN0                8
 218#define GSM_LEN1                9
 219#define GSM_SSOF                10
 220        unsigned int len;
 221        unsigned int address;
 222        unsigned int count;
 223        int escape;
 224        int encoding;
 225        u8 control;
 226        u8 fcs;
 227        u8 received_fcs;
 228        u8 *txframe;                    /* TX framing buffer */
 229
 230        /* Methods for the receiver side */
 231        void (*receive)(struct gsm_mux *gsm, u8 ch);
 232        void (*error)(struct gsm_mux *gsm, u8 ch, u8 flag);
 233        /* And transmit side */
 234        int (*output)(struct gsm_mux *mux, u8 *data, int len);
 235
 236        /* Link Layer */
 237        unsigned int mru;
 238        unsigned int mtu;
 239        int initiator;                  /* Did we initiate connection */
 240        int dead;                       /* Has the mux been shut down */
 241        struct gsm_dlci *dlci[NUM_DLCI];
 242        int constipated;                /* Asked by remote to shut up */
 243
 244        spinlock_t tx_lock;
 245        unsigned int tx_bytes;          /* TX data outstanding */
 246#define TX_THRESH_HI            8192
 247#define TX_THRESH_LO            2048
 248        struct gsm_msg *tx_head;        /* Pending data packets */
 249        struct gsm_msg *tx_tail;
 250
 251        /* Control messages */
 252        struct timer_list t2_timer;     /* Retransmit timer for commands */
 253        int cretries;                   /* Command retry counter */
 254        struct gsm_control *pending_cmd;/* Our current pending command */
 255        spinlock_t control_lock;        /* Protects the pending command */
 256
 257        /* Configuration */
 258        int adaption;           /* 1 or 2 supported */
 259        u8 ftype;               /* UI or UIH */
 260        int t1, t2;             /* Timers in 1/100th of a sec */
 261        int n2;                 /* Retry count */
 262
 263        /* Statistics (not currently exposed) */
 264        unsigned long bad_fcs;
 265        unsigned long malformed;
 266        unsigned long io_error;
 267        unsigned long bad_size;
 268        unsigned long unsupported;
 269};
 270
 271
 272/*
 273 *      Mux objects - needed so that we can translate a tty index into the
 274 *      relevant mux and DLCI.
 275 */
 276
 277#define MAX_MUX         4                       /* 256 minors */
 278static struct gsm_mux *gsm_mux[MAX_MUX];        /* GSM muxes */
 279static spinlock_t gsm_mux_lock;
 280
 281static struct tty_driver *gsm_tty_driver;
 282
 283/*
 284 *      This section of the driver logic implements the GSM encodings
 285 *      both the basic and the 'advanced'. Reliable transport is not
 286 *      supported.
 287 */
 288
 289#define CR                      0x02
 290#define EA                      0x01
 291#define PF                      0x10
 292
 293/* I is special: the rest are ..*/
 294#define RR                      0x01
 295#define UI                      0x03
 296#define RNR                     0x05
 297#define REJ                     0x09
 298#define DM                      0x0F
 299#define SABM                    0x2F
 300#define DISC                    0x43
 301#define UA                      0x63
 302#define UIH                     0xEF
 303
 304/* Channel commands */
 305#define CMD_NSC                 0x09
 306#define CMD_TEST                0x11
 307#define CMD_PSC                 0x21
 308#define CMD_RLS                 0x29
 309#define CMD_FCOFF               0x31
 310#define CMD_PN                  0x41
 311#define CMD_RPN                 0x49
 312#define CMD_FCON                0x51
 313#define CMD_CLD                 0x61
 314#define CMD_SNC                 0x69
 315#define CMD_MSC                 0x71
 316
 317/* Virtual modem bits */
 318#define MDM_FC                  0x01
 319#define MDM_RTC                 0x02
 320#define MDM_RTR                 0x04
 321#define MDM_IC                  0x20
 322#define MDM_DV                  0x40
 323
 324#define GSM0_SOF                0xF9
 325#define GSM1_SOF                0x7E
 326#define GSM1_ESCAPE             0x7D
 327#define GSM1_ESCAPE_BITS        0x20
 328#define XON                     0x11
 329#define XOFF                    0x13
 330
 331static const struct tty_port_operations gsm_port_ops;
 332
 333/*
 334 *      CRC table for GSM 0710
 335 */
 336
 337static const u8 gsm_fcs8[256] = {
 338        0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75,
 339        0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
 340        0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69,
 341        0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
 342        0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D,
 343        0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
 344        0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51,
 345        0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
 346        0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05,
 347        0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
 348        0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19,
 349        0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
 350        0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D,
 351        0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
 352        0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21,
 353        0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
 354        0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95,
 355        0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
 356        0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89,
 357        0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
 358        0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD,
 359        0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
 360        0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1,
 361        0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
 362        0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5,
 363        0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
 364        0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9,
 365        0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
 366        0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD,
 367        0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
 368        0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1,
 369        0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
 370};
 371
 372#define INIT_FCS        0xFF
 373#define GOOD_FCS        0xCF
 374
 375/**
 376 *      gsm_fcs_add     -       update FCS
 377 *      @fcs: Current FCS
 378 *      @c: Next data
 379 *
 380 *      Update the FCS to include c. Uses the algorithm in the specification
 381 *      notes.
 382 */
 383
 384static inline u8 gsm_fcs_add(u8 fcs, u8 c)
 385{
 386        return gsm_fcs8[fcs ^ c];
 387}
 388
 389/**
 390 *      gsm_fcs_add_block       -       update FCS for a block
 391 *      @fcs: Current FCS
 392 *      @c: buffer of data
 393 *      @len: length of buffer
 394 *
 395 *      Update the FCS to include c. Uses the algorithm in the specification
 396 *      notes.
 397 */
 398
 399static inline u8 gsm_fcs_add_block(u8 fcs, u8 *c, int len)
 400{
 401        while (len--)
 402                fcs = gsm_fcs8[fcs ^ *c++];
 403        return fcs;
 404}
 405
 406/**
 407 *      gsm_read_ea             -       read a byte into an EA
 408 *      @val: variable holding value
 409 *      c: byte going into the EA
 410 *
 411 *      Processes one byte of an EA. Updates the passed variable
 412 *      and returns 1 if the EA is now completely read
 413 */
 414
 415static int gsm_read_ea(unsigned int *val, u8 c)
 416{
 417        /* Add the next 7 bits into the value */
 418        *val <<= 7;
 419        *val |= c >> 1;
 420        /* Was this the last byte of the EA 1 = yes*/
 421        return c & EA;
 422}
 423
 424/**
 425 *      gsm_encode_modem        -       encode modem data bits
 426 *      @dlci: DLCI to encode from
 427 *
 428 *      Returns the correct GSM encoded modem status bits (6 bit field) for
 429 *      the current status of the DLCI and attached tty object
 430 */
 431
 432static u8 gsm_encode_modem(const struct gsm_dlci *dlci)
 433{
 434        u8 modembits = 0;
 435        /* FC is true flow control not modem bits */
 436        if (dlci->throttled)
 437                modembits |= MDM_FC;
 438        if (dlci->modem_tx & TIOCM_DTR)
 439                modembits |= MDM_RTC;
 440        if (dlci->modem_tx & TIOCM_RTS)
 441                modembits |= MDM_RTR;
 442        if (dlci->modem_tx & TIOCM_RI)
 443                modembits |= MDM_IC;
 444        if (dlci->modem_tx & TIOCM_CD)
 445                modembits |= MDM_DV;
 446        return modembits;
 447}
 448
 449/**
 450 *      gsm_print_packet        -       display a frame for debug
 451 *      @hdr: header to print before decode
 452 *      @addr: address EA from the frame
 453 *      @cr: C/R bit from the frame
 454 *      @control: control including PF bit
 455 *      @data: following data bytes
 456 *      @dlen: length of data
 457 *
 458 *      Displays a packet in human readable format for debugging purposes. The
 459 *      style is based on amateur radio LAP-B dump display.
 460 */
 461
 462static void gsm_print_packet(const char *hdr, int addr, int cr,
 463                                        u8 control, const u8 *data, int dlen)
 464{
 465        if (!(debug & 1))
 466                return;
 467
 468        pr_info("%s %d) %c: ", hdr, addr, "RC"[cr]);
 469
 470        switch (control & ~PF) {
 471        case SABM:
 472                pr_cont("SABM");
 473                break;
 474        case UA:
 475                pr_cont("UA");
 476                break;
 477        case DISC:
 478                pr_cont("DISC");
 479                break;
 480        case DM:
 481                pr_cont("DM");
 482                break;
 483        case UI:
 484                pr_cont("UI");
 485                break;
 486        case UIH:
 487                pr_cont("UIH");
 488                break;
 489        default:
 490                if (!(control & 0x01)) {
 491                        pr_cont("I N(S)%d N(R)%d",
 492                                (control & 0x0E) >> 1, (control & 0xE) >> 5);
 493                } else switch (control & 0x0F) {
 494                        case RR:
 495                                pr_cont("RR(%d)", (control & 0xE0) >> 5);
 496                                break;
 497                        case RNR:
 498                                pr_cont("RNR(%d)", (control & 0xE0) >> 5);
 499                                break;
 500                        case REJ:
 501                                pr_cont("REJ(%d)", (control & 0xE0) >> 5);
 502                                break;
 503                        default:
 504                                pr_cont("[%02X]", control);
 505                }
 506        }
 507
 508        if (control & PF)
 509                pr_cont("(P)");
 510        else
 511                pr_cont("(F)");
 512
 513        if (dlen) {
 514                int ct = 0;
 515                while (dlen--) {
 516                        if (ct % 8 == 0) {
 517                                pr_cont("\n");
 518                                pr_debug("    ");
 519                        }
 520                        pr_cont("%02X ", *data++);
 521                        ct++;
 522                }
 523        }
 524        pr_cont("\n");
 525}
 526
 527
 528/*
 529 *      Link level transmission side
 530 */
 531
 532/**
 533 *      gsm_stuff_packet        -       bytestuff a packet
 534 *      @ibuf: input
 535 *      @obuf: output
 536 *      @len: length of input
 537 *
 538 *      Expand a buffer by bytestuffing it. The worst case size change
 539 *      is doubling and the caller is responsible for handing out
 540 *      suitable sized buffers.
 541 */
 542
 543static int gsm_stuff_frame(const u8 *input, u8 *output, int len)
 544{
 545        int olen = 0;
 546        while (len--) {
 547                if (*input == GSM1_SOF || *input == GSM1_ESCAPE
 548                    || *input == XON || *input == XOFF) {
 549                        *output++ = GSM1_ESCAPE;
 550                        *output++ = *input++ ^ GSM1_ESCAPE_BITS;
 551                        olen++;
 552                } else
 553                        *output++ = *input++;
 554                olen++;
 555        }
 556        return olen;
 557}
 558
 559/**
 560 *      gsm_send        -       send a control frame
 561 *      @gsm: our GSM mux
 562 *      @addr: address for control frame
 563 *      @cr: command/response bit
 564 *      @control:  control byte including PF bit
 565 *
 566 *      Format up and transmit a control frame. These do not go via the
 567 *      queueing logic as they should be transmitted ahead of data when
 568 *      they are needed.
 569 *
 570 *      FIXME: Lock versus data TX path
 571 */
 572
 573static void gsm_send(struct gsm_mux *gsm, int addr, int cr, int control)
 574{
 575        int len;
 576        u8 cbuf[10];
 577        u8 ibuf[3];
 578
 579        switch (gsm->encoding) {
 580        case 0:
 581                cbuf[0] = GSM0_SOF;
 582                cbuf[1] = (addr << 2) | (cr << 1) | EA;
 583                cbuf[2] = control;
 584                cbuf[3] = EA;   /* Length of data = 0 */
 585                cbuf[4] = 0xFF - gsm_fcs_add_block(INIT_FCS, cbuf + 1, 3);
 586                cbuf[5] = GSM0_SOF;
 587                len = 6;
 588                break;
 589        case 1:
 590        case 2:
 591                /* Control frame + packing (but not frame stuffing) in mode 1 */
 592                ibuf[0] = (addr << 2) | (cr << 1) | EA;
 593                ibuf[1] = control;
 594                ibuf[2] = 0xFF - gsm_fcs_add_block(INIT_FCS, ibuf, 2);
 595                /* Stuffing may double the size worst case */
 596                len = gsm_stuff_frame(ibuf, cbuf + 1, 3);
 597                /* Now add the SOF markers */
 598                cbuf[0] = GSM1_SOF;
 599                cbuf[len + 1] = GSM1_SOF;
 600                /* FIXME: we can omit the lead one in many cases */
 601                len += 2;
 602                break;
 603        default:
 604                WARN_ON(1);
 605                return;
 606        }
 607        gsm->output(gsm, cbuf, len);
 608        gsm_print_packet("-->", addr, cr, control, NULL, 0);
 609}
 610
 611/**
 612 *      gsm_response    -       send a control response
 613 *      @gsm: our GSM mux
 614 *      @addr: address for control frame
 615 *      @control:  control byte including PF bit
 616 *
 617 *      Format up and transmit a link level response frame.
 618 */
 619
 620static inline void gsm_response(struct gsm_mux *gsm, int addr, int control)
 621{
 622        gsm_send(gsm, addr, 0, control);
 623}
 624
 625/**
 626 *      gsm_command     -       send a control command
 627 *      @gsm: our GSM mux
 628 *      @addr: address for control frame
 629 *      @control:  control byte including PF bit
 630 *
 631 *      Format up and transmit a link level command frame.
 632 */
 633
 634static inline void gsm_command(struct gsm_mux *gsm, int addr, int control)
 635{
 636        gsm_send(gsm, addr, 1, control);
 637}
 638
 639/* Data transmission */
 640
 641#define HDR_LEN         6       /* ADDR CTRL [LEN.2] DATA FCS */
 642
 643/**
 644 *      gsm_data_alloc          -       allocate data frame
 645 *      @gsm: GSM mux
 646 *      @addr: DLCI address
 647 *      @len: length excluding header and FCS
 648 *      @ctrl: control byte
 649 *
 650 *      Allocate a new data buffer for sending frames with data. Space is left
 651 *      at the front for header bytes but that is treated as an implementation
 652 *      detail and not for the high level code to use
 653 */
 654
 655static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len,
 656                                                                u8 ctrl)
 657{
 658        struct gsm_msg *m = kmalloc(sizeof(struct gsm_msg) + len + HDR_LEN,
 659                                                                GFP_ATOMIC);
 660        if (m == NULL)
 661                return NULL;
 662        m->data = m->buffer + HDR_LEN - 1;      /* Allow for FCS */
 663        m->len = len;
 664        m->addr = addr;
 665        m->ctrl = ctrl;
 666        m->next = NULL;
 667        return m;
 668}
 669
 670/**
 671 *      gsm_data_kick           -       poke the queue
 672 *      @gsm: GSM Mux
 673 *
 674 *      The tty device has called us to indicate that room has appeared in
 675 *      the transmit queue. Ram more data into the pipe if we have any
 676 *
 677 *      FIXME: lock against link layer control transmissions
 678 */
 679
 680static void gsm_data_kick(struct gsm_mux *gsm)
 681{
 682        struct gsm_msg *msg = gsm->tx_head;
 683        int len;
 684        int skip_sof = 0;
 685
 686        /* FIXME: We need to apply this solely to data messages */
 687        if (gsm->constipated)
 688                return;
 689
 690        while (gsm->tx_head != NULL) {
 691                msg = gsm->tx_head;
 692                if (gsm->encoding != 0) {
 693                        gsm->txframe[0] = GSM1_SOF;
 694                        len = gsm_stuff_frame(msg->data,
 695                                                gsm->txframe + 1, msg->len);
 696                        gsm->txframe[len + 1] = GSM1_SOF;
 697                        len += 2;
 698                } else {
 699                        gsm->txframe[0] = GSM0_SOF;
 700                        memcpy(gsm->txframe + 1 , msg->data, msg->len);
 701                        gsm->txframe[msg->len + 1] = GSM0_SOF;
 702                        len = msg->len + 2;
 703                }
 704
 705                if (debug & 4)
 706                        print_hex_dump_bytes("gsm_data_kick: ",
 707                                             DUMP_PREFIX_OFFSET,
 708                                             gsm->txframe, len);
 709
 710                if (gsm->output(gsm, gsm->txframe + skip_sof,
 711                                                len - skip_sof) < 0)
 712                        break;
 713                /* FIXME: Can eliminate one SOF in many more cases */
 714                gsm->tx_head = msg->next;
 715                if (gsm->tx_head == NULL)
 716                        gsm->tx_tail = NULL;
 717                gsm->tx_bytes -= msg->len;
 718                kfree(msg);
 719                /* For a burst of frames skip the extra SOF within the
 720                   burst */
 721                skip_sof = 1;
 722        }
 723}
 724
 725/**
 726 *      __gsm_data_queue                -       queue a UI or UIH frame
 727 *      @dlci: DLCI sending the data
 728 *      @msg: message queued
 729 *
 730 *      Add data to the transmit queue and try and get stuff moving
 731 *      out of the mux tty if not already doing so. The Caller must hold
 732 *      the gsm tx lock.
 733 */
 734
 735static void __gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
 736{
 737        struct gsm_mux *gsm = dlci->gsm;
 738        u8 *dp = msg->data;
 739        u8 *fcs = dp + msg->len;
 740
 741        /* Fill in the header */
 742        if (gsm->encoding == 0) {
 743                if (msg->len < 128)
 744                        *--dp = (msg->len << 1) | EA;
 745                else {
 746                        *--dp = (msg->len >> 7);        /* bits 7 - 15 */
 747                        *--dp = (msg->len & 127) << 1;  /* bits 0 - 6 */
 748                }
 749        }
 750
 751        *--dp = msg->ctrl;
 752        if (gsm->initiator)
 753                *--dp = (msg->addr << 2) | 2 | EA;
 754        else
 755                *--dp = (msg->addr << 2) | EA;
 756        *fcs = gsm_fcs_add_block(INIT_FCS, dp , msg->data - dp);
 757        /* Ugly protocol layering violation */
 758        if (msg->ctrl == UI || msg->ctrl == (UI|PF))
 759                *fcs = gsm_fcs_add_block(*fcs, msg->data, msg->len);
 760        *fcs = 0xFF - *fcs;
 761
 762        gsm_print_packet("Q> ", msg->addr, gsm->initiator, msg->ctrl,
 763                                                        msg->data, msg->len);
 764
 765        /* Move the header back and adjust the length, also allow for the FCS
 766           now tacked on the end */
 767        msg->len += (msg->data - dp) + 1;
 768        msg->data = dp;
 769
 770        /* Add to the actual output queue */
 771        if (gsm->tx_tail)
 772                gsm->tx_tail->next = msg;
 773        else
 774                gsm->tx_head = msg;
 775        gsm->tx_tail = msg;
 776        gsm->tx_bytes += msg->len;
 777        gsm_data_kick(gsm);
 778}
 779
 780/**
 781 *      gsm_data_queue          -       queue a UI or UIH frame
 782 *      @dlci: DLCI sending the data
 783 *      @msg: message queued
 784 *
 785 *      Add data to the transmit queue and try and get stuff moving
 786 *      out of the mux tty if not already doing so. Take the
 787 *      the gsm tx lock and dlci lock.
 788 */
 789
 790static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
 791{
 792        unsigned long flags;
 793        spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
 794        __gsm_data_queue(dlci, msg);
 795        spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
 796}
 797
 798/**
 799 *      gsm_dlci_data_output    -       try and push data out of a DLCI
 800 *      @gsm: mux
 801 *      @dlci: the DLCI to pull data from
 802 *
 803 *      Pull data from a DLCI and send it into the transmit queue if there
 804 *      is data. Keep to the MRU of the mux. This path handles the usual tty
 805 *      interface which is a byte stream with optional modem data.
 806 *
 807 *      Caller must hold the tx_lock of the mux.
 808 */
 809
 810static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci)
 811{
 812        struct gsm_msg *msg;
 813        u8 *dp;
 814        int len, total_size, size;
 815        int h = dlci->adaption - 1;
 816
 817        total_size = 0;
 818        while(1) {
 819                len = kfifo_len(dlci->fifo);
 820                if (len == 0)
 821                        return total_size;
 822
 823                /* MTU/MRU count only the data bits */
 824                if (len > gsm->mtu)
 825                        len = gsm->mtu;
 826
 827                size = len + h;
 828
 829                msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
 830                /* FIXME: need a timer or something to kick this so it can't
 831                   get stuck with no work outstanding and no buffer free */
 832                if (msg == NULL)
 833                        return -ENOMEM;
 834                dp = msg->data;
 835                switch (dlci->adaption) {
 836                case 1: /* Unstructured */
 837                        break;
 838                case 2: /* Unstructed with modem bits. Always one byte as we never
 839                           send inline break data */
 840                        *dp++ = gsm_encode_modem(dlci);
 841                        break;
 842                }
 843                WARN_ON(kfifo_out_locked(dlci->fifo, dp , len, &dlci->lock) != len);
 844                __gsm_data_queue(dlci, msg);
 845                total_size += size;
 846        }
 847        /* Bytes of data we used up */
 848        return total_size;
 849}
 850
 851/**
 852 *      gsm_dlci_data_output_framed  -  try and push data out of a DLCI
 853 *      @gsm: mux
 854 *      @dlci: the DLCI to pull data from
 855 *
 856 *      Pull data from a DLCI and send it into the transmit queue if there
 857 *      is data. Keep to the MRU of the mux. This path handles framed data
 858 *      queued as skbuffs to the DLCI.
 859 *
 860 *      Caller must hold the tx_lock of the mux.
 861 */
 862
 863static int gsm_dlci_data_output_framed(struct gsm_mux *gsm,
 864                                                struct gsm_dlci *dlci)
 865{
 866        struct gsm_msg *msg;
 867        u8 *dp;
 868        int len, size;
 869        int last = 0, first = 0;
 870        int overhead = 0;
 871
 872        /* One byte per frame is used for B/F flags */
 873        if (dlci->adaption == 4)
 874                overhead = 1;
 875
 876        /* dlci->skb is locked by tx_lock */
 877        if (dlci->skb == NULL) {
 878                dlci->skb = skb_dequeue(&dlci->skb_list);
 879                if (dlci->skb == NULL)
 880                        return 0;
 881                first = 1;
 882        }
 883        len = dlci->skb->len + overhead;
 884
 885        /* MTU/MRU count only the data bits */
 886        if (len > gsm->mtu) {
 887                if (dlci->adaption == 3) {
 888                        /* Over long frame, bin it */
 889                        kfree_skb(dlci->skb);
 890                        dlci->skb = NULL;
 891                        return 0;
 892                }
 893                len = gsm->mtu;
 894        } else
 895                last = 1;
 896
 897        size = len + overhead;
 898        msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
 899
 900        /* FIXME: need a timer or something to kick this so it can't
 901           get stuck with no work outstanding and no buffer free */
 902        if (msg == NULL)
 903                return -ENOMEM;
 904        dp = msg->data;
 905
 906        if (dlci->adaption == 4) { /* Interruptible framed (Packetised Data) */
 907                /* Flag byte to carry the start/end info */
 908                *dp++ = last << 7 | first << 6 | 1;     /* EA */
 909                len--;
 910        }
 911        memcpy(dp, dlci->skb->data, len);
 912        skb_pull(dlci->skb, len);
 913        __gsm_data_queue(dlci, msg);
 914        if (last) {
 915                kfree_skb(dlci->skb);
 916                dlci->skb = NULL;
 917        }
 918        return size;
 919}
 920
 921/**
 922 *      gsm_dlci_data_sweep             -       look for data to send
 923 *      @gsm: the GSM mux
 924 *
 925 *      Sweep the GSM mux channels in priority order looking for ones with
 926 *      data to send. We could do with optimising this scan a bit. We aim
 927 *      to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit
 928 *      TX_THRESH_LO we get called again
 929 *
 930 *      FIXME: We should round robin between groups and in theory you can
 931 *      renegotiate DLCI priorities with optional stuff. Needs optimising.
 932 */
 933
 934static void gsm_dlci_data_sweep(struct gsm_mux *gsm)
 935{
 936        int len;
 937        /* Priority ordering: We should do priority with RR of the groups */
 938        int i = 1;
 939
 940        while (i < NUM_DLCI) {
 941                struct gsm_dlci *dlci;
 942
 943                if (gsm->tx_bytes > TX_THRESH_HI)
 944                        break;
 945                dlci = gsm->dlci[i];
 946                if (dlci == NULL || dlci->constipated) {
 947                        i++;
 948                        continue;
 949                }
 950                if (dlci->adaption < 3 && !dlci->net)
 951                        len = gsm_dlci_data_output(gsm, dlci);
 952                else
 953                        len = gsm_dlci_data_output_framed(gsm, dlci);
 954                if (len < 0)
 955                        break;
 956                /* DLCI empty - try the next */
 957                if (len == 0)
 958                        i++;
 959        }
 960}
 961
 962/**
 963 *      gsm_dlci_data_kick      -       transmit if possible
 964 *      @dlci: DLCI to kick
 965 *
 966 *      Transmit data from this DLCI if the queue is empty. We can't rely on
 967 *      a tty wakeup except when we filled the pipe so we need to fire off
 968 *      new data ourselves in other cases.
 969 */
 970
 971static void gsm_dlci_data_kick(struct gsm_dlci *dlci)
 972{
 973        unsigned long flags;
 974
 975        spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
 976        /* If we have nothing running then we need to fire up */
 977        if (dlci->gsm->tx_bytes == 0) {
 978                if (dlci->net)
 979                        gsm_dlci_data_output_framed(dlci->gsm, dlci);
 980                else
 981                        gsm_dlci_data_output(dlci->gsm, dlci);
 982        } else if (dlci->gsm->tx_bytes < TX_THRESH_LO)
 983                gsm_dlci_data_sweep(dlci->gsm);
 984        spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
 985}
 986
 987/*
 988 *      Control message processing
 989 */
 990
 991
 992/**
 993 *      gsm_control_reply       -       send a response frame to a control
 994 *      @gsm: gsm channel
 995 *      @cmd: the command to use
 996 *      @data: data to follow encoded info
 997 *      @dlen: length of data
 998 *
 999 *      Encode up and queue a UI/UIH frame containing our response.
1000 */
1001
1002static void gsm_control_reply(struct gsm_mux *gsm, int cmd, u8 *data,
1003                                        int dlen)
1004{
1005        struct gsm_msg *msg;
1006        msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->ftype);
1007        if (msg == NULL)
1008                return;
1009        msg->data[0] = (cmd & 0xFE) << 1 | EA;  /* Clear C/R */
1010        msg->data[1] = (dlen << 1) | EA;
1011        memcpy(msg->data + 2, data, dlen);
1012        gsm_data_queue(gsm->dlci[0], msg);
1013}
1014
1015/**
1016 *      gsm_process_modem       -       process received modem status
1017 *      @tty: virtual tty bound to the DLCI
1018 *      @dlci: DLCI to affect
1019 *      @modem: modem bits (full EA)
1020 *
1021 *      Used when a modem control message or line state inline in adaption
1022 *      layer 2 is processed. Sort out the local modem state and throttles
1023 */
1024
1025static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci,
1026                                                        u32 modem, int clen)
1027{
1028        int  mlines = 0;
1029        u8 brk = 0;
1030
1031        /* The modem status command can either contain one octet (v.24 signals)
1032           or two octets (v.24 signals + break signals). The length field will
1033           either be 2 or 3 respectively. This is specified in section
1034           5.4.6.3.7 of the  27.010 mux spec. */
1035
1036        if (clen == 2)
1037                modem = modem & 0x7f;
1038        else {
1039                brk = modem & 0x7f;
1040                modem = (modem >> 7) & 0x7f;
1041        };
1042
1043        /* Flow control/ready to communicate */
1044        if (modem & MDM_FC) {
1045                /* Need to throttle our output on this device */
1046                dlci->constipated = 1;
1047        }
1048        if (modem & MDM_RTC) {
1049                mlines |= TIOCM_DSR | TIOCM_DTR;
1050                dlci->constipated = 0;
1051                gsm_dlci_data_kick(dlci);
1052        }
1053        /* Map modem bits */
1054        if (modem & MDM_RTR)
1055                mlines |= TIOCM_RTS | TIOCM_CTS;
1056        if (modem & MDM_IC)
1057                mlines |= TIOCM_RI;
1058        if (modem & MDM_DV)
1059                mlines |= TIOCM_CD;
1060
1061        /* Carrier drop -> hangup */
1062        if (tty) {
1063                if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD))
1064                        if (!(tty->termios->c_cflag & CLOCAL))
1065                                tty_hangup(tty);
1066                if (brk & 0x01)
1067                        tty_insert_flip_char(tty, 0, TTY_BREAK);
1068        }
1069        dlci->modem_rx = mlines;
1070}
1071
1072/**
1073 *      gsm_control_modem       -       modem status received
1074 *      @gsm: GSM channel
1075 *      @data: data following command
1076 *      @clen: command length
1077 *
1078 *      We have received a modem status control message. This is used by
1079 *      the GSM mux protocol to pass virtual modem line status and optionally
1080 *      to indicate break signals. Unpack it, convert to Linux representation
1081 *      and if need be stuff a break message down the tty.
1082 */
1083
1084static void gsm_control_modem(struct gsm_mux *gsm, u8 *data, int clen)
1085{
1086        unsigned int addr = 0;
1087        unsigned int modem = 0;
1088        struct gsm_dlci *dlci;
1089        int len = clen;
1090        u8 *dp = data;
1091        struct tty_struct *tty;
1092
1093        while (gsm_read_ea(&addr, *dp++) == 0) {
1094                len--;
1095                if (len == 0)
1096                        return;
1097        }
1098        /* Must be at least one byte following the EA */
1099        len--;
1100        if (len <= 0)
1101                return;
1102
1103        addr >>= 1;
1104        /* Closed port, or invalid ? */
1105        if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1106                return;
1107        dlci = gsm->dlci[addr];
1108
1109        while (gsm_read_ea(&modem, *dp++) == 0) {
1110                len--;
1111                if (len == 0)
1112                        return;
1113        }
1114        tty = tty_port_tty_get(&dlci->port);
1115        gsm_process_modem(tty, dlci, modem, clen);
1116        if (tty) {
1117                tty_wakeup(tty);
1118                tty_kref_put(tty);
1119        }
1120        gsm_control_reply(gsm, CMD_MSC, data, clen);
1121}
1122
1123/**
1124 *      gsm_control_rls         -       remote line status
1125 *      @gsm: GSM channel
1126 *      @data: data bytes
1127 *      @clen: data length
1128 *
1129 *      The modem sends us a two byte message on the control channel whenever
1130 *      it wishes to send us an error state from the virtual link. Stuff
1131 *      this into the uplink tty if present
1132 */
1133
1134static void gsm_control_rls(struct gsm_mux *gsm, u8 *data, int clen)
1135{
1136        struct tty_struct *tty;
1137        unsigned int addr = 0 ;
1138        u8 bits;
1139        int len = clen;
1140        u8 *dp = data;
1141
1142        while (gsm_read_ea(&addr, *dp++) == 0) {
1143                len--;
1144                if (len == 0)
1145                        return;
1146        }
1147        /* Must be at least one byte following ea */
1148        len--;
1149        if (len <= 0)
1150                return;
1151        addr >>= 1;
1152        /* Closed port, or invalid ? */
1153        if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1154                return;
1155        /* No error ? */
1156        bits = *dp;
1157        if ((bits & 1) == 0)
1158                return;
1159        /* See if we have an uplink tty */
1160        tty = tty_port_tty_get(&gsm->dlci[addr]->port);
1161
1162        if (tty) {
1163                if (bits & 2)
1164                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1165                if (bits & 4)
1166                        tty_insert_flip_char(tty, 0, TTY_PARITY);
1167                if (bits & 8)
1168                        tty_insert_flip_char(tty, 0, TTY_FRAME);
1169                tty_flip_buffer_push(tty);
1170                tty_kref_put(tty);
1171        }
1172        gsm_control_reply(gsm, CMD_RLS, data, clen);
1173}
1174
1175static void gsm_dlci_begin_close(struct gsm_dlci *dlci);
1176
1177/**
1178 *      gsm_control_message     -       DLCI 0 control processing
1179 *      @gsm: our GSM mux
1180 *      @command:  the command EA
1181 *      @data: data beyond the command/length EAs
1182 *      @clen: length
1183 *
1184 *      Input processor for control messages from the other end of the link.
1185 *      Processes the incoming request and queues a response frame or an
1186 *      NSC response if not supported
1187 */
1188
1189static void gsm_control_message(struct gsm_mux *gsm, unsigned int command,
1190                                                        u8 *data, int clen)
1191{
1192        u8 buf[1];
1193        switch (command) {
1194        case CMD_CLD: {
1195                struct gsm_dlci *dlci = gsm->dlci[0];
1196                /* Modem wishes to close down */
1197                if (dlci) {
1198                        dlci->dead = 1;
1199                        gsm->dead = 1;
1200                        gsm_dlci_begin_close(dlci);
1201                }
1202                }
1203                break;
1204        case CMD_TEST:
1205                /* Modem wishes to test, reply with the data */
1206                gsm_control_reply(gsm, CMD_TEST, data, clen);
1207                break;
1208        case CMD_FCON:
1209                /* Modem wants us to STFU */
1210                gsm->constipated = 1;
1211                gsm_control_reply(gsm, CMD_FCON, NULL, 0);
1212                break;
1213        case CMD_FCOFF:
1214                /* Modem can accept data again */
1215                gsm->constipated = 0;
1216                gsm_control_reply(gsm, CMD_FCOFF, NULL, 0);
1217                /* Kick the link in case it is idling */
1218                gsm_data_kick(gsm);
1219                break;
1220        case CMD_MSC:
1221                /* Out of band modem line change indicator for a DLCI */
1222                gsm_control_modem(gsm, data, clen);
1223                break;
1224        case CMD_RLS:
1225                /* Out of band error reception for a DLCI */
1226                gsm_control_rls(gsm, data, clen);
1227                break;
1228        case CMD_PSC:
1229                /* Modem wishes to enter power saving state */
1230                gsm_control_reply(gsm, CMD_PSC, NULL, 0);
1231                break;
1232                /* Optional unsupported commands */
1233        case CMD_PN:    /* Parameter negotiation */
1234        case CMD_RPN:   /* Remote port negotiation */
1235        case CMD_SNC:   /* Service negotiation command */
1236        default:
1237                /* Reply to bad commands with an NSC */
1238                buf[0] = command;
1239                gsm_control_reply(gsm, CMD_NSC, buf, 1);
1240                break;
1241        }
1242}
1243
1244/**
1245 *      gsm_control_response    -       process a response to our control
1246 *      @gsm: our GSM mux
1247 *      @command: the command (response) EA
1248 *      @data: data beyond the command/length EA
1249 *      @clen: length
1250 *
1251 *      Process a response to an outstanding command. We only allow a single
1252 *      control message in flight so this is fairly easy. All the clean up
1253 *      is done by the caller, we just update the fields, flag it as done
1254 *      and return
1255 */
1256
1257static void gsm_control_response(struct gsm_mux *gsm, unsigned int command,
1258                                                        u8 *data, int clen)
1259{
1260        struct gsm_control *ctrl;
1261        unsigned long flags;
1262
1263        spin_lock_irqsave(&gsm->control_lock, flags);
1264
1265        ctrl = gsm->pending_cmd;
1266        /* Does the reply match our command */
1267        command |= 1;
1268        if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) {
1269                /* Our command was replied to, kill the retry timer */
1270                del_timer(&gsm->t2_timer);
1271                gsm->pending_cmd = NULL;
1272                /* Rejected by the other end */
1273                if (command == CMD_NSC)
1274                        ctrl->error = -EOPNOTSUPP;
1275                ctrl->done = 1;
1276                wake_up(&gsm->event);
1277        }
1278        spin_unlock_irqrestore(&gsm->control_lock, flags);
1279}
1280
1281/**
1282 *      gsm_control_transmit    -       send control packet
1283 *      @gsm: gsm mux
1284 *      @ctrl: frame to send
1285 *
1286 *      Send out a pending control command (called under control lock)
1287 */
1288
1289static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl)
1290{
1291        struct gsm_msg *msg = gsm_data_alloc(gsm, 0, ctrl->len + 1, gsm->ftype);
1292        if (msg == NULL)
1293                return;
1294        msg->data[0] = (ctrl->cmd << 1) | 2 | EA;       /* command */
1295        memcpy(msg->data + 1, ctrl->data, ctrl->len);
1296        gsm_data_queue(gsm->dlci[0], msg);
1297}
1298
1299/**
1300 *      gsm_control_retransmit  -       retransmit a control frame
1301 *      @data: pointer to our gsm object
1302 *
1303 *      Called off the T2 timer expiry in order to retransmit control frames
1304 *      that have been lost in the system somewhere. The control_lock protects
1305 *      us from colliding with another sender or a receive completion event.
1306 *      In that situation the timer may still occur in a small window but
1307 *      gsm->pending_cmd will be NULL and we just let the timer expire.
1308 */
1309
1310static void gsm_control_retransmit(unsigned long data)
1311{
1312        struct gsm_mux *gsm = (struct gsm_mux *)data;
1313        struct gsm_control *ctrl;
1314        unsigned long flags;
1315        spin_lock_irqsave(&gsm->control_lock, flags);
1316        ctrl = gsm->pending_cmd;
1317        if (ctrl) {
1318                gsm->cretries--;
1319                if (gsm->cretries == 0) {
1320                        gsm->pending_cmd = NULL;
1321                        ctrl->error = -ETIMEDOUT;
1322                        ctrl->done = 1;
1323                        spin_unlock_irqrestore(&gsm->control_lock, flags);
1324                        wake_up(&gsm->event);
1325                        return;
1326                }
1327                gsm_control_transmit(gsm, ctrl);
1328                mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1329        }
1330        spin_unlock_irqrestore(&gsm->control_lock, flags);
1331}
1332
1333/**
1334 *      gsm_control_send        -       send a control frame on DLCI 0
1335 *      @gsm: the GSM channel
1336 *      @command: command  to send including CR bit
1337 *      @data: bytes of data (must be kmalloced)
1338 *      @len: length of the block to send
1339 *
1340 *      Queue and dispatch a control command. Only one command can be
1341 *      active at a time. In theory more can be outstanding but the matching
1342 *      gets really complicated so for now stick to one outstanding.
1343 */
1344
1345static struct gsm_control *gsm_control_send(struct gsm_mux *gsm,
1346                unsigned int command, u8 *data, int clen)
1347{
1348        struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control),
1349                                                GFP_KERNEL);
1350        unsigned long flags;
1351        if (ctrl == NULL)
1352                return NULL;
1353retry:
1354        wait_event(gsm->event, gsm->pending_cmd == NULL);
1355        spin_lock_irqsave(&gsm->control_lock, flags);
1356        if (gsm->pending_cmd != NULL) {
1357                spin_unlock_irqrestore(&gsm->control_lock, flags);
1358                goto retry;
1359        }
1360        ctrl->cmd = command;
1361        ctrl->data = data;
1362        ctrl->len = clen;
1363        gsm->pending_cmd = ctrl;
1364        gsm->cretries = gsm->n2;
1365        mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1366        gsm_control_transmit(gsm, ctrl);
1367        spin_unlock_irqrestore(&gsm->control_lock, flags);
1368        return ctrl;
1369}
1370
1371/**
1372 *      gsm_control_wait        -       wait for a control to finish
1373 *      @gsm: GSM mux
1374 *      @control: control we are waiting on
1375 *
1376 *      Waits for the control to complete or time out. Frees any used
1377 *      resources and returns 0 for success, or an error if the remote
1378 *      rejected or ignored the request.
1379 */
1380
1381static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control)
1382{
1383        int err;
1384        wait_event(gsm->event, control->done == 1);
1385        err = control->error;
1386        kfree(control);
1387        return err;
1388}
1389
1390
1391/*
1392 *      DLCI level handling: Needs krefs
1393 */
1394
1395/*
1396 *      State transitions and timers
1397 */
1398
1399/**
1400 *      gsm_dlci_close          -       a DLCI has closed
1401 *      @dlci: DLCI that closed
1402 *
1403 *      Perform processing when moving a DLCI into closed state. If there
1404 *      is an attached tty this is hung up
1405 */
1406
1407static void gsm_dlci_close(struct gsm_dlci *dlci)
1408{
1409        del_timer(&dlci->t1);
1410        if (debug & 8)
1411                pr_debug("DLCI %d goes closed.\n", dlci->addr);
1412        dlci->state = DLCI_CLOSED;
1413        if (dlci->addr != 0) {
1414                struct tty_struct  *tty = tty_port_tty_get(&dlci->port);
1415                if (tty) {
1416                        tty_hangup(tty);
1417                        tty_kref_put(tty);
1418                }
1419                kfifo_reset(dlci->fifo);
1420        } else
1421                dlci->gsm->dead = 1;
1422        wake_up(&dlci->gsm->event);
1423        /* A DLCI 0 close is a MUX termination so we need to kick that
1424           back to userspace somehow */
1425}
1426
1427/**
1428 *      gsm_dlci_open           -       a DLCI has opened
1429 *      @dlci: DLCI that opened
1430 *
1431 *      Perform processing when moving a DLCI into open state.
1432 */
1433
1434static void gsm_dlci_open(struct gsm_dlci *dlci)
1435{
1436        /* Note that SABM UA .. SABM UA first UA lost can mean that we go
1437           open -> open */
1438        del_timer(&dlci->t1);
1439        /* This will let a tty open continue */
1440        dlci->state = DLCI_OPEN;
1441        if (debug & 8)
1442                pr_debug("DLCI %d goes open.\n", dlci->addr);
1443        wake_up(&dlci->gsm->event);
1444}
1445
1446/**
1447 *      gsm_dlci_t1             -       T1 timer expiry
1448 *      @dlci: DLCI that opened
1449 *
1450 *      The T1 timer handles retransmits of control frames (essentially of
1451 *      SABM and DISC). We resend the command until the retry count runs out
1452 *      in which case an opening port goes back to closed and a closing port
1453 *      is simply put into closed state (any further frames from the other
1454 *      end will get a DM response)
1455 */
1456
1457static void gsm_dlci_t1(unsigned long data)
1458{
1459        struct gsm_dlci *dlci = (struct gsm_dlci *)data;
1460        struct gsm_mux *gsm = dlci->gsm;
1461
1462        switch (dlci->state) {
1463        case DLCI_OPENING:
1464                dlci->retries--;
1465                if (dlci->retries) {
1466                        gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1467                        mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1468                } else
1469                        gsm_dlci_close(dlci);
1470                break;
1471        case DLCI_CLOSING:
1472                dlci->retries--;
1473                if (dlci->retries) {
1474                        gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1475                        mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1476                } else
1477                        gsm_dlci_close(dlci);
1478                break;
1479        }
1480}
1481
1482/**
1483 *      gsm_dlci_begin_open     -       start channel open procedure
1484 *      @dlci: DLCI to open
1485 *
1486 *      Commence opening a DLCI from the Linux side. We issue SABM messages
1487 *      to the modem which should then reply with a UA, at which point we
1488 *      will move into open state. Opening is done asynchronously with retry
1489 *      running off timers and the responses.
1490 */
1491
1492static void gsm_dlci_begin_open(struct gsm_dlci *dlci)
1493{
1494        struct gsm_mux *gsm = dlci->gsm;
1495        if (dlci->state == DLCI_OPEN || dlci->state == DLCI_OPENING)
1496                return;
1497        dlci->retries = gsm->n2;
1498        dlci->state = DLCI_OPENING;
1499        gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1500        mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1501}
1502
1503/**
1504 *      gsm_dlci_begin_close    -       start channel open procedure
1505 *      @dlci: DLCI to open
1506 *
1507 *      Commence closing a DLCI from the Linux side. We issue DISC messages
1508 *      to the modem which should then reply with a UA, at which point we
1509 *      will move into closed state. Closing is done asynchronously with retry
1510 *      off timers. We may also receive a DM reply from the other end which
1511 *      indicates the channel was already closed.
1512 */
1513
1514static void gsm_dlci_begin_close(struct gsm_dlci *dlci)
1515{
1516        struct gsm_mux *gsm = dlci->gsm;
1517        if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING)
1518                return;
1519        dlci->retries = gsm->n2;
1520        dlci->state = DLCI_CLOSING;
1521        gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1522        mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1523}
1524
1525/**
1526 *      gsm_dlci_data           -       data arrived
1527 *      @dlci: channel
1528 *      @data: block of bytes received
1529 *      @len: length of received block
1530 *
1531 *      A UI or UIH frame has arrived which contains data for a channel
1532 *      other than the control channel. If the relevant virtual tty is
1533 *      open we shovel the bits down it, if not we drop them.
1534 */
1535
1536static void gsm_dlci_data(struct gsm_dlci *dlci, u8 *data, int clen)
1537{
1538        /* krefs .. */
1539        struct tty_port *port = &dlci->port;
1540        struct tty_struct *tty = tty_port_tty_get(port);
1541        unsigned int modem = 0;
1542        int len = clen;
1543
1544        if (debug & 16)
1545                pr_debug("%d bytes for tty %p\n", len, tty);
1546        if (tty) {
1547                switch (dlci->adaption)  {
1548                /* Unsupported types */
1549                /* Packetised interruptible data */
1550                case 4:
1551                        break;
1552                /* Packetised uininterruptible voice/data */
1553                case 3:
1554                        break;
1555                /* Asynchronous serial with line state in each frame */
1556                case 2:
1557                        while (gsm_read_ea(&modem, *data++) == 0) {
1558                                len--;
1559                                if (len == 0)
1560                                        return;
1561                        }
1562                        gsm_process_modem(tty, dlci, modem, clen);
1563                /* Line state will go via DLCI 0 controls only */
1564                case 1:
1565                default:
1566                        tty_insert_flip_string(tty, data, len);
1567                        tty_flip_buffer_push(tty);
1568                }
1569                tty_kref_put(tty);
1570        }
1571}
1572
1573/**
1574 *      gsm_dlci_control        -       data arrived on control channel
1575 *      @dlci: channel
1576 *      @data: block of bytes received
1577 *      @len: length of received block
1578 *
1579 *      A UI or UIH frame has arrived which contains data for DLCI 0 the
1580 *      control channel. This should contain a command EA followed by
1581 *      control data bytes. The command EA contains a command/response bit
1582 *      and we divide up the work accordingly.
1583 */
1584
1585static void gsm_dlci_command(struct gsm_dlci *dlci, u8 *data, int len)
1586{
1587        /* See what command is involved */
1588        unsigned int command = 0;
1589        while (len-- > 0) {
1590                if (gsm_read_ea(&command, *data++) == 1) {
1591                        int clen = *data++;
1592                        len--;
1593                        /* FIXME: this is properly an EA */
1594                        clen >>= 1;
1595                        /* Malformed command ? */
1596                        if (clen > len)
1597                                return;
1598                        if (command & 1)
1599                                gsm_control_message(dlci->gsm, command,
1600                                                                data, clen);
1601                        else
1602                                gsm_control_response(dlci->gsm, command,
1603                                                                data, clen);
1604                        return;
1605                }
1606        }
1607}
1608
1609/*
1610 *      Allocate/Free DLCI channels
1611 */
1612
1613/**
1614 *      gsm_dlci_alloc          -       allocate a DLCI
1615 *      @gsm: GSM mux
1616 *      @addr: address of the DLCI
1617 *
1618 *      Allocate and install a new DLCI object into the GSM mux.
1619 *
1620 *      FIXME: review locking races
1621 */
1622
1623static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr)
1624{
1625        struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC);
1626        if (dlci == NULL)
1627                return NULL;
1628        spin_lock_init(&dlci->lock);
1629        kref_init(&dlci->ref);
1630        mutex_init(&dlci->mutex);
1631        dlci->fifo = &dlci->_fifo;
1632        if (kfifo_alloc(&dlci->_fifo, 4096, GFP_KERNEL) < 0) {
1633                kfree(dlci);
1634                return NULL;
1635        }
1636
1637        skb_queue_head_init(&dlci->skb_list);
1638        init_timer(&dlci->t1);
1639        dlci->t1.function = gsm_dlci_t1;
1640        dlci->t1.data = (unsigned long)dlci;
1641        tty_port_init(&dlci->port);
1642        dlci->port.ops = &gsm_port_ops;
1643        dlci->gsm = gsm;
1644        dlci->addr = addr;
1645        dlci->adaption = gsm->adaption;
1646        dlci->state = DLCI_CLOSED;
1647        if (addr)
1648                dlci->data = gsm_dlci_data;
1649        else
1650                dlci->data = gsm_dlci_command;
1651        gsm->dlci[addr] = dlci;
1652        return dlci;
1653}
1654
1655/**
1656 *      gsm_dlci_free           -       free DLCI
1657 *      @dlci: DLCI to free
1658 *
1659 *      Free up a DLCI.
1660 *
1661 *      Can sleep.
1662 */
1663static void gsm_dlci_free(struct kref *ref)
1664{
1665        struct gsm_dlci *dlci = container_of(ref, struct gsm_dlci, ref);
1666
1667        del_timer_sync(&dlci->t1);
1668        dlci->gsm->dlci[dlci->addr] = NULL;
1669        kfifo_free(dlci->fifo);
1670        while ((dlci->skb = skb_dequeue(&dlci->skb_list)))
1671                kfree_skb(dlci->skb);
1672        kfree(dlci);
1673}
1674
1675static inline void dlci_get(struct gsm_dlci *dlci)
1676{
1677        kref_get(&dlci->ref);
1678}
1679
1680static inline void dlci_put(struct gsm_dlci *dlci)
1681{
1682        kref_put(&dlci->ref, gsm_dlci_free);
1683}
1684
1685/**
1686 *      gsm_dlci_release                -       release DLCI
1687 *      @dlci: DLCI to destroy
1688 *
1689 *      Release a DLCI. Actual free is deferred until either
1690 *      mux is closed or tty is closed - whichever is last.
1691 *
1692 *      Can sleep.
1693 */
1694static void gsm_dlci_release(struct gsm_dlci *dlci)
1695{
1696        struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1697        if (tty) {
1698                tty_vhangup(tty);
1699                tty_kref_put(tty);
1700        }
1701        dlci_put(dlci);
1702}
1703
1704/*
1705 *      LAPBish link layer logic
1706 */
1707
1708/**
1709 *      gsm_queue               -       a GSM frame is ready to process
1710 *      @gsm: pointer to our gsm mux
1711 *
1712 *      At this point in time a frame has arrived and been demangled from
1713 *      the line encoding. All the differences between the encodings have
1714 *      been handled below us and the frame is unpacked into the structures.
1715 *      The fcs holds the header FCS but any data FCS must be added here.
1716 */
1717
1718static void gsm_queue(struct gsm_mux *gsm)
1719{
1720        struct gsm_dlci *dlci;
1721        u8 cr;
1722        int address;
1723        /* We have to sneak a look at the packet body to do the FCS.
1724           A somewhat layering violation in the spec */
1725
1726        if ((gsm->control & ~PF) == UI)
1727                gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, gsm->len);
1728        if (gsm->encoding == 0){
1729                /* WARNING: gsm->received_fcs is used for gsm->encoding = 0 only.
1730                            In this case it contain the last piece of data
1731                            required to generate final CRC */
1732                gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->received_fcs);
1733        }
1734        if (gsm->fcs != GOOD_FCS) {
1735                gsm->bad_fcs++;
1736                if (debug & 4)
1737                        pr_debug("BAD FCS %02x\n", gsm->fcs);
1738                return;
1739        }
1740        address = gsm->address >> 1;
1741        if (address >= NUM_DLCI)
1742                goto invalid;
1743
1744        cr = gsm->address & 1;          /* C/R bit */
1745
1746        gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len);
1747
1748        cr ^= 1 - gsm->initiator;       /* Flip so 1 always means command */
1749        dlci = gsm->dlci[address];
1750
1751        switch (gsm->control) {
1752        case SABM|PF:
1753                if (cr == 0)
1754                        goto invalid;
1755                if (dlci == NULL)
1756                        dlci = gsm_dlci_alloc(gsm, address);
1757                if (dlci == NULL)
1758                        return;
1759                if (dlci->dead)
1760                        gsm_response(gsm, address, DM);
1761                else {
1762                        gsm_response(gsm, address, UA);
1763                        gsm_dlci_open(dlci);
1764                }
1765                break;
1766        case DISC|PF:
1767                if (cr == 0)
1768                        goto invalid;
1769                if (dlci == NULL || dlci->state == DLCI_CLOSED) {
1770                        gsm_response(gsm, address, DM);
1771                        return;
1772                }
1773                /* Real close complete */
1774                gsm_response(gsm, address, UA);
1775                gsm_dlci_close(dlci);
1776                break;
1777        case UA:
1778        case UA|PF:
1779                if (cr == 0 || dlci == NULL)
1780                        break;
1781                switch (dlci->state) {
1782                case DLCI_CLOSING:
1783                        gsm_dlci_close(dlci);
1784                        break;
1785                case DLCI_OPENING:
1786                        gsm_dlci_open(dlci);
1787                        break;
1788                }
1789                break;
1790        case DM:        /* DM can be valid unsolicited */
1791        case DM|PF:
1792                if (cr)
1793                        goto invalid;
1794                if (dlci == NULL)
1795                        return;
1796                gsm_dlci_close(dlci);
1797                break;
1798        case UI:
1799        case UI|PF:
1800        case UIH:
1801        case UIH|PF:
1802#if 0
1803                if (cr)
1804                        goto invalid;
1805#endif
1806                if (dlci == NULL || dlci->state != DLCI_OPEN) {
1807                        gsm_command(gsm, address, DM|PF);
1808                        return;
1809                }
1810                dlci->data(dlci, gsm->buf, gsm->len);
1811                break;
1812        default:
1813                goto invalid;
1814        }
1815        return;
1816invalid:
1817        gsm->malformed++;
1818        return;
1819}
1820
1821
1822/**
1823 *      gsm0_receive    -       perform processing for non-transparency
1824 *      @gsm: gsm data for this ldisc instance
1825 *      @c: character
1826 *
1827 *      Receive bytes in gsm mode 0
1828 */
1829
1830static void gsm0_receive(struct gsm_mux *gsm, unsigned char c)
1831{
1832        unsigned int len;
1833
1834        switch (gsm->state) {
1835        case GSM_SEARCH:        /* SOF marker */
1836                if (c == GSM0_SOF) {
1837                        gsm->state = GSM_ADDRESS;
1838                        gsm->address = 0;
1839                        gsm->len = 0;
1840                        gsm->fcs = INIT_FCS;
1841                }
1842                break;
1843        case GSM_ADDRESS:       /* Address EA */
1844                gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1845                if (gsm_read_ea(&gsm->address, c))
1846                        gsm->state = GSM_CONTROL;
1847                break;
1848        case GSM_CONTROL:       /* Control Byte */
1849                gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1850                gsm->control = c;
1851                gsm->state = GSM_LEN0;
1852                break;
1853        case GSM_LEN0:          /* Length EA */
1854                gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1855                if (gsm_read_ea(&gsm->len, c)) {
1856                        if (gsm->len > gsm->mru) {
1857                                gsm->bad_size++;
1858                                gsm->state = GSM_SEARCH;
1859                                break;
1860                        }
1861                        gsm->count = 0;
1862                        if (!gsm->len)
1863                                gsm->state = GSM_FCS;
1864                        else
1865                                gsm->state = GSM_DATA;
1866                        break;
1867                }
1868                gsm->state = GSM_LEN1;
1869                break;
1870        case GSM_LEN1:
1871                gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1872                len = c;
1873                gsm->len |= len << 7;
1874                if (gsm->len > gsm->mru) {
1875                        gsm->bad_size++;
1876                        gsm->state = GSM_SEARCH;
1877                        break;
1878                }
1879                gsm->count = 0;
1880                if (!gsm->len)
1881                        gsm->state = GSM_FCS;
1882                else
1883                        gsm->state = GSM_DATA;
1884                break;
1885        case GSM_DATA:          /* Data */
1886                gsm->buf[gsm->count++] = c;
1887                if (gsm->count == gsm->len)
1888                        gsm->state = GSM_FCS;
1889                break;
1890        case GSM_FCS:           /* FCS follows the packet */
1891                gsm->received_fcs = c;
1892                gsm_queue(gsm);
1893                gsm->state = GSM_SSOF;
1894                break;
1895        case GSM_SSOF:
1896                if (c == GSM0_SOF) {
1897                        gsm->state = GSM_SEARCH;
1898                        break;
1899                }
1900                break;
1901        }
1902}
1903
1904/**
1905 *      gsm1_receive    -       perform processing for non-transparency
1906 *      @gsm: gsm data for this ldisc instance
1907 *      @c: character
1908 *
1909 *      Receive bytes in mode 1 (Advanced option)
1910 */
1911
1912static void gsm1_receive(struct gsm_mux *gsm, unsigned char c)
1913{
1914        if (c == GSM1_SOF) {
1915                /* EOF is only valid in frame if we have got to the data state
1916                   and received at least one byte (the FCS) */
1917                if (gsm->state == GSM_DATA && gsm->count) {
1918                        /* Extract the FCS */
1919                        gsm->count--;
1920                        gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]);
1921                        gsm->len = gsm->count;
1922                        gsm_queue(gsm);
1923                        gsm->state  = GSM_START;
1924                        return;
1925                }
1926                /* Any partial frame was a runt so go back to start */
1927                if (gsm->state != GSM_START) {
1928                        gsm->malformed++;
1929                        gsm->state = GSM_START;
1930                }
1931                /* A SOF in GSM_START means we are still reading idling or
1932                   framing bytes */
1933                return;
1934        }
1935
1936        if (c == GSM1_ESCAPE) {
1937                gsm->escape = 1;
1938                return;
1939        }
1940
1941        /* Only an unescaped SOF gets us out of GSM search */
1942        if (gsm->state == GSM_SEARCH)
1943                return;
1944
1945        if (gsm->escape) {
1946                c ^= GSM1_ESCAPE_BITS;
1947                gsm->escape = 0;
1948        }
1949        switch (gsm->state) {
1950        case GSM_START:         /* First byte after SOF */
1951                gsm->address = 0;
1952                gsm->state = GSM_ADDRESS;
1953                gsm->fcs = INIT_FCS;
1954                /* Drop through */
1955        case GSM_ADDRESS:       /* Address continuation */
1956                gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1957                if (gsm_read_ea(&gsm->address, c))
1958                        gsm->state = GSM_CONTROL;
1959                break;
1960        case GSM_CONTROL:       /* Control Byte */
1961                gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1962                gsm->control = c;
1963                gsm->count = 0;
1964                gsm->state = GSM_DATA;
1965                break;
1966        case GSM_DATA:          /* Data */
1967                if (gsm->count > gsm->mru) {    /* Allow one for the FCS */
1968                        gsm->state = GSM_OVERRUN;
1969                        gsm->bad_size++;
1970                } else
1971                        gsm->buf[gsm->count++] = c;
1972                break;
1973        case GSM_OVERRUN:       /* Over-long - eg a dropped SOF */
1974                break;
1975        }
1976}
1977
1978/**
1979 *      gsm_error               -       handle tty error
1980 *      @gsm: ldisc data
1981 *      @data: byte received (may be invalid)
1982 *      @flag: error received
1983 *
1984 *      Handle an error in the receipt of data for a frame. Currently we just
1985 *      go back to hunting for a SOF.
1986 *
1987 *      FIXME: better diagnostics ?
1988 */
1989
1990static void gsm_error(struct gsm_mux *gsm,
1991                                unsigned char data, unsigned char flag)
1992{
1993        gsm->state = GSM_SEARCH;
1994        gsm->io_error++;
1995}
1996
1997/**
1998 *      gsm_cleanup_mux         -       generic GSM protocol cleanup
1999 *      @gsm: our mux
2000 *
2001 *      Clean up the bits of the mux which are the same for all framing
2002 *      protocols. Remove the mux from the mux table, stop all the timers
2003 *      and then shut down each device hanging up the channels as we go.
2004 */
2005
2006void gsm_cleanup_mux(struct gsm_mux *gsm)
2007{
2008        int i;
2009        struct gsm_dlci *dlci = gsm->dlci[0];
2010        struct gsm_msg *txq;
2011        struct gsm_control *gc;
2012
2013        gsm->dead = 1;
2014
2015        spin_lock(&gsm_mux_lock);
2016        for (i = 0; i < MAX_MUX; i++) {
2017                if (gsm_mux[i] == gsm) {
2018                        gsm_mux[i] = NULL;
2019                        break;
2020                }
2021        }
2022        spin_unlock(&gsm_mux_lock);
2023        WARN_ON(i == MAX_MUX);
2024
2025        /* In theory disconnecting DLCI 0 is sufficient but for some
2026           modems this is apparently not the case. */
2027        if (dlci) {
2028                gc = gsm_control_send(gsm, CMD_CLD, NULL, 0);
2029                if (gc)
2030                        gsm_control_wait(gsm, gc);
2031        }
2032        del_timer_sync(&gsm->t2_timer);
2033        /* Now we are sure T2 has stopped */
2034        if (dlci) {
2035                dlci->dead = 1;
2036                gsm_dlci_begin_close(dlci);
2037                wait_event_interruptible(gsm->event,
2038                                        dlci->state == DLCI_CLOSED);
2039        }
2040        /* Free up any link layer users */
2041        for (i = 0; i < NUM_DLCI; i++)
2042                if (gsm->dlci[i])
2043                        gsm_dlci_release(gsm->dlci[i]);
2044        /* Now wipe the queues */
2045        for (txq = gsm->tx_head; txq != NULL; txq = gsm->tx_head) {
2046                gsm->tx_head = txq->next;
2047                kfree(txq);
2048        }
2049        gsm->tx_tail = NULL;
2050}
2051EXPORT_SYMBOL_GPL(gsm_cleanup_mux);
2052
2053/**
2054 *      gsm_activate_mux        -       generic GSM setup
2055 *      @gsm: our mux
2056 *
2057 *      Set up the bits of the mux which are the same for all framing
2058 *      protocols. Add the mux to the mux table so it can be opened and
2059 *      finally kick off connecting to DLCI 0 on the modem.
2060 */
2061
2062int gsm_activate_mux(struct gsm_mux *gsm)
2063{
2064        struct gsm_dlci *dlci;
2065        int i = 0;
2066
2067        init_timer(&gsm->t2_timer);
2068        gsm->t2_timer.function = gsm_control_retransmit;
2069        gsm->t2_timer.data = (unsigned long)gsm;
2070        init_waitqueue_head(&gsm->event);
2071        spin_lock_init(&gsm->control_lock);
2072        spin_lock_init(&gsm->tx_lock);
2073
2074        if (gsm->encoding == 0)
2075                gsm->receive = gsm0_receive;
2076        else
2077                gsm->receive = gsm1_receive;
2078        gsm->error = gsm_error;
2079
2080        spin_lock(&gsm_mux_lock);
2081        for (i = 0; i < MAX_MUX; i++) {
2082                if (gsm_mux[i] == NULL) {
2083                        gsm->num = i;
2084                        gsm_mux[i] = gsm;
2085                        break;
2086                }
2087        }
2088        spin_unlock(&gsm_mux_lock);
2089        if (i == MAX_MUX)
2090                return -EBUSY;
2091
2092        dlci = gsm_dlci_alloc(gsm, 0);
2093        if (dlci == NULL)
2094                return -ENOMEM;
2095        gsm->dead = 0;          /* Tty opens are now permissible */
2096        return 0;
2097}
2098EXPORT_SYMBOL_GPL(gsm_activate_mux);
2099
2100/**
2101 *      gsm_free_mux            -       free up a mux
2102 *      @mux: mux to free
2103 *
2104 *      Dispose of allocated resources for a dead mux
2105 */
2106void gsm_free_mux(struct gsm_mux *gsm)
2107{
2108        kfree(gsm->txframe);
2109        kfree(gsm->buf);
2110        kfree(gsm);
2111}
2112EXPORT_SYMBOL_GPL(gsm_free_mux);
2113
2114/**
2115 *      gsm_free_muxr           -       free up a mux
2116 *      @mux: mux to free
2117 *
2118 *      Dispose of allocated resources for a dead mux
2119 */
2120static void gsm_free_muxr(struct kref *ref)
2121{
2122        struct gsm_mux *gsm = container_of(ref, struct gsm_mux, ref);
2123        gsm_free_mux(gsm);
2124}
2125
2126static inline void mux_get(struct gsm_mux *gsm)
2127{
2128        kref_get(&gsm->ref);
2129}
2130
2131static inline void mux_put(struct gsm_mux *gsm)
2132{
2133        kref_put(&gsm->ref, gsm_free_muxr);
2134}
2135
2136/**
2137 *      gsm_alloc_mux           -       allocate a mux
2138 *
2139 *      Creates a new mux ready for activation.
2140 */
2141
2142struct gsm_mux *gsm_alloc_mux(void)
2143{
2144        struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL);
2145        if (gsm == NULL)
2146                return NULL;
2147        gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL);
2148        if (gsm->buf == NULL) {
2149                kfree(gsm);
2150                return NULL;
2151        }
2152        gsm->txframe = kmalloc(2 * MAX_MRU + 2, GFP_KERNEL);
2153        if (gsm->txframe == NULL) {
2154                kfree(gsm->buf);
2155                kfree(gsm);
2156                return NULL;
2157        }
2158        spin_lock_init(&gsm->lock);
2159        kref_init(&gsm->ref);
2160
2161        gsm->t1 = T1;
2162        gsm->t2 = T2;
2163        gsm->n2 = N2;
2164        gsm->ftype = UIH;
2165        gsm->adaption = 1;
2166        gsm->encoding = 1;
2167        gsm->mru = 64;  /* Default to encoding 1 so these should be 64 */
2168        gsm->mtu = 64;
2169        gsm->dead = 1;  /* Avoid early tty opens */
2170
2171        return gsm;
2172}
2173EXPORT_SYMBOL_GPL(gsm_alloc_mux);
2174
2175/**
2176 *      gsmld_output            -       write to link
2177 *      @gsm: our mux
2178 *      @data: bytes to output
2179 *      @len: size
2180 *
2181 *      Write a block of data from the GSM mux to the data channel. This
2182 *      will eventually be serialized from above but at the moment isn't.
2183 */
2184
2185static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len)
2186{
2187        if (tty_write_room(gsm->tty) < len) {
2188                set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags);
2189                return -ENOSPC;
2190        }
2191        if (debug & 4)
2192                print_hex_dump_bytes("gsmld_output: ", DUMP_PREFIX_OFFSET,
2193                                     data, len);
2194        gsm->tty->ops->write(gsm->tty, data, len);
2195        return len;
2196}
2197
2198/**
2199 *      gsmld_attach_gsm        -       mode set up
2200 *      @tty: our tty structure
2201 *      @gsm: our mux
2202 *
2203 *      Set up the MUX for basic mode and commence connecting to the
2204 *      modem. Currently called from the line discipline set up but
2205 *      will need moving to an ioctl path.
2206 */
2207
2208static int gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2209{
2210        int ret, i;
2211        int base = gsm->num << 6; /* Base for this MUX */
2212
2213        gsm->tty = tty_kref_get(tty);
2214        gsm->output = gsmld_output;
2215        ret =  gsm_activate_mux(gsm);
2216        if (ret != 0)
2217                tty_kref_put(gsm->tty);
2218        else {
2219                /* Don't register device 0 - this is the control channel and not
2220                   a usable tty interface */
2221                for (i = 1; i < NUM_DLCI; i++)
2222                        tty_register_device(gsm_tty_driver, base + i, NULL);
2223        }
2224        return ret;
2225}
2226
2227
2228/**
2229 *      gsmld_detach_gsm        -       stop doing 0710 mux
2230 *      @tty: tty attached to the mux
2231 *      @gsm: mux
2232 *
2233 *      Shutdown and then clean up the resources used by the line discipline
2234 */
2235
2236static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2237{
2238        int i;
2239        int base = gsm->num << 6; /* Base for this MUX */
2240
2241        WARN_ON(tty != gsm->tty);
2242        for (i = 1; i < NUM_DLCI; i++)
2243                tty_unregister_device(gsm_tty_driver, base + i);
2244        gsm_cleanup_mux(gsm);
2245        tty_kref_put(gsm->tty);
2246        gsm->tty = NULL;
2247}
2248
2249static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp,
2250                              char *fp, int count)
2251{
2252        struct gsm_mux *gsm = tty->disc_data;
2253        const unsigned char *dp;
2254        char *f;
2255        int i;
2256        char buf[64];
2257        char flags;
2258
2259        if (debug & 4)
2260                print_hex_dump_bytes("gsmld_receive: ", DUMP_PREFIX_OFFSET,
2261                                     cp, count);
2262
2263        for (i = count, dp = cp, f = fp; i; i--, dp++) {
2264                flags = *f++;
2265                switch (flags) {
2266                case TTY_NORMAL:
2267                        gsm->receive(gsm, *dp);
2268                        break;
2269                case TTY_OVERRUN:
2270                case TTY_BREAK:
2271                case TTY_PARITY:
2272                case TTY_FRAME:
2273                        gsm->error(gsm, *dp, flags);
2274                        break;
2275                default:
2276                        WARN_ONCE("%s: unknown flag %d\n",
2277                               tty_name(tty, buf), flags);
2278                        break;
2279                }
2280        }
2281        /* FASYNC if needed ? */
2282        /* If clogged call tty_throttle(tty); */
2283}
2284
2285/**
2286 *      gsmld_chars_in_buffer   -       report available bytes
2287 *      @tty: tty device
2288 *
2289 *      Report the number of characters buffered to be delivered to user
2290 *      at this instant in time.
2291 *
2292 *      Locking: gsm lock
2293 */
2294
2295static ssize_t gsmld_chars_in_buffer(struct tty_struct *tty)
2296{
2297        return 0;
2298}
2299
2300/**
2301 *      gsmld_flush_buffer      -       clean input queue
2302 *      @tty:   terminal device
2303 *
2304 *      Flush the input buffer. Called when the line discipline is
2305 *      being closed, when the tty layer wants the buffer flushed (eg
2306 *      at hangup).
2307 */
2308
2309static void gsmld_flush_buffer(struct tty_struct *tty)
2310{
2311}
2312
2313/**
2314 *      gsmld_close             -       close the ldisc for this tty
2315 *      @tty: device
2316 *
2317 *      Called from the terminal layer when this line discipline is
2318 *      being shut down, either because of a close or becsuse of a
2319 *      discipline change. The function will not be called while other
2320 *      ldisc methods are in progress.
2321 */
2322
2323static void gsmld_close(struct tty_struct *tty)
2324{
2325        struct gsm_mux *gsm = tty->disc_data;
2326
2327        gsmld_detach_gsm(tty, gsm);
2328
2329        gsmld_flush_buffer(tty);
2330        /* Do other clean up here */
2331        mux_put(gsm);
2332}
2333
2334/**
2335 *      gsmld_open              -       open an ldisc
2336 *      @tty: terminal to open
2337 *
2338 *      Called when this line discipline is being attached to the
2339 *      terminal device. Can sleep. Called serialized so that no
2340 *      other events will occur in parallel. No further open will occur
2341 *      until a close.
2342 */
2343
2344static int gsmld_open(struct tty_struct *tty)
2345{
2346        struct gsm_mux *gsm;
2347
2348        if (tty->ops->write == NULL)
2349                return -EINVAL;
2350
2351        /* Attach our ldisc data */
2352        gsm = gsm_alloc_mux();
2353        if (gsm == NULL)
2354                return -ENOMEM;
2355
2356        tty->disc_data = gsm;
2357        tty->receive_room = 65536;
2358
2359        /* Attach the initial passive connection */
2360        gsm->encoding = 1;
2361        return gsmld_attach_gsm(tty, gsm);
2362}
2363
2364/**
2365 *      gsmld_write_wakeup      -       asynchronous I/O notifier
2366 *      @tty: tty device
2367 *
2368 *      Required for the ptys, serial driver etc. since processes
2369 *      that attach themselves to the master and rely on ASYNC
2370 *      IO must be woken up
2371 */
2372
2373static void gsmld_write_wakeup(struct tty_struct *tty)
2374{
2375        struct gsm_mux *gsm = tty->disc_data;
2376        unsigned long flags;
2377
2378        /* Queue poll */
2379        clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2380        gsm_data_kick(gsm);
2381        if (gsm->tx_bytes < TX_THRESH_LO) {
2382                spin_lock_irqsave(&gsm->tx_lock, flags);
2383                gsm_dlci_data_sweep(gsm);
2384                spin_unlock_irqrestore(&gsm->tx_lock, flags);
2385        }
2386}
2387
2388/**
2389 *      gsmld_read              -       read function for tty
2390 *      @tty: tty device
2391 *      @file: file object
2392 *      @buf: userspace buffer pointer
2393 *      @nr: size of I/O
2394 *
2395 *      Perform reads for the line discipline. We are guaranteed that the
2396 *      line discipline will not be closed under us but we may get multiple
2397 *      parallel readers and must handle this ourselves. We may also get
2398 *      a hangup. Always called in user context, may sleep.
2399 *
2400 *      This code must be sure never to sleep through a hangup.
2401 */
2402
2403static ssize_t gsmld_read(struct tty_struct *tty, struct file *file,
2404                         unsigned char __user *buf, size_t nr)
2405{
2406        return -EOPNOTSUPP;
2407}
2408
2409/**
2410 *      gsmld_write             -       write function for tty
2411 *      @tty: tty device
2412 *      @file: file object
2413 *      @buf: userspace buffer pointer
2414 *      @nr: size of I/O
2415 *
2416 *      Called when the owner of the device wants to send a frame
2417 *      itself (or some other control data). The data is transferred
2418 *      as-is and must be properly framed and checksummed as appropriate
2419 *      by userspace. Frames are either sent whole or not at all as this
2420 *      avoids pain user side.
2421 */
2422
2423static ssize_t gsmld_write(struct tty_struct *tty, struct file *file,
2424                           const unsigned char *buf, size_t nr)
2425{
2426        int space = tty_write_room(tty);
2427        if (space >= nr)
2428                return tty->ops->write(tty, buf, nr);
2429        set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2430        return -ENOBUFS;
2431}
2432
2433/**
2434 *      gsmld_poll              -       poll method for N_GSM0710
2435 *      @tty: terminal device
2436 *      @file: file accessing it
2437 *      @wait: poll table
2438 *
2439 *      Called when the line discipline is asked to poll() for data or
2440 *      for special events. This code is not serialized with respect to
2441 *      other events save open/close.
2442 *
2443 *      This code must be sure never to sleep through a hangup.
2444 *      Called without the kernel lock held - fine
2445 */
2446
2447static unsigned int gsmld_poll(struct tty_struct *tty, struct file *file,
2448                                                        poll_table *wait)
2449{
2450        unsigned int mask = 0;
2451        struct gsm_mux *gsm = tty->disc_data;
2452
2453        poll_wait(file, &tty->read_wait, wait);
2454        poll_wait(file, &tty->write_wait, wait);
2455        if (tty_hung_up_p(file))
2456                mask |= POLLHUP;
2457        if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0)
2458                mask |= POLLOUT | POLLWRNORM;
2459        if (gsm->dead)
2460                mask |= POLLHUP;
2461        return mask;
2462}
2463
2464static int gsmld_config(struct tty_struct *tty, struct gsm_mux *gsm,
2465                                                        struct gsm_config *c)
2466{
2467        int need_close = 0;
2468        int need_restart = 0;
2469
2470        /* Stuff we don't support yet - UI or I frame transport, windowing */
2471        if ((c->adaption != 1 && c->adaption != 2) || c->k)
2472                return -EOPNOTSUPP;
2473        /* Check the MRU/MTU range looks sane */
2474        if (c->mru > MAX_MRU || c->mtu > MAX_MTU || c->mru < 8 || c->mtu < 8)
2475                return -EINVAL;
2476        if (c->n2 < 3)
2477                return -EINVAL;
2478        if (c->encapsulation > 1)       /* Basic, advanced, no I */
2479                return -EINVAL;
2480        if (c->initiator > 1)
2481                return -EINVAL;
2482        if (c->i == 0 || c->i > 2)      /* UIH and UI only */
2483                return -EINVAL;
2484        /*
2485         *      See what is needed for reconfiguration
2486         */
2487
2488        /* Timing fields */
2489        if (c->t1 != 0 && c->t1 != gsm->t1)
2490                need_restart = 1;
2491        if (c->t2 != 0 && c->t2 != gsm->t2)
2492                need_restart = 1;
2493        if (c->encapsulation != gsm->encoding)
2494                need_restart = 1;
2495        if (c->adaption != gsm->adaption)
2496                need_restart = 1;
2497        /* Requires care */
2498        if (c->initiator != gsm->initiator)
2499                need_close = 1;
2500        if (c->mru != gsm->mru)
2501                need_restart = 1;
2502        if (c->mtu != gsm->mtu)
2503                need_restart = 1;
2504
2505        /*
2506         *      Close down what is needed, restart and initiate the new
2507         *      configuration
2508         */
2509
2510        if (need_close || need_restart) {
2511                gsm_dlci_begin_close(gsm->dlci[0]);
2512                /* This will timeout if the link is down due to N2 expiring */
2513                wait_event_interruptible(gsm->event,
2514                                gsm->dlci[0]->state == DLCI_CLOSED);
2515                if (signal_pending(current))
2516                        return -EINTR;
2517        }
2518        if (need_restart)
2519                gsm_cleanup_mux(gsm);
2520
2521        gsm->initiator = c->initiator;
2522        gsm->mru = c->mru;
2523        gsm->mtu = c->mtu;
2524        gsm->encoding = c->encapsulation;
2525        gsm->adaption = c->adaption;
2526        gsm->n2 = c->n2;
2527
2528        if (c->i == 1)
2529                gsm->ftype = UIH;
2530        else if (c->i == 2)
2531                gsm->ftype = UI;
2532
2533        if (c->t1)
2534                gsm->t1 = c->t1;
2535        if (c->t2)
2536                gsm->t2 = c->t2;
2537
2538        /* FIXME: We need to separate activation/deactivation from adding
2539           and removing from the mux array */
2540        if (need_restart)
2541                gsm_activate_mux(gsm);
2542        if (gsm->initiator && need_close)
2543                gsm_dlci_begin_open(gsm->dlci[0]);
2544        return 0;
2545}
2546
2547static int gsmld_ioctl(struct tty_struct *tty, struct file *file,
2548                       unsigned int cmd, unsigned long arg)
2549{
2550        struct gsm_config c;
2551        struct gsm_mux *gsm = tty->disc_data;
2552
2553        switch (cmd) {
2554        case GSMIOC_GETCONF:
2555                memset(&c, 0, sizeof(c));
2556                c.adaption = gsm->adaption;
2557                c.encapsulation = gsm->encoding;
2558                c.initiator = gsm->initiator;
2559                c.t1 = gsm->t1;
2560                c.t2 = gsm->t2;
2561                c.t3 = 0;       /* Not supported */
2562                c.n2 = gsm->n2;
2563                if (gsm->ftype == UIH)
2564                        c.i = 1;
2565                else
2566                        c.i = 2;
2567                pr_debug("Ftype %d i %d\n", gsm->ftype, c.i);
2568                c.mru = gsm->mru;
2569                c.mtu = gsm->mtu;
2570                c.k = 0;
2571                if (copy_to_user((void *)arg, &c, sizeof(c)))
2572                        return -EFAULT;
2573                return 0;
2574        case GSMIOC_SETCONF:
2575                if (copy_from_user(&c, (void *)arg, sizeof(c)))
2576                        return -EFAULT;
2577                return gsmld_config(tty, gsm, &c);
2578        default:
2579                return n_tty_ioctl_helper(tty, file, cmd, arg);
2580        }
2581}
2582
2583/*
2584 *      Network interface
2585 *
2586 */
2587
2588static int gsm_mux_net_open(struct net_device *net)
2589{
2590        pr_debug("%s called\n", __func__);
2591        netif_start_queue(net);
2592        return 0;
2593}
2594
2595static int gsm_mux_net_close(struct net_device *net)
2596{
2597        netif_stop_queue(net);
2598        return 0;
2599}
2600
2601static struct net_device_stats *gsm_mux_net_get_stats(struct net_device *net)
2602{
2603        return &((struct gsm_mux_net *)netdev_priv(net))->stats;
2604}
2605static void dlci_net_free(struct gsm_dlci *dlci)
2606{
2607        if (!dlci->net) {
2608                WARN_ON(1);
2609                return;
2610        }
2611        dlci->adaption = dlci->prev_adaption;
2612        dlci->data = dlci->prev_data;
2613        free_netdev(dlci->net);
2614        dlci->net = NULL;
2615}
2616static void net_free(struct kref *ref)
2617{
2618        struct gsm_mux_net *mux_net;
2619        struct gsm_dlci *dlci;
2620
2621        mux_net = container_of(ref, struct gsm_mux_net, ref);
2622        dlci = mux_net->dlci;
2623
2624        if (dlci->net) {
2625                unregister_netdev(dlci->net);
2626                dlci_net_free(dlci);
2627        }
2628}
2629
2630static inline void muxnet_get(struct gsm_mux_net *mux_net)
2631{
2632        kref_get(&mux_net->ref);
2633}
2634
2635static inline void muxnet_put(struct gsm_mux_net *mux_net)
2636{
2637        kref_put(&mux_net->ref, net_free);
2638}
2639
2640static int gsm_mux_net_start_xmit(struct sk_buff *skb,
2641                                      struct net_device *net)
2642{
2643        struct gsm_mux_net *mux_net = (struct gsm_mux_net *)netdev_priv(net);
2644        struct gsm_dlci *dlci = mux_net->dlci;
2645        muxnet_get(mux_net);
2646
2647        skb_queue_head(&dlci->skb_list, skb);
2648        STATS(net).tx_packets++;
2649        STATS(net).tx_bytes += skb->len;
2650        gsm_dlci_data_kick(dlci);
2651        /* And tell the kernel when the last transmit started. */
2652        net->trans_start = jiffies;
2653        muxnet_put(mux_net);
2654        return NETDEV_TX_OK;
2655}
2656
2657/* called when a packet did not ack after watchdogtimeout */
2658static void gsm_mux_net_tx_timeout(struct net_device *net)
2659{
2660        /* Tell syslog we are hosed. */
2661        dev_dbg(&net->dev, "Tx timed out.\n");
2662
2663        /* Update statistics */
2664        STATS(net).tx_errors++;
2665}
2666
2667static void gsm_mux_rx_netchar(struct gsm_dlci *dlci,
2668                                   unsigned char *in_buf, int size)
2669{
2670        struct net_device *net = dlci->net;
2671        struct sk_buff *skb;
2672        struct gsm_mux_net *mux_net = (struct gsm_mux_net *)netdev_priv(net);
2673        muxnet_get(mux_net);
2674
2675        /* Allocate an sk_buff */
2676        skb = dev_alloc_skb(size + NET_IP_ALIGN);
2677        if (!skb) {
2678                /* We got no receive buffer. */
2679                STATS(net).rx_dropped++;
2680                muxnet_put(mux_net);
2681                return;
2682        }
2683        skb_reserve(skb, NET_IP_ALIGN);
2684        memcpy(skb_put(skb, size), in_buf, size);
2685
2686        skb->dev = net;
2687        skb->protocol = __constant_htons(ETH_P_IP);
2688
2689        /* Ship it off to the kernel */
2690        netif_rx(skb);
2691
2692        /* update out statistics */
2693        STATS(net).rx_packets++;
2694        STATS(net).rx_bytes += size;
2695        muxnet_put(mux_net);
2696        return;
2697}
2698
2699int gsm_change_mtu(struct net_device *net, int new_mtu)
2700{
2701        struct gsm_mux_net *mux_net = (struct gsm_mux_net *)netdev_priv(net);
2702        if ((new_mtu < 8) || (new_mtu > mux_net->dlci->gsm->mtu))
2703                return -EINVAL;
2704        net->mtu = new_mtu;
2705        return 0;
2706}
2707
2708static void gsm_mux_net_init(struct net_device *net)
2709{
2710        static const struct net_device_ops gsm_netdev_ops = {
2711                .ndo_open               = gsm_mux_net_open,
2712                .ndo_stop               = gsm_mux_net_close,
2713                .ndo_start_xmit         = gsm_mux_net_start_xmit,
2714                .ndo_tx_timeout         = gsm_mux_net_tx_timeout,
2715                .ndo_get_stats          = gsm_mux_net_get_stats,
2716                .ndo_change_mtu         = gsm_change_mtu,
2717        };
2718
2719        net->netdev_ops = &gsm_netdev_ops;
2720
2721        /* fill in the other fields */
2722        net->watchdog_timeo = GSM_NET_TX_TIMEOUT;
2723        net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
2724        net->type = ARPHRD_NONE;
2725        net->tx_queue_len = 10;
2726}
2727
2728
2729/* caller holds the dlci mutex */
2730static void gsm_destroy_network(struct gsm_dlci *dlci)
2731{
2732        struct gsm_mux_net *mux_net;
2733
2734        pr_debug("destroy network interface");
2735        if (!dlci->net)
2736                return;
2737        mux_net = (struct gsm_mux_net *)netdev_priv(dlci->net);
2738        muxnet_put(mux_net);
2739}
2740
2741
2742/* caller holds the dlci mutex */
2743static int gsm_create_network(struct gsm_dlci *dlci, struct gsm_netconfig *nc)
2744{
2745        char *netname;
2746        int retval = 0;
2747        struct net_device *net;
2748        struct gsm_mux_net *mux_net;
2749
2750        if (!capable(CAP_NET_ADMIN))
2751                return -EPERM;
2752
2753        /* Already in a non tty mode */
2754        if (dlci->adaption > 2)
2755                return -EBUSY;
2756
2757        if (nc->protocol != htons(ETH_P_IP))
2758                return -EPROTONOSUPPORT;
2759
2760        if (nc->adaption != 3 && nc->adaption != 4)
2761                return -EPROTONOSUPPORT;
2762
2763        pr_debug("create network interface");
2764
2765        netname = "gsm%d";
2766        if (nc->if_name[0] != '\0')
2767                netname = nc->if_name;
2768        net = alloc_netdev(sizeof(struct gsm_mux_net),
2769                        netname,
2770                        gsm_mux_net_init);
2771        if (!net) {
2772                pr_err("alloc_netdev failed");
2773                return -ENOMEM;
2774        }
2775        net->mtu = dlci->gsm->mtu;
2776        mux_net = (struct gsm_mux_net *)netdev_priv(net);
2777        mux_net->dlci = dlci;
2778        kref_init(&mux_net->ref);
2779        strncpy(nc->if_name, net->name, IFNAMSIZ); /* return net name */
2780
2781        /* reconfigure dlci for network */
2782        dlci->prev_adaption = dlci->adaption;
2783        dlci->prev_data = dlci->data;
2784        dlci->adaption = nc->adaption;
2785        dlci->data = gsm_mux_rx_netchar;
2786        dlci->net = net;
2787
2788        pr_debug("register netdev");
2789        retval = register_netdev(net);
2790        if (retval) {
2791                pr_err("network register fail %d\n", retval);
2792                dlci_net_free(dlci);
2793                return retval;
2794        }
2795        return net->ifindex;    /* return network index */
2796}
2797
2798/* Line discipline for real tty */
2799struct tty_ldisc_ops tty_ldisc_packet = {
2800        .owner           = THIS_MODULE,
2801        .magic           = TTY_LDISC_MAGIC,
2802        .name            = "n_gsm",
2803        .open            = gsmld_open,
2804        .close           = gsmld_close,
2805        .flush_buffer    = gsmld_flush_buffer,
2806        .chars_in_buffer = gsmld_chars_in_buffer,
2807        .read            = gsmld_read,
2808        .write           = gsmld_write,
2809        .ioctl           = gsmld_ioctl,
2810        .poll            = gsmld_poll,
2811        .receive_buf     = gsmld_receive_buf,
2812        .write_wakeup    = gsmld_write_wakeup
2813};
2814
2815/*
2816 *      Virtual tty side
2817 */
2818
2819#define TX_SIZE         512
2820
2821static int gsmtty_modem_update(struct gsm_dlci *dlci, u8 brk)
2822{
2823        u8 modembits[5];
2824        struct gsm_control *ctrl;
2825        int len = 2;
2826
2827        if (brk)
2828                len++;
2829
2830        modembits[0] = len << 1 | EA;           /* Data bytes */
2831        modembits[1] = dlci->addr << 2 | 3;     /* DLCI, EA, 1 */
2832        modembits[2] = gsm_encode_modem(dlci) << 1 | EA;
2833        if (brk)
2834                modembits[3] = brk << 4 | 2 | EA;       /* Valid, EA */
2835        ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len + 1);
2836        if (ctrl == NULL)
2837                return -ENOMEM;
2838        return gsm_control_wait(dlci->gsm, ctrl);
2839}
2840
2841static int gsm_carrier_raised(struct tty_port *port)
2842{
2843        struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2844        /* Not yet open so no carrier info */
2845        if (dlci->state != DLCI_OPEN)
2846                return 0;
2847        if (debug & 2)
2848                return 1;
2849        return dlci->modem_rx & TIOCM_CD;
2850}
2851
2852static void gsm_dtr_rts(struct tty_port *port, int onoff)
2853{
2854        struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2855        unsigned int modem_tx = dlci->modem_tx;
2856        if (onoff)
2857                modem_tx |= TIOCM_DTR | TIOCM_RTS;
2858        else
2859                modem_tx &= ~(TIOCM_DTR | TIOCM_RTS);
2860        if (modem_tx != dlci->modem_tx) {
2861                dlci->modem_tx = modem_tx;
2862                gsmtty_modem_update(dlci, 0);
2863        }
2864}
2865
2866static const struct tty_port_operations gsm_port_ops = {
2867        .carrier_raised = gsm_carrier_raised,
2868        .dtr_rts = gsm_dtr_rts,
2869};
2870
2871
2872static int gsmtty_open(struct tty_struct *tty, struct file *filp)
2873{
2874        struct gsm_mux *gsm;
2875        struct gsm_dlci *dlci;
2876        struct tty_port *port;
2877        unsigned int line = tty->index;
2878        unsigned int mux = line >> 6;
2879
2880        line = line & 0x3F;
2881
2882        if (mux >= MAX_MUX)
2883                return -ENXIO;
2884        /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */
2885        if (gsm_mux[mux] == NULL)
2886                return -EUNATCH;
2887        if (line == 0 || line > 61)     /* 62/63 reserved */
2888                return -ECHRNG;
2889        gsm = gsm_mux[mux];
2890        if (gsm->dead)
2891                return -EL2HLT;
2892        dlci = gsm->dlci[line];
2893        if (dlci == NULL)
2894                dlci = gsm_dlci_alloc(gsm, line);
2895        if (dlci == NULL)
2896                return -ENOMEM;
2897        port = &dlci->port;
2898        port->count++;
2899        tty->driver_data = dlci;
2900        dlci_get(dlci);
2901        dlci_get(dlci->gsm->dlci[0]);
2902        mux_get(dlci->gsm);
2903        tty_port_tty_set(port, tty);
2904
2905        dlci->modem_rx = 0;
2906        /* We could in theory open and close before we wait - eg if we get
2907           a DM straight back. This is ok as that will have caused a hangup */
2908        set_bit(ASYNCB_INITIALIZED, &port->flags);
2909        /* Start sending off SABM messages */
2910        gsm_dlci_begin_open(dlci);
2911        /* And wait for virtual carrier */
2912        return tty_port_block_til_ready(port, tty, filp);
2913}
2914
2915static void gsmtty_close(struct tty_struct *tty, struct file *filp)
2916{
2917        struct gsm_dlci *dlci = tty->driver_data;
2918        struct gsm_mux *gsm;
2919
2920        if (dlci == NULL)
2921                return;
2922        mutex_lock(&dlci->mutex);
2923        gsm_destroy_network(dlci);
2924        mutex_unlock(&dlci->mutex);
2925        gsm = dlci->gsm;
2926        if (tty_port_close_start(&dlci->port, tty, filp) == 0)
2927                goto out;
2928        gsm_dlci_begin_close(dlci);
2929        tty_port_close_end(&dlci->port, tty);
2930        tty_port_tty_set(&dlci->port, NULL);
2931out:
2932        dlci_put(dlci);
2933        dlci_put(gsm->dlci[0]);
2934        mux_put(gsm);
2935}
2936
2937static void gsmtty_hangup(struct tty_struct *tty)
2938{
2939        struct gsm_dlci *dlci = tty->driver_data;
2940        tty_port_hangup(&dlci->port);
2941        gsm_dlci_begin_close(dlci);
2942}
2943
2944static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
2945                                                                    int len)
2946{
2947        struct gsm_dlci *dlci = tty->driver_data;
2948        /* Stuff the bytes into the fifo queue */
2949        int sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
2950        /* Need to kick the channel */
2951        gsm_dlci_data_kick(dlci);
2952        return sent;
2953}
2954
2955static int gsmtty_write_room(struct tty_struct *tty)
2956{
2957        struct gsm_dlci *dlci = tty->driver_data;
2958        return TX_SIZE - kfifo_len(dlci->fifo);
2959}
2960
2961static int gsmtty_chars_in_buffer(struct tty_struct *tty)
2962{
2963        struct gsm_dlci *dlci = tty->driver_data;
2964        return kfifo_len(dlci->fifo);
2965}
2966
2967static void gsmtty_flush_buffer(struct tty_struct *tty)
2968{
2969        struct gsm_dlci *dlci = tty->driver_data;
2970        /* Caution needed: If we implement reliable transport classes
2971           then the data being transmitted can't simply be junked once
2972           it has first hit the stack. Until then we can just blow it
2973           away */
2974        kfifo_reset(dlci->fifo);
2975        /* Need to unhook this DLCI from the transmit queue logic */
2976}
2977
2978static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout)
2979{
2980        /* The FIFO handles the queue so the kernel will do the right
2981           thing waiting on chars_in_buffer before calling us. No work
2982           to do here */
2983}
2984
2985static int gsmtty_tiocmget(struct tty_struct *tty)
2986{
2987        struct gsm_dlci *dlci = tty->driver_data;
2988        return dlci->modem_rx;
2989}
2990
2991static int gsmtty_tiocmset(struct tty_struct *tty,
2992        unsigned int set, unsigned int clear)
2993{
2994        struct gsm_dlci *dlci = tty->driver_data;
2995        unsigned int modem_tx = dlci->modem_tx;
2996
2997        modem_tx &= ~clear;
2998        modem_tx |= set;
2999
3000        if (modem_tx != dlci->modem_tx) {
3001                dlci->modem_tx = modem_tx;
3002                return gsmtty_modem_update(dlci, 0);
3003        }
3004        return 0;
3005}
3006
3007
3008static int gsmtty_ioctl(struct tty_struct *tty,
3009                        unsigned int cmd, unsigned long arg)
3010{
3011        struct gsm_dlci *dlci = tty->driver_data;
3012        struct gsm_netconfig nc;
3013        int index;
3014
3015        switch (cmd) {
3016        case GSMIOC_ENABLE_NET:
3017                if (copy_from_user(&nc, (void __user *)arg, sizeof(nc)))
3018                        return -EFAULT;
3019                nc.if_name[IFNAMSIZ-1] = '\0';
3020                /* return net interface index or error code */
3021                mutex_lock(&dlci->mutex);
3022                index = gsm_create_network(dlci, &nc);
3023                mutex_unlock(&dlci->mutex);
3024                if (copy_to_user((void __user *)arg, &nc, sizeof(nc)))
3025                        return -EFAULT;
3026                return index;
3027        case GSMIOC_DISABLE_NET:
3028                if (!capable(CAP_NET_ADMIN))
3029                        return -EPERM;
3030                mutex_lock(&dlci->mutex);
3031                gsm_destroy_network(dlci);
3032                mutex_unlock(&dlci->mutex);
3033                return 0;
3034        default:
3035                return -ENOIOCTLCMD;
3036        }
3037}
3038
3039static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
3040{
3041        /* For the moment its fixed. In actual fact the speed information
3042           for the virtual channel can be propogated in both directions by
3043           the RPN control message. This however rapidly gets nasty as we
3044           then have to remap modem signals each way according to whether
3045           our virtual cable is null modem etc .. */
3046        tty_termios_copy_hw(tty->termios, old);
3047}
3048
3049static void gsmtty_throttle(struct tty_struct *tty)
3050{
3051        struct gsm_dlci *dlci = tty->driver_data;
3052        if (tty->termios->c_cflag & CRTSCTS)
3053                dlci->modem_tx &= ~TIOCM_DTR;
3054        dlci->throttled = 1;
3055        /* Send an MSC with DTR cleared */
3056        gsmtty_modem_update(dlci, 0);
3057}
3058
3059static void gsmtty_unthrottle(struct tty_struct *tty)
3060{
3061        struct gsm_dlci *dlci = tty->driver_data;
3062        if (tty->termios->c_cflag & CRTSCTS)
3063                dlci->modem_tx |= TIOCM_DTR;
3064        dlci->throttled = 0;
3065        /* Send an MSC with DTR set */
3066        gsmtty_modem_update(dlci, 0);
3067}
3068
3069static int gsmtty_break_ctl(struct tty_struct *tty, int state)
3070{
3071        struct gsm_dlci *dlci = tty->driver_data;
3072        int encode = 0; /* Off */
3073
3074        if (state == -1)        /* "On indefinitely" - we can't encode this
3075                                    properly */
3076                encode = 0x0F;
3077        else if (state > 0) {
3078                encode = state / 200;   /* mS to encoding */
3079                if (encode > 0x0F)
3080                        encode = 0x0F;  /* Best effort */
3081        }
3082        return gsmtty_modem_update(dlci, encode);
3083}
3084
3085
3086/* Virtual ttys for the demux */
3087static const struct tty_operations gsmtty_ops = {
3088        .open                   = gsmtty_open,
3089        .close                  = gsmtty_close,
3090        .write                  = gsmtty_write,
3091        .write_room             = gsmtty_write_room,
3092        .chars_in_buffer        = gsmtty_chars_in_buffer,
3093        .flush_buffer           = gsmtty_flush_buffer,
3094        .ioctl                  = gsmtty_ioctl,
3095        .throttle               = gsmtty_throttle,
3096        .unthrottle             = gsmtty_unthrottle,
3097        .set_termios            = gsmtty_set_termios,
3098        .hangup                 = gsmtty_hangup,
3099        .wait_until_sent        = gsmtty_wait_until_sent,
3100        .tiocmget               = gsmtty_tiocmget,
3101        .tiocmset               = gsmtty_tiocmset,
3102        .break_ctl              = gsmtty_break_ctl,
3103};
3104
3105
3106
3107static int __init gsm_init(void)
3108{
3109        /* Fill in our line protocol discipline, and register it */
3110        int status = tty_register_ldisc(N_GSM0710, &tty_ldisc_packet);
3111        if (status != 0) {
3112                pr_err("n_gsm: can't register line discipline (err = %d)\n",
3113                                                                status);
3114                return status;
3115        }
3116
3117        gsm_tty_driver = alloc_tty_driver(256);
3118        if (!gsm_tty_driver) {
3119                tty_unregister_ldisc(N_GSM0710);
3120                pr_err("gsm_init: tty allocation failed.\n");
3121                return -EINVAL;
3122        }
3123        gsm_tty_driver->driver_name     = "gsmtty";
3124        gsm_tty_driver->name            = "gsmtty";
3125        gsm_tty_driver->major           = 0;    /* Dynamic */
3126        gsm_tty_driver->minor_start     = 0;
3127        gsm_tty_driver->type            = TTY_DRIVER_TYPE_SERIAL;
3128        gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
3129        gsm_tty_driver->flags   = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
3130                                                | TTY_DRIVER_HARDWARE_BREAK;
3131        gsm_tty_driver->init_termios    = tty_std_termios;
3132        /* Fixme */
3133        gsm_tty_driver->init_termios.c_lflag &= ~ECHO;
3134        tty_set_operations(gsm_tty_driver, &gsmtty_ops);
3135
3136        spin_lock_init(&gsm_mux_lock);
3137
3138        if (tty_register_driver(gsm_tty_driver)) {
3139                put_tty_driver(gsm_tty_driver);
3140                tty_unregister_ldisc(N_GSM0710);
3141                pr_err("gsm_init: tty registration failed.\n");
3142                return -EBUSY;
3143        }
3144        pr_debug("gsm_init: loaded as %d,%d.\n",
3145                        gsm_tty_driver->major, gsm_tty_driver->minor_start);
3146        return 0;
3147}
3148
3149static void __exit gsm_exit(void)
3150{
3151        int status = tty_unregister_ldisc(N_GSM0710);
3152        if (status != 0)
3153                pr_err("n_gsm: can't unregister line discipline (err = %d)\n",
3154                                                                status);
3155        tty_unregister_driver(gsm_tty_driver);
3156        put_tty_driver(gsm_tty_driver);
3157}
3158
3159module_init(gsm_init);
3160module_exit(gsm_exit);
3161
3162
3163MODULE_LICENSE("GPL");
3164MODULE_ALIAS_LDISC(N_GSM0710);
3165
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.