Subversion Repositories or1k

/*

*

*   (c) 1999 by Computone Corporation

*

********************************************************************************

*

*   PACKAGE:     Linux tty Device Driver for IntelliPort family of multiport

*                serial I/O controllers.

*

*   DESCRIPTION: Mainline code for the device driver

*

*******************************************************************************/

// ToDo:

//

// Fix the immediate DSS_NOW problem.

// Work over the channel stats return logic in ip2_ipl_ioctl so they

//      make sense for all 256 possible channels and so the user space

//      utilities will compile and work properly.

//

// Done:

//

// 1.2.14       /\/\|=mhw=|\/\/

// Added bounds checking to ip2_ipl_ioctl to avoid potential terroristic acts.

// Changed the definition of ip2trace to be more consistant with kernel style

//      Thanks to Andreas Dilger <adilger@turbolabs.com> for these updates

//

// 1.2.13       /\/\|=mhw=|\/\/

// DEVFS: Renamed ttf/{n} to tts/F{n} and cuf/{n} to cua/F{n} to conform

//      to agreed devfs serial device naming convention.

//

// 1.2.12       /\/\|=mhw=|\/\/

// Cleaned up some remove queue cut and paste errors

//

// 1.2.11       /\/\|=mhw=|\/\/

// Clean up potential NULL pointer dereferences

// Clean up devfs registration

// Add kernel command line parsing for io and irq

//      Compile defaults for io and irq are now set in ip2.c not ip2/ip2.h!

// Reworked poll_only hack for explicit parameter setting

//      You must now EXPLICITLY set poll_only = 1 or set all irqs to 0

// Merged ip2_loadmain and old_ip2_init

// Converted all instances of interruptible_sleep_on into queue calls

//      Most of these had no race conditions but better to clean up now

//

// 1.2.10       /\/\|=mhw=|\/\/

// Fixed the bottom half interrupt handler and enabled USE_IQI

//      to split the interrupt handler into a formal top-half / bottom-half

// Fixed timing window on high speed processors that queued messages to

//      the outbound mail fifo faster than the board could handle.

//

// 1.2.9

// Four box EX was barfing on >128k kmalloc, made structure smaller by

// reducing output buffer size

//

// 1.2.8

// Device file system support (MHW)

//

// 1.2.7 

// Fixed

// Reload of ip2 without unloading ip2main hangs system on cat of /proc/modules

//

// 1.2.6

//Fixes DCD problems

//      DCD was not reported when CLOCAL was set on call to TIOCMGET

//

//Enhancements:

//      TIOCMGET requests and waits for status return

//      No DSS interrupts enabled except for DCD when needed

//

// For internal use only

//

//#define IP2DEBUG_INIT

//#define IP2DEBUG_OPEN

//#define IP2DEBUG_WRITE

//#define IP2DEBUG_READ

//#define IP2DEBUG_IOCTL

//#define IP2DEBUG_IPL

//#define IP2DEBUG_TRACE

//#define DEBUG_FIFO

/************/

/* Includes */

/************/

#include <linux/config.h>

// Uncomment the following if you want it compiled with modversions

#include <linux/version.h>

#include <linux/ctype.h>

#include <linux/string.h>

#include <linux/fcntl.h>

#include <linux/errno.h>

#include <linux/module.h>

#include <linux/signal.h>

#include <linux/sched.h>

#ifdef  CONFIG_DEVFS_FS

#include <linux/devfs_fs_kernel.h>

#endif

#include <linux/timer.h>

#include <linux/interrupt.h>

#include <linux/pci.h>

#include <linux/mm.h>

#include <linux/slab.h>

#include <linux/major.h>

#include <linux/wait.h>

#include <linux/tty.h>

#include <linux/tty_flip.h>

#include <linux/termios.h>

#include <linux/tty_driver.h>

#include <linux/serial.h>

#include <linux/ptrace.h>

#include <linux/ioport.h>

#include <linux/cdk.h>

#include <linux/comstats.h>

#include <linux/delay.h>

#include <asm/system.h>

#include <asm/io.h>

