/* * linux/drivers/char/serial.c * * Copyright (C) 1991, 1992 Linus Torvalds */ #define cPCI 0 #define MESSG 0 #define PPORT_TYPE_NORMAL 0 #define PPORT_TYPE_CALLOUT 1 #undef SERIAL_PARANOIA_CHECK #define CONFIG_SERIAL_NOPAUSE_IO #define SERIAL_DO_RESTART /***WANG add this setting to solve the problem from kernel 2.2.14 Because they may not have such setting in autoconf.h So we add this one forcedly ---------24/MAY/2002 ********/ #define CONFIG_SERIAL_SHARE_IRQ /* Normally these defines are controlled by the autoconf.h */ #define CONFIG_SERIAL_DETECT_IRQ /*#define CONFIG_SERIAL_MULTIPORT */ /* Sanity checks */ /* Set of debugging defines */ /* #define SERIAL_DEBUG_INTR #define SERIAL_DEBUG_OPEN #define SERIAL_DEBUG_FLOW #define SERIAL_DEBUG_RS_WAIT_UNTIL_SENT */ #define RS_STROBE_TIME (10*HZ) #define RS_ISR_PASS_LIMIT 256 #define IRQ_T(info) ((info->flags & ASYNC_SHARE_IRQ) ? IRQF_SHARED : IRQF_TIMER) #define SERIAL_INLINE static char *serial_version = "4.27"; #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), p220_serial_refcount,info->count,tty->count,s) #else #define DBG_CNT(s) #endif /* * End of serial driver configuration section. */ //#include #include #include #include #include #include #include #include #include #include #include /*2001/03/13 yuchiehu*/ #include #include #include #include #include #include #include #include #include #include #include /*WANG modify to add ASYNC_SHARE_IRQ as default condition 29-Sep-2004 #define ASTD_COM_FLAGS (ASYNC_BOOT_AUTOCONF |ASYNC_AUTO_IRQ ) ********/ #define ASTD_COM_FLAGS (ASYNC_SHARE_IRQ | ASYNC_BOOT_AUTOCONF) #define CONFIG_SERIAL_CONSOLE #ifdef CONFIG_SERIAL_CONSOLE #include #endif #include #include #include #include #include #include #ifdef SERIAL_INLINE #define _INLINE_ inline #endif #define RAYON_VENDOR_ID1 0x10B5 /* plx9050's manufacturer's ID1. */ #define RAYON_VENDOR_ID2 0x144A /* plx9050's manufacturer's ID2. */ #define RAYON_VENDOR_ID3 0x9710 /* NM9845's manufacturer's ID3.*/ #define RAYON_DEVICE_ID2 0x9845 /* NM9845 */ #define RAYON_DEVICE_ID 0x9050 #define RAYON_SSYS_ID 0x1584 #define RAYON_SSYS_ID2 0x0014 #define RAYON_SVEN_ID2 0x1000 #define RAYON_SVEN_ID 0x10B5 #define P220_BH 27 /*2001/05 yuchiehu*/ #define NCARD 7 #define P588 0 #define P584 1 #define P518 2 #define P514 3 #define P124 4 #define P220 5 #define P984 6 struct cardinfo { char * name; long dpsum; long subsum; int portnum; }; struct cardinfo pcardname[NCARD] = { #if !cPCI {"P588",0x280,0x263d,8}, {"P584",0x27c,0x2639,4}, #else {"cPCI3538",0x280,0x263d,8}, {"cPCI3534",0x27c,0x2639,4}, #endif {"P518",0x227,0x25cd,8}, {"P514",0x223,0x25c9,4}, {"P124",0x220,0x21d9,4}, {"P220",0x4fd,0x22b5,2}, {"P984",0x313,0x22b5,4} }; /* Variables for insmod */ MODULE_AUTHOR("Mike Wang"); MODULE_DESCRIPTION("RAYON PCIPORT card Device Driver"); MODULE_LICENSE("GPL"); static char *Copyright="\n\ **********************************************\n\ RAYON PCI-Serial Device Driver Ver:7.0.4\n\ Copyright (C) 2005-2012 Rayon Company, Ltd.\n\ All Rights Reserved\n\ \n\ Updated for Linux 2.6.26 on 20090519 by:\n\ Roller Network LLC www.rollernet.us\n\ **********************************************"; static struct timer_list p220_serial_timer; static struct tty_driver *p220_serial_driver; static int p220_serial_refcount; /* number of characters left in xmit buffer before we ask for more */ #define WAKEUP_CHARS 256 /* */ static struct async_struct *aIRQ_ports[NR_IRQS]; #ifdef CONFIG_SERIAL_MULTIPORT static struct rs_multiport_struct p220_multiport[NR_IRQS]; #endif static int aIRQ_timeout[NR_IRQS]; #ifdef CONFIG_SERIAL_CONSOLE static struct console p220_sercons; #endif static unsigned detect_p220_irq (struct serial_state * state); static void p220_autoconfig(struct serial_state * info); static void p220_change_speed(struct async_struct *info, struct termios *old); static void p220_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 p220_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 }, { "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}, { 0, 0} }; static struct serial_state p220_rs_table[64]; #define NR_PORTS (sizeof(p220_rs_table)/sizeof(struct serial_state)) static struct tty_struct *p220_serial_table[NR_PORTS]; static struct termios *p220_serial_termios[NR_PORTS]; static struct termios *p220_serial_termios_locked[NR_PORTS]; unsigned int statusbase[3]; unsigned int cardstart=0; unsigned int indon=0; #ifndef MIN #define MIN(a,b) ((a) < (b) ? (a) : (b)) #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 *atmp_buf; #ifdef DECLARE_MUTEX /*2001/03/13 yuchiehu*/ static DECLARE_MUTEX(atmp_buf_sem); #else static struct semaphore atmp_buf_sem = MUTEX; #endif static inline int serial_paranoia_check(struct async_struct *info, char *name, 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, name, routine); return 1; } if (info->magic != SERIAL_MAGIC) { printk(badmagic, name, routine); return 1; } #endif return 0; } static inline unsigned int p220_serial_in(struct async_struct *info, int offset) { return inb(info->port + offset); } static inline unsigned int p220_serial_inp(struct async_struct *info, int offset) { #ifdef CONFIG_SERIAL_NOPAUSE_IO return inb(info->port + offset); #else return inb_p(info->port + offset); #endif } static inline void p220_serial_out(struct async_struct *info, int offset, int value) { outb(value, info->port+offset); } static inline void p220_serial_outp(struct async_struct *info, int offset, int value) { #ifdef CONFIG_SERIAL_NOPAUSE_IO outb(value, info->port+offset); #else outb_p(value, info->port+offset); #endif } /* * ------------------------------------------------------------ * p220_stop() and rs_start() * * This routines are called before setting or resetting tty->stopped. * They enable or disable transmitter interrupts, as necessary. * ------------------------------------------------------------ */ static void p220_stop(struct tty_struct *tty) { struct async_struct *info = (struct async_struct *)tty->driver_data; unsigned long flags; if (serial_paranoia_check(info, tty->name, "p220_stop")) return; #ifdef SERIAL_DEBUG_OPEN printk("p220_stop 0\n"); #endif spin_lock_irqsave(&info->xmit_lock, flags); if (info->IER & UART_IER_THRI) { info->IER &= ~UART_IER_THRI; p220_serial_out(info, UART_IER, info->IER); } spin_unlock_irqrestore(&info->xmit_lock, flags); #ifdef SERIAL_DEBUG_OPEN printk("p220_stop 1\n"); #endif } static void p220_start(struct tty_struct *tty) { struct async_struct *info = (struct async_struct *)tty->driver_data; unsigned long flags; if (serial_paranoia_check(info, tty->name, "p220_start")) return; #ifdef SERIAL_DEBUG_OPEN printk("p220_start 0\n"); #endif spin_lock_irqsave(&info->xmit_lock, flags); if (info->xmit.head != info->xmit.tail && info->xmit.buf && !(info->IER & UART_IER_THRI)) { info->IER |= UART_IER_THRI; p220_serial_out(info, UART_IER, info->IER); } spin_unlock_irqrestore(&info->xmit_lock, flags); #ifdef SERIAL_DEBUG_OPEN printk("p220_start 1\n"); #endif } /* * ---------------------------------------------------------------------- * * Here starts the interrupt handling routines. All of the following * subroutines are declared as inline and are folded into * p220_interrupt(). They were separated out for readability's sake. * * Note: p220_interrupt() is a "fast" interrupt, which means that it * runs with interrupts turned off. People who may want to modify * p220_interrupt() should try to keep the interrupt handler as fast as * possible. After you are done making modifications, it is not a bad * idea to do: * * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c * * and look at the resulting assemble code in serial.s. * * - Ted Ts'o (tytso@mit.edu), 7-Mar-93 * ----------------------------------------------------------------------- */ static _INLINE_ void p220_receive_chars(struct async_struct *info, int *status) { struct tty_struct *tty = info->tty; unsigned char ch, flag; struct async_icount *icount; int oe = 0; icount = &info->state->icount; do { *status = p220_serial_inp(info, UART_LSR); if (*status & UART_LSR_DR) { /*extra check */ ch = p220_serial_inp(info, UART_RX); icount->rx++; flag = TTY_NORMAL; if (*status & (UART_LSR_BI | UART_LSR_PE | UART_LSR_FE | UART_LSR_OE)) { /* * For statistics only */ if (*status & UART_LSR_BI) { *status &= ~(UART_LSR_FE | UART_LSR_PE); icount->brk++; } else if (*status & UART_LSR_PE) icount->parity++; else if (*status & UART_LSR_FE) icount->frame++; if (*status & UART_LSR_OE) icount->overrun++; /* * Now check to see if character should be * ignored, and mask off conditions which * should be ignored. */ if (*status & info->ignore_status_mask) { goto out; } *status &= info->read_status_mask; if (*status & (UART_LSR_BI)) { #ifdef SERIAL_DEBUG_INTR printk("handling break...."); #endif flag = TTY_BREAK; if (info->flags & ASYNC_SAK) do_SAK(tty); } else if (*status & UART_LSR_PE) flag = TTY_PARITY; else if (*status & UART_LSR_FE) flag = TTY_FRAME; if (*status & UART_LSR_OE) { /* * Overrun is special, since it's * reported immediately, and doesn't * affect the current character */ oe = 1; } } tty_insert_flip_char(tty, ch, flag); if (oe == 1) tty_insert_flip_char(tty, 0, TTY_OVERRUN); *status = p220_serial_inp(info, UART_LSR); } /*extra check */ } while (*status & UART_LSR_DR); tty_flip_buffer_push(tty); out: return; } static _INLINE_ void p220_transmit_chars(struct async_struct *info, int *intr_done) { int count; if (info->x_char) { p220_serial_outp(info, UART_TX, info->x_char); info->state->icount.tx++; info->x_char = 0; if (intr_done) *intr_done = 0; return; } if (info->xmit.head == info->xmit.tail || info->tty->stopped || info->tty->hw_stopped) { info->IER &= ~UART_IER_THRI; p220_serial_out(info, UART_IER, info->IER); return; } count = info->xmit_fifo_size; do { p220_serial_out(info, UART_TX, info->xmit.buf[info->xmit.tail]); info->xmit.tail = (info->xmit.tail+1) & (SERIAL_XMIT_SIZE-1); info->state->icount.tx++; if (info->xmit.head == info->xmit.tail) break; } while (--count > 0); if (CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE)< WAKEUP_CHARS) { set_bit(RS_EVENT_WRITE_WAKEUP, &info->event); schedule_work(&info->work); } #ifdef SERIAL_DEBUG_INTR printk("THRE..."); #endif if (intr_done) *intr_done = 0; if (info->xmit.head == info->xmit.tail) { info->IER &= ~UART_IER_THRI; p220_serial_out(info, UART_IER, info->IER); } } static _INLINE_ void p220_check_modem_status(struct async_struct *info) { int status; struct async_icount *icount; status = p220_serial_in(info, UART_MSR); if (status & UART_MSR_ANY_DELTA) { icount = &info->state->icount; /* update input line counters */ if (status & UART_MSR_TERI) icount->rng++; if (status & UART_MSR_DDSR) icount->dsr++; if (status & UART_MSR_DDCD) { icount->dcd++; #ifdef CONFIG_HARD_PPS if ((info->flags & ASYNC_HARDPPS_CD) && (status & UART_MSR_DCD)) hardpps(); #endif } if (status & UART_MSR_DCTS) icount->cts++; wake_up_interruptible(&info->delta_msr_wait); } if ((info->flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) { #if (defined(SERIAL_DEBUG_OPEN) || defined(SERIAL_DEBUG_INTR)) printk("ttys%d CD now %s...", info->line, (status & UART_MSR_DCD) ? "on" : "off"); #endif if (status & UART_MSR_DCD) wake_up_interruptible(&info->open_wait); else { #ifdef SERIAL_DEBUG_OPEN printk("doing serial hangup..."); #endif if (info->tty) tty_hangup(info->tty); } } if (info->flags & ASYNC_CTS_FLOW) { if (info->tty->hw_stopped) { if (status & UART_MSR_CTS) { #if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW)) printk("CTS tx start..."); #endif info->tty->hw_stopped = 0; info->IER |= UART_IER_THRI; p220_serial_out(info, UART_IER, info->IER); set_bit(RS_EVENT_WRITE_WAKEUP, &info->event); schedule_work(&info->work); return; } } else { if (!(status & UART_MSR_CTS)) { #if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW)) printk("CTS tx stop..."); #endif info->tty->hw_stopped = 1; info->IER &= ~UART_IER_THRI; p220_serial_out(info, UART_IER, info->IER); } } } } #ifdef CONFIG_SERIAL_SHARE_IRQ /* * This is the serial driver's generic interrupt routine */ static irqreturn_t p220_interrupt(int irq, void *dev_id, struct pt_regs * regs) { int status; int handled = 0; struct async_struct * info; int pass_counter = 0; struct async_struct *end_mark = 0; #ifdef CONFIG_SERIAL_MULTIPORT int first_multi = 0; struct rs_multiport_struct *multi; #endif #ifdef SERIAL_DEBUG_INTR printk("p220_interrupt(%d)...", irq); #endif info = aIRQ_ports[irq]; if (!info) return IRQ_NONE; #ifdef CONFIG_SERIAL_MULTIPORT multi = &p220_multiport[irq]; if (multi->port_monitor) first_multi = inb(multi->port_monitor); #endif do { if (!info->tty || (p220_serial_in(info, UART_IIR) & UART_IIR_NO_INT)) { if (!end_mark) end_mark = info; goto next; } end_mark = 0; handled = 1; info->last_active = jiffies; status = p220_serial_inp(info, UART_LSR); #ifdef SERIAL_DEBUG_INTR printk("status = %x...", status); #endif if (status & UART_LSR_DR) p220_receive_chars(info, &status); p220_check_modem_status(info); if (status & UART_LSR_THRE) p220_transmit_chars(info, 0); next: info = info->next_port; if (!info) { info = aIRQ_ports[irq]; if (pass_counter++ > RS_ISR_PASS_LIMIT) { break; /* Prevent infinite loops */ } continue; } } while (end_mark != info); #ifdef CONFIG_SERIAL_MULTIPORT if (multi->port_monitor) printk("rs port monitor (normal) irq %d: 0x%x, 0x%x\n", info->state->irq, first_multi, inb(multi->port_monitor)); #endif #ifdef SERIAL_DEBUG_INTR printk("end.\n"); #endif return IRQ_RETVAL(handled); } #endif /* #ifdef CONFIG_SERIAL_SHARE_IRQ */ /* * This is the serial driver's interrupt routine for a single port */ static irqreturn_t p220_interrupt_single(int irq, void *dev_id, struct pt_regs * regs) { int status; int handled = 0; int pass_counter = 0; struct async_struct * info; #ifdef CONFIG_SERIAL_MULTIPORT int first_multi = 0; struct rs_multiport_struct *multi; #endif #ifdef SERIAL_DEBUG_INTR printk("p220_interrupt_single(%d)...", irq); #endif info = aIRQ_ports[irq]; if (!info || !info->tty) return IRQ_NONE; handled = 1; #ifdef CONFIG_SERIAL_MULTIPORT multi = &p220_multiport[irq]; if (multi->port_monitor) first_multi = inb(multi->port_monitor); #endif do { status = p220_serial_inp(info, UART_LSR); #ifdef SERIAL_DEBUG_INTR printk("status = %x...", status); #endif if (status & UART_LSR_DR) p220_receive_chars(info, &status); p220_check_modem_status(info); if (status & UART_LSR_THRE) p220_transmit_chars(info, 0); if (pass_counter++ > RS_ISR_PASS_LIMIT) { #if 0 printk("rs_single loop break.\n"); #endif break; } } while (!(p220_serial_in(info, UART_IIR) & UART_IIR_NO_INT)); info->last_active = jiffies; #ifdef CONFIG_SERIAL_MULTIPORT if (multi->port_monitor) printk("rs port monitor (single) irq %d: 0x%x, 0x%x\n", info->state->irq, first_multi, inb(multi->port_monitor)); #endif #ifdef SERIAL_DEBUG_INTR printk("end.\n"); #endif return IRQ_RETVAL(handled); } #ifdef CONFIG_SERIAL_MULTIPORT /* * This is the serial driver's for multiport boards */ static irqreturn_t p220_interrupt_multi(int irq, void *dev_id, struct pt_regs * regs) { int status; int handled = 0; struct async_struct * info; int pass_counter = 0; int first_multi= 0; struct rs_multiport_struct *multi; #ifdef SERIAL_DEBUG_INTR printk("p220_interrupt_multi(%d)...", irq); #endif info = aIRQ_ports[irq]; if (!info) return IRQ_NONE; multi = &p220_multiport[irq]; if (!multi->port1) { /* Should never happen */ printk("p220_interrupt_multi: NULL port1!\n"); return IRQ_NONE; } handled = 1; if (multi->port_monitor) first_multi = inb(multi->port_monitor); while (1) { if (!info->tty || (p220_serial_in(info, UART_IIR) & UART_IIR_NO_INT)) goto next; info->last_active = jiffies; status = p220_serial_inp(info, UART_LSR); #ifdef SERIAL_DEBUG_INTR printk("status = %x...", status); #endif if (status & UART_LSR_DR) p220_receive_chars(info, &status); p220_check_modem_status(info); if (status & UART_LSR_THRE) p220_transmit_chars(info, 0); next: info = info->next_port; if (info) continue; info = aIRQ_ports[irq]; if (pass_counter++ > RS_ISR_PASS_LIMIT) { #if 1 printk("rs_multi loop break\n"); #endif break; /* Prevent infinite loops */ } if (multi->port_monitor) printk("rs port monitor irq %d: 0x%x, 0x%x\n", info->state->irq, first_multi, inb(multi->port_monitor)); if ((inb(multi->port1) & multi->mask1) != multi->match1) continue; if (!multi->port2) break; if ((inb(multi->port2) & multi->mask2) != multi->match2) continue; if (!multi->port3) break; if ((inb(multi->port3) & multi->mask3) != multi->match3) continue; if (!multi->port4) break; if ((inb(multi->port4) & multi->mask4) == multi->match4) continue; break; } #ifdef SERIAL_DEBUG_INTR printk("end.\n"); #endif return IRQ_RETVAL(handled); } #endif /* * ------------------------------------------------------------------- * Here ends the serial interrupt routines. * ------------------------------------------------------------------- */ static void p220_do_softint(void *private_) { struct async_struct *info = (struct async_struct *) private_; struct tty_struct *tty; tty = info->tty; if (!tty) return; if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) { if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && tty->ldisc.write_wakeup) (tty->ldisc.write_wakeup)(tty); wake_up_interruptible(&tty->write_wait); } } /* * This subroutine is called when the RS_TIMER goes off. It is used * by the serial driver to handle ports that do not have an interrupt * (irq=0). This doesn't work very well for 16450's, but gives barely * passable results for a 16550A. (Although at the expense of much * CPU overhead). */ static void p220_timer(unsigned long dummy) /*2001/05 yuchiehu*/ { static unsigned long last_strobe = 0; struct async_struct *info; unsigned int i; unsigned long flags; if ((jiffies - last_strobe) >= RS_STROBE_TIME) { for (i=1; i < NR_IRQS; i++) { info = aIRQ_ports[i]; if (!info) continue; spin_lock_irqsave(&info->xmit_lock, flags); #ifdef CONFIG_SERIAL_SHARE_IRQ if (info->next_port) { do { p220_serial_out(info, UART_IER, 0); info->IER |= UART_IER_THRI; p220_serial_out(info, UART_IER, info->IER); info = info->next_port; } while (info); #ifdef CONFIG_SERIAL_MULTIPORT if (p220_multiport[i].port1) p220_interrupt_multi(i, NULL, NULL); else #endif p220_interrupt(i, NULL, NULL); } else #endif /* CONFIG_SERIAL_SHARE_IRQ */ p220_interrupt_single(i, NULL, NULL); info = aIRQ_ports[i]; /*need to balance*/ spin_unlock_irqrestore(&info->xmit_lock, flags); } } last_strobe = jiffies; /*2001/03/14*/ mod_timer(&p220_serial_timer, jiffies + RS_STROBE_TIME); /* timer_table[RS_TIMER].expires = jiffies + RS_STROBE_TIME; timer_active |= 1 << RS_TIMER; */ if (aIRQ_ports[0]) { info = aIRQ_ports[0]; spin_lock_irqsave(&info->xmit_lock, flags); #ifdef CONFIG_SERIAL_SHARE_IRQ p220_interrupt(0, NULL, NULL); #else p220_interrupt_single(0, NULL, NULL); #endif spin_unlock_irqrestore(&info->xmit_lock, flags); mod_timer(&p220_serial_timer, jiffies + aIRQ_timeout[0]); } } /* * --------------------------------------------------------------- * Low level utility subroutines for the serial driver: routines to * figure out the appropriate timeout for an interrupt chain, routines * to initialize and startup a serial port, and routines to p220shutdown a * serial port. Useful stuff like that. * --------------------------------------------------------------- */ /* * This routine figures out the correct timeout for a particular IRQ. * It uses the smallest timeout of all of the serial ports in a * particular interrupt chain. Now only used for IRQ 0.... */ static void figure_aIRQ_timeout(int irq) { struct async_struct *info; int timeout = 60*HZ; /* 60 seconds === a long time :-) */ info = aIRQ_ports[irq]; if (!info) { aIRQ_timeout[irq] = 60*HZ; return; } while (info) { if (info->timeout < timeout) timeout = info->timeout; info = info->next_port; } if (!irq) timeout = timeout / 2; aIRQ_timeout[irq] = timeout ? timeout : 1; } static int p220startup(struct async_struct * info) { unsigned long flags; int retval=0; irqreturn_t (*handler)(int, void *, struct pt_regs *); struct serial_state *state= info->state; unsigned long page; page = get_zeroed_page(GFP_KERNEL); if (!page) return -ENOMEM; spin_lock_irqsave(&info->xmit_lock, flags); if (info->flags & ASYNC_INITIALIZED) { free_page(page); goto errout; } /*2001/03/15*/ if (!CONFIGURED_SERIAL_PORT(state) || !state->type) { if (info->tty) set_bit(TTY_IO_ERROR, &info->tty->flags); free_page(page); goto errout; } if (info->xmit.buf) free_page(page); else info->xmit.buf = (unsigned char *) page; #ifdef SERIAL_DEBUG_OPEN printk("starting up ttys%d (irq %d)...", info->line, state->irq); #endif if (p220_uart_config[info->state->type].flags & UART_STARTECH) { /* Wake up UART */ p220_serial_outp(info, UART_LCR, 0xBF); p220_serial_outp(info, UART_EFR, UART_EFR_ECB); p220_serial_outp(info, UART_IER, 0); p220_serial_outp(info, UART_EFR, 0); p220_serial_outp(info, UART_LCR, 0); } if (info->state->type == PORT_16750) { /* Wake up UART */ p220_serial_outp(info, UART_IER, 0); } /* * Clear the FIFO buffers and disable them * (they will be reenabled in p220_change_speed()) */ if (p220_uart_config[state->type].flags & UART_CLEAR_FIFO) p220_serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT)); /* * At this point there's no way the LSR could still be 0xFF; * if it is, then bail out, because there's likely no UART * here. */ if (p220_serial_inp(info, UART_LSR) == 0xff) { if (capable(CAP_SYS_ADMIN)) { if (info->tty) set_bit(TTY_IO_ERROR, &info->tty->flags); } else retval = -ENODEV; goto errout; } /* * Allocate the IRQ if necessary */ if (state->irq && (!aIRQ_ports[state->irq] || !aIRQ_ports[state->irq]->next_port)) { if (aIRQ_ports[state->irq]) { #ifdef CONFIG_SERIAL_SHARE_IRQ free_irq(state->irq, &aIRQ_ports[state->irq]); #ifdef CONFIG_SERIAL_MULTIPORT if (p220_multiport[state->irq].port1) handler = p220_interrupt_multi; else #endif handler = p220_interrupt; #else retval = -EBUSY; goto errout; #endif /* CONFIG_SERIAL_SHARE_IRQ */ } else handler = p220_interrupt_single; retval = request_irq(state->irq, handler, IRQ_T(info), "RAYONserial", &aIRQ_ports[state->irq]); if (retval) { if (capable(CAP_SYS_ADMIN)) { if (info->tty) set_bit(TTY_IO_ERROR, &info->tty->flags); retval = 0; } goto errout; } } /* * Insert serial port into IRQ chain. */ info->prev_port = 0; info->next_port = aIRQ_ports[state->irq]; if (info->next_port) info->next_port->prev_port = info; aIRQ_ports[state->irq] = info; figure_aIRQ_timeout(state->irq); /* * Clear the interrupt registers. */ /* (void) p220_serial_inp(info, UART_LSR); */ /* (see above) */ (void) p220_serial_inp(info, UART_RX); (void) p220_serial_inp(info, UART_IIR); (void) p220_serial_inp(info, UART_MSR); /* * Now, initialize the UART */ p220_serial_outp(info, UART_LCR, UART_LCR_WLEN8); /* reset DLAB */ info->MCR = 0; if (info->tty->termios->c_cflag & CBAUD) info->MCR = UART_MCR_DTR | UART_MCR_RTS; { if (state->irq != 0) info->MCR |= UART_MCR_OUT2; } #if defined(__alpha__) && !defined(CONFIG_PCI) /* * DEC did something gratutiously wrong.... */ info->MCR |= UART_MCR_OUT1 | UART_MCR_OUT2; #endif p220_serial_outp(info, UART_MCR, info->MCR); /* * Finally, enable interrupts */ info->IER = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI; p220_serial_outp(info, UART_IER, info->IER); /* enable interrupts */ /* * And clear the interrupt registers again for luck. */ (void)p220_serial_inp(info, UART_LSR); (void)p220_serial_inp(info, UART_RX); (void)p220_serial_inp(info, UART_IIR); (void)p220_serial_inp(info, UART_MSR); if (info->tty) clear_bit(TTY_IO_ERROR, &info->tty->flags); info->xmit.head = info->xmit.tail = 0; /* * Set up serial timers... */ mod_timer(&p220_serial_timer, jiffies + 2*HZ/100); /* * Set up the tty->alt_speed kludge */ if (info->tty) { if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI) info->tty->alt_speed = 57600; if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI) info->tty->alt_speed = 115200; if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI) info->tty->alt_speed = 230400; if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP) info->tty->alt_speed = 460800; } /* * and set the speed of the serial port */ /***WANG add****/ spin_unlock_irqrestore(&info->xmit_lock, flags); p220_change_speed(info, 0); info->flags |= ASYNC_INITIALIZED; return 0; errout: spin_unlock_irqrestore(&info->xmit_lock, flags); return retval; } /* * This routine will shutdown a serial port; interrupts are disabled, and * DTR is dropped if the hangup on close termio flag is on. */ static void p220shutdown(struct async_struct * info) { unsigned long flags; struct serial_state *state; int retval; if (!(info->flags & ASYNC_INITIALIZED)) return; state = info->state; #ifdef SERIAL_DEBUG_OPEN printk("Shutting down serial port %d (irq %d)....", info->line, state->irq); #endif spin_lock_irqsave(&info->xmit_lock, flags); /* * clear delta_msr_wait queue to avoid mem leaks: we may free the irq * here so the queue might never be waken up */ wake_up_interruptible(&info->delta_msr_wait); /* * First unlink the serial port from the IRQ chain... */ if (info->next_port) info->next_port->prev_port = info->prev_port; if (info->prev_port) info->prev_port->next_port = info->next_port; else aIRQ_ports[state->irq] = info->next_port; figure_aIRQ_timeout(state->irq); /* * Free the IRQ, if necessary */ if (state->irq && (!aIRQ_ports[state->irq] || !aIRQ_ports[state->irq]->next_port)) { if (aIRQ_ports[state->irq]) { free_irq(state->irq, &aIRQ_ports[state->irq]); retval = request_irq(state->irq, p220_interrupt_single, IRQ_T(info), "RAYONserial", &aIRQ_ports[state->irq]); if (retval) printk("serial shutdown: request_irq: error %d" " Couldn't reacquire IRQ.\n", retval); } else free_irq(state->irq, &aIRQ_ports[state->irq]); } /*2001/03/15*/ if (info->xmit.buf) { free_page((unsigned long) info->xmit.buf); info->xmit.buf = 0; } info->IER = 0; p220_serial_outp(info, UART_IER, 0x00); /* disable all intrs */ info->MCR &= ~UART_MCR_OUT2; #if defined(__alpha__) && !defined(CONFIG_PCI) /* * DEC did something gratutiously wrong.... */ info->MCR |= UART_MCR_OUT1 | UART_MCR_OUT2; #endif /* disable break condition */ p220_serial_out(info, UART_LCR, p220_serial_inp(info, UART_LCR) & ~UART_LCR_SBC); if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) info->MCR &= ~(UART_MCR_DTR|UART_MCR_RTS); p220_serial_outp(info, UART_MCR, info->MCR); /* disable FIFO's */ p220_serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT)); (void)p220_serial_in(info, UART_RX); /* read data port to reset things */ if (info->tty) set_bit(TTY_IO_ERROR, &info->tty->flags); if (p220_uart_config[info->state->type].flags & UART_STARTECH) { /* Arrange to enter sleep mode */ p220_serial_outp(info, UART_LCR, 0xBF); p220_serial_outp(info, UART_EFR, UART_EFR_ECB); p220_serial_outp(info, UART_IER, UART_IERX_SLEEP); p220_serial_outp(info, UART_LCR, 0); } if (info->state->type == PORT_16750) { /* Arrange to enter sleep mode */ p220_serial_outp(info, UART_IER, UART_IERX_SLEEP); } info->flags &= ~ASYNC_INITIALIZED; spin_unlock_irqrestore(&info->xmit_lock, flags); } /* * This routine is called to set the UART divisor registers to match * the specified baud rate for a serial port. */ static void p220_change_speed(struct async_struct *info, struct termios *old_termios) { unsigned short port; int quot = 0, baud_base, baud; unsigned cflag, cval, fcr = 0; int bits; unsigned long flags; if (!info->tty || !info->tty->termios) return; cflag = info->tty->termios->c_cflag; if (!(port = info->port)) return; /* byte size and parity */ switch (cflag & CSIZE) { case CS5: cval = 0x00; bits = 7; break; case CS6: cval = 0x01; bits = 8; break; case CS7: cval = 0x02; bits = 9; break; case CS8: cval = 0x03; bits = 10; break; /* Never happens, but GCC is too dumb to figure it out */ default: cval = 0x00; bits = 7; break; } if (cflag & CSTOPB) { cval |= 0x04; bits++; } if (cflag & PARENB) { cval |= UART_LCR_PARITY; bits++; } if (!(cflag & PARODD)) cval |= UART_LCR_EPAR; #ifdef CMSPAR if (cflag & CMSPAR) cval |= UART_LCR_SPAR; #endif /* Determine divisor based on baud rate */ baud = tty_get_baud_rate(info->tty); baud_base = info->state->baud_base; if (baud == 38400 && ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)) quot = info->state->custom_divisor; else { if (baud == 134) /* Special case since 134 is really 134.5 */ quot = (2*baud_base / 269); else if (baud) quot = baud_base / baud; } /* If the quotient is zero refuse the change */ if (!quot && old_termios) { info->tty->termios->c_cflag &= ~CBAUD; info->tty->termios->c_cflag |= (old_termios->c_cflag & CBAUD); baud = tty_get_baud_rate(info->tty); if (!baud) baud = 9600; if (baud == 38400 && ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)) quot = info->state->custom_divisor; else { if (baud == 134) /* Special case since 134 is really 134.5 */ quot = (2*baud_base / 269); else if (baud) quot = baud_base / baud; } } /* As a last resort, if the quotient is zero, default to 9600 bps */ if (!quot) quot = baud_base / 9600; info->quot = quot; info->timeout = ((info->xmit_fifo_size*HZ*bits*quot) / baud_base); info->timeout += HZ/50; /* Add .02 seconds of slop */ /* Set up FIFO's */ if (p220_uart_config[info->state->type].flags & UART_USE_FIFO) { if ((info->state->baud_base / quot) < 2400) fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_1; else fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_8; } if (info->state->type == PORT_16750) fcr |= UART_FCR7_64BYTE; /* CTS flow control flag and modem status interrupts */ info->IER &= ~UART_IER_MSI; if (info->flags & ASYNC_HARDPPS_CD) info->IER |= UART_IER_MSI; if (cflag & CRTSCTS) { info->flags |= ASYNC_CTS_FLOW; info->IER |= UART_IER_MSI; } else info->flags &= ~ASYNC_CTS_FLOW; if (cflag & CLOCAL) info->flags &= ~ASYNC_CHECK_CD; else { info->flags |= ASYNC_CHECK_CD; info->IER |= UART_IER_MSI; } p220_serial_out(info, UART_IER, info->IER); /* * Set up parity check flag */ #define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK)) info->read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR; if (I_INPCK(info->tty)) info->read_status_mask |= UART_LSR_FE | UART_LSR_PE; if (I_BRKINT(info->tty) || I_PARMRK(info->tty)) info->read_status_mask |= UART_LSR_BI; /* * Characters to ignore */ info->ignore_status_mask = 0; if (I_IGNPAR(info->tty)) info->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE; if (I_IGNBRK(info->tty)) { info->ignore_status_mask |= UART_LSR_BI; /* * If we're ignore parity and break indicators, ignore * overruns too. (For real raw support). */ if (I_IGNPAR(info->tty)) info->ignore_status_mask |= UART_LSR_OE; } /* * !!! ignore all characters if CREAD is not set */ if ((cflag & CREAD) == 0) info->ignore_status_mask |= UART_LSR_DR; spin_lock_irqsave(&info->xmit_lock, flags); if (p220_uart_config[info->state->type].flags & UART_STARTECH) { p220_serial_outp(info, UART_LCR, 0xBF); p220_serial_outp(info, UART_EFR, (cflag & CRTSCTS) ? UART_EFR_CTS : 0); } p220_serial_outp(info, UART_LCR, cval | UART_LCR_DLAB); /* set DLAB */ p220_serial_outp(info, UART_DLL, quot & 0xff); /* LS of divisor */ p220_serial_outp(info, UART_DLM, quot >> 8); /* MS of divisor */ if (info->state->type == PORT_16750) p220_serial_outp(info, UART_FCR, fcr); /* set fcr */ p220_serial_outp(info, UART_LCR, cval); /* reset DLAB */ if (info->state->type != PORT_16750) p220_serial_outp(info, UART_FCR, fcr); /* set fcr */ spin_unlock_irqrestore(&info->xmit_lock, flags); } static void p220_put_char(struct tty_struct *tty, unsigned char ch) { struct async_struct *info = (struct async_struct *)tty->driver_data; unsigned long flags; if (serial_paranoia_check(info, tty->name, "p220_put_char")) return; if (!tty || !info->xmit.buf) return; spin_lock_irqsave(&info->xmit_lock, flags); /*2001/03/15*/ if (CIRC_SPACE(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE) == 0) { spin_unlock_irqrestore(&info->xmit_lock, flags); return; } /*2001/03/15*/ info->xmit.buf[info->xmit.head] = ch; info->xmit.head = (info->xmit.head + 1) & (SERIAL_XMIT_SIZE-1); spin_unlock_irqrestore(&info->xmit_lock, flags); } static void p220_flush_chars(struct tty_struct *tty) { struct async_struct *info = (struct async_struct *)tty->driver_data; unsigned long flags; if (serial_paranoia_check(info, tty->name, "p220_flush_chars")) return; /*2001/03/15*/ if (info->xmit.head == info->xmit.tail || tty->stopped || tty->hw_stopped || !info->xmit.buf) return; spin_lock_irqsave(&info->xmit_lock, flags); info->IER |= UART_IER_THRI; p220_serial_out(info, UART_IER, info->IER); spin_unlock_irqrestore(&info->xmit_lock, flags); } static int p220_write(struct tty_struct * tty, const unsigned char *buf, int count) { int c, ret = 0; struct async_struct *info = (struct async_struct *)tty->driver_data; unsigned long flags; if (serial_paranoia_check(info, tty->name, "p220_write")) return 0; if (!tty || !info->xmit.buf || !atmp_buf) return 0; /********************* save_flags(flags); ***********************/ { spin_lock_irqsave(&info->xmit_lock, flags); while (1) { c = CIRC_SPACE_TO_END(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE); if (count < c) c = count; if (c <= 0) { break; } memcpy(info->xmit.buf + info->xmit.head, buf, c); info->xmit.head = ((info->xmit.head + c) & (SERIAL_XMIT_SIZE-1)); buf += c; count -= c; ret += c; } spin_unlock_irqrestore(&info->xmit_lock, flags); } if (info->xmit.head != info->xmit.tail && !tty->stopped && !tty->hw_stopped && !(info->IER & UART_IER_THRI)) { info->IER |= UART_IER_THRI; p220_serial_out(info, UART_IER, info->IER); } return ret; } static int p220_write_room(struct tty_struct *tty) { struct async_struct *info = (struct async_struct *)tty->driver_data; if (serial_paranoia_check(info, tty->name, "p220_write_room")) return 0; /*2001/03/15*/ return CIRC_SPACE(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE); } static int p220_chars_in_buffer(struct tty_struct *tty) { struct async_struct *info = (struct async_struct *)tty->driver_data; if (serial_paranoia_check(info, tty->name, "p220_chars_in_buffer")) return 0; /*2001/03/15*/ return CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE); } static void p220_flush_buffer(struct tty_struct *tty) { struct async_struct *info = (struct async_struct *)tty->driver_data; unsigned long flags; if (serial_paranoia_check(info, tty->name, "p220_flush_buffer")) return; spin_lock_irqsave(&info->xmit_lock, flags); info->xmit.head = info->xmit.tail = 0; spin_unlock_irqrestore(&info->xmit_lock, flags); wake_up_interruptible(&tty->write_wait); if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && tty->ldisc.write_wakeup) (tty->ldisc.write_wakeup)(tty); } /* * This function is used to send a high-priority XON/XOFF character to * the device */ static void p220_send_xchar(struct tty_struct *tty, char ch) { struct async_struct *info = (struct async_struct *)tty->driver_data; if (serial_paranoia_check(info, tty->name, "rs_send_char")) return; info->x_char = ch; if (ch) { /* * Add support tty device's flag in the "CLOSEING" state * don't enable transmit interrupt. 2001/05 yuchiehu */ if(info->flags & ASYNC_CLOSING) return; /* Make sure transmit interrupts are on */ info->IER |= UART_IER_THRI; p220_serial_out(info, UART_IER, info->IER); } } /* * ------------------------------------------------------------ * p220_throttle() * * This routine is called by the upper-layer tty layer to signal that * incoming characters should be throttled. * ------------------------------------------------------------ */ static void p220_throttle(struct tty_struct * tty) { struct async_struct *info = (struct async_struct *)tty->driver_data; unsigned long flags; #ifdef SERIAL_DEBUG_THROTTLE char buf[64]; printk("throttle %s: %d....\n", tty_name(tty, buf), tty->ldisc.chars_in_buffer(tty)); #endif if (serial_paranoia_check(info, tty->name, "p220_throttle")) return; if (I_IXOFF(tty)) p220_send_xchar(tty, STOP_CHAR(tty)); if (tty->termios->c_cflag & CRTSCTS) info->MCR &= ~UART_MCR_RTS; spin_lock_irqsave(&info->xmit_lock, flags); p220_serial_out(info, UART_MCR, info->MCR); spin_unlock_irqrestore(&info->xmit_lock, flags); } static void p220_unthrottle(struct tty_struct * tty) { struct async_struct *info = (struct async_struct *)tty->driver_data; unsigned long flags; #ifdef SERIAL_DEBUG_THROTTLE char buf[64]; printk("unthrottle %s: %d....\n", tty_name(tty, buf), tty->ldisc.chars_in_buffer(tty)); #endif if (serial_paranoia_check(info, tty->name, "p220_unthrottle")) return; if (I_IXOFF(tty)) { if (info->x_char) info->x_char = 0; else p220_send_xchar(tty, START_CHAR(tty)); } if (tty->termios->c_cflag & CRTSCTS) info->MCR |= UART_MCR_RTS; spin_lock_irqsave(&info->xmit_lock, flags); p220_serial_out(info, UART_MCR, info->MCR); spin_unlock_irqrestore(&info->xmit_lock, flags); } /* * ------------------------------------------------------------ * p220_ioctl() and friends * ------------------------------------------------------------ */ static int get_p220_serial_info(struct async_struct * info, struct serial_struct * retinfo) { struct serial_struct tmp; struct serial_state *state = info->state; if (!retinfo) return -EFAULT; memset(&tmp, 0, sizeof(tmp)); tmp.type = state->type; tmp.line = state->line; tmp.port = state->port; tmp.irq = state->irq; tmp.flags = state->flags; tmp.xmit_fifo_size = state->xmit_fifo_size; tmp.baud_base = state->baud_base; tmp.close_delay = state->close_delay; tmp.closing_wait = state->closing_wait; tmp.custom_divisor = state->custom_divisor; tmp.hub6 = state->hub6; if (copy_to_user(retinfo,&tmp,sizeof(*retinfo))) return -EFAULT; return 0; } static int set_p220_serial_info(struct async_struct * info, struct serial_struct * new_info) { struct serial_struct new_serial; struct serial_state old_state, *state; unsigned int i,change_irq,change_port; int retval = 0; if (copy_from_user(&new_serial,new_info,sizeof(new_serial))) return -EFAULT; state = info->state; old_state = *state; change_irq = new_serial.irq != state->irq; change_port = (new_serial.port != state->port) || (new_serial.hub6 != state->hub6); if (!capable(CAP_SYS_ADMIN)) { if (change_irq || change_port || (new_serial.baud_base != state->baud_base) || (new_serial.type != state->type) || (new_serial.close_delay != state->close_delay) || (new_serial.xmit_fifo_size != state->xmit_fifo_size) || ((new_serial.flags & ~ASYNC_USR_MASK) != (state->flags & ~ASYNC_USR_MASK))) return -EPERM; state->flags = ((state->flags & ~ASYNC_USR_MASK) | (new_serial.flags & ASYNC_USR_MASK)); info->flags = ((info->flags & ~ASYNC_USR_MASK) | (new_serial.flags & ASYNC_USR_MASK)); state->custom_divisor = new_serial.custom_divisor; goto check_and_exit; } if ((new_serial.irq >= NR_IRQS) || (new_serial.port > 0xffff) || (new_serial.baud_base < 9600)|| (new_serial.type < PORT_UNKNOWN) || (new_serial.type > PORT_MAX) || (new_serial.type == PORT_CIRRUS) || (new_serial.type == PORT_STARTECH)) { return -EINVAL; } if ((new_serial.type != state->type) || (new_serial.xmit_fifo_size <= 0)) new_serial.xmit_fifo_size = p220_uart_config[state->type].dfl_xmit_fifo_size; /* Make sure address is not already in use */ if (new_serial.type) { for (i = 0 ; i < NR_PORTS; i++) if ((state != &p220_rs_table[i]) && (p220_rs_table[i].port == new_serial.port) && p220_rs_table[i].type) return -EADDRINUSE; } if ((change_port || change_irq) && (state->count > 1)) return -EBUSY; /* * OK, past this point, all the error checking has been done. * At this point, we start making changes..... */ state->baud_base = new_serial.baud_base; state->flags = ((state->flags & ~ASYNC_FLAGS) | (new_serial.flags & ASYNC_FLAGS)); info->flags = ((state->flags & ~ASYNC_INTERNAL_FLAGS) | (info->flags & ASYNC_INTERNAL_FLAGS)); state->custom_divisor = new_serial.custom_divisor; state->type = new_serial.type; state->close_delay = new_serial.close_delay * HZ/100; state->closing_wait = new_serial.closing_wait * HZ/100; info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0; info->xmit_fifo_size = state->xmit_fifo_size = new_serial.xmit_fifo_size; release_region(state->port,8); if (change_port || change_irq) { /* * We need to shutdown the serial port at the old * port/irq combination. */ p220shutdown(info); state->irq = new_serial.irq; info->port = state->port = new_serial.port; info->hub6 = state->hub6 = new_serial.hub6; } request_region(state->port,8,"pciport(set)"); check_and_exit: if (!state->port || !state->type) return 0; if (state->flags & ASYNC_INITIALIZED) { if (((old_state.flags & ASYNC_SPD_MASK) != (state->flags & ASYNC_SPD_MASK)) || (old_state.custom_divisor != state->custom_divisor)) { if ((state->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI) info->tty->alt_speed = 57600; if ((state->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI) info->tty->alt_speed = 115200; if ((state->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI) info->tty->alt_speed = 230400; if ((state->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP) info->tty->alt_speed = 460800; p220_change_speed(info, 0); } } else retval = p220startup(info); return retval; } /* * get_lsr_info - get line status register info * * Purpose: Let user call ioctl() to get info when the UART physically * is emptied. On bus types like RS485, the transmitter must * release the bus after transmitting. This must be done when * the transmit shift register is empty, not be done when the * transmit holding register is empty. This functionality * allows an RS485 driver to be written in user space. */ static int p220_get_lsr_info(struct async_struct * info, unsigned int *value) { unsigned char status; unsigned int result; unsigned long flags; spin_lock_irqsave(&info->xmit_lock, flags); status = p220_serial_in(info, UART_LSR); spin_unlock_irqrestore(&info->xmit_lock, flags); result = ((status & UART_LSR_TEMT) ? TIOCSER_TEMT : 0); return put_user(result,value); } static int p220_modem_info(struct async_struct * info, unsigned int *value) { unsigned char control, status; unsigned int result; unsigned long flags; control = info->MCR; spin_lock_irqsave(&info->xmit_lock, flags); status = p220_serial_in(info, UART_MSR); spin_unlock_irqrestore(&info->xmit_lock, flags); result = ((control & UART_MCR_RTS) ? TIOCM_RTS : 0) | ((control & UART_MCR_DTR) ? TIOCM_DTR : 0) #ifdef TIOCM_OUT1 | ((control & UART_MCR_OUT1) ? TIOCM_OUT1 : 0) | ((control & UART_MCR_OUT2) ? TIOCM_OUT2 : 0) #endif | ((status & UART_MSR_DCD) ? TIOCM_CAR : 0) | ((status & UART_MSR_RI) ? TIOCM_RNG : 0) | ((status & UART_MSR_DSR) ? TIOCM_DSR : 0) | ((status & UART_MSR_CTS) ? TIOCM_CTS : 0); return put_user(result,value); } static int p220_set_modem_info(struct async_struct * info, unsigned int cmd, unsigned int *value) { int error; unsigned int arg; unsigned long flags; error = get_user(arg, value); if (error) return error; switch (cmd) { case TIOCMBIS: if (arg & TIOCM_RTS) info->MCR |= UART_MCR_RTS; if (arg & TIOCM_DTR) info->MCR |= UART_MCR_DTR; #ifdef TIOCM_OUT1 if (arg & TIOCM_OUT1) info->MCR |= UART_MCR_OUT1; if (arg & TIOCM_OUT2) info->MCR |= UART_MCR_OUT2; #endif break; case TIOCMBIC: if (arg & TIOCM_RTS) info->MCR &= ~UART_MCR_RTS; if (arg & TIOCM_DTR) info->MCR &= ~UART_MCR_DTR; #ifdef TIOCM_OUT1 if (arg & TIOCM_OUT1) info->MCR &= ~UART_MCR_OUT1; if (arg & TIOCM_OUT2) info->MCR &= ~UART_MCR_OUT2; #endif break; case TIOCMSET: info->MCR = ((info->MCR & ~(UART_MCR_RTS | #ifdef TIOCM_OUT1 UART_MCR_OUT1 | UART_MCR_OUT2 | #endif UART_MCR_DTR)) | ((arg & TIOCM_RTS) ? UART_MCR_RTS : 0) #ifdef TIOCM_OUT1 | ((arg & TIOCM_OUT1) ? UART_MCR_OUT1 : 0) | ((arg & TIOCM_OUT2) ? UART_MCR_OUT2 : 0) #endif | ((arg & TIOCM_DTR) ? UART_MCR_DTR : 0)); break; default: return -EINVAL; } spin_lock_irqsave(&info->xmit_lock, flags); p220_serial_out(info, UART_MCR, info->MCR); spin_unlock_irqrestore(&info->xmit_lock, flags); return 0; } static int do_p220_autoconfig(struct async_struct * info) { int retval; if (!capable(CAP_SYS_ADMIN)) return -EPERM; if (info->state->count > 1) return -EBUSY; p220shutdown(info); p220_autoconfig(info->state); if ((info->state->flags & ASYNC_AUTO_IRQ) && (info->state->port != 0) && (info->state->type != PORT_UNKNOWN)) info->state->irq = detect_p220_irq(info->state); retval = p220startup(info); if (retval) return retval; return 0; } /* * p220_break() --- routine which turns the break handling on or off */ static void p220_break(struct tty_struct *tty, int break_state) { struct async_struct * info = (struct async_struct *)tty->driver_data; unsigned long flags; if (serial_paranoia_check(info, tty->name, "p220_break")) return; if (!info->port) return; spin_lock_irqsave(&info->xmit_lock, flags); if (break_state == -1) p220_serial_out(info, UART_LCR, p220_serial_inp(info, UART_LCR) | UART_LCR_SBC); else p220_serial_out(info, UART_LCR, p220_serial_inp(info, UART_LCR) & ~UART_LCR_SBC); spin_unlock_irqrestore(&info->xmit_lock, flags); } #ifdef CONFIG_SERIAL_MULTIPORT static int p220_get_multiport_struct(struct async_struct * info, struct serial_multiport_struct *retinfo) { struct serial_multiport_struct ret; struct rs_multiport_struct *multi; multi = &p220_multiport[info->state->irq]; ret.port_monitor = multi->port_monitor; ret.port1 = multi->port1; ret.mask1 = multi->mask1; ret.match1 = multi->match1; ret.port2 = multi->port2; ret.mask2 = multi->mask2; ret.match2 = multi->match2; ret.port3 = multi->port3; ret.mask3 = multi->mask3; ret.match3 = multi->match3; ret.port4 = multi->port4; ret.mask4 = multi->mask4; ret.match4 = multi->match4; ret.irq = info->state->irq; if (copy_to_user(retinfo,&ret,sizeof(*retinfo))) return -EFAULT; return 0; } static int p220_set_multiport_struct(struct async_struct * info, struct serial_multiport_struct *in_multi) { struct serial_multiport_struct new_multi; struct rs_multiport_struct *multi; struct serial_state *state; int was_multi, now_multi; int retval; irqreturn_t (*handler)(int, void *, struct pt_regs *); if (!capable(CAP_SYS_ADMIN)) return -EPERM; state = info->state; if (copy_from_user(&new_multi, in_multi, sizeof(struct serial_multiport_struct))) return -EFAULT; if (new_multi.irq != state->irq || state->irq == 0 || !aIRQ_ports[state->irq]) return -EINVAL; multi = &p220_multiport[state->irq]; was_multi = (multi->port1 != 0); multi->port_monitor = new_multi.port_monitor; if (multi->port1) release_region(multi->port1,1); multi->port1 = new_multi.port1; multi->mask1 = new_multi.mask1; multi->match1 = new_multi.match1; if (multi->port1) request_region(multi->port1,1,"pciport(multiport1)"); if (multi->port2) release_region(multi->port2,1); multi->port2 = new_multi.port2; multi->mask2 = new_multi.mask2; multi->match2 = new_multi.match2; if (multi->port2) request_region(multi->port2,1,"serial(multiport2)"); if (multi->port3) release_region(multi->port3,1); multi->port3 = new_multi.port3; multi->mask3 = new_multi.mask3; multi->match3 = new_multi.match3; if (multi->port3) request_region(multi->port3,1,"serial(multiport3)"); if (multi->port4) release_region(multi->port4,1); multi->port4 = new_multi.port4; multi->mask4 = new_multi.mask4; multi->match4 = new_multi.match4; if (multi->port4) request_region(multi->port4,1,"serial(multiport4)"); now_multi = (multi->port1 != 0); if (aIRQ_ports[state->irq]->next_port && (was_multi != now_multi)) { free_irq(state->irq, &aIRQ_ports[state->irq]); if (now_multi) handler = p220_interrupt_multi; else handler = p220_interrupt; retval = request_irq(state->irq, handler, IRQ_T(info), "RAYONserial", &aIRQ_ports[state->irq]); if (retval) { printk("Couldn't reallocate serial interrupt " "driver!!\n"); } } return 0; } #endif static int p220_ioctl(struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg) { int error; struct async_struct * info = (struct async_struct *)tty->driver_data; struct async_icount cprev, cnow; /* kernel counter temps */ struct serial_icounter_struct *p_cuser; /* user space */ unsigned long flags; if (serial_paranoia_check(info, tty->name, "p220_ioctl")) return -ENODEV; if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) && (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGSTRUCT) && (cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) { if (tty->flags & (1 << TTY_IO_ERROR)) return -EIO; } switch (cmd) { case TIOCMGET: return p220_modem_info(info, (unsigned int *) arg); case TIOCMBIS: case TIOCMBIC: case TIOCMSET: return p220_set_modem_info(info, cmd, (unsigned int *) arg); case TIOCGSERIAL: return get_p220_serial_info(info, (struct serial_struct *) arg); case TIOCSSERIAL: return set_p220_serial_info(info, (struct serial_struct *) arg); case TIOCSERCONFIG: return do_p220_autoconfig(info); case TIOCSERGETLSR: /* Get line status register */ return p220_get_lsr_info(info, (unsigned int *) arg); case TIOCSERGSTRUCT: if (copy_to_user((struct async_struct *) arg, info, sizeof(struct async_struct))) return -EFAULT; return 0; #ifdef CONFIG_SERIAL_MULTIPORT case TIOCSERGETMULTI: return p220_get_multiport_struct(info, (struct serial_multiport_struct *) arg); case TIOCSERSETMULTI: return p220_set_multiport_struct(info, (struct serial_multiport_struct *) arg); #endif /* * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change * - mask passed in arg for lines of interest * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking) * Caller should use TIOCGICOUNT to see which one it was */ case TIOCMIWAIT: spin_lock_irqsave(&info->xmit_lock, flags); /* note the counters on entry */ cprev = info->state->icount; spin_unlock_irqrestore(&info->xmit_lock, flags); while (1) { wait_event_interruptible(info->delta_msr_wait, 0); /* see if a signal did it */ if (signal_pending(current)) return -ERESTARTSYS; spin_lock_irqsave(&info->xmit_lock, flags); cnow = info->state->icount; /* atomic copy */ spin_unlock_irqrestore(&info->xmit_lock, flags); if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr && cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) return -EIO; /* no change => error */ if ( ((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) || ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) || ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) || ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) { return 0; } cprev = cnow; } /* NOTREACHED */ /* * Get counter of input serial line interrupts (DCD,RI,DSR,CTS) * Return: write counters to the user passed counter struct * NB: both 1->0 and 0->1 transitions are counted except for * RI where only 0->1 is counted. */ case TIOCGICOUNT: spin_lock_irqsave(&info->xmit_lock, flags); cnow = info->state->icount; spin_unlock_irqrestore(&info->xmit_lock, flags); p_cuser = (struct serial_icounter_struct *) arg; error = put_user(cnow.cts, &p_cuser->cts); if (error) return error; error = put_user(cnow.dsr, &p_cuser->dsr); if (error) return error; error = put_user(cnow.rng, &p_cuser->rng); if (error) return error; error = put_user(cnow.dcd, &p_cuser->dcd); if (error) return error; error = put_user(cnow.rx, &p_cuser->rx); if (error) return error; error = put_user(cnow.tx, &p_cuser->tx); if (error) return error; error = put_user(cnow.frame, &p_cuser->frame); if (error) return error; error = put_user(cnow.overrun, &p_cuser->overrun); if (error) return error; error = put_user(cnow.parity, &p_cuser->parity); if (error) return error; error = put_user(cnow.brk, &p_cuser->brk); if (error) return error; error = put_user(cnow.buf_overrun, &p_cuser->buf_overrun); if (error) return error; return 0; case TIOCSERGWILD: case TIOCSERSWILD: /* "setserial -W" is called in Debian boot */ printk ("TIOCSER?WILD ioctl obsolete, ignored.\n"); return 0; default: return -ENOIOCTLCMD; } return 0; } static void p220_set_termios(struct tty_struct *tty, struct termios *old_termios) { struct async_struct *info = (struct async_struct *)tty->driver_data; unsigned long flags; if ( (tty->termios->c_cflag == old_termios->c_cflag) && ( RELEVANT_IFLAG(tty->termios->c_iflag) == RELEVANT_IFLAG(old_termios->c_iflag))) return; p220_change_speed(info, old_termios); /* Handle transition to B0 status */ if ((old_termios->c_cflag & CBAUD) && !(tty->termios->c_cflag & CBAUD)) { info->MCR &= ~(UART_MCR_DTR|UART_MCR_RTS); spin_lock_irqsave(&info->xmit_lock, flags); p220_serial_out(info, UART_MCR, info->MCR); spin_unlock_irqrestore(&info->xmit_lock, flags); } /* Handle transition away from B0 status */ if (!(old_termios->c_cflag & CBAUD) && (tty->termios->c_cflag & CBAUD)) { info->MCR |= UART_MCR_DTR; if (!(tty->termios->c_cflag & CRTSCTS) || !test_bit(TTY_THROTTLED, &tty->flags)) { info->MCR |= UART_MCR_RTS; } spin_lock_irqsave(&info->xmit_lock, flags); p220_serial_out(info, UART_MCR, info->MCR); spin_unlock_irqrestore(&info->xmit_lock, flags); } /* Handle turning off CRTSCTS */ if ((old_termios->c_cflag & CRTSCTS) && !(tty->termios->c_cflag & CRTSCTS)) { tty->hw_stopped = 0; p220_start(tty); } } /* * ------------------------------------------------------------ * p220_close() * * This routine is called when the serial port gets closed. First, we * wait for the last remaining data to be sent. Then, we unlink its * async structure from the interrupt chain if necessary, and we free * that IRQ if nothing is left in the chain. * ------------------------------------------------------------ */ static void p220_close(struct tty_struct *tty, struct file * filp) { struct async_struct * info = (struct async_struct *)tty->driver_data; struct serial_state *state; unsigned long flags; if (!info || serial_paranoia_check(info, tty->name, "p220_close")) return; state = info->state; spin_lock_irqsave(&info->xmit_lock, flags); if (tty_hung_up_p(filp)) { DBG_CNT("before DEC-hung"); spin_unlock_irqrestore(&info->xmit_lock, flags); return; } #ifdef SERIAL_DEBUG_OPEN printk("p220_close ttys%d, count = %d\n", info->line, state->count); #endif if ((tty->count == 1) && (state->count != 1)) { /* * Uh, oh. tty->count is 1, which means that the tty * structure will be freed. state->count should always * be one in these conditions. If it's greater than * one, we've got real problems, since it means the * serial port won't be shutdown. */ printk("p220_close: bad serial port count; tty->count is 1, " "state->count is %d\n", state->count); state->count = 1; } if (--state->count < 0) { printk("p220_close: bad serial port count for ttys%d: %d\n", info->line, state->count); state->count = 0; } if (state->count) { DBG_CNT("before DEC-2"); spin_unlock_irqrestore(&info->xmit_lock, flags); return; } info->flags |= ASYNC_CLOSING; /***WANG***/ spin_unlock_irqrestore(&info->xmit_lock, flags); /* * Save the termios structure, since this port may have * separate termios for callout and dialin. */ tty->closing = 1; if (info->closing_wait != ASYNC_CLOSING_WAIT_NONE) tty_wait_until_sent(tty, info->closing_wait); /* * At this point we stop accepting input. To do this, we * disable the receive line status interrupts, and tell the * interrupt driver to stop checking the data ready bit in the * line status register. */ info->IER &= ~UART_IER_RLSI; info->read_status_mask &= ~UART_LSR_DR; if (info->flags & ASYNC_INITIALIZED) { p220_serial_out(info, UART_IER, info->IER); /* * Before we drop DTR, make sure the UART transmitter * has completely drained; this is especially * important if there is a transmit FIFO! */ p220_wait_until_sent(tty, info->timeout); } p220shutdown(info); /* if (tty->driver->flush_buffer) tty->driver->flush_buffer(tty); */ if (tty->driver->ops->flush_buffer) tty_driver_flush_buffer(tty); if (tty->ldisc.flush_buffer) tty->ldisc.flush_buffer(tty); tty->closing = 0; info->event = 0; info->tty = 0; if (info->blocked_open) { if (info->close_delay) { current->state = TASK_INTERRUPTIBLE; schedule_timeout(info->close_delay); } wake_up_interruptible(&info->open_wait); } info->flags &= ~(ASYNC_NORMAL_ACTIVE| ASYNC_CLOSING); wake_up_interruptible(&info->close_wait); } /* * p220_wait_until_sent() --- wait until the transmitter is empty */ static void p220_wait_until_sent(struct tty_struct *tty, int timeout) { struct async_struct * info = (struct async_struct *)tty->driver_data; unsigned long orig_jiffies, char_time; int lsr; if (serial_paranoia_check(info, tty->name, "p220_wait_until_sent")) return; if (info->state->type == PORT_UNKNOWN) return; if (info->xmit_fifo_size == 0) return; /* Just in case.... */ orig_jiffies = jiffies; /* * Set the check interval to be 1/5 of the estimated time to * send a single character, and make it at least 1. The check * interval should also be less than the timeout. * * Note: we have to use pretty tight timings here to satisfy * the NIST-PCTS. */ char_time = (info->timeout - HZ/50) / info->xmit_fifo_size; char_time = char_time / 5; if (char_time == 0) char_time = 1; if (timeout) char_time = MIN(char_time, timeout); /* * If the transmitter hasn't cleared in twice the approximate * amount of time to send the entire FIFO, it probably won't * ever clear. This assumes the UART isn't doing flow * control, which is currently the case. Hence, if it ever * takes longer than info->timeout, this is probably due to a * UART bug of some kind. So, we clamp the timeout parameter at * 2*info->timeout. */ if (!timeout || timeout > 2*info->timeout) timeout = 2*info->timeout; #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT printk("In p220_wait_until_sent(%d) check=%lu...", timeout, char_time); printk("jiff=%lu...", jiffies); #endif while (!((lsr = p220_serial_inp(info, UART_LSR)) & UART_LSR_TEMT)) { #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT printk("lsr = %d (jiff=%lu)...", lsr, jiffies); #endif current->state = TASK_INTERRUPTIBLE; schedule_timeout(char_time); if (signal_pending(current)) break; if (timeout && time_after(jiffies, orig_jiffies + timeout)) break; } current->state = TASK_RUNNING; #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT printk("lsr = %d (jiff=%lu)...done\n", lsr, jiffies); #endif } /* * p220_hangup() --- called by tty_hangup() when a hangup is signaled. */ static void p220_hangup(struct tty_struct *tty) { struct async_struct * info = (struct async_struct *)tty->driver_data; struct serial_state *state = info->state; if (serial_paranoia_check(info, tty->name, "p220_hangup")) return; state = info->state; p220_flush_buffer(tty); p220shutdown(info); info->event = 0; state->count = 0; info->flags &= ~(ASYNC_NORMAL_ACTIVE); info->tty = 0; wake_up_interruptible(&info->open_wait); } /* * ------------------------------------------------------------ * p220_open() and friends * ------------------------------------------------------------ */ static int p220_block_til_ready(struct tty_struct *tty, struct file * filp, struct async_struct *info) { DECLARE_WAITQUEUE(wait, current); /*2001/03/13 yuchiehu*/ struct serial_state *state = info->state; int retval; int do_clocal = 0, extra_count = 0; unsigned long flags; #ifdef SERIAL_DEBUG_OPEN printk("it's block_til_ready!!\n"); #endif /* * If the device is in the middle of being closed, then block * until it's done, and then try again. */ if (tty_hung_up_p(filp) || (info->flags & ASYNC_CLOSING)) { if (info->flags & ASYNC_CLOSING) wait_event_interruptible(info->close_wait, !(info->flags & ASYNC_CLOSING)); #ifdef SERIAL_DO_RESTART return ((info->flags & ASYNC_HUP_NOTIFY) ? -EAGAIN : -ERESTARTSYS); #else return -EAGAIN; #endif } /* * If non-blocking mode is set, or the port is not enabled, * then make the check up front and then exit. */ if ((filp->f_flags & O_NONBLOCK) || (tty->flags & (1 << TTY_IO_ERROR))) { info->flags |= ASYNC_NORMAL_ACTIVE; return 0; } /*****WANG modify to support normal condition here *******/ if (tty->termios->c_cflag & CLOCAL) do_clocal = 1; /* * Block waiting for the carrier detect and the line to become * free (i.e., not in use by the callout). While we are in * this loop, state->count is dropped by one, so that * p220_close() knows when to free things. We restore it upon * exit, either normal or abnormal. */ retval = 0; add_wait_queue(&info->open_wait, &wait); #ifdef SERIAL_DEBUG_OPEN printk("p220_block_til_ready before block: ttys%d, count = %d\n", state->line, state->count); #endif spin_lock_irqsave(&info->xmit_lock, flags); if (!tty_hung_up_p(filp)) { extra_count = 1; state->count--; } spin_unlock_irqrestore(&info->xmit_lock, flags); info->blocked_open++; while (1) { spin_lock_irqsave(&info->xmit_lock, flags); p220_serial_out(info, UART_MCR, p220_serial_inp(info, UART_MCR) | (UART_MCR_DTR | UART_MCR_RTS)); spin_unlock_irqrestore(&info->xmit_lock, flags); current->state = TASK_INTERRUPTIBLE; if (tty_hung_up_p(filp) || !(info->flags & ASYNC_INITIALIZED)) { #ifdef SERIAL_DO_RESTART if (info->flags & ASYNC_HUP_NOTIFY) retval = -EAGAIN; else retval = -ERESTARTSYS; #else retval = -EAGAIN; #endif break; } if ( !(info->flags & ASYNC_CLOSING) && (do_clocal || (p220_serial_in(info, UART_MSR) & UART_MSR_DCD))) break; if (signal_pending(current)) { retval = -ERESTARTSYS; break; } #ifdef SERIAL_DEBUG_OPEN printk("p220_block_til_ready blocking: ttys%d, count = %d\n", info->line, state->count); #endif schedule(); } current->state = TASK_RUNNING; remove_wait_queue(&info->open_wait, &wait); if (extra_count) state->count++; info->blocked_open--; #ifdef SERIAL_DEBUG_OPEN printk("p220_block_til_ready after blocking: ttys%d, count = %d\n", info->line, state->count); #endif if (retval) return retval; info->flags |= ASYNC_NORMAL_ACTIVE; return 0; } static int p220_get_async_struct(int line, struct async_struct **ret_info) { struct async_struct *info; struct serial_state *sstate; sstate = p220_rs_table + line; sstate->count++; if (sstate->info) { *ret_info = sstate->info; return 0; } info = kmalloc(sizeof(struct async_struct), GFP_KERNEL); if (!info) { sstate->count--; return -ENOMEM; } memset(info, 0, sizeof(struct async_struct)); /*2001/03/14*/ init_waitqueue_head(&info->open_wait); init_waitqueue_head(&info->close_wait); init_waitqueue_head(&info->delta_msr_wait); /*yuchiehu*/ info->magic = SERIAL_MAGIC; info->port = sstate->port; info->flags = sstate->flags; /****WANG add for spin_lock ******/ spin_lock_init(&info->xmit_lock); /*2001/03/14*/ info->io_type = sstate->io_type; info->iomem_base = sstate->iomem_base; info->iomem_reg_shift = sstate->iomem_reg_shift; /*yuchiehu*/ info->xmit_fifo_size = sstate->xmit_fifo_size; info->line = line; //INIT_WORK(&info->work, p220_do_softint, info); INIT_WORK(&info->work, p220_do_softint); info->state = sstate; if (sstate->info) { /*2001/03/15*/ /*kfree_s(info, sizeof(struct async_struct)); */ kfree(info); *ret_info = sstate->info; return 0; } *ret_info = sstate->info = info; return 0; } /* * This routine is called whenever a serial port is opened. It * enables interrupts for a serial port, linking in its async structure into * the IRQ chain. It also performs the serial-specific * initialization for the tty structure. */ static int p220_open(struct tty_struct *tty, struct file * filp) { struct async_struct *info; int retval, line; unsigned long page; #ifdef SERIAL_DEBUG_OPEN printk("p220_open 0\n"); #endif line = tty->index; if ((line < 0) || (line >= NR_PORTS)) { return -ENODEV; } retval = p220_get_async_struct(line, &info); if (retval) { return retval; } tty->driver_data = info; info->tty = tty; if (serial_paranoia_check(info, tty->name, "p220_open")) { /* MOD_DEC_USE_COUNT; "info->tty" will cause this */ return -ENODEV; } info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0; if (!atmp_buf) { page = get_zeroed_page(GFP_KERNEL); if (!page) { return -ENOMEM; } if (atmp_buf) free_page(page); else atmp_buf = (unsigned char *) page; } /* * If the port is the middle of closing, bail out now */ if (tty_hung_up_p(filp) || (info->flags & ASYNC_CLOSING)) { if (info->flags & ASYNC_CLOSING) wait_event_interruptible(info->close_wait, !(info->flags & ASYNC_CLOSING)); #ifdef SERIAL_DO_RESTART return ((info->flags & ASYNC_HUP_NOTIFY) ? -EAGAIN : -ERESTARTSYS); #else return -EAGAIN; #endif } /* * Start up serial port */ retval = p220startup(info); if (retval) { /* MOD_DEC_USE_COUNT; "info->tty" will cause this? */ return retval; } #ifdef SERIAL_DEBUG_OPEN printk("p220_open 1\n"); #endif /****WANG move to here for correct port to start polling *****/ mod_timer(&p220_serial_timer, jiffies + RS_STROBE_TIME); retval = p220_block_til_ready(tty, filp, info); if (retval) { /* MOD_DEC_USE_COUNT; "info->tty" will cause this? */ #ifdef SERIAL_DEBUG_OPEN printk("p220_open returning after p220_block_til_ready with %d\n", retval); #endif return retval; } if ((info->state->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) { p220_change_speed(info, 0); } #ifdef CONFIG_SERIAL_CONSOLE if (p220_sercons.cflag && p220_sercons.index == line) { tty->termios->c_cflag = p220_sercons.cflag; p220_sercons.cflag = 0; p220_change_speed(info, 0); } #endif #ifdef SERIAL_DEBUG_OPEN printk("p220_open ttys%d successful...", info->line); #endif return 0; } /* * /proc fs routines.... */ static inline int p220_line_info(char *buf, struct serial_state *state) { struct async_struct *info = state->info, scr_info; char stat_buf[30], control, status; int ret; unsigned long flags; ret = sprintf(buf, "%d: uart:%s port:%X irq:%d", state->line, p220_uart_config[state->type].name, state->port, state->irq); if (!state->port || (state->type == PORT_UNKNOWN)) { ret += sprintf(buf+ret, "\n"); return ret; } /* * Figure out the current RS-232 lines */ if (!info) { info = &scr_info; /* This is just for serial_{in,out} */ info->magic = SERIAL_MAGIC; info->port = state->port; info->flags = state->flags; info->quot = 0; info->tty = 0; /***WANG add for spin_lock******/ spin_lock_init(&info->xmit_lock); } spin_lock_irqsave(&info->xmit_lock, flags); status = p220_serial_in(info, UART_MSR); control = info ? info->MCR : p220_serial_in(info, UART_MCR); spin_unlock_irqrestore(&info->xmit_lock, flags); stat_buf[0] = 0; stat_buf[1] = 0; if (control & UART_MCR_RTS) strcat(stat_buf, "|RTS"); if (status & UART_MSR_CTS) strcat(stat_buf, "|CTS"); if (control & UART_MCR_DTR) strcat(stat_buf, "|DTR"); if (status & UART_MSR_DSR) strcat(stat_buf, "|DSR"); if (status & UART_MSR_DCD) strcat(stat_buf, "|CD"); if (status & UART_MSR_RI) strcat(stat_buf, "|RI"); if (info->quot) { ret += sprintf(buf+ret, " baud:%d", state->baud_base / info->quot); } ret += sprintf(buf+ret, " tx:%d rx:%d", state->icount.tx, state->icount.rx); if (state->icount.frame) ret += sprintf(buf+ret, " fe:%d", state->icount.frame); if (state->icount.parity) ret += sprintf(buf+ret, " pe:%d", state->icount.parity); if (state->icount.brk) ret += sprintf(buf+ret, " brk:%d", state->icount.brk); if (state->icount.overrun) ret += sprintf(buf+ret, " oe:%d", state->icount.overrun); /* * Last thing is the RS-232 status lines */ ret += sprintf(buf+ret, " %s\n", stat_buf+1); return ret; } int p220_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data) { int i, len = 0, l; off_t begin = 0; len += sprintf(page, "serinfo:1.0 driver:%s\n", serial_version); for (i = 0; i < NR_PORTS && len < 4000; i++) { l = p220_line_info(page + len, &p220_rs_table[i]); len += l; if (len+begin > off+count) goto done; if (len+begin < off) { begin += len; len = 0; } } *eof = 1; done: if (off >= len+begin) return 0; *start = page + (begin-off); return ((count < begin+len-off) ? count : begin+len-off); } /* * --------------------------------------------------------------------- * RPort_init() and friends * * RPort_init() is called at boot-time to initialize the serial driver. * --------------------------------------------------------------------- */ /* * This routine detect the IRQ of a serial port by clearing OUT2 when * no UART interrupt are requested (IER = 0) (*GPL*). This seems to work at * each time, as long as no other device permanently request the IRQ. * If no IRQ is detected, or multiple IRQ appear, this function returns 0. * The variable "state" and the field "state->port" should not be null. */ static unsigned detect_p220_irq (struct serial_state * state) { int irq; unsigned long irqs; unsigned char save_mcr, save_ier; struct async_struct scr_info; /* serial_{in,out} because HUB6 */ scr_info.magic = SERIAL_MAGIC; scr_info.port = state->port; scr_info.flags = state->flags; /* forget possible initially masked and pending IRQ */ probe_irq_off(probe_irq_on()); save_mcr = p220_serial_inp(&scr_info, UART_MCR); save_ier = p220_serial_inp(&scr_info, UART_IER); p220_serial_outp(&scr_info, UART_MCR, UART_MCR_OUT1 | UART_MCR_OUT2); irqs = probe_irq_on(); p220_serial_outp(&scr_info, UART_MCR, 0); udelay (10); if (state->flags & ASYNC_FOURPORT) { p220_serial_outp(&scr_info, UART_MCR, UART_MCR_DTR | UART_MCR_RTS); } else { p220_serial_outp(&scr_info, UART_MCR, UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2); } p220_serial_outp(&scr_info, UART_IER, 0x0f); /* enable all intrs */ (void)p220_serial_inp(&scr_info, UART_LSR); (void)p220_serial_inp(&scr_info, UART_RX); (void)p220_serial_inp(&scr_info, UART_IIR); (void)p220_serial_inp(&scr_info, UART_MSR); p220_serial_outp(&scr_info, UART_TX, 0xFF); udelay (20); irq = probe_irq_off(irqs); p220_serial_outp(&scr_info, UART_MCR, save_mcr); p220_serial_outp(&scr_info, UART_IER, save_ier); return (irq > 0)? irq : 0; } /* * This routine is called by RPort_init() to initialize a specific serial * port. It determines what type of UART chip this serial port is * using: 8250, 16450, 16550, 16550A. The important question is * whether or not this UART is a 16550A, since this will determine * whether or not we can use its FIFO features. */ static void p220_autoconfig(struct serial_state * state) { unsigned char scratch, scratch2; struct async_struct *info, scr_info; state->type = PORT_UNKNOWN; if (!state->port) return; info = &scr_info; /* This is just for serial_{in,out} */ info->port = state->port; scratch2 = p220_serial_in(info, UART_LCR); p220_serial_outp(info, UART_LCR, 0); p220_serial_outp(info, UART_FCR, UART_FCR_ENABLE_FIFO); scratch = p220_serial_in(info, UART_IIR) >> 6; state->type = PORT_16550A; /*WANG*/ p220_serial_outp(info, UART_LCR, scratch2); state->xmit_fifo_size = p220_uart_config[state->type].dfl_xmit_fifo_size; } unsigned int p220_detect_device(void) { unsigned int retval,chkval,i; int tmp,indexadapter,indexport; int choice=0; unsigned char dipinp,stusbyte; unsigned int dpr,dsr,dcr,ecr; unsigned char *idcode="RAYONY2KCHINTELIN"; unsigned char *idcode984="BitRayon"; unsigned int base1[8],base2[8],irq[8],jpNum[8],portNum[8]; unsigned int base3[8],base4[8]; unsigned int cardnum[8],choicesum[8],ncard,lastindexport; /*HUS*/ retval = 0; { unsigned char intr; unsigned short pci_ssys_id, pci_sven_id; unsigned int portbase,stusbase,pci_class; unsigned int portbase2=0,portbase3=0,portbase4=0; unsigned int portbase5,portbase6; unsigned int chk=0; unsigned int raypcisum=0; struct pci_dev *pdev = NULL; cardstart=0; { while ((pdev = pci_get_device(RAYON_VENDOR_ID1,RAYON_DEVICE_ID, pdev))) { if (pci_enable_device(pdev)) continue; pci_ssys_id = pdev->subsystem_device; pci_sven_id = pdev->subsystem_vendor; portbase = pci_resource_start (pdev, 2); if(portbase==0) portbase = pci_resource_start (pdev, 0); stusbase = pci_resource_start (pdev, 3); intr = pdev->irq; pci_class = pdev->class; pci_class &= ~7; stusbyte = 0; if((pci_sven_id == RAYON_SVEN_ID || pci_sven_id == RAYON_SVEN_ID2)) { #if MESSG printk("sys %x|ven %x|port %x|stus %x|int %x \n",pci_ssys_id,pci_sven_id,portbase,stusbase,intr); #endif choice = -1; indexport = 0; chkval = 0; indexadapter= 0; ncard=0; switch ( pci_ssys_id + pci_sven_id) { case 0x263d : choice = P588; indexport = pcardname[choice].portnum; stusbyte = ( inb(stusbase+2) ); indexadapter = ( stusbyte >> 7 ); if(indexadapter==0) ncard=1; else ncard=2; statusbase[indexadapter] = stusbase; dipinp = 0; outb(dipinp,stusbase+3); for (retval = 0 ; retval < 9 ; retval ++) { chkval += inb(stusbase+2) & 0x7f ; } if (chkval != pcardname[choice].dpsum) { choice = -1; continue; } break; case 0x2639 : choice = P584; indexport = pcardname[choice].portnum; stusbyte = ( inb(stusbase+2) ); indexadapter = ( stusbyte >> 7 ); if(indexadapter==0) ncard=3; else ncard=4; dipinp = 0; outb(dipinp,stusbase+3); for (retval = 0 ; retval < 9 ; retval ++) { chkval += inb(stusbase+2) & 0x7f ; } if (chkval != pcardname[choice].dpsum) { choice = -1; continue; } break; case 0x21d9 : choice = P124; indexport = pcardname[choice].portnum; indexadapter = ( inb(stusbase+3) & 3 ); if(indexadapter==0) ncard=5; else ncard=6; dipinp = 0; outb(dipinp,stusbase+2); dipinp = 'R'; for (retval = 0 ; retval < 8 ; retval ++) { chkval = chkval+dipinp; outb(dipinp,stusbase+2); dipinp = ~ inb(stusbase+2); } if (chkval != pcardname[choice].dpsum) { choice = -1; continue; } stusbyte = ( inb(stusbase+3) ); break; case 0x25cd: choice = P518; indexport = pcardname[choice].portnum; chkval = 0; indexadapter = ( inb(stusbase+3) & 7 ); ncard=indexadapter+7; dipinp = 0; outb(dipinp,stusbase+2); dipinp = 'R'; for (retval = 0 ; retval < 8 ; retval ++) { chkval = chkval+dipinp; outb(dipinp,stusbase+2); dipinp = ~ inb(stusbase+2); } if (chkval != pcardname[choice].dpsum) { choice = -1; continue; } stusbyte = ( inb(stusbase+3) ); break; case 0x25c9: choice = P514; indexport = pcardname[choice].portnum; chkval = 0; indexadapter = ( inb(stusbase+3) & 7 ); ncard=indexadapter+15; dipinp = 0; outb(dipinp,stusbase+2); dipinp = 'R'; for (retval = 0 ; retval < 8 ; retval ++) { chkval = chkval+dipinp; outb(dipinp,stusbase+2); dipinp = ~ inb(stusbase+2); } if (chkval != pcardname[choice].dpsum) { choice = -1; continue; } stusbyte = ( inb(stusbase+3) ); break; case 0x22d5 : choice = P220; indexport = pcardname[choice].portnum; portbase2=portbase+0x8; dpr=portbase + 0x10; dsr=portbase + 0x11; dcr=portbase + 0x12; ecr=portbase + 0x1a; outb(0x15,ecr); outb(0x0,dpr); outb(0x0,dcr); outb(0x02,dcr); outb(0x0,dcr); for (retval = 0 ; retval < 17 ; retval ++) { dipinp=idcode[retval]; outb(dipinp,dpr); chk+=inb(dpr); outb(0x02,dcr); outb(0x0,dcr); } outb(0x04,dcr); stusbyte=inb(dsr); indexadapter = ( (stusbyte & 0x60) >> 5 ); ncard=indexadapter+23; chkval=stusbyte & 0x80; if (chkval != 0x80 && chk != pcardname[choice].dpsum) { choice = -1; continue; } break; case 0x24d7: portbase = pci_resource_start (pdev, 0); portbase2 = pci_resource_start (pdev, 1); portbase3 = pci_resource_start (pdev, 2); portbase4 = pci_resource_start (pdev, 3); choice = P220; indexport = pcardname[choice].portnum; dpr=portbase3 + 0x0; dsr=portbase3 + 0x1; dcr=portbase3 + 0x2; ecr=portbase4 + 0xa; outb(0x15,ecr); outb(0x0,dpr); outb(0x0,dcr); outb(0x02,dcr); outb(0x0,dcr); for (retval = 0 ; retval < 17 ; retval ++) { dipinp=idcode[retval]; outb(dipinp,dpr); chk+=inb(dpr); outb(0x02,dcr); outb(0x0,dcr); } outb(0x04,dcr); stusbyte=inb(dsr); indexadapter = ( (stusbyte & 0x60) >> 5 ); ncard=indexadapter+27; chkval=stusbyte & 0x80; if (chkval != 0x80 && chk != pcardname[choice].dpsum) { choice = -1; continue; } break; case 0x22e7: portbase = pci_resource_start (pdev, 0); portbase2 = pci_resource_start (pdev, 1); portbase3 = pci_resource_start (pdev, 2); portbase4 = pci_resource_start (pdev, 3); choice = P220; indexport = pcardname[choice].portnum; dpr=portbase3 + 0x0; dsr=portbase3 + 0x1; dcr=portbase3 + 0x2; ecr=portbase4 + 0xa; outb(0x15,ecr); outb(0x0,dpr); outb(0x0,dcr); outb(0x02,dcr); outb(0x0,dcr); for (retval = 0 ; retval < 17 ; retval ++) { dipinp=idcode[retval]; outb(dipinp,dpr); chk+=inb(dpr); outb(0x02,dcr); outb(0x0,dcr); } outb(0x04,dcr); stusbyte=inb(dsr); indexadapter = 0; ncard=indexadapter+27; chkval=stusbyte & 0x80; break; // RJ422,P984 case 0x1014: portbase = pci_resource_start (pdev, 0); portbase2 = pci_resource_start (pdev, 1); portbase3 = pci_resource_start (pdev, 5); portbase4 = pci_resource_start (pdev, 4); portbase5 = pci_resource_start (pdev, 3); portbase6 = pci_resource_start (pdev, 2); #if MESSG printk("this is P984 card base=%x,%x,%x,%x,%x,%x \n",portbase,portbase2,portbase3,portbase4,portbase5,portbase6); #endif choice = P984; indexport = pcardname[choice].portnum; for (retval = 0 ; retval < 8 ; retval ++) { dipinp=idcode[retval]; chk+=inb(portbase6+retval); } outb(0x0, portbase5); for (retval = 0 ; retval < 8 ; retval ++) { dipinp=idcode984[retval]; outb(dipinp,portbase5); } stusbyte=inb(portbase5); indexadapter = stusbyte & 0x01; ncard=indexadapter+31; chkval=stusbyte & 0x80; if (chkval != 0x80 && chk != pcardname[choice].dpsum) { choice = -1; #if MESSG printk("we have error in P984 check %x, %x\n",chk,stusbyte); #endif continue; } break; default: break; } if ( choice == -1) continue; cardnum[raypcisum]=ncard; base1[raypcisum]=portbase; base2[raypcisum]=portbase2; base3[raypcisum]=portbase3; base4[raypcisum]=portbase4; portNum[raypcisum]=indexport; irq[raypcisum]=intr; jpNum[raypcisum]=indexadapter; choicesum[raypcisum]=choice; raypcisum++; } // match if } // match while while ((pdev = pci_get_device(RAYON_VENDOR_ID2,RAYON_DEVICE_ID, pdev))) { if (pci_enable_device(pdev)) continue; pci_ssys_id = pdev->subsystem_device; pci_sven_id = pdev->subsystem_vendor; portbase = pci_resource_start (pdev, 2); if(portbase==0) portbase = pci_resource_start (pdev, 0); stusbase = pci_resource_start (pdev, 3); intr = pdev->irq; pci_class = pdev->class; pci_class &= ~7; stusbyte = 0; if((pci_sven_id == RAYON_SVEN_ID || pci_sven_id == RAYON_SVEN_ID2)) { #if MESSG printk("sys %x|ven %x|port %x|stus %x|int %x \n",pci_ssys_id,pci_sven_id,portbase,stusbase,intr); #endif choice = -1; indexport = 0; chkval = 0; indexadapter= 0; ncard=0; switch ( pci_ssys_id + pci_sven_id) { case 0x263d : choice = P588; indexport = pcardname[choice].portnum; stusbyte = ( inb(stusbase+2) ); indexadapter = ( stusbyte >> 7 ); if(indexadapter==0) ncard=1; else ncard=2; statusbase[indexadapter] = stusbase; dipinp = 0; outb(dipinp,stusbase+3); for (retval = 0 ; retval < 9 ; retval ++) { chkval += inb(stusbase+2) & 0x7f ; } if (chkval != pcardname[choice].dpsum) { choice = -1; continue; } break; case 0x2639 : choice = P584; indexport = pcardname[choice].portnum; stusbyte = ( inb(stusbase+2) ); indexadapter = ( stusbyte >> 7 ); if(indexadapter==0) ncard=3; else ncard=4; dipinp = 0; outb(dipinp,stusbase+3); for (retval = 0 ; retval < 9 ; retval ++) { chkval += inb(stusbase+2) & 0x7f ; } if (chkval != pcardname[choice].dpsum) { choice = -1; continue; } break; case 0x21d9 : choice = P124; indexport = pcardname[choice].portnum; indexadapter = ( inb(stusbase+3) & 3 ); if(indexadapter==0) ncard=5; else ncard=6; dipinp = 0; outb(dipinp,stusbase+2); dipinp = 'R'; for (retval = 0 ; retval < 8 ; retval ++) { chkval = chkval+dipinp; outb(dipinp,stusbase+2); dipinp = ~ inb(stusbase+2); } if (chkval != pcardname[choice].dpsum) { choice = -1; continue; } stusbyte = ( inb(stusbase+3) ); break; case 0x25cd: choice = P518; indexport = pcardname[choice].portnum; chkval = 0; indexadapter = ( inb(stusbase+3) & 7 ); ncard=indexadapter+7; dipinp = 0; outb(dipinp,stusbase+2); dipinp = 'R'; for (retval = 0 ; retval < 8 ; retval ++) { chkval = chkval+dipinp; outb(dipinp,stusbase+2); dipinp = ~ inb(stusbase+2); } if (chkval != pcardname[choice].dpsum) { choice = -1; continue; } stusbyte = ( inb(stusbase+3) ); break; case 0x25c9: choice = P514; indexport = pcardname[choice].portnum; chkval = 0; indexadapter = ( inb(stusbase+3) & 7 ); ncard=indexadapter+15; dipinp = 0; outb(dipinp,stusbase+2); dipinp = 'R'; for (retval = 0 ; retval < 8 ; retval ++) { chkval = chkval+dipinp; outb(dipinp,stusbase+2); dipinp = ~ inb(stusbase+2); } if (chkval != pcardname[choice].dpsum) { choice = -1; continue; } stusbyte = ( inb(stusbase+3) ); break; case 0x22d5 : choice = P220; indexport = pcardname[choice].portnum; portbase2=portbase+0x8; dpr=portbase + 0x10; dsr=portbase + 0x11; dcr=portbase + 0x12; ecr=portbase + 0x1a; outb(0x15,ecr); outb(0x0,dpr); outb(0x0,dcr); outb(0x02,dcr); outb(0x0,dcr); for (retval = 0 ; retval < 17 ; retval ++) { dipinp=idcode[retval]; outb(dipinp,dpr); chk+=inb(dpr); outb(0x02,dcr); outb(0x0,dcr); } outb(0x04,dcr); stusbyte=inb(dsr); indexadapter = ( (stusbyte & 0x60) >> 5 ); ncard=indexadapter+23; chkval=stusbyte & 0x80; if (chkval != 0x80 && chk != pcardname[choice].dpsum) { choice = -1; continue; } break; case 0x24d7: portbase = pci_resource_start (pdev, 0); portbase2 = pci_resource_start (pdev, 1); portbase3 = pci_resource_start (pdev, 2); portbase4 = pci_resource_start (pdev, 3); choice = P220; indexport = pcardname[choice].portnum; dpr=portbase3 + 0x0; dsr=portbase3 + 0x1; dcr=portbase3 + 0x2; ecr=portbase4 + 0xa; outb(0x15,ecr); outb(0x0,dpr); outb(0x0,dcr); outb(0x02,dcr); outb(0x0,dcr); for (retval = 0 ; retval < 17 ; retval ++) { dipinp=idcode[retval]; outb(dipinp,dpr); chk+=inb(dpr); outb(0x02,dcr); outb(0x0,dcr); } outb(0x04,dcr); stusbyte=inb(dsr); indexadapter = ( (stusbyte & 0x60) >> 5 ); ncard=indexadapter+27; chkval=stusbyte & 0x80; if (chkval != 0x80 && chk != pcardname[choice].dpsum) { choice = -1; continue; } break; case 0x22e7: portbase = pci_resource_start (pdev, 0); portbase2 = pci_resource_start (pdev, 1); portbase3 = pci_resource_start (pdev, 2); portbase4 = pci_resource_start (pdev, 3); choice = P220; indexport = pcardname[choice].portnum; dpr=portbase3 + 0x0; dsr=portbase3 + 0x1; dcr=portbase3 + 0x2; ecr=portbase4 + 0xa; outb(0x15,ecr); outb(0x0,dpr); outb(0x0,dcr); outb(0x02,dcr); outb(0x0,dcr); for (retval = 0 ; retval < 17 ; retval ++) { dipinp=idcode[retval]; outb(dipinp,dpr); chk+=inb(dpr); outb(0x02,dcr); outb(0x0,dcr); } outb(0x04,dcr); stusbyte=inb(dsr); indexadapter = 0; ncard=indexadapter+27; chkval=stusbyte & 0x80; break; // RJ422,P984 case 0x1014: portbase = pci_resource_start (pdev, 0); portbase2 = pci_resource_start (pdev, 1); portbase3 = pci_resource_start (pdev, 5); portbase4 = pci_resource_start (pdev, 4); portbase5 = pci_resource_start (pdev, 3); portbase6 = pci_resource_start (pdev, 2); #if MESSG printk("this is P984 card base=%x,%x,%x,%x,%x,%x \n",portbase,portbase2,portbase3,portbase4,portbase5,portbase6); #endif choice = P984; indexport = pcardname[choice].portnum; for (retval = 0 ; retval < 8 ; retval ++) { dipinp=idcode[retval]; chk+=inb(portbase6+retval); } outb(0x0, portbase5); for (retval = 0 ; retval < 8 ; retval ++) { dipinp=idcode984[retval]; outb(dipinp,portbase5); } stusbyte=inb(portbase5); indexadapter = stusbyte & 0x01; ncard=indexadapter+31; chkval=stusbyte & 0x80; if (chkval != 0x80 && chk != pcardname[choice].dpsum) { choice = -1; #if MESSG printk("we have error in P984 check %x, %x\n",chk,stusbyte); #endif continue; } break; default: break; } if ( choice == -1) continue; cardnum[raypcisum]=ncard; base1[raypcisum]=portbase; base2[raypcisum]=portbase2; base3[raypcisum]=portbase3; base4[raypcisum]=portbase4; portNum[raypcisum]=indexport; irq[raypcisum]=intr; jpNum[raypcisum]=indexadapter; choicesum[raypcisum]=choice; raypcisum++; } // match if } // match while while ((pdev = pci_get_device(RAYON_VENDOR_ID3,RAYON_DEVICE_ID2, pdev))) { if (pci_enable_device(pdev)) continue; pci_ssys_id = pdev->subsystem_device; pci_sven_id = pdev->subsystem_vendor; portbase = pci_resource_start (pdev, 2); if(portbase==0) portbase = pci_resource_start (pdev, 0); stusbase = pci_resource_start (pdev, 3); intr = pdev->irq; pci_class = pdev->class; pci_class &= ~7; stusbyte = 0; if((pci_sven_id == RAYON_SVEN_ID || pci_sven_id == RAYON_SVEN_ID2)) { #if MESSG printk("sys %x|ven %x|port %x|stus %x|int %x \n",pci_ssys_id,pci_sven_id,portbase,stusbase,intr); #endif choice = -1; indexport = 0; chkval = 0; indexadapter= 0; ncard=0; switch ( pci_ssys_id + pci_sven_id) { case 0x263d : choice = P588; indexport = pcardname[choice].portnum; stusbyte = ( inb(stusbase+2) ); indexadapter = ( stusbyte >> 7 ); if(indexadapter==0) ncard=1; else ncard=2; statusbase[indexadapter] = stusbase; dipinp = 0; outb(dipinp,stusbase+3); for (retval = 0 ; retval < 9 ; retval ++) { chkval += inb(stusbase+2) & 0x7f ; } if (chkval != pcardname[choice].dpsum) { choice = -1; continue; } break; case 0x2639 : choice = P584; indexport = pcardname[choice].portnum; stusbyte = ( inb(stusbase+2) ); indexadapter = ( stusbyte >> 7 ); if(indexadapter==0) ncard=3; else ncard=4; dipinp = 0; outb(dipinp,stusbase+3); for (retval = 0 ; retval < 9 ; retval ++) { chkval += inb(stusbase+2) & 0x7f ; } if (chkval != pcardname[choice].dpsum) { choice = -1; continue; } break; case 0x21d9 : choice = P124; indexport = pcardname[choice].portnum; indexadapter = ( inb(stusbase+3) & 3 ); if(indexadapter==0) ncard=5; else ncard=6; dipinp = 0; outb(dipinp,stusbase+2); dipinp = 'R'; for (retval = 0 ; retval < 8 ; retval ++) { chkval = chkval+dipinp; outb(dipinp,stusbase+2); dipinp = ~ inb(stusbase+2); } if (chkval != pcardname[choice].dpsum) { choice = -1; continue; } stusbyte = ( inb(stusbase+3) ); break; case 0x25cd: choice = P518; indexport = pcardname[choice].portnum; chkval = 0; indexadapter = ( inb(stusbase+3) & 7 ); ncard=indexadapter+7; dipinp = 0; outb(dipinp,stusbase+2); dipinp = 'R'; for (retval = 0 ; retval < 8 ; retval ++) { chkval = chkval+dipinp; outb(dipinp,stusbase+2); dipinp = ~ inb(stusbase+2); } if (chkval != pcardname[choice].dpsum) { choice = -1; continue; } stusbyte = ( inb(stusbase+3) ); break; case 0x25c9: choice = P514; indexport = pcardname[choice].portnum; chkval = 0; indexadapter = ( inb(stusbase+3) & 7 ); ncard=indexadapter+15; dipinp = 0; outb(dipinp,stusbase+2); dipinp = 'R'; for (retval = 0 ; retval < 8 ; retval ++) { chkval = chkval+dipinp; outb(dipinp,stusbase+2); dipinp = ~ inb(stusbase+2); } if (chkval != pcardname[choice].dpsum) { choice = -1; continue; } stusbyte = ( inb(stusbase+3) ); break; case 0x22d5 : choice = P220; indexport = pcardname[choice].portnum; portbase2=portbase+0x8; dpr=portbase + 0x10; dsr=portbase + 0x11; dcr=portbase + 0x12; ecr=portbase + 0x1a; outb(0x15,ecr); outb(0x0,dpr); outb(0x0,dcr); outb(0x02,dcr); outb(0x0,dcr); for (retval = 0 ; retval < 17 ; retval ++) { dipinp=idcode[retval]; outb(dipinp,dpr); chk+=inb(dpr); outb(0x02,dcr); outb(0x0,dcr); } outb(0x04,dcr); stusbyte=inb(dsr); indexadapter = ( (stusbyte & 0x60) >> 5 ); ncard=indexadapter+23; chkval=stusbyte & 0x80; if (chkval != 0x80 && chk != pcardname[choice].dpsum) { choice = -1; continue; } break; case 0x24d7: portbase = pci_resource_start (pdev, 0); portbase2 = pci_resource_start (pdev, 1); portbase3 = pci_resource_start (pdev, 2); portbase4 = pci_resource_start (pdev, 3); choice = P220; indexport = pcardname[choice].portnum; dpr=portbase3 + 0x0; dsr=portbase3 + 0x1; dcr=portbase3 + 0x2; ecr=portbase4 + 0xa; outb(0x15,ecr); outb(0x0,dpr); outb(0x0,dcr); outb(0x02,dcr); outb(0x0,dcr); for (retval = 0 ; retval < 17 ; retval ++) { dipinp=idcode[retval]; outb(dipinp,dpr); chk+=inb(dpr); outb(0x02,dcr); outb(0x0,dcr); } outb(0x04,dcr); stusbyte=inb(dsr); indexadapter = ( (stusbyte & 0x60) >> 5 ); ncard=indexadapter+27; chkval=stusbyte & 0x80; if (chkval != 0x80 && chk != pcardname[choice].dpsum) { choice = -1; continue; } break; case 0x22e7: portbase = pci_resource_start (pdev, 0); portbase2 = pci_resource_start (pdev, 1); portbase3 = pci_resource_start (pdev, 2); portbase4 = pci_resource_start (pdev, 3); choice = P220; indexport = pcardname[choice].portnum; dpr=portbase3 + 0x0; dsr=portbase3 + 0x1; dcr=portbase3 + 0x2; ecr=portbase4 + 0xa; outb(0x15,ecr); outb(0x0,dpr); outb(0x0,dcr); outb(0x02,dcr); outb(0x0,dcr); for (retval = 0 ; retval < 17 ; retval ++) { dipinp=idcode[retval]; outb(dipinp,dpr); chk+=inb(dpr); outb(0x02,dcr); outb(0x0,dcr); } outb(0x04,dcr); stusbyte=inb(dsr); indexadapter = 0; ncard=indexadapter+27; chkval=stusbyte & 0x80; break; // RJ422,P984 case 0x1014: portbase = pci_resource_start (pdev, 0); portbase2 = pci_resource_start (pdev, 1); portbase3 = pci_resource_start (pdev, 5); portbase4 = pci_resource_start (pdev, 4); portbase5 = pci_resource_start (pdev, 3); portbase6 = pci_resource_start (pdev, 2); #if MESSG printk("this is P984 card base=%x,%x,%x,%x,%x,%x \n",portbase,portbase2,portbase3,portbase4,portbase5,portbase6); #endif choice = P984; indexport = pcardname[choice].portnum; for (retval = 0 ; retval < 8 ; retval ++) { dipinp=idcode[retval]; chk+=inb(portbase6+retval); } outb(0x0, portbase5); for (retval = 0 ; retval < 8 ; retval ++) { dipinp=idcode984[retval]; outb(dipinp,portbase5); } stusbyte=inb(portbase5); indexadapter = stusbyte & 0x01; ncard=indexadapter+31; chkval=stusbyte & 0x80; if (chkval != 0x80 && chk != pcardname[choice].dpsum) { choice = -1; #if MESSG printk("we have error in P984 check %x, %x\n",chk,stusbyte); #endif continue; } break; default: break; } if ( choice == -1) continue; cardnum[raypcisum]=ncard; base1[raypcisum]=portbase; base2[raypcisum]=portbase2; base3[raypcisum]=portbase3; base4[raypcisum]=portbase4; portNum[raypcisum]=indexport; irq[raypcisum]=intr; jpNum[raypcisum]=indexadapter; choicesum[raypcisum]=choice; raypcisum++; } // match if } // match while }//for- pci_index if(raypcisum == 0) printk("There are no PCIPORT card in this system.\n"); if(raypcisum > 0) { i=1; if(raypcisum==1 && jpNum[0]!=0) { cardstart=1; indon=jpNum[0]; } /* * Add support P588/584/124/518/514/422 plug on pc together * 2001/05 yuchiehu */ while(i) { i=0; for(tmp=0;tmpcardnum[tmp+1]) { chk=jpNum[tmp+1]; jpNum[tmp+1]=jpNum[tmp]; jpNum[tmp]=chk; chk=cardnum[tmp+1]; cardnum[tmp+1]=cardnum[tmp]; cardnum[tmp]=chk; chk=base1[tmp+1]; base1[tmp+1]=base1[tmp]; base1[tmp]=chk; chk=base2[tmp+1]; base2[tmp+1]=base2[tmp]; base2[tmp]=chk; chk=base3[tmp+1]; base3[tmp+1]=base3[tmp]; base3[tmp]=chk; chk=base4[tmp+1]; base4[tmp+1]=base4[tmp]; base4[tmp]=chk; chk=irq[tmp+1]; irq[tmp+1]=irq[tmp]; irq[tmp]=chk; chk=portNum[tmp+1]; portNum[tmp+1]=portNum[tmp]; portNum[tmp]=chk; chk=choicesum[tmp+1]; choicesum[tmp+1]=choicesum[tmp]; choicesum[tmp]=chk; i=1; } } }/*while*/ lastindexport=0; for(i=0;iowner = THIS_MODULE; p220_serial_driver->magic = TTY_DRIVER_MAGIC; p220_serial_driver->driver_name = "pciport"; p220_serial_driver->major = 19; p220_serial_driver->name = "tty81"; p220_serial_driver->minor_start = 16; if(cardstart==1) { ret = sprintf(fbuf,"tty8%d",indon+1); p220_serial_driver->name = fbuf; p220_serial_driver->minor_start = indon * 8 + 16; } /*************/ p220_serial_driver->num = NR_PORTS; p220_serial_driver->type = TTY_DRIVER_TYPE_SERIAL; p220_serial_driver->subtype = SERIAL_TYPE_NORMAL; p220_serial_driver->init_termios = tty_std_termios; p220_serial_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; p220_serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;/*2001/03/14 LoriHu*/ p220_serial_driver->refcount = p220_serial_refcount; p220_serial_driver->ttys = p220_serial_table; p220_serial_driver->termios = p220_serial_termios; p220_serial_driver->termios_locked = p220_serial_termios_locked; tty_set_operations(p220_serial_driver, &p220_ops); /* p220_serial_driver->open = p220_open; p220_serial_driver->close = p220_close; p220_serial_driver->write = p220_write; p220_serial_driver->put_char = p220_put_char; p220_serial_driver->flush_chars = p220_flush_chars; p220_serial_driver->write_room = p220_write_room; p220_serial_driver->chars_in_buffer = p220_chars_in_buffer; p220_serial_driver->flush_buffer = p220_flush_buffer; p220_serial_driver->ioctl = p220_ioctl; p220_serial_driver->throttle = p220_throttle; p220_serial_driver->unthrottle = p220_unthrottle; p220_serial_driver->send_xchar = p220_send_xchar; p220_serial_driver->set_termios = p220_set_termios; p220_serial_driver->stop = p220_stop; p220_serial_driver->start = p220_start; p220_serial_driver->hangup = p220_hangup; p220_serial_driver->break_ctl = p220_break; p220_serial_driver->wait_until_sent = p220_wait_until_sent; p220_serial_driver->read_proc = p220_read_proc; */ if (tty_register_driver(p220_serial_driver)) panic("Couldn't register serial driver\n"); for (i = 0, state = p220_rs_table; i < NR_PORTS; i++,state++) { state->magic = SSTATE_MAGIC; state->line = i; state->type = PORT_UNKNOWN; state->custom_divisor = 0; state->close_delay = 5*HZ/10; state->closing_wait = 30*HZ; state->icount.cts = state->icount.dsr = state->icount.rng = state->icount.dcd = 0; state->icount.rx = state->icount.tx = 0; state->icount.frame = state->icount.parity = 0; state->icount.overrun = state->icount.brk = 0; if (state->flags & ASYNC_BOOT_AUTOCONF) p220_autoconfig(state); } /* * Detect the IRQ only once every port is initialised, * because some 16450 do not reset to 0 the MCR register. */ for (i = 0, state = p220_rs_table; i < NR_PORTS; i++,state++) { if (state->type == PORT_UNKNOWN) continue; if ( (state->flags & ASYNC_BOOT_AUTOCONF) && (state->flags & ASYNC_AUTO_IRQ) && (state->port != 0)) state->irq = detect_p220_irq(state); } return 0; } static void __exit RPort_fini(void) { int e1; int i; del_timer_sync(&p220_serial_timer); printk("Unloading pciport module driver....\n"); if ((e1 = tty_unregister_driver(p220_serial_driver))) printk("SERIAL: failed to unregister serial driver (%d)\n", e1); put_tty_driver(p220_serial_driver); for (i = 0; i < NR_PORTS; i++) { if (p220_rs_table[i].type != PORT_UNKNOWN) release_region(p220_rs_table[i].port, 8); } if (atmp_buf) { free_page((unsigned long) atmp_buf); atmp_buf = NULL; } } module_init(RPort_init); module_exit(RPort_fini); /* End file */