drivers/scsi/megaraid/mega_common.h

   1 /*
   2  *
   3  *                      Linux MegaRAID device driver
   4  *
   5  * Copyright (c) 2003-2004  LSI Logic Corporation.
   6  *
   7  *         This program is free software; you can redistribute it and/or
   8  *         modify it under the terms of the GNU General Public License
   9  *         as published by the Free Software Foundation; either version
  10  *         2 of the License, or (at your option) any later version.
  11  *
  12  * FILE         : mega_common.h
  13  *
  14  * Libaray of common routine used by all low-level megaraid drivers
  15  */
  16
  17 #ifndef _MEGA_COMMON_H_
  18 #define _MEGA_COMMON_H_
  19
  20 #include <linux/kernel.h>
  21 #include <linux/types.h>
  22 #include <linux/pci.h>
  23 #include <linux/spinlock.h>
  24 #include <linux/mutex.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/delay.h>
  27 #include <linux/blkdev.h>
  28 #include <linux/list.h>
  29 #include <linux/moduleparam.h>
  30 #include <linux/dma-mapping.h>
  31 #include <asm/semaphore.h>
  32 #include <scsi/scsi.h>
  33 #include <scsi/scsi_cmnd.h>
  34 #include <scsi/scsi_device.h>
  35 #include <scsi/scsi_host.h>
  36
  37
  38 #define LSI_MAX_CHANNELS                16
  39 #define LSI_MAX_LOGICAL_DRIVES_64LD     (64+1)
  40
  41 #define HBA_SIGNATURE_64_BIT            0x299
  42 #define PCI_CONF_AMISIG64               0xa4
  43
  44 #define MEGA_SCSI_INQ_EVPD              1
  45 #define MEGA_INVALID_FIELD_IN_CDB       0x24
  46
  47
  48 /**
  49  * scb_t - scsi command control block
  50  * @ccb                 : command control block for individual driver
  51  * @list                : list of control blocks
  52  * @gp                  : general purpose field for LLDs
  53  * @sno                 : all SCBs have a serial number
  54  * @scp                 : associated scsi command
  55  * @state               : current state of scb
  56  * @dma_dir             : direction of data transfer
  57  * @dma_type            : transfer with sg list, buffer, or no data transfer
  58  * @dev_channel         : actual channel on the device
  59  * @dev_target          : actual target on the device
  60  * @status              : completion status
  61  *
  62  * This is our central data structure to issue commands the each driver.
  63  * Driver specific data structures are maintained in the ccb field.
  64  * scb provides a field 'gp', which can be used by LLD for its own purposes
  65  *
  66  * dev_channel and dev_target must be initialized with the actual channel and
  67  * target on the controller.
  68  */
  69 typedef struct {
  70         caddr_t                 ccb;
  71         struct list_head        list;
  72         unsigned long           gp;
  73         unsigned int            sno;
  74         struct scsi_cmnd        *scp;
  75         uint32_t                state;
  76         uint32_t                dma_direction;
  77         uint32_t                dma_type;
  78         uint16_t                dev_channel;
  79         uint16_t                dev_target;
  80         uint32_t                status;
  81 } scb_t;
  82
  83 /*
  84  * SCB states as it transitions from one state to another
  85  */
  86 #define SCB_FREE        0x0000  /* on the free list */
  87 #define SCB_ACTIVE      0x0001  /* off the free list */
  88 #define SCB_PENDQ       0x0002  /* on the pending queue */
  89 #define SCB_ISSUED      0x0004  /* issued - owner f/w */
  90 #define SCB_ABORT       0x0008  /* Got an abort for this one */
  91 #define SCB_RESET       0x0010  /* Got a reset for this one */
  92
  93 /*
  94  * DMA types for scb
  95  */
  96 #define MRAID_DMA_NONE  0x0000  /* no data transfer for this command */
  97 #define MRAID_DMA_WSG   0x0001  /* data transfer using a sg list */
  98 #define MRAID_DMA_WBUF  0x0002  /* data transfer using a contiguous buffer */
  99
 100
 101 /**
 102  * struct adapter_t - driver's initialization structure
 103  * @aram dpc_h                  : tasklet handle
 104  * @pdev                        : pci configuration pointer for kernel
 105  * @host                        : pointer to host structure of mid-layer
 106  * @lock                        : synchronization lock for mid-layer and driver
 107  * @quiescent                   : driver is quiescent for now.
 108  * @outstanding_cmds            : number of commands pending in the driver
 109  * @kscb_list                   : pointer to the bulk of SCBs pointers for IO
 110  * @kscb_pool                   : pool of free scbs for IO
 111  * @kscb_pool_lock              : lock for pool of free scbs
 112  * @pend_list                   : pending commands list
 113  * @pend_list_lock              : exclusion lock for pending commands list
 114  * @completed_list              : list of completed commands
 115  * @completed_list_lock         : exclusion lock for list of completed commands
 116  * @sglen                       : max sg elements supported
 117  * @device_ids                  : to convert kernel device addr to our devices.
 118  * @raid_device                 : raid adapter specific pointer
 119  * @max_channel                 : maximum channel number supported - inclusive
 120  * @max_target                  : max target supported - inclusive
 121  * @max_lun                     : max lun supported - inclusive
 122  * @unique_id                   : unique identifier for each adapter
 123  * @irq                         : IRQ for this adapter
 124  * @ito                         : internal timeout value, (-1) means no timeout
 125  * @ibuf                        : buffer to issue internal commands
 126  * @ibuf_dma_h                  : dma handle for the above buffer
 127  * @uscb_list                   : SCB pointers for user cmds, common mgmt module
 128  * @uscb_pool                   : pool of SCBs for user commands
 129  * @uscb_pool_lock              : exclusion lock for these SCBs
 130  * @max_cmds                    : max outstanding commands
 131  * @fw_version                  : firmware version
 132  * @bios_version                : bios version
 133  * @max_cdb_sz                  : biggest CDB size supported.
 134  * @ha                          : is high availability present - clustering
 135  * @init_id                     : initiator ID, the default value should be 7
 136  * @max_sectors                 : max sectors per request
 137  * @cmd_per_lun                 : max outstanding commands per LUN
 138  * @being_detached              : set when unloading, no more mgmt calls
 139  *
 140  *
 141  * mraid_setup_device_map() can be called anytime after the device map is
 142  * available and MRAID_GET_DEVICE_MAP() can be called whenever the mapping is
 143  * required, usually from LLD's queue entry point. The formar API sets up the
 144  * MRAID_IS_LOGICAL(adapter_t *, struct scsi_cmnd *) to find out if the
 145  * device in question is a logical drive.
 146  *
 147  * quiescent flag should be set by the driver if it is not accepting more
 148  * commands
 149  *
 150  * NOTE: The fields of this structures are placed to minimize cache misses
 151  */
 152
 153 // amount of space required to store the bios and firmware version strings
 154 #define VERSION_SIZE    16
 155
 156 typedef struct {
 157         struct tasklet_struct   dpc_h;
 158         struct pci_dev          *pdev;
 159         struct Scsi_Host        *host;
 160         spinlock_t              lock;
 161         uint8_t                 quiescent;
 162         int                     outstanding_cmds;
 163         scb_t                   *kscb_list;
 164         struct list_head        kscb_pool;
 165         spinlock_t              kscb_pool_lock;
 166         struct list_head        pend_list;
 167         spinlock_t              pend_list_lock;
 168         struct list_head        completed_list;
 169         spinlock_t              completed_list_lock;
 170         uint16_t                sglen;
 171         int                     device_ids[LSI_MAX_CHANNELS]
 172                                         [LSI_MAX_LOGICAL_DRIVES_64LD];
 173         caddr_t                 raid_device;
 174         uint8_t                 max_channel;
 175         uint16_t                max_target;
 176         uint8_t                 max_lun;
 177
 178         uint32_t                unique_id;
 179         int                     irq;
 180         uint8_t                 ito;
 181         caddr_t                 ibuf;
 182         dma_addr_t              ibuf_dma_h;
 183         scb_t                   *uscb_list;
 184         struct list_head        uscb_pool;
 185         spinlock_t              uscb_pool_lock;
 186         int                     max_cmds;
 187         uint8_t                 fw_version[VERSION_SIZE];
 188         uint8_t                 bios_version[VERSION_SIZE];
 189         uint8_t                 max_cdb_sz;
 190         uint8_t                 ha;
 191         uint16_t                init_id;
 192         uint16_t                max_sectors;
 193         uint16_t                cmd_per_lun;
 194         atomic_t                being_detached;
 195 } adapter_t;
 196
 197 #define SCSI_FREE_LIST_LOCK(adapter)    (&adapter->kscb_pool_lock)
 198 #define USER_FREE_LIST_LOCK(adapter)    (&adapter->uscb_pool_lock)
 199 #define PENDING_LIST_LOCK(adapter)      (&adapter->pend_list_lock)
 200 #define COMPLETED_LIST_LOCK(adapter)    (&adapter->completed_list_lock)
 201
 202
 203 // conversion from scsi command
 204 #define SCP2HOST(scp)                   (scp)->device->host     // to host
 205 #define SCP2HOSTDATA(scp)               SCP2HOST(scp)->hostdata // to soft state
 206 #define SCP2CHANNEL(scp)                (scp)->device->channel  // to channel
 207 #define SCP2TARGET(scp)                 (scp)->device->id       // to target
 208 #define SCP2LUN(scp)                    (scp)->device->lun      // to LUN
 209
 210 // generic macro to convert scsi command and host to controller's soft state
 211 #define SCSIHOST2ADAP(host)     (((caddr_t *)(host->hostdata))[0])
 212 #define SCP2ADAPTER(scp)        (adapter_t *)SCSIHOST2ADAP(SCP2HOST(scp))
 213
 214
 215 #define MRAID_IS_LOGICAL(adp, scp)      \
 216         (SCP2CHANNEL(scp) == (adp)->max_channel) ? 1 : 0
 217
 218 #define MRAID_IS_LOGICAL_SDEV(adp, sdev)        \
 219         (sdev->channel == (adp)->max_channel) ? 1 : 0
 220
 221 /**
 222  * MRAID_GET_DEVICE_MAP - device ids
 223  * @adp                 : adapter's soft state
 224  * @scp                 : mid-layer scsi command pointer
 225  * @p_chan              : physical channel on the controller
 226  * @target              : target id of the device or logical drive number
 227  * @islogical           : set if the command is for the logical drive
 228  *
 229  * Macro to retrieve information about device class, logical or physical and
 230  * the corresponding physical channel and target or logical drive number
 231  */
 232 #define MRAID_GET_DEVICE_MAP(adp, scp, p_chan, target, islogical)       \
 233         /*                                                              \
 234          * Is the request coming for the virtual channel                \
 235          */                                                             \
 236         islogical = MRAID_IS_LOGICAL(adp, scp);                         \
 237                                                                         \
 238         /*                                                              \
 239          * Get an index into our table of drive ids mapping             \
 240          */                                                             \
 241         if (islogical) {                                                \
 242                 p_chan = 0xFF;                                          \
 243                 target =                                                \
 244                 (adp)->device_ids[(adp)->max_channel][SCP2TARGET(scp)]; \
 245         }                                                               \
 246         else {                                                          \
 247                 p_chan = ((adp)->device_ids[SCP2CHANNEL(scp)]           \
 248                                         [SCP2TARGET(scp)] >> 8) & 0xFF; \
 249                 target = ((adp)->device_ids[SCP2CHANNEL(scp)]           \
 250                                         [SCP2TARGET(scp)] & 0xFF);      \
 251         }
 252
 253 /*
 254  * ### Helper routines ###
 255  */
 256 #define LSI_DBGLVL mraid_debug_level    // each LLD must define a global
 257                                         // mraid_debug_level
 258
 259 #ifdef DEBUG
 260 #if defined (_ASSERT_PANIC)
 261 #define ASSERT_ACTION   panic
 262 #else
 263 #define ASSERT_ACTION   printk
 264 #endif
 265
 266 #define ASSERT(expression)                                              \
 267         if (!(expression)) {                                            \
 268         ASSERT_ACTION("assertion failed:(%s), file: %s, line: %d:%s\n", \
 269                         #expression, __FILE__, __LINE__, __FUNCTION__); \
 270         }
 271 #else
 272 #define ASSERT(expression)
 273 #endif
 274
 275 /**
 276  * struct mraid_pci_blk - structure holds DMA memory block info
 277  * @vaddr               : virtual address to a memory block
 278  * @dma_addr            : DMA handle to a memory block
 279  *
 280  * This structure is filled up for the caller. It is the responsibilty of the
 281  * caller to allocate this array big enough to store addresses for all
 282  * requested elements
 283  */
 284 struct mraid_pci_blk {
 285         caddr_t         vaddr;
 286         dma_addr_t      dma_addr;
 287 };
 288
 289 #endif // _MEGA_COMMON_H_
 290
 291 // vim: set ts=8 sw=8 tw=78: