./2.4.8/0040755000076400001440000000000007451752765010724 5ustar davidusers./2.4.8/readme.pci0100644000076400001440000001103507451747013012641 0ustar davidusers >>> Install Decision PCCOM PCI 4/8-Port Cards to LINUX 2.4.X <<< 1 Login as a root user. 2 Manually Configure the Decision PCCOM PCI 4/8 card driver into the LINUX Kernel 2.0 Overview 1> In the LINUX system, the source programs can be normally be found under /usr/src/linux. 2> The program file /usr/src/linux/drivers/char/serial.c is modified to be able to drive Decision PCCOM PCI 2/4/8-Port. 3> Totally, there are two files needed to be modified as follows. - serial.c in /usr/src/linux/drivers/char - serial.h in /usr/src/linux/include/asm 2.1 Replace /usr/src/linux/drivers/char/serial.c # cd /usr/src/linux/drivers/char; mv serial.c serial.c.old # mcopy a:serial.c /usr/src/linux/drivers/char 2.2 Replace /usr/src/linux/include/asm/serial.h # cd /usr/src/linux/include/asm; mv serial.h serial.h.old # mcopy a:serial.h /usr/src/linux/include/asm 3 Build the LINUX kernel with the Decision PCCOM PCI 2/4/8-Port Driver. 3.1 # cd /usr/src/linux 3.2 # make config When the following prompt messages displayed, Standard/generic (8250/16550 and compatible UARTs) serial support (CONFIG_SERIAL) [Y/m/n/?] Y | enter 'Y' + Extended dumb serial driver options (CONFIG_SERIAL_EXTENDED) [Y/n/?] Y | enter 'Y' + Support more than 4 serial ports (CONFIG_SERIAL_MANY_PORTS) [Y/n/?] | enter 'Y' + Support for sharing serial interrupts (CONFIG_SERIAL_SHARE_IRQ) [Y/n/?] | | enter 'Y' + Support special multiport boards (CONFIG_SERIAL_MULTIPORT) [Y/n/?] | enter 'Y' + 3.3 # make depend 3.4 # make zlilo [bzImage | bzlilo] 4 Configure and enable serial ports 4.1 The patched serial driver enabled for Decision PCCOM PCI 2/4/8-port cards is able to support four cards at most. 4.2 The corresponding device nodes are ttyS44 - ttyS47, cua44 - cua47 for the 1st 4-Port card, ttyS52 - ttyS55, cua52 - cua55 for the 2nd 4-Port card, ttyS60 - ttyS63, cua60 - cua63 for the 3rd 4-Port card, ttyS68 - ttyS71, cua68 - cua71 for the 4th 4-Port card, ttyS44 - ttyS51, cua44 - cua51 for the 1st 8-Port card, ttyS52 - ttyS59, cua52 - cua59 for the 2nd 8-Port card. ttyS60 - ttyS67, cua60 - cua67 for the 3rd 8-Port card, ttyS68 - ttyS75, cua68 - cua75 for the 4th 8-Port card, ttyS44 - ttyS45, cua44 - cua45 for the 1st 2-Port card, ttyS52 - ttyS53, cua52 - cua53 for the 2nd 2-Port card. ttyS60 - ttyS61, cua60 - cua61 for the 3rd 2-Port card. ttyS68 - ttyS69, cua68 - cua69 for the 4th 2-Port card. 4.3 Make these device nodes of (ttyS44 - ttyS59, cua44 - cua59, ttyS60 - ttyS67, and ttyS68 - ttyS75) if they are not existent # cd /dev # ./MAKEDEV ttyS44 ttyS45 ttyS46 ttyS47 ttyS48 ttyS49 ttyS50 ttyS51 # ./MAKEDEV ttyS52 ttyS53 ttyS54 ttyS55 ttyS56 ttyS57 ttyS58 ttyS59 # ./MAKEDEV ttyS60 ttyS61 ttyS62 ttyS63 ttyS64 ttyS65 ttyS66 ttyS67 # ./MAKEDEV ttyS68 ttyS69 ttyS70 ttyS71 ttyS72 ttyS73 ttyS74 ttyS75 4.4 Enable serial ports 4.4.1 # cd /etc/rc.d 4.4.2 edit rc.serial 4.4.3 use the utilities "setserial" to enable corresponding cards respectively and add the following lines for e.g. ttyS44 - ttyS51 as follows: ${SETSERIAL} /dev/ttyS44 ${AUTO_IRQ} autoconfig ${SETSERIAL} /dev/ttyS45 ${AUTO_IRQ} autoconfig ${SETSERIAL} /dev/ttyS46 ${AUTO_IRQ} autoconfig ${SETSERIAL} /dev/ttyS47 ${AUTO_IRQ} autoconfig ${SETSERIAL} /dev/ttyS48 ${AUTO_IRQ} autoconfig ${SETSERIAL} /dev/ttyS49 ${AUTO_IRQ} autoconfig ${SETSERIAL} /dev/ttyS50 ${AUTO_IRQ} autoconfig ${SETSERIAL} /dev/ttyS51 ${AUTO_IRQ} autoconfig 5 Reboot your LIUNX system to startup the new kernel and environment ./2.4.8/serial.c0100644000076400001440000052476307451743325012355 0ustar davidusers/* * linux/drivers/char/serial.c * * Copyright (C) 1991, 1992 Linus Torvalds * Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, * 1998, 1999 Theodore Ts'o * * Extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92. Now * much more extensible to support other serial cards based on the * 16450/16550A UART's. Added support for the AST FourPort and the * Accent Async board. * * set_serial_info fixed to set the flags, custom divisor, and uart * type fields. Fix suggested by Michael K. Johnson 12/12/92. * * 11/95: TIOCMIWAIT, TIOCGICOUNT by Angelo Haritsis * * 03/96: Modularised by Angelo Haritsis * * rs_set_termios fixed to look also for changes of the input * flags INPCK, BRKINT, PARMRK, IGNPAR and IGNBRK. * Bernd Anhäupl 05/17/96. * * 1/97: Extended dumb serial ports are a config option now. * Saves 4k. Michael A. Griffith * * 8/97: Fix bug in rs_set_termios with RTS * Stanislav V. Voronyi * * 3/98: Change the IRQ detection, use of probe_irq_o*(), * suppress TIOCSERGWILD and TIOCSERSWILD * Etienne Lorrain * * 4/98: Added changes to support the ARM architecture proposed by * Russell King * * 5/99: Updated to include support for the XR16C850 and ST16C654 * uarts. Stuart MacDonald * * 8/99: Generalized PCI support added. Theodore Ts'o * * 3/00: Rid circular buffer of redundant xmit_cnt. Fix a * few races on freeing buffers too. * Alan Modra * * 5/00: Support for the RSA-DV II/S card added. * Kiyokazu SUTO * * 6/00: Remove old-style timer, use timer_list * Andrew Morton * * 7/00: Support Timedia/Sunix/Exsys PCI cards * * 7/00: fix some returns on failure not using MOD_DEC_USE_COUNT. * Arnaldo Carvalho de Melo * * 10/00: add in optional software flow control for serial console. * Kanoj Sarcar (Modified by Theodore Ts'o) * */ static char *serial_version = "5.05c"; static char *serial_revdate = "2001-07-08"; /* * Serial driver configuration section. Here are the various options: * * CONFIG_DCIPCCOM_PCI * Enable support for the Decision PCCOM PCI 4/8-Port * cards if CONFIG_PCI is defined * * CONFIG_HUB6 * Enables support for the venerable Bell Technologies * HUB6 card. * * CONFIG_SERIAL_MANY_PORTS * Enables support for ports beyond the standard, stupid * COM 1/2/3/4. * * CONFIG_SERIAL_MULTIPORT * Enables support for special multiport board support. * * CONFIG_SERIAL_SHARE_IRQ * Enables support for multiple serial ports on one IRQ * * CONFIG_SERIAL_DETECT_IRQ * Enable the autodetection of IRQ on standart ports * * SERIAL_PARANOIA_CHECK * Check the magic number for the async_structure where * ever possible. */ #include #include #define CONFIG_DCIPCCOM_PCI #undef SERIAL_PARANOIA_CHECK #define CONFIG_SERIAL_NOPAUSE_IO #define SERIAL_DO_RESTART #if 0 /* These defines are normally controlled by the autoconf.h */ #define CONFIG_SERIAL_MANY_PORTS #define CONFIG_SERIAL_SHARE_IRQ #define CONFIG_SERIAL_DETECT_IRQ #define CONFIG_SERIAL_MULTIPORT #define CONFIG_HUB6 #endif #ifdef CONFIG_PCI #define ENABLE_SERIAL_PCI #ifndef CONFIG_SERIAL_SHARE_IRQ #define CONFIG_SERIAL_SHARE_IRQ #endif #ifndef CONFIG_SERIAL_MANY_PORTS #define CONFIG_SERIAL_MANY_PORTS #endif #endif #ifdef CONFIG_DCIPCCOM_PCI #undef ENABLE_SERIAL_PCI #endif /* CONFIG_DCIPCCOM_PCI */ #if defined(CONFIG_ISAPNP)|| (defined(CONFIG_ISAPNP_MODULE) && defined(MODULE)) #ifndef ENABLE_SERIAL_PNP #define ENABLE_SERIAL_PNP #endif #endif /* Set of debugging defines */ #undef SERIAL_DEBUG_INTR #undef SERIAL_DEBUG_OPEN #undef SERIAL_DEBUG_FLOW #undef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT #undef SERIAL_DEBUG_PCI #undef SERIAL_DEBUG_AUTOCONF /* Sanity checks */ #ifdef CONFIG_SERIAL_MULTIPORT #ifndef CONFIG_SERIAL_SHARE_IRQ #define CONFIG_SERIAL_SHARE_IRQ #endif #endif #ifdef CONFIG_HUB6 #ifndef CONFIG_SERIAL_MANY_PORTS #define CONFIG_SERIAL_MANY_PORTS #endif #ifndef CONFIG_SERIAL_SHARE_IRQ #define CONFIG_SERIAL_SHARE_IRQ #endif #endif #ifdef MODULE #undef CONFIG_SERIAL_CONSOLE #endif #define CONFIG_SERIAL_RSA #define RS_STROBE_TIME (10*HZ) #define RS_ISR_PASS_LIMIT 256 #if defined(__i386__) && (defined(CONFIG_M386) || defined(CONFIG_M486)) #define SERIAL_INLINE #endif /* * End of serial driver configuration section. */ #include #include #ifdef LOCAL_HEADERS #include "serial_local.h" #else #include #include #include #include #define LOCAL_VERSTRING "" #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if (LINUX_VERSION_CODE >= 131343) #include #endif #if (LINUX_VERSION_CODE >= 131336) #include #endif #include #ifdef CONFIG_SERIAL_CONSOLE #include #endif #ifdef ENABLE_SERIAL_PCI #include #endif #ifdef CONFIG_DCIPCCOM_PCI #include #endif #ifdef ENABLE_SERIAL_PNP #include #endif #ifdef CONFIG_MAGIC_SYSRQ #include #endif /* * All of the compatibilty code so we can compile serial.c against * older kernels is hidden in serial_compat.h */ #if defined(LOCAL_HEADERS) || (LINUX_VERSION_CODE < 0x020317) /* 2.3.23 */ #include "serial_compat.h" #endif #include #include #include #include #ifdef CONFIG_MAC_SERIAL #define SERIAL_DEV_OFFSET 2 #else #define SERIAL_DEV_OFFSET 0 #endif #ifdef SERIAL_INLINE #define _INLINE_ inline #else #define _INLINE_ #endif #ifdef CONFIG_DCIPCCOM_PCI /* * Programming Interface */ #define PCI_PI_SERIAL_XT 0x00 #define PCI_PI_SERIAL_16450 0x01 #define PCI_PI_SERIAL_16550 0x02 #define PCI_PI_SERIAL_16650 0x03 /* * Vendor */ #define PCI_DECISION 0x6666 /* * Class-, SubClass-, and Vendor-specific */ #define PCI_DC_SIO_PORT 0x2F #define PCI_DC_SIO_2P 0x00 #define PCI_DC_SIO_4P 0x01 #define PCI_DC_SIO_8P 0x02 #define PCI_DC_SIO_16P 0x03 #define PCI_DC_SIO_TYPE 0x2E #define PCI_DC_SIO_RS232 0x00 #define PCI_DC_SIO_RS422 0x01 #define PCI_DC_SIO_RS485 0x02 /* * Hardware configuration */ #define PCCOM_PCI_VECT_2P(base) (base + 0x10) #define PCCOM_PCI_SWID_2P(base) (base + 0x10) #define PCCOM_PCI_VECT_4P(base) (base + 0x20) #define PCCOM_PCI_SWID_4P(base) (base + 0x20) #define PCCOM_PCI_VECT_8P(base) (base + 0x40) #define PCCOM_PCI_SWID_8P(base) (base + 0x80) #endif /* CONFIG_DCIPCCOM_PCI */ static char *serial_name = "Serial driver"; static DECLARE_TASK_QUEUE(tq_serial); static struct tty_driver serial_driver, callout_driver; static int serial_refcount; static struct timer_list serial_timer; /* serial subtype definitions */ #ifndef SERIAL_TYPE_NORMAL #define SERIAL_TYPE_NORMAL 1 #define SERIAL_TYPE_CALLOUT 2 #endif /* number of characters left in xmit buffer before we ask for more */ #define WAKEUP_CHARS 256 /* * IRQ_timeout - How long the timeout should be for each IRQ * should be after the IRQ has been active. */ static struct async_struct *IRQ_ports[NR_IRQS]; #ifdef CONFIG_SERIAL_MULTIPORT static struct rs_multiport_struct rs_multiport[NR_IRQS]; #endif static int IRQ_timeout[NR_IRQS]; #ifdef CONFIG_SERIAL_CONSOLE static struct console sercons; static int lsr_break_flag; #endif #if defined(CONFIG_SERIAL_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) static unsigned long break_pressed; /* break, really ... */ #endif static unsigned detect_uart_irq (struct serial_state * state); static void autoconfig(struct serial_state * state); static void change_speed(struct async_struct *info, struct termios *old); static void rs_wait_until_sent(struct tty_struct *tty, int timeout); /* * Here we define the default xmit fifo size used for each type of * UART */ static struct serial_uart_config uart_config[] = { { "unknown", 1, 0 }, { "8250", 1, 0 }, { "16450", 1, 0 }, { "16550", 1, 0 }, { "16550A", 16, UART_CLEAR_FIFO | UART_USE_FIFO }, { "cirrus", 1, 0 }, /* usurped by cyclades.c */ { "ST16650", 1, UART_CLEAR_FIFO | UART_STARTECH }, { "ST16650V2", 32, UART_CLEAR_FIFO | UART_USE_FIFO | UART_STARTECH }, { "TI16750", 64, UART_CLEAR_FIFO | UART_USE_FIFO}, { "Startech", 1, 0}, /* usurped by cyclades.c */ { "16C950/954", 128, UART_CLEAR_FIFO | UART_USE_FIFO}, { "ST16654", 64, UART_CLEAR_FIFO | UART_USE_FIFO | UART_STARTECH }, { "XR16850", 128, UART_CLEAR_FIFO | UART_USE_FIFO | UART_STARTECH }, { "RSA", 2048, UART_CLEAR_FIFO | UART_USE_FIFO }, { 0, 0} }; #if defined(CONFIG_SERIAL_RSA) && defined(MODULE) #define PORT_RSA_MAX 4 static int probe_rsa[PORT_RSA_MAX]; static int force_rsa[PORT_RSA_MAX]; MODULE_PARM(probe_rsa, "1-" __MODULE_STRING(PORT_RSA_MAX) "i"); MODULE_PARM_DESC(probe_rsa, "Probe I/O ports for RSA"); MODULE_PARM(force_rsa, "1-" __MODULE_STRING(PORT_RSA_MAX) "i"); MODULE_PARM_DESC(force_rsa, "Force I/O ports for RSA"); #endif /* CONFIG_SERIAL_RSA */ static struct serial_state rs_table[RS_TABLE_SIZE] = { SERIAL_PORT_DFNS /* Defined in serial.h */ }; #define NR_PORTS (sizeof(rs_table)/sizeof(struct serial_state)) #if (defined(ENABLE_SERIAL_PCI) || defined(ENABLE_SERIAL_PNP)) #define NR_PCI_BOARDS 8 static struct pci_board_inst serial_pci_board[NR_PCI_BOARDS]; #ifndef IS_PCI_REGION_IOPORT #define IS_PCI_REGION_IOPORT(dev, r) (pci_resource_flags((dev), (r)) & \ IORESOURCE_IO) #endif #ifndef IS_PCI_REGION_IOMEM #define IS_PCI_REGION_IOMEM(dev, r) (pci_resource_flags((dev), (r)) & \ IORESOURCE_MEM) #endif #ifndef PCI_IRQ_RESOURCE #define PCI_IRQ_RESOURCE(dev, r) ((dev)->irq_resource[r].start) #endif #ifndef pci_get_subvendor #define pci_get_subvendor(dev) ((dev)->subsystem_vendor) #define pci_get_subdevice(dev) ((dev)->subsystem_device) #endif #endif /* ENABLE_SERIAL_PCI || ENABLE_SERIAL_PNP */ #ifndef PREPARE_FUNC #define PREPARE_FUNC(dev) (dev->prepare) #define ACTIVATE_FUNC(dev) (dev->activate) #define DEACTIVATE_FUNC(dev) (dev->deactivate) #endif #define HIGH_BITS_OFFSET ((sizeof(long)-sizeof(int))*8) static struct tty_struct *serial_table[NR_PORTS]; static struct termios *serial_termios[NR_PORTS]; static struct termios *serial_termios_locked[NR_PORTS]; #ifdef CONFIG_DCIPCCOM_PCI #define serial_dcpci_nr_cards 4 #define serial_dcpci_minor1 44 #define serial_dcpci_minor2 52 #define serial_dcpci_minor3 60 #define serial_dcpci_minor4 68 static int serial_dcpci_minor[serial_dcpci_nr_cards] = { serial_dcpci_minor1, serial_dcpci_minor2, serial_dcpci_minor3, serial_dcpci_minor4 }; #endif /* CONFIG_DCIPCCOM_PCI */ #if defined(MODULE) && defined(SERIAL_DEBUG_MCOUNT) #define DBG_CNT(s) printk("(%s): [%x] refc=%d, serc=%d, ttyc=%d -> %s\n", \ kdevname(tty->device), (info->flags), serial_refcount,info->count,tty->count,s) #else #define DBG_CNT(s) #endif /* * tmp_buf is used as a temporary buffer by serial_write. We need to * lock it in case the copy_from_user blocks while swapping in a page, * and some other program tries to do a serial write at the same time. * Since the lock will only come under contention when the system is * swapping and available memory is low, it makes sense to share one * buffer across all the serial ports, since it significantly saves * memory if large numbers of serial ports are open. */ static unsigned char *tmp_buf; #ifdef DECLARE_MUTEX static DECLARE_MUTEX(tmp_buf_sem); #else static struct semaphore tmp_buf_sem = MUTEX; #endif static inline int serial_paranoia_check(struct async_struct *info, kdev_t device, const char *routine) { #ifdef SERIAL_PARANOIA_CHECK static const char *badmagic = "Warning: bad magic number for serial struct (%s) in %s\n"; static const char *badinfo = "Warning: null async_struct for (%s) in %s\n"; if (!info) { printk(badinfo, kdevname(device), routine); return 1; } if (info->magic != SERIAL_MAGIC) { printk(badmagic, kdevname(device), routine); return 1; } #endif return 0; } static _INLINE_ unsigned int serial_in(struct async_struct *info, int offset) { switch (info->io_type) { #ifdef CONFIG_HUB6 case SERIAL_IO_HUB6: outb(info->hub6 - 1 + offset, info->port); return inb(info->port+1); #endif case SERIAL_IO_MEM: return readb((unsigned long) info->iomem_base + (offset<iomem_reg_shift)); #ifdef CONFIG_SERIAL_GSC case SERIAL_IO_GSC: return gsc_readb(info->iomem_base + offset); #endif default: return inb(info->port + offset); } } static _INLINE_ void serial_out(struct async_struct *info, int offset, int value) { switch (info->io_type) { #ifdef CONFIG_HUB6 case SERIAL_IO_HUB6: outb(info->hub6 - 1 + offset, info->port); outb(value, info->port+1); break; #endif case SERIAL_IO_MEM: writeb(value, (unsigned long) info->iomem_base + (offset<iomem_reg_shift)); break; #ifdef CONFIG_SERIAL_GSC case SERIAL_IO_GSC: gsc_writeb(value, info->iomem_base + offset); break; #endif default: outb(value, info->port+offset); } } /* * We used to support using pause I/O for certain machines. We * haven't supported this for a while, but just in case it's badly * needed for certain old 386 machines, I've left these #define's * in.... */ #define serial_inp(info, offset) serial_in(info, offset) #define serial_outp(info, offset, value) serial_out(info, offset, value) /* * For the 16C950 */ void serial_icr_write(struct async_struct *info, int offset, int value) { serial_out(info, UART_SCR, offset); serial_out(info, UART_ICR, value); } unsigned int serial_icr_read(struct async_struct *info, int offset) { int value; serial_icr_write(info, UART_ACR, info->ACR | UART_ACR_ICRRD); serial_out(info, UART_SCR, offset); value = serial_in(info, UART_ICR); serial_icr_write(info, UART_ACR, info->ACR); return value; } /* * ------------------------------------------------------------ * rs_stop() and rs_start() * * This routines are called before setting or resetting tty->stopped. * They enable or disable transmitter interrupts, as necessary. * ------------------------------------------------------------ */ static void rs_stop(struct tty_struct *tty) { struct async_struct *info = (struct async_struct *)tty->driver_data; unsigned long flags; if (serial_paranoia_check(info, tty->device, "rs_stop")) return; save_flags(flags); cli(); if (info->IER & UART_IER_THRI) { info->IER &= ~UART_IER_THRI; serial_out(info, UART_IER, info->IER); } if (info->state->type == PORT_16C950) { info->ACR |= UART_ACR_TXDIS; serial_icr_write(info, UART_ACR, info->ACR); } restore_flags(flags); } static void rs_start(struct tty_struct *tty) { struct async_struct *info = (struct async_struct *)tty->driver_data; unsigned long flags; if (serial_paranoia_check(info, tty->device, "rs_start")) return; save_flags(flags); cli(); if (info->xmit.head != info->xmit.tail && info->xmit.buf && !(info->IER & UART_IER_THRI)) { info->IER |= UART_IER_THRI; serial_out(info, UART_IER, info->IER); } if (info->state->type == PORT_16C950) { info->ACR &= ~UART_ACR_TXDIS; serial_icr_write(info, UART_ACR, info->ACR); } restore_flags(flags); } /* * ---------------------------------------------------------------------- * * Here starts the interrupt handling routines. All of the following * subroutines are declared as inline and are folded into * rs_interrupt(). They were separated out for readability's sake. * * Note: rs_interrupt() is a "fast" interrupt, which means that it * runs with interrupts turned off. People who may want to modify * rs_interrupt()