#include <asm/irq.h>

#include <asm/bitops.h>

#ifndef KERNEL_VERSION

#define KERNEL_VERSION(ver,rel,seq) (((ver)<<16) | ((rel)<<8) | (seq))

#endif

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,0)

#       include <linux/vmalloc.h>

#       include <linux/init.h>

#       include <asm/serial.h>

#else

#       include <linux/bios32.h>

#endif

// These VERSION switches maybe inexact because I simply don't know

// when the various features appeared in the 2.1.XX kernels.

// They are good enough for 2.0 vs 2.2 and if you are fooling with

// the 2.1.XX stuff then it would be trivial for you to fix.

// Most of these macros were stolen from some other drivers

// so blame them.

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,4)

#       include <asm/segment.h>

#       define GET_USER(error,value,addr) error = get_user(value,addr)

#       define COPY_FROM_USER(error,dest,src,size) error = copy_from_user(dest,src,size) ? -EFAULT : 0

#       define PUT_USER(error,value,addr) error = put_user(value,addr)

#       define COPY_TO_USER(error,dest,src,size) error = copy_to_user(dest,src,size) ? -EFAULT : 0

#       if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,5)

#               include <asm/uaccess.h>

#               define          pcibios_strerror(status)        \

                                        printk( KERN_ERR "IP2: PCI error 0x%x \n", status );

#       endif

#else  /* 2.0.x and 2.1.x before 2.1.4 */

#       define          proc_register_dynamic(a,b) proc_register(a,b) 

#       define GET_USER(error,value,addr)                                         \

        do {                                                                      \

                error = verify_area (VERIFY_READ, (void *) addr, sizeof (value)); \

                if (error == 0)                                                    \

                        value = get_user(addr);                                   \

        } while (0)

#       define COPY_FROM_USER(error,dest,src,size)                                \

        do {                                                                      \

                error = verify_area (VERIFY_READ, (void *) src, size);            \

                if (error == 0)                                                    \

                        memcpy_fromfs (dest, src, size);                          \

        } while (0)

#       define PUT_USER(error,value,addr)                                          \

        do {                                                                       \

                error = verify_area (VERIFY_WRITE, (void *) addr, sizeof (value)); \

                if (error == 0)                                                     \

                        put_user (value, addr);                                    \

        } while (0)

#       define COPY_TO_USER(error,dest,src,size)                                  \

        do {                                                                      \

                error = verify_area (VERIFY_WRITE, (void *) dest, size);                  \

                if (error == 0)                                                    \

                        memcpy_tofs (dest, src, size);                            \

        } while (0)

#endif

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0)

#define __init

#define __initfunc(a) a

#define __initdata

#define ioremap(a,b) vremap((a),(b))

#define iounmap(a) vfree((a))

#define SERIAL_TYPE_NORMAL      1

#define SERIAL_TYPE_CALLOUT     2

#define schedule_timeout(a){current->timeout = jiffies + (a); schedule();}

#define signal_pending(a) ((a)->signal & ~(a)->blocked)

#define in_interrupt()  intr_count

#endif

#include "./ip2/ip2types.h"

#include "./ip2/ip2trace.h"

#include "./ip2/ip2ioctl.h"

#include "./ip2/ip2.h"

#include "./ip2/i2ellis.h"

#include "./ip2/i2lib.h"

/*****************

 * /proc/ip2mem  *

 *****************/

#include <linux/proc_fs.h>

static int ip2_read_procmem(char *, char **, off_t, int);

int ip2_read_proc(char *, char **, off_t, int, int *, void * );

/********************/

/* Type Definitions */

/********************/

/*************/

/* Constants */

/*************/

/* String constants to identify ourselves */

static char *pcName    = "Computone IntelliPort Plus multiport driver";

static char *pcVersion = "1.2.14";

/* String constants for port names */

static char *pcDriver_name   = "ip2";

#ifdef  CONFIG_DEVFS_FS

static char *pcTty               = "tts/F%d";

static char *pcCallout           = "cua/F%d";

#else

static char *pcTty               = "ttyF";

