Linux-2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 286 insertions, 0 deletions

diff --git a/drivers/scsi/megaraid/mega_common.h b/drivers/scsi/megaraid/mega_common.h
new file mode 100644
index 00000000000..18969a4946b
--- /dev/null
+++ b/drivers/scsi/megaraid/mega_common.h
@@ -0,0 +1,286 @@
+/*
+ *
+ *                      Linux MegaRAID device driver
+ *
+ * Copyright (c) 2003-2004  LSI Logic Corporation.
+ *
+ *         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; either version
+ *         2 of the License, or (at your option) any later version.
+ *
+ * FILE         : mega_common.h
+ *
+ * Libaray of common routine used by all low-level megaraid drivers
+ */
+
+#ifndef _MEGA_COMMON_H_
+#define _MEGA_COMMON_H_
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/pci.h>
+#include <linux/spinlock.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/blkdev.h>
+#include <linux/list.h>
+#include <linux/version.h>
+#include <linux/moduleparam.h>
+#include <asm/semaphore.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_host.h>
+
+
+#define LSI_MAX_CHANNELS                16
+#define LSI_MAX_LOGICAL_DRIVES_64LD     (64+1)
+
+
+/**
+ * scb_t - scsi command control block
+ * @param ccb           : command control block for individual driver
+ * @param list          : list of control blocks
+ * @param gp            : general purpose field for LLDs
+ * @param sno           : all SCBs have a serial number
+ * @param scp           : associated scsi command
+ * @param state         : current state of scb
+ * @param dma_dir       : direction of data transfer
+ * @param dma_type      : transfer with sg list, buffer, or no data transfer
+ * @param dev_channel   : actual channel on the device
+ * @param dev_target    : actual target on the device
+ * @param status        : completion status
+ *
+ * This is our central data structure to issue commands the each driver.
+ * Driver specific data structures are maintained in the ccb field.
+ * scb provides a field 'gp', which can be used by LLD for its own purposes
+ *
+ * dev_channel and dev_target must be initialized with the actual channel and
+ * target on the controller.
+ */
+typedef struct {
+        caddr_t                 ccb;
+        struct list_head        list;
+        unsigned long           gp;
+        unsigned int            sno;
+        struct scsi_cmnd        *scp;
+        uint32_t                state;
+        uint32_t                dma_direction;
+        uint32_t                dma_type;
+        uint16_t                dev_channel;
+        uint16_t                dev_target;
+        uint32_t                status;
+} scb_t;
+
+/*
+ * SCB states as it transitions from one state to another
+ */
+#define SCB_FREE        0x0000  /* on the free list */
+#define SCB_ACTIVE      0x0001  /* off the free list */
+#define SCB_PENDQ       0x0002  /* on the pending queue */
+#define SCB_ISSUED      0x0004  /* issued - owner f/w */
+#define SCB_ABORT       0x0008  /* Got an abort for this one */
+#define SCB_RESET       0x0010  /* Got a reset for this one */
+
+/*
+ * DMA types for scb
+ */
+#define MRAID_DMA_NONE  0x0000  /* no data transfer for this command */
+#define MRAID_DMA_WSG   0x0001  /* data transfer using a sg list */
+#define MRAID_DMA_WBUF  0x0002  /* data transfer using a contiguous buffer */
+
+
+/**
+ * struct adapter_t - driver's initialization structure
+ * @param dpc_h                 : tasklet handle
+ * @param pdev                  : pci configuration pointer for kernel
+ * @param host                  : pointer to host structure of mid-layer
+ * @param host_lock             : pointer to appropriate lock
+ * @param lock                  : synchronization lock for mid-layer and driver
+ * @param quiescent             : driver is quiescent for now.
+ * @param outstanding_cmds      : number of commands pending in the driver
+ * @param kscb_list             : pointer to the bulk of SCBs pointers for IO
+ * @param kscb_pool             : pool of free scbs for IO
+ * @param kscb_pool_lock        : lock for pool of free scbs
+ * @param pend_list             : pending commands list
+ * @param pend_list_lock        : exlusion lock for pending commands list
+ * @param completed_list        : list of completed commands
+ * @param completed_list_lock   : exclusion lock for list of completed commands
+ * @param sglen                 : max sg elements supported
+ * @param device_ids            : to convert kernel device addr to our devices.
+ * @param raid_device           : raid adapter specific pointer
+ * @param max_channel           : maximum channel number supported - inclusive
+ * @param max_target            : max target supported - inclusive
+ * @param max_lun               : max lun supported - inclusive
+ * @param unique_id             : unique identifier for each adapter
+ * @param irq                   : IRQ for this adapter
+ * @param ito                   : internal timeout value, (-1) means no timeout
+ * @param ibuf                  : buffer to issue internal commands
+ * @param ibuf_dma_h            : dma handle for the above buffer
+ * @param uscb_list             : SCB pointers for user cmds, common mgmt module
+ * @param uscb_pool             : pool of SCBs for user commands
+ * @param uscb_pool_lock        : exclusion lock for these SCBs
+ * @param max_cmds              : max outstanding commands
+ * @param fw_version            : firmware version
+ * @param bios_version          : bios version
+ * @param max_cdb_sz            : biggest CDB size supported.
+ * @param ha                    : is high availability present - clustering
+ * @param init_id               : initiator ID, the default value should be 7
+ * @param max_sectors           : max sectors per request
+ * @param cmd_per_lun           : max outstanding commands per LUN
+ * @param being_detached        : set when unloading, no more mgmt calls
+ *
+ *
+ * mraid_setup_device_map() can be called anytime after the device map is
+ * available and MRAID_GET_DEVICE_MAP() can be called whenever the mapping is
+ * required, usually from LLD's queue entry point. The formar API sets up the
+ * MRAID_IS_LOGICAL(adapter_t *, struct scsi_cmnd *) to find out if the
+ * device in question is a logical drive.
+ *
+ * quiescent flag should be set by the driver if it is not accepting more
+ * commands
+ *
+ * NOTE: The fields of this structures are placed to minimize cache misses
+ */
+
+// amount of space required to store the bios and firmware version strings
+#define VERSION_SIZE    16
+
+typedef struct {
+        struct tasklet_struct   dpc_h;
+        struct pci_dev          *pdev;
+        struct Scsi_Host        *host;
+        spinlock_t              *host_lock;
+        spinlock_t              lock;
+        uint8_t                 quiescent;
+        int                     outstanding_cmds;
+        scb_t                   *kscb_list;
+        struct list_head        kscb_pool;
+        spinlock_t              kscb_pool_lock;
+        struct list_head        pend_list;
+        spinlock_t              pend_list_lock;
+        struct list_head        completed_list;
+        spinlock_t              completed_list_lock;
+        uint16_t                sglen;
+        int                     device_ids[LSI_MAX_CHANNELS]
+                                        [LSI_MAX_LOGICAL_DRIVES_64LD];
+        caddr_t                 raid_device;
+        uint8_t                 max_channel;
+        uint16_t                max_target;
+        uint8_t                 max_lun;
+
+        uint32_t                unique_id;
+        uint8_t                 irq;
+        uint8_t                 ito;
+        caddr_t                 ibuf;
+        dma_addr_t              ibuf_dma_h;
+        scb_t                   *uscb_list;
+        struct list_head        uscb_pool;
+        spinlock_t              uscb_pool_lock;
+        int                     max_cmds;
+        uint8_t                 fw_version[VERSION_SIZE];
+        uint8_t                 bios_version[VERSION_SIZE];
+        uint8_t                 max_cdb_sz;
+        uint8_t                 ha;
+        uint16_t                init_id;
+        uint16_t                max_sectors;
+        uint16_t                cmd_per_lun;
+        atomic_t                being_detached;
+} adapter_t;
+
+#define SCSI_FREE_LIST_LOCK(adapter)    (&adapter->kscb_pool_lock)
+#define USER_FREE_LIST_LOCK(adapter)    (&adapter->uscb_pool_lock)
+#define PENDING_LIST_LOCK(adapter)      (&adapter->pend_list_lock)
+#define COMPLETED_LIST_LOCK(adapter)    (&adapter->completed_list_lock)
+
+
+// conversion from scsi command
+#define SCP2HOST(scp)                   (scp)->device->host     // to host
+#define SCP2HOSTDATA(scp)               SCP2HOST(scp)->hostdata // to soft state
+#define SCP2CHANNEL(scp)                (scp)->device->channel  // to channel
+#define SCP2TARGET(scp)                 (scp)->device->id       // to target
+#define SCP2LUN(scp)                    (scp)->device->lun      // to LUN
+
+// generic macro to convert scsi command and host to controller's soft state
+#define SCSIHOST2ADAP(host)     (((caddr_t *)(host->hostdata))[0])
+#define SCP2ADAPTER(scp)        (adapter_t *)SCSIHOST2ADAP(SCP2HOST(scp))
+
+
+/**
+ * MRAID_GET_DEVICE_MAP - device ids
+ * @param adp           - Adapter's soft state
+ * @param scp           - mid-layer scsi command pointer
+ * @param p_chan        - physical channel on the controller
+ * @param target        - target id of the device or logical drive number
+ * @param islogical     - set if the command is for the logical drive
+ *
+ * Macro to retrieve information about device class, logical or physical and
+ * the corresponding physical channel and target or logical drive number
+ **/
+#define MRAID_IS_LOGICAL(adp, scp)      \
+        (SCP2CHANNEL(scp) == (adp)->max_channel) ? 1 : 0
+
+#define MRAID_IS_LOGICAL_SDEV(adp, sdev)        \
+        (sdev->channel == (adp)->max_channel) ? 1 : 0
+
+#define MRAID_GET_DEVICE_MAP(adp, scp, p_chan, target, islogical)       \
+        /*                                                              \
+         * Is the request coming for the virtual channel                \
+         */                                                             \
+        islogical = MRAID_IS_LOGICAL(adp, scp);                         \
+                                                                        \
+        /*                                                              \
+         * Get an index into our table of drive ids mapping             \
+         */                                                             \
+        if (islogical) {                                                \
+                p_chan = 0xFF;                                          \
+                target =                                                \
+                (adp)->device_ids[(adp)->max_channel][SCP2TARGET(scp)]; \
+        }                                                               \
+        else {                                                          \
+                p_chan = ((adp)->device_ids[SCP2CHANNEL(scp)]           \
+                                        [SCP2TARGET(scp)] >> 8) & 0xFF; \
+                target = ((adp)->device_ids[SCP2CHANNEL(scp)]           \
+                                        [SCP2TARGET(scp)] & 0xFF);      \
+        }
+
+/*
+ * ### Helper routines ###
+ */
+#define LSI_DBGLVL mraid_debug_level    // each LLD must define a global
+                                        // mraid_debug_level
+
+#ifdef DEBUG
+#if defined (_ASSERT_PANIC)
+#define ASSERT_ACTION   panic
+#else
+#define ASSERT_ACTION   printk
+#endif
+
+#define ASSERT(expression)                                              \
+        if (!(expression)) {                                            \
+        ASSERT_ACTION("assertion failed:(%s), file: %s, line: %d:%s\n", \
+                        #expression, __FILE__, __LINE__, __FUNCTION__); \
+        }
+#else
+#define ASSERT(expression)
+#endif
+
+/*
+ * struct mraid_pci_blk - structure holds DMA memory block info
+ * @param vaddr         : virtual address to a memory block
+ * @param dma_addr      : DMA handle to a memory block
+ *
+ * This structure is filled up for the caller. It is the responsibilty of the
+ * caller to allocate this array big enough to store addresses for all
+ * requested elements
+ */
+struct mraid_pci_blk {
+        caddr_t         vaddr;
+        dma_addr_t      dma_addr;
+};
+
+#endif // _MEGA_COMMON_H_
+
+// vim: set ts=8 sw=8 tw=78: