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