static char *pcCallout           = "cuf";

#endif

static char *pcIpl               = "ip2ipl";

/* Serial subtype definitions */

#define SERIAL_TYPE_NORMAL    1

#define SERIAL_TYPE_CALLOUT   2

// cheezy kludge or genius - you decide?

int ip2_loadmain(int *, int *, unsigned char *, int);

static unsigned char *Fip_firmware;

static int Fip_firmware_size;

/***********************/

/* Function Prototypes */

/***********************/

/* Global module entry functions */

#ifdef MODULE

int init_module(void);

void cleanup_module(void);

#endif

/* Private (static) functions */

static int  ip2_open(PTTY, struct file *);

static void ip2_close(PTTY, struct file *);

static int  ip2_write(PTTY, int, const unsigned char *, int);

static void ip2_putchar(PTTY, unsigned char);

static void ip2_flush_chars(PTTY);

static int  ip2_write_room(PTTY);

static int  ip2_chars_in_buf(PTTY);

static void ip2_flush_buffer(PTTY);

static int  ip2_ioctl(PTTY, struct file *, UINT, ULONG);

static void ip2_set_termios(PTTY, struct termios *);

static void ip2_set_line_discipline(PTTY);

static void ip2_throttle(PTTY);

static void ip2_unthrottle(PTTY);

static void ip2_stop(PTTY);

static void ip2_start(PTTY);

static void ip2_hangup(PTTY);

static void set_irq(int, int);

static void ip2_interrupt_bh(i2eBordStrPtr pB);

static void ip2_interrupt(int irq, void *dev_id, struct pt_regs * regs);

static void ip2_poll(unsigned long arg);

static inline void service_all_boards(void);

static inline void do_input(i2ChanStrPtr pCh);

static inline void do_status(i2ChanStrPtr pCh);

static void ip2_wait_until_sent(PTTY,int);

static void set_params (i2ChanStrPtr, struct termios *);

static int set_modem_info(i2ChanStrPtr, unsigned int, unsigned int *);

static int get_serial_info(i2ChanStrPtr, struct serial_struct *);

static int set_serial_info(i2ChanStrPtr, struct serial_struct *);

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0)

static int     ip2_ipl_read(struct inode *, char *, size_t , loff_t *);

#else

static ssize_t ip2_ipl_read(struct file *, char *, size_t, loff_t *) ;

#endif

static ssize_t ip2_ipl_write(struct file *, const char *, size_t, loff_t *);

static int ip2_ipl_ioctl(struct inode *, struct file *, UINT, ULONG);

static int ip2_ipl_open(struct inode *, struct file *);

static int DumpTraceBuffer(char *, int);

static int DumpFifoBuffer( char *, int);

static void ip2_init_board(int);

static unsigned short find_eisa_board(int);

/***************/

/* Static Data */

/***************/

static struct tty_driver ip2_tty_driver;

static struct tty_driver ip2_callout_driver;

static int ref_count;

/* Here, then is a table of board pointers which the interrupt routine should

 * scan through to determine who it must service.

 */

static unsigned short i2nBoards; // Number of boards here

static i2eBordStrPtr i2BoardPtrTable[IP2_MAX_BOARDS];

static i2ChanStrPtr  DevTable[IP2_MAX_PORTS];

//DevTableMem just used to save addresses for kfree

static void  *DevTableMem[IP2_MAX_BOARDS];

static struct tty_struct * TtyTable[IP2_MAX_PORTS];

static struct termios    * Termios[IP2_MAX_PORTS];

static struct termios    * TermiosLocked[IP2_MAX_PORTS];

/* This is the driver descriptor for the ip2ipl device, which is used to

 * download the loadware to the boards.

 */

static struct file_operations ip2_ipl = {

        owner:          THIS_MODULE,

        read:           ip2_ipl_read,

        write:          ip2_ipl_write,

        ioctl:          ip2_ipl_ioctl,

        open:           ip2_ipl_open,

};

static unsigned long irq_counter = 0;

static unsigned long bh_counter = 0;

// Use immediate queue to service interrupts

#define USE_IQI

