mxpcdrv.c

isa总线设备

	
	MX_MOD_INC;

	if ( (line < 0) || (line > MXPCDRV_PORTS) )
	    return(-ENODEV);
	info = mxvar_table + line;
	if ( !info->base )
	    return(-ENODEV);

	tty->driver_data = info;
	info->tty = tty;

	if ( !mxvar_tmp_buf ) {
	    page = GET_FPAGE(GFP_KERNEL);
	    if ( !page )
		return(-ENOMEM);
	    if ( mxvar_tmp_buf )
		free_page(page);
	    else
		mxvar_tmp_buf = (unsigned char *)page;
	}

	/*
	 * Start up serial port
	 */
	info->count++;

	retval = mxpcdrv_startup(info);
	if ( retval )
	    return(retval);

	retval = mxpcdrv_block_til_ready(tty, filp, info);
	if ( retval )
	    return(retval);


	if ( (info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS) ) {
	    if ( MX_TTY_DRV(subtype) == SERIAL_TYPE_NORMAL )
		*tty->termios = info->normal_termios;
	    else
		*tty->termios = info->callout_termios;
	    mxpcdrv_change_speed(info, 0);
	}

	info->session = MX_SESSION();
	info->pgrp = MX_CGRP();
#ifdef TTY_DONT_FLIP
	clear_bit(TTY_DONT_FLIP, &tty->flags);
#endif

/* unmark here for very high baud rate (ex. 921600 bps) used
*/
#if (LINUX_VERSION_CODE >= VERSION_CODE(2,1,0))
	tty->low_latency = 1;
#endif
	return(0);
}

/*
 * 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 mxpcdrv_close(struct tty_struct * tty, struct file * filp)
{
	struct mxpcdrv_struct * info = (struct mxpcdrv_struct *)tty->driver_data;
#if (LINUX_VERSION_CODE > VERSION_CODE(2,6,9))
	struct tty_ldisc *ld;
#endif
	unsigned long	timeout;

	MX_LOCK_INIT();
	if ( PORTNO(tty) == MXPCDRV_PORTS )
	    return;
	if ( !info ){
			MX_MOD_DEC;
	    return;
	}

	MX_LOCK(&info->slock);
	if ( tty_hung_up_p(filp) ) {
	    MX_UNLOCK(&info->slock);
	    MX_MOD_DEC;
	    return;
	}

#ifndef SP1
	if ( (tty->count == 1) && (info->count != 1) ) {
#else
#if (LINUX_VERSION_CODE < VERSION_CODE(2,4,21))
	if ( (tty->count == 1) && (info->count != 1) ) {
#else
	if ((atomic_read(&tty->count) == 1) && (info->count != 1)) {
#endif
#endif
	    /*
	     * Uh, oh.	tty->count is 1, which means that the tty
	     * structure will be freed.  Info->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("mxpcdrv_close: bad serial port count; tty->count is 1, "
		   "info->count is %d\n", info->count);
	    info->count = 1;
	}
	if ( --info->count < 0 ) {
	    printk("mxpcdrv_close: bad serial port count for ttys%d: %d\n",
		   info->port, info->count);
	    info->count = 0;
	}
	if ( info->count ) {
	    MX_UNLOCK(&info->slock);
	    MX_MOD_DEC;
	    return;
	}
	info->flags |= ASYNC_CLOSING;
	MX_UNLOCK(&info->slock);	// add by Victor Yu. 09-26-2002
	/*
	 * Save the termios structure, since this port may have
	 * separate termios for callout and dialin.
	 */
	if ( info->flags & ASYNC_NORMAL_ACTIVE )
	    info->normal_termios = *tty->termios;
	if ( info->flags & ASYNC_CALLOUT_ACTIVE )
	    info->callout_termios = *tty->termios;
	/*
	 * Now we wait for the transmit buffer to clear; and we notify
	 * the line discipline to only process XON/XOFF characters.
	 */
	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;
	if ( info->IsMoxaMustChipFlag )
		info->IER &= ~MOXA_MUST_RECV_ISR;
