drivers/scsi/megaraid/mega_common.h

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