//#define USE_IQ        // PCI&2.2 needs work

/* The timer_list entry for our poll routine. If interrupt operation is not

 * selected, the board is serviced periodically to see if anything needs doing.

 */

#define  POLL_TIMEOUT   (jiffies + 1)

static struct timer_list PollTimer = { function: ip2_poll };

static char  TimerOn;

#ifdef IP2DEBUG_TRACE

/* Trace (debug) buffer data */

#define TRACEMAX  1000

static unsigned long tracebuf[TRACEMAX];

static int tracestuff;

static int tracestrip;

static int tracewrap;

#endif

/**********/

/* Macros */

/**********/

#if defined(MODULE) && defined(IP2DEBUG_OPEN)

#define DBG_CNT(s) printk(KERN_DEBUG "(%s): [%x] refc=%d, ttyc=%d, modc=%x -> %s\n", \

                    kdevname(tty->device),(pCh->flags),ref_count, \

                    tty->count,/*GET_USE_COUNT(module)*/0,s)

#else

#define DBG_CNT(s)

#endif

#define MIN(a,b)        ( ( (a) < (b) ) ? (a) : (b) )

#define MAX(a,b)        ( ( (a) > (b) ) ? (a) : (b) )

/********/

/* Code */

/********/

#include "./ip2/i2ellis.c"    /* Extremely low-level interface services */

#include "./ip2/i2cmd.c"      /* Standard loadware command definitions */

#include "./ip2/i2lib.c"      /* High level interface services */

/* Configuration area for modprobe */

#ifdef MODULE

#       if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,0)

                MODULE_AUTHOR("Doug McNash");

                MODULE_DESCRIPTION("Computone IntelliPort Plus Driver");

#       endif   /* LINUX_VERSION */

#endif  /* MODULE */

static int poll_only = 0;

static int Eisa_irq;

static int Eisa_slot;

static int iindx;

static char rirqs[IP2_MAX_BOARDS];

static int Valid_Irqs[] = { 3, 4, 5, 7, 10, 11, 12, 15, 0};

// Some functions to keep track of what irq's we have

static int __init

is_valid_irq(int irq)

{

        int *i = Valid_Irqs;

        while ((*i != 0) && (*i != irq)) {

                i++;

        }

        return (*i);

}

static void __init

mark_requested_irq( char irq )

{

        rirqs[iindx++] = irq;

}

#ifdef MODULE

static int __init

clear_requested_irq( char irq )

{

        int i;

        for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {

                if (rirqs[i] == irq) {

                        rirqs[i] = 0;

                        return 1;

                }

        }

        return 0;

}

#endif

static int __init

have_requested_irq( char irq )

{

        // array init to zeros so 0 irq will not be requested as a side effect

        int i;

        for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {

                if (rirqs[i] == irq)

                        return 1;

        }

        return 0;

}

/******************************************************************************/

/* Function:   init_module()                                                  */

/* Parameters: None                                                           */

/* Returns:    Success (0)                                                    */

/*                                                                            */

/* Description:                                                               */

/* This is a required entry point for an installable module. It simply calls  */

/* the driver initialisation function and returns what it returns.            */

/******************************************************************************/

#ifdef MODULE

int

init_module(void)

{

#ifdef IP2DEBUG_INIT

        printk (KERN_DEBUG "Loading module ...\n" );

#endif

    return 0;

}

#endif /* MODULE */

/******************************************************************************/

/* Function:   cleanup_module()                                               */

/* Parameters: None                                                           */

/* Returns:    Nothing                                                        */

/*                                                                            */

/* Description:                                                               */

/* This is a required entry point for an installable module. It has to return */

/* the device and the driver to a passive state. It should not be necessary   */

/* to reset the board fully, especially as the loadware is downloaded         */

/* externally rather than in the driver. We just want to disable the board    */

/* and clear the loadware to a reset state. To allow this there has to be a   */

/* way to detect whether the board has the loadware running at init time to   */

/* handle subsequent installations of the driver. All memory allocated by the */

/* driver should be returned since it may be unloaded from memory.            */

