Subversion Repositories or1k

/*

   3w-xxxx.c -- 3ware Storage Controller device driver for Linux.

   Written By: Adam Radford <linux@3ware.com>

   Modifications By: Joel Jacobson <linux@3ware.com>

                     Arnaldo Carvalho de Melo <acme@conectiva.com.br>

                     Brad Strand <linux@3ware.com>

   Copyright (C) 1999-2003 3ware Inc.

   Kernel compatablity By:      Andre Hedrick <andre@suse.com>

   Non-Copyright (C) 2000       Andre Hedrick <andre@suse.com>

   Further tiny build fixes and trivial hoovering    Alan Cox

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   NO WARRANTY

   THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR

   CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT

   LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,

   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is

   solely responsible for determining the appropriateness of using and

   distributing the Program and assumes all risks associated with its

   exercise of rights under this Agreement, including but not limited to

   the risks and costs of program errors, damage to or loss of data,

   programs or equipment, and unavailability or interruption of operations.

   DISCLAIMER OF LIABILITY

   NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY

   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

   DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND

   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR

   TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE

   USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED

   HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

   Bugs/Comments/Suggestions should be mailed to:

   linux@3ware.com

   For more information, goto:

   http://www.3ware.com

   History

   -------

   0.1.000 -     Initial release.

   0.4.000 -     Added support for Asynchronous Event Notification through

                 ioctls for 3DM.

   1.0.000 -     Added DPO & FUA bit support for WRITE_10 & WRITE_6 cdb

                 to disable drive write-cache before writes.

   1.1.000 -     Fixed performance bug with DPO & FUA not existing for WRITE_6.

   1.2.000 -     Added support for clean shutdown notification/feature table.

   1.02.00.001 - Added support for full command packet posts through ioctls

                 for 3DM.

                 Bug fix so hot spare drives don't show up.

   1.02.00.002 - Fix bug with tw_setfeature() call that caused oops on some

                 systems.

   08/21/00    - release previously allocated resources on failure at

                 tw_allocate_memory (acme)

   1.02.00.003 - Fix tw_interrupt() to report error to scsi layer when

                 controller status is non-zero.

                 Added handling of request_sense opcode.

                 Fix possible null pointer dereference in

                 tw_reset_device_extension()

   1.02.00.004 - Add support for device id of 3ware 7000 series controllers.

                 Make tw_setfeature() call with interrupts disabled.

                 Register interrupt handler before enabling interrupts.

                 Clear attention interrupt before draining aen queue.

   1.02.00.005 - Allocate bounce buffers and custom queue depth for raid5 for

                 6000 and 5000 series controllers.

                 Reduce polling mdelays causing problems on some systems.

                 Fix use_sg = 1 calculation bug.

                 Check for scsi_register returning NULL.

                 Add aen count to /proc/scsi/3w-xxxx.

                 Remove aen code unit masking in tw_aen_complete().

   1.02.00.006 - Remove unit from printk in tw_scsi_eh_abort(), causing

                 possible oops.

                 Fix possible null pointer dereference in tw_scsi_queue()

                 if done function pointer was invalid.

   1.02.00.007 - Fix possible null pointer dereferences in tw_ioctl().

                 Remove check for invalid done function pointer from

                 tw_scsi_queue().

   1.02.00.008 - Set max sectors per io to TW_MAX_SECTORS in tw_findcards().

                 Add tw_decode_error() for printing readable error messages.

                 Print some useful information on certain aen codes.

                 Add tw_decode_bits() for interpreting status register output.

                 Make scsi_set_pci_device() for kernels >= 2.4.4

                 Fix bug where aen's could be lost before a reset.

                 Re-add spinlocks in tw_scsi_detect().

                 Fix possible null pointer dereference in tw_aen_drain_queue()

                 during initialization.

                 Clear pci parity errors during initialization and during io.

   1.02.00.009 - Remove redundant increment in tw_state_request_start().

                 Add ioctl support for direct ATA command passthru.

                 Add entire aen code string list.

   1.02.00.010 - Cleanup queueing code, fix jbod thoughput.

                 Fix get_param for specific units.

   1.02.00.011 - Fix bug in tw_aen_complete() where aen's could be lost.

                 Fix tw_aen_drain_queue() to display useful info at init.

                 Set tw_host->max_id for 12 port cards.

                 Add ioctl support for raw command packet post from userspace

                 with sglist fragments (parameter and io).

   1.02.00.012 - Fix read capacity to under report by 1 sector to fix get

                 last sector ioctl.

   1.02.00.013 - Fix bug where more AEN codes weren't coming out during

                 driver initialization.

                 Improved handling of PCI aborts.

   1.02.00.014 - Fix bug in tw_findcards() where AEN code could be lost.

                 Increase timeout in tw_aen_drain_queue() to 30 seconds.

   1.02.00.015 - Re-write raw command post with data ioctl method.

   1.02.00.016 - Set max_cmd_len for 3dm.

                 Set max sectors to 256 for non raid5 & 6XXX.

   1.02.00.017 - Modified pci parity error handling/clearing from config space

                 during initialization.

   1.02.00.018 - Better handling of request sense opcode and sense information

                 for failed commands.  Add tw_decode_sense().

                 Replace all mdelay()'s with scsi_sleep().

   1.02.00.019 - Revert mdelay's and scsi_sleep's, this caused problems on

                 some SMP systems.

   1.02.00.020 - Bump cmd_per_lun in SHT to 255 for better jbod performance.

                 Make module license ifdef'd for backward compatibility.

                 Improve handling of errors in tw_interrupt().

                 Add handling/clearing of controller queue error.

                 Better alignment checking in tw_allocate_memory().

                 Cleanup tw_initialize_device_extension().

                 Empty stale responses before draining aen queue.

                 Fix tw_scsi_eh_abort() to not reset on every io abort.

                 Set can_queue in SHT to 255 to prevent hang from AEN.

   1.02.00.021 - Fix possible null pointer dereference in tw_scsi_release().

   1.02.00.022 - Fix bug in tw_aen_drain_queue() where unit # was always zero.

   1.02.00.023 - Add severity levels to AEN strings.

   1.02.00.024 - Fix command interrupt spurious error messages.

                 Fix bug in raw command post with data ioctl method.

                 Fix bug where rollcall sometimes failed with cable errors.

   1.02.00.025 - Print unit # on all command timeouts.

   1.02.00.026 - Fix possible infinite retry bug with power glitch induced

                 drive timeouts.

                 Cleanup some AEN severity levels.

   1.02.00.027 - Add drive not supported AEN code for SATA controllers.

                 Remove spurious unknown ioctl error message.

   1.02.00.028 - Fix bug where multiple controllers with no units were the

                 same card number.

                 Fix bug where cards were being shut down more than once.

   1.02.00.029 - Add new pci dma mapping for kernel 2.4 for highmem support.

                 Replace pci_map_single() with pci_map_page() for highmem.

                 Check for tw_setfeature() failure.

   1.02.00.030 - Make driver 64-bit clean.

   1.02.00.031 - Cleanup polling timeouts/routines in several places.

                 Add support for mode sense opcode.

                 Add support for cache mode page.

                 Add support for synchronize cache opcode.

   1.02.00.032 - Fix small multicard rollcall bug.

                 Make driver stay loaded with no units for hot add/swap.

                 Add support for "twe" character device for ioctls.

                 Clean up request_id queueing code.

                 Fix tw_scsi_queue() spinlocks.

   1.02.00.033 - Fix tw_aen_complete() to not queue 'queue empty' AEN's.

                 Initialize queues correctly when loading with no valid units.

   1.02.00.034 - Fix tw_decode_bits() to handle multiple errors.

                 Add support for user configurable cmd_per_lun.

                 Add support for sht->select_queue_depths.

   1.02.00.035 - Improve tw_allocate_memory() memory allocation.

                 Fix tw_chrdev_ioctl() to sleep correctly.

   1.02.00.036 - Increase character ioctl timeout to 60 seconds.

   1.02.00.037 - Fix tw_ioctl() to handle all non-data ATA passthru cmds

                 for 'smartmontools' support.

*/

