[PATCH] Altix: ioc3 serial support
Patrick Gefre [Sat, 14 Jan 2006 21:20:40 +0000 (13:20 -0800)]
Add driver support for a 2 port PCI IOC3-based serial card on Altix boxes:

This is a re-submission.  On the original submission I was asked to
organize the code so that the MIPS ioc3 ethernet and serial parts could be
used with this driver.  Stanislaw Skowronek was kind enough to provide the
shim layer for this - thanks Stanislaw.  This patch includes the shim layer
and the Altix PCI ioc3 serial driver.  The MIPS merged ioc3 ethernet and
serial support is forthcoming.

Signed-off-by: Patrick Gefre <pfg@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

arch/ia64/configs/gensparse_defconfig
arch/ia64/configs/sn2_defconfig
drivers/serial/Kconfig
drivers/serial/Makefile
drivers/serial/ioc3_serial.c [new file with mode: 0644]
drivers/sn/Kconfig
drivers/sn/Makefile
drivers/sn/ioc3.c [new file with mode: 0644]
include/asm-ia64/sn/ioc3.h [new file with mode: 0644]
include/linux/ioc3.h [new file with mode: 0644]

index 80f8663..1d07d80 100644 (file)
@@ -701,6 +701,7 @@ CONFIG_SERIAL_CORE_CONSOLE=y
 CONFIG_SERIAL_SGI_L1_CONSOLE=y
 # CONFIG_SERIAL_JSM is not set
 CONFIG_SERIAL_SGI_IOC4=y
+CONFIG_SERIAL_SGI_IOC3=y
 CONFIG_UNIX98_PTYS=y
 CONFIG_LEGACY_PTYS=y
 CONFIG_LEGACY_PTY_COUNT=256
@@ -1046,6 +1047,7 @@ CONFIG_INFINIBAND_IPOIB=m
 # SN Devices
 #
 CONFIG_SGI_IOC4=y
+CONFIG_SGI_IOC3=y
 
 #
 # File systems
index ff8bb37..3cb503b 100644 (file)
@@ -659,6 +659,7 @@ CONFIG_SERIAL_CORE_CONSOLE=y
 CONFIG_SERIAL_SGI_L1_CONSOLE=y
 # CONFIG_SERIAL_JSM is not set
 CONFIG_SERIAL_SGI_IOC4=y
+CONFIG_SERIAL_SGI_IOC3=y
 CONFIG_UNIX98_PTYS=y
 CONFIG_LEGACY_PTYS=y
 CONFIG_LEGACY_PTY_COUNT=256
@@ -899,6 +900,7 @@ CONFIG_INFINIBAND_SRP=m
 # SN Devices
 #
 CONFIG_SGI_IOC4=y
+CONFIG_SGI_IOC3=y
 
 #
 # File systems
index 8437172..e0685a5 100644 (file)
@@ -190,7 +190,6 @@ config SERIAL_8250_BOCA
          To compile this driver as a module, choose M here: the module
          will be called 8250_boca.
 
-
 config SERIAL_8250_HUB6
        tristate "Support Hub6 cards"
        depends on SERIAL_8250 != n && ISA && SERIAL_8250_MANY_PORTS
@@ -917,4 +916,12 @@ config SERIAL_SGI_IOC4
                and wish to use the serial ports on this card, say Y.
                Otherwise, say N.
 
+config SERIAL_SGI_IOC3
+       tristate "SGI Altix IOC3 serial support"
+       depends on (IA64_GENERIC || IA64_SGI_SN2) && SGI_IOC3
+       select SERIAL_CORE
+       help
+         If you have an SGI Altix with an IOC3 serial card,
+         say Y or M.  Otherwise, say N.
+
 endmenu
index 24a583e..eaf8e01 100644 (file)
@@ -56,4 +56,5 @@ obj-$(CONFIG_SERIAL_JSM) += jsm/
 obj-$(CONFIG_SERIAL_TXX9) += serial_txx9.o
 obj-$(CONFIG_SERIAL_VR41XX) += vr41xx_siu.o
 obj-$(CONFIG_SERIAL_SGI_IOC4) += ioc4_serial.o
+obj-$(CONFIG_SERIAL_SGI_IOC3) += ioc3_serial.o
 obj-$(CONFIG_SERIAL_AT91) += at91_serial.o
