drivers/net/wan/cycx_x25.c

   1 /*
   2 * cycx_x25.c    Cyclom 2X WAN Link Driver.  X.25 module.
   3 *
   4 * Author:       Arnaldo Carvalho de Melo <acme@conectiva.com.br>
   5 *
   6 * Copyright:    (c) 1998-2003 Arnaldo Carvalho de Melo
   7 *
   8 * Based on sdla_x25.c by Gene Kozin <genek@compuserve.com>
   9 *
  10 *               This program is free software; you can redistribute it and/or
  11 *               modify it under the terms of the GNU General Public License
  12 *               as published by the Free Software Foundation; either version
  13 *               2 of the License, or (at your option) any later version.
  14 * ============================================================================
  15 * 2001/01/12    acme            use dev_kfree_skb_irq on interrupt context
  16 * 2000/04/02    acme            dprintk, cycx_debug
  17 *                               fixed the bug introduced in get_dev_by_lcn and
  18 *                               get_dev_by_dte_addr by the anonymous hacker
  19 *                               that converted this driver to softnet
  20 * 2000/01/08    acme            cleanup
  21 * 1999/10/27    acme            use ARPHRD_HWX25 so that the X.25 stack know
  22 *                               that we have a X.25 stack implemented in
  23 *                               firmware onboard
  24 * 1999/10/18    acme            support for X.25 sockets in if_send,
  25 *                               beware: socket(AF_X25...) IS WORK IN PROGRESS,
  26 *                               TCP/IP over X.25 via wanrouter not affected,
  27 *                               working.
  28 * 1999/10/09    acme            chan_disc renamed to chan_disconnect,
  29 *                               began adding support for X.25 sockets:
  30 *                               conf->protocol in new_if
  31 * 1999/10/05    acme            fixed return E... to return -E...
  32 * 1999/08/10    acme            serialized access to the card thru a spinlock
  33 *                               in x25_exec
  34 * 1999/08/09    acme            removed per channel spinlocks
  35 *                               removed references to enable_tx_int
  36 * 1999/05/28    acme            fixed nibble_to_byte, ackvc now properly treated
  37 *                               if_send simplified
  38 * 1999/05/25    acme            fixed t1, t2, t21 & t23 configuration
  39 *                               use spinlocks instead of cli/sti in some points
  40 * 1999/05/24    acme            finished the x25_get_stat function
  41 * 1999/05/23    acme            dev->type = ARPHRD_X25 (tcpdump only works,
  42 *                               AFAIT, with ARPHRD_ETHER). This seems to be
  43 *                               needed to use socket(AF_X25)...
  44 *                               Now the config file must specify a peer media
  45 *                               address for svc channels over a crossover cable.
  46 *                               Removed hold_timeout from x25_channel_t,
  47 *                               not used.
  48 *                               A little enhancement in the DEBUG processing
  49 * 1999/05/22    acme            go to DISCONNECTED in disconnect_confirm_intr,
  50 *                               instead of chan_disc.
  51 * 1999/05/16    marcelo         fixed timer initialization in SVCs
  52 * 1999/01/05    acme            x25_configure now get (most of) all
  53 *                               parameters...
  54 * 1999/01/05    acme            pktlen now (correctly) uses log2 (value
  55 *                               configured)
  56 * 1999/01/03    acme            judicious use of data types (u8, u16, u32, etc)
  57 * 1999/01/03    acme            cyx_isr: reset dpmbase to acknowledge
  58 *                               indication (interrupt from cyclom 2x)
  59 * 1999/01/02    acme            cyx_isr: first hackings...
  60 * 1999/01/0203  acme            when initializing an array don't give less
  61 *                               elements than declared...
  62 *                               example: char send_cmd[6] = "?\xFF\x10";
  63 *                               you'll gonna lose a couple hours, 'cause your
  64 *                               brain won't admit that there's an error in the
  65 *                               above declaration...  the side effect is that
  66 *                               memset is put into the unresolved symbols
  67 *                               instead of using the inline memset functions...
  68 * 1999/01/02    acme            began chan_connect, chan_send, x25_send
  69 * 1998/12/31    acme            x25_configure
  70 *                               this code can be compiled as non module
  71 * 1998/12/27    acme            code cleanup
  72 *                               IPX code wiped out! let's decrease code
  73 *                               complexity for now, remember: I'm learning! :)
  74 *                               bps_to_speed_code OK
  75 * 1998/12/26    acme            Minimal debug code cleanup
  76 * 1998/08/08    acme            Initial version.
  77 */
  78
  79 #define CYCLOMX_X25_DEBUG 1
  80
  81 #include <linux/errno.h>        /* return codes */
  82 #include <linux/if_arp.h>       /* ARPHRD_HWX25 */
  83 #include <linux/kernel.h>       /* printk(), and other useful stuff */
  84 #include <linux/module.h>
  85 #include <linux/string.h>       /* inline memset(), etc. */
  86 #include <linux/slab.h>         /* kmalloc(), kfree() */
  87 #include <linux/stddef.h>       /* offsetof(), etc. */
  88 #include <linux/wanrouter.h>    /* WAN router definitions */
  89
  90 #include <asm/byteorder.h>      /* htons(), etc. */
  91
  92 #include <linux/cyclomx.h>      /* Cyclom 2X common user API definitions */
  93 #include <linux/cycx_x25.h>     /* X.25 firmware API definitions */
  94
  95 /* Defines & Macros */
  96 #define CYCX_X25_MAX_CMD_RETRY 5
  97 #define CYCX_X25_CHAN_MTU 2048  /* unfragmented logical channel MTU */
  98
  99 /* Data Structures */
 100 /* This is an extension of the 'struct net_device' we create for each network
 101    interface to keep the rest of X.25 channel-specific data. */
 102 struct cycx_x25_channel {
 103         /* This member must be first. */
 104         struct net_device *slave;       /* WAN slave */
 105
 106         char name[WAN_IFNAME_SZ+1];     /* interface name, ASCIIZ */
 107         char addr[WAN_ADDRESS_SZ+1];    /* media address, ASCIIZ */
 108         char *local_addr;               /* local media address, ASCIIZ -
 109                                            svc thru crossover cable */
 110         s16 lcn;                        /* logical channel number/conn.req.key*/
 111         u8 link;
 112         struct timer_list timer;        /* timer used for svc channel disc. */
 113         u16 protocol;                   /* ethertype, 0 - multiplexed */
 114         u8 svc;                         /* 0 - permanent, 1 - switched */
 115         u8 state;                       /* channel state */
 116         u8 drop_sequence;               /* mark sequence for dropping */
 117         u32 idle_tmout;                 /* sec, before disconnecting */
 118         struct sk_buff *rx_skb;         /* receive socket buffer */
 119         struct cycx_device *card;       /* -> owner */
 120         struct net_device_stats ifstats;/* interface statistics */
 121 };
 122
 123 /* Function Prototypes */
 124 /* WAN link driver entry points. These are called by the WAN router module. */
 125 static int cycx_wan_update(struct wan_device *wandev),
 126            cycx_wan_new_if(struct wan_device *wandev, struct net_device *dev,
 127                            wanif_conf_t *conf),
 128            cycx_wan_del_if(struct wan_device *wandev, struct net_device *dev);
 129
 130 /* Network device interface */
 131 static int cycx_netdevice_init(struct net_device *dev),
 132            cycx_netdevice_open(struct net_device *dev),
 133            cycx_netdevice_stop(struct net_device *dev),
 134            cycx_netdevice_hard_header(struct sk_buff *skb,
 135                                      struct net_device *dev, u16 type,
 136                                      void *daddr, void *saddr, unsigned len),
 137            cycx_netdevice_rebuild_header(struct sk_buff *skb),
 138            cycx_netdevice_hard_start_xmit(struct sk_buff *skb,
 139                                           struct net_device *dev);
 140
 141 static struct net_device_stats *
 142                         cycx_netdevice_get_stats(struct net_device *dev);
 143
 144 /* Interrupt handlers */
 145 static void cycx_x25_irq_handler(struct cycx_device *card),
 146             cycx_x25_irq_tx(struct cycx_device *card, struct cycx_x25_cmd *cmd),
 147             cycx_x25_irq_rx(struct cycx_device *card, struct cycx_x25_cmd *cmd),
 148             cycx_x25_irq_log(struct cycx_device *card,
 149                              struct cycx_x25_cmd *cmd),
 150             cycx_x25_irq_stat(struct cycx_device *card,
 151                               struct cycx_x25_cmd *cmd),
 152             cycx_x25_irq_connect_confirm(struct cycx_device *card,
 153                                          struct cycx_x25_cmd *cmd),
 154             cycx_x25_irq_disconnect_confirm(struct cycx_device *card,
 155                                             struct cycx_x25_cmd *cmd),
 156             cycx_x25_irq_connect(struct cycx_device *card,
 157                                  struct cycx_x25_cmd *cmd),
 158             cycx_x25_irq_disconnect(struct cycx_device *card,
 159                                     struct cycx_x25_cmd *cmd),
 160             cycx_x25_irq_spurious(struct cycx_device *card,
 161                                   struct cycx_x25_cmd *cmd);
 162
 163 /* X.25 firmware interface functions */
 164 static int cycx_x25_configure(struct cycx_device *card,
 165                               struct cycx_x25_config *conf),
 166            cycx_x25_get_stats(struct cycx_device *card),
 167            cycx_x25_send(struct cycx_device *card, u8 link, u8 lcn, u8 bitm,
 168                          int len, void *buf),
 169            cycx_x25_connect_response(struct cycx_device *card,
 170                                 struct cycx_x25_channel *chan),
 171            cycx_x25_disconnect_response(struct cycx_device *card, u8 link,
 172                                         u8 lcn);
 173
 174 /* channel functions */
 175 static int cycx_x25_chan_connect(struct net_device *dev),
 176            cycx_x25_chan_send(struct net_device *dev, struct sk_buff *skb);
 177
 178 static void cycx_x25_chan_disconnect(struct net_device *dev),
 179             cycx_x25_chan_send_event(struct net_device *dev, u8 event);
 180
 181 /* Miscellaneous functions */
 182 static void cycx_x25_set_chan_state(struct net_device *dev, u8 state),
 183             cycx_x25_chan_timer(unsigned long d);
 184
 185 static void nibble_to_byte(u8 *s, u8 *d, u8 len, u8 nibble),
 186             reset_timer(struct net_device *dev);
 187
 188 static u8 bps_to_speed_code(u32 bps);
 189 static u8 log2(u32 n);
 190
 191 static unsigned dec_to_uint(u8 *str, int len);
 192
 193 static struct net_device *cycx_x25_get_dev_by_lcn(struct wan_device *wandev,
 194                                                   s16 lcn);
 195 static struct net_device *
 196         cycx_x25_get_dev_by_dte_addr(struct wan_device *wandev, char *dte);
 197
 198 #ifdef CYCLOMX_X25_DEBUG
 199 static void hex_dump(char *msg, unsigned char *p, int len);
 200 static void cycx_x25_dump_config(struct cycx_x25_config *conf);
 201 static void cycx_x25_dump_stats(struct cycx_x25_stats *stats);
 202 static void cycx_x25_dump_devs(struct wan_device *wandev);
 203 #else
 204 #define hex_dump(msg, p, len)
 205 #define cycx_x25_dump_config(conf)
 206 #define cycx_x25_dump_stats(stats)
 207 #define cycx_x25_dump_devs(wandev)
 208 #endif
 209 /* Public Functions */
 210
 211 /* X.25 Protocol Initialization routine.
 212  *
 213  * This routine is called by the main Cyclom 2X module during setup.  At this
 214  * point adapter is completely initialized and X.25 firmware is running.
 215  *  o configure adapter
 216  *  o initialize protocol-specific fields of the adapter data space.
 217  *
 218  * Return:      0       o.k.
 219  *              < 0     failure.  */
 220 int cycx_x25_wan_init(struct cycx_device *card, wandev_conf_t *conf)
 221 {
 222         struct cycx_x25_config cfg;
 223
 224         /* Verify configuration ID */
 225         if (conf->config_id != WANCONFIG_X25) {
 226                 printk(KERN_INFO "%s: invalid configuration ID %u!\n",
 227                                  card->devname, conf->config_id);
 228                 return -EINVAL;
 229         }
 230
 231         /* Initialize protocol-specific fields */
 232         card->mbox  = card->hw.dpmbase + X25_MBOX_OFFS;
 233         card->u.x.connection_keys = 0;
 234         card->u.x.lock = SPIN_LOCK_UNLOCKED;
 235
 236         /* Configure adapter. Here we set reasonable defaults, then parse
 237          * device configuration structure and set configuration options.
 238          * Most configuration options are verified and corrected (if
 239          * necessary) since we can't rely on the adapter to do so and don't
 240          * want it to fail either. */
 241         memset(&cfg, 0, sizeof(cfg));
 242         cfg.link = 0;
 243         cfg.clock = conf->clocking == WANOPT_EXTERNAL ? 8 : 55;
 244         cfg.speed = bps_to_speed_code(conf->bps);
 245         cfg.n3win = 7;
 246         cfg.n2win = 2;
 247         cfg.n2 = 5;
 248         cfg.nvc = 1;
 249         cfg.npvc = 1;
 250         cfg.flags = 0x02; /* default = V35 */
 251         cfg.t1 = 10;   /* line carrier timeout */
 252         cfg.t2 = 29;   /* tx timeout */
 253         cfg.t21 = 180; /* CALL timeout */
 254         cfg.t23 = 180; /* CLEAR timeout */
 255
 256         /* adjust MTU */
 257         if (!conf->mtu || conf->mtu >= 512)
 258                 card->wandev.mtu = 512;
 259         else if (conf->mtu >= 256)
 260                 card->wandev.mtu = 256;
 261         else if (conf->mtu >= 128)
 262                 card->wandev.mtu = 128;
 263         else
 264                 card->wandev.mtu = 64;
 265
 266         cfg.pktlen = log2(card->wandev.mtu);
 267
 268         if (conf->station == WANOPT_DTE) {
 269                 cfg.locaddr = 3; /* DTE */
 270                 cfg.remaddr = 1; /* DCE */
 271         } else {
 272                 cfg.locaddr = 1; /* DCE */
 273                 cfg.remaddr = 3; /* DTE */
 274         }
 275
 276         if (conf->interface == WANOPT_RS232)
 277                 cfg.flags = 0;      /* FIXME just reset the 2nd bit */
 278
 279         if (conf->u.x25.hi_pvc) {
 280                 card->u.x.hi_pvc = min_t(unsigned int, conf->u.x25.hi_pvc, 4095);
 281                 card->u.x.lo_pvc = min_t(unsigned int, conf->u.x25.lo_pvc, card->u.x.hi_pvc);
 282         }
 283
 284         if (conf->u.x25.hi_svc) {
 285                 card->u.x.hi_svc = min_t(unsigned int, conf->u.x25.hi_svc, 4095);
 286                 card->u.x.lo_svc = min_t(unsigned int, conf->u.x25.lo_svc, card->u.x.hi_svc);
 287         }
 288
 289         if (card->u.x.lo_pvc == 255)
 290                 cfg.npvc = 0;
 291         else
 292                 cfg.npvc = card->u.x.hi_pvc - card->u.x.lo_pvc + 1;
 293
 294         cfg.nvc = card->u.x.hi_svc - card->u.x.lo_svc + 1 + cfg.npvc;
 295
 296         if (conf->u.x25.hdlc_window)
 297                 cfg.n2win = min_t(unsigned int, conf->u.x25.hdlc_window, 7);
 298
 299         if (conf->u.x25.pkt_window)
 300                 cfg.n3win = min_t(unsigned int, conf->u.x25.pkt_window, 7);
 301
 302         if (conf->u.x25.t1)
 303                 cfg.t1 = min_t(unsigned int, conf->u.x25.t1, 30);
 304
 305         if (conf->u.x25.t2)
 306                 cfg.t2 = min_t(unsigned int, conf->u.x25.t2, 30);
 307
 308         if (conf->u.x25.t11_t21)
 309                 cfg.t21 = min_t(unsigned int, conf->u.x25.t11_t21, 30);
 310
 311         if (conf->u.x25.t13_t23)
 312                 cfg.t23 = min_t(unsigned int, conf->u.x25.t13_t23, 30);
 313
 314         if (conf->u.x25.n2)
 315                 cfg.n2 = min_t(unsigned int, conf->u.x25.n2, 30);
 316
 317         /* initialize adapter */
 318         if (cycx_x25_configure(card, &cfg))
 319                 return -EIO;
 320
 321         /* Initialize protocol-specific fields of adapter data space */
 322         card->wandev.bps        = conf->bps;
 323         card->wandev.interface  = conf->interface;
 324         card->wandev.clocking   = conf->clocking;
 325         card->wandev.station    = conf->station;
 326         card->isr               = cycx_x25_irq_handler;
 327         card->exec              = NULL;
 328         card->wandev.update     = cycx_wan_update;
 329         card->wandev.new_if     = cycx_wan_new_if;
 330         card->wandev.del_if     = cycx_wan_del_if;
 331         card->wandev.state      = WAN_DISCONNECTED;
 332
 333         return 0;
 334 }
 335
 336 /* WAN Device Driver Entry Points */
 337 /* Update device status & statistics. */
 338 static int cycx_wan_update(struct wan_device *wandev)
 339 {
 340         /* sanity checks */
 341         if (!wandev || !wandev->private)
 342                 return -EFAULT;
 343
 344         if (wandev->state == WAN_UNCONFIGURED)
 345                 return -ENODEV;
 346
 347         cycx_x25_get_stats(wandev->private);
 348
 349         return 0;
 350 }
 351
 352 /* Create new logical channel.
 353  * This routine is called by the router when ROUTER_IFNEW IOCTL is being
 354  * handled.
 355  * o parse media- and hardware-specific configuration
 356  * o make sure that a new channel can be created
 357  * o allocate resources, if necessary
 358  * o prepare network device structure for registration.
 359  *
 360  * Return:      0       o.k.
 361  *              < 0     failure (channel will not be created) */
 362 static int cycx_wan_new_if(struct wan_device *wandev, struct net_device *dev,
 363                            wanif_conf_t *conf)
 364 {
 365         struct cycx_device *card = wandev->private;
 366         struct cycx_x25_channel *chan;
 367         int err = 0;
 368
 369         if (!conf->name[0] || strlen(conf->name) > WAN_IFNAME_SZ) {
 370                 printk(KERN_INFO "%s: invalid interface name!\n",
 371                        card->devname);
 372                 return -EINVAL;
 373         }
 374
 375         /* allocate and initialize private data */
 376         chan = kmalloc(sizeof(struct cycx_x25_channel), GFP_KERNEL);
 377         if (!chan)
 378                 return -ENOMEM;
 379
 380         memset(chan, 0, sizeof(*chan));
 381         strcpy(chan->name, conf->name);
 382         chan->card = card;
 383         chan->link = conf->port;
 384         chan->protocol = conf->protocol ? ETH_P_X25 : ETH_P_IP;
 385         chan->rx_skb = NULL;
 386         /* only used in svc connected thru crossover cable */
 387         chan->local_addr = NULL;
 388
 389         if (conf->addr[0] == '@') {     /* SVC */
 390                 int len = strlen(conf->local_addr);
 391
 392                 if (len) {
 393                         if (len > WAN_ADDRESS_SZ) {
 394                                 printk(KERN_ERR "%s: %s local addr too long!\n",
 395                                                 wandev->name, chan->name);
 396                                 kfree(chan);
 397                                 return -EINVAL;
 398                         } else {
 399                                 chan->local_addr = kmalloc(len + 1, GFP_KERNEL);
 400
 401                                 if (!chan->local_addr) {
 402                                         kfree(chan);
 403                                         return -ENOMEM;
 404                                 }
 405                         }
 406
 407                         strncpy(chan->local_addr, conf->local_addr,
 408                                 WAN_ADDRESS_SZ);
 409                 }
 410
 411                 chan->svc = 1;
 412                 strncpy(chan->addr, &conf->addr[1], WAN_ADDRESS_SZ);
 413                 init_timer(&chan->timer);
 414                 chan->timer.function    = cycx_x25_chan_timer;
 415                 chan->timer.data        = (unsigned long)dev;
 416
 417                 /* Set channel timeouts (default if not specified) */
 418                 chan->idle_tmout = conf->idle_timeout ? conf->idle_timeout : 90;
 419         } else if (is_digit(conf->addr[0])) {   /* PVC */
 420                 s16 lcn = dec_to_uint(conf->addr, 0);
 421
 422                 if (lcn >= card->u.x.lo_pvc && lcn <= card->u.x.hi_pvc)
 423                         chan->lcn = lcn;
 424                 else {
 425                         printk(KERN_ERR
 426                                 "%s: PVC %u is out of range on interface %s!\n",
 427                                 wandev->name, lcn, chan->name);
 428                         err = -EINVAL;
 429                 }
 430         } else {
 431                 printk(KERN_ERR "%s: invalid media address on interface %s!\n",
 432                                 wandev->name, chan->name);
 433                 err = -EINVAL;
 434         }
 435
 436         if (err) {
 437                 if (chan->local_addr)
 438                         kfree(chan->local_addr);
 439
 440                 kfree(chan);
 441                 return err;
 442         }
 443
 444         /* prepare network device data space for registration */
 445         strcpy(dev->name, chan->name);
 446         dev->init = cycx_netdevice_init;
 447         dev->priv = chan;
 448
 449         return 0;
 450 }
 451
 452 /* Delete logical channel. */
 453 static int cycx_wan_del_if(struct wan_device *wandev, struct net_device *dev)
 454 {
 455         if (dev->priv) {
 456                 struct cycx_x25_channel *chan = dev->priv;
 457
 458                 if (chan->svc) {
 459                         if (chan->local_addr)
 460                                 kfree(chan->local_addr);
 461
 462                         if (chan->state == WAN_CONNECTED)
 463                                 del_timer(&chan->timer);
 464                 }
 465
 466                 kfree(chan);
 467                 dev->priv = NULL;
 468         }
 469
 470         return 0;
 471 }
 472
 473 /* Network Device Interface */
 474 /* Initialize Linux network interface.
 475  *
 476  * This routine is called only once for each interface, during Linux network
 477  * interface registration.  Returning anything but zero will fail interface
 478  * registration. */
 479 static int cycx_netdevice_init(struct net_device *dev)
 480 {
 481         struct cycx_x25_channel *chan = dev->priv;
 482         struct cycx_device *card = chan->card;
 483         struct wan_device *wandev = &card->wandev;
 484
 485         /* Initialize device driver entry points */
 486         dev->open               = cycx_netdevice_open;
 487         dev->stop               = cycx_netdevice_stop;
 488         dev->hard_header        = cycx_netdevice_hard_header;
 489         dev->rebuild_header     = cycx_netdevice_rebuild_header;
 490         dev->hard_start_xmit    = cycx_netdevice_hard_start_xmit;
 491         dev->get_stats          = cycx_netdevice_get_stats;
 492
 493         /* Initialize media-specific parameters */
 494         dev->mtu                = CYCX_X25_CHAN_MTU;
 495         dev->type               = ARPHRD_HWX25; /* ARP h/w type */
 496         dev->hard_header_len    = 0;            /* media header length */
 497         dev->addr_len           = 0;            /* hardware address length */
 498
 499         if (!chan->svc)
 500                 *(u16*)dev->dev_addr = htons(chan->lcn);
 501
 502         /* Initialize hardware parameters (just for reference) */
 503         dev->irq                = wandev->irq;
 504         dev->dma                = wandev->dma;
 505         dev->base_addr          = wandev->ioport;
 506         dev->mem_start          = (unsigned long)wandev->maddr;
 507         dev->mem_end            = (unsigned long)(wandev->maddr +
 508                                                   wandev->msize - 1);
 509         dev->flags              |= IFF_NOARP;
 510
 511         /* Set transmit buffer queue length */
 512         dev->tx_queue_len       = 10;
 513         SET_MODULE_OWNER(dev);
 514
 515         /* Initialize socket buffers */
 516         cycx_x25_set_chan_state(dev, WAN_DISCONNECTED);
 517
 518         return 0;
 519 }
 520
 521 /* Open network interface.
 522  * o prevent module from unloading by incrementing use count
 523  * o if link is disconnected then initiate connection
 524  *
 525  * Return 0 if O.k. or errno.  */
 526 static int cycx_netdevice_open(struct net_device *dev)
 527 {
 528         if (netif_running(dev))
 529                 return -EBUSY; /* only one open is allowed */
 530
 531         netif_start_queue(dev);
 532         return 0;
 533 }
 534
 535 /* Close network interface.
 536  * o reset flags.
 537  * o if there's no more open channels then disconnect physical link. */
 538 static int cycx_netdevice_stop(struct net_device *dev)
 539 {
 540         struct cycx_x25_channel *chan = dev->priv;
 541
 542         netif_stop_queue(dev);
 543
 544         if (chan->state == WAN_CONNECTED || chan->state == WAN_CONNECTING)
 545                 cycx_x25_chan_disconnect(dev);
 546
 547         return 0;
 548 }
 549
 550 /* Build media header.
 551  * o encapsulate packet according to encapsulation type.
 552  *
 553  * The trick here is to put packet type (Ethertype) into 'protocol' field of
 554  * the socket buffer, so that we don't forget it.  If encapsulation fails,
 555  * set skb->protocol to 0 and discard packet later.
 556  *
 557  * Return:      media header length. */
 558 static int cycx_netdevice_hard_header(struct sk_buff *skb,
 559                                       struct net_device *dev, u16 type,
 560                                       void *daddr, void *saddr, unsigned len)
 561 {
 562         skb->protocol = type;
 563
 564         return dev->hard_header_len;
 565 }
 566
 567 /* * Re-build media header.
 568  * Return:      1       physical address resolved.
 569  *              0       physical address not resolved */
 570 static int cycx_netdevice_rebuild_header(struct sk_buff *skb)
 571 {
 572         return 1;
 573 }
 574
 575 /* Send a packet on a network interface.
 576  * o set busy flag (marks start of the transmission).
 577  * o check link state. If link is not up, then drop the packet.
 578  * o check channel status. If it's down then initiate a call.
 579  * o pass a packet to corresponding WAN device.
 580  * o free socket buffer
 581  *
 582  * Return:      0       complete (socket buffer must be freed)
 583  *              non-0   packet may be re-transmitted (tbusy must be set)
 584  *
 585  * Notes:
 586  * 1. This routine is called either by the protocol stack or by the "net
 587  *    bottom half" (with interrupts enabled).
 588  * 2. Setting tbusy flag will inhibit further transmit requests from the
 589  *    protocol stack and can be used for flow control with protocol layer. */
 590 static int cycx_netdevice_hard_start_xmit(struct sk_buff *skb,
 591                                           struct net_device *dev)
 592 {
 593         struct cycx_x25_channel *chan = dev->priv;
 594         struct cycx_device *card = chan->card;
 595
 596         if (!chan->svc)
 597                 chan->protocol = skb->protocol;
 598
 599         if (card->wandev.state != WAN_CONNECTED)
 600                 ++chan->ifstats.tx_dropped;
 601         else if (chan->svc && chan->protocol &&
 602                  chan->protocol != skb->protocol) {
 603                 printk(KERN_INFO
 604                        "%s: unsupported Ethertype 0x%04X on interface %s!\n",
 605                        card->devname, skb->protocol, dev->name);
 606                 ++chan->ifstats.tx_errors;
 607         } else if (chan->protocol == ETH_P_IP) {
 608                 switch (chan->state) {
 609                 case WAN_DISCONNECTED:
 610                         if (cycx_x25_chan_connect(dev)) {
 611                                 netif_stop_queue(dev);
 612                                 return -EBUSY;
 613                         }
 614                         /* fall thru */
 615                 case WAN_CONNECTED:
 616                         reset_timer(dev);
 617                         dev->trans_start = jiffies;
 618                         netif_stop_queue(dev);
 619
 620                         if (cycx_x25_chan_send(dev, skb))
 621                                 return -EBUSY;
 622
 623                         break;
 624                 default:
 625                         ++chan->ifstats.tx_dropped;
 626                         ++card->wandev.stats.tx_dropped;
 627         }
 628         } else { /* chan->protocol == ETH_P_X25 */
 629                 switch (skb->data[0]) {
 630                 case 0: break;
 631                 case 1: /* Connect request */
 632                         cycx_x25_chan_connect(dev);
 633                         goto free_packet;
 634                 case 2: /* Disconnect request */
 635                         cycx_x25_chan_disconnect(dev);
 636                         goto free_packet;
 637                 default:
 638                         printk(KERN_INFO
 639                                "%s: unknown %d x25-iface request on %s!\n",
 640                                card->devname, skb->data[0], dev->name);
 641                         ++chan->ifstats.tx_errors;
 642                         goto free_packet;
 643                 }
 644
 645                 skb_pull(skb, 1); /* Remove control byte */
 646                 reset_timer(dev);
 647                 dev->trans_start = jiffies;
 648                 netif_stop_queue(dev);
 649
 650                 if (cycx_x25_chan_send(dev, skb)) {
 651                         /* prepare for future retransmissions */
 652                         skb_push(skb, 1);
 653                         return -EBUSY;
 654                 }
 655         }
 656
 657 free_packet:
 658         dev_kfree_skb(skb);
 659
 660         return 0;
 661 }
 662
 663 /* Get Ethernet-style interface statistics.
 664  * Return a pointer to struct net_device_stats */
 665 static struct net_device_stats *cycx_netdevice_get_stats(struct net_device *dev)
 666 {
 667         struct cycx_x25_channel *chan = dev->priv;
 668
 669         return chan ? &chan->ifstats : NULL;
 670 }
 671
 672 /* Interrupt Handlers */
 673 /* X.25 Interrupt Service Routine. */
 674 static void cycx_x25_irq_handler(struct cycx_device *card)
 675 {
 676         struct cycx_x25_cmd cmd;
 677         u16 z = 0;
 678
 679         card->in_isr = 1;
 680         card->buff_int_mode_unbusy = 0;
 681         cycx_peek(&card->hw, X25_RXMBOX_OFFS, &cmd, sizeof(cmd));
 682
 683         switch (cmd.command) {
 684         case X25_DATA_INDICATION:
 685                 cycx_x25_irq_rx(card, &cmd);
 686                 break;
 687         case X25_ACK_FROM_VC:
 688                 cycx_x25_irq_tx(card, &cmd);
 689                 break;
 690         case X25_LOG:
 691                 cycx_x25_irq_log(card, &cmd);
 692                 break;
 693         case X25_STATISTIC:
 694                 cycx_x25_irq_stat(card, &cmd);
 695                 break;
 696         case X25_CONNECT_CONFIRM:
 697                 cycx_x25_irq_connect_confirm(card, &cmd);
 698                 break;
 699         case X25_CONNECT_INDICATION:
 700                 cycx_x25_irq_connect(card, &cmd);
 701                 break;
 702         case X25_DISCONNECT_INDICATION:
 703                 cycx_x25_irq_disconnect(card, &cmd);
 704                 break;
 705         case X25_DISCONNECT_CONFIRM:
 706                 cycx_x25_irq_disconnect_confirm(card, &cmd);
 707                 break;
 708         case X25_LINE_ON:
 709                 cycx_set_state(card, WAN_CONNECTED);
 710                 break;
 711         case X25_LINE_OFF:
 712                 cycx_set_state(card, WAN_DISCONNECTED);
 713                 break;
 714         default:
 715                 cycx_x25_irq_spurious(card, &cmd);
 716                 break;
 717         }
 718
 719         cycx_poke(&card->hw, 0, &z, sizeof(z));
 720         cycx_poke(&card->hw, X25_RXMBOX_OFFS, &z, sizeof(z));
 721         card->in_isr = 0;
 722 }
 723
 724 /* Transmit interrupt handler.
 725  *      o Release socket buffer
 726  *      o Clear 'tbusy' flag */
 727 static void cycx_x25_irq_tx(struct cycx_device *card, struct cycx_x25_cmd *cmd)
 728 {
 729         struct net_device *dev;
 730         struct wan_device *wandev = &card->wandev;
 731         u8 lcn;
 732
 733         cycx_peek(&card->hw, cmd->buf, &lcn, sizeof(lcn));
 734
 735         /* unbusy device and then dev_tint(); */
 736         dev = cycx_x25_get_dev_by_lcn(wandev, lcn);
 737         if (dev) {
 738                 card->buff_int_mode_unbusy = 1;
 739                 netif_wake_queue(dev);
 740         } else
 741                 printk(KERN_ERR "%s:ackvc for inexistent lcn %d\n",
 742                                  card->devname, lcn);
 743 }
 744
 745 /* Receive interrupt handler.
 746  * This routine handles fragmented IP packets using M-bit according to the
 747  * RFC1356.
 748  * o map logical channel number to network interface.
 749  * o allocate socket buffer or append received packet to the existing one.
 750  * o if M-bit is reset (i.e. it's the last packet in a sequence) then
 751  *   decapsulate packet and pass socket buffer to the protocol stack.
 752  *
 753  * Notes:
 754  * 1. When allocating a socket buffer, if M-bit is set then more data is
 755  *    coming and we have to allocate buffer for the maximum IP packet size
 756  *    expected on this channel.
 757  * 2. If something goes wrong and X.25 packet has to be dropped (e.g. no
 758  *    socket buffers available) the whole packet sequence must be discarded. */
 759 static void cycx_x25_irq_rx(struct cycx_device *card, struct cycx_x25_cmd *cmd)
 760 {
 761         struct wan_device *wandev = &card->wandev;
 762         struct net_device *dev;
 763         struct cycx_x25_channel *chan;
 764         struct sk_buff *skb;
 765         u8 bitm, lcn;
 766         int pktlen = cmd->len - 5;
 767
 768         cycx_peek(&card->hw, cmd->buf, &lcn, sizeof(lcn));
 769         cycx_peek(&card->hw, cmd->buf + 4, &bitm, sizeof(bitm));
 770         bitm &= 0x10;
 771
 772         dev = cycx_x25_get_dev_by_lcn(wandev, lcn);
 773         if (!dev) {
 774                 /* Invalid channel, discard packet */
 775                 printk(KERN_INFO "%s: receiving on orphaned LCN %d!\n",
 776                                  card->devname, lcn);
 777                 return;
 778         }
 779
 780         chan = dev->priv;
 781         reset_timer(dev);
 782
 783         if (chan->drop_sequence) {
 784                 if (!bitm)
 785                         chan->drop_sequence = 0;
 786                 else
 787                         return;
 788         }
 789
 790         if ((skb = chan->rx_skb) == NULL) {
 791                 /* Allocate new socket buffer */
 792                 int bufsize = bitm ? dev->mtu : pktlen;
 793
 794                 if ((skb = dev_alloc_skb((chan->protocol == ETH_P_X25 ? 1 : 0) +
 795                                          bufsize +
 796                                          dev->hard_header_len)) == NULL) {
 797                         printk(KERN_INFO "%s: no socket buffers available!\n",
 798                                          card->devname);
 799                         chan->drop_sequence = 1;
 800                         ++chan->ifstats.rx_dropped;
 801                         return;
 802                 }
 803
 804                 if (chan->protocol == ETH_P_X25) /* X.25 socket layer control */
 805                         /* 0 = data packet (dev_alloc_skb zeroed skb->data) */
 806                         skb_put(skb, 1);
 807
 808                 skb->dev = dev;
 809                 skb->protocol = htons(chan->protocol);
 810                 chan->rx_skb = skb;
 811         }
 812
 813         if (skb_tailroom(skb) < pktlen) {
 814                 /* No room for the packet. Call off the whole thing! */
 815                 dev_kfree_skb_irq(skb);
 816                 chan->rx_skb = NULL;
 817
 818                 if (bitm)
 819                         chan->drop_sequence = 1;
 820
 821                 printk(KERN_INFO "%s: unexpectedly long packet sequence "
 822                         "on interface %s!\n", card->devname, dev->name);
 823                 ++chan->ifstats.rx_length_errors;
 824                 return;
 825         }
 826
 827         /* Append packet to the socket buffer  */
 828         cycx_peek(&card->hw, cmd->buf + 5, skb_put(skb, pktlen), pktlen);
 829
 830         if (bitm)
 831                 return; /* more data is coming */
 832
 833         chan->rx_skb = NULL;            /* dequeue packet */
 834
 835         ++chan->ifstats.rx_packets;
 836         chan->ifstats.rx_bytes += pktlen;
 837
 838         skb->mac.raw = skb->data;
 839         netif_rx(skb);
 840         dev->last_rx = jiffies;         /* timestamp */
 841 }
 842
 843 /* Connect interrupt handler. */
 844 static void cycx_x25_irq_connect(struct cycx_device *card,
 845                                  struct cycx_x25_cmd *cmd)
 846 {
 847         struct wan_device *wandev = &card->wandev;
 848         struct net_device *dev = NULL;
 849         struct cycx_x25_channel *chan;
 850         u8 d[32],
 851            loc[24],
 852            rem[24];
 853         u8 lcn, sizeloc, sizerem;
 854
 855         cycx_peek(&card->hw, cmd->buf, &lcn, sizeof(lcn));
 856         cycx_peek(&card->hw, cmd->buf + 5, &sizeloc, sizeof(sizeloc));
 857         cycx_peek(&card->hw, cmd->buf + 6, d, cmd->len - 6);
 858
 859         sizerem = sizeloc >> 4;
 860         sizeloc &= 0x0F;
 861
 862         loc[0] = rem[0] = '\0';
 863
 864         if (sizeloc)
 865                 nibble_to_byte(d, loc, sizeloc, 0);
 866
 867         if (sizerem)
 868                 nibble_to_byte(d + (sizeloc >> 1), rem, sizerem, sizeloc & 1);
 869
 870         dprintk(1, KERN_INFO "%s:lcn=%d, local=%s, remote=%s\n",
 871                           __FUNCTION__, lcn, loc, rem);
 872
 873         dev = cycx_x25_get_dev_by_dte_addr(wandev, rem);
 874         if (!dev) {
 875                 /* Invalid channel, discard packet */
 876                 printk(KERN_INFO "%s: connect not expected: remote %s!\n",
 877                                  card->devname, rem);
 878                 return;
 879         }
 880
 881         chan = dev->priv;
 882         chan->lcn = lcn;
 883         cycx_x25_connect_response(card, chan);
 884         cycx_x25_set_chan_state(dev, WAN_CONNECTED);
 885 }
 886
 887 /* Connect confirm interrupt handler. */
 888 static void cycx_x25_irq_connect_confirm(struct cycx_device *card,
 889                                          struct cycx_x25_cmd *cmd)
 890 {
 891         struct wan_device *wandev = &card->wandev;
 892         struct net_device *dev;
 893         struct cycx_x25_channel *chan;
 894         u8 lcn, key;
 895
 896         cycx_peek(&card->hw, cmd->buf, &lcn, sizeof(lcn));
 897         cycx_peek(&card->hw, cmd->buf + 1, &key, sizeof(key));
 898         dprintk(1, KERN_INFO "%s: %s:lcn=%d, key=%d\n",
 899                           card->devname, __FUNCTION__, lcn, key);
 900
 901         dev = cycx_x25_get_dev_by_lcn(wandev, -key);
 902         if (!dev) {
 903                 /* Invalid channel, discard packet */
 904                 clear_bit(--key, (void*)&card->u.x.connection_keys);
 905                 printk(KERN_INFO "%s: connect confirm not expected: lcn %d, "
 906                                  "key=%d!\n", card->devname, lcn, key);
 907                 return;
 908         }
 909
 910         clear_bit(--key, (void*)&card->u.x.connection_keys);
 911         chan = dev->priv;
 912         chan->lcn = lcn;
 913         cycx_x25_set_chan_state(dev, WAN_CONNECTED);
 914 }
 915
 916 /* Disconnect confirm interrupt handler. */
 917 static void cycx_x25_irq_disconnect_confirm(struct cycx_device *card,
 918                                             struct cycx_x25_cmd *cmd)
 919 {
 920         struct wan_device *wandev = &card->wandev;
 921         struct net_device *dev;
 922         u8 lcn;
 923
 924         cycx_peek(&card->hw, cmd->buf, &lcn, sizeof(lcn));
 925         dprintk(1, KERN_INFO "%s: %s:lcn=%d\n",
 926                           card->devname, __FUNCTION__, lcn);
 927         dev = cycx_x25_get_dev_by_lcn(wandev, lcn);
 928         if (!dev) {
 929                 /* Invalid channel, discard packet */
 930                 printk(KERN_INFO "%s:disconnect confirm not expected!:lcn %d\n",
 931                                  card->devname, lcn);
 932                 return;
 933         }
 934
 935         cycx_x25_set_chan_state(dev, WAN_DISCONNECTED);
 936 }
 937
 938 /* disconnect interrupt handler. */
 939 static void cycx_x25_irq_disconnect(struct cycx_device *card,
 940                                     struct cycx_x25_cmd *cmd)
 941 {
 942         struct wan_device *wandev = &card->wandev;
 943         struct net_device *dev;
 944         u8 lcn;
 945
 946         cycx_peek(&card->hw, cmd->buf, &lcn, sizeof(lcn));
 947         dprintk(1, KERN_INFO "%s:lcn=%d\n", __FUNCTION__, lcn);
 948
 949         dev = cycx_x25_get_dev_by_lcn(wandev, lcn);
 950         if (dev) {
 951                 struct cycx_x25_channel *chan = dev->priv;
 952
 953                 cycx_x25_disconnect_response(card, chan->link, lcn);
 954                 cycx_x25_set_chan_state(dev, WAN_DISCONNECTED);
 955         } else
 956                 cycx_x25_disconnect_response(card, 0, lcn);
 957 }
 958
 959 /* LOG interrupt handler. */
 960 static void cycx_x25_irq_log(struct cycx_device *card, struct cycx_x25_cmd *cmd)
 961 {
 962 #if CYCLOMX_X25_DEBUG
 963         char bf[20];
 964         u16 size, toread, link, msg_code;
 965         u8 code, routine;
 966
 967         cycx_peek(&card->hw, cmd->buf, &msg_code, sizeof(msg_code));
 968         cycx_peek(&card->hw, cmd->buf + 2, &link, sizeof(link));
 969         cycx_peek(&card->hw, cmd->buf + 4, &size, sizeof(size));
 970         /* at most 20 bytes are available... thanks to Daniela :) */
 971         toread = size < 20 ? size : 20;
 972         cycx_peek(&card->hw, cmd->buf + 10, &bf, toread);
 973         cycx_peek(&card->hw, cmd->buf + 10 + toread, &code, 1);
 974         cycx_peek(&card->hw, cmd->buf + 10 + toread + 1, &routine, 1);
 975
 976         printk(KERN_INFO "cycx_x25_irq_handler: X25_LOG (0x4500) indic.:\n");
 977         printk(KERN_INFO "cmd->buf=0x%X\n", cmd->buf);
 978         printk(KERN_INFO "Log message code=0x%X\n", msg_code);
 979         printk(KERN_INFO "Link=%d\n", link);
 980         printk(KERN_INFO "log code=0x%X\n", code);
 981         printk(KERN_INFO "log routine=0x%X\n", routine);
 982         printk(KERN_INFO "Message size=%d\n", size);
 983         hex_dump("Message", bf, toread);
 984 #endif
 985 }
 986
 987 /* STATISTIC interrupt handler. */
 988 static void cycx_x25_irq_stat(struct cycx_device *card,
 989                               struct cycx_x25_cmd *cmd)
 990 {
 991         cycx_peek(&card->hw, cmd->buf, &card->u.x.stats,
 992                   sizeof(card->u.x.stats));
 993         hex_dump("cycx_x25_irq_stat", (unsigned char*)&card->u.x.stats,
 994                  sizeof(card->u.x.stats));
 995         cycx_x25_dump_stats(&card->u.x.stats);
 996         wake_up_interruptible(&card->wait_stats);
 997 }
 998
 999 /* Spurious interrupt handler.
1000  * o print a warning
1001  * If number of spurious interrupts exceeded some limit, then ??? */
1002 static void cycx_x25_irq_spurious(struct cycx_device *card,
1003                                   struct cycx_x25_cmd *cmd)
1004 {
1005         printk(KERN_INFO "%s: spurious interrupt (0x%X)!\n",
1006                          card->devname, cmd->command);
1007 }
1008 #ifdef CYCLOMX_X25_DEBUG
1009 static void hex_dump(char *msg, unsigned char *p, int len)
1010 {
1011         unsigned char hex[1024],
1012                 * phex = hex;
1013
1014         if (len >= (sizeof(hex) / 2))
1015                 len = (sizeof(hex) / 2) - 1;
1016
1017         while (len--) {
1018                 sprintf(phex, "%02x", *p++);
1019                 phex += 2;
1020         }
1021
1022         printk(KERN_INFO "%s: %s\n", msg, hex);
1023 }
1024 #endif
1025
1026 /* Cyclom 2X Firmware-Specific Functions */
1027 /* Exec X.25 command. */
1028 static int x25_exec(struct cycx_device *card, int command, int link,
1029                     void *d1, int len1, void *d2, int len2)
1030 {
1031         struct cycx_x25_cmd c;
1032         unsigned long flags;
1033         u32 addr = 0x1200 + 0x2E0 * link + 0x1E2;
1034         u8 retry = CYCX_X25_MAX_CMD_RETRY;
1035         int err = 0;
1036
1037         c.command = command;
1038         c.link = link;
1039         c.len = len1 + len2;
1040
1041         spin_lock_irqsave(&card->u.x.lock, flags);
1042
1043         /* write command */
1044         cycx_poke(&card->hw, X25_MBOX_OFFS, &c, sizeof(c) - sizeof(c.buf));
1045
1046         /* write X.25 data */
1047         if (d1) {
1048                 cycx_poke(&card->hw, addr, d1, len1);
1049
1050                 if (d2) {
1051                         if (len2 > 254) {
1052                                 u32 addr1 = 0xA00 + 0x400 * link;
1053
1054                                 cycx_poke(&card->hw, addr + len1, d2, 249);
1055                                 cycx_poke(&card->hw, addr1, ((u8*)d2) + 249,
1056                                           len2 - 249);
1057                         } else
1058                                 cycx_poke(&card->hw, addr + len1, d2, len2);
1059                 }
1060         }
1061
1062         /* generate interruption, executing command */
1063         cycx_intr(&card->hw);
1064
1065         /* wait till card->mbox == 0 */
1066         do {
1067                 err = cycx_exec(card->mbox);
1068         } while (retry-- && err);
1069
1070         spin_unlock_irqrestore(&card->u.x.lock, flags);
1071
1072         return err;
1073 }
1074
1075 /* Configure adapter. */
1076 static int cycx_x25_configure(struct cycx_device *card,
1077                               struct cycx_x25_config *conf)
1078 {
1079         struct {
1080                 u16 nlinks;
1081                 struct cycx_x25_config conf[2];
1082         } x25_cmd_conf;
1083
1084         memset(&x25_cmd_conf, 0, sizeof(x25_cmd_conf));
1085         x25_cmd_conf.nlinks = 2;
1086         x25_cmd_conf.conf[0] = *conf;
1087         /* FIXME: we need to find a way in the wanrouter framework
1088                   to configure the second link, for now lets use it
1089                   with the same config from the first link, fixing
1090                   the interface type to RS232, the speed in 38400 and
1091                   the clock to external */
1092         x25_cmd_conf.conf[1] = *conf;
1093         x25_cmd_conf.conf[1].link = 1;
1094         x25_cmd_conf.conf[1].speed = 5; /* 38400 */
1095         x25_cmd_conf.conf[1].clock = 8;
1096         x25_cmd_conf.conf[1].flags = 0; /* default = RS232 */
1097
1098         cycx_x25_dump_config(&x25_cmd_conf.conf[0]);
1099         cycx_x25_dump_config(&x25_cmd_conf.conf[1]);
1100
1101         return x25_exec(card, X25_CONFIG, 0,
1102                         &x25_cmd_conf, sizeof(x25_cmd_conf), NULL, 0);
1103 }
1104
1105 /* Get protocol statistics. */
1106 static int cycx_x25_get_stats(struct cycx_device *card)
1107 {
1108         /* the firmware expects 20 in the size field!!!
1109            thanks to Daniela */
1110         int err = x25_exec(card, X25_STATISTIC, 0, NULL, 20, NULL, 0);
1111
1112         if (err)
1113                 return err;
1114
1115         interruptible_sleep_on(&card->wait_stats);
1116
1117         if (signal_pending(current))
1118                 return -EINTR;
1119
1120         card->wandev.stats.rx_packets = card->u.x.stats.n2_rx_frames;
1121         card->wandev.stats.rx_over_errors = card->u.x.stats.rx_over_errors;
1122         card->wandev.stats.rx_crc_errors = card->u.x.stats.rx_crc_errors;
1123         card->wandev.stats.rx_length_errors = 0; /* not available from fw */
1124         card->wandev.stats.rx_frame_errors = 0; /* not available from fw */
1125         card->wandev.stats.rx_missed_errors = card->u.x.stats.rx_aborts;
1126         card->wandev.stats.rx_dropped = 0; /* not available from fw */
1127         card->wandev.stats.rx_errors = 0; /* not available from fw */
1128         card->wandev.stats.tx_packets = card->u.x.stats.n2_tx_frames;
1129         card->wandev.stats.tx_aborted_errors = card->u.x.stats.tx_aborts;
1130         card->wandev.stats.tx_dropped = 0; /* not available from fw */
1131         card->wandev.stats.collisions = 0; /* not available from fw */
1132         card->wandev.stats.tx_errors = 0; /* not available from fw */
1133
1134         cycx_x25_dump_devs(&card->wandev);
1135
1136         return 0;
1137 }
1138
1139 /* return the number of nibbles */
1140 static int byte_to_nibble(u8 *s, u8 *d, char *nibble)
1141 {
1142         int i = 0;
1143
1144         if (*nibble && *s) {
1145                 d[i] |= *s++ - '0';
1146                 *nibble = 0;
1147                 ++i;
1148         }
1149
1150         while (*s) {
1151                 d[i] = (*s - '0') << 4;
1152                 if (*(s + 1))
1153                         d[i] |= *(s + 1) - '0';
1154                 else {
1155                         *nibble = 1;
1156                         break;
1157                 }
1158                 ++i;
1159                 s += 2;
1160         }
1161
1162         return i;
1163 }
1164
1165 static void nibble_to_byte(u8 *s, u8 *d, u8 len, u8 nibble)
1166 {
1167         if (nibble) {
1168                 *d++ = '0' + (*s++ & 0x0F);
1169                 --len;
1170         }
1171
1172         while (len) {
1173                 *d++ = '0' + (*s >> 4);
1174
1175                 if (--len) {
1176                         *d++ = '0' + (*s & 0x0F);
1177                         --len;
1178                 } else break;
1179
1180                 ++s;
1181         }
1182
1183         *d = '\0';
1184 }
1185
1186 /* Place X.25 call. */
1187 static int x25_place_call(struct cycx_device *card,
1188                           struct cycx_x25_channel *chan)
1189 {
1190         int err = 0,
1191             len;
1192         char d[64],
1193              nibble = 0,
1194              mylen = chan->local_addr ? strlen(chan->local_addr) : 0,
1195              remotelen = strlen(chan->addr);
1196         u8 key;
1197
1198         if (card->u.x.connection_keys == ~0UL) {
1199                 printk(KERN_INFO "%s: too many simultaneous connection "
1200                                  "requests!\n", card->devname);
1201                 return -EAGAIN;
1202         }
1203
1204         key = ffz(card->u.x.connection_keys);
1205         set_bit(key, (void*)&card->u.x.connection_keys);
1206         ++key;
1207         dprintk(1, KERN_INFO "%s:x25_place_call:key=%d\n", card->devname, key);
1208         memset(d, 0, sizeof(d));
1209         d[1] = key; /* user key */
1210         d[2] = 0x10;
1211         d[4] = 0x0B;
1212
1213         len = byte_to_nibble(chan->addr, d + 6, &nibble);
1214
1215         if (chan->local_addr)
1216                 len += byte_to_nibble(chan->local_addr, d + 6 + len, &nibble);
1217
1218         if (nibble)
1219                 ++len;
1220
1221         d[5] = mylen << 4 | remotelen;
1222         d[6 + len + 1] = 0xCC; /* TCP/IP over X.25, thanks to Daniela :) */
1223
1224         if ((err = x25_exec(card, X25_CONNECT_REQUEST, chan->link,
1225                             &d, 7 + len + 1, NULL, 0)) != 0)
1226                 clear_bit(--key, (void*)&card->u.x.connection_keys);
1227         else
1228                 chan->lcn = -key;
1229
1230         return err;
1231 }
1232
1233 /* Place X.25 CONNECT RESPONSE. */
1234 static int cycx_x25_connect_response(struct cycx_device *card,
1235                                      struct cycx_x25_channel *chan)
1236 {
1237         u8 d[8];
1238
1239         memset(d, 0, sizeof(d));
1240         d[0] = d[3] = chan->lcn;
1241         d[2] = 0x10;
1242         d[4] = 0x0F;
1243         d[7] = 0xCC; /* TCP/IP over X.25, thanks Daniela */
1244
1245         return x25_exec(card, X25_CONNECT_RESPONSE, chan->link, &d, 8, NULL, 0);
1246 }
1247
1248 /* Place X.25 DISCONNECT RESPONSE.  */
1249 static int cycx_x25_disconnect_response(struct cycx_device *card, u8 link,
1250                                         u8 lcn)
1251 {
1252         char d[5];
1253
1254         memset(d, 0, sizeof(d));
1255         d[0] = d[3] = lcn;
1256         d[2] = 0x10;
1257         d[4] = 0x17;
1258
1259         return x25_exec(card, X25_DISCONNECT_RESPONSE, link, &d, 5, NULL, 0);
1260 }
1261
1262 /* Clear X.25 call.  */
1263 static int x25_clear_call(struct cycx_device *card, u8 link, u8 lcn, u8 cause,
1264                           u8 diagn)
1265 {
1266         u8 d[7];
1267
1268         memset(d, 0, sizeof(d));
1269         d[0] = d[3] = lcn;
1270         d[2] = 0x10;
1271         d[4] = 0x13;
1272         d[5] = cause;
1273         d[6] = diagn;
1274
1275         return x25_exec(card, X25_DISCONNECT_REQUEST, link, d, 7, NULL, 0);
1276 }
1277
1278 /* Send X.25 data packet. */
1279 static int cycx_x25_send(struct cycx_device *card, u8 link, u8 lcn, u8 bitm,
1280                          int len, void *buf)
1281 {
1282         u8 d[] = "?\xFF\x10??";
1283
1284         d[0] = d[3] = lcn;
1285         d[4] = bitm;
1286
1287         return x25_exec(card, X25_DATA_REQUEST, link, &d, 5, buf, len);
1288 }
1289
1290 /* Miscellaneous */
1291 /* Find network device by its channel number.  */
1292 static struct net_device *cycx_x25_get_dev_by_lcn(struct wan_device *wandev,
1293                                                   s16 lcn)
1294 {
1295         struct net_device *dev = wandev->dev;
1296         struct cycx_x25_channel *chan;
1297
1298         while (dev) {
1299                 chan = (struct cycx_x25_channel*)dev->priv;
1300
1301                 if (chan->lcn == lcn)
1302                         break;
1303                 dev = chan->slave;
1304         }
1305         return dev;
1306 }
1307
1308 /* Find network device by its remote dte address. */
1309 static struct net_device *
1310         cycx_x25_get_dev_by_dte_addr(struct wan_device *wandev, char *dte)
1311 {
1312         struct net_device *dev = wandev->dev;
1313         struct cycx_x25_channel *chan;
1314
1315         while (dev) {
1316                 chan = (struct cycx_x25_channel*)dev->priv;
1317
1318                 if (!strcmp(chan->addr, dte))
1319                         break;
1320                 dev = chan->slave;
1321         }
1322         return dev;
1323 }
1324
1325 /* Initiate connection on the logical channel.
1326  * o for PVC we just get channel configuration
1327  * o for SVCs place an X.25 call
1328  *
1329  * Return:      0       connected
1330  *              >0      connection in progress
1331  *              <0      failure */
1332 static int cycx_x25_chan_connect(struct net_device *dev)
1333 {
1334         struct cycx_x25_channel *chan = dev->priv;
1335         struct cycx_device *card = chan->card;
1336
1337         if (chan->svc) {
1338                 if (!chan->addr[0])
1339                         return -EINVAL; /* no destination address */
1340
1341                 dprintk(1, KERN_INFO "%s: placing X.25 call to %s...\n",
1342                                   card->devname, chan->addr);
1343
1344                 if (x25_place_call(card, chan))
1345                         return -EIO;
1346
1347                 cycx_x25_set_chan_state(dev, WAN_CONNECTING);
1348                 return 1;
1349         } else
1350                 cycx_x25_set_chan_state(dev, WAN_CONNECTED);
1351
1352         return 0;
1353 }
1354
1355 /* Disconnect logical channel.
1356  * o if SVC then clear X.25 call */
1357 static void cycx_x25_chan_disconnect(struct net_device *dev)
1358 {
1359         struct cycx_x25_channel *chan = dev->priv;
1360
1361         if (chan->svc) {
1362                 x25_clear_call(chan->card, chan->link, chan->lcn, 0, 0);
1363                 cycx_x25_set_chan_state(dev, WAN_DISCONNECTING);
1364         } else
1365                 cycx_x25_set_chan_state(dev, WAN_DISCONNECTED);
1366 }
1367
1368 /* Called by kernel timer */
1369 static void cycx_x25_chan_timer(unsigned long d)
1370 {
1371         struct net_device *dev = (struct net_device *)d;
1372         struct cycx_x25_channel *chan = dev->priv;
1373
1374         if (chan->state == WAN_CONNECTED)
1375                 cycx_x25_chan_disconnect(dev);
1376         else
1377                 printk(KERN_ERR "%s: %s for svc (%s) not connected!\n",
1378                                 chan->card->devname, __FUNCTION__, dev->name);
1379 }
1380
1381 /* Set logical channel state. */
1382 static void cycx_x25_set_chan_state(struct net_device *dev, u8 state)
1383 {
1384         struct cycx_x25_channel *chan = dev->priv;
1385         struct cycx_device *card = chan->card;
1386         unsigned long flags;
1387         char *string_state = NULL;
1388
1389         spin_lock_irqsave(&card->lock, flags);
1390
1391         if (chan->state != state) {
1392                 if (chan->svc && chan->state == WAN_CONNECTED)
1393                         del_timer(&chan->timer);
1394
1395                 switch (state) {
1396                 case WAN_CONNECTED:
1397                         string_state = "connected!";
1398                         *(u16*)dev->dev_addr = htons(chan->lcn);
1399                         netif_wake_queue(dev);
1400                         reset_timer(dev);
1401
1402                         if (chan->protocol == ETH_P_X25)
1403                                 cycx_x25_chan_send_event(dev, 1);
1404
1405                         break;
1406                 case WAN_CONNECTING:
1407                         string_state = "connecting...";
1408                         break;
1409                 case WAN_DISCONNECTING:
1410                         string_state = "disconnecting...";
1411                         break;
1412                 case WAN_DISCONNECTED:
1413                         string_state = "disconnected!";
1414
1415                         if (chan->svc) {
1416                                 *(unsigned short*)dev->dev_addr = 0;
1417                                 chan->lcn = 0;
1418                         }
1419
1420                         if (chan->protocol == ETH_P_X25)
1421                                 cycx_x25_chan_send_event(dev, 2);
1422
1423                         netif_wake_queue(dev);
1424                         break;
1425                 }
1426
1427                 printk(KERN_INFO "%s: interface %s %s\n", card->devname,
1428                                   dev->name, string_state);
1429                 chan->state = state;
1430         }
1431
1432         spin_unlock_irqrestore(&card->lock, flags);
1433 }
1434
1435 /* Send packet on a logical channel.
1436  *      When this function is called, tx_skb field of the channel data space
1437  *      points to the transmit socket buffer.  When transmission is complete,
1438  *      release socket buffer and reset 'tbusy' flag.
1439  *
1440  * Return:      0       - transmission complete
1441  *              1       - busy
1442  *
1443  * Notes:
1444  * 1. If packet length is greater than MTU for this channel, we'll fragment
1445  *    the packet into 'complete sequence' using M-bit.
1446  * 2. When transmission is complete, an event notification should be issued
1447  *    to the router.  */
1448 static int cycx_x25_chan_send(struct net_device *dev, struct sk_buff *skb)
1449 {
1450         struct cycx_x25_channel *chan = dev->priv;
1451         struct cycx_device *card = chan->card;
1452         int bitm = 0;           /* final packet */
1453         unsigned len = skb->len;
1454
1455         if (skb->len > card->wandev.mtu) {
1456                 len = card->wandev.mtu;
1457                 bitm = 0x10;            /* set M-bit (more data) */
1458         }
1459
1460         if (cycx_x25_send(card, chan->link, chan->lcn, bitm, len, skb->data))
1461                 return 1;
1462
1463         if (bitm) {
1464                 skb_pull(skb, len);
1465                 return 1;
1466         }
1467
1468         ++chan->ifstats.tx_packets;
1469         chan->ifstats.tx_bytes += len;
1470
1471         return 0;
1472 }
1473
1474 /* Send event (connection, disconnection, etc) to X.25 socket layer */
1475
1476 static void cycx_x25_chan_send_event(struct net_device *dev, u8 event)
1477 {
1478         struct sk_buff *skb;
1479         unsigned char *ptr;
1480
1481         if ((skb = dev_alloc_skb(1)) == NULL) {
1482                 printk(KERN_ERR "%s: out of memory\n", __FUNCTION__);
1483                 return;
1484         }
1485
1486         ptr  = skb_put(skb, 1);
1487         *ptr = event;
1488
1489         skb->dev = dev;
1490         skb->protocol = htons(ETH_P_X25);
1491         skb->mac.raw = skb->data;
1492         skb->pkt_type = PACKET_HOST;
1493
1494         netif_rx(skb);
1495         dev->last_rx = jiffies;         /* timestamp */
1496 }
1497
1498 /* Convert line speed in bps to a number used by cyclom 2x code. */
1499 static u8 bps_to_speed_code(u32 bps)
1500 {
1501         u8 number = 0; /* defaults to the lowest (1200) speed ;> */
1502
1503              if (bps >= 512000) number = 8;
1504         else if (bps >= 256000) number = 7;
1505         else if (bps >= 64000)  number = 6;
1506         else if (bps >= 38400)  number = 5;
1507         else if (bps >= 19200)  number = 4;
1508         else if (bps >= 9600)   number = 3;
1509         else if (bps >= 4800)   number = 2;
1510         else if (bps >= 2400)   number = 1;
1511
1512         return number;
1513 }
1514
1515 /* log base 2 */
1516 static u8 log2(u32 n)
1517 {
1518         u8 log = 0;
1519
1520         if (!n)
1521                 return 0;
1522
1523         while (n > 1) {
1524                 n >>= 1;
1525                 ++log;
1526         }
1527
1528         return log;
1529 }
1530
1531 /* Convert decimal string to unsigned integer.
1532  * If len != 0 then only 'len' characters of the string are converted. */
1533 static unsigned dec_to_uint(u8 *str, int len)
1534 {
1535         unsigned val = 0;
1536
1537         if (!len)
1538                 len = strlen(str);
1539
1540         for (; len && is_digit(*str); ++str, --len)
1541                 val = (val * 10) + (*str - (unsigned) '0');
1542
1543         return val;
1544 }
1545
1546 static void reset_timer(struct net_device *dev)
1547 {
1548         struct cycx_x25_channel *chan = dev->priv;
1549
1550         if (chan->svc)
1551                 mod_timer(&chan->timer, jiffies+chan->idle_tmout*HZ);
1552 }
1553 #ifdef CYCLOMX_X25_DEBUG
1554 static void cycx_x25_dump_config(struct cycx_x25_config *conf)
1555 {
1556         printk(KERN_INFO "X.25 configuration\n");
1557         printk(KERN_INFO "-----------------\n");
1558         printk(KERN_INFO "link number=%d\n", conf->link);
1559         printk(KERN_INFO "line speed=%d\n", conf->speed);
1560         printk(KERN_INFO "clock=%sternal\n", conf->clock == 8 ? "Ex" : "In");
1561         printk(KERN_INFO "# level 2 retransm.=%d\n", conf->n2);
1562         printk(KERN_INFO "level 2 window=%d\n", conf->n2win);
1563         printk(KERN_INFO "level 3 window=%d\n", conf->n3win);
1564         printk(KERN_INFO "# logical channels=%d\n", conf->nvc);
1565         printk(KERN_INFO "level 3 pkt len=%d\n", conf->pktlen);
1566         printk(KERN_INFO "my address=%d\n", conf->locaddr);
1567         printk(KERN_INFO "remote address=%d\n", conf->remaddr);
1568         printk(KERN_INFO "t1=%d seconds\n", conf->t1);
1569         printk(KERN_INFO "t2=%d seconds\n", conf->t2);
1570         printk(KERN_INFO "t21=%d seconds\n", conf->t21);
1571         printk(KERN_INFO "# PVCs=%d\n", conf->npvc);
1572         printk(KERN_INFO "t23=%d seconds\n", conf->t23);
1573         printk(KERN_INFO "flags=0x%x\n", conf->flags);
1574 }
1575
1576 static void cycx_x25_dump_stats(struct cycx_x25_stats *stats)
1577 {
1578         printk(KERN_INFO "X.25 statistics\n");
1579         printk(KERN_INFO "--------------\n");
1580         printk(KERN_INFO "rx_crc_errors=%d\n", stats->rx_crc_errors);
1581         printk(KERN_INFO "rx_over_errors=%d\n", stats->rx_over_errors);
1582         printk(KERN_INFO "n2_tx_frames=%d\n", stats->n2_tx_frames);
1583         printk(KERN_INFO "n2_rx_frames=%d\n", stats->n2_rx_frames);
1584         printk(KERN_INFO "tx_timeouts=%d\n", stats->tx_timeouts);
1585         printk(KERN_INFO "rx_timeouts=%d\n", stats->rx_timeouts);
1586         printk(KERN_INFO "n3_tx_packets=%d\n", stats->n3_tx_packets);
1587         printk(KERN_INFO "n3_rx_packets=%d\n", stats->n3_rx_packets);
1588         printk(KERN_INFO "tx_aborts=%d\n", stats->tx_aborts);
1589         printk(KERN_INFO "rx_aborts=%d\n", stats->rx_aborts);
1590 }
1591
1592 static void cycx_x25_dump_devs(struct wan_device *wandev)
1593 {
1594         struct net_device *dev = wandev->dev;
1595
1596         printk(KERN_INFO "X.25 dev states\n");
1597         printk(KERN_INFO "name: addr:           txoff:  protocol:\n");
1598         printk(KERN_INFO "---------------------------------------\n");
1599
1600         while(dev) {
1601                 struct cycx_x25_channel *chan = dev->priv;
1602
1603                 printk(KERN_INFO "%-5.5s %-15.15s   %d     ETH_P_%s\n",
1604                                  chan->name, chan->addr, netif_queue_stopped(dev),
1605                                  chan->protocol == ETH_P_IP ? "IP" : "X25");
1606                 dev = chan->slave;
1607         }
1608 }
1609
1610 #endif /* CYCLOMX_X25_DEBUG */
1611 /* End */