?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / scsi / myrb.c
blobd4bd31a75b9dbf8accf12d05c1c6349f9c823163
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Linux Driver for Mylex DAC960/AcceleRAID/eXtremeRAID PCI RAID Controllers
4 *
5 * Copyright 2017 Hannes Reinecke, SUSE Linux GmbH <hare@suse.com>
6 *
7 * Based on the original DAC960 driver,
8 * Copyright 1998-2001 by Leonard N. Zubkoff <lnz@dandelion.com>
9 * Portions Copyright 2002 by Mylex (An IBM Business Unit)
10 *
11 */
12
13 #include <linux/module.h>
14 #include <linux/types.h>
15 #include <linux/delay.h>
16 #include <linux/interrupt.h>
17 #include <linux/pci.h>
18 #include <linux/raid_class.h>
19 #include <asm/unaligned.h>
20 #include <scsi/scsi.h>
21 #include <scsi/scsi_host.h>
22 #include <scsi/scsi_device.h>
23 #include <scsi/scsi_cmnd.h>
24 #include <scsi/scsi_tcq.h>
25 #include "myrb.h"
26
27 static struct raid_template *myrb_raid_template;
28
29 static void myrb_monitor(struct work_struct *work);
30 static inline void myrb_translate_devstate(void *DeviceState);
31
32 static inline int myrb_logical_channel(struct Scsi_Host *shost)
33 {
34 return shost->max_channel - 1;
35 }
36
37 static struct myrb_devstate_name_entry {
38 enum myrb_devstate state;
39 const char *name;
40 } myrb_devstate_name_list[] = {
41 { MYRB_DEVICE_DEAD, "Dead" },
42 { MYRB_DEVICE_WO, "WriteOnly" },
43 { MYRB_DEVICE_ONLINE, "Online" },
44 { MYRB_DEVICE_CRITICAL, "Critical" },
45 { MYRB_DEVICE_STANDBY, "Standby" },
46 { MYRB_DEVICE_OFFLINE, "Offline" },
47 };
48
49 static const char *myrb_devstate_name(enum myrb_devstate state)
50 {
51 struct myrb_devstate_name_entry *entry = myrb_devstate_name_list;
52 int i;
53
54 for (i = 0; i < ARRAY_SIZE(myrb_devstate_name_list); i++) {
55 if (entry[i].state == state)
56 return entry[i].name;
57 }
58 return "Unknown";
59 }
60
61 static struct myrb_raidlevel_name_entry {
62 enum myrb_raidlevel level;
63 const char *name;
64 } myrb_raidlevel_name_list[] = {
65 { MYRB_RAID_LEVEL0, "RAID0" },
66 { MYRB_RAID_LEVEL1, "RAID1" },
67 { MYRB_RAID_LEVEL3, "RAID3" },
68 { MYRB_RAID_LEVEL5, "RAID5" },
69 { MYRB_RAID_LEVEL6, "RAID6" },
70 { MYRB_RAID_JBOD, "JBOD" },
71 };
72
73 static const char *myrb_raidlevel_name(enum myrb_raidlevel level)
74 {
75 struct myrb_raidlevel_name_entry *entry = myrb_raidlevel_name_list;
76 int i;
77
78 for (i = 0; i < ARRAY_SIZE(myrb_raidlevel_name_list); i++) {
79 if (entry[i].level == level)
80 return entry[i].name;
81 }
82 return NULL;
83 }
84
85 /**
86 * myrb_create_mempools - allocates auxiliary data structures
87 *
88 * Return: true on success, false otherwise.
89 */
90 static bool myrb_create_mempools(struct pci_dev *pdev, struct myrb_hba *cb)
91 {
92 size_t elem_size, elem_align;
93
94 elem_align = sizeof(struct myrb_sge);
95 elem_size = cb->host->sg_tablesize * elem_align;
96 cb->sg_pool = dma_pool_create("myrb_sg", &pdev->dev,
97 elem_size, elem_align, 0);
98 if (cb->sg_pool == NULL) {
99 shost_printk(KERN_ERR, cb->host,
100 "Failed to allocate SG pool\n");
101 return false;
102 }
103
104 cb->dcdb_pool = dma_pool_create("myrb_dcdb", &pdev->dev,
105 sizeof(struct myrb_dcdb),
106 sizeof(unsigned int), 0);
107 if (!cb->dcdb_pool) {
108 dma_pool_destroy(cb->sg_pool);
109 cb->sg_pool = NULL;
110 shost_printk(KERN_ERR, cb->host,
111 "Failed to allocate DCDB pool\n");
112 return false;
113 }
114
115 snprintf(cb->work_q_name, sizeof(cb->work_q_name),
116 "myrb_wq_%d", cb->host->host_no);
117 cb->work_q = create_singlethread_workqueue(cb->work_q_name);
118 if (!cb->work_q) {
119 dma_pool_destroy(cb->dcdb_pool);
120 cb->dcdb_pool = NULL;
121 dma_pool_destroy(cb->sg_pool);
122 cb->sg_pool = NULL;
123 shost_printk(KERN_ERR, cb->host,
124 "Failed to create workqueue\n");
125 return false;
126 }
127
128 /*
129 * Initialize the Monitoring Timer.
130 */
131 INIT_DELAYED_WORK(&cb->monitor_work, myrb_monitor);
132 queue_delayed_work(cb->work_q, &cb->monitor_work, 1);
133
134 return true;
135 }
136
137 /**
138 * myrb_destroy_mempools - tears down the memory pools for the controller
139 */
140 static void myrb_destroy_mempools(struct myrb_hba *cb)
141 {
142 cancel_delayed_work_sync(&cb->monitor_work);
143 destroy_workqueue(cb->work_q);
144
145 dma_pool_destroy(cb->sg_pool);
146 dma_pool_destroy(cb->dcdb_pool);
147 }
148
149 /**
150 * myrb_reset_cmd - reset command block
151 */
152 static inline void myrb_reset_cmd(struct myrb_cmdblk *cmd_blk)
153 {
154 union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
155
156 memset(mbox, 0, sizeof(union myrb_cmd_mbox));
157 cmd_blk->status = 0;
158 }
159
160 /**
161 * myrb_qcmd - queues command block for execution
162 */
163 static void myrb_qcmd(struct myrb_hba *cb, struct myrb_cmdblk *cmd_blk)
164 {
165 void __iomem *base = cb->io_base;
166 union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
167 union myrb_cmd_mbox *next_mbox = cb->next_cmd_mbox;
168
169 cb->write_cmd_mbox(next_mbox, mbox);
170 if (cb->prev_cmd_mbox1->words[0] == 0 ||
171 cb->prev_cmd_mbox2->words[0] == 0)
172 cb->get_cmd_mbox(base);
173 cb->prev_cmd_mbox2 = cb->prev_cmd_mbox1;
174 cb->prev_cmd_mbox1 = next_mbox;
175 if (++next_mbox > cb->last_cmd_mbox)
176 next_mbox = cb->first_cmd_mbox;
177 cb->next_cmd_mbox = next_mbox;
178 }
179
180 /**
181 * myrb_exec_cmd - executes command block and waits for completion.
182 *
183 * Return: command status
184 */
185 static unsigned short myrb_exec_cmd(struct myrb_hba *cb,
186 struct myrb_cmdblk *cmd_blk)
187 {
188 DECLARE_COMPLETION_ONSTACK(cmpl);
189 unsigned long flags;
190
191 cmd_blk->completion = &cmpl;
192
193 spin_lock_irqsave(&cb->queue_lock, flags);
194 cb->qcmd(cb, cmd_blk);
195 spin_unlock_irqrestore(&cb->queue_lock, flags);
196
197 WARN_ON(in_interrupt());
198 wait_for_completion(&cmpl);
199 return cmd_blk->status;
200 }
201
202 /**
203 * myrb_exec_type3 - executes a type 3 command and waits for completion.
204 *
205 * Return: command status
206 */
207 static unsigned short myrb_exec_type3(struct myrb_hba *cb,
208 enum myrb_cmd_opcode op, dma_addr_t addr)
209 {
210 struct myrb_cmdblk *cmd_blk = &cb->dcmd_blk;
211 union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
212 unsigned short status;
213
214 mutex_lock(&cb->dcmd_mutex);
215 myrb_reset_cmd(cmd_blk);
216 mbox->type3.id = MYRB_DCMD_TAG;
217 mbox->type3.opcode = op;
218 mbox->type3.addr = addr;
219 status = myrb_exec_cmd(cb, cmd_blk);
220 mutex_unlock(&cb->dcmd_mutex);
221 return status;
222 }
223
224 /**
225 * myrb_exec_type3D - executes a type 3D command and waits for completion.
226 *
227 * Return: command status
228 */
229 static unsigned short myrb_exec_type3D(struct myrb_hba *cb,
230 enum myrb_cmd_opcode op, struct scsi_device *sdev,
231 struct myrb_pdev_state *pdev_info)
232 {
233 struct myrb_cmdblk *cmd_blk = &cb->dcmd_blk;
234 union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
235 unsigned short status;
236 dma_addr_t pdev_info_addr;
237
238 pdev_info_addr = dma_map_single(&cb->pdev->dev, pdev_info,
239 sizeof(struct myrb_pdev_state),
240 DMA_FROM_DEVICE);
241 if (dma_mapping_error(&cb->pdev->dev, pdev_info_addr))
242 return MYRB_STATUS_SUBSYS_FAILED;
243
244 mutex_lock(&cb->dcmd_mutex);
245 myrb_reset_cmd(cmd_blk);
246 mbox->type3D.id = MYRB_DCMD_TAG;
247 mbox->type3D.opcode = op;
248 mbox->type3D.channel = sdev->channel;
249 mbox->type3D.target = sdev->id;
250 mbox->type3D.addr = pdev_info_addr;
251 status = myrb_exec_cmd(cb, cmd_blk);
252 mutex_unlock(&cb->dcmd_mutex);
253 dma_unmap_single(&cb->pdev->dev, pdev_info_addr,
254 sizeof(struct myrb_pdev_state), DMA_FROM_DEVICE);
255 if (status == MYRB_STATUS_SUCCESS &&
256 mbox->type3D.opcode == MYRB_CMD_GET_DEVICE_STATE_OLD)
257 myrb_translate_devstate(pdev_info);
258
259 return status;
260 }
261
262 static char *myrb_event_msg[] = {
263 "killed because write recovery failed",
264 "killed because of SCSI bus reset failure",
265 "killed because of double check condition",
266 "killed because it was removed",
267 "killed because of gross error on SCSI chip",
268 "killed because of bad tag returned from drive",
269 "killed because of timeout on SCSI command",
270 "killed because of reset SCSI command issued from system",
271 "killed because busy or parity error count exceeded limit",
272 "killed because of 'kill drive' command from system",
273 "killed because of selection timeout",
274 "killed due to SCSI phase sequence error",
275 "killed due to unknown status",
276 };
277
278 /**
279 * myrb_get_event - get event log from HBA
280 * @cb: pointer to the hba structure
281 * @event: number of the event
282 *
283 * Execute a type 3E command and logs the event message
284 */
285 static void myrb_get_event(struct myrb_hba *cb, unsigned int event)
286 {
287 struct myrb_cmdblk *cmd_blk = &cb->mcmd_blk;
288 union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
289 struct myrb_log_entry *ev_buf;
290 dma_addr_t ev_addr;
291 unsigned short status;
292
293 ev_buf = dma_alloc_coherent(&cb->pdev->dev,
294 sizeof(struct myrb_log_entry),
295 &ev_addr, GFP_KERNEL);
296 if (!ev_buf)
297 return;
298
299 myrb_reset_cmd(cmd_blk);
300 mbox->type3E.id = MYRB_MCMD_TAG;
301 mbox->type3E.opcode = MYRB_CMD_EVENT_LOG_OPERATION;
302 mbox->type3E.optype = DAC960_V1_GetEventLogEntry;
303 mbox->type3E.opqual = 1;
304 mbox->type3E.ev_seq = event;
305 mbox->type3E.addr = ev_addr;
306 status = myrb_exec_cmd(cb, cmd_blk);
307 if (status != MYRB_STATUS_SUCCESS)
308 shost_printk(KERN_INFO, cb->host,
309 "Failed to get event log %d, status %04x\n",
310 event, status);
311
312 else if (ev_buf->seq_num == event) {
313 struct scsi_sense_hdr sshdr;
314
315 memset(&sshdr, 0, sizeof(sshdr));
316 scsi_normalize_sense(ev_buf->sense, 32, &sshdr);
317
318 if (sshdr.sense_key == VENDOR_SPECIFIC &&
319 sshdr.asc == 0x80 &&
320 sshdr.ascq < ARRAY_SIZE(myrb_event_msg))
321 shost_printk(KERN_CRIT, cb->host,
322 "Physical drive %d:%d: %s\n",
323 ev_buf->channel, ev_buf->target,
324 myrb_event_msg[sshdr.ascq]);
325 else
326 shost_printk(KERN_CRIT, cb->host,
327 "Physical drive %d:%d: Sense: %X/%02X/%02X\n",
328 ev_buf->channel, ev_buf->target,
329 sshdr.sense_key, sshdr.asc, sshdr.ascq);
330 }
331
332 dma_free_coherent(&cb->pdev->dev, sizeof(struct myrb_log_entry),
333 ev_buf, ev_addr);
334 }
335
336 /**
337 * myrb_get_errtable - retrieves the error table from the controller
338 *
339 * Executes a type 3 command and logs the error table from the controller.
340 */
341 static void myrb_get_errtable(struct myrb_hba *cb)
342 {
343 struct myrb_cmdblk *cmd_blk = &cb->mcmd_blk;
344 union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
345 unsigned short status;
346 struct myrb_error_entry old_table[MYRB_MAX_CHANNELS * MYRB_MAX_TARGETS];
347
348 memcpy(&old_table, cb->err_table, sizeof(old_table));
349
350 myrb_reset_cmd(cmd_blk);
351 mbox->type3.id = MYRB_MCMD_TAG;
352 mbox->type3.opcode = MYRB_CMD_GET_ERROR_TABLE;
353 mbox->type3.addr = cb->err_table_addr;
354 status = myrb_exec_cmd(cb, cmd_blk);
355 if (status == MYRB_STATUS_SUCCESS) {
356 struct myrb_error_entry *table = cb->err_table;
357 struct myrb_error_entry *new, *old;
358 size_t err_table_offset;
359 struct scsi_device *sdev;
360
361 shost_for_each_device(sdev, cb->host) {
362 if (sdev->channel >= myrb_logical_channel(cb->host))
363 continue;
364 err_table_offset = sdev->channel * MYRB_MAX_TARGETS
365 + sdev->id;
366 new = table + err_table_offset;
367 old = &old_table[err_table_offset];
368 if (new->parity_err == old->parity_err &&
369 new->soft_err == old->soft_err &&
370 new->hard_err == old->hard_err &&
371 new->misc_err == old->misc_err)
372 continue;
373 sdev_printk(KERN_CRIT, sdev,
374 "Errors: Parity = %d, Soft = %d, Hard = %d, Misc = %d\n",
375 new->parity_err, new->soft_err,
376 new->hard_err, new->misc_err);
377 }
378 }
379 }
380
381 /**
382 * myrb_get_ldev_info - retrieves the logical device table from the controller
383 *
384 * Executes a type 3 command and updates the logical device table.
385 *
386 * Return: command status
387 */
388 static unsigned short myrb_get_ldev_info(struct myrb_hba *cb)
389 {
390 unsigned short status;
391 int ldev_num, ldev_cnt = cb->enquiry->ldev_count;
392 struct Scsi_Host *shost = cb->host;
393
394 status = myrb_exec_type3(cb, MYRB_CMD_GET_LDEV_INFO,
395 cb->ldev_info_addr);
396 if (status != MYRB_STATUS_SUCCESS)
397 return status;
398
399 for (ldev_num = 0; ldev_num < ldev_cnt; ldev_num++) {
400 struct myrb_ldev_info *old = NULL;
401 struct myrb_ldev_info *new = cb->ldev_info_buf + ldev_num;
402 struct scsi_device *sdev;
403
404 sdev = scsi_device_lookup(shost, myrb_logical_channel(shost),
405 ldev_num, 0);
406 if (!sdev) {
407 if (new->state == MYRB_DEVICE_OFFLINE)
408 continue;
409 shost_printk(KERN_INFO, shost,
410 "Adding Logical Drive %d in state %s\n",
411 ldev_num, myrb_devstate_name(new->state));
412 scsi_add_device(shost, myrb_logical_channel(shost),
413 ldev_num, 0);
414 continue;
415 }
416 old = sdev->hostdata;
417 if (new->state != old->state)
418 shost_printk(KERN_INFO, shost,
419 "Logical Drive %d is now %s\n",
420 ldev_num, myrb_devstate_name(new->state));
421 if (new->wb_enabled != old->wb_enabled)
422 sdev_printk(KERN_INFO, sdev,
423 "Logical Drive is now WRITE %s\n",
424 (new->wb_enabled ? "BACK" : "THRU"));
425 memcpy(old, new, sizeof(*new));
426 scsi_device_put(sdev);
427 }
428 return status;
429 }
430
431 /**
432 * myrb_get_rbld_progress - get rebuild progress information
433 *
434 * Executes a type 3 command and returns the rebuild progress
435 * information.
436 *
437 * Return: command status
438 */
439 static unsigned short myrb_get_rbld_progress(struct myrb_hba *cb,
440 struct myrb_rbld_progress *rbld)
441 {
442 struct myrb_cmdblk *cmd_blk = &cb->mcmd_blk;
443 union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
444 struct myrb_rbld_progress *rbld_buf;
445 dma_addr_t rbld_addr;
446 unsigned short status;
447
448 rbld_buf = dma_alloc_coherent(&cb->pdev->dev,
449 sizeof(struct myrb_rbld_progress),
450 &rbld_addr, GFP_KERNEL);
451 if (!rbld_buf)
452 return MYRB_STATUS_RBLD_NOT_CHECKED;
453
454 myrb_reset_cmd(cmd_blk);
455 mbox->type3.id = MYRB_MCMD_TAG;
456 mbox->type3.opcode = MYRB_CMD_GET_REBUILD_PROGRESS;
457 mbox->type3.addr = rbld_addr;
458 status = myrb_exec_cmd(cb, cmd_blk);
459 if (rbld)
460 memcpy(rbld, rbld_buf, sizeof(struct myrb_rbld_progress));
461 dma_free_coherent(&cb->pdev->dev, sizeof(struct myrb_rbld_progress),
462 rbld_buf, rbld_addr);
463 return status;
464 }
465
466 /**
467 * myrb_update_rbld_progress - updates the rebuild status
468 *
469 * Updates the rebuild status for the attached logical devices.
470 *
471 */
472 static void myrb_update_rbld_progress(struct myrb_hba *cb)
473 {
474 struct myrb_rbld_progress rbld_buf;
475 unsigned short status;
476
477 status = myrb_get_rbld_progress(cb, &rbld_buf);
478 if (status == MYRB_NO_STDBY_RBLD_OR_CHECK_IN_PROGRESS &&
479 cb->last_rbld_status == MYRB_STATUS_SUCCESS)
480 status = MYRB_STATUS_RBLD_SUCCESS;
481 if (status != MYRB_NO_STDBY_RBLD_OR_CHECK_IN_PROGRESS) {
482 unsigned int blocks_done =
483 rbld_buf.ldev_size - rbld_buf.blocks_left;
484 struct scsi_device *sdev;
485
486 sdev = scsi_device_lookup(cb->host,
487 myrb_logical_channel(cb->host),
488 rbld_buf.ldev_num, 0);
489 if (!sdev)
490 return;
491
492 switch (status) {
493 case MYRB_STATUS_SUCCESS:
494 sdev_printk(KERN_INFO, sdev,
495 "Rebuild in Progress, %d%% completed\n",
496 (100 * (blocks_done >> 7))
497 / (rbld_buf.ldev_size >> 7));
498 break;
499 case MYRB_STATUS_RBLD_FAILED_LDEV_FAILURE:
500 sdev_printk(KERN_INFO, sdev,
501 "Rebuild Failed due to Logical Drive Failure\n");
502 break;
503 case MYRB_STATUS_RBLD_FAILED_BADBLOCKS:
504 sdev_printk(KERN_INFO, sdev,
505 "Rebuild Failed due to Bad Blocks on Other Drives\n");
506 break;
507 case MYRB_STATUS_RBLD_FAILED_NEW_DRIVE_FAILED:
508 sdev_printk(KERN_INFO, sdev,
509 "Rebuild Failed due to Failure of Drive Being Rebuilt\n");
510 break;
511 case MYRB_STATUS_RBLD_SUCCESS:
512 sdev_printk(KERN_INFO, sdev,
513 "Rebuild Completed Successfully\n");
514 break;
515 case MYRB_STATUS_RBLD_SUCCESS_TERMINATED:
516 sdev_printk(KERN_INFO, sdev,
517 "Rebuild Successfully Terminated\n");
518 break;
519 default:
520 break;
521 }
522 scsi_device_put(sdev);
523 }
524 cb->last_rbld_status = status;
525 }
526
527 /**
528 * myrb_get_cc_progress - retrieve the rebuild status
529 *
530 * Execute a type 3 Command and fetch the rebuild / consistency check
531 * status.
532 */
533 static void myrb_get_cc_progress(struct myrb_hba *cb)
534 {
535 struct myrb_cmdblk *cmd_blk = &cb->mcmd_blk;
536 union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
537 struct myrb_rbld_progress *rbld_buf;
538 dma_addr_t rbld_addr;
539 unsigned short status;
540
541 rbld_buf = dma_alloc_coherent(&cb->pdev->dev,
542 sizeof(struct myrb_rbld_progress),
543 &rbld_addr, GFP_KERNEL);
544 if (!rbld_buf) {
545 cb->need_cc_status = true;
546 return;
547 }
548 myrb_reset_cmd(cmd_blk);
549 mbox->type3.id = MYRB_MCMD_TAG;
550 mbox->type3.opcode = MYRB_CMD_REBUILD_STAT;
551 mbox->type3.addr = rbld_addr;
552 status = myrb_exec_cmd(cb, cmd_blk);
553 if (status == MYRB_STATUS_SUCCESS) {
554 unsigned int ldev_num = rbld_buf->ldev_num;
555 unsigned int ldev_size = rbld_buf->ldev_size;
556 unsigned int blocks_done =
557 ldev_size - rbld_buf->blocks_left;
558 struct scsi_device *sdev;
559
560 sdev = scsi_device_lookup(cb->host,
561 myrb_logical_channel(cb->host),
562 ldev_num, 0);
563 if (sdev) {
564 sdev_printk(KERN_INFO, sdev,
565 "Consistency Check in Progress: %d%% completed\n",
566 (100 * (blocks_done >> 7))
567 / (ldev_size >> 7));
568 scsi_device_put(sdev);
569 }
570 }
571 dma_free_coherent(&cb->pdev->dev, sizeof(struct myrb_rbld_progress),
572 rbld_buf, rbld_addr);
573 }
574
575 /**
576 * myrb_bgi_control - updates background initialisation status
577 *
578 * Executes a type 3B command and updates the background initialisation status
579 */
580 static void myrb_bgi_control(struct myrb_hba *cb)
581 {
582 struct myrb_cmdblk *cmd_blk = &cb->mcmd_blk;
583 union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
584 struct myrb_bgi_status *bgi, *last_bgi;
585 dma_addr_t bgi_addr;
586 struct scsi_device *sdev = NULL;
587 unsigned short status;
588
589 bgi = dma_alloc_coherent(&cb->pdev->dev, sizeof(struct myrb_bgi_status),
590 &bgi_addr, GFP_KERNEL);
591 if (!bgi) {
592 shost_printk(KERN_ERR, cb->host,
593 "Failed to allocate bgi memory\n");
594 return;
595 }
596 myrb_reset_cmd(cmd_blk);
597 mbox->type3B.id = MYRB_DCMD_TAG;
598 mbox->type3B.opcode = MYRB_CMD_BGI_CONTROL;
599 mbox->type3B.optype = 0x20;
600 mbox->type3B.addr = bgi_addr;
601 status = myrb_exec_cmd(cb, cmd_blk);
602 last_bgi = &cb->bgi_status;
603 sdev = scsi_device_lookup(cb->host,
604 myrb_logical_channel(cb->host),
605 bgi->ldev_num, 0);
606 switch (status) {
607 case MYRB_STATUS_SUCCESS:
608 switch (bgi->status) {
609 case MYRB_BGI_INVALID:
610 break;
611 case MYRB_BGI_STARTED:
612 if (!sdev)
613 break;
614 sdev_printk(KERN_INFO, sdev,
615 "Background Initialization Started\n");
616 break;
617 case MYRB_BGI_INPROGRESS:
618 if (!sdev)
619 break;
620 if (bgi->blocks_done == last_bgi->blocks_done &&
621 bgi->ldev_num == last_bgi->ldev_num)
622 break;
623 sdev_printk(KERN_INFO, sdev,
624 "Background Initialization in Progress: %d%% completed\n",
625 (100 * (bgi->blocks_done >> 7))
626 / (bgi->ldev_size >> 7));
627 break;
628 case MYRB_BGI_SUSPENDED:
629 if (!sdev)
630 break;
631 sdev_printk(KERN_INFO, sdev,
632 "Background Initialization Suspended\n");
633 break;
634 case MYRB_BGI_CANCELLED:
635 if (!sdev)
636 break;
637 sdev_printk(KERN_INFO, sdev,
638 "Background Initialization Cancelled\n");
639 break;
640 }
641 memcpy(&cb->bgi_status, bgi, sizeof(struct myrb_bgi_status));
642 break;
643 case MYRB_STATUS_BGI_SUCCESS:
644 if (sdev && cb->bgi_status.status == MYRB_BGI_INPROGRESS)
645 sdev_printk(KERN_INFO, sdev,
646 "Background Initialization Completed Successfully\n");
647 cb->bgi_status.status = MYRB_BGI_INVALID;
648 break;
649 case MYRB_STATUS_BGI_ABORTED:
650 if (sdev && cb->bgi_status.status == MYRB_BGI_INPROGRESS)
651 sdev_printk(KERN_INFO, sdev,
652 "Background Initialization Aborted\n");
653 /* Fallthrough */
654 case MYRB_STATUS_NO_BGI_INPROGRESS:
655 cb->bgi_status.status = MYRB_BGI_INVALID;
656 break;
657 }
658 if (sdev)
659 scsi_device_put(sdev);
660 dma_free_coherent(&cb->pdev->dev, sizeof(struct myrb_bgi_status),
661 bgi, bgi_addr);
662 }
663
664 /**
665 * myrb_hba_enquiry - updates the controller status
666 *
667 * Executes a DAC_V1_Enquiry command and updates the controller status.
668 *
669 * Return: command status
670 */
671 static unsigned short myrb_hba_enquiry(struct myrb_hba *cb)
672 {
673 struct myrb_enquiry old, *new;
674 unsigned short status;
675
676 memcpy(&old, cb->enquiry, sizeof(struct myrb_enquiry));
677
678 status = myrb_exec_type3(cb, MYRB_CMD_ENQUIRY, cb->enquiry_addr);
679 if (status != MYRB_STATUS_SUCCESS)
680 return status;
681
682 new = cb->enquiry;
683 if (new->ldev_count > old.ldev_count) {
684 int ldev_num = old.ldev_count - 1;
685
686 while (++ldev_num < new->ldev_count)
687 shost_printk(KERN_CRIT, cb->host,
688 "Logical Drive %d Now Exists\n",
689 ldev_num);
690 }
691 if (new->ldev_count < old.ldev_count) {
692 int ldev_num = new->ldev_count - 1;
693
694 while (++ldev_num < old.ldev_count)
695 shost_printk(KERN_CRIT, cb->host,
696 "Logical Drive %d No Longer Exists\n",
697 ldev_num);
698 }
699 if (new->status.deferred != old.status.deferred)
700 shost_printk(KERN_CRIT, cb->host,
701 "Deferred Write Error Flag is now %s\n",
702 (new->status.deferred ? "TRUE" : "FALSE"));
703 if (new->ev_seq != old.ev_seq) {
704 cb->new_ev_seq = new->ev_seq;
705 cb->need_err_info = true;
706 shost_printk(KERN_INFO, cb->host,
707 "Event log %d/%d (%d/%d) available\n",
708 cb->old_ev_seq, cb->new_ev_seq,
709 old.ev_seq, new->ev_seq);
710 }
711 if ((new->ldev_critical > 0 &&
712 new->ldev_critical != old.ldev_critical) ||
713 (new->ldev_offline > 0 &&
714 new->ldev_offline != old.ldev_offline) ||
715 (new->ldev_count != old.ldev_count)) {
716 shost_printk(KERN_INFO, cb->host,
717 "Logical drive count changed (%d/%d/%d)\n",
718 new->ldev_critical,
719 new->ldev_offline,
720 new->ldev_count);
721 cb->need_ldev_info = true;
722 }
723 if (new->pdev_dead > 0 ||
724 new->pdev_dead != old.pdev_dead ||
725 time_after_eq(jiffies, cb->secondary_monitor_time
726 + MYRB_SECONDARY_MONITOR_INTERVAL)) {
727 cb->need_bgi_status = cb->bgi_status_supported;
728 cb->secondary_monitor_time = jiffies;
729 }
730 if (new->rbld == MYRB_STDBY_RBLD_IN_PROGRESS ||
731 new->rbld == MYRB_BG_RBLD_IN_PROGRESS ||
732 old.rbld == MYRB_STDBY_RBLD_IN_PROGRESS ||
733 old.rbld == MYRB_BG_RBLD_IN_PROGRESS) {
734 cb->need_rbld = true;
735 cb->rbld_first = (new->ldev_critical < old.ldev_critical);
736 }
737 if (old.rbld == MYRB_BG_CHECK_IN_PROGRESS)
738 switch (new->rbld) {
739 case MYRB_NO_STDBY_RBLD_OR_CHECK_IN_PROGRESS:
740 shost_printk(KERN_INFO, cb->host,
741 "Consistency Check Completed Successfully\n");
742 break;
743 case MYRB_STDBY_RBLD_IN_PROGRESS:
744 case MYRB_BG_RBLD_IN_PROGRESS:
745 break;
746 case MYRB_BG_CHECK_IN_PROGRESS:
747 cb->need_cc_status = true;
748 break;
749 case MYRB_STDBY_RBLD_COMPLETED_WITH_ERROR:
750 shost_printk(KERN_INFO, cb->host,
751 "Consistency Check Completed with Error\n");
752 break;
753 case MYRB_BG_RBLD_OR_CHECK_FAILED_DRIVE_FAILED:
754 shost_printk(KERN_INFO, cb->host,
755 "Consistency Check Failed - Physical Device Failed\n");
756 break;
757 case MYRB_BG_RBLD_OR_CHECK_FAILED_LDEV_FAILED:
758 shost_printk(KERN_INFO, cb->host,
759 "Consistency Check Failed - Logical Drive Failed\n");
760 break;
761 case MYRB_BG_RBLD_OR_CHECK_FAILED_OTHER:
762 shost_printk(KERN_INFO, cb->host,
763 "Consistency Check Failed - Other Causes\n");
764 break;
765 case MYRB_BG_RBLD_OR_CHECK_SUCCESS_TERMINATED:
766 shost_printk(KERN_INFO, cb->host,
767 "Consistency Check Successfully Terminated\n");
768 break;
769 }
770 else if (new->rbld == MYRB_BG_CHECK_IN_PROGRESS)
771 cb->need_cc_status = true;
772
773 return MYRB_STATUS_SUCCESS;
774 }
775
776 /**
777 * myrb_set_pdev_state - sets the device state for a physical device
778 *
779 * Return: command status
780 */
781 static unsigned short myrb_set_pdev_state(struct myrb_hba *cb,
782 struct scsi_device *sdev, enum myrb_devstate state)
783 {
784 struct myrb_cmdblk *cmd_blk = &cb->dcmd_blk;
785 union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
786 unsigned short status;
787
788 mutex_lock(&cb->dcmd_mutex);
789 mbox->type3D.opcode = MYRB_CMD_START_DEVICE;
790 mbox->type3D.id = MYRB_DCMD_TAG;
791 mbox->type3D.channel = sdev->channel;
792 mbox->type3D.target = sdev->id;
793 mbox->type3D.state = state & 0x1F;
794 status = myrb_exec_cmd(cb, cmd_blk);
795 mutex_unlock(&cb->dcmd_mutex);
796
797 return status;
798 }
799
800 /**
801 * myrb_enable_mmio - enables the Memory Mailbox Interface
802 *
803 * PD and P controller types have no memory mailbox, but still need the
804 * other dma mapped memory.
805 *
806 * Return: true on success, false otherwise.
807 */
808 static bool myrb_enable_mmio(struct myrb_hba *cb, mbox_mmio_init_t mmio_init_fn)
809 {
810 void __iomem *base = cb->io_base;
811 struct pci_dev *pdev = cb->pdev;
812 size_t err_table_size;
813 size_t ldev_info_size;
814 union myrb_cmd_mbox *cmd_mbox_mem;
815 struct myrb_stat_mbox *stat_mbox_mem;
816 union myrb_cmd_mbox mbox;
817 unsigned short status;
818
819 memset(&mbox, 0, sizeof(union myrb_cmd_mbox));
820
821 if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) {
822 dev_err(&pdev->dev, "DMA mask out of range\n");
823 return false;
824 }
825
826 cb->enquiry = dma_alloc_coherent(&pdev->dev,
827 sizeof(struct myrb_enquiry),
828 &cb->enquiry_addr, GFP_KERNEL);
829 if (!cb->enquiry)
830 return false;
831
832 err_table_size = sizeof(struct myrb_error_entry) *
833 MYRB_MAX_CHANNELS * MYRB_MAX_TARGETS;
834 cb->err_table = dma_alloc_coherent(&pdev->dev, err_table_size,
835 &cb->err_table_addr, GFP_KERNEL);
836 if (!cb->err_table)
837 return false;
838
839 ldev_info_size = sizeof(struct myrb_ldev_info) * MYRB_MAX_LDEVS;
840 cb->ldev_info_buf = dma_alloc_coherent(&pdev->dev, ldev_info_size,
841 &cb->ldev_info_addr, GFP_KERNEL);
842 if (!cb->ldev_info_buf)
843 return false;
844
845 /*
846 * Skip mailbox initialisation for PD and P Controllers
847 */
848 if (!mmio_init_fn)
849 return true;
850
851 /* These are the base addresses for the command memory mailbox array */
852 cb->cmd_mbox_size = MYRB_CMD_MBOX_COUNT * sizeof(union myrb_cmd_mbox);
853 cb->first_cmd_mbox = dma_alloc_coherent(&pdev->dev,
854 cb->cmd_mbox_size,
855 &cb->cmd_mbox_addr,
856 GFP_KERNEL);
857 if (!cb->first_cmd_mbox)
858 return false;
859
860 cmd_mbox_mem = cb->first_cmd_mbox;
861 cmd_mbox_mem += MYRB_CMD_MBOX_COUNT - 1;
862 cb->last_cmd_mbox = cmd_mbox_mem;
863 cb->next_cmd_mbox = cb->first_cmd_mbox;
864 cb->prev_cmd_mbox1 = cb->last_cmd_mbox;
865 cb->prev_cmd_mbox2 = cb->last_cmd_mbox - 1;
866
867 /* These are the base addresses for the status memory mailbox array */
868 cb->stat_mbox_size = MYRB_STAT_MBOX_COUNT *
869 sizeof(struct myrb_stat_mbox);
870 cb->first_stat_mbox = dma_alloc_coherent(&pdev->dev,
871 cb->stat_mbox_size,
872 &cb->stat_mbox_addr,
873 GFP_KERNEL);
874 if (!cb->first_stat_mbox)
875 return false;
876
877 stat_mbox_mem = cb->first_stat_mbox;
878 stat_mbox_mem += MYRB_STAT_MBOX_COUNT - 1;
879 cb->last_stat_mbox = stat_mbox_mem;
880 cb->next_stat_mbox = cb->first_stat_mbox;
881
882 /* Enable the Memory Mailbox Interface. */
883 cb->dual_mode_interface = true;
884 mbox.typeX.opcode = 0x2B;
885 mbox.typeX.id = 0;
886 mbox.typeX.opcode2 = 0x14;
887 mbox.typeX.cmd_mbox_addr = cb->cmd_mbox_addr;
888 mbox.typeX.stat_mbox_addr = cb->stat_mbox_addr;
889
890 status = mmio_init_fn(pdev, base, &mbox);
891 if (status != MYRB_STATUS_SUCCESS) {
892 cb->dual_mode_interface = false;
893 mbox.typeX.opcode2 = 0x10;
894 status = mmio_init_fn(pdev, base, &mbox);
895 if (status != MYRB_STATUS_SUCCESS) {
896 dev_err(&pdev->dev,
897 "Failed to enable mailbox, statux %02X\n",
898 status);
899 return false;
900 }
901 }
902 return true;
903 }
904
905 /**
906 * myrb_get_hba_config - reads the configuration information
907 *
908 * Reads the configuration information from the controller and
909 * initializes the controller structure.
910 *
911 * Return: 0 on success, errno otherwise
912 */
913 static int myrb_get_hba_config(struct myrb_hba *cb)
914 {
915 struct myrb_enquiry2 *enquiry2;
916 dma_addr_t enquiry2_addr;
917 struct myrb_config2 *config2;
918 dma_addr_t config2_addr;
919 struct Scsi_Host *shost = cb->host;
920 struct pci_dev *pdev = cb->pdev;
921 int pchan_max = 0, pchan_cur = 0;
922 unsigned short status;
923 int ret = -ENODEV, memsize = 0;
924
925 enquiry2 = dma_alloc_coherent(&pdev->dev, sizeof(struct myrb_enquiry2),
926 &enquiry2_addr, GFP_KERNEL);
927 if (!enquiry2) {
928 shost_printk(KERN_ERR, cb->host,
929 "Failed to allocate V1 enquiry2 memory\n");
930 return -ENOMEM;
931 }
932 config2 = dma_alloc_coherent(&pdev->dev, sizeof(struct myrb_config2),
933 &config2_addr, GFP_KERNEL);
934 if (!config2) {
935 shost_printk(KERN_ERR, cb->host,
936 "Failed to allocate V1 config2 memory\n");
937 dma_free_coherent(&pdev->dev, sizeof(struct myrb_enquiry2),
938 enquiry2, enquiry2_addr);
939 return -ENOMEM;
940 }
941 mutex_lock(&cb->dma_mutex);
942 status = myrb_hba_enquiry(cb);
943 mutex_unlock(&cb->dma_mutex);
944 if (status != MYRB_STATUS_SUCCESS) {
945 shost_printk(KERN_WARNING, cb->host,
946 "Failed it issue V1 Enquiry\n");
947 goto out_free;
948 }
949
950 status = myrb_exec_type3(cb, MYRB_CMD_ENQUIRY2, enquiry2_addr);
951 if (status != MYRB_STATUS_SUCCESS) {
952 shost_printk(KERN_WARNING, cb->host,
953 "Failed to issue V1 Enquiry2\n");
954 goto out_free;
955 }
956
957 status = myrb_exec_type3(cb, MYRB_CMD_READ_CONFIG2, config2_addr);
958 if (status != MYRB_STATUS_SUCCESS) {
959 shost_printk(KERN_WARNING, cb->host,
960 "Failed to issue ReadConfig2\n");
961 goto out_free;
962 }
963
964 status = myrb_get_ldev_info(cb);
965 if (status != MYRB_STATUS_SUCCESS) {
966 shost_printk(KERN_WARNING, cb->host,
967 "Failed to get logical drive information\n");
968 goto out_free;
969 }
970
971 /*
972 * Initialize the Controller Model Name and Full Model Name fields.
973 */
974 switch (enquiry2->hw.sub_model) {
975 case DAC960_V1_P_PD_PU:
976 if (enquiry2->scsi_cap.bus_speed == MYRB_SCSI_SPEED_ULTRA)
977 strcpy(cb->model_name, "DAC960PU");
978 else
979 strcpy(cb->model_name, "DAC960PD");
980 break;
981 case DAC960_V1_PL:
982 strcpy(cb->model_name, "DAC960PL");
983 break;
984 case DAC960_V1_PG:
985 strcpy(cb->model_name, "DAC960PG");
986 break;
987 case DAC960_V1_PJ:
988 strcpy(cb->model_name, "DAC960PJ");
989 break;
990 case DAC960_V1_PR:
991 strcpy(cb->model_name, "DAC960PR");
992 break;
993 case DAC960_V1_PT:
994 strcpy(cb->model_name, "DAC960PT");
995 break;
996 case DAC960_V1_PTL0:
997 strcpy(cb->model_name, "DAC960PTL0");
998 break;
999 case DAC960_V1_PRL:
1000 strcpy(cb->model_name, "DAC960PRL");
1001 break;
1002 case DAC960_V1_PTL1:
1003 strcpy(cb->model_name, "DAC960PTL1");
1004 break;
1005 case DAC960_V1_1164P:
1006 strcpy(cb->model_name, "eXtremeRAID 1100");
1007 break;
1008 default:
1009 shost_printk(KERN_WARNING, cb->host,
1010 "Unknown Model %X\n",
1011 enquiry2->hw.sub_model);
1012 goto out;
1013 }
1014 /*
1015 * Initialize the Controller Firmware Version field and verify that it
1016 * is a supported firmware version.
1017 * The supported firmware versions are:
1018 *
1019 * DAC1164P 5.06 and above
1020 * DAC960PTL/PRL/PJ/PG 4.06 and above
1021 * DAC960PU/PD/PL 3.51 and above
1022 * DAC960PU/PD/PL/P 2.73 and above
1023 */
1024 #if defined(CONFIG_ALPHA)
1025 /*
1026 * DEC Alpha machines were often equipped with DAC960 cards that were
1027 * OEMed from Mylex, and had their own custom firmware. Version 2.70,
1028 * the last custom FW revision to be released by DEC for these older
1029 * controllers, appears to work quite well with this driver.
1030 *
1031 * Cards tested successfully were several versions each of the PD and
1032 * PU, called by DEC the KZPSC and KZPAC, respectively, and having
1033 * the Manufacturer Numbers (from Mylex), usually on a sticker on the
1034 * back of the board, of:
1035 *
1036 * KZPSC: D040347 (1-channel) or D040348 (2-channel)
1037 * or D040349 (3-channel)
1038 * KZPAC: D040395 (1-channel) or D040396 (2-channel)
1039 * or D040397 (3-channel)
1040 */
1041 # define FIRMWARE_27X "2.70"
1042 #else
1043 # define FIRMWARE_27X "2.73"
1044 #endif
1045
1046 if (enquiry2->fw.major_version == 0) {
1047 enquiry2->fw.major_version = cb->enquiry->fw_major_version;
1048 enquiry2->fw.minor_version = cb->enquiry->fw_minor_version;
1049 enquiry2->fw.firmware_type = '0';
1050 enquiry2->fw.turn_id = 0;
1051 }
1052 snprintf(cb->fw_version, sizeof(cb->fw_version),
1053 "%d.%02d-%c-%02d",
1054 enquiry2->fw.major_version,
1055 enquiry2->fw.minor_version,
1056 enquiry2->fw.firmware_type,
1057 enquiry2->fw.turn_id);
1058 if (!((enquiry2->fw.major_version == 5 &&
1059 enquiry2->fw.minor_version >= 6) ||
1060 (enquiry2->fw.major_version == 4 &&
1061 enquiry2->fw.minor_version >= 6) ||
1062 (enquiry2->fw.major_version == 3 &&
1063 enquiry2->fw.minor_version >= 51) ||
1064 (enquiry2->fw.major_version == 2 &&
1065 strcmp(cb->fw_version, FIRMWARE_27X) >= 0))) {
1066 shost_printk(KERN_WARNING, cb->host,
1067 "Firmware Version '%s' unsupported\n",
1068 cb->fw_version);
1069 goto out;
1070 }
1071 /*
1072 * Initialize the Channels, Targets, Memory Size, and SAF-TE
1073 * Enclosure Management Enabled fields.
1074 */
1075 switch (enquiry2->hw.model) {
1076 case MYRB_5_CHANNEL_BOARD:
1077 pchan_max = 5;
1078 break;
1079 case MYRB_3_CHANNEL_BOARD:
1080 case MYRB_3_CHANNEL_ASIC_DAC:
1081 pchan_max = 3;
1082 break;
1083 case MYRB_2_CHANNEL_BOARD:
1084 pchan_max = 2;
1085 break;
1086 default:
1087 pchan_max = enquiry2->cfg_chan;
1088 break;
1089 }
1090 pchan_cur = enquiry2->cur_chan;
1091 if (enquiry2->scsi_cap.bus_width == MYRB_WIDTH_WIDE_32BIT)
1092 cb->bus_width = 32;
1093 else if (enquiry2->scsi_cap.bus_width == MYRB_WIDTH_WIDE_16BIT)
1094 cb->bus_width = 16;
1095 else
1096 cb->bus_width = 8;
1097 cb->ldev_block_size = enquiry2->ldev_block_size;
1098 shost->max_channel = pchan_cur;
1099 shost->max_id = enquiry2->max_targets;
1100 memsize = enquiry2->mem_size >> 20;
1101 cb->safte_enabled = (enquiry2->fault_mgmt == MYRB_FAULT_SAFTE);
1102 /*
1103 * Initialize the Controller Queue Depth, Driver Queue Depth,
1104 * Logical Drive Count, Maximum Blocks per Command, Controller
1105 * Scatter/Gather Limit, and Driver Scatter/Gather Limit.
1106 * The Driver Queue Depth must be at most one less than the
1107 * Controller Queue Depth to allow for an automatic drive
1108 * rebuild operation.
1109 */
1110 shost->can_queue = cb->enquiry->max_tcq;
1111 if (shost->can_queue < 3)
1112 shost->can_queue = enquiry2->max_cmds;
1113 if (shost->can_queue < 3)
1114 /* Play safe and disable TCQ */
1115 shost->can_queue = 1;
1116
1117 if (shost->can_queue > MYRB_CMD_MBOX_COUNT - 2)
1118 shost->can_queue = MYRB_CMD_MBOX_COUNT - 2;
1119 shost->max_sectors = enquiry2->max_sectors;
1120 shost->sg_tablesize = enquiry2->max_sge;
1121 if (shost->sg_tablesize > MYRB_SCATTER_GATHER_LIMIT)
1122 shost->sg_tablesize = MYRB_SCATTER_GATHER_LIMIT;
1123 /*
1124 * Initialize the Stripe Size, Segment Size, and Geometry Translation.
1125 */
1126 cb->stripe_size = config2->blocks_per_stripe * config2->block_factor
1127 >> (10 - MYRB_BLKSIZE_BITS);
1128 cb->segment_size = config2->blocks_per_cacheline * config2->block_factor
1129 >> (10 - MYRB_BLKSIZE_BITS);
1130 /* Assume 255/63 translation */
1131 cb->ldev_geom_heads = 255;
1132 cb->ldev_geom_sectors = 63;
1133 if (config2->drive_geometry) {
1134 cb->ldev_geom_heads = 128;
1135 cb->ldev_geom_sectors = 32;
1136 }
1137
1138 /*
1139 * Initialize the Background Initialization Status.
1140 */
1141 if ((cb->fw_version[0] == '4' &&
1142 strcmp(cb->fw_version, "4.08") >= 0) ||
1143 (cb->fw_version[0] == '5' &&
1144 strcmp(cb->fw_version, "5.08") >= 0)) {
1145 cb->bgi_status_supported = true;
1146 myrb_bgi_control(cb);
1147 }
1148 cb->last_rbld_status = MYRB_NO_STDBY_RBLD_OR_CHECK_IN_PROGRESS;
1149 ret = 0;
1150
1151 out:
1152 shost_printk(KERN_INFO, cb->host,
1153 "Configuring %s PCI RAID Controller\n", cb->model_name);
1154 shost_printk(KERN_INFO, cb->host,
1155 " Firmware Version: %s, Memory Size: %dMB\n",
1156 cb->fw_version, memsize);
1157 if (cb->io_addr == 0)
1158 shost_printk(KERN_INFO, cb->host,
1159 " I/O Address: n/a, PCI Address: 0x%lX, IRQ Channel: %d\n",
1160 (unsigned long)cb->pci_addr, cb->irq);
1161 else
1162 shost_printk(KERN_INFO, cb->host,
1163 " I/O Address: 0x%lX, PCI Address: 0x%lX, IRQ Channel: %d\n",
1164 (unsigned long)cb->io_addr, (unsigned long)cb->pci_addr,
1165 cb->irq);
1166 shost_printk(KERN_INFO, cb->host,
1167 " Controller Queue Depth: %d, Maximum Blocks per Command: %d\n",
1168 cb->host->can_queue, cb->host->max_sectors);
1169 shost_printk(KERN_INFO, cb->host,
1170 " Driver Queue Depth: %d, Scatter/Gather Limit: %d of %d Segments\n",
1171 cb->host->can_queue, cb->host->sg_tablesize,
1172 MYRB_SCATTER_GATHER_LIMIT);
1173 shost_printk(KERN_INFO, cb->host,
1174 " Stripe Size: %dKB, Segment Size: %dKB, BIOS Geometry: %d/%d%s\n",
1175 cb->stripe_size, cb->segment_size,
1176 cb->ldev_geom_heads, cb->ldev_geom_sectors,
1177 cb->safte_enabled ?
1178 " SAF-TE Enclosure Management Enabled" : "");
1179 shost_printk(KERN_INFO, cb->host,
1180 " Physical: %d/%d channels %d/%d/%d devices\n",
1181 pchan_cur, pchan_max, 0, cb->enquiry->pdev_dead,
1182 cb->host->max_id);
1183
1184 shost_printk(KERN_INFO, cb->host,
1185 " Logical: 1/1 channels, %d/%d disks\n",
1186 cb->enquiry->ldev_count, MYRB_MAX_LDEVS);
1187
1188 out_free:
1189 dma_free_coherent(&pdev->dev, sizeof(struct myrb_enquiry2),
1190 enquiry2, enquiry2_addr);
1191 dma_free_coherent(&pdev->dev, sizeof(struct myrb_config2),
1192 config2, config2_addr);
1193
1194 return ret;
1195 }
1196
1197 /**
1198 * myrb_unmap - unmaps controller structures
1199 */
1200 static void myrb_unmap(struct myrb_hba *cb)
1201 {
1202 if (cb->ldev_info_buf) {
1203 size_t ldev_info_size = sizeof(struct myrb_ldev_info) *
1204 MYRB_MAX_LDEVS;
1205 dma_free_coherent(&cb->pdev->dev, ldev_info_size,
1206 cb->ldev_info_buf, cb->ldev_info_addr);
1207 cb->ldev_info_buf = NULL;
1208 }
1209 if (cb->err_table) {
1210 size_t err_table_size = sizeof(struct myrb_error_entry) *
1211 MYRB_MAX_CHANNELS * MYRB_MAX_TARGETS;
1212 dma_free_coherent(&cb->pdev->dev, err_table_size,
1213 cb->err_table, cb->err_table_addr);
1214 cb->err_table = NULL;
1215 }
1216 if (cb->enquiry) {
1217 dma_free_coherent(&cb->pdev->dev, sizeof(struct myrb_enquiry),
1218 cb->enquiry, cb->enquiry_addr);
1219 cb->enquiry = NULL;
1220 }
1221 if (cb->first_stat_mbox) {
1222 dma_free_coherent(&cb->pdev->dev, cb->stat_mbox_size,
1223 cb->first_stat_mbox, cb->stat_mbox_addr);
1224 cb->first_stat_mbox = NULL;
1225 }
1226 if (cb->first_cmd_mbox) {
1227 dma_free_coherent(&cb->pdev->dev, cb->cmd_mbox_size,
1228 cb->first_cmd_mbox, cb->cmd_mbox_addr);
1229 cb->first_cmd_mbox = NULL;
1230 }
1231 }
1232
1233 /**
1234 * myrb_cleanup - cleanup controller structures
1235 */
1236 static void myrb_cleanup(struct myrb_hba *cb)
1237 {
1238 struct pci_dev *pdev = cb->pdev;
1239
1240 /* Free the memory mailbox, status, and related structures */
1241 myrb_unmap(cb);
1242
1243 if (cb->mmio_base) {
1244 cb->disable_intr(cb->io_base);
1245 iounmap(cb->mmio_base);
1246 }
1247 if (cb->irq)
1248 free_irq(cb->irq, cb);
1249 if (cb->io_addr)
1250 release_region(cb->io_addr, 0x80);
1251 pci_set_drvdata(pdev, NULL);
1252 pci_disable_device(pdev);
1253 scsi_host_put(cb->host);
1254 }
1255
1256 static int myrb_host_reset(struct scsi_cmnd *scmd)
1257 {
1258 struct Scsi_Host *shost = scmd->device->host;
1259 struct myrb_hba *cb = shost_priv(shost);
1260
1261 cb->reset(cb->io_base);
1262 return SUCCESS;
1263 }
1264
1265 static int myrb_pthru_queuecommand(struct Scsi_Host *shost,
1266 struct scsi_cmnd *scmd)
1267 {
1268 struct myrb_hba *cb = shost_priv(shost);
1269 struct myrb_cmdblk *cmd_blk = scsi_cmd_priv(scmd);
1270 union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
1271 struct myrb_dcdb *dcdb;
1272 dma_addr_t dcdb_addr;
1273 struct scsi_device *sdev = scmd->device;
1274 struct scatterlist *sgl;
1275 unsigned long flags;
1276 int nsge;
1277
1278 myrb_reset_cmd(cmd_blk);
1279 dcdb = dma_pool_alloc(cb->dcdb_pool, GFP_ATOMIC, &dcdb_addr);
1280 if (!dcdb)
1281 return SCSI_MLQUEUE_HOST_BUSY;
1282 nsge = scsi_dma_map(scmd);
1283 if (nsge > 1) {
1284 dma_pool_free(cb->dcdb_pool, dcdb, dcdb_addr);
1285 scmd->result = (DID_ERROR << 16);
1286 scmd->scsi_done(scmd);
1287 return 0;
1288 }
1289
1290 mbox->type3.opcode = MYRB_CMD_DCDB;
1291 mbox->type3.id = scmd->request->tag + 3;
1292 mbox->type3.addr = dcdb_addr;
1293 dcdb->channel = sdev->channel;
1294 dcdb->target = sdev->id;
1295 switch (scmd->sc_data_direction) {
1296 case DMA_NONE:
1297 dcdb->data_xfer = MYRB_DCDB_XFER_NONE;
1298 break;
1299 case DMA_TO_DEVICE:
1300 dcdb->data_xfer = MYRB_DCDB_XFER_SYSTEM_TO_DEVICE;
1301 break;
1302 case DMA_FROM_DEVICE:
1303 dcdb->data_xfer = MYRB_DCDB_XFER_DEVICE_TO_SYSTEM;
1304 break;
1305 default:
1306 dcdb->data_xfer = MYRB_DCDB_XFER_ILLEGAL;
1307 break;
1308 }
1309 dcdb->early_status = false;
1310 if (scmd->request->timeout <= 10)
1311 dcdb->timeout = MYRB_DCDB_TMO_10_SECS;
1312 else if (scmd->request->timeout <= 60)
1313 dcdb->timeout = MYRB_DCDB_TMO_60_SECS;
1314 else if (scmd->request->timeout <= 600)
1315 dcdb->timeout = MYRB_DCDB_TMO_10_MINS;
1316 else
1317 dcdb->timeout = MYRB_DCDB_TMO_24_HRS;
1318 dcdb->no_autosense = false;
1319 dcdb->allow_disconnect = true;
1320 sgl = scsi_sglist(scmd);
1321 dcdb->dma_addr = sg_dma_address(sgl);
1322 if (sg_dma_len(sgl) > USHRT_MAX) {
1323 dcdb->xfer_len_lo = sg_dma_len(sgl) & 0xffff;
1324 dcdb->xfer_len_hi4 = sg_dma_len(sgl) >> 16;
1325 } else {
1326 dcdb->xfer_len_lo = sg_dma_len(sgl);
1327 dcdb->xfer_len_hi4 = 0;
1328 }
1329 dcdb->cdb_len = scmd->cmd_len;
1330 dcdb->sense_len = sizeof(dcdb->sense);
1331 memcpy(&dcdb->cdb, scmd->cmnd, scmd->cmd_len);
1332
1333 spin_lock_irqsave(&cb->queue_lock, flags);
1334 cb->qcmd(cb, cmd_blk);
1335 spin_unlock_irqrestore(&cb->queue_lock, flags);
1336 return 0;
1337 }
1338
1339 static void myrb_inquiry(struct myrb_hba *cb,
1340 struct scsi_cmnd *scmd)
1341 {
1342 unsigned char inq[36] = {
1343 0x00, 0x00, 0x03, 0x02, 0x20, 0x00, 0x01, 0x00,
1344 0x4d, 0x59, 0x4c, 0x45, 0x58, 0x20, 0x20, 0x20,
1345 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1346 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
1347 0x20, 0x20, 0x20, 0x20,
1348 };
1349
1350 if (cb->bus_width > 16)
1351 inq[7] |= 1 << 6;
1352 if (cb->bus_width > 8)
1353 inq[7] |= 1 << 5;
1354 memcpy(&inq[16], cb->model_name, 16);
1355 memcpy(&inq[32], cb->fw_version, 1);
1356 memcpy(&inq[33], &cb->fw_version[2], 2);
1357 memcpy(&inq[35], &cb->fw_version[7], 1);
1358
1359 scsi_sg_copy_from_buffer(scmd, (void *)inq, 36);
1360 }
1361
1362 static void
1363 myrb_mode_sense(struct myrb_hba *cb, struct scsi_cmnd *scmd,
1364 struct myrb_ldev_info *ldev_info)
1365 {
1366 unsigned char modes[32], *mode_pg;
1367 bool dbd;
1368 size_t mode_len;
1369
1370 dbd = (scmd->cmnd[1] & 0x08) == 0x08;
1371 if (dbd) {
1372 mode_len = 24;
1373 mode_pg = &modes[4];
1374 } else {
1375 mode_len = 32;
1376 mode_pg = &modes[12];
1377 }
1378 memset(modes, 0, sizeof(modes));
1379 modes[0] = mode_len - 1;
1380 if (!dbd) {
1381 unsigned char *block_desc = &modes[4];
1382
1383 modes[3] = 8;
1384 put_unaligned_be32(ldev_info->size, &block_desc[0]);
1385 put_unaligned_be32(cb->ldev_block_size, &block_desc[5]);
1386 }
1387 mode_pg[0] = 0x08;
1388 mode_pg[1] = 0x12;
1389 if (ldev_info->wb_enabled)
1390 mode_pg[2] |= 0x04;
1391 if (cb->segment_size) {
1392 mode_pg[2] |= 0x08;
1393 put_unaligned_be16(cb->segment_size, &mode_pg[14]);
1394 }
1395
1396 scsi_sg_copy_from_buffer(scmd, modes, mode_len);
1397 }
1398
1399 static void myrb_request_sense(struct myrb_hba *cb,
1400 struct scsi_cmnd *scmd)
1401 {
1402 scsi_build_sense_buffer(0, scmd->sense_buffer,
1403 NO_SENSE, 0, 0);
1404 scsi_sg_copy_from_buffer(scmd, scmd->sense_buffer,
1405 SCSI_SENSE_BUFFERSIZE);
1406 }
1407
1408 static void myrb_read_capacity(struct myrb_hba *cb, struct scsi_cmnd *scmd,
1409 struct myrb_ldev_info *ldev_info)
1410 {
1411 unsigned char data[8];
1412
1413 dev_dbg(&scmd->device->sdev_gendev,
1414 "Capacity %u, blocksize %u\n",
1415 ldev_info->size, cb->ldev_block_size);
1416 put_unaligned_be32(ldev_info->size - 1, &data[0]);
1417 put_unaligned_be32(cb->ldev_block_size, &data[4]);
1418 scsi_sg_copy_from_buffer(scmd, data, 8);
1419 }
1420
1421 static int myrb_ldev_queuecommand(struct Scsi_Host *shost,
1422 struct scsi_cmnd *scmd)
1423 {
1424 struct myrb_hba *cb = shost_priv(shost);
1425 struct myrb_cmdblk *cmd_blk = scsi_cmd_priv(scmd);
1426 union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
1427 struct myrb_ldev_info *ldev_info;
1428 struct scsi_device *sdev = scmd->device;
1429 struct scatterlist *sgl;
1430 unsigned long flags;
1431 u64 lba;
1432 u32 block_cnt;
1433 int nsge;
1434
1435 ldev_info = sdev->hostdata;
1436 if (ldev_info->state != MYRB_DEVICE_ONLINE &&
1437 ldev_info->state != MYRB_DEVICE_WO) {
1438 dev_dbg(&shost->shost_gendev, "ldev %u in state %x, skip\n",
1439 sdev->id, ldev_info ? ldev_info->state : 0xff);
1440 scmd->result = (DID_BAD_TARGET << 16);
1441 scmd->scsi_done(scmd);
1442 return 0;
1443 }
1444 switch (scmd->cmnd[0]) {
1445 case TEST_UNIT_READY:
1446 scmd->result = (DID_OK << 16);
1447 scmd->scsi_done(scmd);
1448 return 0;
1449 case INQUIRY:
1450 if (scmd->cmnd[1] & 1) {
1451 /* Illegal request, invalid field in CDB */
1452 scsi_build_sense_buffer(0, scmd->sense_buffer,
1453 ILLEGAL_REQUEST, 0x24, 0);
1454 scmd->result = (DRIVER_SENSE << 24) |
1455 SAM_STAT_CHECK_CONDITION;
1456 } else {
1457 myrb_inquiry(cb, scmd);
1458 scmd->result = (DID_OK << 16);
1459 }
1460 scmd->scsi_done(scmd);
1461 return 0;
1462 case SYNCHRONIZE_CACHE:
1463 scmd->result = (DID_OK << 16);
1464 scmd->scsi_done(scmd);
1465 return 0;
1466 case MODE_SENSE:
1467 if ((scmd->cmnd[2] & 0x3F) != 0x3F &&
1468 (scmd->cmnd[2] & 0x3F) != 0x08) {
1469 /* Illegal request, invalid field in CDB */
1470 scsi_build_sense_buffer(0, scmd->sense_buffer,
1471 ILLEGAL_REQUEST, 0x24, 0);
1472 scmd->result = (DRIVER_SENSE << 24) |
1473 SAM_STAT_CHECK_CONDITION;
1474 } else {
1475 myrb_mode_sense(cb, scmd, ldev_info);
1476 scmd->result = (DID_OK << 16);
1477 }
1478 scmd->scsi_done(scmd);
1479 return 0;
1480 case READ_CAPACITY:
1481 if ((scmd->cmnd[1] & 1) ||
1482 (scmd->cmnd[8] & 1)) {
1483 /* Illegal request, invalid field in CDB */
1484 scsi_build_sense_buffer(0, scmd->sense_buffer,
1485 ILLEGAL_REQUEST, 0x24, 0);
1486 scmd->result = (DRIVER_SENSE << 24) |
1487 SAM_STAT_CHECK_CONDITION;
1488 scmd->scsi_done(scmd);
1489 return 0;
1490 }
1491 lba = get_unaligned_be32(&scmd->cmnd[2]);
1492 if (lba) {
1493 /* Illegal request, invalid field in CDB */
1494 scsi_build_sense_buffer(0, scmd->sense_buffer,
1495 ILLEGAL_REQUEST, 0x24, 0);
1496 scmd->result = (DRIVER_SENSE << 24) |
1497 SAM_STAT_CHECK_CONDITION;
1498 scmd->scsi_done(scmd);
1499 return 0;
1500 }
1501 myrb_read_capacity(cb, scmd, ldev_info);
1502 scmd->scsi_done(scmd);
1503 return 0;
1504 case REQUEST_SENSE:
1505 myrb_request_sense(cb, scmd);
1506 scmd->result = (DID_OK << 16);
1507 return 0;
1508 case SEND_DIAGNOSTIC:
1509 if (scmd->cmnd[1] != 0x04) {
1510 /* Illegal request, invalid field in CDB */
1511 scsi_build_sense_buffer(0, scmd->sense_buffer,
1512 ILLEGAL_REQUEST, 0x24, 0);
1513 scmd->result = (DRIVER_SENSE << 24) |
1514 SAM_STAT_CHECK_CONDITION;
1515 } else {
1516 /* Assume good status */
1517 scmd->result = (DID_OK << 16);
1518 }
1519 scmd->scsi_done(scmd);
1520 return 0;
1521 case READ_6:
1522 if (ldev_info->state == MYRB_DEVICE_WO) {
1523 /* Data protect, attempt to read invalid data */
1524 scsi_build_sense_buffer(0, scmd->sense_buffer,
1525 DATA_PROTECT, 0x21, 0x06);
1526 scmd->result = (DRIVER_SENSE << 24) |
1527 SAM_STAT_CHECK_CONDITION;
1528 scmd->scsi_done(scmd);
1529 return 0;
1530 }
1531 /* fall through */
1532 case WRITE_6:
1533 lba = (((scmd->cmnd[1] & 0x1F) << 16) |
1534 (scmd->cmnd[2] << 8) |
1535 scmd->cmnd[3]);
1536 block_cnt = scmd->cmnd[4];
1537 break;
1538 case READ_10:
1539 if (ldev_info->state == MYRB_DEVICE_WO) {
1540 /* Data protect, attempt to read invalid data */
1541 scsi_build_sense_buffer(0, scmd->sense_buffer,
1542 DATA_PROTECT, 0x21, 0x06);
1543 scmd->result = (DRIVER_SENSE << 24) |
1544 SAM_STAT_CHECK_CONDITION;
1545 scmd->scsi_done(scmd);
1546 return 0;
1547 }
1548 /* fall through */
1549 case WRITE_10:
1550 case VERIFY: /* 0x2F */
1551 case WRITE_VERIFY: /* 0x2E */
1552 lba = get_unaligned_be32(&scmd->cmnd[2]);
1553 block_cnt = get_unaligned_be16(&scmd->cmnd[7]);
1554 break;
1555 case READ_12:
1556 if (ldev_info->state == MYRB_DEVICE_WO) {
1557 /* Data protect, attempt to read invalid data */
1558 scsi_build_sense_buffer(0, scmd->sense_buffer,
1559 DATA_PROTECT, 0x21, 0x06);
1560 scmd->result = (DRIVER_SENSE << 24) |
1561 SAM_STAT_CHECK_CONDITION;
1562 scmd->scsi_done(scmd);
1563 return 0;
1564 }
1565 /* fall through */
1566 case WRITE_12:
1567 case VERIFY_12: /* 0xAF */
1568 case WRITE_VERIFY_12: /* 0xAE */
1569 lba = get_unaligned_be32(&scmd->cmnd[2]);
1570 block_cnt = get_unaligned_be32(&scmd->cmnd[6]);
1571 break;
1572 default:
1573 /* Illegal request, invalid opcode */
1574 scsi_build_sense_buffer(0, scmd->sense_buffer,
1575 ILLEGAL_REQUEST, 0x20, 0);
1576 scmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
1577 scmd->scsi_done(scmd);
1578 return 0;
1579 }
1580
1581 myrb_reset_cmd(cmd_blk);
1582 mbox->type5.id = scmd->request->tag + 3;
1583 if (scmd->sc_data_direction == DMA_NONE)
1584 goto submit;
1585 nsge = scsi_dma_map(scmd);
1586 if (nsge == 1) {
1587 sgl = scsi_sglist(scmd);
1588 if (scmd->sc_data_direction == DMA_FROM_DEVICE)
1589 mbox->type5.opcode = MYRB_CMD_READ;
1590 else
1591 mbox->type5.opcode = MYRB_CMD_WRITE;
1592
1593 mbox->type5.ld.xfer_len = block_cnt;
1594 mbox->type5.ld.ldev_num = sdev->id;
1595 mbox->type5.lba = lba;
1596 mbox->type5.addr = (u32)sg_dma_address(sgl);
1597 } else {
1598 struct myrb_sge *hw_sgl;
1599 dma_addr_t hw_sgl_addr;
1600 int i;
1601
1602 hw_sgl = dma_pool_alloc(cb->sg_pool, GFP_ATOMIC, &hw_sgl_addr);
1603 if (!hw_sgl)
1604 return SCSI_MLQUEUE_HOST_BUSY;
1605
1606 cmd_blk->sgl = hw_sgl;
1607 cmd_blk->sgl_addr = hw_sgl_addr;
1608
1609 if (scmd->sc_data_direction == DMA_FROM_DEVICE)
1610 mbox->type5.opcode = MYRB_CMD_READ_SG;
1611 else
1612 mbox->type5.opcode = MYRB_CMD_WRITE_SG;
1613
1614 mbox->type5.ld.xfer_len = block_cnt;
1615 mbox->type5.ld.ldev_num = sdev->id;
1616 mbox->type5.lba = lba;
1617 mbox->type5.addr = hw_sgl_addr;
1618 mbox->type5.sg_count = nsge;
1619
1620 scsi_for_each_sg(scmd, sgl, nsge, i) {
1621 hw_sgl->sge_addr = (u32)sg_dma_address(sgl);
1622 hw_sgl->sge_count = (u32)sg_dma_len(sgl);
1623 hw_sgl++;
1624 }
1625 }
1626 submit:
1627 spin_lock_irqsave(&cb->queue_lock, flags);
1628 cb->qcmd(cb, cmd_blk);
1629 spin_unlock_irqrestore(&cb->queue_lock, flags);
1630
1631 return 0;
1632 }
1633
1634 static int myrb_queuecommand(struct Scsi_Host *shost,
1635 struct scsi_cmnd *scmd)
1636 {
1637 struct scsi_device *sdev = scmd->device;
1638
1639 if (sdev->channel > myrb_logical_channel(shost)) {
1640 scmd->result = (DID_BAD_TARGET << 16);
1641 scmd->scsi_done(scmd);
1642 return 0;
1643 }
1644 if (sdev->channel == myrb_logical_channel(shost))
1645 return myrb_ldev_queuecommand(shost, scmd);
1646
1647 return myrb_pthru_queuecommand(shost, scmd);
1648 }
1649
1650 static int myrb_ldev_slave_alloc(struct scsi_device *sdev)
1651 {
1652 struct myrb_hba *cb = shost_priv(sdev->host);
1653 struct myrb_ldev_info *ldev_info;
1654 unsigned short ldev_num = sdev->id;
1655 enum raid_level level;
1656
1657 ldev_info = cb->ldev_info_buf + ldev_num;
1658 if (!ldev_info)
1659 return -ENXIO;
1660
1661 sdev->hostdata = kzalloc(sizeof(*ldev_info), GFP_KERNEL);
1662 if (!sdev->hostdata)
1663 return -ENOMEM;
1664 dev_dbg(&sdev->sdev_gendev,
1665 "slave alloc ldev %d state %x\n",
1666 ldev_num, ldev_info->state);
1667 memcpy(sdev->hostdata, ldev_info,
1668 sizeof(*ldev_info));
1669 switch (ldev_info->raid_level) {
1670 case MYRB_RAID_LEVEL0:
1671 level = RAID_LEVEL_LINEAR;
1672 break;
1673 case MYRB_RAID_LEVEL1:
1674 level = RAID_LEVEL_1;
1675 break;
1676 case MYRB_RAID_LEVEL3:
1677 level = RAID_LEVEL_3;
1678 break;
1679 case MYRB_RAID_LEVEL5:
1680 level = RAID_LEVEL_5;
1681 break;
1682 case MYRB_RAID_LEVEL6:
1683 level = RAID_LEVEL_6;
1684 break;
1685 case MYRB_RAID_JBOD:
1686 level = RAID_LEVEL_JBOD;
1687 break;
1688 default:
1689 level = RAID_LEVEL_UNKNOWN;
1690 break;
1691 }
1692 raid_set_level(myrb_raid_template, &sdev->sdev_gendev, level);
1693 return 0;
1694 }
1695
1696 static int myrb_pdev_slave_alloc(struct scsi_device *sdev)
1697 {
1698 struct myrb_hba *cb = shost_priv(sdev->host);
1699 struct myrb_pdev_state *pdev_info;
1700 unsigned short status;
1701
1702 if (sdev->id > MYRB_MAX_TARGETS)
1703 return -ENXIO;
1704
1705 pdev_info = kzalloc(sizeof(*pdev_info), GFP_KERNEL|GFP_DMA);
1706 if (!pdev_info)
1707 return -ENOMEM;
1708
1709 status = myrb_exec_type3D(cb, MYRB_CMD_GET_DEVICE_STATE,
1710 sdev, pdev_info);
1711 if (status != MYRB_STATUS_SUCCESS) {
1712 dev_dbg(&sdev->sdev_gendev,
1713 "Failed to get device state, status %x\n",
1714 status);
1715 kfree(pdev_info);
1716 return -ENXIO;
1717 }
1718 if (!pdev_info->present) {
1719 dev_dbg(&sdev->sdev_gendev,
1720 "device not present, skip\n");
1721 kfree(pdev_info);
1722 return -ENXIO;
1723 }
1724 dev_dbg(&sdev->sdev_gendev,
1725 "slave alloc pdev %d:%d state %x\n",
1726 sdev->channel, sdev->id, pdev_info->state);
1727 sdev->hostdata = pdev_info;
1728
1729 return 0;
1730 }
1731
1732 static int myrb_slave_alloc(struct scsi_device *sdev)
1733 {
1734 if (sdev->channel > myrb_logical_channel(sdev->host))
1735 return -ENXIO;
1736
1737 if (sdev->lun > 0)
1738 return -ENXIO;
1739
1740 if (sdev->channel == myrb_logical_channel(sdev->host))
1741 return myrb_ldev_slave_alloc(sdev);
1742
1743 return myrb_pdev_slave_alloc(sdev);
1744 }
1745
1746 static int myrb_slave_configure(struct scsi_device *sdev)
1747 {
1748 struct myrb_ldev_info *ldev_info;
1749
1750 if (sdev->channel > myrb_logical_channel(sdev->host))
1751 return -ENXIO;
1752
1753 if (sdev->channel < myrb_logical_channel(sdev->host)) {
1754 sdev->no_uld_attach = 1;
1755 return 0;
1756 }
1757 if (sdev->lun != 0)
1758 return -ENXIO;
1759
1760 ldev_info = sdev->hostdata;
1761 if (!ldev_info)
1762 return -ENXIO;
1763 if (ldev_info->state != MYRB_DEVICE_ONLINE)
1764 sdev_printk(KERN_INFO, sdev,
1765 "Logical drive is %s\n",
1766 myrb_devstate_name(ldev_info->state));
1767
1768 sdev->tagged_supported = 1;
1769 return 0;
1770 }
1771
1772 static void myrb_slave_destroy(struct scsi_device *sdev)
1773 {
1774 kfree(sdev->hostdata);
1775 }
1776
1777 static int myrb_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1778 sector_t capacity, int geom[])
1779 {
1780 struct myrb_hba *cb = shost_priv(sdev->host);
1781
1782 geom[0] = cb->ldev_geom_heads;
1783 geom[1] = cb->ldev_geom_sectors;
1784 geom[2] = sector_div(capacity, geom[0] * geom[1]);
1785
1786 return 0;
1787 }
1788
1789 static ssize_t raid_state_show(struct device *dev,
1790 struct device_attribute *attr, char *buf)
1791 {
1792 struct scsi_device *sdev = to_scsi_device(dev);
1793 struct myrb_hba *cb = shost_priv(sdev->host);
1794 int ret;
1795
1796 if (!sdev->hostdata)
1797 return snprintf(buf, 16, "Unknown\n");
1798
1799 if (sdev->channel == myrb_logical_channel(sdev->host)) {
1800 struct myrb_ldev_info *ldev_info = sdev->hostdata;
1801 const char *name;
1802
1803 name = myrb_devstate_name(ldev_info->state);
1804 if (name)
1805 ret = snprintf(buf, 32, "%s\n", name);
1806 else
1807 ret = snprintf(buf, 32, "Invalid (%02X)\n",
1808 ldev_info->state);
1809 } else {
1810 struct myrb_pdev_state *pdev_info = sdev->hostdata;
1811 unsigned short status;
1812 const char *name;
1813
1814 status = myrb_exec_type3D(cb, MYRB_CMD_GET_DEVICE_STATE,
1815 sdev, pdev_info);
1816 if (status != MYRB_STATUS_SUCCESS)
1817 sdev_printk(KERN_INFO, sdev,
1818 "Failed to get device state, status %x\n",
1819 status);
1820
1821 if (!pdev_info->present)
1822 name = "Removed";
1823 else
1824 name = myrb_devstate_name(pdev_info->state);
1825 if (name)
1826 ret = snprintf(buf, 32, "%s\n", name);
1827 else
1828 ret = snprintf(buf, 32, "Invalid (%02X)\n",
1829 pdev_info->state);
1830 }
1831 return ret;
1832 }
1833
1834 static ssize_t raid_state_store(struct device *dev,
1835 struct device_attribute *attr, const char *buf, size_t count)
1836 {
1837 struct scsi_device *sdev = to_scsi_device(dev);
1838 struct myrb_hba *cb = shost_priv(sdev->host);
1839 struct myrb_pdev_state *pdev_info;
1840 enum myrb_devstate new_state;
1841 unsigned short status;
1842
1843 if (!strncmp(buf, "kill", 4) ||
1844 !strncmp(buf, "offline", 7))
1845 new_state = MYRB_DEVICE_DEAD;
1846 else if (!strncmp(buf, "online", 6))
1847 new_state = MYRB_DEVICE_ONLINE;
1848 else if (!strncmp(buf, "standby", 7))
1849 new_state = MYRB_DEVICE_STANDBY;
1850 else
1851 return -EINVAL;
1852
1853 pdev_info = sdev->hostdata;
1854 if (!pdev_info) {
1855 sdev_printk(KERN_INFO, sdev,
1856 "Failed - no physical device information\n");
1857 return -ENXIO;
1858 }
1859 if (!pdev_info->present) {
1860 sdev_printk(KERN_INFO, sdev,
1861 "Failed - device not present\n");
1862 return -ENXIO;
1863 }
1864
1865 if (pdev_info->state == new_state)
1866 return count;
1867
1868 status = myrb_set_pdev_state(cb, sdev, new_state);
1869 switch (status) {
1870 case MYRB_STATUS_SUCCESS:
1871 break;
1872 case MYRB_STATUS_START_DEVICE_FAILED:
1873 sdev_printk(KERN_INFO, sdev,
1874 "Failed - Unable to Start Device\n");
1875 count = -EAGAIN;
1876 break;
1877 case MYRB_STATUS_NO_DEVICE:
1878 sdev_printk(KERN_INFO, sdev,
1879 "Failed - No Device at Address\n");
1880 count = -ENODEV;
1881 break;
1882 case MYRB_STATUS_INVALID_CHANNEL_OR_TARGET:
1883 sdev_printk(KERN_INFO, sdev,
1884 "Failed - Invalid Channel or Target or Modifier\n");
1885 count = -EINVAL;
1886 break;
1887 case MYRB_STATUS_CHANNEL_BUSY:
1888 sdev_printk(KERN_INFO, sdev,
1889 "Failed - Channel Busy\n");
1890 count = -EBUSY;
1891 break;
1892 default:
1893 sdev_printk(KERN_INFO, sdev,
1894 "Failed - Unexpected Status %04X\n", status);
1895 count = -EIO;
1896 break;
1897 }
1898 return count;
1899 }
1900 static DEVICE_ATTR_RW(raid_state);
1901
1902 static ssize_t raid_level_show(struct device *dev,
1903 struct device_attribute *attr, char *buf)
1904 {
1905 struct scsi_device *sdev = to_scsi_device(dev);
1906
1907 if (sdev->channel == myrb_logical_channel(sdev->host)) {
1908 struct myrb_ldev_info *ldev_info = sdev->hostdata;
1909 const char *name;
1910
1911 if (!ldev_info)
1912 return -ENXIO;
1913
1914 name = myrb_raidlevel_name(ldev_info->raid_level);
1915 if (!name)
1916 return snprintf(buf, 32, "Invalid (%02X)\n",
1917 ldev_info->state);
1918 return snprintf(buf, 32, "%s\n", name);
1919 }
1920 return snprintf(buf, 32, "Physical Drive\n");
1921 }
1922 static DEVICE_ATTR_RO(raid_level);
1923
1924 static ssize_t rebuild_show(struct device *dev,
1925 struct device_attribute *attr, char *buf)
1926 {
1927 struct scsi_device *sdev = to_scsi_device(dev);
1928 struct myrb_hba *cb = shost_priv(sdev->host);
1929 struct myrb_rbld_progress rbld_buf;
1930 unsigned char status;
1931
1932 if (sdev->channel < myrb_logical_channel(sdev->host))
1933 return snprintf(buf, 32, "physical device - not rebuilding\n");
1934
1935 status = myrb_get_rbld_progress(cb, &rbld_buf);
1936
1937 if (rbld_buf.ldev_num != sdev->id ||
1938 status != MYRB_STATUS_SUCCESS)
1939 return snprintf(buf, 32, "not rebuilding\n");
1940
1941 return snprintf(buf, 32, "rebuilding block %u of %u\n",
1942 rbld_buf.ldev_size - rbld_buf.blocks_left,
1943 rbld_buf.ldev_size);
1944 }
1945
1946 static ssize_t rebuild_store(struct device *dev,
1947 struct device_attribute *attr, const char *buf, size_t count)
1948 {
1949 struct scsi_device *sdev = to_scsi_device(dev);
1950 struct myrb_hba *cb = shost_priv(sdev->host);
1951 struct myrb_cmdblk *cmd_blk;
1952 union myrb_cmd_mbox *mbox;
1953 unsigned short status;
1954 int rc, start;
1955 const char *msg;
1956
1957 rc = kstrtoint(buf, 0, &start);
1958 if (rc)
1959 return rc;
1960
1961 if (sdev->channel >= myrb_logical_channel(sdev->host))
1962 return -ENXIO;
1963
1964 status = myrb_get_rbld_progress(cb, NULL);
1965 if (start) {
1966 if (status == MYRB_STATUS_SUCCESS) {
1967 sdev_printk(KERN_INFO, sdev,
1968 "Rebuild Not Initiated; already in progress\n");
1969 return -EALREADY;
1970 }
1971 mutex_lock(&cb->dcmd_mutex);
1972 cmd_blk = &cb->dcmd_blk;
1973 myrb_reset_cmd(cmd_blk);
1974 mbox = &cmd_blk->mbox;
1975 mbox->type3D.opcode = MYRB_CMD_REBUILD_ASYNC;
1976 mbox->type3D.id = MYRB_DCMD_TAG;
1977 mbox->type3D.channel = sdev->channel;
1978 mbox->type3D.target = sdev->id;
1979 status = myrb_exec_cmd(cb, cmd_blk);
1980 mutex_unlock(&cb->dcmd_mutex);
1981 } else {
1982 struct pci_dev *pdev = cb->pdev;
1983 unsigned char *rate;
1984 dma_addr_t rate_addr;
1985
1986 if (status != MYRB_STATUS_SUCCESS) {
1987 sdev_printk(KERN_INFO, sdev,
1988 "Rebuild Not Cancelled; not in progress\n");
1989 return 0;
1990 }
1991
1992 rate = dma_alloc_coherent(&pdev->dev, sizeof(char),
1993 &rate_addr, GFP_KERNEL);
1994 if (rate == NULL) {
1995 sdev_printk(KERN_INFO, sdev,
1996 "Cancellation of Rebuild Failed - Out of Memory\n");
1997 return -ENOMEM;
1998 }
1999 mutex_lock(&cb->dcmd_mutex);
2000 cmd_blk = &cb->dcmd_blk;
2001 myrb_reset_cmd(cmd_blk);
2002 mbox = &cmd_blk->mbox;
2003 mbox->type3R.opcode = MYRB_CMD_REBUILD_CONTROL;
2004 mbox->type3R.id = MYRB_DCMD_TAG;
2005 mbox->type3R.rbld_rate = 0xFF;
2006 mbox->type3R.addr = rate_addr;
2007 status = myrb_exec_cmd(cb, cmd_blk);
2008 dma_free_coherent(&pdev->dev, sizeof(char), rate, rate_addr);
2009 mutex_unlock(&cb->dcmd_mutex);
2010 }
2011 if (status == MYRB_STATUS_SUCCESS) {
2012 sdev_printk(KERN_INFO, sdev, "Rebuild %s\n",
2013 start ? "Initiated" : "Cancelled");
2014 return count;
2015 }
2016 if (!start) {
2017 sdev_printk(KERN_INFO, sdev,
2018 "Rebuild Not Cancelled, status 0x%x\n",
2019 status);
2020 return -EIO;
2021 }
2022
2023 switch (status) {
2024 case MYRB_STATUS_ATTEMPT_TO_RBLD_ONLINE_DRIVE:
2025 msg = "Attempt to Rebuild Online or Unresponsive Drive";
2026 break;
2027 case MYRB_STATUS_RBLD_NEW_DISK_FAILED:
2028 msg = "New Disk Failed During Rebuild";
2029 break;
2030 case MYRB_STATUS_INVALID_ADDRESS:
2031 msg = "Invalid Device Address";
2032 break;
2033 case MYRB_STATUS_RBLD_OR_CHECK_INPROGRESS:
2034 msg = "Already in Progress";
2035 break;
2036 default:
2037 msg = NULL;
2038 break;
2039 }
2040 if (msg)
2041 sdev_printk(KERN_INFO, sdev,
2042 "Rebuild Failed - %s\n", msg);
2043 else
2044 sdev_printk(KERN_INFO, sdev,
2045 "Rebuild Failed, status 0x%x\n", status);
2046
2047 return -EIO;
2048 }
2049 static DEVICE_ATTR_RW(rebuild);
2050
2051 static ssize_t consistency_check_store(struct device *dev,
2052 struct device_attribute *attr, const char *buf, size_t count)
2053 {
2054 struct scsi_device *sdev = to_scsi_device(dev);
2055 struct myrb_hba *cb = shost_priv(sdev->host);
2056 struct myrb_rbld_progress rbld_buf;
2057 struct myrb_cmdblk *cmd_blk;
2058 union myrb_cmd_mbox *mbox;
2059 unsigned short ldev_num = 0xFFFF;
2060 unsigned short status;
2061 int rc, start;
2062 const char *msg;
2063
2064 rc = kstrtoint(buf, 0, &start);
2065 if (rc)
2066 return rc;
2067
2068 if (sdev->channel < myrb_logical_channel(sdev->host))
2069 return -ENXIO;
2070
2071 status = myrb_get_rbld_progress(cb, &rbld_buf);
2072 if (start) {
2073 if (status == MYRB_STATUS_SUCCESS) {
2074 sdev_printk(KERN_INFO, sdev,
2075 "Check Consistency Not Initiated; already in progress\n");
2076 return -EALREADY;
2077 }
2078 mutex_lock(&cb->dcmd_mutex);
2079 cmd_blk = &cb->dcmd_blk;
2080 myrb_reset_cmd(cmd_blk);
2081 mbox = &cmd_blk->mbox;
2082 mbox->type3C.opcode = MYRB_CMD_CHECK_CONSISTENCY_ASYNC;
2083 mbox->type3C.id = MYRB_DCMD_TAG;
2084 mbox->type3C.ldev_num = sdev->id;
2085 mbox->type3C.auto_restore = true;
2086
2087 status = myrb_exec_cmd(cb, cmd_blk);
2088 mutex_unlock(&cb->dcmd_mutex);
2089 } else {
2090 struct pci_dev *pdev = cb->pdev;
2091 unsigned char *rate;
2092 dma_addr_t rate_addr;
2093
2094 if (ldev_num != sdev->id) {
2095 sdev_printk(KERN_INFO, sdev,
2096 "Check Consistency Not Cancelled; not in progress\n");
2097 return 0;
2098 }
2099 rate = dma_alloc_coherent(&pdev->dev, sizeof(char),
2100 &rate_addr, GFP_KERNEL);
2101 if (rate == NULL) {
2102 sdev_printk(KERN_INFO, sdev,
2103 "Cancellation of Check Consistency Failed - Out of Memory\n");
2104 return -ENOMEM;
2105 }
2106 mutex_lock(&cb->dcmd_mutex);
2107 cmd_blk = &cb->dcmd_blk;
2108 myrb_reset_cmd(cmd_blk);
2109 mbox = &cmd_blk->mbox;
2110 mbox->type3R.opcode = MYRB_CMD_REBUILD_CONTROL;
2111 mbox->type3R.id = MYRB_DCMD_TAG;
2112 mbox->type3R.rbld_rate = 0xFF;
2113 mbox->type3R.addr = rate_addr;
2114 status = myrb_exec_cmd(cb, cmd_blk);
2115 dma_free_coherent(&pdev->dev, sizeof(char), rate, rate_addr);
2116 mutex_unlock(&cb->dcmd_mutex);
2117 }
2118 if (status == MYRB_STATUS_SUCCESS) {
2119 sdev_printk(KERN_INFO, sdev, "Check Consistency %s\n",
2120 start ? "Initiated" : "Cancelled");
2121 return count;
2122 }
2123 if (!start) {
2124 sdev_printk(KERN_INFO, sdev,
2125 "Check Consistency Not Cancelled, status 0x%x\n",
2126 status);
2127 return -EIO;
2128 }
2129
2130 switch (status) {
2131 case MYRB_STATUS_ATTEMPT_TO_RBLD_ONLINE_DRIVE:
2132 msg = "Dependent Physical Device is DEAD";
2133 break;
2134 case MYRB_STATUS_RBLD_NEW_DISK_FAILED:
2135 msg = "New Disk Failed During Rebuild";
2136 break;
2137 case MYRB_STATUS_INVALID_ADDRESS:
2138 msg = "Invalid or Nonredundant Logical Drive";
2139 break;
2140 case MYRB_STATUS_RBLD_OR_CHECK_INPROGRESS:
2141 msg = "Already in Progress";
2142 break;
2143 default:
2144 msg = NULL;
2145 break;
2146 }
2147 if (msg)
2148 sdev_printk(KERN_INFO, sdev,
2149 "Check Consistency Failed - %s\n", msg);
2150 else
2151 sdev_printk(KERN_INFO, sdev,
2152 "Check Consistency Failed, status 0x%x\n", status);
2153
2154 return -EIO;
2155 }
2156
2157 static ssize_t consistency_check_show(struct device *dev,
2158 struct device_attribute *attr, char *buf)
2159 {
2160 return rebuild_show(dev, attr, buf);
2161 }
2162 static DEVICE_ATTR_RW(consistency_check);
2163
2164 static ssize_t ctlr_num_show(struct device *dev,
2165 struct device_attribute *attr, char *buf)
2166 {
2167 struct Scsi_Host *shost = class_to_shost(dev);
2168 struct myrb_hba *cb = shost_priv(shost);
2169
2170 return snprintf(buf, 20, "%d\n", cb->ctlr_num);
2171 }
2172 static DEVICE_ATTR_RO(ctlr_num);
2173
2174 static ssize_t firmware_show(struct device *dev,
2175 struct device_attribute *attr, char *buf)
2176 {
2177 struct Scsi_Host *shost = class_to_shost(dev);
2178 struct myrb_hba *cb = shost_priv(shost);
2179
2180 return snprintf(buf, 16, "%s\n", cb->fw_version);
2181 }
2182 static DEVICE_ATTR_RO(firmware);
2183
2184 static ssize_t model_show(struct device *dev,
2185 struct device_attribute *attr, char *buf)
2186 {
2187 struct Scsi_Host *shost = class_to_shost(dev);
2188 struct myrb_hba *cb = shost_priv(shost);
2189
2190 return snprintf(buf, 16, "%s\n", cb->model_name);
2191 }
2192 static DEVICE_ATTR_RO(model);
2193
2194 static ssize_t flush_cache_store(struct device *dev,
2195 struct device_attribute *attr, const char *buf, size_t count)
2196 {
2197 struct Scsi_Host *shost = class_to_shost(dev);
2198 struct myrb_hba *cb = shost_priv(shost);
2199 unsigned short status;
2200
2201 status = myrb_exec_type3(cb, MYRB_CMD_FLUSH, 0);
2202 if (status == MYRB_STATUS_SUCCESS) {
2203 shost_printk(KERN_INFO, shost,
2204 "Cache Flush Completed\n");
2205 return count;
2206 }
2207 shost_printk(KERN_INFO, shost,
2208 "Cache Flush Failed, status %x\n", status);
2209 return -EIO;
2210 }
2211 static DEVICE_ATTR_WO(flush_cache);
2212
2213 static struct device_attribute *myrb_sdev_attrs[] = {
2214 &dev_attr_rebuild,
2215 &dev_attr_consistency_check,
2216 &dev_attr_raid_state,
2217 &dev_attr_raid_level,
2218 NULL,
2219 };
2220
2221 static struct device_attribute *myrb_shost_attrs[] = {
2222 &dev_attr_ctlr_num,
2223 &dev_attr_model,
2224 &dev_attr_firmware,
2225 &dev_attr_flush_cache,
2226 NULL,
2227 };
2228
2229 struct scsi_host_template myrb_template = {
2230 .module = THIS_MODULE,
2231 .name = "DAC960",
2232 .proc_name = "myrb",
2233 .queuecommand = myrb_queuecommand,
2234 .eh_host_reset_handler = myrb_host_reset,
2235 .slave_alloc = myrb_slave_alloc,
2236 .slave_configure = myrb_slave_configure,
2237 .slave_destroy = myrb_slave_destroy,
2238 .bios_param = myrb_biosparam,
2239 .cmd_size = sizeof(struct myrb_cmdblk),
2240 .shost_attrs = myrb_shost_attrs,
2241 .sdev_attrs = myrb_sdev_attrs,
2242 .this_id = -1,
2243 };
2244
2245 /**
2246 * myrb_is_raid - return boolean indicating device is raid volume
2247 * @dev the device struct object
2248 */
2249 static int myrb_is_raid(struct device *dev)
2250 {
2251 struct scsi_device *sdev = to_scsi_device(dev);
2252
2253 return sdev->channel == myrb_logical_channel(sdev->host);
2254 }
2255
2256 /**
2257 * myrb_get_resync - get raid volume resync percent complete
2258 * @dev the device struct object
2259 */
2260 static void myrb_get_resync(struct device *dev)
2261 {
2262 struct scsi_device *sdev = to_scsi_device(dev);
2263 struct myrb_hba *cb = shost_priv(sdev->host);
2264 struct myrb_rbld_progress rbld_buf;
2265 unsigned int percent_complete = 0;
2266 unsigned short status;
2267 unsigned int ldev_size = 0, remaining = 0;
2268
2269 if (sdev->channel < myrb_logical_channel(sdev->host))
2270 return;
2271 status = myrb_get_rbld_progress(cb, &rbld_buf);
2272 if (status == MYRB_STATUS_SUCCESS) {
2273 if (rbld_buf.ldev_num == sdev->id) {
2274 ldev_size = rbld_buf.ldev_size;
2275 remaining = rbld_buf.blocks_left;
2276 }
2277 }
2278 if (remaining && ldev_size)
2279 percent_complete = (ldev_size - remaining) * 100 / ldev_size;
2280 raid_set_resync(myrb_raid_template, dev, percent_complete);
2281 }
2282
2283 /**
2284 * myrb_get_state - get raid volume status
2285 * @dev the device struct object
2286 */
2287 static void myrb_get_state(struct device *dev)
2288 {
2289 struct scsi_device *sdev = to_scsi_device(dev);
2290 struct myrb_hba *cb = shost_priv(sdev->host);
2291 struct myrb_ldev_info *ldev_info = sdev->hostdata;
2292 enum raid_state state = RAID_STATE_UNKNOWN;
2293 unsigned short status;
2294
2295 if (sdev->channel < myrb_logical_channel(sdev->host) || !ldev_info)
2296 state = RAID_STATE_UNKNOWN;
2297 else {
2298 status = myrb_get_rbld_progress(cb, NULL);
2299 if (status == MYRB_STATUS_SUCCESS)
2300 state = RAID_STATE_RESYNCING;
2301 else {
2302 switch (ldev_info->state) {
2303 case MYRB_DEVICE_ONLINE:
2304 state = RAID_STATE_ACTIVE;
2305 break;
2306 case MYRB_DEVICE_WO:
2307 case MYRB_DEVICE_CRITICAL:
2308 state = RAID_STATE_DEGRADED;
2309 break;
2310 default:
2311 state = RAID_STATE_OFFLINE;
2312 }
2313 }
2314 }
2315 raid_set_state(myrb_raid_template, dev, state);
2316 }
2317
2318 struct raid_function_template myrb_raid_functions = {
2319 .cookie = &myrb_template,
2320 .is_raid = myrb_is_raid,
2321 .get_resync = myrb_get_resync,
2322 .get_state = myrb_get_state,
2323 };
2324
2325 static void myrb_handle_scsi(struct myrb_hba *cb, struct myrb_cmdblk *cmd_blk,
2326 struct scsi_cmnd *scmd)
2327 {
2328 unsigned short status;
2329
2330 if (!cmd_blk)
2331 return;
2332
2333 scsi_dma_unmap(scmd);
2334
2335 if (cmd_blk->dcdb) {
2336 memcpy(scmd->sense_buffer, &cmd_blk->dcdb->sense, 64);
2337 dma_pool_free(cb->dcdb_pool, cmd_blk->dcdb,
2338 cmd_blk->dcdb_addr);
2339 cmd_blk->dcdb = NULL;
2340 }
2341 if (cmd_blk->sgl) {
2342 dma_pool_free(cb->sg_pool, cmd_blk->sgl, cmd_blk->sgl_addr);
2343 cmd_blk->sgl = NULL;
2344 cmd_blk->sgl_addr = 0;
2345 }
2346 status = cmd_blk->status;
2347 switch (status) {
2348 case MYRB_STATUS_SUCCESS:
2349 case MYRB_STATUS_DEVICE_BUSY:
2350 scmd->result = (DID_OK << 16) | status;
2351 break;
2352 case MYRB_STATUS_BAD_DATA:
2353 dev_dbg(&scmd->device->sdev_gendev,
2354 "Bad Data Encountered\n");
2355 if (scmd->sc_data_direction == DMA_FROM_DEVICE)
2356 /* Unrecovered read error */
2357 scsi_build_sense_buffer(0, scmd->sense_buffer,
2358 MEDIUM_ERROR, 0x11, 0);
2359 else
2360 /* Write error */
2361 scsi_build_sense_buffer(0, scmd->sense_buffer,
2362 MEDIUM_ERROR, 0x0C, 0);
2363 scmd->result = (DID_OK << 16) | SAM_STAT_CHECK_CONDITION;
2364 break;
2365 case MYRB_STATUS_IRRECOVERABLE_DATA_ERROR:
2366 scmd_printk(KERN_ERR, scmd, "Irrecoverable Data Error\n");
2367 if (scmd->sc_data_direction == DMA_FROM_DEVICE)
2368 /* Unrecovered read error, auto-reallocation failed */
2369 scsi_build_sense_buffer(0, scmd->sense_buffer,
2370 MEDIUM_ERROR, 0x11, 0x04);
2371 else
2372 /* Write error, auto-reallocation failed */
2373 scsi_build_sense_buffer(0, scmd->sense_buffer,
2374 MEDIUM_ERROR, 0x0C, 0x02);
2375 scmd->result = (DID_OK << 16) | SAM_STAT_CHECK_CONDITION;
2376 break;
2377 case MYRB_STATUS_LDRV_NONEXISTENT_OR_OFFLINE:
2378 dev_dbg(&scmd->device->sdev_gendev,
2379 "Logical Drive Nonexistent or Offline");
2380 scmd->result = (DID_BAD_TARGET << 16);
2381 break;
2382 case MYRB_STATUS_ACCESS_BEYOND_END_OF_LDRV:
2383 dev_dbg(&scmd->device->sdev_gendev,
2384 "Attempt to Access Beyond End of Logical Drive");
2385 /* Logical block address out of range */
2386 scsi_build_sense_buffer(0, scmd->sense_buffer,
2387 NOT_READY, 0x21, 0);
2388 break;
2389 case MYRB_STATUS_DEVICE_NONRESPONSIVE:
2390 dev_dbg(&scmd->device->sdev_gendev, "Device nonresponsive\n");
2391 scmd->result = (DID_BAD_TARGET << 16);
2392 break;
2393 default:
2394 scmd_printk(KERN_ERR, scmd,
2395 "Unexpected Error Status %04X", status);
2396 scmd->result = (DID_ERROR << 16);
2397 break;
2398 }
2399 scmd->scsi_done(scmd);
2400 }
2401
2402 static void myrb_handle_cmdblk(struct myrb_hba *cb, struct myrb_cmdblk *cmd_blk)
2403 {
2404 if (!cmd_blk)
2405 return;
2406
2407 if (cmd_blk->completion) {
2408 complete(cmd_blk->completion);
2409 cmd_blk->completion = NULL;
2410 }
2411 }
2412
2413 static void myrb_monitor(struct work_struct *work)
2414 {
2415 struct myrb_hba *cb = container_of(work,
2416 struct myrb_hba, monitor_work.work);
2417 struct Scsi_Host *shost = cb->host;
2418 unsigned long interval = MYRB_PRIMARY_MONITOR_INTERVAL;
2419
2420 dev_dbg(&shost->shost_gendev, "monitor tick\n");
2421
2422 if (cb->new_ev_seq > cb->old_ev_seq) {
2423 int event = cb->old_ev_seq;
2424
2425 dev_dbg(&shost->shost_gendev,
2426 "get event log no %d/%d\n",
2427 cb->new_ev_seq, event);
2428 myrb_get_event(cb, event);
2429 cb->old_ev_seq = event + 1;
2430 interval = 10;
2431 } else if (cb->need_err_info) {
2432 cb->need_err_info = false;
2433 dev_dbg(&shost->shost_gendev, "get error table\n");
2434 myrb_get_errtable(cb);
2435 interval = 10;
2436 } else if (cb->need_rbld && cb->rbld_first) {
2437 cb->need_rbld = false;
2438 dev_dbg(&shost->shost_gendev,
2439 "get rebuild progress\n");
2440 myrb_update_rbld_progress(cb);
2441 interval = 10;
2442 } else if (cb->need_ldev_info) {
2443 cb->need_ldev_info = false;
2444 dev_dbg(&shost->shost_gendev,
2445 "get logical drive info\n");
2446 myrb_get_ldev_info(cb);
2447 interval = 10;
2448 } else if (cb->need_rbld) {
2449 cb->need_rbld = false;
2450 dev_dbg(&shost->shost_gendev,
2451 "get rebuild progress\n");
2452 myrb_update_rbld_progress(cb);
2453 interval = 10;
2454 } else if (cb->need_cc_status) {
2455 cb->need_cc_status = false;
2456 dev_dbg(&shost->shost_gendev,
2457 "get consistency check progress\n");
2458 myrb_get_cc_progress(cb);
2459 interval = 10;
2460 } else if (cb->need_bgi_status) {
2461 cb->need_bgi_status = false;
2462 dev_dbg(&shost->shost_gendev, "get background init status\n");
2463 myrb_bgi_control(cb);
2464 interval = 10;
2465 } else {
2466 dev_dbg(&shost->shost_gendev, "new enquiry\n");
2467 mutex_lock(&cb->dma_mutex);
2468 myrb_hba_enquiry(cb);
2469 mutex_unlock(&cb->dma_mutex);
2470 if ((cb->new_ev_seq - cb->old_ev_seq > 0) ||
2471 cb->need_err_info || cb->need_rbld ||
2472 cb->need_ldev_info || cb->need_cc_status ||
2473 cb->need_bgi_status) {
2474 dev_dbg(&shost->shost_gendev,
2475 "reschedule monitor\n");
2476 interval = 0;
2477 }
2478 }
2479 if (interval > 1)
2480 cb->primary_monitor_time = jiffies;
2481 queue_delayed_work(cb->work_q, &cb->monitor_work, interval);
2482 }
2483
2484 /**
2485 * myrb_err_status - reports controller BIOS messages
2486 *
2487 * Controller BIOS messages are passed through the Error Status Register
2488 * when the driver performs the BIOS handshaking.
2489 *
2490 * Return: true for fatal errors and false otherwise.
2491 */
2492 bool myrb_err_status(struct myrb_hba *cb, unsigned char error,
2493 unsigned char parm0, unsigned char parm1)
2494 {
2495 struct pci_dev *pdev = cb->pdev;
2496
2497 switch (error) {
2498 case 0x00:
2499 dev_info(&pdev->dev,
2500 "Physical Device %d:%d Not Responding\n",
2501 parm1, parm0);
2502 break;
2503 case 0x08:
2504 dev_notice(&pdev->dev, "Spinning Up Drives\n");
2505 break;
2506 case 0x30:
2507 dev_notice(&pdev->dev, "Configuration Checksum Error\n");
2508 break;
2509 case 0x60:
2510 dev_notice(&pdev->dev, "Mirror Race Recovery Failed\n");
2511 break;
2512 case 0x70:
2513 dev_notice(&pdev->dev, "Mirror Race Recovery In Progress\n");
2514 break;
2515 case 0x90:
2516 dev_notice(&pdev->dev, "Physical Device %d:%d COD Mismatch\n",
2517 parm1, parm0);
2518 break;
2519 case 0xA0:
2520 dev_notice(&pdev->dev, "Logical Drive Installation Aborted\n");
2521 break;
2522 case 0xB0:
2523 dev_notice(&pdev->dev, "Mirror Race On A Critical Logical Drive\n");
2524 break;
2525 case 0xD0:
2526 dev_notice(&pdev->dev, "New Controller Configuration Found\n");
2527 break;
2528 case 0xF0:
2529 dev_err(&pdev->dev, "Fatal Memory Parity Error\n");
2530 return true;
2531 default:
2532 dev_err(&pdev->dev, "Unknown Initialization Error %02X\n",
2533 error);
2534 return true;
2535 }
2536 return false;
2537 }
2538
2539 /*
2540 * Hardware-specific functions
2541 */
2542
2543 /*
2544 * DAC960 LA Series Controllers
2545 */
2546
2547 static inline void DAC960_LA_hw_mbox_new_cmd(void __iomem *base)
2548 {
2549 writeb(DAC960_LA_IDB_HWMBOX_NEW_CMD, base + DAC960_LA_IDB_OFFSET);
2550 }
2551
2552 static inline void DAC960_LA_ack_hw_mbox_status(void __iomem *base)
2553 {
2554 writeb(DAC960_LA_IDB_HWMBOX_ACK_STS, base + DAC960_LA_IDB_OFFSET);
2555 }
2556
2557 static inline void DAC960_LA_gen_intr(void __iomem *base)
2558 {
2559 writeb(DAC960_LA_IDB_GEN_IRQ, base + DAC960_LA_IDB_OFFSET);
2560 }
2561
2562 static inline void DAC960_LA_reset_ctrl(void __iomem *base)
2563 {
2564 writeb(DAC960_LA_IDB_CTRL_RESET, base + DAC960_LA_IDB_OFFSET);
2565 }
2566
2567 static inline void DAC960_LA_mem_mbox_new_cmd(void __iomem *base)
2568 {
2569 writeb(DAC960_LA_IDB_MMBOX_NEW_CMD, base + DAC960_LA_IDB_OFFSET);
2570 }
2571
2572 static inline bool DAC960_LA_hw_mbox_is_full(void __iomem *base)
2573 {
2574 unsigned char idb = readb(base + DAC960_LA_IDB_OFFSET);
2575
2576 return !(idb & DAC960_LA_IDB_HWMBOX_EMPTY);
2577 }
2578
2579 static inline bool DAC960_LA_init_in_progress(void __iomem *base)
2580 {
2581 unsigned char idb = readb(base + DAC960_LA_IDB_OFFSET);
2582
2583 return !(idb & DAC960_LA_IDB_INIT_DONE);
2584 }
2585
2586 static inline void DAC960_LA_ack_hw_mbox_intr(void __iomem *base)
2587 {
2588 writeb(DAC960_LA_ODB_HWMBOX_ACK_IRQ, base + DAC960_LA_ODB_OFFSET);
2589 }
2590
2591 static inline void DAC960_LA_ack_mem_mbox_intr(void __iomem *base)
2592 {
2593 writeb(DAC960_LA_ODB_MMBOX_ACK_IRQ, base + DAC960_LA_ODB_OFFSET);
2594 }
2595
2596 static inline void DAC960_LA_ack_intr(void __iomem *base)
2597 {
2598 writeb(DAC960_LA_ODB_HWMBOX_ACK_IRQ | DAC960_LA_ODB_MMBOX_ACK_IRQ,
2599 base + DAC960_LA_ODB_OFFSET);
2600 }
2601
2602 static inline bool DAC960_LA_hw_mbox_status_available(void __iomem *base)
2603 {
2604 unsigned char odb = readb(base + DAC960_LA_ODB_OFFSET);
2605
2606 return odb & DAC960_LA_ODB_HWMBOX_STS_AVAIL;
2607 }
2608
2609 static inline bool DAC960_LA_mem_mbox_status_available(void __iomem *base)
2610 {
2611 unsigned char odb = readb(base + DAC960_LA_ODB_OFFSET);
2612
2613 return odb & DAC960_LA_ODB_MMBOX_STS_AVAIL;
2614 }
2615
2616 static inline void DAC960_LA_enable_intr(void __iomem *base)
2617 {
2618 unsigned char odb = 0xFF;
2619
2620 odb &= ~DAC960_LA_IRQMASK_DISABLE_IRQ;
2621 writeb(odb, base + DAC960_LA_IRQMASK_OFFSET);
2622 }
2623
2624 static inline void DAC960_LA_disable_intr(void __iomem *base)
2625 {
2626 unsigned char odb = 0xFF;
2627
2628 odb |= DAC960_LA_IRQMASK_DISABLE_IRQ;
2629 writeb(odb, base + DAC960_LA_IRQMASK_OFFSET);
2630 }
2631
2632 static inline bool DAC960_LA_intr_enabled(void __iomem *base)
2633 {
2634 unsigned char imask = readb(base + DAC960_LA_IRQMASK_OFFSET);
2635
2636 return !(imask & DAC960_LA_IRQMASK_DISABLE_IRQ);
2637 }
2638
2639 static inline void DAC960_LA_write_cmd_mbox(union myrb_cmd_mbox *mem_mbox,
2640 union myrb_cmd_mbox *mbox)
2641 {
2642 mem_mbox->words[1] = mbox->words[1];
2643 mem_mbox->words[2] = mbox->words[2];
2644 mem_mbox->words[3] = mbox->words[3];
2645 /* Memory barrier to prevent reordering */
2646 wmb();
2647 mem_mbox->words[0] = mbox->words[0];
2648 /* Memory barrier to force PCI access */
2649 mb();
2650 }
2651
2652 static inline void DAC960_LA_write_hw_mbox(void __iomem *base,
2653 union myrb_cmd_mbox *mbox)
2654 {
2655 writel(mbox->words[0], base + DAC960_LA_CMDOP_OFFSET);
2656 writel(mbox->words[1], base + DAC960_LA_MBOX4_OFFSET);
2657 writel(mbox->words[2], base + DAC960_LA_MBOX8_OFFSET);
2658 writeb(mbox->bytes[12], base + DAC960_LA_MBOX12_OFFSET);
2659 }
2660
2661 static inline unsigned char DAC960_LA_read_status_cmd_ident(void __iomem *base)
2662 {
2663 return readb(base + DAC960_LA_STSID_OFFSET);
2664 }
2665
2666 static inline unsigned short DAC960_LA_read_status(void __iomem *base)
2667 {
2668 return readw(base + DAC960_LA_STS_OFFSET);
2669 }
2670
2671 static inline bool
2672 DAC960_LA_read_error_status(void __iomem *base, unsigned char *error,
2673 unsigned char *param0, unsigned char *param1)
2674 {
2675 unsigned char errsts = readb(base + DAC960_LA_ERRSTS_OFFSET);
2676
2677 if (!(errsts & DAC960_LA_ERRSTS_PENDING))
2678 return false;
2679 errsts &= ~DAC960_LA_ERRSTS_PENDING;
2680
2681 *error = errsts;
2682 *param0 = readb(base + DAC960_LA_CMDOP_OFFSET);
2683 *param1 = readb(base + DAC960_LA_CMDID_OFFSET);
2684 writeb(0xFF, base + DAC960_LA_ERRSTS_OFFSET);
2685 return true;
2686 }
2687
2688 static inline unsigned short
2689 DAC960_LA_mbox_init(struct pci_dev *pdev, void __iomem *base,
2690 union myrb_cmd_mbox *mbox)
2691 {
2692 unsigned short status;
2693 int timeout = 0;
2694
2695 while (timeout < MYRB_MAILBOX_TIMEOUT) {
2696 if (!DAC960_LA_hw_mbox_is_full(base))
2697 break;
2698 udelay(10);
2699 timeout++;
2700 }
2701 if (DAC960_LA_hw_mbox_is_full(base)) {
2702 dev_err(&pdev->dev,
2703 "Timeout waiting for empty mailbox\n");
2704 return MYRB_STATUS_SUBSYS_TIMEOUT;
2705 }
2706 DAC960_LA_write_hw_mbox(base, mbox);
2707 DAC960_LA_hw_mbox_new_cmd(base);
2708 timeout = 0;
2709 while (timeout < MYRB_MAILBOX_TIMEOUT) {
2710 if (DAC960_LA_hw_mbox_status_available(base))
2711 break;
2712 udelay(10);
2713 timeout++;
2714 }
2715 if (!DAC960_LA_hw_mbox_status_available(base)) {
2716 dev_err(&pdev->dev, "Timeout waiting for mailbox status\n");
2717 return MYRB_STATUS_SUBSYS_TIMEOUT;
2718 }
2719 status = DAC960_LA_read_status(base);
2720 DAC960_LA_ack_hw_mbox_intr(base);
2721 DAC960_LA_ack_hw_mbox_status(base);
2722
2723 return status;
2724 }
2725
2726 static int DAC960_LA_hw_init(struct pci_dev *pdev,
2727 struct myrb_hba *cb, void __iomem *base)
2728 {
2729 int timeout = 0;
2730 unsigned char error, parm0, parm1;
2731
2732 DAC960_LA_disable_intr(base);
2733 DAC960_LA_ack_hw_mbox_status(base);
2734 udelay(1000);
2735 timeout = 0;
2736 while (DAC960_LA_init_in_progress(base) &&
2737 timeout < MYRB_MAILBOX_TIMEOUT) {
2738 if (DAC960_LA_read_error_status(base, &error,
2739 &parm0, &parm1) &&
2740 myrb_err_status(cb, error, parm0, parm1))
2741 return -ENODEV;
2742 udelay(10);
2743 timeout++;
2744 }
2745 if (timeout == MYRB_MAILBOX_TIMEOUT) {
2746 dev_err(&pdev->dev,
2747 "Timeout waiting for Controller Initialisation\n");
2748 return -ETIMEDOUT;
2749 }
2750 if (!myrb_enable_mmio(cb, DAC960_LA_mbox_init)) {
2751 dev_err(&pdev->dev,
2752 "Unable to Enable Memory Mailbox Interface\n");
2753 DAC960_LA_reset_ctrl(base);
2754 return -ENODEV;
2755 }
2756 DAC960_LA_enable_intr(base);
2757 cb->qcmd = myrb_qcmd;
2758 cb->write_cmd_mbox = DAC960_LA_write_cmd_mbox;
2759 if (cb->dual_mode_interface)
2760 cb->get_cmd_mbox = DAC960_LA_mem_mbox_new_cmd;
2761 else
2762 cb->get_cmd_mbox = DAC960_LA_hw_mbox_new_cmd;
2763 cb->disable_intr = DAC960_LA_disable_intr;
2764 cb->reset = DAC960_LA_reset_ctrl;
2765
2766 return 0;
2767 }
2768
2769 static irqreturn_t DAC960_LA_intr_handler(int irq, void *arg)
2770 {
2771 struct myrb_hba *cb = arg;
2772 void __iomem *base = cb->io_base;
2773 struct myrb_stat_mbox *next_stat_mbox;
2774 unsigned long flags;
2775
2776 spin_lock_irqsave(&cb->queue_lock, flags);
2777 DAC960_LA_ack_intr(base);
2778 next_stat_mbox = cb->next_stat_mbox;
2779 while (next_stat_mbox->valid) {
2780 unsigned char id = next_stat_mbox->id;
2781 struct scsi_cmnd *scmd = NULL;
2782 struct myrb_cmdblk *cmd_blk = NULL;
2783
2784 if (id == MYRB_DCMD_TAG)
2785 cmd_blk = &cb->dcmd_blk;
2786 else if (id == MYRB_MCMD_TAG)
2787 cmd_blk = &cb->mcmd_blk;
2788 else {
2789 scmd = scsi_host_find_tag(cb->host, id - 3);
2790 if (scmd)
2791 cmd_blk = scsi_cmd_priv(scmd);
2792 }
2793 if (cmd_blk)
2794 cmd_blk->status = next_stat_mbox->status;
2795 else
2796 dev_err(&cb->pdev->dev,
2797 "Unhandled command completion %d\n", id);
2798
2799 memset(next_stat_mbox, 0, sizeof(struct myrb_stat_mbox));
2800 if (++next_stat_mbox > cb->last_stat_mbox)
2801 next_stat_mbox = cb->first_stat_mbox;
2802
2803 if (cmd_blk) {
2804 if (id < 3)
2805 myrb_handle_cmdblk(cb, cmd_blk);
2806 else
2807 myrb_handle_scsi(cb, cmd_blk, scmd);
2808 }
2809 }
2810 cb->next_stat_mbox = next_stat_mbox;
2811 spin_unlock_irqrestore(&cb->queue_lock, flags);
2812 return IRQ_HANDLED;
2813 }
2814
2815 struct myrb_privdata DAC960_LA_privdata = {
2816 .hw_init = DAC960_LA_hw_init,
2817 .irq_handler = DAC960_LA_intr_handler,
2818 .mmio_size = DAC960_LA_mmio_size,
2819 };
2820
2821 /*
2822 * DAC960 PG Series Controllers
2823 */
2824 static inline void DAC960_PG_hw_mbox_new_cmd(void __iomem *base)
2825 {
2826 writel(DAC960_PG_IDB_HWMBOX_NEW_CMD, base + DAC960_PG_IDB_OFFSET);
2827 }
2828
2829 static inline void DAC960_PG_ack_hw_mbox_status(void __iomem *base)
2830 {
2831 writel(DAC960_PG_IDB_HWMBOX_ACK_STS, base + DAC960_PG_IDB_OFFSET);
2832 }
2833
2834 static inline void DAC960_PG_gen_intr(void __iomem *base)
2835 {
2836 writel(DAC960_PG_IDB_GEN_IRQ, base + DAC960_PG_IDB_OFFSET);
2837 }
2838
2839 static inline void DAC960_PG_reset_ctrl(void __iomem *base)
2840 {
2841 writel(DAC960_PG_IDB_CTRL_RESET, base + DAC960_PG_IDB_OFFSET);
2842 }
2843
2844 static inline void DAC960_PG_mem_mbox_new_cmd(void __iomem *base)
2845 {
2846 writel(DAC960_PG_IDB_MMBOX_NEW_CMD, base + DAC960_PG_IDB_OFFSET);
2847 }
2848
2849 static inline bool DAC960_PG_hw_mbox_is_full(void __iomem *base)
2850 {
2851 unsigned char idb = readl(base + DAC960_PG_IDB_OFFSET);
2852
2853 return idb & DAC960_PG_IDB_HWMBOX_FULL;
2854 }
2855
2856 static inline bool DAC960_PG_init_in_progress(void __iomem *base)
2857 {
2858 unsigned char idb = readl(base + DAC960_PG_IDB_OFFSET);
2859
2860 return idb & DAC960_PG_IDB_INIT_IN_PROGRESS;
2861 }
2862
2863 static inline void DAC960_PG_ack_hw_mbox_intr(void __iomem *base)
2864 {
2865 writel(DAC960_PG_ODB_HWMBOX_ACK_IRQ, base + DAC960_PG_ODB_OFFSET);
2866 }
2867
2868 static inline void DAC960_PG_ack_mem_mbox_intr(void __iomem *base)
2869 {
2870 writel(DAC960_PG_ODB_MMBOX_ACK_IRQ, base + DAC960_PG_ODB_OFFSET);
2871 }
2872
2873 static inline void DAC960_PG_ack_intr(void __iomem *base)
2874 {
2875 writel(DAC960_PG_ODB_HWMBOX_ACK_IRQ | DAC960_PG_ODB_MMBOX_ACK_IRQ,
2876 base + DAC960_PG_ODB_OFFSET);
2877 }
2878
2879 static inline bool DAC960_PG_hw_mbox_status_available(void __iomem *base)
2880 {
2881 unsigned char odb = readl(base + DAC960_PG_ODB_OFFSET);
2882
2883 return odb & DAC960_PG_ODB_HWMBOX_STS_AVAIL;
2884 }
2885
2886 static inline bool DAC960_PG_mem_mbox_status_available(void __iomem *base)
2887 {
2888 unsigned char odb = readl(base + DAC960_PG_ODB_OFFSET);
2889
2890 return odb & DAC960_PG_ODB_MMBOX_STS_AVAIL;
2891 }
2892
2893 static inline void DAC960_PG_enable_intr(void __iomem *base)
2894 {
2895 unsigned int imask = (unsigned int)-1;
2896
2897 imask &= ~DAC960_PG_IRQMASK_DISABLE_IRQ;
2898 writel(imask, base + DAC960_PG_IRQMASK_OFFSET);
2899 }
2900
2901 static inline void DAC960_PG_disable_intr(void __iomem *base)
2902 {
2903 unsigned int imask = (unsigned int)-1;
2904
2905 writel(imask, base + DAC960_PG_IRQMASK_OFFSET);
2906 }
2907
2908 static inline bool DAC960_PG_intr_enabled(void __iomem *base)
2909 {
2910 unsigned int imask = readl(base + DAC960_PG_IRQMASK_OFFSET);
2911
2912 return !(imask & DAC960_PG_IRQMASK_DISABLE_IRQ);
2913 }
2914
2915 static inline void DAC960_PG_write_cmd_mbox(union myrb_cmd_mbox *mem_mbox,
2916 union myrb_cmd_mbox *mbox)
2917 {
2918 mem_mbox->words[1] = mbox->words[1];
2919 mem_mbox->words[2] = mbox->words[2];
2920 mem_mbox->words[3] = mbox->words[3];
2921 /* Memory barrier to prevent reordering */
2922 wmb();
2923 mem_mbox->words[0] = mbox->words[0];
2924 /* Memory barrier to force PCI access */
2925 mb();
2926 }
2927
2928 static inline void DAC960_PG_write_hw_mbox(void __iomem *base,
2929 union myrb_cmd_mbox *mbox)
2930 {
2931 writel(mbox->words[0], base + DAC960_PG_CMDOP_OFFSET);
2932 writel(mbox->words[1], base + DAC960_PG_MBOX4_OFFSET);
2933 writel(mbox->words[2], base + DAC960_PG_MBOX8_OFFSET);
2934 writeb(mbox->bytes[12], base + DAC960_PG_MBOX12_OFFSET);
2935 }
2936
2937 static inline unsigned char
2938 DAC960_PG_read_status_cmd_ident(void __iomem *base)
2939 {
2940 return readb(base + DAC960_PG_STSID_OFFSET);
2941 }
2942
2943 static inline unsigned short
2944 DAC960_PG_read_status(void __iomem *base)
2945 {
2946 return readw(base + DAC960_PG_STS_OFFSET);
2947 }
2948
2949 static inline bool
2950 DAC960_PG_read_error_status(void __iomem *base, unsigned char *error,
2951 unsigned char *param0, unsigned char *param1)
2952 {
2953 unsigned char errsts = readb(base + DAC960_PG_ERRSTS_OFFSET);
2954
2955 if (!(errsts & DAC960_PG_ERRSTS_PENDING))
2956 return false;
2957 errsts &= ~DAC960_PG_ERRSTS_PENDING;
2958 *error = errsts;
2959 *param0 = readb(base + DAC960_PG_CMDOP_OFFSET);
2960 *param1 = readb(base + DAC960_PG_CMDID_OFFSET);
2961 writeb(0, base + DAC960_PG_ERRSTS_OFFSET);
2962 return true;
2963 }
2964
2965 static inline unsigned short
2966 DAC960_PG_mbox_init(struct pci_dev *pdev, void __iomem *base,
2967 union myrb_cmd_mbox *mbox)
2968 {
2969 unsigned short status;
2970 int timeout = 0;
2971
2972 while (timeout < MYRB_MAILBOX_TIMEOUT) {
2973 if (!DAC960_PG_hw_mbox_is_full(base))
2974 break;
2975 udelay(10);
2976 timeout++;
2977 }
2978 if (DAC960_PG_hw_mbox_is_full(base)) {
2979 dev_err(&pdev->dev,
2980 "Timeout waiting for empty mailbox\n");
2981 return MYRB_STATUS_SUBSYS_TIMEOUT;
2982 }
2983 DAC960_PG_write_hw_mbox(base, mbox);
2984 DAC960_PG_hw_mbox_new_cmd(base);
2985
2986 timeout = 0;
2987 while (timeout < MYRB_MAILBOX_TIMEOUT) {
2988 if (DAC960_PG_hw_mbox_status_available(base))
2989 break;
2990 udelay(10);
2991 timeout++;
2992 }
2993 if (!DAC960_PG_hw_mbox_status_available(base)) {
2994 dev_err(&pdev->dev,
2995 "Timeout waiting for mailbox status\n");
2996 return MYRB_STATUS_SUBSYS_TIMEOUT;
2997 }
2998 status = DAC960_PG_read_status(base);
2999 DAC960_PG_ack_hw_mbox_intr(base);
3000 DAC960_PG_ack_hw_mbox_status(base);
3001
3002 return status;
3003 }
3004
3005 static int DAC960_PG_hw_init(struct pci_dev *pdev,
3006 struct myrb_hba *cb, void __iomem *base)
3007 {
3008 int timeout = 0;
3009 unsigned char error, parm0, parm1;
3010
3011 DAC960_PG_disable_intr(base);
3012 DAC960_PG_ack_hw_mbox_status(base);
3013 udelay(1000);
3014 while (DAC960_PG_init_in_progress(base) &&
3015 timeout < MYRB_MAILBOX_TIMEOUT) {
3016 if (DAC960_PG_read_error_status(base, &error,
3017 &parm0, &parm1) &&
3018 myrb_err_status(cb, error, parm0, parm1))
3019 return -EIO;
3020 udelay(10);
3021 timeout++;
3022 }
3023 if (timeout == MYRB_MAILBOX_TIMEOUT) {
3024 dev_err(&pdev->dev,
3025 "Timeout waiting for Controller Initialisation\n");
3026 return -ETIMEDOUT;
3027 }
3028 if (!myrb_enable_mmio(cb, DAC960_PG_mbox_init)) {
3029 dev_err(&pdev->dev,
3030 "Unable to Enable Memory Mailbox Interface\n");
3031 DAC960_PG_reset_ctrl(base);
3032 return -ENODEV;
3033 }
3034 DAC960_PG_enable_intr(base);
3035 cb->qcmd = myrb_qcmd;
3036 cb->write_cmd_mbox = DAC960_PG_write_cmd_mbox;
3037 if (cb->dual_mode_interface)
3038 cb->get_cmd_mbox = DAC960_PG_mem_mbox_new_cmd;
3039 else
3040 cb->get_cmd_mbox = DAC960_PG_hw_mbox_new_cmd;
3041 cb->disable_intr = DAC960_PG_disable_intr;
3042 cb->reset = DAC960_PG_reset_ctrl;
3043
3044 return 0;
3045 }
3046
3047 static irqreturn_t DAC960_PG_intr_handler(int irq, void *arg)
3048 {
3049 struct myrb_hba *cb = arg;
3050 void __iomem *base = cb->io_base;
3051 struct myrb_stat_mbox *next_stat_mbox;
3052 unsigned long flags;
3053
3054 spin_lock_irqsave(&cb->queue_lock, flags);
3055 DAC960_PG_ack_intr(base);
3056 next_stat_mbox = cb->next_stat_mbox;
3057 while (next_stat_mbox->valid) {
3058 unsigned char id = next_stat_mbox->id;
3059 struct scsi_cmnd *scmd = NULL;
3060 struct myrb_cmdblk *cmd_blk = NULL;
3061
3062 if (id == MYRB_DCMD_TAG)
3063 cmd_blk = &cb->dcmd_blk;
3064 else if (id == MYRB_MCMD_TAG)
3065 cmd_blk = &cb->mcmd_blk;
3066 else {
3067 scmd = scsi_host_find_tag(cb->host, id - 3);
3068 if (scmd)
3069 cmd_blk = scsi_cmd_priv(scmd);
3070 }
3071 if (cmd_blk)
3072 cmd_blk->status = next_stat_mbox->status;
3073 else
3074 dev_err(&cb->pdev->dev,
3075 "Unhandled command completion %d\n", id);
3076
3077 memset(next_stat_mbox, 0, sizeof(struct myrb_stat_mbox));
3078 if (++next_stat_mbox > cb->last_stat_mbox)
3079 next_stat_mbox = cb->first_stat_mbox;
3080
3081 if (id < 3)
3082 myrb_handle_cmdblk(cb, cmd_blk);
3083 else
3084 myrb_handle_scsi(cb, cmd_blk, scmd);
3085 }
3086 cb->next_stat_mbox = next_stat_mbox;
3087 spin_unlock_irqrestore(&cb->queue_lock, flags);
3088 return IRQ_HANDLED;
3089 }
3090
3091 struct myrb_privdata DAC960_PG_privdata = {
3092 .hw_init = DAC960_PG_hw_init,
3093 .irq_handler = DAC960_PG_intr_handler,
3094 .mmio_size = DAC960_PG_mmio_size,
3095 };
3096
3097
3098 /*
3099 * DAC960 PD Series Controllers
3100 */
3101
3102 static inline void DAC960_PD_hw_mbox_new_cmd(void __iomem *base)
3103 {
3104 writeb(DAC960_PD_IDB_HWMBOX_NEW_CMD, base + DAC960_PD_IDB_OFFSET);
3105 }
3106
3107 static inline void DAC960_PD_ack_hw_mbox_status(void __iomem *base)
3108 {
3109 writeb(DAC960_PD_IDB_HWMBOX_ACK_STS, base + DAC960_PD_IDB_OFFSET);
3110 }
3111
3112 static inline void DAC960_PD_gen_intr(void __iomem *base)
3113 {
3114 writeb(DAC960_PD_IDB_GEN_IRQ, base + DAC960_PD_IDB_OFFSET);
3115 }
3116
3117 static inline void DAC960_PD_reset_ctrl(void __iomem *base)
3118 {
3119 writeb(DAC960_PD_IDB_CTRL_RESET, base + DAC960_PD_IDB_OFFSET);
3120 }
3121
3122 static inline bool DAC960_PD_hw_mbox_is_full(void __iomem *base)
3123 {
3124 unsigned char idb = readb(base + DAC960_PD_IDB_OFFSET);
3125
3126 return idb & DAC960_PD_IDB_HWMBOX_FULL;
3127 }
3128
3129 static inline bool DAC960_PD_init_in_progress(void __iomem *base)
3130 {
3131 unsigned char idb = readb(base + DAC960_PD_IDB_OFFSET);
3132
3133 return idb & DAC960_PD_IDB_INIT_IN_PROGRESS;
3134 }
3135
3136 static inline void DAC960_PD_ack_intr(void __iomem *base)
3137 {
3138 writeb(DAC960_PD_ODB_HWMBOX_ACK_IRQ, base + DAC960_PD_ODB_OFFSET);
3139 }
3140
3141 static inline bool DAC960_PD_hw_mbox_status_available(void __iomem *base)
3142 {
3143 unsigned char odb = readb(base + DAC960_PD_ODB_OFFSET);
3144
3145 return odb & DAC960_PD_ODB_HWMBOX_STS_AVAIL;
3146 }
3147
3148 static inline void DAC960_PD_enable_intr(void __iomem *base)
3149 {
3150 writeb(DAC960_PD_IRQMASK_ENABLE_IRQ, base + DAC960_PD_IRQEN_OFFSET);
3151 }
3152
3153 static inline void DAC960_PD_disable_intr(void __iomem *base)
3154 {
3155 writeb(0, base + DAC960_PD_IRQEN_OFFSET);
3156 }
3157
3158 static inline bool DAC960_PD_intr_enabled(void __iomem *base)
3159 {
3160 unsigned char imask = readb(base + DAC960_PD_IRQEN_OFFSET);
3161
3162 return imask & DAC960_PD_IRQMASK_ENABLE_IRQ;
3163 }
3164
3165 static inline void DAC960_PD_write_cmd_mbox(void __iomem *base,
3166 union myrb_cmd_mbox *mbox)
3167 {
3168 writel(mbox->words[0], base + DAC960_PD_CMDOP_OFFSET);
3169 writel(mbox->words[1], base + DAC960_PD_MBOX4_OFFSET);
3170 writel(mbox->words[2], base + DAC960_PD_MBOX8_OFFSET);
3171 writeb(mbox->bytes[12], base + DAC960_PD_MBOX12_OFFSET);
3172 }
3173
3174 static inline unsigned char
3175 DAC960_PD_read_status_cmd_ident(void __iomem *base)
3176 {
3177 return readb(base + DAC960_PD_STSID_OFFSET);
3178 }
3179
3180 static inline unsigned short
3181 DAC960_PD_read_status(void __iomem *base)
3182 {
3183 return readw(base + DAC960_PD_STS_OFFSET);
3184 }
3185
3186 static inline bool
3187 DAC960_PD_read_error_status(void __iomem *base, unsigned char *error,
3188 unsigned char *param0, unsigned char *param1)
3189 {
3190 unsigned char errsts = readb(base + DAC960_PD_ERRSTS_OFFSET);
3191
3192 if (!(errsts & DAC960_PD_ERRSTS_PENDING))
3193 return false;
3194 errsts &= ~DAC960_PD_ERRSTS_PENDING;
3195 *error = errsts;
3196 *param0 = readb(base + DAC960_PD_CMDOP_OFFSET);
3197 *param1 = readb(base + DAC960_PD_CMDID_OFFSET);
3198 writeb(0, base + DAC960_PD_ERRSTS_OFFSET);
3199 return true;
3200 }
3201
3202 static void DAC960_PD_qcmd(struct myrb_hba *cb, struct myrb_cmdblk *cmd_blk)
3203 {
3204 void __iomem *base = cb->io_base;
3205 union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
3206
3207 while (DAC960_PD_hw_mbox_is_full(base))
3208 udelay(1);
3209 DAC960_PD_write_cmd_mbox(base, mbox);
3210 DAC960_PD_hw_mbox_new_cmd(base);
3211 }
3212
3213 static int DAC960_PD_hw_init(struct pci_dev *pdev,
3214 struct myrb_hba *cb, void __iomem *base)
3215 {
3216 int timeout = 0;
3217 unsigned char error, parm0, parm1;
3218
3219 if (!request_region(cb->io_addr, 0x80, "myrb")) {
3220 dev_err(&pdev->dev, "IO port 0x%lx busy\n",
3221 (unsigned long)cb->io_addr);
3222 return -EBUSY;
3223 }
3224 DAC960_PD_disable_intr(base);
3225 DAC960_PD_ack_hw_mbox_status(base);
3226 udelay(1000);
3227 while (DAC960_PD_init_in_progress(base) &&
3228 timeout < MYRB_MAILBOX_TIMEOUT) {
3229 if (DAC960_PD_read_error_status(base, &error,
3230 &parm0, &parm1) &&
3231 myrb_err_status(cb, error, parm0, parm1))
3232 return -EIO;
3233 udelay(10);
3234 timeout++;
3235 }
3236 if (timeout == MYRB_MAILBOX_TIMEOUT) {
3237 dev_err(&pdev->dev,
3238 "Timeout waiting for Controller Initialisation\n");
3239 return -ETIMEDOUT;
3240 }
3241 if (!myrb_enable_mmio(cb, NULL)) {
3242 dev_err(&pdev->dev,
3243 "Unable to Enable Memory Mailbox Interface\n");
3244 DAC960_PD_reset_ctrl(base);
3245 return -ENODEV;
3246 }
3247 DAC960_PD_enable_intr(base);
3248 cb->qcmd = DAC960_PD_qcmd;
3249 cb->disable_intr = DAC960_PD_disable_intr;
3250 cb->reset = DAC960_PD_reset_ctrl;
3251
3252 return 0;
3253 }
3254
3255 static irqreturn_t DAC960_PD_intr_handler(int irq, void *arg)
3256 {
3257 struct myrb_hba *cb = arg;
3258 void __iomem *base = cb->io_base;
3259 unsigned long flags;
3260
3261 spin_lock_irqsave(&cb->queue_lock, flags);
3262 while (DAC960_PD_hw_mbox_status_available(base)) {
3263 unsigned char id = DAC960_PD_read_status_cmd_ident(base);
3264 struct scsi_cmnd *scmd = NULL;
3265 struct myrb_cmdblk *cmd_blk = NULL;
3266
3267 if (id == MYRB_DCMD_TAG)
3268 cmd_blk = &cb->dcmd_blk;
3269 else if (id == MYRB_MCMD_TAG)
3270 cmd_blk = &cb->mcmd_blk;
3271 else {
3272 scmd = scsi_host_find_tag(cb->host, id - 3);
3273 if (scmd)
3274 cmd_blk = scsi_cmd_priv(scmd);
3275 }
3276 if (cmd_blk)
3277 cmd_blk->status = DAC960_PD_read_status(base);
3278 else
3279 dev_err(&cb->pdev->dev,
3280 "Unhandled command completion %d\n", id);
3281
3282 DAC960_PD_ack_intr(base);
3283 DAC960_PD_ack_hw_mbox_status(base);
3284
3285 if (id < 3)
3286 myrb_handle_cmdblk(cb, cmd_blk);
3287 else
3288 myrb_handle_scsi(cb, cmd_blk, scmd);
3289 }
3290 spin_unlock_irqrestore(&cb->queue_lock, flags);
3291 return IRQ_HANDLED;
3292 }
3293
3294 struct myrb_privdata DAC960_PD_privdata = {
3295 .hw_init = DAC960_PD_hw_init,
3296 .irq_handler = DAC960_PD_intr_handler,
3297 .mmio_size = DAC960_PD_mmio_size,
3298 };
3299
3300
3301 /*
3302 * DAC960 P Series Controllers
3303 *
3304 * Similar to the DAC960 PD Series Controllers, but some commands have
3305 * to be translated.
3306 */
3307
3308 static inline void myrb_translate_enquiry(void *enq)
3309 {
3310 memcpy(enq + 132, enq + 36, 64);
3311 memset(enq + 36, 0, 96);
3312 }
3313
3314 static inline void myrb_translate_devstate(void *state)
3315 {
3316 memcpy(state + 2, state + 3, 1);
3317 memmove(state + 4, state + 5, 2);
3318 memmove(state + 6, state + 8, 4);
3319 }
3320
3321 static inline void myrb_translate_to_rw_command(struct myrb_cmdblk *cmd_blk)
3322 {
3323 union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
3324 int ldev_num = mbox->type5.ld.ldev_num;
3325
3326 mbox->bytes[3] &= 0x7;
3327 mbox->bytes[3] |= mbox->bytes[7] << 6;
3328 mbox->bytes[7] = ldev_num;
3329 }
3330
3331 static inline void myrb_translate_from_rw_command(struct myrb_cmdblk *cmd_blk)
3332 {
3333 union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
3334 int ldev_num = mbox->bytes[7];
3335
3336 mbox->bytes[7] = mbox->bytes[3] >> 6;
3337 mbox->bytes[3] &= 0x7;
3338 mbox->bytes[3] |= ldev_num << 3;
3339 }
3340
3341 static void DAC960_P_qcmd(struct myrb_hba *cb, struct myrb_cmdblk *cmd_blk)
3342 {
3343 void __iomem *base = cb->io_base;
3344 union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
3345
3346 switch (mbox->common.opcode) {
3347 case MYRB_CMD_ENQUIRY:
3348 mbox->common.opcode = MYRB_CMD_ENQUIRY_OLD;
3349 break;
3350 case MYRB_CMD_GET_DEVICE_STATE:
3351 mbox->common.opcode = MYRB_CMD_GET_DEVICE_STATE_OLD;
3352 break;
3353 case MYRB_CMD_READ:
3354 mbox->common.opcode = MYRB_CMD_READ_OLD;
3355 myrb_translate_to_rw_command(cmd_blk);
3356 break;
3357 case MYRB_CMD_WRITE:
3358 mbox->common.opcode = MYRB_CMD_WRITE_OLD;
3359 myrb_translate_to_rw_command(cmd_blk);
3360 break;
3361 case MYRB_CMD_READ_SG:
3362 mbox->common.opcode = MYRB_CMD_READ_SG_OLD;
3363 myrb_translate_to_rw_command(cmd_blk);
3364 break;
3365 case MYRB_CMD_WRITE_SG:
3366 mbox->common.opcode = MYRB_CMD_WRITE_SG_OLD;
3367 myrb_translate_to_rw_command(cmd_blk);
3368 break;
3369 default:
3370 break;
3371 }
3372 while (DAC960_PD_hw_mbox_is_full(base))
3373 udelay(1);
3374 DAC960_PD_write_cmd_mbox(base, mbox);
3375 DAC960_PD_hw_mbox_new_cmd(base);
3376 }
3377
3378
3379 static int DAC960_P_hw_init(struct pci_dev *pdev,
3380 struct myrb_hba *cb, void __iomem *base)
3381 {
3382 int timeout = 0;
3383 unsigned char error, parm0, parm1;
3384
3385 if (!request_region(cb->io_addr, 0x80, "myrb")) {
3386 dev_err(&pdev->dev, "IO port 0x%lx busy\n",
3387 (unsigned long)cb->io_addr);
3388 return -EBUSY;
3389 }
3390 DAC960_PD_disable_intr(base);
3391 DAC960_PD_ack_hw_mbox_status(base);
3392 udelay(1000);
3393 while (DAC960_PD_init_in_progress(base) &&
3394 timeout < MYRB_MAILBOX_TIMEOUT) {
3395 if (DAC960_PD_read_error_status(base, &error,
3396 &parm0, &parm1) &&
3397 myrb_err_status(cb, error, parm0, parm1))
3398 return -EAGAIN;
3399 udelay(10);
3400 timeout++;
3401 }
3402 if (timeout == MYRB_MAILBOX_TIMEOUT) {
3403 dev_err(&pdev->dev,
3404 "Timeout waiting for Controller Initialisation\n");
3405 return -ETIMEDOUT;
3406 }
3407 if (!myrb_enable_mmio(cb, NULL)) {
3408 dev_err(&pdev->dev,
3409 "Unable to allocate DMA mapped memory\n");
3410 DAC960_PD_reset_ctrl(base);
3411 return -ETIMEDOUT;
3412 }
3413 DAC960_PD_enable_intr(base);
3414 cb->qcmd = DAC960_P_qcmd;
3415 cb->disable_intr = DAC960_PD_disable_intr;
3416 cb->reset = DAC960_PD_reset_ctrl;
3417
3418 return 0;
3419 }
3420
3421 static irqreturn_t DAC960_P_intr_handler(int irq, void *arg)
3422 {
3423 struct myrb_hba *cb = arg;
3424 void __iomem *base = cb->io_base;
3425 unsigned long flags;
3426
3427 spin_lock_irqsave(&cb->queue_lock, flags);
3428 while (DAC960_PD_hw_mbox_status_available(base)) {
3429 unsigned char id = DAC960_PD_read_status_cmd_ident(base);
3430 struct scsi_cmnd *scmd = NULL;
3431 struct myrb_cmdblk *cmd_blk = NULL;
3432 union myrb_cmd_mbox *mbox;
3433 enum myrb_cmd_opcode op;
3434
3435
3436 if (id == MYRB_DCMD_TAG)
3437 cmd_blk = &cb->dcmd_blk;
3438 else if (id == MYRB_MCMD_TAG)
3439 cmd_blk = &cb->mcmd_blk;
3440 else {
3441 scmd = scsi_host_find_tag(cb->host, id - 3);
3442 if (scmd)
3443 cmd_blk = scsi_cmd_priv(scmd);
3444 }
3445 if (cmd_blk)
3446 cmd_blk->status = DAC960_PD_read_status(base);
3447 else
3448 dev_err(&cb->pdev->dev,
3449 "Unhandled command completion %d\n", id);
3450
3451 DAC960_PD_ack_intr(base);
3452 DAC960_PD_ack_hw_mbox_status(base);
3453
3454 if (!cmd_blk)
3455 continue;
3456
3457 mbox = &cmd_blk->mbox;
3458 op = mbox->common.opcode;
3459 switch (op) {
3460 case MYRB_CMD_ENQUIRY_OLD:
3461 mbox->common.opcode = MYRB_CMD_ENQUIRY;
3462 myrb_translate_enquiry(cb->enquiry);
3463 break;
3464 case MYRB_CMD_READ_OLD:
3465 mbox->common.opcode = MYRB_CMD_READ;
3466 myrb_translate_from_rw_command(cmd_blk);
3467 break;
3468 case MYRB_CMD_WRITE_OLD:
3469 mbox->common.opcode = MYRB_CMD_WRITE;
3470 myrb_translate_from_rw_command(cmd_blk);
3471 break;
3472 case MYRB_CMD_READ_SG_OLD:
3473 mbox->common.opcode = MYRB_CMD_READ_SG;
3474 myrb_translate_from_rw_command(cmd_blk);
3475 break;
3476 case MYRB_CMD_WRITE_SG_OLD:
3477 mbox->common.opcode = MYRB_CMD_WRITE_SG;
3478 myrb_translate_from_rw_command(cmd_blk);
3479 break;
3480 default:
3481 break;
3482 }
3483 if (id < 3)
3484 myrb_handle_cmdblk(cb, cmd_blk);
3485 else
3486 myrb_handle_scsi(cb, cmd_blk, scmd);
3487 }
3488 spin_unlock_irqrestore(&cb->queue_lock, flags);
3489 return IRQ_HANDLED;
3490 }
3491
3492 struct myrb_privdata DAC960_P_privdata = {
3493 .hw_init = DAC960_P_hw_init,
3494 .irq_handler = DAC960_P_intr_handler,
3495 .mmio_size = DAC960_PD_mmio_size,
3496 };
3497
3498 static struct myrb_hba *myrb_detect(struct pci_dev *pdev,
3499 const struct pci_device_id *entry)
3500 {
3501 struct myrb_privdata *privdata =
3502 (struct myrb_privdata *)entry->driver_data;
3503 irq_handler_t irq_handler = privdata->irq_handler;
3504 unsigned int mmio_size = privdata->mmio_size;
3505 struct Scsi_Host *shost;
3506 struct myrb_hba *cb = NULL;
3507
3508 shost = scsi_host_alloc(&myrb_template, sizeof(struct myrb_hba));
3509 if (!shost) {
3510 dev_err(&pdev->dev, "Unable to allocate Controller\n");
3511 return NULL;
3512 }
3513 shost->max_cmd_len = 12;
3514 shost->max_lun = 256;
3515 cb = shost_priv(shost);
3516 mutex_init(&cb->dcmd_mutex);
3517 mutex_init(&cb->dma_mutex);
3518 cb->pdev = pdev;
3519
3520 if (pci_enable_device(pdev))
3521 goto failure;
3522
3523 if (privdata->hw_init == DAC960_PD_hw_init ||
3524 privdata->hw_init == DAC960_P_hw_init) {
3525 cb->io_addr = pci_resource_start(pdev, 0);
3526 cb->pci_addr = pci_resource_start(pdev, 1);
3527 } else
3528 cb->pci_addr = pci_resource_start(pdev, 0);
3529
3530 pci_set_drvdata(pdev, cb);
3531 spin_lock_init(&cb->queue_lock);
3532 if (mmio_size < PAGE_SIZE)
3533 mmio_size = PAGE_SIZE;
3534 cb->mmio_base = ioremap(cb->pci_addr & PAGE_MASK, mmio_size);
3535 if (cb->mmio_base == NULL) {
3536 dev_err(&pdev->dev,
3537 "Unable to map Controller Register Window\n");
3538 goto failure;
3539 }
3540
3541 cb->io_base = cb->mmio_base + (cb->pci_addr & ~PAGE_MASK);
3542 if (privdata->hw_init(pdev, cb, cb->io_base))
3543 goto failure;
3544
3545 if (request_irq(pdev->irq, irq_handler, IRQF_SHARED, "myrb", cb) < 0) {
3546 dev_err(&pdev->dev,
3547 "Unable to acquire IRQ Channel %d\n", pdev->irq);
3548 goto failure;
3549 }
3550 cb->irq = pdev->irq;
3551 return cb;
3552
3553 failure:
3554 dev_err(&pdev->dev,
3555 "Failed to initialize Controller\n");
3556 myrb_cleanup(cb);
3557 return NULL;
3558 }
3559
3560 static int myrb_probe(struct pci_dev *dev, const struct pci_device_id *entry)
3561 {
3562 struct myrb_hba *cb;
3563 int ret;
3564
3565 cb = myrb_detect(dev, entry);
3566 if (!cb)
3567 return -ENODEV;
3568
3569 ret = myrb_get_hba_config(cb);
3570 if (ret < 0) {
3571 myrb_cleanup(cb);
3572 return ret;
3573 }
3574
3575 if (!myrb_create_mempools(dev, cb)) {
3576 ret = -ENOMEM;
3577 goto failed;
3578 }
3579
3580 ret = scsi_add_host(cb->host, &dev->dev);
3581 if (ret) {
3582 dev_err(&dev->dev, "scsi_add_host failed with %d\n", ret);
3583 myrb_destroy_mempools(cb);
3584 goto failed;
3585 }
3586 scsi_scan_host(cb->host);
3587 return 0;
3588 failed:
3589 myrb_cleanup(cb);
3590 return ret;
3591 }
3592
3593
3594 static void myrb_remove(struct pci_dev *pdev)
3595 {
3596 struct myrb_hba *cb = pci_get_drvdata(pdev);
3597
3598 shost_printk(KERN_NOTICE, cb->host, "Flushing Cache...");
3599 myrb_exec_type3(cb, MYRB_CMD_FLUSH, 0);
3600 myrb_cleanup(cb);
3601 myrb_destroy_mempools(cb);
3602 }
3603
3604
3605 static const struct pci_device_id myrb_id_table[] = {
3606 {
3607 PCI_DEVICE_SUB(PCI_VENDOR_ID_DEC,
3608 PCI_DEVICE_ID_DEC_21285,
3609 PCI_VENDOR_ID_MYLEX,
3610 PCI_DEVICE_ID_MYLEX_DAC960_LA),
3611 .driver_data = (unsigned long) &DAC960_LA_privdata,
3612 },
3613 {
3614 PCI_DEVICE_DATA(MYLEX, DAC960_PG, &DAC960_PG_privdata),
3615 },
3616 {
3617 PCI_DEVICE_DATA(MYLEX, DAC960_PD, &DAC960_PD_privdata),
3618 },
3619 {
3620 PCI_DEVICE_DATA(MYLEX, DAC960_P, &DAC960_P_privdata),
3621 },
3622 {0, },
3623 };
3624
3625 MODULE_DEVICE_TABLE(pci, myrb_id_table);
3626
3627 static struct pci_driver myrb_pci_driver = {
3628 .name = "myrb",
3629 .id_table = myrb_id_table,
3630 .probe = myrb_probe,
3631 .remove = myrb_remove,
3632 };
3633
3634 static int __init myrb_init_module(void)
3635 {
3636 int ret;
3637
3638 myrb_raid_template = raid_class_attach(&myrb_raid_functions);
3639 if (!myrb_raid_template)
3640 return -ENODEV;
3641
3642 ret = pci_register_driver(&myrb_pci_driver);
3643 if (ret)
3644 raid_class_release(myrb_raid_template);
3645
3646 return ret;
3647 }
3648
3649 static void __exit myrb_cleanup_module(void)
3650 {
3651 pci_unregister_driver(&myrb_pci_driver);
3652 raid_class_release(myrb_raid_template);
3653 }
3654
3655 module_init(myrb_init_module);
3656 module_exit(myrb_cleanup_module);
3657
3658 MODULE_DESCRIPTION("Mylex DAC960/AcceleRAID/eXtremeRAID driver (Block interface)");
3659 MODULE_AUTHOR("Hannes Reinecke <hare@suse.com>");
3660 MODULE_LICENSE("GPL");
Linux with added FPC-III support