/* by William
	info->read_status_mask &= ~UART_LSR_DR;
*/
	if ( info->flags & ASYNC_INITIALIZED ) {
	    outb(info->IER, info->base + UART_IER);
	    /*
	     * Before we drop DTR, make sure the UART transmitter
	     * has completely drained; this is especially
	     * important if there is a transmit FIFO!
	     */
	    timeout = jiffies + HZ;
	    while ( !(inb(info->base + UART_LSR) & UART_LSR_TEMT) ) {
#if (LINUX_VERSION_CODE >= VERSION_CODE(2,3,0))
				set_current_state(TASK_INTERRUPTIBLE);
#else
				current->state = TASK_INTERRUPTIBLE;
#endif
		schedule_timeout(5);
		if ( time_after(jiffies, timeout) )
		    break;
	    }
	}
	mxpcdrv_shutdown(info);

	// following add by Victor Yu. 09-23-2002
	/*
	if ( info->IsMoxaMustChipFlag )
		SET_MOXA_MUST_NO_SOFTWARE_FLOW_CONTROL(info->base);
	*/
	// above add by Victor Yu. 09-23-2002

	if ( MX_TTY_DRV(flush_buffer) )
	    MX_TTY_DRV(flush_buffer)(tty);
	    
#if (LINUX_VERSION_CODE < VERSION_CODE(2,6,10))
	if ( tty->ldisc.flush_buffer )
	    tty->ldisc.flush_buffer(tty);
#else    
	ld = tty_ldisc_ref(tty);
	if (ld) {
		if(ld->flush_buffer)
			ld->flush_buffer(tty);
		tty_ldisc_deref(ld);
	}
#endif

	tty->closing = 0;
	info->event = 0;
	info->tty = 0;
	if ( info->blocked_open ) {
	    if ( info->close_delay ) {
#if (LINUX_VERSION_CODE >= VERSION_CODE(2,3,0))
				set_current_state(TASK_INTERRUPTIBLE);
#else
				current->state = TASK_INTERRUPTIBLE;
#endif
		schedule_timeout(info->close_delay);
	    }
	    wake_up_interruptible(&info->open_wait);
	}

	info->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CALLOUT_ACTIVE |
			 ASYNC_CLOSING);
	wake_up_interruptible(&info->close_wait);
//	MX_UNLOCK(&info->slock);	// mask by Vicror Yu. 09-26-2002

	MX_MOD_DEC;
}

#if (LINUX_VERSION_CODE < VERSION_CODE(2,6,10))
static int mxpcdrv_write(struct tty_struct * tty, int from_user,
		       const unsigned char * buf, int count)
#else
static int mxpcdrv_write(struct tty_struct * tty, 
		       const unsigned char * buf, int count)
#endif
{
	int		c, total = 0;
	struct mxpcdrv_struct *info = (struct mxpcdrv_struct *)tty->driver_data;
	MX_LOCK_INIT();

	if ( !tty || !info->xmit_buf || !mxvar_tmp_buf )
	    return(0);

#if (LINUX_VERSION_CODE < VERSION_CODE(2,6,10))
	if ( from_user )
	    down(&mxvar_tmp_buf_sem);
#endif

	while ( 1 ) {
	    c = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
			       SERIAL_XMIT_SIZE - info->xmit_head));
	    if ( c <= 0 )
		break;

#if (LINUX_VERSION_CODE < VERSION_CODE(2,6,10))
	    if ( from_user ) {
		/*
		copy_from_user(mxvar_tmp_buf, buf, c);
		c = MIN(c, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
			       SERIAL_XMIT_SIZE - info->xmit_head));
		memcpy(info->xmit_buf + info->xmit_head, mxvar_tmp_buf, c);
	    */
		if(copy_from_user(info->xmit_buf+info->xmit_head, buf, c)==c){
		    total = -EFAULT;	
		    break;
		}
	    } else
		memcpy(info->xmit_buf + info->xmit_head, buf, c);
#else
		memcpy(info->xmit_buf + info->xmit_head, buf, c);
