开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
dmascc.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：38k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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