#include <linux/module.h>

MODULE_AUTHOR ("3ware Inc.");

#ifdef CONFIG_SMP

MODULE_DESCRIPTION ("3ware Storage Controller Linux Driver (SMP)");

#else

MODULE_DESCRIPTION ("3ware Storage Controller Linux Driver");

#endif

#include <linux/kernel.h>

#include <linux/pci.h>

#include <linux/time.h>

#include <linux/proc_fs.h>

#include <linux/sched.h>

#include <linux/ioport.h>

#include <linux/blk.h>

#include <linux/hdreg.h>

#include <linux/string.h>

#include <linux/delay.h>

#include <linux/smp.h>

#include <linux/reboot.h>

#include <linux/spinlock.h>

#include <asm/errno.h>

#include <asm/io.h>

#include <asm/irq.h>

#include <asm/uaccess.h>

#define __3W_C                  /* let 3w-xxxx.h know it is use */

#include "sd.h"

#include "scsi.h"

#include "hosts.h"

#include "3w-xxxx.h"

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

MODULE_LICENSE("GPL");

#endif

static int tw_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);

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

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

static int tw_copy_info(TW_Info *info, char *fmt, ...);

static void tw_copy_mem_info(TW_Info *info, char *data, int len);

static void tw_interrupt(int irq, void *dev_instance, struct pt_regs *regs);