/******************************************************************************/

#ifdef MODULE

void

cleanup_module(void)

{

        int err;

        int i;

#ifdef IP2DEBUG_INIT

        printk (KERN_DEBUG "Unloading %s: version %s\n", pcName, pcVersion );

#endif

        /* Stop poll timer if we had one. */

        if ( TimerOn ) {

                del_timer ( &PollTimer );

                TimerOn = 0;

        }

        /* Reset the boards we have. */

        for( i = 0; i < IP2_MAX_BOARDS; ++i ) {

                if ( i2BoardPtrTable[i] ) {

                        iiReset( i2BoardPtrTable[i] );

                }

        }

        /* The following is done at most once, if any boards were installed. */

        for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {

                if ( i2BoardPtrTable[i] ) {

                        iiResetDelay( i2BoardPtrTable[i] );

                        /* free io addresses and Tibet */

                        release_region( ip2config.addr[i], 8 );

#ifdef  CONFIG_DEVFS_FS

                        devfs_unregister (i2BoardPtrTable[i]->devfs_ipl_handle);

                        devfs_unregister (i2BoardPtrTable[i]->devfs_stat_handle);

#endif

                }

                /* Disable and remove interrupt handler. */

                if ( (ip2config.irq[i] > 0) && have_requested_irq(ip2config.irq[i]) ) {

                        free_irq ( ip2config.irq[i], (void *)&pcName);

                        clear_requested_irq( ip2config.irq[i]);

                }

        }

        if ( ( err = tty_unregister_driver ( &ip2_tty_driver ) ) ) {

                printk(KERN_ERR "IP2: failed to unregister tty driver (%d)\n", err);

        }

        if ( ( err = tty_unregister_driver ( &ip2_callout_driver ) ) ) {

                printk(KERN_ERR "IP2: failed to unregister callout driver (%d)\n", err);

        }

#ifdef  CONFIG_DEVFS_FS

        if ( ( err = devfs_unregister_chrdev ( IP2_IPL_MAJOR, pcIpl ) ) )

#else

        if ( ( err = unregister_chrdev ( IP2_IPL_MAJOR, pcIpl ) ) )

#endif

        {

                printk(KERN_ERR "IP2: failed to unregister IPL driver (%d)\n", err);

        }

        remove_proc_entry("ip2mem", &proc_root);

        // free memory

        for (i = 0; i < IP2_MAX_BOARDS; i++) {

                void *pB;

                if ((pB = i2BoardPtrTable[i]) != 0 ) {

                        kfree ( pB );

                        i2BoardPtrTable[i] = NULL;

                }

                if ((DevTableMem[i]) != NULL ) {

                        kfree ( DevTableMem[i]  );

                        DevTableMem[i] = NULL;

                }

        }

        /* Cleanup the iiEllis subsystem. */

        iiEllisCleanup();

#ifdef IP2DEBUG_INIT

        printk (KERN_DEBUG "IP2 Unloaded\n" );

#endif

}

#endif /* MODULE */

/******************************************************************************/

/* Function:   ip2_loadmain()                                                 */

/* Parameters: irq, io from command line of insmod et. al.                    */

/*              pointer to fip firmware and firmware size for boards          */

/* Returns:    Success (0)                                                    */

/*                                                                            */

/* Description:                                                               */

/* This was the required entry point for all drivers (now in ip2.c)           */

/* It performs all                                                            */

/* initialisation of the devices and driver structures, and registers itself  */

/* with the relevant kernel modules.                                          */

/******************************************************************************/

/* SA_INTERRUPT- if set blocks all interrupts else only this line */

/* SA_SHIRQ    - for shared irq PCI or maybe EISA only */

/* SA_RANDOM   - can be source for cert. random number generators */

#define IP2_SA_FLAGS    0

int __init

ip2_loadmain(int *iop, int *irqp, unsigned char *firmware, int firmsize)

