4061 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 *4 * Linux MegaRAID device driver5 *6 * Copyright (c) 2003-2004 LSI Logic Corporation.7 *8 * FILE : megaraid_mbox.c9 * 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 Ju16 *17 * List of supported controllers18 *19 * OEM Product Name VID DID SSVID SSID20 * --- ------------ --- --- ---- ----21 * Dell PERC3/QC 101E 1960 1028 047122 * Dell PERC3/DC 101E 1960 1028 049323 * Dell PERC3/SC 101E 1960 1028 047524 * Dell PERC3/Di 1028 1960 1028 012325 * Dell PERC4/SC 1000 1960 1028 052026 * Dell PERC4/DC 1000 1960 1028 051827 * Dell PERC4/QC 1000 0407 1028 053128 * Dell PERC4/Di 1028 000F 1028 014A29 * Dell PERC 4e/Si 1028 0013 1028 016c30 * Dell PERC 4e/Di 1028 0013 1028 016d31 * Dell PERC 4e/Di 1028 0013 1028 016e32 * Dell PERC 4e/Di 1028 0013 1028 016f33 * Dell PERC 4e/Di 1028 0013 1028 017034 * Dell PERC 4e/DC 1000 0408 1028 000235 * Dell PERC 4e/SC 1000 0408 1028 000136 *37 * LSI MegaRAID SCSI 320-0 1000 1960 1000 A52038 * LSI MegaRAID SCSI 320-1 1000 1960 1000 052039 * LSI MegaRAID SCSI 320-2 1000 1960 1000 051840 * LSI MegaRAID SCSI 320-0X 1000 0407 1000 053041 * LSI MegaRAID SCSI 320-2X 1000 0407 1000 053242 * LSI MegaRAID SCSI 320-4X 1000 0407 1000 053143 * LSI MegaRAID SCSI 320-1E 1000 0408 1000 000144 * LSI MegaRAID SCSI 320-2E 1000 0408 1000 000245 * LSI MegaRAID SATA 150-4 1000 1960 1000 452346 * LSI MegaRAID SATA 150-6 1000 1960 1000 052347 * LSI MegaRAID SATA 300-4X 1000 0409 1000 300448 * LSI MegaRAID SATA 300-8X 1000 0409 1000 300849 *50 * INTEL RAID Controller SRCU42X 1000 0407 8086 053251 * INTEL RAID Controller SRCS16 1000 1960 8086 052352 * INTEL RAID Controller SRCU42E 1000 0408 8086 000253 * INTEL RAID Controller SRCZCRX 1000 0407 8086 053054 * INTEL RAID Controller SRCS28X 1000 0409 8086 300855 * INTEL RAID Controller SROMBU42E 1000 0408 8086 343156 * INTEL RAID Controller SROMBU42E 1000 0408 8086 349957 * INTEL RAID Controller SRCU51L 1000 1960 8086 052058 *59 * FSC MegaRAID PCI Express ROMB 1000 0408 1734 106560 *61 * ACER MegaRAID ROMB-2E 1000 0408 1025 004D62 *63 * NEC MegaRAID PCI Express ROMB 1000 0408 1033 828764 *65 * For history of changes, see Documentation/scsi/ChangeLog.megaraid66 */67 68#include <linux/slab.h>69#include <linux/module.h>70#include "megaraid_mbox.h"71 72static int megaraid_init(void);73static void megaraid_exit(void);74 75static int megaraid_probe_one(struct pci_dev*, const struct pci_device_id *);76static void megaraid_detach_one(struct pci_dev *);77static void megaraid_mbox_shutdown(struct pci_dev *);78 79static int megaraid_io_attach(adapter_t *);80static void megaraid_io_detach(adapter_t *);81 82static int megaraid_init_mbox(adapter_t *);83static void megaraid_fini_mbox(adapter_t *);84 85static int megaraid_alloc_cmd_packets(adapter_t *);86static void megaraid_free_cmd_packets(adapter_t *);87 88static int megaraid_mbox_setup_dma_pools(adapter_t *);89static void megaraid_mbox_teardown_dma_pools(adapter_t *);90 91static int megaraid_sysfs_alloc_resources(adapter_t *);92static void megaraid_sysfs_free_resources(adapter_t *);93 94static int megaraid_abort_handler(struct scsi_cmnd *);95static int megaraid_reset_handler(struct scsi_cmnd *);96 97static int mbox_post_sync_cmd(adapter_t *, uint8_t []);98static int mbox_post_sync_cmd_fast(adapter_t *, uint8_t []);99static int megaraid_busywait_mbox(mraid_device_t *);100static int megaraid_mbox_product_info(adapter_t *);101static int megaraid_mbox_extended_cdb(adapter_t *);102static int megaraid_mbox_support_ha(adapter_t *, uint16_t *);103static int megaraid_mbox_support_random_del(adapter_t *);104static int megaraid_mbox_get_max_sg(adapter_t *);105static void megaraid_mbox_enum_raid_scsi(adapter_t *);106static void megaraid_mbox_flush_cache(adapter_t *);107static int megaraid_mbox_fire_sync_cmd(adapter_t *);108 109static void megaraid_mbox_display_scb(adapter_t *, scb_t *);110static void megaraid_mbox_setup_device_map(adapter_t *);111 112static int megaraid_queue_command(struct Scsi_Host *, struct scsi_cmnd *);113static scb_t *megaraid_mbox_build_cmd(adapter_t *, struct scsi_cmnd *, int *);114static void megaraid_mbox_runpendq(adapter_t *, scb_t *);115static void megaraid_mbox_prepare_pthru(adapter_t *, scb_t *,116 struct scsi_cmnd *);117static void megaraid_mbox_prepare_epthru(adapter_t *, scb_t *,118 struct scsi_cmnd *);119 120static irqreturn_t megaraid_isr(int, void *);121 122static void megaraid_mbox_dpc(unsigned long);123 124static ssize_t megaraid_mbox_app_hndl_show(struct device *, struct device_attribute *attr, char *);125static ssize_t megaraid_mbox_ld_show(struct device *, struct device_attribute *attr, char *);126 127static int megaraid_cmm_register(adapter_t *);128static int megaraid_cmm_unregister(adapter_t *);129static int megaraid_mbox_mm_handler(unsigned long, uioc_t *, uint32_t);130static int megaraid_mbox_mm_command(adapter_t *, uioc_t *);131static void megaraid_mbox_mm_done(adapter_t *, scb_t *);132static int gather_hbainfo(adapter_t *, mraid_hba_info_t *);133static int wait_till_fw_empty(adapter_t *);134 135 136 137MODULE_AUTHOR("megaraidlinux@lsi.com");138MODULE_DESCRIPTION("LSI Logic MegaRAID Mailbox Driver");139MODULE_LICENSE("GPL");140MODULE_VERSION(MEGARAID_VERSION);141 142/*143 * ### modules parameters for driver ###144 */145 146/*147 * Set to enable driver to expose unconfigured disk to kernel148 */149static int megaraid_expose_unconf_disks = 0;150module_param_named(unconf_disks, megaraid_expose_unconf_disks, int, 0);151MODULE_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 busy156 */157static unsigned int max_mbox_busy_wait = MBOX_BUSY_WAIT;158module_param_named(busy_wait, max_mbox_busy_wait, int, 0);159MODULE_PARM_DESC(busy_wait,160 "Max wait for mailbox in microseconds if busy (default=10)");161 162/*163 * number of sectors per IO command164 */165static unsigned int megaraid_max_sectors = MBOX_MAX_SECTORS;166module_param_named(max_sectors, megaraid_max_sectors, int, 0);167MODULE_PARM_DESC(max_sectors,168 "Maximum number of sectors per IO command (default=128)");169 170/*171 * number of commands per logical unit172 */173static unsigned int megaraid_cmd_per_lun = MBOX_DEF_CMD_PER_LUN;174module_param_named(cmd_per_lun, megaraid_cmd_per_lun, int, 0);175MODULE_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 load182 * time. These can be later added though, using /proc/scsi/scsi183 */184static unsigned int megaraid_fast_load;185module_param_named(fast_load, megaraid_fast_load, int, 0);186MODULE_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 by192 * the driver. This level can be changed through modules parameters, ioctl or193 * sysfs/proc interface. By default, print the announcement messages only.194 */195int mraid_debug_level = CL_ANN;196module_param_named(debug_level, mraid_debug_level, int, 0);197MODULE_PARM_DESC(debug_level, "Debug level for driver (default=0)");198 199/*200 * PCI table for all supported controllers.201 */202static 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};289MODULE_DEVICE_TABLE(pci, pci_id_table_g);290 291 292static 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 number303// for a scsi address (Host, Channel, Id, Lun)304 305static DEVICE_ATTR_ADMIN_RO(megaraid_mbox_app_hndl);306 307// Host template initializer for megaraid mbox sysfs device attributes308static struct attribute *megaraid_shost_attrs[] = {309 &dev_attr_megaraid_mbox_app_hndl.attr,310 NULL,311};312 313ATTRIBUTE_GROUPS(megaraid_shost);314 315static DEVICE_ATTR_ADMIN_RO(megaraid_mbox_ld);316 317// Host template initializer for megaraid mbox sysfs device attributes318static struct attribute *megaraid_sdev_attrs[] = {319 &dev_attr_megaraid_mbox_ld.attr,320 NULL,321};322 323ATTRIBUTE_GROUPS(megaraid_sdev);324 325/*326 * Scsi host template for megaraid unified driver327 */328static 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 hook344 *345 * We register ourselves as hotplug enabled module and let PCI subsystem346 * discover our adapters.347 */348static int __init349megaraid_init(void)350{351 int rval;352 353 // Announce the driver version354 con_log(CL_ANN, (KERN_INFO "megaraid: %s %s\n", MEGARAID_VERSION,355 MEGARAID_EXT_VERSION));356 357 // check validity of module parameters358 if (megaraid_cmd_per_lun > MBOX_MAX_SCSI_CMDS) {359 360 con_log(CL_ANN, (KERN_WARNING361 "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 module369 rval = pci_register_driver(&megaraid_pci_driver);370 if (rval < 0) {371 con_log(CL_ANN, (KERN_WARNING372 "megaraid: could not register hotplug support.\n"));373 }374 375 return rval;376}377 378 379/**380 * megaraid_exit - driver unload entry point381 *382 * We simply unwrap the megaraid_init routine here.383 */384static void __exit385megaraid_exit(void)386{387 con_log(CL_DLEVEL1, (KERN_NOTICE "megaraid: unloading framework\n"));388 389 // unregister as PCI hotplug driver390 pci_unregister_driver(&megaraid_pci_driver);391 392 return;393}394 395 396/**397 * megaraid_probe_one - PCI hotplug entry point398 * @pdev : handle to this controller's PCI configuration space399 * @id : pci device id of the class of controllers400 *401 * This routine should be called whenever a new adapter is detected by the402 * PCI hotplug susbsystem.403 */404static int405megaraid_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)406{407 adapter_t *adapter;408 409 410 // detected a new controller411 con_log(CL_ANN, (KERN_INFO412 "megaraid: probe new device %#4.04x:%#4.04x:%#4.04x:%#4.04x: ",413 pdev->vendor, pdev->device, pdev->subsystem_vendor,414 pdev->subsystem_device));415 416 con_log(CL_ANN, ("bus %d:slot %d:func %d\n", pdev->bus->number,417 PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn)));418 419 if (pci_enable_device(pdev)) {420 con_log(CL_ANN, (KERN_WARNING421 "megaraid: pci_enable_device failed\n"));422 423 return -ENODEV;424 }425 426 // Enable bus-mastering on this controller427 pci_set_master(pdev);428 429 // Allocate the per driver initialization structure430 adapter = kzalloc(sizeof(adapter_t), GFP_KERNEL);431 432 if (adapter == NULL) {433 con_log(CL_ANN, (KERN_WARNING434 "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 parameters441 adapter->unique_id = pci_dev_id(pdev);442 adapter->irq = pdev->irq;443 adapter->pdev = pdev;444 445 atomic_set(&adapter->being_detached, 0);446 447 // Setup the default DMA mask. This would be changed later on448 // depending on hardware capabilities449 if (dma_set_mask(&adapter->pdev->dev, DMA_BIT_MASK(32))) {450 con_log(CL_ANN, (KERN_WARNING451 "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 LLD458 spin_lock_init(&adapter->lock);459 460 // Initialize the command queues: the list of free SCBs and the list461 // of pending SCBs.462 INIT_LIST_HEAD(&adapter->kscb_pool);463 spin_lock_init(SCSI_FREE_LIST_LOCK(adapter));464 465 INIT_LIST_HEAD(&adapter->pend_list);466 spin_lock_init(PENDING_LIST_LOCK(adapter));467 468 INIT_LIST_HEAD(&adapter->completed_list);469 spin_lock_init(COMPLETED_LIST_LOCK(adapter));470 471 472 // Start the mailbox based controller473 if (megaraid_init_mbox(adapter) != 0) {474 con_log(CL_ANN, (KERN_WARNING475 "megaraid: mailbox adapter did not initialize\n"));476 477 goto out_free_adapter;478 }479 480 // Register with LSI Common Management Module481 if (megaraid_cmm_register(adapter) != 0) {482 483 con_log(CL_ANN, (KERN_WARNING484 "megaraid: could not register with management module\n"));485 486 goto out_fini_mbox;487 }488 489 // setup adapter handle in PCI soft state490 pci_set_drvdata(pdev, adapter);491 492 // attach with scsi mid-layer493 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 502out_cmm_unreg:503 megaraid_cmm_unregister(adapter);504out_fini_mbox:505 megaraid_fini_mbox(adapter);506out_free_adapter:507 kfree(adapter);508out_probe_one:509 pci_disable_device(pdev);510 511 return -ENODEV;512}513 514 515/**516 * megaraid_detach_one - release framework resources and call LLD release routine517 * @pdev : handle for our PCI configuration space518 *519 * This routine is called during driver unload. We free all the allocated520 * resources and call the corresponding LLD so that it can also release all521 * its resources.522 *523 * This routine is also called from the PCI hotplug system.524 */525static void526megaraid_detach_one(struct pci_dev *pdev)527{528 adapter_t *adapter;529 struct Scsi_Host *host;530 531 532 // Start a rollback on this adapter533 adapter = pci_get_drvdata(pdev);534 535 if (!adapter) {536 con_log(CL_ANN, (KERN_CRIT537 "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_NOTICE545 "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 this554 // adapter.555 // FIXME: How do we account for the request which might still be556 // pending with us?557 atomic_set(&adapter->being_detached, 1);558 559 // detach from the IO sub-system560 megaraid_io_detach(adapter);561 562 // Unregister from common management module563 //564 // FIXME: this must return success or failure for conditions if there565 // is a command pending with LLD or not.566 megaraid_cmm_unregister(adapter);567 568 // finalize the mailbox based controller and release all resources569 megaraid_fini_mbox(adapter);570 571 kfree(adapter);572 573 scsi_host_put(host);574 575 pci_disable_device(pdev);576 577 return;578}579 580 581/**582 * megaraid_mbox_shutdown - PCI shutdown for megaraid HBA583 * @pdev : generic driver model device584 *585 * Shutdown notification, perform flush cache.586 */587static void588megaraid_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_WARNING595 "megaraid: null device in shutdown\n"));596 return;597 }598 599 // flush caches now600 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 subsystem611 * @adapter : controller's soft state612 *613 * Attach this device with the IO subsystem.614 */615static int616megaraid_io_attach(adapter_t *adapter)617{618 struct Scsi_Host *host;619 620 // Initialize SCSI Host structure621 host = scsi_host_alloc(&megaraid_template_g, 8);622 if (!host) {623 con_log(CL_ANN, (KERN_WARNING624 "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 controller645 if (scsi_add_host(host, &adapter->pdev->dev)) {646 647 con_log(CL_ANN, (KERN_WARNING648 "megaraid mbox: scsi_add_host failed\n"));649 650 scsi_host_put(host);651 652 return -1;653 }654 655 scsi_scan_host(host);656 657 return 0;658}659 660 661/**662 * megaraid_io_detach - detach a device from the IO subsystem663 * @adapter : controller's soft state664 *665 * Detach this device from the IO subsystem.666 */667static void668megaraid_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 Driver684 *685 * This is section specific to the single mailbox based controllers686 */687 688/**689 * megaraid_init_mbox - initialize controller690 * @adapter : our soft state691 *692 * - Allocate 16-byte aligned mailbox memory for firmware handshake693 * - Allocate controller's memory resources694 * - Find out all initialization data695 * - Allocate memory required for all the commands696 * - Use internal library of FW routines, build up complete soft state697 */698static int699megaraid_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 mailbox712 * controllers713 */714 raid_dev = kzalloc(sizeof(mraid_device_t), GFP_KERNEL);715 if (raid_dev == NULL) return -1;716 717 718 /*719 * Attach the adapter soft state to raid device soft state720 */721 adapter->raid_device = (caddr_t)raid_dev;722 raid_dev->fast_load = megaraid_fast_load;723 724 725 // our baseport726 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_WARNING731 "megaraid: mem region busy\n"));732 733 goto out_free_raid_dev;734 }735 736 raid_dev->baseaddr = ioremap(raid_dev->baseport, 128);737 738 if (!raid_dev->baseaddr) {739 740 con_log(CL_ANN, (KERN_WARNING741 "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 adapter755 * and initialize its internal state756 */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 of763 * FW routines764 */765 766 /* request IRQ and register the interrupt service routine */767 if (request_irq(adapter->irq, megaraid_isr, IRQF_SHARED, "megaraid",768 adapter)) {769 770 con_log(CL_ANN, (KERN_WARNING771 "megaraid: Couldn't register IRQ %d!\n", adapter->irq));772 goto out_alloc_cmds;773 774 }775 776 // Product info777 if (megaraid_mbox_product_info(adapter) != 0)778 goto out_free_irq;779 780 // Do we support extended CDBs781 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 initiator788 * id.789 * NOTE: In a non-cluster aware firmware environment, the LLD should790 * 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 kernel800 * device address and megaraid device address.801 * We export the physical devices on their actual addresses. The802 * logical drives are exported on a virtual SCSI channel803 */804 megaraid_mbox_setup_device_map(adapter);805 806 // If the firmware supports random deletion, update the device id map807 if (megaraid_mbox_support_random_del(adapter)) {808 809 // Change the logical drives numbers in device_ids array one810 // slot in device_ids is reserved for target id, that's why811 // "<=" below812 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 by823 * this firmware824 */825 adapter->sglen = megaraid_mbox_get_max_sg(adapter);826 827 // enumerate RAID and SCSI channels so that all devices on SCSI828 // channels can later be exported, including disk devices829 megaraid_mbox_enum_raid_scsi(adapter);830 831 /*832 * Other parameters required by upper layer833 *834 * maximum number of sectors per IO command835 */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 is845 * accessed846 */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 of851 // DMA in this range852 pci_read_config_dword(adapter->pdev, PCI_CONF_AMISIG64, &magic64);853 854 if (((magic64 == HBA_SIGNATURE_64_BIT) &&855 ((adapter->pdev->subsystem_device !=856 PCI_SUBSYS_ID_MEGARAID_SATA_150_6) &&857 (adapter->pdev->subsystem_device !=858 PCI_SUBSYS_ID_MEGARAID_SATA_150_4))) ||859 (adapter->pdev->vendor == PCI_VENDOR_ID_LSI_LOGIC &&860 adapter->pdev->device == PCI_DEVICE_ID_VERDE) ||861 (adapter->pdev->vendor == PCI_VENDOR_ID_LSI_LOGIC &&862 adapter->pdev->device == PCI_DEVICE_ID_DOBSON) ||863 (adapter->pdev->vendor == PCI_VENDOR_ID_LSI_LOGIC &&864 adapter->pdev->device == PCI_DEVICE_ID_LINDSAY) ||865 (adapter->pdev->vendor == PCI_VENDOR_ID_DELL &&866 adapter->pdev->device == PCI_DEVICE_ID_PERC4_DI_EVERGLADES) ||867 (adapter->pdev->vendor == PCI_VENDOR_ID_DELL &&868 adapter->pdev->device == PCI_DEVICE_ID_PERC4E_DI_KOBUK)) {869 if (dma_set_mask(&adapter->pdev->dev, DMA_BIT_MASK(64))) {870 con_log(CL_ANN, (KERN_WARNING871 "megaraid: DMA mask for 64-bit failed\n"));872 873 if (dma_set_mask(&adapter->pdev->dev,874 DMA_BIT_MASK(32))) {875 con_log(CL_ANN, (KERN_WARNING876 "megaraid: 32-bit DMA mask failed\n"));877 goto out_free_sysfs_res;878 }879 }880 }881 882 // setup tasklet for DPC883 tasklet_init(&adapter->dpc_h, megaraid_mbox_dpc,884 (unsigned long)adapter);885 886 con_log(CL_DLEVEL1, (KERN_INFO887 "megaraid mbox hba successfully initialized\n"));888 889 return 0;890 891out_free_sysfs_res:892 megaraid_sysfs_free_resources(adapter);893out_free_irq:894 free_irq(adapter->irq, adapter);895out_alloc_cmds:896 megaraid_free_cmd_packets(adapter);897out_iounmap:898 iounmap(raid_dev->baseaddr);899out_release_regions:900 pci_release_regions(pdev);901out_free_raid_dev:902 kfree(raid_dev);903 904 return -1;905}906 907 908/**909 * megaraid_fini_mbox - undo controller initialization910 * @adapter : our soft state911 */912static void913megaraid_fini_mbox(adapter_t *adapter)914{915 mraid_device_t *raid_dev = ADAP2RAIDDEV(adapter);916 917 // flush all caches918 megaraid_mbox_flush_cache(adapter);919 920 tasklet_kill(&adapter->dpc_h);921 922 megaraid_sysfs_free_resources(adapter);923 924 megaraid_free_cmd_packets(adapter);925 926 free_irq(adapter->irq, adapter);927 928 iounmap(raid_dev->baseaddr);929 930 pci_release_regions(adapter->pdev);931 932 kfree(raid_dev);933 934 return;935}936 937 938/**939 * megaraid_alloc_cmd_packets - allocate shared mailbox940 * @adapter : soft state of the raid controller941 *942 * Allocate and align the shared mailbox. This mailbox is used to issue943 * all the commands. For IO based controllers, the mailbox is also registered944 * with the FW. Allocate memory for all commands as well.945 * This is our big allocator.946 */947static int948megaraid_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 mailbox964 * Allocate the common 16-byte aligned memory for the handshake965 * mailbox.966 */967 raid_dev->una_mbox64 = dma_alloc_coherent(&adapter->pdev->dev,968 sizeof(mbox64_t),969 &raid_dev->una_mbox64_dma,970 GFP_KERNEL);971 972 if (!raid_dev->una_mbox64) {973 con_log(CL_ANN, (KERN_WARNING974 "megaraid: out of memory, %s %d\n", __func__,975 __LINE__));976 return -1;977 }978 979 /*980 * Align the mailbox at 16-byte boundary981 */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 internally996 adapter->ibuf = dma_alloc_coherent(&pdev->dev, MBOX_IBUF_SIZE,997 &adapter->ibuf_dma_h, GFP_KERNEL);998 if (!adapter->ibuf) {999 1000 con_log(CL_ANN, (KERN_WARNING1001 "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 associated1008 // memory1009 1010 /*1011 * Allocate memory for the base list of scb. Later allocate memory for1012 * CCBs and embedded components of each CCB and point the pointers in1013 * scb to the allocated components1014 * NOTE: The code to allocate SCB will be duplicated in all the LLD1015 * since the calling routine does not yet know the number of available1016 * commands.1017 */1018 adapter->kscb_list = kcalloc(MBOX_MAX_SCSI_CMDS, sizeof(scb_t), GFP_KERNEL);1019 1020 if (adapter->kscb_list == NULL) {1021 con_log(CL_ANN, (KERN_WARNING1022 "megaraid: out of memory, %s %d\n", __func__,1023 __LINE__));1024 goto out_free_ibuf;1025 }1026 1027 // memory allocation for our command packets1028 if (megaraid_mbox_setup_dma_pools(adapter) != 0) {1029 con_log(CL_ANN, (KERN_WARNING1030 "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 pool1036 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 properly1050 if (ccb->mbox_dma_h & 0x0F) {1051 con_log(CL_ANN, (KERN_CRIT1052 "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 index1072 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 pool1081 list_add_tail(&scb->list, &adapter->kscb_pool);1082 }1083 1084 return 0;1085 1086out_teardown_dma_pools:1087 megaraid_mbox_teardown_dma_pools(adapter);1088out_free_scb_list:1089 kfree(adapter->kscb_list);1090out_free_ibuf:1091 dma_free_coherent(&pdev->dev, MBOX_IBUF_SIZE, (void *)adapter->ibuf,1092 adapter->ibuf_dma_h);1093out_free_common_mbox:1094 dma_free_coherent(&adapter->pdev->dev, sizeof(mbox64_t),1095 (caddr_t)raid_dev->una_mbox64, raid_dev->una_mbox64_dma);1096 1097 return -1;1098}1099 1100 1101/**1102 * megaraid_free_cmd_packets - free memory1103 * @adapter : soft state of the raid controller1104 *1105 * Release memory resources allocated for commands.1106 */1107static void1108megaraid_free_cmd_packets(adapter_t *adapter)1109{1110 mraid_device_t *raid_dev = ADAP2RAIDDEV(adapter);1111 1112 megaraid_mbox_teardown_dma_pools(adapter);1113 1114 kfree(adapter->kscb_list);1115 1116 dma_free_coherent(&adapter->pdev->dev, MBOX_IBUF_SIZE,1117 (void *)adapter->ibuf, adapter->ibuf_dma_h);1118 1119 dma_free_coherent(&adapter->pdev->dev, sizeof(mbox64_t),1120 (caddr_t)raid_dev->una_mbox64, raid_dev->una_mbox64_dma);1121 return;1122}1123 1124 1125/**1126 * megaraid_mbox_setup_dma_pools - setup dma pool for command packets1127 * @adapter : HBA soft state1128 *1129 * Setup the dma pools for mailbox, passthru and extended passthru structures,1130 * and scatter-gather lists.1131 */1132static int1133megaraid_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 mailboxes1144 raid_dev->mbox_pool_handle = dma_pool_create("megaraid mbox pool",1145 &adapter->pdev->dev,1146 sizeof(mbox64_t) + 16,1147 16, 0);1148 1149 if (raid_dev->mbox_pool_handle == NULL) {1150 goto fail_setup_dma_pool;1151 }1152 1153 mbox_pci_blk = raid_dev->mbox_pool;1154 for (i = 0; i < MBOX_MAX_SCSI_CMDS; i++) {1155 mbox_pci_blk[i].vaddr = dma_pool_alloc(1156 raid_dev->mbox_pool_handle,1157 GFP_KERNEL,1158 &mbox_pci_blk[i].dma_addr);1159 if (!mbox_pci_blk[i].vaddr) {1160 goto fail_setup_dma_pool;1161 }1162 }1163 1164 /*1165 * Allocate memory for each embedded passthru strucuture pointer1166 * Request for a 128 bytes aligned structure for each passthru command1167 * structure1168 * Since passthru and extended passthru commands are exclusive, they1169 * share common memory pool. Passthru structures piggyback on memory1170 * allocated to extended passthru since passthru is smaller of the two1171 */1172 raid_dev->epthru_pool_handle = dma_pool_create("megaraid mbox pthru",1173 &adapter->pdev->dev, sizeof(mraid_epassthru_t), 128, 0);1174 1175 if (raid_dev->epthru_pool_handle == NULL) {1176 goto fail_setup_dma_pool;1177 }1178 1179 epthru_pci_blk = raid_dev->epthru_pool;1180 for (i = 0; i < MBOX_MAX_SCSI_CMDS; i++) {1181 epthru_pci_blk[i].vaddr = dma_pool_alloc(1182 raid_dev->epthru_pool_handle,1183 GFP_KERNEL,1184 &epthru_pci_blk[i].dma_addr);1185 if (!epthru_pci_blk[i].vaddr) {1186 goto fail_setup_dma_pool;1187 }1188 }1189 1190 1191 // Allocate memory for each scatter-gather list. Request for 512 bytes1192 // alignment for each sg list1193 raid_dev->sg_pool_handle = dma_pool_create("megaraid mbox sg",1194 &adapter->pdev->dev,1195 sizeof(mbox_sgl64) * MBOX_MAX_SG_SIZE,1196 512, 0);1197 1198 if (raid_dev->sg_pool_handle == NULL) {1199 goto fail_setup_dma_pool;1200 }1201 1202 sg_pci_blk = raid_dev->sg_pool;1203 for (i = 0; i < MBOX_MAX_SCSI_CMDS; i++) {1204 sg_pci_blk[i].vaddr = dma_pool_alloc(1205 raid_dev->sg_pool_handle,1206 GFP_KERNEL,1207 &sg_pci_blk[i].dma_addr);1208 if (!sg_pci_blk[i].vaddr) {1209 goto fail_setup_dma_pool;1210 }1211 }1212 1213 return 0;1214 1215fail_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 packets1223 * @adapter : HBA soft state1224 *1225 * Teardown the dma pool for mailbox, passthru and extended passthru1226 * structures, and scatter-gather lists.1227 */1228static void1229megaraid_mbox_teardown_dma_pools(adapter_t *adapter)1230{1231 mraid_device_t *raid_dev = ADAP2RAIDDEV(adapter);1232 struct mraid_pci_blk *epthru_pci_blk;1233 struct mraid_pci_blk *sg_pci_blk;1234 struct mraid_pci_blk *mbox_pci_blk;1235 int i;1236 1237 1238 sg_pci_blk = raid_dev->sg_pool;1239 for (i = 0; i < MBOX_MAX_SCSI_CMDS && sg_pci_blk[i].vaddr; i++) {1240 dma_pool_free(raid_dev->sg_pool_handle, sg_pci_blk[i].vaddr,1241 sg_pci_blk[i].dma_addr);1242 }1243 dma_pool_destroy(raid_dev->sg_pool_handle);1244 1245 1246 epthru_pci_blk = raid_dev->epthru_pool;1247 for (i = 0; i < MBOX_MAX_SCSI_CMDS && epthru_pci_blk[i].vaddr; i++) {1248 dma_pool_free(raid_dev->epthru_pool_handle,1249 epthru_pci_blk[i].vaddr, epthru_pci_blk[i].dma_addr);1250 }1251 dma_pool_destroy(raid_dev->epthru_pool_handle);1252 1253 1254 mbox_pci_blk = raid_dev->mbox_pool;1255 for (i = 0; i < MBOX_MAX_SCSI_CMDS && mbox_pci_blk[i].vaddr; i++) {1256 dma_pool_free(raid_dev->mbox_pool_handle,1257 mbox_pci_blk[i].vaddr, mbox_pci_blk[i].dma_addr);1258 }1259 dma_pool_destroy(raid_dev->mbox_pool_handle);1260 1261 return;1262}1263 1264 1265/**1266 * megaraid_alloc_scb - detach and return a scb from the free list1267 * @adapter : controller's soft state1268 * @scp : pointer to the scsi command to be executed1269 *1270 * Return the scb from the head of the free list. %NULL if there are none1271 * available.1272 */1273static scb_t *1274megaraid_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 pool1281 spin_lock_irqsave(SCSI_FREE_LIST_LOCK(adapter), flags);1282 1283 if (list_empty(head)) {1284 spin_unlock_irqrestore(SCSI_FREE_LIST_LOCK(adapter), flags);1285 return NULL;1286 }1287 1288 scb = list_entry(head->next, scb_t, list);1289 list_del_init(&scb->list);1290 1291 spin_unlock_irqrestore(SCSI_FREE_LIST_LOCK(adapter), flags);1292 1293 scb->state = SCB_ACTIVE;1294 scb->scp = scp;1295 scb->dma_type = MRAID_DMA_NONE;1296 1297 return scb;1298}1299 1300 1301/**1302 * megaraid_dealloc_scb - return the scb to the free pool1303 * @adapter : controller's soft state1304 * @scb : scb to be freed1305 *1306 * Return the scb back to the free list of scbs. The caller must 'flush' the1307 * 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 this1309 * routine.1310 */1311static inline void1312megaraid_dealloc_scb(adapter_t *adapter, scb_t *scb)1313{1314 unsigned long flags;1315 1316 // put scb in the free pool1317 scb->state = SCB_FREE;1318 scb->scp = NULL;1319 spin_lock_irqsave(SCSI_FREE_LIST_LOCK(adapter), flags);1320 1321 list_add(&scb->list, &adapter->kscb_pool);1322 1323 spin_unlock_irqrestore(SCSI_FREE_LIST_LOCK(adapter), flags);1324 1325 return;1326}1327 1328 1329/**1330 * megaraid_mbox_mksgl - make the scatter-gather list1331 * @adapter : controller's soft state1332 * @scb : scsi control block1333 *1334 * Prepare the scatter-gather list.1335 */1336static int1337megaraid_mbox_mksgl(adapter_t *adapter, scb_t *scb)1338{1339 struct scatterlist *sgl;1340 mbox_ccb_t *ccb;1341 struct scsi_cmnd *scp;1342 int sgcnt;1343 int i;1344 1345 1346 scp = scb->scp;1347 ccb = (mbox_ccb_t *)scb->ccb;1348 1349 sgcnt = scsi_dma_map(scp);1350 BUG_ON(sgcnt < 0 || sgcnt > adapter->sglen);1351 1352 // no mapping required if no data to be transferred1353 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 nodes1364 return sgcnt;1365}1366 1367 1368/**1369 * mbox_post_cmd - issue a mailbox command1370 * @adapter : controller's soft state1371 * @scb : command to be issued1372 *1373 * Post the command to the controller if mailbox is available.1374 */1375static int1376mbox_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 caller1392 * 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" mailbox1413 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 busy1419 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 LLDs1433 * @scp : pointer to the scsi command to be executed1434 *1435 * Queue entry point for mailbox based controllers.1436 */1437static 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 request1449 * if_busy flag will be set if megaraid_mbox_build_cmd() command could1450 * not allocate scb. We will return non-zero status in that case.1451 * NOTE: scb can be null even though certain commands completed1452 * successfully, e.g., MODE_SENSE and TEST_UNIT_READY, it would1453 * 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 completed1458 done(scp);1459 return 0;1460 }1461 1462 megaraid_mbox_runpendq(adapter, scb);1463 return if_busy;1464}1465 1466static DEF_SCSI_QCMD(megaraid_queue_command)1467 1468/**1469 * megaraid_mbox_build_cmd - transform the mid-layer scsi commands1470 * @adapter : controller's soft state1471 * @scp : mid-layer scsi command pointer1472 * @busy : set if request could not be completed because of lack of1473 * resources1474 *1475 * Transform the mid-layer scsi command to megaraid firmware lingua.1476 * Convert the command issued by mid-layer to format understood by megaraid1477 * firmware. We also complete certain commands without sending them to firmware.1478 */1479static scb_t *1480megaraid_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 is1498 * intended for1499 */1500 MRAID_GET_DEVICE_MAP(adapter, scp, channel, target, islogical);1501 1502 /*1503 * Logical drive commands1504 */1505 if (islogical) {1506 switch (scp->cmnd[0]) {1507 case TEST_UNIT_READY:1508 /*1509 * Do we support clustering and is the support enabled1510 * If no, return success always1511 */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 command1530 * issuance routine1531 */1532 ccb->raw_mbox[0] = CLUSTER_CMD;1533 ccb->raw_mbox[2] = RESERVATION_STATUS;1534 ccb->raw_mbox[3] = target;1535 1536 return scb;1537 1538 case MODE_SENSE:1539 {1540 struct scatterlist *sgl;1541 caddr_t vaddr;1542 1543 sgl = scsi_sglist(scp);1544 if (sg_page(sgl)) {1545 vaddr = (caddr_t) sg_virt(&sgl[0]);1546 1547 memset(vaddr, 0, scp->cmnd[4]);1548 }1549 else {1550 con_log(CL_ANN, (KERN_WARNING1551 "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 drives1561 * 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_INFO1566 "scsi[%d]: scanning scsi channel %d",1567 adapter->host->host_no,1568 SCP2CHANNEL(scp)));1569 1570 con_log(CL_ANN, (1571 " [virtual] for logical drives\n"));1572 1573 rdev->last_disp |= (1L << SCP2CHANNEL(scp));1574 }1575 1576 if (scp->cmnd[1] & MEGA_SCSI_INQ_EVPD) {1577 scsi_build_sense(scp, 0, ILLEGAL_REQUEST,1578 MEGA_INVALID_FIELD_IN_CDB, 0);1579 return NULL;1580 }1581 1582 fallthrough;1583 1584 case READ_CAPACITY:1585 /*1586 * Do not allow LUN > 0 for logical drives and1587 * requests for more than 40 logical drives1588 */1589 if (SCP2LUN(scp)) {1590 scp->result = (DID_BAD_TARGET << 16);1591 return NULL;1592 }1593 if ((target % 0x80) >= MAX_LOGICAL_DRIVES_40LD) {1594 scp->result = (DID_BAD_TARGET << 16);1595 return NULL;1596 }1597 1598 1599 /* Allocate a SCB and initialize passthru */1600 if (!(scb = megaraid_alloc_scb(adapter, scp))) {1601 scp->result = (DID_ERROR << 16);1602 *busy = 1;1603 return NULL;1604 }1605 1606 ccb = (mbox_ccb_t *)scb->ccb;1607 scb->dev_channel = 0xFF;1608 scb->dev_target = target;1609 pthru = ccb->pthru;1610 mbox = ccb->mbox;1611 mbox64 = ccb->mbox64;1612 1613 pthru->timeout = 0;1614 pthru->ars = 1;1615 pthru->reqsenselen = 14;1616 pthru->islogical = 1;1617 pthru->logdrv = target;1618 pthru->cdblen = scp->cmd_len;1619 memcpy(pthru->cdb, scp->cmnd, scp->cmd_len);1620 1621 mbox->cmd = MBOXCMD_PASSTHRU64;1622 scb->dma_direction = scp->sc_data_direction;1623 1624 pthru->dataxferlen = scsi_bufflen(scp);1625 pthru->dataxferaddr = ccb->sgl_dma_h;1626 pthru->numsge = megaraid_mbox_mksgl(adapter,1627 scb);1628 1629 mbox->xferaddr = 0xFFFFFFFF;1630 mbox64->xferaddr_lo = (uint32_t )ccb->pthru_dma_h;1631 mbox64->xferaddr_hi = 0;1632 1633 return scb;1634 1635 case READ_6:1636 case WRITE_6:1637 case READ_10:1638 case WRITE_10:1639 case READ_12:1640 case WRITE_12:1641 1642 /*1643 * Allocate a SCB and initialize mailbox1644 */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 read1659 * commands and is set for all scsi write commands1660 */1661 mbox->cmd = (scp->cmnd[0] & 0x02) ? MBOXCMD_LWRITE64:1662 MBOXCMD_LREAD64 ;1663 1664 /*1665 * 6-byte READ(0x08) or WRITE(0x0A) cdb1666 */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) cdb1679 */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) cdb1693 */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_WARNING1709 "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 info1720 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 enabled1732 */1733 if (!adapter->ha) {1734 scp->result = (DID_BAD_TARGET << 16);1735 return NULL;1736 }1737 1738 /*1739 * Allocate a SCB and initialize mailbox1740 */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 commands1765 1766 // Do not allow access to target id > 15 or LUN > 71767 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 is1773 // over, reset the fast_load flag so that during a possible1774 // next scan, devices can be made available1775 if (rdev->fast_load && (target == 15) &&1776 (SCP2CHANNEL(scp) == adapter->max_channel -1)) {1777 1778 con_log(CL_ANN, (KERN_INFO1779 "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 devices1786 */1787 if (!(rdev->last_disp & (1L << SCP2CHANNEL(scp)))) {1788 1789 ss = rdev->fast_load ? skip : scan;1790 1791 con_log(CL_ANN, (KERN_INFO1792 "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 given1803 if (rdev->fast_load) {1804 scp->result = (DID_BAD_TARGET << 16);1805 return NULL;1806 }1807 1808 // Allocate a SCB and initialize passthru1809 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 CDBs1823 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 REACHED1845}1846 1847 1848/**1849 * megaraid_mbox_runpendq - execute commands queued in the pending queue1850 * @adapter : controller's soft state1851 * @scb_q : SCB to be queued in the pending list1852 *1853 * Scan the pending list for commands which are not yet issued and try to1854 * post to the controller. The SCB can be a null pointer, which would indicate1855 * 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 plucked1858 * out from the head of the pending list. If it is successfully issued, the1859 * next SCB is at the head now.1860 */1861static void1862megaraid_mbox_runpendq(adapter_t *adapter, scb_t *scb_q)1863{1864 scb_t *scb;1865 unsigned long flags;1866 1867 spin_lock_irqsave(PENDING_LIST_LOCK(adapter), flags);1868 1869 if (scb_q) {1870 scb_q->state = SCB_PENDQ;1871 list_add_tail(&scb_q->list, &adapter->pend_list);1872 }1873 1874 // if the adapter in not in quiescent mode, post the commands to FW1875 if (adapter->quiescent) {1876 spin_unlock_irqrestore(PENDING_LIST_LOCK(adapter), flags);1877 return;1878 }1879 1880 while (!list_empty(&adapter->pend_list)) {1881 1882 assert_spin_locked(PENDING_LIST_LOCK(adapter));1883 1884 scb = list_entry(adapter->pend_list.next, scb_t, list);1885 1886 // remove the scb from the pending list and try to1887 // issue. If we are unable to issue it, put back in1888 // the pending list and return1889 1890 list_del_init(&scb->list);1891 1892 spin_unlock_irqrestore(PENDING_LIST_LOCK(adapter), flags);1893 1894 // if mailbox was busy, return SCB back to pending1895 // list. Make sure to add at the head, since that's1896 // where it would have been removed from1897 1898 scb->state = SCB_ISSUED;1899 1900 if (mbox_post_cmd(adapter, scb) != 0) {1901 1902 spin_lock_irqsave(PENDING_LIST_LOCK(adapter), flags);1903 1904 scb->state = SCB_PENDQ;1905 1906 list_add(&scb->list, &adapter->pend_list);1907 1908 spin_unlock_irqrestore(PENDING_LIST_LOCK(adapter),1909 flags);1910 1911 return;1912 }1913 1914 spin_lock_irqsave(PENDING_LIST_LOCK(adapter), flags);1915 }1916 1917 spin_unlock_irqrestore(PENDING_LIST_LOCK(adapter), flags);1918 1919 1920 return;1921}1922 1923 1924/**1925 * megaraid_mbox_prepare_pthru - prepare a command for physical devices1926 * @adapter : pointer to controller's soft state1927 * @scb : scsi control block1928 * @scp : scsi command from the mid-layer1929 *1930 * Prepare a command for the scsi physical devices.1931 */1932static void1933megaraid_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 timeout1947 pthru->timeout = 4; 1948 pthru->ars = 1;1949 pthru->islogical = 0;1950 pthru->channel = 0;1951 pthru->target = (channel << 4) | target;1952 pthru->logdrv = SCP2LUN(scp);1953 pthru->reqsenselen = 14;1954 pthru->cdblen = scp->cmd_len;1955 1956 memcpy(pthru->cdb, scp->cmnd, scp->cmd_len);1957 1958 if (scsi_bufflen(scp)) {1959 pthru->dataxferlen = scsi_bufflen(scp);1960 pthru->dataxferaddr = ccb->sgl_dma_h;1961 pthru->numsge = megaraid_mbox_mksgl(adapter, scb);1962 }1963 else {1964 pthru->dataxferaddr = 0;1965 pthru->dataxferlen = 0;1966 pthru->numsge = 0;1967 }1968 return;1969}1970 1971 1972/**1973 * megaraid_mbox_prepare_epthru - prepare a command for physical devices1974 * @adapter : pointer to controller's soft state1975 * @scb : scsi control block1976 * @scp : scsi command from the mid-layer1977 *1978 * Prepare a command for the scsi physical devices. This routine prepares1979 * commands for devices which can take extended CDBs (>10 bytes).1980 */1981static void1982megaraid_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 timeout1996 epthru->timeout = 4; 1997 epthru->ars = 1;1998 epthru->islogical = 0;1999 epthru->channel = 0;2000 epthru->target = (channel << 4) | target;2001 epthru->logdrv = SCP2LUN(scp);2002 epthru->reqsenselen = 14;2003 epthru->cdblen = scp->cmd_len;2004 2005 memcpy(epthru->cdb, scp->cmnd, scp->cmd_len);2006 2007 if (scsi_bufflen(scp)) {2008 epthru->dataxferlen = scsi_bufflen(scp);2009 epthru->dataxferaddr = ccb->sgl_dma_h;2010 epthru->numsge = megaraid_mbox_mksgl(adapter, scb);2011 }2012 else {2013 epthru->dataxferaddr = 0;2014 epthru->dataxferlen = 0;2015 epthru->numsge = 0;2016 }2017 return;2018}2019 2020 2021/**2022 * megaraid_ack_sequence - interrupt ack sequence for memory mapped HBAs2023 * @adapter : controller's soft state2024 *2025 * Interrupt acknowledgement sequence for memory mapped HBAs. Find out the2026 * completed command and put them on the completed list for later processing.2027 *2028 * Returns: 1 if the interrupt is valid, 0 otherwise2029 */2030static int2031megaraid_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 list2048 INIT_LIST_HEAD(&clist);2049 2050 // loop till F/W has more commands for us to complete2051 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 the2056 * 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 post2067 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 post2081 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_CRIT2090 "megaraid: command posting timed out\n"));2091 2092 BUG();2093 continue;2094 }2095 2096 // Get SCB associated with this command id2097 if (completed[i] >= MBOX_MAX_SCSI_CMDS) {2098 // a cmm command2099 scb = adapter->uscb_list + (completed[i] -2100 MBOX_MAX_SCSI_CMDS);2101 }2102 else {2103 // an os command2104 scb = adapter->kscb_list + completed[i];2105 }2106 2107 scb->status = mbox->status;2108 list_add_tail(&scb->list, &clist);2109 }2110 2111 // Acknowledge interrupt2112 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 would2120 // complete these commands later2121 spin_lock_irqsave(COMPLETED_LIST_LOCK(adapter), flags);2122 2123 list_splice(&clist, &adapter->completed_list);2124 2125 spin_unlock_irqrestore(COMPLETED_LIST_LOCK(adapter), flags);2126 2127 2128 // schedule the DPC if there is some work for it2129 if (handled)2130 tasklet_schedule(&adapter->dpc_h);2131 2132 return handled;2133}2134 2135 2136/**2137 * megaraid_isr - isr for memory based mailbox based controllers2138 * @irq : irq2139 * @devp : pointer to our soft state2140 *2141 * Interrupt service routine for memory-mapped mailbox controllers.2142 */2143static irqreturn_t2144megaraid_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 list2162 * @devp : pointer to HBA soft state2163 *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 while2166 * it is being called.2167 */2168static void2169megaraid_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 list2196 INIT_LIST_HEAD(&clist);2197 2198 spin_lock_irqsave(COMPLETED_LIST_LOCK(adapter), flags);2199 2200 list_splice_init(&adapter->completed_list, &clist);2201 2202 spin_unlock_irqrestore(COMPLETED_LIST_LOCK(adapter), flags);2203 2204 2205 list_for_each_entry_safe(scb, tmp, &clist, list) {2206 2207 status = scb->status;2208 scp = scb->scp;2209 ccb = (mbox_ccb_t *)scb->ccb;2210 pthru = ccb->pthru;2211 epthru = ccb->epthru;2212 mbox = ccb->mbox;2213 2214 // Make sure f/w has completed a valid command2215 if (scb->state != SCB_ISSUED) {2216 con_log(CL_ANN, (KERN_CRIT2217 "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 away2224 if (scb->sno >= MBOX_MAX_SCSI_CMDS) {2225 scb->state = SCB_FREE;2226 scb->status = status;2227 2228 // remove from local clist2229 list_del_init(&scb->list);2230 2231 kioc = (uioc_t *)scb->gp;2232 kioc->status = 0;2233 2234 megaraid_mbox_mm_done(adapter, scb);2235 2236 continue;2237 }2238 2239 // Was an abort issued for this command earlier2240 if (scb->state & SCB_ABORT) {2241 con_log(CL_ANN, (KERN_NOTICE2242 "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 of2248 * any RAID array, expose it to the kernel. For this to be2249 * 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 other2252 * configurations.2253 */2254 islogical = MRAID_IS_LOGICAL(adapter, scp);2255 if (scp->cmnd[0] == INQUIRY && status == 0 && islogical == 02256 && IS_RAID_CH(raid_dev, scb->dev_channel)) {2257 2258 sgl = scsi_sglist(scp);2259 if (sg_page(sgl)) {2260 c = *(unsigned char *) sg_virt(&sgl[0]);2261 } else {2262 con_log(CL_ANN, (KERN_WARNING2263 "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 code2286 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 } else2312 scsi_build_sense(scp, 0,2313 ABORTED_COMMAND, 0, 0);2314 }2315 break;2316 2317 case 0x08:2318 2319 scp->result = DID_BUS_BUSY << 16 | status;2320 break;2321 2322 default:2323 2324 /*2325 * If TEST_UNIT_READY fails, we know RESERVATION_STATUS2326 * failed2327 */2328 if (scp->cmnd[0] == TEST_UNIT_READY) {2329 scp->result = DID_ERROR << 16 |2330 SAM_STAT_RESERVATION_CONFLICT;2331 }2332 else2333 /*2334 * Error code returned is 1 if Reserve or Release2335 * failed or the input parameter is invalid2336 */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 commands2349 if (status) {2350 megaraid_mbox_display_scb(adapter, scb);2351 }2352 2353 scsi_dma_unmap(scp);2354 2355 // remove from local clist2356 list_del_init(&scb->list);2357 2358 // put back in free list2359 megaraid_dealloc_scb(adapter, scb);2360 2361 // send the scsi packet back to kernel2362 scsi_done(scp);2363 }2364 2365 return;2366}2367 2368 2369/**2370 * megaraid_abort_handler - abort the scsi command2371 * @scp : command to be aborted2372 *2373 * Abort a previous SCSI request. Only commands on the pending list can be2374 * aborted. All the commands issued to the F/W must complete.2375 **/2376static int2377megaraid_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_WARNING2392 "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 failure2397 if (raid_dev->hw_error) {2398 con_log(CL_ANN, (KERN_NOTICE2399 "megaraid: hw error, not aborting\n"));2400 return FAILED;2401 }2402 2403 // There might a race here, where the command was completed by the2404 // firmware and now it is on the completed list. Before we could2405 // 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 command2412 2413 list_del_init(&scb->list); // from completed list2414 2415 con_log(CL_ANN, (KERN_WARNING2416 "megaraid: %d[%d:%d], abort from completed list\n",2417 scb->sno, scb->dev_channel, scb->dev_target));2418 2419 scp->result = (DID_ABORT << 16);2420 scsi_done(scp);2421 2422 megaraid_dealloc_scb(adapter, scb);2423 2424 spin_unlock_irqrestore(COMPLETED_LIST_LOCK(adapter),2425 flags);2426 2427 return SUCCESS;2428 }2429 }2430 spin_unlock_irqrestore(COMPLETED_LIST_LOCK(adapter), flags);2431 2432 2433 // Find out if this command is still on the pending list. If it is and2434 // was never issued, abort and return success. If the command is owned2435 // 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 command2440 2441 list_del_init(&scb->list); // from pending list2442 2443 ASSERT(!(scb->state & SCB_ISSUED));2444 2445 con_log(CL_ANN, (KERN_WARNING2446 "megaraid abort: [%d:%d], driver owner\n",2447 scb->dev_channel, scb->dev_target));2448 2449 scp->result = (DID_ABORT << 16);2450 scsi_done(scp);2451 2452 megaraid_dealloc_scb(adapter, scb);2453 2454 spin_unlock_irqrestore(PENDING_LIST_LOCK(adapter),2455 flags);2456 2457 return SUCCESS;2458 }2459 }2460 spin_unlock_irqrestore(PENDING_LIST_LOCK(adapter), flags);2461 2462 2463 // Check do we even own this command, in which case this would be2464 // owned by the firmware. The only way to locate the FW scb is to2465 // traverse through the list of all SCB, since driver does not2466 // maintain these SCBs on any list2467 found = 0;2468 spin_lock_irq(&adapter->lock);2469 for (i = 0; i < MBOX_MAX_SCSI_CMDS; i++) {2470 scb = adapter->kscb_list + i;2471 2472 if (scb->scp == scp) {2473 2474 found = 1;2475 2476 if (!(scb->state & SCB_ISSUED)) {2477 con_log(CL_ANN, (KERN_WARNING2478 "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_WARNING2484 "megaraid abort: %d[%d:%d], fw owner\n",2485 scb->sno, scb->dev_channel, scb->dev_target));2486 }2487 }2488 }2489 spin_unlock_irq(&adapter->lock);2490 2491 if (!found) {2492 con_log(CL_ANN, (KERN_WARNING "megaraid abort: do now own\n"));2493 2494 // FIXME: Should there be a callback for this command?2495 return SUCCESS;2496 }2497 2498 // We cannot actually abort a command owned by firmware, return2499 // failure and wait for reset. In host reset handler, we will find out2500 // if the HBA is still live2501 return FAILED;2502}2503 2504/**2505 * megaraid_reset_handler - device reset handler for mailbox based driver2506 * @scp : reference command2507 *2508 * Reset handler for the mailbox based controller. First try to find out if2509 * the FW is still live, in which case the outstanding commands counter mut go2510 * down to 0. If that happens, also issue the reservation reset command to2511 * relinquish (possible) reservations on the logical drives connected to this2512 * host.2513 **/2514static int2515megaraid_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 responding2532 if (raid_dev->hw_error) {2533 con_log(CL_ANN, (KERN_NOTICE2534 "megaraid: hw error, cannot reset\n"));2535 return FAILED;2536 }2537 2538 // Under exceptional conditions, FW can take up to 3 minutes to2539 // complete command processing. Wait for additional 2 minutes for the2540 // pending commands counter to go down to 0. If it doesn't, let the2541 // controller be marked offline2542 // Also, reset all the commands currently owned by the driver2543 spin_lock_irqsave(PENDING_LIST_LOCK(adapter), flags);2544 list_for_each_entry_safe(scb, tmp, &adapter->pend_list, list) {2545 list_del_init(&scb->list); // from pending list2546 2547 if (scb->sno >= MBOX_MAX_SCSI_CMDS) {2548 con_log(CL_ANN, (KERN_WARNING2549 "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 command2560 con_log(CL_ANN, (KERN_WARNING2561 "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_WARNING2565 "megaraid: IO packet with %d[%d:%d] being reset\n",2566 scb->sno, scb->dev_channel, scb->dev_target));2567 }2568 2569 scb->scp->result = (DID_RESET << 16);2570 scsi_done(scb->scp);2571 2572 megaraid_dealloc_scb(adapter, scb);2573 }2574 }2575 spin_unlock_irqrestore(PENDING_LIST_LOCK(adapter), flags);2576 2577 if (adapter->outstanding_cmds) {2578 con_log(CL_ANN, (KERN_NOTICE2579 "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 only2591 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 time2599 if (adapter->outstanding_cmds == 0) {2600 break;2601 }2602 2603 msleep(1000);2604 }2605 2606 spin_lock(&adapter->lock);2607 2608 // If still outstanding commands, bail out2609 if (adapter->outstanding_cmds) {2610 con_log(CL_ANN, (KERN_WARNING2611 "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_NOTICE2620 "megaraid mbox: reset sequence completed successfully\n"));2621 }2622 2623 2624 // If the controller supports clustering, reset reservations2625 if (!adapter->ha) {2626 rval = SUCCESS;2627 goto out;2628 }2629 2630 // clear reservations if any2631 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_WARNING2642 "megaraid: reservation reset failed\n"));2643 }2644 2645 out:2646 spin_unlock(&adapter->lock);2647 return rval;2648}2649 2650/*2651 * START: internal commands library2652 *2653 * This section of the driver has the common routine used by the driver and2654 * also has all the FW routines2655 */2656 2657/**2658 * mbox_post_sync_cmd() - blocking command to the mailbox based controllers2659 * @adapter : controller's soft state2660 * @raw_mbox : the mailbox2661 *2662 * Issue a scb in synchronous and non-interrupt mode for mailbox based2663 * controllers.2664 */2665static int2666mbox_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 free2677 */2678 if (megaraid_busywait_mbox(raid_dev) != 0)2679 goto blocked_mailbox;2680 2681 /*2682 * Copy mailbox data into host structure2683 */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 not2696 // available within 1 second, assume FW is initializing and wait2697 // for an extended amount of time2698 if (mbox->numstatus == 0xFF) { // status not yet available2699 udelay(25);2700 2701 for (i = 0; mbox->numstatus == 0xFF && i < 1000; i++) {2702 rmb();2703 msleep(1);2704 }2705 2706 2707 if (i == 1000) {2708 con_log(CL_ANN, (KERN_NOTICE2709 "megaraid mailbox: wait for FW to boot "));2710 2711 for (i = 0; (mbox->numstatus == 0xFF) &&2712 (i < MBOX_RESET_WAIT); i++) {2713 rmb();2714 con_log(CL_ANN, ("\b\b\b\b\b[%03d]",2715 MBOX_RESET_WAIT - i));2716 msleep(1000);2717 }2718 2719 if (i == MBOX_RESET_WAIT) {2720 2721 con_log(CL_ANN, (2722 "\nmegaraid mailbox: status not available\n"));2723 2724 return -1;2725 }2726 con_log(CL_ANN, ("\b\b\b\b\b[ok] \n"));2727 }2728 }2729 2730 // wait for maximum 1 second for poll semaphore2731 if (mbox->poll != 0x77) {2732 udelay(25);2733 2734 for (i = 0; (mbox->poll != 0x77) && (i < 1000); i++) {2735 rmb();2736 msleep(1);2737 }2738 2739 if (i == 1000) {2740 con_log(CL_ANN, (KERN_WARNING2741 "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 acknowledgement2750 if (RDINDOOR(raid_dev) & 0x2) {2751 udelay(25);2752 2753 for (i = 0; (RDINDOOR(raid_dev) & 0x2) && (i < 1000); i++) {2754 rmb();2755 msleep(1);2756 }2757 2758 if (i == 1000) {2759 con_log(CL_ANN, (KERN_WARNING2760 "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 command2770 // 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 2779blocked_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 controllers2788 * @adapter : controller's soft state2789 * @raw_mbox : the mailbox2790 *2791 * Issue a scb in synchronous and non-interrupt mode for mailbox based2792 * controllers. This is a faster version of the synchronous command and2793 * therefore can be called in interrupt-context as well.2794 */2795static int2796mbox_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 busy2806 if (mbox->busy) return -1;2807 2808 // Copy mailbox data into host structure2809 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 counter2828 con_log(CL_ANN, (KERN_CRIT2829 "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 available2841 * @raid_dev : RAID device (HBA) soft state2842 *2843 * Wait until the controller's mailbox is available to accept more commands.2844 * Wait for at most 1 second.2845 */2846static int2847megaraid_busywait_mbox(mraid_device_t *raid_dev)2848{2849 mbox_t *mbox = raid_dev->mbox;2850 int i = 0;2851 2852 if (mbox->busy) {2853 udelay(25);2854 for (i = 0; mbox->busy && i < 1000; i++)2855 msleep(1);2856 }2857 2858 if (i < 1000) return 0;2859 else return -1;2860}2861 2862 2863/**2864 * megaraid_mbox_product_info - some static information about the controller2865 * @adapter : our soft state2866 *2867 * Issue commands to the controller to grab some parameters required by our2868 * caller.2869 */2870static int2871megaraid_mbox_product_info(adapter_t *adapter)2872{2873 mraid_device_t *raid_dev = ADAP2RAIDDEV(adapter);2874 mbox_t *mbox;2875 uint8_t raw_mbox[sizeof(mbox_t)];2876 mraid_pinfo_t *pinfo;2877 dma_addr_t pinfo_dma_h;2878 mraid_inquiry3_t *mraid_inq3;2879 int i;2880 2881 2882 memset((caddr_t)raw_mbox, 0, sizeof(raw_mbox));2883 mbox = (mbox_t *)raw_mbox;2884 2885 /*2886 * Issue an ENQUIRY3 command to find out certain adapter parameters,2887 * e.g., max channels, max commands etc.2888 */2889 pinfo = dma_alloc_coherent(&adapter->pdev->dev, sizeof(mraid_pinfo_t),2890 &pinfo_dma_h, GFP_KERNEL);2891 if (pinfo == NULL) {2892 con_log(CL_ANN, (KERN_WARNING2893 "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 command2907 if (mbox_post_sync_cmd(adapter, raw_mbox) != 0) {2908 2909 con_log(CL_ANN, (KERN_WARNING "megaraid: Inquiry3 failed\n"));2910 2911 dma_free_coherent(&adapter->pdev->dev, sizeof(mraid_pinfo_t),2912 pinfo, pinfo_dma_h);2913 2914 return -1;2915 }2916 2917 /*2918 * Collect information about state of each physical drive2919 * attached to the controller. We will expose all the disks2920 * which are not part of RAID2921 */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_WARNING2940 "megaraid: product info failed\n"));2941 2942 dma_free_coherent(&adapter->pdev->dev, sizeof(mraid_pinfo_t),2943 pinfo, pinfo_dma_h);2944 2945 return -1;2946 }2947 2948 /*2949 * Setup some parameters for host, as required by our caller2950 */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 ID2956 */2957 adapter->max_target = MAX_LOGICAL_DRIVES_40LD + 1;2958 adapter->max_lun = 8; // up to 8 LUNs for non-disk devices2959 2960 /*2961 * These are the maximum outstanding commands for the scsi-layer2962 */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_NOTICE2975 "megaraid: fw version:[%s] bios version:[%s]\n",2976 adapter->fw_version, adapter->bios_version));2977 2978 dma_free_coherent(&adapter->pdev->dev, sizeof(mraid_pinfo_t), pinfo,2979 pinfo_dma_h);2980 2981 return 0;2982}2983 2984 2985 2986/**2987 * megaraid_mbox_extended_cdb - check for support for extended CDBs2988 * @adapter : soft state for the controller2989 *2990 * This routine check whether the controller in question supports extended2991 * ( > 10 bytes ) CDBs.2992 */2993static int2994megaraid_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 command3012 */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 clustering3024 * @adapter : soft state for the controller3025 * @init_id : ID of the initiator3026 *3027 * Determine if the firmware supports clustering and the ID of the initiator.3028 */3029static int3030megaraid_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 command3048 *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_INFO3055 "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 deletion3067 * @adapter : soft state for the controller3068 *3069 * Determine if the firmware supports random deletion.3070 * Return: 1 is operation supported, 0 otherwise3071 */3072static int3073megaraid_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 different3080 * 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 command3102 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 firmware3116 * @adapter : soft state for the controller3117 *3118 * Find out the maximum number of scatter-gather elements supported by the3119 * firmware.3120 */3121static int3122megaraid_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 command3141 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 channels3156 * @adapter : soft state for the controller3157 *3158 * Enumerate the RAID and SCSI channels for ROMB platforms so that channels3159 * can be exported as regular SCSI channels.3160 */3161static void3162megaraid_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 RAID3181 // channels3182 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 cache3193 * @adapter : soft state for the controller3194 *3195 * Flush adapter cache followed by disks cache.3196 */3197static void3198megaraid_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 cmd3222 * @adapter : soft state for the controller3223 *3224 * Clears the pending cmds in FW and reinits its RAID structs.3225 */3226static int3227megaraid_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 03263 * else3264 * the firmware will reject the command with3265 * mbox->numstatus set to 13266 */3267 3268 i = 0;3269 status = 0;3270 while (!mbox->numstatus && mbox->cmd == 0xFF) {3271 rmb();3272 msleep(1);3273 i++;3274 if (i > 1000 * 60) {3275 status = 1;3276 break;3277 }3278 }3279 if (mbox->numstatus == 1)3280 status = 1; /*cmd not supported*/3281 3282 /* Check for interrupt line */3283 dword = RDOUTDOOR(raid_dev);3284 WROUTDOOR(raid_dev, dword);3285 WRINDOOR(raid_dev,2);3286 3287 return status;3288 3289blocked_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 purposes3296 * @adapter : controller's soft state3297 * @scb : SCB to be displayed3298 *3299 * Diplay information about the given SCB iff the current debug level is3300 * verbose.3301 */3302static void3303megaraid_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_NOTICE3319 "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 ids3342 * @adapter : Driver's soft state3343 *3344 * Manage the device ids to have an appropriate mapping between the kernel3345 * scsi addresses and megaraid scsi and logical drive addresses. We export3346 * scsi devices on their actual addresses, whereas the logical drives are3347 * exported on a virtual scsi channel.3348 */3349static void3350megaraid_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 channel3357 */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 channels3366 */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 library3375 */3376 3377/*3378 * START: Interface for the common management module3379 *3380 * This is the module, which interfaces with the common management module to3381 * provide support for ioctl and sysfs3382 */3383 3384/**3385 * megaraid_cmm_register - register with the management module3386 * @adapter : HBA soft state3387 *3388 * Register with the management module, which allows applications to issue3389 * ioctl calls to the drivers. This interface is used by the management module3390 * to setup sysfs support as well.3391 */3392static int3393megaraid_cmm_register(adapter_t *adapter)3394{3395 mraid_device_t *raid_dev = ADAP2RAIDDEV(adapter);3396 mraid_mmadp_t adp;3397 scb_t *scb;3398 mbox_ccb_t *ccb;3399 int rval;3400 int i;3401 3402 // Allocate memory for the base list of scb for management module.3403 adapter->uscb_list = kcalloc(MBOX_MAX_USER_CMDS, sizeof(scb_t), GFP_KERNEL);3404 3405 if (adapter->uscb_list == NULL) {3406 con_log(CL_ANN, (KERN_WARNING3407 "megaraid: out of memory, %s %d\n", __func__,3408 __LINE__));3409 return -1;3410 }3411 3412 3413 // Initialize the synchronization parameters for resources for3414 // commands for management module3415 INIT_LIST_HEAD(&adapter->uscb_pool);3416 3417 spin_lock_init(USER_FREE_LIST_LOCK(adapter));3418 3419 3420 3421 // link all the packets. Note, CCB for commands, coming from the3422 // commom management module, mailbox physical address are already3423 // setup by it. We just need placeholder for that in our local command3424 // control blocks3425 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 FOR3438 // 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 pool3449 list_add_tail(&scb->list, &adapter->uscb_pool);3450 }3451 3452 adp.unique_id = adapter->unique_id;3453 adp.drvr_type = DRVRTYPE_MBOX;3454 adp.drvr_data = (unsigned long)adapter;3455 adp.pdev = adapter->pdev;3456 adp.issue_uioc = megaraid_mbox_mm_handler;3457 adp.timeout = MBOX_RESET_WAIT + MBOX_RESET_EXT_WAIT;3458 adp.max_kioc = MBOX_MAX_USER_CMDS;3459 3460 if ((rval = mraid_mm_register_adp(&adp)) != 0) {3461 3462 con_log(CL_ANN, (KERN_WARNING3463 "megaraid mbox: did not register with CMM\n"));3464 3465 kfree(adapter->uscb_list);3466 }3467 3468 return rval;3469}3470 3471 3472/**3473 * megaraid_cmm_unregister - un-register with the management module3474 * @adapter : HBA soft state3475 *3476 * Un-register with the management module.3477 * FIXME: mgmt module must return failure for unregister if it has pending3478 * commands in LLD.3479 */3480static int3481megaraid_cmm_unregister(adapter_t *adapter)3482{3483 kfree(adapter->uscb_list);3484 mraid_mm_unregister_adp(adapter->unique_id);3485 return 0;3486}3487 3488 3489/**3490 * megaraid_mbox_mm_handler - interface for CMM to issue commands to LLD3491 * @drvr_data : LLD specific data3492 * @kioc : CMM interface packet3493 * @action : command action3494 *3495 * This routine is invoked whenever the Common Management Module (CMM) has a3496 * command for us. The 'action' parameter specifies if this is a new command3497 * or otherwise.3498 */3499static int3500megaraid_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_WARNING3506 "megaraid: unsupported management action:%#2x\n",3507 action));3508 return (-ENOTSUPP);3509 }3510 3511 adapter = (adapter_t *)drvr_data;3512 3513 // make sure this adapter is not being detached right now.3514 if (atomic_read(&adapter->being_detached)) {3515 con_log(CL_ANN, (KERN_WARNING3516 "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 reached3542}3543 3544/**3545 * megaraid_mbox_mm_command - issues commands routed through CMM3546 * @adapter : HBA soft state3547 * @kioc : management command packet3548 *3549 * Issues commands, which are routed through the management module.3550 */3551static int3552megaraid_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 pool3562 spin_lock_irqsave(USER_FREE_LIST_LOCK(adapter), flags);3563 3564 if (list_empty(head)) { // should never happen because of CMM3565 3566 con_log(CL_ANN, (KERN_WARNING3567 "megaraid mbox: bug in cmm handler, lost resources\n"));3568 3569 spin_unlock_irqrestore(USER_FREE_LIST_LOCK(adapter), flags);3570 3571 return (-EINVAL);3572 }3573 3574 scb = list_entry(head->next, scb_t, list);3575 list_del_init(&scb->list);3576 3577 spin_unlock_irqrestore(USER_FREE_LIST_LOCK(adapter), flags);3578 3579 scb->state = SCB_ACTIVE;3580 scb->dma_type = MRAID_DMA_NONE;3581 scb->dma_direction = DMA_NONE;3582 3583 ccb = (mbox_ccb_t *)scb->ccb;3584 mbox64 = (mbox64_t *)(unsigned long)kioc->cmdbuf;3585 raw_mbox = (uint8_t *)&mbox64->mbox32;3586 3587 memcpy(ccb->mbox64, mbox64, sizeof(mbox64_t));3588 3589 scb->gp = (unsigned long)kioc;3590 3591 /*3592 * If it is a logdrv random delete operation, we have to wait till3593 * there are no outstanding cmds at the fw and then issue it directly3594 */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_NOTICE3599 "megaraid mbox: LD delete, timed out\n"));3600 3601 kioc->status = -ETIME;3602 3603 scb->status = -1;3604 3605 megaraid_mbox_mm_done(adapter, scb);3606 3607 return (-ETIME);3608 }3609 3610 INIT_LIST_HEAD(&scb->list);3611 3612 scb->state = SCB_ISSUED;3613 if (mbox_post_cmd(adapter, scb) != 0) {3614 3615 con_log(CL_ANN, (KERN_NOTICE3616 "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 execute3631 megaraid_mbox_runpendq(adapter, scb);3632 3633 return 0;3634}3635 3636 3637static int3638wait_till_fw_empty(adapter_t *adapter)3639{3640 unsigned long flags = 0;3641 int i;3642 3643 3644 /*3645 * Set the quiescent flag to stop issuing cmds to FW.3646 */3647 spin_lock_irqsave(&adapter->lock, flags);3648 adapter->quiescent++;3649 spin_unlock_irqrestore(&adapter->lock, flags);3650 3651 /*3652 * Wait till there are no more cmds outstanding at FW. Try for at most3653 * 60 seconds3654 */3655 for (i = 0; i < 60 && adapter->outstanding_cmds; i++) {3656 con_log(CL_DLEVEL1, (KERN_INFO3657 "megaraid: FW has %d pending commands\n",3658 adapter->outstanding_cmds));3659 3660 msleep(1000);3661 }3662 3663 return adapter->outstanding_cmds;3664}3665 3666 3667/**3668 * megaraid_mbox_mm_done - callback for CMM commands3669 * @adapter : HBA soft state3670 * @scb : completed command3671 *3672 * Callback routine for internal commands originated from the management3673 * module.3674 */3675static void3676megaraid_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 pool3690 scb->state = SCB_FREE;3691 scb->scp = NULL;3692 3693 spin_lock_irqsave(USER_FREE_LIST_LOCK(adapter), flags);3694 3695 list_add(&scb->list, &adapter->uscb_pool);3696 3697 spin_unlock_irqrestore(USER_FREE_LIST_LOCK(adapter), flags);3698 3699 // if a delete logical drive operation succeeded, restart the3700 // controller3701 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 applications3716 * @adapter : HBA soft state3717 * @hinfo : pointer to the caller's host info strucuture3718 */3719static int3720gather_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 module3741 */3742 3743 3744 3745/**3746 * megaraid_sysfs_alloc_resources - allocate sysfs related resources3747 * @adapter : controller's soft state3748 *3749 * Allocate packets required to issue FW calls whenever the sysfs attributes3750 * are read. These attributes would require up-to-date information from the3751 * FW. Also set up resources for mutual exclusion to share these resources and3752 * the wait queue.3753 *3754 * Return 0 on success.3755 * Return -ERROR_CODE on failure.3756 */3757static int3758megaraid_sysfs_alloc_resources(adapter_t *adapter)3759{3760 mraid_device_t *raid_dev = ADAP2RAIDDEV(adapter);3761 int rval = 0;3762 3763 raid_dev->sysfs_uioc = kmalloc(sizeof(uioc_t), GFP_KERNEL);3764 3765 raid_dev->sysfs_mbox64 = kmalloc(sizeof(mbox64_t), GFP_KERNEL);3766 3767 raid_dev->sysfs_buffer = dma_alloc_coherent(&adapter->pdev->dev,3768 PAGE_SIZE, &raid_dev->sysfs_buffer_dma, GFP_KERNEL);3769 3770 if (!raid_dev->sysfs_uioc || !raid_dev->sysfs_mbox64 ||3771 !raid_dev->sysfs_buffer) {3772 3773 con_log(CL_ANN, (KERN_WARNING3774 "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 resources3792 * @adapter : controller's soft state3793 *3794 * Free packets allocated for sysfs FW commands3795 */3796static void3797megaraid_sysfs_free_resources(adapter_t *adapter)3798{3799 mraid_device_t *raid_dev = ADAP2RAIDDEV(adapter);3800 3801 kfree(raid_dev->sysfs_uioc);3802 kfree(raid_dev->sysfs_mbox64);3803 3804 if (raid_dev->sysfs_buffer) {3805 dma_free_coherent(&adapter->pdev->dev, PAGE_SIZE,3806 raid_dev->sysfs_buffer, raid_dev->sysfs_buffer_dma);3807 }3808}3809 3810 3811/**3812 * megaraid_sysfs_get_ldmap_done - callback for get ldmap3813 * @uioc : completed packet3814 *3815 * Callback routine called in the ISR/tasklet context for get ldmap call3816 */3817static void3818megaraid_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 ldmap3830 * @t : timed out timer3831 *3832 * Timeout routine to recover and return to application, in case the adapter3833 * has stopped responding. A timeout of 60 seconds for this command seems like3834 * a good value.3835 */3836static void3837megaraid_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 map3852 * @adapter : controller's soft state3853 *3854 * This routine will be called whenever user reads the logical drive3855 * attributes, go get the current logical drive mapping table from the3856 * firmware. We use the management API's to issue commands to the controller.3857 *3858 * NOTE: The commands issuance functionality is not generalized and3859 * implemented in context of "get ld map" command only. If required, the3860 * command issuance logical can be trivially pulled out and implemented as a3861 * standalone library. For now, this should suffice since there is no other3862 * user of this interface.3863 *3864 * Return 0 on success.3865 * Return -1 on failure.3866 */3867static int3868megaraid_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 attributes3881 */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 mapping3901 * table3902 */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 controller3910 */3911 timeout.uioc = uioc;3912 timer_setup_on_stack(&timeout.timer,3913 megaraid_sysfs_get_ldmap_timeout, 0);3914 3915 timeout.timer.expires = jiffies + 60 * HZ;3916 add_timer(&timeout.timer);3917 3918 /*3919 * Send the command to the firmware3920 */3921 rval = megaraid_mbox_mm_command(adapter, uioc);3922 3923 if (rval == 0) { // command successfully issued3924 wait_event(raid_dev->sysfs_wait_q, (uioc->status != -ENODATA));3925 3926 /*3927 * Check if the command timed out3928 */3929 if (uioc->status == -ETIME) {3930 con_log(CL_ANN, (KERN_NOTICE3931 "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_NOTICE3945 "megaraid: get ld map failed with %x\n", rval));3946 }3947 }3948 else {3949 con_log(CL_ANN, (KERN_NOTICE3950 "megaraid: could not issue ldmap command:%x\n", rval));3951 }3952 3953 3954 del_timer_sync(&timeout.timer);3955 destroy_timer_on_stack(&timeout.timer);3956 3957 mutex_unlock(&raid_dev->sysfs_mtx);3958 3959 return rval;3960}3961 3962 3963/**3964 * megaraid_mbox_app_hndl_show - display application handle for this adapter3965 * @dev : class device object representation for the host3966 * @attr : device attribute (unused)3967 * @buf : buffer to send data to3968 *3969 * Display the handle used by the applications while executing management3970 * tasks on the adapter. We invoke a management module API to get the adapter3971 * handle, since we do not interface with applications directly.3972 */3973static ssize_t3974megaraid_mbox_app_hndl_show(struct device *dev, struct device_attribute *attr, char *buf)3975{3976 struct Scsi_Host *shost = class_to_shost(dev);3977 adapter_t *adapter = (adapter_t *)SCSIHOST2ADAP(shost);3978 uint32_t app_hndl;3979 3980 app_hndl = mraid_mm_adapter_app_handle(adapter->unique_id);3981 3982 return sysfs_emit(buf, "%u\n", app_hndl);3983}3984 3985 3986/**3987 * megaraid_mbox_ld_show - display the logical drive number for this device3988 * @dev : device object representation for the scsi device3989 * @attr : device attribute to show3990 * @buf : buffer to send data to3991 *3992 * Display the logical drive number for the device in question, if it a valid3993 * 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 */4001static ssize_t4002megaraid_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_NOTICE4046 "megaraid: sysfs get ld map failed: %x\n",4047 rval));4048 }4049 }4050 4051 return sysfs_emit(buf, "%d %d %d %d\n", scsi_id, logical_drv,4052 ldid_map, app_hndl);4053}4054 4055 4056/*4057 * END: Mailbox Low Level Driver4058 */4059module_init(megaraid_init);4060module_exit(megaraid_exit);4061