static int tw_halt(struct notifier_block *nb, ulong event, void *buf);

static int tw_map_scsi_sg_data(struct pci_dev *pdev, Scsi_Cmnd *cmd);

static u32 tw_map_scsi_single_data(struct pci_dev *pdev, Scsi_Cmnd *cmd);

static void tw_unmap_scsi_data(struct pci_dev *pdev, Scsi_Cmnd *cmd);

/* Notifier block to get a notify on system shutdown/halt/reboot */

static struct notifier_block tw_notifier = {

        tw_halt, NULL, 0

};

/* File operations struct for character device */

static struct file_operations tw_fops = {

        owner: THIS_MODULE,

        ioctl: tw_chrdev_ioctl,

        open: tw_chrdev_open,

        release: tw_chrdev_release

};

/* Globals */

char *tw_driver_version="1.02.00.037";

TW_Device_Extension *tw_device_extension_list[TW_MAX_SLOT];

int tw_device_extension_count = 0;

static int twe_major = -1;

/* Functions */

/* This function will complete an aen request from the isr */

int tw_aen_complete(TW_Device_Extension *tw_dev, int request_id)

{

        TW_Param *param;

        unsigned short aen;

        int error = 0, table_max = 0;

        dprintk(KERN_WARNING "3w-xxxx: tw_aen_complete()\n");

        if (tw_dev->alignment_virtual_address[request_id] == NULL) {

                printk(KERN_WARNING "3w-xxxx: tw_aen_complete(): Bad alignment virtual address.\n");

                return 1;

        }

        param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];

        aen = *(unsigned short *)(param->data);

        dprintk(KERN_NOTICE "3w-xxxx: tw_aen_complete(): Queue'd code 0x%x\n", aen);

        /* Print some useful info when certain aen codes come out */

        if (aen == 0x0ff) {

                printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: INFO: AEN queue overflow.\n", tw_dev->host->host_no);

        } else {

                table_max = sizeof(tw_aen_string)/sizeof(char *);

                if ((aen & 0x0ff) < table_max) {

                        if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') {

                                printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s%d.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff], aen >> 8);

                        } else {

                                if (aen != 0x0)

                                        printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff]);

                        }

                } else {

                        printk(KERN_WARNING "3w-xxxx: scsi%d: Received AEN %d.\n", tw_dev->host->host_no, aen);

                }

        }

        if (aen != TW_AEN_QUEUE_EMPTY) {

                tw_dev->aen_count++;

                /* Now queue the code */

                tw_dev->aen_queue[tw_dev->aen_tail] = aen;

                if (tw_dev->aen_tail == TW_Q_LENGTH - 1) {

                        tw_dev->aen_tail = TW_Q_START;

                } else {

                        tw_dev->aen_tail = tw_dev->aen_tail + 1;

                }

                if (tw_dev->aen_head == tw_dev->aen_tail) {

                        if (tw_dev->aen_head == TW_Q_LENGTH - 1) {

                                tw_dev->aen_head = TW_Q_START;

                        } else {

                                tw_dev->aen_head = tw_dev->aen_head + 1;

                        }

                }

                error = tw_aen_read_queue(tw_dev, request_id);

                if (error) {

                        printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing AEN.\n", tw_dev->host->host_no);

                        tw_dev->state[request_id] = TW_S_COMPLETED;

                        tw_state_request_finish(tw_dev, request_id);

                }

        } else {

                tw_dev->state[request_id] = TW_S_COMPLETED;

                tw_state_request_finish(tw_dev, request_id);

        }

        return 0;

} /* End tw_aen_complete() */

