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 */ 64typedef 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 151typedef 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 */ 279struct mraid_pci_blk { 280 caddr_t vaddr; 281 dma_addr_t dma_addr; 282}; 283 284#endif // _MEGA_COMMON_H_ 285