Commit | Line | Data |
---|---|---|
1da177e4 LT |
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> | |
0c2cc433 | 24 | #include <linux/mutex.h> |
1da177e4 LT |
25 | #include <linux/interrupt.h> |
26 | #include <linux/delay.h> | |
27 | #include <linux/blkdev.h> | |
28 | #include <linux/list.h> | |
1da177e4 | 29 | #include <linux/moduleparam.h> |
672b2d38 | 30 | #include <linux/dma-mapping.h> |
1da177e4 LT |
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 | ||
fbf60802 JS |
40 | #define HBA_SIGNATURE_64_BIT 0x299 |
41 | #define PCI_CONF_AMISIG64 0xa4 | |
42 | ||
aa677bc7 JS |
43 | #define MEGA_SCSI_INQ_EVPD 1 |
44 | #define MEGA_INVALID_FIELD_IN_CDB 0x24 | |
45 | ||
1da177e4 LT |
46 | |
47 | /** | |
48 | * scb_t - scsi command control block | |
a69b74d3 RD |
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 | |
1da177e4 LT |
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 | */ | |
68 | typedef 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 | |
a69b74d3 RD |
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 | |
1da177e4 LT |
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 | ||
155 | typedef struct { | |
156 | struct tasklet_struct dpc_h; | |
157 | struct pci_dev *pdev; | |
158 | struct Scsi_Host *host; | |
1da177e4 LT |
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; | |
f5ebbeb5 | 178 | int irq; |
1da177e4 LT |
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 | |
9cb78c16 | 207 | #define SCP2LUN(scp) (u32)(scp)->device->lun // to LUN |
1da177e4 LT |
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 | ||
1da177e4 LT |
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 | ||
a69b74d3 RD |
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 | */ | |
1da177e4 LT |
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", \ | |
cadbd4a5 | 268 | #expression, __FILE__, __LINE__, __func__); \ |
1da177e4 LT |
269 | } |
270 | #else | |
271 | #define ASSERT(expression) | |
272 | #endif | |
273 | ||
59f19a9e | 274 | /** |
1da177e4 | 275 | * struct mraid_pci_blk - structure holds DMA memory block info |
a69b74d3 RD |
276 | * @vaddr : virtual address to a memory block |
277 | * @dma_addr : DMA handle to a memory block | |
1da177e4 LT |
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 | */ | |
283 | struct 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: |