/* This function will drain the aen queue after a soft reset */

int tw_aen_drain_queue(TW_Device_Extension *tw_dev)

{

        TW_Command *command_packet;

        TW_Param *param;

        int request_id = 0;

        u32 command_que_addr;

        unsigned long command_que_value;

        unsigned long param_value;

        TW_Response_Queue response_queue;

        u32 response_que_addr;

        unsigned short aen;

        unsigned short aen_code;

        int finished = 0;

        int first_reset = 0;

        int queue = 0;

        int found = 0, table_max = 0;

        dprintk(KERN_NOTICE "3w-xxxx: tw_aen_drain_queue()\n");

        command_que_addr = tw_dev->registers.command_que_addr;

        response_que_addr = tw_dev->registers.response_que_addr;

        if (tw_poll_status(tw_dev, TW_STATUS_ATTENTION_INTERRUPT | TW_STATUS_MICROCONTROLLER_READY, 30)) {

                dprintk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): No attention interrupt for card %d.\n", tw_device_extension_count);

                return 1;

        }

        tw_clear_attention_interrupt(tw_dev);

        /* Empty response queue */

        tw_empty_response_que(tw_dev);

        /* Initialize command packet */

        if (tw_dev->command_packet_virtual_address[request_id] == NULL) {

                printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet virtual address.\n");

                return 1;

        }

        command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];

        memset(command_packet, 0, sizeof(TW_Sector));

        command_packet->byte0.opcode = TW_OP_GET_PARAM;

        command_packet->byte0.sgl_offset = 2;

        command_packet->size = 4;

        command_packet->request_id = request_id;

        command_packet->byte3.unit = 0;

        command_packet->byte3.host_id = 0;

        command_packet->status = 0;

        command_packet->flags = 0;

        command_packet->byte6.parameter_count = 1;

        command_que_value = tw_dev->command_packet_physical_address[request_id];

        if (command_que_value == 0) {

                printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet physical address.\n");

                return 1;

        }

        /* Now setup the param */

        if (tw_dev->alignment_virtual_address[request_id] == NULL) {

                printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment virtual address.\n");

                return 1;

        }

        param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];

        memset(param, 0, sizeof(TW_Sector));

        param->table_id = 0x401; /* AEN table */

        param->parameter_id = 2; /* Unit code */

        param->parameter_size_bytes = 2;

        param_value = tw_dev->alignment_physical_address[request_id];

        if (param_value == 0) {

                printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment physical address.\n");

                return 1;

        }

        command_packet->byte8.param.sgl[0].address = param_value;

        command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);

        /* Now drain the controller's aen queue */

        do {

                /* Post command packet */

                outl(command_que_value, command_que_addr);

                /* Now poll for completion */

                if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {

                        response_queue.value = inl(response_que_addr);

                        request_id = (unsigned char)response_queue.u.response_id;

                        if (request_id != 0) {

                                /* Unexpected request id */

                                printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Unexpected request id.\n");

                                return 1;

                        }

                        if (command_packet->status != 0) {

                                if (command_packet->flags != TW_AEN_TABLE_UNDEFINED) {

                                        /* Bad response */

                                        tw_decode_sense(tw_dev, request_id, 0);

                                        return 1;

                                } else {

                                        /* We know this is a 3w-1x00, and doesn't support aen's */

                                        return 0;

                                }

                        }

                        /* Now check the aen */

                        aen = *(unsigned short *)(param->data);

                        aen_code = (aen & 0x0ff);

                        queue = 0;

                        switch (aen_code) {

                                case TW_AEN_QUEUE_EMPTY:

                                        dprintk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);

                                        if (first_reset != 1) {

                                                return 1;

                                        } else {

                                                finished = 1;

                                        }

                                        break;

                                case TW_AEN_SOFT_RESET:

                                        if (first_reset == 0) {

                                                first_reset = 1;

                                        } else {

                                                printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);

                                                tw_dev->aen_count++;

                                                queue = 1;

                                        }

                                        break;

                                default:

                                        if (aen == 0x0ff) {

                                                printk(KERN_WARNING "3w-xxxx: AEN: INFO: AEN queue overflow.\n");

                                        } else {

                                                table_max = sizeof(tw_aen_string)/sizeof(char *);

                                                if ((aen & 0x0ff) < table_max) {

                                                        if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') {

                                                                printk(KERN_WARNING "3w-xxxx: AEN: %s%d.\n", tw_aen_string[aen & 0xff], aen >> 8);

                                                        } else {

                                                                printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);

                                                        }

                                                } else

                                                        printk(KERN_WARNING "3w-xxxx: Received AEN %d.\n", aen);

                                        }

                                        tw_dev->aen_count++;

                                        queue = 1;

                        }

                        /* Now put the aen on the aen_queue */

                        if (queue == 1) {

                                tw_dev->aen_queue[tw_dev->aen_tail] = aen;

                                if (tw_dev->aen_tail == TW_Q_LENGTH - 1) {

                                        tw_dev->aen_tail = TW_Q_START;

                                } else {

                                        tw_dev->aen_tail = tw_dev->aen_tail + 1;

                                }

                                if (tw_dev->aen_head == tw_dev->aen_tail) {

                                        if (tw_dev->aen_head == TW_Q_LENGTH - 1) {

                                                tw_dev->aen_head = TW_Q_START;

                                        } else {

                                                tw_dev->aen_head = tw_dev->aen_head + 1;

                                        }

                                }

                        }

                        found = 1;

                }

                if (found == 0) {

                        printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Response never received.\n");

                        return 1;

                }

        } while (finished == 0);

        return 0;

} /* End tw_aen_drain_queue() */