#endif
	    MX_LOCK(&info->slock);    
	    info->xmit_head = (info->xmit_head + c) & (SERIAL_XMIT_SIZE - 1);
	    info->xmit_cnt += c;
	    MX_UNLOCK(&info->slock);
	    buf += c;
	    count -= c;
	    total += c;
	}
#if (LINUX_VERSION_CODE < VERSION_CODE(2,6,10))
	if ( from_user )
	    up(&mxvar_tmp_buf_sem);
#endif

	if ( info->xmit_cnt && !tty->stopped ){ 
        	    MX_LOCK(&info->slock);
			        info->IER &= ~UART_IER_THRI;
	            outb(info->IER, info->base + UART_IER);
	            info->IER |= UART_IER_THRI;
	            outb(info->IER, info->base + UART_IER);
	            MX_UNLOCK(&info->slock);
	}

	return(total);
}

static void mxpcdrv_put_char(struct tty_struct * tty, unsigned char ch)
{
	struct mxpcdrv_struct *info = (struct mxpcdrv_struct *)tty->driver_data;
	MX_LOCK_INIT();

	if ( !tty || !info->xmit_buf )
	    return;

	if ( info->xmit_cnt >= SERIAL_XMIT_SIZE - 1 ) {
	    return;
	}

	MX_LOCK(&info->slock);
	info->xmit_buf[info->xmit_head++] = ch;
	info->xmit_head &= SERIAL_XMIT_SIZE - 1;
	info->xmit_cnt++;
	MX_UNLOCK(&info->slock);
	if ( !tty->stopped/* && !(info->IER & UART_IER_THRI) */) {
        		MX_LOCK(&info->slock);
		        info->IER &= ~UART_IER_THRI	;
            outb(info->IER, info->base + UART_IER);
		    		info->IER |= UART_IER_THRI;
		    		outb(info->IER, info->base + UART_IER);
	  	  		MX_UNLOCK(&info->slock);
	}
}

static void mxpcdrv_flush_chars(struct tty_struct * tty)
{
	struct mxpcdrv_struct *info = (struct mxpcdrv_struct *)tty->driver_data;
	MX_LOCK_INIT();

	if ( info->xmit_cnt <= 0 || tty->stopped || !info->xmit_buf || 
	     (tty->hw_stopped && (info->type!=PORT_16550A) && (!info->IsMoxaMustChipFlag)))
	    return;

	MX_LOCK(&info->slock);
  info->IER &= ~UART_IER_THRI	;
  outb(info->IER, info->base + UART_IER);
	info->IER |= UART_IER_THRI;
	outb(info->IER, info->base + UART_IER);
	MX_UNLOCK(&info->slock);
}

static int mxpcdrv_write_room(struct tty_struct * tty)
{
	struct mxpcdrv_struct *info = (struct mxpcdrv_struct *)tty->driver_data;
	int	ret;

	ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
	if ( ret < 0 )
	    ret = 0;
	return(ret);
}

static int mxpcdrv_chars_in_buffer(struct tty_struct * tty)
{
	int len;
	struct mxpcdrv_struct *info = (struct mxpcdrv_struct *)tty->driver_data;
	len = info->xmit_cnt;

	if(!(inb(info->base + UART_LSR) & UART_LSR_THRE))  
		len++;
		
	return len;
}