diff --git a/drivers/serial/ioc3_serial.c b/drivers/serial/ioc3_serial.c
new file mode 100644 (file)
index 0000000..8097cd9
--- /dev/null
@@ -0,0 +1,2197 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2005 Silicon Graphics, Inc.  All Rights Reserved.
+ */
+
+/*
+ * This file contains a module version of the ioc3 serial driver. This
+ * includes all the support functions needed (support functions, etc.)
+ * and the serial driver itself.
+ */
+#include <linux/errno.h>
+#include <linux/tty.h>
+#include <linux/serial.h>
+#include <linux/circ_buf.h>
+#include <linux/serial_reg.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/serial_core.h>
+#include <linux/ioc3.h>
+
+/*
+ * Interesting things about the ioc3
+ */
+
+#define LOGICAL_PORTS          2       /* rs232(0) and rs422(1) */
+#define PORTS_PER_CARD         2
+#define LOGICAL_PORTS_PER_CARD (PORTS_PER_CARD * LOGICAL_PORTS)
+#define MAX_CARDS              8
+#define MAX_LOGICAL_PORTS      (LOGICAL_PORTS_PER_CARD * MAX_CARDS)
+
+/* determine given the sio_ir what port it applies to */
+#define GET_PORT_FROM_SIO_IR(_x)       (_x & SIO_IR_SA) ? 0 : 1
+
+
+/*
+ * we have 2 logical ports (rs232, rs422) for each physical port
+ * evens are rs232, odds are rs422
+ */
+#define GET_PHYSICAL_PORT(_x)  ((_x) >> 1)
+#define GET_LOGICAL_PORT(_x)   ((_x) & 1)
+#define IS_PHYSICAL_PORT(_x)   !((_x) & 1)
+#define IS_RS232(_x)           !((_x) & 1)
+
+static unsigned int Num_of_ioc3_cards;
+static unsigned int Submodule_slot;
+
+/* defining this will get you LOTS of great debug info */
+//#define DEBUG_INTERRUPTS
+#define DPRINT_CONFIG(_x...)   ;
+//#define DPRINT_CONFIG(_x...)  printk _x
+#define NOT_PROGRESS() ;
+//#define NOT_PROGRESS()       printk("%s : fails %d\n", __FUNCTION__, __LINE__)
+
+/* number of characters we want to transmit to the lower level at a time */
+#define MAX_CHARS              256
+#define FIFO_SIZE              (MAX_CHARS-1)   /* it's a uchar */
+
+/* Device name we're using */
+#define DEVICE_NAME            "ttySIOC"
+#define DEVICE_MAJOR           204
+#define DEVICE_MINOR           116
+
+/* flags for next_char_state */
+#define NCS_BREAK              0x1
+#define NCS_PARITY             0x2
+#define NCS_FRAMING            0x4
+#define NCS_OVERRUN            0x8
+
+/* cause we need SOME parameters ... */
+#define MIN_BAUD_SUPPORTED     1200
+#define MAX_BAUD_SUPPORTED     115200
+
+/* protocol types supported */
+#define PROTO_RS232            0
+#define PROTO_RS422            1
+
+/* Notification types */
+#define N_DATA_READY           0x01
+#define N_OUTPUT_LOWAT         0x02
+#define N_BREAK                        0x04
+#define N_PARITY_ERROR         0x08
+#define N_FRAMING_ERROR                0x10
+#define N_OVERRUN_ERROR                0x20
+#define N_DDCD                 0x40
+#define N_DCTS                 0x80
+
+#define N_ALL_INPUT            (N_DATA_READY | N_BREAK                    \
+                                       | N_PARITY_ERROR | N_FRAMING_ERROR \
+                                       | N_OVERRUN_ERROR | N_DDCD | N_DCTS)
+
+#define N_ALL_OUTPUT           N_OUTPUT_LOWAT
+
+#define N_ALL_ERRORS           (N_PARITY_ERROR | N_FRAMING_ERROR \
+                                               | N_OVERRUN_ERROR)
+
+#define N_ALL                  (N_DATA_READY | N_OUTPUT_LOWAT | N_BREAK    \
+                                       | N_PARITY_ERROR | N_FRAMING_ERROR  \
+                                       | N_OVERRUN_ERROR | N_DDCD | N_DCTS)
+
+#define SER_CLK_SPEED(prediv)  ((22000000 << 1) / prediv)
+#define SER_DIVISOR(x, clk)    (((clk) + (x) * 8) / ((x) * 16))
+#define DIVISOR_TO_BAUD(div, clk) ((clk) / 16 / (div))
+
+/* Some masks */
+#define LCR_MASK_BITS_CHAR     (UART_LCR_WLEN5 | UART_LCR_WLEN6 \
+                                       | UART_LCR_WLEN7 | UART_LCR_WLEN8)
+#define LCR_MASK_STOP_BITS     (UART_LCR_STOP)
+
+#define PENDING(_a, _p)                (readl(&(_p)->vma->sio_ir) & (_a)->ic_enable)
+
+#define RING_BUF_SIZE          4096
+#define BUF_SIZE_BIT           SBBR_L_SIZE
+#define PROD_CONS_MASK         PROD_CONS_PTR_4K
+
+#define TOTAL_RING_BUF_SIZE    (RING_BUF_SIZE * 4)
+
+/* driver specific - one per card */
+struct ioc3_card {
+       struct {
+               /* uart ports are allocated here */
+               struct uart_port icp_uart_port[LOGICAL_PORTS];
+               /* the ioc3_port used for this port */
+               struct ioc3_port *icp_port;
+       } ic_port[PORTS_PER_CARD];
+       /* currently enabled interrupts */
+       uint32_t ic_enable;
+};
+
+/* Local port info for each IOC3 serial port */
+struct ioc3_port {
+       /* handy reference material */
+       struct uart_port *ip_port;
+       struct ioc3_card *ip_card;
+       struct ioc3_driver_data *ip_idd;
+       struct ioc3_submodule *ip_is;
+
+       /* pci mem addresses for this port */
+       struct ioc3_serialregs __iomem *ip_serial_regs;
+       struct ioc3_uartregs __iomem *ip_uart_regs;
+
+       /* Ring buffer page for this port */
+       dma_addr_t ip_dma_ringbuf;
+       /* vaddr of ring buffer */
+       struct ring_buffer *ip_cpu_ringbuf;
+
+       /* Rings for this port */
+       struct ring *ip_inring;
+       struct ring *ip_outring;
+
+       /* Hook to port specific values */
+       struct port_hooks *ip_hooks;
+
+       spinlock_t ip_lock;
+
+       /* Various rx/tx parameters */
+       int ip_baud;
+       int ip_tx_lowat;
+       int ip_rx_timeout;
+
+       /* Copy of notification bits */
+       int ip_notify;
+
+       /* Shadow copies of various registers so we don't need to PIO
+        * read them constantly
+        */
+       uint32_t ip_sscr;
+       uint32_t ip_tx_prod;
+       uint32_t ip_rx_cons;
+       unsigned char ip_flags;
+};
+
+/* tx low water mark.  We need to notify the driver whenever tx is getting
+ * close to empty so it can refill the tx buffer and keep things going.
+ * Let's assume that if we interrupt 1 ms before the tx goes idle, we'll
+ * have no trouble getting in more chars in time (I certainly hope so).
+ */
+#define TX_LOWAT_LATENCY      1000
+#define TX_LOWAT_HZ          (1000000 / TX_LOWAT_LATENCY)
+#define TX_LOWAT_CHARS(baud) (baud / 10 / TX_LOWAT_HZ)
+
+/* Flags per port */
+#define INPUT_HIGH             0x01
+       /* used to signify that we have turned off the rx_high
+        * temporarily - we need to drain the fifo and don't
+        * want to get blasted with interrupts.
+        */
+#define DCD_ON                 0x02
+       /* DCD state is on */
+#define LOWAT_WRITTEN          0x04
+#define READ_ABORTED           0x08
+       /* the read was aborted - used to avaoid infinate looping
+        * in the interrupt handler
+        */
+#define INPUT_ENABLE           0x10
+
+/* Since each port has different register offsets and bitmasks
+ * for everything, we'll store those that we need in tables so we
+ * don't have to be constantly checking the port we are dealing with.
+ */
+struct port_hooks {
+       uint32_t intr_delta_dcd;
+       uint32_t intr_delta_cts;
+       uint32_t intr_tx_mt;
+       uint32_t intr_rx_timer;
+       uint32_t intr_rx_high;
+       uint32_t intr_tx_explicit;
+       uint32_t intr_clear;
+       uint32_t intr_all;
+       char rs422_select_pin;
+};
+
+static struct port_hooks hooks_array[PORTS_PER_CARD] = {
+       /* values for port A */
+       {
+       .intr_delta_dcd = SIO_IR_SA_DELTA_DCD,
+       .intr_delta_cts = SIO_IR_SA_DELTA_CTS,
+       .intr_tx_mt = SIO_IR_SA_TX_MT,
+       .intr_rx_timer = SIO_IR_SA_RX_TIMER,
+       .intr_rx_high = SIO_IR_SA_RX_HIGH,
+       .intr_tx_explicit = SIO_IR_SA_TX_EXPLICIT,
+       .intr_clear = (SIO_IR_SA_TX_MT | SIO_IR_SA_RX_FULL
+                               | SIO_IR_SA_RX_HIGH
+                               | SIO_IR_SA_RX_TIMER
+                               | SIO_IR_SA_DELTA_DCD
+                               | SIO_IR_SA_DELTA_CTS
+                               | SIO_IR_SA_INT
+                               | SIO_IR_SA_TX_EXPLICIT
+                               | SIO_IR_SA_MEMERR),
+       .intr_all =  SIO_IR_SA,
+       .rs422_select_pin = GPPR_UARTA_MODESEL_PIN,
+        },
+
+       /* values for port B */
+       {
+       .intr_delta_dcd = SIO_IR_SB_DELTA_DCD,
+       .intr_delta_cts = SIO_IR_SB_DELTA_CTS,
+       .intr_tx_mt = SIO_IR_SB_TX_MT,
+       .intr_rx_timer = SIO_IR_SB_RX_TIMER,
+       .intr_rx_high = SIO_IR_SB_RX_HIGH,
+       .intr_tx_explicit = SIO_IR_SB_TX_EXPLICIT,
+       .intr_clear = (SIO_IR_SB_TX_MT | SIO_IR_SB_RX_FULL
+                               | SIO_IR_SB_RX_HIGH
+                               | SIO_IR_SB_RX_TIMER
+                               | SIO_IR_SB_DELTA_DCD
+                               | SIO_IR_SB_DELTA_CTS
+                               | SIO_IR_SB_INT
+                               | SIO_IR_SB_TX_EXPLICIT
+                               | SIO_IR_SB_MEMERR),
+       .intr_all = SIO_IR_SB,
+       .rs422_select_pin = GPPR_UARTB_MODESEL_PIN,
+        }
+};
+
+struct ring_entry {
+       union {
+               struct {
+                       uint32_t alldata;
+                       uint32_t allsc;
+               } all;
+               struct {
+                       char data[4];   /* data bytes */
+                       char sc[4];     /* status/control */
+               } s;
+       } u;
+};
+
+/* Test the valid bits in any of the 4 sc chars using "allsc" member */
+#define RING_ANY_VALID \
+       ((uint32_t)(RXSB_MODEM_VALID | RXSB_DATA_VALID) * 0x01010101)
+
+#define ring_sc                u.s.sc
+#define ring_data      u.s.data
+#define ring_allsc     u.all.allsc
+
+/* Number of entries per ring buffer. */
+#define ENTRIES_PER_RING (RING_BUF_SIZE / (int) sizeof(struct ring_entry))
+
+/* An individual ring */
+struct ring {
+       struct ring_entry entries[ENTRIES_PER_RING];
+};
+
+/* The whole enchilada */
+struct ring_buffer {
+       struct ring TX_A;
+       struct ring RX_A;
+       struct ring TX_B;
+       struct ring RX_B;
+};
+
+/* Get a ring from a port struct */
+#define RING(_p, _wh)  &(((struct ring_buffer *)((_p)->ip_cpu_ringbuf))->_wh)
+
+/* for Infinite loop detection  */
+#define MAXITER                10000000
+
+
+/**
+ * set_baud - Baud rate setting code
+ * @port: port to set
+ * @baud: baud rate to use
+ */
+static int set_baud(struct ioc3_port *port, int baud)
+{
+       int divisor;
+       int actual_baud;
+       int diff;
+       int lcr, prediv;
+       struct ioc3_uartregs __iomem *uart;
+
+       for (prediv = 6; prediv < 64; prediv++) {
+               divisor = SER_DIVISOR(baud, SER_CLK_SPEED(prediv));
+               if (!divisor)
+                       continue;       /* invalid divisor */
+               actual_baud = DIVISOR_TO_BAUD(divisor, SER_CLK_SPEED(prediv));
+
+               diff = actual_baud - baud;
+               if (diff < 0)
+                       diff = -diff;
+
+               /* if we're within 1% we've found a match */
+               if (diff * 100 <= actual_baud)
+                       break;
+       }
+
+       /* if the above loop completed, we didn't match
+        * the baud rate.  give up.
+        */
+       if (prediv == 64) {
+               NOT_PROGRESS();
+               return 1;
+       }
+
+       uart = port->ip_uart_regs;
+       lcr = readb(&uart->iu_lcr);
+
+       writeb(lcr | UART_LCR_DLAB, &uart->iu_lcr);
+       writeb((unsigned char)divisor, &uart->iu_dll);
+       writeb((unsigned char)(divisor >> 8), &uart->iu_dlm);
+       writeb((unsigned char)prediv, &uart->iu_scr);
+       writeb((unsigned char)lcr, &uart->iu_lcr);
+
+       return 0;
+}
+
+/**
+ * get_ioc3_port - given a uart port, return the control structure
+ * @the_port: uart port to find
+ */
+static struct ioc3_port *get_ioc3_port(struct uart_port *the_port)
+{
+       struct ioc3_driver_data *idd = dev_get_drvdata(the_port->dev);
+       struct ioc3_card *card_ptr = idd->data[Submodule_slot];
+       int ii, jj;
+
+       if (!card_ptr) {
+               NOT_PROGRESS();
+               return NULL;
+       }
+       for (ii = 0; ii < PORTS_PER_CARD; ii++) {
+               for (jj = 0; jj < LOGICAL_PORTS; jj++) {
+                       if (the_port == &card_ptr->ic_port[ii].icp_uart_port[jj])
+                               return card_ptr->ic_port[ii].icp_port;
+               }
+       }
+       NOT_PROGRESS();
+       return NULL;
+}
+
+/**
+ * port_init - Initialize the sio and ioc3 hardware for a given port
+ *                     called per port from attach...
+ * @port: port to initialize
+ */
+static int inline port_init(struct ioc3_port *port)
+{
+       uint32_t sio_cr;
+       struct port_hooks *hooks = port->ip_hooks;
+       struct ioc3_uartregs __iomem *uart;
+       int reset_loop_counter = 0xfffff;
+       struct ioc3_driver_data *idd = port->ip_idd;
+
+       /* Idle the IOC3 serial interface */
+       writel(SSCR_RESET, &port->ip_serial_regs->sscr);
+
+       /* Wait until any pending bus activity for this port has ceased */
+       do {
+               sio_cr = readl(&idd->vma->sio_cr);
+               if (reset_loop_counter-- <= 0) {
+                       printk(KERN_WARNING
+                              "IOC3 unable to come out of reset"
+                               " scr 0x%x\n", sio_cr);
+                       return -1;
+               }
+       } while (!(sio_cr & SIO_CR_ARB_DIAG_IDLE) &&
+              (((sio_cr &= SIO_CR_ARB_DIAG) == SIO_CR_ARB_DIAG_TXA)
+               || sio_cr == SIO_CR_ARB_DIAG_TXB
+               || sio_cr == SIO_CR_ARB_DIAG_RXA
+               || sio_cr == SIO_CR_ARB_DIAG_RXB));
+
+       /* Finish reset sequence */
+       writel(0, &port->ip_serial_regs->sscr);
+
+       /* Once RESET is done, reload cached tx_prod and rx_cons values
+        * and set rings to empty by making prod == cons
+        */
+       port->ip_tx_prod = readl(&port->ip_serial_regs->stcir) & PROD_CONS_MASK;
+       writel(port->ip_tx_prod, &port->ip_serial_regs->stpir);
+       port->ip_rx_cons = readl(&port->ip_serial_regs->srpir) & PROD_CONS_MASK;
+       writel(port->ip_rx_cons | SRCIR_ARM, &port->ip_serial_regs->srcir);
+
+       /* Disable interrupts for this 16550 */
+       uart = port->ip_uart_regs;
+       writeb(0, &uart->iu_lcr);
+       writeb(0, &uart->iu_ier);
+
+       /* Set the default baud */
+       set_baud(port, port->ip_baud);
+
+       /* Set line control to 8 bits no parity */
+       writeb(UART_LCR_WLEN8 | 0, &uart->iu_lcr);
+       /* UART_LCR_STOP == 1 stop */
+
+       /* Enable the FIFOs */
+       writeb(UART_FCR_ENABLE_FIFO, &uart->iu_fcr);
+       /* then reset 16550 FIFOs */
+       writeb(UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT,
+              &uart->iu_fcr);
+
+       /* Clear modem control register */
+       writeb(0, &uart->iu_mcr);
+
+       /* Clear deltas in modem status register */
+       writel(0, &port->ip_serial_regs->shadow);
+
+       /* Only do this once per port pair */
+       if (port->ip_hooks == &hooks_array[0]) {
+               unsigned long ring_pci_addr;
+               uint32_t __iomem *sbbr_l, *sbbr_h;
+
+               sbbr_l = &idd->vma->sbbr_l;
+               sbbr_h = &idd->vma->sbbr_h;
+               ring_pci_addr = (unsigned long __iomem)port->ip_dma_ringbuf;
+               DPRINT_CONFIG(("%s: ring_pci_addr 0x%p\n",
+                              __FUNCTION__, (void *)ring_pci_addr));
+
+               writel((unsigned int)((uint64_t) ring_pci_addr >> 32), sbbr_h);
+               writel((unsigned int)ring_pci_addr | BUF_SIZE_BIT, sbbr_l);
+       }
+
+       /* Set the receive timeout value to 10 msec */
+       writel(SRTR_HZ / 100, &port->ip_serial_regs->srtr);
+
+       /* Set rx threshold, enable DMA */
+       /* Set high water mark at 3/4 of full ring */
+       port->ip_sscr = (ENTRIES_PER_RING * 3 / 4);
+
+       /* uart experiences pauses at high baud rate reducing actual
+        * throughput by 10% or so unless we enable high speed polling
+        * XXX when this hardware bug is resolved we should revert to
+        * normal polling speed
+        */
+       port->ip_sscr |= SSCR_HIGH_SPD;
+
+       writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+
+       /* Disable and clear all serial related interrupt bits */
+       port->ip_card->ic_enable &= ~hooks->intr_clear;
+       ioc3_disable(port->ip_is, idd, hooks->intr_clear);
+       ioc3_ack(port->ip_is, idd, hooks->intr_clear);
+       return 0;
+}
+
+/**
+ * enable_intrs - enable interrupts
+ * @port: port to enable
+ * @mask: mask to use
+ */
+static void enable_intrs(struct ioc3_port *port, uint32_t mask)
+{
+       if ((port->ip_card->ic_enable & mask) != mask) {
+               port->ip_card->ic_enable |= mask;
+               ioc3_enable(port->ip_is, port->ip_idd, mask);
+       }
+}
+
+/**
+ * local_open - local open a port
+ * @port: port to open
+ */
+static inline int local_open(struct ioc3_port *port)
+{
+       int spiniter = 0;
+
+       port->ip_flags = INPUT_ENABLE;
+
+       /* Pause the DMA interface if necessary */
+       if (port->ip_sscr & SSCR_DMA_EN) {
+               writel(port->ip_sscr | SSCR_DMA_PAUSE,
+                      &port->ip_serial_regs->sscr);
+               while ((readl(&port->ip_serial_regs->sscr)
+                       & SSCR_PAUSE_STATE) == 0) {
+                       spiniter++;
+                       if (spiniter > MAXITER) {
+                               NOT_PROGRESS();
+                               return -1;
+                       }
+               }
+       }
+
+       /* Reset the input fifo.  If the uart received chars while the port
+        * was closed and DMA is not enabled, the uart may have a bunch of
+        * chars hanging around in its rx fifo which will not be discarded
+        * by rclr in the upper layer. We must get rid of them here.
+        */
+       writeb(UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR,
+              &port->ip_uart_regs->iu_fcr);
+
+       writeb(UART_LCR_WLEN8, &port->ip_uart_regs->iu_lcr);
+       /* UART_LCR_STOP == 1 stop */
+
+       /* Re-enable DMA, set default threshold to intr whenever there is
+        * data available.
+        */
+       port->ip_sscr &= ~SSCR_RX_THRESHOLD;
+       port->ip_sscr |= 1;     /* default threshold */
+
+       /* Plug in the new sscr.  This implicitly clears the DMA_PAUSE
+        * flag if it was set above
+        */
+       writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+       port->ip_tx_lowat = 1;
+       return 0;
+}
+
+/**
+ * set_rx_timeout - Set rx timeout and threshold values.
+ * @port: port to use
+ * @timeout: timeout value in ticks
+ */
+static inline int set_rx_timeout(struct ioc3_port *port, int timeout)
+{
+       int threshold;
+
+       port->ip_rx_timeout = timeout;
+
+       /* Timeout is in ticks.  Let's figure out how many chars we
+        * can receive at the current baud rate in that interval
+        * and set the rx threshold to that amount.  There are 4 chars
+        * per ring entry, so we'll divide the number of chars that will
+        * arrive in timeout by 4.
+        * So .... timeout * baud / 10 / HZ / 4, with HZ = 100.
+        */
+       threshold = timeout * port->ip_baud / 4000;
+       if (threshold == 0)
+               threshold = 1;  /* otherwise we'll intr all the time! */
+
+       if ((unsigned)threshold > (unsigned)SSCR_RX_THRESHOLD)
+               return 1;
+
+       port->ip_sscr &= ~SSCR_RX_THRESHOLD;
+       port->ip_sscr |= threshold;
+       writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+
+       /* Now set the rx timeout to the given value
+        * again timeout * SRTR_HZ / HZ
+        */
+       timeout = timeout * SRTR_HZ / 100;
+       if (timeout > SRTR_CNT)
+               timeout = SRTR_CNT;
+       writel(timeout, &port->ip_serial_regs->srtr);
+       return 0;
+}
+
+/**
+ * config_port - config the hardware
+ * @port: port to config
+ * @baud: baud rate for the port
+ * @byte_size: data size
+ * @stop_bits: number of stop bits
+ * @parenb: parity enable ?
+ * @parodd: odd parity ?
+ */
+static inline int
+config_port(struct ioc3_port *port,
+           int baud, int byte_size, int stop_bits, int parenb, int parodd)
+{
+       char lcr, sizebits;
+       int spiniter = 0;
+
+       DPRINT_CONFIG(("%s: line %d baud %d byte_size %d stop %d parenb %d "
+                       "parodd %d\n",
+                      __FUNCTION__, ((struct uart_port *)port->ip_port)->line,
+                       baud, byte_size, stop_bits, parenb, parodd));
+
+       if (set_baud(port, baud))
+               return 1;
+
+       switch (byte_size) {
+       case 5:
+               sizebits = UART_LCR_WLEN5;
+               break;
+       case 6:
+               sizebits = UART_LCR_WLEN6;
+               break;
+       case 7:
+               sizebits = UART_LCR_WLEN7;
+               break;
+       case 8:
+               sizebits = UART_LCR_WLEN8;
+               break;
+       default:
+               return 1;
+       }
+
+       /* Pause the DMA interface if necessary */
+       if (port->ip_sscr & SSCR_DMA_EN) {
+               writel(port->ip_sscr | SSCR_DMA_PAUSE,
+                      &port->ip_serial_regs->sscr);
+               while ((readl(&port->ip_serial_regs->sscr)
+                       & SSCR_PAUSE_STATE) == 0) {
+                       spiniter++;
+                       if (spiniter > MAXITER)
+                               return -1;
+               }
+       }
+
+       /* Clear relevant fields in lcr */
+       lcr = readb(&port->ip_uart_regs->iu_lcr);
+       lcr &= ~(LCR_MASK_BITS_CHAR | UART_LCR_EPAR |
+                UART_LCR_PARITY | LCR_MASK_STOP_BITS);
+
+       /* Set byte size in lcr */
+       lcr |= sizebits;
+
+       /* Set parity */
+       if (parenb) {
+               lcr |= UART_LCR_PARITY;
+               if (!parodd)
+                       lcr |= UART_LCR_EPAR;
+       }
+
+       /* Set stop bits */
+       if (stop_bits)
+               lcr |= UART_LCR_STOP /* 2 stop bits */ ;
+
+       writeb(lcr, &port->ip_uart_regs->iu_lcr);
+
+       /* Re-enable the DMA interface if necessary */
+       if (port->ip_sscr & SSCR_DMA_EN) {
+               writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+       }
+       port->ip_baud = baud;
+
+       /* When we get within this number of ring entries of filling the
+        * entire ring on tx, place an EXPLICIT intr to generate a lowat
+        * notification when output has drained.
+        */
+       port->ip_tx_lowat = (TX_LOWAT_CHARS(baud) + 3) / 4;
+       if (port->ip_tx_lowat == 0)
+               port->ip_tx_lowat = 1;
+
+       set_rx_timeout(port, 2);
+       return 0;
+}
+
+/**
+ * do_write - Write bytes to the port.  Returns the number of bytes
+ *                     actually written. Called from transmit_chars
+ * @port: port to use
+ * @buf: the stuff to write
+ * @len: how many bytes in 'buf'
+ */
+static inline int do_write(struct ioc3_port *port, char *buf, int len)
+{
+       int prod_ptr, cons_ptr, total = 0;
+       struct ring *outring;
+       struct ring_entry *entry;
+       struct port_hooks *hooks = port->ip_hooks;
+
+       BUG_ON(!(len >= 0));
+
+       prod_ptr = port->ip_tx_prod;
+       cons_ptr = readl(&port->ip_serial_regs->stcir) & PROD_CONS_MASK;
+       outring = port->ip_outring;
+
+       /* Maintain a 1-entry red-zone.  The ring buffer is full when
+        * (cons - prod) % ring_size is 1.  Rather than do this subtraction
+        * in the body of the loop, I'll do it now.
+        */
+       cons_ptr = (cons_ptr - (int)sizeof(struct ring_entry)) & PROD_CONS_MASK;
+
+       /* Stuff the bytes into the output */
+       while ((prod_ptr != cons_ptr) && (len > 0)) {
+               int xx;
+
+               /* Get 4 bytes (one ring entry) at a time */
+               entry = (struct ring_entry *)((caddr_t) outring + prod_ptr);
+
+               /* Invalidate all entries */
+               entry->ring_allsc = 0;
+
+               /* Copy in some bytes */
+               for (xx = 0; (xx < 4) && (len > 0); xx++) {
+                       entry->ring_data[xx] = *buf++;
+                       entry->ring_sc[xx] = TXCB_VALID;
+                       len--;
+                       total++;
+               }
+
+               /* If we are within some small threshold of filling up the
+                * entire ring buffer, we must place an EXPLICIT intr here
+                * to generate a lowat interrupt in case we subsequently
+                * really do fill up the ring and the caller goes to sleep.
+                * No need to place more than one though.
+                */
+               if (!(port->ip_flags & LOWAT_WRITTEN) &&
+                   ((cons_ptr - prod_ptr) & PROD_CONS_MASK)
+                   <= port->ip_tx_lowat * (int)sizeof(struct ring_entry)) {
+                       port->ip_flags |= LOWAT_WRITTEN;
+                       entry->ring_sc[0] |= TXCB_INT_WHEN_DONE;
+               }
+
+               /* Go on to next entry */
+               prod_ptr += sizeof(struct ring_entry);
+               prod_ptr &= PROD_CONS_MASK;
+       }
+
+       /* If we sent something, start DMA if necessary */
+       if (total > 0 && !(port->ip_sscr & SSCR_DMA_EN)) {
+               port->ip_sscr |= SSCR_DMA_EN;
+               writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+       }
+
+       /* Store the new producer pointer.  If tx is disabled, we stuff the
+        * data into the ring buffer, but we don't actually start tx.
+        */
+       if (!uart_tx_stopped(port->ip_port)) {
+               writel(prod_ptr, &port->ip_serial_regs->stpir);
+
+               /* If we are now transmitting, enable tx_mt interrupt so we
+                * can disable DMA if necessary when the tx finishes.
+                */
+               if (total > 0)
+                       enable_intrs(port, hooks->intr_tx_mt);
+       }
+       port->ip_tx_prod = prod_ptr;
+
+       return total;
+}
+
+/**
+ * disable_intrs - disable interrupts
+ * @port: port to enable
+ * @mask: mask to use
+ */
+static inline void disable_intrs(struct ioc3_port *port, uint32_t mask)
+{
+       if (port->ip_card->ic_enable & mask) {
+               ioc3_disable(port->ip_is, port->ip_idd, mask);
+               port->ip_card->ic_enable &= ~mask;
+       }
+}
+
+/**
+ * set_notification - Modify event notification
+ * @port: port to use
+ * @mask: events mask
+ * @set_on: set ?
+ */
+static int set_notification(struct ioc3_port *port, int mask, int set_on)
+{
+       struct port_hooks *hooks = port->ip_hooks;
+       uint32_t intrbits, sscrbits;
+
+       BUG_ON(!mask);
+
+       intrbits = sscrbits = 0;
+
+       if (mask & N_DATA_READY)
+               intrbits |= (hooks->intr_rx_timer | hooks->intr_rx_high);
+       if (mask & N_OUTPUT_LOWAT)
+               intrbits |= hooks->intr_tx_explicit;
+       if (mask & N_DDCD) {
+               intrbits |= hooks->intr_delta_dcd;
+               sscrbits |= SSCR_RX_RING_DCD;
+       }
+       if (mask & N_DCTS)
+               intrbits |= hooks->intr_delta_cts;
+
+       if (set_on) {
+               enable_intrs(port, intrbits);
+               port->ip_notify |= mask;
+               port->ip_sscr |= sscrbits;
+       } else {
+               disable_intrs(port, intrbits);
+               port->ip_notify &= ~mask;
+               port->ip_sscr &= ~sscrbits;
+       }
+
+       /* We require DMA if either DATA_READY or DDCD notification is
+        * currently requested. If neither of these is requested and
+        * there is currently no tx in progress, DMA may be disabled.
+        */
+       if (port->ip_notify & (N_DATA_READY | N_DDCD))
+               port->ip_sscr |= SSCR_DMA_EN;
+       else if (!(port->ip_card->ic_enable & hooks->intr_tx_mt))
+               port->ip_sscr &= ~SSCR_DMA_EN;
+
+       writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+       return 0;
+}
+
+/**
+ * set_mcr - set the master control reg
+ * @the_port: port to use
+ * @mask1: mcr mask
+ * @mask2: shadow mask
+ */
+static inline int set_mcr(struct uart_port *the_port,
+                         int mask1, int mask2)
+{
+       struct ioc3_port *port = get_ioc3_port(the_port);
+       uint32_t shadow;
+       int spiniter = 0;
+       char mcr;
+
+       if (!port)
+               return -1;
+
+       /* Pause the DMA interface if necessary */
+       if (port->ip_sscr & SSCR_DMA_EN) {
+               writel(port->ip_sscr | SSCR_DMA_PAUSE,
+                      &port->ip_serial_regs->sscr);
+               while ((readl(&port->ip_serial_regs->sscr)
+                       & SSCR_PAUSE_STATE) == 0) {
+                       spiniter++;
+                       if (spiniter > MAXITER)
+                               return -1;
+               }
+       }
+       shadow = readl(&port->ip_serial_regs->shadow);
+       mcr = (shadow & 0xff000000) >> 24;
+
+       /* Set new value */
+       mcr |= mask1;
+       shadow |= mask2;
+       writeb(mcr, &port->ip_uart_regs->iu_mcr);
+       writel(shadow, &port->ip_serial_regs->shadow);
+
+       /* Re-enable the DMA interface if necessary */
+       if (port->ip_sscr & SSCR_DMA_EN) {
+               writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+       }
+       return 0;
+}
+
+/**
+ * ioc3_set_proto - set the protocol for the port
+ * @port: port to use
+ * @proto: protocol to use
+ */
+static int ioc3_set_proto(struct ioc3_port *port, int proto)
+{
+       struct port_hooks *hooks = port->ip_hooks;
+
+       switch (proto) {
+       default:
+       case PROTO_RS232:
+               /* Clear the appropriate GIO pin */
+               DPRINT_CONFIG(("%s: rs232\n", __FUNCTION__));
+               writel(0, (&port->ip_idd->vma->gppr[0]
+                                       + hooks->rs422_select_pin));
+               break;
+
+       case PROTO_RS422:
+               /* Set the appropriate GIO pin */
+               DPRINT_CONFIG(("%s: rs422\n", __FUNCTION__));
+               writel(1, (&port->ip_idd->vma->gppr[0]
+                                       + hooks->rs422_select_pin));
+               break;
+       }
+       return 0;
+}
+
+/**
+ * transmit_chars - upper level write, called with the_port->lock
+ * @the_port: port to write
+ */
+static void transmit_chars(struct uart_port *the_port)
+{
+       int xmit_count, tail, head;
+       int result;
+       char *start;
+       struct tty_struct *tty;
+       struct ioc3_port *port = get_ioc3_port(the_port);
+       struct uart_info *info;
+
+       if (!the_port)
+               return;
+       if (!port)
+               return;
+
+       info = the_port->info;
+       tty = info->tty;
+
+       if (uart_circ_empty(&info->xmit) || uart_tx_stopped(the_port)) {
+               /* Nothing to do or hw stopped */
+               set_notification(port, N_ALL_OUTPUT, 0);
+               return;
+       }
+
+       head = info->xmit.head;
+       tail = info->xmit.tail;
+       start = (char *)&info->xmit.buf[tail];
+
+       /* write out all the data or until the end of the buffer */
+       xmit_count = (head < tail) ? (UART_XMIT_SIZE - tail) : (head - tail);
+       if (xmit_count > 0) {
+               result = do_write(port, start, xmit_count);
+               if (result > 0) {
+                       /* booking */
+                       xmit_count -= result;
+                       the_port->icount.tx += result;
+                       /* advance the pointers */
+                       tail += result;
+                       tail &= UART_XMIT_SIZE - 1;
+                       info->xmit.tail = tail;
+                       start = (char *)&info->xmit.buf[tail];
+               }
+       }
+       if (uart_circ_chars_pending(&info->xmit) < WAKEUP_CHARS)
+               uart_write_wakeup(the_port);
+
+       if (uart_circ_empty(&info->xmit)) {
+               set_notification(port, N_OUTPUT_LOWAT, 0);
+       } else {
+               set_notification(port, N_OUTPUT_LOWAT, 1);
+       }
+}
+
+/**
+ * ioc3_change_speed - change the speed of the port
+ * @the_port: port to change
+ * @new_termios: new termios settings
+ * @old_termios: old termios settings
+ */
+static void
+ioc3_change_speed(struct uart_port *the_port,
+                 struct termios *new_termios, struct termios *old_termios)
+{
+       struct ioc3_port *port = get_ioc3_port(the_port);
+       unsigned int cflag;
+       int baud;
+       int new_parity = 0, new_parity_enable = 0, new_stop = 0, new_data = 8;
+       struct uart_info *info = the_port->info;
+
+       cflag = new_termios->c_cflag;
+
+       switch (cflag & CSIZE) {
+       case CS5:
+               new_data = 5;
+               break;
+       case CS6:
+               new_data = 6;
+               break;
+       case CS7:
+               new_data = 7;
+               break;
+       case CS8:
+               new_data = 8;
+               break;
+       default:
+               /* cuz we always need a default ... */
+               new_data = 5;
+               break;
+       }
+       if (cflag & CSTOPB) {
+               new_stop = 1;
+       }
+       if (cflag & PARENB) {
+               new_parity_enable = 1;
+               if (cflag & PARODD)
+                       new_parity = 1;
+       }
+       baud = uart_get_baud_rate(the_port, new_termios, old_termios,
+                                 MIN_BAUD_SUPPORTED, MAX_BAUD_SUPPORTED);
+       DPRINT_CONFIG(("%s: returned baud %d for line %d\n", __FUNCTION__, baud,
+                               the_port->line));
+
+       if (!the_port->fifosize)
+               the_port->fifosize = FIFO_SIZE;
+       uart_update_timeout(the_port, cflag, baud);
+
+       the_port->ignore_status_mask = N_ALL_INPUT;
+
+       info->tty->low_latency = 1;
+
+       if (I_IGNPAR(info->tty))
+               the_port->ignore_status_mask &= ~(N_PARITY_ERROR
+                                                 | N_FRAMING_ERROR);
+       if (I_IGNBRK(info->tty)) {
+               the_port->ignore_status_mask &= ~N_BREAK;
+               if (I_IGNPAR(info->tty))
+                       the_port->ignore_status_mask &= ~N_OVERRUN_ERROR;
+       }
+       if (!(cflag & CREAD)) {
+               /* ignore everything */
+               the_port->ignore_status_mask &= ~N_DATA_READY;
+       }
+
+       if (cflag & CRTSCTS) {
+               /* enable hardware flow control */
+               port->ip_sscr |= SSCR_HFC_EN;
+       }
+       else {
+               /* disable hardware flow control */
+               port->ip_sscr &= ~SSCR_HFC_EN;
+       }
+       writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+
+       /* Set the configuration and proper notification call */
+       DPRINT_CONFIG(("%s : port 0x%p line %d cflag 0%o "
+                      "config_port(baud %d data %d stop %d penable %d "
+                       " parity %d), notification 0x%x\n",
+                      __FUNCTION__, (void *)port, the_port->line, cflag, baud,
+                      new_data, new_stop, new_parity_enable, new_parity,
+                      the_port->ignore_status_mask));
+
+       if ((config_port(port, baud,    /* baud */
+                        new_data,      /* byte size */
+                        new_stop,      /* stop bits */
+                        new_parity_enable,     /* set parity */
+                        new_parity)) >= 0) {   /* parity 1==odd */
+               set_notification(port, the_port->ignore_status_mask, 1);
+       }
+}
+
+/**
+ * ic3_startup_local - Start up the serial port - returns >= 0 if no errors
+ * @the_port: Port to operate on
+ */
+static inline int ic3_startup_local(struct uart_port *the_port)
+{
+       struct ioc3_port *port;
+
+       if (!the_port) {
+               NOT_PROGRESS();
+               return -1;
+       }
+
+       port = get_ioc3_port(the_port);
+       if (!port) {
+               NOT_PROGRESS();
+               return -1;
+       }
+
+       local_open(port);
+
+       /* set the protocol */
+       ioc3_set_proto(port, IS_RS232(the_port->line) ? PROTO_RS232 :
+                                                       PROTO_RS422);
+       return 0;
+}
+
+/*
+ * ioc3_cb_output_lowat - called when the output low water mark is hit
+ * @port: port to output
+ */
+static void ioc3_cb_output_lowat(struct ioc3_port *port)
+{
+       unsigned long pflags;
+
+       /* the_port->lock is set on the call here */
+       if (port->ip_port) {
+               spin_lock_irqsave(&port->ip_port->lock, pflags);
+               transmit_chars(port->ip_port);
+               spin_unlock_irqrestore(&port->ip_port->lock, pflags);
+       }
+}
+
+/*
+ * ioc3_cb_post_ncs - called for some basic errors
+ * @port: port to use
+ * @ncs: event
+ */
+static void ioc3_cb_post_ncs(struct uart_port *the_port, int ncs)
+{
+       struct uart_icount *icount;
+
+       icount = &the_port->icount;
+
+       if (ncs & NCS_BREAK)
+               icount->brk++;
+       if (ncs & NCS_FRAMING)
+               icount->frame++;
+       if (ncs & NCS_OVERRUN)
+               icount->overrun++;
+       if (ncs & NCS_PARITY)
+               icount->parity++;
+}
+
+/**
+ * do_read - Read in bytes from the port.  Return the number of bytes
+ *                     actually read.
+ * @the_port: port to use
+ * @buf: place to put the stuff we read
+ * @len: how big 'buf' is
+ */
+
+static inline int do_read(struct uart_port *the_port, char *buf, int len)
+{
+       int prod_ptr, cons_ptr, total;
+       struct ioc3_port *port = get_ioc3_port(the_port);
+       struct ring *inring;
+       struct ring_entry *entry;
+       struct port_hooks *hooks = port->ip_hooks;
+       int byte_num;
+       char *sc;
+       int loop_counter;
+
+       BUG_ON(!(len >= 0));
+       BUG_ON(!port);
+
+       /* There is a nasty timing issue in the IOC3. When the rx_timer
+        * expires or the rx_high condition arises, we take an interrupt.
+        * At some point while servicing the interrupt, we read bytes from
+        * the ring buffer and re-arm the rx_timer.  However the rx_timer is
+        * not started until the first byte is received *after* it is armed,
+        * and any bytes pending in the rx construction buffers are not drained
+        * to memory until either there are 4 bytes available or the rx_timer
+        * expires.  This leads to a potential situation where data is left
+        * in the construction buffers forever - 1 to 3 bytes were received
+        * after the interrupt was generated but before the rx_timer was
+        * re-armed. At that point as long as no subsequent bytes are received
+        * the timer will never be started and the bytes will remain in the
+        * construction buffer forever.  The solution is to execute a DRAIN
+        * command after rearming the timer.  This way any bytes received before
+        * the DRAIN will be drained to memory, and any bytes received after
+        * the DRAIN will start the TIMER and be drained when it expires.
+        * Luckily, this only needs to be done when the DMA buffer is empty
+        * since there is no requirement that this function return all
+        * available data as long as it returns some.
+        */
+       /* Re-arm the timer */
+
+       writel(port->ip_rx_cons | SRCIR_ARM, &port->ip_serial_regs->srcir);
+
+       prod_ptr = readl(&port->ip_serial_regs->srpir) & PROD_CONS_MASK;
+       cons_ptr = port->ip_rx_cons;
+
+       if (prod_ptr == cons_ptr) {
+               int reset_dma = 0;
+
+               /* Input buffer appears empty, do a flush. */
+
+               /* DMA must be enabled for this to work. */
+               if (!(port->ip_sscr & SSCR_DMA_EN)) {
+                       port->ip_sscr |= SSCR_DMA_EN;
+                       reset_dma = 1;
+               }
+
+               /* Potential race condition: we must reload the srpir after
+                * issuing the drain command, otherwise we could think the rx
+                * buffer is empty, then take a very long interrupt, and when
+                * we come back it's full and we wait forever for the drain to
+                * complete.
+                */
+               writel(port->ip_sscr | SSCR_RX_DRAIN,
+                      &port->ip_serial_regs->sscr);
+               prod_ptr = readl(&port->ip_serial_regs->srpir) & PROD_CONS_MASK;
+
+               /* We must not wait for the DRAIN to complete unless there are
+                * at least 8 bytes (2 ring entries) available to receive the
+                * data otherwise the DRAIN will never complete and we'll
+                * deadlock here.
+                * In fact, to make things easier, I'll just ignore the flush if
+                * there is any data at all now available.
+                */
+               if (prod_ptr == cons_ptr) {
+                       loop_counter = 0;
+                       while (readl(&port->ip_serial_regs->sscr) &
+                              SSCR_RX_DRAIN) {
+                               loop_counter++;
+                               if (loop_counter > MAXITER)
+                                       return -1;
+                       }
+
+                       /* SIGH. We have to reload the prod_ptr *again* since
+                        * the drain may have caused it to change
+                        */
+                       prod_ptr = readl(&port->ip_serial_regs->srpir)
+                           & PROD_CONS_MASK;
+               }
+               if (reset_dma) {
+                       port->ip_sscr &= ~SSCR_DMA_EN;
+                       writel(port->ip_sscr, &port->ip_serial_regs->sscr);
+               }
+       }
+       inring = port->ip_inring;
+       port->ip_flags &= ~READ_ABORTED;
+
+       total = 0;
+       loop_counter = 0xfffff; /* to avoid hangs */
+
+       /* Grab bytes from the hardware */
+       while ((prod_ptr != cons_ptr) && (len > 0)) {
+               entry = (struct ring_entry *)((caddr_t) inring + cons_ptr);
+
+               if (loop_counter-- <= 0) {
+                       printk(KERN_WARNING "IOC3 serial: "
+                              "possible hang condition/"
+                              "port stuck on read (line %d).\n",
+                               the_port->line);
+                       break;
+               }
+
+               /* According to the producer pointer, this ring entry
+                * must contain some data.  But if the PIO happened faster
+                * than the DMA, the data may not be available yet, so let's
+                * wait until it arrives.
+                */
+               if ((entry->ring_allsc & RING_ANY_VALID) == 0) {
+                       /* Indicate the read is aborted so we don't disable
+                        * the interrupt thinking that the consumer is
+                        * congested.
+                        */
+                       port->ip_flags |= READ_ABORTED;
+                       len = 0;
+                       break;
+               }
+
+               /* Load the bytes/status out of the ring entry */
+               for (byte_num = 0; byte_num < 4 && len > 0; byte_num++) {
+                       sc = &(entry->ring_sc[byte_num]);
+
+                       /* Check for change in modem state or overrun */
+                       if ((*sc & RXSB_MODEM_VALID)
+                           && (port->ip_notify & N_DDCD)) {
+                               /* Notify upper layer if DCD dropped */
+                               if ((port->ip_flags & DCD_ON)
+                                   && !(*sc & RXSB_DCD)) {
+                                       /* If we have already copied some data,
+                                        * return it.  We'll pick up the carrier
+                                        * drop on the next pass.  That way we
+                                        * don't throw away the data that has
+                                        * already been copied back to
+                                        * the caller's buffer.
+                                        */
+                                       if (total > 0) {
+                                               len = 0;
+                                               break;
+                                       }
+                                       port->ip_flags &= ~DCD_ON;
+
+                                       /* Turn off this notification so the
+                                        * carrier drop protocol won't see it
+                                        * again when it does a read.
+                                        */
+                                       *sc &= ~RXSB_MODEM_VALID;
+
+                                       /* To keep things consistent, we need
+                                        * to update the consumer pointer so
+                                        * the next reader won't come in and
+                                        * try to read the same ring entries
+                                        * again. This must be done here before
+                                        * the dcd change.
+                                        */
+
+                                       if ((entry->ring_allsc & RING_ANY_VALID)
+                                           == 0) {
+                                               cons_ptr += (int)sizeof
+                                                   (struct ring_entry);
+                                               cons_ptr &= PROD_CONS_MASK;
+                                       }
+                                       writel(cons_ptr,
+                                              &port->ip_serial_regs->srcir);
+                                       port->ip_rx_cons = cons_ptr;
+
+                                       /* Notify upper layer of carrier drop */
+                                       if ((port->ip_notify & N_DDCD)
+                                           && port->ip_port) {
+                                               uart_handle_dcd_change
+                                                       (port->ip_port, 0);
+                                               wake_up_interruptible
+                                                   (&the_port->info->
+                                                    delta_msr_wait);
+                                       }
+
+                                       /* If we had any data to return, we
+                                        * would have returned it above.
+                                        */
+                                       return 0;
+                               }
+                       }
+                       if (*sc & RXSB_MODEM_VALID) {
+                               /* Notify that an input overrun occurred */
+                               if ((*sc & RXSB_OVERRUN)
+                                   && (port->ip_notify & N_OVERRUN_ERROR)) {
+                                       ioc3_cb_post_ncs(the_port, NCS_OVERRUN);
+                               }
+                               /* Don't look at this byte again */
+                               *sc &= ~RXSB_MODEM_VALID;
+                       }
+
+                       /* Check for valid data or RX errors */
+                       if ((*sc & RXSB_DATA_VALID) &&
+                           ((*sc & (RXSB_PAR_ERR
+                                    | RXSB_FRAME_ERR | RXSB_BREAK))
+                            && (port->ip_notify & (N_PARITY_ERROR
+                                                   | N_FRAMING_ERROR
+                                                   | N_BREAK)))) {
+                               /* There is an error condition on the next byte.
+                                * If we have already transferred some bytes,
+                                * we'll stop here. Otherwise if this is the
+                                * first byte to be read, we'll just transfer
+                                * it alone after notifying the
+                                * upper layer of its status.
+                                */
+                               if (total > 0) {
+                                       len = 0;
+                                       break;
+                               } else {
+                                       if ((*sc & RXSB_PAR_ERR) &&
+                                           (port->
+                                            ip_notify & N_PARITY_ERROR)) {
+                                               ioc3_cb_post_ncs(the_port,
+                                                                NCS_PARITY);
+                                       }
+                                       if ((*sc & RXSB_FRAME_ERR) &&
+                                           (port->
+                                            ip_notify & N_FRAMING_ERROR)) {
+                                               ioc3_cb_post_ncs(the_port,
+                                                                NCS_FRAMING);
+                                       }
+                                       if ((*sc & RXSB_BREAK)
+                                           && (port->ip_notify & N_BREAK)) {
+                                               ioc3_cb_post_ncs
+                                                   (the_port, NCS_BREAK);
+                                       }
+                                       len = 1;
+                               }
+                       }
+                       if (*sc & RXSB_DATA_VALID) {
+                               *sc &= ~RXSB_DATA_VALID;
+                               *buf = entry->ring_data[byte_num];
+                               buf++;
+                               len--;
+                               total++;
+                       }
+               }
+
+               /* If we used up this entry entirely, go on to the next one,
+                * otherwise we must have run out of buffer space, so
+                * leave the consumer pointer here for the next read in case
+                * there are still unread bytes in this entry.
+                */
+               if ((entry->ring_allsc & RING_ANY_VALID) == 0) {
+                       cons_ptr += (int)sizeof(struct ring_entry);
+                       cons_ptr &= PROD_CONS_MASK;
+               }
+       }
+
+       /* Update consumer pointer and re-arm rx timer interrupt */
+       writel(cons_ptr, &port->ip_serial_regs->srcir);
+       port->ip_rx_cons = cons_ptr;
+
+       /* If we have now dipped below the rx high water mark and we have
+        * rx_high interrupt turned off, we can now turn it back on again.
+        */
+       if ((port->ip_flags & INPUT_HIGH) && (((prod_ptr - cons_ptr)
+                                              & PROD_CONS_MASK) <
+                                             ((port->
+                                               ip_sscr &
+                                               SSCR_RX_THRESHOLD)
+                                              << PROD_CONS_PTR_OFF))) {
+               port->ip_flags &= ~INPUT_HIGH;
+               enable_intrs(port, hooks->intr_rx_high);
+       }
+       return total;
+}
+
+/**
+ * receive_chars - upper level read.
+ * @the_port: port to read from
+ */
+static int receive_chars(struct uart_port *the_port)
+{
+       struct tty_struct *tty;
+       unsigned char ch[MAX_CHARS];
+       int read_count = 0, read_room, flip = 0;
+       struct uart_info *info = the_port->info;
+       struct ioc3_port *port = get_ioc3_port(the_port);
+       unsigned long pflags;
+
+       /* Make sure all the pointers are "good" ones */
+       if (!info)
+               return 0;
+       if (!info->tty)
+               return 0;
+
+       if (!(port->ip_flags & INPUT_ENABLE))
+               return 0;
+
+       spin_lock_irqsave(&the_port->lock, pflags);
+       tty = info->tty;
+
+       read_count = do_read(the_port, ch, MAX_CHARS);
+       if (read_count > 0) {
+               flip = 1;
+               read_room = tty_buffer_request_room(tty, read_count);
+               tty_insert_flip_string(tty, ch, read_room);
+               the_port->icount.rx += read_count;
+       }
+       spin_unlock_irqrestore(&the_port->lock, pflags);
+
+       if (flip)
+               tty_flip_buffer_push(tty);
+
+       return read_count;
+}
+
+/**
+ * ioc3uart_intr_one - lowest level (per port) interrupt handler.
+ * @is : submodule
+ * @idd: driver data
+ * @pending: interrupts to handle
+ * @regs: pt_regs
+ */
+
+static int inline
+ioc3uart_intr_one(struct ioc3_submodule *is,
+                       struct ioc3_driver_data *idd,
+                       unsigned int pending, struct pt_regs *regs)
+{
+       int port_num = GET_PORT_FROM_SIO_IR(pending);
+       struct port_hooks *hooks;
+       unsigned int rx_high_rd_aborted = 0;
+       unsigned long flags;
+       struct uart_port *the_port;
+       struct ioc3_port *port;
+       int loop_counter;
+       struct ioc3_card *card_ptr;
+       unsigned int sio_ir;
+
+       card_ptr = idd->data[is->id];
+       port = card_ptr->ic_port[port_num].icp_port;
+       hooks = port->ip_hooks;
+
+       /* Possible race condition here: The tx_mt interrupt bit may be
+        * cleared without the intervention of the interrupt handler,
+        * e.g. by a write.  If the top level interrupt handler reads a
+        * tx_mt, then some other processor does a write, starting up
+        * output, then we come in here, see the tx_mt and stop DMA, the
+        * output started by the other processor will hang.  Thus we can
+        * only rely on tx_mt being legitimate if it is read while the
+        * port lock is held.  Therefore this bit must be ignored in the
+        * passed in interrupt mask which was read by the top level
+        * interrupt handler since the port lock was not held at the time
+        * it was read.  We can only rely on this bit being accurate if it
+        * is read while the port lock is held.  So we'll clear it for now,
+        * and reload it later once we have the port lock.
+        */
+
+       sio_ir = pending & ~(hooks->intr_tx_mt);
+       spin_lock_irqsave(&port->ip_lock, flags);
+
+       loop_counter = MAXITER; /* to avoid hangs */
+
+       do {
+               uint32_t shadow;
+
+               if (loop_counter-- <= 0) {
+                       printk(KERN_WARNING "IOC3 serial: "
+                              "possible hang condition/"
+                              "port stuck on interrupt (line %d).\n",
+                               ((struct uart_port *)port->ip_port)->line);
+                       break;
+               }
+               /* Handle a DCD change */
+               if (sio_ir & hooks->intr_delta_dcd) {
+                       ioc3_ack(is, idd, hooks->intr_delta_dcd);
+                       shadow = readl(&port->ip_serial_regs->shadow);
+
+                       if ((port->ip_notify & N_DDCD)
+                           && (shadow & SHADOW_DCD)
+                           && (port->ip_port)) {
+                               the_port = port->ip_port;
+                               uart_handle_dcd_change(the_port,
+                                               shadow & SHADOW_DCD);
+                               wake_up_interruptible
+                                   (&the_port->info->delta_msr_wait);
+                       } else if ((port->ip_notify & N_DDCD)
+                                  && !(shadow & SHADOW_DCD)) {
+                               /* Flag delta DCD/no DCD */
+                               uart_handle_dcd_change(port->ip_port,
+                                               shadow & SHADOW_DCD);
+                               port->ip_flags |= DCD_ON;
+                       }
+               }
+
+               /* Handle a CTS change */
+               if (sio_ir & hooks->intr_delta_cts) {
+                       ioc3_ack(is, idd, hooks->intr_delta_cts);
+                       shadow = readl(&port->ip_serial_regs->shadow);
+
+                       if ((port->ip_notify & N_DCTS) && (port->ip_port)) {
+                               the_port = port->ip_port;
+                               uart_handle_cts_change(the_port, shadow
+                                               & SHADOW_CTS);
+                               wake_up_interruptible
+                                   (&the_port->info->delta_msr_wait);
+                       }
+               }
+
+               /* rx timeout interrupt.  Must be some data available.  Put this
+                * before the check for rx_high since servicing this condition
+                * may cause that condition to clear.
+                */
+               if (sio_ir & hooks->intr_rx_timer) {
+                       ioc3_ack(is, idd, hooks->intr_rx_timer);
+                       if ((port->ip_notify & N_DATA_READY)
+                                               && (port->ip_port)) {
+                               receive_chars(port->ip_port);
+                       }
+               }
+
+               /* rx high interrupt. Must be after rx_timer.  */
+               else if (sio_ir & hooks->intr_rx_high) {
+                       /* Data available, notify upper layer */
+                       if ((port->ip_notify & N_DATA_READY) && port->ip_port) {
+                               receive_chars(port->ip_port);
+                       }
+
+                       /* We can't ACK this interrupt.  If receive_chars didn't
+                        * cause the condition to clear, we'll have to disable
+                        * the interrupt until the data is drained.
+                        * If the read was aborted, don't disable the interrupt
+                        * as this may cause us to hang indefinitely.  An
+                        * aborted read generally means that this interrupt
+                        * hasn't been delivered to the cpu yet anyway, even
+                        * though we see it as asserted when we read the sio_ir.
+                        */
+                       if ((sio_ir = PENDING(card_ptr, idd))
+                                       & hooks->intr_rx_high) {
+                               if (port->ip_flags & READ_ABORTED) {
+                                       rx_high_rd_aborted++;
+                               }
+                               else {
+                                       card_ptr->ic_enable &= ~hooks->intr_rx_high;
+                                       port->ip_flags |= INPUT_HIGH;
+                               }
+                       }
+               }
+
+               /* We got a low water interrupt: notify upper layer to
+                * send more data.  Must come before tx_mt since servicing
+                * this condition may cause that condition to clear.
+                */
+               if (sio_ir & hooks->intr_tx_explicit) {
+                       port->ip_flags &= ~LOWAT_WRITTEN;
+                       ioc3_ack(is, idd, hooks->intr_tx_explicit);
+                       if (port->ip_notify & N_OUTPUT_LOWAT)
+                               ioc3_cb_output_lowat(port);
+               }
+
+               /* Handle tx_mt.  Must come after tx_explicit.  */
+               else if (sio_ir & hooks->intr_tx_mt) {
+                       /* If we are expecting a lowat notification
+                        * and we get to this point it probably means that for
+                        * some reason the tx_explicit didn't work as expected
+                        * (that can legitimately happen if the output buffer is
+                        * filled up in just the right way).
+                        * So send the notification now.
+                        */
+                       if (port->ip_notify & N_OUTPUT_LOWAT) {
+                               ioc3_cb_output_lowat(port);
+
+                               /* We need to reload the sio_ir since the lowat
+                                * call may have caused another write to occur,
+                                * clearing the tx_mt condition.
+                                */
+                               sio_ir = PENDING(card_ptr, idd);
+                       }
+
+                       /* If the tx_mt condition still persists even after the
+                        * lowat call, we've got some work to do.
+                        */
+                       if (sio_ir & hooks->intr_tx_mt) {
+                               /* If we are not currently expecting DMA input,
+                                * and the transmitter has just gone idle,
+                                * there is no longer any reason for DMA, so
+                                * disable it.
+                                */
+                               if (!(port->ip_notify
+                                     & (N_DATA_READY | N_DDCD))) {
+                                       BUG_ON(!(port->ip_sscr
+                                                & SSCR_DMA_EN));
+                                       port->ip_sscr &= ~SSCR_DMA_EN;
+                                       writel(port->ip_sscr,
+                                              &port->ip_serial_regs->sscr);
+                               }
+                               /* Prevent infinite tx_mt interrupt */
+                               card_ptr->ic_enable &= ~hooks->intr_tx_mt;
+                       }
+               }
+               sio_ir = PENDING(card_ptr, idd);
+
+               /* if the read was aborted and only hooks->intr_rx_high,
+                * clear hooks->intr_rx_high, so we do not loop forever.
+                */
+
+               if (rx_high_rd_aborted && (sio_ir == hooks->intr_rx_high)) {
+                       sio_ir &= ~hooks->intr_rx_high;
+               }
+       } while (sio_ir & hooks->intr_all);
+
+       spin_unlock_irqrestore(&port->ip_lock, flags);
+       ioc3_enable(is, idd, card_ptr->ic_enable);
+       return 0;
+}
+
+/**
+ * ioc3uart_intr - field all serial interrupts
+ * @is : submodule
+ * @idd: driver data
+ * @pending: interrupts to handle
+ * @regs: pt_regs
+ *
+ */
+
+static int ioc3uart_intr(struct ioc3_submodule *is,
+                       struct ioc3_driver_data *idd,
+                       unsigned int pending, struct pt_regs *regs)
+{
+       int ret = 0;
+
+       /*
+        * The upper level interrupt handler sends interrupts for both ports
+        * here. So we need to call for each port with its interrupts.
+        */
+
+       if (pending & SIO_IR_SA)
+               ret |= ioc3uart_intr_one(is, idd, pending & SIO_IR_SA, regs);
+       if (pending & SIO_IR_SB)
+               ret |= ioc3uart_intr_one(is, idd, pending & SIO_IR_SB, regs);
+
+       return ret;
+}
+
+/**
+ * ic3_type
+ * @port: Port to operate with (we ignore since we only have one port)
+ *
+ */
+static const char *ic3_type(struct uart_port *the_port)
+{
+       if (IS_RS232(the_port->line))
+               return "SGI IOC3 Serial [rs232]";
+       else
+               return "SGI IOC3 Serial [rs422]";
+}
+
+/**
+ * ic3_tx_empty - Is the transmitter empty?
+ * @port: Port to operate on
+ *
+ */
+static unsigned int ic3_tx_empty(struct uart_port *the_port)
+{
+       unsigned int ret = 0;
+       struct ioc3_port *port = get_ioc3_port(the_port);
+
+       if (readl(&port->ip_serial_regs->shadow) & SHADOW_TEMT)
+               ret = TIOCSER_TEMT;
+       return ret;
+}
+
+/**
+ * ic3_stop_tx - stop the transmitter
+ * @port: Port to operate on
+ *
+ */
+static void ic3_stop_tx(struct uart_port *the_port)
+{
+       struct ioc3_port *port = get_ioc3_port(the_port);
+
+       if (port)
+               set_notification(port, N_OUTPUT_LOWAT, 0);
+}
+
+/**
+ * ic3_stop_rx - stop the receiver
+ * @port: Port to operate on
+ *
+ */
+static void ic3_stop_rx(struct uart_port *the_port)
+{
+       struct ioc3_port *port = get_ioc3_port(the_port);
+
+       if (port)
+               port->ip_flags &= ~INPUT_ENABLE;
+}
+
+/**
+ * null_void_function
+ * @port: Port to operate on
+ *
+ */
+static void null_void_function(struct uart_port *the_port)
+{
+}
+
+/**
+ * ic3_shutdown - shut down the port - free irq and disable
+ * @port: port to shut down
+ *
+ */
+static void ic3_shutdown(struct uart_port *the_port)
+{
+       unsigned long port_flags;
+       struct ioc3_port *port;
+       struct uart_info *info;
+
+       port = get_ioc3_port(the_port);
+       if (!port)
+               return;
+
+       info = the_port->info;
+       wake_up_interruptible(&info->delta_msr_wait);
+
+       spin_lock_irqsave(&the_port->lock, port_flags);
+       set_notification(port, N_ALL, 0);
+       spin_unlock_irqrestore(&the_port->lock, port_flags);
+}
+
+/**
+ * ic3_set_mctrl - set control lines (dtr, rts, etc)
+ * @port: Port to operate on
+ * @mctrl: Lines to set/unset
+ *
+ */
+static void ic3_set_mctrl(struct uart_port *the_port, unsigned int mctrl)
+{
+       unsigned char mcr = 0;
+
+       if (mctrl & TIOCM_RTS)
+               mcr |= UART_MCR_RTS;
+       if (mctrl & TIOCM_DTR)
+               mcr |= UART_MCR_DTR;
+       if (mctrl & TIOCM_OUT1)
+               mcr |= UART_MCR_OUT1;
+       if (mctrl & TIOCM_OUT2)
+               mcr |= UART_MCR_OUT2;
+       if (mctrl & TIOCM_LOOP)
+               mcr |= UART_MCR_LOOP;
+
+       set_mcr(the_port, mcr, SHADOW_DTR);
+}
+
+/**
+ * ic3_get_mctrl - get control line info
+ * @port: port to operate on
+ *
+ */
+static unsigned int ic3_get_mctrl(struct uart_port *the_port)
+{
+       struct ioc3_port *port = get_ioc3_port(the_port);
+       uint32_t shadow;
+       unsigned int ret = 0;
+
+       if (!port)
+               return 0;
+
+       shadow = readl(&port->ip_serial_regs->shadow);
+       if (shadow & SHADOW_DCD)
+               ret |= TIOCM_CD;
+       if (shadow & SHADOW_DR)
+               ret |= TIOCM_DSR;
+       if (shadow & SHADOW_CTS)
+               ret |= TIOCM_CTS;
+       return ret;
+}
+
+/**
+ * ic3_start_tx - Start transmitter. Called with the_port->lock
+ * @port: Port to operate on
+ *
+ */
+static void ic3_start_tx(struct uart_port *the_port)
+{
+       struct ioc3_port *port = get_ioc3_port(the_port);
+
+       if (port) {
+               set_notification(port, N_OUTPUT_LOWAT, 1);
+               enable_intrs(port, port->ip_hooks->intr_tx_mt);
+       }
+}
+
+/**
+ * ic3_break_ctl - handle breaks
+ * @port: Port to operate on
+ * @break_state: Break state
+ *
+ */
+static void ic3_break_ctl(struct uart_port *the_port, int break_state)
+{
+}
+
+/**
+ * ic3_startup - Start up the serial port - always return 0 (We're always on)
+ * @port: Port to operate on
+ *
+ */
+static int ic3_startup(struct uart_port *the_port)
+{
+       int retval;
+       struct ioc3_port *port;
+       struct ioc3_card *card_ptr;
+       unsigned long port_flags;
+
+       if (!the_port) {
+               NOT_PROGRESS();
+               return -ENODEV;
+       }
+       port = get_ioc3_port(the_port);
+       if (!port) {
+               NOT_PROGRESS();
+               return -ENODEV;
+       }
+       card_ptr = port->ip_card;
+       port->ip_port = the_port;
+
+       if (!card_ptr) {
+               NOT_PROGRESS();
+               return -ENODEV;
+       }
+
+       /* Start up the serial port */
+       spin_lock_irqsave(&the_port->lock, port_flags);
+       retval = ic3_startup_local(the_port);
+       spin_unlock_irqrestore(&the_port->lock, port_flags);
+       return retval;
+}
+
+/**
+ * ic3_set_termios - set termios stuff
+ * @port: port to operate on
+ * @termios: New settings
+ * @termios: Old
+ *
+ */
+static void
+ic3_set_termios(struct uart_port *the_port,
+               struct termios *termios, struct termios *old_termios)
+{
+       unsigned long port_flags;
+
+       spin_lock_irqsave(&the_port->lock, port_flags);
+       ioc3_change_speed(the_port, termios, old_termios);
+       spin_unlock_irqrestore(&the_port->lock, port_flags);
+}
+
+/**
+ * ic3_request_port - allocate resources for port - no op....
+ * @port: port to operate on
+ *
+ */
+static int ic3_request_port(struct uart_port *port)
+{
+       return 0;
+}
+
+/* Associate the uart functions above - given to serial core */
+static struct uart_ops ioc3_ops = {
+       .tx_empty = ic3_tx_empty,
+       .set_mctrl = ic3_set_mctrl,
+       .get_mctrl = ic3_get_mctrl,
+       .stop_tx = ic3_stop_tx,
+       .start_tx = ic3_start_tx,
+       .stop_rx = ic3_stop_rx,
+       .enable_ms = null_void_function,
+       .break_ctl = ic3_break_ctl,
+       .startup = ic3_startup,
+       .shutdown = ic3_shutdown,
+       .set_termios = ic3_set_termios,
+       .type = ic3_type,
+       .release_port = null_void_function,
+       .request_port = ic3_request_port,
+};
+
+/*
+ * Boot-time initialization code
+ */
+
+static struct uart_driver ioc3_uart = {
+       .owner = THIS_MODULE,
+       .driver_name = "ioc3_serial",
+       .dev_name = DEVICE_NAME,
+       .major = DEVICE_MAJOR,
+       .minor = DEVICE_MINOR,
+       .nr = MAX_LOGICAL_PORTS
+};
+
+/**
+ * ioc3_serial_core_attach - register with serial core
+ *             This is done during pci probing
+ * @is: submodule struct for this
+ * @idd: handle for this card
+ */
+static inline int ioc3_serial_core_attach( struct ioc3_submodule *is,
+                               struct ioc3_driver_data *idd)
+{
+       struct ioc3_port *port;
+       struct uart_port *the_port;
+       struct ioc3_card *card_ptr = idd->data[is->id];
+       int ii, phys_port;
+       struct pci_dev *pdev = idd->pdev;
+
+       DPRINT_CONFIG(("%s: attach pdev 0x%p - card_ptr 0x%p\n",
+                      __FUNCTION__, pdev, (void *)card_ptr));
+
+       if (!card_ptr)
+               return -ENODEV;
+
+       /* once around for each logical port on this card */
+       for (ii = 0; ii < LOGICAL_PORTS_PER_CARD; ii++) {
+               phys_port = GET_PHYSICAL_PORT(ii);
+               the_port = &card_ptr->ic_port[phys_port].
+                               icp_uart_port[GET_LOGICAL_PORT(ii)];
+               port = card_ptr->ic_port[phys_port].icp_port;
+               port->ip_port = the_port;
+
+               DPRINT_CONFIG(("%s: attach the_port 0x%p / port 0x%p [%d/%d]\n",
+                       __FUNCTION__, (void *)the_port, (void *)port,
+                               phys_port, ii));
+
+               /* membase, iobase and mapbase just need to be non-0 */
+               the_port->membase = (unsigned char __iomem *)1;
+               the_port->iobase = (pdev->bus->number << 16) |  ii;
+               the_port->line = (Num_of_ioc3_cards << 2) | ii;
+               the_port->mapbase = 1;
+               the_port->type = PORT_16550A;
+               the_port->fifosize = FIFO_SIZE;
+               the_port->ops = &ioc3_ops;
+               the_port->irq = idd->irq_io;
+               the_port->dev = &pdev->dev;
+
+               if (uart_add_one_port(&ioc3_uart, the_port) < 0) {
+                       printk(KERN_WARNING
+                         "%s: unable to add port %d bus %d\n",
+                              __FUNCTION__, the_port->line, pdev->bus->number);
+               } else {
+                       DPRINT_CONFIG(("IOC3 serial port %d irq %d bus %d\n",
+                         the_port->line, the_port->irq, pdev->bus->number));
+               }
+
+               /* all ports are rs232 for now */
+               if (IS_PHYSICAL_PORT(ii))
+                       ioc3_set_proto(port, PROTO_RS232);
+       }
+       return 0;
+}
+
+/**
+ * ioc3uart_remove - register detach function
+ * @is: submodule struct for this submodule
+ * @idd: ioc3 driver data for this submodule
+ */
+
+static int ioc3uart_remove(struct ioc3_submodule *is,
+                       struct ioc3_driver_data *idd)
+{
+       struct ioc3_card *card_ptr = idd->data[is->id];
+       struct uart_port *the_port;
+       struct ioc3_port *port;
+       int ii;
+
+       if (card_ptr) {
+               for (ii = 0; ii < LOGICAL_PORTS_PER_CARD; ii++) {
+                       the_port = &card_ptr->ic_port[GET_PHYSICAL_PORT(ii)].
+                                       icp_uart_port[GET_LOGICAL_PORT(ii)];
+                       if (the_port)
+                               uart_remove_one_port(&ioc3_uart, the_port);
+                       port = card_ptr->ic_port[GET_PHYSICAL_PORT(ii)].icp_port;
+                       if (port && IS_PHYSICAL_PORT(ii)
+                                       && (GET_PHYSICAL_PORT(ii) == 0)) {
+                               pci_free_consistent(port->ip_idd->pdev,
+                                       TOTAL_RING_BUF_SIZE,
+                                       (void *)port->ip_cpu_ringbuf,
+                                       port->ip_dma_ringbuf);
+                               kfree(port);
+                               card_ptr->ic_port[GET_PHYSICAL_PORT(ii)].
+                                                       icp_port = NULL;
+                       }
+               }
+               kfree(card_ptr);
+               idd->data[is->id] = NULL;
+       }
+       return 0;
+}
+
+/**
+ * ioc3uart_probe - card probe function called from shim driver
+ * @is: submodule struct for this submodule
+ * @idd: ioc3 driver data for this card
+ */
+
+static int __devinit
+ioc3uart_probe(struct ioc3_submodule *is, struct ioc3_driver_data *idd)
+{
+       struct pci_dev *pdev = idd->pdev;
+       struct ioc3_card *card_ptr;
+       int ret = 0;
+       struct ioc3_port *port;
+       struct ioc3_port *ports[PORTS_PER_CARD];
+       int phys_port;
+
+       DPRINT_CONFIG(("%s (0x%p, 0x%p)\n", __FUNCTION__, is, idd));
+
+       card_ptr = kmalloc(sizeof(struct ioc3_card), GFP_KERNEL);
+       if (!card_ptr) {
+               printk(KERN_WARNING "ioc3_attach_one"
+                      ": unable to get memory for the IOC3\n");
+               return -ENOMEM;
+       }
+       memset(card_ptr, 0, sizeof(struct ioc3_card));
+       idd->data[is->id] = card_ptr;
+       Submodule_slot = is->id;
+
+       writel(((UARTA_BASE >> 3) << SIO_CR_SER_A_BASE_SHIFT) |
+               ((UARTB_BASE >> 3) << SIO_CR_SER_B_BASE_SHIFT) |
+               (0xf << SIO_CR_CMD_PULSE_SHIFT), &idd->vma->sio_cr);
+
+       pci_write_config_dword(pdev, PCI_LAT, 0xff00);
+
+       /* Enable serial port mode select generic PIO pins as outputs */
+       ioc3_gpcr_set(idd, GPCR_UARTA_MODESEL | GPCR_UARTB_MODESEL);
+
+       /* Create port structures for each port */
+       for (phys_port = 0; phys_port < PORTS_PER_CARD; phys_port++) {
+               port = kmalloc(sizeof(struct ioc3_port), GFP_KERNEL);
+               if (!port) {
+                       printk(KERN_WARNING
+                              "IOC3 serial memory not available for port\n");
+                       goto out4;
+               }
+               memset(port, 0, sizeof(struct ioc3_port));
+               spin_lock_init(&port->ip_lock);
+
+               /* we need to remember the previous ones, to point back to
+                * them farther down - setting up the ring buffers.
+                */
+               ports[phys_port] = port;
+
+               /* init to something useful */
+               card_ptr->ic_port[phys_port].icp_port = port;
+               port->ip_is = is;
+               port->ip_idd = idd;
+               port->ip_baud = 9600;
+               port->ip_card = card_ptr;
+               port->ip_hooks = &hooks_array[phys_port];
+
+               /* Setup each port */
+               if (phys_port == 0) {
+                       port->ip_serial_regs = &idd->vma->port_a;
+                       port->ip_uart_regs = &idd->vma->sregs.uarta;
+
+                       DPRINT_CONFIG(("%s : Port A ip_serial_regs 0x%p "
+                                      "ip_uart_regs 0x%p\n",
+                                      __FUNCTION__,
+                                      (void *)port->ip_serial_regs,
+                                      (void *)port->ip_uart_regs));
+
+                       /* setup ring buffers */
+                       port->ip_cpu_ringbuf = pci_alloc_consistent(pdev,
+                               TOTAL_RING_BUF_SIZE, &port->ip_dma_ringbuf);
+
+                       BUG_ON(!((((int64_t) port->ip_dma_ringbuf) &
+                                 (TOTAL_RING_BUF_SIZE - 1)) == 0));
+                       port->ip_inring = RING(port, RX_A);
+                       port->ip_outring = RING(port, TX_A);
+                       DPRINT_CONFIG(("%s : Port A ip_cpu_ringbuf 0x%p "
+                                      "ip_dma_ringbuf 0x%p, ip_inring 0x%p "
+                                       "ip_outring 0x%p\n",
+                                      __FUNCTION__,
+                                      (void *)port->ip_cpu_ringbuf,
+                                      (void *)port->ip_dma_ringbuf,
+                                      (void *)port->ip_inring,
+                                      (void *)port->ip_outring));
+               }
+               else {
+                       port->ip_serial_regs = &idd->vma->port_b;
+                       port->ip_uart_regs = &idd->vma->sregs.uartb;
+
+                       DPRINT_CONFIG(("%s : Port B ip_serial_regs 0x%p "
+                                      "ip_uart_regs 0x%p\n",
+                                      __FUNCTION__,
+                                      (void *)port->ip_serial_regs,
+                                      (void *)port->ip_uart_regs));
+
+                       /* share the ring buffers */
+                       port->ip_dma_ringbuf =
+                           ports[phys_port - 1]->ip_dma_ringbuf;
+                       port->ip_cpu_ringbuf =
+                           ports[phys_port - 1]->ip_cpu_ringbuf;
+                       port->ip_inring = RING(port, RX_B);
+                       port->ip_outring = RING(port, TX_B);
+                       DPRINT_CONFIG(("%s : Port B ip_cpu_ringbuf 0x%p "
+                                      "ip_dma_ringbuf 0x%p, ip_inring 0x%p "
+                                       "ip_outring 0x%p\n",
+                                      __FUNCTION__,
+                                      (void *)port->ip_cpu_ringbuf,
+                                      (void *)port->ip_dma_ringbuf,
+                                      (void *)port->ip_inring,
+                                      (void *)port->ip_outring));
+               }
+
+               DPRINT_CONFIG(("%s : port %d [addr 0x%p] card_ptr 0x%p",
+                              __FUNCTION__,
+                              phys_port, (void *)port, (void *)card_ptr));
+               DPRINT_CONFIG((" ip_serial_regs 0x%p ip_uart_regs 0x%p\n",
+                              (void *)port->ip_serial_regs,
+                              (void *)port->ip_uart_regs));
+
+               /* Initialize the hardware for IOC3 */
+               port_init(port);
+
+               DPRINT_CONFIG(("%s: phys_port %d port 0x%p inring 0x%p "
+                              "outring 0x%p\n",
+                              __FUNCTION__,
+                              phys_port, (void *)port,
+                              (void *)port->ip_inring,
+                              (void *)port->ip_outring));
+
+       }
+
+       /* register port with the serial core */
+
+       if ((ret = ioc3_serial_core_attach(is, idd)))
+               goto out4;
+
+       Num_of_ioc3_cards++;
+
+       return ret;
+
+       /* error exits that give back resources */
+out4:
+       kfree(card_ptr);
+       return ret;
+}
+
+static struct ioc3_submodule ioc3uart_submodule = {
+       .name = "IOC3uart",
+       .probe = ioc3uart_probe,
+       .remove = ioc3uart_remove,
+       /* call .intr for both ports initially */
+       .irq_mask = SIO_IR_SA | SIO_IR_SB,
+       .intr = ioc3uart_intr,
+       .owner = THIS_MODULE,
+};
+
+/**
+ * ioc3_detect - module init called,
+ */
+static int __devinit ioc3uart_init(void)
+{
+       int ret;
+
+       /* register with serial core */
+       if ((ret = uart_register_driver(&ioc3_uart)) < 0) {
+               printk(KERN_WARNING
+                      "%s: Couldn't register IOC3 uart serial driver\n",
+                      __FUNCTION__);
+               return ret;
+       }
+       ret = ioc3_register_submodule(&ioc3uart_submodule);
+       if (ret)
+               uart_unregister_driver(&ioc3_uart);
+       return ret;
+}
+
+static void __devexit ioc3uart_exit(void)
+{
+       ioc3_unregister_submodule(&ioc3uart_submodule);
+       uart_unregister_driver(&ioc3_uart);
+}
+
+module_init(ioc3uart_init);
+module_exit(ioc3uart_exit);
+
+MODULE_AUTHOR("Pat Gefre - Silicon Graphics Inc. (SGI) <pfg@sgi.com>");
+MODULE_DESCRIPTION("Serial PCI driver module for SGI IOC3 card");
+MODULE_LICENSE("GPL");
index 13b8d24..d95265b 100644 (file)
@@ -17,4 +17,18 @@ config SGI_IOC4
        If you have an SGI Altix with an IOC4-based
        I/O controller say Y.  Otherwise say N.
 