/* This function will read the aen queue from the isr */

int tw_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)

{

        TW_Command *command_packet;

        TW_Param *param;

        u32 command_que_addr;

        unsigned long command_que_value;

        u32 status_reg_value = 0, status_reg_addr;

        unsigned long param_value = 0;

        dprintk(KERN_NOTICE "3w-xxxx: tw_aen_read_queue()\n");

        command_que_addr = tw_dev->registers.command_que_addr;

        status_reg_addr = tw_dev->registers.status_reg_addr;

        status_reg_value = inl(status_reg_addr);

        if (tw_check_bits(status_reg_value)) {

                dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Unexpected bits.\n");

                tw_decode_bits(tw_dev, status_reg_value, 1);

                return 1;

        }

        if (tw_dev->command_packet_virtual_address[request_id] == NULL) {

                printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet virtual address.\n");

                return 1;

        }

        command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];

        memset(command_packet, 0, sizeof(TW_Sector));

        command_packet->byte0.opcode = TW_OP_GET_PARAM;

        command_packet->byte0.sgl_offset = 2;

        command_packet->size = 4;

        command_packet->request_id = request_id;

        command_packet->byte3.unit = 0;

        command_packet->byte3.host_id = 0;

        command_packet->status = 0;

        command_packet->flags = 0;

        command_packet->byte6.parameter_count = 1;

        command_que_value = tw_dev->command_packet_physical_address[request_id];

        if (command_que_value == 0) {

                printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet physical address.\n");

                return 1;

        }

        /* Now setup the param */

        if (tw_dev->alignment_virtual_address[request_id] == NULL) {

                printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment virtual address.\n");

                return 1;

        }

        param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];

        memset(param, 0, sizeof(TW_Sector));

        param->table_id = 0x401; /* AEN table */

        param->parameter_id = 2; /* Unit code */

        param->parameter_size_bytes = 2;

        param_value = tw_dev->alignment_physical_address[request_id];

        if (param_value == 0) {

                printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment physical address.\n");

                return 1;

        }

        command_packet->byte8.param.sgl[0].address = param_value;

        command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);

        /* Now post the command packet */

        if ((status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL) == 0) {

                dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post succeeded.\n");

                tw_dev->srb[request_id] = 0; /* Flag internal command */

                tw_dev->state[request_id] = TW_S_POSTED;

                outl(command_que_value, command_que_addr);

        } else {

                printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post failed, will retry.\n");

                return 1;

        }

        return 0;

} /* End tw_aen_read_queue() */

