git.oblomov.eu Git - linux-2.6/blob - drivers/net/hamradio/dmascc.c

   1 /*
   2  * Driver for high-speed SCC boards (those with DMA support)
   3  * Copyright (C) 1997-2000 Klaus Kudielka
   4  *
   5  * S5SCC/DMA support by Janko Koleznik S52HI
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22
  23 #include <linux/module.h>
  24 #include <linux/bitops.h>
  25 #include <linux/delay.h>
  26 #include <linux/errno.h>
  27 #include <linux/if_arp.h>
  28 #include <linux/in.h>
  29 #include <linux/init.h>
  30 #include <linux/interrupt.h>
  31 #include <linux/ioport.h>
  32 #include <linux/kernel.h>
  33 #include <linux/mm.h>
  34 #include <linux/netdevice.h>
  35 #include <linux/rtnetlink.h>
  36 #include <linux/sockios.h>
  37 #include <linux/workqueue.h>
  38 #include <asm/atomic.h>
  39 #include <asm/dma.h>
  40 #include <asm/io.h>
  41 #include <asm/irq.h>
  42 #include <asm/uaccess.h>
  43 #include <net/ax25.h>
  44 #include "z8530.h"
  45
  46
  47 /* Number of buffers per channel */
  48
  49 #define NUM_TX_BUF      2       /* NUM_TX_BUF >= 1 (min. 2 recommended) */
  50 #define NUM_RX_BUF      6       /* NUM_RX_BUF >= 1 (min. 2 recommended) */
  51 #define BUF_SIZE        1576    /* BUF_SIZE >= mtu + hard_header_len */
  52
  53
  54 /* Cards supported */
  55
  56 #define HW_PI           { "Ottawa PI", 0x300, 0x20, 0x10, 8, \
  57                             0, 8, 1843200, 3686400 }
  58 #define HW_PI2          { "Ottawa PI2", 0x300, 0x20, 0x10, 8, \
  59                             0, 8, 3686400, 7372800 }
  60 #define HW_TWIN         { "Gracilis PackeTwin", 0x200, 0x10, 0x10, 32, \
  61                             0, 4, 6144000, 6144000 }
  62 #define HW_S5           { "S5SCC/DMA", 0x200, 0x10, 0x10, 32, \
  63                           0, 8, 4915200, 9830400 }
  64
  65 #define HARDWARE        { HW_PI, HW_PI2, HW_TWIN, HW_S5 }
  66
  67 #define TMR_0_HZ        25600   /* Frequency of timer 0 */
  68
  69 #define TYPE_PI         0
  70 #define TYPE_PI2        1
  71 #define TYPE_TWIN       2
  72 #define TYPE_S5         3
  73 #define NUM_TYPES       4
  74
  75 #define MAX_NUM_DEVS    32
  76
  77
  78 /* SCC chips supported */
  79
  80 #define Z8530           0
  81 #define Z85C30          1
  82 #define Z85230          2
  83
  84 #define CHIPNAMES       { "Z8530", "Z85C30", "Z85230" }
  85
  86
  87 /* I/O registers */
  88
  89 /* 8530 registers relative to card base */
  90 #define SCCB_CMD        0x00
  91 #define SCCB_DATA       0x01
  92 #define SCCA_CMD        0x02
  93 #define SCCA_DATA       0x03
  94
  95 /* 8253/8254 registers relative to card base */
  96 #define TMR_CNT0        0x00
  97 #define TMR_CNT1        0x01
  98 #define TMR_CNT2        0x02
  99 #define TMR_CTRL        0x03
 100
 101 /* Additional PI/PI2 registers relative to card base */
 102 #define PI_DREQ_MASK    0x04
 103
 104 /* Additional PackeTwin registers relative to card base */
 105 #define TWIN_INT_REG    0x08
 106 #define TWIN_CLR_TMR1   0x09
 107 #define TWIN_CLR_TMR2   0x0a
 108 #define TWIN_SPARE_1    0x0b
 109 #define TWIN_DMA_CFG    0x08
 110 #define TWIN_SERIAL_CFG 0x09
 111 #define TWIN_DMA_CLR_FF 0x0a
 112 #define TWIN_SPARE_2    0x0b
 113
 114
 115 /* PackeTwin I/O register values */
 116
 117 /* INT_REG */
 118 #define TWIN_SCC_MSK       0x01
 119 #define TWIN_TMR1_MSK      0x02
 120 #define TWIN_TMR2_MSK      0x04
 121 #define TWIN_INT_MSK       0x07
 122
 123 /* SERIAL_CFG */
 124 #define TWIN_DTRA_ON       0x01
 125 #define TWIN_DTRB_ON       0x02
 126 #define TWIN_EXTCLKA       0x04
 127 #define TWIN_EXTCLKB       0x08
 128 #define TWIN_LOOPA_ON      0x10
 129 #define TWIN_LOOPB_ON      0x20
 130 #define TWIN_EI            0x80
 131
 132 /* DMA_CFG */
 133 #define TWIN_DMA_HDX_T1    0x08
 134 #define TWIN_DMA_HDX_R1    0x0a
 135 #define TWIN_DMA_HDX_T3    0x14
 136 #define TWIN_DMA_HDX_R3    0x16
 137 #define TWIN_DMA_FDX_T3R1  0x1b
 138 #define TWIN_DMA_FDX_T1R3  0x1d
 139
 140
 141 /* Status values */
 142
 143 #define IDLE      0
 144 #define TX_HEAD   1
 145 #define TX_DATA   2
 146 #define TX_PAUSE  3
 147 #define TX_TAIL   4
 148 #define RTS_OFF   5
 149 #define WAIT      6
 150 #define DCD_ON    7
 151 #define RX_ON     8
 152 #define DCD_OFF   9
 153
 154
 155 /* Ioctls */
 156
 157 #define SIOCGSCCPARAM SIOCDEVPRIVATE
 158 #define SIOCSSCCPARAM (SIOCDEVPRIVATE+1)
 159
 160
 161 /* Data types */
 162
 163 struct scc_param {
 164         int pclk_hz;            /* frequency of BRG input (don't change) */
 165         int brg_tc;             /* BRG terminal count; BRG disabled if < 0 */
 166         int nrzi;               /* 0 (nrz), 1 (nrzi) */
 167         int clocks;             /* see dmascc_cfg documentation */
 168         int txdelay;            /* [1/TMR_0_HZ] */
 169         int txtimeout;          /* [1/HZ] */
 170         int txtail;             /* [1/TMR_0_HZ] */
 171         int waittime;           /* [1/TMR_0_HZ] */
 172         int slottime;           /* [1/TMR_0_HZ] */
 173         int persist;            /* 1 ... 256 */
 174         int dma;                /* -1 (disable), 0, 1, 3 */
 175         int txpause;            /* [1/TMR_0_HZ] */
 176         int rtsoff;             /* [1/TMR_0_HZ] */
 177         int dcdon;              /* [1/TMR_0_HZ] */
 178         int dcdoff;             /* [1/TMR_0_HZ] */
 179 };
 180
 181 struct scc_hardware {
 182         char *name;
 183         int io_region;
 184         int io_delta;
 185         int io_size;
 186         int num_devs;
 187         int scc_offset;
 188         int tmr_offset;
 189         int tmr_hz;
 190         int pclk_hz;
 191 };
 192
 193 struct scc_priv {
 194         int type;
 195         int chip;
 196         struct net_device *dev;
 197         struct scc_info *info;
 198
 199         int channel;
 200         int card_base, scc_cmd, scc_data;
 201         int tmr_cnt, tmr_ctrl, tmr_mode;
 202         struct scc_param param;
 203         char rx_buf[NUM_RX_BUF][BUF_SIZE];
 204         int rx_len[NUM_RX_BUF];
 205         int rx_ptr;
 206         struct work_struct rx_work;
 207         int rx_head, rx_tail, rx_count;
 208         int rx_over;
 209         char tx_buf[NUM_TX_BUF][BUF_SIZE];
 210         int tx_len[NUM_TX_BUF];
 211         int tx_ptr;
 212         int tx_head, tx_tail, tx_count;
 213         int state;
 214         unsigned long tx_start;
 215         int rr0;
 216         spinlock_t *register_lock;      /* Per scc_info */
 217         spinlock_t ring_lock;
 218 };
 219
 220 struct scc_info {
 221         int irq_used;
 222         int twin_serial_cfg;
 223         struct net_device *dev[2];
 224         struct scc_priv priv[2];
 225         struct scc_info *next;
 226         spinlock_t register_lock;       /* Per device register lock */
 227 };
 228
 229
 230 /* Function declarations */
 231 static int setup_adapter(int card_base, int type, int n) __init;
 232
 233 static void write_scc(struct scc_priv *priv, int reg, int val);
 234 static void write_scc_data(struct scc_priv *priv, int val, int fast);
 235 static int read_scc(struct scc_priv *priv, int reg);
 236 static int read_scc_data(struct scc_priv *priv);
 237
 238 static int scc_open(struct net_device *dev);
 239 static int scc_close(struct net_device *dev);
 240 static int scc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
 241 static int scc_send_packet(struct sk_buff *skb, struct net_device *dev);
 242 static int scc_set_mac_address(struct net_device *dev, void *sa);
 243
 244 static inline void tx_on(struct scc_priv *priv);
 245 static inline void rx_on(struct scc_priv *priv);
 246 static inline void rx_off(struct scc_priv *priv);
 247 static void start_timer(struct scc_priv *priv, int t, int r15);
 248 static inline unsigned char random(void);
 249
 250 static inline void z8530_isr(struct scc_info *info);
 251 static irqreturn_t scc_isr(int irq, void *dev_id);
 252 static void rx_isr(struct scc_priv *priv);
 253 static void special_condition(struct scc_priv *priv, int rc);
 254 static void rx_bh(struct work_struct *);
 255 static void tx_isr(struct scc_priv *priv);
 256 static void es_isr(struct scc_priv *priv);
 257 static void tm_isr(struct scc_priv *priv);
 258
 259
 260 /* Initialization variables */
 261
 262 static int io[MAX_NUM_DEVS] __initdata = { 0, };
 263
 264 /* Beware! hw[] is also used in dmascc_exit(). */
 265 static struct scc_hardware hw[NUM_TYPES] = HARDWARE;
 266
 267
 268 /* Global variables */
 269
 270 static struct scc_info *first;
 271 static unsigned long rand;
 272
 273
 274 MODULE_AUTHOR("Klaus Kudielka");
 275 MODULE_DESCRIPTION("Driver for high-speed SCC boards");
 276 module_param_array(io, int, NULL, 0);
 277 MODULE_LICENSE("GPL");
 278
 279 static void __exit dmascc_exit(void)
 280 {
 281         int i;
 282         struct scc_info *info;
 283
 284         while (first) {
 285                 info = first;
 286
 287                 /* Unregister devices */
 288                 for (i = 0; i < 2; i++)
 289                         unregister_netdev(info->dev[i]);
 290
 291                 /* Reset board */
 292                 if (info->priv[0].type == TYPE_TWIN)
 293                         outb(0, info->dev[0]->base_addr + TWIN_SERIAL_CFG);
 294                 write_scc(&info->priv[0], R9, FHWRES);
 295                 release_region(info->dev[0]->base_addr,
 296                                hw[info->priv[0].type].io_size);
 297
 298                 for (i = 0; i < 2; i++)
 299                         free_netdev(info->dev[i]);
 300
 301                 /* Free memory */
 302                 first = info->next;
 303                 kfree(info);
 304         }
 305 }
 306
 307 static int __init dmascc_init(void)
 308 {
 309         int h, i, j, n;
 310         int base[MAX_NUM_DEVS], tcmd[MAX_NUM_DEVS], t0[MAX_NUM_DEVS],
 311             t1[MAX_NUM_DEVS];
 312         unsigned t_val;
 313         unsigned long time, start[MAX_NUM_DEVS], delay[MAX_NUM_DEVS],
 314             counting[MAX_NUM_DEVS];
 315
 316         /* Initialize random number generator */
 317         rand = jiffies;
 318         /* Cards found = 0 */
 319         n = 0;
 320         /* Warning message */
 321         if (!io[0])
 322                 printk(KERN_INFO "dmascc: autoprobing (dangerous)\n");
 323
 324         /* Run autodetection for each card type */
 325         for (h = 0; h < NUM_TYPES; h++) {
 326
 327                 if (io[0]) {
 328                         /* User-specified I/O address regions */
 329                         for (i = 0; i < hw[h].num_devs; i++)
 330                                 base[i] = 0;
 331                         for (i = 0; i < MAX_NUM_DEVS && io[i]; i++) {
 332                                 j = (io[i] -
 333                                      hw[h].io_region) / hw[h].io_delta;
 334                                 if (j >= 0 && j < hw[h].num_devs
 335                                     && hw[h].io_region +
 336                                     j * hw[h].io_delta == io[i]) {
 337                                         base[j] = io[i];
 338                                 }
 339                         }
 340                 } else {
 341                         /* Default I/O address regions */
 342                         for (i = 0; i < hw[h].num_devs; i++) {
 343                                 base[i] =
 344                                     hw[h].io_region + i * hw[h].io_delta;
 345                         }
 346                 }
 347
 348                 /* Check valid I/O address regions */
 349                 for (i = 0; i < hw[h].num_devs; i++)
 350                         if (base[i]) {
 351                                 if (!request_region
 352                                     (base[i], hw[h].io_size, "dmascc"))
 353                                         base[i] = 0;
 354                                 else {
 355                                         tcmd[i] =
 356                                             base[i] + hw[h].tmr_offset +
 357                                             TMR_CTRL;
 358                                         t0[i] =
 359                                             base[i] + hw[h].tmr_offset +
 360                                             TMR_CNT0;
 361                                         t1[i] =
 362                                             base[i] + hw[h].tmr_offset +
 363                                             TMR_CNT1;
 364                                 }
 365                         }
 366
 367                 /* Start timers */
 368                 for (i = 0; i < hw[h].num_devs; i++)
 369                         if (base[i]) {
 370                                 /* Timer 0: LSB+MSB, Mode 3, TMR_0_HZ */
 371                                 outb(0x36, tcmd[i]);
 372                                 outb((hw[h].tmr_hz / TMR_0_HZ) & 0xFF,
 373                                      t0[i]);
 374                                 outb((hw[h].tmr_hz / TMR_0_HZ) >> 8,
 375                                      t0[i]);
 376                                 /* Timer 1: LSB+MSB, Mode 0, HZ/10 */
 377                                 outb(0x70, tcmd[i]);
 378                                 outb((TMR_0_HZ / HZ * 10) & 0xFF, t1[i]);
 379                                 outb((TMR_0_HZ / HZ * 10) >> 8, t1[i]);
 380                                 start[i] = jiffies;
 381                                 delay[i] = 0;
 382                                 counting[i] = 1;
 383                                 /* Timer 2: LSB+MSB, Mode 0 */
 384                                 outb(0xb0, tcmd[i]);
 385                         }
 386                 time = jiffies;
 387                 /* Wait until counter registers are loaded */
 388                 udelay(2000000 / TMR_0_HZ);
 389
 390                 /* Timing loop */
 391                 while (jiffies - time < 13) {
 392                         for (i = 0; i < hw[h].num_devs; i++)
 393                                 if (base[i] && counting[i]) {
 394                                         /* Read back Timer 1: latch; read LSB; read MSB */
 395                                         outb(0x40, tcmd[i]);
 396                                         t_val =
 397                                             inb(t1[i]) + (inb(t1[i]) << 8);
 398                                         /* Also check whether counter did wrap */
 399                                         if (t_val == 0
 400                                             || t_val > TMR_0_HZ / HZ * 10)
 401                                                 counting[i] = 0;
 402                                         delay[i] = jiffies - start[i];
 403                                 }
 404                 }
 405
 406                 /* Evaluate measurements */
 407                 for (i = 0; i < hw[h].num_devs; i++)
 408                         if (base[i]) {
 409                                 if ((delay[i] >= 9 && delay[i] <= 11) &&
 410                                     /* Ok, we have found an adapter */
 411                                     (setup_adapter(base[i], h, n) == 0))
 412                                         n++;
 413                                 else
 414                                         release_region(base[i],
 415                                                        hw[h].io_size);
 416                         }
 417
 418         }                       /* NUM_TYPES */
 419
 420         /* If any adapter was successfully initialized, return ok */
 421         if (n)
 422                 return 0;
 423
 424         /* If no adapter found, return error */
 425         printk(KERN_INFO "dmascc: no adapters found\n");
 426         return -EIO;
 427 }
 428
 429 module_init(dmascc_init);
 430 module_exit(dmascc_exit);
 431
 432 static void __init dev_setup(struct net_device *dev)
 433 {
 434         dev->type = ARPHRD_AX25;
 435         dev->hard_header_len = AX25_MAX_HEADER_LEN;
 436         dev->mtu = 1500;
 437         dev->addr_len = AX25_ADDR_LEN;
 438         dev->tx_queue_len = 64;
 439         memcpy(dev->broadcast, &ax25_bcast, AX25_ADDR_LEN);
 440         memcpy(dev->dev_addr, &ax25_defaddr, AX25_ADDR_LEN);
 441 }
 442
 443 static const struct net_device_ops scc_netdev_ops = {
 444         .ndo_open = scc_open,
 445         .ndo_stop = scc_close,
 446         .ndo_start_xmit = scc_send_packet,
 447         .ndo_do_ioctl = scc_ioctl,
 448         .ndo_set_mac_address = scc_set_mac_address,
 449 };
 450
 451 static int __init setup_adapter(int card_base, int type, int n)
 452 {
 453         int i, irq, chip;
 454         struct scc_info *info;
 455         struct net_device *dev;
 456         struct scc_priv *priv;
 457         unsigned long time;
 458         unsigned int irqs;
 459         int tmr_base = card_base + hw[type].tmr_offset;
 460         int scc_base = card_base + hw[type].scc_offset;
 461         char *chipnames[] = CHIPNAMES;
 462
 463         /* Initialize what is necessary for write_scc and write_scc_data */
 464         info = kzalloc(sizeof(struct scc_info), GFP_KERNEL | GFP_DMA);
 465         if (!info) {
 466                 printk(KERN_ERR "dmascc: "
 467                        "could not allocate memory for %s at %#3x\n",
 468                        hw[type].name, card_base);
 469                 goto out;
 470         }
 471
 472
 473         info->dev[0] = alloc_netdev(0, "", dev_setup);
 474         if (!info->dev[0]) {
 475                 printk(KERN_ERR "dmascc: "
 476                        "could not allocate memory for %s at %#3x\n",
 477                        hw[type].name, card_base);
 478                 goto out1;
 479         }
 480
 481         info->dev[1] = alloc_netdev(0, "", dev_setup);
 482         if (!info->dev[1]) {
 483                 printk(KERN_ERR "dmascc: "
 484                        "could not allocate memory for %s at %#3x\n",
 485                        hw[type].name, card_base);
 486                 goto out2;
 487         }
 488         spin_lock_init(&info->register_lock);
 489
 490         priv = &info->priv[0];
 491         priv->type = type;
 492         priv->card_base = card_base;
 493         priv->scc_cmd = scc_base + SCCA_CMD;
 494         priv->scc_data = scc_base + SCCA_DATA;
 495         priv->register_lock = &info->register_lock;
 496
 497         /* Reset SCC */
 498         write_scc(priv, R9, FHWRES | MIE | NV);
 499
 500         /* Determine type of chip by enabling SDLC/HDLC enhancements */
 501         write_scc(priv, R15, SHDLCE);
 502         if (!read_scc(priv, R15)) {
 503                 /* WR7' not present. This is an ordinary Z8530 SCC. */
 504                 chip = Z8530;
 505         } else {
 506                 /* Put one character in TX FIFO */
 507                 write_scc_data(priv, 0, 0);
 508                 if (read_scc(priv, R0) & Tx_BUF_EMP) {
 509                         /* TX FIFO not full. This is a Z85230 ESCC with a 4-byte FIFO. */
 510                         chip = Z85230;
 511                 } else {
 512                         /* TX FIFO full. This is a Z85C30 SCC with a 1-byte FIFO. */
 513                         chip = Z85C30;
 514                 }
 515         }
 516         write_scc(priv, R15, 0);
 517
 518         /* Start IRQ auto-detection */
 519         irqs = probe_irq_on();
 520
 521         /* Enable interrupts */
 522         if (type == TYPE_TWIN) {
 523                 outb(0, card_base + TWIN_DMA_CFG);
 524                 inb(card_base + TWIN_CLR_TMR1);
 525                 inb(card_base + TWIN_CLR_TMR2);
 526                 info->twin_serial_cfg = TWIN_EI;
 527                 outb(info->twin_serial_cfg, card_base + TWIN_SERIAL_CFG);
 528         } else {
 529                 write_scc(priv, R15, CTSIE);
 530                 write_scc(priv, R0, RES_EXT_INT);
 531                 write_scc(priv, R1, EXT_INT_ENAB);
 532         }
 533
 534         /* Start timer */
 535         outb(1, tmr_base + TMR_CNT1);
 536         outb(0, tmr_base + TMR_CNT1);
 537
 538         /* Wait and detect IRQ */
 539         time = jiffies;
 540         while (jiffies - time < 2 + HZ / TMR_0_HZ);
 541         irq = probe_irq_off(irqs);
 542
 543         /* Clear pending interrupt, disable interrupts */
 544         if (type == TYPE_TWIN) {
 545                 inb(card_base + TWIN_CLR_TMR1);
 546         } else {
 547                 write_scc(priv, R1, 0);
 548                 write_scc(priv, R15, 0);
 549                 write_scc(priv, R0, RES_EXT_INT);
 550         }
 551
 552         if (irq <= 0) {
 553                 printk(KERN_ERR
 554                        "dmascc: could not find irq of %s at %#3x (irq=%d)\n",
 555                        hw[type].name, card_base, irq);
 556                 goto out3;
 557         }
 558
 559         /* Set up data structures */
 560         for (i = 0; i < 2; i++) {
 561                 dev = info->dev[i];
 562                 priv = &info->priv[i];
 563                 priv->type = type;
 564                 priv->chip = chip;
 565                 priv->dev = dev;
 566                 priv->info = info;
 567                 priv->channel = i;
 568                 spin_lock_init(&priv->ring_lock);
 569                 priv->register_lock = &info->register_lock;
 570                 priv->card_base = card_base;
 571                 priv->scc_cmd = scc_base + (i ? SCCB_CMD : SCCA_CMD);
 572                 priv->scc_data = scc_base + (i ? SCCB_DATA : SCCA_DATA);
 573                 priv->tmr_cnt = tmr_base + (i ? TMR_CNT2 : TMR_CNT1);
 574                 priv->tmr_ctrl = tmr_base + TMR_CTRL;
 575                 priv->tmr_mode = i ? 0xb0 : 0x70;
 576                 priv->param.pclk_hz = hw[type].pclk_hz;
 577                 priv->param.brg_tc = -1;
 578                 priv->param.clocks = TCTRxCP | RCRTxCP;
 579                 priv->param.persist = 256;
 580                 priv->param.dma = -1;
 581                 INIT_WORK(&priv->rx_work, rx_bh);
 582                 dev->ml_priv = priv;
 583                 sprintf(dev->name, "dmascc%i", 2 * n + i);
 584                 dev->base_addr = card_base;
 585                 dev->irq = irq;
 586                 dev->netdev_ops = &scc_netdev_ops;
 587                 dev->header_ops = &ax25_header_ops;
 588         }
 589         if (register_netdev(info->dev[0])) {
 590                 printk(KERN_ERR "dmascc: could not register %s\n",
 591                        info->dev[0]->name);
 592                 goto out3;
 593         }
 594         if (register_netdev(info->dev[1])) {
 595                 printk(KERN_ERR "dmascc: could not register %s\n",
 596                        info->dev[1]->name);
 597                 goto out4;
 598         }
 599
 600
 601         info->next = first;
 602         first = info;
 603         printk(KERN_INFO "dmascc: found %s (%s) at %#3x, irq %d\n",
 604                hw[type].name, chipnames[chip], card_base, irq);
 605         return 0;
 606
 607       out4:
 608         unregister_netdev(info->dev[0]);
 609       out3:
 610         if (info->priv[0].type == TYPE_TWIN)
 611                 outb(0, info->dev[0]->base_addr + TWIN_SERIAL_CFG);
 612         write_scc(&info->priv[0], R9, FHWRES);
 613         free_netdev(info->dev[1]);
 614       out2:
 615         free_netdev(info->dev[0]);
 616       out1:
 617         kfree(info);
 618       out:
 619         return -1;
 620 }
 621
 622
 623 /* Driver functions */
 624
 625 static void write_scc(struct scc_priv *priv, int reg, int val)
 626 {
 627         unsigned long flags;
 628         switch (priv->type) {
 629         case TYPE_S5:
 630                 if (reg)
 631                         outb(reg, priv->scc_cmd);
 632                 outb(val, priv->scc_cmd);
 633                 return;
 634         case TYPE_TWIN:
 635                 if (reg)
 636                         outb_p(reg, priv->scc_cmd);
 637                 outb_p(val, priv->scc_cmd);
 638                 return;
 639         default:
 640                 spin_lock_irqsave(priv->register_lock, flags);
 641                 outb_p(0, priv->card_base + PI_DREQ_MASK);
 642                 if (reg)
 643                         outb_p(reg, priv->scc_cmd);
 644                 outb_p(val, priv->scc_cmd);
 645                 outb(1, priv->card_base + PI_DREQ_MASK);
 646                 spin_unlock_irqrestore(priv->register_lock, flags);
 647                 return;
 648         }
 649 }
 650
 651
 652 static void write_scc_data(struct scc_priv *priv, int val, int fast)
 653 {
 654         unsigned long flags;
 655         switch (priv->type) {
 656         case TYPE_S5:
 657                 outb(val, priv->scc_data);
 658                 return;
 659         case TYPE_TWIN:
 660                 outb_p(val, priv->scc_data);
 661                 return;
 662         default:
 663                 if (fast)
 664                         outb_p(val, priv->scc_data);
 665                 else {
 666                         spin_lock_irqsave(priv->register_lock, flags);
 667                         outb_p(0, priv->card_base + PI_DREQ_MASK);
 668                         outb_p(val, priv->scc_data);
 669                         outb(1, priv->card_base + PI_DREQ_MASK);
 670                         spin_unlock_irqrestore(priv->register_lock, flags);
 671                 }
 672                 return;
 673         }
 674 }
 675
 676
 677 static int read_scc(struct scc_priv *priv, int reg)
 678 {
 679         int rc;
 680         unsigned long flags;
 681         switch (priv->type) {
 682         case TYPE_S5:
 683                 if (reg)
 684                         outb(reg, priv->scc_cmd);
 685                 return inb(priv->scc_cmd);
 686         case TYPE_TWIN:
 687                 if (reg)
 688                         outb_p(reg, priv->scc_cmd);
 689                 return inb_p(priv->scc_cmd);
 690         default:
 691                 spin_lock_irqsave(priv->register_lock, flags);
 692                 outb_p(0, priv->card_base + PI_DREQ_MASK);
 693                 if (reg)
 694                         outb_p(reg, priv->scc_cmd);
 695                 rc = inb_p(priv->scc_cmd);
 696                 outb(1, priv->card_base + PI_DREQ_MASK);
 697                 spin_unlock_irqrestore(priv->register_lock, flags);
 698                 return rc;
 699         }
 700 }
 701
 702
 703 static int read_scc_data(struct scc_priv *priv)
 704 {
 705         int rc;
 706         unsigned long flags;
 707         switch (priv->type) {
 708         case TYPE_S5:
 709                 return inb(priv->scc_data);
 710         case TYPE_TWIN:
 711                 return inb_p(priv->scc_data);
 712         default:
 713                 spin_lock_irqsave(priv->register_lock, flags);
 714                 outb_p(0, priv->card_base + PI_DREQ_MASK);
 715                 rc = inb_p(priv->scc_data);
 716                 outb(1, priv->card_base + PI_DREQ_MASK);
 717                 spin_unlock_irqrestore(priv->register_lock, flags);
 718                 return rc;
 719         }
 720 }
 721
 722
 723 static int scc_open(struct net_device *dev)
 724 {
 725         struct scc_priv *priv = dev->ml_priv;
 726         struct scc_info *info = priv->info;
 727         int card_base = priv->card_base;
 728
 729         /* Request IRQ if not already used by other channel */
 730         if (!info->irq_used) {
 731                 if (request_irq(dev->irq, scc_isr, 0, "dmascc", info)) {
 732                         return -EAGAIN;
 733                 }
 734         }
 735         info->irq_used++;
 736
 737         /* Request DMA if required */
 738         if (priv->param.dma >= 0) {
 739                 if (request_dma(priv->param.dma, "dmascc")) {
 740                         if (--info->irq_used == 0)
 741                                 free_irq(dev->irq, info);
 742                         return -EAGAIN;
 743                 } else {
 744                         unsigned long flags = claim_dma_lock();
 745                         clear_dma_ff(priv->param.dma);
 746                         release_dma_lock(flags);
 747                 }
 748         }
 749
 750         /* Initialize local variables */
 751         priv->rx_ptr = 0;
 752         priv->rx_over = 0;
 753         priv->rx_head = priv->rx_tail = priv->rx_count = 0;
 754         priv->state = IDLE;
 755         priv->tx_head = priv->tx_tail = priv->tx_count = 0;
 756         priv->tx_ptr = 0;
 757
 758         /* Reset channel */
 759         write_scc(priv, R9, (priv->channel ? CHRB : CHRA) | MIE | NV);
 760         /* X1 clock, SDLC mode */
 761         write_scc(priv, R4, SDLC | X1CLK);
 762         /* DMA */
 763         write_scc(priv, R1, EXT_INT_ENAB | WT_FN_RDYFN);
 764         /* 8 bit RX char, RX disable */
 765         write_scc(priv, R3, Rx8);
 766         /* 8 bit TX char, TX disable */
 767         write_scc(priv, R5, Tx8);
 768         /* SDLC address field */
 769         write_scc(priv, R6, 0);
 770         /* SDLC flag */
 771         write_scc(priv, R7, FLAG);
 772         switch (priv->chip) {
 773         case Z85C30:
 774                 /* Select WR7' */
 775                 write_scc(priv, R15, SHDLCE);
 776                 /* Auto EOM reset */
 777                 write_scc(priv, R7, AUTOEOM);
 778                 write_scc(priv, R15, 0);
 779                 break;
 780         case Z85230:
 781                 /* Select WR7' */
 782                 write_scc(priv, R15, SHDLCE);
 783                 /* The following bits are set (see 2.5.2.1):
 784                    - Automatic EOM reset
 785                    - Interrupt request if RX FIFO is half full
 786                    This bit should be ignored in DMA mode (according to the
 787                    documentation), but actually isn't. The receiver doesn't work if
 788                    it is set. Thus, we have to clear it in DMA mode.
 789                    - Interrupt/DMA request if TX FIFO is completely empty
 790                    a) If set, the ESCC behaves as if it had no TX FIFO (Z85C30
 791                    compatibility).
 792                    b) If cleared, DMA requests may follow each other very quickly,
 793                    filling up the TX FIFO.
 794                    Advantage: TX works even in case of high bus latency.
 795                    Disadvantage: Edge-triggered DMA request circuitry may miss
 796                    a request. No more data is delivered, resulting
 797                    in a TX FIFO underrun.
 798                    Both PI2 and S5SCC/DMA seem to work fine with TXFIFOE cleared.
 799                    The PackeTwin doesn't. I don't know about the PI, but let's
 800                    assume it behaves like the PI2.
 801                  */
 802                 if (priv->param.dma >= 0) {
 803                         if (priv->type == TYPE_TWIN)
 804                                 write_scc(priv, R7, AUTOEOM | TXFIFOE);
 805                         else
 806                                 write_scc(priv, R7, AUTOEOM);
 807                 } else {
 808                         write_scc(priv, R7, AUTOEOM | RXFIFOH);
 809                 }
 810                 write_scc(priv, R15, 0);
 811                 break;
 812         }
 813         /* Preset CRC, NRZ(I) encoding */
 814         write_scc(priv, R10, CRCPS | (priv->param.nrzi ? NRZI : NRZ));
 815
 816         /* Configure baud rate generator */
 817         if (priv->param.brg_tc >= 0) {
 818                 /* Program BR generator */
 819                 write_scc(priv, R12, priv->param.brg_tc & 0xFF);
 820                 write_scc(priv, R13, (priv->param.brg_tc >> 8) & 0xFF);
 821                 /* BRG source = SYS CLK; enable BRG; DTR REQ function (required by
 822                    PackeTwin, not connected on the PI2); set DPLL source to BRG */
 823                 write_scc(priv, R14, SSBR | DTRREQ | BRSRC | BRENABL);
 824                 /* Enable DPLL */
 825                 write_scc(priv, R14, SEARCH | DTRREQ | BRSRC | BRENABL);
 826         } else {
 827                 /* Disable BR generator */
 828                 write_scc(priv, R14, DTRREQ | BRSRC);
 829         }
 830
 831         /* Configure clocks */
 832         if (priv->type == TYPE_TWIN) {
 833                 /* Disable external TX clock receiver */
 834                 outb((info->twin_serial_cfg &=
 835                       ~(priv->channel ? TWIN_EXTCLKB : TWIN_EXTCLKA)),
 836                      card_base + TWIN_SERIAL_CFG);
 837         }
 838         write_scc(priv, R11, priv->param.clocks);
 839         if ((priv->type == TYPE_TWIN) && !(priv->param.clocks & TRxCOI)) {
 840                 /* Enable external TX clock receiver */
 841                 outb((info->twin_serial_cfg |=
 842                       (priv->channel ? TWIN_EXTCLKB : TWIN_EXTCLKA)),
 843                      card_base + TWIN_SERIAL_CFG);
 844         }
 845
 846         /* Configure PackeTwin */
 847         if (priv->type == TYPE_TWIN) {
 848                 /* Assert DTR, enable interrupts */
 849                 outb((info->twin_serial_cfg |= TWIN_EI |
 850                       (priv->channel ? TWIN_DTRB_ON : TWIN_DTRA_ON)),
 851                      card_base + TWIN_SERIAL_CFG);
 852         }
 853
 854         /* Read current status */
 855         priv->rr0 = read_scc(priv, R0);
 856         /* Enable DCD interrupt */
 857         write_scc(priv, R15, DCDIE);
 858
 859         netif_start_queue(dev);
 860
 861         return 0;
 862 }
 863
 864
 865 static int scc_close(struct net_device *dev)
 866 {
 867         struct scc_priv *priv = dev->ml_priv;
 868         struct scc_info *info = priv->info;
 869         int card_base = priv->card_base;
 870
 871         netif_stop_queue(dev);
 872
 873         if (priv->type == TYPE_TWIN) {
 874                 /* Drop DTR */
 875                 outb((info->twin_serial_cfg &=
 876                       (priv->channel ? ~TWIN_DTRB_ON : ~TWIN_DTRA_ON)),
 877                      card_base + TWIN_SERIAL_CFG);
 878         }
 879
 880         /* Reset channel, free DMA and IRQ */
 881         write_scc(priv, R9, (priv->channel ? CHRB : CHRA) | MIE | NV);
 882         if (priv->param.dma >= 0) {
 883                 if (priv->type == TYPE_TWIN)
 884                         outb(0, card_base + TWIN_DMA_CFG);
 885                 free_dma(priv->param.dma);
 886         }
 887         if (--info->irq_used == 0)
 888                 free_irq(dev->irq, info);
 889
 890         return 0;
 891 }
 892
 893
 894 static int scc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 895 {
 896         struct scc_priv *priv = dev->ml_priv;
 897
 898         switch (cmd) {
 899         case SIOCGSCCPARAM:
 900                 if (copy_to_user
 901                     (ifr->ifr_data, &priv->param,
 902                      sizeof(struct scc_param)))
 903                         return -EFAULT;
 904                 return 0;
 905         case SIOCSSCCPARAM:
 906                 if (!capable(CAP_NET_ADMIN))
 907                         return -EPERM;
 908                 if (netif_running(dev))
 909                         return -EAGAIN;
 910                 if (copy_from_user
 911                     (&priv->param, ifr->ifr_data,
 912                      sizeof(struct scc_param)))
 913                         return -EFAULT;
 914                 return 0;
 915         default:
 916                 return -EINVAL;
 917         }
 918 }
 919
 920
 921 static int scc_send_packet(struct sk_buff *skb, struct net_device *dev)
 922 {
 923         struct scc_priv *priv = dev->ml_priv;
 924         unsigned long flags;
 925         int i;
 926
 927         /* Temporarily stop the scheduler feeding us packets */
 928         netif_stop_queue(dev);
 929
 930         /* Transfer data to DMA buffer */
 931         i = priv->tx_head;
 932         skb_copy_from_linear_data_offset(skb, 1, priv->tx_buf[i], skb->len - 1);
 933         priv->tx_len[i] = skb->len - 1;
 934
 935         /* Clear interrupts while we touch our circular buffers */
 936
 937         spin_lock_irqsave(&priv->ring_lock, flags);
 938         /* Move the ring buffer's head */
 939         priv->tx_head = (i + 1) % NUM_TX_BUF;
 940         priv->tx_count++;
 941
 942         /* If we just filled up the last buffer, leave queue stopped.
 943            The higher layers must wait until we have a DMA buffer
 944            to accept the data. */
 945         if (priv->tx_count < NUM_TX_BUF)
 946                 netif_wake_queue(dev);
 947
 948         /* Set new TX state */
 949         if (priv->state == IDLE) {
 950                 /* Assert RTS, start timer */
 951                 priv->state = TX_HEAD;
 952                 priv->tx_start = jiffies;
 953                 write_scc(priv, R5, TxCRC_ENAB | RTS | TxENAB | Tx8);
 954                 write_scc(priv, R15, 0);
 955                 start_timer(priv, priv->param.txdelay, 0);
 956         }
 957
 958         /* Turn interrupts back on and free buffer */
 959         spin_unlock_irqrestore(&priv->ring_lock, flags);
 960         dev_kfree_skb(skb);
 961
 962         return 0;
 963 }
 964
 965
 966 static int scc_set_mac_address(struct net_device *dev, void *sa)
 967 {
 968         memcpy(dev->dev_addr, ((struct sockaddr *) sa)->sa_data,
 969                dev->addr_len);
 970         return 0;
 971 }
 972
 973
 974 static inline void tx_on(struct scc_priv *priv)
 975 {
 976         int i, n;
 977         unsigned long flags;
 978
 979         if (priv->param.dma >= 0) {
 980                 n = (priv->chip == Z85230) ? 3 : 1;
 981                 /* Program DMA controller */
 982                 flags = claim_dma_lock();
 983                 set_dma_mode(priv->param.dma, DMA_MODE_WRITE);
 984                 set_dma_addr(priv->param.dma,
 985                              (int) priv->tx_buf[priv->tx_tail] + n);
 986                 set_dma_count(priv->param.dma,
 987                               priv->tx_len[priv->tx_tail] - n);
 988                 release_dma_lock(flags);
 989                 /* Enable TX underrun interrupt */
 990                 write_scc(priv, R15, TxUIE);
 991                 /* Configure DREQ */
 992                 if (priv->type == TYPE_TWIN)
 993                         outb((priv->param.dma ==
 994                               1) ? TWIN_DMA_HDX_T1 : TWIN_DMA_HDX_T3,
 995                              priv->card_base + TWIN_DMA_CFG);
 996                 else
 997                         write_scc(priv, R1,
 998                                   EXT_INT_ENAB | WT_FN_RDYFN |
 999                                   WT_RDY_ENAB);
1000                 /* Write first byte(s) */
1001                 spin_lock_irqsave(priv->register_lock, flags);
1002                 for (i = 0; i < n; i++)
1003                         write_scc_data(priv,
1004                                        priv->tx_buf[priv->tx_tail][i], 1);
1005                 enable_dma(priv->param.dma);
1006                 spin_unlock_irqrestore(priv->register_lock, flags);
1007         } else {
1008                 write_scc(priv, R15, TxUIE);
1009                 write_scc(priv, R1,
1010                           EXT_INT_ENAB | WT_FN_RDYFN | TxINT_ENAB);
1011                 tx_isr(priv);
1012         }
1013         /* Reset EOM latch if we do not have the AUTOEOM feature */
1014         if (priv->chip == Z8530)
1015                 write_scc(priv, R0, RES_EOM_L);
1016 }
1017
1018
1019 static inline void rx_on(struct scc_priv *priv)
1020 {
1021         unsigned long flags;
1022
1023         /* Clear RX FIFO */
1024         while (read_scc(priv, R0) & Rx_CH_AV)
1025                 read_scc_data(priv);
1026         priv->rx_over = 0;
1027         if (priv->param.dma >= 0) {
1028                 /* Program DMA controller */
1029                 flags = claim_dma_lock();
1030                 set_dma_mode(priv->param.dma, DMA_MODE_READ);
1031                 set_dma_addr(priv->param.dma,
1032                              (int) priv->rx_buf[priv->rx_head]);
1033                 set_dma_count(priv->param.dma, BUF_SIZE);
1034                 release_dma_lock(flags);
1035                 enable_dma(priv->param.dma);
1036                 /* Configure PackeTwin DMA */
1037                 if (priv->type == TYPE_TWIN) {
1038                         outb((priv->param.dma ==
1039                               1) ? TWIN_DMA_HDX_R1 : TWIN_DMA_HDX_R3,
1040                              priv->card_base + TWIN_DMA_CFG);
1041                 }
1042                 /* Sp. cond. intr. only, ext int enable, RX DMA enable */
1043                 write_scc(priv, R1, EXT_INT_ENAB | INT_ERR_Rx |
1044                           WT_RDY_RT | WT_FN_RDYFN | WT_RDY_ENAB);
1045         } else {
1046                 /* Reset current frame */
1047                 priv->rx_ptr = 0;
1048                 /* Intr. on all Rx characters and Sp. cond., ext int enable */
1049                 write_scc(priv, R1, EXT_INT_ENAB | INT_ALL_Rx | WT_RDY_RT |
1050                           WT_FN_RDYFN);
1051         }
1052         write_scc(priv, R0, ERR_RES);
1053         write_scc(priv, R3, RxENABLE | Rx8 | RxCRC_ENAB);
1054 }
1055
1056
1057 static inline void rx_off(struct scc_priv *priv)
1058 {
1059         /* Disable receiver */
1060         write_scc(priv, R3, Rx8);
1061         /* Disable DREQ / RX interrupt */
1062         if (priv->param.dma >= 0 && priv->type == TYPE_TWIN)
1063                 outb(0, priv->card_base + TWIN_DMA_CFG);
1064         else
1065                 write_scc(priv, R1, EXT_INT_ENAB | WT_FN_RDYFN);
1066         /* Disable DMA */
1067         if (priv->param.dma >= 0)
1068                 disable_dma(priv->param.dma);
1069 }
1070
1071
1072 static void start_timer(struct scc_priv *priv, int t, int r15)
1073 {
1074         outb(priv->tmr_mode, priv->tmr_ctrl);
1075         if (t == 0) {
1076                 tm_isr(priv);
1077         } else if (t > 0) {
1078                 outb(t & 0xFF, priv->tmr_cnt);
1079                 outb((t >> 8) & 0xFF, priv->tmr_cnt);
1080                 if (priv->type != TYPE_TWIN) {
1081                         write_scc(priv, R15, r15 | CTSIE);
1082                         priv->rr0 |= CTS;
1083                 }
1084         }
1085 }
1086
1087
1088 static inline unsigned char random(void)
1089 {
1090         /* See "Numerical Recipes in C", second edition, p. 284 */
1091         rand = rand * 1664525L + 1013904223L;
1092         return (unsigned char) (rand >> 24);
1093 }
1094
1095 static inline void z8530_isr(struct scc_info *info)
1096 {
1097         int is, i = 100;
1098
1099         while ((is = read_scc(&info->priv[0], R3)) && i--) {
1100                 if (is & CHARxIP) {
1101                         rx_isr(&info->priv[0]);
1102                 } else if (is & CHATxIP) {
1103                         tx_isr(&info->priv[0]);
1104                 } else if (is & CHAEXT) {
1105                         es_isr(&info->priv[0]);
1106                 } else if (is & CHBRxIP) {
1107                         rx_isr(&info->priv[1]);
1108                 } else if (is & CHBTxIP) {
1109                         tx_isr(&info->priv[1]);
1110                 } else {
1111                         es_isr(&info->priv[1]);
1112                 }
1113                 write_scc(&info->priv[0], R0, RES_H_IUS);
1114                 i++;
1115         }
1116         if (i < 0) {
1117                 printk(KERN_ERR "dmascc: stuck in ISR with RR3=0x%02x.\n",
1118                        is);
1119         }
1120         /* Ok, no interrupts pending from this 8530. The INT line should
1121            be inactive now. */
1122 }
1123
1124
1125 static irqreturn_t scc_isr(int irq, void *dev_id)
1126 {
1127         struct scc_info *info = dev_id;
1128
1129         spin_lock(info->priv[0].register_lock);
1130         /* At this point interrupts are enabled, and the interrupt under service
1131            is already acknowledged, but masked off.
1132
1133            Interrupt processing: We loop until we know that the IRQ line is
1134            low. If another positive edge occurs afterwards during the ISR,
1135            another interrupt will be triggered by the interrupt controller
1136            as soon as the IRQ level is enabled again (see asm/irq.h).
1137
1138            Bottom-half handlers will be processed after scc_isr(). This is
1139            important, since we only have small ringbuffers and want new data
1140            to be fetched/delivered immediately. */
1141
1142         if (info->priv[0].type == TYPE_TWIN) {
1143                 int is, card_base = info->priv[0].card_base;
1144                 while ((is = ~inb(card_base + TWIN_INT_REG)) &
1145                        TWIN_INT_MSK) {
1146                         if (is & TWIN_SCC_MSK) {
1147                                 z8530_isr(info);
1148                         } else if (is & TWIN_TMR1_MSK) {
1149                                 inb(card_base + TWIN_CLR_TMR1);
1150                                 tm_isr(&info->priv[0]);
1151                         } else {
1152                                 inb(card_base + TWIN_CLR_TMR2);
1153                                 tm_isr(&info->priv[1]);
1154                         }
1155                 }
1156         } else
1157                 z8530_isr(info);
1158         spin_unlock(info->priv[0].register_lock);
1159         return IRQ_HANDLED;
1160 }
1161
1162
1163 static void rx_isr(struct scc_priv *priv)
1164 {
1165         if (priv->param.dma >= 0) {
1166                 /* Check special condition and perform error reset. See 2.4.7.5. */
1167                 special_condition(priv, read_scc(priv, R1));
1168                 write_scc(priv, R0, ERR_RES);
1169         } else {
1170                 /* Check special condition for each character. Error reset not necessary.
1171                    Same algorithm for SCC and ESCC. See 2.4.7.1 and 2.4.7.4. */
1172                 int rc;
1173                 while (read_scc(priv, R0) & Rx_CH_AV) {
1174                         rc = read_scc(priv, R1);
1175                         if (priv->rx_ptr < BUF_SIZE)
1176                                 priv->rx_buf[priv->rx_head][priv->
1177                                                             rx_ptr++] =
1178                                     read_scc_data(priv);
1179                         else {
1180                                 priv->rx_over = 2;
1181                                 read_scc_data(priv);
1182                         }
1183                         special_condition(priv, rc);
1184                 }
1185         }
1186 }
1187
1188
1189 static void special_condition(struct scc_priv *priv, int rc)
1190 {
1191         int cb;
1192         unsigned long flags;
1193
1194         /* See Figure 2-15. Only overrun and EOF need to be checked. */
1195
1196         if (rc & Rx_OVR) {
1197                 /* Receiver overrun */
1198                 priv->rx_over = 1;
1199                 if (priv->param.dma < 0)
1200                         write_scc(priv, R0, ERR_RES);
1201         } else if (rc & END_FR) {
1202                 /* End of frame. Get byte count */
1203                 if (priv->param.dma >= 0) {
1204                         flags = claim_dma_lock();
1205                         cb = BUF_SIZE - get_dma_residue(priv->param.dma) -
1206                             2;
1207                         release_dma_lock(flags);
1208                 } else {
1209                         cb = priv->rx_ptr - 2;
1210                 }
1211                 if (priv->rx_over) {
1212                         /* We had an overrun */
1213                         priv->dev->stats.rx_errors++;
1214                         if (priv->rx_over == 2)
1215                                 priv->dev->stats.rx_length_errors++;
1216                         else
1217                                 priv->dev->stats.rx_fifo_errors++;
1218                         priv->rx_over = 0;
1219                 } else if (rc & CRC_ERR) {
1220                         /* Count invalid CRC only if packet length >= minimum */
1221                         if (cb >= 15) {
1222                                 priv->dev->stats.rx_errors++;
1223                                 priv->dev->stats.rx_crc_errors++;
1224                         }
1225                 } else {
1226                         if (cb >= 15) {
1227                                 if (priv->rx_count < NUM_RX_BUF - 1) {
1228                                         /* Put good frame in FIFO */
1229                                         priv->rx_len[priv->rx_head] = cb;
1230                                         priv->rx_head =
1231                                             (priv->rx_head +
1232                                              1) % NUM_RX_BUF;
1233                                         priv->rx_count++;
1234                                         schedule_work(&priv->rx_work);
1235                                 } else {
1236                                         priv->dev->stats.rx_errors++;
1237                                         priv->dev->stats.rx_over_errors++;
1238                                 }
1239                         }
1240                 }
1241                 /* Get ready for new frame */
1242                 if (priv->param.dma >= 0) {
1243                         flags = claim_dma_lock();
1244                         set_dma_addr(priv->param.dma,
1245                                      (int) priv->rx_buf[priv->rx_head]);
1246                         set_dma_count(priv->param.dma, BUF_SIZE);
1247                         release_dma_lock(flags);
1248                 } else {
1249                         priv->rx_ptr = 0;
1250                 }
1251         }
1252 }
1253
1254
1255 static void rx_bh(struct work_struct *ugli_api)
1256 {
1257         struct scc_priv *priv = container_of(ugli_api, struct scc_priv, rx_work);
1258         int i = priv->rx_tail;
1259         int cb;
1260         unsigned long flags;
1261         struct sk_buff *skb;
1262         unsigned char *data;
1263
1264         spin_lock_irqsave(&priv->ring_lock, flags);
1265         while (priv->rx_count) {
1266                 spin_unlock_irqrestore(&priv->ring_lock, flags);
1267                 cb = priv->rx_len[i];
1268                 /* Allocate buffer */
1269                 skb = dev_alloc_skb(cb + 1);
1270                 if (skb == NULL) {
1271                         /* Drop packet */
1272                         priv->dev->stats.rx_dropped++;
1273                 } else {
1274                         /* Fill buffer */
1275                         data = skb_put(skb, cb + 1);
1276                         data[0] = 0;
1277                         memcpy(&data[1], priv->rx_buf[i], cb);
1278                         skb->protocol = ax25_type_trans(skb, priv->dev);
1279                         netif_rx(skb);
1280                         priv->dev->stats.rx_packets++;
1281                         priv->dev->stats.rx_bytes += cb;
1282                 }
1283                 spin_lock_irqsave(&priv->ring_lock, flags);
1284                 /* Move tail */
1285                 priv->rx_tail = i = (i + 1) % NUM_RX_BUF;
1286                 priv->rx_count--;
1287         }
1288         spin_unlock_irqrestore(&priv->ring_lock, flags);
1289 }
1290
1291
1292 static void tx_isr(struct scc_priv *priv)
1293 {
1294         int i = priv->tx_tail, p = priv->tx_ptr;
1295
1296         /* Suspend TX interrupts if we don't want to send anything.
1297            See Figure 2-22. */
1298         if (p == priv->tx_len[i]) {
1299                 write_scc(priv, R0, RES_Tx_P);
1300                 return;
1301         }
1302
1303         /* Write characters */
1304         while ((read_scc(priv, R0) & Tx_BUF_EMP) && p < priv->tx_len[i]) {
1305                 write_scc_data(priv, priv->tx_buf[i][p++], 0);
1306         }
1307
1308         /* Reset EOM latch of Z8530 */
1309         if (!priv->tx_ptr && p && priv->chip == Z8530)
1310                 write_scc(priv, R0, RES_EOM_L);
1311
1312         priv->tx_ptr = p;
1313 }
1314
1315
1316 static void es_isr(struct scc_priv *priv)
1317 {
1318         int i, rr0, drr0, res;
1319         unsigned long flags;
1320
1321         /* Read status, reset interrupt bit (open latches) */
1322         rr0 = read_scc(priv, R0);
1323         write_scc(priv, R0, RES_EXT_INT);
1324         drr0 = priv->rr0 ^ rr0;
1325         priv->rr0 = rr0;
1326
1327         /* Transmit underrun (2.4.9.6). We can't check the TxEOM flag, since
1328            it might have already been cleared again by AUTOEOM. */
1329         if (priv->state == TX_DATA) {
1330                 /* Get remaining bytes */
1331                 i = priv->tx_tail;
1332                 if (priv->param.dma >= 0) {
1333                         disable_dma(priv->param.dma);
1334                         flags = claim_dma_lock();
1335                         res = get_dma_residue(priv->param.dma);
1336                         release_dma_lock(flags);
1337                 } else {
1338                         res = priv->tx_len[i] - priv->tx_ptr;
1339                         priv->tx_ptr = 0;
1340                 }
1341                 /* Disable DREQ / TX interrupt */
1342                 if (priv->param.dma >= 0 && priv->type == TYPE_TWIN)
1343                         outb(0, priv->card_base + TWIN_DMA_CFG);
1344                 else
1345                         write_scc(priv, R1, EXT_INT_ENAB | WT_FN_RDYFN);
1346                 if (res) {
1347                         /* Update packet statistics */
1348                         priv->dev->stats.tx_errors++;
1349                         priv->dev->stats.tx_fifo_errors++;
1350                         /* Other underrun interrupts may already be waiting */
1351                         write_scc(priv, R0, RES_EXT_INT);
1352                         write_scc(priv, R0, RES_EXT_INT);
1353                 } else {
1354                         /* Update packet statistics */
1355                         priv->dev->stats.tx_packets++;
1356                         priv->dev->stats.tx_bytes += priv->tx_len[i];
1357                         /* Remove frame from FIFO */
1358                         priv->tx_tail = (i + 1) % NUM_TX_BUF;
1359                         priv->tx_count--;
1360                         /* Inform upper layers */
1361                         netif_wake_queue(priv->dev);
1362                 }
1363                 /* Switch state */
1364                 write_scc(priv, R15, 0);
1365                 if (priv->tx_count &&
1366                     (jiffies - priv->tx_start) < priv->param.txtimeout) {
1367                         priv->state = TX_PAUSE;
1368                         start_timer(priv, priv->param.txpause, 0);
1369                 } else {
1370                         priv->state = TX_TAIL;
1371                         start_timer(priv, priv->param.txtail, 0);
1372                 }
1373         }
1374
1375         /* DCD transition */
1376         if (drr0 & DCD) {
1377                 if (rr0 & DCD) {
1378                         switch (priv->state) {
1379                         case IDLE:
1380                         case WAIT:
1381                                 priv->state = DCD_ON;
1382                                 write_scc(priv, R15, 0);
1383                                 start_timer(priv, priv->param.dcdon, 0);
1384                         }
1385                 } else {
1386                         switch (priv->state) {
1387                         case RX_ON:
1388                                 rx_off(priv);
1389                                 priv->state = DCD_OFF;
1390                                 write_scc(priv, R15, 0);
1391                                 start_timer(priv, priv->param.dcdoff, 0);
1392                         }
1393                 }
1394         }
1395
1396         /* CTS transition */
1397         if ((drr0 & CTS) && (~rr0 & CTS) && priv->type != TYPE_TWIN)
1398                 tm_isr(priv);
1399
1400 }
1401
1402
1403 static void tm_isr(struct scc_priv *priv)
1404 {
1405         switch (priv->state) {
1406         case TX_HEAD:
1407         case TX_PAUSE:
1408                 tx_on(priv);
1409                 priv->state = TX_DATA;
1410                 break;
1411         case TX_TAIL:
1412                 write_scc(priv, R5, TxCRC_ENAB | Tx8);
1413                 priv->state = RTS_OFF;
1414                 if (priv->type != TYPE_TWIN)
1415                         write_scc(priv, R15, 0);
1416                 start_timer(priv, priv->param.rtsoff, 0);
1417                 break;
1418         case RTS_OFF:
1419                 write_scc(priv, R15, DCDIE);
1420                 priv->rr0 = read_scc(priv, R0);
1421                 if (priv->rr0 & DCD) {
1422                         priv->dev->stats.collisions++;
1423                         rx_on(priv);
1424                         priv->state = RX_ON;
1425                 } else {
1426                         priv->state = WAIT;
1427                         start_timer(priv, priv->param.waittime, DCDIE);
1428                 }
1429                 break;
1430         case WAIT:
1431                 if (priv->tx_count) {
1432                         priv->state = TX_HEAD;
1433                         priv->tx_start = jiffies;
1434                         write_scc(priv, R5,
1435                                   TxCRC_ENAB | RTS | TxENAB | Tx8);
1436                         write_scc(priv, R15, 0);
1437                         start_timer(priv, priv->param.txdelay, 0);
1438                 } else {
1439                         priv->state = IDLE;
1440                         if (priv->type != TYPE_TWIN)
1441                                 write_scc(priv, R15, DCDIE);
1442                 }
1443                 break;
1444         case DCD_ON:
1445         case DCD_OFF:
1446                 write_scc(priv, R15, DCDIE);
1447                 priv->rr0 = read_scc(priv, R0);
1448                 if (priv->rr0 & DCD) {
1449                         rx_on(priv);
1450                         priv->state = RX_ON;
1451                 } else {
1452                         priv->state = WAIT;
1453                         start_timer(priv,
1454                                     random() / priv->param.persist *
1455                                     priv->param.slottime, DCDIE);
1456                 }
1457                 break;
1458         }
1459 }