1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *
4  *			Linux MegaRAID device driver
5  *
6  * Copyright (c) 2003-2004  LSI Logic Corporation.
7  *
8  * FILE		: megaraid_mbox.c
9  * Version	: v2.20.5.1 (Nov 16 2006)
10  *
11  * Authors:
12  * 	Atul Mukker		<Atul.Mukker@lsi.com>
13  * 	Sreenivas Bagalkote	<Sreenivas.Bagalkote@lsi.com>
14  * 	Manoj Jose		<Manoj.Jose@lsi.com>
15  * 	Seokmann Ju
16  *
17  * List of supported controllers
18  *
19  * OEM	Product Name			VID	DID	SSVID	SSID
20  * ---	------------			---	---	----	----
21  * Dell PERC3/QC			101E	1960	1028	0471
22  * Dell PERC3/DC			101E	1960	1028	0493
23  * Dell PERC3/SC			101E	1960	1028	0475
24  * Dell PERC3/Di			1028	1960	1028	0123
25  * Dell PERC4/SC			1000	1960	1028	0520
26  * Dell PERC4/DC			1000	1960	1028	0518
27  * Dell PERC4/QC			1000	0407	1028	0531
28  * Dell PERC4/Di			1028	000F	1028	014A
29  * Dell PERC 4e/Si			1028	0013	1028	016c
30  * Dell PERC 4e/Di			1028	0013	1028	016d
31  * Dell PERC 4e/Di			1028	0013	1028	016e
32  * Dell PERC 4e/Di			1028	0013	1028	016f
33  * Dell PERC 4e/Di			1028	0013	1028	0170
34  * Dell PERC 4e/DC			1000	0408	1028	0002
35  * Dell PERC 4e/SC			1000	0408	1028	0001
36  *
37  * LSI MegaRAID SCSI 320-0		1000	1960	1000	A520
38  * LSI MegaRAID SCSI 320-1		1000	1960	1000	0520
39  * LSI MegaRAID SCSI 320-2		1000	1960	1000	0518
40  * LSI MegaRAID SCSI 320-0X		1000	0407	1000	0530
41  * LSI MegaRAID SCSI 320-2X		1000	0407	1000	0532
42  * LSI MegaRAID SCSI 320-4X		1000	0407	1000	0531
43  * LSI MegaRAID SCSI 320-1E		1000	0408	1000	0001
44  * LSI MegaRAID SCSI 320-2E		1000	0408	1000	0002
45  * LSI MegaRAID SATA 150-4		1000	1960	1000	4523
46  * LSI MegaRAID SATA 150-6		1000	1960	1000	0523
47  * LSI MegaRAID SATA 300-4X		1000	0409	1000	3004
48  * LSI MegaRAID SATA 300-8X		1000	0409	1000	3008
49  *
50  * INTEL RAID Controller SRCU42X	1000	0407	8086	0532
51  * INTEL RAID Controller SRCS16		1000	1960	8086	0523
52  * INTEL RAID Controller SRCU42E	1000	0408	8086	0002
53  * INTEL RAID Controller SRCZCRX	1000	0407	8086	0530
54  * INTEL RAID Controller SRCS28X	1000	0409	8086	3008
55  * INTEL RAID Controller SROMBU42E	1000	0408	8086	3431
56  * INTEL RAID Controller SROMBU42E	1000	0408	8086	3499
57  * INTEL RAID Controller SRCU51L	1000	1960	8086	0520
58  *
59  * FSC	MegaRAID PCI Express ROMB	1000	0408	1734	1065
60  *
61  * ACER	MegaRAID ROMB-2E		1000	0408	1025	004D
62  *
63  * NEC	MegaRAID PCI Express ROMB	1000	0408	1033	8287
64  *
65  * For history of changes, see Documentation/scsi/ChangeLog.megaraid
66  */
67 
68 #include <linux/slab.h>
69 #include <linux/module.h>
70 #include "megaraid_mbox.h"
71 
72 static int megaraid_init(void);
73 static void megaraid_exit(void);
74 
75 static int megaraid_probe_one(struct pci_dev*, const struct pci_device_id *);
76 static void megaraid_detach_one(struct pci_dev *);
77 static void megaraid_mbox_shutdown(struct pci_dev *);
78 
79 static int megaraid_io_attach(adapter_t *);
80 static void megaraid_io_detach(adapter_t *);
81 
82 static int megaraid_init_mbox(adapter_t *);
83 static void megaraid_fini_mbox(adapter_t *);
84 
85 static int megaraid_alloc_cmd_packets(adapter_t *);
86 static void megaraid_free_cmd_packets(adapter_t *);
87 
88 static int megaraid_mbox_setup_dma_pools(adapter_t *);
89 static void megaraid_mbox_teardown_dma_pools(adapter_t *);
90 
91 static int megaraid_sysfs_alloc_resources(adapter_t *);
92 static void megaraid_sysfs_free_resources(adapter_t *);
93 
94 static int megaraid_abort_handler(struct scsi_cmnd *);
95 static int megaraid_reset_handler(struct scsi_cmnd *);
96 
97 static int mbox_post_sync_cmd(adapter_t *, uint8_t []);
98 static int mbox_post_sync_cmd_fast(adapter_t *, uint8_t []);
99 static int megaraid_busywait_mbox(mraid_device_t *);
100 static int megaraid_mbox_product_info(adapter_t *);
101 static int megaraid_mbox_extended_cdb(adapter_t *);
102 static int megaraid_mbox_support_ha(adapter_t *, uint16_t *);
103 static int megaraid_mbox_support_random_del(adapter_t *);
104 static int megaraid_mbox_get_max_sg(adapter_t *);
105 static void megaraid_mbox_enum_raid_scsi(adapter_t *);
106 static void megaraid_mbox_flush_cache(adapter_t *);
107 static int megaraid_mbox_fire_sync_cmd(adapter_t *);
108 
109 static void megaraid_mbox_display_scb(adapter_t *, scb_t *);
110 static void megaraid_mbox_setup_device_map(adapter_t *);
111 
112 static int megaraid_queue_command(struct Scsi_Host *, struct scsi_cmnd *);
113 static scb_t *megaraid_mbox_build_cmd(adapter_t *, struct scsi_cmnd *, int *);
114 static void megaraid_mbox_runpendq(adapter_t *, scb_t *);
115 static void megaraid_mbox_prepare_pthru(adapter_t *, scb_t *,
116 		struct scsi_cmnd *);
117 static void megaraid_mbox_prepare_epthru(adapter_t *, scb_t *,
118 		struct scsi_cmnd *);
119 
120 static irqreturn_t megaraid_isr(int, void *);
121 
122 static void megaraid_mbox_dpc(unsigned long);
123 
124 static ssize_t megaraid_mbox_app_hndl_show(struct device *, struct device_attribute *attr, char *);
125 static ssize_t megaraid_mbox_ld_show(struct device *, struct device_attribute *attr, char *);
126 
127 static int megaraid_cmm_register(adapter_t *);
128 static int megaraid_cmm_unregister(adapter_t *);
129 static int megaraid_mbox_mm_handler(unsigned long, uioc_t *, uint32_t);
130 static int megaraid_mbox_mm_command(adapter_t *, uioc_t *);
131 static void megaraid_mbox_mm_done(adapter_t *, scb_t *);
132 static int gather_hbainfo(adapter_t *, mraid_hba_info_t *);
133 static int wait_till_fw_empty(adapter_t *);
134 
135 
136 
137 MODULE_AUTHOR("megaraidlinux@lsi.com");
138 MODULE_DESCRIPTION("LSI Logic MegaRAID Mailbox Driver");
139 MODULE_LICENSE("GPL");
140 MODULE_VERSION(MEGARAID_VERSION);
141 
142 /*
143  * ### modules parameters for driver ###
144  */
145 
146 /*
147  * Set to enable driver to expose unconfigured disk to kernel
148  */
149 static int megaraid_expose_unconf_disks = 0;
150 module_param_named(unconf_disks, megaraid_expose_unconf_disks, int, 0);
151 MODULE_PARM_DESC(unconf_disks,
152 	"Set to expose unconfigured disks to kernel (default=0)");
153 
154 /*
155  * driver wait time if the adapter's mailbox is busy
156  */
157 static unsigned int max_mbox_busy_wait = MBOX_BUSY_WAIT;
158 module_param_named(busy_wait, max_mbox_busy_wait, int, 0);
159 MODULE_PARM_DESC(busy_wait,
160 	"Max wait for mailbox in microseconds if busy (default=10)");
161 
162 /*
163  * number of sectors per IO command
164  */
165 static unsigned int megaraid_max_sectors = MBOX_MAX_SECTORS;
166 module_param_named(max_sectors, megaraid_max_sectors, int, 0);
167 MODULE_PARM_DESC(max_sectors,
168 	"Maximum number of sectors per IO command (default=128)");
169 
170 /*
171  * number of commands per logical unit
172  */
173 static unsigned int megaraid_cmd_per_lun = MBOX_DEF_CMD_PER_LUN;
174 module_param_named(cmd_per_lun, megaraid_cmd_per_lun, int, 0);
175 MODULE_PARM_DESC(cmd_per_lun,
176 	"Maximum number of commands per logical unit (default=64)");
177 
178 
179 /*
180  * Fast driver load option, skip scanning for physical devices during load.
181  * This would result in non-disk devices being skipped during driver load
182  * time. These can be later added though, using /proc/scsi/scsi
183  */
184 static unsigned int megaraid_fast_load;
185 module_param_named(fast_load, megaraid_fast_load, int, 0);
186 MODULE_PARM_DESC(fast_load,
187 	"Faster loading of the driver, skips physical devices! (default=0)");
188 
189 
190 /*
191  * mraid_debug level - threshold for amount of information to be displayed by
192  * the driver. This level can be changed through modules parameters, ioctl or
193  * sysfs/proc interface. By default, print the announcement messages only.
194  */
195 int mraid_debug_level = CL_ANN;
196 module_param_named(debug_level, mraid_debug_level, int, 0);
197 MODULE_PARM_DESC(debug_level, "Debug level for driver (default=0)");
198 
199 /*
200  * PCI table for all supported controllers.
201  */
202 static struct pci_device_id pci_id_table_g[] =  {
203 	{
204 		PCI_VENDOR_ID_DELL,
205 		PCI_DEVICE_ID_PERC4_DI_DISCOVERY,
206 		PCI_VENDOR_ID_DELL,
207 		PCI_SUBSYS_ID_PERC4_DI_DISCOVERY,
208 	},
209 	{
210 		PCI_VENDOR_ID_LSI_LOGIC,
211 		PCI_DEVICE_ID_PERC4_SC,
212 		PCI_VENDOR_ID_DELL,
213 		PCI_SUBSYS_ID_PERC4_SC,
214 	},
215 	{
216 		PCI_VENDOR_ID_LSI_LOGIC,
217 		PCI_DEVICE_ID_PERC4_DC,
218 		PCI_VENDOR_ID_DELL,
219 		PCI_SUBSYS_ID_PERC4_DC,
220 	},
221 	{
222 		PCI_VENDOR_ID_LSI_LOGIC,
223 		PCI_DEVICE_ID_VERDE,
224 		PCI_ANY_ID,
225 		PCI_ANY_ID,
226 	},
227 	{
228 		PCI_VENDOR_ID_DELL,
229 		PCI_DEVICE_ID_PERC4_DI_EVERGLADES,
230 		PCI_VENDOR_ID_DELL,
231 		PCI_SUBSYS_ID_PERC4_DI_EVERGLADES,
232 	},
233 	{
234 		PCI_VENDOR_ID_DELL,
235 		PCI_DEVICE_ID_PERC4E_SI_BIGBEND,
236 		PCI_VENDOR_ID_DELL,
237 		PCI_SUBSYS_ID_PERC4E_SI_BIGBEND,
238 	},
239 	{
240 		PCI_VENDOR_ID_DELL,
241 		PCI_DEVICE_ID_PERC4E_DI_KOBUK,
242 		PCI_VENDOR_ID_DELL,
243 		PCI_SUBSYS_ID_PERC4E_DI_KOBUK,
244 	},
245 	{
246 		PCI_VENDOR_ID_DELL,
247 		PCI_DEVICE_ID_PERC4E_DI_CORVETTE,
248 		PCI_VENDOR_ID_DELL,
249 		PCI_SUBSYS_ID_PERC4E_DI_CORVETTE,
250 	},
251 	{
252 		PCI_VENDOR_ID_DELL,
253 		PCI_DEVICE_ID_PERC4E_DI_EXPEDITION,
254 		PCI_VENDOR_ID_DELL,
255 		PCI_SUBSYS_ID_PERC4E_DI_EXPEDITION,
256 	},
257 	{
258 		PCI_VENDOR_ID_DELL,
259 		PCI_DEVICE_ID_PERC4E_DI_GUADALUPE,
260 		PCI_VENDOR_ID_DELL,
261 		PCI_SUBSYS_ID_PERC4E_DI_GUADALUPE,
262 	},
263 	{
264 		PCI_VENDOR_ID_LSI_LOGIC,
265 		PCI_DEVICE_ID_DOBSON,
266 		PCI_ANY_ID,
267 		PCI_ANY_ID,
268 	},
269 	{
270 		PCI_VENDOR_ID_AMI,
271 		PCI_DEVICE_ID_AMI_MEGARAID3,
272 		PCI_ANY_ID,
273 		PCI_ANY_ID,
274 	},
275 	{
276 		PCI_VENDOR_ID_LSI_LOGIC,
277 		PCI_DEVICE_ID_AMI_MEGARAID3,
278 		PCI_ANY_ID,
279 		PCI_ANY_ID,
280 	},
281 	{
282 		PCI_VENDOR_ID_LSI_LOGIC,
283 		PCI_DEVICE_ID_LINDSAY,
284 		PCI_ANY_ID,
285 		PCI_ANY_ID,
286 	},
287 	{0}	/* Terminating entry */
288 };
289 MODULE_DEVICE_TABLE(pci, pci_id_table_g);
290 
291 
292 static struct pci_driver megaraid_pci_driver = {
293 	.name		= "megaraid",
294 	.id_table	= pci_id_table_g,
295 	.probe		= megaraid_probe_one,
296 	.remove		= megaraid_detach_one,
297 	.shutdown	= megaraid_mbox_shutdown,
298 };
299 
300 
301 
302 // definitions for the device attributes for exporting logical drive number
303 // for a scsi address (Host, Channel, Id, Lun)
304 
305 static DEVICE_ATTR_ADMIN_RO(megaraid_mbox_app_hndl);
306 
307 // Host template initializer for megaraid mbox sysfs device attributes
308 static struct attribute *megaraid_shost_attrs[] = {
309 	&dev_attr_megaraid_mbox_app_hndl.attr,
310 	NULL,
311 };
312 
313 ATTRIBUTE_GROUPS(megaraid_shost);
314 
315 static DEVICE_ATTR_ADMIN_RO(megaraid_mbox_ld);
316 
317 // Host template initializer for megaraid mbox sysfs device attributes
318 static struct attribute *megaraid_sdev_attrs[] = {
319 	&dev_attr_megaraid_mbox_ld.attr,
320 	NULL,
321 };
322 
323 ATTRIBUTE_GROUPS(megaraid_sdev);
324 
325 /*
326  * Scsi host template for megaraid unified driver
327  */
328 static struct scsi_host_template megaraid_template_g = {
329 	.module				= THIS_MODULE,
330 	.name				= "LSI Logic MegaRAID driver",
331 	.proc_name			= "megaraid",
332 	.queuecommand			= megaraid_queue_command,
333 	.eh_abort_handler		= megaraid_abort_handler,
334 	.eh_host_reset_handler		= megaraid_reset_handler,
335 	.change_queue_depth		= scsi_change_queue_depth,
336 	.no_write_same			= 1,
337 	.sdev_groups			= megaraid_sdev_groups,
338 	.shost_groups			= megaraid_shost_groups,
339 };
340 
341 
342 /**
343  * megaraid_init - module load hook
344  *
345  * We register ourselves as hotplug enabled module and let PCI subsystem
346  * discover our adapters.
347  */
348 static int __init
349 megaraid_init(void)
350 {
351 	int	rval;
352 
353 	// Announce the driver version
354 	con_log(CL_ANN, (KERN_INFO "megaraid: %s %s\n", MEGARAID_VERSION,
355 		MEGARAID_EXT_VERSION));
356 
357 	// check validity of module parameters
358 	if (megaraid_cmd_per_lun > MBOX_MAX_SCSI_CMDS) {
359 
360 		con_log(CL_ANN, (KERN_WARNING
361 			"megaraid mailbox: max commands per lun reset to %d\n",
362 			MBOX_MAX_SCSI_CMDS));
363 
364 		megaraid_cmd_per_lun = MBOX_MAX_SCSI_CMDS;
365 	}
366 
367 
368 	// register as a PCI hot-plug driver module
369 	rval = pci_register_driver(&megaraid_pci_driver);
370 	if (rval < 0) {
371 		con_log(CL_ANN, (KERN_WARNING
372 			"megaraid: could not register hotplug support.\n"));
373 	}
374 
375 	return rval;
376 }
377 
378 
379 /**
380  * megaraid_exit - driver unload entry point
381  *
382  * We simply unwrap the megaraid_init routine here.
383  */
384 static void __exit
385 megaraid_exit(void)
386 {
387 	con_log(CL_DLEVEL1, (KERN_NOTICE "megaraid: unloading framework\n"));
388 
389 	// unregister as PCI hotplug driver
390 	pci_unregister_driver(&megaraid_pci_driver);
391 
392 	return;
393 }
394 
395 
396 /**
397  * megaraid_probe_one - PCI hotplug entry point
398  * @pdev	: handle to this controller's PCI configuration space
399  * @id		: pci device id of the class of controllers
400  *
401  * This routine should be called whenever a new adapter is detected by the
402  * PCI hotplug susbsystem.
403  */
404 static int
405 megaraid_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
406 {
407 	adapter_t	*adapter;
408 
409 
410 	// detected a new controller
411 	con_log(CL_ANN, (KERN_INFO
412 		"megaraid: probe new device %#4.04x:%#4.04x:%#4.04x:%#4.04x: ",
413 		pdev->vendor, pdev->device, pdev->subsystem_vendor,
414 		pdev->subsystem_device));
415 
416 	con_log(CL_ANN, ("bus %d:slot %d:func %d\n", pdev->bus->number,
417 		PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn)));
418 
419 	if (pci_enable_device(pdev)) {
420 		con_log(CL_ANN, (KERN_WARNING
421 				"megaraid: pci_enable_device failed\n"));
422 
423 		return -ENODEV;
424 	}
425 
426 	// Enable bus-mastering on this controller
427 	pci_set_master(pdev);
428 
429 	// Allocate the per driver initialization structure
430 	adapter = kzalloc(sizeof(adapter_t), GFP_KERNEL);
431 
432 	if (adapter == NULL) {
433 		con_log(CL_ANN, (KERN_WARNING
434 		"megaraid: out of memory, %s %d.\n", __func__, __LINE__));
435 
436 		goto out_probe_one;
437 	}
438 
439 
440 	// set up PCI related soft state and other pre-known parameters
441 	adapter->unique_id	= pdev->bus->number << 8 | pdev->devfn;
442 	adapter->irq		= pdev->irq;
443 	adapter->pdev		= pdev;
444 
445 	atomic_set(&adapter->being_detached, 0);
446 
447 	// Setup the default DMA mask. This would be changed later on
448 	// depending on hardware capabilities
449 	if (dma_set_mask(&adapter->pdev->dev, DMA_BIT_MASK(32))) {
450 		con_log(CL_ANN, (KERN_WARNING
451 			"megaraid: dma_set_mask failed:%d\n", __LINE__));
452 
453 		goto out_free_adapter;
454 	}
455 
456 
457 	// Initialize the synchronization lock for kernel and LLD
458 	spin_lock_init(&adapter->lock);
459 
460 	// Initialize the command queues: the list of free SCBs and the list
461 	// of pending SCBs.
462 	INIT_LIST_HEAD(&adapter->kscb_pool);
463 	spin_lock_init(SCSI_FREE_LIST_LOCK(adapter));
464 
465 	INIT_LIST_HEAD(&adapter->pend_list);
466 	spin_lock_init(PENDING_LIST_LOCK(adapter));
467 
468 	INIT_LIST_HEAD(&adapter->completed_list);
469 	spin_lock_init(COMPLETED_LIST_LOCK(adapter));
470 
471 
472 	// Start the mailbox based controller
473 	if (megaraid_init_mbox(adapter) != 0) {
474 		con_log(CL_ANN, (KERN_WARNING
475 			"megaraid: mailbox adapter did not initialize\n"));
476 
477 		goto out_free_adapter;
478 	}
479 
480 	// Register with LSI Common Management Module
481 	if (megaraid_cmm_register(adapter) != 0) {
482 
483 		con_log(CL_ANN, (KERN_WARNING
484 		"megaraid: could not register with management module\n"));
485 
486 		goto out_fini_mbox;
487 	}
488 
489 	// setup adapter handle in PCI soft state
490 	pci_set_drvdata(pdev, adapter);
491 
492 	// attach with scsi mid-layer
493 	if (megaraid_io_attach(adapter) != 0) {
494 
495 		con_log(CL_ANN, (KERN_WARNING "megaraid: io attach failed\n"));
496 
497 		goto out_cmm_unreg;
498 	}
499 
500 	return 0;
501 
502 out_cmm_unreg:
503 	megaraid_cmm_unregister(adapter);
504 out_fini_mbox:
505 	megaraid_fini_mbox(adapter);
506 out_free_adapter:
507 	kfree(adapter);
508 out_probe_one:
509 	pci_disable_device(pdev);
510 
511 	return -ENODEV;
512 }
513 
514 
515 /**
516  * megaraid_detach_one - release framework resources and call LLD release routine
517  * @pdev	: handle for our PCI configuration space
518  *
519  * This routine is called during driver unload. We free all the allocated
520  * resources and call the corresponding LLD so that it can also release all
521  * its resources.
522  *
523  * This routine is also called from the PCI hotplug system.
524  */
525 static void
526 megaraid_detach_one(struct pci_dev *pdev)
527 {
528 	adapter_t		*adapter;
529 	struct Scsi_Host	*host;
530 
531 
532 	// Start a rollback on this adapter
533 	adapter = pci_get_drvdata(pdev);
534 
535 	if (!adapter) {
536 		con_log(CL_ANN, (KERN_CRIT
537 		"megaraid: Invalid detach on %#4.04x:%#4.04x:%#4.04x:%#4.04x\n",
538 			pdev->vendor, pdev->device, pdev->subsystem_vendor,
539 			pdev->subsystem_device));
540 
541 		return;
542 	}
543 	else {
544 		con_log(CL_ANN, (KERN_NOTICE
545 		"megaraid: detaching device %#4.04x:%#4.04x:%#4.04x:%#4.04x\n",
546 			pdev->vendor, pdev->device, pdev->subsystem_vendor,
547 			pdev->subsystem_device));
548 	}
549 
550 
551 	host = adapter->host;
552 
553 	// do not allow any more requests from the management module for this
554 	// adapter.
555 	// FIXME: How do we account for the request which might still be
556 	// pending with us?
557 	atomic_set(&adapter->being_detached, 1);
558 
559 	// detach from the IO sub-system
560 	megaraid_io_detach(adapter);
561 
562 	// Unregister from common management module
563 	//
564 	// FIXME: this must return success or failure for conditions if there
565 	// is a command pending with LLD or not.
566 	megaraid_cmm_unregister(adapter);
567 
568 	// finalize the mailbox based controller and release all resources
569 	megaraid_fini_mbox(adapter);
570 
571 	kfree(adapter);
572 
573 	scsi_host_put(host);
574 
575 	pci_disable_device(pdev);
576 
577 	return;
578 }
579 
580 
581 /**
582  * megaraid_mbox_shutdown - PCI shutdown for megaraid HBA
583  * @pdev		: generic driver model device
584  *
585  * Shutdown notification, perform flush cache.
586  */
587 static void
588 megaraid_mbox_shutdown(struct pci_dev *pdev)
589 {
590 	adapter_t		*adapter = pci_get_drvdata(pdev);
591 	static int		counter;
592 
593 	if (!adapter) {
594 		con_log(CL_ANN, (KERN_WARNING
595 			"megaraid: null device in shutdown\n"));
596 		return;
597 	}
598 
599 	// flush caches now
600 	con_log(CL_ANN, (KERN_INFO "megaraid: flushing adapter %d...",
601 		counter++));
602 
603 	megaraid_mbox_flush_cache(adapter);
604 
605 	con_log(CL_ANN, ("done\n"));
606 }
607 
608 
609 /**
610  * megaraid_io_attach - attach a device with the IO subsystem
611  * @adapter		: controller's soft state
612  *
613  * Attach this device with the IO subsystem.
614  */
615 static int
616 megaraid_io_attach(adapter_t *adapter)
617 {
618 	struct Scsi_Host	*host;
619 
620 	// Initialize SCSI Host structure
621 	host = scsi_host_alloc(&megaraid_template_g, 8);
622 	if (!host) {
623 		con_log(CL_ANN, (KERN_WARNING
624 			"megaraid mbox: scsi_register failed\n"));
625 
626 		return -1;
627 	}
628 
629 	SCSIHOST2ADAP(host)	= (caddr_t)adapter;
630 	adapter->host		= host;
631 
632 	host->irq		= adapter->irq;
633 	host->unique_id		= adapter->unique_id;
634 	host->can_queue		= adapter->max_cmds;
635 	host->this_id		= adapter->init_id;
636 	host->sg_tablesize	= adapter->sglen;
637 	host->max_sectors	= adapter->max_sectors;
638 	host->cmd_per_lun	= adapter->cmd_per_lun;
639 	host->max_channel	= adapter->max_channel;
640 	host->max_id		= adapter->max_target;
641 	host->max_lun		= adapter->max_lun;
642 
643 
644 	// notify mid-layer about the new controller
645 	if (scsi_add_host(host, &adapter->pdev->dev)) {
646 
647 		con_log(CL_ANN, (KERN_WARNING
648 			"megaraid mbox: scsi_add_host failed\n"));
649 
650 		scsi_host_put(host);
651 
652 		return -1;
653 	}
654 
655 	scsi_scan_host(host);
656 
657 	return 0;
658 }
659 
660 
661 /**
662  * megaraid_io_detach - detach a device from the IO subsystem
663  * @adapter		: controller's soft state
664  *
665  * Detach this device from the IO subsystem.
666  */
667 static void
668 megaraid_io_detach(adapter_t *adapter)
669 {
670 	struct Scsi_Host	*host;
671 
672 	con_log(CL_DLEVEL1, (KERN_INFO "megaraid: io detach\n"));
673 
674 	host = adapter->host;
675 
676 	scsi_remove_host(host);
677 
678 	return;
679 }
680 
681 
682 /*
683  * START: Mailbox Low Level Driver
684  *
685  * This is section specific to the single mailbox based controllers
686  */
687 
688 /**
689  * megaraid_init_mbox - initialize controller
690  * @adapter		: our soft state
691  *
692  * - Allocate 16-byte aligned mailbox memory for firmware handshake
693  * - Allocate controller's memory resources
694  * - Find out all initialization data
695  * - Allocate memory required for all the commands
696  * - Use internal library of FW routines, build up complete soft state
697  */
698 static int
699 megaraid_init_mbox(adapter_t *adapter)
700 {
701 	struct pci_dev		*pdev;
702 	mraid_device_t		*raid_dev;
703 	int			i;
704 	uint32_t		magic64;
705 
706 
707 	adapter->ito	= MBOX_TIMEOUT;
708 	pdev		= adapter->pdev;
709 
710 	/*
711 	 * Allocate and initialize the init data structure for mailbox
712 	 * controllers
713 	 */
714 	raid_dev = kzalloc(sizeof(mraid_device_t), GFP_KERNEL);
715 	if (raid_dev == NULL) return -1;
716 
717 
718 	/*
719 	 * Attach the adapter soft state to raid device soft state
720 	 */
721 	adapter->raid_device	= (caddr_t)raid_dev;
722 	raid_dev->fast_load	= megaraid_fast_load;
723 
724 
725 	// our baseport
726 	raid_dev->baseport = pci_resource_start(pdev, 0);
727 
728 	if (pci_request_regions(pdev, "MegaRAID: LSI Logic Corporation") != 0) {
729 
730 		con_log(CL_ANN, (KERN_WARNING
731 				"megaraid: mem region busy\n"));
732 
733 		goto out_free_raid_dev;
734 	}
735 
736 	raid_dev->baseaddr = ioremap(raid_dev->baseport, 128);
737 
738 	if (!raid_dev->baseaddr) {
739 
740 		con_log(CL_ANN, (KERN_WARNING
741 			"megaraid: could not map hba memory\n") );
742 
743 		goto out_release_regions;
744 	}
745 
746 	/* initialize the mutual exclusion lock for the mailbox */
747 	spin_lock_init(&raid_dev->mailbox_lock);
748 
749 	/* allocate memory required for commands */
750 	if (megaraid_alloc_cmd_packets(adapter) != 0)
751 		goto out_iounmap;
752 
753 	/*
754 	 * Issue SYNC cmd to flush the pending cmds in the adapter
755 	 * and initialize its internal state
756 	 */
757 
758 	if (megaraid_mbox_fire_sync_cmd(adapter))
759 		con_log(CL_ANN, ("megaraid: sync cmd failed\n"));
760 
761 	/*
762 	 * Setup the rest of the soft state using the library of
763 	 * FW routines
764 	 */
765 
766 	/* request IRQ and register the interrupt service routine */
767 	if (request_irq(adapter->irq, megaraid_isr, IRQF_SHARED, "megaraid",
768 		adapter)) {
769 
770 		con_log(CL_ANN, (KERN_WARNING
771 			"megaraid: Couldn't register IRQ %d!\n", adapter->irq));
772 		goto out_alloc_cmds;
773 
774 	}
775 
776 	// Product info
777 	if (megaraid_mbox_product_info(adapter) != 0)
778 		goto out_free_irq;
779 
780 	// Do we support extended CDBs
781 	adapter->max_cdb_sz = 10;
782 	if (megaraid_mbox_extended_cdb(adapter) == 0) {
783 		adapter->max_cdb_sz = 16;
784 	}
785 
786 	/*
787 	 * Do we support cluster environment, if we do, what is the initiator
788 	 * id.
789 	 * NOTE: In a non-cluster aware firmware environment, the LLD should
790 	 * return 7 as initiator id.
791 	 */
792 	adapter->ha		= 0;
793 	adapter->init_id	= -1;
794 	if (megaraid_mbox_support_ha(adapter, &adapter->init_id) == 0) {
795 		adapter->ha = 1;
796 	}
797 
798 	/*
799 	 * Prepare the device ids array to have the mapping between the kernel
800 	 * device address and megaraid device address.
801 	 * We export the physical devices on their actual addresses. The
802 	 * logical drives are exported on a virtual SCSI channel
803 	 */
804 	megaraid_mbox_setup_device_map(adapter);
805 
806 	// If the firmware supports random deletion, update the device id map
807 	if (megaraid_mbox_support_random_del(adapter)) {
808 
809 		// Change the logical drives numbers in device_ids array one
810 		// slot in device_ids is reserved for target id, that's why
811 		// "<=" below
812 		for (i = 0; i <= MAX_LOGICAL_DRIVES_40LD; i++) {
813 			adapter->device_ids[adapter->max_channel][i] += 0x80;
814 		}
815 		adapter->device_ids[adapter->max_channel][adapter->init_id] =
816 			0xFF;
817 
818 		raid_dev->random_del_supported = 1;
819 	}
820 
821 	/*
822 	 * find out the maximum number of scatter-gather elements supported by
823 	 * this firmware
824 	 */
825 	adapter->sglen = megaraid_mbox_get_max_sg(adapter);
826 
827 	// enumerate RAID and SCSI channels so that all devices on SCSI
828 	// channels can later be exported, including disk devices
829 	megaraid_mbox_enum_raid_scsi(adapter);
830 
831 	/*
832 	 * Other parameters required by upper layer
833 	 *
834 	 * maximum number of sectors per IO command
835 	 */
836 	adapter->max_sectors = megaraid_max_sectors;
837 
838 	/*
839 	 * number of queued commands per LUN.
840 	 */
841 	adapter->cmd_per_lun = megaraid_cmd_per_lun;
842 
843 	/*
844 	 * Allocate resources required to issue FW calls, when sysfs is
845 	 * accessed
846 	 */
847 	if (megaraid_sysfs_alloc_resources(adapter) != 0)
848 		goto out_free_irq;
849 
850 	// Set the DMA mask to 64-bit. All supported controllers as capable of
851 	// DMA in this range
852 	pci_read_config_dword(adapter->pdev, PCI_CONF_AMISIG64, &magic64);
853 
854 	if (((magic64 == HBA_SIGNATURE_64_BIT) &&
855 		((adapter->pdev->subsystem_device !=
856 		PCI_SUBSYS_ID_MEGARAID_SATA_150_6) &&
857 		(adapter->pdev->subsystem_device !=
858 		PCI_SUBSYS_ID_MEGARAID_SATA_150_4))) ||
859 		(adapter->pdev->vendor == PCI_VENDOR_ID_LSI_LOGIC &&
860 		adapter->pdev->device == PCI_DEVICE_ID_VERDE) ||
861 		(adapter->pdev->vendor == PCI_VENDOR_ID_LSI_LOGIC &&
862 		adapter->pdev->device == PCI_DEVICE_ID_DOBSON) ||
863 		(adapter->pdev->vendor == PCI_VENDOR_ID_LSI_LOGIC &&
864 		adapter->pdev->device == PCI_DEVICE_ID_LINDSAY) ||
865 		(adapter->pdev->vendor == PCI_VENDOR_ID_DELL &&
866 		adapter->pdev->device == PCI_DEVICE_ID_PERC4_DI_EVERGLADES) ||
867 		(adapter->pdev->vendor == PCI_VENDOR_ID_DELL &&
868 		adapter->pdev->device == PCI_DEVICE_ID_PERC4E_DI_KOBUK)) {
869 		if (dma_set_mask(&adapter->pdev->dev, DMA_BIT_MASK(64))) {
870 			con_log(CL_ANN, (KERN_WARNING
871 				"megaraid: DMA mask for 64-bit failed\n"));
872 
873 			if (dma_set_mask(&adapter->pdev->dev,
874 						DMA_BIT_MASK(32))) {
875 				con_log(CL_ANN, (KERN_WARNING
876 					"megaraid: 32-bit DMA mask failed\n"));
877 				goto out_free_sysfs_res;
878 			}
879 		}
880 	}
881 
882 	// setup tasklet for DPC
883 	tasklet_init(&adapter->dpc_h, megaraid_mbox_dpc,
884 			(unsigned long)adapter);
885 
886 	con_log(CL_DLEVEL1, (KERN_INFO
887 		"megaraid mbox hba successfully initialized\n"));
888 
889 	return 0;
890 
891 out_free_sysfs_res:
892 	megaraid_sysfs_free_resources(adapter);
893 out_free_irq:
894 	free_irq(adapter->irq, adapter);
895 out_alloc_cmds:
896 	megaraid_free_cmd_packets(adapter);
897 out_iounmap:
898 	iounmap(raid_dev->baseaddr);
899 out_release_regions:
900 	pci_release_regions(pdev);
901 out_free_raid_dev:
902 	kfree(raid_dev);
903 
904 	return -1;
905 }
906 
907 
908 /**
909  * megaraid_fini_mbox - undo controller initialization
910  * @adapter		: our soft state
911  */
912 static void
913 megaraid_fini_mbox(adapter_t *adapter)
914 {
915 	mraid_device_t *raid_dev = ADAP2RAIDDEV(adapter);
916 
917 	// flush all caches
918 	megaraid_mbox_flush_cache(adapter);
919 
920 	tasklet_kill(&adapter->dpc_h);
921 
922 	megaraid_sysfs_free_resources(adapter);
923 
924 	megaraid_free_cmd_packets(adapter);
925 
926 	free_irq(adapter->irq, adapter);
927 
928 	iounmap(raid_dev->baseaddr);
929 
930 	pci_release_regions(adapter->pdev);
931 
932 	kfree(raid_dev);
933 
934 	return;
935 }
936 
937 
938 /**
939  * megaraid_alloc_cmd_packets - allocate shared mailbox
940  * @adapter		: soft state of the raid controller
941  *
942  * Allocate and align the shared mailbox. This mailbox is used to issue
943  * all the commands. For IO based controllers, the mailbox is also registered
944  * with the FW. Allocate memory for all commands as well.
945  * This is our big allocator.
946  */
947 static int
948 megaraid_alloc_cmd_packets(adapter_t *adapter)
949 {
950 	mraid_device_t		*raid_dev = ADAP2RAIDDEV(adapter);
951 	struct pci_dev		*pdev;
952 	unsigned long		align;
953 	scb_t			*scb;
954 	mbox_ccb_t		*ccb;
955 	struct mraid_pci_blk	*epthru_pci_blk;
956 	struct mraid_pci_blk	*sg_pci_blk;
957 	struct mraid_pci_blk	*mbox_pci_blk;
958 	int			i;
959 
960 	pdev = adapter->pdev;
961 
962 	/*
963 	 * Setup the mailbox
964 	 * Allocate the common 16-byte aligned memory for the handshake
965 	 * mailbox.
966 	 */
967 	raid_dev->una_mbox64 = dma_alloc_coherent(&adapter->pdev->dev,
968 						  sizeof(mbox64_t),
969 						  &raid_dev->una_mbox64_dma,
970 						  GFP_KERNEL);
971 
972 	if (!raid_dev->una_mbox64) {
973 		con_log(CL_ANN, (KERN_WARNING
974 			"megaraid: out of memory, %s %d\n", __func__,
975 			__LINE__));
976 		return -1;
977 	}
978 
979 	/*
980 	 * Align the mailbox at 16-byte boundary
981 	 */
982 	raid_dev->mbox	= &raid_dev->una_mbox64->mbox32;
983 
984 	raid_dev->mbox	= (mbox_t *)((((unsigned long)raid_dev->mbox) + 15) &
985 				(~0UL ^ 0xFUL));
986 
987 	raid_dev->mbox64 = (mbox64_t *)(((unsigned long)raid_dev->mbox) - 8);
988 
989 	align = ((void *)raid_dev->mbox -
990 			((void *)&raid_dev->una_mbox64->mbox32));
991 
992 	raid_dev->mbox_dma = (unsigned long)raid_dev->una_mbox64_dma + 8 +
993 			align;
994 
995 	// Allocate memory for commands issued internally
996 	adapter->ibuf = dma_alloc_coherent(&pdev->dev, MBOX_IBUF_SIZE,
997 					   &adapter->ibuf_dma_h, GFP_KERNEL);
998 	if (!adapter->ibuf) {
999 
1000 		con_log(CL_ANN, (KERN_WARNING
1001 			"megaraid: out of memory, %s %d\n", __func__,
1002 			__LINE__));
1003 
1004 		goto out_free_common_mbox;
1005 	}
1006 
1007 	// Allocate memory for our SCSI Command Blocks and their associated
1008 	// memory
1009 
1010 	/*
1011 	 * Allocate memory for the base list of scb. Later allocate memory for
1012 	 * CCBs and embedded components of each CCB and point the pointers in
1013 	 * scb to the allocated components
1014 	 * NOTE: The code to allocate SCB will be duplicated in all the LLD
1015 	 * since the calling routine does not yet know the number of available
1016 	 * commands.
1017 	 */
1018 	adapter->kscb_list = kcalloc(MBOX_MAX_SCSI_CMDS, sizeof(scb_t), GFP_KERNEL);
1019 
1020 	if (adapter->kscb_list == NULL) {
1021 		con_log(CL_ANN, (KERN_WARNING
1022 			"megaraid: out of memory, %s %d\n", __func__,
1023 			__LINE__));
1024 		goto out_free_ibuf;
1025 	}
1026 
1027 	// memory allocation for our command packets
1028 	if (megaraid_mbox_setup_dma_pools(adapter) != 0) {
1029 		con_log(CL_ANN, (KERN_WARNING
1030 			"megaraid: out of memory, %s %d\n", __func__,
1031 			__LINE__));
1032 		goto out_free_scb_list;
1033 	}
1034 
1035 	// Adjust the scb pointers and link in the free pool
1036 	epthru_pci_blk	= raid_dev->epthru_pool;
1037 	sg_pci_blk	= raid_dev->sg_pool;
1038 	mbox_pci_blk	= raid_dev->mbox_pool;
1039 
1040 	for (i = 0; i < MBOX_MAX_SCSI_CMDS; i++) {
1041 		scb			= adapter->kscb_list + i;
1042 		ccb			= raid_dev->ccb_list + i;
1043 
1044 		ccb->mbox	= (mbox_t *)(mbox_pci_blk[i].vaddr + 16);
1045 		ccb->raw_mbox	= (uint8_t *)ccb->mbox;
1046 		ccb->mbox64	= (mbox64_t *)(mbox_pci_blk[i].vaddr + 8);
1047 		ccb->mbox_dma_h	= (unsigned long)mbox_pci_blk[i].dma_addr + 16;
1048 
1049 		// make sure the mailbox is aligned properly
1050 		if (ccb->mbox_dma_h & 0x0F) {
1051 			con_log(CL_ANN, (KERN_CRIT
1052 				"megaraid mbox: not aligned on 16-bytes\n"));
1053 
1054 			goto out_teardown_dma_pools;
1055 		}
1056 
1057 		ccb->epthru		= (mraid_epassthru_t *)
1058 						epthru_pci_blk[i].vaddr;
1059 		ccb->epthru_dma_h	= epthru_pci_blk[i].dma_addr;
1060 		ccb->pthru		= (mraid_passthru_t *)ccb->epthru;
1061 		ccb->pthru_dma_h	= ccb->epthru_dma_h;
1062 
1063 
1064 		ccb->sgl64		= (mbox_sgl64 *)sg_pci_blk[i].vaddr;
1065 		ccb->sgl_dma_h		= sg_pci_blk[i].dma_addr;
1066 		ccb->sgl32		= (mbox_sgl32 *)ccb->sgl64;
1067 
1068 		scb->ccb		= (caddr_t)ccb;
1069 		scb->gp			= 0;
1070 
1071 		scb->sno		= i;	// command index
1072 
1073 		scb->scp		= NULL;
1074 		scb->state		= SCB_FREE;
1075 		scb->dma_direction	= DMA_NONE;
1076 		scb->dma_type		= MRAID_DMA_NONE;
1077 		scb->dev_channel	= -1;
1078 		scb->dev_target		= -1;
1079 
1080 		// put scb in the free pool
1081 		list_add_tail(&scb->list, &adapter->kscb_pool);
1082 	}
1083 
1084 	return 0;
1085 
1086 out_teardown_dma_pools:
1087 	megaraid_mbox_teardown_dma_pools(adapter);
1088 out_free_scb_list:
1089 	kfree(adapter->kscb_list);
1090 out_free_ibuf:
1091 	dma_free_coherent(&pdev->dev, MBOX_IBUF_SIZE, (void *)adapter->ibuf,
1092 		adapter->ibuf_dma_h);
1093 out_free_common_mbox:
1094 	dma_free_coherent(&adapter->pdev->dev, sizeof(mbox64_t),
1095 		(caddr_t)raid_dev->una_mbox64, raid_dev->una_mbox64_dma);
1096 
1097 	return -1;
1098 }
1099 
1100 
1101 /**
1102  * megaraid_free_cmd_packets - free memory
1103  * @adapter		: soft state of the raid controller
1104  *
1105  * Release memory resources allocated for commands.
1106  */
1107 static void
1108 megaraid_free_cmd_packets(adapter_t *adapter)
1109 {
1110 	mraid_device_t *raid_dev = ADAP2RAIDDEV(adapter);
1111 
1112 	megaraid_mbox_teardown_dma_pools(adapter);
1113 
1114 	kfree(adapter->kscb_list);
1115 
1116 	dma_free_coherent(&adapter->pdev->dev, MBOX_IBUF_SIZE,
1117 		(void *)adapter->ibuf, adapter->ibuf_dma_h);
1118 
1119 	dma_free_coherent(&adapter->pdev->dev, sizeof(mbox64_t),
1120 		(caddr_t)raid_dev->una_mbox64, raid_dev->una_mbox64_dma);
1121 	return;
1122 }
1123 
1124 
1125 /**
1126  * megaraid_mbox_setup_dma_pools - setup dma pool for command packets
1127  * @adapter		: HBA soft state
1128  *
1129  * Setup the dma pools for mailbox, passthru and extended passthru structures,
1130  * and scatter-gather lists.
1131  */
1132 static int
1133 megaraid_mbox_setup_dma_pools(adapter_t *adapter)
1134 {
1135 	mraid_device_t		*raid_dev = ADAP2RAIDDEV(adapter);
1136 	struct mraid_pci_blk	*epthru_pci_blk;
1137 	struct mraid_pci_blk	*sg_pci_blk;
1138 	struct mraid_pci_blk	*mbox_pci_blk;
1139 	int			i;
1140 
1141 
1142 
1143 	// Allocate memory for 16-bytes aligned mailboxes
1144 	raid_dev->mbox_pool_handle = dma_pool_create("megaraid mbox pool",
1145 						&adapter->pdev->dev,
1146 						sizeof(mbox64_t) + 16,
1147 						16, 0);
1148 
1149 	if (raid_dev->mbox_pool_handle == NULL) {
1150 		goto fail_setup_dma_pool;
1151 	}
1152 
1153 	mbox_pci_blk = raid_dev->mbox_pool;
1154 	for (i = 0; i < MBOX_MAX_SCSI_CMDS; i++) {
1155 		mbox_pci_blk[i].vaddr = dma_pool_alloc(
1156 						raid_dev->mbox_pool_handle,
1157 						GFP_KERNEL,
1158 						&mbox_pci_blk[i].dma_addr);
1159 		if (!mbox_pci_blk[i].vaddr) {
1160 			goto fail_setup_dma_pool;
1161 		}
1162 	}
1163 
1164 	/*
1165 	 * Allocate memory for each embedded passthru strucuture pointer
1166 	 * Request for a 128 bytes aligned structure for each passthru command
1167 	 * structure
1168 	 * Since passthru and extended passthru commands are exclusive, they
1169 	 * share common memory pool. Passthru structures piggyback on memory
1170 	 * allocated to extended passthru since passthru is smaller of the two
1171 	 */
1172 	raid_dev->epthru_pool_handle = dma_pool_create("megaraid mbox pthru",
1173 			&adapter->pdev->dev, sizeof(mraid_epassthru_t), 128, 0);
1174 
1175 	if (raid_dev->epthru_pool_handle == NULL) {
1176 		goto fail_setup_dma_pool;
1177 	}
1178 
1179 	epthru_pci_blk = raid_dev->epthru_pool;
1180 	for (i = 0; i < MBOX_MAX_SCSI_CMDS; i++) {
1181 		epthru_pci_blk[i].vaddr = dma_pool_alloc(
1182 						raid_dev->epthru_pool_handle,
1183 						GFP_KERNEL,
1184 						&epthru_pci_blk[i].dma_addr);
1185 		if (!epthru_pci_blk[i].vaddr) {
1186 			goto fail_setup_dma_pool;
1187 		}
1188 	}
1189 
1190 
1191 	// Allocate memory for each scatter-gather list. Request for 512 bytes
1192 	// alignment for each sg list
1193 	raid_dev->sg_pool_handle = dma_pool_create("megaraid mbox sg",
1194 					&adapter->pdev->dev,
1195 					sizeof(mbox_sgl64) * MBOX_MAX_SG_SIZE,
1196 					512, 0);
1197 
1198 	if (raid_dev->sg_pool_handle == NULL) {
1199 		goto fail_setup_dma_pool;
1200 	}
1201 
1202 	sg_pci_blk = raid_dev->sg_pool;
1203 	for (i = 0; i < MBOX_MAX_SCSI_CMDS; i++) {
1204 		sg_pci_blk[i].vaddr = dma_pool_alloc(
1205 						raid_dev->sg_pool_handle,
1206 						GFP_KERNEL,
1207 						&sg_pci_blk[i].dma_addr);
1208 		if (!sg_pci_blk[i].vaddr) {
1209 			goto fail_setup_dma_pool;
1210 		}
1211 	}
1212 
1213 	return 0;
1214 
1215 fail_setup_dma_pool:
1216 	megaraid_mbox_teardown_dma_pools(adapter);
1217 	return -1;
1218 }
1219 
1220 
1221 /**
1222  * megaraid_mbox_teardown_dma_pools - teardown dma pools for command packets
1223  * @adapter		: HBA soft state
1224  *
1225  * Teardown the dma pool for mailbox, passthru and extended passthru
1226  * structures, and scatter-gather lists.
1227  */
1228 static void
1229 megaraid_mbox_teardown_dma_pools(adapter_t *adapter)
1230 {
1231 	mraid_device_t		*raid_dev = ADAP2RAIDDEV(adapter);
1232 	struct mraid_pci_blk	*epthru_pci_blk;
1233 	struct mraid_pci_blk	*sg_pci_blk;
1234 	struct mraid_pci_blk	*mbox_pci_blk;
1235 	int			i;
1236 
1237 
1238 	sg_pci_blk = raid_dev->sg_pool;
1239 	for (i = 0; i < MBOX_MAX_SCSI_CMDS && sg_pci_blk[i].vaddr; i++) {
1240 		dma_pool_free(raid_dev->sg_pool_handle, sg_pci_blk[i].vaddr,
1241 			sg_pci_blk[i].dma_addr);
1242 	}
1243 	dma_pool_destroy(raid_dev->sg_pool_handle);
1244 
1245 
1246 	epthru_pci_blk = raid_dev->epthru_pool;
1247 	for (i = 0; i < MBOX_MAX_SCSI_CMDS && epthru_pci_blk[i].vaddr; i++) {
1248 		dma_pool_free(raid_dev->epthru_pool_handle,
1249 			epthru_pci_blk[i].vaddr, epthru_pci_blk[i].dma_addr);
1250 	}
1251 	dma_pool_destroy(raid_dev->epthru_pool_handle);
1252 
1253 
1254 	mbox_pci_blk = raid_dev->mbox_pool;
1255 	for (i = 0; i < MBOX_MAX_SCSI_CMDS && mbox_pci_blk[i].vaddr; i++) {
1256 		dma_pool_free(raid_dev->mbox_pool_handle,
1257 			mbox_pci_blk[i].vaddr, mbox_pci_blk[i].dma_addr);
1258 	}
1259 	dma_pool_destroy(raid_dev->mbox_pool_handle);
1260 
1261 	return;
1262 }
1263 
1264 
1265 /**
1266  * megaraid_alloc_scb - detach and return a scb from the free list
1267  * @adapter	: controller's soft state
1268  * @scp		: pointer to the scsi command to be executed
1269  *
1270  * Return the scb from the head of the free list. %NULL if there are none
1271  * available.
1272  */
1273 static scb_t *
1274 megaraid_alloc_scb(adapter_t *adapter, struct scsi_cmnd *scp)
1275 {
1276 	struct list_head	*head = &adapter->kscb_pool;
1277 	scb_t			*scb = NULL;
1278 	unsigned long		flags;
1279 
1280 	// detach scb from free pool
1281 	spin_lock_irqsave(SCSI_FREE_LIST_LOCK(adapter), flags);
1282 
1283 	if (list_empty(head)) {
1284 		spin_unlock_irqrestore(SCSI_FREE_LIST_LOCK(adapter), flags);
1285 		return NULL;
1286 	}
1287 
1288 	scb = list_entry(head->next, scb_t, list);
1289 	list_del_init(&scb->list);
1290 
1291 	spin_unlock_irqrestore(SCSI_FREE_LIST_LOCK(adapter), flags);
1292 
1293 	scb->state	= SCB_ACTIVE;
1294 	scb->scp	= scp;
1295 	scb->dma_type	= MRAID_DMA_NONE;
1296 
1297 	return scb;
1298 }
1299 
1300 
1301 /**
1302  * megaraid_dealloc_scb - return the scb to the free pool
1303  * @adapter	: controller's soft state
1304  * @scb		: scb to be freed
1305  *
1306  * Return the scb back to the free list of scbs. The caller must 'flush' the
1307  * SCB before calling us. E.g., performing pci_unamp and/or pci_sync etc.
1308  * NOTE NOTE: Make sure the scb is not on any list before calling this
1309  * routine.
1310  */
1311 static inline void
1312 megaraid_dealloc_scb(adapter_t *adapter, scb_t *scb)
1313 {
1314 	unsigned long		flags;
1315 
1316 	// put scb in the free pool
1317 	scb->state	= SCB_FREE;
1318 	scb->scp	= NULL;
1319 	spin_lock_irqsave(SCSI_FREE_LIST_LOCK(adapter), flags);
1320 
1321 	list_add(&scb->list, &adapter->kscb_pool);
1322 
1323 	spin_unlock_irqrestore(SCSI_FREE_LIST_LOCK(adapter), flags);
1324 
1325 	return;
1326 }
1327 
1328 
1329 /**
1330  * megaraid_mbox_mksgl - make the scatter-gather list
1331  * @adapter	: controller's soft state
1332  * @scb		: scsi control block
1333  *
1334  * Prepare the scatter-gather list.
1335  */
1336 static int
1337 megaraid_mbox_mksgl(adapter_t *adapter, scb_t *scb)
1338 {
1339 	struct scatterlist	*sgl;
1340 	mbox_ccb_t		*ccb;
1341 	struct scsi_cmnd	*scp;
1342 	int			sgcnt;
1343 	int			i;
1344 
1345 
1346 	scp	= scb->scp;
1347 	ccb	= (mbox_ccb_t *)scb->ccb;
1348 
1349 	sgcnt = scsi_dma_map(scp);
1350 	BUG_ON(sgcnt < 0 || sgcnt > adapter->sglen);
1351 
1352 	// no mapping required if no data to be transferred
1353 	if (!sgcnt)
1354 		return 0;
1355 
1356 	scb->dma_type = MRAID_DMA_WSG;
1357 
1358 	scsi_for_each_sg(scp, sgl, sgcnt, i) {
1359 		ccb->sgl64[i].address	= sg_dma_address(sgl);
1360 		ccb->sgl64[i].length	= sg_dma_len(sgl);
1361 	}
1362 
1363 	// Return count of SG nodes
1364 	return sgcnt;
1365 }
1366 
1367 
1368 /**
1369  * mbox_post_cmd - issue a mailbox command
1370  * @adapter	: controller's soft state
1371  * @scb		: command to be issued
1372  *
1373  * Post the command to the controller if mailbox is available.
1374  */
1375 static int
1376 mbox_post_cmd(adapter_t *adapter, scb_t *scb)
1377 {
1378 	mraid_device_t	*raid_dev = ADAP2RAIDDEV(adapter);
1379 	mbox64_t	*mbox64;
1380 	mbox_t		*mbox;
1381 	mbox_ccb_t	*ccb;
1382 	unsigned long	flags;
1383 	unsigned int	i = 0;
1384 
1385 
1386 	ccb	= (mbox_ccb_t *)scb->ccb;
1387 	mbox	= raid_dev->mbox;
1388 	mbox64	= raid_dev->mbox64;
1389 
1390 	/*
1391 	 * Check for busy mailbox. If it is, return failure - the caller
1392 	 * should retry later.
1393 	 */
1394 	spin_lock_irqsave(MAILBOX_LOCK(raid_dev), flags);
1395 
1396 	if (unlikely(mbox->busy)) {
1397 		do {
1398 			udelay(1);
1399 			i++;
1400 			rmb();
1401 		} while(mbox->busy && (i < max_mbox_busy_wait));
1402 
1403 		if (mbox->busy) {
1404 
1405 			spin_unlock_irqrestore(MAILBOX_LOCK(raid_dev), flags);
1406 
1407 			return -1;
1408 		}
1409 	}
1410 
1411 
1412 	// Copy this command's mailbox data into "adapter's" mailbox
1413 	memcpy((caddr_t)mbox64, (caddr_t)ccb->mbox64, 22);
1414 	mbox->cmdid = scb->sno;
1415 
1416 	adapter->outstanding_cmds++;
1417 
1418 	mbox->busy	= 1;	// Set busy
1419 	mbox->poll	= 0;
1420 	mbox->ack	= 0;
1421 	wmb();
1422 
1423 	WRINDOOR(raid_dev, raid_dev->mbox_dma | 0x1);
1424 
1425 	spin_unlock_irqrestore(MAILBOX_LOCK(raid_dev), flags);
1426 
1427 	return 0;
1428 }
1429 
1430 
1431 /**
1432  * megaraid_queue_command_lck - generic queue entry point for all LLDs
1433  * @scp		: pointer to the scsi command to be executed
1434  *
1435  * Queue entry point for mailbox based controllers.
1436  */
1437 static int megaraid_queue_command_lck(struct scsi_cmnd *scp)
1438 {
1439 	void (*done)(struct scsi_cmnd *) = scsi_done;
1440 	adapter_t	*adapter;
1441 	scb_t		*scb;
1442 	int		if_busy;
1443 
1444 	adapter		= SCP2ADAPTER(scp);
1445 	scp->result	= 0;
1446 
1447 	/*
1448 	 * Allocate and build a SCB request
1449 	 * if_busy flag will be set if megaraid_mbox_build_cmd() command could
1450 	 * not allocate scb. We will return non-zero status in that case.
1451 	 * NOTE: scb can be null even though certain commands completed
1452 	 * successfully, e.g., MODE_SENSE and TEST_UNIT_READY, it would
1453 	 * return 0 in that case, and we would do the callback right away.
1454 	 */
1455 	if_busy	= 0;
1456 	scb = megaraid_mbox_build_cmd(adapter, scp, &if_busy);
1457 	if (!scb) {	// command already completed
1458 		done(scp);
1459 		return 0;
1460 	}
1461 
1462 	megaraid_mbox_runpendq(adapter, scb);
1463 	return if_busy;
1464 }
1465 
1466 static DEF_SCSI_QCMD(megaraid_queue_command)
1467 
1468 /**
1469  * megaraid_mbox_build_cmd - transform the mid-layer scsi commands
1470  * @adapter	: controller's soft state
1471  * @scp		: mid-layer scsi command pointer
1472  * @busy	: set if request could not be completed because of lack of
1473  *		resources
1474  *
1475  * Transform the mid-layer scsi command to megaraid firmware lingua.
1476  * Convert the command issued by mid-layer to format understood by megaraid
1477  * firmware. We also complete certain commands without sending them to firmware.
1478  */
1479 static scb_t *
1480 megaraid_mbox_build_cmd(adapter_t *adapter, struct scsi_cmnd *scp, int *busy)
1481 {
1482 	mraid_device_t		*rdev = ADAP2RAIDDEV(adapter);
1483 	int			channel;
1484 	int			target;
1485 	int			islogical;
1486 	mbox_ccb_t		*ccb;
1487 	mraid_passthru_t	*pthru;
1488 	mbox64_t		*mbox64;
1489 	mbox_t			*mbox;
1490 	scb_t			*scb;
1491 	char			skip[] = "skipping";
1492 	char			scan[] = "scanning";
1493 	char			*ss;
1494 
1495 
1496 	/*
1497 	 * Get the appropriate device map for the device this command is
1498 	 * intended for
1499 	 */
1500 	MRAID_GET_DEVICE_MAP(adapter, scp, channel, target, islogical);
1501 
1502 	/*
1503 	 * Logical drive commands
1504 	 */
1505 	if (islogical) {
1506 		switch (scp->cmnd[0]) {
1507 		case TEST_UNIT_READY:
1508 			/*
1509 			 * Do we support clustering and is the support enabled
1510 			 * If no, return success always
1511 			 */
1512 			if (!adapter->ha) {
1513 				scp->result = (DID_OK << 16);
1514 				return NULL;
1515 			}
1516 
1517 			if (!(scb = megaraid_alloc_scb(adapter, scp))) {
1518 				scp->result = (DID_ERROR << 16);
1519 				*busy = 1;
1520 				return NULL;
1521 			}
1522 
1523 			scb->dma_direction	= scp->sc_data_direction;
1524 			scb->dev_channel	= 0xFF;
1525 			scb->dev_target		= target;
1526 			ccb			= (mbox_ccb_t *)scb->ccb;
1527 
1528 			/*
1529 			 * The command id will be provided by the command
1530 			 * issuance routine
1531 			 */
1532 			ccb->raw_mbox[0]	= CLUSTER_CMD;
1533 			ccb->raw_mbox[2]	= RESERVATION_STATUS;
1534 			ccb->raw_mbox[3]	= target;
1535 
1536 			return scb;
1537 
1538 		case MODE_SENSE:
1539 		{
1540 			struct scatterlist	*sgl;
1541 			caddr_t			vaddr;
1542 
1543 			sgl = scsi_sglist(scp);
1544 			if (sg_page(sgl)) {
1545 				vaddr = (caddr_t) sg_virt(&sgl[0]);
1546 
1547 				memset(vaddr, 0, scp->cmnd[4]);
1548 			}
1549 			else {
1550 				con_log(CL_ANN, (KERN_WARNING
1551 						 "megaraid mailbox: invalid sg:%d\n",
1552 						 __LINE__));
1553 			}
1554 		}
1555 		scp->result = (DID_OK << 16);
1556 		return NULL;
1557 
1558 		case INQUIRY:
1559 			/*
1560 			 * Display the channel scan for logical drives
1561 			 * Do not display scan for a channel if already done.
1562 			 */
1563 			if (!(rdev->last_disp & (1L << SCP2CHANNEL(scp)))) {
1564 
1565 				con_log(CL_ANN, (KERN_INFO
1566 					"scsi[%d]: scanning scsi channel %d",
1567 					adapter->host->host_no,
1568 					SCP2CHANNEL(scp)));
1569 
1570 				con_log(CL_ANN, (
1571 					" [virtual] for logical drives\n"));
1572 
1573 				rdev->last_disp |= (1L << SCP2CHANNEL(scp));
1574 			}
1575 
1576 			if (scp->cmnd[1] & MEGA_SCSI_INQ_EVPD) {
1577 				scsi_build_sense(scp, 0, ILLEGAL_REQUEST,
1578 						 MEGA_INVALID_FIELD_IN_CDB, 0);
1579 				return NULL;
1580 			}
1581 
1582 			fallthrough;
1583 
1584 		case READ_CAPACITY:
1585 			/*
1586 			 * Do not allow LUN > 0 for logical drives and
1587 			 * requests for more than 40 logical drives
1588 			 */
1589 			if (SCP2LUN(scp)) {
1590 				scp->result = (DID_BAD_TARGET << 16);
1591 				return NULL;
1592 			}
1593 			if ((target % 0x80) >= MAX_LOGICAL_DRIVES_40LD) {
1594 				scp->result = (DID_BAD_TARGET << 16);
1595 				return NULL;
1596 			}
1597 
1598 
1599 			/* Allocate a SCB and initialize passthru */
1600 			if (!(scb = megaraid_alloc_scb(adapter, scp))) {
1601 				scp->result = (DID_ERROR << 16);
1602 				*busy = 1;
1603 				return NULL;
1604 			}
1605 
1606 			ccb			= (mbox_ccb_t *)scb->ccb;
1607 			scb->dev_channel	= 0xFF;
1608 			scb->dev_target		= target;
1609 			pthru			= ccb->pthru;
1610 			mbox			= ccb->mbox;
1611 			mbox64			= ccb->mbox64;
1612 
1613 			pthru->timeout		= 0;
1614 			pthru->ars		= 1;
1615 			pthru->reqsenselen	= 14;
1616 			pthru->islogical	= 1;
1617 			pthru->logdrv		= target;
1618 			pthru->cdblen		= scp->cmd_len;
1619 			memcpy(pthru->cdb, scp->cmnd, scp->cmd_len);
1620 
1621 			mbox->cmd		= MBOXCMD_PASSTHRU64;
1622 			scb->dma_direction	= scp->sc_data_direction;
1623 
1624 			pthru->dataxferlen	= scsi_bufflen(scp);
1625 			pthru->dataxferaddr	= ccb->sgl_dma_h;
1626 			pthru->numsge		= megaraid_mbox_mksgl(adapter,
1627 							scb);
1628 
1629 			mbox->xferaddr		= 0xFFFFFFFF;
1630 			mbox64->xferaddr_lo	= (uint32_t )ccb->pthru_dma_h;
1631 			mbox64->xferaddr_hi	= 0;
1632 
1633 			return scb;
1634 
1635 		case READ_6:
1636 		case WRITE_6:
1637 		case READ_10:
1638 		case WRITE_10:
1639 		case READ_12:
1640 		case WRITE_12:
1641 
1642 			/*
1643 			 * Allocate a SCB and initialize mailbox
1644 			 */
1645 			if (!(scb = megaraid_alloc_scb(adapter, scp))) {
1646 				scp->result = (DID_ERROR << 16);
1647 				*busy = 1;
1648 				return NULL;
1649 			}
1650 			ccb			= (mbox_ccb_t *)scb->ccb;
1651 			scb->dev_channel	= 0xFF;
1652 			scb->dev_target		= target;
1653 			mbox			= ccb->mbox;
1654 			mbox64			= ccb->mbox64;
1655 			mbox->logdrv		= target;
1656 
1657 			/*
1658 			 * A little HACK: 2nd bit is zero for all scsi read
1659 			 * commands and is set for all scsi write commands
1660 			 */
1661 			mbox->cmd = (scp->cmnd[0] & 0x02) ?  MBOXCMD_LWRITE64:
1662 					MBOXCMD_LREAD64 ;
1663 
1664 			/*
1665 			 * 6-byte READ(0x08) or WRITE(0x0A) cdb
1666 			 */
1667 			if (scp->cmd_len == 6) {
1668 				mbox->numsectors = (uint32_t)scp->cmnd[4];
1669 				mbox->lba =
1670 					((uint32_t)scp->cmnd[1] << 16)	|
1671 					((uint32_t)scp->cmnd[2] << 8)	|
1672 					(uint32_t)scp->cmnd[3];
1673 
1674 				mbox->lba &= 0x1FFFFF;
1675 			}
1676 
1677 			/*
1678 			 * 10-byte READ(0x28) or WRITE(0x2A) cdb
1679 			 */
1680 			else if (scp->cmd_len == 10) {
1681 				mbox->numsectors =
1682 					(uint32_t)scp->cmnd[8] |
1683 					((uint32_t)scp->cmnd[7] << 8);
1684 				mbox->lba =
1685 					((uint32_t)scp->cmnd[2] << 24) |
1686 					((uint32_t)scp->cmnd[3] << 16) |
1687 					((uint32_t)scp->cmnd[4] << 8) |
1688 					(uint32_t)scp->cmnd[5];
1689 			}
1690 
1691 			/*
1692 			 * 12-byte READ(0xA8) or WRITE(0xAA) cdb
1693 			 */
1694 			else if (scp->cmd_len == 12) {
1695 				mbox->lba =
1696 					((uint32_t)scp->cmnd[2] << 24) |
1697 					((uint32_t)scp->cmnd[3] << 16) |
1698 					((uint32_t)scp->cmnd[4] << 8) |
1699 					(uint32_t)scp->cmnd[5];
1700 
1701 				mbox->numsectors =
1702 					((uint32_t)scp->cmnd[6] << 24) |
1703 					((uint32_t)scp->cmnd[7] << 16) |
1704 					((uint32_t)scp->cmnd[8] << 8) |
1705 					(uint32_t)scp->cmnd[9];
1706 			}
1707 			else {
1708 				con_log(CL_ANN, (KERN_WARNING
1709 					"megaraid: unsupported CDB length\n"));
1710 
1711 				megaraid_dealloc_scb(adapter, scb);
1712 
1713 				scp->result = (DID_ERROR << 16);
1714 				return NULL;
1715 			}
1716 
1717 			scb->dma_direction = scp->sc_data_direction;
1718 
1719 			// Calculate Scatter-Gather info
1720 			mbox64->xferaddr_lo	= (uint32_t )ccb->sgl_dma_h;
1721 			mbox->numsge		= megaraid_mbox_mksgl(adapter,
1722 							scb);
1723 			mbox->xferaddr		= 0xFFFFFFFF;
1724 			mbox64->xferaddr_hi	= 0;
1725 
1726 			return scb;
1727 
1728 		case RESERVE:
1729 		case RELEASE:
1730 			/*
1731 			 * Do we support clustering and is the support enabled
1732 			 */
1733 			if (!adapter->ha) {
1734 				scp->result = (DID_BAD_TARGET << 16);
1735 				return NULL;
1736 			}
1737 
1738 			/*
1739 			 * Allocate a SCB and initialize mailbox
1740 			 */
1741 			if (!(scb = megaraid_alloc_scb(adapter, scp))) {
1742 				scp->result = (DID_ERROR << 16);
1743 				*busy = 1;
1744 				return NULL;
1745 			}
1746 
1747 			ccb			= (mbox_ccb_t *)scb->ccb;
1748 			scb->dev_channel	= 0xFF;
1749 			scb->dev_target		= target;
1750 			ccb->raw_mbox[0]	= CLUSTER_CMD;
1751 			ccb->raw_mbox[2]	=  (scp->cmnd[0] == RESERVE) ?
1752 						RESERVE_LD : RELEASE_LD;
1753 
1754 			ccb->raw_mbox[3]	= target;
1755 			scb->dma_direction	= scp->sc_data_direction;
1756 
1757 			return scb;
1758 
1759 		default:
1760 			scp->result = (DID_BAD_TARGET << 16);
1761 			return NULL;
1762 		}
1763 	}
1764 	else { // Passthru device commands
1765 
1766 		// Do not allow access to target id > 15 or LUN > 7
1767 		if (target > 15 || SCP2LUN(scp) > 7) {
1768 			scp->result = (DID_BAD_TARGET << 16);
1769 			return NULL;
1770 		}
1771 
1772 		// if fast load option was set and scan for last device is
1773 		// over, reset the fast_load flag so that during a possible
1774 		// next scan, devices can be made available
1775 		if (rdev->fast_load && (target == 15) &&
1776 			(SCP2CHANNEL(scp) == adapter->max_channel -1)) {
1777 
1778 			con_log(CL_ANN, (KERN_INFO
1779 			"megaraid[%d]: physical device scan re-enabled\n",
1780 				adapter->host->host_no));
1781 			rdev->fast_load = 0;
1782 		}
1783 
1784 		/*
1785 		 * Display the channel scan for physical devices
1786 		 */
1787 		if (!(rdev->last_disp & (1L << SCP2CHANNEL(scp)))) {
1788 
1789 			ss = rdev->fast_load ? skip : scan;
1790 
1791 			con_log(CL_ANN, (KERN_INFO
1792 				"scsi[%d]: %s scsi channel %d [Phy %d]",
1793 				adapter->host->host_no, ss, SCP2CHANNEL(scp),
1794 				channel));
1795 
1796 			con_log(CL_ANN, (
1797 				" for non-raid devices\n"));
1798 
1799 			rdev->last_disp |= (1L << SCP2CHANNEL(scp));
1800 		}
1801 
1802 		// disable channel sweep if fast load option given
1803 		if (rdev->fast_load) {
1804 			scp->result = (DID_BAD_TARGET << 16);
1805 			return NULL;
1806 		}
1807 
1808 		// Allocate a SCB and initialize passthru
1809 		if (!(scb = megaraid_alloc_scb(adapter, scp))) {
1810 			scp->result = (DID_ERROR << 16);
1811 			*busy = 1;
1812 			return NULL;
1813 		}
1814 
1815 		ccb			= (mbox_ccb_t *)scb->ccb;
1816 		scb->dev_channel	= channel;
1817 		scb->dev_target		= target;
1818 		scb->dma_direction	= scp->sc_data_direction;
1819 		mbox			= ccb->mbox;
1820 		mbox64			= ccb->mbox64;
1821 
1822 		// Does this firmware support extended CDBs
1823 		if (adapter->max_cdb_sz == 16) {
1824 			mbox->cmd		= MBOXCMD_EXTPTHRU;
1825 
1826 			megaraid_mbox_prepare_epthru(adapter, scb, scp);
1827 
1828 			mbox64->xferaddr_lo	= (uint32_t)ccb->epthru_dma_h;
1829 			mbox64->xferaddr_hi	= 0;
1830 			mbox->xferaddr		= 0xFFFFFFFF;
1831 		}
1832 		else {
1833 			mbox->cmd = MBOXCMD_PASSTHRU64;
1834 
1835 			megaraid_mbox_prepare_pthru(adapter, scb, scp);
1836 
1837 			mbox64->xferaddr_lo	= (uint32_t)ccb->pthru_dma_h;
1838 			mbox64->xferaddr_hi	= 0;
1839 			mbox->xferaddr		= 0xFFFFFFFF;
1840 		}
1841 		return scb;
1842 	}
1843 
1844 	// NOT REACHED
1845 }
1846 
1847 
1848 /**
1849  * megaraid_mbox_runpendq - execute commands queued in the pending queue
1850  * @adapter	: controller's soft state
1851  * @scb_q	: SCB to be queued in the pending list
1852  *
1853  * Scan the pending list for commands which are not yet issued and try to
1854  * post to the controller. The SCB can be a null pointer, which would indicate
1855  * no SCB to be queue, just try to execute the ones in the pending list.
1856  *
1857  * NOTE: We do not actually traverse the pending list. The SCBs are plucked
1858  * out from the head of the pending list. If it is successfully issued, the
1859  * next SCB is at the head now.
1860  */
1861 static void
1862 megaraid_mbox_runpendq(adapter_t *adapter, scb_t *scb_q)
1863 {
1864 	scb_t			*scb;
1865 	unsigned long		flags;
1866 
1867 	spin_lock_irqsave(PENDING_LIST_LOCK(adapter), flags);
1868 
1869 	if (scb_q) {
1870 		scb_q->state = SCB_PENDQ;
1871 		list_add_tail(&scb_q->list, &adapter->pend_list);
1872 	}
1873 
1874 	// if the adapter in not in quiescent mode, post the commands to FW
1875 	if (adapter->quiescent) {
1876 		spin_unlock_irqrestore(PENDING_LIST_LOCK(adapter), flags);
1877 		return;
1878 	}
1879 
1880 	while (!list_empty(&adapter->pend_list)) {
1881 
1882 		assert_spin_locked(PENDING_LIST_LOCK(adapter));
1883 
1884 		scb = list_entry(adapter->pend_list.next, scb_t, list);
1885 
1886 		// remove the scb from the pending list and try to
1887 		// issue. If we are unable to issue it, put back in
1888 		// the pending list and return
1889 
1890 		list_del_init(&scb->list);
1891 
1892 		spin_unlock_irqrestore(PENDING_LIST_LOCK(adapter), flags);
1893 
1894 		// if mailbox was busy, return SCB back to pending
1895 		// list. Make sure to add at the head, since that's
1896 		// where it would have been removed from
1897 
1898 		scb->state = SCB_ISSUED;
1899 
1900 		if (mbox_post_cmd(adapter, scb) != 0) {
1901 
1902 			spin_lock_irqsave(PENDING_LIST_LOCK(adapter), flags);
1903 
1904 			scb->state = SCB_PENDQ;
1905 
1906 			list_add(&scb->list, &adapter->pend_list);
1907 
1908 			spin_unlock_irqrestore(PENDING_LIST_LOCK(adapter),
1909 				flags);
1910 
1911 			return;
1912 		}
1913 
1914 		spin_lock_irqsave(PENDING_LIST_LOCK(adapter), flags);
1915 	}
1916 
1917 	spin_unlock_irqrestore(PENDING_LIST_LOCK(adapter), flags);
1918 
1919 
1920 	return;
1921 }
1922 
1923 
1924 /**
1925  * megaraid_mbox_prepare_pthru - prepare a command for physical devices
1926  * @adapter	: pointer to controller's soft state
1927  * @scb		: scsi control block
1928  * @scp		: scsi command from the mid-layer
1929  *
1930  * Prepare a command for the scsi physical devices.
1931  */
1932 static void
1933 megaraid_mbox_prepare_pthru(adapter_t *adapter, scb_t *scb,
1934 		struct scsi_cmnd *scp)
1935 {
1936 	mbox_ccb_t		*ccb;
1937 	mraid_passthru_t	*pthru;
1938 	uint8_t			channel;
1939 	uint8_t			target;
1940 
1941 	ccb	= (mbox_ccb_t *)scb->ccb;
1942 	pthru	= ccb->pthru;
1943 	channel	= scb->dev_channel;
1944 	target	= scb->dev_target;
1945 
1946 	// 0=6sec, 1=60sec, 2=10min, 3=3hrs, 4=NO timeout
1947 	pthru->timeout		= 4;
1948 	pthru->ars		= 1;
1949 	pthru->islogical	= 0;
1950 	pthru->channel		= 0;
1951 	pthru->target		= (channel << 4) | target;
1952 	pthru->logdrv		= SCP2LUN(scp);
1953 	pthru->reqsenselen	= 14;
1954 	pthru->cdblen		= scp->cmd_len;
1955 
1956 	memcpy(pthru->cdb, scp->cmnd, scp->cmd_len);
1957 
1958 	if (scsi_bufflen(scp)) {
1959 		pthru->dataxferlen	= scsi_bufflen(scp);
1960 		pthru->dataxferaddr	= ccb->sgl_dma_h;
1961 		pthru->numsge		= megaraid_mbox_mksgl(adapter, scb);
1962 	}
1963 	else {
1964 		pthru->dataxferaddr	= 0;
1965 		pthru->dataxferlen	= 0;
1966 		pthru->numsge		= 0;
1967 	}
1968 	return;
1969 }
1970 
1971 
1972 /**
1973  * megaraid_mbox_prepare_epthru - prepare a command for physical devices
1974  * @adapter	: pointer to controller's soft state
1975  * @scb		: scsi control block
1976  * @scp		: scsi command from the mid-layer
1977  *
1978  * Prepare a command for the scsi physical devices. This routine prepares
1979  * commands for devices which can take extended CDBs (>10 bytes).
1980  */
1981 static void
1982 megaraid_mbox_prepare_epthru(adapter_t *adapter, scb_t *scb,
1983 		struct scsi_cmnd *scp)
1984 {
1985 	mbox_ccb_t		*ccb;
1986 	mraid_epassthru_t	*epthru;
1987 	uint8_t			channel;
1988 	uint8_t			target;
1989 
1990 	ccb	= (mbox_ccb_t *)scb->ccb;
1991 	epthru	= ccb->epthru;
1992 	channel	= scb->dev_channel;
1993 	target	= scb->dev_target;
1994 
1995 	// 0=6sec, 1=60sec, 2=10min, 3=3hrs, 4=NO timeout
1996 	epthru->timeout		= 4;
1997 	epthru->ars		= 1;
1998 	epthru->islogical	= 0;
1999 	epthru->channel		= 0;
2000 	epthru->target		= (channel << 4) | target;
2001 	epthru->logdrv		= SCP2LUN(scp);
2002 	epthru->reqsenselen	= 14;
2003 	epthru->cdblen		= scp->cmd_len;
2004 
2005 	memcpy(epthru->cdb, scp->cmnd, scp->cmd_len);
2006 
2007 	if (scsi_bufflen(scp)) {
2008 		epthru->dataxferlen	= scsi_bufflen(scp);
2009 		epthru->dataxferaddr	= ccb->sgl_dma_h;
2010 		epthru->numsge		= megaraid_mbox_mksgl(adapter, scb);
2011 	}
2012 	else {
2013 		epthru->dataxferaddr	= 0;
2014 		epthru->dataxferlen	= 0;
2015 		epthru->numsge		= 0;
2016 	}
2017 	return;
2018 }
2019 
2020 
2021 /**
2022  * megaraid_ack_sequence - interrupt ack sequence for memory mapped HBAs
2023  * @adapter	: controller's soft state
2024  *
2025  * Interrupt acknowledgement sequence for memory mapped HBAs. Find out the
2026  * completed command and put them on the completed list for later processing.
2027  *
2028  * Returns:	1 if the interrupt is valid, 0 otherwise
2029  */
2030 static int
2031 megaraid_ack_sequence(adapter_t *adapter)
2032 {
2033 	mraid_device_t		*raid_dev = ADAP2RAIDDEV(adapter);
2034 	mbox_t			*mbox;
2035 	scb_t			*scb;
2036 	uint8_t			nstatus;
2037 	uint8_t			completed[MBOX_MAX_FIRMWARE_STATUS];
2038 	struct list_head	clist;
2039 	int			handled;
2040 	uint32_t		dword;
2041 	unsigned long		flags;
2042 	int			i, j;
2043 
2044 
2045 	mbox	= raid_dev->mbox;
2046 
2047 	// move the SCBs from the firmware completed array to our local list
2048 	INIT_LIST_HEAD(&clist);
2049 
2050 	// loop till F/W has more commands for us to complete
2051 	handled = 0;
2052 	spin_lock_irqsave(MAILBOX_LOCK(raid_dev), flags);
2053 	do {
2054 		/*
2055 		 * Check if a valid interrupt is pending. If found, force the
2056 		 * interrupt line low.
2057 		 */
2058 		dword = RDOUTDOOR(raid_dev);
2059 		if (dword != 0x10001234) break;
2060 
2061 		handled = 1;
2062 
2063 		WROUTDOOR(raid_dev, 0x10001234);
2064 
2065 		nstatus = 0;
2066 		// wait for valid numstatus to post
2067 		for (i = 0; i < 0xFFFFF; i++) {
2068 			if (mbox->numstatus != 0xFF) {
2069 				nstatus = mbox->numstatus;
2070 				break;
2071 			}
2072 			rmb();
2073 		}
2074 		mbox->numstatus = 0xFF;
2075 
2076 		adapter->outstanding_cmds -= nstatus;
2077 
2078 		for (i = 0; i < nstatus; i++) {
2079 
2080 			// wait for valid command index to post
2081 			for (j = 0; j < 0xFFFFF; j++) {
2082 				if (mbox->completed[i] != 0xFF) break;
2083 				rmb();
2084 			}
2085 			completed[i]		= mbox->completed[i];
2086 			mbox->completed[i]	= 0xFF;
2087 
2088 			if (completed[i] == 0xFF) {
2089 				con_log(CL_ANN, (KERN_CRIT
2090 				"megaraid: command posting timed out\n"));
2091 
2092 				BUG();
2093 				continue;
2094 			}
2095 
2096 			// Get SCB associated with this command id
2097 			if (completed[i] >= MBOX_MAX_SCSI_CMDS) {
2098 				// a cmm command
2099 				scb = adapter->uscb_list + (completed[i] -
2100 						MBOX_MAX_SCSI_CMDS);
2101 			}
2102 			else {
2103 				// an os command
2104 				scb = adapter->kscb_list + completed[i];
2105 			}
2106 
2107 			scb->status = mbox->status;
2108 			list_add_tail(&scb->list, &clist);
2109 		}
2110 
2111 		// Acknowledge interrupt
2112 		WRINDOOR(raid_dev, 0x02);
2113 
2114 	} while(1);
2115 
2116 	spin_unlock_irqrestore(MAILBOX_LOCK(raid_dev), flags);
2117 
2118 
2119 	// put the completed commands in the completed list. DPC would
2120 	// complete these commands later
2121 	spin_lock_irqsave(COMPLETED_LIST_LOCK(adapter), flags);
2122 
2123 	list_splice(&clist, &adapter->completed_list);
2124 
2125 	spin_unlock_irqrestore(COMPLETED_LIST_LOCK(adapter), flags);
2126 
2127 
2128 	// schedule the DPC if there is some work for it
2129 	if (handled)
2130 		tasklet_schedule(&adapter->dpc_h);
2131 
2132 	return handled;
2133 }
2134 
2135 
2136 /**
2137  * megaraid_isr - isr for memory based mailbox based controllers
2138  * @irq		: irq
2139  * @devp	: pointer to our soft state
2140  *
2141  * Interrupt service routine for memory-mapped mailbox controllers.
2142  */
2143 static irqreturn_t
2144 megaraid_isr(int irq, void *devp)
2145 {
2146 	adapter_t	*adapter = devp;
2147 	int		handled;
2148 
2149 	handled = megaraid_ack_sequence(adapter);
2150 
2151 	/* Loop through any pending requests */
2152 	if (!adapter->quiescent) {
2153 		megaraid_mbox_runpendq(adapter, NULL);
2154 	}
2155 
2156 	return IRQ_RETVAL(handled);
2157 }
2158 
2159 
2160 /**
2161  * megaraid_mbox_dpc - the tasklet to complete the commands from completed list
2162  * @devp	: pointer to HBA soft state
2163  *
2164  * Pick up the commands from the completed list and send back to the owners.
2165  * This is a reentrant function and does not assume any locks are held while
2166  * it is being called.
2167  */
2168 static void
2169 megaraid_mbox_dpc(unsigned long devp)
2170 {
2171 	adapter_t		*adapter = (adapter_t *)devp;
2172 	mraid_device_t		*raid_dev;
2173 	struct list_head	clist;
2174 	struct scatterlist	*sgl;
2175 	scb_t			*scb;
2176 	scb_t			*tmp;
2177 	struct scsi_cmnd	*scp;
2178 	mraid_passthru_t	*pthru;
2179 	mraid_epassthru_t	*epthru;
2180 	mbox_ccb_t		*ccb;
2181 	int			islogical;
2182 	int			pdev_index;
2183 	int			pdev_state;
2184 	mbox_t			*mbox;
2185 	unsigned long		flags;
2186 	uint8_t			c;
2187 	int			status;
2188 	uioc_t			*kioc;
2189 
2190 
2191 	if (!adapter) return;
2192 
2193 	raid_dev = ADAP2RAIDDEV(adapter);
2194 
2195 	// move the SCBs from the completed list to our local list
2196 	INIT_LIST_HEAD(&clist);
2197 
2198 	spin_lock_irqsave(COMPLETED_LIST_LOCK(adapter), flags);
2199 
2200 	list_splice_init(&adapter->completed_list, &clist);
2201 
2202 	spin_unlock_irqrestore(COMPLETED_LIST_LOCK(adapter), flags);
2203 
2204 
2205 	list_for_each_entry_safe(scb, tmp, &clist, list) {
2206 
2207 		status		= scb->status;
2208 		scp		= scb->scp;
2209 		ccb		= (mbox_ccb_t *)scb->ccb;
2210 		pthru		= ccb->pthru;
2211 		epthru		= ccb->epthru;
2212 		mbox		= ccb->mbox;
2213 
2214 		// Make sure f/w has completed a valid command
2215 		if (scb->state != SCB_ISSUED) {
2216 			con_log(CL_ANN, (KERN_CRIT
2217 			"megaraid critical err: invalid command %d:%d:%p\n",
2218 				scb->sno, scb->state, scp));
2219 			BUG();
2220 			continue;	// Must never happen!
2221 		}
2222 
2223 		// check for the management command and complete it right away
2224 		if (scb->sno >= MBOX_MAX_SCSI_CMDS) {
2225 			scb->state	= SCB_FREE;
2226 			scb->status	= status;
2227 
2228 			// remove from local clist
2229 			list_del_init(&scb->list);
2230 
2231 			kioc			= (uioc_t *)scb->gp;
2232 			kioc->status		= 0;
2233 
2234 			megaraid_mbox_mm_done(adapter, scb);
2235 
2236 			continue;
2237 		}
2238 
2239 		// Was an abort issued for this command earlier
2240 		if (scb->state & SCB_ABORT) {
2241 			con_log(CL_ANN, (KERN_NOTICE
2242 			"megaraid: aborted cmd [%x] completed\n",
2243 				scb->sno));
2244 		}
2245 
2246 		/*
2247 		 * If the inquiry came of a disk drive which is not part of
2248 		 * any RAID array, expose it to the kernel. For this to be
2249 		 * enabled, user must set the "megaraid_expose_unconf_disks"
2250 		 * flag to 1 by specifying it on module parameter list.
2251 		 * This would enable data migration off drives from other
2252 		 * configurations.
2253 		 */
2254 		islogical = MRAID_IS_LOGICAL(adapter, scp);
2255 		if (scp->cmnd[0] == INQUIRY && status == 0 && islogical == 0
2256 				&& IS_RAID_CH(raid_dev, scb->dev_channel)) {
2257 
2258 			sgl = scsi_sglist(scp);
2259 			if (sg_page(sgl)) {
2260 				c = *(unsigned char *) sg_virt(&sgl[0]);
2261 			} else {
2262 				con_log(CL_ANN, (KERN_WARNING
2263 						 "megaraid mailbox: invalid sg:%d\n",
2264 						 __LINE__));
2265 				c = 0;
2266 			}
2267 
2268 			if ((c & 0x1F ) == TYPE_DISK) {
2269 				pdev_index = (scb->dev_channel * 16) +
2270 					scb->dev_target;
2271 				pdev_state =
2272 					raid_dev->pdrv_state[pdev_index] & 0x0F;
2273 
2274 				if (pdev_state == PDRV_ONLINE		||
2275 					pdev_state == PDRV_FAILED	||
2276 					pdev_state == PDRV_RBLD		||
2277 					pdev_state == PDRV_HOTSPARE	||
2278 					megaraid_expose_unconf_disks == 0) {
2279 
2280 					status = 0xF0;
2281 				}
2282 			}
2283 		}
2284 
2285 		// Convert MegaRAID status to Linux error code
2286 		switch (status) {
2287 
2288 		case 0x00:
2289 
2290 			scp->result = (DID_OK << 16);
2291 			break;
2292 
2293 		case 0x02:
2294 
2295 			/* set sense_buffer and result fields */
2296 			if (mbox->cmd == MBOXCMD_PASSTHRU ||
2297 				mbox->cmd == MBOXCMD_PASSTHRU64) {
2298 
2299 				memcpy(scp->sense_buffer, pthru->reqsensearea,
2300 						14);
2301 
2302 				scp->result = SAM_STAT_CHECK_CONDITION;
2303 			}
2304 			else {
2305 				if (mbox->cmd == MBOXCMD_EXTPTHRU) {
2306 
2307 					memcpy(scp->sense_buffer,
2308 						epthru->reqsensearea, 14);
2309 
2310 					scp->result = SAM_STAT_CHECK_CONDITION;
2311 				} else
2312 					scsi_build_sense(scp, 0,
2313 							 ABORTED_COMMAND, 0, 0);
2314 			}
2315 			break;
2316 
2317 		case 0x08:
2318 
2319 			scp->result = DID_BUS_BUSY << 16 | status;
2320 			break;
2321 
2322 		default:
2323 
2324 			/*
2325 			 * If TEST_UNIT_READY fails, we know RESERVATION_STATUS
2326 			 * failed
2327 			 */
2328 			if (scp->cmnd[0] == TEST_UNIT_READY) {
2329 				scp->result = DID_ERROR << 16 |
2330 					SAM_STAT_RESERVATION_CONFLICT;
2331 			}
2332 			else
2333 			/*
2334 			 * Error code returned is 1 if Reserve or Release
2335 			 * failed or the input parameter is invalid
2336 			 */
2337 			if (status == 1 && (scp->cmnd[0] == RESERVE ||
2338 					 scp->cmnd[0] == RELEASE)) {
2339 
2340 				scp->result = DID_ERROR << 16 |
2341 					SAM_STAT_RESERVATION_CONFLICT;
2342 			}
2343 			else {
2344 				scp->result = DID_BAD_TARGET << 16 | status;
2345 			}
2346 		}
2347 
2348 		// print a debug message for all failed commands
2349 		if (status) {
2350 			megaraid_mbox_display_scb(adapter, scb);
2351 		}
2352 
2353 		scsi_dma_unmap(scp);
2354 
2355 		// remove from local clist
2356 		list_del_init(&scb->list);
2357 
2358 		// put back in free list
2359 		megaraid_dealloc_scb(adapter, scb);
2360 
2361 		// send the scsi packet back to kernel
2362 		scsi_done(scp);
2363 	}
2364 
2365 	return;
2366 }
2367 
2368 
2369 /**
2370  * megaraid_abort_handler - abort the scsi command
2371  * @scp		: command to be aborted
2372  *
2373  * Abort a previous SCSI request. Only commands on the pending list can be
2374  * aborted. All the commands issued to the F/W must complete.
2375  **/
2376 static int
2377 megaraid_abort_handler(struct scsi_cmnd *scp)
2378 {
2379 	adapter_t		*adapter;
2380 	mraid_device_t		*raid_dev;
2381 	scb_t			*scb;
2382 	scb_t			*tmp;
2383 	int			found;
2384 	unsigned long		flags;
2385 	int			i;
2386 
2387 
2388 	adapter		= SCP2ADAPTER(scp);
2389 	raid_dev	= ADAP2RAIDDEV(adapter);
2390 
2391 	con_log(CL_ANN, (KERN_WARNING
2392 		"megaraid: aborting cmd=%x <c=%d t=%d l=%d>\n",
2393 		scp->cmnd[0], SCP2CHANNEL(scp),
2394 		SCP2TARGET(scp), SCP2LUN(scp)));
2395 
2396 	// If FW has stopped responding, simply return failure
2397 	if (raid_dev->hw_error) {
2398 		con_log(CL_ANN, (KERN_NOTICE
2399 			"megaraid: hw error, not aborting\n"));
2400 		return FAILED;
2401 	}
2402 
2403 	// There might a race here, where the command was completed by the
2404 	// firmware and now it is on the completed list. Before we could
2405 	// complete the command to the kernel in dpc, the abort came.
2406 	// Find out if this is the case to avoid the race.
2407 	scb = NULL;
2408 	spin_lock_irqsave(COMPLETED_LIST_LOCK(adapter), flags);
2409 	list_for_each_entry_safe(scb, tmp, &adapter->completed_list, list) {
2410 
2411 		if (scb->scp == scp) {	// Found command
2412 
2413 			list_del_init(&scb->list);	// from completed list
2414 
2415 			con_log(CL_ANN, (KERN_WARNING
2416 			"megaraid: %d[%d:%d], abort from completed list\n",
2417 				scb->sno, scb->dev_channel, scb->dev_target));
2418 
2419 			scp->result = (DID_ABORT << 16);
2420 			scsi_done(scp);
2421 
2422 			megaraid_dealloc_scb(adapter, scb);
2423 
2424 			spin_unlock_irqrestore(COMPLETED_LIST_LOCK(adapter),
2425 				flags);
2426 
2427 			return SUCCESS;
2428 		}
2429 	}
2430 	spin_unlock_irqrestore(COMPLETED_LIST_LOCK(adapter), flags);
2431 
2432 
2433 	// Find out if this command is still on the pending list. If it is and
2434 	// was never issued, abort and return success. If the command is owned
2435 	// by the firmware, we must wait for it to complete by the FW.
2436 	spin_lock_irqsave(PENDING_LIST_LOCK(adapter), flags);
2437 	list_for_each_entry_safe(scb, tmp, &adapter->pend_list, list) {
2438 
2439 		if (scb->scp == scp) {	// Found command
2440 
2441 			list_del_init(&scb->list);	// from pending list
2442 
2443 			ASSERT(!(scb->state & SCB_ISSUED));
2444 
2445 			con_log(CL_ANN, (KERN_WARNING
2446 				"megaraid abort: [%d:%d], driver owner\n",
2447 				scb->dev_channel, scb->dev_target));
2448 
2449 			scp->result = (DID_ABORT << 16);
2450 			scsi_done(scp);
2451 
2452 			megaraid_dealloc_scb(adapter, scb);
2453 
2454 			spin_unlock_irqrestore(PENDING_LIST_LOCK(adapter),
2455 				flags);
2456 
2457 			return SUCCESS;
2458 		}
2459 	}
2460 	spin_unlock_irqrestore(PENDING_LIST_LOCK(adapter), flags);
2461 
2462 
2463 	// Check do we even own this command, in which case this would be
2464 	// owned by the firmware. The only way to locate the FW scb is to
2465 	// traverse through the list of all SCB, since driver does not
2466 	// maintain these SCBs on any list
2467 	found = 0;
2468 	spin_lock_irq(&adapter->lock);
2469 	for (i = 0; i < MBOX_MAX_SCSI_CMDS; i++) {
2470 		scb = adapter->kscb_list + i;
2471 
2472 		if (scb->scp == scp) {
2473 
2474 			found = 1;
2475 
2476 			if (!(scb->state & SCB_ISSUED)) {
2477 				con_log(CL_ANN, (KERN_WARNING
2478 				"megaraid abort: %d[%d:%d], invalid state\n",
2479 				scb->sno, scb->dev_channel, scb->dev_target));
2480 				BUG();
2481 			}
2482 			else {
2483 				con_log(CL_ANN, (KERN_WARNING
2484 				"megaraid abort: %d[%d:%d], fw owner\n",
2485 				scb->sno, scb->dev_channel, scb->dev_target));
2486 			}
2487 		}
2488 	}
2489 	spin_unlock_irq(&adapter->lock);
2490 
2491 	if (!found) {
2492 		con_log(CL_ANN, (KERN_WARNING "megaraid abort: do now own\n"));
2493 
2494 		// FIXME: Should there be a callback for this command?
2495 		return SUCCESS;
2496 	}
2497 
2498 	// We cannot actually abort a command owned by firmware, return
2499 	// failure and wait for reset. In host reset handler, we will find out
2500 	// if the HBA is still live
2501 	return FAILED;
2502 }
2503 
2504 /**
2505  * megaraid_reset_handler - device reset handler for mailbox based driver
2506  * @scp		: reference command
2507  *
2508  * Reset handler for the mailbox based controller. First try to find out if
2509  * the FW is still live, in which case the outstanding commands counter mut go
2510  * down to 0. If that happens, also issue the reservation reset command to
2511  * relinquish (possible) reservations on the logical drives connected to this
2512  * host.
2513  **/
2514 static int
2515 megaraid_reset_handler(struct scsi_cmnd *scp)
2516 {
2517 	adapter_t	*adapter;
2518 	scb_t		*scb;
2519 	scb_t		*tmp;
2520 	mraid_device_t	*raid_dev;
2521 	unsigned long	flags;
2522 	uint8_t		raw_mbox[sizeof(mbox_t)];
2523 	int		rval;
2524 	int		recovery_window;
2525 	int		i;
2526 	uioc_t		*kioc;
2527 
2528 	adapter		= SCP2ADAPTER(scp);
2529 	raid_dev	= ADAP2RAIDDEV(adapter);
2530 
2531 	// return failure if adapter is not responding
2532 	if (raid_dev->hw_error) {
2533 		con_log(CL_ANN, (KERN_NOTICE
2534 			"megaraid: hw error, cannot reset\n"));
2535 		return FAILED;
2536 	}
2537 
2538 	// Under exceptional conditions, FW can take up to 3 minutes to
2539 	// complete command processing. Wait for additional 2 minutes for the
2540 	// pending commands counter to go down to 0. If it doesn't, let the
2541 	// controller be marked offline
2542 	// Also, reset all the commands currently owned by the driver
2543 	spin_lock_irqsave(PENDING_LIST_LOCK(adapter), flags);
2544 	list_for_each_entry_safe(scb, tmp, &adapter->pend_list, list) {
2545 		list_del_init(&scb->list);	// from pending list
2546 
2547 		if (scb->sno >= MBOX_MAX_SCSI_CMDS) {
2548 			con_log(CL_ANN, (KERN_WARNING
2549 			"megaraid: IOCTL packet with %d[%d:%d] being reset\n",
2550 			scb->sno, scb->dev_channel, scb->dev_target));
2551 
2552 			scb->status = -1;
2553 
2554 			kioc			= (uioc_t *)scb->gp;
2555 			kioc->status		= -EFAULT;
2556 
2557 			megaraid_mbox_mm_done(adapter, scb);
2558 		} else {
2559 			if (scb->scp == scp) {	// Found command
2560 				con_log(CL_ANN, (KERN_WARNING
2561 					"megaraid: %d[%d:%d], reset from pending list\n",
2562 					scb->sno, scb->dev_channel, scb->dev_target));
2563 			} else {
2564 				con_log(CL_ANN, (KERN_WARNING
2565 				"megaraid: IO packet with %d[%d:%d] being reset\n",
2566 				scb->sno, scb->dev_channel, scb->dev_target));
2567 			}
2568 
2569 			scb->scp->result = (DID_RESET << 16);
2570 			scsi_done(scb->scp);
2571 
2572 			megaraid_dealloc_scb(adapter, scb);
2573 		}
2574 	}
2575 	spin_unlock_irqrestore(PENDING_LIST_LOCK(adapter), flags);
2576 
2577 	if (adapter->outstanding_cmds) {
2578 		con_log(CL_ANN, (KERN_NOTICE
2579 			"megaraid: %d outstanding commands. Max wait %d sec\n",
2580 			adapter->outstanding_cmds,
2581 			(MBOX_RESET_WAIT + MBOX_RESET_EXT_WAIT)));
2582 	}
2583 
2584 	recovery_window = MBOX_RESET_WAIT + MBOX_RESET_EXT_WAIT;
2585 
2586 	for (i = 0; i < recovery_window; i++) {
2587 
2588 		megaraid_ack_sequence(adapter);
2589 
2590 		// print a message once every 5 seconds only
2591 		if (!(i % 5)) {
2592 			con_log(CL_ANN, (
2593 			"megaraid mbox: Wait for %d commands to complete:%d\n",
2594 				adapter->outstanding_cmds,
2595 				(MBOX_RESET_WAIT + MBOX_RESET_EXT_WAIT) - i));
2596 		}
2597 
2598 		// bailout if no recovery happened in reset time
2599 		if (adapter->outstanding_cmds == 0) {
2600 			break;
2601 		}
2602 
2603 		msleep(1000);
2604 	}
2605 
2606 	spin_lock(&adapter->lock);
2607 
2608 	// If still outstanding commands, bail out
2609 	if (adapter->outstanding_cmds) {
2610 		con_log(CL_ANN, (KERN_WARNING
2611 			"megaraid mbox: critical hardware error!\n"));
2612 
2613 		raid_dev->hw_error = 1;
2614 
2615 		rval = FAILED;
2616 		goto out;
2617 	}
2618 	else {
2619 		con_log(CL_ANN, (KERN_NOTICE
2620 		"megaraid mbox: reset sequence completed successfully\n"));
2621 	}
2622 
2623 
2624 	// If the controller supports clustering, reset reservations
2625 	if (!adapter->ha) {
2626 		rval = SUCCESS;
2627 		goto out;
2628 	}
2629 
2630 	// clear reservations if any
2631 	raw_mbox[0] = CLUSTER_CMD;
2632 	raw_mbox[2] = RESET_RESERVATIONS;
2633 
2634 	rval = SUCCESS;
2635 	if (mbox_post_sync_cmd_fast(adapter, raw_mbox) == 0) {
2636 		con_log(CL_ANN,
2637 			(KERN_INFO "megaraid: reservation reset\n"));
2638 	}
2639 	else {
2640 		rval = FAILED;
2641 		con_log(CL_ANN, (KERN_WARNING
2642 				"megaraid: reservation reset failed\n"));
2643 	}
2644 
2645  out:
2646 	spin_unlock(&adapter->lock);
2647 	return rval;
2648 }
2649 
2650 /*
2651  * START: internal commands library
2652  *
2653  * This section of the driver has the common routine used by the driver and
2654  * also has all the FW routines
2655  */
2656 
2657 /**
2658  * mbox_post_sync_cmd() - blocking command to the mailbox based controllers
2659  * @adapter	: controller's soft state
2660  * @raw_mbox	: the mailbox
2661  *
2662  * Issue a scb in synchronous and non-interrupt mode for mailbox based
2663  * controllers.
2664  */
2665 static int
2666 mbox_post_sync_cmd(adapter_t *adapter, uint8_t raw_mbox[])
2667 {
2668 	mraid_device_t	*raid_dev = ADAP2RAIDDEV(adapter);
2669 	mbox_t		*mbox;
2670 	uint8_t		status;
2671 	int		i;
2672 
2673 	mbox	= raid_dev->mbox;
2674 
2675 	/*
2676 	 * Wait until mailbox is free
2677 	 */
2678 	if (megaraid_busywait_mbox(raid_dev) != 0)
2679 		goto blocked_mailbox;
2680 
2681 	/*
2682 	 * Copy mailbox data into host structure
2683 	 */
2684 	memcpy((caddr_t)mbox, (caddr_t)raw_mbox, 16);
2685 	mbox->cmdid		= 0xFE;
2686 	mbox->busy		= 1;
2687 	mbox->poll		= 0;
2688 	mbox->ack		= 0;
2689 	mbox->numstatus		= 0xFF;
2690 	mbox->status		= 0xFF;
2691 
2692 	wmb();
2693 	WRINDOOR(raid_dev, raid_dev->mbox_dma | 0x1);
2694 
2695 	// wait for maximum 1 second for status to post. If the status is not
2696 	// available within 1 second, assume FW is initializing and wait
2697 	// for an extended amount of time
2698 	if (mbox->numstatus == 0xFF) {	// status not yet available
2699 		udelay(25);
2700 
2701 		for (i = 0; mbox->numstatus == 0xFF && i < 1000; i++) {
2702 			rmb();
2703 			msleep(1);
2704 		}
2705 
2706 
2707 		if (i == 1000) {
2708 			con_log(CL_ANN, (KERN_NOTICE
2709 				"megaraid mailbox: wait for FW to boot      "));
2710 
2711 			for (i = 0; (mbox->numstatus == 0xFF) &&
2712 					(i < MBOX_RESET_WAIT); i++) {
2713 				rmb();
2714 				con_log(CL_ANN, ("\b\b\b\b\b[%03d]",
2715 							MBOX_RESET_WAIT - i));
2716 				msleep(1000);
2717 			}
2718 
2719 			if (i == MBOX_RESET_WAIT) {
2720 
2721 				con_log(CL_ANN, (
2722 				"\nmegaraid mailbox: status not available\n"));
2723 
2724 				return -1;
2725 			}
2726 			con_log(CL_ANN, ("\b\b\b\b\b[ok] \n"));
2727 		}
2728 	}
2729 
2730 	// wait for maximum 1 second for poll semaphore
2731 	if (mbox->poll != 0x77) {
2732 		udelay(25);
2733 
2734 		for (i = 0; (mbox->poll != 0x77) && (i < 1000); i++) {
2735 			rmb();
2736 			msleep(1);
2737 		}
2738 
2739 		if (i == 1000) {
2740 			con_log(CL_ANN, (KERN_WARNING
2741 			"megaraid mailbox: could not get poll semaphore\n"));
2742 			return -1;
2743 		}
2744 	}
2745 
2746 	WRINDOOR(raid_dev, raid_dev->mbox_dma | 0x2);
2747 	wmb();
2748 
2749 	// wait for maximum 1 second for acknowledgement
2750 	if (RDINDOOR(raid_dev) & 0x2) {
2751 		udelay(25);
2752 
2753 		for (i = 0; (RDINDOOR(raid_dev) & 0x2) && (i < 1000); i++) {
2754 			rmb();
2755 			msleep(1);
2756 		}
2757 
2758 		if (i == 1000) {
2759 			con_log(CL_ANN, (KERN_WARNING
2760 				"megaraid mailbox: could not acknowledge\n"));
2761 			return -1;
2762 		}
2763 	}
2764 	mbox->poll	= 0;
2765 	mbox->ack	= 0x77;
2766 
2767 	status = mbox->status;
2768 
2769 	// invalidate the completed command id array. After command
2770 	// completion, firmware would write the valid id.
2771 	mbox->numstatus	= 0xFF;
2772 	mbox->status	= 0xFF;
2773 	for (i = 0; i < MBOX_MAX_FIRMWARE_STATUS; i++) {
2774 		mbox->completed[i] = 0xFF;
2775 	}
2776 
2777 	return status;
2778 
2779 blocked_mailbox:
2780 
2781 	con_log(CL_ANN, (KERN_WARNING "megaraid: blocked mailbox\n") );
2782 	return -1;
2783 }
2784 
2785 
2786 /**
2787  * mbox_post_sync_cmd_fast - blocking command to the mailbox based controllers
2788  * @adapter	: controller's soft state
2789  * @raw_mbox	: the mailbox
2790  *
2791  * Issue a scb in synchronous and non-interrupt mode for mailbox based
2792  * controllers. This is a faster version of the synchronous command and
2793  * therefore can be called in interrupt-context as well.
2794  */
2795 static int
2796 mbox_post_sync_cmd_fast(adapter_t *adapter, uint8_t raw_mbox[])
2797 {
2798 	mraid_device_t	*raid_dev = ADAP2RAIDDEV(adapter);
2799 	mbox_t		*mbox;
2800 	long		i;
2801 
2802 
2803 	mbox	= raid_dev->mbox;
2804 
2805 	// return immediately if the mailbox is busy
2806 	if (mbox->busy) return -1;
2807 
2808 	// Copy mailbox data into host structure
2809 	memcpy((caddr_t)mbox, (caddr_t)raw_mbox, 14);
2810 	mbox->cmdid		= 0xFE;
2811 	mbox->busy		= 1;
2812 	mbox->poll		= 0;
2813 	mbox->ack		= 0;
2814 	mbox->numstatus		= 0xFF;
2815 	mbox->status		= 0xFF;
2816 
2817 	wmb();
2818 	WRINDOOR(raid_dev, raid_dev->mbox_dma | 0x1);
2819 
2820 	for (i = 0; i < MBOX_SYNC_WAIT_CNT; i++) {
2821 		if (mbox->numstatus != 0xFF) break;
2822 		rmb();
2823 		udelay(MBOX_SYNC_DELAY_200);
2824 	}
2825 
2826 	if (i == MBOX_SYNC_WAIT_CNT) {
2827 		// We may need to re-calibrate the counter
2828 		con_log(CL_ANN, (KERN_CRIT
2829 			"megaraid: fast sync command timed out\n"));
2830 	}
2831 
2832 	WRINDOOR(raid_dev, raid_dev->mbox_dma | 0x2);
2833 	wmb();
2834 
2835 	return mbox->status;
2836 }
2837 
2838 
2839 /**
2840  * megaraid_busywait_mbox() - Wait until the controller's mailbox is available
2841  * @raid_dev	: RAID device (HBA) soft state
2842  *
2843  * Wait until the controller's mailbox is available to accept more commands.
2844  * Wait for at most 1 second.
2845  */
2846 static int
2847 megaraid_busywait_mbox(mraid_device_t *raid_dev)
2848 {
2849 	mbox_t	*mbox = raid_dev->mbox;
2850 	int	i = 0;
2851 
2852 	if (mbox->busy) {
2853 		udelay(25);
2854 		for (i = 0; mbox->busy && i < 1000; i++)
2855 			msleep(1);
2856 	}
2857 
2858 	if (i < 1000) return 0;
2859 	else return -1;
2860 }
2861 
2862 
2863 /**
2864  * megaraid_mbox_product_info - some static information about the controller
2865  * @adapter	: our soft state
2866  *
2867  * Issue commands to the controller to grab some parameters required by our
2868  * caller.
2869  */
2870 static int
2871 megaraid_mbox_product_info(adapter_t *adapter)
2872 {
2873 	mraid_device_t		*raid_dev = ADAP2RAIDDEV(adapter);
2874 	mbox_t			*mbox;
2875 	uint8_t			raw_mbox[sizeof(mbox_t)];
2876 	mraid_pinfo_t		*pinfo;
2877 	dma_addr_t		pinfo_dma_h;
2878 	mraid_inquiry3_t	*mraid_inq3;
2879 	int			i;
2880 
2881 
2882 	memset((caddr_t)raw_mbox, 0, sizeof(raw_mbox));
2883 	mbox = (mbox_t *)raw_mbox;
2884 
2885 	/*
2886 	 * Issue an ENQUIRY3 command to find out certain adapter parameters,
2887 	 * e.g., max channels, max commands etc.
2888 	 */
2889 	pinfo = dma_alloc_coherent(&adapter->pdev->dev, sizeof(mraid_pinfo_t),
2890 				   &pinfo_dma_h, GFP_KERNEL);
2891 	if (pinfo == NULL) {
2892 		con_log(CL_ANN, (KERN_WARNING
2893 			"megaraid: out of memory, %s %d\n", __func__,
2894 			__LINE__));
2895 
2896 		return -1;
2897 	}
2898 
2899 	mbox->xferaddr = (uint32_t)adapter->ibuf_dma_h;
2900 	memset((void *)adapter->ibuf, 0, MBOX_IBUF_SIZE);
2901 
2902 	raw_mbox[0] = FC_NEW_CONFIG;
2903 	raw_mbox[2] = NC_SUBOP_ENQUIRY3;
2904 	raw_mbox[3] = ENQ3_GET_SOLICITED_FULL;
2905 
2906 	// Issue the command
2907 	if (mbox_post_sync_cmd(adapter, raw_mbox) != 0) {
2908 
2909 		con_log(CL_ANN, (KERN_WARNING "megaraid: Inquiry3 failed\n"));
2910 
2911 		dma_free_coherent(&adapter->pdev->dev, sizeof(mraid_pinfo_t),
2912 			pinfo, pinfo_dma_h);
2913 
2914 		return -1;
2915 	}
2916 
2917 	/*
2918 	 * Collect information about state of each physical drive
2919 	 * attached to the controller. We will expose all the disks
2920 	 * which are not part of RAID
2921 	 */
2922 	mraid_inq3 = (mraid_inquiry3_t *)adapter->ibuf;
2923 	for (i = 0; i < MBOX_MAX_PHYSICAL_DRIVES; i++) {
2924 		raid_dev->pdrv_state[i] = mraid_inq3->pdrv_state[i];
2925 	}
2926 
2927 	/*
2928 	 * Get product info for information like number of channels,
2929 	 * maximum commands supported.
2930 	 */
2931 	memset((caddr_t)raw_mbox, 0, sizeof(raw_mbox));
2932 	mbox->xferaddr = (uint32_t)pinfo_dma_h;
2933 
2934 	raw_mbox[0] = FC_NEW_CONFIG;
2935 	raw_mbox[2] = NC_SUBOP_PRODUCT_INFO;
2936 
2937 	if (mbox_post_sync_cmd(adapter, raw_mbox) != 0) {
2938 
2939 		con_log(CL_ANN, (KERN_WARNING
2940 			"megaraid: product info failed\n"));
2941 
2942 		dma_free_coherent(&adapter->pdev->dev, sizeof(mraid_pinfo_t),
2943 			pinfo, pinfo_dma_h);
2944 
2945 		return -1;
2946 	}
2947 
2948 	/*
2949 	 * Setup some parameters for host, as required by our caller
2950 	 */
2951 	adapter->max_channel = pinfo->nchannels;
2952 
2953 	/*
2954 	 * we will export all the logical drives on a single channel.
2955 	 * Add 1 since inquires do not come for inititor ID
2956 	 */
2957 	adapter->max_target	= MAX_LOGICAL_DRIVES_40LD + 1;
2958 	adapter->max_lun	= 8;	// up to 8 LUNs for non-disk devices
2959 
2960 	/*
2961 	 * These are the maximum outstanding commands for the scsi-layer
2962 	 */
2963 	adapter->max_cmds	= MBOX_MAX_SCSI_CMDS;
2964 
2965 	memset(adapter->fw_version, 0, VERSION_SIZE);
2966 	memset(adapter->bios_version, 0, VERSION_SIZE);
2967 
2968 	memcpy(adapter->fw_version, pinfo->fw_version, 4);
2969 	adapter->fw_version[4] = 0;
2970 
2971 	memcpy(adapter->bios_version, pinfo->bios_version, 4);
2972 	adapter->bios_version[4] = 0;
2973 
2974 	con_log(CL_ANN, (KERN_NOTICE
2975 		"megaraid: fw version:[%s] bios version:[%s]\n",
2976 		adapter->fw_version, adapter->bios_version));
2977 
2978 	dma_free_coherent(&adapter->pdev->dev, sizeof(mraid_pinfo_t), pinfo,
2979 			pinfo_dma_h);
2980 
2981 	return 0;
2982 }
2983 
2984 
2985 
2986 /**
2987  * megaraid_mbox_extended_cdb - check for support for extended CDBs
2988  * @adapter	: soft state for the controller
2989  *
2990  * This routine check whether the controller in question supports extended
2991  * ( > 10 bytes ) CDBs.
2992  */
2993 static int
2994 megaraid_mbox_extended_cdb(adapter_t *adapter)
2995 {
2996 	mbox_t		*mbox;
2997 	uint8_t		raw_mbox[sizeof(mbox_t)];
2998 	int		rval;
2999 
3000 	mbox = (mbox_t *)raw_mbox;
3001 
3002 	memset((caddr_t)raw_mbox, 0, sizeof(raw_mbox));
3003 	mbox->xferaddr	= (uint32_t)adapter->ibuf_dma_h;
3004 
3005 	memset((void *)adapter->ibuf, 0, MBOX_IBUF_SIZE);
3006 
3007 	raw_mbox[0] = MAIN_MISC_OPCODE;
3008 	raw_mbox[2] = SUPPORT_EXT_CDB;
3009 
3010 	/*
3011 	 * Issue the command
3012 	 */
3013 	rval = 0;
3014 	if (mbox_post_sync_cmd(adapter, raw_mbox) != 0) {
3015 		rval = -1;
3016 	}
3017 
3018 	return rval;
3019 }
3020 
3021 
3022 /**
3023  * megaraid_mbox_support_ha - Do we support clustering
3024  * @adapter	: soft state for the controller
3025  * @init_id	: ID of the initiator
3026  *
3027  * Determine if the firmware supports clustering and the ID of the initiator.
3028  */
3029 static int
3030 megaraid_mbox_support_ha(adapter_t *adapter, uint16_t *init_id)
3031 {
3032 	mbox_t		*mbox;
3033 	uint8_t		raw_mbox[sizeof(mbox_t)];
3034 	int		rval;
3035 
3036 
3037 	mbox = (mbox_t *)raw_mbox;
3038 
3039 	memset((caddr_t)raw_mbox, 0, sizeof(raw_mbox));
3040 
3041 	mbox->xferaddr = (uint32_t)adapter->ibuf_dma_h;
3042 
3043 	memset((void *)adapter->ibuf, 0, MBOX_IBUF_SIZE);
3044 
3045 	raw_mbox[0] = GET_TARGET_ID;
3046 
3047 	// Issue the command
3048 	*init_id = 7;
3049 	rval =  -1;
3050 	if (mbox_post_sync_cmd(adapter, raw_mbox) == 0) {
3051 
3052 		*init_id = *(uint8_t *)adapter->ibuf;
3053 
3054 		con_log(CL_ANN, (KERN_INFO
3055 			"megaraid: cluster firmware, initiator ID: %d\n",
3056 			*init_id));
3057 
3058 		rval =  0;
3059 	}
3060 
3061 	return rval;
3062 }
3063 
3064 
3065 /**
3066  * megaraid_mbox_support_random_del - Do we support random deletion
3067  * @adapter	: soft state for the controller
3068  *
3069  * Determine if the firmware supports random deletion.
3070  * Return:	1 is operation supported, 0 otherwise
3071  */
3072 static int
3073 megaraid_mbox_support_random_del(adapter_t *adapter)
3074 {
3075 	uint8_t		raw_mbox[sizeof(mbox_t)];
3076 	int		rval;
3077 
3078 	/*
3079 	 * Newer firmware on Dell CERC expect a different
3080 	 * random deletion handling, so disable it.
3081 	 */
3082 	if (adapter->pdev->vendor == PCI_VENDOR_ID_AMI &&
3083 	    adapter->pdev->device == PCI_DEVICE_ID_AMI_MEGARAID3 &&
3084 	    adapter->pdev->subsystem_vendor == PCI_VENDOR_ID_DELL &&
3085 	    adapter->pdev->subsystem_device == PCI_SUBSYS_ID_CERC_ATA100_4CH &&
3086 	    (adapter->fw_version[0] > '6' ||
3087 	     (adapter->fw_version[0] == '6' &&
3088 	      adapter->fw_version[2] > '6') ||
3089 	     (adapter->fw_version[0] == '6'
3090 	      && adapter->fw_version[2] == '6'
3091 	      && adapter->fw_version[3] > '1'))) {
3092 		con_log(CL_DLEVEL1, ("megaraid: disable random deletion\n"));
3093 		return 0;
3094 	}
3095 
3096 	memset((caddr_t)raw_mbox, 0, sizeof(mbox_t));
3097 
3098 	raw_mbox[0] = FC_DEL_LOGDRV;
3099 	raw_mbox[2] = OP_SUP_DEL_LOGDRV;
3100 
3101 	// Issue the command
3102 	rval = 0;
3103 	if (mbox_post_sync_cmd(adapter, raw_mbox) == 0) {
3104 
3105 		con_log(CL_DLEVEL1, ("megaraid: supports random deletion\n"));
3106 
3107 		rval =  1;
3108 	}
3109 
3110 	return rval;
3111 }
3112 
3113 
3114 /**
3115  * megaraid_mbox_get_max_sg - maximum sg elements supported by the firmware
3116  * @adapter	: soft state for the controller
3117  *
3118  * Find out the maximum number of scatter-gather elements supported by the
3119  * firmware.
3120  */
3121 static int
3122 megaraid_mbox_get_max_sg(adapter_t *adapter)
3123 {
3124 	mbox_t		*mbox;
3125 	uint8_t		raw_mbox[sizeof(mbox_t)];
3126 	int		nsg;
3127 
3128 
3129 	mbox = (mbox_t *)raw_mbox;
3130 
3131 	memset((caddr_t)raw_mbox, 0, sizeof(mbox_t));
3132 
3133 	mbox->xferaddr = (uint32_t)adapter->ibuf_dma_h;
3134 
3135 	memset((void *)adapter->ibuf, 0, MBOX_IBUF_SIZE);
3136 
3137 	raw_mbox[0] = MAIN_MISC_OPCODE;
3138 	raw_mbox[2] = GET_MAX_SG_SUPPORT;
3139 
3140 	// Issue the command
3141 	if (mbox_post_sync_cmd(adapter, raw_mbox) == 0) {
3142 		nsg =  *(uint8_t *)adapter->ibuf;
3143 	}
3144 	else {
3145 		nsg =  MBOX_DEFAULT_SG_SIZE;
3146 	}
3147 
3148 	if (nsg > MBOX_MAX_SG_SIZE) nsg = MBOX_MAX_SG_SIZE;
3149 
3150 	return nsg;
3151 }
3152 
3153 
3154 /**
3155  * megaraid_mbox_enum_raid_scsi - enumerate the RAID and SCSI channels
3156  * @adapter	: soft state for the controller
3157  *
3158  * Enumerate the RAID and SCSI channels for ROMB platforms so that channels
3159  * can be exported as regular SCSI channels.
3160  */
3161 static void
3162 megaraid_mbox_enum_raid_scsi(adapter_t *adapter)
3163 {
3164 	mraid_device_t	*raid_dev = ADAP2RAIDDEV(adapter);
3165 	mbox_t		*mbox;
3166 	uint8_t		raw_mbox[sizeof(mbox_t)];
3167 
3168 
3169 	mbox = (mbox_t *)raw_mbox;
3170 
3171 	memset((caddr_t)raw_mbox, 0, sizeof(mbox_t));
3172 
3173 	mbox->xferaddr = (uint32_t)adapter->ibuf_dma_h;
3174 
3175 	memset((void *)adapter->ibuf, 0, MBOX_IBUF_SIZE);
3176 
3177 	raw_mbox[0] = CHNL_CLASS;
3178 	raw_mbox[2] = GET_CHNL_CLASS;
3179 
3180 	// Issue the command. If the command fails, all channels are RAID
3181 	// channels
3182 	raid_dev->channel_class = 0xFF;
3183 	if (mbox_post_sync_cmd(adapter, raw_mbox) == 0) {
3184 		raid_dev->channel_class =  *(uint8_t *)adapter->ibuf;
3185 	}
3186 
3187 	return;
3188 }
3189 
3190 
3191 /**
3192  * megaraid_mbox_flush_cache - flush adapter and disks cache
3193  * @adapter		: soft state for the controller
3194  *
3195  * Flush adapter cache followed by disks cache.
3196  */
3197 static void
3198 megaraid_mbox_flush_cache(adapter_t *adapter)
3199 {
3200 	uint8_t	raw_mbox[sizeof(mbox_t)];
3201 
3202 	memset((caddr_t)raw_mbox, 0, sizeof(mbox_t));
3203 
3204 	raw_mbox[0] = FLUSH_ADAPTER;
3205 
3206 	if (mbox_post_sync_cmd(adapter, raw_mbox) != 0) {
3207 		con_log(CL_ANN, ("megaraid: flush adapter failed\n"));
3208 	}
3209 
3210 	raw_mbox[0] = FLUSH_SYSTEM;
3211 
3212 	if (mbox_post_sync_cmd(adapter, raw_mbox) != 0) {
3213 		con_log(CL_ANN, ("megaraid: flush disks cache failed\n"));
3214 	}
3215 
3216 	return;
3217 }
3218 
3219 
3220 /**
3221  * megaraid_mbox_fire_sync_cmd - fire the sync cmd
3222  * @adapter		: soft state for the controller
3223  *
3224  * Clears the pending cmds in FW and reinits its RAID structs.
3225  */
3226 static int
3227 megaraid_mbox_fire_sync_cmd(adapter_t *adapter)
3228 {
3229 	mbox_t	*mbox;
3230 	uint8_t	raw_mbox[sizeof(mbox_t)];
3231 	mraid_device_t	*raid_dev = ADAP2RAIDDEV(adapter);
3232 	int	status = 0;
3233 	int i;
3234 	uint32_t dword;
3235 
3236 	memset((caddr_t)raw_mbox, 0, sizeof(mbox_t));
3237 
3238 	raw_mbox[0] = 0xFF;
3239 
3240 	mbox	= raid_dev->mbox;
3241 
3242 	/* Wait until mailbox is free */
3243 	if (megaraid_busywait_mbox(raid_dev) != 0) {
3244 		status = 1;
3245 		goto blocked_mailbox;
3246 	}
3247 
3248 	/* Copy mailbox data into host structure */
3249 	memcpy((caddr_t)mbox, (caddr_t)raw_mbox, 16);
3250 	mbox->cmdid		= 0xFE;
3251 	mbox->busy		= 1;
3252 	mbox->poll		= 0;
3253 	mbox->ack		= 0;
3254 	mbox->numstatus		= 0;
3255 	mbox->status		= 0;
3256 
3257 	wmb();
3258 	WRINDOOR(raid_dev, raid_dev->mbox_dma | 0x1);
3259 
3260 	/* Wait for maximum 1 min for status to post.
3261 	 * If the Firmware SUPPORTS the ABOVE COMMAND,
3262 	 * mbox->cmd will be set to 0
3263 	 * else
3264 	 * the firmware will reject the command with
3265 	 * mbox->numstatus set to 1
3266 	 */
3267 
3268 	i = 0;
3269 	status = 0;
3270 	while (!mbox->numstatus && mbox->cmd == 0xFF) {
3271 		rmb();
3272 		msleep(1);
3273 		i++;
3274 		if (i > 1000 * 60) {
3275 			status = 1;
3276 			break;
3277 		}
3278 	}
3279 	if (mbox->numstatus == 1)
3280 		status = 1; /*cmd not supported*/
3281 
3282 	/* Check for interrupt line */
3283 	dword = RDOUTDOOR(raid_dev);
3284 	WROUTDOOR(raid_dev, dword);
3285 	WRINDOOR(raid_dev,2);
3286 
3287 	return status;
3288 
3289 blocked_mailbox:
3290 	con_log(CL_ANN, (KERN_WARNING "megaraid: blocked mailbox\n"));
3291 	return status;
3292 }
3293 
3294 /**
3295  * megaraid_mbox_display_scb - display SCB information, mostly debug purposes
3296  * @adapter		: controller's soft state
3297  * @scb			: SCB to be displayed
3298  *
3299  * Diplay information about the given SCB iff the current debug level is
3300  * verbose.
3301  */
3302 static void
3303 megaraid_mbox_display_scb(adapter_t *adapter, scb_t *scb)
3304 {
3305 	mbox_ccb_t		*ccb;
3306 	struct scsi_cmnd	*scp;
3307 	mbox_t			*mbox;
3308 	int			level;
3309 	int			i;
3310 
3311 
3312 	ccb	= (mbox_ccb_t *)scb->ccb;
3313 	scp	= scb->scp;
3314 	mbox	= ccb->mbox;
3315 
3316 	level = CL_DLEVEL3;
3317 
3318 	con_log(level, (KERN_NOTICE
3319 		"megaraid mailbox: status:%#x cmd:%#x id:%#x ", scb->status,
3320 		mbox->cmd, scb->sno));
3321 
3322 	con_log(level, ("sec:%#x lba:%#x addr:%#x ld:%d sg:%d\n",
3323 		mbox->numsectors, mbox->lba, mbox->xferaddr, mbox->logdrv,
3324 		mbox->numsge));
3325 
3326 	if (!scp) return;
3327 
3328 	con_log(level, (KERN_NOTICE "scsi cmnd: "));
3329 
3330 	for (i = 0; i < scp->cmd_len; i++) {
3331 		con_log(level, ("%#2.02x ", scp->cmnd[i]));
3332 	}
3333 
3334 	con_log(level, ("\n"));
3335 
3336 	return;
3337 }
3338 
3339 
3340 /**
3341  * megaraid_mbox_setup_device_map - manage device ids
3342  * @adapter	: Driver's soft state
3343  *
3344  * Manage the device ids to have an appropriate mapping between the kernel
3345  * scsi addresses and megaraid scsi and logical drive addresses. We export
3346  * scsi devices on their actual addresses, whereas the logical drives are
3347  * exported on a virtual scsi channel.
3348  */
3349 static void
3350 megaraid_mbox_setup_device_map(adapter_t *adapter)
3351 {
3352 	uint8_t		c;
3353 	uint8_t		t;
3354 
3355 	/*
3356 	 * First fill the values on the logical drive channel
3357 	 */
3358 	for (t = 0; t < LSI_MAX_LOGICAL_DRIVES_64LD; t++)
3359 		adapter->device_ids[adapter->max_channel][t] =
3360 			(t < adapter->init_id) ?  t : t - 1;
3361 
3362 	adapter->device_ids[adapter->max_channel][adapter->init_id] = 0xFF;
3363 
3364 	/*
3365 	 * Fill the values on the physical devices channels
3366 	 */
3367 	for (c = 0; c < adapter->max_channel; c++)
3368 		for (t = 0; t < LSI_MAX_LOGICAL_DRIVES_64LD; t++)
3369 			adapter->device_ids[c][t] = (c << 8) | t;
3370 }
3371 
3372 
3373 /*
3374  * END: internal commands library
3375  */
3376 
3377 /*
3378  * START: Interface for the common management module
3379  *
3380  * This is the module, which interfaces with the common management module to
3381  * provide support for ioctl and sysfs
3382  */
3383 
3384 /**
3385  * megaraid_cmm_register - register with the management module
3386  * @adapter		: HBA soft state
3387  *
3388  * Register with the management module, which allows applications to issue
3389  * ioctl calls to the drivers. This interface is used by the management module
3390  * to setup sysfs support as well.
3391  */
3392 static int
3393 megaraid_cmm_register(adapter_t *adapter)
3394 {
3395 	mraid_device_t	*raid_dev = ADAP2RAIDDEV(adapter);
3396 	mraid_mmadp_t	adp;
3397 	scb_t		*scb;
3398 	mbox_ccb_t	*ccb;
3399 	int		rval;
3400 	int		i;
3401 
3402 	// Allocate memory for the base list of scb for management module.
3403 	adapter->uscb_list = kcalloc(MBOX_MAX_USER_CMDS, sizeof(scb_t), GFP_KERNEL);
3404 
3405 	if (adapter->uscb_list == NULL) {
3406 		con_log(CL_ANN, (KERN_WARNING
3407 			"megaraid: out of memory, %s %d\n", __func__,
3408 			__LINE__));
3409 		return -1;
3410 	}
3411 
3412 
3413 	// Initialize the synchronization parameters for resources for
3414 	// commands for management module
3415 	INIT_LIST_HEAD(&adapter->uscb_pool);
3416 
3417 	spin_lock_init(USER_FREE_LIST_LOCK(adapter));
3418 
3419 
3420 
3421 	// link all the packets. Note, CCB for commands, coming from the
3422 	// commom management module, mailbox physical address are already
3423 	// setup by it. We just need placeholder for that in our local command
3424 	// control blocks
3425 	for (i = 0; i < MBOX_MAX_USER_CMDS; i++) {
3426 
3427 		scb			= adapter->uscb_list + i;
3428 		ccb			= raid_dev->uccb_list + i;
3429 
3430 		scb->ccb		= (caddr_t)ccb;
3431 		ccb->mbox64		= raid_dev->umbox64 + i;
3432 		ccb->mbox		= &ccb->mbox64->mbox32;
3433 		ccb->raw_mbox		= (uint8_t *)ccb->mbox;
3434 
3435 		scb->gp			= 0;
3436 
3437 		// COMMAND ID 0 - (MBOX_MAX_SCSI_CMDS-1) ARE RESERVED FOR
3438 		// COMMANDS COMING FROM IO SUBSYSTEM (MID-LAYER)
3439 		scb->sno		= i + MBOX_MAX_SCSI_CMDS;
3440 
3441 		scb->scp		= NULL;
3442 		scb->state		= SCB_FREE;
3443 		scb->dma_direction	= DMA_NONE;
3444 		scb->dma_type		= MRAID_DMA_NONE;
3445 		scb->dev_channel	= -1;
3446 		scb->dev_target		= -1;
3447 
3448 		// put scb in the free pool
3449 		list_add_tail(&scb->list, &adapter->uscb_pool);
3450 	}
3451 
3452 	adp.unique_id		= adapter->unique_id;
3453 	adp.drvr_type		= DRVRTYPE_MBOX;
3454 	adp.drvr_data		= (unsigned long)adapter;
3455 	adp.pdev		= adapter->pdev;
3456 	adp.issue_uioc		= megaraid_mbox_mm_handler;
3457 	adp.timeout		= MBOX_RESET_WAIT + MBOX_RESET_EXT_WAIT;
3458 	adp.max_kioc		= MBOX_MAX_USER_CMDS;
3459 
3460 	if ((rval = mraid_mm_register_adp(&adp)) != 0) {
3461 
3462 		con_log(CL_ANN, (KERN_WARNING
3463 			"megaraid mbox: did not register with CMM\n"));
3464 
3465 		kfree(adapter->uscb_list);
3466 	}
3467 
3468 	return rval;
3469 }
3470 
3471 
3472 /**
3473  * megaraid_cmm_unregister - un-register with the management module
3474  * @adapter		: HBA soft state
3475  *
3476  * Un-register with the management module.
3477  * FIXME: mgmt module must return failure for unregister if it has pending
3478  * commands in LLD.
3479  */
3480 static int
3481 megaraid_cmm_unregister(adapter_t *adapter)
3482 {
3483 	kfree(adapter->uscb_list);
3484 	mraid_mm_unregister_adp(adapter->unique_id);
3485 	return 0;
3486 }
3487 
3488 
3489 /**
3490  * megaraid_mbox_mm_handler - interface for CMM to issue commands to LLD
3491  * @drvr_data		: LLD specific data
3492  * @kioc		: CMM interface packet
3493  * @action		: command action
3494  *
3495  * This routine is invoked whenever the Common Management Module (CMM) has a
3496  * command for us. The 'action' parameter specifies if this is a new command
3497  * or otherwise.
3498  */
3499 static int
3500 megaraid_mbox_mm_handler(unsigned long drvr_data, uioc_t *kioc, uint32_t action)
3501 {
3502 	adapter_t *adapter;
3503 
3504 	if (action != IOCTL_ISSUE) {
3505 		con_log(CL_ANN, (KERN_WARNING
3506 			"megaraid: unsupported management action:%#2x\n",
3507 			action));
3508 		return (-ENOTSUPP);
3509 	}
3510 
3511 	adapter = (adapter_t *)drvr_data;
3512 
3513 	// make sure this adapter is not being detached right now.
3514 	if (atomic_read(&adapter->being_detached)) {
3515 		con_log(CL_ANN, (KERN_WARNING
3516 			"megaraid: reject management request, detaching\n"));
3517 		return (-ENODEV);
3518 	}
3519 
3520 	switch (kioc->opcode) {
3521 
3522 	case GET_ADAP_INFO:
3523 
3524 		kioc->status =  gather_hbainfo(adapter, (mraid_hba_info_t *)
3525 					(unsigned long)kioc->buf_vaddr);
3526 
3527 		kioc->done(kioc);
3528 
3529 		return kioc->status;
3530 
3531 	case MBOX_CMD:
3532 
3533 		return megaraid_mbox_mm_command(adapter, kioc);
3534 
3535 	default:
3536 		kioc->status = (-EINVAL);
3537 		kioc->done(kioc);
3538 		return (-EINVAL);
3539 	}
3540 
3541 	return 0;	// not reached
3542 }
3543 
3544 /**
3545  * megaraid_mbox_mm_command - issues commands routed through CMM
3546  * @adapter		: HBA soft state
3547  * @kioc		: management command packet
3548  *
3549  * Issues commands, which are routed through the management module.
3550  */
3551 static int
3552 megaraid_mbox_mm_command(adapter_t *adapter, uioc_t *kioc)
3553 {
3554 	struct list_head	*head = &adapter->uscb_pool;
3555 	mbox64_t		*mbox64;
3556 	uint8_t			*raw_mbox;
3557 	scb_t			*scb;
3558 	mbox_ccb_t		*ccb;
3559 	unsigned long		flags;
3560 
3561 	// detach one scb from free pool
3562 	spin_lock_irqsave(USER_FREE_LIST_LOCK(adapter), flags);
3563 
3564 	if (list_empty(head)) {	// should never happen because of CMM
3565 
3566 		con_log(CL_ANN, (KERN_WARNING
3567 			"megaraid mbox: bug in cmm handler, lost resources\n"));
3568 
3569 		spin_unlock_irqrestore(USER_FREE_LIST_LOCK(adapter), flags);
3570 
3571 		return (-EINVAL);
3572 	}
3573 
3574 	scb = list_entry(head->next, scb_t, list);
3575 	list_del_init(&scb->list);
3576 
3577 	spin_unlock_irqrestore(USER_FREE_LIST_LOCK(adapter), flags);
3578 
3579 	scb->state		= SCB_ACTIVE;
3580 	scb->dma_type		= MRAID_DMA_NONE;
3581 	scb->dma_direction	= DMA_NONE;
3582 
3583 	ccb		= (mbox_ccb_t *)scb->ccb;
3584 	mbox64		= (mbox64_t *)(unsigned long)kioc->cmdbuf;
3585 	raw_mbox	= (uint8_t *)&mbox64->mbox32;
3586 
3587 	memcpy(ccb->mbox64, mbox64, sizeof(mbox64_t));
3588 
3589 	scb->gp		= (unsigned long)kioc;
3590 
3591 	/*
3592 	 * If it is a logdrv random delete operation, we have to wait till
3593 	 * there are no outstanding cmds at the fw and then issue it directly
3594 	 */
3595 	if (raw_mbox[0] == FC_DEL_LOGDRV && raw_mbox[2] == OP_DEL_LOGDRV) {
3596 
3597 		if (wait_till_fw_empty(adapter)) {
3598 			con_log(CL_ANN, (KERN_NOTICE
3599 				"megaraid mbox: LD delete, timed out\n"));
3600 
3601 			kioc->status = -ETIME;
3602 
3603 			scb->status = -1;
3604 
3605 			megaraid_mbox_mm_done(adapter, scb);
3606 
3607 			return (-ETIME);
3608 		}
3609 
3610 		INIT_LIST_HEAD(&scb->list);
3611 
3612 		scb->state = SCB_ISSUED;
3613 		if (mbox_post_cmd(adapter, scb) != 0) {
3614 
3615 			con_log(CL_ANN, (KERN_NOTICE
3616 				"megaraid mbox: LD delete, mailbox busy\n"));
3617 
3618 			kioc->status = -EBUSY;
3619 
3620 			scb->status = -1;
3621 
3622 			megaraid_mbox_mm_done(adapter, scb);
3623 
3624 			return (-EBUSY);
3625 		}
3626 
3627 		return 0;
3628 	}
3629 
3630 	// put the command on the pending list and execute
3631 	megaraid_mbox_runpendq(adapter, scb);
3632 
3633 	return 0;
3634 }
3635 
3636 
3637 static int
3638 wait_till_fw_empty(adapter_t *adapter)
3639 {
3640 	unsigned long	flags = 0;
3641 	int		i;
3642 
3643 
3644 	/*
3645 	 * Set the quiescent flag to stop issuing cmds to FW.
3646 	 */
3647 	spin_lock_irqsave(&adapter->lock, flags);
3648 	adapter->quiescent++;
3649 	spin_unlock_irqrestore(&adapter->lock, flags);
3650 
3651 	/*
3652 	 * Wait till there are no more cmds outstanding at FW. Try for at most
3653 	 * 60 seconds
3654 	 */
3655 	for (i = 0; i < 60 && adapter->outstanding_cmds; i++) {
3656 		con_log(CL_DLEVEL1, (KERN_INFO
3657 			"megaraid: FW has %d pending commands\n",
3658 			adapter->outstanding_cmds));
3659 
3660 		msleep(1000);
3661 	}
3662 
3663 	return adapter->outstanding_cmds;
3664 }
3665 
3666 
3667 /**
3668  * megaraid_mbox_mm_done - callback for CMM commands
3669  * @adapter	: HBA soft state
3670  * @scb		: completed command
3671  *
3672  * Callback routine for internal commands originated from the management
3673  * module.
3674  */
3675 static void
3676 megaraid_mbox_mm_done(adapter_t *adapter, scb_t *scb)
3677 {
3678 	uioc_t			*kioc;
3679 	mbox64_t		*mbox64;
3680 	uint8_t			*raw_mbox;
3681 	unsigned long		flags;
3682 
3683 	kioc			= (uioc_t *)scb->gp;
3684 	mbox64			= (mbox64_t *)(unsigned long)kioc->cmdbuf;
3685 	mbox64->mbox32.status	= scb->status;
3686 	raw_mbox		= (uint8_t *)&mbox64->mbox32;
3687 
3688 
3689 	// put scb in the free pool
3690 	scb->state	= SCB_FREE;
3691 	scb->scp	= NULL;
3692 
3693 	spin_lock_irqsave(USER_FREE_LIST_LOCK(adapter), flags);
3694 
3695 	list_add(&scb->list, &adapter->uscb_pool);
3696 
3697 	spin_unlock_irqrestore(USER_FREE_LIST_LOCK(adapter), flags);
3698 
3699 	// if a delete logical drive operation succeeded, restart the
3700 	// controller
3701 	if (raw_mbox[0] == FC_DEL_LOGDRV && raw_mbox[2] == OP_DEL_LOGDRV) {
3702 
3703 		adapter->quiescent--;
3704 
3705 		megaraid_mbox_runpendq(adapter, NULL);
3706 	}
3707 
3708 	kioc->done(kioc);
3709 
3710 	return;
3711 }
3712 
3713 
3714 /**
3715  * gather_hbainfo - HBA characteristics for the applications
3716  * @adapter		: HBA soft state
3717  * @hinfo		: pointer to the caller's host info strucuture
3718  */
3719 static int
3720 gather_hbainfo(adapter_t *adapter, mraid_hba_info_t *hinfo)
3721 {
3722 	hinfo->pci_vendor_id	= adapter->pdev->vendor;
3723 	hinfo->pci_device_id	= adapter->pdev->device;
3724 	hinfo->subsys_vendor_id	= adapter->pdev->subsystem_vendor;
3725 	hinfo->subsys_device_id	= adapter->pdev->subsystem_device;
3726 
3727 	hinfo->pci_bus		= adapter->pdev->bus->number;
3728 	hinfo->pci_dev_fn	= adapter->pdev->devfn;
3729 	hinfo->pci_slot		= PCI_SLOT(adapter->pdev->devfn);
3730 	hinfo->irq		= adapter->host->irq;
3731 	hinfo->baseport		= ADAP2RAIDDEV(adapter)->baseport;
3732 
3733 	hinfo->unique_id	= (hinfo->pci_bus << 8) | adapter->pdev->devfn;
3734 	hinfo->host_no		= adapter->host->host_no;
3735 
3736 	return 0;
3737 }
3738 
3739 /*
3740  * END: Interface for the common management module
3741  */
3742 
3743 
3744 
3745 /**
3746  * megaraid_sysfs_alloc_resources - allocate sysfs related resources
3747  * @adapter	: controller's soft state
3748  *
3749  * Allocate packets required to issue FW calls whenever the sysfs attributes
3750  * are read. These attributes would require up-to-date information from the
3751  * FW. Also set up resources for mutual exclusion to share these resources and
3752  * the wait queue.
3753  *
3754  * Return 0 on success.
3755  * Return -ERROR_CODE on failure.
3756  */
3757 static int
3758 megaraid_sysfs_alloc_resources(adapter_t *adapter)
3759 {
3760 	mraid_device_t	*raid_dev = ADAP2RAIDDEV(adapter);
3761 	int		rval = 0;
3762 
3763 	raid_dev->sysfs_uioc = kmalloc(sizeof(uioc_t), GFP_KERNEL);
3764 
3765 	raid_dev->sysfs_mbox64 = kmalloc(sizeof(mbox64_t), GFP_KERNEL);
3766 
3767 	raid_dev->sysfs_buffer = dma_alloc_coherent(&adapter->pdev->dev,
3768 			PAGE_SIZE, &raid_dev->sysfs_buffer_dma, GFP_KERNEL);
3769 
3770 	if (!raid_dev->sysfs_uioc || !raid_dev->sysfs_mbox64 ||
3771 		!raid_dev->sysfs_buffer) {
3772 
3773 		con_log(CL_ANN, (KERN_WARNING
3774 			"megaraid: out of memory, %s %d\n", __func__,
3775 			__LINE__));
3776 
3777 		rval = -ENOMEM;
3778 
3779 		megaraid_sysfs_free_resources(adapter);
3780 	}
3781 
3782 	mutex_init(&raid_dev->sysfs_mtx);
3783 
3784 	init_waitqueue_head(&raid_dev->sysfs_wait_q);
3785 
3786 	return rval;
3787 }
3788 
3789 
3790 /**
3791  * megaraid_sysfs_free_resources - free sysfs related resources
3792  * @adapter	: controller's soft state
3793  *
3794  * Free packets allocated for sysfs FW commands
3795  */
3796 static void
3797 megaraid_sysfs_free_resources(adapter_t *adapter)
3798 {
3799 	mraid_device_t	*raid_dev = ADAP2RAIDDEV(adapter);
3800 
3801 	kfree(raid_dev->sysfs_uioc);
3802 	kfree(raid_dev->sysfs_mbox64);
3803 
3804 	if (raid_dev->sysfs_buffer) {
3805 		dma_free_coherent(&adapter->pdev->dev, PAGE_SIZE,
3806 			raid_dev->sysfs_buffer, raid_dev->sysfs_buffer_dma);
3807 	}
3808 }
3809 
3810 
3811 /**
3812  * megaraid_sysfs_get_ldmap_done - callback for get ldmap
3813  * @uioc	: completed packet
3814  *
3815  * Callback routine called in the ISR/tasklet context for get ldmap call
3816  */
3817 static void
3818 megaraid_sysfs_get_ldmap_done(uioc_t *uioc)
3819 {
3820 	adapter_t	*adapter = (adapter_t *)uioc->buf_vaddr;
3821 	mraid_device_t	*raid_dev = ADAP2RAIDDEV(adapter);
3822 
3823 	uioc->status = 0;
3824 
3825 	wake_up(&raid_dev->sysfs_wait_q);
3826 }
3827 
3828 /**
3829  * megaraid_sysfs_get_ldmap_timeout - timeout handling for get ldmap
3830  * @t	: timed out timer
3831  *
3832  * Timeout routine to recover and return to application, in case the adapter
3833  * has stopped responding. A timeout of 60 seconds for this command seems like
3834  * a good value.
3835  */
3836 static void
3837 megaraid_sysfs_get_ldmap_timeout(struct timer_list *t)
3838 {
3839 	struct uioc_timeout *timeout = from_timer(timeout, t, timer);
3840 	uioc_t		*uioc = timeout->uioc;
3841 	adapter_t	*adapter = (adapter_t *)uioc->buf_vaddr;
3842 	mraid_device_t	*raid_dev = ADAP2RAIDDEV(adapter);
3843 
3844 	uioc->status = -ETIME;
3845 
3846 	wake_up(&raid_dev->sysfs_wait_q);
3847 }
3848 
3849 
3850 /**
3851  * megaraid_sysfs_get_ldmap - get update logical drive map
3852  * @adapter	: controller's soft state
3853  *
3854  * This routine will be called whenever user reads the logical drive
3855  * attributes, go get the current logical drive mapping table from the
3856  * firmware. We use the management API's to issue commands to the controller.
3857  *
3858  * NOTE: The commands issuance functionality is not generalized and
3859  * implemented in context of "get ld map" command only. If required, the
3860  * command issuance logical can be trivially pulled out and implemented as a
3861  * standalone library. For now, this should suffice since there is no other
3862  * user of this interface.
3863  *
3864  * Return 0 on success.
3865  * Return -1 on failure.
3866  */
3867 static int
3868 megaraid_sysfs_get_ldmap(adapter_t *adapter)
3869 {
3870 	mraid_device_t		*raid_dev = ADAP2RAIDDEV(adapter);
3871 	uioc_t			*uioc;
3872 	mbox64_t		*mbox64;
3873 	mbox_t			*mbox;
3874 	char			*raw_mbox;
3875 	struct uioc_timeout	timeout;
3876 	caddr_t			ldmap;
3877 	int			rval = 0;
3878 
3879 	/*
3880 	 * Allow only one read at a time to go through the sysfs attributes
3881 	 */
3882 	mutex_lock(&raid_dev->sysfs_mtx);
3883 
3884 	uioc	= raid_dev->sysfs_uioc;
3885 	mbox64	= raid_dev->sysfs_mbox64;
3886 	ldmap	= raid_dev->sysfs_buffer;
3887 
3888 	memset(uioc, 0, sizeof(uioc_t));
3889 	memset(mbox64, 0, sizeof(mbox64_t));
3890 	memset(ldmap, 0, sizeof(raid_dev->curr_ldmap));
3891 
3892 	mbox		= &mbox64->mbox32;
3893 	raw_mbox	= (char *)mbox;
3894 	uioc->cmdbuf    = (uint64_t)(unsigned long)mbox64;
3895 	uioc->buf_vaddr	= (caddr_t)adapter;
3896 	uioc->status	= -ENODATA;
3897 	uioc->done	= megaraid_sysfs_get_ldmap_done;
3898 
3899 	/*
3900 	 * Prepare the mailbox packet to get the current logical drive mapping
3901 	 * table
3902 	 */
3903 	mbox->xferaddr = (uint32_t)raid_dev->sysfs_buffer_dma;
3904 
3905 	raw_mbox[0] = FC_DEL_LOGDRV;
3906 	raw_mbox[2] = OP_GET_LDID_MAP;
3907 
3908 	/*
3909 	 * Setup a timer to recover from a non-responding controller
3910 	 */
3911 	timeout.uioc = uioc;
3912 	timer_setup_on_stack(&timeout.timer,
3913 			     megaraid_sysfs_get_ldmap_timeout, 0);
3914 
3915 	timeout.timer.expires		= jiffies + 60 * HZ;
3916 	add_timer(&timeout.timer);
3917 
3918 	/*
3919 	 * Send the command to the firmware
3920 	 */
3921 	rval = megaraid_mbox_mm_command(adapter, uioc);
3922 
3923 	if (rval == 0) {	// command successfully issued
3924 		wait_event(raid_dev->sysfs_wait_q, (uioc->status != -ENODATA));
3925 
3926 		/*
3927 		 * Check if the command timed out
3928 		 */
3929 		if (uioc->status == -ETIME) {
3930 			con_log(CL_ANN, (KERN_NOTICE
3931 				"megaraid: sysfs get ld map timed out\n"));
3932 
3933 			rval = -ETIME;
3934 		}
3935 		else {
3936 			rval = mbox->status;
3937 		}
3938 
3939 		if (rval == 0) {
3940 			memcpy(raid_dev->curr_ldmap, ldmap,
3941 				sizeof(raid_dev->curr_ldmap));
3942 		}
3943 		else {
3944 			con_log(CL_ANN, (KERN_NOTICE
3945 				"megaraid: get ld map failed with %x\n", rval));
3946 		}
3947 	}
3948 	else {
3949 		con_log(CL_ANN, (KERN_NOTICE
3950 			"megaraid: could not issue ldmap command:%x\n", rval));
3951 	}
3952 
3953 
3954 	del_timer_sync(&timeout.timer);
3955 	destroy_timer_on_stack(&timeout.timer);
3956 
3957 	mutex_unlock(&raid_dev->sysfs_mtx);
3958 
3959 	return rval;
3960 }
3961 
3962 
3963 /**
3964  * megaraid_mbox_app_hndl_show - display application handle for this adapter
3965  * @dev		: class device object representation for the host
3966  * @attr	: device attribute (unused)
3967  * @buf		: buffer to send data to
3968  *
3969  * Display the handle used by the applications while executing management
3970  * tasks on the adapter. We invoke a management module API to get the adapter
3971  * handle, since we do not interface with applications directly.
3972  */
3973 static ssize_t
3974 megaraid_mbox_app_hndl_show(struct device *dev, struct device_attribute *attr, char *buf)
3975 {
3976 	struct Scsi_Host *shost = class_to_shost(dev);
3977 	adapter_t	*adapter = (adapter_t *)SCSIHOST2ADAP(shost);
3978 	uint32_t	app_hndl;
3979 
3980 	app_hndl = mraid_mm_adapter_app_handle(adapter->unique_id);
3981 
3982 	return sysfs_emit(buf, "%u\n", app_hndl);
3983 }
3984 
3985 
3986 /**
3987  * megaraid_mbox_ld_show - display the logical drive number for this device
3988  * @dev		: device object representation for the scsi device
3989  * @attr	: device attribute to show
3990  * @buf		: buffer to send data to
3991  *
3992  * Display the logical drive number for the device in question, if it a valid
3993  * logical drive. For physical devices, "-1" is returned.
3994  *
3995  * The logical drive number is displayed in following format:
3996  *
3997  * <SCSI ID> <LD NUM> <LD STICKY ID> <APP ADAPTER HANDLE>
3998  *
3999  *   <int>     <int>       <int>            <int>
4000  */
4001 static ssize_t
4002 megaraid_mbox_ld_show(struct device *dev, struct device_attribute *attr, char *buf)
4003 {
4004 	struct scsi_device *sdev = to_scsi_device(dev);
4005 	adapter_t	*adapter = (adapter_t *)SCSIHOST2ADAP(sdev->host);
4006 	mraid_device_t	*raid_dev = ADAP2RAIDDEV(adapter);
4007 	int		scsi_id = -1;
4008 	int		logical_drv = -1;
4009 	int		ldid_map = -1;
4010 	uint32_t	app_hndl = 0;
4011 	int		mapped_sdev_id;
4012 	int		rval;
4013 	int		i;
4014 
4015 	if (raid_dev->random_del_supported &&
4016 			MRAID_IS_LOGICAL_SDEV(adapter, sdev)) {
4017 
4018 		rval = megaraid_sysfs_get_ldmap(adapter);
4019 		if (rval == 0) {
4020 
4021 			for (i = 0; i < MAX_LOGICAL_DRIVES_40LD; i++) {
4022 
4023 				mapped_sdev_id = sdev->id;
4024 
4025 				if (sdev->id > adapter->init_id) {
4026 					mapped_sdev_id -= 1;
4027 				}
4028 
4029 				if (raid_dev->curr_ldmap[i] == mapped_sdev_id) {
4030 
4031 					scsi_id = sdev->id;
4032 
4033 					logical_drv = i;
4034 
4035 					ldid_map = raid_dev->curr_ldmap[i];
4036 
4037 					app_hndl = mraid_mm_adapter_app_handle(
4038 							adapter->unique_id);
4039 
4040 					break;
4041 				}
4042 			}
4043 		}
4044 		else {
4045 			con_log(CL_ANN, (KERN_NOTICE
4046 				"megaraid: sysfs get ld map failed: %x\n",
4047 				rval));
4048 		}
4049 	}
4050 
4051 	return sysfs_emit(buf, "%d %d %d %d\n", scsi_id, logical_drv,
4052 			ldid_map, app_hndl);
4053 }
4054 
4055 
4056 /*
4057  * END: Mailbox Low Level Driver
4058  */
4059 module_init(megaraid_init);
4060 module_exit(megaraid_exit);
4061