2 * Disk Array driver for HP Smart Array SAS controllers
3 * Copyright 2000, 2009 Hewlett-Packard Development Company, L.P.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; version 2 of the License.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
12 * NON INFRINGEMENT. See the GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 * Questions/Comments/Bugfixes to iss_storagedev@hp.com
24 #include <scsi/scsicam.h>
31 struct access_method {
32 void (*submit_command)(struct ctlr_info *h,
33 struct CommandList *c);
34 void (*set_intr_mask)(struct ctlr_info *h, unsigned long val);
35 unsigned long (*fifo_full)(struct ctlr_info *h);
36 bool (*intr_pending)(struct ctlr_info *h);
37 unsigned long (*command_completed)(struct ctlr_info *h, u8 q);
40 struct hpsa_scsi_dev_t {
42 int bus, target, lun; /* as presented to the OS */
43 unsigned char scsi3addr[8]; /* as presented to the HW */
44 #define RAID_CTLR_LUNID "\0\0\0\0\0\0\0\0"
45 unsigned char device_id[16]; /* from inquiry pg. 0x83 */
46 unsigned char vendor[8]; /* bytes 8-15 of inquiry data */
47 unsigned char model[16]; /* bytes 16-31 of inquiry data */
48 unsigned char raid_level; /* from inquiry page 0xC1 */
50 int offload_config; /* I/O accel RAID offload configured */
51 int offload_enabled; /* I/O accel RAID offload enabled */
52 int offload_to_mirror; /* Send next I/O accelerator RAID
53 * offload request to mirror drive
55 struct raid_map_data raid_map; /* I/O accelerator RAID map */
74 int nr_cmds; /* Number of commands allowed on this controller */
75 struct CfgTable __iomem *cfgtable;
76 int interrupts_enabled;
79 int commands_outstanding;
80 int max_outstanding; /* Debug */
81 int usage_count; /* number of opens all all minor devices */
82 # define PERF_MODE_INT 0
83 # define DOORBELL_INT 1
84 # define SIMPLE_MODE_INT 2
85 # define MEMQ_MODE_INT 3
86 unsigned int intr[MAX_REPLY_QUEUES];
87 unsigned int msix_vector;
88 unsigned int msi_vector;
89 int intr_mode; /* either PERF_MODE_INT or SIMPLE_MODE_INT */
90 struct access_method access;
92 /* queue and queue Info */
93 struct list_head reqQ;
94 struct list_head cmpQ;
99 u8 max_cmd_sg_entries;
101 struct SGDescriptor **cmd_sg_list;
103 /* pointers to command and error info pool */
104 struct CommandList *cmd_pool;
105 dma_addr_t cmd_pool_dhandle;
106 struct io_accel1_cmd *ioaccel_cmd_pool;
107 dma_addr_t ioaccel_cmd_pool_dhandle;
108 struct ErrorInfo *errinfo_pool;
109 dma_addr_t errinfo_pool_dhandle;
110 unsigned long *cmd_pool_bits;
112 spinlock_t scan_lock;
113 wait_queue_head_t scan_wait_queue;
115 struct Scsi_Host *scsi_host;
116 spinlock_t devlock; /* to protect hba[ctlr]->dev[]; */
117 int ndevices; /* number of used elements in .dev[] array. */
118 struct hpsa_scsi_dev_t *dev[HPSA_MAX_DEVICES];
120 * Performant mode tables.
124 struct TransTable_struct *transtable;
125 unsigned long transMethod;
127 /* cap concurrent passthrus at some reasonable maximum */
128 #define HPSA_MAX_CONCURRENT_PASSTHRUS (20)
129 spinlock_t passthru_count_lock; /* protects passthru_count */
133 * Performant mode completion buffers
136 size_t reply_pool_size;
137 struct reply_pool reply_queue[MAX_REPLY_QUEUES];
139 dma_addr_t reply_pool_dhandle;
140 u32 *blockFetchTable;
141 u32 *ioaccel1_blockFetchTable;
142 unsigned char *hba_inquiry_data;
147 u64 last_intr_timestamp;
149 u64 last_heartbeat_timestamp;
150 u32 heartbeat_sample_interval;
151 atomic_t firmware_flash_in_progress;
153 struct delayed_work monitor_ctlr_work;
154 int remove_in_progress;
155 u32 fifo_recently_full;
156 /* Address of h->q[x] is passed to intr handler to know which queue */
157 u8 q[MAX_REPLY_QUEUES];
158 u32 TMFSupportFlags; /* cache what task mgmt funcs are supported. */
159 #define HPSATMF_BITS_SUPPORTED (1 << 0)
160 #define HPSATMF_PHYS_LUN_RESET (1 << 1)
161 #define HPSATMF_PHYS_NEX_RESET (1 << 2)
162 #define HPSATMF_PHYS_TASK_ABORT (1 << 3)
163 #define HPSATMF_PHYS_TSET_ABORT (1 << 4)
164 #define HPSATMF_PHYS_CLEAR_ACA (1 << 5)
165 #define HPSATMF_PHYS_CLEAR_TSET (1 << 6)
166 #define HPSATMF_PHYS_QRY_TASK (1 << 7)
167 #define HPSATMF_PHYS_QRY_TSET (1 << 8)
168 #define HPSATMF_PHYS_QRY_ASYNC (1 << 9)
169 #define HPSATMF_MASK_SUPPORTED (1 << 16)
170 #define HPSATMF_LOG_LUN_RESET (1 << 17)
171 #define HPSATMF_LOG_NEX_RESET (1 << 18)
172 #define HPSATMF_LOG_TASK_ABORT (1 << 19)
173 #define HPSATMF_LOG_TSET_ABORT (1 << 20)
174 #define HPSATMF_LOG_CLEAR_ACA (1 << 21)
175 #define HPSATMF_LOG_CLEAR_TSET (1 << 22)
176 #define HPSATMF_LOG_QRY_TASK (1 << 23)
177 #define HPSATMF_LOG_QRY_TSET (1 << 24)
178 #define HPSATMF_LOG_QRY_ASYNC (1 << 25)
181 #define HPSA_ABORT_MSG 0
182 #define HPSA_DEVICE_RESET_MSG 1
183 #define HPSA_RESET_TYPE_CONTROLLER 0x00
184 #define HPSA_RESET_TYPE_BUS 0x01
185 #define HPSA_RESET_TYPE_TARGET 0x03
186 #define HPSA_RESET_TYPE_LUN 0x04
187 #define HPSA_MSG_SEND_RETRY_LIMIT 10
188 #define HPSA_MSG_SEND_RETRY_INTERVAL_MSECS (10000)
190 /* Maximum time in seconds driver will wait for command completions
191 * when polling before giving up.
193 #define HPSA_MAX_POLL_TIME_SECS (20)
195 /* During SCSI error recovery, HPSA_TUR_RETRY_LIMIT defines
196 * how many times to retry TEST UNIT READY on a device
197 * while waiting for it to become ready before giving up.
198 * HPSA_MAX_WAIT_INTERVAL_SECS is the max wait interval
199 * between sending TURs while waiting for a device
202 #define HPSA_TUR_RETRY_LIMIT (20)
203 #define HPSA_MAX_WAIT_INTERVAL_SECS (30)
205 /* HPSA_BOARD_READY_WAIT_SECS is how long to wait for a board
206 * to become ready, in seconds, before giving up on it.
207 * HPSA_BOARD_READY_POLL_INTERVAL_MSECS * is how long to wait
208 * between polling the board to see if it is ready, in
209 * milliseconds. HPSA_BOARD_READY_POLL_INTERVAL and
210 * HPSA_BOARD_READY_ITERATIONS are derived from those.
212 #define HPSA_BOARD_READY_WAIT_SECS (120)
213 #define HPSA_BOARD_NOT_READY_WAIT_SECS (100)
214 #define HPSA_BOARD_READY_POLL_INTERVAL_MSECS (100)
215 #define HPSA_BOARD_READY_POLL_INTERVAL \
216 ((HPSA_BOARD_READY_POLL_INTERVAL_MSECS * HZ) / 1000)
217 #define HPSA_BOARD_READY_ITERATIONS \
218 ((HPSA_BOARD_READY_WAIT_SECS * 1000) / \
219 HPSA_BOARD_READY_POLL_INTERVAL_MSECS)
220 #define HPSA_BOARD_NOT_READY_ITERATIONS \
221 ((HPSA_BOARD_NOT_READY_WAIT_SECS * 1000) / \
222 HPSA_BOARD_READY_POLL_INTERVAL_MSECS)
223 #define HPSA_POST_RESET_PAUSE_MSECS (3000)
224 #define HPSA_POST_RESET_NOOP_RETRIES (12)
226 /* Defining the diffent access_menthods */
228 * Memory mapped FIFO interface (SMART 53xx cards)
230 #define SA5_DOORBELL 0x20
231 #define SA5_REQUEST_PORT_OFFSET 0x40
232 #define SA5_REPLY_INTR_MASK_OFFSET 0x34
233 #define SA5_REPLY_PORT_OFFSET 0x44
234 #define SA5_INTR_STATUS 0x30
235 #define SA5_SCRATCHPAD_OFFSET 0xB0
237 #define SA5_CTCFG_OFFSET 0xB4
238 #define SA5_CTMEM_OFFSET 0xB8
240 #define SA5_INTR_OFF 0x08
241 #define SA5B_INTR_OFF 0x04
242 #define SA5_INTR_PENDING 0x08
243 #define SA5B_INTR_PENDING 0x04
244 #define FIFO_EMPTY 0xffffffff
245 #define HPSA_FIRMWARE_READY 0xffff0000 /* value in scratchpad register */
247 #define HPSA_ERROR_BIT 0x02
249 /* Performant mode flags */
250 #define SA5_PERF_INTR_PENDING 0x04
251 #define SA5_PERF_INTR_OFF 0x05
252 #define SA5_OUTDB_STATUS_PERF_BIT 0x01
253 #define SA5_OUTDB_CLEAR_PERF_BIT 0x01
254 #define SA5_OUTDB_CLEAR 0xA0
255 #define SA5_OUTDB_CLEAR_PERF_BIT 0x01
256 #define SA5_OUTDB_STATUS 0x9C
259 #define HPSA_INTR_ON 1
260 #define HPSA_INTR_OFF 0
263 * Inbound Post Queue offsets for IO Accelerator Mode 2
265 #define IOACCEL2_INBOUND_POSTQ_32 0x48
266 #define IOACCEL2_INBOUND_POSTQ_64_LOW 0xd0
267 #define IOACCEL2_INBOUND_POSTQ_64_HI 0xd4
270 Send the command to the hardware
272 static void SA5_submit_command(struct ctlr_info *h,
273 struct CommandList *c)
275 dev_dbg(&h->pdev->dev, "Sending %x, tag = %x\n", c->busaddr,
276 c->Header.Tag.lower);
277 writel(c->busaddr, h->vaddr + SA5_REQUEST_PORT_OFFSET);
278 (void) readl(h->vaddr + SA5_SCRATCHPAD_OFFSET);
282 * This card is the opposite of the other cards.
283 * 0 turns interrupts on...
284 * 0x08 turns them off...
286 static void SA5_intr_mask(struct ctlr_info *h, unsigned long val)
288 if (val) { /* Turn interrupts on */
289 h->interrupts_enabled = 1;
290 writel(0, h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
291 (void) readl(h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
292 } else { /* Turn them off */
293 h->interrupts_enabled = 0;
295 h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
296 (void) readl(h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
300 static void SA5_performant_intr_mask(struct ctlr_info *h, unsigned long val)
302 if (val) { /* turn on interrupts */
303 h->interrupts_enabled = 1;
304 writel(0, h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
305 (void) readl(h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
307 h->interrupts_enabled = 0;
308 writel(SA5_PERF_INTR_OFF,
309 h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
310 (void) readl(h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
314 static unsigned long SA5_performant_completed(struct ctlr_info *h, u8 q)
316 struct reply_pool *rq = &h->reply_queue[q];
317 unsigned long flags, register_value = FIFO_EMPTY;
319 /* msi auto clears the interrupt pending bit. */
320 if (!(h->msi_vector || h->msix_vector)) {
321 /* flush the controller write of the reply queue by reading
322 * outbound doorbell status register.
324 register_value = readl(h->vaddr + SA5_OUTDB_STATUS);
325 writel(SA5_OUTDB_CLEAR_PERF_BIT, h->vaddr + SA5_OUTDB_CLEAR);
326 /* Do a read in order to flush the write to the controller
329 register_value = readl(h->vaddr + SA5_OUTDB_STATUS);
332 if ((rq->head[rq->current_entry] & 1) == rq->wraparound) {
333 register_value = rq->head[rq->current_entry];
335 spin_lock_irqsave(&h->lock, flags);
336 h->commands_outstanding--;
337 spin_unlock_irqrestore(&h->lock, flags);
339 register_value = FIFO_EMPTY;
341 /* Check for wraparound */
342 if (rq->current_entry == h->max_commands) {
343 rq->current_entry = 0;
346 return register_value;
350 * Returns true if fifo is full.
353 static unsigned long SA5_fifo_full(struct ctlr_info *h)
355 if (h->commands_outstanding >= h->max_commands)
362 * returns value read from hardware.
363 * returns FIFO_EMPTY if there is nothing to read
365 static unsigned long SA5_completed(struct ctlr_info *h,
366 __attribute__((unused)) u8 q)
368 unsigned long register_value
369 = readl(h->vaddr + SA5_REPLY_PORT_OFFSET);
372 if (register_value != FIFO_EMPTY) {
373 spin_lock_irqsave(&h->lock, flags);
374 h->commands_outstanding--;
375 spin_unlock_irqrestore(&h->lock, flags);
379 if (register_value != FIFO_EMPTY)
380 dev_dbg(&h->pdev->dev, "Read %lx back from board\n",
383 dev_dbg(&h->pdev->dev, "FIFO Empty read\n");
386 return register_value;
389 * Returns true if an interrupt is pending..
391 static bool SA5_intr_pending(struct ctlr_info *h)
393 unsigned long register_value =
394 readl(h->vaddr + SA5_INTR_STATUS);
395 dev_dbg(&h->pdev->dev, "intr_pending %lx\n", register_value);
396 return register_value & SA5_INTR_PENDING;
399 static bool SA5_performant_intr_pending(struct ctlr_info *h)
401 unsigned long register_value = readl(h->vaddr + SA5_INTR_STATUS);
406 if (h->msi_vector || h->msix_vector)
409 /* Read outbound doorbell to flush */
410 register_value = readl(h->vaddr + SA5_OUTDB_STATUS);
411 return register_value & SA5_OUTDB_STATUS_PERF_BIT;
414 #define SA5_IOACCEL_MODE1_INTR_STATUS_CMP_BIT 0x100
416 static bool SA5_ioaccel_mode1_intr_pending(struct ctlr_info *h)
418 unsigned long register_value = readl(h->vaddr + SA5_INTR_STATUS);
420 return (register_value & SA5_IOACCEL_MODE1_INTR_STATUS_CMP_BIT) ?
424 #define IOACCEL_MODE1_REPLY_QUEUE_INDEX 0x1A0
425 #define IOACCEL_MODE1_PRODUCER_INDEX 0x1B8
426 #define IOACCEL_MODE1_CONSUMER_INDEX 0x1BC
427 #define IOACCEL_MODE1_REPLY_UNUSED 0xFFFFFFFFFFFFFFFFULL
429 static unsigned long SA5_ioaccel_mode1_completed(struct ctlr_info *h, u8 q)
432 struct reply_pool *rq = &h->reply_queue[q];
435 BUG_ON(q >= h->nreply_queues);
437 register_value = rq->head[rq->current_entry];
438 if (register_value != IOACCEL_MODE1_REPLY_UNUSED) {
439 rq->head[rq->current_entry] = IOACCEL_MODE1_REPLY_UNUSED;
440 if (++rq->current_entry == rq->size)
441 rq->current_entry = 0;
445 * Don't really need to write the new index after each command,
446 * but with current driver design this is easiest.
449 writel((q << 24) | rq->current_entry, h->vaddr +
450 IOACCEL_MODE1_CONSUMER_INDEX);
451 spin_lock_irqsave(&h->lock, flags);
452 h->commands_outstanding--;
453 spin_unlock_irqrestore(&h->lock, flags);
455 return (unsigned long) register_value;
458 static struct access_method SA5_access = {
466 static struct access_method SA5_ioaccel_mode1_access = {
468 SA5_performant_intr_mask,
470 SA5_ioaccel_mode1_intr_pending,
471 SA5_ioaccel_mode1_completed,
474 static struct access_method SA5_performant_access = {
476 SA5_performant_intr_mask,
478 SA5_performant_intr_pending,
479 SA5_performant_completed,
485 struct access_method *access;