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