static void mxpcdrv_flush_buffer(struct tty_struct * tty)
{
	struct mxpcdrv_struct *info = (struct mxpcdrv_struct *)tty->driver_data;
	char fcr;
	MX_LOCK_INIT();

	MX_LOCK(&info->slock);
	info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
	MX_UNLOCK(&info->slock);

	fcr = inb(info->base + UART_FCR);
	outb((fcr | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT), 
		info->base + UART_FCR);
	outb(fcr, info->base+UART_FCR);

	wake_up_interruptible(&tty->write_wait);
	if ( (tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
	     tty->ldisc.write_wakeup )
	    (tty->ldisc.write_wakeup)(tty);
}

static int mxpcdrv_ioctl(struct tty_struct * tty, struct file * file,
		       unsigned int cmd, unsigned long arg)
{
	int			error;
	struct mxpcdrv_struct *	info = (struct mxpcdrv_struct *)tty->driver_data;
	int			retval;
	struct async_icount	cprev, cnow;	    /* kernel counter temps */
	struct serial_icounter_struct *p_cuser;     /* user space */
	unsigned long 		templ;

	MX_LOCK_INIT();
	
	if ( PORTNO(tty) == MXPCDRV_PORTS )
	    return(mxpcdrv_ioctl_special(cmd, arg));
	if ( (cmd != TIOCGSERIAL) && (cmd != TIOCMIWAIT) &&
	     (cmd != TIOCGICOUNT) ) {
	    if ( tty->flags & (1 << TTY_IO_ERROR) )
		return(-EIO);
	}
	switch ( cmd ) {
	case TCSBRK:	/* SVID version: non-zero arg --> no break */
	    retval = tty_check_change(tty);
	    if ( retval )
		return(retval);
	    tty_wait_until_sent(tty, 0);
	    if ( !arg )
		mxpcdrv_send_break(info, HZ/4);		/* 1/4 second */
	    return(0);
	case TCSBRKP:	/* support for POSIX tcsendbreak() */
	    retval = tty_check_change(tty);
	    if ( retval )
		return(retval);
	    tty_wait_until_sent(tty, 0);
	    mxpcdrv_send_break(info, arg ? arg*(HZ/10) : HZ/4);
	    return(0);
	case TIOCGSOFTCAR:
	    error = MX_ACCESS_CHK(VERIFY_WRITE, (void *)arg, sizeof(long));
	    if ( MX_ERR(error) )
		return(error);
	    put_to_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long *)arg);
	    return 0;
	case TIOCSSOFTCAR:
	    error = MX_ACCESS_CHK(VERIFY_READ, (void *)arg, sizeof(long));
	    if ( MX_ERR(error) )
		return(error);
	    get_from_user(templ,(unsigned long *)arg);
	    arg = templ;
	    tty->termios->c_cflag = ((tty->termios->c_cflag & ~CLOCAL) |
				    (arg ? CLOCAL : 0));
	    return(0);
#if (LINUX_VERSION_CODE < VERSION_CODE(2,6,0))
	case TIOCMGET:
	    error = MX_ACCESS_CHK(VERIFY_WRITE, (void *)arg,
				sizeof(unsigned int));
	    if ( MX_ERR(error) )
		return(error);
	    return(mxpcdrv_get_modem_info(info, (unsigned int *)arg));
	case TIOCMBIS:
	case TIOCMBIC:
	case TIOCMSET:
	    return(mxpcdrv_set_modem_info(info, cmd, (unsigned int *)arg));
#endif
	case TIOCGSERIAL:
	    error = MX_ACCESS_CHK(VERIFY_WRITE, (void *)arg,
				sizeof(struct serial_struct));
	    if ( MX_ERR(error) )
		return(error);
	    return(mxpcdrv_get_serial_info(info, (struct serial_struct *)arg));
	case TIOCSSERIAL:
	    error = MX_ACCESS_CHK(VERIFY_READ, (void *)arg,
				sizeof(struct serial_struct));
	    if ( MX_ERR(error) )
		return(error);
	    return(mxpcdrv_set_serial_info(info, (struct serial_struct *)arg));
	case TIOCSERGETLSR: /* Get line status register */
	    error = MX_ACCESS_CHK(VERIFY_WRITE, (void *)arg,
				sizeof(unsigned int));
	    if ( MX_ERR(error) )
		return(error);
	    else
		return(mxpcdrv_get_lsr_info(info, (unsigned int *)arg));
	/*
	 * 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:
	    MX_LOCK(&info->slock);
	    cprev = info->icount;   /* note the counters on entry */
	    MX_UNLOCK(&info->slock);
	    while ( 1 ) {
		//interruptible_sleep_on(&info->delta_msr_wait);
		/* see if a signal did it */
		if ( signal_pending(current) )
		    return(-ERESTARTSYS);

	    MX_LOCK(&info->slock);