11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * Adaptec AAC series RAID controller driver 3fa195afeSAlan Cox * (c) Copyright 2001 Red Hat Inc. 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * based on the old aacraid driver that is.. 61da177e4SLinus Torvalds * Adaptec aacraid device driver for Linux. 71da177e4SLinus Torvalds * 8e8b12f0fSMahesh Rajashekhara * Copyright (c) 2000-2010 Adaptec, Inc. 9e8b12f0fSMahesh Rajashekhara * 2010 PMC-Sierra, Inc. (aacraid@pmc-sierra.com) 101da177e4SLinus Torvalds * 111da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or modify 121da177e4SLinus Torvalds * it under the terms of the GNU General Public License as published by 131da177e4SLinus Torvalds * the Free Software Foundation; either version 2, or (at your option) 141da177e4SLinus Torvalds * any later version. 151da177e4SLinus Torvalds * 161da177e4SLinus Torvalds * This program is distributed in the hope that it will be useful, 171da177e4SLinus Torvalds * but WITHOUT ANY WARRANTY; without even the implied warranty of 181da177e4SLinus Torvalds * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 191da177e4SLinus Torvalds * GNU General Public License for more details. 201da177e4SLinus Torvalds * 211da177e4SLinus Torvalds * You should have received a copy of the GNU General Public License 221da177e4SLinus Torvalds * along with this program; see the file COPYING. If not, write to 231da177e4SLinus Torvalds * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 241da177e4SLinus Torvalds * 251da177e4SLinus Torvalds */ 261da177e4SLinus Torvalds 271da177e4SLinus Torvalds #include <linux/kernel.h> 281da177e4SLinus Torvalds #include <linux/init.h> 291da177e4SLinus Torvalds #include <linux/types.h> 301da177e4SLinus Torvalds #include <linux/pci.h> 311da177e4SLinus Torvalds #include <linux/spinlock.h> 321da177e4SLinus Torvalds #include <linux/slab.h> 331da177e4SLinus Torvalds #include <linux/completion.h> 341da177e4SLinus Torvalds #include <linux/blkdev.h> 351da177e4SLinus Torvalds #include <asm/uaccess.h> 363a0086a8SSalyzyn, Mark #include <linux/highmem.h> /* For flush_kernel_dcache_page */ 37acf3368fSPaul Gortmaker #include <linux/module.h> 381da177e4SLinus Torvalds 391da177e4SLinus Torvalds #include <scsi/scsi.h> 401da177e4SLinus Torvalds #include <scsi/scsi_cmnd.h> 411da177e4SLinus Torvalds #include <scsi/scsi_device.h> 421da177e4SLinus Torvalds #include <scsi/scsi_host.h> 431da177e4SLinus Torvalds 441da177e4SLinus Torvalds #include "aacraid.h" 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds /* values for inqd_pdt: Peripheral device type in plain English */ 471da177e4SLinus Torvalds #define INQD_PDT_DA 0x00 /* Direct-access (DISK) device */ 481da177e4SLinus Torvalds #define INQD_PDT_PROC 0x03 /* Processor device */ 491da177e4SLinus Torvalds #define INQD_PDT_CHNGR 0x08 /* Changer (jukebox, scsi2) */ 501da177e4SLinus Torvalds #define INQD_PDT_COMM 0x09 /* Communication device (scsi2) */ 511da177e4SLinus Torvalds #define INQD_PDT_NOLUN2 0x1f /* Unknown Device (scsi2) */ 521da177e4SLinus Torvalds #define INQD_PDT_NOLUN 0x7f /* Logical Unit Not Present */ 531da177e4SLinus Torvalds 541da177e4SLinus Torvalds #define INQD_PDT_DMASK 0x1F /* Peripheral Device Type Mask */ 551da177e4SLinus Torvalds #define INQD_PDT_QMASK 0xE0 /* Peripheral Device Qualifer Mask */ 561da177e4SLinus Torvalds 571da177e4SLinus Torvalds /* 581da177e4SLinus Torvalds * Sense codes 591da177e4SLinus Torvalds */ 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds #define SENCODE_NO_SENSE 0x00 621da177e4SLinus Torvalds #define SENCODE_END_OF_DATA 0x00 631da177e4SLinus Torvalds #define SENCODE_BECOMING_READY 0x04 641da177e4SLinus Torvalds #define SENCODE_INIT_CMD_REQUIRED 0x04 651da177e4SLinus Torvalds #define SENCODE_PARAM_LIST_LENGTH_ERROR 0x1A 661da177e4SLinus Torvalds #define SENCODE_INVALID_COMMAND 0x20 671da177e4SLinus Torvalds #define SENCODE_LBA_OUT_OF_RANGE 0x21 681da177e4SLinus Torvalds #define SENCODE_INVALID_CDB_FIELD 0x24 691da177e4SLinus Torvalds #define SENCODE_LUN_NOT_SUPPORTED 0x25 701da177e4SLinus Torvalds #define SENCODE_INVALID_PARAM_FIELD 0x26 711da177e4SLinus Torvalds #define SENCODE_PARAM_NOT_SUPPORTED 0x26 721da177e4SLinus Torvalds #define SENCODE_PARAM_VALUE_INVALID 0x26 731da177e4SLinus Torvalds #define SENCODE_RESET_OCCURRED 0x29 741da177e4SLinus Torvalds #define SENCODE_LUN_NOT_SELF_CONFIGURED_YET 0x3E 751da177e4SLinus Torvalds #define SENCODE_INQUIRY_DATA_CHANGED 0x3F 761da177e4SLinus Torvalds #define SENCODE_SAVING_PARAMS_NOT_SUPPORTED 0x39 771da177e4SLinus Torvalds #define SENCODE_DIAGNOSTIC_FAILURE 0x40 781da177e4SLinus Torvalds #define SENCODE_INTERNAL_TARGET_FAILURE 0x44 791da177e4SLinus Torvalds #define SENCODE_INVALID_MESSAGE_ERROR 0x49 801da177e4SLinus Torvalds #define SENCODE_LUN_FAILED_SELF_CONFIG 0x4c 811da177e4SLinus Torvalds #define SENCODE_OVERLAPPED_COMMAND 0x4E 821da177e4SLinus Torvalds 831da177e4SLinus Torvalds /* 841da177e4SLinus Torvalds * Additional sense codes 851da177e4SLinus Torvalds */ 861da177e4SLinus Torvalds 871da177e4SLinus Torvalds #define ASENCODE_NO_SENSE 0x00 881da177e4SLinus Torvalds #define ASENCODE_END_OF_DATA 0x05 891da177e4SLinus Torvalds #define ASENCODE_BECOMING_READY 0x01 901da177e4SLinus Torvalds #define ASENCODE_INIT_CMD_REQUIRED 0x02 911da177e4SLinus Torvalds #define ASENCODE_PARAM_LIST_LENGTH_ERROR 0x00 921da177e4SLinus Torvalds #define ASENCODE_INVALID_COMMAND 0x00 931da177e4SLinus Torvalds #define ASENCODE_LBA_OUT_OF_RANGE 0x00 941da177e4SLinus Torvalds #define ASENCODE_INVALID_CDB_FIELD 0x00 951da177e4SLinus Torvalds #define ASENCODE_LUN_NOT_SUPPORTED 0x00 961da177e4SLinus Torvalds #define ASENCODE_INVALID_PARAM_FIELD 0x00 971da177e4SLinus Torvalds #define ASENCODE_PARAM_NOT_SUPPORTED 0x01 981da177e4SLinus Torvalds #define ASENCODE_PARAM_VALUE_INVALID 0x02 991da177e4SLinus Torvalds #define ASENCODE_RESET_OCCURRED 0x00 1001da177e4SLinus Torvalds #define ASENCODE_LUN_NOT_SELF_CONFIGURED_YET 0x00 1011da177e4SLinus Torvalds #define ASENCODE_INQUIRY_DATA_CHANGED 0x03 1021da177e4SLinus Torvalds #define ASENCODE_SAVING_PARAMS_NOT_SUPPORTED 0x00 1031da177e4SLinus Torvalds #define ASENCODE_DIAGNOSTIC_FAILURE 0x80 1041da177e4SLinus Torvalds #define ASENCODE_INTERNAL_TARGET_FAILURE 0x00 1051da177e4SLinus Torvalds #define ASENCODE_INVALID_MESSAGE_ERROR 0x00 1061da177e4SLinus Torvalds #define ASENCODE_LUN_FAILED_SELF_CONFIG 0x00 1071da177e4SLinus Torvalds #define ASENCODE_OVERLAPPED_COMMAND 0x00 1081da177e4SLinus Torvalds 1091da177e4SLinus Torvalds #define BYTE0(x) (unsigned char)(x) 1101da177e4SLinus Torvalds #define BYTE1(x) (unsigned char)((x) >> 8) 1111da177e4SLinus Torvalds #define BYTE2(x) (unsigned char)((x) >> 16) 1121da177e4SLinus Torvalds #define BYTE3(x) (unsigned char)((x) >> 24) 1131da177e4SLinus Torvalds 1141da177e4SLinus Torvalds /*------------------------------------------------------------------------------ 1151da177e4SLinus Torvalds * S T R U C T S / T Y P E D E F S 1161da177e4SLinus Torvalds *----------------------------------------------------------------------------*/ 1171da177e4SLinus Torvalds /* SCSI inquiry data */ 1181da177e4SLinus Torvalds struct inquiry_data { 1191da177e4SLinus Torvalds u8 inqd_pdt; /* Peripheral qualifier | Peripheral Device Type */ 1201da177e4SLinus Torvalds u8 inqd_dtq; /* RMB | Device Type Qualifier */ 1211da177e4SLinus Torvalds u8 inqd_ver; /* ISO version | ECMA version | ANSI-approved version */ 1221da177e4SLinus Torvalds u8 inqd_rdf; /* AENC | TrmIOP | Response data format */ 1231da177e4SLinus Torvalds u8 inqd_len; /* Additional length (n-4) */ 1241da177e4SLinus Torvalds u8 inqd_pad1[2];/* Reserved - must be zero */ 1251da177e4SLinus Torvalds u8 inqd_pad2; /* RelAdr | WBus32 | WBus16 | Sync | Linked |Reserved| CmdQue | SftRe */ 1261da177e4SLinus Torvalds u8 inqd_vid[8]; /* Vendor ID */ 1271da177e4SLinus Torvalds u8 inqd_pid[16];/* Product ID */ 1281da177e4SLinus Torvalds u8 inqd_prl[4]; /* Product Revision Level */ 1291da177e4SLinus Torvalds }; 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds /* 1321da177e4SLinus Torvalds * M O D U L E G L O B A L S 1331da177e4SLinus Torvalds */ 1341da177e4SLinus Torvalds 1351da177e4SLinus Torvalds static unsigned long aac_build_sg(struct scsi_cmnd* scsicmd, struct sgmap* sgmap); 1361da177e4SLinus Torvalds static unsigned long aac_build_sg64(struct scsi_cmnd* scsicmd, struct sgmap64* psg); 1370e68c003SMark Haverkamp static unsigned long aac_build_sgraw(struct scsi_cmnd* scsicmd, struct sgmapraw* psg); 1381da177e4SLinus Torvalds static int aac_send_srb_fib(struct scsi_cmnd* scsicmd); 1391da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 1401da177e4SLinus Torvalds static char *aac_get_status_string(u32 status); 1411da177e4SLinus Torvalds #endif 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds /* 1441da177e4SLinus Torvalds * Non dasd selection is handled entirely in aachba now 1451da177e4SLinus Torvalds */ 1461da177e4SLinus Torvalds 1471da177e4SLinus Torvalds static int nondasd = -1; 148d8e96507SLeubner, Achim static int aac_cache = 2; /* WCE=0 to avoid performance problems */ 1491da177e4SLinus Torvalds static int dacmode = -1; 1508ef22247SSalyzyn, Mark int aac_msi; 1511208bab5SSalyzyn, Mark int aac_commit = -1; 152404d9a90SMark Haverkamp int startup_timeout = 180; 153404d9a90SMark Haverkamp int aif_timeout = 120; 15411604612SMahesh Rajashekhara int aac_sync_mode; /* Only Sync. transfer - disabled */ 1551da177e4SLinus Torvalds 15611604612SMahesh Rajashekhara module_param(aac_sync_mode, int, S_IRUGO|S_IWUSR); 15711604612SMahesh Rajashekhara MODULE_PARM_DESC(aac_sync_mode, "Force sync. transfer mode" 15811604612SMahesh Rajashekhara " 0=off, 1=on"); 1599a72f976SMark Haverkamp module_param(nondasd, int, S_IRUGO|S_IWUSR); 1608ef22247SSalyzyn, Mark MODULE_PARM_DESC(nondasd, "Control scanning of hba for nondasd devices." 1618ef22247SSalyzyn, Mark " 0=off, 1=on"); 16295e852e1SSalyzyn, Mark module_param_named(cache, aac_cache, int, S_IRUGO|S_IWUSR); 1638ef22247SSalyzyn, Mark MODULE_PARM_DESC(cache, "Disable Queue Flush commands:\n" 1648ef22247SSalyzyn, Mark "\tbit 0 - Disable FUA in WRITE SCSI commands\n" 1658ef22247SSalyzyn, Mark "\tbit 1 - Disable SYNCHRONIZE_CACHE SCSI command\n" 166d8e96507SLeubner, Achim "\tbit 2 - Disable only if Battery is protecting Cache"); 1679a72f976SMark Haverkamp module_param(dacmode, int, S_IRUGO|S_IWUSR); 1688ef22247SSalyzyn, Mark MODULE_PARM_DESC(dacmode, "Control whether dma addressing is using 64 bit DAC." 1698ef22247SSalyzyn, Mark " 0=off, 1=on"); 1701208bab5SSalyzyn, Mark module_param_named(commit, aac_commit, int, S_IRUGO|S_IWUSR); 1718ef22247SSalyzyn, Mark MODULE_PARM_DESC(commit, "Control whether a COMMIT_CONFIG is issued to the" 1728ef22247SSalyzyn, Mark " adapter for foreign arrays.\n" 1738ef22247SSalyzyn, Mark "This is typically needed in systems that do not have a BIOS." 1748ef22247SSalyzyn, Mark " 0=off, 1=on"); 1758ef22247SSalyzyn, Mark module_param_named(msi, aac_msi, int, S_IRUGO|S_IWUSR); 1768ef22247SSalyzyn, Mark MODULE_PARM_DESC(msi, "IRQ handling." 1778ef22247SSalyzyn, Mark " 0=PIC(default), 1=MSI, 2=MSI-X(unsupported, uses MSI)"); 178404d9a90SMark Haverkamp module_param(startup_timeout, int, S_IRUGO|S_IWUSR); 1798ef22247SSalyzyn, Mark MODULE_PARM_DESC(startup_timeout, "The duration of time in seconds to wait for" 1808ef22247SSalyzyn, Mark " adapter to have it's kernel up and\n" 1818ef22247SSalyzyn, Mark "running. This is typically adjusted for large systems that do not" 1828ef22247SSalyzyn, Mark " have a BIOS."); 183404d9a90SMark Haverkamp module_param(aif_timeout, int, S_IRUGO|S_IWUSR); 1848ef22247SSalyzyn, Mark MODULE_PARM_DESC(aif_timeout, "The duration of time in seconds to wait for" 1858ef22247SSalyzyn, Mark " applications to pick up AIFs before\n" 1868ef22247SSalyzyn, Mark "deregistering them. This is typically adjusted for heavily burdened" 1878ef22247SSalyzyn, Mark " systems."); 1881da177e4SLinus Torvalds 1897c00ffa3SMark Haverkamp int numacb = -1; 1907c00ffa3SMark Haverkamp module_param(numacb, int, S_IRUGO|S_IWUSR); 1918ef22247SSalyzyn, Mark MODULE_PARM_DESC(numacb, "Request a limit to the number of adapter control" 1928ef22247SSalyzyn, Mark " blocks (FIB) allocated. Valid values are 512 and down. Default is" 1938ef22247SSalyzyn, Mark " to use suggestion from Firmware."); 1947c00ffa3SMark Haverkamp 1957c00ffa3SMark Haverkamp int acbsize = -1; 1967c00ffa3SMark Haverkamp module_param(acbsize, int, S_IRUGO|S_IWUSR); 1978ef22247SSalyzyn, Mark MODULE_PARM_DESC(acbsize, "Request a specific adapter control block (FIB)" 1988ef22247SSalyzyn, Mark " size. Valid values are 512, 2048, 4096 and 8192. Default is to use" 1998ef22247SSalyzyn, Mark " suggestion from Firmware."); 200653ba58dSMark Haverkamp 20129c97684SSalyzyn, Mark int update_interval = 30 * 60; 20229c97684SSalyzyn, Mark module_param(update_interval, int, S_IRUGO|S_IWUSR); 2038ef22247SSalyzyn, Mark MODULE_PARM_DESC(update_interval, "Interval in seconds between time sync" 2048ef22247SSalyzyn, Mark " updates issued to adapter."); 20529c97684SSalyzyn, Mark 20629c97684SSalyzyn, Mark int check_interval = 24 * 60 * 60; 20729c97684SSalyzyn, Mark module_param(check_interval, int, S_IRUGO|S_IWUSR); 2088ef22247SSalyzyn, Mark MODULE_PARM_DESC(check_interval, "Interval in seconds between adapter health" 2098ef22247SSalyzyn, Mark " checks."); 21029c97684SSalyzyn, Mark 21187f3bda3SAndrew Morton int aac_check_reset = 1; 21287f3bda3SAndrew Morton module_param_named(check_reset, aac_check_reset, int, S_IRUGO|S_IWUSR); 21395e7a8efSPaul Bolle MODULE_PARM_DESC(check_reset, "If adapter fails health check, reset the" 2148ef22247SSalyzyn, Mark " adapter. a value of -1 forces the reset to adapters programmed to" 2158ef22247SSalyzyn, Mark " ignore it."); 21629c97684SSalyzyn, Mark 217e37ee4beSMark Haverkamp int expose_physicals = -1; 218653ba58dSMark Haverkamp module_param(expose_physicals, int, S_IRUGO|S_IWUSR); 2198ef22247SSalyzyn, Mark MODULE_PARM_DESC(expose_physicals, "Expose physical components of the arrays." 2208ef22247SSalyzyn, Mark " -1=protect 0=off, 1=on"); 22103d44337SMark Haverkamp 2228ef22247SSalyzyn, Mark int aac_reset_devices; 2231208bab5SSalyzyn, Mark module_param_named(reset_devices, aac_reset_devices, int, S_IRUGO|S_IWUSR); 2241208bab5SSalyzyn, Mark MODULE_PARM_DESC(reset_devices, "Force an adapter reset at initialization."); 22503d44337SMark Haverkamp 226d8e96507SLeubner, Achim int aac_wwn = 1; 227d8e96507SLeubner, Achim module_param_named(wwn, aac_wwn, int, S_IRUGO|S_IWUSR); 228d8e96507SLeubner, Achim MODULE_PARM_DESC(wwn, "Select a WWN type for the arrays:\n" 229d8e96507SLeubner, Achim "\t0 - Disable\n" 230d8e96507SLeubner, Achim "\t1 - Array Meta Data Signature (default)\n" 231d8e96507SLeubner, Achim "\t2 - Adapter Serial Number"); 232d8e96507SLeubner, Achim 233d8e96507SLeubner, Achim 23403d44337SMark Haverkamp static inline int aac_valid_context(struct scsi_cmnd *scsicmd, 23503d44337SMark Haverkamp struct fib *fibptr) { 23603d44337SMark Haverkamp struct scsi_device *device; 23703d44337SMark Haverkamp 23803d44337SMark Haverkamp if (unlikely(!scsicmd || !scsicmd->scsi_done)) { 239c835e372SSalyzyn, Mark dprintk((KERN_WARNING "aac_valid_context: scsi command corrupt\n")); 24003d44337SMark Haverkamp aac_fib_complete(fibptr); 24103d44337SMark Haverkamp aac_fib_free(fibptr); 24203d44337SMark Haverkamp return 0; 24303d44337SMark Haverkamp } 24403d44337SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL; 24503d44337SMark Haverkamp device = scsicmd->device; 24603d44337SMark Haverkamp if (unlikely(!device || !scsi_device_online(device))) { 24703d44337SMark Haverkamp dprintk((KERN_WARNING "aac_valid_context: scsi device corrupt\n")); 24803d44337SMark Haverkamp aac_fib_complete(fibptr); 24903d44337SMark Haverkamp aac_fib_free(fibptr); 25003d44337SMark Haverkamp return 0; 25103d44337SMark Haverkamp } 25203d44337SMark Haverkamp return 1; 25303d44337SMark Haverkamp } 25403d44337SMark Haverkamp 2551da177e4SLinus Torvalds /** 2561da177e4SLinus Torvalds * aac_get_config_status - check the adapter configuration 2571da177e4SLinus Torvalds * @common: adapter to query 2581da177e4SLinus Torvalds * 2591da177e4SLinus Torvalds * Query config status, and commit the configuration if needed. 2601da177e4SLinus Torvalds */ 2618c867b25SMark Haverkamp int aac_get_config_status(struct aac_dev *dev, int commit_flag) 2621da177e4SLinus Torvalds { 2631da177e4SLinus Torvalds int status = 0; 2641da177e4SLinus Torvalds struct fib * fibptr; 2651da177e4SLinus Torvalds 266bfb35aa8SMark Haverkamp if (!(fibptr = aac_fib_alloc(dev))) 2671da177e4SLinus Torvalds return -ENOMEM; 2681da177e4SLinus Torvalds 269bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 2701da177e4SLinus Torvalds { 2711da177e4SLinus Torvalds struct aac_get_config_status *dinfo; 2721da177e4SLinus Torvalds dinfo = (struct aac_get_config_status *) fib_data(fibptr); 2731da177e4SLinus Torvalds 2741da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 2751da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_GET_CONFIG_STATUS); 2761da177e4SLinus Torvalds dinfo->count = cpu_to_le32(sizeof(((struct aac_get_config_status_resp *)NULL)->data)); 2771da177e4SLinus Torvalds } 2781da177e4SLinus Torvalds 279bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 2801da177e4SLinus Torvalds fibptr, 2811da177e4SLinus Torvalds sizeof (struct aac_get_config_status), 2821da177e4SLinus Torvalds FsaNormal, 2831da177e4SLinus Torvalds 1, 1, 2841da177e4SLinus Torvalds NULL, NULL); 2851da177e4SLinus Torvalds if (status < 0) { 2861da177e4SLinus Torvalds printk(KERN_WARNING "aac_get_config_status: SendFIB failed.\n"); 2871da177e4SLinus Torvalds } else { 2881da177e4SLinus Torvalds struct aac_get_config_status_resp *reply 2891da177e4SLinus Torvalds = (struct aac_get_config_status_resp *) fib_data(fibptr); 2901da177e4SLinus Torvalds dprintk((KERN_WARNING 2911da177e4SLinus Torvalds "aac_get_config_status: response=%d status=%d action=%d\n", 2921da177e4SLinus Torvalds le32_to_cpu(reply->response), 2931da177e4SLinus Torvalds le32_to_cpu(reply->status), 2941da177e4SLinus Torvalds le32_to_cpu(reply->data.action))); 2951da177e4SLinus Torvalds if ((le32_to_cpu(reply->response) != ST_OK) || 2961da177e4SLinus Torvalds (le32_to_cpu(reply->status) != CT_OK) || 2971da177e4SLinus Torvalds (le32_to_cpu(reply->data.action) > CFACT_PAUSE)) { 2981da177e4SLinus Torvalds printk(KERN_WARNING "aac_get_config_status: Will not issue the Commit Configuration\n"); 2991da177e4SLinus Torvalds status = -EINVAL; 3001da177e4SLinus Torvalds } 3011da177e4SLinus Torvalds } 302cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* Do not set XferState to zero unless receives a response from F/W */ 303cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (status >= 0) 304bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 305cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech 3061da177e4SLinus Torvalds /* Send a CT_COMMIT_CONFIG to enable discovery of devices */ 3071da177e4SLinus Torvalds if (status >= 0) { 3081208bab5SSalyzyn, Mark if ((aac_commit == 1) || commit_flag) { 3091da177e4SLinus Torvalds struct aac_commit_config * dinfo; 310bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 3111da177e4SLinus Torvalds dinfo = (struct aac_commit_config *) fib_data(fibptr); 3121da177e4SLinus Torvalds 3131da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 3141da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_COMMIT_CONFIG); 3151da177e4SLinus Torvalds 316bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 3171da177e4SLinus Torvalds fibptr, 3181da177e4SLinus Torvalds sizeof (struct aac_commit_config), 3191da177e4SLinus Torvalds FsaNormal, 3201da177e4SLinus Torvalds 1, 1, 3211da177e4SLinus Torvalds NULL, NULL); 322cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* Do not set XferState to zero unless 323cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech * receives a response from F/W */ 324cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (status >= 0) 325bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 3261208bab5SSalyzyn, Mark } else if (aac_commit == 0) { 3271da177e4SLinus Torvalds printk(KERN_WARNING 3281da177e4SLinus Torvalds "aac_get_config_status: Foreign device configurations are being ignored\n"); 3291da177e4SLinus Torvalds } 3301da177e4SLinus Torvalds } 331cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* FIB should be freed only after getting the response from the F/W */ 332cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (status != -ERESTARTSYS) 333bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 3341da177e4SLinus Torvalds return status; 3351da177e4SLinus Torvalds } 3361da177e4SLinus Torvalds 337e3cc268fSRajashekhara, Mahesh static void aac_expose_phy_device(struct scsi_cmnd *scsicmd) 338e3cc268fSRajashekhara, Mahesh { 339e3cc268fSRajashekhara, Mahesh char inq_data; 340e3cc268fSRajashekhara, Mahesh scsi_sg_copy_to_buffer(scsicmd, &inq_data, sizeof(inq_data)); 341e3cc268fSRajashekhara, Mahesh if ((inq_data & 0x20) && (inq_data & 0x1f) == TYPE_DISK) { 342e3cc268fSRajashekhara, Mahesh inq_data &= 0xdf; 343e3cc268fSRajashekhara, Mahesh scsi_sg_copy_from_buffer(scsicmd, &inq_data, sizeof(inq_data)); 344e3cc268fSRajashekhara, Mahesh } 345e3cc268fSRajashekhara, Mahesh } 346e3cc268fSRajashekhara, Mahesh 3471da177e4SLinus Torvalds /** 3481da177e4SLinus Torvalds * aac_get_containers - list containers 3491da177e4SLinus Torvalds * @common: adapter to probe 3501da177e4SLinus Torvalds * 3511da177e4SLinus Torvalds * Make a list of all containers on this controller 3521da177e4SLinus Torvalds */ 3531da177e4SLinus Torvalds int aac_get_containers(struct aac_dev *dev) 3541da177e4SLinus Torvalds { 3551da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 3561da177e4SLinus Torvalds u32 index; 3571da177e4SLinus Torvalds int status = 0; 3581da177e4SLinus Torvalds struct fib * fibptr; 3591da177e4SLinus Torvalds struct aac_get_container_count *dinfo; 3601da177e4SLinus Torvalds struct aac_get_container_count_resp *dresp; 3611da177e4SLinus Torvalds int maximum_num_containers = MAXIMUM_NUM_CONTAINERS; 3621da177e4SLinus Torvalds 363bfb35aa8SMark Haverkamp if (!(fibptr = aac_fib_alloc(dev))) 3641da177e4SLinus Torvalds return -ENOMEM; 3651da177e4SLinus Torvalds 366bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 3671da177e4SLinus Torvalds dinfo = (struct aac_get_container_count *) fib_data(fibptr); 3681da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 3691da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_GET_CONTAINER_COUNT); 3701da177e4SLinus Torvalds 371bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 3721da177e4SLinus Torvalds fibptr, 3731da177e4SLinus Torvalds sizeof (struct aac_get_container_count), 3741da177e4SLinus Torvalds FsaNormal, 3751da177e4SLinus Torvalds 1, 1, 3761da177e4SLinus Torvalds NULL, NULL); 3771da177e4SLinus Torvalds if (status >= 0) { 3781da177e4SLinus Torvalds dresp = (struct aac_get_container_count_resp *)fib_data(fibptr); 3791da177e4SLinus Torvalds maximum_num_containers = le32_to_cpu(dresp->ContainerSwitchEntries); 380bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 3811da177e4SLinus Torvalds } 382cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* FIB should be freed only after getting the response from the F/W */ 383cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (status != -ERESTARTSYS) 384fe76df42SMark Haverkamp aac_fib_free(fibptr); 3851da177e4SLinus Torvalds 3861da177e4SLinus Torvalds if (maximum_num_containers < MAXIMUM_NUM_CONTAINERS) 3871da177e4SLinus Torvalds maximum_num_containers = MAXIMUM_NUM_CONTAINERS; 3881a655040SSalyzyn, Mark fsa_dev_ptr = kzalloc(sizeof(*fsa_dev_ptr) * maximum_num_containers, 389fe76df42SMark Haverkamp GFP_KERNEL); 390fe76df42SMark Haverkamp if (!fsa_dev_ptr) 3911da177e4SLinus Torvalds return -ENOMEM; 3921da177e4SLinus Torvalds 3931da177e4SLinus Torvalds dev->fsa_dev = fsa_dev_ptr; 3941da177e4SLinus Torvalds dev->maximum_num_containers = maximum_num_containers; 3951da177e4SLinus Torvalds 396fe76df42SMark Haverkamp for (index = 0; index < dev->maximum_num_containers; ) { 3971da177e4SLinus Torvalds fsa_dev_ptr[index].devname[0] = '\0'; 3981da177e4SLinus Torvalds 399fe76df42SMark Haverkamp status = aac_probe_container(dev, index); 4001da177e4SLinus Torvalds 4011da177e4SLinus Torvalds if (status < 0) { 4021da177e4SLinus Torvalds printk(KERN_WARNING "aac_get_containers: SendFIB failed.\n"); 4031da177e4SLinus Torvalds break; 4041da177e4SLinus Torvalds } 4051da177e4SLinus Torvalds 4061da177e4SLinus Torvalds /* 4071da177e4SLinus Torvalds * If there are no more containers, then stop asking. 4081da177e4SLinus Torvalds */ 409fe76df42SMark Haverkamp if (++index >= status) 4101da177e4SLinus Torvalds break; 4111da177e4SLinus Torvalds } 4121da177e4SLinus Torvalds return status; 4131da177e4SLinus Torvalds } 4141da177e4SLinus Torvalds 4151da177e4SLinus Torvalds static void get_container_name_callback(void *context, struct fib * fibptr) 4161da177e4SLinus Torvalds { 4171da177e4SLinus Torvalds struct aac_get_name_resp * get_name_reply; 4181da177e4SLinus Torvalds struct scsi_cmnd * scsicmd; 4191da177e4SLinus Torvalds 4201da177e4SLinus Torvalds scsicmd = (struct scsi_cmnd *) context; 4211da177e4SLinus Torvalds 42203d44337SMark Haverkamp if (!aac_valid_context(scsicmd, fibptr)) 42303d44337SMark Haverkamp return; 42403d44337SMark Haverkamp 4251da177e4SLinus Torvalds dprintk((KERN_DEBUG "get_container_name_callback[cpu %d]: t = %ld.\n", smp_processor_id(), jiffies)); 426125e1874SEric Sesterhenn BUG_ON(fibptr == NULL); 4271da177e4SLinus Torvalds 4281da177e4SLinus Torvalds get_name_reply = (struct aac_get_name_resp *) fib_data(fibptr); 4291da177e4SLinus Torvalds /* Failure is irrelevant, using default value instead */ 4301da177e4SLinus Torvalds if ((le32_to_cpu(get_name_reply->status) == CT_OK) 4311da177e4SLinus Torvalds && (get_name_reply->data[0] != '\0')) { 4321da177e4SLinus Torvalds char *sp = get_name_reply->data; 4331da177e4SLinus Torvalds sp[sizeof(((struct aac_get_name_resp *)NULL)->data)-1] = '\0'; 4341da177e4SLinus Torvalds while (*sp == ' ') 4351da177e4SLinus Torvalds ++sp; 4363b2946ccSMark Haverkamp if (*sp) { 437d4345028SFUJITA Tomonori struct inquiry_data inq; 4383b2946ccSMark Haverkamp char d[sizeof(((struct inquiry_data *)NULL)->inqd_pid)]; 4393b2946ccSMark Haverkamp int count = sizeof(d); 4403b2946ccSMark Haverkamp char *dp = d; 4413b2946ccSMark Haverkamp do { 4421da177e4SLinus Torvalds *dp++ = (*sp) ? *sp++ : ' '; 4431da177e4SLinus Torvalds } while (--count > 0); 444d4345028SFUJITA Tomonori 445d4345028SFUJITA Tomonori scsi_sg_copy_to_buffer(scsicmd, &inq, sizeof(inq)); 446d4345028SFUJITA Tomonori memcpy(inq.inqd_pid, d, sizeof(d)); 447d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, &inq, sizeof(inq)); 4481da177e4SLinus Torvalds } 4493b2946ccSMark Haverkamp } 4503b2946ccSMark Haverkamp 4511da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 4521da177e4SLinus Torvalds 453bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 454bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 4558e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 4561da177e4SLinus Torvalds } 4571da177e4SLinus Torvalds 4581da177e4SLinus Torvalds /** 4591da177e4SLinus Torvalds * aac_get_container_name - get container name, none blocking. 4601da177e4SLinus Torvalds */ 4619e7c349cSMark Haverkamp static int aac_get_container_name(struct scsi_cmnd * scsicmd) 4621da177e4SLinus Torvalds { 4631da177e4SLinus Torvalds int status; 4641da177e4SLinus Torvalds struct aac_get_name *dinfo; 4651da177e4SLinus Torvalds struct fib * cmd_fibcontext; 4661da177e4SLinus Torvalds struct aac_dev * dev; 4671da177e4SLinus Torvalds 4681da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 4691da177e4SLinus Torvalds 470bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) 4711da177e4SLinus Torvalds return -ENOMEM; 4721da177e4SLinus Torvalds 473bfb35aa8SMark Haverkamp aac_fib_init(cmd_fibcontext); 4741da177e4SLinus Torvalds dinfo = (struct aac_get_name *) fib_data(cmd_fibcontext); 4751da177e4SLinus Torvalds 4761da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 4771da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_READ_NAME); 4789e7c349cSMark Haverkamp dinfo->cid = cpu_to_le32(scmd_id(scsicmd)); 4791da177e4SLinus Torvalds dinfo->count = cpu_to_le32(sizeof(((struct aac_get_name_resp *)NULL)->data)); 4801da177e4SLinus Torvalds 481bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 4821da177e4SLinus Torvalds cmd_fibcontext, 4831da177e4SLinus Torvalds sizeof (struct aac_get_name), 4841da177e4SLinus Torvalds FsaNormal, 4851da177e4SLinus Torvalds 0, 1, 4861da177e4SLinus Torvalds (fib_callback)get_container_name_callback, 4871da177e4SLinus Torvalds (void *) scsicmd); 4881da177e4SLinus Torvalds 4891da177e4SLinus Torvalds /* 4901da177e4SLinus Torvalds * Check that the command queued to the controller 4911da177e4SLinus Torvalds */ 49277d644d4SMark Haverkamp if (status == -EINPROGRESS) { 49377d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 4941da177e4SLinus Torvalds return 0; 49577d644d4SMark Haverkamp } 4961da177e4SLinus Torvalds 497bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_get_container_name: aac_fib_send failed with status: %d.\n", status); 498bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 499bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 5001da177e4SLinus Torvalds return -1; 5011da177e4SLinus Torvalds } 5021da177e4SLinus Torvalds 503fe76df42SMark Haverkamp static int aac_probe_container_callback2(struct scsi_cmnd * scsicmd) 504fe76df42SMark Haverkamp { 505fe76df42SMark Haverkamp struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev; 506fe76df42SMark Haverkamp 5071a655040SSalyzyn, Mark if ((fsa_dev_ptr[scmd_id(scsicmd)].valid & 1)) 508fe76df42SMark Haverkamp return aac_scsi_cmd(scsicmd); 509fe76df42SMark Haverkamp 510fe76df42SMark Haverkamp scsicmd->result = DID_NO_CONNECT << 16; 511fe76df42SMark Haverkamp scsicmd->scsi_done(scsicmd); 512fe76df42SMark Haverkamp return 0; 513fe76df42SMark Haverkamp } 514fe76df42SMark Haverkamp 5151a655040SSalyzyn, Mark static void _aac_probe_container2(void * context, struct fib * fibptr) 516fe76df42SMark Haverkamp { 51703d44337SMark Haverkamp struct fsa_dev_info *fsa_dev_ptr; 518fe76df42SMark Haverkamp int (*callback)(struct scsi_cmnd *); 51903d44337SMark Haverkamp struct scsi_cmnd * scsicmd = (struct scsi_cmnd *)context; 52003d44337SMark Haverkamp 52103d44337SMark Haverkamp 5221a655040SSalyzyn, Mark if (!aac_valid_context(scsicmd, fibptr)) 5231a655040SSalyzyn, Mark return; 524fe76df42SMark Haverkamp 525fe76df42SMark Haverkamp scsicmd->SCp.Status = 0; 5261a655040SSalyzyn, Mark fsa_dev_ptr = fibptr->dev->fsa_dev; 527fe76df42SMark Haverkamp if (fsa_dev_ptr) { 528fe76df42SMark Haverkamp struct aac_mount * dresp = (struct aac_mount *) fib_data(fibptr); 529fe76df42SMark Haverkamp fsa_dev_ptr += scmd_id(scsicmd); 530fe76df42SMark Haverkamp 531fe76df42SMark Haverkamp if ((le32_to_cpu(dresp->status) == ST_OK) && 532fe76df42SMark Haverkamp (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE) && 533fe76df42SMark Haverkamp (le32_to_cpu(dresp->mnt[0].state) != FSCS_HIDDEN)) { 534fe76df42SMark Haverkamp fsa_dev_ptr->valid = 1; 535655d722cSMark Salyzyn /* sense_key holds the current state of the spin-up */ 536655d722cSMark Salyzyn if (dresp->mnt[0].state & cpu_to_le32(FSCS_NOT_READY)) 537655d722cSMark Salyzyn fsa_dev_ptr->sense_data.sense_key = NOT_READY; 538655d722cSMark Salyzyn else if (fsa_dev_ptr->sense_data.sense_key == NOT_READY) 539655d722cSMark Salyzyn fsa_dev_ptr->sense_data.sense_key = NO_SENSE; 540fe76df42SMark Haverkamp fsa_dev_ptr->type = le32_to_cpu(dresp->mnt[0].vol); 541fe76df42SMark Haverkamp fsa_dev_ptr->size 542fe76df42SMark Haverkamp = ((u64)le32_to_cpu(dresp->mnt[0].capacity)) + 543fe76df42SMark Haverkamp (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32); 544fe76df42SMark Haverkamp fsa_dev_ptr->ro = ((le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY) != 0); 545fe76df42SMark Haverkamp } 546fe76df42SMark Haverkamp if ((fsa_dev_ptr->valid & 1) == 0) 547fe76df42SMark Haverkamp fsa_dev_ptr->valid = 0; 548fe76df42SMark Haverkamp scsicmd->SCp.Status = le32_to_cpu(dresp->count); 549fe76df42SMark Haverkamp } 550fe76df42SMark Haverkamp aac_fib_complete(fibptr); 551fe76df42SMark Haverkamp aac_fib_free(fibptr); 552fe76df42SMark Haverkamp callback = (int (*)(struct scsi_cmnd *))(scsicmd->SCp.ptr); 553fe76df42SMark Haverkamp scsicmd->SCp.ptr = NULL; 5541a655040SSalyzyn, Mark (*callback)(scsicmd); 5551a655040SSalyzyn, Mark return; 556fe76df42SMark Haverkamp } 557fe76df42SMark Haverkamp 5581a655040SSalyzyn, Mark static void _aac_probe_container1(void * context, struct fib * fibptr) 559fe76df42SMark Haverkamp { 560fe76df42SMark Haverkamp struct scsi_cmnd * scsicmd; 561fe76df42SMark Haverkamp struct aac_mount * dresp; 562fe76df42SMark Haverkamp struct aac_query_mount *dinfo; 563fe76df42SMark Haverkamp int status; 564fe76df42SMark Haverkamp 565fe76df42SMark Haverkamp dresp = (struct aac_mount *) fib_data(fibptr); 566fe76df42SMark Haverkamp dresp->mnt[0].capacityhigh = 0; 567fe76df42SMark Haverkamp if ((le32_to_cpu(dresp->status) != ST_OK) || 5681a655040SSalyzyn, Mark (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE)) { 5691a655040SSalyzyn, Mark _aac_probe_container2(context, fibptr); 5701a655040SSalyzyn, Mark return; 5711a655040SSalyzyn, Mark } 572fe76df42SMark Haverkamp scsicmd = (struct scsi_cmnd *) context; 573fe76df42SMark Haverkamp 57403d44337SMark Haverkamp if (!aac_valid_context(scsicmd, fibptr)) 5751a655040SSalyzyn, Mark return; 57603d44337SMark Haverkamp 577fe76df42SMark Haverkamp aac_fib_init(fibptr); 578fe76df42SMark Haverkamp 579fe76df42SMark Haverkamp dinfo = (struct aac_query_mount *)fib_data(fibptr); 580fe76df42SMark Haverkamp 581fe76df42SMark Haverkamp dinfo->command = cpu_to_le32(VM_NameServe64); 582fe76df42SMark Haverkamp dinfo->count = cpu_to_le32(scmd_id(scsicmd)); 583fe76df42SMark Haverkamp dinfo->type = cpu_to_le32(FT_FILESYS); 584fe76df42SMark Haverkamp 585fe76df42SMark Haverkamp status = aac_fib_send(ContainerCommand, 586fe76df42SMark Haverkamp fibptr, 587fe76df42SMark Haverkamp sizeof(struct aac_query_mount), 588fe76df42SMark Haverkamp FsaNormal, 589fe76df42SMark Haverkamp 0, 1, 5901a655040SSalyzyn, Mark _aac_probe_container2, 591fe76df42SMark Haverkamp (void *) scsicmd); 592fe76df42SMark Haverkamp /* 593fe76df42SMark Haverkamp * Check that the command queued to the controller 594fe76df42SMark Haverkamp */ 5951a655040SSalyzyn, Mark if (status == -EINPROGRESS) 596fe76df42SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 5971a655040SSalyzyn, Mark else if (status < 0) { 598fe76df42SMark Haverkamp /* Inherit results from VM_NameServe, if any */ 599fe76df42SMark Haverkamp dresp->status = cpu_to_le32(ST_OK); 6001a655040SSalyzyn, Mark _aac_probe_container2(context, fibptr); 601fe76df42SMark Haverkamp } 602fe76df42SMark Haverkamp } 603fe76df42SMark Haverkamp 604fe76df42SMark Haverkamp static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(struct scsi_cmnd *)) 605fe76df42SMark Haverkamp { 606fe76df42SMark Haverkamp struct fib * fibptr; 607fe76df42SMark Haverkamp int status = -ENOMEM; 608fe76df42SMark Haverkamp 609fe76df42SMark Haverkamp if ((fibptr = aac_fib_alloc((struct aac_dev *)scsicmd->device->host->hostdata))) { 610fe76df42SMark Haverkamp struct aac_query_mount *dinfo; 611fe76df42SMark Haverkamp 612fe76df42SMark Haverkamp aac_fib_init(fibptr); 613fe76df42SMark Haverkamp 614fe76df42SMark Haverkamp dinfo = (struct aac_query_mount *)fib_data(fibptr); 615fe76df42SMark Haverkamp 616fe76df42SMark Haverkamp dinfo->command = cpu_to_le32(VM_NameServe); 617fe76df42SMark Haverkamp dinfo->count = cpu_to_le32(scmd_id(scsicmd)); 618fe76df42SMark Haverkamp dinfo->type = cpu_to_le32(FT_FILESYS); 619fe76df42SMark Haverkamp scsicmd->SCp.ptr = (char *)callback; 620fe76df42SMark Haverkamp 621fe76df42SMark Haverkamp status = aac_fib_send(ContainerCommand, 622fe76df42SMark Haverkamp fibptr, 623fe76df42SMark Haverkamp sizeof(struct aac_query_mount), 624fe76df42SMark Haverkamp FsaNormal, 625fe76df42SMark Haverkamp 0, 1, 6261a655040SSalyzyn, Mark _aac_probe_container1, 627fe76df42SMark Haverkamp (void *) scsicmd); 628fe76df42SMark Haverkamp /* 629fe76df42SMark Haverkamp * Check that the command queued to the controller 630fe76df42SMark Haverkamp */ 631fe76df42SMark Haverkamp if (status == -EINPROGRESS) { 632fe76df42SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 633fe76df42SMark Haverkamp return 0; 634fe76df42SMark Haverkamp } 635fe76df42SMark Haverkamp if (status < 0) { 636fe76df42SMark Haverkamp scsicmd->SCp.ptr = NULL; 637fe76df42SMark Haverkamp aac_fib_complete(fibptr); 638fe76df42SMark Haverkamp aac_fib_free(fibptr); 639fe76df42SMark Haverkamp } 640fe76df42SMark Haverkamp } 641fe76df42SMark Haverkamp if (status < 0) { 642fe76df42SMark Haverkamp struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev; 643fe76df42SMark Haverkamp if (fsa_dev_ptr) { 644fe76df42SMark Haverkamp fsa_dev_ptr += scmd_id(scsicmd); 645fe76df42SMark Haverkamp if ((fsa_dev_ptr->valid & 1) == 0) { 646fe76df42SMark Haverkamp fsa_dev_ptr->valid = 0; 647fe76df42SMark Haverkamp return (*callback)(scsicmd); 648fe76df42SMark Haverkamp } 649fe76df42SMark Haverkamp } 650fe76df42SMark Haverkamp } 651fe76df42SMark Haverkamp return status; 652fe76df42SMark Haverkamp } 653fe76df42SMark Haverkamp 6541da177e4SLinus Torvalds /** 655bfb35aa8SMark Haverkamp * aac_probe_container - query a logical volume 6561da177e4SLinus Torvalds * @dev: device to query 6571da177e4SLinus Torvalds * @cid: container identifier 6581da177e4SLinus Torvalds * 6591da177e4SLinus Torvalds * Queries the controller about the given volume. The volume information 6601da177e4SLinus Torvalds * is updated in the struct fsa_dev_info structure rather than returned. 6611da177e4SLinus Torvalds */ 662fe76df42SMark Haverkamp static int aac_probe_container_callback1(struct scsi_cmnd * scsicmd) 663fe76df42SMark Haverkamp { 664fe76df42SMark Haverkamp scsicmd->device = NULL; 665fe76df42SMark Haverkamp return 0; 666fe76df42SMark Haverkamp } 6671da177e4SLinus Torvalds 668bfb35aa8SMark Haverkamp int aac_probe_container(struct aac_dev *dev, int cid) 6691da177e4SLinus Torvalds { 670fe76df42SMark Haverkamp struct scsi_cmnd *scsicmd = kmalloc(sizeof(*scsicmd), GFP_KERNEL); 671fe76df42SMark Haverkamp struct scsi_device *scsidev = kmalloc(sizeof(*scsidev), GFP_KERNEL); 6721da177e4SLinus Torvalds int status; 6731da177e4SLinus Torvalds 674fe76df42SMark Haverkamp if (!scsicmd || !scsidev) { 675fe76df42SMark Haverkamp kfree(scsicmd); 676fe76df42SMark Haverkamp kfree(scsidev); 67790ee3466SMark Haverkamp return -ENOMEM; 6781da177e4SLinus Torvalds } 679fe76df42SMark Haverkamp scsicmd->list.next = NULL; 6801a655040SSalyzyn, Mark scsicmd->scsi_done = (void (*)(struct scsi_cmnd*))aac_probe_container_callback1; 6811da177e4SLinus Torvalds 682fe76df42SMark Haverkamp scsicmd->device = scsidev; 683fe76df42SMark Haverkamp scsidev->sdev_state = 0; 684fe76df42SMark Haverkamp scsidev->id = cid; 685fe76df42SMark Haverkamp scsidev->host = dev->scsi_host_ptr; 6861da177e4SLinus Torvalds 687fe76df42SMark Haverkamp if (_aac_probe_container(scsicmd, aac_probe_container_callback1) == 0) 688fe76df42SMark Haverkamp while (scsicmd->device == scsidev) 689fe76df42SMark Haverkamp schedule(); 690802ae2f0SSalyzyn, Mark kfree(scsidev); 691fe76df42SMark Haverkamp status = scsicmd->SCp.Status; 692fe76df42SMark Haverkamp kfree(scsicmd); 6931da177e4SLinus Torvalds return status; 6941da177e4SLinus Torvalds } 6951da177e4SLinus Torvalds 6961da177e4SLinus Torvalds /* Local Structure to set SCSI inquiry data strings */ 6971da177e4SLinus Torvalds struct scsi_inq { 6981da177e4SLinus Torvalds char vid[8]; /* Vendor ID */ 6991da177e4SLinus Torvalds char pid[16]; /* Product ID */ 7001da177e4SLinus Torvalds char prl[4]; /* Product Revision Level */ 7011da177e4SLinus Torvalds }; 7021da177e4SLinus Torvalds 7031da177e4SLinus Torvalds /** 7041da177e4SLinus Torvalds * InqStrCopy - string merge 7051da177e4SLinus Torvalds * @a: string to copy from 7061da177e4SLinus Torvalds * @b: string to copy to 7071da177e4SLinus Torvalds * 7081da177e4SLinus Torvalds * Copy a String from one location to another 7091da177e4SLinus Torvalds * without copying \0 7101da177e4SLinus Torvalds */ 7111da177e4SLinus Torvalds 7121da177e4SLinus Torvalds static void inqstrcpy(char *a, char *b) 7131da177e4SLinus Torvalds { 7141da177e4SLinus Torvalds 7151da177e4SLinus Torvalds while (*a != (char)0) 7161da177e4SLinus Torvalds *b++ = *a++; 7171da177e4SLinus Torvalds } 7181da177e4SLinus Torvalds 7191da177e4SLinus Torvalds static char *container_types[] = { 7201da177e4SLinus Torvalds "None", 7211da177e4SLinus Torvalds "Volume", 7221da177e4SLinus Torvalds "Mirror", 7231da177e4SLinus Torvalds "Stripe", 7241da177e4SLinus Torvalds "RAID5", 7251da177e4SLinus Torvalds "SSRW", 7261da177e4SLinus Torvalds "SSRO", 7271da177e4SLinus Torvalds "Morph", 7281da177e4SLinus Torvalds "Legacy", 7291da177e4SLinus Torvalds "RAID4", 7301da177e4SLinus Torvalds "RAID10", 7311da177e4SLinus Torvalds "RAID00", 7321da177e4SLinus Torvalds "V-MIRRORS", 7331da177e4SLinus Torvalds "PSEUDO R4", 7341da177e4SLinus Torvalds "RAID50", 73584971738SMark Haverkamp "RAID5D", 73684971738SMark Haverkamp "RAID5D0", 73784971738SMark Haverkamp "RAID1E", 73884971738SMark Haverkamp "RAID6", 73984971738SMark Haverkamp "RAID60", 7401da177e4SLinus Torvalds "Unknown" 7411da177e4SLinus Torvalds }; 7421da177e4SLinus Torvalds 74317eaaceeSSalyzyn, Mark char * get_container_type(unsigned tindex) 74417eaaceeSSalyzyn, Mark { 74517eaaceeSSalyzyn, Mark if (tindex >= ARRAY_SIZE(container_types)) 74617eaaceeSSalyzyn, Mark tindex = ARRAY_SIZE(container_types) - 1; 74717eaaceeSSalyzyn, Mark return container_types[tindex]; 74817eaaceeSSalyzyn, Mark } 7491da177e4SLinus Torvalds 7501da177e4SLinus Torvalds /* Function: setinqstr 7511da177e4SLinus Torvalds * 7521da177e4SLinus Torvalds * Arguments: [1] pointer to void [1] int 7531da177e4SLinus Torvalds * 7541da177e4SLinus Torvalds * Purpose: Sets SCSI inquiry data strings for vendor, product 75525985edcSLucas De Marchi * and revision level. Allows strings to be set in platform dependent 75625985edcSLucas De Marchi * files instead of in OS dependent driver source. 7571da177e4SLinus Torvalds */ 7581da177e4SLinus Torvalds 759794d0601SMark Haverkamp static void setinqstr(struct aac_dev *dev, void *data, int tindex) 7601da177e4SLinus Torvalds { 7611da177e4SLinus Torvalds struct scsi_inq *str; 7621da177e4SLinus Torvalds 7631da177e4SLinus Torvalds str = (struct scsi_inq *)(data); /* cast data to scsi inq block */ 764794d0601SMark Haverkamp memset(str, ' ', sizeof(*str)); 765794d0601SMark Haverkamp 766794d0601SMark Haverkamp if (dev->supplement_adapter_info.AdapterTypeText[0]) { 767794d0601SMark Haverkamp char * cp = dev->supplement_adapter_info.AdapterTypeText; 7683bc8070fSSalyzyn, Mark int c; 7693bc8070fSSalyzyn, Mark if ((cp[0] == 'A') && (cp[1] == 'O') && (cp[2] == 'C')) 7703bc8070fSSalyzyn, Mark inqstrcpy("SMC", str->vid); 7713bc8070fSSalyzyn, Mark else { 7723bc8070fSSalyzyn, Mark c = sizeof(str->vid); 773794d0601SMark Haverkamp while (*cp && *cp != ' ' && --c) 774794d0601SMark Haverkamp ++cp; 775794d0601SMark Haverkamp c = *cp; 776794d0601SMark Haverkamp *cp = '\0'; 777794d0601SMark Haverkamp inqstrcpy (dev->supplement_adapter_info.AdapterTypeText, 778794d0601SMark Haverkamp str->vid); 779794d0601SMark Haverkamp *cp = c; 780794d0601SMark Haverkamp while (*cp && *cp != ' ') 781794d0601SMark Haverkamp ++cp; 7823bc8070fSSalyzyn, Mark } 783794d0601SMark Haverkamp while (*cp == ' ') 784794d0601SMark Haverkamp ++cp; 785794d0601SMark Haverkamp /* last six chars reserved for vol type */ 786794d0601SMark Haverkamp c = 0; 787794d0601SMark Haverkamp if (strlen(cp) > sizeof(str->pid)) { 788794d0601SMark Haverkamp c = cp[sizeof(str->pid)]; 789794d0601SMark Haverkamp cp[sizeof(str->pid)] = '\0'; 790794d0601SMark Haverkamp } 791794d0601SMark Haverkamp inqstrcpy (cp, str->pid); 792794d0601SMark Haverkamp if (c) 793794d0601SMark Haverkamp cp[sizeof(str->pid)] = c; 794794d0601SMark Haverkamp } else { 795794d0601SMark Haverkamp struct aac_driver_ident *mp = aac_get_driver_ident(dev->cardtype); 7961da177e4SLinus Torvalds 7971da177e4SLinus Torvalds inqstrcpy (mp->vname, str->vid); 798794d0601SMark Haverkamp /* last six chars reserved for vol type */ 799794d0601SMark Haverkamp inqstrcpy (mp->model, str->pid); 800794d0601SMark Haverkamp } 8011da177e4SLinus Torvalds 8026391a113STobias Klauser if (tindex < ARRAY_SIZE(container_types)){ 8031da177e4SLinus Torvalds char *findit = str->pid; 8041da177e4SLinus Torvalds 8051da177e4SLinus Torvalds for ( ; *findit != ' '; findit++); /* walk till we find a space */ 8061da177e4SLinus Torvalds /* RAID is superfluous in the context of a RAID device */ 8071da177e4SLinus Torvalds if (memcmp(findit-4, "RAID", 4) == 0) 8081da177e4SLinus Torvalds *(findit -= 4) = ' '; 809794d0601SMark Haverkamp if (((findit - str->pid) + strlen(container_types[tindex])) 810794d0601SMark Haverkamp < (sizeof(str->pid) + sizeof(str->prl))) 8111da177e4SLinus Torvalds inqstrcpy (container_types[tindex], findit + 1); 8121da177e4SLinus Torvalds } 8131da177e4SLinus Torvalds inqstrcpy ("V1.0", str->prl); 8141da177e4SLinus Torvalds } 8151da177e4SLinus Torvalds 81688e2f98eSSalyzyn, Mark static void get_container_serial_callback(void *context, struct fib * fibptr) 81788e2f98eSSalyzyn, Mark { 81888e2f98eSSalyzyn, Mark struct aac_get_serial_resp * get_serial_reply; 81988e2f98eSSalyzyn, Mark struct scsi_cmnd * scsicmd; 82088e2f98eSSalyzyn, Mark 82188e2f98eSSalyzyn, Mark BUG_ON(fibptr == NULL); 82288e2f98eSSalyzyn, Mark 82388e2f98eSSalyzyn, Mark scsicmd = (struct scsi_cmnd *) context; 82488e2f98eSSalyzyn, Mark if (!aac_valid_context(scsicmd, fibptr)) 82588e2f98eSSalyzyn, Mark return; 82688e2f98eSSalyzyn, Mark 82788e2f98eSSalyzyn, Mark get_serial_reply = (struct aac_get_serial_resp *) fib_data(fibptr); 82888e2f98eSSalyzyn, Mark /* Failure is irrelevant, using default value instead */ 82988e2f98eSSalyzyn, Mark if (le32_to_cpu(get_serial_reply->status) == CT_OK) { 83088e2f98eSSalyzyn, Mark char sp[13]; 83188e2f98eSSalyzyn, Mark /* EVPD bit set */ 83288e2f98eSSalyzyn, Mark sp[0] = INQD_PDT_DA; 83388e2f98eSSalyzyn, Mark sp[1] = scsicmd->cmnd[2]; 83488e2f98eSSalyzyn, Mark sp[2] = 0; 83588e2f98eSSalyzyn, Mark sp[3] = snprintf(sp+4, sizeof(sp)-4, "%08X", 83688e2f98eSSalyzyn, Mark le32_to_cpu(get_serial_reply->uid)); 837d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, sp, sizeof(sp)); 83888e2f98eSSalyzyn, Mark } 83988e2f98eSSalyzyn, Mark 84088e2f98eSSalyzyn, Mark scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 84188e2f98eSSalyzyn, Mark 84288e2f98eSSalyzyn, Mark aac_fib_complete(fibptr); 84388e2f98eSSalyzyn, Mark aac_fib_free(fibptr); 84488e2f98eSSalyzyn, Mark scsicmd->scsi_done(scsicmd); 84588e2f98eSSalyzyn, Mark } 84688e2f98eSSalyzyn, Mark 84788e2f98eSSalyzyn, Mark /** 84888e2f98eSSalyzyn, Mark * aac_get_container_serial - get container serial, none blocking. 84988e2f98eSSalyzyn, Mark */ 85088e2f98eSSalyzyn, Mark static int aac_get_container_serial(struct scsi_cmnd * scsicmd) 85188e2f98eSSalyzyn, Mark { 85288e2f98eSSalyzyn, Mark int status; 85388e2f98eSSalyzyn, Mark struct aac_get_serial *dinfo; 85488e2f98eSSalyzyn, Mark struct fib * cmd_fibcontext; 85588e2f98eSSalyzyn, Mark struct aac_dev * dev; 85688e2f98eSSalyzyn, Mark 85788e2f98eSSalyzyn, Mark dev = (struct aac_dev *)scsicmd->device->host->hostdata; 85888e2f98eSSalyzyn, Mark 85988e2f98eSSalyzyn, Mark if (!(cmd_fibcontext = aac_fib_alloc(dev))) 86088e2f98eSSalyzyn, Mark return -ENOMEM; 86188e2f98eSSalyzyn, Mark 86288e2f98eSSalyzyn, Mark aac_fib_init(cmd_fibcontext); 86388e2f98eSSalyzyn, Mark dinfo = (struct aac_get_serial *) fib_data(cmd_fibcontext); 86488e2f98eSSalyzyn, Mark 86588e2f98eSSalyzyn, Mark dinfo->command = cpu_to_le32(VM_ContainerConfig); 86688e2f98eSSalyzyn, Mark dinfo->type = cpu_to_le32(CT_CID_TO_32BITS_UID); 86788e2f98eSSalyzyn, Mark dinfo->cid = cpu_to_le32(scmd_id(scsicmd)); 86888e2f98eSSalyzyn, Mark 86988e2f98eSSalyzyn, Mark status = aac_fib_send(ContainerCommand, 87088e2f98eSSalyzyn, Mark cmd_fibcontext, 87188e2f98eSSalyzyn, Mark sizeof (struct aac_get_serial), 87288e2f98eSSalyzyn, Mark FsaNormal, 87388e2f98eSSalyzyn, Mark 0, 1, 87488e2f98eSSalyzyn, Mark (fib_callback) get_container_serial_callback, 87588e2f98eSSalyzyn, Mark (void *) scsicmd); 87688e2f98eSSalyzyn, Mark 87788e2f98eSSalyzyn, Mark /* 87888e2f98eSSalyzyn, Mark * Check that the command queued to the controller 87988e2f98eSSalyzyn, Mark */ 88088e2f98eSSalyzyn, Mark if (status == -EINPROGRESS) { 88188e2f98eSSalyzyn, Mark scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 88288e2f98eSSalyzyn, Mark return 0; 88388e2f98eSSalyzyn, Mark } 88488e2f98eSSalyzyn, Mark 88588e2f98eSSalyzyn, Mark printk(KERN_WARNING "aac_get_container_serial: aac_fib_send failed with status: %d.\n", status); 88688e2f98eSSalyzyn, Mark aac_fib_complete(cmd_fibcontext); 88788e2f98eSSalyzyn, Mark aac_fib_free(cmd_fibcontext); 88888e2f98eSSalyzyn, Mark return -1; 88988e2f98eSSalyzyn, Mark } 89088e2f98eSSalyzyn, Mark 89188e2f98eSSalyzyn, Mark /* Function: setinqserial 89288e2f98eSSalyzyn, Mark * 89388e2f98eSSalyzyn, Mark * Arguments: [1] pointer to void [1] int 89488e2f98eSSalyzyn, Mark * 89588e2f98eSSalyzyn, Mark * Purpose: Sets SCSI Unit Serial number. 89688e2f98eSSalyzyn, Mark * This is a fake. We should read a proper 89788e2f98eSSalyzyn, Mark * serial number from the container. <SuSE>But 89888e2f98eSSalyzyn, Mark * without docs it's quite hard to do it :-) 89988e2f98eSSalyzyn, Mark * So this will have to do in the meantime.</SuSE> 90088e2f98eSSalyzyn, Mark */ 90188e2f98eSSalyzyn, Mark 90288e2f98eSSalyzyn, Mark static int setinqserial(struct aac_dev *dev, void *data, int cid) 90388e2f98eSSalyzyn, Mark { 90488e2f98eSSalyzyn, Mark /* 90588e2f98eSSalyzyn, Mark * This breaks array migration. 90688e2f98eSSalyzyn, Mark */ 90788e2f98eSSalyzyn, Mark return snprintf((char *)(data), sizeof(struct scsi_inq) - 4, "%08X%02X", 90888e2f98eSSalyzyn, Mark le32_to_cpu(dev->adapter_info.serial[0]), cid); 90988e2f98eSSalyzyn, Mark } 91088e2f98eSSalyzyn, Mark 9118e31e607SSalyzyn, Mark static inline void set_sense(struct sense_data *sense_data, u8 sense_key, 9128e31e607SSalyzyn, Mark u8 sense_code, u8 a_sense_code, u8 bit_pointer, u16 field_pointer) 9131da177e4SLinus Torvalds { 9148e31e607SSalyzyn, Mark u8 *sense_buf = (u8 *)sense_data; 9158e31e607SSalyzyn, Mark /* Sense data valid, err code 70h */ 9168e31e607SSalyzyn, Mark sense_buf[0] = 0x70; /* No info field */ 9171da177e4SLinus Torvalds sense_buf[1] = 0; /* Segment number, always zero */ 9181da177e4SLinus Torvalds 9191da177e4SLinus Torvalds sense_buf[2] = sense_key; /* Sense key */ 9201da177e4SLinus Torvalds 9211da177e4SLinus Torvalds sense_buf[12] = sense_code; /* Additional sense code */ 9221da177e4SLinus Torvalds sense_buf[13] = a_sense_code; /* Additional sense code qualifier */ 9238e31e607SSalyzyn, Mark 9241da177e4SLinus Torvalds if (sense_key == ILLEGAL_REQUEST) { 9258e31e607SSalyzyn, Mark sense_buf[7] = 10; /* Additional sense length */ 9261da177e4SLinus Torvalds 9278e31e607SSalyzyn, Mark sense_buf[15] = bit_pointer; 9281da177e4SLinus Torvalds /* Illegal parameter is in the parameter block */ 9291da177e4SLinus Torvalds if (sense_code == SENCODE_INVALID_CDB_FIELD) 9308e31e607SSalyzyn, Mark sense_buf[15] |= 0xc0;/* Std sense key specific field */ 9311da177e4SLinus Torvalds /* Illegal parameter is in the CDB block */ 9321da177e4SLinus Torvalds sense_buf[16] = field_pointer >> 8; /* MSB */ 9331da177e4SLinus Torvalds sense_buf[17] = field_pointer; /* LSB */ 9348e31e607SSalyzyn, Mark } else 9358e31e607SSalyzyn, Mark sense_buf[7] = 6; /* Additional sense length */ 9361da177e4SLinus Torvalds } 9371da177e4SLinus Torvalds 938e8f32de5SMark Haverkamp static int aac_bounds_32(struct aac_dev * dev, struct scsi_cmnd * cmd, u64 lba) 939e8f32de5SMark Haverkamp { 940e8f32de5SMark Haverkamp if (lba & 0xffffffff00000000LL) { 941e8f32de5SMark Haverkamp int cid = scmd_id(cmd); 942e8f32de5SMark Haverkamp dprintk((KERN_DEBUG "aacraid: Illegal lba\n")); 943e8f32de5SMark Haverkamp cmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 944e8f32de5SMark Haverkamp SAM_STAT_CHECK_CONDITION; 9458e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 9468e31e607SSalyzyn, Mark HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 9478e31e607SSalyzyn, Mark ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 948e8f32de5SMark Haverkamp memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 9493ace426fSSalyzyn, Mark min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 9503ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE)); 951e8f32de5SMark Haverkamp cmd->scsi_done(cmd); 952e8f32de5SMark Haverkamp return 1; 953e8f32de5SMark Haverkamp } 954e8f32de5SMark Haverkamp return 0; 955e8f32de5SMark Haverkamp } 956e8f32de5SMark Haverkamp 957e8f32de5SMark Haverkamp static int aac_bounds_64(struct aac_dev * dev, struct scsi_cmnd * cmd, u64 lba) 958e8f32de5SMark Haverkamp { 959e8f32de5SMark Haverkamp return 0; 960e8f32de5SMark Haverkamp } 961e8f32de5SMark Haverkamp 962e8f32de5SMark Haverkamp static void io_callback(void *context, struct fib * fibptr); 963e8f32de5SMark Haverkamp 964e8f32de5SMark Haverkamp static int aac_read_raw_io(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 965e8f32de5SMark Haverkamp { 966e8f32de5SMark Haverkamp u16 fibsize; 967e8f32de5SMark Haverkamp struct aac_raw_io *readcmd; 968e8f32de5SMark Haverkamp aac_fib_init(fib); 969e8f32de5SMark Haverkamp readcmd = (struct aac_raw_io *) fib_data(fib); 970e8f32de5SMark Haverkamp readcmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff)); 971e8f32de5SMark Haverkamp readcmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 972e8f32de5SMark Haverkamp readcmd->count = cpu_to_le32(count<<9); 973e8f32de5SMark Haverkamp readcmd->cid = cpu_to_le16(scmd_id(cmd)); 9749d399cc7SSalyzyn, Mark readcmd->flags = cpu_to_le16(IO_TYPE_READ); 975e8f32de5SMark Haverkamp readcmd->bpTotal = 0; 976e8f32de5SMark Haverkamp readcmd->bpComplete = 0; 977e8f32de5SMark Haverkamp 978e8f32de5SMark Haverkamp aac_build_sgraw(cmd, &readcmd->sg); 979e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_raw_io) + ((le32_to_cpu(readcmd->sg.count) - 1) * sizeof (struct sgentryraw)); 980e8f32de5SMark Haverkamp BUG_ON(fibsize > (fib->dev->max_fib_size - sizeof(struct aac_fibhdr))); 981e8f32de5SMark Haverkamp /* 982e8f32de5SMark Haverkamp * Now send the Fib to the adapter 983e8f32de5SMark Haverkamp */ 984e8f32de5SMark Haverkamp return aac_fib_send(ContainerRawIo, 985e8f32de5SMark Haverkamp fib, 986e8f32de5SMark Haverkamp fibsize, 987e8f32de5SMark Haverkamp FsaNormal, 988e8f32de5SMark Haverkamp 0, 1, 989e8f32de5SMark Haverkamp (fib_callback) io_callback, 990e8f32de5SMark Haverkamp (void *) cmd); 991e8f32de5SMark Haverkamp } 992e8f32de5SMark Haverkamp 993e8f32de5SMark Haverkamp static int aac_read_block64(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 994e8f32de5SMark Haverkamp { 995e8f32de5SMark Haverkamp u16 fibsize; 996e8f32de5SMark Haverkamp struct aac_read64 *readcmd; 997e8f32de5SMark Haverkamp aac_fib_init(fib); 998e8f32de5SMark Haverkamp readcmd = (struct aac_read64 *) fib_data(fib); 999e8f32de5SMark Haverkamp readcmd->command = cpu_to_le32(VM_CtHostRead64); 1000e8f32de5SMark Haverkamp readcmd->cid = cpu_to_le16(scmd_id(cmd)); 1001e8f32de5SMark Haverkamp readcmd->sector_count = cpu_to_le16(count); 1002e8f32de5SMark Haverkamp readcmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1003e8f32de5SMark Haverkamp readcmd->pad = 0; 1004e8f32de5SMark Haverkamp readcmd->flags = 0; 1005e8f32de5SMark Haverkamp 1006e8f32de5SMark Haverkamp aac_build_sg64(cmd, &readcmd->sg); 1007e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_read64) + 1008e8f32de5SMark Haverkamp ((le32_to_cpu(readcmd->sg.count) - 1) * 1009e8f32de5SMark Haverkamp sizeof (struct sgentry64)); 1010e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1011e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1012e8f32de5SMark Haverkamp /* 1013e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1014e8f32de5SMark Haverkamp */ 1015e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand64, 1016e8f32de5SMark Haverkamp fib, 1017e8f32de5SMark Haverkamp fibsize, 1018e8f32de5SMark Haverkamp FsaNormal, 1019e8f32de5SMark Haverkamp 0, 1, 1020e8f32de5SMark Haverkamp (fib_callback) io_callback, 1021e8f32de5SMark Haverkamp (void *) cmd); 1022e8f32de5SMark Haverkamp } 1023e8f32de5SMark Haverkamp 1024e8f32de5SMark Haverkamp static int aac_read_block(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 1025e8f32de5SMark Haverkamp { 1026e8f32de5SMark Haverkamp u16 fibsize; 1027e8f32de5SMark Haverkamp struct aac_read *readcmd; 1028e8f32de5SMark Haverkamp aac_fib_init(fib); 1029e8f32de5SMark Haverkamp readcmd = (struct aac_read *) fib_data(fib); 1030e8f32de5SMark Haverkamp readcmd->command = cpu_to_le32(VM_CtBlockRead); 1031f3307f72SChristoph Hellwig readcmd->cid = cpu_to_le32(scmd_id(cmd)); 1032e8f32de5SMark Haverkamp readcmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1033e8f32de5SMark Haverkamp readcmd->count = cpu_to_le32(count * 512); 1034e8f32de5SMark Haverkamp 1035e8f32de5SMark Haverkamp aac_build_sg(cmd, &readcmd->sg); 1036e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_read) + 1037e8f32de5SMark Haverkamp ((le32_to_cpu(readcmd->sg.count) - 1) * 1038e8f32de5SMark Haverkamp sizeof (struct sgentry)); 1039e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1040e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1041e8f32de5SMark Haverkamp /* 1042e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1043e8f32de5SMark Haverkamp */ 1044e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand, 1045e8f32de5SMark Haverkamp fib, 1046e8f32de5SMark Haverkamp fibsize, 1047e8f32de5SMark Haverkamp FsaNormal, 1048e8f32de5SMark Haverkamp 0, 1, 1049e8f32de5SMark Haverkamp (fib_callback) io_callback, 1050e8f32de5SMark Haverkamp (void *) cmd); 1051e8f32de5SMark Haverkamp } 1052e8f32de5SMark Haverkamp 10539d399cc7SSalyzyn, Mark static int aac_write_raw_io(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua) 1054e8f32de5SMark Haverkamp { 1055e8f32de5SMark Haverkamp u16 fibsize; 1056e8f32de5SMark Haverkamp struct aac_raw_io *writecmd; 1057e8f32de5SMark Haverkamp aac_fib_init(fib); 1058e8f32de5SMark Haverkamp writecmd = (struct aac_raw_io *) fib_data(fib); 1059e8f32de5SMark Haverkamp writecmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff)); 1060e8f32de5SMark Haverkamp writecmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 1061e8f32de5SMark Haverkamp writecmd->count = cpu_to_le32(count<<9); 1062e8f32de5SMark Haverkamp writecmd->cid = cpu_to_le16(scmd_id(cmd)); 106395e852e1SSalyzyn, Mark writecmd->flags = (fua && ((aac_cache & 5) != 1) && 106495e852e1SSalyzyn, Mark (((aac_cache & 5) != 5) || !fib->dev->cache_protected)) ? 10659d399cc7SSalyzyn, Mark cpu_to_le16(IO_TYPE_WRITE|IO_SUREWRITE) : 10669d399cc7SSalyzyn, Mark cpu_to_le16(IO_TYPE_WRITE); 1067e8f32de5SMark Haverkamp writecmd->bpTotal = 0; 1068e8f32de5SMark Haverkamp writecmd->bpComplete = 0; 1069e8f32de5SMark Haverkamp 1070e8f32de5SMark Haverkamp aac_build_sgraw(cmd, &writecmd->sg); 1071e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_raw_io) + ((le32_to_cpu(writecmd->sg.count) - 1) * sizeof (struct sgentryraw)); 1072e8f32de5SMark Haverkamp BUG_ON(fibsize > (fib->dev->max_fib_size - sizeof(struct aac_fibhdr))); 1073e8f32de5SMark Haverkamp /* 1074e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1075e8f32de5SMark Haverkamp */ 1076e8f32de5SMark Haverkamp return aac_fib_send(ContainerRawIo, 1077e8f32de5SMark Haverkamp fib, 1078e8f32de5SMark Haverkamp fibsize, 1079e8f32de5SMark Haverkamp FsaNormal, 1080e8f32de5SMark Haverkamp 0, 1, 1081e8f32de5SMark Haverkamp (fib_callback) io_callback, 1082e8f32de5SMark Haverkamp (void *) cmd); 1083e8f32de5SMark Haverkamp } 1084e8f32de5SMark Haverkamp 10859d399cc7SSalyzyn, Mark static int aac_write_block64(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua) 1086e8f32de5SMark Haverkamp { 1087e8f32de5SMark Haverkamp u16 fibsize; 1088e8f32de5SMark Haverkamp struct aac_write64 *writecmd; 1089e8f32de5SMark Haverkamp aac_fib_init(fib); 1090e8f32de5SMark Haverkamp writecmd = (struct aac_write64 *) fib_data(fib); 1091e8f32de5SMark Haverkamp writecmd->command = cpu_to_le32(VM_CtHostWrite64); 1092e8f32de5SMark Haverkamp writecmd->cid = cpu_to_le16(scmd_id(cmd)); 1093e8f32de5SMark Haverkamp writecmd->sector_count = cpu_to_le16(count); 1094e8f32de5SMark Haverkamp writecmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1095e8f32de5SMark Haverkamp writecmd->pad = 0; 1096e8f32de5SMark Haverkamp writecmd->flags = 0; 1097e8f32de5SMark Haverkamp 1098e8f32de5SMark Haverkamp aac_build_sg64(cmd, &writecmd->sg); 1099e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_write64) + 1100e8f32de5SMark Haverkamp ((le32_to_cpu(writecmd->sg.count) - 1) * 1101e8f32de5SMark Haverkamp sizeof (struct sgentry64)); 1102e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1103e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1104e8f32de5SMark Haverkamp /* 1105e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1106e8f32de5SMark Haverkamp */ 1107e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand64, 1108e8f32de5SMark Haverkamp fib, 1109e8f32de5SMark Haverkamp fibsize, 1110e8f32de5SMark Haverkamp FsaNormal, 1111e8f32de5SMark Haverkamp 0, 1, 1112e8f32de5SMark Haverkamp (fib_callback) io_callback, 1113e8f32de5SMark Haverkamp (void *) cmd); 1114e8f32de5SMark Haverkamp } 1115e8f32de5SMark Haverkamp 11169d399cc7SSalyzyn, Mark static int aac_write_block(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua) 1117e8f32de5SMark Haverkamp { 1118e8f32de5SMark Haverkamp u16 fibsize; 1119e8f32de5SMark Haverkamp struct aac_write *writecmd; 1120e8f32de5SMark Haverkamp aac_fib_init(fib); 1121e8f32de5SMark Haverkamp writecmd = (struct aac_write *) fib_data(fib); 1122e8f32de5SMark Haverkamp writecmd->command = cpu_to_le32(VM_CtBlockWrite); 1123f3307f72SChristoph Hellwig writecmd->cid = cpu_to_le32(scmd_id(cmd)); 1124e8f32de5SMark Haverkamp writecmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1125e8f32de5SMark Haverkamp writecmd->count = cpu_to_le32(count * 512); 1126e8f32de5SMark Haverkamp writecmd->sg.count = cpu_to_le32(1); 1127e8f32de5SMark Haverkamp /* ->stable is not used - it did mean which type of write */ 1128e8f32de5SMark Haverkamp 1129e8f32de5SMark Haverkamp aac_build_sg(cmd, &writecmd->sg); 1130e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_write) + 1131e8f32de5SMark Haverkamp ((le32_to_cpu(writecmd->sg.count) - 1) * 1132e8f32de5SMark Haverkamp sizeof (struct sgentry)); 1133e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1134e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1135e8f32de5SMark Haverkamp /* 1136e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1137e8f32de5SMark Haverkamp */ 1138e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand, 1139e8f32de5SMark Haverkamp fib, 1140e8f32de5SMark Haverkamp fibsize, 1141e8f32de5SMark Haverkamp FsaNormal, 1142e8f32de5SMark Haverkamp 0, 1, 1143e8f32de5SMark Haverkamp (fib_callback) io_callback, 1144e8f32de5SMark Haverkamp (void *) cmd); 1145e8f32de5SMark Haverkamp } 1146e8f32de5SMark Haverkamp 1147e8f32de5SMark Haverkamp static struct aac_srb * aac_scsi_common(struct fib * fib, struct scsi_cmnd * cmd) 1148e8f32de5SMark Haverkamp { 1149e8f32de5SMark Haverkamp struct aac_srb * srbcmd; 1150e8f32de5SMark Haverkamp u32 flag; 1151e8f32de5SMark Haverkamp u32 timeout; 1152e8f32de5SMark Haverkamp 1153e8f32de5SMark Haverkamp aac_fib_init(fib); 1154e8f32de5SMark Haverkamp switch(cmd->sc_data_direction){ 1155e8f32de5SMark Haverkamp case DMA_TO_DEVICE: 1156e8f32de5SMark Haverkamp flag = SRB_DataOut; 1157e8f32de5SMark Haverkamp break; 1158e8f32de5SMark Haverkamp case DMA_BIDIRECTIONAL: 1159e8f32de5SMark Haverkamp flag = SRB_DataIn | SRB_DataOut; 1160e8f32de5SMark Haverkamp break; 1161e8f32de5SMark Haverkamp case DMA_FROM_DEVICE: 1162e8f32de5SMark Haverkamp flag = SRB_DataIn; 1163e8f32de5SMark Haverkamp break; 1164e8f32de5SMark Haverkamp case DMA_NONE: 1165e8f32de5SMark Haverkamp default: /* shuts up some versions of gcc */ 1166e8f32de5SMark Haverkamp flag = SRB_NoDataXfer; 1167e8f32de5SMark Haverkamp break; 1168e8f32de5SMark Haverkamp } 1169e8f32de5SMark Haverkamp 1170e8f32de5SMark Haverkamp srbcmd = (struct aac_srb*) fib_data(fib); 1171e8f32de5SMark Haverkamp srbcmd->function = cpu_to_le32(SRBF_ExecuteScsi); 1172e8f32de5SMark Haverkamp srbcmd->channel = cpu_to_le32(aac_logical_to_phys(scmd_channel(cmd))); 1173e8f32de5SMark Haverkamp srbcmd->id = cpu_to_le32(scmd_id(cmd)); 1174e8f32de5SMark Haverkamp srbcmd->lun = cpu_to_le32(cmd->device->lun); 1175e8f32de5SMark Haverkamp srbcmd->flags = cpu_to_le32(flag); 1176242f9dcbSJens Axboe timeout = cmd->request->timeout/HZ; 1177e8f32de5SMark Haverkamp if (timeout == 0) 1178e8f32de5SMark Haverkamp timeout = 1; 1179e8f32de5SMark Haverkamp srbcmd->timeout = cpu_to_le32(timeout); // timeout in seconds 1180e8f32de5SMark Haverkamp srbcmd->retry_limit = 0; /* Obsolete parameter */ 1181e8f32de5SMark Haverkamp srbcmd->cdb_size = cpu_to_le32(cmd->cmd_len); 1182e8f32de5SMark Haverkamp return srbcmd; 1183e8f32de5SMark Haverkamp } 1184e8f32de5SMark Haverkamp 1185e8f32de5SMark Haverkamp static void aac_srb_callback(void *context, struct fib * fibptr); 1186e8f32de5SMark Haverkamp 1187e8f32de5SMark Haverkamp static int aac_scsi_64(struct fib * fib, struct scsi_cmnd * cmd) 1188e8f32de5SMark Haverkamp { 1189e8f32de5SMark Haverkamp u16 fibsize; 1190e8f32de5SMark Haverkamp struct aac_srb * srbcmd = aac_scsi_common(fib, cmd); 1191e8f32de5SMark Haverkamp 1192e8f32de5SMark Haverkamp aac_build_sg64(cmd, (struct sgmap64*) &srbcmd->sg); 1193727eead6SFUJITA Tomonori srbcmd->count = cpu_to_le32(scsi_bufflen(cmd)); 1194e8f32de5SMark Haverkamp 1195e8f32de5SMark Haverkamp memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb)); 1196e8f32de5SMark Haverkamp memcpy(srbcmd->cdb, cmd->cmnd, cmd->cmd_len); 1197e8f32de5SMark Haverkamp /* 1198e8f32de5SMark Haverkamp * Build Scatter/Gather list 1199e8f32de5SMark Haverkamp */ 1200e8f32de5SMark Haverkamp fibsize = sizeof (struct aac_srb) - sizeof (struct sgentry) + 1201e8f32de5SMark Haverkamp ((le32_to_cpu(srbcmd->sg.count) & 0xff) * 1202e8f32de5SMark Haverkamp sizeof (struct sgentry64)); 1203e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1204e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1205e8f32de5SMark Haverkamp 1206e8f32de5SMark Haverkamp /* 1207e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1208e8f32de5SMark Haverkamp */ 1209e8f32de5SMark Haverkamp return aac_fib_send(ScsiPortCommand64, fib, 1210e8f32de5SMark Haverkamp fibsize, FsaNormal, 0, 1, 1211e8f32de5SMark Haverkamp (fib_callback) aac_srb_callback, 1212e8f32de5SMark Haverkamp (void *) cmd); 1213e8f32de5SMark Haverkamp } 1214e8f32de5SMark Haverkamp 1215e8f32de5SMark Haverkamp static int aac_scsi_32(struct fib * fib, struct scsi_cmnd * cmd) 1216e8f32de5SMark Haverkamp { 1217e8f32de5SMark Haverkamp u16 fibsize; 1218e8f32de5SMark Haverkamp struct aac_srb * srbcmd = aac_scsi_common(fib, cmd); 1219e8f32de5SMark Haverkamp 1220e8f32de5SMark Haverkamp aac_build_sg(cmd, (struct sgmap*)&srbcmd->sg); 1221727eead6SFUJITA Tomonori srbcmd->count = cpu_to_le32(scsi_bufflen(cmd)); 1222e8f32de5SMark Haverkamp 1223e8f32de5SMark Haverkamp memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb)); 1224e8f32de5SMark Haverkamp memcpy(srbcmd->cdb, cmd->cmnd, cmd->cmd_len); 1225e8f32de5SMark Haverkamp /* 1226e8f32de5SMark Haverkamp * Build Scatter/Gather list 1227e8f32de5SMark Haverkamp */ 1228e8f32de5SMark Haverkamp fibsize = sizeof (struct aac_srb) + 1229e8f32de5SMark Haverkamp (((le32_to_cpu(srbcmd->sg.count) & 0xff) - 1) * 1230e8f32de5SMark Haverkamp sizeof (struct sgentry)); 1231e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1232e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1233e8f32de5SMark Haverkamp 1234e8f32de5SMark Haverkamp /* 1235e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1236e8f32de5SMark Haverkamp */ 1237e8f32de5SMark Haverkamp return aac_fib_send(ScsiPortCommand, fib, fibsize, FsaNormal, 0, 1, 1238e8f32de5SMark Haverkamp (fib_callback) aac_srb_callback, (void *) cmd); 1239e8f32de5SMark Haverkamp } 1240e8f32de5SMark Haverkamp 124194cf6ba1SSalyzyn, Mark static int aac_scsi_32_64(struct fib * fib, struct scsi_cmnd * cmd) 124294cf6ba1SSalyzyn, Mark { 1243d8e96507SLeubner, Achim if ((sizeof(dma_addr_t) > 4) && fib->dev->needs_dac && 124494cf6ba1SSalyzyn, Mark (fib->dev->adapter_info.options & AAC_OPT_SGMAP_HOST64)) 124594cf6ba1SSalyzyn, Mark return FAILED; 124694cf6ba1SSalyzyn, Mark return aac_scsi_32(fib, cmd); 124794cf6ba1SSalyzyn, Mark } 124894cf6ba1SSalyzyn, Mark 12491da177e4SLinus Torvalds int aac_get_adapter_info(struct aac_dev* dev) 12501da177e4SLinus Torvalds { 12511da177e4SLinus Torvalds struct fib* fibptr; 12521da177e4SLinus Torvalds int rcode; 12531da177e4SLinus Torvalds u32 tmp; 12547c00ffa3SMark Haverkamp struct aac_adapter_info *info; 125584971738SMark Haverkamp struct aac_bus_info *command; 125684971738SMark Haverkamp struct aac_bus_info_response *bus_info; 12577c00ffa3SMark Haverkamp 1258bfb35aa8SMark Haverkamp if (!(fibptr = aac_fib_alloc(dev))) 12591da177e4SLinus Torvalds return -ENOMEM; 12601da177e4SLinus Torvalds 1261bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 12621da177e4SLinus Torvalds info = (struct aac_adapter_info *) fib_data(fibptr); 12637c00ffa3SMark Haverkamp memset(info,0,sizeof(*info)); 12641da177e4SLinus Torvalds 1265bfb35aa8SMark Haverkamp rcode = aac_fib_send(RequestAdapterInfo, 12661da177e4SLinus Torvalds fibptr, 12677c00ffa3SMark Haverkamp sizeof(*info), 12681da177e4SLinus Torvalds FsaNormal, 12699203344cSMark Haverkamp -1, 1, /* First `interrupt' command uses special wait */ 12701da177e4SLinus Torvalds NULL, 12711da177e4SLinus Torvalds NULL); 12721da177e4SLinus Torvalds 12737c00ffa3SMark Haverkamp if (rcode < 0) { 1274cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* FIB should be freed only after 1275cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech * getting the response from the F/W */ 1276cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (rcode != -ERESTARTSYS) { 1277bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1278bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 1279cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech } 12807c00ffa3SMark Haverkamp return rcode; 12817c00ffa3SMark Haverkamp } 12827c00ffa3SMark Haverkamp memcpy(&dev->adapter_info, info, sizeof(*info)); 12837c00ffa3SMark Haverkamp 12847c00ffa3SMark Haverkamp if (dev->adapter_info.options & AAC_OPT_SUPPLEMENT_ADAPTER_INFO) { 128506a43d17SSalyzyn, Mark struct aac_supplement_adapter_info * sinfo; 12867c00ffa3SMark Haverkamp 1287bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 12887c00ffa3SMark Haverkamp 128906a43d17SSalyzyn, Mark sinfo = (struct aac_supplement_adapter_info *) fib_data(fibptr); 12907c00ffa3SMark Haverkamp 129106a43d17SSalyzyn, Mark memset(sinfo,0,sizeof(*sinfo)); 12927c00ffa3SMark Haverkamp 1293bfb35aa8SMark Haverkamp rcode = aac_fib_send(RequestSupplementAdapterInfo, 12947c00ffa3SMark Haverkamp fibptr, 129506a43d17SSalyzyn, Mark sizeof(*sinfo), 12967c00ffa3SMark Haverkamp FsaNormal, 12977c00ffa3SMark Haverkamp 1, 1, 12987c00ffa3SMark Haverkamp NULL, 12997c00ffa3SMark Haverkamp NULL); 13007c00ffa3SMark Haverkamp 13017c00ffa3SMark Haverkamp if (rcode >= 0) 130206a43d17SSalyzyn, Mark memcpy(&dev->supplement_adapter_info, sinfo, sizeof(*sinfo)); 1303cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (rcode == -ERESTARTSYS) { 1304cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech fibptr = aac_fib_alloc(dev); 1305cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (!fibptr) 1306cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech return -ENOMEM; 1307cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech } 1308cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech 13097c00ffa3SMark Haverkamp } 13101da177e4SLinus Torvalds 131184971738SMark Haverkamp 131284971738SMark Haverkamp /* 131384971738SMark Haverkamp * GetBusInfo 131484971738SMark Haverkamp */ 131584971738SMark Haverkamp 1316bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 131784971738SMark Haverkamp 131884971738SMark Haverkamp bus_info = (struct aac_bus_info_response *) fib_data(fibptr); 131984971738SMark Haverkamp 132084971738SMark Haverkamp memset(bus_info, 0, sizeof(*bus_info)); 132184971738SMark Haverkamp 132284971738SMark Haverkamp command = (struct aac_bus_info *)bus_info; 132384971738SMark Haverkamp 132484971738SMark Haverkamp command->Command = cpu_to_le32(VM_Ioctl); 132584971738SMark Haverkamp command->ObjType = cpu_to_le32(FT_DRIVE); 132684971738SMark Haverkamp command->MethodId = cpu_to_le32(1); 132784971738SMark Haverkamp command->CtlCmd = cpu_to_le32(GetBusInfo); 132884971738SMark Haverkamp 1329bfb35aa8SMark Haverkamp rcode = aac_fib_send(ContainerCommand, 133084971738SMark Haverkamp fibptr, 133184971738SMark Haverkamp sizeof (*bus_info), 133284971738SMark Haverkamp FsaNormal, 133384971738SMark Haverkamp 1, 1, 133484971738SMark Haverkamp NULL, NULL); 133584971738SMark Haverkamp 133694cf6ba1SSalyzyn, Mark /* reasoned default */ 133794cf6ba1SSalyzyn, Mark dev->maximum_num_physicals = 16; 133884971738SMark Haverkamp if (rcode >= 0 && le32_to_cpu(bus_info->Status) == ST_OK) { 133984971738SMark Haverkamp dev->maximum_num_physicals = le32_to_cpu(bus_info->TargetsPerBus); 134084971738SMark Haverkamp dev->maximum_num_channels = le32_to_cpu(bus_info->BusCount); 134184971738SMark Haverkamp } 134284971738SMark Haverkamp 13438c867b25SMark Haverkamp if (!dev->in_reset) { 134424f02e1dSSalyzyn, Mark char buffer[16]; 13451da177e4SLinus Torvalds tmp = le32_to_cpu(dev->adapter_info.kernelrev); 13467c00ffa3SMark Haverkamp printk(KERN_INFO "%s%d: kernel %d.%d-%d[%d] %.*s\n", 13471da177e4SLinus Torvalds dev->name, 13481da177e4SLinus Torvalds dev->id, 13491da177e4SLinus Torvalds tmp>>24, 13501da177e4SLinus Torvalds (tmp>>16)&0xff, 13511da177e4SLinus Torvalds tmp&0xff, 13527c00ffa3SMark Haverkamp le32_to_cpu(dev->adapter_info.kernelbuild), 13537c00ffa3SMark Haverkamp (int)sizeof(dev->supplement_adapter_info.BuildDate), 13547c00ffa3SMark Haverkamp dev->supplement_adapter_info.BuildDate); 13551da177e4SLinus Torvalds tmp = le32_to_cpu(dev->adapter_info.monitorrev); 13561da177e4SLinus Torvalds printk(KERN_INFO "%s%d: monitor %d.%d-%d[%d]\n", 13571da177e4SLinus Torvalds dev->name, dev->id, 13581da177e4SLinus Torvalds tmp>>24,(tmp>>16)&0xff,tmp&0xff, 13591da177e4SLinus Torvalds le32_to_cpu(dev->adapter_info.monitorbuild)); 13601da177e4SLinus Torvalds tmp = le32_to_cpu(dev->adapter_info.biosrev); 13611da177e4SLinus Torvalds printk(KERN_INFO "%s%d: bios %d.%d-%d[%d]\n", 13621da177e4SLinus Torvalds dev->name, dev->id, 13631da177e4SLinus Torvalds tmp>>24,(tmp>>16)&0xff,tmp&0xff, 13641da177e4SLinus Torvalds le32_to_cpu(dev->adapter_info.biosbuild)); 136524f02e1dSSalyzyn, Mark buffer[0] = '\0'; 1366ee959b00STony Jones if (aac_get_serial_number( 136724f02e1dSSalyzyn, Mark shost_to_class(dev->scsi_host_ptr), buffer)) 136824f02e1dSSalyzyn, Mark printk(KERN_INFO "%s%d: serial %s", 136924f02e1dSSalyzyn, Mark dev->name, dev->id, buffer); 1370a45c863fSSalyzyn, Mark if (dev->supplement_adapter_info.VpdInfo.Tsid[0]) { 1371a45c863fSSalyzyn, Mark printk(KERN_INFO "%s%d: TSID %.*s\n", 1372a45c863fSSalyzyn, Mark dev->name, dev->id, 1373a45c863fSSalyzyn, Mark (int)sizeof(dev->supplement_adapter_info.VpdInfo.Tsid), 1374a45c863fSSalyzyn, Mark dev->supplement_adapter_info.VpdInfo.Tsid); 1375a45c863fSSalyzyn, Mark } 13762f7ecc55SSalyzyn, Mark if (!aac_check_reset || ((aac_check_reset == 1) && 137729c97684SSalyzyn, Mark (dev->supplement_adapter_info.SupportedOptions2 & 1378a3940da5SSalyzyn, Mark AAC_OPTION_IGNORE_RESET))) { 137929c97684SSalyzyn, Mark printk(KERN_INFO "%s%d: Reset Adapter Ignored\n", 138029c97684SSalyzyn, Mark dev->name, dev->id); 138129c97684SSalyzyn, Mark } 13828c867b25SMark Haverkamp } 13831da177e4SLinus Torvalds 138495e852e1SSalyzyn, Mark dev->cache_protected = 0; 1385cb1042f2SSalyzyn, Mark dev->jbod = ((dev->supplement_adapter_info.FeatureBits & 1386cb1042f2SSalyzyn, Mark AAC_FEATURE_JBOD) != 0); 13871da177e4SLinus Torvalds dev->nondasd_support = 0; 13881da177e4SLinus Torvalds dev->raid_scsi_mode = 0; 138995e852e1SSalyzyn, Mark if(dev->adapter_info.options & AAC_OPT_NONDASD) 13901da177e4SLinus Torvalds dev->nondasd_support = 1; 13911da177e4SLinus Torvalds 13921da177e4SLinus Torvalds /* 13931da177e4SLinus Torvalds * If the firmware supports ROMB RAID/SCSI mode and we are currently 13941da177e4SLinus Torvalds * in RAID/SCSI mode, set the flag. For now if in this mode we will 13951da177e4SLinus Torvalds * force nondasd support on. If we decide to allow the non-dasd flag 13961da177e4SLinus Torvalds * additional changes changes will have to be made to support 13971da177e4SLinus Torvalds * RAID/SCSI. the function aac_scsi_cmd in this module will have to be 13981da177e4SLinus Torvalds * changed to support the new dev->raid_scsi_mode flag instead of 13991da177e4SLinus Torvalds * leaching off of the dev->nondasd_support flag. Also in linit.c the 14001da177e4SLinus Torvalds * function aac_detect will have to be modified where it sets up the 14011da177e4SLinus Torvalds * max number of channels based on the aac->nondasd_support flag only. 14021da177e4SLinus Torvalds */ 14031da177e4SLinus Torvalds if ((dev->adapter_info.options & AAC_OPT_SCSI_MANAGED) && 14041da177e4SLinus Torvalds (dev->adapter_info.options & AAC_OPT_RAID_SCSI_MODE)) { 14051da177e4SLinus Torvalds dev->nondasd_support = 1; 14061da177e4SLinus Torvalds dev->raid_scsi_mode = 1; 14071da177e4SLinus Torvalds } 14081da177e4SLinus Torvalds if (dev->raid_scsi_mode != 0) 14091da177e4SLinus Torvalds printk(KERN_INFO "%s%d: ROMB RAID/SCSI mode enabled\n", 14101da177e4SLinus Torvalds dev->name, dev->id); 14111da177e4SLinus Torvalds 141295e852e1SSalyzyn, Mark if (nondasd != -1) 14131da177e4SLinus Torvalds dev->nondasd_support = (nondasd!=0); 14142f7ecc55SSalyzyn, Mark if (dev->nondasd_support && !dev->in_reset) 14151da177e4SLinus Torvalds printk(KERN_INFO "%s%d: Non-DASD support enabled.\n",dev->name, dev->id); 14161da177e4SLinus Torvalds 1417e930438cSYang Hongyang if (dma_get_required_mask(&dev->pdev->dev) > DMA_BIT_MASK(32)) 1418d8e96507SLeubner, Achim dev->needs_dac = 1; 14191da177e4SLinus Torvalds dev->dac_support = 0; 1420d8e96507SLeubner, Achim if ((sizeof(dma_addr_t) > 4) && dev->needs_dac && 1421d8e96507SLeubner, Achim (dev->adapter_info.options & AAC_OPT_SGMAP_HOST64)) { 14222f7ecc55SSalyzyn, Mark if (!dev->in_reset) 14232f7ecc55SSalyzyn, Mark printk(KERN_INFO "%s%d: 64bit support enabled.\n", 14242f7ecc55SSalyzyn, Mark dev->name, dev->id); 14251da177e4SLinus Torvalds dev->dac_support = 1; 14261da177e4SLinus Torvalds } 14271da177e4SLinus Torvalds 14281da177e4SLinus Torvalds if(dacmode != -1) { 14291da177e4SLinus Torvalds dev->dac_support = (dacmode!=0); 14301da177e4SLinus Torvalds } 1431d8e96507SLeubner, Achim 1432d8e96507SLeubner, Achim /* avoid problems with AAC_QUIRK_SCSI_32 controllers */ 1433d8e96507SLeubner, Achim if (dev->dac_support && (aac_get_driver_ident(dev->cardtype)->quirks 1434d8e96507SLeubner, Achim & AAC_QUIRK_SCSI_32)) { 1435d8e96507SLeubner, Achim dev->nondasd_support = 0; 1436d8e96507SLeubner, Achim dev->jbod = 0; 1437d8e96507SLeubner, Achim expose_physicals = 0; 1438d8e96507SLeubner, Achim } 1439d8e96507SLeubner, Achim 14401da177e4SLinus Torvalds if(dev->dac_support != 0) { 14416a35528aSYang Hongyang if (!pci_set_dma_mask(dev->pdev, DMA_BIT_MASK(64)) && 14426a35528aSYang Hongyang !pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(64))) { 14432f7ecc55SSalyzyn, Mark if (!dev->in_reset) 14441da177e4SLinus Torvalds printk(KERN_INFO"%s%d: 64 Bit DAC enabled\n", 14451da177e4SLinus Torvalds dev->name, dev->id); 1446284901a9SYang Hongyang } else if (!pci_set_dma_mask(dev->pdev, DMA_BIT_MASK(32)) && 1447284901a9SYang Hongyang !pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(32))) { 14481da177e4SLinus Torvalds printk(KERN_INFO"%s%d: DMA mask set failed, 64 Bit DAC disabled\n", 14491da177e4SLinus Torvalds dev->name, dev->id); 14501da177e4SLinus Torvalds dev->dac_support = 0; 14511da177e4SLinus Torvalds } else { 14521da177e4SLinus Torvalds printk(KERN_WARNING"%s%d: No suitable DMA available.\n", 14531da177e4SLinus Torvalds dev->name, dev->id); 14541da177e4SLinus Torvalds rcode = -ENOMEM; 14551da177e4SLinus Torvalds } 14561da177e4SLinus Torvalds } 14577c00ffa3SMark Haverkamp /* 1458e8f32de5SMark Haverkamp * Deal with configuring for the individualized limits of each packet 1459e8f32de5SMark Haverkamp * interface. 14607c00ffa3SMark Haverkamp */ 1461e8f32de5SMark Haverkamp dev->a_ops.adapter_scsi = (dev->dac_support) 146294cf6ba1SSalyzyn, Mark ? ((aac_get_driver_ident(dev->cardtype)->quirks & AAC_QUIRK_SCSI_32) 146394cf6ba1SSalyzyn, Mark ? aac_scsi_32_64 146494cf6ba1SSalyzyn, Mark : aac_scsi_64) 1465e8f32de5SMark Haverkamp : aac_scsi_32; 1466e8f32de5SMark Haverkamp if (dev->raw_io_interface) { 1467e8f32de5SMark Haverkamp dev->a_ops.adapter_bounds = (dev->raw_io_64) 1468e8f32de5SMark Haverkamp ? aac_bounds_64 1469e8f32de5SMark Haverkamp : aac_bounds_32; 1470e8f32de5SMark Haverkamp dev->a_ops.adapter_read = aac_read_raw_io; 1471e8f32de5SMark Haverkamp dev->a_ops.adapter_write = aac_write_raw_io; 1472e8f32de5SMark Haverkamp } else { 1473e8f32de5SMark Haverkamp dev->a_ops.adapter_bounds = aac_bounds_32; 14747c00ffa3SMark Haverkamp dev->scsi_host_ptr->sg_tablesize = (dev->max_fib_size - 14757c00ffa3SMark Haverkamp sizeof(struct aac_fibhdr) - 147663a70eeaSMark Haverkamp sizeof(struct aac_write) + sizeof(struct sgentry)) / 147763a70eeaSMark Haverkamp sizeof(struct sgentry); 14787c00ffa3SMark Haverkamp if (dev->dac_support) { 1479e8f32de5SMark Haverkamp dev->a_ops.adapter_read = aac_read_block64; 1480e8f32de5SMark Haverkamp dev->a_ops.adapter_write = aac_write_block64; 14817c00ffa3SMark Haverkamp /* 14827c00ffa3SMark Haverkamp * 38 scatter gather elements 14837c00ffa3SMark Haverkamp */ 14847c00ffa3SMark Haverkamp dev->scsi_host_ptr->sg_tablesize = 14857c00ffa3SMark Haverkamp (dev->max_fib_size - 14867c00ffa3SMark Haverkamp sizeof(struct aac_fibhdr) - 14877c00ffa3SMark Haverkamp sizeof(struct aac_write64) + 148863a70eeaSMark Haverkamp sizeof(struct sgentry64)) / 148963a70eeaSMark Haverkamp sizeof(struct sgentry64); 1490e8f32de5SMark Haverkamp } else { 1491e8f32de5SMark Haverkamp dev->a_ops.adapter_read = aac_read_block; 1492e8f32de5SMark Haverkamp dev->a_ops.adapter_write = aac_write_block; 14937c00ffa3SMark Haverkamp } 14947c00ffa3SMark Haverkamp dev->scsi_host_ptr->max_sectors = AAC_MAX_32BIT_SGBCOUNT; 1495e8b12f0fSMahesh Rajashekhara if (dev->adapter_info.options & AAC_OPT_NEW_COMM_TYPE1) 1496e8b12f0fSMahesh Rajashekhara dev->adapter_info.options |= AAC_OPT_NEW_COMM; 14977c00ffa3SMark Haverkamp if (!(dev->adapter_info.options & AAC_OPT_NEW_COMM)) { 14987c00ffa3SMark Haverkamp /* 14997c00ffa3SMark Haverkamp * Worst case size that could cause sg overflow when 15007c00ffa3SMark Haverkamp * we break up SG elements that are larger than 64KB. 15017c00ffa3SMark Haverkamp * Would be nice if we could tell the SCSI layer what 15027c00ffa3SMark Haverkamp * the maximum SG element size can be. Worst case is 15037c00ffa3SMark Haverkamp * (sg_tablesize-1) 4KB elements with one 64KB 15047c00ffa3SMark Haverkamp * element. 15057c00ffa3SMark Haverkamp * 32bit -> 468 or 238KB 64bit -> 424 or 212KB 15067c00ffa3SMark Haverkamp */ 15077c00ffa3SMark Haverkamp dev->scsi_host_ptr->max_sectors = 15087c00ffa3SMark Haverkamp (dev->scsi_host_ptr->sg_tablesize * 8) + 112; 15097c00ffa3SMark Haverkamp } 15100e68c003SMark Haverkamp } 1511cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* FIB should be freed only after getting the response from the F/W */ 1512cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (rcode != -ERESTARTSYS) { 1513bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1514bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 1515cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech } 15161da177e4SLinus Torvalds 15171da177e4SLinus Torvalds return rcode; 15181da177e4SLinus Torvalds } 15191da177e4SLinus Torvalds 15201da177e4SLinus Torvalds 1521e53cb35aSMark Haverkamp static void io_callback(void *context, struct fib * fibptr) 15221da177e4SLinus Torvalds { 15231da177e4SLinus Torvalds struct aac_dev *dev; 15241da177e4SLinus Torvalds struct aac_read_reply *readreply; 15251da177e4SLinus Torvalds struct scsi_cmnd *scsicmd; 15261da177e4SLinus Torvalds u32 cid; 15271da177e4SLinus Torvalds 15281da177e4SLinus Torvalds scsicmd = (struct scsi_cmnd *) context; 15291da177e4SLinus Torvalds 153003d44337SMark Haverkamp if (!aac_valid_context(scsicmd, fibptr)) 153103d44337SMark Haverkamp return; 153203d44337SMark Haverkamp 15331a655040SSalyzyn, Mark dev = fibptr->dev; 1534e5718774SMark Haverkamp cid = scmd_id(scsicmd); 15351da177e4SLinus Torvalds 15367a8cf29dSMark Haverkamp if (nblank(dprintk(x))) { 15377a8cf29dSMark Haverkamp u64 lba; 15387a8cf29dSMark Haverkamp switch (scsicmd->cmnd[0]) { 15397a8cf29dSMark Haverkamp case WRITE_6: 15407a8cf29dSMark Haverkamp case READ_6: 15417a8cf29dSMark Haverkamp lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | 15427a8cf29dSMark Haverkamp (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 15437a8cf29dSMark Haverkamp break; 15447a8cf29dSMark Haverkamp case WRITE_16: 15457a8cf29dSMark Haverkamp case READ_16: 15467a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 56) | 15477a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[3] << 48) | 15487a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[4] << 40) | 15497a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[5] << 32) | 15507a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[6] << 24) | 15517a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 15527a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 15537a8cf29dSMark Haverkamp break; 15547a8cf29dSMark Haverkamp case WRITE_12: 15557a8cf29dSMark Haverkamp case READ_12: 15567a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 15577a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 15587a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 15597a8cf29dSMark Haverkamp break; 15607a8cf29dSMark Haverkamp default: 15617a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 15627a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 15637a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 15647a8cf29dSMark Haverkamp break; 15657a8cf29dSMark Haverkamp } 15667a8cf29dSMark Haverkamp printk(KERN_DEBUG 15677a8cf29dSMark Haverkamp "io_callback[cpu %d]: lba = %llu, t = %ld.\n", 15687a8cf29dSMark Haverkamp smp_processor_id(), (unsigned long long)lba, jiffies); 15697a8cf29dSMark Haverkamp } 15701da177e4SLinus Torvalds 1571125e1874SEric Sesterhenn BUG_ON(fibptr == NULL); 15721da177e4SLinus Torvalds 1573727eead6SFUJITA Tomonori scsi_dma_unmap(scsicmd); 1574727eead6SFUJITA Tomonori 15751da177e4SLinus Torvalds readreply = (struct aac_read_reply *)fib_data(fibptr); 1576655d722cSMark Salyzyn switch (le32_to_cpu(readreply->status)) { 1577655d722cSMark Salyzyn case ST_OK: 1578655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 1579655d722cSMark Salyzyn SAM_STAT_GOOD; 1580655d722cSMark Salyzyn dev->fsa_dev[cid].sense_data.sense_key = NO_SENSE; 1581655d722cSMark Salyzyn break; 1582655d722cSMark Salyzyn case ST_NOT_READY: 1583655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 1584655d722cSMark Salyzyn SAM_STAT_CHECK_CONDITION; 1585655d722cSMark Salyzyn set_sense(&dev->fsa_dev[cid].sense_data, NOT_READY, 1586655d722cSMark Salyzyn SENCODE_BECOMING_READY, ASENCODE_BECOMING_READY, 0, 0); 1587655d722cSMark Salyzyn memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1588655d722cSMark Salyzyn min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 1589655d722cSMark Salyzyn SCSI_SENSE_BUFFERSIZE)); 1590655d722cSMark Salyzyn break; 1591655d722cSMark Salyzyn default: 15927c00ffa3SMark Haverkamp #ifdef AAC_DETAILED_STATUS_INFO 1593e53cb35aSMark Haverkamp printk(KERN_WARNING "io_callback: io failed, status = %d\n", 15941da177e4SLinus Torvalds le32_to_cpu(readreply->status)); 15957c00ffa3SMark Haverkamp #endif 1596655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 1597655d722cSMark Salyzyn SAM_STAT_CHECK_CONDITION; 15988e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 15998e31e607SSalyzyn, Mark HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 16008e31e607SSalyzyn, Mark ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 16011da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 16023ace426fSSalyzyn, Mark min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 16033ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE)); 1604655d722cSMark Salyzyn break; 16051da177e4SLinus Torvalds } 1606bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1607bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 16081da177e4SLinus Torvalds 16098e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 16101da177e4SLinus Torvalds } 16111da177e4SLinus Torvalds 16129e7c349cSMark Haverkamp static int aac_read(struct scsi_cmnd * scsicmd) 16131da177e4SLinus Torvalds { 16147a8cf29dSMark Haverkamp u64 lba; 16151da177e4SLinus Torvalds u32 count; 16161da177e4SLinus Torvalds int status; 16171da177e4SLinus Torvalds struct aac_dev *dev; 16181da177e4SLinus Torvalds struct fib * cmd_fibcontext; 1619da3cc679SRajashekhara, Mahesh int cid; 16201da177e4SLinus Torvalds 16211da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 16221da177e4SLinus Torvalds /* 16231da177e4SLinus Torvalds * Get block address and transfer length 16241da177e4SLinus Torvalds */ 16257a8cf29dSMark Haverkamp switch (scsicmd->cmnd[0]) { 16267a8cf29dSMark Haverkamp case READ_6: 16279e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a read(6) command on id %d.\n", scmd_id(scsicmd))); 16281da177e4SLinus Torvalds 16297a8cf29dSMark Haverkamp lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | 16307a8cf29dSMark Haverkamp (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 16311da177e4SLinus Torvalds count = scsicmd->cmnd[4]; 16321da177e4SLinus Torvalds 16331da177e4SLinus Torvalds if (count == 0) 16341da177e4SLinus Torvalds count = 256; 16357a8cf29dSMark Haverkamp break; 16367a8cf29dSMark Haverkamp case READ_16: 16379e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a read(16) command on id %d.\n", scmd_id(scsicmd))); 16387a8cf29dSMark Haverkamp 16397a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 56) | 16407a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[3] << 48) | 16417a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[4] << 40) | 16427a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[5] << 32) | 16437a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[6] << 24) | 16447a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 16457a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 16467a8cf29dSMark Haverkamp count = (scsicmd->cmnd[10] << 24) | 16477a8cf29dSMark Haverkamp (scsicmd->cmnd[11] << 16) | 16487a8cf29dSMark Haverkamp (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13]; 16497a8cf29dSMark Haverkamp break; 16507a8cf29dSMark Haverkamp case READ_12: 16519e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a read(12) command on id %d.\n", scmd_id(scsicmd))); 16527a8cf29dSMark Haverkamp 16537a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 16547a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 16557a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 16567a8cf29dSMark Haverkamp count = (scsicmd->cmnd[6] << 24) | 16577a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 16587a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 16597a8cf29dSMark Haverkamp break; 16607a8cf29dSMark Haverkamp default: 16619e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a read(10) command on id %d.\n", scmd_id(scsicmd))); 16621da177e4SLinus Torvalds 16637a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 16647a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 16657a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 16661da177e4SLinus Torvalds count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 16677a8cf29dSMark Haverkamp break; 16681da177e4SLinus Torvalds } 1669da3cc679SRajashekhara, Mahesh 1670da3cc679SRajashekhara, Mahesh if ((lba + count) > (dev->fsa_dev[scmd_id(scsicmd)].size)) { 1671da3cc679SRajashekhara, Mahesh cid = scmd_id(scsicmd); 1672da3cc679SRajashekhara, Mahesh dprintk((KERN_DEBUG "aacraid: Illegal lba\n")); 1673da3cc679SRajashekhara, Mahesh scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 1674da3cc679SRajashekhara, Mahesh SAM_STAT_CHECK_CONDITION; 1675da3cc679SRajashekhara, Mahesh set_sense(&dev->fsa_dev[cid].sense_data, 1676da3cc679SRajashekhara, Mahesh HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 1677da3cc679SRajashekhara, Mahesh ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 1678da3cc679SRajashekhara, Mahesh memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1679da3cc679SRajashekhara, Mahesh min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 1680da3cc679SRajashekhara, Mahesh SCSI_SENSE_BUFFERSIZE)); 1681da3cc679SRajashekhara, Mahesh scsicmd->scsi_done(scsicmd); 1682da3cc679SRajashekhara, Mahesh return 1; 1683da3cc679SRajashekhara, Mahesh } 1684da3cc679SRajashekhara, Mahesh 16857a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aac_read[cpu %d]: lba = %llu, t = %ld.\n", 16867c00ffa3SMark Haverkamp smp_processor_id(), (unsigned long long)lba, jiffies)); 1687e8f32de5SMark Haverkamp if (aac_adapter_bounds(dev,scsicmd,lba)) 16887a8cf29dSMark Haverkamp return 0; 16891da177e4SLinus Torvalds /* 16901da177e4SLinus Torvalds * Alocate and initialize a Fib 16911da177e4SLinus Torvalds */ 1692bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) { 1693cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech printk(KERN_WARNING "aac_read: fib allocation failed\n"); 16941da177e4SLinus Torvalds return -1; 16951da177e4SLinus Torvalds } 16961da177e4SLinus Torvalds 1697e8f32de5SMark Haverkamp status = aac_adapter_read(cmd_fibcontext, scsicmd, lba, count); 16981da177e4SLinus Torvalds 16991da177e4SLinus Torvalds /* 17001da177e4SLinus Torvalds * Check that the command queued to the controller 17011da177e4SLinus Torvalds */ 170277d644d4SMark Haverkamp if (status == -EINPROGRESS) { 170377d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 17041da177e4SLinus Torvalds return 0; 170577d644d4SMark Haverkamp } 17061da177e4SLinus Torvalds 1707bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_read: aac_fib_send failed with status: %d.\n", status); 17081da177e4SLinus Torvalds /* 17091da177e4SLinus Torvalds * For some reason, the Fib didn't queue, return QUEUE_FULL 17101da177e4SLinus Torvalds */ 17111da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL; 17128e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 1713bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 1714bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 17151da177e4SLinus Torvalds return 0; 17161da177e4SLinus Torvalds } 17171da177e4SLinus Torvalds 17189e7c349cSMark Haverkamp static int aac_write(struct scsi_cmnd * scsicmd) 17191da177e4SLinus Torvalds { 17207a8cf29dSMark Haverkamp u64 lba; 17211da177e4SLinus Torvalds u32 count; 17229d399cc7SSalyzyn, Mark int fua; 17231da177e4SLinus Torvalds int status; 17241da177e4SLinus Torvalds struct aac_dev *dev; 17251da177e4SLinus Torvalds struct fib * cmd_fibcontext; 1726da3cc679SRajashekhara, Mahesh int cid; 17271da177e4SLinus Torvalds 17281da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 17291da177e4SLinus Torvalds /* 17301da177e4SLinus Torvalds * Get block address and transfer length 17311da177e4SLinus Torvalds */ 17321da177e4SLinus Torvalds if (scsicmd->cmnd[0] == WRITE_6) /* 6 byte command */ 17331da177e4SLinus Torvalds { 17341da177e4SLinus Torvalds lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 17351da177e4SLinus Torvalds count = scsicmd->cmnd[4]; 17361da177e4SLinus Torvalds if (count == 0) 17371da177e4SLinus Torvalds count = 256; 17389d399cc7SSalyzyn, Mark fua = 0; 17397a8cf29dSMark Haverkamp } else if (scsicmd->cmnd[0] == WRITE_16) { /* 16 byte command */ 17409e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a write(16) command on id %d.\n", scmd_id(scsicmd))); 17417a8cf29dSMark Haverkamp 17427a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 56) | 17437a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[3] << 48) | 17447a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[4] << 40) | 17457a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[5] << 32) | 17467a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[6] << 24) | 17477a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 17487a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 17497a8cf29dSMark Haverkamp count = (scsicmd->cmnd[10] << 24) | (scsicmd->cmnd[11] << 16) | 17507a8cf29dSMark Haverkamp (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13]; 17519d399cc7SSalyzyn, Mark fua = scsicmd->cmnd[1] & 0x8; 17527a8cf29dSMark Haverkamp } else if (scsicmd->cmnd[0] == WRITE_12) { /* 12 byte command */ 17539e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a write(12) command on id %d.\n", scmd_id(scsicmd))); 17547a8cf29dSMark Haverkamp 17557a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) 17567a8cf29dSMark Haverkamp | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 17577a8cf29dSMark Haverkamp count = (scsicmd->cmnd[6] << 24) | (scsicmd->cmnd[7] << 16) 17587a8cf29dSMark Haverkamp | (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 17599d399cc7SSalyzyn, Mark fua = scsicmd->cmnd[1] & 0x8; 17601da177e4SLinus Torvalds } else { 17619e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a write(10) command on id %d.\n", scmd_id(scsicmd))); 17627a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 17631da177e4SLinus Torvalds count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 17649d399cc7SSalyzyn, Mark fua = scsicmd->cmnd[1] & 0x8; 17651da177e4SLinus Torvalds } 1766da3cc679SRajashekhara, Mahesh 1767da3cc679SRajashekhara, Mahesh if ((lba + count) > (dev->fsa_dev[scmd_id(scsicmd)].size)) { 1768da3cc679SRajashekhara, Mahesh cid = scmd_id(scsicmd); 1769da3cc679SRajashekhara, Mahesh dprintk((KERN_DEBUG "aacraid: Illegal lba\n")); 1770da3cc679SRajashekhara, Mahesh scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 1771da3cc679SRajashekhara, Mahesh SAM_STAT_CHECK_CONDITION; 1772da3cc679SRajashekhara, Mahesh set_sense(&dev->fsa_dev[cid].sense_data, 1773da3cc679SRajashekhara, Mahesh HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 1774da3cc679SRajashekhara, Mahesh ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 1775da3cc679SRajashekhara, Mahesh memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1776da3cc679SRajashekhara, Mahesh min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 1777da3cc679SRajashekhara, Mahesh SCSI_SENSE_BUFFERSIZE)); 1778da3cc679SRajashekhara, Mahesh scsicmd->scsi_done(scsicmd); 1779da3cc679SRajashekhara, Mahesh return 1; 1780da3cc679SRajashekhara, Mahesh } 1781da3cc679SRajashekhara, Mahesh 17827a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aac_write[cpu %d]: lba = %llu, t = %ld.\n", 17831da177e4SLinus Torvalds smp_processor_id(), (unsigned long long)lba, jiffies)); 1784e8f32de5SMark Haverkamp if (aac_adapter_bounds(dev,scsicmd,lba)) 17857a8cf29dSMark Haverkamp return 0; 17861da177e4SLinus Torvalds /* 17871da177e4SLinus Torvalds * Allocate and initialize a Fib then setup a BlockWrite command 17881da177e4SLinus Torvalds */ 1789bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) { 1790cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* FIB temporarily unavailable,not catastrophic failure */ 1791cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech 1792cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* scsicmd->result = DID_ERROR << 16; 1793cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech * scsicmd->scsi_done(scsicmd); 1794cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech * return 0; 1795cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech */ 1796cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech printk(KERN_WARNING "aac_write: fib allocation failed\n"); 1797cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech return -1; 17981da177e4SLinus Torvalds } 17991da177e4SLinus Torvalds 18009d399cc7SSalyzyn, Mark status = aac_adapter_write(cmd_fibcontext, scsicmd, lba, count, fua); 18011da177e4SLinus Torvalds 18021da177e4SLinus Torvalds /* 18031da177e4SLinus Torvalds * Check that the command queued to the controller 18041da177e4SLinus Torvalds */ 180577d644d4SMark Haverkamp if (status == -EINPROGRESS) { 180677d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 18071da177e4SLinus Torvalds return 0; 18081da177e4SLinus Torvalds } 18091da177e4SLinus Torvalds 1810bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_write: aac_fib_send failed with status: %d\n", status); 18111da177e4SLinus Torvalds /* 18121da177e4SLinus Torvalds * For some reason, the Fib didn't queue, return QUEUE_FULL 18131da177e4SLinus Torvalds */ 18141da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL; 18158e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 18161da177e4SLinus Torvalds 1817bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 1818bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 18191da177e4SLinus Torvalds return 0; 18201da177e4SLinus Torvalds } 18211da177e4SLinus Torvalds 18221da177e4SLinus Torvalds static void synchronize_callback(void *context, struct fib *fibptr) 18231da177e4SLinus Torvalds { 18241da177e4SLinus Torvalds struct aac_synchronize_reply *synchronizereply; 18251da177e4SLinus Torvalds struct scsi_cmnd *cmd; 18261da177e4SLinus Torvalds 18271da177e4SLinus Torvalds cmd = context; 18281da177e4SLinus Torvalds 182903d44337SMark Haverkamp if (!aac_valid_context(cmd, fibptr)) 183003d44337SMark Haverkamp return; 183103d44337SMark Haverkamp 18321da177e4SLinus Torvalds dprintk((KERN_DEBUG "synchronize_callback[cpu %d]: t = %ld.\n", 18331da177e4SLinus Torvalds smp_processor_id(), jiffies)); 18341da177e4SLinus Torvalds BUG_ON(fibptr == NULL); 18351da177e4SLinus Torvalds 18361da177e4SLinus Torvalds 18371da177e4SLinus Torvalds synchronizereply = fib_data(fibptr); 18381da177e4SLinus Torvalds if (le32_to_cpu(synchronizereply->status) == CT_OK) 18391da177e4SLinus Torvalds cmd->result = DID_OK << 16 | 18401da177e4SLinus Torvalds COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 18411da177e4SLinus Torvalds else { 18421da177e4SLinus Torvalds struct scsi_device *sdev = cmd->device; 18431a655040SSalyzyn, Mark struct aac_dev *dev = fibptr->dev; 1844e5718774SMark Haverkamp u32 cid = sdev_id(sdev); 18451da177e4SLinus Torvalds printk(KERN_WARNING 18461da177e4SLinus Torvalds "synchronize_callback: synchronize failed, status = %d\n", 18471da177e4SLinus Torvalds le32_to_cpu(synchronizereply->status)); 18481da177e4SLinus Torvalds cmd->result = DID_OK << 16 | 18491da177e4SLinus Torvalds COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 18508e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 18518e31e607SSalyzyn, Mark HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 18528e31e607SSalyzyn, Mark ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 18531da177e4SLinus Torvalds memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1854b80ca4f7SFUJITA Tomonori min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 1855b80ca4f7SFUJITA Tomonori SCSI_SENSE_BUFFERSIZE)); 18561da177e4SLinus Torvalds } 18571da177e4SLinus Torvalds 1858bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1859bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 18608e0c5ebdSMark Haverkamp cmd->scsi_done(cmd); 18611da177e4SLinus Torvalds } 18621da177e4SLinus Torvalds 18639e7c349cSMark Haverkamp static int aac_synchronize(struct scsi_cmnd *scsicmd) 18641da177e4SLinus Torvalds { 18651da177e4SLinus Torvalds int status; 18661da177e4SLinus Torvalds struct fib *cmd_fibcontext; 18671da177e4SLinus Torvalds struct aac_synchronize *synchronizecmd; 18681da177e4SLinus Torvalds struct scsi_cmnd *cmd; 18691da177e4SLinus Torvalds struct scsi_device *sdev = scsicmd->device; 18701da177e4SLinus Torvalds int active = 0; 187190ee3466SMark Haverkamp struct aac_dev *aac; 1872b90f90d2SSalyzyn, Mark u64 lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | 1873b90f90d2SSalyzyn, Mark (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 1874b90f90d2SSalyzyn, Mark u32 count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 18751da177e4SLinus Torvalds unsigned long flags; 18761da177e4SLinus Torvalds 18771da177e4SLinus Torvalds /* 187877d644d4SMark Haverkamp * Wait for all outstanding queued commands to complete to this 187977d644d4SMark Haverkamp * specific target (block). 18801da177e4SLinus Torvalds */ 18811da177e4SLinus Torvalds spin_lock_irqsave(&sdev->list_lock, flags); 18821da177e4SLinus Torvalds list_for_each_entry(cmd, &sdev->cmd_list, list) 1883b90f90d2SSalyzyn, Mark if (cmd->SCp.phase == AAC_OWNER_FIRMWARE) { 1884b90f90d2SSalyzyn, Mark u64 cmnd_lba; 1885b90f90d2SSalyzyn, Mark u32 cmnd_count; 1886b90f90d2SSalyzyn, Mark 1887b90f90d2SSalyzyn, Mark if (cmd->cmnd[0] == WRITE_6) { 1888b90f90d2SSalyzyn, Mark cmnd_lba = ((cmd->cmnd[1] & 0x1F) << 16) | 1889b90f90d2SSalyzyn, Mark (cmd->cmnd[2] << 8) | 1890b90f90d2SSalyzyn, Mark cmd->cmnd[3]; 1891b90f90d2SSalyzyn, Mark cmnd_count = cmd->cmnd[4]; 1892b90f90d2SSalyzyn, Mark if (cmnd_count == 0) 1893b90f90d2SSalyzyn, Mark cmnd_count = 256; 1894b90f90d2SSalyzyn, Mark } else if (cmd->cmnd[0] == WRITE_16) { 1895b90f90d2SSalyzyn, Mark cmnd_lba = ((u64)cmd->cmnd[2] << 56) | 1896b90f90d2SSalyzyn, Mark ((u64)cmd->cmnd[3] << 48) | 1897b90f90d2SSalyzyn, Mark ((u64)cmd->cmnd[4] << 40) | 1898b90f90d2SSalyzyn, Mark ((u64)cmd->cmnd[5] << 32) | 1899b90f90d2SSalyzyn, Mark ((u64)cmd->cmnd[6] << 24) | 1900b90f90d2SSalyzyn, Mark (cmd->cmnd[7] << 16) | 1901b90f90d2SSalyzyn, Mark (cmd->cmnd[8] << 8) | 1902b90f90d2SSalyzyn, Mark cmd->cmnd[9]; 1903b90f90d2SSalyzyn, Mark cmnd_count = (cmd->cmnd[10] << 24) | 1904b90f90d2SSalyzyn, Mark (cmd->cmnd[11] << 16) | 1905b90f90d2SSalyzyn, Mark (cmd->cmnd[12] << 8) | 1906b90f90d2SSalyzyn, Mark cmd->cmnd[13]; 1907b90f90d2SSalyzyn, Mark } else if (cmd->cmnd[0] == WRITE_12) { 1908b90f90d2SSalyzyn, Mark cmnd_lba = ((u64)cmd->cmnd[2] << 24) | 1909b90f90d2SSalyzyn, Mark (cmd->cmnd[3] << 16) | 1910b90f90d2SSalyzyn, Mark (cmd->cmnd[4] << 8) | 1911b90f90d2SSalyzyn, Mark cmd->cmnd[5]; 1912b90f90d2SSalyzyn, Mark cmnd_count = (cmd->cmnd[6] << 24) | 1913b90f90d2SSalyzyn, Mark (cmd->cmnd[7] << 16) | 1914b90f90d2SSalyzyn, Mark (cmd->cmnd[8] << 8) | 1915b90f90d2SSalyzyn, Mark cmd->cmnd[9]; 1916b90f90d2SSalyzyn, Mark } else if (cmd->cmnd[0] == WRITE_10) { 1917b90f90d2SSalyzyn, Mark cmnd_lba = ((u64)cmd->cmnd[2] << 24) | 1918b90f90d2SSalyzyn, Mark (cmd->cmnd[3] << 16) | 1919b90f90d2SSalyzyn, Mark (cmd->cmnd[4] << 8) | 1920b90f90d2SSalyzyn, Mark cmd->cmnd[5]; 1921b90f90d2SSalyzyn, Mark cmnd_count = (cmd->cmnd[7] << 8) | 1922b90f90d2SSalyzyn, Mark cmd->cmnd[8]; 1923b90f90d2SSalyzyn, Mark } else 1924b90f90d2SSalyzyn, Mark continue; 1925b90f90d2SSalyzyn, Mark if (((cmnd_lba + cmnd_count) < lba) || 1926b90f90d2SSalyzyn, Mark (count && ((lba + count) < cmnd_lba))) 1927b90f90d2SSalyzyn, Mark continue; 19281da177e4SLinus Torvalds ++active; 19291da177e4SLinus Torvalds break; 19301da177e4SLinus Torvalds } 19311da177e4SLinus Torvalds 19321da177e4SLinus Torvalds spin_unlock_irqrestore(&sdev->list_lock, flags); 19331da177e4SLinus Torvalds 19341da177e4SLinus Torvalds /* 19351da177e4SLinus Torvalds * Yield the processor (requeue for later) 19361da177e4SLinus Torvalds */ 19371da177e4SLinus Torvalds if (active) 19381da177e4SLinus Torvalds return SCSI_MLQUEUE_DEVICE_BUSY; 19391da177e4SLinus Torvalds 1940f858317dSSalyzyn, Mark aac = (struct aac_dev *)sdev->host->hostdata; 19418c867b25SMark Haverkamp if (aac->in_reset) 19428c867b25SMark Haverkamp return SCSI_MLQUEUE_HOST_BUSY; 19438c867b25SMark Haverkamp 19441da177e4SLinus Torvalds /* 19457c00ffa3SMark Haverkamp * Allocate and initialize a Fib 19461da177e4SLinus Torvalds */ 194790ee3466SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(aac))) 19481da177e4SLinus Torvalds return SCSI_MLQUEUE_HOST_BUSY; 19491da177e4SLinus Torvalds 1950bfb35aa8SMark Haverkamp aac_fib_init(cmd_fibcontext); 19511da177e4SLinus Torvalds 19521da177e4SLinus Torvalds synchronizecmd = fib_data(cmd_fibcontext); 19531da177e4SLinus Torvalds synchronizecmd->command = cpu_to_le32(VM_ContainerConfig); 19541da177e4SLinus Torvalds synchronizecmd->type = cpu_to_le32(CT_FLUSH_CACHE); 19559e7c349cSMark Haverkamp synchronizecmd->cid = cpu_to_le32(scmd_id(scsicmd)); 19561da177e4SLinus Torvalds synchronizecmd->count = 19571da177e4SLinus Torvalds cpu_to_le32(sizeof(((struct aac_synchronize_reply *)NULL)->data)); 19581da177e4SLinus Torvalds 19591da177e4SLinus Torvalds /* 19601da177e4SLinus Torvalds * Now send the Fib to the adapter 19611da177e4SLinus Torvalds */ 1962bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 19631da177e4SLinus Torvalds cmd_fibcontext, 19641da177e4SLinus Torvalds sizeof(struct aac_synchronize), 19651da177e4SLinus Torvalds FsaNormal, 19661da177e4SLinus Torvalds 0, 1, 19671da177e4SLinus Torvalds (fib_callback)synchronize_callback, 19681da177e4SLinus Torvalds (void *)scsicmd); 19691da177e4SLinus Torvalds 19701da177e4SLinus Torvalds /* 19711da177e4SLinus Torvalds * Check that the command queued to the controller 19721da177e4SLinus Torvalds */ 197377d644d4SMark Haverkamp if (status == -EINPROGRESS) { 197477d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 19751da177e4SLinus Torvalds return 0; 197677d644d4SMark Haverkamp } 19771da177e4SLinus Torvalds 19781da177e4SLinus Torvalds printk(KERN_WARNING 1979bfb35aa8SMark Haverkamp "aac_synchronize: aac_fib_send failed with status: %d.\n", status); 1980bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 1981bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 19821da177e4SLinus Torvalds return SCSI_MLQUEUE_HOST_BUSY; 19831da177e4SLinus Torvalds } 19841da177e4SLinus Torvalds 1985655d722cSMark Salyzyn static void aac_start_stop_callback(void *context, struct fib *fibptr) 1986655d722cSMark Salyzyn { 1987655d722cSMark Salyzyn struct scsi_cmnd *scsicmd = context; 1988655d722cSMark Salyzyn 1989655d722cSMark Salyzyn if (!aac_valid_context(scsicmd, fibptr)) 1990655d722cSMark Salyzyn return; 1991655d722cSMark Salyzyn 1992655d722cSMark Salyzyn BUG_ON(fibptr == NULL); 1993655d722cSMark Salyzyn 1994655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 1995655d722cSMark Salyzyn 1996655d722cSMark Salyzyn aac_fib_complete(fibptr); 1997655d722cSMark Salyzyn aac_fib_free(fibptr); 1998655d722cSMark Salyzyn scsicmd->scsi_done(scsicmd); 1999655d722cSMark Salyzyn } 2000655d722cSMark Salyzyn 2001655d722cSMark Salyzyn static int aac_start_stop(struct scsi_cmnd *scsicmd) 2002655d722cSMark Salyzyn { 2003655d722cSMark Salyzyn int status; 2004655d722cSMark Salyzyn struct fib *cmd_fibcontext; 2005655d722cSMark Salyzyn struct aac_power_management *pmcmd; 2006655d722cSMark Salyzyn struct scsi_device *sdev = scsicmd->device; 2007655d722cSMark Salyzyn struct aac_dev *aac = (struct aac_dev *)sdev->host->hostdata; 2008655d722cSMark Salyzyn 2009655d722cSMark Salyzyn if (!(aac->supplement_adapter_info.SupportedOptions2 & 2010655d722cSMark Salyzyn AAC_OPTION_POWER_MANAGEMENT)) { 2011655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 2012655d722cSMark Salyzyn SAM_STAT_GOOD; 2013655d722cSMark Salyzyn scsicmd->scsi_done(scsicmd); 2014655d722cSMark Salyzyn return 0; 2015655d722cSMark Salyzyn } 2016655d722cSMark Salyzyn 2017655d722cSMark Salyzyn if (aac->in_reset) 2018655d722cSMark Salyzyn return SCSI_MLQUEUE_HOST_BUSY; 2019655d722cSMark Salyzyn 2020655d722cSMark Salyzyn /* 2021655d722cSMark Salyzyn * Allocate and initialize a Fib 2022655d722cSMark Salyzyn */ 2023655d722cSMark Salyzyn cmd_fibcontext = aac_fib_alloc(aac); 2024655d722cSMark Salyzyn if (!cmd_fibcontext) 2025655d722cSMark Salyzyn return SCSI_MLQUEUE_HOST_BUSY; 2026655d722cSMark Salyzyn 2027655d722cSMark Salyzyn aac_fib_init(cmd_fibcontext); 2028655d722cSMark Salyzyn 2029655d722cSMark Salyzyn pmcmd = fib_data(cmd_fibcontext); 2030655d722cSMark Salyzyn pmcmd->command = cpu_to_le32(VM_ContainerConfig); 2031655d722cSMark Salyzyn pmcmd->type = cpu_to_le32(CT_POWER_MANAGEMENT); 2032655d722cSMark Salyzyn /* Eject bit ignored, not relevant */ 2033655d722cSMark Salyzyn pmcmd->sub = (scsicmd->cmnd[4] & 1) ? 2034655d722cSMark Salyzyn cpu_to_le32(CT_PM_START_UNIT) : cpu_to_le32(CT_PM_STOP_UNIT); 2035655d722cSMark Salyzyn pmcmd->cid = cpu_to_le32(sdev_id(sdev)); 2036655d722cSMark Salyzyn pmcmd->parm = (scsicmd->cmnd[1] & 1) ? 2037655d722cSMark Salyzyn cpu_to_le32(CT_PM_UNIT_IMMEDIATE) : 0; 2038655d722cSMark Salyzyn 2039655d722cSMark Salyzyn /* 2040655d722cSMark Salyzyn * Now send the Fib to the adapter 2041655d722cSMark Salyzyn */ 2042655d722cSMark Salyzyn status = aac_fib_send(ContainerCommand, 2043655d722cSMark Salyzyn cmd_fibcontext, 2044655d722cSMark Salyzyn sizeof(struct aac_power_management), 2045655d722cSMark Salyzyn FsaNormal, 2046655d722cSMark Salyzyn 0, 1, 2047655d722cSMark Salyzyn (fib_callback)aac_start_stop_callback, 2048655d722cSMark Salyzyn (void *)scsicmd); 2049655d722cSMark Salyzyn 2050655d722cSMark Salyzyn /* 2051655d722cSMark Salyzyn * Check that the command queued to the controller 2052655d722cSMark Salyzyn */ 2053655d722cSMark Salyzyn if (status == -EINPROGRESS) { 2054655d722cSMark Salyzyn scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 2055655d722cSMark Salyzyn return 0; 2056655d722cSMark Salyzyn } 2057655d722cSMark Salyzyn 2058655d722cSMark Salyzyn aac_fib_complete(cmd_fibcontext); 2059655d722cSMark Salyzyn aac_fib_free(cmd_fibcontext); 2060655d722cSMark Salyzyn return SCSI_MLQUEUE_HOST_BUSY; 2061655d722cSMark Salyzyn } 2062655d722cSMark Salyzyn 20631da177e4SLinus Torvalds /** 20641da177e4SLinus Torvalds * aac_scsi_cmd() - Process SCSI command 20651da177e4SLinus Torvalds * @scsicmd: SCSI command block 20661da177e4SLinus Torvalds * 20671da177e4SLinus Torvalds * Emulate a SCSI command and queue the required request for the 20681da177e4SLinus Torvalds * aacraid firmware. 20691da177e4SLinus Torvalds */ 20701da177e4SLinus Torvalds 20711da177e4SLinus Torvalds int aac_scsi_cmd(struct scsi_cmnd * scsicmd) 20721da177e4SLinus Torvalds { 20731a655040SSalyzyn, Mark u32 cid; 20741da177e4SLinus Torvalds struct Scsi_Host *host = scsicmd->device->host; 20751da177e4SLinus Torvalds struct aac_dev *dev = (struct aac_dev *)host->hostdata; 20761da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr = dev->fsa_dev; 20771da177e4SLinus Torvalds 207890ee3466SMark Haverkamp if (fsa_dev_ptr == NULL) 207990ee3466SMark Haverkamp return -1; 20801da177e4SLinus Torvalds /* 20811da177e4SLinus Torvalds * If the bus, id or lun is out of range, return fail 20821da177e4SLinus Torvalds * Test does not apply to ID 16, the pseudo id for the controller 20831da177e4SLinus Torvalds * itself. 20841da177e4SLinus Torvalds */ 20851a655040SSalyzyn, Mark cid = scmd_id(scsicmd); 20861a655040SSalyzyn, Mark if (cid != host->this_id) { 20871a655040SSalyzyn, Mark if (scmd_channel(scsicmd) == CONTAINER_CHANNEL) { 20881a655040SSalyzyn, Mark if((cid >= dev->maximum_num_containers) || 2089e5718774SMark Haverkamp (scsicmd->device->lun != 0)) { 20901da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16; 20911da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 20921da177e4SLinus Torvalds return 0; 20931da177e4SLinus Torvalds } 20941da177e4SLinus Torvalds 20951da177e4SLinus Torvalds /* 20961da177e4SLinus Torvalds * If the target container doesn't exist, it may have 20971da177e4SLinus Torvalds * been newly created 20981da177e4SLinus Torvalds */ 2099655d722cSMark Salyzyn if (((fsa_dev_ptr[cid].valid & 1) == 0) || 2100655d722cSMark Salyzyn (fsa_dev_ptr[cid].sense_data.sense_key == 2101655d722cSMark Salyzyn NOT_READY)) { 21021da177e4SLinus Torvalds switch (scsicmd->cmnd[0]) { 21037a8cf29dSMark Haverkamp case SERVICE_ACTION_IN: 21047a8cf29dSMark Haverkamp if (!(dev->raw_io_interface) || 21057a8cf29dSMark Haverkamp !(dev->raw_io_64) || 21067a8cf29dSMark Haverkamp ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16)) 21077a8cf29dSMark Haverkamp break; 21081da177e4SLinus Torvalds case INQUIRY: 21091da177e4SLinus Torvalds case READ_CAPACITY: 21101da177e4SLinus Torvalds case TEST_UNIT_READY: 21118c867b25SMark Haverkamp if (dev->in_reset) 21128c867b25SMark Haverkamp return -1; 2113fe76df42SMark Haverkamp return _aac_probe_container(scsicmd, 2114fe76df42SMark Haverkamp aac_probe_container_callback2); 21151da177e4SLinus Torvalds default: 21161da177e4SLinus Torvalds break; 21171da177e4SLinus Torvalds } 21181da177e4SLinus Torvalds } 21191da177e4SLinus Torvalds } else { /* check for physical non-dasd devices */ 2120cb1042f2SSalyzyn, Mark if (dev->nondasd_support || expose_physicals || 2121cb1042f2SSalyzyn, Mark dev->jbod) { 21228c867b25SMark Haverkamp if (dev->in_reset) 21238c867b25SMark Haverkamp return -1; 21241da177e4SLinus Torvalds return aac_send_srb_fib(scsicmd); 21251da177e4SLinus Torvalds } else { 21261da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16; 21271da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 21281da177e4SLinus Torvalds return 0; 21291da177e4SLinus Torvalds } 21301da177e4SLinus Torvalds } 21311da177e4SLinus Torvalds } 21321da177e4SLinus Torvalds /* 21331da177e4SLinus Torvalds * else Command for the controller itself 21341da177e4SLinus Torvalds */ 21351da177e4SLinus Torvalds else if ((scsicmd->cmnd[0] != INQUIRY) && /* only INQUIRY & TUR cmnd supported for controller */ 21361da177e4SLinus Torvalds (scsicmd->cmnd[0] != TEST_UNIT_READY)) 21371da177e4SLinus Torvalds { 21381da177e4SLinus Torvalds dprintk((KERN_WARNING "Only INQUIRY & TUR command supported for controller, rcvd = 0x%x.\n", scsicmd->cmnd[0])); 21391da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 21408e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 21418e31e607SSalyzyn, Mark ILLEGAL_REQUEST, SENCODE_INVALID_COMMAND, 21428e31e607SSalyzyn, Mark ASENCODE_INVALID_COMMAND, 0, 0); 21431da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 21443ace426fSSalyzyn, Mark min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 21453ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE)); 21461da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 21471da177e4SLinus Torvalds return 0; 21481da177e4SLinus Torvalds } 21491da177e4SLinus Torvalds 21501da177e4SLinus Torvalds 21511da177e4SLinus Torvalds /* Handle commands here that don't really require going out to the adapter */ 21521da177e4SLinus Torvalds switch (scsicmd->cmnd[0]) { 21531da177e4SLinus Torvalds case INQUIRY: 21541da177e4SLinus Torvalds { 21553b2946ccSMark Haverkamp struct inquiry_data inq_data; 21561da177e4SLinus Torvalds 21571a655040SSalyzyn, Mark dprintk((KERN_DEBUG "INQUIRY command, ID: %d.\n", cid)); 21583b2946ccSMark Haverkamp memset(&inq_data, 0, sizeof (struct inquiry_data)); 21591da177e4SLinus Torvalds 2160d8e96507SLeubner, Achim if ((scsicmd->cmnd[1] & 0x1) && aac_wwn) { 216188e2f98eSSalyzyn, Mark char *arr = (char *)&inq_data; 216288e2f98eSSalyzyn, Mark 216388e2f98eSSalyzyn, Mark /* EVPD bit set */ 216488e2f98eSSalyzyn, Mark arr[0] = (scmd_id(scsicmd) == host->this_id) ? 216588e2f98eSSalyzyn, Mark INQD_PDT_PROC : INQD_PDT_DA; 216688e2f98eSSalyzyn, Mark if (scsicmd->cmnd[2] == 0) { 216788e2f98eSSalyzyn, Mark /* supported vital product data pages */ 216888e2f98eSSalyzyn, Mark arr[3] = 2; 216988e2f98eSSalyzyn, Mark arr[4] = 0x0; 217088e2f98eSSalyzyn, Mark arr[5] = 0x80; 217188e2f98eSSalyzyn, Mark arr[1] = scsicmd->cmnd[2]; 2172d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, &inq_data, 217388e2f98eSSalyzyn, Mark sizeof(inq_data)); 217488e2f98eSSalyzyn, Mark scsicmd->result = DID_OK << 16 | 217588e2f98eSSalyzyn, Mark COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 217688e2f98eSSalyzyn, Mark } else if (scsicmd->cmnd[2] == 0x80) { 217788e2f98eSSalyzyn, Mark /* unit serial number page */ 217888e2f98eSSalyzyn, Mark arr[3] = setinqserial(dev, &arr[4], 217988e2f98eSSalyzyn, Mark scmd_id(scsicmd)); 218088e2f98eSSalyzyn, Mark arr[1] = scsicmd->cmnd[2]; 2181d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, &inq_data, 218288e2f98eSSalyzyn, Mark sizeof(inq_data)); 2183d8e96507SLeubner, Achim if (aac_wwn != 2) 2184d8e96507SLeubner, Achim return aac_get_container_serial( 2185d8e96507SLeubner, Achim scsicmd); 2186d8e96507SLeubner, Achim /* SLES 10 SP1 special */ 2187d8e96507SLeubner, Achim scsicmd->result = DID_OK << 16 | 2188d8e96507SLeubner, Achim COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 218988e2f98eSSalyzyn, Mark } else { 219088e2f98eSSalyzyn, Mark /* vpd page not implemented */ 219188e2f98eSSalyzyn, Mark scsicmd->result = DID_OK << 16 | 219288e2f98eSSalyzyn, Mark COMMAND_COMPLETE << 8 | 219388e2f98eSSalyzyn, Mark SAM_STAT_CHECK_CONDITION; 21948e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 21958e31e607SSalyzyn, Mark ILLEGAL_REQUEST, SENCODE_INVALID_CDB_FIELD, 21968e31e607SSalyzyn, Mark ASENCODE_NO_SENSE, 7, 2); 219788e2f98eSSalyzyn, Mark memcpy(scsicmd->sense_buffer, 219888e2f98eSSalyzyn, Mark &dev->fsa_dev[cid].sense_data, 21993ace426fSSalyzyn, Mark min_t(size_t, 22003ace426fSSalyzyn, Mark sizeof(dev->fsa_dev[cid].sense_data), 22013ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE)); 220288e2f98eSSalyzyn, Mark } 220388e2f98eSSalyzyn, Mark scsicmd->scsi_done(scsicmd); 220488e2f98eSSalyzyn, Mark return 0; 220588e2f98eSSalyzyn, Mark } 22063b2946ccSMark Haverkamp inq_data.inqd_ver = 2; /* claim compliance to SCSI-2 */ 22073b2946ccSMark Haverkamp inq_data.inqd_rdf = 2; /* A response data format value of two indicates that the data shall be in the format specified in SCSI-2 */ 22083b2946ccSMark Haverkamp inq_data.inqd_len = 31; 22091da177e4SLinus Torvalds /*Format for "pad2" is RelAdr | WBus32 | WBus16 | Sync | Linked |Reserved| CmdQue | SftRe */ 22103b2946ccSMark Haverkamp inq_data.inqd_pad2= 0x32 ; /*WBus16|Sync|CmdQue */ 22111da177e4SLinus Torvalds /* 22121da177e4SLinus Torvalds * Set the Vendor, Product, and Revision Level 22131da177e4SLinus Torvalds * see: <vendor>.c i.e. aac.c 22141da177e4SLinus Torvalds */ 22151a655040SSalyzyn, Mark if (cid == host->this_id) { 22166391a113STobias Klauser setinqstr(dev, (void *) (inq_data.inqd_vid), ARRAY_SIZE(container_types)); 22173b2946ccSMark Haverkamp inq_data.inqd_pdt = INQD_PDT_PROC; /* Processor device */ 2218d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, &inq_data, 2219d4345028SFUJITA Tomonori sizeof(inq_data)); 22201da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 22211da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 22221da177e4SLinus Torvalds return 0; 22231da177e4SLinus Torvalds } 22248c867b25SMark Haverkamp if (dev->in_reset) 22258c867b25SMark Haverkamp return -1; 2226794d0601SMark Haverkamp setinqstr(dev, (void *) (inq_data.inqd_vid), fsa_dev_ptr[cid].type); 22273b2946ccSMark Haverkamp inq_data.inqd_pdt = INQD_PDT_DA; /* Direct/random access device */ 2228d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, &inq_data, sizeof(inq_data)); 22299e7c349cSMark Haverkamp return aac_get_container_name(scsicmd); 22301da177e4SLinus Torvalds } 22317a8cf29dSMark Haverkamp case SERVICE_ACTION_IN: 22327a8cf29dSMark Haverkamp if (!(dev->raw_io_interface) || 22337a8cf29dSMark Haverkamp !(dev->raw_io_64) || 22347a8cf29dSMark Haverkamp ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16)) 22357a8cf29dSMark Haverkamp break; 22367a8cf29dSMark Haverkamp { 22377a8cf29dSMark Haverkamp u64 capacity; 223807ce5ebaSMark Haverkamp char cp[13]; 2239b271f1c8SFUJITA Tomonori unsigned int alloc_len; 22407a8cf29dSMark Haverkamp 22417a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "READ CAPACITY_16 command.\n")); 22427a8cf29dSMark Haverkamp capacity = fsa_dev_ptr[cid].size - 1; 22437a8cf29dSMark Haverkamp cp[0] = (capacity >> 56) & 0xff; 22447a8cf29dSMark Haverkamp cp[1] = (capacity >> 48) & 0xff; 22457a8cf29dSMark Haverkamp cp[2] = (capacity >> 40) & 0xff; 22467a8cf29dSMark Haverkamp cp[3] = (capacity >> 32) & 0xff; 22477a8cf29dSMark Haverkamp cp[4] = (capacity >> 24) & 0xff; 22487a8cf29dSMark Haverkamp cp[5] = (capacity >> 16) & 0xff; 22497a8cf29dSMark Haverkamp cp[6] = (capacity >> 8) & 0xff; 22507a8cf29dSMark Haverkamp cp[7] = (capacity >> 0) & 0xff; 22517a8cf29dSMark Haverkamp cp[8] = 0; 22527a8cf29dSMark Haverkamp cp[9] = 0; 22537a8cf29dSMark Haverkamp cp[10] = 2; 22547a8cf29dSMark Haverkamp cp[11] = 0; 225507ce5ebaSMark Haverkamp cp[12] = 0; 225607ce5ebaSMark Haverkamp 2257b271f1c8SFUJITA Tomonori alloc_len = ((scsicmd->cmnd[10] << 24) 2258b271f1c8SFUJITA Tomonori + (scsicmd->cmnd[11] << 16) 2259b271f1c8SFUJITA Tomonori + (scsicmd->cmnd[12] << 8) + scsicmd->cmnd[13]); 2260b271f1c8SFUJITA Tomonori 2261b271f1c8SFUJITA Tomonori alloc_len = min_t(size_t, alloc_len, sizeof(cp)); 2262d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, cp, alloc_len); 2263b271f1c8SFUJITA Tomonori if (alloc_len < scsi_bufflen(scsicmd)) 2264b271f1c8SFUJITA Tomonori scsi_set_resid(scsicmd, 2265b271f1c8SFUJITA Tomonori scsi_bufflen(scsicmd) - alloc_len); 22667a8cf29dSMark Haverkamp 22677a8cf29dSMark Haverkamp /* Do not cache partition table for arrays */ 22687a8cf29dSMark Haverkamp scsicmd->device->removable = 1; 22697a8cf29dSMark Haverkamp 22707a8cf29dSMark Haverkamp scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 22717a8cf29dSMark Haverkamp scsicmd->scsi_done(scsicmd); 22727a8cf29dSMark Haverkamp 22737a8cf29dSMark Haverkamp return 0; 22747a8cf29dSMark Haverkamp } 22757a8cf29dSMark Haverkamp 22761da177e4SLinus Torvalds case READ_CAPACITY: 22771da177e4SLinus Torvalds { 22781da177e4SLinus Torvalds u32 capacity; 22793b2946ccSMark Haverkamp char cp[8]; 22801da177e4SLinus Torvalds 22811da177e4SLinus Torvalds dprintk((KERN_DEBUG "READ CAPACITY command.\n")); 22827a8cf29dSMark Haverkamp if (fsa_dev_ptr[cid].size <= 0x100000000ULL) 22831da177e4SLinus Torvalds capacity = fsa_dev_ptr[cid].size - 1; 22841da177e4SLinus Torvalds else 22851da177e4SLinus Torvalds capacity = (u32)-1; 22863b2946ccSMark Haverkamp 22871da177e4SLinus Torvalds cp[0] = (capacity >> 24) & 0xff; 22881da177e4SLinus Torvalds cp[1] = (capacity >> 16) & 0xff; 22891da177e4SLinus Torvalds cp[2] = (capacity >> 8) & 0xff; 22901da177e4SLinus Torvalds cp[3] = (capacity >> 0) & 0xff; 22911da177e4SLinus Torvalds cp[4] = 0; 22921da177e4SLinus Torvalds cp[5] = 0; 22931da177e4SLinus Torvalds cp[6] = 2; 22941da177e4SLinus Torvalds cp[7] = 0; 2295d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, cp, sizeof(cp)); 22967a8cf29dSMark Haverkamp /* Do not cache partition table for arrays */ 22977a8cf29dSMark Haverkamp scsicmd->device->removable = 1; 2298655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 2299655d722cSMark Salyzyn SAM_STAT_GOOD; 23001da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 23011da177e4SLinus Torvalds 23021da177e4SLinus Torvalds return 0; 23031da177e4SLinus Torvalds } 23041da177e4SLinus Torvalds 23051da177e4SLinus Torvalds case MODE_SENSE: 23061da177e4SLinus Torvalds { 23079d399cc7SSalyzyn, Mark char mode_buf[7]; 23089d399cc7SSalyzyn, Mark int mode_buf_length = 4; 23091da177e4SLinus Torvalds 23101da177e4SLinus Torvalds dprintk((KERN_DEBUG "MODE SENSE command.\n")); 23111da177e4SLinus Torvalds mode_buf[0] = 3; /* Mode data length */ 23121da177e4SLinus Torvalds mode_buf[1] = 0; /* Medium type - default */ 23139d399cc7SSalyzyn, Mark mode_buf[2] = 0; /* Device-specific param, 23149d399cc7SSalyzyn, Mark bit 8: 0/1 = write enabled/protected 23159d399cc7SSalyzyn, Mark bit 4: 0/1 = FUA enabled */ 231695e852e1SSalyzyn, Mark if (dev->raw_io_interface && ((aac_cache & 5) != 1)) 23179d399cc7SSalyzyn, Mark mode_buf[2] = 0x10; 23181da177e4SLinus Torvalds mode_buf[3] = 0; /* Block descriptor length */ 23199d399cc7SSalyzyn, Mark if (((scsicmd->cmnd[2] & 0x3f) == 8) || 23209d399cc7SSalyzyn, Mark ((scsicmd->cmnd[2] & 0x3f) == 0x3f)) { 23219d399cc7SSalyzyn, Mark mode_buf[0] = 6; 23229d399cc7SSalyzyn, Mark mode_buf[4] = 8; 23239d399cc7SSalyzyn, Mark mode_buf[5] = 1; 232495e852e1SSalyzyn, Mark mode_buf[6] = ((aac_cache & 6) == 2) 232595e852e1SSalyzyn, Mark ? 0 : 0x04; /* WCE */ 23269d399cc7SSalyzyn, Mark mode_buf_length = 7; 23279d399cc7SSalyzyn, Mark if (mode_buf_length > scsicmd->cmnd[4]) 23289d399cc7SSalyzyn, Mark mode_buf_length = scsicmd->cmnd[4]; 23299d399cc7SSalyzyn, Mark } 2330d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, mode_buf, mode_buf_length); 23311da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 23321da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 23331da177e4SLinus Torvalds 23341da177e4SLinus Torvalds return 0; 23351da177e4SLinus Torvalds } 23361da177e4SLinus Torvalds case MODE_SENSE_10: 23371da177e4SLinus Torvalds { 23389d399cc7SSalyzyn, Mark char mode_buf[11]; 23399d399cc7SSalyzyn, Mark int mode_buf_length = 8; 23401da177e4SLinus Torvalds 23411da177e4SLinus Torvalds dprintk((KERN_DEBUG "MODE SENSE 10 byte command.\n")); 23421da177e4SLinus Torvalds mode_buf[0] = 0; /* Mode data length (MSB) */ 23431da177e4SLinus Torvalds mode_buf[1] = 6; /* Mode data length (LSB) */ 23441da177e4SLinus Torvalds mode_buf[2] = 0; /* Medium type - default */ 23459d399cc7SSalyzyn, Mark mode_buf[3] = 0; /* Device-specific param, 23469d399cc7SSalyzyn, Mark bit 8: 0/1 = write enabled/protected 23479d399cc7SSalyzyn, Mark bit 4: 0/1 = FUA enabled */ 234895e852e1SSalyzyn, Mark if (dev->raw_io_interface && ((aac_cache & 5) != 1)) 23499d399cc7SSalyzyn, Mark mode_buf[3] = 0x10; 23501da177e4SLinus Torvalds mode_buf[4] = 0; /* reserved */ 23511da177e4SLinus Torvalds mode_buf[5] = 0; /* reserved */ 23521da177e4SLinus Torvalds mode_buf[6] = 0; /* Block descriptor length (MSB) */ 23531da177e4SLinus Torvalds mode_buf[7] = 0; /* Block descriptor length (LSB) */ 23549d399cc7SSalyzyn, Mark if (((scsicmd->cmnd[2] & 0x3f) == 8) || 23559d399cc7SSalyzyn, Mark ((scsicmd->cmnd[2] & 0x3f) == 0x3f)) { 23569d399cc7SSalyzyn, Mark mode_buf[1] = 9; 23579d399cc7SSalyzyn, Mark mode_buf[8] = 8; 23589d399cc7SSalyzyn, Mark mode_buf[9] = 1; 235995e852e1SSalyzyn, Mark mode_buf[10] = ((aac_cache & 6) == 2) 236095e852e1SSalyzyn, Mark ? 0 : 0x04; /* WCE */ 23619d399cc7SSalyzyn, Mark mode_buf_length = 11; 23629d399cc7SSalyzyn, Mark if (mode_buf_length > scsicmd->cmnd[8]) 23639d399cc7SSalyzyn, Mark mode_buf_length = scsicmd->cmnd[8]; 23649d399cc7SSalyzyn, Mark } 2365d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, mode_buf, mode_buf_length); 23661da177e4SLinus Torvalds 23671da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 23681da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 23691da177e4SLinus Torvalds 23701da177e4SLinus Torvalds return 0; 23711da177e4SLinus Torvalds } 23721da177e4SLinus Torvalds case REQUEST_SENSE: 23731da177e4SLinus Torvalds dprintk((KERN_DEBUG "REQUEST SENSE command.\n")); 23741da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, sizeof (struct sense_data)); 23751da177e4SLinus Torvalds memset(&dev->fsa_dev[cid].sense_data, 0, sizeof (struct sense_data)); 23761da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 23771da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 23781da177e4SLinus Torvalds return 0; 23791da177e4SLinus Torvalds 23801da177e4SLinus Torvalds case ALLOW_MEDIUM_REMOVAL: 23811da177e4SLinus Torvalds dprintk((KERN_DEBUG "LOCK command.\n")); 23821da177e4SLinus Torvalds if (scsicmd->cmnd[4]) 23831da177e4SLinus Torvalds fsa_dev_ptr[cid].locked = 1; 23841da177e4SLinus Torvalds else 23851da177e4SLinus Torvalds fsa_dev_ptr[cid].locked = 0; 23861da177e4SLinus Torvalds 23871da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 23881da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 23891da177e4SLinus Torvalds return 0; 23901da177e4SLinus Torvalds /* 23911da177e4SLinus Torvalds * These commands are all No-Ops 23921da177e4SLinus Torvalds */ 23931da177e4SLinus Torvalds case TEST_UNIT_READY: 2394655d722cSMark Salyzyn if (fsa_dev_ptr[cid].sense_data.sense_key == NOT_READY) { 2395655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 2396655d722cSMark Salyzyn SAM_STAT_CHECK_CONDITION; 2397655d722cSMark Salyzyn set_sense(&dev->fsa_dev[cid].sense_data, 2398655d722cSMark Salyzyn NOT_READY, SENCODE_BECOMING_READY, 2399655d722cSMark Salyzyn ASENCODE_BECOMING_READY, 0, 0); 2400655d722cSMark Salyzyn memcpy(scsicmd->sense_buffer, 2401655d722cSMark Salyzyn &dev->fsa_dev[cid].sense_data, 2402655d722cSMark Salyzyn min_t(size_t, 2403655d722cSMark Salyzyn sizeof(dev->fsa_dev[cid].sense_data), 2404655d722cSMark Salyzyn SCSI_SENSE_BUFFERSIZE)); 2405655d722cSMark Salyzyn scsicmd->scsi_done(scsicmd); 2406655d722cSMark Salyzyn return 0; 2407655d722cSMark Salyzyn } 2408655d722cSMark Salyzyn /* FALLTHRU */ 24091da177e4SLinus Torvalds case RESERVE: 24101da177e4SLinus Torvalds case RELEASE: 24111da177e4SLinus Torvalds case REZERO_UNIT: 24121da177e4SLinus Torvalds case REASSIGN_BLOCKS: 24131da177e4SLinus Torvalds case SEEK_10: 24141da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 24151da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 24161da177e4SLinus Torvalds return 0; 2417655d722cSMark Salyzyn 2418655d722cSMark Salyzyn case START_STOP: 2419655d722cSMark Salyzyn return aac_start_stop(scsicmd); 24201da177e4SLinus Torvalds } 24211da177e4SLinus Torvalds 24221da177e4SLinus Torvalds switch (scsicmd->cmnd[0]) 24231da177e4SLinus Torvalds { 24241da177e4SLinus Torvalds case READ_6: 24251da177e4SLinus Torvalds case READ_10: 24267a8cf29dSMark Haverkamp case READ_12: 24277a8cf29dSMark Haverkamp case READ_16: 24288c867b25SMark Haverkamp if (dev->in_reset) 24298c867b25SMark Haverkamp return -1; 24301da177e4SLinus Torvalds /* 24311da177e4SLinus Torvalds * Hack to keep track of ordinal number of the device that 24321da177e4SLinus Torvalds * corresponds to a container. Needed to convert 24331da177e4SLinus Torvalds * containers to /dev/sd device names 24341da177e4SLinus Torvalds */ 24351da177e4SLinus Torvalds 24361da177e4SLinus Torvalds if (scsicmd->request->rq_disk) 24377a8cf29dSMark Haverkamp strlcpy(fsa_dev_ptr[cid].devname, 24381da177e4SLinus Torvalds scsicmd->request->rq_disk->disk_name, 24397a8cf29dSMark Haverkamp min(sizeof(fsa_dev_ptr[cid].devname), 24407a8cf29dSMark Haverkamp sizeof(scsicmd->request->rq_disk->disk_name) + 1)); 244177d644d4SMark Haverkamp 24429e7c349cSMark Haverkamp return aac_read(scsicmd); 24431da177e4SLinus Torvalds 24441da177e4SLinus Torvalds case WRITE_6: 24451da177e4SLinus Torvalds case WRITE_10: 24467a8cf29dSMark Haverkamp case WRITE_12: 24477a8cf29dSMark Haverkamp case WRITE_16: 24488c867b25SMark Haverkamp if (dev->in_reset) 24498c867b25SMark Haverkamp return -1; 24509e7c349cSMark Haverkamp return aac_write(scsicmd); 24511da177e4SLinus Torvalds 24521da177e4SLinus Torvalds case SYNCHRONIZE_CACHE: 245395e852e1SSalyzyn, Mark if (((aac_cache & 6) == 6) && dev->cache_protected) { 245495e852e1SSalyzyn, Mark scsicmd->result = DID_OK << 16 | 245595e852e1SSalyzyn, Mark COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 245695e852e1SSalyzyn, Mark scsicmd->scsi_done(scsicmd); 245795e852e1SSalyzyn, Mark return 0; 245895e852e1SSalyzyn, Mark } 24591da177e4SLinus Torvalds /* Issue FIB to tell Firmware to flush it's cache */ 246095e852e1SSalyzyn, Mark if ((aac_cache & 6) != 2) 24619e7c349cSMark Haverkamp return aac_synchronize(scsicmd); 246295e852e1SSalyzyn, Mark /* FALLTHRU */ 24631da177e4SLinus Torvalds default: 24641da177e4SLinus Torvalds /* 24651da177e4SLinus Torvalds * Unhandled commands 24661da177e4SLinus Torvalds */ 24677c00ffa3SMark Haverkamp dprintk((KERN_WARNING "Unhandled SCSI Command: 0x%x.\n", scsicmd->cmnd[0])); 24681da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 24698e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 24701da177e4SLinus Torvalds ILLEGAL_REQUEST, SENCODE_INVALID_COMMAND, 24718e31e607SSalyzyn, Mark ASENCODE_INVALID_COMMAND, 0, 0); 24721da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 24733ace426fSSalyzyn, Mark min_t(size_t, 24743ace426fSSalyzyn, Mark sizeof(dev->fsa_dev[cid].sense_data), 24753ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE)); 24761da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 24771da177e4SLinus Torvalds return 0; 24781da177e4SLinus Torvalds } 24791da177e4SLinus Torvalds } 24801da177e4SLinus Torvalds 24811da177e4SLinus Torvalds static int query_disk(struct aac_dev *dev, void __user *arg) 24821da177e4SLinus Torvalds { 24831da177e4SLinus Torvalds struct aac_query_disk qd; 24841da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 24851da177e4SLinus Torvalds 24861da177e4SLinus Torvalds fsa_dev_ptr = dev->fsa_dev; 248790ee3466SMark Haverkamp if (!fsa_dev_ptr) 248865101355SMark Haverkamp return -EBUSY; 24891da177e4SLinus Torvalds if (copy_from_user(&qd, arg, sizeof (struct aac_query_disk))) 24901da177e4SLinus Torvalds return -EFAULT; 24911da177e4SLinus Torvalds if (qd.cnum == -1) 2492e5718774SMark Haverkamp qd.cnum = qd.id; 24931da177e4SLinus Torvalds else if ((qd.bus == -1) && (qd.id == -1) && (qd.lun == -1)) 24941da177e4SLinus Torvalds { 24951da177e4SLinus Torvalds if (qd.cnum < 0 || qd.cnum >= dev->maximum_num_containers) 24961da177e4SLinus Torvalds return -EINVAL; 24971da177e4SLinus Torvalds qd.instance = dev->scsi_host_ptr->host_no; 24981da177e4SLinus Torvalds qd.bus = 0; 24991da177e4SLinus Torvalds qd.id = CONTAINER_TO_ID(qd.cnum); 25001da177e4SLinus Torvalds qd.lun = CONTAINER_TO_LUN(qd.cnum); 25011da177e4SLinus Torvalds } 25021da177e4SLinus Torvalds else return -EINVAL; 25031da177e4SLinus Torvalds 2504fd622b1bSSalyzyn, Mark qd.valid = fsa_dev_ptr[qd.cnum].valid != 0; 25051da177e4SLinus Torvalds qd.locked = fsa_dev_ptr[qd.cnum].locked; 25061da177e4SLinus Torvalds qd.deleted = fsa_dev_ptr[qd.cnum].deleted; 25071da177e4SLinus Torvalds 25081da177e4SLinus Torvalds if (fsa_dev_ptr[qd.cnum].devname[0] == '\0') 25091da177e4SLinus Torvalds qd.unmapped = 1; 25101da177e4SLinus Torvalds else 25111da177e4SLinus Torvalds qd.unmapped = 0; 25121da177e4SLinus Torvalds 25131da177e4SLinus Torvalds strlcpy(qd.name, fsa_dev_ptr[qd.cnum].devname, 25141da177e4SLinus Torvalds min(sizeof(qd.name), sizeof(fsa_dev_ptr[qd.cnum].devname) + 1)); 25151da177e4SLinus Torvalds 25161da177e4SLinus Torvalds if (copy_to_user(arg, &qd, sizeof (struct aac_query_disk))) 25171da177e4SLinus Torvalds return -EFAULT; 25181da177e4SLinus Torvalds return 0; 25191da177e4SLinus Torvalds } 25201da177e4SLinus Torvalds 25211da177e4SLinus Torvalds static int force_delete_disk(struct aac_dev *dev, void __user *arg) 25221da177e4SLinus Torvalds { 25231da177e4SLinus Torvalds struct aac_delete_disk dd; 25241da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 25251da177e4SLinus Torvalds 25261da177e4SLinus Torvalds fsa_dev_ptr = dev->fsa_dev; 252765101355SMark Haverkamp if (!fsa_dev_ptr) 252865101355SMark Haverkamp return -EBUSY; 25291da177e4SLinus Torvalds 25301da177e4SLinus Torvalds if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk))) 25311da177e4SLinus Torvalds return -EFAULT; 25321da177e4SLinus Torvalds 25331da177e4SLinus Torvalds if (dd.cnum >= dev->maximum_num_containers) 25341da177e4SLinus Torvalds return -EINVAL; 25351da177e4SLinus Torvalds /* 25361da177e4SLinus Torvalds * Mark this container as being deleted. 25371da177e4SLinus Torvalds */ 25381da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].deleted = 1; 25391da177e4SLinus Torvalds /* 25401da177e4SLinus Torvalds * Mark the container as no longer valid 25411da177e4SLinus Torvalds */ 25421da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].valid = 0; 25431da177e4SLinus Torvalds return 0; 25441da177e4SLinus Torvalds } 25451da177e4SLinus Torvalds 25461da177e4SLinus Torvalds static int delete_disk(struct aac_dev *dev, void __user *arg) 25471da177e4SLinus Torvalds { 25481da177e4SLinus Torvalds struct aac_delete_disk dd; 25491da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 25501da177e4SLinus Torvalds 25511da177e4SLinus Torvalds fsa_dev_ptr = dev->fsa_dev; 255290ee3466SMark Haverkamp if (!fsa_dev_ptr) 255365101355SMark Haverkamp return -EBUSY; 25541da177e4SLinus Torvalds 25551da177e4SLinus Torvalds if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk))) 25561da177e4SLinus Torvalds return -EFAULT; 25571da177e4SLinus Torvalds 25581da177e4SLinus Torvalds if (dd.cnum >= dev->maximum_num_containers) 25591da177e4SLinus Torvalds return -EINVAL; 25601da177e4SLinus Torvalds /* 25611da177e4SLinus Torvalds * If the container is locked, it can not be deleted by the API. 25621da177e4SLinus Torvalds */ 25631da177e4SLinus Torvalds if (fsa_dev_ptr[dd.cnum].locked) 25641da177e4SLinus Torvalds return -EBUSY; 25651da177e4SLinus Torvalds else { 25661da177e4SLinus Torvalds /* 25671da177e4SLinus Torvalds * Mark the container as no longer being valid. 25681da177e4SLinus Torvalds */ 25691da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].valid = 0; 25701da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].devname[0] = '\0'; 25711da177e4SLinus Torvalds return 0; 25721da177e4SLinus Torvalds } 25731da177e4SLinus Torvalds } 25741da177e4SLinus Torvalds 25751da177e4SLinus Torvalds int aac_dev_ioctl(struct aac_dev *dev, int cmd, void __user *arg) 25761da177e4SLinus Torvalds { 25771da177e4SLinus Torvalds switch (cmd) { 25781da177e4SLinus Torvalds case FSACTL_QUERY_DISK: 25791da177e4SLinus Torvalds return query_disk(dev, arg); 25801da177e4SLinus Torvalds case FSACTL_DELETE_DISK: 25811da177e4SLinus Torvalds return delete_disk(dev, arg); 25821da177e4SLinus Torvalds case FSACTL_FORCE_DELETE_DISK: 25831da177e4SLinus Torvalds return force_delete_disk(dev, arg); 25841da177e4SLinus Torvalds case FSACTL_GET_CONTAINERS: 25851da177e4SLinus Torvalds return aac_get_containers(dev); 25861da177e4SLinus Torvalds default: 25871da177e4SLinus Torvalds return -ENOTTY; 25881da177e4SLinus Torvalds } 25891da177e4SLinus Torvalds } 25901da177e4SLinus Torvalds 25911da177e4SLinus Torvalds /** 25921da177e4SLinus Torvalds * 25931da177e4SLinus Torvalds * aac_srb_callback 25941da177e4SLinus Torvalds * @context: the context set in the fib - here it is scsi cmd 25951da177e4SLinus Torvalds * @fibptr: pointer to the fib 25961da177e4SLinus Torvalds * 25971da177e4SLinus Torvalds * Handles the completion of a scsi command to a non dasd device 25981da177e4SLinus Torvalds * 25991da177e4SLinus Torvalds */ 26001da177e4SLinus Torvalds 26011da177e4SLinus Torvalds static void aac_srb_callback(void *context, struct fib * fibptr) 26021da177e4SLinus Torvalds { 26031da177e4SLinus Torvalds struct aac_dev *dev; 26041da177e4SLinus Torvalds struct aac_srb_reply *srbreply; 26051da177e4SLinus Torvalds struct scsi_cmnd *scsicmd; 26061da177e4SLinus Torvalds 26071da177e4SLinus Torvalds scsicmd = (struct scsi_cmnd *) context; 260803d44337SMark Haverkamp 260903d44337SMark Haverkamp if (!aac_valid_context(scsicmd, fibptr)) 261003d44337SMark Haverkamp return; 261103d44337SMark Haverkamp 2612125e1874SEric Sesterhenn BUG_ON(fibptr == NULL); 26131da177e4SLinus Torvalds 26141a655040SSalyzyn, Mark dev = fibptr->dev; 26151a655040SSalyzyn, Mark 26161da177e4SLinus Torvalds srbreply = (struct aac_srb_reply *) fib_data(fibptr); 26171da177e4SLinus Torvalds 26181da177e4SLinus Torvalds scsicmd->sense_buffer[0] = '\0'; /* Initialize sense valid flag to false */ 26191da177e4SLinus Torvalds /* 26201da177e4SLinus Torvalds * Calculate resid for sg 26211da177e4SLinus Torvalds */ 26221da177e4SLinus Torvalds 2623727eead6SFUJITA Tomonori scsi_set_resid(scsicmd, scsi_bufflen(scsicmd) 2624727eead6SFUJITA Tomonori - le32_to_cpu(srbreply->data_xfer_length)); 26251da177e4SLinus Torvalds 2626727eead6SFUJITA Tomonori scsi_dma_unmap(scsicmd); 26271da177e4SLinus Torvalds 2628e3cc268fSRajashekhara, Mahesh /* expose physical device if expose_physicald flag is on */ 2629e3cc268fSRajashekhara, Mahesh if (scsicmd->cmnd[0] == INQUIRY && !(scsicmd->cmnd[1] & 0x01) 2630e3cc268fSRajashekhara, Mahesh && expose_physicals > 0) 2631e3cc268fSRajashekhara, Mahesh aac_expose_phy_device(scsicmd); 2632e3cc268fSRajashekhara, Mahesh 26331da177e4SLinus Torvalds /* 26341da177e4SLinus Torvalds * First check the fib status 26351da177e4SLinus Torvalds */ 26361da177e4SLinus Torvalds 26371da177e4SLinus Torvalds if (le32_to_cpu(srbreply->status) != ST_OK){ 26381da177e4SLinus Torvalds int len; 26391da177e4SLinus Torvalds printk(KERN_WARNING "aac_srb_callback: srb failed, status = %d\n", le32_to_cpu(srbreply->status)); 26403ace426fSSalyzyn, Mark len = min_t(u32, le32_to_cpu(srbreply->sense_data_size), 26413ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE); 26421da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 26431da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, srbreply->sense_data, len); 26441da177e4SLinus Torvalds } 26451da177e4SLinus Torvalds 26461da177e4SLinus Torvalds /* 26471da177e4SLinus Torvalds * Next check the srb status 26481da177e4SLinus Torvalds */ 26491da177e4SLinus Torvalds switch( (le32_to_cpu(srbreply->srb_status))&0x3f){ 26501da177e4SLinus Torvalds case SRB_STATUS_ERROR_RECOVERY: 26511da177e4SLinus Torvalds case SRB_STATUS_PENDING: 26521da177e4SLinus Torvalds case SRB_STATUS_SUCCESS: 26531da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 26541da177e4SLinus Torvalds break; 26551da177e4SLinus Torvalds case SRB_STATUS_DATA_OVERRUN: 26561da177e4SLinus Torvalds switch(scsicmd->cmnd[0]){ 26571da177e4SLinus Torvalds case READ_6: 26581da177e4SLinus Torvalds case WRITE_6: 26591da177e4SLinus Torvalds case READ_10: 26601da177e4SLinus Torvalds case WRITE_10: 26611da177e4SLinus Torvalds case READ_12: 26621da177e4SLinus Torvalds case WRITE_12: 26637a8cf29dSMark Haverkamp case READ_16: 26647a8cf29dSMark Haverkamp case WRITE_16: 26651da177e4SLinus Torvalds if (le32_to_cpu(srbreply->data_xfer_length) < scsicmd->underflow) { 26661da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: SCSI CMD underflow\n"); 26671da177e4SLinus Torvalds } else { 26681da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: SCSI CMD Data Overrun\n"); 26691da177e4SLinus Torvalds } 26701da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8; 26711da177e4SLinus Torvalds break; 26721da177e4SLinus Torvalds case INQUIRY: { 26731da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 26741da177e4SLinus Torvalds break; 26751da177e4SLinus Torvalds } 26761da177e4SLinus Torvalds default: 26771da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 26781da177e4SLinus Torvalds break; 26791da177e4SLinus Torvalds } 26801da177e4SLinus Torvalds break; 26811da177e4SLinus Torvalds case SRB_STATUS_ABORTED: 26821da177e4SLinus Torvalds scsicmd->result = DID_ABORT << 16 | ABORT << 8; 26831da177e4SLinus Torvalds break; 26841da177e4SLinus Torvalds case SRB_STATUS_ABORT_FAILED: 26851da177e4SLinus Torvalds // Not sure about this one - but assuming the hba was trying to abort for some reason 26861da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | ABORT << 8; 26871da177e4SLinus Torvalds break; 26881da177e4SLinus Torvalds case SRB_STATUS_PARITY_ERROR: 26891da177e4SLinus Torvalds scsicmd->result = DID_PARITY << 16 | MSG_PARITY_ERROR << 8; 26901da177e4SLinus Torvalds break; 26911da177e4SLinus Torvalds case SRB_STATUS_NO_DEVICE: 26921da177e4SLinus Torvalds case SRB_STATUS_INVALID_PATH_ID: 26931da177e4SLinus Torvalds case SRB_STATUS_INVALID_TARGET_ID: 26941da177e4SLinus Torvalds case SRB_STATUS_INVALID_LUN: 26951da177e4SLinus Torvalds case SRB_STATUS_SELECTION_TIMEOUT: 26961da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8; 26971da177e4SLinus Torvalds break; 26981da177e4SLinus Torvalds 26991da177e4SLinus Torvalds case SRB_STATUS_COMMAND_TIMEOUT: 27001da177e4SLinus Torvalds case SRB_STATUS_TIMEOUT: 27011da177e4SLinus Torvalds scsicmd->result = DID_TIME_OUT << 16 | COMMAND_COMPLETE << 8; 27021da177e4SLinus Torvalds break; 27031da177e4SLinus Torvalds 27041da177e4SLinus Torvalds case SRB_STATUS_BUSY: 2705760af100SSalyzyn, Mark scsicmd->result = DID_BUS_BUSY << 16 | COMMAND_COMPLETE << 8; 27061da177e4SLinus Torvalds break; 27071da177e4SLinus Torvalds 27081da177e4SLinus Torvalds case SRB_STATUS_BUS_RESET: 27091da177e4SLinus Torvalds scsicmd->result = DID_RESET << 16 | COMMAND_COMPLETE << 8; 27101da177e4SLinus Torvalds break; 27111da177e4SLinus Torvalds 27121da177e4SLinus Torvalds case SRB_STATUS_MESSAGE_REJECTED: 27131da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | MESSAGE_REJECT << 8; 27141da177e4SLinus Torvalds break; 27151da177e4SLinus Torvalds case SRB_STATUS_REQUEST_FLUSHED: 27161da177e4SLinus Torvalds case SRB_STATUS_ERROR: 27171da177e4SLinus Torvalds case SRB_STATUS_INVALID_REQUEST: 27181da177e4SLinus Torvalds case SRB_STATUS_REQUEST_SENSE_FAILED: 27191da177e4SLinus Torvalds case SRB_STATUS_NO_HBA: 27201da177e4SLinus Torvalds case SRB_STATUS_UNEXPECTED_BUS_FREE: 27211da177e4SLinus Torvalds case SRB_STATUS_PHASE_SEQUENCE_FAILURE: 27221da177e4SLinus Torvalds case SRB_STATUS_BAD_SRB_BLOCK_LENGTH: 27231da177e4SLinus Torvalds case SRB_STATUS_DELAYED_RETRY: 27241da177e4SLinus Torvalds case SRB_STATUS_BAD_FUNCTION: 27251da177e4SLinus Torvalds case SRB_STATUS_NOT_STARTED: 27261da177e4SLinus Torvalds case SRB_STATUS_NOT_IN_USE: 27271da177e4SLinus Torvalds case SRB_STATUS_FORCE_ABORT: 27281da177e4SLinus Torvalds case SRB_STATUS_DOMAIN_VALIDATION_FAIL: 27291da177e4SLinus Torvalds default: 27301da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 27311da177e4SLinus Torvalds printk("aacraid: SRB ERROR(%u) %s scsi cmd 0x%x - scsi status 0x%x\n", 27321da177e4SLinus Torvalds le32_to_cpu(srbreply->srb_status) & 0x3F, 27331da177e4SLinus Torvalds aac_get_status_string( 27341da177e4SLinus Torvalds le32_to_cpu(srbreply->srb_status) & 0x3F), 27351da177e4SLinus Torvalds scsicmd->cmnd[0], 27361da177e4SLinus Torvalds le32_to_cpu(srbreply->scsi_status)); 27371da177e4SLinus Torvalds #endif 27381fc8010aSRajashekhara, Mahesh if ((scsicmd->cmnd[0] == ATA_12) 27391fc8010aSRajashekhara, Mahesh || (scsicmd->cmnd[0] == ATA_16)) { 27401fc8010aSRajashekhara, Mahesh if (scsicmd->cmnd[2] & (0x01 << 5)) { 27411fc8010aSRajashekhara, Mahesh scsicmd->result = DID_OK << 16 27421fc8010aSRajashekhara, Mahesh | COMMAND_COMPLETE << 8; 27431da177e4SLinus Torvalds break; 27441fc8010aSRajashekhara, Mahesh } else { 27451fc8010aSRajashekhara, Mahesh scsicmd->result = DID_ERROR << 16 27461fc8010aSRajashekhara, Mahesh | COMMAND_COMPLETE << 8; 27471fc8010aSRajashekhara, Mahesh break; 27481fc8010aSRajashekhara, Mahesh } 27491fc8010aSRajashekhara, Mahesh } else { 27501fc8010aSRajashekhara, Mahesh scsicmd->result = DID_ERROR << 16 27511fc8010aSRajashekhara, Mahesh | COMMAND_COMPLETE << 8; 27521fc8010aSRajashekhara, Mahesh break; 27531fc8010aSRajashekhara, Mahesh } 27541da177e4SLinus Torvalds } 27558ce3eca4SSalyzyn, Mark if (le32_to_cpu(srbreply->scsi_status) == SAM_STAT_CHECK_CONDITION) { 27561da177e4SLinus Torvalds int len; 27571da177e4SLinus Torvalds scsicmd->result |= SAM_STAT_CHECK_CONDITION; 27583ace426fSSalyzyn, Mark len = min_t(u32, le32_to_cpu(srbreply->sense_data_size), 27593ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE); 27601da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 27617a8cf29dSMark Haverkamp printk(KERN_WARNING "aac_srb_callback: check condition, status = %d len=%d\n", 27627a8cf29dSMark Haverkamp le32_to_cpu(srbreply->status), len); 27631da177e4SLinus Torvalds #endif 27641da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, srbreply->sense_data, len); 27651da177e4SLinus Torvalds } 27661da177e4SLinus Torvalds /* 27671da177e4SLinus Torvalds * OR in the scsi status (already shifted up a bit) 27681da177e4SLinus Torvalds */ 27691da177e4SLinus Torvalds scsicmd->result |= le32_to_cpu(srbreply->scsi_status); 27701da177e4SLinus Torvalds 2771bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 2772bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 27738e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 27741da177e4SLinus Torvalds } 27751da177e4SLinus Torvalds 27761da177e4SLinus Torvalds /** 27771da177e4SLinus Torvalds * 27781da177e4SLinus Torvalds * aac_send_scb_fib 27791da177e4SLinus Torvalds * @scsicmd: the scsi command block 27801da177e4SLinus Torvalds * 27811da177e4SLinus Torvalds * This routine will form a FIB and fill in the aac_srb from the 27821da177e4SLinus Torvalds * scsicmd passed in. 27831da177e4SLinus Torvalds */ 27841da177e4SLinus Torvalds 27851da177e4SLinus Torvalds static int aac_send_srb_fib(struct scsi_cmnd* scsicmd) 27861da177e4SLinus Torvalds { 27871da177e4SLinus Torvalds struct fib* cmd_fibcontext; 27881da177e4SLinus Torvalds struct aac_dev* dev; 27891da177e4SLinus Torvalds int status; 27901da177e4SLinus Torvalds 279184971738SMark Haverkamp dev = (struct aac_dev *)scsicmd->device->host->hostdata; 2792e5718774SMark Haverkamp if (scmd_id(scsicmd) >= dev->maximum_num_physicals || 279384971738SMark Haverkamp scsicmd->device->lun > 7) { 27941da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16; 27951da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 27961da177e4SLinus Torvalds return 0; 27971da177e4SLinus Torvalds } 27981da177e4SLinus Torvalds 27991da177e4SLinus Torvalds /* 28001da177e4SLinus Torvalds * Allocate and initialize a Fib then setup a BlockWrite command 28011da177e4SLinus Torvalds */ 2802bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) { 28031da177e4SLinus Torvalds return -1; 28041da177e4SLinus Torvalds } 2805e8f32de5SMark Haverkamp status = aac_adapter_scsi(cmd_fibcontext, scsicmd); 28061da177e4SLinus Torvalds 28071da177e4SLinus Torvalds /* 28081da177e4SLinus Torvalds * Check that the command queued to the controller 28091da177e4SLinus Torvalds */ 28101da177e4SLinus Torvalds if (status == -EINPROGRESS) { 281177d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 28121da177e4SLinus Torvalds return 0; 28131da177e4SLinus Torvalds } 28141da177e4SLinus Torvalds 2815bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_srb: aac_fib_send failed with status: %d\n", status); 2816bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 2817bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 28181da177e4SLinus Torvalds 28191da177e4SLinus Torvalds return -1; 28201da177e4SLinus Torvalds } 28211da177e4SLinus Torvalds 28221da177e4SLinus Torvalds static unsigned long aac_build_sg(struct scsi_cmnd* scsicmd, struct sgmap* psg) 28231da177e4SLinus Torvalds { 28241da177e4SLinus Torvalds struct aac_dev *dev; 28251da177e4SLinus Torvalds unsigned long byte_count = 0; 2826727eead6SFUJITA Tomonori int nseg; 28271da177e4SLinus Torvalds 28281da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 28291da177e4SLinus Torvalds // Get rid of old data 28301da177e4SLinus Torvalds psg->count = 0; 28311da177e4SLinus Torvalds psg->sg[0].addr = 0; 28321da177e4SLinus Torvalds psg->sg[0].count = 0; 2833727eead6SFUJITA Tomonori 2834727eead6SFUJITA Tomonori nseg = scsi_dma_map(scsicmd); 2835727eead6SFUJITA Tomonori BUG_ON(nseg < 0); 2836727eead6SFUJITA Tomonori if (nseg) { 28371da177e4SLinus Torvalds struct scatterlist *sg; 28381da177e4SLinus Torvalds int i; 28391da177e4SLinus Torvalds 2840727eead6SFUJITA Tomonori psg->count = cpu_to_le32(nseg); 28411da177e4SLinus Torvalds 2842727eead6SFUJITA Tomonori scsi_for_each_sg(scsicmd, sg, nseg, i) { 28431da177e4SLinus Torvalds psg->sg[i].addr = cpu_to_le32(sg_dma_address(sg)); 28441da177e4SLinus Torvalds psg->sg[i].count = cpu_to_le32(sg_dma_len(sg)); 28451da177e4SLinus Torvalds byte_count += sg_dma_len(sg); 28461da177e4SLinus Torvalds } 28471da177e4SLinus Torvalds /* hba wants the size to be exact */ 2848727eead6SFUJITA Tomonori if (byte_count > scsi_bufflen(scsicmd)) { 284956b58712SMark Haverkamp u32 temp = le32_to_cpu(psg->sg[i-1].count) - 2850727eead6SFUJITA Tomonori (byte_count - scsi_bufflen(scsicmd)); 285156b58712SMark Haverkamp psg->sg[i-1].count = cpu_to_le32(temp); 2852727eead6SFUJITA Tomonori byte_count = scsi_bufflen(scsicmd); 28531da177e4SLinus Torvalds } 28541da177e4SLinus Torvalds /* Check for command underflow */ 28551da177e4SLinus Torvalds if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 28561da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 28571da177e4SLinus Torvalds byte_count, scsicmd->underflow); 28581da177e4SLinus Torvalds } 28591da177e4SLinus Torvalds } 28601da177e4SLinus Torvalds return byte_count; 28611da177e4SLinus Torvalds } 28621da177e4SLinus Torvalds 28631da177e4SLinus Torvalds 28641da177e4SLinus Torvalds static unsigned long aac_build_sg64(struct scsi_cmnd* scsicmd, struct sgmap64* psg) 28651da177e4SLinus Torvalds { 28661da177e4SLinus Torvalds struct aac_dev *dev; 28671da177e4SLinus Torvalds unsigned long byte_count = 0; 286856b58712SMark Haverkamp u64 addr; 2869727eead6SFUJITA Tomonori int nseg; 28701da177e4SLinus Torvalds 28711da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 28721da177e4SLinus Torvalds // Get rid of old data 28731da177e4SLinus Torvalds psg->count = 0; 28741da177e4SLinus Torvalds psg->sg[0].addr[0] = 0; 28751da177e4SLinus Torvalds psg->sg[0].addr[1] = 0; 28761da177e4SLinus Torvalds psg->sg[0].count = 0; 2877727eead6SFUJITA Tomonori 2878727eead6SFUJITA Tomonori nseg = scsi_dma_map(scsicmd); 2879727eead6SFUJITA Tomonori BUG_ON(nseg < 0); 2880727eead6SFUJITA Tomonori if (nseg) { 28811da177e4SLinus Torvalds struct scatterlist *sg; 28821da177e4SLinus Torvalds int i; 28831da177e4SLinus Torvalds 2884727eead6SFUJITA Tomonori scsi_for_each_sg(scsicmd, sg, nseg, i) { 28851241f359SMark Haverkamp int count = sg_dma_len(sg); 288656b58712SMark Haverkamp addr = sg_dma_address(sg); 288756b58712SMark Haverkamp psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff); 288856b58712SMark Haverkamp psg->sg[i].addr[1] = cpu_to_le32(addr>>32); 28891241f359SMark Haverkamp psg->sg[i].count = cpu_to_le32(count); 28901241f359SMark Haverkamp byte_count += count; 28911da177e4SLinus Torvalds } 2892727eead6SFUJITA Tomonori psg->count = cpu_to_le32(nseg); 28931da177e4SLinus Torvalds /* hba wants the size to be exact */ 2894727eead6SFUJITA Tomonori if (byte_count > scsi_bufflen(scsicmd)) { 289556b58712SMark Haverkamp u32 temp = le32_to_cpu(psg->sg[i-1].count) - 2896727eead6SFUJITA Tomonori (byte_count - scsi_bufflen(scsicmd)); 289756b58712SMark Haverkamp psg->sg[i-1].count = cpu_to_le32(temp); 2898727eead6SFUJITA Tomonori byte_count = scsi_bufflen(scsicmd); 28991da177e4SLinus Torvalds } 29001da177e4SLinus Torvalds /* Check for command underflow */ 29011da177e4SLinus Torvalds if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 29021da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 29031da177e4SLinus Torvalds byte_count, scsicmd->underflow); 29041da177e4SLinus Torvalds } 29051da177e4SLinus Torvalds } 29061da177e4SLinus Torvalds return byte_count; 29071da177e4SLinus Torvalds } 29081da177e4SLinus Torvalds 29090e68c003SMark Haverkamp static unsigned long aac_build_sgraw(struct scsi_cmnd* scsicmd, struct sgmapraw* psg) 29100e68c003SMark Haverkamp { 29110e68c003SMark Haverkamp unsigned long byte_count = 0; 2912727eead6SFUJITA Tomonori int nseg; 29130e68c003SMark Haverkamp 29140e68c003SMark Haverkamp // Get rid of old data 29150e68c003SMark Haverkamp psg->count = 0; 29160e68c003SMark Haverkamp psg->sg[0].next = 0; 29170e68c003SMark Haverkamp psg->sg[0].prev = 0; 29180e68c003SMark Haverkamp psg->sg[0].addr[0] = 0; 29190e68c003SMark Haverkamp psg->sg[0].addr[1] = 0; 29200e68c003SMark Haverkamp psg->sg[0].count = 0; 29210e68c003SMark Haverkamp psg->sg[0].flags = 0; 2922727eead6SFUJITA Tomonori 2923727eead6SFUJITA Tomonori nseg = scsi_dma_map(scsicmd); 2924727eead6SFUJITA Tomonori BUG_ON(nseg < 0); 2925727eead6SFUJITA Tomonori if (nseg) { 29260e68c003SMark Haverkamp struct scatterlist *sg; 29270e68c003SMark Haverkamp int i; 29280e68c003SMark Haverkamp 2929727eead6SFUJITA Tomonori scsi_for_each_sg(scsicmd, sg, nseg, i) { 29300e68c003SMark Haverkamp int count = sg_dma_len(sg); 29310e68c003SMark Haverkamp u64 addr = sg_dma_address(sg); 29320e68c003SMark Haverkamp psg->sg[i].next = 0; 29330e68c003SMark Haverkamp psg->sg[i].prev = 0; 29340e68c003SMark Haverkamp psg->sg[i].addr[1] = cpu_to_le32((u32)(addr>>32)); 29350e68c003SMark Haverkamp psg->sg[i].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff)); 29360e68c003SMark Haverkamp psg->sg[i].count = cpu_to_le32(count); 29370e68c003SMark Haverkamp psg->sg[i].flags = 0; 29380e68c003SMark Haverkamp byte_count += count; 29390e68c003SMark Haverkamp } 2940727eead6SFUJITA Tomonori psg->count = cpu_to_le32(nseg); 29410e68c003SMark Haverkamp /* hba wants the size to be exact */ 2942727eead6SFUJITA Tomonori if (byte_count > scsi_bufflen(scsicmd)) { 29430e68c003SMark Haverkamp u32 temp = le32_to_cpu(psg->sg[i-1].count) - 2944727eead6SFUJITA Tomonori (byte_count - scsi_bufflen(scsicmd)); 29450e68c003SMark Haverkamp psg->sg[i-1].count = cpu_to_le32(temp); 2946727eead6SFUJITA Tomonori byte_count = scsi_bufflen(scsicmd); 29470e68c003SMark Haverkamp } 29480e68c003SMark Haverkamp /* Check for command underflow */ 29490e68c003SMark Haverkamp if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 29500e68c003SMark Haverkamp printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 29510e68c003SMark Haverkamp byte_count, scsicmd->underflow); 29520e68c003SMark Haverkamp } 29530e68c003SMark Haverkamp } 29540e68c003SMark Haverkamp return byte_count; 29550e68c003SMark Haverkamp } 29560e68c003SMark Haverkamp 29571da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 29581da177e4SLinus Torvalds 29591da177e4SLinus Torvalds struct aac_srb_status_info { 29601da177e4SLinus Torvalds u32 status; 29611da177e4SLinus Torvalds char *str; 29621da177e4SLinus Torvalds }; 29631da177e4SLinus Torvalds 29641da177e4SLinus Torvalds 29651da177e4SLinus Torvalds static struct aac_srb_status_info srb_status_info[] = { 29661da177e4SLinus Torvalds { SRB_STATUS_PENDING, "Pending Status"}, 29671da177e4SLinus Torvalds { SRB_STATUS_SUCCESS, "Success"}, 29681da177e4SLinus Torvalds { SRB_STATUS_ABORTED, "Aborted Command"}, 29691da177e4SLinus Torvalds { SRB_STATUS_ABORT_FAILED, "Abort Failed"}, 29701da177e4SLinus Torvalds { SRB_STATUS_ERROR, "Error Event"}, 29711da177e4SLinus Torvalds { SRB_STATUS_BUSY, "Device Busy"}, 29721da177e4SLinus Torvalds { SRB_STATUS_INVALID_REQUEST, "Invalid Request"}, 29731da177e4SLinus Torvalds { SRB_STATUS_INVALID_PATH_ID, "Invalid Path ID"}, 29741da177e4SLinus Torvalds { SRB_STATUS_NO_DEVICE, "No Device"}, 29751da177e4SLinus Torvalds { SRB_STATUS_TIMEOUT, "Timeout"}, 29761da177e4SLinus Torvalds { SRB_STATUS_SELECTION_TIMEOUT, "Selection Timeout"}, 29771da177e4SLinus Torvalds { SRB_STATUS_COMMAND_TIMEOUT, "Command Timeout"}, 29781da177e4SLinus Torvalds { SRB_STATUS_MESSAGE_REJECTED, "Message Rejected"}, 29791da177e4SLinus Torvalds { SRB_STATUS_BUS_RESET, "Bus Reset"}, 29801da177e4SLinus Torvalds { SRB_STATUS_PARITY_ERROR, "Parity Error"}, 29811da177e4SLinus Torvalds { SRB_STATUS_REQUEST_SENSE_FAILED,"Request Sense Failed"}, 29821da177e4SLinus Torvalds { SRB_STATUS_NO_HBA, "No HBA"}, 29831da177e4SLinus Torvalds { SRB_STATUS_DATA_OVERRUN, "Data Overrun/Data Underrun"}, 29841da177e4SLinus Torvalds { SRB_STATUS_UNEXPECTED_BUS_FREE,"Unexpected Bus Free"}, 29851da177e4SLinus Torvalds { SRB_STATUS_PHASE_SEQUENCE_FAILURE,"Phase Error"}, 29861da177e4SLinus Torvalds { SRB_STATUS_BAD_SRB_BLOCK_LENGTH,"Bad Srb Block Length"}, 29871da177e4SLinus Torvalds { SRB_STATUS_REQUEST_FLUSHED, "Request Flushed"}, 29881da177e4SLinus Torvalds { SRB_STATUS_DELAYED_RETRY, "Delayed Retry"}, 29891da177e4SLinus Torvalds { SRB_STATUS_INVALID_LUN, "Invalid LUN"}, 29901da177e4SLinus Torvalds { SRB_STATUS_INVALID_TARGET_ID, "Invalid TARGET ID"}, 29911da177e4SLinus Torvalds { SRB_STATUS_BAD_FUNCTION, "Bad Function"}, 29921da177e4SLinus Torvalds { SRB_STATUS_ERROR_RECOVERY, "Error Recovery"}, 29931da177e4SLinus Torvalds { SRB_STATUS_NOT_STARTED, "Not Started"}, 29941da177e4SLinus Torvalds { SRB_STATUS_NOT_IN_USE, "Not In Use"}, 29951da177e4SLinus Torvalds { SRB_STATUS_FORCE_ABORT, "Force Abort"}, 29961da177e4SLinus Torvalds { SRB_STATUS_DOMAIN_VALIDATION_FAIL,"Domain Validation Failure"}, 29971da177e4SLinus Torvalds { 0xff, "Unknown Error"} 29981da177e4SLinus Torvalds }; 29991da177e4SLinus Torvalds 30001da177e4SLinus Torvalds char *aac_get_status_string(u32 status) 30011da177e4SLinus Torvalds { 30021da177e4SLinus Torvalds int i; 30031da177e4SLinus Torvalds 30046391a113STobias Klauser for (i = 0; i < ARRAY_SIZE(srb_status_info); i++) 30056391a113STobias Klauser if (srb_status_info[i].status == status) 30061da177e4SLinus Torvalds return srb_status_info[i].str; 30071da177e4SLinus Torvalds 30081da177e4SLinus Torvalds return "Bad Status Code"; 30091da177e4SLinus Torvalds } 30101da177e4SLinus Torvalds 30111da177e4SLinus Torvalds #endif 3012