{

#ifdef  CONFIG_DEVFS_FS

        static devfs_handle_t devfs_handle;

        int j, box;

#endif

        int i;

        int err;

        int status = 0;

        static int loaded;

        i2eBordStrPtr pB = NULL;

        int rc = -1;

        ip2trace (ITRC_NO_PORT, ITRC_INIT, ITRC_ENTER, 0 );

        /* process command line arguments to modprobe or

                insmod i.e. iop & irqp */

        /* irqp and iop should ALWAYS be specified now...  But we check

                them individually just to be sure, anyways... */

        for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {

                if (iop) {

                        ip2config.addr[i] = iop[i];

                        if (irqp) {

                                if( irqp[i] >= 0 ) {

                                        ip2config.irq[i] = irqp[i];

                                } else {

                                        ip2config.irq[i] = 0;

                                }

        // This is a little bit of a hack.  If poll_only=1 on command

        // line back in ip2.c OR all IRQs on all specified boards are

        // explicitly set to 0, then drop to poll only mode and override

        // PCI or EISA interrupts.  This superceeds the old hack of

        // triggering if all interrupts were zero (like da default).

        // Still a hack but less prone to random acts of terrorism.

        //

        // What we really should do, now that the IRQ default is set

        // to -1, is to use 0 as a hard coded, do not probe.

        //

        //      /\/\|=mhw=|\/\/

                                poll_only |= irqp[i];

                        }

                }

        }

        poll_only = !poll_only;

        Fip_firmware = firmware;

        Fip_firmware_size = firmsize;

        /* Announce our presence */

        printk( KERN_INFO "%s version %s\n", pcName, pcVersion );

        // ip2 can be unloaded and reloaded for no good reason

        // we can't let that happen here or bad things happen

        // second load hoses board but not system - fixme later

        if (loaded) {

                printk( KERN_INFO "Still loaded\n" );

                return 0;

        }

        loaded++;

        /* Initialise the iiEllis subsystem. */

        iiEllisInit();

        /* Initialize arrays. */

        memset( i2BoardPtrTable, 0, sizeof i2BoardPtrTable );

        memset( DevTable, 0, sizeof DevTable );

        memset( TtyTable, 0, sizeof TtyTable );

        memset( Termios, 0, sizeof Termios );

        memset( TermiosLocked, 0, sizeof TermiosLocked );

        /* Initialise all the boards we can find (up to the maximum). */

        for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {

                switch ( ip2config.addr[i] ) {

                case 0:  /* skip this slot even if card is present */

                        break;

                default: /* ISA */

                   /* ISA address must be specified */

                        if ( (ip2config.addr[i] < 0x100) || (ip2config.addr[i] > 0x3f8) ) {

                                printk ( KERN_ERR "IP2: Bad ISA board %d address %x\n",

                                                         i, ip2config.addr[i] );

                                ip2config.addr[i] = 0;

                        } else {

                                ip2config.type[i] = ISA;

                                /* Check for valid irq argument, set for polling if invalid */

                                if (ip2config.irq[i] && !is_valid_irq(ip2config.irq[i])) {

                                        printk(KERN_ERR "IP2: Bad IRQ(%d) specified\n",ip2config.irq[i]);

                                        ip2config.irq[i] = 0;// 0 is polling and is valid in that sense

                                }

                        }

                        break;

                case PCI:

#ifdef CONFIG_PCI

#if (LINUX_VERSION_CODE < 0x020163) /* 2.1.99 */

                        if (pcibios_present()) {

                                unsigned char pci_bus, pci_devfn;

                                int Pci_index = 0;

                                status = pcibios_find_device(PCI_VENDOR_ID_COMPUTONE,

                                                          PCI_DEVICE_ID_COMPUTONE_IP2EX, Pci_index,

                                                          &pci_bus, &pci_devfn);

                                if (status == 0) {

                                        unsigned int addr;

                                        unsigned char pci_irq;

                                        ip2config.type[i] = PCI;

                                        /*

                                         * Update Pci_index, so that the next time we go

                                         * searching for a PCI board we find a different

                                         * one.

                                         */

                                        ++Pci_index;

                                        pcibios_read_config_dword(pci_bus, pci_devfn,

                                                                  PCI_BASE_ADDRESS_1, &addr);