/* This function will allocate memory and check if it is 16 d-word aligned */

int tw_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)

{

        int i, imax;

        dma_addr_t dma_handle;

        unsigned long *cpu_addr = NULL;

        dprintk(KERN_NOTICE "3w-xxxx: tw_allocate_memory()\n");

        if (which == 2)

                imax = TW_MAX_BOUNCEBUF;

        else

                imax = TW_Q_LENGTH;

        cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*imax, &dma_handle);

        if (cpu_addr == NULL) {

                printk(KERN_WARNING "3w-xxxx: pci_alloc_consistent() failed.\n");

                return 1;

        }

        if ((unsigned long)cpu_addr % (tw_dev->tw_pci_dev->device == TW_DEVICE_ID ? TW_ALIGNMENT_6000 : TW_ALIGNMENT_7000)) {

                printk(KERN_WARNING "3w-xxxx: Couldn't allocate correctly aligned memory.\n");

                pci_free_consistent(tw_dev->tw_pci_dev, size*imax, cpu_addr, dma_handle);

                return 1;

        }

        memset(cpu_addr, 0, size*imax);

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

                switch(which) {

                case 0:

                        tw_dev->command_packet_physical_address[i] = dma_handle+(i*size);

                        tw_dev->command_packet_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));

                        break;

                case 1:

                        tw_dev->alignment_physical_address[i] = dma_handle+(i*size);

                        tw_dev->alignment_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));

                        break;

                case 2:

                        tw_dev->bounce_buffer_phys[i] = dma_handle+(i*size);

                        tw_dev->bounce_buffer[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));

                        break;

                default:

                        printk(KERN_WARNING "3w-xxxx: tw_allocate_memory(): case slip in tw_allocate_memory()\n");

                        return 1;

                }

        }

        return 0;

} /* End tw_allocate_memory() */

/* This function will check the status register for unexpected bits */

int tw_check_bits(u32 status_reg_value)

{

        if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS) {

                dprintk(KERN_WARNING "3w-xxxx: tw_check_bits(): No expected bits (0x%x).\n", status_reg_value);

                return 1;

        }

        if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0) {

                dprintk(KERN_WARNING "3w-xxxx: tw_check_bits(): Found unexpected bits (0x%x).\n", status_reg_value);

                return 1;

        }

        return 0;

} /* End tw_check_bits() */

/* This function will report controller error status */

int tw_check_errors(TW_Device_Extension *tw_dev)

{

        u32 status_reg_addr, status_reg_value;

        status_reg_addr = tw_dev->registers.status_reg_addr;

        status_reg_value = inl(status_reg_addr);

        if (TW_STATUS_ERRORS(status_reg_value) || tw_check_bits(status_reg_value)) {

                tw_decode_bits(tw_dev, status_reg_value, 0);

                return 1;

        }

        return 0;

} /* End tw_check_errors() */

/* This function handles ioctl for the character device */

static int tw_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)

{

        int error, request_id;

        dma_addr_t dma_handle;

        unsigned short tw_aen_code;

        unsigned long flags;

        unsigned int data_buffer_length = 0;

        unsigned long data_buffer_length_adjusted = 0;

        unsigned long *cpu_addr;

        long timeout;

        TW_New_Ioctl *tw_ioctl;

        TW_Passthru *passthru;

        TW_Device_Extension *tw_dev = tw_device_extension_list[MINOR(inode->i_rdev)];

        int retval = -EFAULT;

        dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl()\n");

        /* Only let one of these through at a time */

        if (down_interruptible(&tw_dev->ioctl_sem))

                return -EINTR;

        /* First copy down the buffer length */

        error = copy_from_user(&data_buffer_length, (void *)arg, sizeof(unsigned int));

        if (error)

                goto out;

        /* Check size */

        if (data_buffer_length > TW_MAX_SECTORS * 512) {

                retval = -EINVAL;

                goto out;

        }

        /* Hardware can only do multiple of 512 byte transfers */

        data_buffer_length_adjusted = (data_buffer_length + 511) & ~511;

        /* Now allocate ioctl buf memory */

        cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, &dma_handle);