+config SGI_IOC3
+       tristate "SGI IOC3 Base IO support"
+       depends on (IA64_GENERIC || IA64_SGI_SN2)
+       default m
+       ---help---
+       This option enables basic support for the SGI IOC3-based Base IO
+       controller card.  This option does not enable any specific
+       functions on such a card, but provides necessary infrastructure
+       for other drivers to utilize.
+
+       If you have an SGI Altix with an IOC3-based
+       I/O controller or a PCI IOC3 serial card say Y.
+       Otherwise say N.
+
 endmenu
index c2a2841..2cda011 100644 (file)
@@ -4,3 +4,4 @@
 #
 
 obj-$(CONFIG_SGI_IOC4) += ioc4.o
+obj-$(CONFIG_SGI_IOC3) += ioc3.o
diff --git a/drivers/sn/ioc3.c b/drivers/sn/ioc3.c
new file mode 100644 (file)
index 0000000..aaa009f
--- /dev/null
@@ -0,0 +1,851 @@
+/*
+ * SGI IOC3 master driver and IRQ demuxer
+ *
+ * Copyright (c) 2005 Stanislaw Skowronek <skylark@linux-mips.org>
+ * Heavily based on similar work by:
+ *   Brent Casavant <bcasavan@sgi.com> - IOC4 master driver
+ *   Pat Gefre <pfg@sgi.com> - IOC3 serial port IRQ demuxer
+ */
+
+#include <linux/config.h>
+#include <linux/errno.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/interrupt.h>
+#include <linux/spinlock.h>
+#include <linux/delay.h>
+#include <linux/ioc3.h>
+#include <linux/rwsem.h>
+
+#define IOC3_PCI_SIZE 0x100000
+
+static LIST_HEAD(ioc3_devices);
+static int ioc3_counter;
+static DECLARE_RWSEM(ioc3_devices_rwsem);
+
+static struct ioc3_submodule *ioc3_submodules[IOC3_MAX_SUBMODULES];
+static struct ioc3_submodule *ioc3_ethernet;
+static rwlock_t ioc3_submodules_lock = RW_LOCK_UNLOCKED;
+
+/* NIC probing code */
+
+#define GPCR_MLAN_EN    0x00200000      /* enable MCR to pin 8 */
+
+static inline unsigned mcr_pack(unsigned pulse, unsigned sample)
+{
+       return (pulse << 10) | (sample << 2);
+}
+
+static int nic_wait(struct ioc3_driver_data *idd)
+{
+       volatile unsigned mcr;
+
+        do {
+                mcr = (volatile unsigned)idd->vma->mcr;
+        } while (!(mcr & 2));
+
+        return mcr & 1;
+}
+
+static int nic_reset(struct ioc3_driver_data *idd)
+{
+        int presence;
+       unsigned long flags;
+
+       local_irq_save(flags);
+       idd->vma->mcr = mcr_pack(500, 65);
+       presence = nic_wait(idd);
+       local_irq_restore(flags);
+
+       udelay(500);
+
+        return presence;
+}
+
+static inline int nic_read_bit(struct ioc3_driver_data *idd)
+{
+       int result;
+       unsigned long flags;
+
+       local_irq_save(flags);
+       idd->vma->mcr = mcr_pack(6, 13);
+       result = nic_wait(idd);
+       local_irq_restore(flags);
+
+       udelay(500);
+
+       return result;
+}
+
+static inline void nic_write_bit(struct ioc3_driver_data *idd, int bit)
+{
+       if (bit)
+               idd->vma->mcr = mcr_pack(6, 110);
+       else
+               idd->vma->mcr = mcr_pack(80, 30);
+
+       nic_wait(idd);
+}
+
+static unsigned nic_read_byte(struct ioc3_driver_data *idd)
+{
+       unsigned result = 0;
+       int i;
+
+       for (i = 0; i < 8; i++)
+               result = (result >> 1) | (nic_read_bit(idd) << 7);
+
+       return result;
+}
+
+static void nic_write_byte(struct ioc3_driver_data *idd, int byte)
+{
+       int i, bit;
+
+       for (i = 8; i; i--) {
+               bit = byte & 1;
+               byte >>= 1;
+
+               nic_write_bit(idd, bit);
+       }
+}
+
+static unsigned long
+nic_find(struct ioc3_driver_data *idd, int *last, unsigned long addr)
+{
+       int a, b, index, disc;
+
+       nic_reset(idd);
+
+       /* Search ROM.  */
+       nic_write_byte(idd, 0xF0);
+
+       /* Algorithm from ``Book of iButton Standards''.  */
+       for (index = 0, disc = 0; index < 64; index++) {
+               a = nic_read_bit(idd);
+               b = nic_read_bit(idd);
+
+               if (a && b) {
+                       printk(KERN_WARNING "IOC3 NIC search failed.\n");
+                       *last = 0;
+                       return 0;
+               }
+
+               if (!a && !b) {
+                       if (index == *last) {
+                               addr |= 1UL << index;
+                       } else if (index > *last) {
+                               addr &= ~(1UL << index);
+                               disc = index;
+                       } else if ((addr & (1UL << index)) == 0)
+                               disc = index;
+                       nic_write_bit(idd, (addr>>index)&1);
+                       continue;
+               } else {
+                       if (a)
+                               addr |= 1UL << index;
+                       else
+                               addr &= ~(1UL << index);
+                       nic_write_bit(idd, a);
+                       continue;
+               }
+       }
+       *last = disc;
+       return addr;
+}
+
+static void nic_addr(struct ioc3_driver_data *idd, unsigned long addr)
+{
+       int index;
+
+       nic_reset(idd);
+       nic_write_byte(idd, 0xF0);
+       for (index = 0; index < 64; index++) {
+               nic_read_bit(idd);
+               nic_read_bit(idd);
+               nic_write_bit(idd, (addr>>index)&1);
+       }
+}
+
+static void crc16_byte(unsigned int *crc, unsigned char db)
+{
+       int i;
+
+       for(i=0;i<8;i++) {
+               *crc <<= 1;
+               if((db^(*crc>>16)) & 1)
+                       *crc ^= 0x8005;
+               db >>= 1;
+       }
+       *crc &= 0xFFFF;
+}
+
+static unsigned int crc16_area(unsigned char *dbs, int size, unsigned int crc)
+{
+       while(size--)
+               crc16_byte(&crc, *(dbs++));
+       return crc;
+}
+
+static void crc8_byte(unsigned int *crc, unsigned char db)
+{
+       int i,f;
+
+       for(i=0;i<8;i++) {
+               f = (*crc ^ db) & 1;
+               *crc >>= 1;
+               db >>= 1;
+               if(f)
+                       *crc ^= 0x8c;
+       }
+       *crc &= 0xff;
+}
+
+static unsigned int crc8_addr(unsigned long addr)
+{
+       int i;
+       unsigned int crc = 0x00;
+
+       for(i=0;i<8;i++)
+               crc8_byte(&crc, addr>>(i<<3));
+       return crc;
+}
+
+static void
+read_redir_page(struct ioc3_driver_data *idd, unsigned long addr, int page,
+                       unsigned char *redir, unsigned char *data)
+{
+       int loops = 16, i;
+
+       while(redir[page] != 0xFF) {
+               page = redir[page]^0xFF;
+               loops--;
+               if(loops<0) {
+                       printk(KERN_ERR "IOC3: NIC circular redirection\n");
+                       return;
+               }
+       }
+       loops = 3;
+       while(loops>0) {
+               nic_addr(idd, addr);
+               nic_write_byte(idd, 0xF0);
+               nic_write_byte(idd, (page << 5) & 0xE0);
+               nic_write_byte(idd, (page >> 3) & 0x1F);
+               for(i=0;i<0x20;i++)
+                       data[i] = nic_read_byte(idd);
+               if(crc16_area(data, 0x20, 0x0000) == 0x800d)
+                       return;
+               loops--;
+       }
+       printk(KERN_ERR "IOC3: CRC error in data page\n");
+       for(i=0;i<0x20;i++)
+               data[i] = 0x00;
+}
+
+static void
+read_redir_map(struct ioc3_driver_data *idd, unsigned long addr,
+                                        unsigned char *redir)
+{
+       int i,j,loops = 3,crc_ok;
+       unsigned int crc;
+
+       while(loops>0) {
+               crc_ok = 1;
+               nic_addr(idd, addr);
+               nic_write_byte(idd, 0xAA);
+               nic_write_byte(idd, 0x00);
+               nic_write_byte(idd, 0x01);
+               for(i=0;i<64;i+=8) {
+                       for(j=0;j<8;j++)
+                               redir[i+j] = nic_read_byte(idd);
+                       crc = crc16_area(redir+i, 8, (i==0)?0x8707:0x0000);
+                       crc16_byte(&crc, nic_read_byte(idd));
+                       crc16_byte(&crc, nic_read_byte(idd));
+                       if(crc != 0x800d)
+                               crc_ok = 0;
+               }
+               if(crc_ok)
+                       return;
+               loops--;
+       }
+       printk(KERN_ERR "IOC3: CRC error in redirection page\n");
+       for(i=0;i<64;i++)
+               redir[i] = 0xFF;
+}
+
+static void read_nic(struct ioc3_driver_data *idd, unsigned long addr)
+{
+       unsigned char redir[64];
+       unsigned char data[64],part[32];
+       int i,j;
+
+       /* read redirections */
+       read_redir_map(idd, addr, redir);
+       /* read data pages */
+       read_redir_page(idd, addr, 0, redir, data);
+       read_redir_page(idd, addr, 1, redir, data+32);
+       /* assemble the part # */
+       j=0;
+       for(i=0;i<19;i++)
+               if(data[i+11] != ' ')
+                       part[j++] = data[i+11];
+       for(i=0;i<6;i++)
+               if(data[i+32] != ' ')
+                       part[j++] = data[i+32];
+       part[j] = 0;
+       /* skip Octane power supplies */
+       if(!strncmp(part, "060-0035-", 9))
+               return;
+       if(!strncmp(part, "060-0038-", 9))
+               return;
+       strcpy(idd->nic_part, part);
+       /* assemble the serial # */
+       j=0;
+       for(i=0;i<10;i++)
+               if(data[i+1] != ' ')
+                       idd->nic_serial[j++] = data[i+1];
+       idd->nic_serial[j] = 0;
+}
+
+static void read_mac(struct ioc3_driver_data *idd, unsigned long addr)
+{
+       int i, loops = 3;
+       unsigned char data[13];
+
+       while(loops>0) {
+               nic_addr(idd, addr);
+               nic_write_byte(idd, 0xF0);
+               nic_write_byte(idd, 0x00);
+               nic_write_byte(idd, 0x00);
+               nic_read_byte(idd);
+               for(i=0;i<13;i++)
+                       data[i] = nic_read_byte(idd);
+               if(crc16_area(data, 13, 0x0000) == 0x800d) {
+                       for(i=10;i>4;i--)
+                               idd->nic_mac[10-i] = data[i];
+                       return;
+               }
+               loops--;
+       }
+       printk(KERN_ERR "IOC3: CRC error in MAC address\n");
+       for(i=0;i<6;i++)
+               idd->nic_mac[i] = 0x00;
+}
+
+static void probe_nic(struct ioc3_driver_data *idd)
+{
+        int save = 0, loops = 3;
+        unsigned long first, addr;
+
+        idd->vma->gpcr_s = GPCR_MLAN_EN;
+
+        while(loops>0) {
+                idd->nic_part[0] = 0;
+                idd->nic_serial[0] = 0;
+                addr = first = nic_find(idd, &save, 0);
+                if(!first)
+                        return;
+                while(1) {
+                        if(crc8_addr(addr))
+                                break;
+                        else {
+                                switch(addr & 0xFF) {
+                                case 0x0B:
+                                        read_nic(idd, addr);
+                                        break;
+                                case 0x09:
+                                case 0x89:
+                                case 0x91:
+                                        read_mac(idd, addr);
+                                        break;
+                                }
+                        }
+                        addr = nic_find(idd, &save, addr);
+                        if(addr == first)
+                                return;
+                }
+                loops--;
+        }
+        printk(KERN_ERR "IOC3: CRC error in NIC address\n");
+}
+
+/* Interrupts */
+
+static inline void
+write_ireg(struct ioc3_driver_data *idd, uint32_t val, int which)
+{
+       unsigned long flags;
+
+       spin_lock_irqsave(&idd->ir_lock, flags);
+       switch (which) {
+       case IOC3_W_IES:
+               writel(val, &idd->vma->sio_ies);
+               break;
+       case IOC3_W_IEC:
+               writel(val, &idd->vma->sio_iec);
+               break;
+       }
+       spin_unlock_irqrestore(&idd->ir_lock, flags);
+}
+static inline uint32_t get_pending_intrs(struct ioc3_driver_data *idd)
+{
+       unsigned long flag;
+       uint32_t intrs = 0;
+
+       spin_lock_irqsave(&idd->ir_lock, flag);
+       intrs = readl(&idd->vma->sio_ir);
+       intrs &= readl(&idd->vma->sio_ies);
+       spin_unlock_irqrestore(&idd->ir_lock, flag);
+       return intrs;
+}
+
+static irqreturn_t ioc3_intr_io(int irq, void *arg, struct pt_regs *regs)
+{
+       unsigned long flags;
+       struct ioc3_driver_data *idd = (struct ioc3_driver_data *)arg;
+       int handled = 1, id;
+       unsigned int pending;
+
+       read_lock_irqsave(&ioc3_submodules_lock, flags);
+
+       if(idd->dual_irq && idd->vma->eisr) {
+               /* send Ethernet IRQ to the driver */
+               if(ioc3_ethernet && idd->active[ioc3_ethernet->id] &&
+                                               ioc3_ethernet->intr) {
+                       handled = handled && !ioc3_ethernet->intr(ioc3_ethernet,
+                                                       idd, 0, regs);
+               }
+       }
+       pending = get_pending_intrs(idd);       /* look at the IO IRQs */
+
+       for(id=0;id<IOC3_MAX_SUBMODULES;id++) {
+               if(idd->active[id] && ioc3_submodules[id]
+                               && (pending & ioc3_submodules[id]->irq_mask)
+                               && ioc3_submodules[id]->intr) {
+                       write_ireg(idd, ioc3_submodules[id]->irq_mask,
+                                                       IOC3_W_IEC);
+                       if(!ioc3_submodules[id]->intr(ioc3_submodules[id],
+                                  idd, pending & ioc3_submodules[id]->irq_mask,
+                                       regs))
+                               pending &= ~ioc3_submodules[id]->irq_mask;
+                       if (ioc3_submodules[id]->reset_mask)
+                               write_ireg(idd, ioc3_submodules[id]->irq_mask,
+                                                       IOC3_W_IES);
+               }
+       }
+       read_unlock_irqrestore(&ioc3_submodules_lock, flags);
+       if(pending) {
+               printk(KERN_WARNING
+                 "IOC3: Pending IRQs 0x%08x discarded and disabled\n",pending);
+               write_ireg(idd, pending, IOC3_W_IEC);
+               handled = 1;
+       }
+       return handled?IRQ_HANDLED:IRQ_NONE;
+}
+
+static irqreturn_t ioc3_intr_eth(int irq, void *arg, struct pt_regs *regs)
+{
+       unsigned long flags;
+       struct ioc3_driver_data *idd = (struct ioc3_driver_data *)arg;
+       int handled = 1;
+
+       if(!idd->dual_irq)
+               return IRQ_NONE;
+       read_lock_irqsave(&ioc3_submodules_lock, flags);
+       if(ioc3_ethernet && idd->active[ioc3_ethernet->id]
+                               && ioc3_ethernet->intr)
+               handled = handled && !ioc3_ethernet->intr(ioc3_ethernet, idd, 0,
+                                                               regs);
+       read_unlock_irqrestore(&ioc3_submodules_lock, flags);
+       return handled?IRQ_HANDLED:IRQ_NONE;
+}
+
+void ioc3_enable(struct ioc3_submodule *is,
+                               struct ioc3_driver_data *idd, unsigned int irqs)
+{
+       write_ireg(idd, irqs & is->irq_mask, IOC3_W_IES);
+}
+
+void ioc3_ack(struct ioc3_submodule *is, struct ioc3_driver_data *idd,
+                               unsigned int irqs)
+{
+       writel(irqs & is->irq_mask, &idd->vma->sio_ir);
+}
+
+void ioc3_disable(struct ioc3_submodule *is,
+                               struct ioc3_driver_data *idd, unsigned int irqs)
+{
+       write_ireg(idd, irqs & is->irq_mask, IOC3_W_IEC);
+}
+
+void ioc3_gpcr_set(struct ioc3_driver_data *idd, unsigned int val)
+{
+       unsigned long flags;
+       spin_lock_irqsave(&idd->gpio_lock, flags);
+       writel(val, &idd->vma->gpcr_s);
+       spin_unlock_irqrestore(&idd->gpio_lock, flags);
+}
+
+/* Keep it simple, stupid! */
+static int find_slot(void **tab, int max)
+{
+       int i;
+       for(i=0;i<max;i++)
+               if(!(tab[i]))
+                       return i;
+       return -1;
+}
+
+/* Register an IOC3 submodule */
+int ioc3_register_submodule(struct ioc3_submodule *is)
+{
+       struct ioc3_driver_data *idd;
+       int alloc_id;
+       unsigned long flags;
+
+       write_lock_irqsave(&ioc3_submodules_lock, flags);
+       alloc_id = find_slot((void **)ioc3_submodules, IOC3_MAX_SUBMODULES);
+       if(alloc_id != -1) {
+               ioc3_submodules[alloc_id] = is;
+               if(is->ethernet) {
+                       if(ioc3_ethernet==NULL)
+                               ioc3_ethernet=is;
+                       else
+                               printk(KERN_WARNING
+                                 "IOC3 Ethernet module already registered!\n");
+               }
+       }
+       write_unlock_irqrestore(&ioc3_submodules_lock, flags);
+
+       if(alloc_id == -1) {
+               printk(KERN_WARNING "Increase IOC3_MAX_SUBMODULES!\n");
+               return -ENOMEM;
+       }
+
+       is->id=alloc_id;
+
+       /* Initialize submodule for each IOC3 */
+       if (!is->probe)
+               return 0;
+
+       down_read(&ioc3_devices_rwsem);
+       list_for_each_entry(idd, &ioc3_devices, list) {
+               /* set to 1 for IRQs in probe */
+               idd->active[alloc_id] = 1;
+               idd->active[alloc_id] = !is->probe(is, idd);
+       }
+       up_read(&ioc3_devices_rwsem);
+
+       return 0;
+}
+
+/* Unregister an IOC3 submodule */
+void ioc3_unregister_submodule(struct ioc3_submodule *is)
+{
+       struct ioc3_driver_data *idd;
+       unsigned long flags;
+
+       write_lock_irqsave(&ioc3_submodules_lock, flags);
+       if(ioc3_submodules[is->id]==is)
+               ioc3_submodules[is->id]=NULL;
+       else
+               printk(KERN_WARNING
+                       "IOC3 submodule %s has wrong ID.\n",is->name);
+       if(ioc3_ethernet==is)
+               ioc3_ethernet = NULL;
+       write_unlock_irqrestore(&ioc3_submodules_lock, flags);
+
+       /* Remove submodule for each IOC3 */
+       down_read(&ioc3_devices_rwsem);
+       list_for_each_entry(idd, &ioc3_devices, list)
+               if(idd->active[is->id]) {
+                       if(is->remove)
+                               if(is->remove(is, idd))
+                                       printk(KERN_WARNING
+                                              "%s: IOC3 submodule %s remove failed "
+                                              "for pci_dev %s.\n",
+                                              __FUNCTION__, module_name(is->owner),
+                                              pci_name(idd->pdev));
+                       idd->active[is->id] = 0;
+                       if(is->irq_mask)
+                               write_ireg(idd, is->irq_mask, IOC3_W_IEC);
+               }
+       up_read(&ioc3_devices_rwsem);
+}
+
+/*********************
+ * Device management *
+ *********************/
+
+static char *
+ioc3_class_names[]={"unknown", "IP27 BaseIO", "IP30 system", "MENET 1/2/3",
+                       "MENET 4", "CADduo", "Altix Serial"};
+
+static int ioc3_class(struct ioc3_driver_data *idd)
+{
+       int res = IOC3_CLASS_NONE;
+       /* NIC-based logic */
+       if(!strncmp(idd->nic_part, "030-0891-", 9))
+               res = IOC3_CLASS_BASE_IP30;
+       if(!strncmp(idd->nic_part, "030-1155-", 9))
+               res = IOC3_CLASS_CADDUO;
+       if(!strncmp(idd->nic_part, "030-1657-", 9))
+               res = IOC3_CLASS_SERIAL;
+       if(!strncmp(idd->nic_part, "030-1664-", 9))
+               res = IOC3_CLASS_SERIAL;
+       /* total random heuristics */
+#ifdef CONFIG_SGI_IP27
+       if(!idd->nic_part[0])
+               res = IOC3_CLASS_BASE_IP27;
+#endif
+       /* print educational message */
+       printk(KERN_INFO "IOC3 part: [%s], serial: [%s] => class %s\n",
+                       idd->nic_part, idd->nic_serial, ioc3_class_names[res]);
+       return res;
+}
+/* Adds a new instance of an IOC3 card */
+static int ioc3_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
+{
+       struct ioc3_driver_data *idd;
+       uint32_t pcmd;
+       int ret, id;
+
+       /* Enable IOC3 and take ownership of it */
+       if ((ret = pci_enable_device(pdev))) {
+               printk(KERN_WARNING
+                      "%s: Failed to enable IOC3 device for pci_dev %s.\n",
+                      __FUNCTION__, pci_name(pdev));
+               goto out;
+       }
+       pci_set_master(pdev);
+
+#ifdef USE_64BIT_DMA
+        ret = pci_set_dma_mask(pdev, 0xffffffffffffffffULL);
+        if (!ret) {
+                ret = pci_set_consistent_dma_mask(pdev, 0xffffffffffffffffULL);
+                if (ret < 0) {
+                        printk(KERN_WARNING "%s: Unable to obtain 64 bit DMA "
+                               "for consistent allocations\n",
+                               __FUNCTION__);
+                }
+       }
+#endif
+
+       /* Set up per-IOC3 data */
+       idd = kmalloc(sizeof(struct ioc3_driver_data), GFP_KERNEL);
+       if (!idd) {
+               printk(KERN_WARNING
+                      "%s: Failed to allocate IOC3 data for pci_dev %s.\n",
+                      __FUNCTION__, pci_name(pdev));
+               ret = -ENODEV;
+               goto out_idd;
+       }
+       memset(idd, 0, sizeof(struct ioc3_driver_data));
+       spin_lock_init(&idd->ir_lock);
+       spin_lock_init(&idd->gpio_lock);
+       idd->pdev = pdev;
+
+       /* Map all IOC3 registers.  These are shared between subdevices
+        * so the main IOC3 module manages them.
+        */
+       idd->pma = pci_resource_start(pdev, 0);
+       if (!idd->pma) {
+               printk(KERN_WARNING
+                      "%s: Unable to find IOC3 resource "
+                      "for pci_dev %s.\n",
+                      __FUNCTION__, pci_name(pdev));
+               ret = -ENODEV;
+               goto out_pci;
+       }
+       if (!request_region(idd->pma, IOC3_PCI_SIZE, "ioc3")) {
+               printk(KERN_WARNING
+                      "%s: Unable to request IOC3 region "
+                      "for pci_dev %s.\n",
+                      __FUNCTION__, pci_name(pdev));
+               ret = -ENODEV;
+               goto out_pci;
+       }
+       idd->vma = ioremap(idd->pma, IOC3_PCI_SIZE);
+       if (!idd->vma) {
+               printk(KERN_WARNING
+                      "%s: Unable to remap IOC3 region "
+                      "for pci_dev %s.\n",
+                      __FUNCTION__, pci_name(pdev));
+               ret = -ENODEV;
+               goto out_misc_region;
+       }
+
+       /* Track PCI-device specific data */
+       pci_set_drvdata(pdev, idd);
+       down_write(&ioc3_devices_rwsem);
+       list_add(&idd->list, &ioc3_devices);
+       idd->id = ioc3_counter++;
+       up_write(&ioc3_devices_rwsem);
+
+       idd->gpdr_shadow = idd->vma->gpdr;
+
+       /* Read IOC3 NIC contents */
+       probe_nic(idd);
+
+       /* Detect IOC3 class */
+       idd->class = ioc3_class(idd);
+
+       /* Initialize IOC3 */
+       pci_read_config_dword(pdev, PCI_COMMAND, &pcmd);
+       pci_write_config_dword(pdev, PCI_COMMAND,
+                               pcmd | PCI_COMMAND_MEMORY |
+                               PCI_COMMAND_PARITY | PCI_COMMAND_SERR |
+                               PCI_SCR_DROP_MODE_EN);
+
+       write_ireg(idd, ~0, IOC3_W_IEC);
+       writel(~0, &idd->vma->sio_ir);
+
+       /* Set up IRQs */
+       if(idd->class == IOC3_CLASS_BASE_IP30
+                               || idd->class == IOC3_CLASS_BASE_IP27) {
+               writel(0, &idd->vma->eier);
+               writel(~0, &idd->vma->eisr);
+
+               idd->dual_irq = 1;
+               if (!request_irq(pdev->irq, ioc3_intr_eth, SA_SHIRQ,
+                                "ioc3-eth", (void *)idd)) {
+                       idd->irq_eth = pdev->irq;
+               } else {
+                       printk(KERN_WARNING
+                              "%s : request_irq fails for IRQ 0x%x\n ",
+                              __FUNCTION__, pdev->irq);
+               }
+               if (!request_irq(pdev->irq+2, ioc3_intr_io, SA_SHIRQ,
+                                "ioc3-io", (void *)idd)) {
+                       idd->irq_io = pdev->irq+2;
+               } else {
+                       printk(KERN_WARNING
+                              "%s : request_irq fails for IRQ 0x%x\n ",
+                              __FUNCTION__, pdev->irq+2);
+               }
+       } else {
+               if (!request_irq(pdev->irq, ioc3_intr_io, SA_SHIRQ,
+                                "ioc3", (void *)idd)) {
+                       idd->irq_io = pdev->irq;
+               } else {
+                       printk(KERN_WARNING
+                              "%s : request_irq fails for IRQ 0x%x\n ",
+                              __FUNCTION__, pdev->irq);
+               }
+       }
+
+       /* Add this IOC3 to all submodules */
+       read_lock(&ioc3_submodules_lock);
+       for(id=0;id<IOC3_MAX_SUBMODULES;id++)
+               if(ioc3_submodules[id] && ioc3_submodules[id]->probe) {
+                       idd->active[id] = 1;
+                       idd->active[id] = !ioc3_submodules[id]->probe
+                                               (ioc3_submodules[id], idd);
+               }
+       read_unlock(&ioc3_submodules_lock);
+
+       printk(KERN_INFO "IOC3 Master Driver loaded for %s\n", pci_name(pdev));
+
+       return 0;
+
+out_misc_region:
+       release_region(idd->pma, IOC3_PCI_SIZE);
+out_pci:
+       kfree(idd);
+out_idd:
+       pci_disable_device(pdev);
+out:
+       return ret;
+}
+
+/* Removes a particular instance of an IOC3 card. */
+static void ioc3_remove(struct pci_dev *pdev)
+{
+       int id;
+       struct ioc3_driver_data *idd;
+
+       idd = pci_get_drvdata(pdev);
+
+       /* Remove this IOC3 from all submodules */
+       read_lock(&ioc3_submodules_lock);
+       for(id=0;id<IOC3_MAX_SUBMODULES;id++)
+               if(idd->active[id]) {
+                       if(ioc3_submodules[id] && ioc3_submodules[id]->remove)
+                               if(ioc3_submodules[id]->remove(ioc3_submodules[id],
+                                                               idd))
+                                       printk(KERN_WARNING
+                                              "%s: IOC3 submodule 0x%s remove failed "
+                                              "for pci_dev %s.\n",
+                                               __FUNCTION__,
+                                               module_name(ioc3_submodules[id]->owner),
+                                               pci_name(pdev));
+                       idd->active[id] = 0;
+               }
+       read_unlock(&ioc3_submodules_lock);
+
+       /* Clear and disable all IRQs */
+       write_ireg(idd, ~0, IOC3_W_IEC);
+       writel(~0, &idd->vma->sio_ir);
+
+       /* Release resources */
+       free_irq(idd->irq_io, (void *)idd);
+       if(idd->dual_irq)
+               free_irq(idd->irq_eth, (void *)idd);
+       iounmap(idd->vma);
+       release_region(idd->pma, IOC3_PCI_SIZE);
+
+       /* Disable IOC3 and relinquish */
+       pci_disable_device(pdev);
+
+       /* Remove and free driver data */
+       down_write(&ioc3_devices_rwsem);
+       list_del(&idd->list);
+       up_write(&ioc3_devices_rwsem);
+       kfree(idd);
+}
+
+static struct pci_device_id ioc3_id_table[] = {
+       {PCI_VENDOR_ID_SGI, PCI_DEVICE_ID_SGI_IOC3, PCI_ANY_ID, PCI_ANY_ID},
+       {0}
+};
+
+static struct pci_driver ioc3_driver = {
+       .name = "IOC3",
+       .id_table = ioc3_id_table,
+       .probe = ioc3_probe,
+       .remove = ioc3_remove,
+};
+
+MODULE_DEVICE_TABLE(pci, ioc3_id_table);
+
+/*********************
+ * Module management *
+ *********************/
+
+/* Module load */
+static int __devinit ioc3_init(void)
+{
+       if (ia64_platform_is("sn2"))
+               return pci_register_driver(&ioc3_driver);
+       return 0;
+}
+
+/* Module unload */
+static void __devexit ioc3_exit(void)
+{
+       pci_unregister_driver(&ioc3_driver);
+}
+
+module_init(ioc3_init);
+module_exit(ioc3_exit);
+
+MODULE_AUTHOR("Stanislaw Skowronek <skylark@linux-mips.org>");
+MODULE_DESCRIPTION("PCI driver for SGI IOC3");
+MODULE_LICENSE("GPL");
+
+EXPORT_SYMBOL(ioc3_register_submodule);
+EXPORT_SYMBOL(ioc3_unregister_submodule);
+EXPORT_SYMBOL(ioc3_ack);
+EXPORT_SYMBOL(ioc3_gpcr_set);
+EXPORT_SYMBOL(ioc3_disable);
+EXPORT_SYMBOL(ioc3_enable);
diff --git a/include/asm-ia64/sn/ioc3.h b/include/asm-ia64/sn/ioc3.h
new file mode 100644 (file)
index 0000000..95ed6cc
--- /dev/null
@@ -0,0 +1,241 @@
+/*
+ * Copyright (C) 2005 Silicon Graphics, Inc.
+ */
+#ifndef IA64_SN_IOC3_H
+#define IA64_SN_IOC3_H
+
+/* serial port register map */
+struct ioc3_serialregs {
+       uint32_t sscr;
+       uint32_t stpir;
+       uint32_t stcir;
+       uint32_t srpir;
+       uint32_t srcir;
+       uint32_t srtr;
+       uint32_t shadow;
+};
+
+/* SUPERIO uart register map */
+struct ioc3_uartregs {
+       char iu_lcr;
+       union {
+               char iir;       /* read only */
+               char fcr;       /* write only */
+       } u3;
+       union {
+               char ier;       /* DLAB == 0 */
+               char dlm;       /* DLAB == 1 */
+       } u2;
+       union {
+               char rbr;       /* read only, DLAB == 0 */
+               char thr;       /* write only, DLAB == 0 */
+               char dll;       /* DLAB == 1 */
+       } u1;
+       char iu_scr;
+       char iu_msr;
+       char iu_lsr;
+       char iu_mcr;
+};
+
+#define iu_rbr u1.rbr
+#define iu_thr u1.thr
+#define iu_dll u1.dll
+#define iu_ier u2.ier
+#define iu_dlm u2.dlm
+#define iu_iir u3.iir
+#define iu_fcr u3.fcr
+
+struct ioc3_sioregs {
+       char fill[0x170];
+       struct ioc3_uartregs uartb;
+       struct ioc3_uartregs uarta;
+};
+
+/* PCI IO/mem space register map */
+struct ioc3 {
+       uint32_t pci_id;
+       uint32_t pci_scr;
+       uint32_t pci_rev;
+       uint32_t pci_lat;
+       uint32_t pci_addr;
+       uint32_t pci_err_addr_l;
+       uint32_t pci_err_addr_h;
+
+       uint32_t sio_ir;
+       /* these registers are read-only for general kernel code. To
+        * modify them use the functions in ioc3.c
+        */
+       uint32_t sio_ies;
+       uint32_t sio_iec;
+       uint32_t sio_cr;
+       uint32_t int_out;
+       uint32_t mcr;
+       uint32_t gpcr_s;
+       uint32_t gpcr_c;
+       uint32_t gpdr;
+       uint32_t gppr[9];
+       char fill[0x4c];
+
+       /* serial port registers */
+       uint32_t sbbr_h;
+       uint32_t sbbr_l;
+
+       struct ioc3_serialregs port_a;
+       struct ioc3_serialregs port_b;
+       char fill1[0x1ff10];
+       /* superio registers */
+       struct ioc3_sioregs sregs;
+};
+
+/* These don't exist on the ioc3 serial card... */
+#define eier   fill1[8]
+#define eisr   fill1[4]
+
+#define PCI_LAT                        0xc     /* Latency Timer */
+#define PCI_SCR_DROP_MODE_EN   0x00008000 /* drop pios on parity err */
+#define UARTA_BASE             0x178
+#define UARTB_BASE             0x170
+
+
+/* bitmasks for serial RX status byte */
+#define RXSB_OVERRUN           0x01    /* char(s) lost */
+#define RXSB_PAR_ERR           0x02    /* parity error */
+#define RXSB_FRAME_ERR         0x04    /* framing error */
+#define RXSB_BREAK             0x08    /* break character */
+#define RXSB_CTS               0x10    /* state of CTS */
+#define RXSB_DCD               0x20    /* state of DCD */
+#define RXSB_MODEM_VALID       0x40    /* DCD, CTS and OVERRUN are valid */
+#define RXSB_DATA_VALID                0x80    /* FRAME_ERR PAR_ERR & BREAK valid */
+
+/* bitmasks for serial TX control byte */
+#define TXCB_INT_WHEN_DONE     0x20    /* interrupt after this byte is sent */
+#define TXCB_INVALID           0x00    /* byte is invalid */
+#define TXCB_VALID             0x40    /* byte is valid */
+#define TXCB_MCR               0x80    /* data<7:0> to modem cntrl register */
+#define TXCB_DELAY             0xc0    /* delay data<7:0> mSec */
+
+/* bitmasks for SBBR_L */
+#define SBBR_L_SIZE            0x00000001      /* 0 1KB rings, 1 4KB rings */
+
+/* bitmasks for SSCR_<A:B> */
+#define SSCR_RX_THRESHOLD      0x000001ff      /* hiwater mark */
+#define SSCR_TX_TIMER_BUSY     0x00010000      /* TX timer in progress */
+#define SSCR_HFC_EN            0x00020000      /* h/w flow cntrl enabled */
+#define SSCR_RX_RING_DCD       0x00040000      /* postRX record on delta-DCD */
+#define SSCR_RX_RING_CTS       0x00080000      /* postRX record on delta-CTS */
+#define SSCR_HIGH_SPD          0x00100000      /* 4X speed */
+#define SSCR_DIAG              0x00200000      /* bypass clock divider */
+#define SSCR_RX_DRAIN          0x08000000      /* drain RX buffer to memory */
+#define SSCR_DMA_EN            0x10000000      /* enable ring buffer DMA */
+#define SSCR_DMA_PAUSE         0x20000000      /* pause DMA */
+#define SSCR_PAUSE_STATE       0x40000000      /* set when PAUSE takes effect*/
+#define SSCR_RESET             0x80000000      /* reset DMA channels */
+
+/* all producer/comsumer pointers are the same bitfield */
+#define PROD_CONS_PTR_4K       0x00000ff8      /* for 4K buffers */
+#define PROD_CONS_PTR_1K       0x000003f8      /* for 1K buffers */
+#define PROD_CONS_PTR_OFF      3
+
+/* bitmasks for SRCIR_<A:B> */
+#define SRCIR_ARM              0x80000000      /* arm RX timer */
+
+/* bitmasks for SHADOW_<A:B> */
+#define SHADOW_DR              0x00000001      /* data ready */
+#define SHADOW_OE              0x00000002      /* overrun error */
+#define SHADOW_PE              0x00000004      /* parity error */
+#define SHADOW_FE              0x00000008      /* framing error */
+#define SHADOW_BI              0x00000010      /* break interrupt */
+#define SHADOW_THRE            0x00000020      /* transmit holding reg empty */
+#define SHADOW_TEMT            0x00000040      /* transmit shift reg empty */
+#define SHADOW_RFCE            0x00000080      /* char in RX fifo has error */
+#define SHADOW_DCTS            0x00010000      /* delta clear to send */
+#define SHADOW_DDCD            0x00080000      /* delta data carrier detect */
+#define SHADOW_CTS             0x00100000      /* clear to send */
+#define SHADOW_DCD             0x00800000      /* data carrier detect */
+#define SHADOW_DTR             0x01000000      /* data terminal ready */
+#define SHADOW_RTS             0x02000000      /* request to send */
+#define SHADOW_OUT1            0x04000000      /* 16550 OUT1 bit */
+#define SHADOW_OUT2            0x08000000      /* 16550 OUT2 bit */
+#define SHADOW_LOOP            0x10000000      /* loopback enabled */
+
+/* bitmasks for SRTR_<A:B> */
+#define SRTR_CNT               0x00000fff      /* reload value for RX timer */
+#define SRTR_CNT_VAL           0x0fff0000      /* current value of RX timer */
+#define SRTR_CNT_VAL_SHIFT     16
+#define SRTR_HZ                        16000           /* SRTR clock frequency */
+
+/* bitmasks for SIO_IR, SIO_IEC and SIO_IES  */
+#define SIO_IR_SA_TX_MT                0x00000001      /* Serial port A TX empty */
+#define SIO_IR_SA_RX_FULL      0x00000002      /* port A RX buf full */
+#define SIO_IR_SA_RX_HIGH      0x00000004      /* port A RX hiwat */
+#define SIO_IR_SA_RX_TIMER     0x00000008      /* port A RX timeout */
+#define SIO_IR_SA_DELTA_DCD    0x00000010      /* port A delta DCD */
+#define SIO_IR_SA_DELTA_CTS    0x00000020      /* port A delta CTS */
+#define SIO_IR_SA_INT          0x00000040      /* port A pass-thru intr */
+#define SIO_IR_SA_TX_EXPLICIT  0x00000080      /* port A explicit TX thru */
+#define SIO_IR_SA_MEMERR       0x00000100      /* port A PCI error */
+#define SIO_IR_SB_TX_MT                0x00000200
+#define SIO_IR_SB_RX_FULL      0x00000400
+#define SIO_IR_SB_RX_HIGH      0x00000800
+#define SIO_IR_SB_RX_TIMER     0x00001000
+#define SIO_IR_SB_DELTA_DCD    0x00002000
+#define SIO_IR_SB_DELTA_CTS    0x00004000
+#define SIO_IR_SB_INT          0x00008000
+#define SIO_IR_SB_TX_EXPLICIT  0x00010000
+#define SIO_IR_SB_MEMERR       0x00020000
+#define SIO_IR_PP_INT          0x00040000      /* P port pass-thru intr */
+#define SIO_IR_PP_INTA         0x00080000      /* PP context A thru */
+#define SIO_IR_PP_INTB         0x00100000      /* PP context B thru */
+#define SIO_IR_PP_MEMERR       0x00200000      /* PP PCI error */
+#define SIO_IR_KBD_INT         0x00400000      /* kbd/mouse intr */
+#define SIO_IR_RT_INT          0x08000000      /* RT output pulse */
+#define SIO_IR_GEN_INT1                0x10000000      /* RT input pulse */
+#define SIO_IR_GEN_INT_SHIFT   28
+
+/* per device interrupt masks */
+#define SIO_IR_SA              (SIO_IR_SA_TX_MT | \
+                                SIO_IR_SA_RX_FULL | \
+                                SIO_IR_SA_RX_HIGH | \
+                                SIO_IR_SA_RX_TIMER | \
+                                SIO_IR_SA_DELTA_DCD | \
+                                SIO_IR_SA_DELTA_CTS | \
+                                SIO_IR_SA_INT | \
+                                SIO_IR_SA_TX_EXPLICIT | \
+                                SIO_IR_SA_MEMERR)
+
+#define SIO_IR_SB              (SIO_IR_SB_TX_MT | \
+                                SIO_IR_SB_RX_FULL | \
+                                SIO_IR_SB_RX_HIGH | \
+                                SIO_IR_SB_RX_TIMER | \
+                                SIO_IR_SB_DELTA_DCD | \
+                                SIO_IR_SB_DELTA_CTS | \
+                                SIO_IR_SB_INT | \
+                                SIO_IR_SB_TX_EXPLICIT | \
+                                SIO_IR_SB_MEMERR)
+
+#define SIO_IR_PP              (SIO_IR_PP_INT | SIO_IR_PP_INTA | \
+                                SIO_IR_PP_INTB | SIO_IR_PP_MEMERR)
+#define SIO_IR_RT              (SIO_IR_RT_INT | SIO_IR_GEN_INT1)
+
+/* bitmasks for SIO_CR */
+#define SIO_CR_CMD_PULSE_SHIFT 15
+#define SIO_CR_SER_A_BASE_SHIFT 1
+#define SIO_CR_SER_B_BASE_SHIFT 8
+#define SIO_CR_ARB_DIAG                0x00380000      /* cur !enet PCI requet (ro) */
+#define SIO_CR_ARB_DIAG_TXA    0x00000000
+#define SIO_CR_ARB_DIAG_RXA    0x00080000
+#define SIO_CR_ARB_DIAG_TXB    0x00100000
+#define SIO_CR_ARB_DIAG_RXB    0x00180000
+#define SIO_CR_ARB_DIAG_PP     0x00200000
+#define SIO_CR_ARB_DIAG_IDLE   0x00400000      /* 0 -> active request (ro) */
+
+/* defs for some of the generic I/O pins */
+#define GPCR_PHY_RESET         0x20    /* pin is output to PHY reset */
+#define GPCR_UARTB_MODESEL     0x40    /* pin is output to port B mode sel */
+#define GPCR_UARTA_MODESEL     0x80    /* pin is output to port A mode sel */
+
+#define GPPR_PHY_RESET_PIN     5       /* GIO pin controlling phy reset */
+#define GPPR_UARTB_MODESEL_PIN 6       /* GIO pin cntrling uartb modeselect */
+#define GPPR_UARTA_MODESEL_PIN 7       /* GIO pin cntrling uarta modeselect */
+
+#endif /* IA64_SN_IOC3_H */
diff --git a/include/linux/ioc3.h b/include/linux/ioc3.h
new file mode 100644 (file)
index 0000000..e7906a7
--- /dev/null
@@ -0,0 +1,93 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (c) 2005 Stanislaw Skowronek <skylark@linux-mips.org>
+ */
+
+#ifndef _LINUX_IOC3_H
+#define _LINUX_IOC3_H
+
+#include <asm/sn/ioc3.h>
+
+#define IOC3_MAX_SUBMODULES    32
+
+#define IOC3_CLASS_NONE                0
+#define IOC3_CLASS_BASE_IP27   1
+#define IOC3_CLASS_BASE_IP30   2
+#define IOC3_CLASS_MENET_123   3
+#define IOC3_CLASS_MENET_4     4
+#define IOC3_CLASS_CADDUO      5
+#define IOC3_CLASS_SERIAL      6
+
+/* One of these per IOC3 */
+struct ioc3_driver_data {
+       struct list_head list;
+       int id;                         /* IOC3 sequence number */
+       /* PCI mapping */
+       unsigned long pma;              /* physical address */
+       struct __iomem ioc3 *vma;       /* pointer to registers */
+       struct pci_dev *pdev;           /* PCI device */
+       /* IRQ stuff */
+       int dual_irq;                   /* set if separate IRQs are used */
+       int irq_io, irq_eth;            /* IRQ numbers */
+       /* GPIO magic */
+       spinlock_t gpio_lock;
+       unsigned int gpdr_shadow;
+       /* NIC identifiers */
+       char nic_part[32];
+       char nic_serial[16];
+       char nic_mac[6];
+       /* submodule set */
+       int class;
+       void *data[IOC3_MAX_SUBMODULES];        /* for submodule use */
+       int active[IOC3_MAX_SUBMODULES];        /* set if probe succeeds */
+       /* is_ir_lock must be held while
+        * modifying sio_ie values, so
+        * we can be sure that sio_ie is
+        * not changing when we read it
+        * along with sio_ir.
+        */
+       spinlock_t ir_lock;     /* SIO_IE[SC] mod lock */
+};
+
+/* One per submodule */
+struct ioc3_submodule {
+       char *name;             /* descriptive submodule name */
+       struct module *owner;   /* owning kernel module */
+       int ethernet;           /* set for ethernet drivers */
+       int (*probe) (struct ioc3_submodule *, struct ioc3_driver_data *);
+       int (*remove) (struct ioc3_submodule *, struct ioc3_driver_data *);
+       int id;                 /* assigned by IOC3, index for the "data" array */
+       /* IRQ stuff */
+       unsigned int irq_mask;  /* IOC3 IRQ mask, leave clear for Ethernet */
+       int reset_mask;         /* non-zero if you want the ioc3.c module to reset interrupts */
+       int (*intr) (struct ioc3_submodule *, struct ioc3_driver_data *, unsigned int, struct pt_regs *);
+       /* private submodule data */
+       void *data;             /* assigned by submodule */
+};
+
+/**********************************
+ * Functions needed by submodules *
+ **********************************/
+
+#define IOC3_W_IES             0
+#define IOC3_W_IEC             1
+
+/* registers a submodule for all existing and future IOC3 chips */
+extern int ioc3_register_submodule(struct ioc3_submodule *);
+/* unregisters a submodule */
+extern void ioc3_unregister_submodule(struct ioc3_submodule *);
+/* enables IRQs indicated by irq_mask for a specified IOC3 chip */
+extern void ioc3_enable(struct ioc3_submodule *, struct ioc3_driver_data *, unsigned int);
+/* ackowledges specified IRQs */
+extern void ioc3_ack(struct ioc3_submodule *, struct ioc3_driver_data *, unsigned int);
+/* disables IRQs indicated by irq_mask for a specified IOC3 chip */
+extern void ioc3_disable(struct ioc3_submodule *, struct ioc3_driver_data *, unsigned int);
+/* atomically sets GPCR bits */
+extern void ioc3_gpcr_set(struct ioc3_driver_data *, unsigned int);
+/* general ireg writer */
+extern void ioc3_write_ireg(struct ioc3_driver_data *idd, uint32_t value, int reg);
+
+#endif