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); 13885d22bbfSMahesh Rajashekhara static unsigned long aac_build_sgraw2(struct scsi_cmnd *scsicmd, struct aac_raw_io2 *rio2, int sg_max); 13985d22bbfSMahesh Rajashekhara static int aac_convert_sgraw2(struct aac_raw_io2 *rio2, int pages, int nseg, int nseg_new); 1401da177e4SLinus Torvalds static int aac_send_srb_fib(struct scsi_cmnd* scsicmd); 1411da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 1421da177e4SLinus Torvalds static char *aac_get_status_string(u32 status); 1431da177e4SLinus Torvalds #endif 1441da177e4SLinus Torvalds 1451da177e4SLinus Torvalds /* 1461da177e4SLinus Torvalds * Non dasd selection is handled entirely in aachba now 1471da177e4SLinus Torvalds */ 1481da177e4SLinus Torvalds 1491da177e4SLinus Torvalds static int nondasd = -1; 150d8e96507SLeubner, Achim static int aac_cache = 2; /* WCE=0 to avoid performance problems */ 1511da177e4SLinus Torvalds static int dacmode = -1; 1528ef22247SSalyzyn, Mark int aac_msi; 1531208bab5SSalyzyn, Mark int aac_commit = -1; 154404d9a90SMark Haverkamp int startup_timeout = 180; 155404d9a90SMark Haverkamp int aif_timeout = 120; 15611604612SMahesh Rajashekhara int aac_sync_mode; /* Only Sync. transfer - disabled */ 15785d22bbfSMahesh Rajashekhara int aac_convert_sgl = 1; /* convert non-conformable s/g list - enabled */ 1581da177e4SLinus Torvalds 15911604612SMahesh Rajashekhara module_param(aac_sync_mode, int, S_IRUGO|S_IWUSR); 16011604612SMahesh Rajashekhara MODULE_PARM_DESC(aac_sync_mode, "Force sync. transfer mode" 16111604612SMahesh Rajashekhara " 0=off, 1=on"); 16285d22bbfSMahesh Rajashekhara module_param(aac_convert_sgl, int, S_IRUGO|S_IWUSR); 16385d22bbfSMahesh Rajashekhara MODULE_PARM_DESC(aac_convert_sgl, "Convert non-conformable s/g list" 16485d22bbfSMahesh Rajashekhara " 0=off, 1=on"); 1659a72f976SMark Haverkamp module_param(nondasd, int, S_IRUGO|S_IWUSR); 1668ef22247SSalyzyn, Mark MODULE_PARM_DESC(nondasd, "Control scanning of hba for nondasd devices." 1678ef22247SSalyzyn, Mark " 0=off, 1=on"); 16895e852e1SSalyzyn, Mark module_param_named(cache, aac_cache, int, S_IRUGO|S_IWUSR); 1698ef22247SSalyzyn, Mark MODULE_PARM_DESC(cache, "Disable Queue Flush commands:\n" 1708ef22247SSalyzyn, Mark "\tbit 0 - Disable FUA in WRITE SCSI commands\n" 1718ef22247SSalyzyn, Mark "\tbit 1 - Disable SYNCHRONIZE_CACHE SCSI command\n" 172d8e96507SLeubner, Achim "\tbit 2 - Disable only if Battery is protecting Cache"); 1739a72f976SMark Haverkamp module_param(dacmode, int, S_IRUGO|S_IWUSR); 1748ef22247SSalyzyn, Mark MODULE_PARM_DESC(dacmode, "Control whether dma addressing is using 64 bit DAC." 1758ef22247SSalyzyn, Mark " 0=off, 1=on"); 1761208bab5SSalyzyn, Mark module_param_named(commit, aac_commit, int, S_IRUGO|S_IWUSR); 1778ef22247SSalyzyn, Mark MODULE_PARM_DESC(commit, "Control whether a COMMIT_CONFIG is issued to the" 1788ef22247SSalyzyn, Mark " adapter for foreign arrays.\n" 1798ef22247SSalyzyn, Mark "This is typically needed in systems that do not have a BIOS." 1808ef22247SSalyzyn, Mark " 0=off, 1=on"); 1818ef22247SSalyzyn, Mark module_param_named(msi, aac_msi, int, S_IRUGO|S_IWUSR); 1828ef22247SSalyzyn, Mark MODULE_PARM_DESC(msi, "IRQ handling." 1838ef22247SSalyzyn, Mark " 0=PIC(default), 1=MSI, 2=MSI-X(unsupported, uses MSI)"); 184404d9a90SMark Haverkamp module_param(startup_timeout, int, S_IRUGO|S_IWUSR); 1858ef22247SSalyzyn, Mark MODULE_PARM_DESC(startup_timeout, "The duration of time in seconds to wait for" 1868ef22247SSalyzyn, Mark " adapter to have it's kernel up and\n" 1878ef22247SSalyzyn, Mark "running. This is typically adjusted for large systems that do not" 1888ef22247SSalyzyn, Mark " have a BIOS."); 189404d9a90SMark Haverkamp module_param(aif_timeout, int, S_IRUGO|S_IWUSR); 1908ef22247SSalyzyn, Mark MODULE_PARM_DESC(aif_timeout, "The duration of time in seconds to wait for" 1918ef22247SSalyzyn, Mark " applications to pick up AIFs before\n" 1928ef22247SSalyzyn, Mark "deregistering them. This is typically adjusted for heavily burdened" 1938ef22247SSalyzyn, Mark " systems."); 1941da177e4SLinus Torvalds 1957c00ffa3SMark Haverkamp int numacb = -1; 1967c00ffa3SMark Haverkamp module_param(numacb, int, S_IRUGO|S_IWUSR); 1978ef22247SSalyzyn, Mark MODULE_PARM_DESC(numacb, "Request a limit to the number of adapter control" 1988ef22247SSalyzyn, Mark " blocks (FIB) allocated. Valid values are 512 and down. Default is" 1998ef22247SSalyzyn, Mark " to use suggestion from Firmware."); 2007c00ffa3SMark Haverkamp 2017c00ffa3SMark Haverkamp int acbsize = -1; 2027c00ffa3SMark Haverkamp module_param(acbsize, int, S_IRUGO|S_IWUSR); 2038ef22247SSalyzyn, Mark MODULE_PARM_DESC(acbsize, "Request a specific adapter control block (FIB)" 2048ef22247SSalyzyn, Mark " size. Valid values are 512, 2048, 4096 and 8192. Default is to use" 2058ef22247SSalyzyn, Mark " suggestion from Firmware."); 206653ba58dSMark Haverkamp 20729c97684SSalyzyn, Mark int update_interval = 30 * 60; 20829c97684SSalyzyn, Mark module_param(update_interval, int, S_IRUGO|S_IWUSR); 2098ef22247SSalyzyn, Mark MODULE_PARM_DESC(update_interval, "Interval in seconds between time sync" 2108ef22247SSalyzyn, Mark " updates issued to adapter."); 21129c97684SSalyzyn, Mark 21229c97684SSalyzyn, Mark int check_interval = 24 * 60 * 60; 21329c97684SSalyzyn, Mark module_param(check_interval, int, S_IRUGO|S_IWUSR); 2148ef22247SSalyzyn, Mark MODULE_PARM_DESC(check_interval, "Interval in seconds between adapter health" 2158ef22247SSalyzyn, Mark " checks."); 21629c97684SSalyzyn, Mark 21787f3bda3SAndrew Morton int aac_check_reset = 1; 21887f3bda3SAndrew Morton module_param_named(check_reset, aac_check_reset, int, S_IRUGO|S_IWUSR); 21995e7a8efSPaul Bolle MODULE_PARM_DESC(check_reset, "If adapter fails health check, reset the" 2208ef22247SSalyzyn, Mark " adapter. a value of -1 forces the reset to adapters programmed to" 2218ef22247SSalyzyn, Mark " ignore it."); 22229c97684SSalyzyn, Mark 223e37ee4beSMark Haverkamp int expose_physicals = -1; 224653ba58dSMark Haverkamp module_param(expose_physicals, int, S_IRUGO|S_IWUSR); 2258ef22247SSalyzyn, Mark MODULE_PARM_DESC(expose_physicals, "Expose physical components of the arrays." 2268ef22247SSalyzyn, Mark " -1=protect 0=off, 1=on"); 22703d44337SMark Haverkamp 2288ef22247SSalyzyn, Mark int aac_reset_devices; 2291208bab5SSalyzyn, Mark module_param_named(reset_devices, aac_reset_devices, int, S_IRUGO|S_IWUSR); 2301208bab5SSalyzyn, Mark MODULE_PARM_DESC(reset_devices, "Force an adapter reset at initialization."); 23103d44337SMark Haverkamp 232d8e96507SLeubner, Achim int aac_wwn = 1; 233d8e96507SLeubner, Achim module_param_named(wwn, aac_wwn, int, S_IRUGO|S_IWUSR); 234d8e96507SLeubner, Achim MODULE_PARM_DESC(wwn, "Select a WWN type for the arrays:\n" 235d8e96507SLeubner, Achim "\t0 - Disable\n" 236d8e96507SLeubner, Achim "\t1 - Array Meta Data Signature (default)\n" 237d8e96507SLeubner, Achim "\t2 - Adapter Serial Number"); 238d8e96507SLeubner, Achim 239d8e96507SLeubner, Achim 24003d44337SMark Haverkamp static inline int aac_valid_context(struct scsi_cmnd *scsicmd, 24103d44337SMark Haverkamp struct fib *fibptr) { 24203d44337SMark Haverkamp struct scsi_device *device; 24303d44337SMark Haverkamp 24403d44337SMark Haverkamp if (unlikely(!scsicmd || !scsicmd->scsi_done)) { 245c835e372SSalyzyn, Mark dprintk((KERN_WARNING "aac_valid_context: scsi command corrupt\n")); 24603d44337SMark Haverkamp aac_fib_complete(fibptr); 24703d44337SMark Haverkamp aac_fib_free(fibptr); 24803d44337SMark Haverkamp return 0; 24903d44337SMark Haverkamp } 25003d44337SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL; 25103d44337SMark Haverkamp device = scsicmd->device; 25203d44337SMark Haverkamp if (unlikely(!device || !scsi_device_online(device))) { 25303d44337SMark Haverkamp dprintk((KERN_WARNING "aac_valid_context: scsi device corrupt\n")); 25403d44337SMark Haverkamp aac_fib_complete(fibptr); 25503d44337SMark Haverkamp aac_fib_free(fibptr); 25603d44337SMark Haverkamp return 0; 25703d44337SMark Haverkamp } 25803d44337SMark Haverkamp return 1; 25903d44337SMark Haverkamp } 26003d44337SMark Haverkamp 2611da177e4SLinus Torvalds /** 2621da177e4SLinus Torvalds * aac_get_config_status - check the adapter configuration 2631da177e4SLinus Torvalds * @common: adapter to query 2641da177e4SLinus Torvalds * 2651da177e4SLinus Torvalds * Query config status, and commit the configuration if needed. 2661da177e4SLinus Torvalds */ 2678c867b25SMark Haverkamp int aac_get_config_status(struct aac_dev *dev, int commit_flag) 2681da177e4SLinus Torvalds { 2691da177e4SLinus Torvalds int status = 0; 2701da177e4SLinus Torvalds struct fib * fibptr; 2711da177e4SLinus Torvalds 272bfb35aa8SMark Haverkamp if (!(fibptr = aac_fib_alloc(dev))) 2731da177e4SLinus Torvalds return -ENOMEM; 2741da177e4SLinus Torvalds 275bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 2761da177e4SLinus Torvalds { 2771da177e4SLinus Torvalds struct aac_get_config_status *dinfo; 2781da177e4SLinus Torvalds dinfo = (struct aac_get_config_status *) fib_data(fibptr); 2791da177e4SLinus Torvalds 2801da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 2811da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_GET_CONFIG_STATUS); 2821da177e4SLinus Torvalds dinfo->count = cpu_to_le32(sizeof(((struct aac_get_config_status_resp *)NULL)->data)); 2831da177e4SLinus Torvalds } 2841da177e4SLinus Torvalds 285bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 2861da177e4SLinus Torvalds fibptr, 2871da177e4SLinus Torvalds sizeof (struct aac_get_config_status), 2881da177e4SLinus Torvalds FsaNormal, 2891da177e4SLinus Torvalds 1, 1, 2901da177e4SLinus Torvalds NULL, NULL); 2911da177e4SLinus Torvalds if (status < 0) { 2921da177e4SLinus Torvalds printk(KERN_WARNING "aac_get_config_status: SendFIB failed.\n"); 2931da177e4SLinus Torvalds } else { 2941da177e4SLinus Torvalds struct aac_get_config_status_resp *reply 2951da177e4SLinus Torvalds = (struct aac_get_config_status_resp *) fib_data(fibptr); 2961da177e4SLinus Torvalds dprintk((KERN_WARNING 2971da177e4SLinus Torvalds "aac_get_config_status: response=%d status=%d action=%d\n", 2981da177e4SLinus Torvalds le32_to_cpu(reply->response), 2991da177e4SLinus Torvalds le32_to_cpu(reply->status), 3001da177e4SLinus Torvalds le32_to_cpu(reply->data.action))); 3011da177e4SLinus Torvalds if ((le32_to_cpu(reply->response) != ST_OK) || 3021da177e4SLinus Torvalds (le32_to_cpu(reply->status) != CT_OK) || 3031da177e4SLinus Torvalds (le32_to_cpu(reply->data.action) > CFACT_PAUSE)) { 3041da177e4SLinus Torvalds printk(KERN_WARNING "aac_get_config_status: Will not issue the Commit Configuration\n"); 3051da177e4SLinus Torvalds status = -EINVAL; 3061da177e4SLinus Torvalds } 3071da177e4SLinus Torvalds } 308cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* Do not set XferState to zero unless receives a response from F/W */ 309cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (status >= 0) 310bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 311cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech 3121da177e4SLinus Torvalds /* Send a CT_COMMIT_CONFIG to enable discovery of devices */ 3131da177e4SLinus Torvalds if (status >= 0) { 3141208bab5SSalyzyn, Mark if ((aac_commit == 1) || commit_flag) { 3151da177e4SLinus Torvalds struct aac_commit_config * dinfo; 316bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 3171da177e4SLinus Torvalds dinfo = (struct aac_commit_config *) fib_data(fibptr); 3181da177e4SLinus Torvalds 3191da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 3201da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_COMMIT_CONFIG); 3211da177e4SLinus Torvalds 322bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 3231da177e4SLinus Torvalds fibptr, 3241da177e4SLinus Torvalds sizeof (struct aac_commit_config), 3251da177e4SLinus Torvalds FsaNormal, 3261da177e4SLinus Torvalds 1, 1, 3271da177e4SLinus Torvalds NULL, NULL); 328cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* Do not set XferState to zero unless 329cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech * receives a response from F/W */ 330cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (status >= 0) 331bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 3321208bab5SSalyzyn, Mark } else if (aac_commit == 0) { 3331da177e4SLinus Torvalds printk(KERN_WARNING 3341da177e4SLinus Torvalds "aac_get_config_status: Foreign device configurations are being ignored\n"); 3351da177e4SLinus Torvalds } 3361da177e4SLinus Torvalds } 337cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* FIB should be freed only after getting the response from the F/W */ 338cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (status != -ERESTARTSYS) 339bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 3401da177e4SLinus Torvalds return status; 3411da177e4SLinus Torvalds } 3421da177e4SLinus Torvalds 343e3cc268fSRajashekhara, Mahesh static void aac_expose_phy_device(struct scsi_cmnd *scsicmd) 344e3cc268fSRajashekhara, Mahesh { 345e3cc268fSRajashekhara, Mahesh char inq_data; 346e3cc268fSRajashekhara, Mahesh scsi_sg_copy_to_buffer(scsicmd, &inq_data, sizeof(inq_data)); 347e3cc268fSRajashekhara, Mahesh if ((inq_data & 0x20) && (inq_data & 0x1f) == TYPE_DISK) { 348e3cc268fSRajashekhara, Mahesh inq_data &= 0xdf; 349e3cc268fSRajashekhara, Mahesh scsi_sg_copy_from_buffer(scsicmd, &inq_data, sizeof(inq_data)); 350e3cc268fSRajashekhara, Mahesh } 351e3cc268fSRajashekhara, Mahesh } 352e3cc268fSRajashekhara, Mahesh 3531da177e4SLinus Torvalds /** 3541da177e4SLinus Torvalds * aac_get_containers - list containers 3551da177e4SLinus Torvalds * @common: adapter to probe 3561da177e4SLinus Torvalds * 3571da177e4SLinus Torvalds * Make a list of all containers on this controller 3581da177e4SLinus Torvalds */ 3591da177e4SLinus Torvalds int aac_get_containers(struct aac_dev *dev) 3601da177e4SLinus Torvalds { 3611da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 3621da177e4SLinus Torvalds u32 index; 3631da177e4SLinus Torvalds int status = 0; 3641da177e4SLinus Torvalds struct fib * fibptr; 3651da177e4SLinus Torvalds struct aac_get_container_count *dinfo; 3661da177e4SLinus Torvalds struct aac_get_container_count_resp *dresp; 3671da177e4SLinus Torvalds int maximum_num_containers = MAXIMUM_NUM_CONTAINERS; 3681da177e4SLinus Torvalds 369bfb35aa8SMark Haverkamp if (!(fibptr = aac_fib_alloc(dev))) 3701da177e4SLinus Torvalds return -ENOMEM; 3711da177e4SLinus Torvalds 372bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 3731da177e4SLinus Torvalds dinfo = (struct aac_get_container_count *) fib_data(fibptr); 3741da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 3751da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_GET_CONTAINER_COUNT); 3761da177e4SLinus Torvalds 377bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 3781da177e4SLinus Torvalds fibptr, 3791da177e4SLinus Torvalds sizeof (struct aac_get_container_count), 3801da177e4SLinus Torvalds FsaNormal, 3811da177e4SLinus Torvalds 1, 1, 3821da177e4SLinus Torvalds NULL, NULL); 3831da177e4SLinus Torvalds if (status >= 0) { 3841da177e4SLinus Torvalds dresp = (struct aac_get_container_count_resp *)fib_data(fibptr); 3851da177e4SLinus Torvalds maximum_num_containers = le32_to_cpu(dresp->ContainerSwitchEntries); 386bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 3871da177e4SLinus Torvalds } 388cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* FIB should be freed only after getting the response from the F/W */ 389cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (status != -ERESTARTSYS) 390fe76df42SMark Haverkamp aac_fib_free(fibptr); 3911da177e4SLinus Torvalds 3921da177e4SLinus Torvalds if (maximum_num_containers < MAXIMUM_NUM_CONTAINERS) 3931da177e4SLinus Torvalds maximum_num_containers = MAXIMUM_NUM_CONTAINERS; 3941a655040SSalyzyn, Mark fsa_dev_ptr = kzalloc(sizeof(*fsa_dev_ptr) * maximum_num_containers, 395fe76df42SMark Haverkamp GFP_KERNEL); 396fe76df42SMark Haverkamp if (!fsa_dev_ptr) 3971da177e4SLinus Torvalds return -ENOMEM; 3981da177e4SLinus Torvalds 3991da177e4SLinus Torvalds dev->fsa_dev = fsa_dev_ptr; 4001da177e4SLinus Torvalds dev->maximum_num_containers = maximum_num_containers; 4011da177e4SLinus Torvalds 402fe76df42SMark Haverkamp for (index = 0; index < dev->maximum_num_containers; ) { 4031da177e4SLinus Torvalds fsa_dev_ptr[index].devname[0] = '\0'; 4041da177e4SLinus Torvalds 405fe76df42SMark Haverkamp status = aac_probe_container(dev, index); 4061da177e4SLinus Torvalds 4071da177e4SLinus Torvalds if (status < 0) { 4081da177e4SLinus Torvalds printk(KERN_WARNING "aac_get_containers: SendFIB failed.\n"); 4091da177e4SLinus Torvalds break; 4101da177e4SLinus Torvalds } 4111da177e4SLinus Torvalds 4121da177e4SLinus Torvalds /* 4131da177e4SLinus Torvalds * If there are no more containers, then stop asking. 4141da177e4SLinus Torvalds */ 415fe76df42SMark Haverkamp if (++index >= status) 4161da177e4SLinus Torvalds break; 4171da177e4SLinus Torvalds } 4181da177e4SLinus Torvalds return status; 4191da177e4SLinus Torvalds } 4201da177e4SLinus Torvalds 4211da177e4SLinus Torvalds static void get_container_name_callback(void *context, struct fib * fibptr) 4221da177e4SLinus Torvalds { 4231da177e4SLinus Torvalds struct aac_get_name_resp * get_name_reply; 4241da177e4SLinus Torvalds struct scsi_cmnd * scsicmd; 4251da177e4SLinus Torvalds 4261da177e4SLinus Torvalds scsicmd = (struct scsi_cmnd *) context; 4271da177e4SLinus Torvalds 42803d44337SMark Haverkamp if (!aac_valid_context(scsicmd, fibptr)) 42903d44337SMark Haverkamp return; 43003d44337SMark Haverkamp 4311da177e4SLinus Torvalds dprintk((KERN_DEBUG "get_container_name_callback[cpu %d]: t = %ld.\n", smp_processor_id(), jiffies)); 432125e1874SEric Sesterhenn BUG_ON(fibptr == NULL); 4331da177e4SLinus Torvalds 4341da177e4SLinus Torvalds get_name_reply = (struct aac_get_name_resp *) fib_data(fibptr); 4351da177e4SLinus Torvalds /* Failure is irrelevant, using default value instead */ 4361da177e4SLinus Torvalds if ((le32_to_cpu(get_name_reply->status) == CT_OK) 4371da177e4SLinus Torvalds && (get_name_reply->data[0] != '\0')) { 4381da177e4SLinus Torvalds char *sp = get_name_reply->data; 4391da177e4SLinus Torvalds sp[sizeof(((struct aac_get_name_resp *)NULL)->data)-1] = '\0'; 4401da177e4SLinus Torvalds while (*sp == ' ') 4411da177e4SLinus Torvalds ++sp; 4423b2946ccSMark Haverkamp if (*sp) { 443d4345028SFUJITA Tomonori struct inquiry_data inq; 4443b2946ccSMark Haverkamp char d[sizeof(((struct inquiry_data *)NULL)->inqd_pid)]; 4453b2946ccSMark Haverkamp int count = sizeof(d); 4463b2946ccSMark Haverkamp char *dp = d; 4473b2946ccSMark Haverkamp do { 4481da177e4SLinus Torvalds *dp++ = (*sp) ? *sp++ : ' '; 4491da177e4SLinus Torvalds } while (--count > 0); 450d4345028SFUJITA Tomonori 451d4345028SFUJITA Tomonori scsi_sg_copy_to_buffer(scsicmd, &inq, sizeof(inq)); 452d4345028SFUJITA Tomonori memcpy(inq.inqd_pid, d, sizeof(d)); 453d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, &inq, sizeof(inq)); 4541da177e4SLinus Torvalds } 4553b2946ccSMark Haverkamp } 4563b2946ccSMark Haverkamp 4571da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 4581da177e4SLinus Torvalds 459bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 460bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 4618e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 4621da177e4SLinus Torvalds } 4631da177e4SLinus Torvalds 4641da177e4SLinus Torvalds /** 4651da177e4SLinus Torvalds * aac_get_container_name - get container name, none blocking. 4661da177e4SLinus Torvalds */ 4679e7c349cSMark Haverkamp static int aac_get_container_name(struct scsi_cmnd * scsicmd) 4681da177e4SLinus Torvalds { 4691da177e4SLinus Torvalds int status; 4701da177e4SLinus Torvalds struct aac_get_name *dinfo; 4711da177e4SLinus Torvalds struct fib * cmd_fibcontext; 4721da177e4SLinus Torvalds struct aac_dev * dev; 4731da177e4SLinus Torvalds 4741da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 4751da177e4SLinus Torvalds 476bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) 4771da177e4SLinus Torvalds return -ENOMEM; 4781da177e4SLinus Torvalds 479bfb35aa8SMark Haverkamp aac_fib_init(cmd_fibcontext); 4801da177e4SLinus Torvalds dinfo = (struct aac_get_name *) fib_data(cmd_fibcontext); 4811da177e4SLinus Torvalds 4821da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 4831da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_READ_NAME); 4849e7c349cSMark Haverkamp dinfo->cid = cpu_to_le32(scmd_id(scsicmd)); 4851da177e4SLinus Torvalds dinfo->count = cpu_to_le32(sizeof(((struct aac_get_name_resp *)NULL)->data)); 4861da177e4SLinus Torvalds 487bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 4881da177e4SLinus Torvalds cmd_fibcontext, 4891da177e4SLinus Torvalds sizeof (struct aac_get_name), 4901da177e4SLinus Torvalds FsaNormal, 4911da177e4SLinus Torvalds 0, 1, 4921da177e4SLinus Torvalds (fib_callback)get_container_name_callback, 4931da177e4SLinus Torvalds (void *) scsicmd); 4941da177e4SLinus Torvalds 4951da177e4SLinus Torvalds /* 4961da177e4SLinus Torvalds * Check that the command queued to the controller 4971da177e4SLinus Torvalds */ 49877d644d4SMark Haverkamp if (status == -EINPROGRESS) { 49977d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 5001da177e4SLinus Torvalds return 0; 50177d644d4SMark Haverkamp } 5021da177e4SLinus Torvalds 503bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_get_container_name: aac_fib_send failed with status: %d.\n", status); 504bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 505bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 5061da177e4SLinus Torvalds return -1; 5071da177e4SLinus Torvalds } 5081da177e4SLinus Torvalds 509fe76df42SMark Haverkamp static int aac_probe_container_callback2(struct scsi_cmnd * scsicmd) 510fe76df42SMark Haverkamp { 511fe76df42SMark Haverkamp struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev; 512fe76df42SMark Haverkamp 5131a655040SSalyzyn, Mark if ((fsa_dev_ptr[scmd_id(scsicmd)].valid & 1)) 514fe76df42SMark Haverkamp return aac_scsi_cmd(scsicmd); 515fe76df42SMark Haverkamp 516fe76df42SMark Haverkamp scsicmd->result = DID_NO_CONNECT << 16; 517fe76df42SMark Haverkamp scsicmd->scsi_done(scsicmd); 518fe76df42SMark Haverkamp return 0; 519fe76df42SMark Haverkamp } 520fe76df42SMark Haverkamp 5211a655040SSalyzyn, Mark static void _aac_probe_container2(void * context, struct fib * fibptr) 522fe76df42SMark Haverkamp { 52303d44337SMark Haverkamp struct fsa_dev_info *fsa_dev_ptr; 524fe76df42SMark Haverkamp int (*callback)(struct scsi_cmnd *); 52503d44337SMark Haverkamp struct scsi_cmnd * scsicmd = (struct scsi_cmnd *)context; 52603d44337SMark Haverkamp 52703d44337SMark Haverkamp 5281a655040SSalyzyn, Mark if (!aac_valid_context(scsicmd, fibptr)) 5291a655040SSalyzyn, Mark return; 530fe76df42SMark Haverkamp 531fe76df42SMark Haverkamp scsicmd->SCp.Status = 0; 5321a655040SSalyzyn, Mark fsa_dev_ptr = fibptr->dev->fsa_dev; 533fe76df42SMark Haverkamp if (fsa_dev_ptr) { 534fe76df42SMark Haverkamp struct aac_mount * dresp = (struct aac_mount *) fib_data(fibptr); 535fe76df42SMark Haverkamp fsa_dev_ptr += scmd_id(scsicmd); 536fe76df42SMark Haverkamp 537fe76df42SMark Haverkamp if ((le32_to_cpu(dresp->status) == ST_OK) && 538fe76df42SMark Haverkamp (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE) && 539fe76df42SMark Haverkamp (le32_to_cpu(dresp->mnt[0].state) != FSCS_HIDDEN)) { 540fe76df42SMark Haverkamp fsa_dev_ptr->valid = 1; 541655d722cSMark Salyzyn /* sense_key holds the current state of the spin-up */ 542655d722cSMark Salyzyn if (dresp->mnt[0].state & cpu_to_le32(FSCS_NOT_READY)) 543655d722cSMark Salyzyn fsa_dev_ptr->sense_data.sense_key = NOT_READY; 544655d722cSMark Salyzyn else if (fsa_dev_ptr->sense_data.sense_key == NOT_READY) 545655d722cSMark Salyzyn fsa_dev_ptr->sense_data.sense_key = NO_SENSE; 546fe76df42SMark Haverkamp fsa_dev_ptr->type = le32_to_cpu(dresp->mnt[0].vol); 547fe76df42SMark Haverkamp fsa_dev_ptr->size 548fe76df42SMark Haverkamp = ((u64)le32_to_cpu(dresp->mnt[0].capacity)) + 549fe76df42SMark Haverkamp (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32); 550fe76df42SMark Haverkamp fsa_dev_ptr->ro = ((le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY) != 0); 551fe76df42SMark Haverkamp } 552fe76df42SMark Haverkamp if ((fsa_dev_ptr->valid & 1) == 0) 553fe76df42SMark Haverkamp fsa_dev_ptr->valid = 0; 554fe76df42SMark Haverkamp scsicmd->SCp.Status = le32_to_cpu(dresp->count); 555fe76df42SMark Haverkamp } 556fe76df42SMark Haverkamp aac_fib_complete(fibptr); 557fe76df42SMark Haverkamp aac_fib_free(fibptr); 558fe76df42SMark Haverkamp callback = (int (*)(struct scsi_cmnd *))(scsicmd->SCp.ptr); 559fe76df42SMark Haverkamp scsicmd->SCp.ptr = NULL; 5601a655040SSalyzyn, Mark (*callback)(scsicmd); 5611a655040SSalyzyn, Mark return; 562fe76df42SMark Haverkamp } 563fe76df42SMark Haverkamp 5641a655040SSalyzyn, Mark static void _aac_probe_container1(void * context, struct fib * fibptr) 565fe76df42SMark Haverkamp { 566fe76df42SMark Haverkamp struct scsi_cmnd * scsicmd; 567fe76df42SMark Haverkamp struct aac_mount * dresp; 568fe76df42SMark Haverkamp struct aac_query_mount *dinfo; 569fe76df42SMark Haverkamp int status; 570fe76df42SMark Haverkamp 571fe76df42SMark Haverkamp dresp = (struct aac_mount *) fib_data(fibptr); 572fe76df42SMark Haverkamp dresp->mnt[0].capacityhigh = 0; 573fe76df42SMark Haverkamp if ((le32_to_cpu(dresp->status) != ST_OK) || 5741a655040SSalyzyn, Mark (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE)) { 5751a655040SSalyzyn, Mark _aac_probe_container2(context, fibptr); 5761a655040SSalyzyn, Mark return; 5771a655040SSalyzyn, Mark } 578fe76df42SMark Haverkamp scsicmd = (struct scsi_cmnd *) context; 579fe76df42SMark Haverkamp 58003d44337SMark Haverkamp if (!aac_valid_context(scsicmd, fibptr)) 5811a655040SSalyzyn, Mark return; 58203d44337SMark Haverkamp 583fe76df42SMark Haverkamp aac_fib_init(fibptr); 584fe76df42SMark Haverkamp 585fe76df42SMark Haverkamp dinfo = (struct aac_query_mount *)fib_data(fibptr); 586fe76df42SMark Haverkamp 587fe76df42SMark Haverkamp dinfo->command = cpu_to_le32(VM_NameServe64); 588fe76df42SMark Haverkamp dinfo->count = cpu_to_le32(scmd_id(scsicmd)); 589fe76df42SMark Haverkamp dinfo->type = cpu_to_le32(FT_FILESYS); 590fe76df42SMark Haverkamp 591fe76df42SMark Haverkamp status = aac_fib_send(ContainerCommand, 592fe76df42SMark Haverkamp fibptr, 593fe76df42SMark Haverkamp sizeof(struct aac_query_mount), 594fe76df42SMark Haverkamp FsaNormal, 595fe76df42SMark Haverkamp 0, 1, 5961a655040SSalyzyn, Mark _aac_probe_container2, 597fe76df42SMark Haverkamp (void *) scsicmd); 598fe76df42SMark Haverkamp /* 599fe76df42SMark Haverkamp * Check that the command queued to the controller 600fe76df42SMark Haverkamp */ 6011a655040SSalyzyn, Mark if (status == -EINPROGRESS) 602fe76df42SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 6031a655040SSalyzyn, Mark else if (status < 0) { 604fe76df42SMark Haverkamp /* Inherit results from VM_NameServe, if any */ 605fe76df42SMark Haverkamp dresp->status = cpu_to_le32(ST_OK); 6061a655040SSalyzyn, Mark _aac_probe_container2(context, fibptr); 607fe76df42SMark Haverkamp } 608fe76df42SMark Haverkamp } 609fe76df42SMark Haverkamp 610fe76df42SMark Haverkamp static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(struct scsi_cmnd *)) 611fe76df42SMark Haverkamp { 612fe76df42SMark Haverkamp struct fib * fibptr; 613fe76df42SMark Haverkamp int status = -ENOMEM; 614fe76df42SMark Haverkamp 615fe76df42SMark Haverkamp if ((fibptr = aac_fib_alloc((struct aac_dev *)scsicmd->device->host->hostdata))) { 616fe76df42SMark Haverkamp struct aac_query_mount *dinfo; 617fe76df42SMark Haverkamp 618fe76df42SMark Haverkamp aac_fib_init(fibptr); 619fe76df42SMark Haverkamp 620fe76df42SMark Haverkamp dinfo = (struct aac_query_mount *)fib_data(fibptr); 621fe76df42SMark Haverkamp 622fe76df42SMark Haverkamp dinfo->command = cpu_to_le32(VM_NameServe); 623fe76df42SMark Haverkamp dinfo->count = cpu_to_le32(scmd_id(scsicmd)); 624fe76df42SMark Haverkamp dinfo->type = cpu_to_le32(FT_FILESYS); 625fe76df42SMark Haverkamp scsicmd->SCp.ptr = (char *)callback; 626fe76df42SMark Haverkamp 627fe76df42SMark Haverkamp status = aac_fib_send(ContainerCommand, 628fe76df42SMark Haverkamp fibptr, 629fe76df42SMark Haverkamp sizeof(struct aac_query_mount), 630fe76df42SMark Haverkamp FsaNormal, 631fe76df42SMark Haverkamp 0, 1, 6321a655040SSalyzyn, Mark _aac_probe_container1, 633fe76df42SMark Haverkamp (void *) scsicmd); 634fe76df42SMark Haverkamp /* 635fe76df42SMark Haverkamp * Check that the command queued to the controller 636fe76df42SMark Haverkamp */ 637fe76df42SMark Haverkamp if (status == -EINPROGRESS) { 638fe76df42SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 639fe76df42SMark Haverkamp return 0; 640fe76df42SMark Haverkamp } 641fe76df42SMark Haverkamp if (status < 0) { 642fe76df42SMark Haverkamp scsicmd->SCp.ptr = NULL; 643fe76df42SMark Haverkamp aac_fib_complete(fibptr); 644fe76df42SMark Haverkamp aac_fib_free(fibptr); 645fe76df42SMark Haverkamp } 646fe76df42SMark Haverkamp } 647fe76df42SMark Haverkamp if (status < 0) { 648fe76df42SMark Haverkamp struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev; 649fe76df42SMark Haverkamp if (fsa_dev_ptr) { 650fe76df42SMark Haverkamp fsa_dev_ptr += scmd_id(scsicmd); 651fe76df42SMark Haverkamp if ((fsa_dev_ptr->valid & 1) == 0) { 652fe76df42SMark Haverkamp fsa_dev_ptr->valid = 0; 653fe76df42SMark Haverkamp return (*callback)(scsicmd); 654fe76df42SMark Haverkamp } 655fe76df42SMark Haverkamp } 656fe76df42SMark Haverkamp } 657fe76df42SMark Haverkamp return status; 658fe76df42SMark Haverkamp } 659fe76df42SMark Haverkamp 6601da177e4SLinus Torvalds /** 661bfb35aa8SMark Haverkamp * aac_probe_container - query a logical volume 6621da177e4SLinus Torvalds * @dev: device to query 6631da177e4SLinus Torvalds * @cid: container identifier 6641da177e4SLinus Torvalds * 6651da177e4SLinus Torvalds * Queries the controller about the given volume. The volume information 6661da177e4SLinus Torvalds * is updated in the struct fsa_dev_info structure rather than returned. 6671da177e4SLinus Torvalds */ 668fe76df42SMark Haverkamp static int aac_probe_container_callback1(struct scsi_cmnd * scsicmd) 669fe76df42SMark Haverkamp { 670fe76df42SMark Haverkamp scsicmd->device = NULL; 671fe76df42SMark Haverkamp return 0; 672fe76df42SMark Haverkamp } 6731da177e4SLinus Torvalds 674bfb35aa8SMark Haverkamp int aac_probe_container(struct aac_dev *dev, int cid) 6751da177e4SLinus Torvalds { 676fe76df42SMark Haverkamp struct scsi_cmnd *scsicmd = kmalloc(sizeof(*scsicmd), GFP_KERNEL); 677fe76df42SMark Haverkamp struct scsi_device *scsidev = kmalloc(sizeof(*scsidev), GFP_KERNEL); 6781da177e4SLinus Torvalds int status; 6791da177e4SLinus Torvalds 680fe76df42SMark Haverkamp if (!scsicmd || !scsidev) { 681fe76df42SMark Haverkamp kfree(scsicmd); 682fe76df42SMark Haverkamp kfree(scsidev); 68390ee3466SMark Haverkamp return -ENOMEM; 6841da177e4SLinus Torvalds } 685fe76df42SMark Haverkamp scsicmd->list.next = NULL; 6861a655040SSalyzyn, Mark scsicmd->scsi_done = (void (*)(struct scsi_cmnd*))aac_probe_container_callback1; 6871da177e4SLinus Torvalds 688fe76df42SMark Haverkamp scsicmd->device = scsidev; 689fe76df42SMark Haverkamp scsidev->sdev_state = 0; 690fe76df42SMark Haverkamp scsidev->id = cid; 691fe76df42SMark Haverkamp scsidev->host = dev->scsi_host_ptr; 6921da177e4SLinus Torvalds 693fe76df42SMark Haverkamp if (_aac_probe_container(scsicmd, aac_probe_container_callback1) == 0) 694fe76df42SMark Haverkamp while (scsicmd->device == scsidev) 695fe76df42SMark Haverkamp schedule(); 696802ae2f0SSalyzyn, Mark kfree(scsidev); 697fe76df42SMark Haverkamp status = scsicmd->SCp.Status; 698fe76df42SMark Haverkamp kfree(scsicmd); 6991da177e4SLinus Torvalds return status; 7001da177e4SLinus Torvalds } 7011da177e4SLinus Torvalds 7021da177e4SLinus Torvalds /* Local Structure to set SCSI inquiry data strings */ 7031da177e4SLinus Torvalds struct scsi_inq { 7041da177e4SLinus Torvalds char vid[8]; /* Vendor ID */ 7051da177e4SLinus Torvalds char pid[16]; /* Product ID */ 7061da177e4SLinus Torvalds char prl[4]; /* Product Revision Level */ 7071da177e4SLinus Torvalds }; 7081da177e4SLinus Torvalds 7091da177e4SLinus Torvalds /** 7101da177e4SLinus Torvalds * InqStrCopy - string merge 7111da177e4SLinus Torvalds * @a: string to copy from 7121da177e4SLinus Torvalds * @b: string to copy to 7131da177e4SLinus Torvalds * 7141da177e4SLinus Torvalds * Copy a String from one location to another 7151da177e4SLinus Torvalds * without copying \0 7161da177e4SLinus Torvalds */ 7171da177e4SLinus Torvalds 7181da177e4SLinus Torvalds static void inqstrcpy(char *a, char *b) 7191da177e4SLinus Torvalds { 7201da177e4SLinus Torvalds 7211da177e4SLinus Torvalds while (*a != (char)0) 7221da177e4SLinus Torvalds *b++ = *a++; 7231da177e4SLinus Torvalds } 7241da177e4SLinus Torvalds 7251da177e4SLinus Torvalds static char *container_types[] = { 7261da177e4SLinus Torvalds "None", 7271da177e4SLinus Torvalds "Volume", 7281da177e4SLinus Torvalds "Mirror", 7291da177e4SLinus Torvalds "Stripe", 7301da177e4SLinus Torvalds "RAID5", 7311da177e4SLinus Torvalds "SSRW", 7321da177e4SLinus Torvalds "SSRO", 7331da177e4SLinus Torvalds "Morph", 7341da177e4SLinus Torvalds "Legacy", 7351da177e4SLinus Torvalds "RAID4", 7361da177e4SLinus Torvalds "RAID10", 7371da177e4SLinus Torvalds "RAID00", 7381da177e4SLinus Torvalds "V-MIRRORS", 7391da177e4SLinus Torvalds "PSEUDO R4", 7401da177e4SLinus Torvalds "RAID50", 74184971738SMark Haverkamp "RAID5D", 74284971738SMark Haverkamp "RAID5D0", 74384971738SMark Haverkamp "RAID1E", 74484971738SMark Haverkamp "RAID6", 74584971738SMark Haverkamp "RAID60", 7461da177e4SLinus Torvalds "Unknown" 7471da177e4SLinus Torvalds }; 7481da177e4SLinus Torvalds 74917eaaceeSSalyzyn, Mark char * get_container_type(unsigned tindex) 75017eaaceeSSalyzyn, Mark { 75117eaaceeSSalyzyn, Mark if (tindex >= ARRAY_SIZE(container_types)) 75217eaaceeSSalyzyn, Mark tindex = ARRAY_SIZE(container_types) - 1; 75317eaaceeSSalyzyn, Mark return container_types[tindex]; 75417eaaceeSSalyzyn, Mark } 7551da177e4SLinus Torvalds 7561da177e4SLinus Torvalds /* Function: setinqstr 7571da177e4SLinus Torvalds * 7581da177e4SLinus Torvalds * Arguments: [1] pointer to void [1] int 7591da177e4SLinus Torvalds * 7601da177e4SLinus Torvalds * Purpose: Sets SCSI inquiry data strings for vendor, product 76125985edcSLucas De Marchi * and revision level. Allows strings to be set in platform dependent 76225985edcSLucas De Marchi * files instead of in OS dependent driver source. 7631da177e4SLinus Torvalds */ 7641da177e4SLinus Torvalds 765794d0601SMark Haverkamp static void setinqstr(struct aac_dev *dev, void *data, int tindex) 7661da177e4SLinus Torvalds { 7671da177e4SLinus Torvalds struct scsi_inq *str; 7681da177e4SLinus Torvalds 7691da177e4SLinus Torvalds str = (struct scsi_inq *)(data); /* cast data to scsi inq block */ 770794d0601SMark Haverkamp memset(str, ' ', sizeof(*str)); 771794d0601SMark Haverkamp 772794d0601SMark Haverkamp if (dev->supplement_adapter_info.AdapterTypeText[0]) { 773794d0601SMark Haverkamp char * cp = dev->supplement_adapter_info.AdapterTypeText; 7743bc8070fSSalyzyn, Mark int c; 7753bc8070fSSalyzyn, Mark if ((cp[0] == 'A') && (cp[1] == 'O') && (cp[2] == 'C')) 7763bc8070fSSalyzyn, Mark inqstrcpy("SMC", str->vid); 7773bc8070fSSalyzyn, Mark else { 7783bc8070fSSalyzyn, Mark c = sizeof(str->vid); 779794d0601SMark Haverkamp while (*cp && *cp != ' ' && --c) 780794d0601SMark Haverkamp ++cp; 781794d0601SMark Haverkamp c = *cp; 782794d0601SMark Haverkamp *cp = '\0'; 783794d0601SMark Haverkamp inqstrcpy (dev->supplement_adapter_info.AdapterTypeText, 784794d0601SMark Haverkamp str->vid); 785794d0601SMark Haverkamp *cp = c; 786794d0601SMark Haverkamp while (*cp && *cp != ' ') 787794d0601SMark Haverkamp ++cp; 7883bc8070fSSalyzyn, Mark } 789794d0601SMark Haverkamp while (*cp == ' ') 790794d0601SMark Haverkamp ++cp; 791794d0601SMark Haverkamp /* last six chars reserved for vol type */ 792794d0601SMark Haverkamp c = 0; 793794d0601SMark Haverkamp if (strlen(cp) > sizeof(str->pid)) { 794794d0601SMark Haverkamp c = cp[sizeof(str->pid)]; 795794d0601SMark Haverkamp cp[sizeof(str->pid)] = '\0'; 796794d0601SMark Haverkamp } 797794d0601SMark Haverkamp inqstrcpy (cp, str->pid); 798794d0601SMark Haverkamp if (c) 799794d0601SMark Haverkamp cp[sizeof(str->pid)] = c; 800794d0601SMark Haverkamp } else { 801794d0601SMark Haverkamp struct aac_driver_ident *mp = aac_get_driver_ident(dev->cardtype); 8021da177e4SLinus Torvalds 8031da177e4SLinus Torvalds inqstrcpy (mp->vname, str->vid); 804794d0601SMark Haverkamp /* last six chars reserved for vol type */ 805794d0601SMark Haverkamp inqstrcpy (mp->model, str->pid); 806794d0601SMark Haverkamp } 8071da177e4SLinus Torvalds 8086391a113STobias Klauser if (tindex < ARRAY_SIZE(container_types)){ 8091da177e4SLinus Torvalds char *findit = str->pid; 8101da177e4SLinus Torvalds 8111da177e4SLinus Torvalds for ( ; *findit != ' '; findit++); /* walk till we find a space */ 8121da177e4SLinus Torvalds /* RAID is superfluous in the context of a RAID device */ 8131da177e4SLinus Torvalds if (memcmp(findit-4, "RAID", 4) == 0) 8141da177e4SLinus Torvalds *(findit -= 4) = ' '; 815794d0601SMark Haverkamp if (((findit - str->pid) + strlen(container_types[tindex])) 816794d0601SMark Haverkamp < (sizeof(str->pid) + sizeof(str->prl))) 8171da177e4SLinus Torvalds inqstrcpy (container_types[tindex], findit + 1); 8181da177e4SLinus Torvalds } 8191da177e4SLinus Torvalds inqstrcpy ("V1.0", str->prl); 8201da177e4SLinus Torvalds } 8211da177e4SLinus Torvalds 82288e2f98eSSalyzyn, Mark static void get_container_serial_callback(void *context, struct fib * fibptr) 82388e2f98eSSalyzyn, Mark { 82488e2f98eSSalyzyn, Mark struct aac_get_serial_resp * get_serial_reply; 82588e2f98eSSalyzyn, Mark struct scsi_cmnd * scsicmd; 82688e2f98eSSalyzyn, Mark 82788e2f98eSSalyzyn, Mark BUG_ON(fibptr == NULL); 82888e2f98eSSalyzyn, Mark 82988e2f98eSSalyzyn, Mark scsicmd = (struct scsi_cmnd *) context; 83088e2f98eSSalyzyn, Mark if (!aac_valid_context(scsicmd, fibptr)) 83188e2f98eSSalyzyn, Mark return; 83288e2f98eSSalyzyn, Mark 83388e2f98eSSalyzyn, Mark get_serial_reply = (struct aac_get_serial_resp *) fib_data(fibptr); 83488e2f98eSSalyzyn, Mark /* Failure is irrelevant, using default value instead */ 83588e2f98eSSalyzyn, Mark if (le32_to_cpu(get_serial_reply->status) == CT_OK) { 83688e2f98eSSalyzyn, Mark char sp[13]; 83788e2f98eSSalyzyn, Mark /* EVPD bit set */ 83888e2f98eSSalyzyn, Mark sp[0] = INQD_PDT_DA; 83988e2f98eSSalyzyn, Mark sp[1] = scsicmd->cmnd[2]; 84088e2f98eSSalyzyn, Mark sp[2] = 0; 84188e2f98eSSalyzyn, Mark sp[3] = snprintf(sp+4, sizeof(sp)-4, "%08X", 84288e2f98eSSalyzyn, Mark le32_to_cpu(get_serial_reply->uid)); 843d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, sp, sizeof(sp)); 84488e2f98eSSalyzyn, Mark } 84588e2f98eSSalyzyn, Mark 84688e2f98eSSalyzyn, Mark scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 84788e2f98eSSalyzyn, Mark 84888e2f98eSSalyzyn, Mark aac_fib_complete(fibptr); 84988e2f98eSSalyzyn, Mark aac_fib_free(fibptr); 85088e2f98eSSalyzyn, Mark scsicmd->scsi_done(scsicmd); 85188e2f98eSSalyzyn, Mark } 85288e2f98eSSalyzyn, Mark 85388e2f98eSSalyzyn, Mark /** 85488e2f98eSSalyzyn, Mark * aac_get_container_serial - get container serial, none blocking. 85588e2f98eSSalyzyn, Mark */ 85688e2f98eSSalyzyn, Mark static int aac_get_container_serial(struct scsi_cmnd * scsicmd) 85788e2f98eSSalyzyn, Mark { 85888e2f98eSSalyzyn, Mark int status; 85988e2f98eSSalyzyn, Mark struct aac_get_serial *dinfo; 86088e2f98eSSalyzyn, Mark struct fib * cmd_fibcontext; 86188e2f98eSSalyzyn, Mark struct aac_dev * dev; 86288e2f98eSSalyzyn, Mark 86388e2f98eSSalyzyn, Mark dev = (struct aac_dev *)scsicmd->device->host->hostdata; 86488e2f98eSSalyzyn, Mark 86588e2f98eSSalyzyn, Mark if (!(cmd_fibcontext = aac_fib_alloc(dev))) 86688e2f98eSSalyzyn, Mark return -ENOMEM; 86788e2f98eSSalyzyn, Mark 86888e2f98eSSalyzyn, Mark aac_fib_init(cmd_fibcontext); 86988e2f98eSSalyzyn, Mark dinfo = (struct aac_get_serial *) fib_data(cmd_fibcontext); 87088e2f98eSSalyzyn, Mark 87188e2f98eSSalyzyn, Mark dinfo->command = cpu_to_le32(VM_ContainerConfig); 87288e2f98eSSalyzyn, Mark dinfo->type = cpu_to_le32(CT_CID_TO_32BITS_UID); 87388e2f98eSSalyzyn, Mark dinfo->cid = cpu_to_le32(scmd_id(scsicmd)); 87488e2f98eSSalyzyn, Mark 87588e2f98eSSalyzyn, Mark status = aac_fib_send(ContainerCommand, 87688e2f98eSSalyzyn, Mark cmd_fibcontext, 87788e2f98eSSalyzyn, Mark sizeof (struct aac_get_serial), 87888e2f98eSSalyzyn, Mark FsaNormal, 87988e2f98eSSalyzyn, Mark 0, 1, 88088e2f98eSSalyzyn, Mark (fib_callback) get_container_serial_callback, 88188e2f98eSSalyzyn, Mark (void *) scsicmd); 88288e2f98eSSalyzyn, Mark 88388e2f98eSSalyzyn, Mark /* 88488e2f98eSSalyzyn, Mark * Check that the command queued to the controller 88588e2f98eSSalyzyn, Mark */ 88688e2f98eSSalyzyn, Mark if (status == -EINPROGRESS) { 88788e2f98eSSalyzyn, Mark scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 88888e2f98eSSalyzyn, Mark return 0; 88988e2f98eSSalyzyn, Mark } 89088e2f98eSSalyzyn, Mark 89188e2f98eSSalyzyn, Mark printk(KERN_WARNING "aac_get_container_serial: aac_fib_send failed with status: %d.\n", status); 89288e2f98eSSalyzyn, Mark aac_fib_complete(cmd_fibcontext); 89388e2f98eSSalyzyn, Mark aac_fib_free(cmd_fibcontext); 89488e2f98eSSalyzyn, Mark return -1; 89588e2f98eSSalyzyn, Mark } 89688e2f98eSSalyzyn, Mark 89788e2f98eSSalyzyn, Mark /* Function: setinqserial 89888e2f98eSSalyzyn, Mark * 89988e2f98eSSalyzyn, Mark * Arguments: [1] pointer to void [1] int 90088e2f98eSSalyzyn, Mark * 90188e2f98eSSalyzyn, Mark * Purpose: Sets SCSI Unit Serial number. 90288e2f98eSSalyzyn, Mark * This is a fake. We should read a proper 90388e2f98eSSalyzyn, Mark * serial number from the container. <SuSE>But 90488e2f98eSSalyzyn, Mark * without docs it's quite hard to do it :-) 90588e2f98eSSalyzyn, Mark * So this will have to do in the meantime.</SuSE> 90688e2f98eSSalyzyn, Mark */ 90788e2f98eSSalyzyn, Mark 90888e2f98eSSalyzyn, Mark static int setinqserial(struct aac_dev *dev, void *data, int cid) 90988e2f98eSSalyzyn, Mark { 91088e2f98eSSalyzyn, Mark /* 91188e2f98eSSalyzyn, Mark * This breaks array migration. 91288e2f98eSSalyzyn, Mark */ 91388e2f98eSSalyzyn, Mark return snprintf((char *)(data), sizeof(struct scsi_inq) - 4, "%08X%02X", 91488e2f98eSSalyzyn, Mark le32_to_cpu(dev->adapter_info.serial[0]), cid); 91588e2f98eSSalyzyn, Mark } 91688e2f98eSSalyzyn, Mark 9178e31e607SSalyzyn, Mark static inline void set_sense(struct sense_data *sense_data, u8 sense_key, 9188e31e607SSalyzyn, Mark u8 sense_code, u8 a_sense_code, u8 bit_pointer, u16 field_pointer) 9191da177e4SLinus Torvalds { 9208e31e607SSalyzyn, Mark u8 *sense_buf = (u8 *)sense_data; 9218e31e607SSalyzyn, Mark /* Sense data valid, err code 70h */ 9228e31e607SSalyzyn, Mark sense_buf[0] = 0x70; /* No info field */ 9231da177e4SLinus Torvalds sense_buf[1] = 0; /* Segment number, always zero */ 9241da177e4SLinus Torvalds 9251da177e4SLinus Torvalds sense_buf[2] = sense_key; /* Sense key */ 9261da177e4SLinus Torvalds 9271da177e4SLinus Torvalds sense_buf[12] = sense_code; /* Additional sense code */ 9281da177e4SLinus Torvalds sense_buf[13] = a_sense_code; /* Additional sense code qualifier */ 9298e31e607SSalyzyn, Mark 9301da177e4SLinus Torvalds if (sense_key == ILLEGAL_REQUEST) { 9318e31e607SSalyzyn, Mark sense_buf[7] = 10; /* Additional sense length */ 9321da177e4SLinus Torvalds 9338e31e607SSalyzyn, Mark sense_buf[15] = bit_pointer; 9341da177e4SLinus Torvalds /* Illegal parameter is in the parameter block */ 9351da177e4SLinus Torvalds if (sense_code == SENCODE_INVALID_CDB_FIELD) 9368e31e607SSalyzyn, Mark sense_buf[15] |= 0xc0;/* Std sense key specific field */ 9371da177e4SLinus Torvalds /* Illegal parameter is in the CDB block */ 9381da177e4SLinus Torvalds sense_buf[16] = field_pointer >> 8; /* MSB */ 9391da177e4SLinus Torvalds sense_buf[17] = field_pointer; /* LSB */ 9408e31e607SSalyzyn, Mark } else 9418e31e607SSalyzyn, Mark sense_buf[7] = 6; /* Additional sense length */ 9421da177e4SLinus Torvalds } 9431da177e4SLinus Torvalds 944e8f32de5SMark Haverkamp static int aac_bounds_32(struct aac_dev * dev, struct scsi_cmnd * cmd, u64 lba) 945e8f32de5SMark Haverkamp { 946e8f32de5SMark Haverkamp if (lba & 0xffffffff00000000LL) { 947e8f32de5SMark Haverkamp int cid = scmd_id(cmd); 948e8f32de5SMark Haverkamp dprintk((KERN_DEBUG "aacraid: Illegal lba\n")); 949e8f32de5SMark Haverkamp cmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 950e8f32de5SMark Haverkamp SAM_STAT_CHECK_CONDITION; 9518e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 9528e31e607SSalyzyn, Mark HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 9538e31e607SSalyzyn, Mark ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 954e8f32de5SMark Haverkamp memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 9553ace426fSSalyzyn, Mark min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 9563ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE)); 957e8f32de5SMark Haverkamp cmd->scsi_done(cmd); 958e8f32de5SMark Haverkamp return 1; 959e8f32de5SMark Haverkamp } 960e8f32de5SMark Haverkamp return 0; 961e8f32de5SMark Haverkamp } 962e8f32de5SMark Haverkamp 963e8f32de5SMark Haverkamp static int aac_bounds_64(struct aac_dev * dev, struct scsi_cmnd * cmd, u64 lba) 964e8f32de5SMark Haverkamp { 965e8f32de5SMark Haverkamp return 0; 966e8f32de5SMark Haverkamp } 967e8f32de5SMark Haverkamp 968e8f32de5SMark Haverkamp static void io_callback(void *context, struct fib * fibptr); 969e8f32de5SMark Haverkamp 970e8f32de5SMark Haverkamp static int aac_read_raw_io(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 971e8f32de5SMark Haverkamp { 97285d22bbfSMahesh Rajashekhara struct aac_dev *dev = fib->dev; 97385d22bbfSMahesh Rajashekhara u16 fibsize, command; 97485d22bbfSMahesh Rajashekhara 975e8f32de5SMark Haverkamp aac_fib_init(fib); 97685d22bbfSMahesh Rajashekhara if (dev->comm_interface == AAC_COMM_MESSAGE_TYPE2 && !dev->sync_mode) { 97785d22bbfSMahesh Rajashekhara struct aac_raw_io2 *readcmd2; 97885d22bbfSMahesh Rajashekhara readcmd2 = (struct aac_raw_io2 *) fib_data(fib); 97985d22bbfSMahesh Rajashekhara memset(readcmd2, 0, sizeof(struct aac_raw_io2)); 98085d22bbfSMahesh Rajashekhara readcmd2->blockLow = cpu_to_le32((u32)(lba&0xffffffff)); 98185d22bbfSMahesh Rajashekhara readcmd2->blockHigh = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 98285d22bbfSMahesh Rajashekhara readcmd2->byteCount = cpu_to_le32(count<<9); 98385d22bbfSMahesh Rajashekhara readcmd2->cid = cpu_to_le16(scmd_id(cmd)); 98485d22bbfSMahesh Rajashekhara readcmd2->flags = cpu_to_le16(RIO2_IO_TYPE_READ); 98585d22bbfSMahesh Rajashekhara aac_build_sgraw2(cmd, readcmd2, dev->scsi_host_ptr->sg_tablesize); 98685d22bbfSMahesh Rajashekhara command = ContainerRawIo2; 98785d22bbfSMahesh Rajashekhara fibsize = sizeof(struct aac_raw_io2) + 98885d22bbfSMahesh Rajashekhara ((le32_to_cpu(readcmd2->sgeCnt)-1) * sizeof(struct sge_ieee1212)); 98985d22bbfSMahesh Rajashekhara } else { 99085d22bbfSMahesh Rajashekhara struct aac_raw_io *readcmd; 991e8f32de5SMark Haverkamp readcmd = (struct aac_raw_io *) fib_data(fib); 992e8f32de5SMark Haverkamp readcmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff)); 993e8f32de5SMark Haverkamp readcmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 994e8f32de5SMark Haverkamp readcmd->count = cpu_to_le32(count<<9); 995e8f32de5SMark Haverkamp readcmd->cid = cpu_to_le16(scmd_id(cmd)); 99685d22bbfSMahesh Rajashekhara readcmd->flags = cpu_to_le16(RIO_TYPE_READ); 997e8f32de5SMark Haverkamp readcmd->bpTotal = 0; 998e8f32de5SMark Haverkamp readcmd->bpComplete = 0; 999e8f32de5SMark Haverkamp aac_build_sgraw(cmd, &readcmd->sg); 100085d22bbfSMahesh Rajashekhara command = ContainerRawIo; 100185d22bbfSMahesh Rajashekhara fibsize = sizeof(struct aac_raw_io) + 100285d22bbfSMahesh Rajashekhara ((le32_to_cpu(readcmd->sg.count)-1) * sizeof(struct sgentryraw)); 100385d22bbfSMahesh Rajashekhara } 100485d22bbfSMahesh Rajashekhara 1005e8f32de5SMark Haverkamp BUG_ON(fibsize > (fib->dev->max_fib_size - sizeof(struct aac_fibhdr))); 1006e8f32de5SMark Haverkamp /* 1007e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1008e8f32de5SMark Haverkamp */ 100985d22bbfSMahesh Rajashekhara return aac_fib_send(command, 1010e8f32de5SMark Haverkamp fib, 1011e8f32de5SMark Haverkamp fibsize, 1012e8f32de5SMark Haverkamp FsaNormal, 1013e8f32de5SMark Haverkamp 0, 1, 1014e8f32de5SMark Haverkamp (fib_callback) io_callback, 1015e8f32de5SMark Haverkamp (void *) cmd); 1016e8f32de5SMark Haverkamp } 1017e8f32de5SMark Haverkamp 1018e8f32de5SMark Haverkamp static int aac_read_block64(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 1019e8f32de5SMark Haverkamp { 1020e8f32de5SMark Haverkamp u16 fibsize; 1021e8f32de5SMark Haverkamp struct aac_read64 *readcmd; 1022e8f32de5SMark Haverkamp aac_fib_init(fib); 1023e8f32de5SMark Haverkamp readcmd = (struct aac_read64 *) fib_data(fib); 1024e8f32de5SMark Haverkamp readcmd->command = cpu_to_le32(VM_CtHostRead64); 1025e8f32de5SMark Haverkamp readcmd->cid = cpu_to_le16(scmd_id(cmd)); 1026e8f32de5SMark Haverkamp readcmd->sector_count = cpu_to_le16(count); 1027e8f32de5SMark Haverkamp readcmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1028e8f32de5SMark Haverkamp readcmd->pad = 0; 1029e8f32de5SMark Haverkamp readcmd->flags = 0; 1030e8f32de5SMark Haverkamp 1031e8f32de5SMark Haverkamp aac_build_sg64(cmd, &readcmd->sg); 1032e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_read64) + 1033e8f32de5SMark Haverkamp ((le32_to_cpu(readcmd->sg.count) - 1) * 1034e8f32de5SMark Haverkamp sizeof (struct sgentry64)); 1035e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1036e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1037e8f32de5SMark Haverkamp /* 1038e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1039e8f32de5SMark Haverkamp */ 1040e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand64, 1041e8f32de5SMark Haverkamp fib, 1042e8f32de5SMark Haverkamp fibsize, 1043e8f32de5SMark Haverkamp FsaNormal, 1044e8f32de5SMark Haverkamp 0, 1, 1045e8f32de5SMark Haverkamp (fib_callback) io_callback, 1046e8f32de5SMark Haverkamp (void *) cmd); 1047e8f32de5SMark Haverkamp } 1048e8f32de5SMark Haverkamp 1049e8f32de5SMark Haverkamp static int aac_read_block(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 1050e8f32de5SMark Haverkamp { 1051e8f32de5SMark Haverkamp u16 fibsize; 1052e8f32de5SMark Haverkamp struct aac_read *readcmd; 1053e8f32de5SMark Haverkamp aac_fib_init(fib); 1054e8f32de5SMark Haverkamp readcmd = (struct aac_read *) fib_data(fib); 1055e8f32de5SMark Haverkamp readcmd->command = cpu_to_le32(VM_CtBlockRead); 1056f3307f72SChristoph Hellwig readcmd->cid = cpu_to_le32(scmd_id(cmd)); 1057e8f32de5SMark Haverkamp readcmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1058e8f32de5SMark Haverkamp readcmd->count = cpu_to_le32(count * 512); 1059e8f32de5SMark Haverkamp 1060e8f32de5SMark Haverkamp aac_build_sg(cmd, &readcmd->sg); 1061e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_read) + 1062e8f32de5SMark Haverkamp ((le32_to_cpu(readcmd->sg.count) - 1) * 1063e8f32de5SMark Haverkamp sizeof (struct sgentry)); 1064e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1065e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1066e8f32de5SMark Haverkamp /* 1067e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1068e8f32de5SMark Haverkamp */ 1069e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand, 1070e8f32de5SMark Haverkamp fib, 1071e8f32de5SMark Haverkamp fibsize, 1072e8f32de5SMark Haverkamp FsaNormal, 1073e8f32de5SMark Haverkamp 0, 1, 1074e8f32de5SMark Haverkamp (fib_callback) io_callback, 1075e8f32de5SMark Haverkamp (void *) cmd); 1076e8f32de5SMark Haverkamp } 1077e8f32de5SMark Haverkamp 10789d399cc7SSalyzyn, Mark static int aac_write_raw_io(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua) 1079e8f32de5SMark Haverkamp { 108085d22bbfSMahesh Rajashekhara struct aac_dev *dev = fib->dev; 108185d22bbfSMahesh Rajashekhara u16 fibsize, command; 108285d22bbfSMahesh Rajashekhara 1083e8f32de5SMark Haverkamp aac_fib_init(fib); 108485d22bbfSMahesh Rajashekhara if (dev->comm_interface == AAC_COMM_MESSAGE_TYPE2 && !dev->sync_mode) { 108585d22bbfSMahesh Rajashekhara struct aac_raw_io2 *writecmd2; 108685d22bbfSMahesh Rajashekhara writecmd2 = (struct aac_raw_io2 *) fib_data(fib); 108785d22bbfSMahesh Rajashekhara memset(writecmd2, 0, sizeof(struct aac_raw_io2)); 108885d22bbfSMahesh Rajashekhara writecmd2->blockLow = cpu_to_le32((u32)(lba&0xffffffff)); 108985d22bbfSMahesh Rajashekhara writecmd2->blockHigh = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 109085d22bbfSMahesh Rajashekhara writecmd2->byteCount = cpu_to_le32(count<<9); 109185d22bbfSMahesh Rajashekhara writecmd2->cid = cpu_to_le16(scmd_id(cmd)); 109285d22bbfSMahesh Rajashekhara writecmd2->flags = (fua && ((aac_cache & 5) != 1) && 109385d22bbfSMahesh Rajashekhara (((aac_cache & 5) != 5) || !fib->dev->cache_protected)) ? 109485d22bbfSMahesh Rajashekhara cpu_to_le16(RIO2_IO_TYPE_WRITE|RIO2_IO_SUREWRITE) : 109585d22bbfSMahesh Rajashekhara cpu_to_le16(RIO2_IO_TYPE_WRITE); 109685d22bbfSMahesh Rajashekhara aac_build_sgraw2(cmd, writecmd2, dev->scsi_host_ptr->sg_tablesize); 109785d22bbfSMahesh Rajashekhara command = ContainerRawIo2; 109885d22bbfSMahesh Rajashekhara fibsize = sizeof(struct aac_raw_io2) + 109985d22bbfSMahesh Rajashekhara ((le32_to_cpu(writecmd2->sgeCnt)-1) * sizeof(struct sge_ieee1212)); 110085d22bbfSMahesh Rajashekhara } else { 110185d22bbfSMahesh Rajashekhara struct aac_raw_io *writecmd; 1102e8f32de5SMark Haverkamp writecmd = (struct aac_raw_io *) fib_data(fib); 1103e8f32de5SMark Haverkamp writecmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff)); 1104e8f32de5SMark Haverkamp writecmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 1105e8f32de5SMark Haverkamp writecmd->count = cpu_to_le32(count<<9); 1106e8f32de5SMark Haverkamp writecmd->cid = cpu_to_le16(scmd_id(cmd)); 110795e852e1SSalyzyn, Mark writecmd->flags = (fua && ((aac_cache & 5) != 1) && 110895e852e1SSalyzyn, Mark (((aac_cache & 5) != 5) || !fib->dev->cache_protected)) ? 110985d22bbfSMahesh Rajashekhara cpu_to_le16(RIO_TYPE_WRITE|RIO_SUREWRITE) : 111085d22bbfSMahesh Rajashekhara cpu_to_le16(RIO_TYPE_WRITE); 1111e8f32de5SMark Haverkamp writecmd->bpTotal = 0; 1112e8f32de5SMark Haverkamp writecmd->bpComplete = 0; 1113e8f32de5SMark Haverkamp aac_build_sgraw(cmd, &writecmd->sg); 111485d22bbfSMahesh Rajashekhara command = ContainerRawIo; 111585d22bbfSMahesh Rajashekhara fibsize = sizeof(struct aac_raw_io) + 111685d22bbfSMahesh Rajashekhara ((le32_to_cpu(writecmd->sg.count)-1) * sizeof (struct sgentryraw)); 111785d22bbfSMahesh Rajashekhara } 111885d22bbfSMahesh Rajashekhara 1119e8f32de5SMark Haverkamp BUG_ON(fibsize > (fib->dev->max_fib_size - sizeof(struct aac_fibhdr))); 1120e8f32de5SMark Haverkamp /* 1121e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1122e8f32de5SMark Haverkamp */ 112385d22bbfSMahesh Rajashekhara return aac_fib_send(command, 1124e8f32de5SMark Haverkamp fib, 1125e8f32de5SMark Haverkamp fibsize, 1126e8f32de5SMark Haverkamp FsaNormal, 1127e8f32de5SMark Haverkamp 0, 1, 1128e8f32de5SMark Haverkamp (fib_callback) io_callback, 1129e8f32de5SMark Haverkamp (void *) cmd); 1130e8f32de5SMark Haverkamp } 1131e8f32de5SMark Haverkamp 11329d399cc7SSalyzyn, Mark static int aac_write_block64(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua) 1133e8f32de5SMark Haverkamp { 1134e8f32de5SMark Haverkamp u16 fibsize; 1135e8f32de5SMark Haverkamp struct aac_write64 *writecmd; 1136e8f32de5SMark Haverkamp aac_fib_init(fib); 1137e8f32de5SMark Haverkamp writecmd = (struct aac_write64 *) fib_data(fib); 1138e8f32de5SMark Haverkamp writecmd->command = cpu_to_le32(VM_CtHostWrite64); 1139e8f32de5SMark Haverkamp writecmd->cid = cpu_to_le16(scmd_id(cmd)); 1140e8f32de5SMark Haverkamp writecmd->sector_count = cpu_to_le16(count); 1141e8f32de5SMark Haverkamp writecmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1142e8f32de5SMark Haverkamp writecmd->pad = 0; 1143e8f32de5SMark Haverkamp writecmd->flags = 0; 1144e8f32de5SMark Haverkamp 1145e8f32de5SMark Haverkamp aac_build_sg64(cmd, &writecmd->sg); 1146e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_write64) + 1147e8f32de5SMark Haverkamp ((le32_to_cpu(writecmd->sg.count) - 1) * 1148e8f32de5SMark Haverkamp sizeof (struct sgentry64)); 1149e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1150e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1151e8f32de5SMark Haverkamp /* 1152e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1153e8f32de5SMark Haverkamp */ 1154e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand64, 1155e8f32de5SMark Haverkamp fib, 1156e8f32de5SMark Haverkamp fibsize, 1157e8f32de5SMark Haverkamp FsaNormal, 1158e8f32de5SMark Haverkamp 0, 1, 1159e8f32de5SMark Haverkamp (fib_callback) io_callback, 1160e8f32de5SMark Haverkamp (void *) cmd); 1161e8f32de5SMark Haverkamp } 1162e8f32de5SMark Haverkamp 11639d399cc7SSalyzyn, Mark static int aac_write_block(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua) 1164e8f32de5SMark Haverkamp { 1165e8f32de5SMark Haverkamp u16 fibsize; 1166e8f32de5SMark Haverkamp struct aac_write *writecmd; 1167e8f32de5SMark Haverkamp aac_fib_init(fib); 1168e8f32de5SMark Haverkamp writecmd = (struct aac_write *) fib_data(fib); 1169e8f32de5SMark Haverkamp writecmd->command = cpu_to_le32(VM_CtBlockWrite); 1170f3307f72SChristoph Hellwig writecmd->cid = cpu_to_le32(scmd_id(cmd)); 1171e8f32de5SMark Haverkamp writecmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1172e8f32de5SMark Haverkamp writecmd->count = cpu_to_le32(count * 512); 1173e8f32de5SMark Haverkamp writecmd->sg.count = cpu_to_le32(1); 1174e8f32de5SMark Haverkamp /* ->stable is not used - it did mean which type of write */ 1175e8f32de5SMark Haverkamp 1176e8f32de5SMark Haverkamp aac_build_sg(cmd, &writecmd->sg); 1177e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_write) + 1178e8f32de5SMark Haverkamp ((le32_to_cpu(writecmd->sg.count) - 1) * 1179e8f32de5SMark Haverkamp sizeof (struct sgentry)); 1180e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1181e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1182e8f32de5SMark Haverkamp /* 1183e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1184e8f32de5SMark Haverkamp */ 1185e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand, 1186e8f32de5SMark Haverkamp fib, 1187e8f32de5SMark Haverkamp fibsize, 1188e8f32de5SMark Haverkamp FsaNormal, 1189e8f32de5SMark Haverkamp 0, 1, 1190e8f32de5SMark Haverkamp (fib_callback) io_callback, 1191e8f32de5SMark Haverkamp (void *) cmd); 1192e8f32de5SMark Haverkamp } 1193e8f32de5SMark Haverkamp 1194e8f32de5SMark Haverkamp static struct aac_srb * aac_scsi_common(struct fib * fib, struct scsi_cmnd * cmd) 1195e8f32de5SMark Haverkamp { 1196e8f32de5SMark Haverkamp struct aac_srb * srbcmd; 1197e8f32de5SMark Haverkamp u32 flag; 1198e8f32de5SMark Haverkamp u32 timeout; 1199e8f32de5SMark Haverkamp 1200e8f32de5SMark Haverkamp aac_fib_init(fib); 1201e8f32de5SMark Haverkamp switch(cmd->sc_data_direction){ 1202e8f32de5SMark Haverkamp case DMA_TO_DEVICE: 1203e8f32de5SMark Haverkamp flag = SRB_DataOut; 1204e8f32de5SMark Haverkamp break; 1205e8f32de5SMark Haverkamp case DMA_BIDIRECTIONAL: 1206e8f32de5SMark Haverkamp flag = SRB_DataIn | SRB_DataOut; 1207e8f32de5SMark Haverkamp break; 1208e8f32de5SMark Haverkamp case DMA_FROM_DEVICE: 1209e8f32de5SMark Haverkamp flag = SRB_DataIn; 1210e8f32de5SMark Haverkamp break; 1211e8f32de5SMark Haverkamp case DMA_NONE: 1212e8f32de5SMark Haverkamp default: /* shuts up some versions of gcc */ 1213e8f32de5SMark Haverkamp flag = SRB_NoDataXfer; 1214e8f32de5SMark Haverkamp break; 1215e8f32de5SMark Haverkamp } 1216e8f32de5SMark Haverkamp 1217e8f32de5SMark Haverkamp srbcmd = (struct aac_srb*) fib_data(fib); 1218e8f32de5SMark Haverkamp srbcmd->function = cpu_to_le32(SRBF_ExecuteScsi); 1219e8f32de5SMark Haverkamp srbcmd->channel = cpu_to_le32(aac_logical_to_phys(scmd_channel(cmd))); 1220e8f32de5SMark Haverkamp srbcmd->id = cpu_to_le32(scmd_id(cmd)); 1221e8f32de5SMark Haverkamp srbcmd->lun = cpu_to_le32(cmd->device->lun); 1222e8f32de5SMark Haverkamp srbcmd->flags = cpu_to_le32(flag); 1223242f9dcbSJens Axboe timeout = cmd->request->timeout/HZ; 1224e8f32de5SMark Haverkamp if (timeout == 0) 1225e8f32de5SMark Haverkamp timeout = 1; 1226e8f32de5SMark Haverkamp srbcmd->timeout = cpu_to_le32(timeout); // timeout in seconds 1227e8f32de5SMark Haverkamp srbcmd->retry_limit = 0; /* Obsolete parameter */ 1228e8f32de5SMark Haverkamp srbcmd->cdb_size = cpu_to_le32(cmd->cmd_len); 1229e8f32de5SMark Haverkamp return srbcmd; 1230e8f32de5SMark Haverkamp } 1231e8f32de5SMark Haverkamp 1232e8f32de5SMark Haverkamp static void aac_srb_callback(void *context, struct fib * fibptr); 1233e8f32de5SMark Haverkamp 1234e8f32de5SMark Haverkamp static int aac_scsi_64(struct fib * fib, struct scsi_cmnd * cmd) 1235e8f32de5SMark Haverkamp { 1236e8f32de5SMark Haverkamp u16 fibsize; 1237e8f32de5SMark Haverkamp struct aac_srb * srbcmd = aac_scsi_common(fib, cmd); 1238e8f32de5SMark Haverkamp 1239e8f32de5SMark Haverkamp aac_build_sg64(cmd, (struct sgmap64*) &srbcmd->sg); 1240727eead6SFUJITA Tomonori srbcmd->count = cpu_to_le32(scsi_bufflen(cmd)); 1241e8f32de5SMark Haverkamp 1242e8f32de5SMark Haverkamp memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb)); 1243e8f32de5SMark Haverkamp memcpy(srbcmd->cdb, cmd->cmnd, cmd->cmd_len); 1244e8f32de5SMark Haverkamp /* 1245e8f32de5SMark Haverkamp * Build Scatter/Gather list 1246e8f32de5SMark Haverkamp */ 1247e8f32de5SMark Haverkamp fibsize = sizeof (struct aac_srb) - sizeof (struct sgentry) + 1248e8f32de5SMark Haverkamp ((le32_to_cpu(srbcmd->sg.count) & 0xff) * 1249e8f32de5SMark Haverkamp sizeof (struct sgentry64)); 1250e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1251e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1252e8f32de5SMark Haverkamp 1253e8f32de5SMark Haverkamp /* 1254e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1255e8f32de5SMark Haverkamp */ 1256e8f32de5SMark Haverkamp return aac_fib_send(ScsiPortCommand64, fib, 1257e8f32de5SMark Haverkamp fibsize, FsaNormal, 0, 1, 1258e8f32de5SMark Haverkamp (fib_callback) aac_srb_callback, 1259e8f32de5SMark Haverkamp (void *) cmd); 1260e8f32de5SMark Haverkamp } 1261e8f32de5SMark Haverkamp 1262e8f32de5SMark Haverkamp static int aac_scsi_32(struct fib * fib, struct scsi_cmnd * cmd) 1263e8f32de5SMark Haverkamp { 1264e8f32de5SMark Haverkamp u16 fibsize; 1265e8f32de5SMark Haverkamp struct aac_srb * srbcmd = aac_scsi_common(fib, cmd); 1266e8f32de5SMark Haverkamp 1267e8f32de5SMark Haverkamp aac_build_sg(cmd, (struct sgmap*)&srbcmd->sg); 1268727eead6SFUJITA Tomonori srbcmd->count = cpu_to_le32(scsi_bufflen(cmd)); 1269e8f32de5SMark Haverkamp 1270e8f32de5SMark Haverkamp memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb)); 1271e8f32de5SMark Haverkamp memcpy(srbcmd->cdb, cmd->cmnd, cmd->cmd_len); 1272e8f32de5SMark Haverkamp /* 1273e8f32de5SMark Haverkamp * Build Scatter/Gather list 1274e8f32de5SMark Haverkamp */ 1275e8f32de5SMark Haverkamp fibsize = sizeof (struct aac_srb) + 1276e8f32de5SMark Haverkamp (((le32_to_cpu(srbcmd->sg.count) & 0xff) - 1) * 1277e8f32de5SMark Haverkamp sizeof (struct sgentry)); 1278e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1279e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1280e8f32de5SMark Haverkamp 1281e8f32de5SMark Haverkamp /* 1282e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1283e8f32de5SMark Haverkamp */ 1284e8f32de5SMark Haverkamp return aac_fib_send(ScsiPortCommand, fib, fibsize, FsaNormal, 0, 1, 1285e8f32de5SMark Haverkamp (fib_callback) aac_srb_callback, (void *) cmd); 1286e8f32de5SMark Haverkamp } 1287e8f32de5SMark Haverkamp 128894cf6ba1SSalyzyn, Mark static int aac_scsi_32_64(struct fib * fib, struct scsi_cmnd * cmd) 128994cf6ba1SSalyzyn, Mark { 1290d8e96507SLeubner, Achim if ((sizeof(dma_addr_t) > 4) && fib->dev->needs_dac && 129194cf6ba1SSalyzyn, Mark (fib->dev->adapter_info.options & AAC_OPT_SGMAP_HOST64)) 129294cf6ba1SSalyzyn, Mark return FAILED; 129394cf6ba1SSalyzyn, Mark return aac_scsi_32(fib, cmd); 129494cf6ba1SSalyzyn, Mark } 129594cf6ba1SSalyzyn, Mark 12961da177e4SLinus Torvalds int aac_get_adapter_info(struct aac_dev* dev) 12971da177e4SLinus Torvalds { 12981da177e4SLinus Torvalds struct fib* fibptr; 12991da177e4SLinus Torvalds int rcode; 13001da177e4SLinus Torvalds u32 tmp; 13017c00ffa3SMark Haverkamp struct aac_adapter_info *info; 130284971738SMark Haverkamp struct aac_bus_info *command; 130384971738SMark Haverkamp struct aac_bus_info_response *bus_info; 13047c00ffa3SMark Haverkamp 1305bfb35aa8SMark Haverkamp if (!(fibptr = aac_fib_alloc(dev))) 13061da177e4SLinus Torvalds return -ENOMEM; 13071da177e4SLinus Torvalds 1308bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 13091da177e4SLinus Torvalds info = (struct aac_adapter_info *) fib_data(fibptr); 13107c00ffa3SMark Haverkamp memset(info,0,sizeof(*info)); 13111da177e4SLinus Torvalds 1312bfb35aa8SMark Haverkamp rcode = aac_fib_send(RequestAdapterInfo, 13131da177e4SLinus Torvalds fibptr, 13147c00ffa3SMark Haverkamp sizeof(*info), 13151da177e4SLinus Torvalds FsaNormal, 13169203344cSMark Haverkamp -1, 1, /* First `interrupt' command uses special wait */ 13171da177e4SLinus Torvalds NULL, 13181da177e4SLinus Torvalds NULL); 13191da177e4SLinus Torvalds 13207c00ffa3SMark Haverkamp if (rcode < 0) { 1321cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* FIB should be freed only after 1322cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech * getting the response from the F/W */ 1323cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (rcode != -ERESTARTSYS) { 1324bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1325bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 1326cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech } 13277c00ffa3SMark Haverkamp return rcode; 13287c00ffa3SMark Haverkamp } 13297c00ffa3SMark Haverkamp memcpy(&dev->adapter_info, info, sizeof(*info)); 13307c00ffa3SMark Haverkamp 13317c00ffa3SMark Haverkamp if (dev->adapter_info.options & AAC_OPT_SUPPLEMENT_ADAPTER_INFO) { 133206a43d17SSalyzyn, Mark struct aac_supplement_adapter_info * sinfo; 13337c00ffa3SMark Haverkamp 1334bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 13357c00ffa3SMark Haverkamp 133606a43d17SSalyzyn, Mark sinfo = (struct aac_supplement_adapter_info *) fib_data(fibptr); 13377c00ffa3SMark Haverkamp 133806a43d17SSalyzyn, Mark memset(sinfo,0,sizeof(*sinfo)); 13397c00ffa3SMark Haverkamp 1340bfb35aa8SMark Haverkamp rcode = aac_fib_send(RequestSupplementAdapterInfo, 13417c00ffa3SMark Haverkamp fibptr, 134206a43d17SSalyzyn, Mark sizeof(*sinfo), 13437c00ffa3SMark Haverkamp FsaNormal, 13447c00ffa3SMark Haverkamp 1, 1, 13457c00ffa3SMark Haverkamp NULL, 13467c00ffa3SMark Haverkamp NULL); 13477c00ffa3SMark Haverkamp 13487c00ffa3SMark Haverkamp if (rcode >= 0) 134906a43d17SSalyzyn, Mark memcpy(&dev->supplement_adapter_info, sinfo, sizeof(*sinfo)); 1350cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (rcode == -ERESTARTSYS) { 1351cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech fibptr = aac_fib_alloc(dev); 1352cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (!fibptr) 1353cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech return -ENOMEM; 1354cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech } 1355cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech 13567c00ffa3SMark Haverkamp } 13571da177e4SLinus Torvalds 135884971738SMark Haverkamp 135984971738SMark Haverkamp /* 136084971738SMark Haverkamp * GetBusInfo 136184971738SMark Haverkamp */ 136284971738SMark Haverkamp 1363bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 136484971738SMark Haverkamp 136584971738SMark Haverkamp bus_info = (struct aac_bus_info_response *) fib_data(fibptr); 136684971738SMark Haverkamp 136784971738SMark Haverkamp memset(bus_info, 0, sizeof(*bus_info)); 136884971738SMark Haverkamp 136984971738SMark Haverkamp command = (struct aac_bus_info *)bus_info; 137084971738SMark Haverkamp 137184971738SMark Haverkamp command->Command = cpu_to_le32(VM_Ioctl); 137284971738SMark Haverkamp command->ObjType = cpu_to_le32(FT_DRIVE); 137384971738SMark Haverkamp command->MethodId = cpu_to_le32(1); 137484971738SMark Haverkamp command->CtlCmd = cpu_to_le32(GetBusInfo); 137584971738SMark Haverkamp 1376bfb35aa8SMark Haverkamp rcode = aac_fib_send(ContainerCommand, 137784971738SMark Haverkamp fibptr, 137884971738SMark Haverkamp sizeof (*bus_info), 137984971738SMark Haverkamp FsaNormal, 138084971738SMark Haverkamp 1, 1, 138184971738SMark Haverkamp NULL, NULL); 138284971738SMark Haverkamp 138394cf6ba1SSalyzyn, Mark /* reasoned default */ 138494cf6ba1SSalyzyn, Mark dev->maximum_num_physicals = 16; 138584971738SMark Haverkamp if (rcode >= 0 && le32_to_cpu(bus_info->Status) == ST_OK) { 138684971738SMark Haverkamp dev->maximum_num_physicals = le32_to_cpu(bus_info->TargetsPerBus); 138784971738SMark Haverkamp dev->maximum_num_channels = le32_to_cpu(bus_info->BusCount); 138884971738SMark Haverkamp } 138984971738SMark Haverkamp 13908c867b25SMark Haverkamp if (!dev->in_reset) { 139124f02e1dSSalyzyn, Mark char buffer[16]; 13921da177e4SLinus Torvalds tmp = le32_to_cpu(dev->adapter_info.kernelrev); 13937c00ffa3SMark Haverkamp printk(KERN_INFO "%s%d: kernel %d.%d-%d[%d] %.*s\n", 13941da177e4SLinus Torvalds dev->name, 13951da177e4SLinus Torvalds dev->id, 13961da177e4SLinus Torvalds tmp>>24, 13971da177e4SLinus Torvalds (tmp>>16)&0xff, 13981da177e4SLinus Torvalds tmp&0xff, 13997c00ffa3SMark Haverkamp le32_to_cpu(dev->adapter_info.kernelbuild), 14007c00ffa3SMark Haverkamp (int)sizeof(dev->supplement_adapter_info.BuildDate), 14017c00ffa3SMark Haverkamp dev->supplement_adapter_info.BuildDate); 14021da177e4SLinus Torvalds tmp = le32_to_cpu(dev->adapter_info.monitorrev); 14031da177e4SLinus Torvalds printk(KERN_INFO "%s%d: monitor %d.%d-%d[%d]\n", 14041da177e4SLinus Torvalds dev->name, dev->id, 14051da177e4SLinus Torvalds tmp>>24,(tmp>>16)&0xff,tmp&0xff, 14061da177e4SLinus Torvalds le32_to_cpu(dev->adapter_info.monitorbuild)); 14071da177e4SLinus Torvalds tmp = le32_to_cpu(dev->adapter_info.biosrev); 14081da177e4SLinus Torvalds printk(KERN_INFO "%s%d: bios %d.%d-%d[%d]\n", 14091da177e4SLinus Torvalds dev->name, dev->id, 14101da177e4SLinus Torvalds tmp>>24,(tmp>>16)&0xff,tmp&0xff, 14111da177e4SLinus Torvalds le32_to_cpu(dev->adapter_info.biosbuild)); 141224f02e1dSSalyzyn, Mark buffer[0] = '\0'; 1413ee959b00STony Jones if (aac_get_serial_number( 141424f02e1dSSalyzyn, Mark shost_to_class(dev->scsi_host_ptr), buffer)) 141524f02e1dSSalyzyn, Mark printk(KERN_INFO "%s%d: serial %s", 141624f02e1dSSalyzyn, Mark dev->name, dev->id, buffer); 1417a45c863fSSalyzyn, Mark if (dev->supplement_adapter_info.VpdInfo.Tsid[0]) { 1418a45c863fSSalyzyn, Mark printk(KERN_INFO "%s%d: TSID %.*s\n", 1419a45c863fSSalyzyn, Mark dev->name, dev->id, 1420a45c863fSSalyzyn, Mark (int)sizeof(dev->supplement_adapter_info.VpdInfo.Tsid), 1421a45c863fSSalyzyn, Mark dev->supplement_adapter_info.VpdInfo.Tsid); 1422a45c863fSSalyzyn, Mark } 14232f7ecc55SSalyzyn, Mark if (!aac_check_reset || ((aac_check_reset == 1) && 142429c97684SSalyzyn, Mark (dev->supplement_adapter_info.SupportedOptions2 & 1425a3940da5SSalyzyn, Mark AAC_OPTION_IGNORE_RESET))) { 142629c97684SSalyzyn, Mark printk(KERN_INFO "%s%d: Reset Adapter Ignored\n", 142729c97684SSalyzyn, Mark dev->name, dev->id); 142829c97684SSalyzyn, Mark } 14298c867b25SMark Haverkamp } 14301da177e4SLinus Torvalds 143195e852e1SSalyzyn, Mark dev->cache_protected = 0; 1432cb1042f2SSalyzyn, Mark dev->jbod = ((dev->supplement_adapter_info.FeatureBits & 1433cb1042f2SSalyzyn, Mark AAC_FEATURE_JBOD) != 0); 14341da177e4SLinus Torvalds dev->nondasd_support = 0; 14351da177e4SLinus Torvalds dev->raid_scsi_mode = 0; 143695e852e1SSalyzyn, Mark if(dev->adapter_info.options & AAC_OPT_NONDASD) 14371da177e4SLinus Torvalds dev->nondasd_support = 1; 14381da177e4SLinus Torvalds 14391da177e4SLinus Torvalds /* 14401da177e4SLinus Torvalds * If the firmware supports ROMB RAID/SCSI mode and we are currently 14411da177e4SLinus Torvalds * in RAID/SCSI mode, set the flag. For now if in this mode we will 14421da177e4SLinus Torvalds * force nondasd support on. If we decide to allow the non-dasd flag 14431da177e4SLinus Torvalds * additional changes changes will have to be made to support 14441da177e4SLinus Torvalds * RAID/SCSI. the function aac_scsi_cmd in this module will have to be 14451da177e4SLinus Torvalds * changed to support the new dev->raid_scsi_mode flag instead of 14461da177e4SLinus Torvalds * leaching off of the dev->nondasd_support flag. Also in linit.c the 14471da177e4SLinus Torvalds * function aac_detect will have to be modified where it sets up the 14481da177e4SLinus Torvalds * max number of channels based on the aac->nondasd_support flag only. 14491da177e4SLinus Torvalds */ 14501da177e4SLinus Torvalds if ((dev->adapter_info.options & AAC_OPT_SCSI_MANAGED) && 14511da177e4SLinus Torvalds (dev->adapter_info.options & AAC_OPT_RAID_SCSI_MODE)) { 14521da177e4SLinus Torvalds dev->nondasd_support = 1; 14531da177e4SLinus Torvalds dev->raid_scsi_mode = 1; 14541da177e4SLinus Torvalds } 14551da177e4SLinus Torvalds if (dev->raid_scsi_mode != 0) 14561da177e4SLinus Torvalds printk(KERN_INFO "%s%d: ROMB RAID/SCSI mode enabled\n", 14571da177e4SLinus Torvalds dev->name, dev->id); 14581da177e4SLinus Torvalds 145995e852e1SSalyzyn, Mark if (nondasd != -1) 14601da177e4SLinus Torvalds dev->nondasd_support = (nondasd!=0); 14612f7ecc55SSalyzyn, Mark if (dev->nondasd_support && !dev->in_reset) 14621da177e4SLinus Torvalds printk(KERN_INFO "%s%d: Non-DASD support enabled.\n",dev->name, dev->id); 14631da177e4SLinus Torvalds 1464e930438cSYang Hongyang if (dma_get_required_mask(&dev->pdev->dev) > DMA_BIT_MASK(32)) 1465d8e96507SLeubner, Achim dev->needs_dac = 1; 14661da177e4SLinus Torvalds dev->dac_support = 0; 1467d8e96507SLeubner, Achim if ((sizeof(dma_addr_t) > 4) && dev->needs_dac && 1468d8e96507SLeubner, Achim (dev->adapter_info.options & AAC_OPT_SGMAP_HOST64)) { 14692f7ecc55SSalyzyn, Mark if (!dev->in_reset) 14702f7ecc55SSalyzyn, Mark printk(KERN_INFO "%s%d: 64bit support enabled.\n", 14712f7ecc55SSalyzyn, Mark dev->name, dev->id); 14721da177e4SLinus Torvalds dev->dac_support = 1; 14731da177e4SLinus Torvalds } 14741da177e4SLinus Torvalds 14751da177e4SLinus Torvalds if(dacmode != -1) { 14761da177e4SLinus Torvalds dev->dac_support = (dacmode!=0); 14771da177e4SLinus Torvalds } 1478d8e96507SLeubner, Achim 1479d8e96507SLeubner, Achim /* avoid problems with AAC_QUIRK_SCSI_32 controllers */ 1480d8e96507SLeubner, Achim if (dev->dac_support && (aac_get_driver_ident(dev->cardtype)->quirks 1481d8e96507SLeubner, Achim & AAC_QUIRK_SCSI_32)) { 1482d8e96507SLeubner, Achim dev->nondasd_support = 0; 1483d8e96507SLeubner, Achim dev->jbod = 0; 1484d8e96507SLeubner, Achim expose_physicals = 0; 1485d8e96507SLeubner, Achim } 1486d8e96507SLeubner, Achim 14871da177e4SLinus Torvalds if(dev->dac_support != 0) { 14886a35528aSYang Hongyang if (!pci_set_dma_mask(dev->pdev, DMA_BIT_MASK(64)) && 14896a35528aSYang Hongyang !pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(64))) { 14902f7ecc55SSalyzyn, Mark if (!dev->in_reset) 14911da177e4SLinus Torvalds printk(KERN_INFO"%s%d: 64 Bit DAC enabled\n", 14921da177e4SLinus Torvalds dev->name, dev->id); 1493284901a9SYang Hongyang } else if (!pci_set_dma_mask(dev->pdev, DMA_BIT_MASK(32)) && 1494284901a9SYang Hongyang !pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(32))) { 14951da177e4SLinus Torvalds printk(KERN_INFO"%s%d: DMA mask set failed, 64 Bit DAC disabled\n", 14961da177e4SLinus Torvalds dev->name, dev->id); 14971da177e4SLinus Torvalds dev->dac_support = 0; 14981da177e4SLinus Torvalds } else { 14991da177e4SLinus Torvalds printk(KERN_WARNING"%s%d: No suitable DMA available.\n", 15001da177e4SLinus Torvalds dev->name, dev->id); 15011da177e4SLinus Torvalds rcode = -ENOMEM; 15021da177e4SLinus Torvalds } 15031da177e4SLinus Torvalds } 15047c00ffa3SMark Haverkamp /* 1505e8f32de5SMark Haverkamp * Deal with configuring for the individualized limits of each packet 1506e8f32de5SMark Haverkamp * interface. 15077c00ffa3SMark Haverkamp */ 1508e8f32de5SMark Haverkamp dev->a_ops.adapter_scsi = (dev->dac_support) 150994cf6ba1SSalyzyn, Mark ? ((aac_get_driver_ident(dev->cardtype)->quirks & AAC_QUIRK_SCSI_32) 151094cf6ba1SSalyzyn, Mark ? aac_scsi_32_64 151194cf6ba1SSalyzyn, Mark : aac_scsi_64) 1512e8f32de5SMark Haverkamp : aac_scsi_32; 1513e8f32de5SMark Haverkamp if (dev->raw_io_interface) { 1514e8f32de5SMark Haverkamp dev->a_ops.adapter_bounds = (dev->raw_io_64) 1515e8f32de5SMark Haverkamp ? aac_bounds_64 1516e8f32de5SMark Haverkamp : aac_bounds_32; 1517e8f32de5SMark Haverkamp dev->a_ops.adapter_read = aac_read_raw_io; 1518e8f32de5SMark Haverkamp dev->a_ops.adapter_write = aac_write_raw_io; 1519e8f32de5SMark Haverkamp } else { 1520e8f32de5SMark Haverkamp dev->a_ops.adapter_bounds = aac_bounds_32; 15217c00ffa3SMark Haverkamp dev->scsi_host_ptr->sg_tablesize = (dev->max_fib_size - 15227c00ffa3SMark Haverkamp sizeof(struct aac_fibhdr) - 152363a70eeaSMark Haverkamp sizeof(struct aac_write) + sizeof(struct sgentry)) / 152463a70eeaSMark Haverkamp sizeof(struct sgentry); 15257c00ffa3SMark Haverkamp if (dev->dac_support) { 1526e8f32de5SMark Haverkamp dev->a_ops.adapter_read = aac_read_block64; 1527e8f32de5SMark Haverkamp dev->a_ops.adapter_write = aac_write_block64; 15287c00ffa3SMark Haverkamp /* 15297c00ffa3SMark Haverkamp * 38 scatter gather elements 15307c00ffa3SMark Haverkamp */ 15317c00ffa3SMark Haverkamp dev->scsi_host_ptr->sg_tablesize = 15327c00ffa3SMark Haverkamp (dev->max_fib_size - 15337c00ffa3SMark Haverkamp sizeof(struct aac_fibhdr) - 15347c00ffa3SMark Haverkamp sizeof(struct aac_write64) + 153563a70eeaSMark Haverkamp sizeof(struct sgentry64)) / 153663a70eeaSMark Haverkamp sizeof(struct sgentry64); 1537e8f32de5SMark Haverkamp } else { 1538e8f32de5SMark Haverkamp dev->a_ops.adapter_read = aac_read_block; 1539e8f32de5SMark Haverkamp dev->a_ops.adapter_write = aac_write_block; 15407c00ffa3SMark Haverkamp } 15417c00ffa3SMark Haverkamp dev->scsi_host_ptr->max_sectors = AAC_MAX_32BIT_SGBCOUNT; 15427c00ffa3SMark Haverkamp if (!(dev->adapter_info.options & AAC_OPT_NEW_COMM)) { 15437c00ffa3SMark Haverkamp /* 15447c00ffa3SMark Haverkamp * Worst case size that could cause sg overflow when 15457c00ffa3SMark Haverkamp * we break up SG elements that are larger than 64KB. 15467c00ffa3SMark Haverkamp * Would be nice if we could tell the SCSI layer what 15477c00ffa3SMark Haverkamp * the maximum SG element size can be. Worst case is 15487c00ffa3SMark Haverkamp * (sg_tablesize-1) 4KB elements with one 64KB 15497c00ffa3SMark Haverkamp * element. 15507c00ffa3SMark Haverkamp * 32bit -> 468 or 238KB 64bit -> 424 or 212KB 15517c00ffa3SMark Haverkamp */ 15527c00ffa3SMark Haverkamp dev->scsi_host_ptr->max_sectors = 15537c00ffa3SMark Haverkamp (dev->scsi_host_ptr->sg_tablesize * 8) + 112; 15547c00ffa3SMark Haverkamp } 15550e68c003SMark Haverkamp } 1556cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* FIB should be freed only after getting the response from the F/W */ 1557cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (rcode != -ERESTARTSYS) { 1558bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1559bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 1560cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech } 15611da177e4SLinus Torvalds 15621da177e4SLinus Torvalds return rcode; 15631da177e4SLinus Torvalds } 15641da177e4SLinus Torvalds 15651da177e4SLinus Torvalds 1566e53cb35aSMark Haverkamp static void io_callback(void *context, struct fib * fibptr) 15671da177e4SLinus Torvalds { 15681da177e4SLinus Torvalds struct aac_dev *dev; 15691da177e4SLinus Torvalds struct aac_read_reply *readreply; 15701da177e4SLinus Torvalds struct scsi_cmnd *scsicmd; 15711da177e4SLinus Torvalds u32 cid; 15721da177e4SLinus Torvalds 15731da177e4SLinus Torvalds scsicmd = (struct scsi_cmnd *) context; 15741da177e4SLinus Torvalds 157503d44337SMark Haverkamp if (!aac_valid_context(scsicmd, fibptr)) 157603d44337SMark Haverkamp return; 157703d44337SMark Haverkamp 15781a655040SSalyzyn, Mark dev = fibptr->dev; 1579e5718774SMark Haverkamp cid = scmd_id(scsicmd); 15801da177e4SLinus Torvalds 15817a8cf29dSMark Haverkamp if (nblank(dprintk(x))) { 15827a8cf29dSMark Haverkamp u64 lba; 15837a8cf29dSMark Haverkamp switch (scsicmd->cmnd[0]) { 15847a8cf29dSMark Haverkamp case WRITE_6: 15857a8cf29dSMark Haverkamp case READ_6: 15867a8cf29dSMark Haverkamp lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | 15877a8cf29dSMark Haverkamp (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 15887a8cf29dSMark Haverkamp break; 15897a8cf29dSMark Haverkamp case WRITE_16: 15907a8cf29dSMark Haverkamp case READ_16: 15917a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 56) | 15927a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[3] << 48) | 15937a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[4] << 40) | 15947a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[5] << 32) | 15957a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[6] << 24) | 15967a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 15977a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 15987a8cf29dSMark Haverkamp break; 15997a8cf29dSMark Haverkamp case WRITE_12: 16007a8cf29dSMark Haverkamp case READ_12: 16017a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 16027a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 16037a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 16047a8cf29dSMark Haverkamp break; 16057a8cf29dSMark Haverkamp default: 16067a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 16077a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 16087a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 16097a8cf29dSMark Haverkamp break; 16107a8cf29dSMark Haverkamp } 16117a8cf29dSMark Haverkamp printk(KERN_DEBUG 16127a8cf29dSMark Haverkamp "io_callback[cpu %d]: lba = %llu, t = %ld.\n", 16137a8cf29dSMark Haverkamp smp_processor_id(), (unsigned long long)lba, jiffies); 16147a8cf29dSMark Haverkamp } 16151da177e4SLinus Torvalds 1616125e1874SEric Sesterhenn BUG_ON(fibptr == NULL); 16171da177e4SLinus Torvalds 1618727eead6SFUJITA Tomonori scsi_dma_unmap(scsicmd); 1619727eead6SFUJITA Tomonori 16201da177e4SLinus Torvalds readreply = (struct aac_read_reply *)fib_data(fibptr); 1621655d722cSMark Salyzyn switch (le32_to_cpu(readreply->status)) { 1622655d722cSMark Salyzyn case ST_OK: 1623655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 1624655d722cSMark Salyzyn SAM_STAT_GOOD; 1625655d722cSMark Salyzyn dev->fsa_dev[cid].sense_data.sense_key = NO_SENSE; 1626655d722cSMark Salyzyn break; 1627655d722cSMark Salyzyn case ST_NOT_READY: 1628655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 1629655d722cSMark Salyzyn SAM_STAT_CHECK_CONDITION; 1630655d722cSMark Salyzyn set_sense(&dev->fsa_dev[cid].sense_data, NOT_READY, 1631655d722cSMark Salyzyn SENCODE_BECOMING_READY, ASENCODE_BECOMING_READY, 0, 0); 1632655d722cSMark Salyzyn memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1633655d722cSMark Salyzyn min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 1634655d722cSMark Salyzyn SCSI_SENSE_BUFFERSIZE)); 1635655d722cSMark Salyzyn break; 1636655d722cSMark Salyzyn default: 16377c00ffa3SMark Haverkamp #ifdef AAC_DETAILED_STATUS_INFO 1638e53cb35aSMark Haverkamp printk(KERN_WARNING "io_callback: io failed, status = %d\n", 16391da177e4SLinus Torvalds le32_to_cpu(readreply->status)); 16407c00ffa3SMark Haverkamp #endif 1641655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 1642655d722cSMark Salyzyn SAM_STAT_CHECK_CONDITION; 16438e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 16448e31e607SSalyzyn, Mark HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 16458e31e607SSalyzyn, Mark ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 16461da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 16473ace426fSSalyzyn, Mark min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 16483ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE)); 1649655d722cSMark Salyzyn break; 16501da177e4SLinus Torvalds } 1651bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1652bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 16531da177e4SLinus Torvalds 16548e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 16551da177e4SLinus Torvalds } 16561da177e4SLinus Torvalds 16579e7c349cSMark Haverkamp static int aac_read(struct scsi_cmnd * scsicmd) 16581da177e4SLinus Torvalds { 16597a8cf29dSMark Haverkamp u64 lba; 16601da177e4SLinus Torvalds u32 count; 16611da177e4SLinus Torvalds int status; 16621da177e4SLinus Torvalds struct aac_dev *dev; 16631da177e4SLinus Torvalds struct fib * cmd_fibcontext; 1664da3cc679SRajashekhara, Mahesh int cid; 16651da177e4SLinus Torvalds 16661da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 16671da177e4SLinus Torvalds /* 16681da177e4SLinus Torvalds * Get block address and transfer length 16691da177e4SLinus Torvalds */ 16707a8cf29dSMark Haverkamp switch (scsicmd->cmnd[0]) { 16717a8cf29dSMark Haverkamp case READ_6: 16729e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a read(6) command on id %d.\n", scmd_id(scsicmd))); 16731da177e4SLinus Torvalds 16747a8cf29dSMark Haverkamp lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | 16757a8cf29dSMark Haverkamp (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 16761da177e4SLinus Torvalds count = scsicmd->cmnd[4]; 16771da177e4SLinus Torvalds 16781da177e4SLinus Torvalds if (count == 0) 16791da177e4SLinus Torvalds count = 256; 16807a8cf29dSMark Haverkamp break; 16817a8cf29dSMark Haverkamp case READ_16: 16829e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a read(16) command on id %d.\n", scmd_id(scsicmd))); 16837a8cf29dSMark Haverkamp 16847a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 56) | 16857a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[3] << 48) | 16867a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[4] << 40) | 16877a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[5] << 32) | 16887a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[6] << 24) | 16897a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 16907a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 16917a8cf29dSMark Haverkamp count = (scsicmd->cmnd[10] << 24) | 16927a8cf29dSMark Haverkamp (scsicmd->cmnd[11] << 16) | 16937a8cf29dSMark Haverkamp (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13]; 16947a8cf29dSMark Haverkamp break; 16957a8cf29dSMark Haverkamp case READ_12: 16969e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a read(12) command on id %d.\n", scmd_id(scsicmd))); 16977a8cf29dSMark Haverkamp 16987a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 16997a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 17007a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 17017a8cf29dSMark Haverkamp count = (scsicmd->cmnd[6] << 24) | 17027a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 17037a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 17047a8cf29dSMark Haverkamp break; 17057a8cf29dSMark Haverkamp default: 17069e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a read(10) command on id %d.\n", scmd_id(scsicmd))); 17071da177e4SLinus Torvalds 17087a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 17097a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 17107a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 17111da177e4SLinus Torvalds count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 17127a8cf29dSMark Haverkamp break; 17131da177e4SLinus Torvalds } 1714da3cc679SRajashekhara, Mahesh 1715da3cc679SRajashekhara, Mahesh if ((lba + count) > (dev->fsa_dev[scmd_id(scsicmd)].size)) { 1716da3cc679SRajashekhara, Mahesh cid = scmd_id(scsicmd); 1717da3cc679SRajashekhara, Mahesh dprintk((KERN_DEBUG "aacraid: Illegal lba\n")); 1718da3cc679SRajashekhara, Mahesh scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 1719da3cc679SRajashekhara, Mahesh SAM_STAT_CHECK_CONDITION; 1720da3cc679SRajashekhara, Mahesh set_sense(&dev->fsa_dev[cid].sense_data, 1721da3cc679SRajashekhara, Mahesh HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 1722da3cc679SRajashekhara, Mahesh ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 1723da3cc679SRajashekhara, Mahesh memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1724da3cc679SRajashekhara, Mahesh min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 1725da3cc679SRajashekhara, Mahesh SCSI_SENSE_BUFFERSIZE)); 1726da3cc679SRajashekhara, Mahesh scsicmd->scsi_done(scsicmd); 1727da3cc679SRajashekhara, Mahesh return 1; 1728da3cc679SRajashekhara, Mahesh } 1729da3cc679SRajashekhara, Mahesh 17307a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aac_read[cpu %d]: lba = %llu, t = %ld.\n", 17317c00ffa3SMark Haverkamp smp_processor_id(), (unsigned long long)lba, jiffies)); 1732e8f32de5SMark Haverkamp if (aac_adapter_bounds(dev,scsicmd,lba)) 17337a8cf29dSMark Haverkamp return 0; 17341da177e4SLinus Torvalds /* 17351da177e4SLinus Torvalds * Alocate and initialize a Fib 17361da177e4SLinus Torvalds */ 1737bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) { 1738cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech printk(KERN_WARNING "aac_read: fib allocation failed\n"); 17391da177e4SLinus Torvalds return -1; 17401da177e4SLinus Torvalds } 17411da177e4SLinus Torvalds 1742e8f32de5SMark Haverkamp status = aac_adapter_read(cmd_fibcontext, scsicmd, lba, count); 17431da177e4SLinus Torvalds 17441da177e4SLinus Torvalds /* 17451da177e4SLinus Torvalds * Check that the command queued to the controller 17461da177e4SLinus Torvalds */ 174777d644d4SMark Haverkamp if (status == -EINPROGRESS) { 174877d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 17491da177e4SLinus Torvalds return 0; 175077d644d4SMark Haverkamp } 17511da177e4SLinus Torvalds 1752bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_read: aac_fib_send failed with status: %d.\n", status); 17531da177e4SLinus Torvalds /* 17541da177e4SLinus Torvalds * For some reason, the Fib didn't queue, return QUEUE_FULL 17551da177e4SLinus Torvalds */ 17561da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL; 17578e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 1758bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 1759bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 17601da177e4SLinus Torvalds return 0; 17611da177e4SLinus Torvalds } 17621da177e4SLinus Torvalds 17639e7c349cSMark Haverkamp static int aac_write(struct scsi_cmnd * scsicmd) 17641da177e4SLinus Torvalds { 17657a8cf29dSMark Haverkamp u64 lba; 17661da177e4SLinus Torvalds u32 count; 17679d399cc7SSalyzyn, Mark int fua; 17681da177e4SLinus Torvalds int status; 17691da177e4SLinus Torvalds struct aac_dev *dev; 17701da177e4SLinus Torvalds struct fib * cmd_fibcontext; 1771da3cc679SRajashekhara, Mahesh int cid; 17721da177e4SLinus Torvalds 17731da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 17741da177e4SLinus Torvalds /* 17751da177e4SLinus Torvalds * Get block address and transfer length 17761da177e4SLinus Torvalds */ 17771da177e4SLinus Torvalds if (scsicmd->cmnd[0] == WRITE_6) /* 6 byte command */ 17781da177e4SLinus Torvalds { 17791da177e4SLinus Torvalds lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 17801da177e4SLinus Torvalds count = scsicmd->cmnd[4]; 17811da177e4SLinus Torvalds if (count == 0) 17821da177e4SLinus Torvalds count = 256; 17839d399cc7SSalyzyn, Mark fua = 0; 17847a8cf29dSMark Haverkamp } else if (scsicmd->cmnd[0] == WRITE_16) { /* 16 byte command */ 17859e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a write(16) command on id %d.\n", scmd_id(scsicmd))); 17867a8cf29dSMark Haverkamp 17877a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 56) | 17887a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[3] << 48) | 17897a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[4] << 40) | 17907a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[5] << 32) | 17917a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[6] << 24) | 17927a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 17937a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 17947a8cf29dSMark Haverkamp count = (scsicmd->cmnd[10] << 24) | (scsicmd->cmnd[11] << 16) | 17957a8cf29dSMark Haverkamp (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13]; 17969d399cc7SSalyzyn, Mark fua = scsicmd->cmnd[1] & 0x8; 17977a8cf29dSMark Haverkamp } else if (scsicmd->cmnd[0] == WRITE_12) { /* 12 byte command */ 17989e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a write(12) command on id %d.\n", scmd_id(scsicmd))); 17997a8cf29dSMark Haverkamp 18007a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) 18017a8cf29dSMark Haverkamp | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 18027a8cf29dSMark Haverkamp count = (scsicmd->cmnd[6] << 24) | (scsicmd->cmnd[7] << 16) 18037a8cf29dSMark Haverkamp | (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 18049d399cc7SSalyzyn, Mark fua = scsicmd->cmnd[1] & 0x8; 18051da177e4SLinus Torvalds } else { 18069e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a write(10) command on id %d.\n", scmd_id(scsicmd))); 18077a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 18081da177e4SLinus Torvalds count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 18099d399cc7SSalyzyn, Mark fua = scsicmd->cmnd[1] & 0x8; 18101da177e4SLinus Torvalds } 1811da3cc679SRajashekhara, Mahesh 1812da3cc679SRajashekhara, Mahesh if ((lba + count) > (dev->fsa_dev[scmd_id(scsicmd)].size)) { 1813da3cc679SRajashekhara, Mahesh cid = scmd_id(scsicmd); 1814da3cc679SRajashekhara, Mahesh dprintk((KERN_DEBUG "aacraid: Illegal lba\n")); 1815da3cc679SRajashekhara, Mahesh scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 1816da3cc679SRajashekhara, Mahesh SAM_STAT_CHECK_CONDITION; 1817da3cc679SRajashekhara, Mahesh set_sense(&dev->fsa_dev[cid].sense_data, 1818da3cc679SRajashekhara, Mahesh HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 1819da3cc679SRajashekhara, Mahesh ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 1820da3cc679SRajashekhara, Mahesh memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1821da3cc679SRajashekhara, Mahesh min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 1822da3cc679SRajashekhara, Mahesh SCSI_SENSE_BUFFERSIZE)); 1823da3cc679SRajashekhara, Mahesh scsicmd->scsi_done(scsicmd); 1824da3cc679SRajashekhara, Mahesh return 1; 1825da3cc679SRajashekhara, Mahesh } 1826da3cc679SRajashekhara, Mahesh 18277a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aac_write[cpu %d]: lba = %llu, t = %ld.\n", 18281da177e4SLinus Torvalds smp_processor_id(), (unsigned long long)lba, jiffies)); 1829e8f32de5SMark Haverkamp if (aac_adapter_bounds(dev,scsicmd,lba)) 18307a8cf29dSMark Haverkamp return 0; 18311da177e4SLinus Torvalds /* 18321da177e4SLinus Torvalds * Allocate and initialize a Fib then setup a BlockWrite command 18331da177e4SLinus Torvalds */ 1834bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) { 1835cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* FIB temporarily unavailable,not catastrophic failure */ 1836cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech 1837cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* scsicmd->result = DID_ERROR << 16; 1838cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech * scsicmd->scsi_done(scsicmd); 1839cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech * return 0; 1840cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech */ 1841cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech printk(KERN_WARNING "aac_write: fib allocation failed\n"); 1842cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech return -1; 18431da177e4SLinus Torvalds } 18441da177e4SLinus Torvalds 18459d399cc7SSalyzyn, Mark status = aac_adapter_write(cmd_fibcontext, scsicmd, lba, count, fua); 18461da177e4SLinus Torvalds 18471da177e4SLinus Torvalds /* 18481da177e4SLinus Torvalds * Check that the command queued to the controller 18491da177e4SLinus Torvalds */ 185077d644d4SMark Haverkamp if (status == -EINPROGRESS) { 185177d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 18521da177e4SLinus Torvalds return 0; 18531da177e4SLinus Torvalds } 18541da177e4SLinus Torvalds 1855bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_write: aac_fib_send failed with status: %d\n", status); 18561da177e4SLinus Torvalds /* 18571da177e4SLinus Torvalds * For some reason, the Fib didn't queue, return QUEUE_FULL 18581da177e4SLinus Torvalds */ 18591da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL; 18608e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 18611da177e4SLinus Torvalds 1862bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 1863bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 18641da177e4SLinus Torvalds return 0; 18651da177e4SLinus Torvalds } 18661da177e4SLinus Torvalds 18671da177e4SLinus Torvalds static void synchronize_callback(void *context, struct fib *fibptr) 18681da177e4SLinus Torvalds { 18691da177e4SLinus Torvalds struct aac_synchronize_reply *synchronizereply; 18701da177e4SLinus Torvalds struct scsi_cmnd *cmd; 18711da177e4SLinus Torvalds 18721da177e4SLinus Torvalds cmd = context; 18731da177e4SLinus Torvalds 187403d44337SMark Haverkamp if (!aac_valid_context(cmd, fibptr)) 187503d44337SMark Haverkamp return; 187603d44337SMark Haverkamp 18771da177e4SLinus Torvalds dprintk((KERN_DEBUG "synchronize_callback[cpu %d]: t = %ld.\n", 18781da177e4SLinus Torvalds smp_processor_id(), jiffies)); 18791da177e4SLinus Torvalds BUG_ON(fibptr == NULL); 18801da177e4SLinus Torvalds 18811da177e4SLinus Torvalds 18821da177e4SLinus Torvalds synchronizereply = fib_data(fibptr); 18831da177e4SLinus Torvalds if (le32_to_cpu(synchronizereply->status) == CT_OK) 18841da177e4SLinus Torvalds cmd->result = DID_OK << 16 | 18851da177e4SLinus Torvalds COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 18861da177e4SLinus Torvalds else { 18871da177e4SLinus Torvalds struct scsi_device *sdev = cmd->device; 18881a655040SSalyzyn, Mark struct aac_dev *dev = fibptr->dev; 1889e5718774SMark Haverkamp u32 cid = sdev_id(sdev); 18901da177e4SLinus Torvalds printk(KERN_WARNING 18911da177e4SLinus Torvalds "synchronize_callback: synchronize failed, status = %d\n", 18921da177e4SLinus Torvalds le32_to_cpu(synchronizereply->status)); 18931da177e4SLinus Torvalds cmd->result = DID_OK << 16 | 18941da177e4SLinus Torvalds COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 18958e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 18968e31e607SSalyzyn, Mark HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 18978e31e607SSalyzyn, Mark ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 18981da177e4SLinus Torvalds memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1899b80ca4f7SFUJITA Tomonori min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 1900b80ca4f7SFUJITA Tomonori SCSI_SENSE_BUFFERSIZE)); 19011da177e4SLinus Torvalds } 19021da177e4SLinus Torvalds 1903bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1904bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 19058e0c5ebdSMark Haverkamp cmd->scsi_done(cmd); 19061da177e4SLinus Torvalds } 19071da177e4SLinus Torvalds 19089e7c349cSMark Haverkamp static int aac_synchronize(struct scsi_cmnd *scsicmd) 19091da177e4SLinus Torvalds { 19101da177e4SLinus Torvalds int status; 19111da177e4SLinus Torvalds struct fib *cmd_fibcontext; 19121da177e4SLinus Torvalds struct aac_synchronize *synchronizecmd; 19131da177e4SLinus Torvalds struct scsi_cmnd *cmd; 19141da177e4SLinus Torvalds struct scsi_device *sdev = scsicmd->device; 19151da177e4SLinus Torvalds int active = 0; 191690ee3466SMark Haverkamp struct aac_dev *aac; 1917b90f90d2SSalyzyn, Mark u64 lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | 1918b90f90d2SSalyzyn, Mark (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 1919b90f90d2SSalyzyn, Mark u32 count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 19201da177e4SLinus Torvalds unsigned long flags; 19211da177e4SLinus Torvalds 19221da177e4SLinus Torvalds /* 192377d644d4SMark Haverkamp * Wait for all outstanding queued commands to complete to this 192477d644d4SMark Haverkamp * specific target (block). 19251da177e4SLinus Torvalds */ 19261da177e4SLinus Torvalds spin_lock_irqsave(&sdev->list_lock, flags); 19271da177e4SLinus Torvalds list_for_each_entry(cmd, &sdev->cmd_list, list) 1928b90f90d2SSalyzyn, Mark if (cmd->SCp.phase == AAC_OWNER_FIRMWARE) { 1929b90f90d2SSalyzyn, Mark u64 cmnd_lba; 1930b90f90d2SSalyzyn, Mark u32 cmnd_count; 1931b90f90d2SSalyzyn, Mark 1932b90f90d2SSalyzyn, Mark if (cmd->cmnd[0] == WRITE_6) { 1933b90f90d2SSalyzyn, Mark cmnd_lba = ((cmd->cmnd[1] & 0x1F) << 16) | 1934b90f90d2SSalyzyn, Mark (cmd->cmnd[2] << 8) | 1935b90f90d2SSalyzyn, Mark cmd->cmnd[3]; 1936b90f90d2SSalyzyn, Mark cmnd_count = cmd->cmnd[4]; 1937b90f90d2SSalyzyn, Mark if (cmnd_count == 0) 1938b90f90d2SSalyzyn, Mark cmnd_count = 256; 1939b90f90d2SSalyzyn, Mark } else if (cmd->cmnd[0] == WRITE_16) { 1940b90f90d2SSalyzyn, Mark cmnd_lba = ((u64)cmd->cmnd[2] << 56) | 1941b90f90d2SSalyzyn, Mark ((u64)cmd->cmnd[3] << 48) | 1942b90f90d2SSalyzyn, Mark ((u64)cmd->cmnd[4] << 40) | 1943b90f90d2SSalyzyn, Mark ((u64)cmd->cmnd[5] << 32) | 1944b90f90d2SSalyzyn, Mark ((u64)cmd->cmnd[6] << 24) | 1945b90f90d2SSalyzyn, Mark (cmd->cmnd[7] << 16) | 1946b90f90d2SSalyzyn, Mark (cmd->cmnd[8] << 8) | 1947b90f90d2SSalyzyn, Mark cmd->cmnd[9]; 1948b90f90d2SSalyzyn, Mark cmnd_count = (cmd->cmnd[10] << 24) | 1949b90f90d2SSalyzyn, Mark (cmd->cmnd[11] << 16) | 1950b90f90d2SSalyzyn, Mark (cmd->cmnd[12] << 8) | 1951b90f90d2SSalyzyn, Mark cmd->cmnd[13]; 1952b90f90d2SSalyzyn, Mark } else if (cmd->cmnd[0] == WRITE_12) { 1953b90f90d2SSalyzyn, Mark cmnd_lba = ((u64)cmd->cmnd[2] << 24) | 1954b90f90d2SSalyzyn, Mark (cmd->cmnd[3] << 16) | 1955b90f90d2SSalyzyn, Mark (cmd->cmnd[4] << 8) | 1956b90f90d2SSalyzyn, Mark cmd->cmnd[5]; 1957b90f90d2SSalyzyn, Mark cmnd_count = (cmd->cmnd[6] << 24) | 1958b90f90d2SSalyzyn, Mark (cmd->cmnd[7] << 16) | 1959b90f90d2SSalyzyn, Mark (cmd->cmnd[8] << 8) | 1960b90f90d2SSalyzyn, Mark cmd->cmnd[9]; 1961b90f90d2SSalyzyn, Mark } else if (cmd->cmnd[0] == WRITE_10) { 1962b90f90d2SSalyzyn, Mark cmnd_lba = ((u64)cmd->cmnd[2] << 24) | 1963b90f90d2SSalyzyn, Mark (cmd->cmnd[3] << 16) | 1964b90f90d2SSalyzyn, Mark (cmd->cmnd[4] << 8) | 1965b90f90d2SSalyzyn, Mark cmd->cmnd[5]; 1966b90f90d2SSalyzyn, Mark cmnd_count = (cmd->cmnd[7] << 8) | 1967b90f90d2SSalyzyn, Mark cmd->cmnd[8]; 1968b90f90d2SSalyzyn, Mark } else 1969b90f90d2SSalyzyn, Mark continue; 1970b90f90d2SSalyzyn, Mark if (((cmnd_lba + cmnd_count) < lba) || 1971b90f90d2SSalyzyn, Mark (count && ((lba + count) < cmnd_lba))) 1972b90f90d2SSalyzyn, Mark continue; 19731da177e4SLinus Torvalds ++active; 19741da177e4SLinus Torvalds break; 19751da177e4SLinus Torvalds } 19761da177e4SLinus Torvalds 19771da177e4SLinus Torvalds spin_unlock_irqrestore(&sdev->list_lock, flags); 19781da177e4SLinus Torvalds 19791da177e4SLinus Torvalds /* 19801da177e4SLinus Torvalds * Yield the processor (requeue for later) 19811da177e4SLinus Torvalds */ 19821da177e4SLinus Torvalds if (active) 19831da177e4SLinus Torvalds return SCSI_MLQUEUE_DEVICE_BUSY; 19841da177e4SLinus Torvalds 1985f858317dSSalyzyn, Mark aac = (struct aac_dev *)sdev->host->hostdata; 19868c867b25SMark Haverkamp if (aac->in_reset) 19878c867b25SMark Haverkamp return SCSI_MLQUEUE_HOST_BUSY; 19888c867b25SMark Haverkamp 19891da177e4SLinus Torvalds /* 19907c00ffa3SMark Haverkamp * Allocate and initialize a Fib 19911da177e4SLinus Torvalds */ 199290ee3466SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(aac))) 19931da177e4SLinus Torvalds return SCSI_MLQUEUE_HOST_BUSY; 19941da177e4SLinus Torvalds 1995bfb35aa8SMark Haverkamp aac_fib_init(cmd_fibcontext); 19961da177e4SLinus Torvalds 19971da177e4SLinus Torvalds synchronizecmd = fib_data(cmd_fibcontext); 19981da177e4SLinus Torvalds synchronizecmd->command = cpu_to_le32(VM_ContainerConfig); 19991da177e4SLinus Torvalds synchronizecmd->type = cpu_to_le32(CT_FLUSH_CACHE); 20009e7c349cSMark Haverkamp synchronizecmd->cid = cpu_to_le32(scmd_id(scsicmd)); 20011da177e4SLinus Torvalds synchronizecmd->count = 20021da177e4SLinus Torvalds cpu_to_le32(sizeof(((struct aac_synchronize_reply *)NULL)->data)); 20031da177e4SLinus Torvalds 20041da177e4SLinus Torvalds /* 20051da177e4SLinus Torvalds * Now send the Fib to the adapter 20061da177e4SLinus Torvalds */ 2007bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 20081da177e4SLinus Torvalds cmd_fibcontext, 20091da177e4SLinus Torvalds sizeof(struct aac_synchronize), 20101da177e4SLinus Torvalds FsaNormal, 20111da177e4SLinus Torvalds 0, 1, 20121da177e4SLinus Torvalds (fib_callback)synchronize_callback, 20131da177e4SLinus Torvalds (void *)scsicmd); 20141da177e4SLinus Torvalds 20151da177e4SLinus Torvalds /* 20161da177e4SLinus Torvalds * Check that the command queued to the controller 20171da177e4SLinus Torvalds */ 201877d644d4SMark Haverkamp if (status == -EINPROGRESS) { 201977d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 20201da177e4SLinus Torvalds return 0; 202177d644d4SMark Haverkamp } 20221da177e4SLinus Torvalds 20231da177e4SLinus Torvalds printk(KERN_WARNING 2024bfb35aa8SMark Haverkamp "aac_synchronize: aac_fib_send failed with status: %d.\n", status); 2025bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 2026bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 20271da177e4SLinus Torvalds return SCSI_MLQUEUE_HOST_BUSY; 20281da177e4SLinus Torvalds } 20291da177e4SLinus Torvalds 2030655d722cSMark Salyzyn static void aac_start_stop_callback(void *context, struct fib *fibptr) 2031655d722cSMark Salyzyn { 2032655d722cSMark Salyzyn struct scsi_cmnd *scsicmd = context; 2033655d722cSMark Salyzyn 2034655d722cSMark Salyzyn if (!aac_valid_context(scsicmd, fibptr)) 2035655d722cSMark Salyzyn return; 2036655d722cSMark Salyzyn 2037655d722cSMark Salyzyn BUG_ON(fibptr == NULL); 2038655d722cSMark Salyzyn 2039655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 2040655d722cSMark Salyzyn 2041655d722cSMark Salyzyn aac_fib_complete(fibptr); 2042655d722cSMark Salyzyn aac_fib_free(fibptr); 2043655d722cSMark Salyzyn scsicmd->scsi_done(scsicmd); 2044655d722cSMark Salyzyn } 2045655d722cSMark Salyzyn 2046655d722cSMark Salyzyn static int aac_start_stop(struct scsi_cmnd *scsicmd) 2047655d722cSMark Salyzyn { 2048655d722cSMark Salyzyn int status; 2049655d722cSMark Salyzyn struct fib *cmd_fibcontext; 2050655d722cSMark Salyzyn struct aac_power_management *pmcmd; 2051655d722cSMark Salyzyn struct scsi_device *sdev = scsicmd->device; 2052655d722cSMark Salyzyn struct aac_dev *aac = (struct aac_dev *)sdev->host->hostdata; 2053655d722cSMark Salyzyn 2054655d722cSMark Salyzyn if (!(aac->supplement_adapter_info.SupportedOptions2 & 2055655d722cSMark Salyzyn AAC_OPTION_POWER_MANAGEMENT)) { 2056655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 2057655d722cSMark Salyzyn SAM_STAT_GOOD; 2058655d722cSMark Salyzyn scsicmd->scsi_done(scsicmd); 2059655d722cSMark Salyzyn return 0; 2060655d722cSMark Salyzyn } 2061655d722cSMark Salyzyn 2062655d722cSMark Salyzyn if (aac->in_reset) 2063655d722cSMark Salyzyn return SCSI_MLQUEUE_HOST_BUSY; 2064655d722cSMark Salyzyn 2065655d722cSMark Salyzyn /* 2066655d722cSMark Salyzyn * Allocate and initialize a Fib 2067655d722cSMark Salyzyn */ 2068655d722cSMark Salyzyn cmd_fibcontext = aac_fib_alloc(aac); 2069655d722cSMark Salyzyn if (!cmd_fibcontext) 2070655d722cSMark Salyzyn return SCSI_MLQUEUE_HOST_BUSY; 2071655d722cSMark Salyzyn 2072655d722cSMark Salyzyn aac_fib_init(cmd_fibcontext); 2073655d722cSMark Salyzyn 2074655d722cSMark Salyzyn pmcmd = fib_data(cmd_fibcontext); 2075655d722cSMark Salyzyn pmcmd->command = cpu_to_le32(VM_ContainerConfig); 2076655d722cSMark Salyzyn pmcmd->type = cpu_to_le32(CT_POWER_MANAGEMENT); 2077655d722cSMark Salyzyn /* Eject bit ignored, not relevant */ 2078655d722cSMark Salyzyn pmcmd->sub = (scsicmd->cmnd[4] & 1) ? 2079655d722cSMark Salyzyn cpu_to_le32(CT_PM_START_UNIT) : cpu_to_le32(CT_PM_STOP_UNIT); 2080655d722cSMark Salyzyn pmcmd->cid = cpu_to_le32(sdev_id(sdev)); 2081655d722cSMark Salyzyn pmcmd->parm = (scsicmd->cmnd[1] & 1) ? 2082655d722cSMark Salyzyn cpu_to_le32(CT_PM_UNIT_IMMEDIATE) : 0; 2083655d722cSMark Salyzyn 2084655d722cSMark Salyzyn /* 2085655d722cSMark Salyzyn * Now send the Fib to the adapter 2086655d722cSMark Salyzyn */ 2087655d722cSMark Salyzyn status = aac_fib_send(ContainerCommand, 2088655d722cSMark Salyzyn cmd_fibcontext, 2089655d722cSMark Salyzyn sizeof(struct aac_power_management), 2090655d722cSMark Salyzyn FsaNormal, 2091655d722cSMark Salyzyn 0, 1, 2092655d722cSMark Salyzyn (fib_callback)aac_start_stop_callback, 2093655d722cSMark Salyzyn (void *)scsicmd); 2094655d722cSMark Salyzyn 2095655d722cSMark Salyzyn /* 2096655d722cSMark Salyzyn * Check that the command queued to the controller 2097655d722cSMark Salyzyn */ 2098655d722cSMark Salyzyn if (status == -EINPROGRESS) { 2099655d722cSMark Salyzyn scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 2100655d722cSMark Salyzyn return 0; 2101655d722cSMark Salyzyn } 2102655d722cSMark Salyzyn 2103655d722cSMark Salyzyn aac_fib_complete(cmd_fibcontext); 2104655d722cSMark Salyzyn aac_fib_free(cmd_fibcontext); 2105655d722cSMark Salyzyn return SCSI_MLQUEUE_HOST_BUSY; 2106655d722cSMark Salyzyn } 2107655d722cSMark Salyzyn 21081da177e4SLinus Torvalds /** 21091da177e4SLinus Torvalds * aac_scsi_cmd() - Process SCSI command 21101da177e4SLinus Torvalds * @scsicmd: SCSI command block 21111da177e4SLinus Torvalds * 21121da177e4SLinus Torvalds * Emulate a SCSI command and queue the required request for the 21131da177e4SLinus Torvalds * aacraid firmware. 21141da177e4SLinus Torvalds */ 21151da177e4SLinus Torvalds 21161da177e4SLinus Torvalds int aac_scsi_cmd(struct scsi_cmnd * scsicmd) 21171da177e4SLinus Torvalds { 21181a655040SSalyzyn, Mark u32 cid; 21191da177e4SLinus Torvalds struct Scsi_Host *host = scsicmd->device->host; 21201da177e4SLinus Torvalds struct aac_dev *dev = (struct aac_dev *)host->hostdata; 21211da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr = dev->fsa_dev; 21221da177e4SLinus Torvalds 212390ee3466SMark Haverkamp if (fsa_dev_ptr == NULL) 212490ee3466SMark Haverkamp return -1; 21251da177e4SLinus Torvalds /* 21261da177e4SLinus Torvalds * If the bus, id or lun is out of range, return fail 21271da177e4SLinus Torvalds * Test does not apply to ID 16, the pseudo id for the controller 21281da177e4SLinus Torvalds * itself. 21291da177e4SLinus Torvalds */ 21301a655040SSalyzyn, Mark cid = scmd_id(scsicmd); 21311a655040SSalyzyn, Mark if (cid != host->this_id) { 21321a655040SSalyzyn, Mark if (scmd_channel(scsicmd) == CONTAINER_CHANNEL) { 21331a655040SSalyzyn, Mark if((cid >= dev->maximum_num_containers) || 2134e5718774SMark Haverkamp (scsicmd->device->lun != 0)) { 21351da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16; 21361da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 21371da177e4SLinus Torvalds return 0; 21381da177e4SLinus Torvalds } 21391da177e4SLinus Torvalds 21401da177e4SLinus Torvalds /* 21411da177e4SLinus Torvalds * If the target container doesn't exist, it may have 21421da177e4SLinus Torvalds * been newly created 21431da177e4SLinus Torvalds */ 2144655d722cSMark Salyzyn if (((fsa_dev_ptr[cid].valid & 1) == 0) || 2145655d722cSMark Salyzyn (fsa_dev_ptr[cid].sense_data.sense_key == 2146655d722cSMark Salyzyn NOT_READY)) { 21471da177e4SLinus Torvalds switch (scsicmd->cmnd[0]) { 21487a8cf29dSMark Haverkamp case SERVICE_ACTION_IN: 21497a8cf29dSMark Haverkamp if (!(dev->raw_io_interface) || 21507a8cf29dSMark Haverkamp !(dev->raw_io_64) || 21517a8cf29dSMark Haverkamp ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16)) 21527a8cf29dSMark Haverkamp break; 21531da177e4SLinus Torvalds case INQUIRY: 21541da177e4SLinus Torvalds case READ_CAPACITY: 21551da177e4SLinus Torvalds case TEST_UNIT_READY: 21568c867b25SMark Haverkamp if (dev->in_reset) 21578c867b25SMark Haverkamp return -1; 2158fe76df42SMark Haverkamp return _aac_probe_container(scsicmd, 2159fe76df42SMark Haverkamp aac_probe_container_callback2); 21601da177e4SLinus Torvalds default: 21611da177e4SLinus Torvalds break; 21621da177e4SLinus Torvalds } 21631da177e4SLinus Torvalds } 21641da177e4SLinus Torvalds } else { /* check for physical non-dasd devices */ 2165cb1042f2SSalyzyn, Mark if (dev->nondasd_support || expose_physicals || 2166cb1042f2SSalyzyn, Mark dev->jbod) { 21678c867b25SMark Haverkamp if (dev->in_reset) 21688c867b25SMark Haverkamp return -1; 21691da177e4SLinus Torvalds return aac_send_srb_fib(scsicmd); 21701da177e4SLinus Torvalds } else { 21711da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16; 21721da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 21731da177e4SLinus Torvalds return 0; 21741da177e4SLinus Torvalds } 21751da177e4SLinus Torvalds } 21761da177e4SLinus Torvalds } 21771da177e4SLinus Torvalds /* 21781da177e4SLinus Torvalds * else Command for the controller itself 21791da177e4SLinus Torvalds */ 21801da177e4SLinus Torvalds else if ((scsicmd->cmnd[0] != INQUIRY) && /* only INQUIRY & TUR cmnd supported for controller */ 21811da177e4SLinus Torvalds (scsicmd->cmnd[0] != TEST_UNIT_READY)) 21821da177e4SLinus Torvalds { 21831da177e4SLinus Torvalds dprintk((KERN_WARNING "Only INQUIRY & TUR command supported for controller, rcvd = 0x%x.\n", scsicmd->cmnd[0])); 21841da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 21858e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 21868e31e607SSalyzyn, Mark ILLEGAL_REQUEST, SENCODE_INVALID_COMMAND, 21878e31e607SSalyzyn, Mark ASENCODE_INVALID_COMMAND, 0, 0); 21881da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 21893ace426fSSalyzyn, Mark min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 21903ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE)); 21911da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 21921da177e4SLinus Torvalds return 0; 21931da177e4SLinus Torvalds } 21941da177e4SLinus Torvalds 21951da177e4SLinus Torvalds 21961da177e4SLinus Torvalds /* Handle commands here that don't really require going out to the adapter */ 21971da177e4SLinus Torvalds switch (scsicmd->cmnd[0]) { 21981da177e4SLinus Torvalds case INQUIRY: 21991da177e4SLinus Torvalds { 22003b2946ccSMark Haverkamp struct inquiry_data inq_data; 22011da177e4SLinus Torvalds 22021a655040SSalyzyn, Mark dprintk((KERN_DEBUG "INQUIRY command, ID: %d.\n", cid)); 22033b2946ccSMark Haverkamp memset(&inq_data, 0, sizeof (struct inquiry_data)); 22041da177e4SLinus Torvalds 2205d8e96507SLeubner, Achim if ((scsicmd->cmnd[1] & 0x1) && aac_wwn) { 220688e2f98eSSalyzyn, Mark char *arr = (char *)&inq_data; 220788e2f98eSSalyzyn, Mark 220888e2f98eSSalyzyn, Mark /* EVPD bit set */ 220988e2f98eSSalyzyn, Mark arr[0] = (scmd_id(scsicmd) == host->this_id) ? 221088e2f98eSSalyzyn, Mark INQD_PDT_PROC : INQD_PDT_DA; 221188e2f98eSSalyzyn, Mark if (scsicmd->cmnd[2] == 0) { 221288e2f98eSSalyzyn, Mark /* supported vital product data pages */ 221388e2f98eSSalyzyn, Mark arr[3] = 2; 221488e2f98eSSalyzyn, Mark arr[4] = 0x0; 221588e2f98eSSalyzyn, Mark arr[5] = 0x80; 221688e2f98eSSalyzyn, Mark arr[1] = scsicmd->cmnd[2]; 2217d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, &inq_data, 221888e2f98eSSalyzyn, Mark sizeof(inq_data)); 221988e2f98eSSalyzyn, Mark scsicmd->result = DID_OK << 16 | 222088e2f98eSSalyzyn, Mark COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 222188e2f98eSSalyzyn, Mark } else if (scsicmd->cmnd[2] == 0x80) { 222288e2f98eSSalyzyn, Mark /* unit serial number page */ 222388e2f98eSSalyzyn, Mark arr[3] = setinqserial(dev, &arr[4], 222488e2f98eSSalyzyn, Mark scmd_id(scsicmd)); 222588e2f98eSSalyzyn, Mark arr[1] = scsicmd->cmnd[2]; 2226d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, &inq_data, 222788e2f98eSSalyzyn, Mark sizeof(inq_data)); 2228d8e96507SLeubner, Achim if (aac_wwn != 2) 2229d8e96507SLeubner, Achim return aac_get_container_serial( 2230d8e96507SLeubner, Achim scsicmd); 2231d8e96507SLeubner, Achim /* SLES 10 SP1 special */ 2232d8e96507SLeubner, Achim scsicmd->result = DID_OK << 16 | 2233d8e96507SLeubner, Achim COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 223488e2f98eSSalyzyn, Mark } else { 223588e2f98eSSalyzyn, Mark /* vpd page not implemented */ 223688e2f98eSSalyzyn, Mark scsicmd->result = DID_OK << 16 | 223788e2f98eSSalyzyn, Mark COMMAND_COMPLETE << 8 | 223888e2f98eSSalyzyn, Mark SAM_STAT_CHECK_CONDITION; 22398e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 22408e31e607SSalyzyn, Mark ILLEGAL_REQUEST, SENCODE_INVALID_CDB_FIELD, 22418e31e607SSalyzyn, Mark ASENCODE_NO_SENSE, 7, 2); 224288e2f98eSSalyzyn, Mark memcpy(scsicmd->sense_buffer, 224388e2f98eSSalyzyn, Mark &dev->fsa_dev[cid].sense_data, 22443ace426fSSalyzyn, Mark min_t(size_t, 22453ace426fSSalyzyn, Mark sizeof(dev->fsa_dev[cid].sense_data), 22463ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE)); 224788e2f98eSSalyzyn, Mark } 224888e2f98eSSalyzyn, Mark scsicmd->scsi_done(scsicmd); 224988e2f98eSSalyzyn, Mark return 0; 225088e2f98eSSalyzyn, Mark } 22513b2946ccSMark Haverkamp inq_data.inqd_ver = 2; /* claim compliance to SCSI-2 */ 22523b2946ccSMark 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 */ 22533b2946ccSMark Haverkamp inq_data.inqd_len = 31; 22541da177e4SLinus Torvalds /*Format for "pad2" is RelAdr | WBus32 | WBus16 | Sync | Linked |Reserved| CmdQue | SftRe */ 22553b2946ccSMark Haverkamp inq_data.inqd_pad2= 0x32 ; /*WBus16|Sync|CmdQue */ 22561da177e4SLinus Torvalds /* 22571da177e4SLinus Torvalds * Set the Vendor, Product, and Revision Level 22581da177e4SLinus Torvalds * see: <vendor>.c i.e. aac.c 22591da177e4SLinus Torvalds */ 22601a655040SSalyzyn, Mark if (cid == host->this_id) { 22616391a113STobias Klauser setinqstr(dev, (void *) (inq_data.inqd_vid), ARRAY_SIZE(container_types)); 22623b2946ccSMark Haverkamp inq_data.inqd_pdt = INQD_PDT_PROC; /* Processor device */ 2263d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, &inq_data, 2264d4345028SFUJITA Tomonori sizeof(inq_data)); 22651da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 22661da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 22671da177e4SLinus Torvalds return 0; 22681da177e4SLinus Torvalds } 22698c867b25SMark Haverkamp if (dev->in_reset) 22708c867b25SMark Haverkamp return -1; 2271794d0601SMark Haverkamp setinqstr(dev, (void *) (inq_data.inqd_vid), fsa_dev_ptr[cid].type); 22723b2946ccSMark Haverkamp inq_data.inqd_pdt = INQD_PDT_DA; /* Direct/random access device */ 2273d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, &inq_data, sizeof(inq_data)); 22749e7c349cSMark Haverkamp return aac_get_container_name(scsicmd); 22751da177e4SLinus Torvalds } 22767a8cf29dSMark Haverkamp case SERVICE_ACTION_IN: 22777a8cf29dSMark Haverkamp if (!(dev->raw_io_interface) || 22787a8cf29dSMark Haverkamp !(dev->raw_io_64) || 22797a8cf29dSMark Haverkamp ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16)) 22807a8cf29dSMark Haverkamp break; 22817a8cf29dSMark Haverkamp { 22827a8cf29dSMark Haverkamp u64 capacity; 228307ce5ebaSMark Haverkamp char cp[13]; 2284b271f1c8SFUJITA Tomonori unsigned int alloc_len; 22857a8cf29dSMark Haverkamp 22867a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "READ CAPACITY_16 command.\n")); 22877a8cf29dSMark Haverkamp capacity = fsa_dev_ptr[cid].size - 1; 22887a8cf29dSMark Haverkamp cp[0] = (capacity >> 56) & 0xff; 22897a8cf29dSMark Haverkamp cp[1] = (capacity >> 48) & 0xff; 22907a8cf29dSMark Haverkamp cp[2] = (capacity >> 40) & 0xff; 22917a8cf29dSMark Haverkamp cp[3] = (capacity >> 32) & 0xff; 22927a8cf29dSMark Haverkamp cp[4] = (capacity >> 24) & 0xff; 22937a8cf29dSMark Haverkamp cp[5] = (capacity >> 16) & 0xff; 22947a8cf29dSMark Haverkamp cp[6] = (capacity >> 8) & 0xff; 22957a8cf29dSMark Haverkamp cp[7] = (capacity >> 0) & 0xff; 22967a8cf29dSMark Haverkamp cp[8] = 0; 22977a8cf29dSMark Haverkamp cp[9] = 0; 22987a8cf29dSMark Haverkamp cp[10] = 2; 22997a8cf29dSMark Haverkamp cp[11] = 0; 230007ce5ebaSMark Haverkamp cp[12] = 0; 230107ce5ebaSMark Haverkamp 2302b271f1c8SFUJITA Tomonori alloc_len = ((scsicmd->cmnd[10] << 24) 2303b271f1c8SFUJITA Tomonori + (scsicmd->cmnd[11] << 16) 2304b271f1c8SFUJITA Tomonori + (scsicmd->cmnd[12] << 8) + scsicmd->cmnd[13]); 2305b271f1c8SFUJITA Tomonori 2306b271f1c8SFUJITA Tomonori alloc_len = min_t(size_t, alloc_len, sizeof(cp)); 2307d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, cp, alloc_len); 2308b271f1c8SFUJITA Tomonori if (alloc_len < scsi_bufflen(scsicmd)) 2309b271f1c8SFUJITA Tomonori scsi_set_resid(scsicmd, 2310b271f1c8SFUJITA Tomonori scsi_bufflen(scsicmd) - alloc_len); 23117a8cf29dSMark Haverkamp 23127a8cf29dSMark Haverkamp /* Do not cache partition table for arrays */ 23137a8cf29dSMark Haverkamp scsicmd->device->removable = 1; 23147a8cf29dSMark Haverkamp 23157a8cf29dSMark Haverkamp scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 23167a8cf29dSMark Haverkamp scsicmd->scsi_done(scsicmd); 23177a8cf29dSMark Haverkamp 23187a8cf29dSMark Haverkamp return 0; 23197a8cf29dSMark Haverkamp } 23207a8cf29dSMark Haverkamp 23211da177e4SLinus Torvalds case READ_CAPACITY: 23221da177e4SLinus Torvalds { 23231da177e4SLinus Torvalds u32 capacity; 23243b2946ccSMark Haverkamp char cp[8]; 23251da177e4SLinus Torvalds 23261da177e4SLinus Torvalds dprintk((KERN_DEBUG "READ CAPACITY command.\n")); 23277a8cf29dSMark Haverkamp if (fsa_dev_ptr[cid].size <= 0x100000000ULL) 23281da177e4SLinus Torvalds capacity = fsa_dev_ptr[cid].size - 1; 23291da177e4SLinus Torvalds else 23301da177e4SLinus Torvalds capacity = (u32)-1; 23313b2946ccSMark Haverkamp 23321da177e4SLinus Torvalds cp[0] = (capacity >> 24) & 0xff; 23331da177e4SLinus Torvalds cp[1] = (capacity >> 16) & 0xff; 23341da177e4SLinus Torvalds cp[2] = (capacity >> 8) & 0xff; 23351da177e4SLinus Torvalds cp[3] = (capacity >> 0) & 0xff; 23361da177e4SLinus Torvalds cp[4] = 0; 23371da177e4SLinus Torvalds cp[5] = 0; 23381da177e4SLinus Torvalds cp[6] = 2; 23391da177e4SLinus Torvalds cp[7] = 0; 2340d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, cp, sizeof(cp)); 23417a8cf29dSMark Haverkamp /* Do not cache partition table for arrays */ 23427a8cf29dSMark Haverkamp scsicmd->device->removable = 1; 2343655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 2344655d722cSMark Salyzyn SAM_STAT_GOOD; 23451da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 23461da177e4SLinus Torvalds 23471da177e4SLinus Torvalds return 0; 23481da177e4SLinus Torvalds } 23491da177e4SLinus Torvalds 23501da177e4SLinus Torvalds case MODE_SENSE: 23511da177e4SLinus Torvalds { 23529d399cc7SSalyzyn, Mark char mode_buf[7]; 23539d399cc7SSalyzyn, Mark int mode_buf_length = 4; 23541da177e4SLinus Torvalds 23551da177e4SLinus Torvalds dprintk((KERN_DEBUG "MODE SENSE command.\n")); 23561da177e4SLinus Torvalds mode_buf[0] = 3; /* Mode data length */ 23571da177e4SLinus Torvalds mode_buf[1] = 0; /* Medium type - default */ 23589d399cc7SSalyzyn, Mark mode_buf[2] = 0; /* Device-specific param, 23599d399cc7SSalyzyn, Mark bit 8: 0/1 = write enabled/protected 23609d399cc7SSalyzyn, Mark bit 4: 0/1 = FUA enabled */ 236195e852e1SSalyzyn, Mark if (dev->raw_io_interface && ((aac_cache & 5) != 1)) 23629d399cc7SSalyzyn, Mark mode_buf[2] = 0x10; 23631da177e4SLinus Torvalds mode_buf[3] = 0; /* Block descriptor length */ 23649d399cc7SSalyzyn, Mark if (((scsicmd->cmnd[2] & 0x3f) == 8) || 23659d399cc7SSalyzyn, Mark ((scsicmd->cmnd[2] & 0x3f) == 0x3f)) { 23669d399cc7SSalyzyn, Mark mode_buf[0] = 6; 23679d399cc7SSalyzyn, Mark mode_buf[4] = 8; 23689d399cc7SSalyzyn, Mark mode_buf[5] = 1; 236995e852e1SSalyzyn, Mark mode_buf[6] = ((aac_cache & 6) == 2) 237095e852e1SSalyzyn, Mark ? 0 : 0x04; /* WCE */ 23719d399cc7SSalyzyn, Mark mode_buf_length = 7; 23729d399cc7SSalyzyn, Mark if (mode_buf_length > scsicmd->cmnd[4]) 23739d399cc7SSalyzyn, Mark mode_buf_length = scsicmd->cmnd[4]; 23749d399cc7SSalyzyn, Mark } 2375d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, mode_buf, mode_buf_length); 23761da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 23771da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 23781da177e4SLinus Torvalds 23791da177e4SLinus Torvalds return 0; 23801da177e4SLinus Torvalds } 23811da177e4SLinus Torvalds case MODE_SENSE_10: 23821da177e4SLinus Torvalds { 23839d399cc7SSalyzyn, Mark char mode_buf[11]; 23849d399cc7SSalyzyn, Mark int mode_buf_length = 8; 23851da177e4SLinus Torvalds 23861da177e4SLinus Torvalds dprintk((KERN_DEBUG "MODE SENSE 10 byte command.\n")); 23871da177e4SLinus Torvalds mode_buf[0] = 0; /* Mode data length (MSB) */ 23881da177e4SLinus Torvalds mode_buf[1] = 6; /* Mode data length (LSB) */ 23891da177e4SLinus Torvalds mode_buf[2] = 0; /* Medium type - default */ 23909d399cc7SSalyzyn, Mark mode_buf[3] = 0; /* Device-specific param, 23919d399cc7SSalyzyn, Mark bit 8: 0/1 = write enabled/protected 23929d399cc7SSalyzyn, Mark bit 4: 0/1 = FUA enabled */ 239395e852e1SSalyzyn, Mark if (dev->raw_io_interface && ((aac_cache & 5) != 1)) 23949d399cc7SSalyzyn, Mark mode_buf[3] = 0x10; 23951da177e4SLinus Torvalds mode_buf[4] = 0; /* reserved */ 23961da177e4SLinus Torvalds mode_buf[5] = 0; /* reserved */ 23971da177e4SLinus Torvalds mode_buf[6] = 0; /* Block descriptor length (MSB) */ 23981da177e4SLinus Torvalds mode_buf[7] = 0; /* Block descriptor length (LSB) */ 23999d399cc7SSalyzyn, Mark if (((scsicmd->cmnd[2] & 0x3f) == 8) || 24009d399cc7SSalyzyn, Mark ((scsicmd->cmnd[2] & 0x3f) == 0x3f)) { 24019d399cc7SSalyzyn, Mark mode_buf[1] = 9; 24029d399cc7SSalyzyn, Mark mode_buf[8] = 8; 24039d399cc7SSalyzyn, Mark mode_buf[9] = 1; 240495e852e1SSalyzyn, Mark mode_buf[10] = ((aac_cache & 6) == 2) 240595e852e1SSalyzyn, Mark ? 0 : 0x04; /* WCE */ 24069d399cc7SSalyzyn, Mark mode_buf_length = 11; 24079d399cc7SSalyzyn, Mark if (mode_buf_length > scsicmd->cmnd[8]) 24089d399cc7SSalyzyn, Mark mode_buf_length = scsicmd->cmnd[8]; 24099d399cc7SSalyzyn, Mark } 2410d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, mode_buf, mode_buf_length); 24111da177e4SLinus Torvalds 24121da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 24131da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 24141da177e4SLinus Torvalds 24151da177e4SLinus Torvalds return 0; 24161da177e4SLinus Torvalds } 24171da177e4SLinus Torvalds case REQUEST_SENSE: 24181da177e4SLinus Torvalds dprintk((KERN_DEBUG "REQUEST SENSE command.\n")); 24191da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, sizeof (struct sense_data)); 24201da177e4SLinus Torvalds memset(&dev->fsa_dev[cid].sense_data, 0, sizeof (struct sense_data)); 24211da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 24221da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 24231da177e4SLinus Torvalds return 0; 24241da177e4SLinus Torvalds 24251da177e4SLinus Torvalds case ALLOW_MEDIUM_REMOVAL: 24261da177e4SLinus Torvalds dprintk((KERN_DEBUG "LOCK command.\n")); 24271da177e4SLinus Torvalds if (scsicmd->cmnd[4]) 24281da177e4SLinus Torvalds fsa_dev_ptr[cid].locked = 1; 24291da177e4SLinus Torvalds else 24301da177e4SLinus Torvalds fsa_dev_ptr[cid].locked = 0; 24311da177e4SLinus Torvalds 24321da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 24331da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 24341da177e4SLinus Torvalds return 0; 24351da177e4SLinus Torvalds /* 24361da177e4SLinus Torvalds * These commands are all No-Ops 24371da177e4SLinus Torvalds */ 24381da177e4SLinus Torvalds case TEST_UNIT_READY: 2439655d722cSMark Salyzyn if (fsa_dev_ptr[cid].sense_data.sense_key == NOT_READY) { 2440655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 2441655d722cSMark Salyzyn SAM_STAT_CHECK_CONDITION; 2442655d722cSMark Salyzyn set_sense(&dev->fsa_dev[cid].sense_data, 2443655d722cSMark Salyzyn NOT_READY, SENCODE_BECOMING_READY, 2444655d722cSMark Salyzyn ASENCODE_BECOMING_READY, 0, 0); 2445655d722cSMark Salyzyn memcpy(scsicmd->sense_buffer, 2446655d722cSMark Salyzyn &dev->fsa_dev[cid].sense_data, 2447655d722cSMark Salyzyn min_t(size_t, 2448655d722cSMark Salyzyn sizeof(dev->fsa_dev[cid].sense_data), 2449655d722cSMark Salyzyn SCSI_SENSE_BUFFERSIZE)); 2450655d722cSMark Salyzyn scsicmd->scsi_done(scsicmd); 2451655d722cSMark Salyzyn return 0; 2452655d722cSMark Salyzyn } 2453655d722cSMark Salyzyn /* FALLTHRU */ 24541da177e4SLinus Torvalds case RESERVE: 24551da177e4SLinus Torvalds case RELEASE: 24561da177e4SLinus Torvalds case REZERO_UNIT: 24571da177e4SLinus Torvalds case REASSIGN_BLOCKS: 24581da177e4SLinus Torvalds case SEEK_10: 24591da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 24601da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 24611da177e4SLinus Torvalds return 0; 2462655d722cSMark Salyzyn 2463655d722cSMark Salyzyn case START_STOP: 2464655d722cSMark Salyzyn return aac_start_stop(scsicmd); 24651da177e4SLinus Torvalds } 24661da177e4SLinus Torvalds 24671da177e4SLinus Torvalds switch (scsicmd->cmnd[0]) 24681da177e4SLinus Torvalds { 24691da177e4SLinus Torvalds case READ_6: 24701da177e4SLinus Torvalds case READ_10: 24717a8cf29dSMark Haverkamp case READ_12: 24727a8cf29dSMark Haverkamp case READ_16: 24738c867b25SMark Haverkamp if (dev->in_reset) 24748c867b25SMark Haverkamp return -1; 24751da177e4SLinus Torvalds /* 24761da177e4SLinus Torvalds * Hack to keep track of ordinal number of the device that 24771da177e4SLinus Torvalds * corresponds to a container. Needed to convert 24781da177e4SLinus Torvalds * containers to /dev/sd device names 24791da177e4SLinus Torvalds */ 24801da177e4SLinus Torvalds 24811da177e4SLinus Torvalds if (scsicmd->request->rq_disk) 24827a8cf29dSMark Haverkamp strlcpy(fsa_dev_ptr[cid].devname, 24831da177e4SLinus Torvalds scsicmd->request->rq_disk->disk_name, 24847a8cf29dSMark Haverkamp min(sizeof(fsa_dev_ptr[cid].devname), 24857a8cf29dSMark Haverkamp sizeof(scsicmd->request->rq_disk->disk_name) + 1)); 248677d644d4SMark Haverkamp 24879e7c349cSMark Haverkamp return aac_read(scsicmd); 24881da177e4SLinus Torvalds 24891da177e4SLinus Torvalds case WRITE_6: 24901da177e4SLinus Torvalds case WRITE_10: 24917a8cf29dSMark Haverkamp case WRITE_12: 24927a8cf29dSMark Haverkamp case WRITE_16: 24938c867b25SMark Haverkamp if (dev->in_reset) 24948c867b25SMark Haverkamp return -1; 24959e7c349cSMark Haverkamp return aac_write(scsicmd); 24961da177e4SLinus Torvalds 24971da177e4SLinus Torvalds case SYNCHRONIZE_CACHE: 249895e852e1SSalyzyn, Mark if (((aac_cache & 6) == 6) && dev->cache_protected) { 249995e852e1SSalyzyn, Mark scsicmd->result = DID_OK << 16 | 250095e852e1SSalyzyn, Mark COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 250195e852e1SSalyzyn, Mark scsicmd->scsi_done(scsicmd); 250295e852e1SSalyzyn, Mark return 0; 250395e852e1SSalyzyn, Mark } 25041da177e4SLinus Torvalds /* Issue FIB to tell Firmware to flush it's cache */ 250595e852e1SSalyzyn, Mark if ((aac_cache & 6) != 2) 25069e7c349cSMark Haverkamp return aac_synchronize(scsicmd); 250795e852e1SSalyzyn, Mark /* FALLTHRU */ 25081da177e4SLinus Torvalds default: 25091da177e4SLinus Torvalds /* 25101da177e4SLinus Torvalds * Unhandled commands 25111da177e4SLinus Torvalds */ 25127c00ffa3SMark Haverkamp dprintk((KERN_WARNING "Unhandled SCSI Command: 0x%x.\n", scsicmd->cmnd[0])); 25131da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 25148e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 25151da177e4SLinus Torvalds ILLEGAL_REQUEST, SENCODE_INVALID_COMMAND, 25168e31e607SSalyzyn, Mark ASENCODE_INVALID_COMMAND, 0, 0); 25171da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 25183ace426fSSalyzyn, Mark min_t(size_t, 25193ace426fSSalyzyn, Mark sizeof(dev->fsa_dev[cid].sense_data), 25203ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE)); 25211da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 25221da177e4SLinus Torvalds return 0; 25231da177e4SLinus Torvalds } 25241da177e4SLinus Torvalds } 25251da177e4SLinus Torvalds 25261da177e4SLinus Torvalds static int query_disk(struct aac_dev *dev, void __user *arg) 25271da177e4SLinus Torvalds { 25281da177e4SLinus Torvalds struct aac_query_disk qd; 25291da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 25301da177e4SLinus Torvalds 25311da177e4SLinus Torvalds fsa_dev_ptr = dev->fsa_dev; 253290ee3466SMark Haverkamp if (!fsa_dev_ptr) 253365101355SMark Haverkamp return -EBUSY; 25341da177e4SLinus Torvalds if (copy_from_user(&qd, arg, sizeof (struct aac_query_disk))) 25351da177e4SLinus Torvalds return -EFAULT; 25361da177e4SLinus Torvalds if (qd.cnum == -1) 2537e5718774SMark Haverkamp qd.cnum = qd.id; 25381da177e4SLinus Torvalds else if ((qd.bus == -1) && (qd.id == -1) && (qd.lun == -1)) 25391da177e4SLinus Torvalds { 25401da177e4SLinus Torvalds if (qd.cnum < 0 || qd.cnum >= dev->maximum_num_containers) 25411da177e4SLinus Torvalds return -EINVAL; 25421da177e4SLinus Torvalds qd.instance = dev->scsi_host_ptr->host_no; 25431da177e4SLinus Torvalds qd.bus = 0; 25441da177e4SLinus Torvalds qd.id = CONTAINER_TO_ID(qd.cnum); 25451da177e4SLinus Torvalds qd.lun = CONTAINER_TO_LUN(qd.cnum); 25461da177e4SLinus Torvalds } 25471da177e4SLinus Torvalds else return -EINVAL; 25481da177e4SLinus Torvalds 2549fd622b1bSSalyzyn, Mark qd.valid = fsa_dev_ptr[qd.cnum].valid != 0; 25501da177e4SLinus Torvalds qd.locked = fsa_dev_ptr[qd.cnum].locked; 25511da177e4SLinus Torvalds qd.deleted = fsa_dev_ptr[qd.cnum].deleted; 25521da177e4SLinus Torvalds 25531da177e4SLinus Torvalds if (fsa_dev_ptr[qd.cnum].devname[0] == '\0') 25541da177e4SLinus Torvalds qd.unmapped = 1; 25551da177e4SLinus Torvalds else 25561da177e4SLinus Torvalds qd.unmapped = 0; 25571da177e4SLinus Torvalds 25581da177e4SLinus Torvalds strlcpy(qd.name, fsa_dev_ptr[qd.cnum].devname, 25591da177e4SLinus Torvalds min(sizeof(qd.name), sizeof(fsa_dev_ptr[qd.cnum].devname) + 1)); 25601da177e4SLinus Torvalds 25611da177e4SLinus Torvalds if (copy_to_user(arg, &qd, sizeof (struct aac_query_disk))) 25621da177e4SLinus Torvalds return -EFAULT; 25631da177e4SLinus Torvalds return 0; 25641da177e4SLinus Torvalds } 25651da177e4SLinus Torvalds 25661da177e4SLinus Torvalds static int force_delete_disk(struct aac_dev *dev, void __user *arg) 25671da177e4SLinus Torvalds { 25681da177e4SLinus Torvalds struct aac_delete_disk dd; 25691da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 25701da177e4SLinus Torvalds 25711da177e4SLinus Torvalds fsa_dev_ptr = dev->fsa_dev; 257265101355SMark Haverkamp if (!fsa_dev_ptr) 257365101355SMark Haverkamp return -EBUSY; 25741da177e4SLinus Torvalds 25751da177e4SLinus Torvalds if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk))) 25761da177e4SLinus Torvalds return -EFAULT; 25771da177e4SLinus Torvalds 25781da177e4SLinus Torvalds if (dd.cnum >= dev->maximum_num_containers) 25791da177e4SLinus Torvalds return -EINVAL; 25801da177e4SLinus Torvalds /* 25811da177e4SLinus Torvalds * Mark this container as being deleted. 25821da177e4SLinus Torvalds */ 25831da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].deleted = 1; 25841da177e4SLinus Torvalds /* 25851da177e4SLinus Torvalds * Mark the container as no longer valid 25861da177e4SLinus Torvalds */ 25871da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].valid = 0; 25881da177e4SLinus Torvalds return 0; 25891da177e4SLinus Torvalds } 25901da177e4SLinus Torvalds 25911da177e4SLinus Torvalds static int delete_disk(struct aac_dev *dev, void __user *arg) 25921da177e4SLinus Torvalds { 25931da177e4SLinus Torvalds struct aac_delete_disk dd; 25941da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 25951da177e4SLinus Torvalds 25961da177e4SLinus Torvalds fsa_dev_ptr = dev->fsa_dev; 259790ee3466SMark Haverkamp if (!fsa_dev_ptr) 259865101355SMark Haverkamp return -EBUSY; 25991da177e4SLinus Torvalds 26001da177e4SLinus Torvalds if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk))) 26011da177e4SLinus Torvalds return -EFAULT; 26021da177e4SLinus Torvalds 26031da177e4SLinus Torvalds if (dd.cnum >= dev->maximum_num_containers) 26041da177e4SLinus Torvalds return -EINVAL; 26051da177e4SLinus Torvalds /* 26061da177e4SLinus Torvalds * If the container is locked, it can not be deleted by the API. 26071da177e4SLinus Torvalds */ 26081da177e4SLinus Torvalds if (fsa_dev_ptr[dd.cnum].locked) 26091da177e4SLinus Torvalds return -EBUSY; 26101da177e4SLinus Torvalds else { 26111da177e4SLinus Torvalds /* 26121da177e4SLinus Torvalds * Mark the container as no longer being valid. 26131da177e4SLinus Torvalds */ 26141da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].valid = 0; 26151da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].devname[0] = '\0'; 26161da177e4SLinus Torvalds return 0; 26171da177e4SLinus Torvalds } 26181da177e4SLinus Torvalds } 26191da177e4SLinus Torvalds 26201da177e4SLinus Torvalds int aac_dev_ioctl(struct aac_dev *dev, int cmd, void __user *arg) 26211da177e4SLinus Torvalds { 26221da177e4SLinus Torvalds switch (cmd) { 26231da177e4SLinus Torvalds case FSACTL_QUERY_DISK: 26241da177e4SLinus Torvalds return query_disk(dev, arg); 26251da177e4SLinus Torvalds case FSACTL_DELETE_DISK: 26261da177e4SLinus Torvalds return delete_disk(dev, arg); 26271da177e4SLinus Torvalds case FSACTL_FORCE_DELETE_DISK: 26281da177e4SLinus Torvalds return force_delete_disk(dev, arg); 26291da177e4SLinus Torvalds case FSACTL_GET_CONTAINERS: 26301da177e4SLinus Torvalds return aac_get_containers(dev); 26311da177e4SLinus Torvalds default: 26321da177e4SLinus Torvalds return -ENOTTY; 26331da177e4SLinus Torvalds } 26341da177e4SLinus Torvalds } 26351da177e4SLinus Torvalds 26361da177e4SLinus Torvalds /** 26371da177e4SLinus Torvalds * 26381da177e4SLinus Torvalds * aac_srb_callback 26391da177e4SLinus Torvalds * @context: the context set in the fib - here it is scsi cmd 26401da177e4SLinus Torvalds * @fibptr: pointer to the fib 26411da177e4SLinus Torvalds * 26421da177e4SLinus Torvalds * Handles the completion of a scsi command to a non dasd device 26431da177e4SLinus Torvalds * 26441da177e4SLinus Torvalds */ 26451da177e4SLinus Torvalds 26461da177e4SLinus Torvalds static void aac_srb_callback(void *context, struct fib * fibptr) 26471da177e4SLinus Torvalds { 26481da177e4SLinus Torvalds struct aac_dev *dev; 26491da177e4SLinus Torvalds struct aac_srb_reply *srbreply; 26501da177e4SLinus Torvalds struct scsi_cmnd *scsicmd; 26511da177e4SLinus Torvalds 26521da177e4SLinus Torvalds scsicmd = (struct scsi_cmnd *) context; 265303d44337SMark Haverkamp 265403d44337SMark Haverkamp if (!aac_valid_context(scsicmd, fibptr)) 265503d44337SMark Haverkamp return; 265603d44337SMark Haverkamp 2657125e1874SEric Sesterhenn BUG_ON(fibptr == NULL); 26581da177e4SLinus Torvalds 26591a655040SSalyzyn, Mark dev = fibptr->dev; 26601a655040SSalyzyn, Mark 26611da177e4SLinus Torvalds srbreply = (struct aac_srb_reply *) fib_data(fibptr); 26621da177e4SLinus Torvalds 26631da177e4SLinus Torvalds scsicmd->sense_buffer[0] = '\0'; /* Initialize sense valid flag to false */ 266485d22bbfSMahesh Rajashekhara 266585d22bbfSMahesh Rajashekhara if (fibptr->flags & FIB_CONTEXT_FLAG_FASTRESP) { 266685d22bbfSMahesh Rajashekhara /* fast response */ 266785d22bbfSMahesh Rajashekhara srbreply->srb_status = cpu_to_le32(SRB_STATUS_SUCCESS); 266885d22bbfSMahesh Rajashekhara srbreply->scsi_status = cpu_to_le32(SAM_STAT_GOOD); 266985d22bbfSMahesh Rajashekhara } else { 26701da177e4SLinus Torvalds /* 26711da177e4SLinus Torvalds * Calculate resid for sg 26721da177e4SLinus Torvalds */ 2673727eead6SFUJITA Tomonori scsi_set_resid(scsicmd, scsi_bufflen(scsicmd) 2674727eead6SFUJITA Tomonori - le32_to_cpu(srbreply->data_xfer_length)); 267585d22bbfSMahesh Rajashekhara } 26761da177e4SLinus Torvalds 2677727eead6SFUJITA Tomonori scsi_dma_unmap(scsicmd); 26781da177e4SLinus Torvalds 2679e3cc268fSRajashekhara, Mahesh /* expose physical device if expose_physicald flag is on */ 2680e3cc268fSRajashekhara, Mahesh if (scsicmd->cmnd[0] == INQUIRY && !(scsicmd->cmnd[1] & 0x01) 2681e3cc268fSRajashekhara, Mahesh && expose_physicals > 0) 2682e3cc268fSRajashekhara, Mahesh aac_expose_phy_device(scsicmd); 2683e3cc268fSRajashekhara, Mahesh 26841da177e4SLinus Torvalds /* 26851da177e4SLinus Torvalds * First check the fib status 26861da177e4SLinus Torvalds */ 26871da177e4SLinus Torvalds 26881da177e4SLinus Torvalds if (le32_to_cpu(srbreply->status) != ST_OK){ 26891da177e4SLinus Torvalds int len; 26901da177e4SLinus Torvalds printk(KERN_WARNING "aac_srb_callback: srb failed, status = %d\n", le32_to_cpu(srbreply->status)); 26913ace426fSSalyzyn, Mark len = min_t(u32, le32_to_cpu(srbreply->sense_data_size), 26923ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE); 26931da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 26941da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, srbreply->sense_data, len); 26951da177e4SLinus Torvalds } 26961da177e4SLinus Torvalds 26971da177e4SLinus Torvalds /* 26981da177e4SLinus Torvalds * Next check the srb status 26991da177e4SLinus Torvalds */ 27001da177e4SLinus Torvalds switch( (le32_to_cpu(srbreply->srb_status))&0x3f){ 27011da177e4SLinus Torvalds case SRB_STATUS_ERROR_RECOVERY: 27021da177e4SLinus Torvalds case SRB_STATUS_PENDING: 27031da177e4SLinus Torvalds case SRB_STATUS_SUCCESS: 27041da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 27051da177e4SLinus Torvalds break; 27061da177e4SLinus Torvalds case SRB_STATUS_DATA_OVERRUN: 27071da177e4SLinus Torvalds switch(scsicmd->cmnd[0]){ 27081da177e4SLinus Torvalds case READ_6: 27091da177e4SLinus Torvalds case WRITE_6: 27101da177e4SLinus Torvalds case READ_10: 27111da177e4SLinus Torvalds case WRITE_10: 27121da177e4SLinus Torvalds case READ_12: 27131da177e4SLinus Torvalds case WRITE_12: 27147a8cf29dSMark Haverkamp case READ_16: 27157a8cf29dSMark Haverkamp case WRITE_16: 27161da177e4SLinus Torvalds if (le32_to_cpu(srbreply->data_xfer_length) < scsicmd->underflow) { 27171da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: SCSI CMD underflow\n"); 27181da177e4SLinus Torvalds } else { 27191da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: SCSI CMD Data Overrun\n"); 27201da177e4SLinus Torvalds } 27211da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8; 27221da177e4SLinus Torvalds break; 27231da177e4SLinus Torvalds case INQUIRY: { 27241da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 27251da177e4SLinus Torvalds break; 27261da177e4SLinus Torvalds } 27271da177e4SLinus Torvalds default: 27281da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 27291da177e4SLinus Torvalds break; 27301da177e4SLinus Torvalds } 27311da177e4SLinus Torvalds break; 27321da177e4SLinus Torvalds case SRB_STATUS_ABORTED: 27331da177e4SLinus Torvalds scsicmd->result = DID_ABORT << 16 | ABORT << 8; 27341da177e4SLinus Torvalds break; 27351da177e4SLinus Torvalds case SRB_STATUS_ABORT_FAILED: 27361da177e4SLinus Torvalds // Not sure about this one - but assuming the hba was trying to abort for some reason 27371da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | ABORT << 8; 27381da177e4SLinus Torvalds break; 27391da177e4SLinus Torvalds case SRB_STATUS_PARITY_ERROR: 27401da177e4SLinus Torvalds scsicmd->result = DID_PARITY << 16 | MSG_PARITY_ERROR << 8; 27411da177e4SLinus Torvalds break; 27421da177e4SLinus Torvalds case SRB_STATUS_NO_DEVICE: 27431da177e4SLinus Torvalds case SRB_STATUS_INVALID_PATH_ID: 27441da177e4SLinus Torvalds case SRB_STATUS_INVALID_TARGET_ID: 27451da177e4SLinus Torvalds case SRB_STATUS_INVALID_LUN: 27461da177e4SLinus Torvalds case SRB_STATUS_SELECTION_TIMEOUT: 27471da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8; 27481da177e4SLinus Torvalds break; 27491da177e4SLinus Torvalds 27501da177e4SLinus Torvalds case SRB_STATUS_COMMAND_TIMEOUT: 27511da177e4SLinus Torvalds case SRB_STATUS_TIMEOUT: 27521da177e4SLinus Torvalds scsicmd->result = DID_TIME_OUT << 16 | COMMAND_COMPLETE << 8; 27531da177e4SLinus Torvalds break; 27541da177e4SLinus Torvalds 27551da177e4SLinus Torvalds case SRB_STATUS_BUSY: 2756760af100SSalyzyn, Mark scsicmd->result = DID_BUS_BUSY << 16 | COMMAND_COMPLETE << 8; 27571da177e4SLinus Torvalds break; 27581da177e4SLinus Torvalds 27591da177e4SLinus Torvalds case SRB_STATUS_BUS_RESET: 27601da177e4SLinus Torvalds scsicmd->result = DID_RESET << 16 | COMMAND_COMPLETE << 8; 27611da177e4SLinus Torvalds break; 27621da177e4SLinus Torvalds 27631da177e4SLinus Torvalds case SRB_STATUS_MESSAGE_REJECTED: 27641da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | MESSAGE_REJECT << 8; 27651da177e4SLinus Torvalds break; 27661da177e4SLinus Torvalds case SRB_STATUS_REQUEST_FLUSHED: 27671da177e4SLinus Torvalds case SRB_STATUS_ERROR: 27681da177e4SLinus Torvalds case SRB_STATUS_INVALID_REQUEST: 27691da177e4SLinus Torvalds case SRB_STATUS_REQUEST_SENSE_FAILED: 27701da177e4SLinus Torvalds case SRB_STATUS_NO_HBA: 27711da177e4SLinus Torvalds case SRB_STATUS_UNEXPECTED_BUS_FREE: 27721da177e4SLinus Torvalds case SRB_STATUS_PHASE_SEQUENCE_FAILURE: 27731da177e4SLinus Torvalds case SRB_STATUS_BAD_SRB_BLOCK_LENGTH: 27741da177e4SLinus Torvalds case SRB_STATUS_DELAYED_RETRY: 27751da177e4SLinus Torvalds case SRB_STATUS_BAD_FUNCTION: 27761da177e4SLinus Torvalds case SRB_STATUS_NOT_STARTED: 27771da177e4SLinus Torvalds case SRB_STATUS_NOT_IN_USE: 27781da177e4SLinus Torvalds case SRB_STATUS_FORCE_ABORT: 27791da177e4SLinus Torvalds case SRB_STATUS_DOMAIN_VALIDATION_FAIL: 27801da177e4SLinus Torvalds default: 27811da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 27821da177e4SLinus Torvalds printk("aacraid: SRB ERROR(%u) %s scsi cmd 0x%x - scsi status 0x%x\n", 27831da177e4SLinus Torvalds le32_to_cpu(srbreply->srb_status) & 0x3F, 27841da177e4SLinus Torvalds aac_get_status_string( 27851da177e4SLinus Torvalds le32_to_cpu(srbreply->srb_status) & 0x3F), 27861da177e4SLinus Torvalds scsicmd->cmnd[0], 27871da177e4SLinus Torvalds le32_to_cpu(srbreply->scsi_status)); 27881da177e4SLinus Torvalds #endif 27891fc8010aSRajashekhara, Mahesh if ((scsicmd->cmnd[0] == ATA_12) 27901fc8010aSRajashekhara, Mahesh || (scsicmd->cmnd[0] == ATA_16)) { 27911fc8010aSRajashekhara, Mahesh if (scsicmd->cmnd[2] & (0x01 << 5)) { 27921fc8010aSRajashekhara, Mahesh scsicmd->result = DID_OK << 16 27931fc8010aSRajashekhara, Mahesh | COMMAND_COMPLETE << 8; 27941da177e4SLinus Torvalds break; 27951fc8010aSRajashekhara, Mahesh } else { 27961fc8010aSRajashekhara, Mahesh scsicmd->result = DID_ERROR << 16 27971fc8010aSRajashekhara, Mahesh | COMMAND_COMPLETE << 8; 27981fc8010aSRajashekhara, Mahesh break; 27991fc8010aSRajashekhara, Mahesh } 28001fc8010aSRajashekhara, Mahesh } else { 28011fc8010aSRajashekhara, Mahesh scsicmd->result = DID_ERROR << 16 28021fc8010aSRajashekhara, Mahesh | COMMAND_COMPLETE << 8; 28031fc8010aSRajashekhara, Mahesh break; 28041fc8010aSRajashekhara, Mahesh } 28051da177e4SLinus Torvalds } 28068ce3eca4SSalyzyn, Mark if (le32_to_cpu(srbreply->scsi_status) == SAM_STAT_CHECK_CONDITION) { 28071da177e4SLinus Torvalds int len; 28081da177e4SLinus Torvalds scsicmd->result |= SAM_STAT_CHECK_CONDITION; 28093ace426fSSalyzyn, Mark len = min_t(u32, le32_to_cpu(srbreply->sense_data_size), 28103ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE); 28111da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 28127a8cf29dSMark Haverkamp printk(KERN_WARNING "aac_srb_callback: check condition, status = %d len=%d\n", 28137a8cf29dSMark Haverkamp le32_to_cpu(srbreply->status), len); 28141da177e4SLinus Torvalds #endif 28151da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, srbreply->sense_data, len); 28161da177e4SLinus Torvalds } 28171da177e4SLinus Torvalds /* 28181da177e4SLinus Torvalds * OR in the scsi status (already shifted up a bit) 28191da177e4SLinus Torvalds */ 28201da177e4SLinus Torvalds scsicmd->result |= le32_to_cpu(srbreply->scsi_status); 28211da177e4SLinus Torvalds 2822bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 2823bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 28248e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 28251da177e4SLinus Torvalds } 28261da177e4SLinus Torvalds 28271da177e4SLinus Torvalds /** 28281da177e4SLinus Torvalds * 28291da177e4SLinus Torvalds * aac_send_scb_fib 28301da177e4SLinus Torvalds * @scsicmd: the scsi command block 28311da177e4SLinus Torvalds * 28321da177e4SLinus Torvalds * This routine will form a FIB and fill in the aac_srb from the 28331da177e4SLinus Torvalds * scsicmd passed in. 28341da177e4SLinus Torvalds */ 28351da177e4SLinus Torvalds 28361da177e4SLinus Torvalds static int aac_send_srb_fib(struct scsi_cmnd* scsicmd) 28371da177e4SLinus Torvalds { 28381da177e4SLinus Torvalds struct fib* cmd_fibcontext; 28391da177e4SLinus Torvalds struct aac_dev* dev; 28401da177e4SLinus Torvalds int status; 28411da177e4SLinus Torvalds 284284971738SMark Haverkamp dev = (struct aac_dev *)scsicmd->device->host->hostdata; 2843e5718774SMark Haverkamp if (scmd_id(scsicmd) >= dev->maximum_num_physicals || 284484971738SMark Haverkamp scsicmd->device->lun > 7) { 28451da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16; 28461da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 28471da177e4SLinus Torvalds return 0; 28481da177e4SLinus Torvalds } 28491da177e4SLinus Torvalds 28501da177e4SLinus Torvalds /* 28511da177e4SLinus Torvalds * Allocate and initialize a Fib then setup a BlockWrite command 28521da177e4SLinus Torvalds */ 2853bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) { 28541da177e4SLinus Torvalds return -1; 28551da177e4SLinus Torvalds } 2856e8f32de5SMark Haverkamp status = aac_adapter_scsi(cmd_fibcontext, scsicmd); 28571da177e4SLinus Torvalds 28581da177e4SLinus Torvalds /* 28591da177e4SLinus Torvalds * Check that the command queued to the controller 28601da177e4SLinus Torvalds */ 28611da177e4SLinus Torvalds if (status == -EINPROGRESS) { 286277d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 28631da177e4SLinus Torvalds return 0; 28641da177e4SLinus Torvalds } 28651da177e4SLinus Torvalds 2866bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_srb: aac_fib_send failed with status: %d\n", status); 2867bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 2868bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 28691da177e4SLinus Torvalds 28701da177e4SLinus Torvalds return -1; 28711da177e4SLinus Torvalds } 28721da177e4SLinus Torvalds 28731da177e4SLinus Torvalds static unsigned long aac_build_sg(struct scsi_cmnd* scsicmd, struct sgmap* psg) 28741da177e4SLinus Torvalds { 28751da177e4SLinus Torvalds struct aac_dev *dev; 28761da177e4SLinus Torvalds unsigned long byte_count = 0; 2877727eead6SFUJITA Tomonori int nseg; 28781da177e4SLinus Torvalds 28791da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 28801da177e4SLinus Torvalds // Get rid of old data 28811da177e4SLinus Torvalds psg->count = 0; 28821da177e4SLinus Torvalds psg->sg[0].addr = 0; 28831da177e4SLinus Torvalds psg->sg[0].count = 0; 2884727eead6SFUJITA Tomonori 2885727eead6SFUJITA Tomonori nseg = scsi_dma_map(scsicmd); 2886727eead6SFUJITA Tomonori BUG_ON(nseg < 0); 2887727eead6SFUJITA Tomonori if (nseg) { 28881da177e4SLinus Torvalds struct scatterlist *sg; 28891da177e4SLinus Torvalds int i; 28901da177e4SLinus Torvalds 2891727eead6SFUJITA Tomonori psg->count = cpu_to_le32(nseg); 28921da177e4SLinus Torvalds 2893727eead6SFUJITA Tomonori scsi_for_each_sg(scsicmd, sg, nseg, i) { 28941da177e4SLinus Torvalds psg->sg[i].addr = cpu_to_le32(sg_dma_address(sg)); 28951da177e4SLinus Torvalds psg->sg[i].count = cpu_to_le32(sg_dma_len(sg)); 28961da177e4SLinus Torvalds byte_count += sg_dma_len(sg); 28971da177e4SLinus Torvalds } 28981da177e4SLinus Torvalds /* hba wants the size to be exact */ 2899727eead6SFUJITA Tomonori if (byte_count > scsi_bufflen(scsicmd)) { 290056b58712SMark Haverkamp u32 temp = le32_to_cpu(psg->sg[i-1].count) - 2901727eead6SFUJITA Tomonori (byte_count - scsi_bufflen(scsicmd)); 290256b58712SMark Haverkamp psg->sg[i-1].count = cpu_to_le32(temp); 2903727eead6SFUJITA Tomonori byte_count = scsi_bufflen(scsicmd); 29041da177e4SLinus Torvalds } 29051da177e4SLinus Torvalds /* Check for command underflow */ 29061da177e4SLinus Torvalds if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 29071da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 29081da177e4SLinus Torvalds byte_count, scsicmd->underflow); 29091da177e4SLinus Torvalds } 29101da177e4SLinus Torvalds } 29111da177e4SLinus Torvalds return byte_count; 29121da177e4SLinus Torvalds } 29131da177e4SLinus Torvalds 29141da177e4SLinus Torvalds 29151da177e4SLinus Torvalds static unsigned long aac_build_sg64(struct scsi_cmnd* scsicmd, struct sgmap64* psg) 29161da177e4SLinus Torvalds { 29171da177e4SLinus Torvalds struct aac_dev *dev; 29181da177e4SLinus Torvalds unsigned long byte_count = 0; 291956b58712SMark Haverkamp u64 addr; 2920727eead6SFUJITA Tomonori int nseg; 29211da177e4SLinus Torvalds 29221da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 29231da177e4SLinus Torvalds // Get rid of old data 29241da177e4SLinus Torvalds psg->count = 0; 29251da177e4SLinus Torvalds psg->sg[0].addr[0] = 0; 29261da177e4SLinus Torvalds psg->sg[0].addr[1] = 0; 29271da177e4SLinus Torvalds psg->sg[0].count = 0; 2928727eead6SFUJITA Tomonori 2929727eead6SFUJITA Tomonori nseg = scsi_dma_map(scsicmd); 2930727eead6SFUJITA Tomonori BUG_ON(nseg < 0); 2931727eead6SFUJITA Tomonori if (nseg) { 29321da177e4SLinus Torvalds struct scatterlist *sg; 29331da177e4SLinus Torvalds int i; 29341da177e4SLinus Torvalds 2935727eead6SFUJITA Tomonori scsi_for_each_sg(scsicmd, sg, nseg, i) { 29361241f359SMark Haverkamp int count = sg_dma_len(sg); 293756b58712SMark Haverkamp addr = sg_dma_address(sg); 293856b58712SMark Haverkamp psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff); 293956b58712SMark Haverkamp psg->sg[i].addr[1] = cpu_to_le32(addr>>32); 29401241f359SMark Haverkamp psg->sg[i].count = cpu_to_le32(count); 29411241f359SMark Haverkamp byte_count += count; 29421da177e4SLinus Torvalds } 2943727eead6SFUJITA Tomonori psg->count = cpu_to_le32(nseg); 29441da177e4SLinus Torvalds /* hba wants the size to be exact */ 2945727eead6SFUJITA Tomonori if (byte_count > scsi_bufflen(scsicmd)) { 294656b58712SMark Haverkamp u32 temp = le32_to_cpu(psg->sg[i-1].count) - 2947727eead6SFUJITA Tomonori (byte_count - scsi_bufflen(scsicmd)); 294856b58712SMark Haverkamp psg->sg[i-1].count = cpu_to_le32(temp); 2949727eead6SFUJITA Tomonori byte_count = scsi_bufflen(scsicmd); 29501da177e4SLinus Torvalds } 29511da177e4SLinus Torvalds /* Check for command underflow */ 29521da177e4SLinus Torvalds if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 29531da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 29541da177e4SLinus Torvalds byte_count, scsicmd->underflow); 29551da177e4SLinus Torvalds } 29561da177e4SLinus Torvalds } 29571da177e4SLinus Torvalds return byte_count; 29581da177e4SLinus Torvalds } 29591da177e4SLinus Torvalds 29600e68c003SMark Haverkamp static unsigned long aac_build_sgraw(struct scsi_cmnd* scsicmd, struct sgmapraw* psg) 29610e68c003SMark Haverkamp { 29620e68c003SMark Haverkamp unsigned long byte_count = 0; 2963727eead6SFUJITA Tomonori int nseg; 29640e68c003SMark Haverkamp 29650e68c003SMark Haverkamp // Get rid of old data 29660e68c003SMark Haverkamp psg->count = 0; 29670e68c003SMark Haverkamp psg->sg[0].next = 0; 29680e68c003SMark Haverkamp psg->sg[0].prev = 0; 29690e68c003SMark Haverkamp psg->sg[0].addr[0] = 0; 29700e68c003SMark Haverkamp psg->sg[0].addr[1] = 0; 29710e68c003SMark Haverkamp psg->sg[0].count = 0; 29720e68c003SMark Haverkamp psg->sg[0].flags = 0; 2973727eead6SFUJITA Tomonori 2974727eead6SFUJITA Tomonori nseg = scsi_dma_map(scsicmd); 2975727eead6SFUJITA Tomonori BUG_ON(nseg < 0); 2976727eead6SFUJITA Tomonori if (nseg) { 29770e68c003SMark Haverkamp struct scatterlist *sg; 29780e68c003SMark Haverkamp int i; 29790e68c003SMark Haverkamp 2980727eead6SFUJITA Tomonori scsi_for_each_sg(scsicmd, sg, nseg, i) { 29810e68c003SMark Haverkamp int count = sg_dma_len(sg); 29820e68c003SMark Haverkamp u64 addr = sg_dma_address(sg); 29830e68c003SMark Haverkamp psg->sg[i].next = 0; 29840e68c003SMark Haverkamp psg->sg[i].prev = 0; 29850e68c003SMark Haverkamp psg->sg[i].addr[1] = cpu_to_le32((u32)(addr>>32)); 29860e68c003SMark Haverkamp psg->sg[i].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff)); 29870e68c003SMark Haverkamp psg->sg[i].count = cpu_to_le32(count); 29880e68c003SMark Haverkamp psg->sg[i].flags = 0; 29890e68c003SMark Haverkamp byte_count += count; 29900e68c003SMark Haverkamp } 2991727eead6SFUJITA Tomonori psg->count = cpu_to_le32(nseg); 29920e68c003SMark Haverkamp /* hba wants the size to be exact */ 2993727eead6SFUJITA Tomonori if (byte_count > scsi_bufflen(scsicmd)) { 29940e68c003SMark Haverkamp u32 temp = le32_to_cpu(psg->sg[i-1].count) - 2995727eead6SFUJITA Tomonori (byte_count - scsi_bufflen(scsicmd)); 29960e68c003SMark Haverkamp psg->sg[i-1].count = cpu_to_le32(temp); 2997727eead6SFUJITA Tomonori byte_count = scsi_bufflen(scsicmd); 29980e68c003SMark Haverkamp } 29990e68c003SMark Haverkamp /* Check for command underflow */ 30000e68c003SMark Haverkamp if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 30010e68c003SMark Haverkamp printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 30020e68c003SMark Haverkamp byte_count, scsicmd->underflow); 30030e68c003SMark Haverkamp } 30040e68c003SMark Haverkamp } 30050e68c003SMark Haverkamp return byte_count; 30060e68c003SMark Haverkamp } 30070e68c003SMark Haverkamp 300885d22bbfSMahesh Rajashekhara static unsigned long aac_build_sgraw2(struct scsi_cmnd *scsicmd, struct aac_raw_io2 *rio2, int sg_max) 300985d22bbfSMahesh Rajashekhara { 301085d22bbfSMahesh Rajashekhara unsigned long byte_count = 0; 301185d22bbfSMahesh Rajashekhara int nseg; 301285d22bbfSMahesh Rajashekhara 301385d22bbfSMahesh Rajashekhara nseg = scsi_dma_map(scsicmd); 301485d22bbfSMahesh Rajashekhara BUG_ON(nseg < 0); 301585d22bbfSMahesh Rajashekhara if (nseg) { 301685d22bbfSMahesh Rajashekhara struct scatterlist *sg; 301785d22bbfSMahesh Rajashekhara int i, conformable = 0; 301885d22bbfSMahesh Rajashekhara u32 min_size = PAGE_SIZE, cur_size; 301985d22bbfSMahesh Rajashekhara 302085d22bbfSMahesh Rajashekhara scsi_for_each_sg(scsicmd, sg, nseg, i) { 302185d22bbfSMahesh Rajashekhara int count = sg_dma_len(sg); 302285d22bbfSMahesh Rajashekhara u64 addr = sg_dma_address(sg); 302385d22bbfSMahesh Rajashekhara 302485d22bbfSMahesh Rajashekhara BUG_ON(i >= sg_max); 302585d22bbfSMahesh Rajashekhara rio2->sge[i].addrHigh = cpu_to_le32((u32)(addr>>32)); 302685d22bbfSMahesh Rajashekhara rio2->sge[i].addrLow = cpu_to_le32((u32)(addr & 0xffffffff)); 302785d22bbfSMahesh Rajashekhara cur_size = cpu_to_le32(count); 302885d22bbfSMahesh Rajashekhara rio2->sge[i].length = cur_size; 302985d22bbfSMahesh Rajashekhara rio2->sge[i].flags = 0; 303085d22bbfSMahesh Rajashekhara if (i == 0) { 303185d22bbfSMahesh Rajashekhara conformable = 1; 303285d22bbfSMahesh Rajashekhara rio2->sgeFirstSize = cur_size; 303385d22bbfSMahesh Rajashekhara } else if (i == 1) { 303485d22bbfSMahesh Rajashekhara rio2->sgeNominalSize = cur_size; 303585d22bbfSMahesh Rajashekhara min_size = cur_size; 303685d22bbfSMahesh Rajashekhara } else if ((i+1) < nseg && cur_size != rio2->sgeNominalSize) { 303785d22bbfSMahesh Rajashekhara conformable = 0; 303885d22bbfSMahesh Rajashekhara if (cur_size < min_size) 303985d22bbfSMahesh Rajashekhara min_size = cur_size; 304085d22bbfSMahesh Rajashekhara } 304185d22bbfSMahesh Rajashekhara byte_count += count; 304285d22bbfSMahesh Rajashekhara } 304385d22bbfSMahesh Rajashekhara 304485d22bbfSMahesh Rajashekhara /* hba wants the size to be exact */ 304585d22bbfSMahesh Rajashekhara if (byte_count > scsi_bufflen(scsicmd)) { 304685d22bbfSMahesh Rajashekhara u32 temp = le32_to_cpu(rio2->sge[i-1].length) - 304785d22bbfSMahesh Rajashekhara (byte_count - scsi_bufflen(scsicmd)); 304885d22bbfSMahesh Rajashekhara rio2->sge[i-1].length = cpu_to_le32(temp); 304985d22bbfSMahesh Rajashekhara byte_count = scsi_bufflen(scsicmd); 305085d22bbfSMahesh Rajashekhara } 305185d22bbfSMahesh Rajashekhara 305285d22bbfSMahesh Rajashekhara rio2->sgeCnt = cpu_to_le32(nseg); 305385d22bbfSMahesh Rajashekhara rio2->flags |= cpu_to_le16(RIO2_SG_FORMAT_IEEE1212); 305485d22bbfSMahesh Rajashekhara /* not conformable: evaluate required sg elements */ 305585d22bbfSMahesh Rajashekhara if (!conformable) { 305685d22bbfSMahesh Rajashekhara int j, nseg_new = nseg, err_found; 305785d22bbfSMahesh Rajashekhara for (i = min_size / PAGE_SIZE; i >= 1; --i) { 305885d22bbfSMahesh Rajashekhara err_found = 0; 305985d22bbfSMahesh Rajashekhara nseg_new = 2; 306085d22bbfSMahesh Rajashekhara for (j = 1; j < nseg - 1; ++j) { 306185d22bbfSMahesh Rajashekhara if (rio2->sge[j].length % (i*PAGE_SIZE)) { 306285d22bbfSMahesh Rajashekhara err_found = 1; 306385d22bbfSMahesh Rajashekhara break; 306485d22bbfSMahesh Rajashekhara } 306585d22bbfSMahesh Rajashekhara nseg_new += (rio2->sge[j].length / (i*PAGE_SIZE)); 306685d22bbfSMahesh Rajashekhara } 306785d22bbfSMahesh Rajashekhara if (!err_found) 306885d22bbfSMahesh Rajashekhara break; 306985d22bbfSMahesh Rajashekhara } 307085d22bbfSMahesh Rajashekhara if (i > 0 && nseg_new <= sg_max) 307185d22bbfSMahesh Rajashekhara aac_convert_sgraw2(rio2, i, nseg, nseg_new); 307285d22bbfSMahesh Rajashekhara } else 307385d22bbfSMahesh Rajashekhara rio2->flags |= cpu_to_le16(RIO2_SGL_CONFORMANT); 307485d22bbfSMahesh Rajashekhara 307585d22bbfSMahesh Rajashekhara /* Check for command underflow */ 307685d22bbfSMahesh Rajashekhara if (scsicmd->underflow && (byte_count < scsicmd->underflow)) { 307785d22bbfSMahesh Rajashekhara printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 307885d22bbfSMahesh Rajashekhara byte_count, scsicmd->underflow); 307985d22bbfSMahesh Rajashekhara } 308085d22bbfSMahesh Rajashekhara } 308185d22bbfSMahesh Rajashekhara 308285d22bbfSMahesh Rajashekhara return byte_count; 308385d22bbfSMahesh Rajashekhara } 308485d22bbfSMahesh Rajashekhara 308585d22bbfSMahesh Rajashekhara static int aac_convert_sgraw2(struct aac_raw_io2 *rio2, int pages, int nseg, int nseg_new) 308685d22bbfSMahesh Rajashekhara { 308785d22bbfSMahesh Rajashekhara struct sge_ieee1212 *sge; 308885d22bbfSMahesh Rajashekhara int i, j, pos; 308985d22bbfSMahesh Rajashekhara u32 addr_low; 309085d22bbfSMahesh Rajashekhara 309185d22bbfSMahesh Rajashekhara if (aac_convert_sgl == 0) 309285d22bbfSMahesh Rajashekhara return 0; 309385d22bbfSMahesh Rajashekhara 309485d22bbfSMahesh Rajashekhara sge = kmalloc(nseg_new * sizeof(struct sge_ieee1212), GFP_ATOMIC); 309585d22bbfSMahesh Rajashekhara if (sge == NULL) 309685d22bbfSMahesh Rajashekhara return -1; 309785d22bbfSMahesh Rajashekhara 309885d22bbfSMahesh Rajashekhara for (i = 1, pos = 1; i < nseg-1; ++i) { 309985d22bbfSMahesh Rajashekhara for (j = 0; j < rio2->sge[i].length / (pages * PAGE_SIZE); ++j) { 310085d22bbfSMahesh Rajashekhara addr_low = rio2->sge[i].addrLow + j * pages * PAGE_SIZE; 310185d22bbfSMahesh Rajashekhara sge[pos].addrLow = addr_low; 310285d22bbfSMahesh Rajashekhara sge[pos].addrHigh = rio2->sge[i].addrHigh; 310385d22bbfSMahesh Rajashekhara if (addr_low < rio2->sge[i].addrLow) 310485d22bbfSMahesh Rajashekhara sge[pos].addrHigh++; 310585d22bbfSMahesh Rajashekhara sge[pos].length = pages * PAGE_SIZE; 310685d22bbfSMahesh Rajashekhara sge[pos].flags = 0; 310785d22bbfSMahesh Rajashekhara pos++; 310885d22bbfSMahesh Rajashekhara } 310985d22bbfSMahesh Rajashekhara } 311085d22bbfSMahesh Rajashekhara sge[pos] = rio2->sge[nseg-1]; 311185d22bbfSMahesh Rajashekhara memcpy(&rio2->sge[1], &sge[1], (nseg_new-1)*sizeof(struct sge_ieee1212)); 311285d22bbfSMahesh Rajashekhara 311385d22bbfSMahesh Rajashekhara kfree(sge); 311485d22bbfSMahesh Rajashekhara rio2->sgeCnt = cpu_to_le32(nseg_new); 311585d22bbfSMahesh Rajashekhara rio2->flags |= cpu_to_le16(RIO2_SGL_CONFORMANT); 311685d22bbfSMahesh Rajashekhara rio2->sgeNominalSize = pages * PAGE_SIZE; 311785d22bbfSMahesh Rajashekhara return 0; 311885d22bbfSMahesh Rajashekhara } 311985d22bbfSMahesh Rajashekhara 31201da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 31211da177e4SLinus Torvalds 31221da177e4SLinus Torvalds struct aac_srb_status_info { 31231da177e4SLinus Torvalds u32 status; 31241da177e4SLinus Torvalds char *str; 31251da177e4SLinus Torvalds }; 31261da177e4SLinus Torvalds 31271da177e4SLinus Torvalds 31281da177e4SLinus Torvalds static struct aac_srb_status_info srb_status_info[] = { 31291da177e4SLinus Torvalds { SRB_STATUS_PENDING, "Pending Status"}, 31301da177e4SLinus Torvalds { SRB_STATUS_SUCCESS, "Success"}, 31311da177e4SLinus Torvalds { SRB_STATUS_ABORTED, "Aborted Command"}, 31321da177e4SLinus Torvalds { SRB_STATUS_ABORT_FAILED, "Abort Failed"}, 31331da177e4SLinus Torvalds { SRB_STATUS_ERROR, "Error Event"}, 31341da177e4SLinus Torvalds { SRB_STATUS_BUSY, "Device Busy"}, 31351da177e4SLinus Torvalds { SRB_STATUS_INVALID_REQUEST, "Invalid Request"}, 31361da177e4SLinus Torvalds { SRB_STATUS_INVALID_PATH_ID, "Invalid Path ID"}, 31371da177e4SLinus Torvalds { SRB_STATUS_NO_DEVICE, "No Device"}, 31381da177e4SLinus Torvalds { SRB_STATUS_TIMEOUT, "Timeout"}, 31391da177e4SLinus Torvalds { SRB_STATUS_SELECTION_TIMEOUT, "Selection Timeout"}, 31401da177e4SLinus Torvalds { SRB_STATUS_COMMAND_TIMEOUT, "Command Timeout"}, 31411da177e4SLinus Torvalds { SRB_STATUS_MESSAGE_REJECTED, "Message Rejected"}, 31421da177e4SLinus Torvalds { SRB_STATUS_BUS_RESET, "Bus Reset"}, 31431da177e4SLinus Torvalds { SRB_STATUS_PARITY_ERROR, "Parity Error"}, 31441da177e4SLinus Torvalds { SRB_STATUS_REQUEST_SENSE_FAILED,"Request Sense Failed"}, 31451da177e4SLinus Torvalds { SRB_STATUS_NO_HBA, "No HBA"}, 31461da177e4SLinus Torvalds { SRB_STATUS_DATA_OVERRUN, "Data Overrun/Data Underrun"}, 31471da177e4SLinus Torvalds { SRB_STATUS_UNEXPECTED_BUS_FREE,"Unexpected Bus Free"}, 31481da177e4SLinus Torvalds { SRB_STATUS_PHASE_SEQUENCE_FAILURE,"Phase Error"}, 31491da177e4SLinus Torvalds { SRB_STATUS_BAD_SRB_BLOCK_LENGTH,"Bad Srb Block Length"}, 31501da177e4SLinus Torvalds { SRB_STATUS_REQUEST_FLUSHED, "Request Flushed"}, 31511da177e4SLinus Torvalds { SRB_STATUS_DELAYED_RETRY, "Delayed Retry"}, 31521da177e4SLinus Torvalds { SRB_STATUS_INVALID_LUN, "Invalid LUN"}, 31531da177e4SLinus Torvalds { SRB_STATUS_INVALID_TARGET_ID, "Invalid TARGET ID"}, 31541da177e4SLinus Torvalds { SRB_STATUS_BAD_FUNCTION, "Bad Function"}, 31551da177e4SLinus Torvalds { SRB_STATUS_ERROR_RECOVERY, "Error Recovery"}, 31561da177e4SLinus Torvalds { SRB_STATUS_NOT_STARTED, "Not Started"}, 31571da177e4SLinus Torvalds { SRB_STATUS_NOT_IN_USE, "Not In Use"}, 31581da177e4SLinus Torvalds { SRB_STATUS_FORCE_ABORT, "Force Abort"}, 31591da177e4SLinus Torvalds { SRB_STATUS_DOMAIN_VALIDATION_FAIL,"Domain Validation Failure"}, 31601da177e4SLinus Torvalds { 0xff, "Unknown Error"} 31611da177e4SLinus Torvalds }; 31621da177e4SLinus Torvalds 31631da177e4SLinus Torvalds char *aac_get_status_string(u32 status) 31641da177e4SLinus Torvalds { 31651da177e4SLinus Torvalds int i; 31661da177e4SLinus Torvalds 31676391a113STobias Klauser for (i = 0; i < ARRAY_SIZE(srb_status_info); i++) 31686391a113STobias Klauser if (srb_status_info[i].status == status) 31691da177e4SLinus Torvalds return srb_status_info[i].str; 31701da177e4SLinus Torvalds 31711da177e4SLinus Torvalds return "Bad Status Code"; 31721da177e4SLinus Torvalds } 31731da177e4SLinus Torvalds 31741da177e4SLinus Torvalds #endif 3175