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 const 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(dev: &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(dev: 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(dev: pdev);
428
429	// Allocate the per driver initialization structure
430	adapter = kzalloc(size: 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 = pci_dev_id(dev: pdev);
442	adapter->irq = pdev->irq;
443	adapter->pdev = pdev;
444
445	atomic_set(v: &adapter->being_detached, i: 0);
446
447	// Setup the default DMA mask. This would be changed later on
448	// depending on hardware capabilities
449	if (dma_set_mask(dev: &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(list: &adapter->kscb_pool);
463	spin_lock_init(SCSI_FREE_LIST_LOCK(adapter));
464
465	INIT_LIST_HEAD(list: &adapter->pend_list);
466	spin_lock_init(PENDING_LIST_LOCK(adapter));
467
468	INIT_LIST_HEAD(list: &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, data: 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(objp: adapter);
508	out_probe_one:
509	pci_disable_device(dev: 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(v: &adapter->being_detached, i: 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(objp: adapter);
572
573	scsi_host_put(t: host);
574
575	pci_disable_device(dev: 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, dev: &adapter->pdev->dev)) {
646
647	con_log(CL_ANN, (KERN_WARNING
648	"megaraid mbox: scsi_add_host failed\n"));
649
650	scsi_host_put(t: 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(size: 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(offset: raid_dev->baseport, size: 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(irq: adapter->irq, handler: megaraid_isr, IRQF_SHARED, name: "megaraid",
768	dev: 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(dev: adapter->pdev, PCI_CONF_AMISIG64, val: &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(dev: &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(dev: &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(t: &adapter->dpc_h, func: megaraid_mbox_dpc,
884	data: (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(addr: raid_dev->baseaddr);
899	out_release_regions:
900	pci_release_regions(pdev);
901	out_free_raid_dev:
902	kfree(objp: 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(t: &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(addr: raid_dev->baseaddr);
929
930	pci_release_regions(adapter->pdev);
931
932	kfree(objp: 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(dev: &adapter->pdev->dev,
968	size: sizeof(mbox64_t),
969	dma_handle: &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(dev: &pdev->dev, MBOX_IBUF_SIZE,
997	dma_handle: &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, size: 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(new: &scb->list, head: &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(objp: adapter->kscb_list);
1090	out_free_ibuf:
1091	dma_free_coherent(dev: &pdev->dev, MBOX_IBUF_SIZE, cpu_addr: (void *)adapter->ibuf,
1092	dma_handle: adapter->ibuf_dma_h);
1093	out_free_common_mbox:
1094	dma_free_coherent(dev: &adapter->pdev->dev, size: sizeof(mbox64_t),
1095	cpu_addr: (caddr_t)raid_dev->una_mbox64, dma_handle: 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(objp: adapter->kscb_list);
1115
1116	dma_free_coherent(dev: &adapter->pdev->dev, MBOX_IBUF_SIZE,
1117	cpu_addr: (void *)adapter->ibuf, dma_handle: adapter->ibuf_dma_h);
1118
1119	dma_free_coherent(dev: &adapter->pdev->dev, size: sizeof(mbox64_t),
1120	cpu_addr: (caddr_t)raid_dev->una_mbox64, dma_handle: 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(name: "megaraid mbox pool",
1145	dev: &adapter->pdev->dev,
1146	size: sizeof(mbox64_t) + 16,
1147	align: 16, allocation: 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	pool: raid_dev->mbox_pool_handle,
1157	GFP_KERNEL,
1158	handle: &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(name: "megaraid mbox pthru",
1173	dev: &adapter->pdev->dev, size: sizeof(mraid_epassthru_t), align: 128, allocation: 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	pool: raid_dev->epthru_pool_handle,
1183	GFP_KERNEL,
1184	handle: &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(name: "megaraid mbox sg",
1194	dev: &adapter->pdev->dev,
1195	size: sizeof(mbox_sgl64) * MBOX_MAX_SG_SIZE,
1196	align: 512, allocation: 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	pool: raid_dev->sg_pool_handle,
1206	GFP_KERNEL,
1207	handle: &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(pool: raid_dev->sg_pool_handle, vaddr: sg_pci_blk[i].vaddr,
1241	addr: sg_pci_blk[i].dma_addr);
1242	}
1243	dma_pool_destroy(pool: 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(pool: raid_dev->epthru_pool_handle,
1249	vaddr: epthru_pci_blk[i].vaddr, addr: epthru_pci_blk[i].dma_addr);
1250	}
1251	dma_pool_destroy(pool: 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(pool: raid_dev->mbox_pool_handle,
1257	vaddr: mbox_pci_blk[i].vaddr, addr: mbox_pci_blk[i].dma_addr);
1258	}
1259	dma_pool_destroy(pool: 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(entry: &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(new: &scb->list, head: &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(cmd: 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(cmd: scp);
1544	if (sg_page(sg: sgl)) {
1545	vaddr = (caddr_t) sg_virt(sg: &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(scmd: scp, desc: 0, ILLEGAL_REQUEST,
1578	MEGA_INVALID_FIELD_IN_CDB, ascq: 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(cmd: 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(new: &scb_q->list, head: &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(head: &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(entry: &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(new: &scb->list, head: &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(cmd: scp)) {
1959	pthru->dataxferlen = scsi_bufflen(cmd: 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(cmd: scp)) {
2008	epthru->dataxferlen = scsi_bufflen(cmd: 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(list: &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(new: &scb->list, head: &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(list: &clist, head: &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(t: &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(list: &clist);
2197
2198	spin_lock_irqsave(COMPLETED_LIST_LOCK(adapter), flags);
2199
2200	list_splice_init(list: &adapter->completed_list, head: &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(entry: &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(cmd: scp);
2259	if (sg_page(sg: sgl)) {
2260	c = *(unsigned char *) sg_virt(sg: &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(scmd: scp, desc: 0,
2313	ABORTED_COMMAND, asc: 0, ascq: 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(cmd: scp);
2354
2355	// remove from local clist
2356	list_del_init(entry: &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(cmd: 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(entry: &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(cmd: 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(entry: &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(cmd: 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(lock: &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(lock: &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(entry: &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(cmd: 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(msecs: 1000);
2604	}
2605
2606	spin_lock(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(lock: &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(msecs: 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(msecs: 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(msecs: 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(msecs: 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(msecs: 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(dev: &adapter->pdev->dev, size: sizeof(mraid_pinfo_t),
2890	dma_handle: &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(dev: &adapter->pdev->dev, size: sizeof(mraid_pinfo_t),
2912	cpu_addr: pinfo, dma_handle: 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(dev: &adapter->pdev->dev, size: sizeof(mraid_pinfo_t),
2943	cpu_addr: pinfo, dma_handle: 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(dev: &adapter->pdev->dev, size: sizeof(mraid_pinfo_t), cpu_addr: pinfo,
2979	dma_handle: 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(msecs: 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, size: 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(list: &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(new: &scb->list, head: &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(objp: 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(objp: 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(v: &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(entry: &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(list: &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_q: 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(lock: &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(msecs: 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(new: &scb->list, head: &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(size: sizeof(uioc_t), GFP_KERNEL);
3764
3765	raid_dev->sysfs_mbox64 = kmalloc(size: sizeof(mbox64_t), GFP_KERNEL);
3766
3767	raid_dev->sysfs_buffer = dma_alloc_coherent(dev: &adapter->pdev->dev,
3768	PAGE_SIZE, dma_handle: &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(objp: raid_dev->sysfs_uioc);
3802	kfree(objp: raid_dev->sysfs_mbox64);
3803
3804	if (raid_dev->sysfs_buffer) {
3805	dma_free_coherent(dev: &adapter->pdev->dev, PAGE_SIZE,
3806	cpu_addr: raid_dev->sysfs_buffer, dma_handle: 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(timer: &timeout.timer);
3917
3918	/*
3919	* Send the command to the firmware
3920	*/
3921	rval = megaraid_mbox_mm_command(adapter, kioc: 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(timer: &timeout.timer);
3955	destroy_timer_on_stack(timer: &timeout.timer);
3956
3957	mutex_unlock(lock: &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, fmt: "%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, fmt: "%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