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 1350b433447SMahesh Rajashekhara static long aac_build_sg(struct scsi_cmnd *scsicmd, struct sgmap *sgmap); 1360b433447SMahesh Rajashekhara static long aac_build_sg64(struct scsi_cmnd *scsicmd, struct sgmap64 *psg); 1370b433447SMahesh Rajashekhara static long aac_build_sgraw(struct scsi_cmnd *scsicmd, struct sgmapraw *psg); 1380b433447SMahesh Rajashekhara static long aac_build_sgraw2(struct scsi_cmnd *scsicmd, 1390b433447SMahesh Rajashekhara struct aac_raw_io2 *rio2, int sg_max); 1400b433447SMahesh Rajashekhara static int aac_convert_sgraw2(struct aac_raw_io2 *rio2, 1410b433447SMahesh Rajashekhara int pages, int nseg, int nseg_new); 1421da177e4SLinus Torvalds static int aac_send_srb_fib(struct scsi_cmnd* scsicmd); 1431da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 1441da177e4SLinus Torvalds static char *aac_get_status_string(u32 status); 1451da177e4SLinus Torvalds #endif 1461da177e4SLinus Torvalds 1471da177e4SLinus Torvalds /* 1481da177e4SLinus Torvalds * Non dasd selection is handled entirely in aachba now 1491da177e4SLinus Torvalds */ 1501da177e4SLinus Torvalds 1511da177e4SLinus Torvalds static int nondasd = -1; 152d8e96507SLeubner, Achim static int aac_cache = 2; /* WCE=0 to avoid performance problems */ 1531da177e4SLinus Torvalds static int dacmode = -1; 1548ef22247SSalyzyn, Mark int aac_msi; 1551208bab5SSalyzyn, Mark int aac_commit = -1; 156404d9a90SMark Haverkamp int startup_timeout = 180; 157404d9a90SMark Haverkamp int aif_timeout = 120; 15811604612SMahesh Rajashekhara int aac_sync_mode; /* Only Sync. transfer - disabled */ 15985d22bbfSMahesh Rajashekhara int aac_convert_sgl = 1; /* convert non-conformable s/g list - enabled */ 1601da177e4SLinus Torvalds 16111604612SMahesh Rajashekhara module_param(aac_sync_mode, int, S_IRUGO|S_IWUSR); 16211604612SMahesh Rajashekhara MODULE_PARM_DESC(aac_sync_mode, "Force sync. transfer mode" 16311604612SMahesh Rajashekhara " 0=off, 1=on"); 16485d22bbfSMahesh Rajashekhara module_param(aac_convert_sgl, int, S_IRUGO|S_IWUSR); 16585d22bbfSMahesh Rajashekhara MODULE_PARM_DESC(aac_convert_sgl, "Convert non-conformable s/g list" 16685d22bbfSMahesh Rajashekhara " 0=off, 1=on"); 1679a72f976SMark Haverkamp module_param(nondasd, int, S_IRUGO|S_IWUSR); 1688ef22247SSalyzyn, Mark MODULE_PARM_DESC(nondasd, "Control scanning of hba for nondasd devices." 1698ef22247SSalyzyn, Mark " 0=off, 1=on"); 17095e852e1SSalyzyn, Mark module_param_named(cache, aac_cache, int, S_IRUGO|S_IWUSR); 1718ef22247SSalyzyn, Mark MODULE_PARM_DESC(cache, "Disable Queue Flush commands:\n" 1728ef22247SSalyzyn, Mark "\tbit 0 - Disable FUA in WRITE SCSI commands\n" 1738ef22247SSalyzyn, Mark "\tbit 1 - Disable SYNCHRONIZE_CACHE SCSI command\n" 174d8e96507SLeubner, Achim "\tbit 2 - Disable only if Battery is protecting Cache"); 1759a72f976SMark Haverkamp module_param(dacmode, int, S_IRUGO|S_IWUSR); 1768ef22247SSalyzyn, Mark MODULE_PARM_DESC(dacmode, "Control whether dma addressing is using 64 bit DAC." 1778ef22247SSalyzyn, Mark " 0=off, 1=on"); 1781208bab5SSalyzyn, Mark module_param_named(commit, aac_commit, int, S_IRUGO|S_IWUSR); 1798ef22247SSalyzyn, Mark MODULE_PARM_DESC(commit, "Control whether a COMMIT_CONFIG is issued to the" 1808ef22247SSalyzyn, Mark " adapter for foreign arrays.\n" 1818ef22247SSalyzyn, Mark "This is typically needed in systems that do not have a BIOS." 1828ef22247SSalyzyn, Mark " 0=off, 1=on"); 1838ef22247SSalyzyn, Mark module_param_named(msi, aac_msi, int, S_IRUGO|S_IWUSR); 1848ef22247SSalyzyn, Mark MODULE_PARM_DESC(msi, "IRQ handling." 1858ef22247SSalyzyn, Mark " 0=PIC(default), 1=MSI, 2=MSI-X(unsupported, uses MSI)"); 186404d9a90SMark Haverkamp module_param(startup_timeout, int, S_IRUGO|S_IWUSR); 1878ef22247SSalyzyn, Mark MODULE_PARM_DESC(startup_timeout, "The duration of time in seconds to wait for" 1888ef22247SSalyzyn, Mark " adapter to have it's kernel up and\n" 1898ef22247SSalyzyn, Mark "running. This is typically adjusted for large systems that do not" 1908ef22247SSalyzyn, Mark " have a BIOS."); 191404d9a90SMark Haverkamp module_param(aif_timeout, int, S_IRUGO|S_IWUSR); 1928ef22247SSalyzyn, Mark MODULE_PARM_DESC(aif_timeout, "The duration of time in seconds to wait for" 1938ef22247SSalyzyn, Mark " applications to pick up AIFs before\n" 1948ef22247SSalyzyn, Mark "deregistering them. This is typically adjusted for heavily burdened" 1958ef22247SSalyzyn, Mark " systems."); 1961da177e4SLinus Torvalds 1977c00ffa3SMark Haverkamp int numacb = -1; 1987c00ffa3SMark Haverkamp module_param(numacb, int, S_IRUGO|S_IWUSR); 1998ef22247SSalyzyn, Mark MODULE_PARM_DESC(numacb, "Request a limit to the number of adapter control" 2008ef22247SSalyzyn, Mark " blocks (FIB) allocated. Valid values are 512 and down. Default is" 2018ef22247SSalyzyn, Mark " to use suggestion from Firmware."); 2027c00ffa3SMark Haverkamp 2037c00ffa3SMark Haverkamp int acbsize = -1; 2047c00ffa3SMark Haverkamp module_param(acbsize, int, S_IRUGO|S_IWUSR); 2058ef22247SSalyzyn, Mark MODULE_PARM_DESC(acbsize, "Request a specific adapter control block (FIB)" 2068ef22247SSalyzyn, Mark " size. Valid values are 512, 2048, 4096 and 8192. Default is to use" 2078ef22247SSalyzyn, Mark " suggestion from Firmware."); 208653ba58dSMark Haverkamp 20929c97684SSalyzyn, Mark int update_interval = 30 * 60; 21029c97684SSalyzyn, Mark module_param(update_interval, int, S_IRUGO|S_IWUSR); 2118ef22247SSalyzyn, Mark MODULE_PARM_DESC(update_interval, "Interval in seconds between time sync" 2128ef22247SSalyzyn, Mark " updates issued to adapter."); 21329c97684SSalyzyn, Mark 21429c97684SSalyzyn, Mark int check_interval = 24 * 60 * 60; 21529c97684SSalyzyn, Mark module_param(check_interval, int, S_IRUGO|S_IWUSR); 2168ef22247SSalyzyn, Mark MODULE_PARM_DESC(check_interval, "Interval in seconds between adapter health" 2178ef22247SSalyzyn, Mark " checks."); 21829c97684SSalyzyn, Mark 21987f3bda3SAndrew Morton int aac_check_reset = 1; 22087f3bda3SAndrew Morton module_param_named(check_reset, aac_check_reset, int, S_IRUGO|S_IWUSR); 22195e7a8efSPaul Bolle MODULE_PARM_DESC(check_reset, "If adapter fails health check, reset the" 2228ef22247SSalyzyn, Mark " adapter. a value of -1 forces the reset to adapters programmed to" 2238ef22247SSalyzyn, Mark " ignore it."); 22429c97684SSalyzyn, Mark 225e37ee4beSMark Haverkamp int expose_physicals = -1; 226653ba58dSMark Haverkamp module_param(expose_physicals, int, S_IRUGO|S_IWUSR); 2278ef22247SSalyzyn, Mark MODULE_PARM_DESC(expose_physicals, "Expose physical components of the arrays." 2288ef22247SSalyzyn, Mark " -1=protect 0=off, 1=on"); 22903d44337SMark Haverkamp 2308ef22247SSalyzyn, Mark int aac_reset_devices; 2311208bab5SSalyzyn, Mark module_param_named(reset_devices, aac_reset_devices, int, S_IRUGO|S_IWUSR); 2321208bab5SSalyzyn, Mark MODULE_PARM_DESC(reset_devices, "Force an adapter reset at initialization."); 23303d44337SMark Haverkamp 234d8e96507SLeubner, Achim int aac_wwn = 1; 235d8e96507SLeubner, Achim module_param_named(wwn, aac_wwn, int, S_IRUGO|S_IWUSR); 236d8e96507SLeubner, Achim MODULE_PARM_DESC(wwn, "Select a WWN type for the arrays:\n" 237d8e96507SLeubner, Achim "\t0 - Disable\n" 238d8e96507SLeubner, Achim "\t1 - Array Meta Data Signature (default)\n" 239d8e96507SLeubner, Achim "\t2 - Adapter Serial Number"); 240d8e96507SLeubner, Achim 241d8e96507SLeubner, Achim 24203d44337SMark Haverkamp static inline int aac_valid_context(struct scsi_cmnd *scsicmd, 24303d44337SMark Haverkamp struct fib *fibptr) { 24403d44337SMark Haverkamp struct scsi_device *device; 24503d44337SMark Haverkamp 24603d44337SMark Haverkamp if (unlikely(!scsicmd || !scsicmd->scsi_done)) { 247c835e372SSalyzyn, Mark dprintk((KERN_WARNING "aac_valid_context: scsi command corrupt\n")); 24803d44337SMark Haverkamp aac_fib_complete(fibptr); 24903d44337SMark Haverkamp aac_fib_free(fibptr); 25003d44337SMark Haverkamp return 0; 25103d44337SMark Haverkamp } 25203d44337SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL; 25303d44337SMark Haverkamp device = scsicmd->device; 25403d44337SMark Haverkamp if (unlikely(!device || !scsi_device_online(device))) { 25503d44337SMark Haverkamp dprintk((KERN_WARNING "aac_valid_context: scsi device corrupt\n")); 25603d44337SMark Haverkamp aac_fib_complete(fibptr); 25703d44337SMark Haverkamp aac_fib_free(fibptr); 25803d44337SMark Haverkamp return 0; 25903d44337SMark Haverkamp } 26003d44337SMark Haverkamp return 1; 26103d44337SMark Haverkamp } 26203d44337SMark Haverkamp 2631da177e4SLinus Torvalds /** 2641da177e4SLinus Torvalds * aac_get_config_status - check the adapter configuration 2651da177e4SLinus Torvalds * @common: adapter to query 2661da177e4SLinus Torvalds * 2671da177e4SLinus Torvalds * Query config status, and commit the configuration if needed. 2681da177e4SLinus Torvalds */ 2698c867b25SMark Haverkamp int aac_get_config_status(struct aac_dev *dev, int commit_flag) 2701da177e4SLinus Torvalds { 2711da177e4SLinus Torvalds int status = 0; 2721da177e4SLinus Torvalds struct fib * fibptr; 2731da177e4SLinus Torvalds 274bfb35aa8SMark Haverkamp if (!(fibptr = aac_fib_alloc(dev))) 2751da177e4SLinus Torvalds return -ENOMEM; 2761da177e4SLinus Torvalds 277bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 2781da177e4SLinus Torvalds { 2791da177e4SLinus Torvalds struct aac_get_config_status *dinfo; 2801da177e4SLinus Torvalds dinfo = (struct aac_get_config_status *) fib_data(fibptr); 2811da177e4SLinus Torvalds 2821da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 2831da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_GET_CONFIG_STATUS); 2841da177e4SLinus Torvalds dinfo->count = cpu_to_le32(sizeof(((struct aac_get_config_status_resp *)NULL)->data)); 2851da177e4SLinus Torvalds } 2861da177e4SLinus Torvalds 287bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 2881da177e4SLinus Torvalds fibptr, 2891da177e4SLinus Torvalds sizeof (struct aac_get_config_status), 2901da177e4SLinus Torvalds FsaNormal, 2911da177e4SLinus Torvalds 1, 1, 2921da177e4SLinus Torvalds NULL, NULL); 2931da177e4SLinus Torvalds if (status < 0) { 2941da177e4SLinus Torvalds printk(KERN_WARNING "aac_get_config_status: SendFIB failed.\n"); 2951da177e4SLinus Torvalds } else { 2961da177e4SLinus Torvalds struct aac_get_config_status_resp *reply 2971da177e4SLinus Torvalds = (struct aac_get_config_status_resp *) fib_data(fibptr); 2981da177e4SLinus Torvalds dprintk((KERN_WARNING 2991da177e4SLinus Torvalds "aac_get_config_status: response=%d status=%d action=%d\n", 3001da177e4SLinus Torvalds le32_to_cpu(reply->response), 3011da177e4SLinus Torvalds le32_to_cpu(reply->status), 3021da177e4SLinus Torvalds le32_to_cpu(reply->data.action))); 3031da177e4SLinus Torvalds if ((le32_to_cpu(reply->response) != ST_OK) || 3041da177e4SLinus Torvalds (le32_to_cpu(reply->status) != CT_OK) || 3051da177e4SLinus Torvalds (le32_to_cpu(reply->data.action) > CFACT_PAUSE)) { 3061da177e4SLinus Torvalds printk(KERN_WARNING "aac_get_config_status: Will not issue the Commit Configuration\n"); 3071da177e4SLinus Torvalds status = -EINVAL; 3081da177e4SLinus Torvalds } 3091da177e4SLinus Torvalds } 310cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* Do not set XferState to zero unless receives a response from F/W */ 311cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (status >= 0) 312bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 313cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech 3141da177e4SLinus Torvalds /* Send a CT_COMMIT_CONFIG to enable discovery of devices */ 3151da177e4SLinus Torvalds if (status >= 0) { 3161208bab5SSalyzyn, Mark if ((aac_commit == 1) || commit_flag) { 3171da177e4SLinus Torvalds struct aac_commit_config * dinfo; 318bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 3191da177e4SLinus Torvalds dinfo = (struct aac_commit_config *) fib_data(fibptr); 3201da177e4SLinus Torvalds 3211da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 3221da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_COMMIT_CONFIG); 3231da177e4SLinus Torvalds 324bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 3251da177e4SLinus Torvalds fibptr, 3261da177e4SLinus Torvalds sizeof (struct aac_commit_config), 3271da177e4SLinus Torvalds FsaNormal, 3281da177e4SLinus Torvalds 1, 1, 3291da177e4SLinus Torvalds NULL, NULL); 330cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* Do not set XferState to zero unless 331cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech * receives a response from F/W */ 332cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (status >= 0) 333bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 3341208bab5SSalyzyn, Mark } else if (aac_commit == 0) { 3351da177e4SLinus Torvalds printk(KERN_WARNING 3361da177e4SLinus Torvalds "aac_get_config_status: Foreign device configurations are being ignored\n"); 3371da177e4SLinus Torvalds } 3381da177e4SLinus Torvalds } 339cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* FIB should be freed only after getting the response from the F/W */ 340cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (status != -ERESTARTSYS) 341bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 3421da177e4SLinus Torvalds return status; 3431da177e4SLinus Torvalds } 3441da177e4SLinus Torvalds 345e3cc268fSRajashekhara, Mahesh static void aac_expose_phy_device(struct scsi_cmnd *scsicmd) 346e3cc268fSRajashekhara, Mahesh { 347e3cc268fSRajashekhara, Mahesh char inq_data; 348e3cc268fSRajashekhara, Mahesh scsi_sg_copy_to_buffer(scsicmd, &inq_data, sizeof(inq_data)); 349e3cc268fSRajashekhara, Mahesh if ((inq_data & 0x20) && (inq_data & 0x1f) == TYPE_DISK) { 350e3cc268fSRajashekhara, Mahesh inq_data &= 0xdf; 351e3cc268fSRajashekhara, Mahesh scsi_sg_copy_from_buffer(scsicmd, &inq_data, sizeof(inq_data)); 352e3cc268fSRajashekhara, Mahesh } 353e3cc268fSRajashekhara, Mahesh } 354e3cc268fSRajashekhara, Mahesh 3551da177e4SLinus Torvalds /** 3561da177e4SLinus Torvalds * aac_get_containers - list containers 3571da177e4SLinus Torvalds * @common: adapter to probe 3581da177e4SLinus Torvalds * 3591da177e4SLinus Torvalds * Make a list of all containers on this controller 3601da177e4SLinus Torvalds */ 3611da177e4SLinus Torvalds int aac_get_containers(struct aac_dev *dev) 3621da177e4SLinus Torvalds { 3631da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 3641da177e4SLinus Torvalds u32 index; 3651da177e4SLinus Torvalds int status = 0; 3661da177e4SLinus Torvalds struct fib * fibptr; 3671da177e4SLinus Torvalds struct aac_get_container_count *dinfo; 3681da177e4SLinus Torvalds struct aac_get_container_count_resp *dresp; 3691da177e4SLinus Torvalds int maximum_num_containers = MAXIMUM_NUM_CONTAINERS; 3701da177e4SLinus Torvalds 371bfb35aa8SMark Haverkamp if (!(fibptr = aac_fib_alloc(dev))) 3721da177e4SLinus Torvalds return -ENOMEM; 3731da177e4SLinus Torvalds 374bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 3751da177e4SLinus Torvalds dinfo = (struct aac_get_container_count *) fib_data(fibptr); 3761da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 3771da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_GET_CONTAINER_COUNT); 3781da177e4SLinus Torvalds 379bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 3801da177e4SLinus Torvalds fibptr, 3811da177e4SLinus Torvalds sizeof (struct aac_get_container_count), 3821da177e4SLinus Torvalds FsaNormal, 3831da177e4SLinus Torvalds 1, 1, 3841da177e4SLinus Torvalds NULL, NULL); 3851da177e4SLinus Torvalds if (status >= 0) { 3861da177e4SLinus Torvalds dresp = (struct aac_get_container_count_resp *)fib_data(fibptr); 3871da177e4SLinus Torvalds maximum_num_containers = le32_to_cpu(dresp->ContainerSwitchEntries); 388bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 3891da177e4SLinus Torvalds } 390cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* FIB should be freed only after getting the response from the F/W */ 391cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (status != -ERESTARTSYS) 392fe76df42SMark Haverkamp aac_fib_free(fibptr); 3931da177e4SLinus Torvalds 3941da177e4SLinus Torvalds if (maximum_num_containers < MAXIMUM_NUM_CONTAINERS) 3951da177e4SLinus Torvalds maximum_num_containers = MAXIMUM_NUM_CONTAINERS; 3961a655040SSalyzyn, Mark fsa_dev_ptr = kzalloc(sizeof(*fsa_dev_ptr) * maximum_num_containers, 397fe76df42SMark Haverkamp GFP_KERNEL); 398fe76df42SMark Haverkamp if (!fsa_dev_ptr) 3991da177e4SLinus Torvalds return -ENOMEM; 4001da177e4SLinus Torvalds 4011da177e4SLinus Torvalds dev->fsa_dev = fsa_dev_ptr; 4021da177e4SLinus Torvalds dev->maximum_num_containers = maximum_num_containers; 4031da177e4SLinus Torvalds 404fe76df42SMark Haverkamp for (index = 0; index < dev->maximum_num_containers; ) { 4051da177e4SLinus Torvalds fsa_dev_ptr[index].devname[0] = '\0'; 4061da177e4SLinus Torvalds 407fe76df42SMark Haverkamp status = aac_probe_container(dev, index); 4081da177e4SLinus Torvalds 4091da177e4SLinus Torvalds if (status < 0) { 4101da177e4SLinus Torvalds printk(KERN_WARNING "aac_get_containers: SendFIB failed.\n"); 4111da177e4SLinus Torvalds break; 4121da177e4SLinus Torvalds } 4131da177e4SLinus Torvalds 4141da177e4SLinus Torvalds /* 4151da177e4SLinus Torvalds * If there are no more containers, then stop asking. 4161da177e4SLinus Torvalds */ 417fe76df42SMark Haverkamp if (++index >= status) 4181da177e4SLinus Torvalds break; 4191da177e4SLinus Torvalds } 4201da177e4SLinus Torvalds return status; 4211da177e4SLinus Torvalds } 4221da177e4SLinus Torvalds 4231da177e4SLinus Torvalds static void get_container_name_callback(void *context, struct fib * fibptr) 4241da177e4SLinus Torvalds { 4251da177e4SLinus Torvalds struct aac_get_name_resp * get_name_reply; 4261da177e4SLinus Torvalds struct scsi_cmnd * scsicmd; 4271da177e4SLinus Torvalds 4281da177e4SLinus Torvalds scsicmd = (struct scsi_cmnd *) context; 4291da177e4SLinus Torvalds 43003d44337SMark Haverkamp if (!aac_valid_context(scsicmd, fibptr)) 43103d44337SMark Haverkamp return; 43203d44337SMark Haverkamp 4331da177e4SLinus Torvalds dprintk((KERN_DEBUG "get_container_name_callback[cpu %d]: t = %ld.\n", smp_processor_id(), jiffies)); 434125e1874SEric Sesterhenn BUG_ON(fibptr == NULL); 4351da177e4SLinus Torvalds 4361da177e4SLinus Torvalds get_name_reply = (struct aac_get_name_resp *) fib_data(fibptr); 4371da177e4SLinus Torvalds /* Failure is irrelevant, using default value instead */ 4381da177e4SLinus Torvalds if ((le32_to_cpu(get_name_reply->status) == CT_OK) 4391da177e4SLinus Torvalds && (get_name_reply->data[0] != '\0')) { 4401da177e4SLinus Torvalds char *sp = get_name_reply->data; 4411da177e4SLinus Torvalds sp[sizeof(((struct aac_get_name_resp *)NULL)->data)-1] = '\0'; 4421da177e4SLinus Torvalds while (*sp == ' ') 4431da177e4SLinus Torvalds ++sp; 4443b2946ccSMark Haverkamp if (*sp) { 445d4345028SFUJITA Tomonori struct inquiry_data inq; 4463b2946ccSMark Haverkamp char d[sizeof(((struct inquiry_data *)NULL)->inqd_pid)]; 4473b2946ccSMark Haverkamp int count = sizeof(d); 4483b2946ccSMark Haverkamp char *dp = d; 4493b2946ccSMark Haverkamp do { 4501da177e4SLinus Torvalds *dp++ = (*sp) ? *sp++ : ' '; 4511da177e4SLinus Torvalds } while (--count > 0); 452d4345028SFUJITA Tomonori 453d4345028SFUJITA Tomonori scsi_sg_copy_to_buffer(scsicmd, &inq, sizeof(inq)); 454d4345028SFUJITA Tomonori memcpy(inq.inqd_pid, d, sizeof(d)); 455d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, &inq, sizeof(inq)); 4561da177e4SLinus Torvalds } 4573b2946ccSMark Haverkamp } 4583b2946ccSMark Haverkamp 4591da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 4601da177e4SLinus Torvalds 461bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 462bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 4638e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 4641da177e4SLinus Torvalds } 4651da177e4SLinus Torvalds 4661da177e4SLinus Torvalds /** 4671da177e4SLinus Torvalds * aac_get_container_name - get container name, none blocking. 4681da177e4SLinus Torvalds */ 4699e7c349cSMark Haverkamp static int aac_get_container_name(struct scsi_cmnd * scsicmd) 4701da177e4SLinus Torvalds { 4711da177e4SLinus Torvalds int status; 4721da177e4SLinus Torvalds struct aac_get_name *dinfo; 4731da177e4SLinus Torvalds struct fib * cmd_fibcontext; 4741da177e4SLinus Torvalds struct aac_dev * dev; 4751da177e4SLinus Torvalds 4761da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 4771da177e4SLinus Torvalds 478bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) 4791da177e4SLinus Torvalds return -ENOMEM; 4801da177e4SLinus Torvalds 481bfb35aa8SMark Haverkamp aac_fib_init(cmd_fibcontext); 4821da177e4SLinus Torvalds dinfo = (struct aac_get_name *) fib_data(cmd_fibcontext); 4831da177e4SLinus Torvalds 4841da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 4851da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_READ_NAME); 4869e7c349cSMark Haverkamp dinfo->cid = cpu_to_le32(scmd_id(scsicmd)); 4871da177e4SLinus Torvalds dinfo->count = cpu_to_le32(sizeof(((struct aac_get_name_resp *)NULL)->data)); 4881da177e4SLinus Torvalds 489bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 4901da177e4SLinus Torvalds cmd_fibcontext, 4911da177e4SLinus Torvalds sizeof (struct aac_get_name), 4921da177e4SLinus Torvalds FsaNormal, 4931da177e4SLinus Torvalds 0, 1, 4941da177e4SLinus Torvalds (fib_callback)get_container_name_callback, 4951da177e4SLinus Torvalds (void *) scsicmd); 4961da177e4SLinus Torvalds 4971da177e4SLinus Torvalds /* 4981da177e4SLinus Torvalds * Check that the command queued to the controller 4991da177e4SLinus Torvalds */ 50077d644d4SMark Haverkamp if (status == -EINPROGRESS) { 50177d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 5021da177e4SLinus Torvalds return 0; 50377d644d4SMark Haverkamp } 5041da177e4SLinus Torvalds 505bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_get_container_name: aac_fib_send failed with status: %d.\n", status); 506bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 507bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 5081da177e4SLinus Torvalds return -1; 5091da177e4SLinus Torvalds } 5101da177e4SLinus Torvalds 511fe76df42SMark Haverkamp static int aac_probe_container_callback2(struct scsi_cmnd * scsicmd) 512fe76df42SMark Haverkamp { 513fe76df42SMark Haverkamp struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev; 514fe76df42SMark Haverkamp 5151a655040SSalyzyn, Mark if ((fsa_dev_ptr[scmd_id(scsicmd)].valid & 1)) 516fe76df42SMark Haverkamp return aac_scsi_cmd(scsicmd); 517fe76df42SMark Haverkamp 518fe76df42SMark Haverkamp scsicmd->result = DID_NO_CONNECT << 16; 519fe76df42SMark Haverkamp scsicmd->scsi_done(scsicmd); 520fe76df42SMark Haverkamp return 0; 521fe76df42SMark Haverkamp } 522fe76df42SMark Haverkamp 5231a655040SSalyzyn, Mark static void _aac_probe_container2(void * context, struct fib * fibptr) 524fe76df42SMark Haverkamp { 52503d44337SMark Haverkamp struct fsa_dev_info *fsa_dev_ptr; 526fe76df42SMark Haverkamp int (*callback)(struct scsi_cmnd *); 52703d44337SMark Haverkamp struct scsi_cmnd * scsicmd = (struct scsi_cmnd *)context; 52803d44337SMark Haverkamp 52903d44337SMark Haverkamp 5301a655040SSalyzyn, Mark if (!aac_valid_context(scsicmd, fibptr)) 5311a655040SSalyzyn, Mark return; 532fe76df42SMark Haverkamp 533fe76df42SMark Haverkamp scsicmd->SCp.Status = 0; 5341a655040SSalyzyn, Mark fsa_dev_ptr = fibptr->dev->fsa_dev; 535fe76df42SMark Haverkamp if (fsa_dev_ptr) { 536fe76df42SMark Haverkamp struct aac_mount * dresp = (struct aac_mount *) fib_data(fibptr); 537fe76df42SMark Haverkamp fsa_dev_ptr += scmd_id(scsicmd); 538fe76df42SMark Haverkamp 539fe76df42SMark Haverkamp if ((le32_to_cpu(dresp->status) == ST_OK) && 540fe76df42SMark Haverkamp (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE) && 541fe76df42SMark Haverkamp (le32_to_cpu(dresp->mnt[0].state) != FSCS_HIDDEN)) { 542fe76df42SMark Haverkamp fsa_dev_ptr->valid = 1; 543655d722cSMark Salyzyn /* sense_key holds the current state of the spin-up */ 544655d722cSMark Salyzyn if (dresp->mnt[0].state & cpu_to_le32(FSCS_NOT_READY)) 545655d722cSMark Salyzyn fsa_dev_ptr->sense_data.sense_key = NOT_READY; 546655d722cSMark Salyzyn else if (fsa_dev_ptr->sense_data.sense_key == NOT_READY) 547655d722cSMark Salyzyn fsa_dev_ptr->sense_data.sense_key = NO_SENSE; 548fe76df42SMark Haverkamp fsa_dev_ptr->type = le32_to_cpu(dresp->mnt[0].vol); 549fe76df42SMark Haverkamp fsa_dev_ptr->size 550fe76df42SMark Haverkamp = ((u64)le32_to_cpu(dresp->mnt[0].capacity)) + 551fe76df42SMark Haverkamp (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32); 552fe76df42SMark Haverkamp fsa_dev_ptr->ro = ((le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY) != 0); 553fe76df42SMark Haverkamp } 554fe76df42SMark Haverkamp if ((fsa_dev_ptr->valid & 1) == 0) 555fe76df42SMark Haverkamp fsa_dev_ptr->valid = 0; 556fe76df42SMark Haverkamp scsicmd->SCp.Status = le32_to_cpu(dresp->count); 557fe76df42SMark Haverkamp } 558fe76df42SMark Haverkamp aac_fib_complete(fibptr); 559fe76df42SMark Haverkamp aac_fib_free(fibptr); 560fe76df42SMark Haverkamp callback = (int (*)(struct scsi_cmnd *))(scsicmd->SCp.ptr); 561fe76df42SMark Haverkamp scsicmd->SCp.ptr = NULL; 5621a655040SSalyzyn, Mark (*callback)(scsicmd); 5631a655040SSalyzyn, Mark return; 564fe76df42SMark Haverkamp } 565fe76df42SMark Haverkamp 5661a655040SSalyzyn, Mark static void _aac_probe_container1(void * context, struct fib * fibptr) 567fe76df42SMark Haverkamp { 568fe76df42SMark Haverkamp struct scsi_cmnd * scsicmd; 569fe76df42SMark Haverkamp struct aac_mount * dresp; 570fe76df42SMark Haverkamp struct aac_query_mount *dinfo; 571fe76df42SMark Haverkamp int status; 572fe76df42SMark Haverkamp 573fe76df42SMark Haverkamp dresp = (struct aac_mount *) fib_data(fibptr); 574fe76df42SMark Haverkamp dresp->mnt[0].capacityhigh = 0; 575fe76df42SMark Haverkamp if ((le32_to_cpu(dresp->status) != ST_OK) || 5761a655040SSalyzyn, Mark (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE)) { 5771a655040SSalyzyn, Mark _aac_probe_container2(context, fibptr); 5781a655040SSalyzyn, Mark return; 5791a655040SSalyzyn, Mark } 580fe76df42SMark Haverkamp scsicmd = (struct scsi_cmnd *) context; 581fe76df42SMark Haverkamp 58203d44337SMark Haverkamp if (!aac_valid_context(scsicmd, fibptr)) 5831a655040SSalyzyn, Mark return; 58403d44337SMark Haverkamp 585fe76df42SMark Haverkamp aac_fib_init(fibptr); 586fe76df42SMark Haverkamp 587fe76df42SMark Haverkamp dinfo = (struct aac_query_mount *)fib_data(fibptr); 588fe76df42SMark Haverkamp 589fe76df42SMark Haverkamp dinfo->command = cpu_to_le32(VM_NameServe64); 590fe76df42SMark Haverkamp dinfo->count = cpu_to_le32(scmd_id(scsicmd)); 591fe76df42SMark Haverkamp dinfo->type = cpu_to_le32(FT_FILESYS); 592fe76df42SMark Haverkamp 593fe76df42SMark Haverkamp status = aac_fib_send(ContainerCommand, 594fe76df42SMark Haverkamp fibptr, 595fe76df42SMark Haverkamp sizeof(struct aac_query_mount), 596fe76df42SMark Haverkamp FsaNormal, 597fe76df42SMark Haverkamp 0, 1, 5981a655040SSalyzyn, Mark _aac_probe_container2, 599fe76df42SMark Haverkamp (void *) scsicmd); 600fe76df42SMark Haverkamp /* 601fe76df42SMark Haverkamp * Check that the command queued to the controller 602fe76df42SMark Haverkamp */ 6031a655040SSalyzyn, Mark if (status == -EINPROGRESS) 604fe76df42SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 6051a655040SSalyzyn, Mark else if (status < 0) { 606fe76df42SMark Haverkamp /* Inherit results from VM_NameServe, if any */ 607fe76df42SMark Haverkamp dresp->status = cpu_to_le32(ST_OK); 6081a655040SSalyzyn, Mark _aac_probe_container2(context, fibptr); 609fe76df42SMark Haverkamp } 610fe76df42SMark Haverkamp } 611fe76df42SMark Haverkamp 612fe76df42SMark Haverkamp static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(struct scsi_cmnd *)) 613fe76df42SMark Haverkamp { 614fe76df42SMark Haverkamp struct fib * fibptr; 615fe76df42SMark Haverkamp int status = -ENOMEM; 616fe76df42SMark Haverkamp 617fe76df42SMark Haverkamp if ((fibptr = aac_fib_alloc((struct aac_dev *)scsicmd->device->host->hostdata))) { 618fe76df42SMark Haverkamp struct aac_query_mount *dinfo; 619fe76df42SMark Haverkamp 620fe76df42SMark Haverkamp aac_fib_init(fibptr); 621fe76df42SMark Haverkamp 622fe76df42SMark Haverkamp dinfo = (struct aac_query_mount *)fib_data(fibptr); 623fe76df42SMark Haverkamp 624fe76df42SMark Haverkamp dinfo->command = cpu_to_le32(VM_NameServe); 625fe76df42SMark Haverkamp dinfo->count = cpu_to_le32(scmd_id(scsicmd)); 626fe76df42SMark Haverkamp dinfo->type = cpu_to_le32(FT_FILESYS); 627fe76df42SMark Haverkamp scsicmd->SCp.ptr = (char *)callback; 628fe76df42SMark Haverkamp 629fe76df42SMark Haverkamp status = aac_fib_send(ContainerCommand, 630fe76df42SMark Haverkamp fibptr, 631fe76df42SMark Haverkamp sizeof(struct aac_query_mount), 632fe76df42SMark Haverkamp FsaNormal, 633fe76df42SMark Haverkamp 0, 1, 6341a655040SSalyzyn, Mark _aac_probe_container1, 635fe76df42SMark Haverkamp (void *) scsicmd); 636fe76df42SMark Haverkamp /* 637fe76df42SMark Haverkamp * Check that the command queued to the controller 638fe76df42SMark Haverkamp */ 639fe76df42SMark Haverkamp if (status == -EINPROGRESS) { 640fe76df42SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 641fe76df42SMark Haverkamp return 0; 642fe76df42SMark Haverkamp } 643fe76df42SMark Haverkamp if (status < 0) { 644fe76df42SMark Haverkamp scsicmd->SCp.ptr = NULL; 645fe76df42SMark Haverkamp aac_fib_complete(fibptr); 646fe76df42SMark Haverkamp aac_fib_free(fibptr); 647fe76df42SMark Haverkamp } 648fe76df42SMark Haverkamp } 649fe76df42SMark Haverkamp if (status < 0) { 650fe76df42SMark Haverkamp struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev; 651fe76df42SMark Haverkamp if (fsa_dev_ptr) { 652fe76df42SMark Haverkamp fsa_dev_ptr += scmd_id(scsicmd); 653fe76df42SMark Haverkamp if ((fsa_dev_ptr->valid & 1) == 0) { 654fe76df42SMark Haverkamp fsa_dev_ptr->valid = 0; 655fe76df42SMark Haverkamp return (*callback)(scsicmd); 656fe76df42SMark Haverkamp } 657fe76df42SMark Haverkamp } 658fe76df42SMark Haverkamp } 659fe76df42SMark Haverkamp return status; 660fe76df42SMark Haverkamp } 661fe76df42SMark Haverkamp 6621da177e4SLinus Torvalds /** 663bfb35aa8SMark Haverkamp * aac_probe_container - query a logical volume 6641da177e4SLinus Torvalds * @dev: device to query 6651da177e4SLinus Torvalds * @cid: container identifier 6661da177e4SLinus Torvalds * 6671da177e4SLinus Torvalds * Queries the controller about the given volume. The volume information 6681da177e4SLinus Torvalds * is updated in the struct fsa_dev_info structure rather than returned. 6691da177e4SLinus Torvalds */ 670fe76df42SMark Haverkamp static int aac_probe_container_callback1(struct scsi_cmnd * scsicmd) 671fe76df42SMark Haverkamp { 672fe76df42SMark Haverkamp scsicmd->device = NULL; 673fe76df42SMark Haverkamp return 0; 674fe76df42SMark Haverkamp } 6751da177e4SLinus Torvalds 676bfb35aa8SMark Haverkamp int aac_probe_container(struct aac_dev *dev, int cid) 6771da177e4SLinus Torvalds { 678fe76df42SMark Haverkamp struct scsi_cmnd *scsicmd = kmalloc(sizeof(*scsicmd), GFP_KERNEL); 679fe76df42SMark Haverkamp struct scsi_device *scsidev = kmalloc(sizeof(*scsidev), GFP_KERNEL); 6801da177e4SLinus Torvalds int status; 6811da177e4SLinus Torvalds 682fe76df42SMark Haverkamp if (!scsicmd || !scsidev) { 683fe76df42SMark Haverkamp kfree(scsicmd); 684fe76df42SMark Haverkamp kfree(scsidev); 68590ee3466SMark Haverkamp return -ENOMEM; 6861da177e4SLinus Torvalds } 687fe76df42SMark Haverkamp scsicmd->list.next = NULL; 6881a655040SSalyzyn, Mark scsicmd->scsi_done = (void (*)(struct scsi_cmnd*))aac_probe_container_callback1; 6891da177e4SLinus Torvalds 690fe76df42SMark Haverkamp scsicmd->device = scsidev; 691fe76df42SMark Haverkamp scsidev->sdev_state = 0; 692fe76df42SMark Haverkamp scsidev->id = cid; 693fe76df42SMark Haverkamp scsidev->host = dev->scsi_host_ptr; 6941da177e4SLinus Torvalds 695fe76df42SMark Haverkamp if (_aac_probe_container(scsicmd, aac_probe_container_callback1) == 0) 696fe76df42SMark Haverkamp while (scsicmd->device == scsidev) 697fe76df42SMark Haverkamp schedule(); 698802ae2f0SSalyzyn, Mark kfree(scsidev); 699fe76df42SMark Haverkamp status = scsicmd->SCp.Status; 700fe76df42SMark Haverkamp kfree(scsicmd); 7011da177e4SLinus Torvalds return status; 7021da177e4SLinus Torvalds } 7031da177e4SLinus Torvalds 7041da177e4SLinus Torvalds /* Local Structure to set SCSI inquiry data strings */ 7051da177e4SLinus Torvalds struct scsi_inq { 7061da177e4SLinus Torvalds char vid[8]; /* Vendor ID */ 7071da177e4SLinus Torvalds char pid[16]; /* Product ID */ 7081da177e4SLinus Torvalds char prl[4]; /* Product Revision Level */ 7091da177e4SLinus Torvalds }; 7101da177e4SLinus Torvalds 7111da177e4SLinus Torvalds /** 7121da177e4SLinus Torvalds * InqStrCopy - string merge 7131da177e4SLinus Torvalds * @a: string to copy from 7141da177e4SLinus Torvalds * @b: string to copy to 7151da177e4SLinus Torvalds * 7161da177e4SLinus Torvalds * Copy a String from one location to another 7171da177e4SLinus Torvalds * without copying \0 7181da177e4SLinus Torvalds */ 7191da177e4SLinus Torvalds 7201da177e4SLinus Torvalds static void inqstrcpy(char *a, char *b) 7211da177e4SLinus Torvalds { 7221da177e4SLinus Torvalds 7231da177e4SLinus Torvalds while (*a != (char)0) 7241da177e4SLinus Torvalds *b++ = *a++; 7251da177e4SLinus Torvalds } 7261da177e4SLinus Torvalds 7271da177e4SLinus Torvalds static char *container_types[] = { 7281da177e4SLinus Torvalds "None", 7291da177e4SLinus Torvalds "Volume", 7301da177e4SLinus Torvalds "Mirror", 7311da177e4SLinus Torvalds "Stripe", 7321da177e4SLinus Torvalds "RAID5", 7331da177e4SLinus Torvalds "SSRW", 7341da177e4SLinus Torvalds "SSRO", 7351da177e4SLinus Torvalds "Morph", 7361da177e4SLinus Torvalds "Legacy", 7371da177e4SLinus Torvalds "RAID4", 7381da177e4SLinus Torvalds "RAID10", 7391da177e4SLinus Torvalds "RAID00", 7401da177e4SLinus Torvalds "V-MIRRORS", 7411da177e4SLinus Torvalds "PSEUDO R4", 7421da177e4SLinus Torvalds "RAID50", 74384971738SMark Haverkamp "RAID5D", 74484971738SMark Haverkamp "RAID5D0", 74584971738SMark Haverkamp "RAID1E", 74684971738SMark Haverkamp "RAID6", 74784971738SMark Haverkamp "RAID60", 7481da177e4SLinus Torvalds "Unknown" 7491da177e4SLinus Torvalds }; 7501da177e4SLinus Torvalds 75117eaaceeSSalyzyn, Mark char * get_container_type(unsigned tindex) 75217eaaceeSSalyzyn, Mark { 75317eaaceeSSalyzyn, Mark if (tindex >= ARRAY_SIZE(container_types)) 75417eaaceeSSalyzyn, Mark tindex = ARRAY_SIZE(container_types) - 1; 75517eaaceeSSalyzyn, Mark return container_types[tindex]; 75617eaaceeSSalyzyn, Mark } 7571da177e4SLinus Torvalds 7581da177e4SLinus Torvalds /* Function: setinqstr 7591da177e4SLinus Torvalds * 7601da177e4SLinus Torvalds * Arguments: [1] pointer to void [1] int 7611da177e4SLinus Torvalds * 7621da177e4SLinus Torvalds * Purpose: Sets SCSI inquiry data strings for vendor, product 76325985edcSLucas De Marchi * and revision level. Allows strings to be set in platform dependent 76425985edcSLucas De Marchi * files instead of in OS dependent driver source. 7651da177e4SLinus Torvalds */ 7661da177e4SLinus Torvalds 767794d0601SMark Haverkamp static void setinqstr(struct aac_dev *dev, void *data, int tindex) 7681da177e4SLinus Torvalds { 7691da177e4SLinus Torvalds struct scsi_inq *str; 7701da177e4SLinus Torvalds 7711da177e4SLinus Torvalds str = (struct scsi_inq *)(data); /* cast data to scsi inq block */ 772794d0601SMark Haverkamp memset(str, ' ', sizeof(*str)); 773794d0601SMark Haverkamp 774794d0601SMark Haverkamp if (dev->supplement_adapter_info.AdapterTypeText[0]) { 775794d0601SMark Haverkamp char * cp = dev->supplement_adapter_info.AdapterTypeText; 7763bc8070fSSalyzyn, Mark int c; 7773bc8070fSSalyzyn, Mark if ((cp[0] == 'A') && (cp[1] == 'O') && (cp[2] == 'C')) 7783bc8070fSSalyzyn, Mark inqstrcpy("SMC", str->vid); 7793bc8070fSSalyzyn, Mark else { 7803bc8070fSSalyzyn, Mark c = sizeof(str->vid); 781794d0601SMark Haverkamp while (*cp && *cp != ' ' && --c) 782794d0601SMark Haverkamp ++cp; 783794d0601SMark Haverkamp c = *cp; 784794d0601SMark Haverkamp *cp = '\0'; 785794d0601SMark Haverkamp inqstrcpy (dev->supplement_adapter_info.AdapterTypeText, 786794d0601SMark Haverkamp str->vid); 787794d0601SMark Haverkamp *cp = c; 788794d0601SMark Haverkamp while (*cp && *cp != ' ') 789794d0601SMark Haverkamp ++cp; 7903bc8070fSSalyzyn, Mark } 791794d0601SMark Haverkamp while (*cp == ' ') 792794d0601SMark Haverkamp ++cp; 793794d0601SMark Haverkamp /* last six chars reserved for vol type */ 794794d0601SMark Haverkamp c = 0; 795794d0601SMark Haverkamp if (strlen(cp) > sizeof(str->pid)) { 796794d0601SMark Haverkamp c = cp[sizeof(str->pid)]; 797794d0601SMark Haverkamp cp[sizeof(str->pid)] = '\0'; 798794d0601SMark Haverkamp } 799794d0601SMark Haverkamp inqstrcpy (cp, str->pid); 800794d0601SMark Haverkamp if (c) 801794d0601SMark Haverkamp cp[sizeof(str->pid)] = c; 802794d0601SMark Haverkamp } else { 803794d0601SMark Haverkamp struct aac_driver_ident *mp = aac_get_driver_ident(dev->cardtype); 8041da177e4SLinus Torvalds 8051da177e4SLinus Torvalds inqstrcpy (mp->vname, str->vid); 806794d0601SMark Haverkamp /* last six chars reserved for vol type */ 807794d0601SMark Haverkamp inqstrcpy (mp->model, str->pid); 808794d0601SMark Haverkamp } 8091da177e4SLinus Torvalds 8106391a113STobias Klauser if (tindex < ARRAY_SIZE(container_types)){ 8111da177e4SLinus Torvalds char *findit = str->pid; 8121da177e4SLinus Torvalds 8131da177e4SLinus Torvalds for ( ; *findit != ' '; findit++); /* walk till we find a space */ 8141da177e4SLinus Torvalds /* RAID is superfluous in the context of a RAID device */ 8151da177e4SLinus Torvalds if (memcmp(findit-4, "RAID", 4) == 0) 8161da177e4SLinus Torvalds *(findit -= 4) = ' '; 817794d0601SMark Haverkamp if (((findit - str->pid) + strlen(container_types[tindex])) 818794d0601SMark Haverkamp < (sizeof(str->pid) + sizeof(str->prl))) 8191da177e4SLinus Torvalds inqstrcpy (container_types[tindex], findit + 1); 8201da177e4SLinus Torvalds } 8211da177e4SLinus Torvalds inqstrcpy ("V1.0", str->prl); 8221da177e4SLinus Torvalds } 8231da177e4SLinus Torvalds 82488e2f98eSSalyzyn, Mark static void get_container_serial_callback(void *context, struct fib * fibptr) 82588e2f98eSSalyzyn, Mark { 82688e2f98eSSalyzyn, Mark struct aac_get_serial_resp * get_serial_reply; 82788e2f98eSSalyzyn, Mark struct scsi_cmnd * scsicmd; 82888e2f98eSSalyzyn, Mark 82988e2f98eSSalyzyn, Mark BUG_ON(fibptr == NULL); 83088e2f98eSSalyzyn, Mark 83188e2f98eSSalyzyn, Mark scsicmd = (struct scsi_cmnd *) context; 83288e2f98eSSalyzyn, Mark if (!aac_valid_context(scsicmd, fibptr)) 83388e2f98eSSalyzyn, Mark return; 83488e2f98eSSalyzyn, Mark 83588e2f98eSSalyzyn, Mark get_serial_reply = (struct aac_get_serial_resp *) fib_data(fibptr); 83688e2f98eSSalyzyn, Mark /* Failure is irrelevant, using default value instead */ 83788e2f98eSSalyzyn, Mark if (le32_to_cpu(get_serial_reply->status) == CT_OK) { 83888e2f98eSSalyzyn, Mark char sp[13]; 83988e2f98eSSalyzyn, Mark /* EVPD bit set */ 84088e2f98eSSalyzyn, Mark sp[0] = INQD_PDT_DA; 84188e2f98eSSalyzyn, Mark sp[1] = scsicmd->cmnd[2]; 84288e2f98eSSalyzyn, Mark sp[2] = 0; 84388e2f98eSSalyzyn, Mark sp[3] = snprintf(sp+4, sizeof(sp)-4, "%08X", 84488e2f98eSSalyzyn, Mark le32_to_cpu(get_serial_reply->uid)); 845d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, sp, sizeof(sp)); 84688e2f98eSSalyzyn, Mark } 84788e2f98eSSalyzyn, Mark 84888e2f98eSSalyzyn, Mark scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 84988e2f98eSSalyzyn, Mark 85088e2f98eSSalyzyn, Mark aac_fib_complete(fibptr); 85188e2f98eSSalyzyn, Mark aac_fib_free(fibptr); 85288e2f98eSSalyzyn, Mark scsicmd->scsi_done(scsicmd); 85388e2f98eSSalyzyn, Mark } 85488e2f98eSSalyzyn, Mark 85588e2f98eSSalyzyn, Mark /** 85688e2f98eSSalyzyn, Mark * aac_get_container_serial - get container serial, none blocking. 85788e2f98eSSalyzyn, Mark */ 85888e2f98eSSalyzyn, Mark static int aac_get_container_serial(struct scsi_cmnd * scsicmd) 85988e2f98eSSalyzyn, Mark { 86088e2f98eSSalyzyn, Mark int status; 86188e2f98eSSalyzyn, Mark struct aac_get_serial *dinfo; 86288e2f98eSSalyzyn, Mark struct fib * cmd_fibcontext; 86388e2f98eSSalyzyn, Mark struct aac_dev * dev; 86488e2f98eSSalyzyn, Mark 86588e2f98eSSalyzyn, Mark dev = (struct aac_dev *)scsicmd->device->host->hostdata; 86688e2f98eSSalyzyn, Mark 86788e2f98eSSalyzyn, Mark if (!(cmd_fibcontext = aac_fib_alloc(dev))) 86888e2f98eSSalyzyn, Mark return -ENOMEM; 86988e2f98eSSalyzyn, Mark 87088e2f98eSSalyzyn, Mark aac_fib_init(cmd_fibcontext); 87188e2f98eSSalyzyn, Mark dinfo = (struct aac_get_serial *) fib_data(cmd_fibcontext); 87288e2f98eSSalyzyn, Mark 87388e2f98eSSalyzyn, Mark dinfo->command = cpu_to_le32(VM_ContainerConfig); 87488e2f98eSSalyzyn, Mark dinfo->type = cpu_to_le32(CT_CID_TO_32BITS_UID); 87588e2f98eSSalyzyn, Mark dinfo->cid = cpu_to_le32(scmd_id(scsicmd)); 87688e2f98eSSalyzyn, Mark 87788e2f98eSSalyzyn, Mark status = aac_fib_send(ContainerCommand, 87888e2f98eSSalyzyn, Mark cmd_fibcontext, 87988e2f98eSSalyzyn, Mark sizeof (struct aac_get_serial), 88088e2f98eSSalyzyn, Mark FsaNormal, 88188e2f98eSSalyzyn, Mark 0, 1, 88288e2f98eSSalyzyn, Mark (fib_callback) get_container_serial_callback, 88388e2f98eSSalyzyn, Mark (void *) scsicmd); 88488e2f98eSSalyzyn, Mark 88588e2f98eSSalyzyn, Mark /* 88688e2f98eSSalyzyn, Mark * Check that the command queued to the controller 88788e2f98eSSalyzyn, Mark */ 88888e2f98eSSalyzyn, Mark if (status == -EINPROGRESS) { 88988e2f98eSSalyzyn, Mark scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 89088e2f98eSSalyzyn, Mark return 0; 89188e2f98eSSalyzyn, Mark } 89288e2f98eSSalyzyn, Mark 89388e2f98eSSalyzyn, Mark printk(KERN_WARNING "aac_get_container_serial: aac_fib_send failed with status: %d.\n", status); 89488e2f98eSSalyzyn, Mark aac_fib_complete(cmd_fibcontext); 89588e2f98eSSalyzyn, Mark aac_fib_free(cmd_fibcontext); 89688e2f98eSSalyzyn, Mark return -1; 89788e2f98eSSalyzyn, Mark } 89888e2f98eSSalyzyn, Mark 89988e2f98eSSalyzyn, Mark /* Function: setinqserial 90088e2f98eSSalyzyn, Mark * 90188e2f98eSSalyzyn, Mark * Arguments: [1] pointer to void [1] int 90288e2f98eSSalyzyn, Mark * 90388e2f98eSSalyzyn, Mark * Purpose: Sets SCSI Unit Serial number. 90488e2f98eSSalyzyn, Mark * This is a fake. We should read a proper 90588e2f98eSSalyzyn, Mark * serial number from the container. <SuSE>But 90688e2f98eSSalyzyn, Mark * without docs it's quite hard to do it :-) 90788e2f98eSSalyzyn, Mark * So this will have to do in the meantime.</SuSE> 90888e2f98eSSalyzyn, Mark */ 90988e2f98eSSalyzyn, Mark 91088e2f98eSSalyzyn, Mark static int setinqserial(struct aac_dev *dev, void *data, int cid) 91188e2f98eSSalyzyn, Mark { 91288e2f98eSSalyzyn, Mark /* 91388e2f98eSSalyzyn, Mark * This breaks array migration. 91488e2f98eSSalyzyn, Mark */ 91588e2f98eSSalyzyn, Mark return snprintf((char *)(data), sizeof(struct scsi_inq) - 4, "%08X%02X", 91688e2f98eSSalyzyn, Mark le32_to_cpu(dev->adapter_info.serial[0]), cid); 91788e2f98eSSalyzyn, Mark } 91888e2f98eSSalyzyn, Mark 9198e31e607SSalyzyn, Mark static inline void set_sense(struct sense_data *sense_data, u8 sense_key, 9208e31e607SSalyzyn, Mark u8 sense_code, u8 a_sense_code, u8 bit_pointer, u16 field_pointer) 9211da177e4SLinus Torvalds { 9228e31e607SSalyzyn, Mark u8 *sense_buf = (u8 *)sense_data; 9238e31e607SSalyzyn, Mark /* Sense data valid, err code 70h */ 9248e31e607SSalyzyn, Mark sense_buf[0] = 0x70; /* No info field */ 9251da177e4SLinus Torvalds sense_buf[1] = 0; /* Segment number, always zero */ 9261da177e4SLinus Torvalds 9271da177e4SLinus Torvalds sense_buf[2] = sense_key; /* Sense key */ 9281da177e4SLinus Torvalds 9291da177e4SLinus Torvalds sense_buf[12] = sense_code; /* Additional sense code */ 9301da177e4SLinus Torvalds sense_buf[13] = a_sense_code; /* Additional sense code qualifier */ 9318e31e607SSalyzyn, Mark 9321da177e4SLinus Torvalds if (sense_key == ILLEGAL_REQUEST) { 9338e31e607SSalyzyn, Mark sense_buf[7] = 10; /* Additional sense length */ 9341da177e4SLinus Torvalds 9358e31e607SSalyzyn, Mark sense_buf[15] = bit_pointer; 9361da177e4SLinus Torvalds /* Illegal parameter is in the parameter block */ 9371da177e4SLinus Torvalds if (sense_code == SENCODE_INVALID_CDB_FIELD) 9388e31e607SSalyzyn, Mark sense_buf[15] |= 0xc0;/* Std sense key specific field */ 9391da177e4SLinus Torvalds /* Illegal parameter is in the CDB block */ 9401da177e4SLinus Torvalds sense_buf[16] = field_pointer >> 8; /* MSB */ 9411da177e4SLinus Torvalds sense_buf[17] = field_pointer; /* LSB */ 9428e31e607SSalyzyn, Mark } else 9438e31e607SSalyzyn, Mark sense_buf[7] = 6; /* Additional sense length */ 9441da177e4SLinus Torvalds } 9451da177e4SLinus Torvalds 946e8f32de5SMark Haverkamp static int aac_bounds_32(struct aac_dev * dev, struct scsi_cmnd * cmd, u64 lba) 947e8f32de5SMark Haverkamp { 948e8f32de5SMark Haverkamp if (lba & 0xffffffff00000000LL) { 949e8f32de5SMark Haverkamp int cid = scmd_id(cmd); 950e8f32de5SMark Haverkamp dprintk((KERN_DEBUG "aacraid: Illegal lba\n")); 951e8f32de5SMark Haverkamp cmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 952e8f32de5SMark Haverkamp SAM_STAT_CHECK_CONDITION; 9538e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 9548e31e607SSalyzyn, Mark HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 9558e31e607SSalyzyn, Mark ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 956e8f32de5SMark Haverkamp memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 9573ace426fSSalyzyn, Mark min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 9583ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE)); 959e8f32de5SMark Haverkamp cmd->scsi_done(cmd); 960e8f32de5SMark Haverkamp return 1; 961e8f32de5SMark Haverkamp } 962e8f32de5SMark Haverkamp return 0; 963e8f32de5SMark Haverkamp } 964e8f32de5SMark Haverkamp 965e8f32de5SMark Haverkamp static int aac_bounds_64(struct aac_dev * dev, struct scsi_cmnd * cmd, u64 lba) 966e8f32de5SMark Haverkamp { 967e8f32de5SMark Haverkamp return 0; 968e8f32de5SMark Haverkamp } 969e8f32de5SMark Haverkamp 970e8f32de5SMark Haverkamp static void io_callback(void *context, struct fib * fibptr); 971e8f32de5SMark Haverkamp 972e8f32de5SMark Haverkamp static int aac_read_raw_io(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 973e8f32de5SMark Haverkamp { 97485d22bbfSMahesh Rajashekhara struct aac_dev *dev = fib->dev; 97585d22bbfSMahesh Rajashekhara u16 fibsize, command; 9760b433447SMahesh Rajashekhara long ret; 97785d22bbfSMahesh Rajashekhara 978e8f32de5SMark Haverkamp aac_fib_init(fib); 97985d22bbfSMahesh Rajashekhara if (dev->comm_interface == AAC_COMM_MESSAGE_TYPE2 && !dev->sync_mode) { 98085d22bbfSMahesh Rajashekhara struct aac_raw_io2 *readcmd2; 98185d22bbfSMahesh Rajashekhara readcmd2 = (struct aac_raw_io2 *) fib_data(fib); 98285d22bbfSMahesh Rajashekhara memset(readcmd2, 0, sizeof(struct aac_raw_io2)); 98385d22bbfSMahesh Rajashekhara readcmd2->blockLow = cpu_to_le32((u32)(lba&0xffffffff)); 98485d22bbfSMahesh Rajashekhara readcmd2->blockHigh = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 98585d22bbfSMahesh Rajashekhara readcmd2->byteCount = cpu_to_le32(count<<9); 98685d22bbfSMahesh Rajashekhara readcmd2->cid = cpu_to_le16(scmd_id(cmd)); 98785d22bbfSMahesh Rajashekhara readcmd2->flags = cpu_to_le16(RIO2_IO_TYPE_READ); 9880b433447SMahesh Rajashekhara ret = aac_build_sgraw2(cmd, readcmd2, 9890b433447SMahesh Rajashekhara dev->scsi_host_ptr->sg_tablesize); 9900b433447SMahesh Rajashekhara if (ret < 0) 9910b433447SMahesh Rajashekhara return ret; 99285d22bbfSMahesh Rajashekhara command = ContainerRawIo2; 99385d22bbfSMahesh Rajashekhara fibsize = sizeof(struct aac_raw_io2) + 99485d22bbfSMahesh Rajashekhara ((le32_to_cpu(readcmd2->sgeCnt)-1) * sizeof(struct sge_ieee1212)); 99585d22bbfSMahesh Rajashekhara } else { 99685d22bbfSMahesh Rajashekhara struct aac_raw_io *readcmd; 997e8f32de5SMark Haverkamp readcmd = (struct aac_raw_io *) fib_data(fib); 998e8f32de5SMark Haverkamp readcmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff)); 999e8f32de5SMark Haverkamp readcmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 1000e8f32de5SMark Haverkamp readcmd->count = cpu_to_le32(count<<9); 1001e8f32de5SMark Haverkamp readcmd->cid = cpu_to_le16(scmd_id(cmd)); 100285d22bbfSMahesh Rajashekhara readcmd->flags = cpu_to_le16(RIO_TYPE_READ); 1003e8f32de5SMark Haverkamp readcmd->bpTotal = 0; 1004e8f32de5SMark Haverkamp readcmd->bpComplete = 0; 10050b433447SMahesh Rajashekhara ret = aac_build_sgraw(cmd, &readcmd->sg); 10060b433447SMahesh Rajashekhara if (ret < 0) 10070b433447SMahesh Rajashekhara return ret; 100885d22bbfSMahesh Rajashekhara command = ContainerRawIo; 100985d22bbfSMahesh Rajashekhara fibsize = sizeof(struct aac_raw_io) + 101085d22bbfSMahesh Rajashekhara ((le32_to_cpu(readcmd->sg.count)-1) * sizeof(struct sgentryraw)); 101185d22bbfSMahesh Rajashekhara } 101285d22bbfSMahesh Rajashekhara 1013e8f32de5SMark Haverkamp BUG_ON(fibsize > (fib->dev->max_fib_size - sizeof(struct aac_fibhdr))); 1014e8f32de5SMark Haverkamp /* 1015e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1016e8f32de5SMark Haverkamp */ 101785d22bbfSMahesh Rajashekhara return aac_fib_send(command, 1018e8f32de5SMark Haverkamp fib, 1019e8f32de5SMark Haverkamp fibsize, 1020e8f32de5SMark Haverkamp FsaNormal, 1021e8f32de5SMark Haverkamp 0, 1, 1022e8f32de5SMark Haverkamp (fib_callback) io_callback, 1023e8f32de5SMark Haverkamp (void *) cmd); 1024e8f32de5SMark Haverkamp } 1025e8f32de5SMark Haverkamp 1026e8f32de5SMark Haverkamp static int aac_read_block64(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 1027e8f32de5SMark Haverkamp { 1028e8f32de5SMark Haverkamp u16 fibsize; 1029e8f32de5SMark Haverkamp struct aac_read64 *readcmd; 10300b433447SMahesh Rajashekhara long ret; 10310b433447SMahesh Rajashekhara 1032e8f32de5SMark Haverkamp aac_fib_init(fib); 1033e8f32de5SMark Haverkamp readcmd = (struct aac_read64 *) fib_data(fib); 1034e8f32de5SMark Haverkamp readcmd->command = cpu_to_le32(VM_CtHostRead64); 1035e8f32de5SMark Haverkamp readcmd->cid = cpu_to_le16(scmd_id(cmd)); 1036e8f32de5SMark Haverkamp readcmd->sector_count = cpu_to_le16(count); 1037e8f32de5SMark Haverkamp readcmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1038e8f32de5SMark Haverkamp readcmd->pad = 0; 1039e8f32de5SMark Haverkamp readcmd->flags = 0; 1040e8f32de5SMark Haverkamp 10410b433447SMahesh Rajashekhara ret = aac_build_sg64(cmd, &readcmd->sg); 10420b433447SMahesh Rajashekhara if (ret < 0) 10430b433447SMahesh Rajashekhara return ret; 1044e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_read64) + 1045e8f32de5SMark Haverkamp ((le32_to_cpu(readcmd->sg.count) - 1) * 1046e8f32de5SMark Haverkamp sizeof (struct sgentry64)); 1047e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1048e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1049e8f32de5SMark Haverkamp /* 1050e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1051e8f32de5SMark Haverkamp */ 1052e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand64, 1053e8f32de5SMark Haverkamp fib, 1054e8f32de5SMark Haverkamp fibsize, 1055e8f32de5SMark Haverkamp FsaNormal, 1056e8f32de5SMark Haverkamp 0, 1, 1057e8f32de5SMark Haverkamp (fib_callback) io_callback, 1058e8f32de5SMark Haverkamp (void *) cmd); 1059e8f32de5SMark Haverkamp } 1060e8f32de5SMark Haverkamp 1061e8f32de5SMark Haverkamp static int aac_read_block(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 1062e8f32de5SMark Haverkamp { 1063e8f32de5SMark Haverkamp u16 fibsize; 1064e8f32de5SMark Haverkamp struct aac_read *readcmd; 10650b433447SMahesh Rajashekhara long ret; 10660b433447SMahesh Rajashekhara 1067e8f32de5SMark Haverkamp aac_fib_init(fib); 1068e8f32de5SMark Haverkamp readcmd = (struct aac_read *) fib_data(fib); 1069e8f32de5SMark Haverkamp readcmd->command = cpu_to_le32(VM_CtBlockRead); 1070f3307f72SChristoph Hellwig readcmd->cid = cpu_to_le32(scmd_id(cmd)); 1071e8f32de5SMark Haverkamp readcmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1072e8f32de5SMark Haverkamp readcmd->count = cpu_to_le32(count * 512); 1073e8f32de5SMark Haverkamp 10740b433447SMahesh Rajashekhara ret = aac_build_sg(cmd, &readcmd->sg); 10750b433447SMahesh Rajashekhara if (ret < 0) 10760b433447SMahesh Rajashekhara return ret; 1077e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_read) + 1078e8f32de5SMark Haverkamp ((le32_to_cpu(readcmd->sg.count) - 1) * 1079e8f32de5SMark Haverkamp sizeof (struct sgentry)); 1080e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1081e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1082e8f32de5SMark Haverkamp /* 1083e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1084e8f32de5SMark Haverkamp */ 1085e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand, 1086e8f32de5SMark Haverkamp fib, 1087e8f32de5SMark Haverkamp fibsize, 1088e8f32de5SMark Haverkamp FsaNormal, 1089e8f32de5SMark Haverkamp 0, 1, 1090e8f32de5SMark Haverkamp (fib_callback) io_callback, 1091e8f32de5SMark Haverkamp (void *) cmd); 1092e8f32de5SMark Haverkamp } 1093e8f32de5SMark Haverkamp 10949d399cc7SSalyzyn, Mark static int aac_write_raw_io(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua) 1095e8f32de5SMark Haverkamp { 109685d22bbfSMahesh Rajashekhara struct aac_dev *dev = fib->dev; 109785d22bbfSMahesh Rajashekhara u16 fibsize, command; 10980b433447SMahesh Rajashekhara long ret; 109985d22bbfSMahesh Rajashekhara 1100e8f32de5SMark Haverkamp aac_fib_init(fib); 110185d22bbfSMahesh Rajashekhara if (dev->comm_interface == AAC_COMM_MESSAGE_TYPE2 && !dev->sync_mode) { 110285d22bbfSMahesh Rajashekhara struct aac_raw_io2 *writecmd2; 110385d22bbfSMahesh Rajashekhara writecmd2 = (struct aac_raw_io2 *) fib_data(fib); 110485d22bbfSMahesh Rajashekhara memset(writecmd2, 0, sizeof(struct aac_raw_io2)); 110585d22bbfSMahesh Rajashekhara writecmd2->blockLow = cpu_to_le32((u32)(lba&0xffffffff)); 110685d22bbfSMahesh Rajashekhara writecmd2->blockHigh = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 110785d22bbfSMahesh Rajashekhara writecmd2->byteCount = cpu_to_le32(count<<9); 110885d22bbfSMahesh Rajashekhara writecmd2->cid = cpu_to_le16(scmd_id(cmd)); 110985d22bbfSMahesh Rajashekhara writecmd2->flags = (fua && ((aac_cache & 5) != 1) && 111085d22bbfSMahesh Rajashekhara (((aac_cache & 5) != 5) || !fib->dev->cache_protected)) ? 111185d22bbfSMahesh Rajashekhara cpu_to_le16(RIO2_IO_TYPE_WRITE|RIO2_IO_SUREWRITE) : 111285d22bbfSMahesh Rajashekhara cpu_to_le16(RIO2_IO_TYPE_WRITE); 11130b433447SMahesh Rajashekhara ret = aac_build_sgraw2(cmd, writecmd2, 11140b433447SMahesh Rajashekhara dev->scsi_host_ptr->sg_tablesize); 11150b433447SMahesh Rajashekhara if (ret < 0) 11160b433447SMahesh Rajashekhara return ret; 111785d22bbfSMahesh Rajashekhara command = ContainerRawIo2; 111885d22bbfSMahesh Rajashekhara fibsize = sizeof(struct aac_raw_io2) + 111985d22bbfSMahesh Rajashekhara ((le32_to_cpu(writecmd2->sgeCnt)-1) * sizeof(struct sge_ieee1212)); 112085d22bbfSMahesh Rajashekhara } else { 112185d22bbfSMahesh Rajashekhara struct aac_raw_io *writecmd; 1122e8f32de5SMark Haverkamp writecmd = (struct aac_raw_io *) fib_data(fib); 1123e8f32de5SMark Haverkamp writecmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff)); 1124e8f32de5SMark Haverkamp writecmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 1125e8f32de5SMark Haverkamp writecmd->count = cpu_to_le32(count<<9); 1126e8f32de5SMark Haverkamp writecmd->cid = cpu_to_le16(scmd_id(cmd)); 112795e852e1SSalyzyn, Mark writecmd->flags = (fua && ((aac_cache & 5) != 1) && 112895e852e1SSalyzyn, Mark (((aac_cache & 5) != 5) || !fib->dev->cache_protected)) ? 112985d22bbfSMahesh Rajashekhara cpu_to_le16(RIO_TYPE_WRITE|RIO_SUREWRITE) : 113085d22bbfSMahesh Rajashekhara cpu_to_le16(RIO_TYPE_WRITE); 1131e8f32de5SMark Haverkamp writecmd->bpTotal = 0; 1132e8f32de5SMark Haverkamp writecmd->bpComplete = 0; 11330b433447SMahesh Rajashekhara ret = aac_build_sgraw(cmd, &writecmd->sg); 11340b433447SMahesh Rajashekhara if (ret < 0) 11350b433447SMahesh Rajashekhara return ret; 113685d22bbfSMahesh Rajashekhara command = ContainerRawIo; 113785d22bbfSMahesh Rajashekhara fibsize = sizeof(struct aac_raw_io) + 113885d22bbfSMahesh Rajashekhara ((le32_to_cpu(writecmd->sg.count)-1) * sizeof (struct sgentryraw)); 113985d22bbfSMahesh Rajashekhara } 114085d22bbfSMahesh Rajashekhara 1141e8f32de5SMark Haverkamp BUG_ON(fibsize > (fib->dev->max_fib_size - sizeof(struct aac_fibhdr))); 1142e8f32de5SMark Haverkamp /* 1143e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1144e8f32de5SMark Haverkamp */ 114585d22bbfSMahesh Rajashekhara return aac_fib_send(command, 1146e8f32de5SMark Haverkamp fib, 1147e8f32de5SMark Haverkamp fibsize, 1148e8f32de5SMark Haverkamp FsaNormal, 1149e8f32de5SMark Haverkamp 0, 1, 1150e8f32de5SMark Haverkamp (fib_callback) io_callback, 1151e8f32de5SMark Haverkamp (void *) cmd); 1152e8f32de5SMark Haverkamp } 1153e8f32de5SMark Haverkamp 11549d399cc7SSalyzyn, Mark static int aac_write_block64(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua) 1155e8f32de5SMark Haverkamp { 1156e8f32de5SMark Haverkamp u16 fibsize; 1157e8f32de5SMark Haverkamp struct aac_write64 *writecmd; 11580b433447SMahesh Rajashekhara long ret; 11590b433447SMahesh Rajashekhara 1160e8f32de5SMark Haverkamp aac_fib_init(fib); 1161e8f32de5SMark Haverkamp writecmd = (struct aac_write64 *) fib_data(fib); 1162e8f32de5SMark Haverkamp writecmd->command = cpu_to_le32(VM_CtHostWrite64); 1163e8f32de5SMark Haverkamp writecmd->cid = cpu_to_le16(scmd_id(cmd)); 1164e8f32de5SMark Haverkamp writecmd->sector_count = cpu_to_le16(count); 1165e8f32de5SMark Haverkamp writecmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1166e8f32de5SMark Haverkamp writecmd->pad = 0; 1167e8f32de5SMark Haverkamp writecmd->flags = 0; 1168e8f32de5SMark Haverkamp 11690b433447SMahesh Rajashekhara ret = aac_build_sg64(cmd, &writecmd->sg); 11700b433447SMahesh Rajashekhara if (ret < 0) 11710b433447SMahesh Rajashekhara return ret; 1172e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_write64) + 1173e8f32de5SMark Haverkamp ((le32_to_cpu(writecmd->sg.count) - 1) * 1174e8f32de5SMark Haverkamp sizeof (struct sgentry64)); 1175e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1176e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1177e8f32de5SMark Haverkamp /* 1178e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1179e8f32de5SMark Haverkamp */ 1180e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand64, 1181e8f32de5SMark Haverkamp fib, 1182e8f32de5SMark Haverkamp fibsize, 1183e8f32de5SMark Haverkamp FsaNormal, 1184e8f32de5SMark Haverkamp 0, 1, 1185e8f32de5SMark Haverkamp (fib_callback) io_callback, 1186e8f32de5SMark Haverkamp (void *) cmd); 1187e8f32de5SMark Haverkamp } 1188e8f32de5SMark Haverkamp 11899d399cc7SSalyzyn, Mark static int aac_write_block(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua) 1190e8f32de5SMark Haverkamp { 1191e8f32de5SMark Haverkamp u16 fibsize; 1192e8f32de5SMark Haverkamp struct aac_write *writecmd; 11930b433447SMahesh Rajashekhara long ret; 11940b433447SMahesh Rajashekhara 1195e8f32de5SMark Haverkamp aac_fib_init(fib); 1196e8f32de5SMark Haverkamp writecmd = (struct aac_write *) fib_data(fib); 1197e8f32de5SMark Haverkamp writecmd->command = cpu_to_le32(VM_CtBlockWrite); 1198f3307f72SChristoph Hellwig writecmd->cid = cpu_to_le32(scmd_id(cmd)); 1199e8f32de5SMark Haverkamp writecmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1200e8f32de5SMark Haverkamp writecmd->count = cpu_to_le32(count * 512); 1201e8f32de5SMark Haverkamp writecmd->sg.count = cpu_to_le32(1); 1202e8f32de5SMark Haverkamp /* ->stable is not used - it did mean which type of write */ 1203e8f32de5SMark Haverkamp 12040b433447SMahesh Rajashekhara ret = aac_build_sg(cmd, &writecmd->sg); 12050b433447SMahesh Rajashekhara if (ret < 0) 12060b433447SMahesh Rajashekhara return ret; 1207e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_write) + 1208e8f32de5SMark Haverkamp ((le32_to_cpu(writecmd->sg.count) - 1) * 1209e8f32de5SMark Haverkamp sizeof (struct sgentry)); 1210e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1211e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1212e8f32de5SMark Haverkamp /* 1213e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1214e8f32de5SMark Haverkamp */ 1215e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand, 1216e8f32de5SMark Haverkamp fib, 1217e8f32de5SMark Haverkamp fibsize, 1218e8f32de5SMark Haverkamp FsaNormal, 1219e8f32de5SMark Haverkamp 0, 1, 1220e8f32de5SMark Haverkamp (fib_callback) io_callback, 1221e8f32de5SMark Haverkamp (void *) cmd); 1222e8f32de5SMark Haverkamp } 1223e8f32de5SMark Haverkamp 1224e8f32de5SMark Haverkamp static struct aac_srb * aac_scsi_common(struct fib * fib, struct scsi_cmnd * cmd) 1225e8f32de5SMark Haverkamp { 1226e8f32de5SMark Haverkamp struct aac_srb * srbcmd; 1227e8f32de5SMark Haverkamp u32 flag; 1228e8f32de5SMark Haverkamp u32 timeout; 1229e8f32de5SMark Haverkamp 1230e8f32de5SMark Haverkamp aac_fib_init(fib); 1231e8f32de5SMark Haverkamp switch(cmd->sc_data_direction){ 1232e8f32de5SMark Haverkamp case DMA_TO_DEVICE: 1233e8f32de5SMark Haverkamp flag = SRB_DataOut; 1234e8f32de5SMark Haverkamp break; 1235e8f32de5SMark Haverkamp case DMA_BIDIRECTIONAL: 1236e8f32de5SMark Haverkamp flag = SRB_DataIn | SRB_DataOut; 1237e8f32de5SMark Haverkamp break; 1238e8f32de5SMark Haverkamp case DMA_FROM_DEVICE: 1239e8f32de5SMark Haverkamp flag = SRB_DataIn; 1240e8f32de5SMark Haverkamp break; 1241e8f32de5SMark Haverkamp case DMA_NONE: 1242e8f32de5SMark Haverkamp default: /* shuts up some versions of gcc */ 1243e8f32de5SMark Haverkamp flag = SRB_NoDataXfer; 1244e8f32de5SMark Haverkamp break; 1245e8f32de5SMark Haverkamp } 1246e8f32de5SMark Haverkamp 1247e8f32de5SMark Haverkamp srbcmd = (struct aac_srb*) fib_data(fib); 1248e8f32de5SMark Haverkamp srbcmd->function = cpu_to_le32(SRBF_ExecuteScsi); 1249e8f32de5SMark Haverkamp srbcmd->channel = cpu_to_le32(aac_logical_to_phys(scmd_channel(cmd))); 1250e8f32de5SMark Haverkamp srbcmd->id = cpu_to_le32(scmd_id(cmd)); 1251e8f32de5SMark Haverkamp srbcmd->lun = cpu_to_le32(cmd->device->lun); 1252e8f32de5SMark Haverkamp srbcmd->flags = cpu_to_le32(flag); 1253242f9dcbSJens Axboe timeout = cmd->request->timeout/HZ; 1254e8f32de5SMark Haverkamp if (timeout == 0) 1255e8f32de5SMark Haverkamp timeout = 1; 1256e8f32de5SMark Haverkamp srbcmd->timeout = cpu_to_le32(timeout); // timeout in seconds 1257e8f32de5SMark Haverkamp srbcmd->retry_limit = 0; /* Obsolete parameter */ 1258e8f32de5SMark Haverkamp srbcmd->cdb_size = cpu_to_le32(cmd->cmd_len); 1259e8f32de5SMark Haverkamp return srbcmd; 1260e8f32de5SMark Haverkamp } 1261e8f32de5SMark Haverkamp 1262e8f32de5SMark Haverkamp static void aac_srb_callback(void *context, struct fib * fibptr); 1263e8f32de5SMark Haverkamp 1264e8f32de5SMark Haverkamp static int aac_scsi_64(struct fib * fib, struct scsi_cmnd * cmd) 1265e8f32de5SMark Haverkamp { 1266e8f32de5SMark Haverkamp u16 fibsize; 1267e8f32de5SMark Haverkamp struct aac_srb * srbcmd = aac_scsi_common(fib, cmd); 12680b433447SMahesh Rajashekhara long ret; 1269e8f32de5SMark Haverkamp 12700b433447SMahesh Rajashekhara ret = aac_build_sg64(cmd, (struct sgmap64 *) &srbcmd->sg); 12710b433447SMahesh Rajashekhara if (ret < 0) 12720b433447SMahesh Rajashekhara return ret; 1273727eead6SFUJITA Tomonori srbcmd->count = cpu_to_le32(scsi_bufflen(cmd)); 1274e8f32de5SMark Haverkamp 1275e8f32de5SMark Haverkamp memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb)); 1276e8f32de5SMark Haverkamp memcpy(srbcmd->cdb, cmd->cmnd, cmd->cmd_len); 1277e8f32de5SMark Haverkamp /* 1278e8f32de5SMark Haverkamp * Build Scatter/Gather list 1279e8f32de5SMark Haverkamp */ 1280e8f32de5SMark Haverkamp fibsize = sizeof (struct aac_srb) - sizeof (struct sgentry) + 1281e8f32de5SMark Haverkamp ((le32_to_cpu(srbcmd->sg.count) & 0xff) * 1282e8f32de5SMark Haverkamp sizeof (struct sgentry64)); 1283e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1284e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1285e8f32de5SMark Haverkamp 1286e8f32de5SMark Haverkamp /* 1287e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1288e8f32de5SMark Haverkamp */ 1289e8f32de5SMark Haverkamp return aac_fib_send(ScsiPortCommand64, fib, 1290e8f32de5SMark Haverkamp fibsize, FsaNormal, 0, 1, 1291e8f32de5SMark Haverkamp (fib_callback) aac_srb_callback, 1292e8f32de5SMark Haverkamp (void *) cmd); 1293e8f32de5SMark Haverkamp } 1294e8f32de5SMark Haverkamp 1295e8f32de5SMark Haverkamp static int aac_scsi_32(struct fib * fib, struct scsi_cmnd * cmd) 1296e8f32de5SMark Haverkamp { 1297e8f32de5SMark Haverkamp u16 fibsize; 1298e8f32de5SMark Haverkamp struct aac_srb * srbcmd = aac_scsi_common(fib, cmd); 12990b433447SMahesh Rajashekhara long ret; 1300e8f32de5SMark Haverkamp 13010b433447SMahesh Rajashekhara ret = aac_build_sg(cmd, (struct sgmap *)&srbcmd->sg); 13020b433447SMahesh Rajashekhara if (ret < 0) 13030b433447SMahesh Rajashekhara return ret; 1304727eead6SFUJITA Tomonori srbcmd->count = cpu_to_le32(scsi_bufflen(cmd)); 1305e8f32de5SMark Haverkamp 1306e8f32de5SMark Haverkamp memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb)); 1307e8f32de5SMark Haverkamp memcpy(srbcmd->cdb, cmd->cmnd, cmd->cmd_len); 1308e8f32de5SMark Haverkamp /* 1309e8f32de5SMark Haverkamp * Build Scatter/Gather list 1310e8f32de5SMark Haverkamp */ 1311e8f32de5SMark Haverkamp fibsize = sizeof (struct aac_srb) + 1312e8f32de5SMark Haverkamp (((le32_to_cpu(srbcmd->sg.count) & 0xff) - 1) * 1313e8f32de5SMark Haverkamp sizeof (struct sgentry)); 1314e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1315e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1316e8f32de5SMark Haverkamp 1317e8f32de5SMark Haverkamp /* 1318e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1319e8f32de5SMark Haverkamp */ 1320e8f32de5SMark Haverkamp return aac_fib_send(ScsiPortCommand, fib, fibsize, FsaNormal, 0, 1, 1321e8f32de5SMark Haverkamp (fib_callback) aac_srb_callback, (void *) cmd); 1322e8f32de5SMark Haverkamp } 1323e8f32de5SMark Haverkamp 132494cf6ba1SSalyzyn, Mark static int aac_scsi_32_64(struct fib * fib, struct scsi_cmnd * cmd) 132594cf6ba1SSalyzyn, Mark { 1326d8e96507SLeubner, Achim if ((sizeof(dma_addr_t) > 4) && fib->dev->needs_dac && 132794cf6ba1SSalyzyn, Mark (fib->dev->adapter_info.options & AAC_OPT_SGMAP_HOST64)) 132894cf6ba1SSalyzyn, Mark return FAILED; 132994cf6ba1SSalyzyn, Mark return aac_scsi_32(fib, cmd); 133094cf6ba1SSalyzyn, Mark } 133194cf6ba1SSalyzyn, Mark 13321da177e4SLinus Torvalds int aac_get_adapter_info(struct aac_dev* dev) 13331da177e4SLinus Torvalds { 13341da177e4SLinus Torvalds struct fib* fibptr; 13351da177e4SLinus Torvalds int rcode; 13361da177e4SLinus Torvalds u32 tmp; 13377c00ffa3SMark Haverkamp struct aac_adapter_info *info; 133884971738SMark Haverkamp struct aac_bus_info *command; 133984971738SMark Haverkamp struct aac_bus_info_response *bus_info; 13407c00ffa3SMark Haverkamp 1341bfb35aa8SMark Haverkamp if (!(fibptr = aac_fib_alloc(dev))) 13421da177e4SLinus Torvalds return -ENOMEM; 13431da177e4SLinus Torvalds 1344bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 13451da177e4SLinus Torvalds info = (struct aac_adapter_info *) fib_data(fibptr); 13467c00ffa3SMark Haverkamp memset(info,0,sizeof(*info)); 13471da177e4SLinus Torvalds 1348bfb35aa8SMark Haverkamp rcode = aac_fib_send(RequestAdapterInfo, 13491da177e4SLinus Torvalds fibptr, 13507c00ffa3SMark Haverkamp sizeof(*info), 13511da177e4SLinus Torvalds FsaNormal, 13529203344cSMark Haverkamp -1, 1, /* First `interrupt' command uses special wait */ 13531da177e4SLinus Torvalds NULL, 13541da177e4SLinus Torvalds NULL); 13551da177e4SLinus Torvalds 13567c00ffa3SMark Haverkamp if (rcode < 0) { 1357cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* FIB should be freed only after 1358cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech * getting the response from the F/W */ 1359cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (rcode != -ERESTARTSYS) { 1360bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1361bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 1362cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech } 13637c00ffa3SMark Haverkamp return rcode; 13647c00ffa3SMark Haverkamp } 13657c00ffa3SMark Haverkamp memcpy(&dev->adapter_info, info, sizeof(*info)); 13667c00ffa3SMark Haverkamp 13677c00ffa3SMark Haverkamp if (dev->adapter_info.options & AAC_OPT_SUPPLEMENT_ADAPTER_INFO) { 136806a43d17SSalyzyn, Mark struct aac_supplement_adapter_info * sinfo; 13697c00ffa3SMark Haverkamp 1370bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 13717c00ffa3SMark Haverkamp 137206a43d17SSalyzyn, Mark sinfo = (struct aac_supplement_adapter_info *) fib_data(fibptr); 13737c00ffa3SMark Haverkamp 137406a43d17SSalyzyn, Mark memset(sinfo,0,sizeof(*sinfo)); 13757c00ffa3SMark Haverkamp 1376bfb35aa8SMark Haverkamp rcode = aac_fib_send(RequestSupplementAdapterInfo, 13777c00ffa3SMark Haverkamp fibptr, 137806a43d17SSalyzyn, Mark sizeof(*sinfo), 13797c00ffa3SMark Haverkamp FsaNormal, 13807c00ffa3SMark Haverkamp 1, 1, 13817c00ffa3SMark Haverkamp NULL, 13827c00ffa3SMark Haverkamp NULL); 13837c00ffa3SMark Haverkamp 13847c00ffa3SMark Haverkamp if (rcode >= 0) 138506a43d17SSalyzyn, Mark memcpy(&dev->supplement_adapter_info, sinfo, sizeof(*sinfo)); 1386cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (rcode == -ERESTARTSYS) { 1387cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech fibptr = aac_fib_alloc(dev); 1388cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (!fibptr) 1389cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech return -ENOMEM; 1390cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech } 1391cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech 13927c00ffa3SMark Haverkamp } 13931da177e4SLinus Torvalds 139484971738SMark Haverkamp 139584971738SMark Haverkamp /* 139684971738SMark Haverkamp * GetBusInfo 139784971738SMark Haverkamp */ 139884971738SMark Haverkamp 1399bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 140084971738SMark Haverkamp 140184971738SMark Haverkamp bus_info = (struct aac_bus_info_response *) fib_data(fibptr); 140284971738SMark Haverkamp 140384971738SMark Haverkamp memset(bus_info, 0, sizeof(*bus_info)); 140484971738SMark Haverkamp 140584971738SMark Haverkamp command = (struct aac_bus_info *)bus_info; 140684971738SMark Haverkamp 140784971738SMark Haverkamp command->Command = cpu_to_le32(VM_Ioctl); 140884971738SMark Haverkamp command->ObjType = cpu_to_le32(FT_DRIVE); 140984971738SMark Haverkamp command->MethodId = cpu_to_le32(1); 141084971738SMark Haverkamp command->CtlCmd = cpu_to_le32(GetBusInfo); 141184971738SMark Haverkamp 1412bfb35aa8SMark Haverkamp rcode = aac_fib_send(ContainerCommand, 141384971738SMark Haverkamp fibptr, 141484971738SMark Haverkamp sizeof (*bus_info), 141584971738SMark Haverkamp FsaNormal, 141684971738SMark Haverkamp 1, 1, 141784971738SMark Haverkamp NULL, NULL); 141884971738SMark Haverkamp 141994cf6ba1SSalyzyn, Mark /* reasoned default */ 142094cf6ba1SSalyzyn, Mark dev->maximum_num_physicals = 16; 142184971738SMark Haverkamp if (rcode >= 0 && le32_to_cpu(bus_info->Status) == ST_OK) { 142284971738SMark Haverkamp dev->maximum_num_physicals = le32_to_cpu(bus_info->TargetsPerBus); 142384971738SMark Haverkamp dev->maximum_num_channels = le32_to_cpu(bus_info->BusCount); 142484971738SMark Haverkamp } 142584971738SMark Haverkamp 14268c867b25SMark Haverkamp if (!dev->in_reset) { 142724f02e1dSSalyzyn, Mark char buffer[16]; 14281da177e4SLinus Torvalds tmp = le32_to_cpu(dev->adapter_info.kernelrev); 14297c00ffa3SMark Haverkamp printk(KERN_INFO "%s%d: kernel %d.%d-%d[%d] %.*s\n", 14301da177e4SLinus Torvalds dev->name, 14311da177e4SLinus Torvalds dev->id, 14321da177e4SLinus Torvalds tmp>>24, 14331da177e4SLinus Torvalds (tmp>>16)&0xff, 14341da177e4SLinus Torvalds tmp&0xff, 14357c00ffa3SMark Haverkamp le32_to_cpu(dev->adapter_info.kernelbuild), 14367c00ffa3SMark Haverkamp (int)sizeof(dev->supplement_adapter_info.BuildDate), 14377c00ffa3SMark Haverkamp dev->supplement_adapter_info.BuildDate); 14381da177e4SLinus Torvalds tmp = le32_to_cpu(dev->adapter_info.monitorrev); 14391da177e4SLinus Torvalds printk(KERN_INFO "%s%d: monitor %d.%d-%d[%d]\n", 14401da177e4SLinus Torvalds dev->name, dev->id, 14411da177e4SLinus Torvalds tmp>>24,(tmp>>16)&0xff,tmp&0xff, 14421da177e4SLinus Torvalds le32_to_cpu(dev->adapter_info.monitorbuild)); 14431da177e4SLinus Torvalds tmp = le32_to_cpu(dev->adapter_info.biosrev); 14441da177e4SLinus Torvalds printk(KERN_INFO "%s%d: bios %d.%d-%d[%d]\n", 14451da177e4SLinus Torvalds dev->name, dev->id, 14461da177e4SLinus Torvalds tmp>>24,(tmp>>16)&0xff,tmp&0xff, 14471da177e4SLinus Torvalds le32_to_cpu(dev->adapter_info.biosbuild)); 144824f02e1dSSalyzyn, Mark buffer[0] = '\0'; 1449ee959b00STony Jones if (aac_get_serial_number( 145024f02e1dSSalyzyn, Mark shost_to_class(dev->scsi_host_ptr), buffer)) 145124f02e1dSSalyzyn, Mark printk(KERN_INFO "%s%d: serial %s", 145224f02e1dSSalyzyn, Mark dev->name, dev->id, buffer); 1453a45c863fSSalyzyn, Mark if (dev->supplement_adapter_info.VpdInfo.Tsid[0]) { 1454a45c863fSSalyzyn, Mark printk(KERN_INFO "%s%d: TSID %.*s\n", 1455a45c863fSSalyzyn, Mark dev->name, dev->id, 1456a45c863fSSalyzyn, Mark (int)sizeof(dev->supplement_adapter_info.VpdInfo.Tsid), 1457a45c863fSSalyzyn, Mark dev->supplement_adapter_info.VpdInfo.Tsid); 1458a45c863fSSalyzyn, Mark } 14592f7ecc55SSalyzyn, Mark if (!aac_check_reset || ((aac_check_reset == 1) && 146029c97684SSalyzyn, Mark (dev->supplement_adapter_info.SupportedOptions2 & 1461a3940da5SSalyzyn, Mark AAC_OPTION_IGNORE_RESET))) { 146229c97684SSalyzyn, Mark printk(KERN_INFO "%s%d: Reset Adapter Ignored\n", 146329c97684SSalyzyn, Mark dev->name, dev->id); 146429c97684SSalyzyn, Mark } 14658c867b25SMark Haverkamp } 14661da177e4SLinus Torvalds 146795e852e1SSalyzyn, Mark dev->cache_protected = 0; 1468cb1042f2SSalyzyn, Mark dev->jbod = ((dev->supplement_adapter_info.FeatureBits & 1469cb1042f2SSalyzyn, Mark AAC_FEATURE_JBOD) != 0); 14701da177e4SLinus Torvalds dev->nondasd_support = 0; 14711da177e4SLinus Torvalds dev->raid_scsi_mode = 0; 147295e852e1SSalyzyn, Mark if(dev->adapter_info.options & AAC_OPT_NONDASD) 14731da177e4SLinus Torvalds dev->nondasd_support = 1; 14741da177e4SLinus Torvalds 14751da177e4SLinus Torvalds /* 14761da177e4SLinus Torvalds * If the firmware supports ROMB RAID/SCSI mode and we are currently 14771da177e4SLinus Torvalds * in RAID/SCSI mode, set the flag. For now if in this mode we will 14781da177e4SLinus Torvalds * force nondasd support on. If we decide to allow the non-dasd flag 14791da177e4SLinus Torvalds * additional changes changes will have to be made to support 14801da177e4SLinus Torvalds * RAID/SCSI. the function aac_scsi_cmd in this module will have to be 14811da177e4SLinus Torvalds * changed to support the new dev->raid_scsi_mode flag instead of 14821da177e4SLinus Torvalds * leaching off of the dev->nondasd_support flag. Also in linit.c the 14831da177e4SLinus Torvalds * function aac_detect will have to be modified where it sets up the 14841da177e4SLinus Torvalds * max number of channels based on the aac->nondasd_support flag only. 14851da177e4SLinus Torvalds */ 14861da177e4SLinus Torvalds if ((dev->adapter_info.options & AAC_OPT_SCSI_MANAGED) && 14871da177e4SLinus Torvalds (dev->adapter_info.options & AAC_OPT_RAID_SCSI_MODE)) { 14881da177e4SLinus Torvalds dev->nondasd_support = 1; 14891da177e4SLinus Torvalds dev->raid_scsi_mode = 1; 14901da177e4SLinus Torvalds } 14911da177e4SLinus Torvalds if (dev->raid_scsi_mode != 0) 14921da177e4SLinus Torvalds printk(KERN_INFO "%s%d: ROMB RAID/SCSI mode enabled\n", 14931da177e4SLinus Torvalds dev->name, dev->id); 14941da177e4SLinus Torvalds 149595e852e1SSalyzyn, Mark if (nondasd != -1) 14961da177e4SLinus Torvalds dev->nondasd_support = (nondasd!=0); 14972f7ecc55SSalyzyn, Mark if (dev->nondasd_support && !dev->in_reset) 14981da177e4SLinus Torvalds printk(KERN_INFO "%s%d: Non-DASD support enabled.\n",dev->name, dev->id); 14991da177e4SLinus Torvalds 1500e930438cSYang Hongyang if (dma_get_required_mask(&dev->pdev->dev) > DMA_BIT_MASK(32)) 1501d8e96507SLeubner, Achim dev->needs_dac = 1; 15021da177e4SLinus Torvalds dev->dac_support = 0; 1503d8e96507SLeubner, Achim if ((sizeof(dma_addr_t) > 4) && dev->needs_dac && 1504d8e96507SLeubner, Achim (dev->adapter_info.options & AAC_OPT_SGMAP_HOST64)) { 15052f7ecc55SSalyzyn, Mark if (!dev->in_reset) 15062f7ecc55SSalyzyn, Mark printk(KERN_INFO "%s%d: 64bit support enabled.\n", 15072f7ecc55SSalyzyn, Mark dev->name, dev->id); 15081da177e4SLinus Torvalds dev->dac_support = 1; 15091da177e4SLinus Torvalds } 15101da177e4SLinus Torvalds 15111da177e4SLinus Torvalds if(dacmode != -1) { 15121da177e4SLinus Torvalds dev->dac_support = (dacmode!=0); 15131da177e4SLinus Torvalds } 1514d8e96507SLeubner, Achim 1515d8e96507SLeubner, Achim /* avoid problems with AAC_QUIRK_SCSI_32 controllers */ 1516d8e96507SLeubner, Achim if (dev->dac_support && (aac_get_driver_ident(dev->cardtype)->quirks 1517d8e96507SLeubner, Achim & AAC_QUIRK_SCSI_32)) { 1518d8e96507SLeubner, Achim dev->nondasd_support = 0; 1519d8e96507SLeubner, Achim dev->jbod = 0; 1520d8e96507SLeubner, Achim expose_physicals = 0; 1521d8e96507SLeubner, Achim } 1522d8e96507SLeubner, Achim 15231da177e4SLinus Torvalds if(dev->dac_support != 0) { 15246a35528aSYang Hongyang if (!pci_set_dma_mask(dev->pdev, DMA_BIT_MASK(64)) && 15256a35528aSYang Hongyang !pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(64))) { 15262f7ecc55SSalyzyn, Mark if (!dev->in_reset) 15271da177e4SLinus Torvalds printk(KERN_INFO"%s%d: 64 Bit DAC enabled\n", 15281da177e4SLinus Torvalds dev->name, dev->id); 1529284901a9SYang Hongyang } else if (!pci_set_dma_mask(dev->pdev, DMA_BIT_MASK(32)) && 1530284901a9SYang Hongyang !pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(32))) { 15311da177e4SLinus Torvalds printk(KERN_INFO"%s%d: DMA mask set failed, 64 Bit DAC disabled\n", 15321da177e4SLinus Torvalds dev->name, dev->id); 15331da177e4SLinus Torvalds dev->dac_support = 0; 15341da177e4SLinus Torvalds } else { 15351da177e4SLinus Torvalds printk(KERN_WARNING"%s%d: No suitable DMA available.\n", 15361da177e4SLinus Torvalds dev->name, dev->id); 15371da177e4SLinus Torvalds rcode = -ENOMEM; 15381da177e4SLinus Torvalds } 15391da177e4SLinus Torvalds } 15407c00ffa3SMark Haverkamp /* 1541e8f32de5SMark Haverkamp * Deal with configuring for the individualized limits of each packet 1542e8f32de5SMark Haverkamp * interface. 15437c00ffa3SMark Haverkamp */ 1544e8f32de5SMark Haverkamp dev->a_ops.adapter_scsi = (dev->dac_support) 154594cf6ba1SSalyzyn, Mark ? ((aac_get_driver_ident(dev->cardtype)->quirks & AAC_QUIRK_SCSI_32) 154694cf6ba1SSalyzyn, Mark ? aac_scsi_32_64 154794cf6ba1SSalyzyn, Mark : aac_scsi_64) 1548e8f32de5SMark Haverkamp : aac_scsi_32; 1549e8f32de5SMark Haverkamp if (dev->raw_io_interface) { 1550e8f32de5SMark Haverkamp dev->a_ops.adapter_bounds = (dev->raw_io_64) 1551e8f32de5SMark Haverkamp ? aac_bounds_64 1552e8f32de5SMark Haverkamp : aac_bounds_32; 1553e8f32de5SMark Haverkamp dev->a_ops.adapter_read = aac_read_raw_io; 1554e8f32de5SMark Haverkamp dev->a_ops.adapter_write = aac_write_raw_io; 1555e8f32de5SMark Haverkamp } else { 1556e8f32de5SMark Haverkamp dev->a_ops.adapter_bounds = aac_bounds_32; 15577c00ffa3SMark Haverkamp dev->scsi_host_ptr->sg_tablesize = (dev->max_fib_size - 15587c00ffa3SMark Haverkamp sizeof(struct aac_fibhdr) - 155963a70eeaSMark Haverkamp sizeof(struct aac_write) + sizeof(struct sgentry)) / 156063a70eeaSMark Haverkamp sizeof(struct sgentry); 15617c00ffa3SMark Haverkamp if (dev->dac_support) { 1562e8f32de5SMark Haverkamp dev->a_ops.adapter_read = aac_read_block64; 1563e8f32de5SMark Haverkamp dev->a_ops.adapter_write = aac_write_block64; 15647c00ffa3SMark Haverkamp /* 15657c00ffa3SMark Haverkamp * 38 scatter gather elements 15667c00ffa3SMark Haverkamp */ 15677c00ffa3SMark Haverkamp dev->scsi_host_ptr->sg_tablesize = 15687c00ffa3SMark Haverkamp (dev->max_fib_size - 15697c00ffa3SMark Haverkamp sizeof(struct aac_fibhdr) - 15707c00ffa3SMark Haverkamp sizeof(struct aac_write64) + 157163a70eeaSMark Haverkamp sizeof(struct sgentry64)) / 157263a70eeaSMark Haverkamp sizeof(struct sgentry64); 1573e8f32de5SMark Haverkamp } else { 1574e8f32de5SMark Haverkamp dev->a_ops.adapter_read = aac_read_block; 1575e8f32de5SMark Haverkamp dev->a_ops.adapter_write = aac_write_block; 15767c00ffa3SMark Haverkamp } 15777c00ffa3SMark Haverkamp dev->scsi_host_ptr->max_sectors = AAC_MAX_32BIT_SGBCOUNT; 15787c00ffa3SMark Haverkamp if (!(dev->adapter_info.options & AAC_OPT_NEW_COMM)) { 15797c00ffa3SMark Haverkamp /* 15807c00ffa3SMark Haverkamp * Worst case size that could cause sg overflow when 15817c00ffa3SMark Haverkamp * we break up SG elements that are larger than 64KB. 15827c00ffa3SMark Haverkamp * Would be nice if we could tell the SCSI layer what 15837c00ffa3SMark Haverkamp * the maximum SG element size can be. Worst case is 15847c00ffa3SMark Haverkamp * (sg_tablesize-1) 4KB elements with one 64KB 15857c00ffa3SMark Haverkamp * element. 15867c00ffa3SMark Haverkamp * 32bit -> 468 or 238KB 64bit -> 424 or 212KB 15877c00ffa3SMark Haverkamp */ 15887c00ffa3SMark Haverkamp dev->scsi_host_ptr->max_sectors = 15897c00ffa3SMark Haverkamp (dev->scsi_host_ptr->sg_tablesize * 8) + 112; 15907c00ffa3SMark Haverkamp } 15910e68c003SMark Haverkamp } 1592cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* FIB should be freed only after getting the response from the F/W */ 1593cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (rcode != -ERESTARTSYS) { 1594bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1595bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 1596cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech } 15971da177e4SLinus Torvalds 15981da177e4SLinus Torvalds return rcode; 15991da177e4SLinus Torvalds } 16001da177e4SLinus Torvalds 16011da177e4SLinus Torvalds 1602e53cb35aSMark Haverkamp static void io_callback(void *context, struct fib * fibptr) 16031da177e4SLinus Torvalds { 16041da177e4SLinus Torvalds struct aac_dev *dev; 16051da177e4SLinus Torvalds struct aac_read_reply *readreply; 16061da177e4SLinus Torvalds struct scsi_cmnd *scsicmd; 16071da177e4SLinus Torvalds u32 cid; 16081da177e4SLinus Torvalds 16091da177e4SLinus Torvalds scsicmd = (struct scsi_cmnd *) context; 16101da177e4SLinus Torvalds 161103d44337SMark Haverkamp if (!aac_valid_context(scsicmd, fibptr)) 161203d44337SMark Haverkamp return; 161303d44337SMark Haverkamp 16141a655040SSalyzyn, Mark dev = fibptr->dev; 1615e5718774SMark Haverkamp cid = scmd_id(scsicmd); 16161da177e4SLinus Torvalds 16177a8cf29dSMark Haverkamp if (nblank(dprintk(x))) { 16187a8cf29dSMark Haverkamp u64 lba; 16197a8cf29dSMark Haverkamp switch (scsicmd->cmnd[0]) { 16207a8cf29dSMark Haverkamp case WRITE_6: 16217a8cf29dSMark Haverkamp case READ_6: 16227a8cf29dSMark Haverkamp lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | 16237a8cf29dSMark Haverkamp (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 16247a8cf29dSMark Haverkamp break; 16257a8cf29dSMark Haverkamp case WRITE_16: 16267a8cf29dSMark Haverkamp case READ_16: 16277a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 56) | 16287a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[3] << 48) | 16297a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[4] << 40) | 16307a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[5] << 32) | 16317a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[6] << 24) | 16327a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 16337a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 16347a8cf29dSMark Haverkamp break; 16357a8cf29dSMark Haverkamp case WRITE_12: 16367a8cf29dSMark Haverkamp case READ_12: 16377a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 16387a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 16397a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 16407a8cf29dSMark Haverkamp break; 16417a8cf29dSMark Haverkamp default: 16427a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 16437a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 16447a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 16457a8cf29dSMark Haverkamp break; 16467a8cf29dSMark Haverkamp } 16477a8cf29dSMark Haverkamp printk(KERN_DEBUG 16487a8cf29dSMark Haverkamp "io_callback[cpu %d]: lba = %llu, t = %ld.\n", 16497a8cf29dSMark Haverkamp smp_processor_id(), (unsigned long long)lba, jiffies); 16507a8cf29dSMark Haverkamp } 16511da177e4SLinus Torvalds 1652125e1874SEric Sesterhenn BUG_ON(fibptr == NULL); 16531da177e4SLinus Torvalds 1654727eead6SFUJITA Tomonori scsi_dma_unmap(scsicmd); 1655727eead6SFUJITA Tomonori 16561da177e4SLinus Torvalds readreply = (struct aac_read_reply *)fib_data(fibptr); 1657655d722cSMark Salyzyn switch (le32_to_cpu(readreply->status)) { 1658655d722cSMark Salyzyn case ST_OK: 1659655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 1660655d722cSMark Salyzyn SAM_STAT_GOOD; 1661655d722cSMark Salyzyn dev->fsa_dev[cid].sense_data.sense_key = NO_SENSE; 1662655d722cSMark Salyzyn break; 1663655d722cSMark Salyzyn case ST_NOT_READY: 1664655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 1665655d722cSMark Salyzyn SAM_STAT_CHECK_CONDITION; 1666655d722cSMark Salyzyn set_sense(&dev->fsa_dev[cid].sense_data, NOT_READY, 1667655d722cSMark Salyzyn SENCODE_BECOMING_READY, ASENCODE_BECOMING_READY, 0, 0); 1668655d722cSMark Salyzyn memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1669655d722cSMark Salyzyn min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 1670655d722cSMark Salyzyn SCSI_SENSE_BUFFERSIZE)); 1671655d722cSMark Salyzyn break; 1672655d722cSMark Salyzyn default: 16737c00ffa3SMark Haverkamp #ifdef AAC_DETAILED_STATUS_INFO 1674e53cb35aSMark Haverkamp printk(KERN_WARNING "io_callback: io failed, status = %d\n", 16751da177e4SLinus Torvalds le32_to_cpu(readreply->status)); 16767c00ffa3SMark Haverkamp #endif 1677655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 1678655d722cSMark Salyzyn SAM_STAT_CHECK_CONDITION; 16798e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 16808e31e607SSalyzyn, Mark HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 16818e31e607SSalyzyn, Mark ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 16821da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 16833ace426fSSalyzyn, Mark min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 16843ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE)); 1685655d722cSMark Salyzyn break; 16861da177e4SLinus Torvalds } 1687bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1688bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 16891da177e4SLinus Torvalds 16908e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 16911da177e4SLinus Torvalds } 16921da177e4SLinus Torvalds 16939e7c349cSMark Haverkamp static int aac_read(struct scsi_cmnd * scsicmd) 16941da177e4SLinus Torvalds { 16957a8cf29dSMark Haverkamp u64 lba; 16961da177e4SLinus Torvalds u32 count; 16971da177e4SLinus Torvalds int status; 16981da177e4SLinus Torvalds struct aac_dev *dev; 16991da177e4SLinus Torvalds struct fib * cmd_fibcontext; 1700da3cc679SRajashekhara, Mahesh int cid; 17011da177e4SLinus Torvalds 17021da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 17031da177e4SLinus Torvalds /* 17041da177e4SLinus Torvalds * Get block address and transfer length 17051da177e4SLinus Torvalds */ 17067a8cf29dSMark Haverkamp switch (scsicmd->cmnd[0]) { 17077a8cf29dSMark Haverkamp case READ_6: 17089e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a read(6) command on id %d.\n", scmd_id(scsicmd))); 17091da177e4SLinus Torvalds 17107a8cf29dSMark Haverkamp lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | 17117a8cf29dSMark Haverkamp (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 17121da177e4SLinus Torvalds count = scsicmd->cmnd[4]; 17131da177e4SLinus Torvalds 17141da177e4SLinus Torvalds if (count == 0) 17151da177e4SLinus Torvalds count = 256; 17167a8cf29dSMark Haverkamp break; 17177a8cf29dSMark Haverkamp case READ_16: 17189e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a read(16) command on id %d.\n", scmd_id(scsicmd))); 17197a8cf29dSMark Haverkamp 17207a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 56) | 17217a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[3] << 48) | 17227a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[4] << 40) | 17237a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[5] << 32) | 17247a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[6] << 24) | 17257a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 17267a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 17277a8cf29dSMark Haverkamp count = (scsicmd->cmnd[10] << 24) | 17287a8cf29dSMark Haverkamp (scsicmd->cmnd[11] << 16) | 17297a8cf29dSMark Haverkamp (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13]; 17307a8cf29dSMark Haverkamp break; 17317a8cf29dSMark Haverkamp case READ_12: 17329e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a read(12) command on id %d.\n", scmd_id(scsicmd))); 17337a8cf29dSMark Haverkamp 17347a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 17357a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 17367a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 17377a8cf29dSMark Haverkamp count = (scsicmd->cmnd[6] << 24) | 17387a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 17397a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 17407a8cf29dSMark Haverkamp break; 17417a8cf29dSMark Haverkamp default: 17429e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a read(10) command on id %d.\n", scmd_id(scsicmd))); 17431da177e4SLinus Torvalds 17447a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 17457a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 17467a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 17471da177e4SLinus Torvalds count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 17487a8cf29dSMark Haverkamp break; 17491da177e4SLinus Torvalds } 1750da3cc679SRajashekhara, Mahesh 1751da3cc679SRajashekhara, Mahesh if ((lba + count) > (dev->fsa_dev[scmd_id(scsicmd)].size)) { 1752da3cc679SRajashekhara, Mahesh cid = scmd_id(scsicmd); 1753da3cc679SRajashekhara, Mahesh dprintk((KERN_DEBUG "aacraid: Illegal lba\n")); 1754da3cc679SRajashekhara, Mahesh scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 1755da3cc679SRajashekhara, Mahesh SAM_STAT_CHECK_CONDITION; 1756da3cc679SRajashekhara, Mahesh set_sense(&dev->fsa_dev[cid].sense_data, 1757da3cc679SRajashekhara, Mahesh HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 1758da3cc679SRajashekhara, Mahesh ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 1759da3cc679SRajashekhara, Mahesh memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1760da3cc679SRajashekhara, Mahesh min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 1761da3cc679SRajashekhara, Mahesh SCSI_SENSE_BUFFERSIZE)); 1762da3cc679SRajashekhara, Mahesh scsicmd->scsi_done(scsicmd); 1763da3cc679SRajashekhara, Mahesh return 1; 1764da3cc679SRajashekhara, Mahesh } 1765da3cc679SRajashekhara, Mahesh 17667a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aac_read[cpu %d]: lba = %llu, t = %ld.\n", 17677c00ffa3SMark Haverkamp smp_processor_id(), (unsigned long long)lba, jiffies)); 1768e8f32de5SMark Haverkamp if (aac_adapter_bounds(dev,scsicmd,lba)) 17697a8cf29dSMark Haverkamp return 0; 17701da177e4SLinus Torvalds /* 17711da177e4SLinus Torvalds * Alocate and initialize a Fib 17721da177e4SLinus Torvalds */ 1773bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) { 1774cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech printk(KERN_WARNING "aac_read: fib allocation failed\n"); 17751da177e4SLinus Torvalds return -1; 17761da177e4SLinus Torvalds } 17771da177e4SLinus Torvalds 1778e8f32de5SMark Haverkamp status = aac_adapter_read(cmd_fibcontext, scsicmd, lba, count); 17791da177e4SLinus Torvalds 17801da177e4SLinus Torvalds /* 17811da177e4SLinus Torvalds * Check that the command queued to the controller 17821da177e4SLinus Torvalds */ 178377d644d4SMark Haverkamp if (status == -EINPROGRESS) { 178477d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 17851da177e4SLinus Torvalds return 0; 178677d644d4SMark Haverkamp } 17871da177e4SLinus Torvalds 1788bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_read: aac_fib_send failed with status: %d.\n", status); 17891da177e4SLinus Torvalds /* 17901da177e4SLinus Torvalds * For some reason, the Fib didn't queue, return QUEUE_FULL 17911da177e4SLinus Torvalds */ 17921da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL; 17938e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 1794bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 1795bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 17961da177e4SLinus Torvalds return 0; 17971da177e4SLinus Torvalds } 17981da177e4SLinus Torvalds 17999e7c349cSMark Haverkamp static int aac_write(struct scsi_cmnd * scsicmd) 18001da177e4SLinus Torvalds { 18017a8cf29dSMark Haverkamp u64 lba; 18021da177e4SLinus Torvalds u32 count; 18039d399cc7SSalyzyn, Mark int fua; 18041da177e4SLinus Torvalds int status; 18051da177e4SLinus Torvalds struct aac_dev *dev; 18061da177e4SLinus Torvalds struct fib * cmd_fibcontext; 1807da3cc679SRajashekhara, Mahesh int cid; 18081da177e4SLinus Torvalds 18091da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 18101da177e4SLinus Torvalds /* 18111da177e4SLinus Torvalds * Get block address and transfer length 18121da177e4SLinus Torvalds */ 18131da177e4SLinus Torvalds if (scsicmd->cmnd[0] == WRITE_6) /* 6 byte command */ 18141da177e4SLinus Torvalds { 18151da177e4SLinus Torvalds lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 18161da177e4SLinus Torvalds count = scsicmd->cmnd[4]; 18171da177e4SLinus Torvalds if (count == 0) 18181da177e4SLinus Torvalds count = 256; 18199d399cc7SSalyzyn, Mark fua = 0; 18207a8cf29dSMark Haverkamp } else if (scsicmd->cmnd[0] == WRITE_16) { /* 16 byte command */ 18219e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a write(16) command on id %d.\n", scmd_id(scsicmd))); 18227a8cf29dSMark Haverkamp 18237a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 56) | 18247a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[3] << 48) | 18257a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[4] << 40) | 18267a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[5] << 32) | 18277a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[6] << 24) | 18287a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 18297a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 18307a8cf29dSMark Haverkamp count = (scsicmd->cmnd[10] << 24) | (scsicmd->cmnd[11] << 16) | 18317a8cf29dSMark Haverkamp (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13]; 18329d399cc7SSalyzyn, Mark fua = scsicmd->cmnd[1] & 0x8; 18337a8cf29dSMark Haverkamp } else if (scsicmd->cmnd[0] == WRITE_12) { /* 12 byte command */ 18349e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a write(12) command on id %d.\n", scmd_id(scsicmd))); 18357a8cf29dSMark Haverkamp 18367a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) 18377a8cf29dSMark Haverkamp | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 18387a8cf29dSMark Haverkamp count = (scsicmd->cmnd[6] << 24) | (scsicmd->cmnd[7] << 16) 18397a8cf29dSMark Haverkamp | (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 18409d399cc7SSalyzyn, Mark fua = scsicmd->cmnd[1] & 0x8; 18411da177e4SLinus Torvalds } else { 18429e7c349cSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a write(10) command on id %d.\n", scmd_id(scsicmd))); 18437a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 18441da177e4SLinus Torvalds count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 18459d399cc7SSalyzyn, Mark fua = scsicmd->cmnd[1] & 0x8; 18461da177e4SLinus Torvalds } 1847da3cc679SRajashekhara, Mahesh 1848da3cc679SRajashekhara, Mahesh if ((lba + count) > (dev->fsa_dev[scmd_id(scsicmd)].size)) { 1849da3cc679SRajashekhara, Mahesh cid = scmd_id(scsicmd); 1850da3cc679SRajashekhara, Mahesh dprintk((KERN_DEBUG "aacraid: Illegal lba\n")); 1851da3cc679SRajashekhara, Mahesh scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 1852da3cc679SRajashekhara, Mahesh SAM_STAT_CHECK_CONDITION; 1853da3cc679SRajashekhara, Mahesh set_sense(&dev->fsa_dev[cid].sense_data, 1854da3cc679SRajashekhara, Mahesh HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 1855da3cc679SRajashekhara, Mahesh ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 1856da3cc679SRajashekhara, Mahesh memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1857da3cc679SRajashekhara, Mahesh min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 1858da3cc679SRajashekhara, Mahesh SCSI_SENSE_BUFFERSIZE)); 1859da3cc679SRajashekhara, Mahesh scsicmd->scsi_done(scsicmd); 1860da3cc679SRajashekhara, Mahesh return 1; 1861da3cc679SRajashekhara, Mahesh } 1862da3cc679SRajashekhara, Mahesh 18637a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aac_write[cpu %d]: lba = %llu, t = %ld.\n", 18641da177e4SLinus Torvalds smp_processor_id(), (unsigned long long)lba, jiffies)); 1865e8f32de5SMark Haverkamp if (aac_adapter_bounds(dev,scsicmd,lba)) 18667a8cf29dSMark Haverkamp return 0; 18671da177e4SLinus Torvalds /* 18681da177e4SLinus Torvalds * Allocate and initialize a Fib then setup a BlockWrite command 18691da177e4SLinus Torvalds */ 1870bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) { 1871cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* FIB temporarily unavailable,not catastrophic failure */ 1872cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech 1873cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech /* scsicmd->result = DID_ERROR << 16; 1874cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech * scsicmd->scsi_done(scsicmd); 1875cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech * return 0; 1876cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech */ 1877cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech printk(KERN_WARNING "aac_write: fib allocation failed\n"); 1878cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech return -1; 18791da177e4SLinus Torvalds } 18801da177e4SLinus Torvalds 18819d399cc7SSalyzyn, Mark status = aac_adapter_write(cmd_fibcontext, scsicmd, lba, count, fua); 18821da177e4SLinus Torvalds 18831da177e4SLinus Torvalds /* 18841da177e4SLinus Torvalds * Check that the command queued to the controller 18851da177e4SLinus Torvalds */ 188677d644d4SMark Haverkamp if (status == -EINPROGRESS) { 188777d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 18881da177e4SLinus Torvalds return 0; 18891da177e4SLinus Torvalds } 18901da177e4SLinus Torvalds 1891bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_write: aac_fib_send failed with status: %d\n", status); 18921da177e4SLinus Torvalds /* 18931da177e4SLinus Torvalds * For some reason, the Fib didn't queue, return QUEUE_FULL 18941da177e4SLinus Torvalds */ 18951da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL; 18968e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 18971da177e4SLinus Torvalds 1898bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 1899bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 19001da177e4SLinus Torvalds return 0; 19011da177e4SLinus Torvalds } 19021da177e4SLinus Torvalds 19031da177e4SLinus Torvalds static void synchronize_callback(void *context, struct fib *fibptr) 19041da177e4SLinus Torvalds { 19051da177e4SLinus Torvalds struct aac_synchronize_reply *synchronizereply; 19061da177e4SLinus Torvalds struct scsi_cmnd *cmd; 19071da177e4SLinus Torvalds 19081da177e4SLinus Torvalds cmd = context; 19091da177e4SLinus Torvalds 191003d44337SMark Haverkamp if (!aac_valid_context(cmd, fibptr)) 191103d44337SMark Haverkamp return; 191203d44337SMark Haverkamp 19131da177e4SLinus Torvalds dprintk((KERN_DEBUG "synchronize_callback[cpu %d]: t = %ld.\n", 19141da177e4SLinus Torvalds smp_processor_id(), jiffies)); 19151da177e4SLinus Torvalds BUG_ON(fibptr == NULL); 19161da177e4SLinus Torvalds 19171da177e4SLinus Torvalds 19181da177e4SLinus Torvalds synchronizereply = fib_data(fibptr); 19191da177e4SLinus Torvalds if (le32_to_cpu(synchronizereply->status) == CT_OK) 19201da177e4SLinus Torvalds cmd->result = DID_OK << 16 | 19211da177e4SLinus Torvalds COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 19221da177e4SLinus Torvalds else { 19231da177e4SLinus Torvalds struct scsi_device *sdev = cmd->device; 19241a655040SSalyzyn, Mark struct aac_dev *dev = fibptr->dev; 1925e5718774SMark Haverkamp u32 cid = sdev_id(sdev); 19261da177e4SLinus Torvalds printk(KERN_WARNING 19271da177e4SLinus Torvalds "synchronize_callback: synchronize failed, status = %d\n", 19281da177e4SLinus Torvalds le32_to_cpu(synchronizereply->status)); 19291da177e4SLinus Torvalds cmd->result = DID_OK << 16 | 19301da177e4SLinus Torvalds COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 19318e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 19328e31e607SSalyzyn, Mark HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 19338e31e607SSalyzyn, Mark ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 19341da177e4SLinus Torvalds memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1935b80ca4f7SFUJITA Tomonori min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 1936b80ca4f7SFUJITA Tomonori SCSI_SENSE_BUFFERSIZE)); 19371da177e4SLinus Torvalds } 19381da177e4SLinus Torvalds 1939bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1940bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 19418e0c5ebdSMark Haverkamp cmd->scsi_done(cmd); 19421da177e4SLinus Torvalds } 19431da177e4SLinus Torvalds 19449e7c349cSMark Haverkamp static int aac_synchronize(struct scsi_cmnd *scsicmd) 19451da177e4SLinus Torvalds { 19461da177e4SLinus Torvalds int status; 19471da177e4SLinus Torvalds struct fib *cmd_fibcontext; 19481da177e4SLinus Torvalds struct aac_synchronize *synchronizecmd; 19491da177e4SLinus Torvalds struct scsi_cmnd *cmd; 19501da177e4SLinus Torvalds struct scsi_device *sdev = scsicmd->device; 19511da177e4SLinus Torvalds int active = 0; 195290ee3466SMark Haverkamp struct aac_dev *aac; 1953b90f90d2SSalyzyn, Mark u64 lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | 1954b90f90d2SSalyzyn, Mark (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 1955b90f90d2SSalyzyn, Mark u32 count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 19561da177e4SLinus Torvalds unsigned long flags; 19571da177e4SLinus Torvalds 19581da177e4SLinus Torvalds /* 195977d644d4SMark Haverkamp * Wait for all outstanding queued commands to complete to this 196077d644d4SMark Haverkamp * specific target (block). 19611da177e4SLinus Torvalds */ 19621da177e4SLinus Torvalds spin_lock_irqsave(&sdev->list_lock, flags); 19631da177e4SLinus Torvalds list_for_each_entry(cmd, &sdev->cmd_list, list) 1964b90f90d2SSalyzyn, Mark if (cmd->SCp.phase == AAC_OWNER_FIRMWARE) { 1965b90f90d2SSalyzyn, Mark u64 cmnd_lba; 1966b90f90d2SSalyzyn, Mark u32 cmnd_count; 1967b90f90d2SSalyzyn, Mark 1968b90f90d2SSalyzyn, Mark if (cmd->cmnd[0] == WRITE_6) { 1969b90f90d2SSalyzyn, Mark cmnd_lba = ((cmd->cmnd[1] & 0x1F) << 16) | 1970b90f90d2SSalyzyn, Mark (cmd->cmnd[2] << 8) | 1971b90f90d2SSalyzyn, Mark cmd->cmnd[3]; 1972b90f90d2SSalyzyn, Mark cmnd_count = cmd->cmnd[4]; 1973b90f90d2SSalyzyn, Mark if (cmnd_count == 0) 1974b90f90d2SSalyzyn, Mark cmnd_count = 256; 1975b90f90d2SSalyzyn, Mark } else if (cmd->cmnd[0] == WRITE_16) { 1976b90f90d2SSalyzyn, Mark cmnd_lba = ((u64)cmd->cmnd[2] << 56) | 1977b90f90d2SSalyzyn, Mark ((u64)cmd->cmnd[3] << 48) | 1978b90f90d2SSalyzyn, Mark ((u64)cmd->cmnd[4] << 40) | 1979b90f90d2SSalyzyn, Mark ((u64)cmd->cmnd[5] << 32) | 1980b90f90d2SSalyzyn, Mark ((u64)cmd->cmnd[6] << 24) | 1981b90f90d2SSalyzyn, Mark (cmd->cmnd[7] << 16) | 1982b90f90d2SSalyzyn, Mark (cmd->cmnd[8] << 8) | 1983b90f90d2SSalyzyn, Mark cmd->cmnd[9]; 1984b90f90d2SSalyzyn, Mark cmnd_count = (cmd->cmnd[10] << 24) | 1985b90f90d2SSalyzyn, Mark (cmd->cmnd[11] << 16) | 1986b90f90d2SSalyzyn, Mark (cmd->cmnd[12] << 8) | 1987b90f90d2SSalyzyn, Mark cmd->cmnd[13]; 1988b90f90d2SSalyzyn, Mark } else if (cmd->cmnd[0] == WRITE_12) { 1989b90f90d2SSalyzyn, Mark cmnd_lba = ((u64)cmd->cmnd[2] << 24) | 1990b90f90d2SSalyzyn, Mark (cmd->cmnd[3] << 16) | 1991b90f90d2SSalyzyn, Mark (cmd->cmnd[4] << 8) | 1992b90f90d2SSalyzyn, Mark cmd->cmnd[5]; 1993b90f90d2SSalyzyn, Mark cmnd_count = (cmd->cmnd[6] << 24) | 1994b90f90d2SSalyzyn, Mark (cmd->cmnd[7] << 16) | 1995b90f90d2SSalyzyn, Mark (cmd->cmnd[8] << 8) | 1996b90f90d2SSalyzyn, Mark cmd->cmnd[9]; 1997b90f90d2SSalyzyn, Mark } else if (cmd->cmnd[0] == WRITE_10) { 1998b90f90d2SSalyzyn, Mark cmnd_lba = ((u64)cmd->cmnd[2] << 24) | 1999b90f90d2SSalyzyn, Mark (cmd->cmnd[3] << 16) | 2000b90f90d2SSalyzyn, Mark (cmd->cmnd[4] << 8) | 2001b90f90d2SSalyzyn, Mark cmd->cmnd[5]; 2002b90f90d2SSalyzyn, Mark cmnd_count = (cmd->cmnd[7] << 8) | 2003b90f90d2SSalyzyn, Mark cmd->cmnd[8]; 2004b90f90d2SSalyzyn, Mark } else 2005b90f90d2SSalyzyn, Mark continue; 2006b90f90d2SSalyzyn, Mark if (((cmnd_lba + cmnd_count) < lba) || 2007b90f90d2SSalyzyn, Mark (count && ((lba + count) < cmnd_lba))) 2008b90f90d2SSalyzyn, Mark continue; 20091da177e4SLinus Torvalds ++active; 20101da177e4SLinus Torvalds break; 20111da177e4SLinus Torvalds } 20121da177e4SLinus Torvalds 20131da177e4SLinus Torvalds spin_unlock_irqrestore(&sdev->list_lock, flags); 20141da177e4SLinus Torvalds 20151da177e4SLinus Torvalds /* 20161da177e4SLinus Torvalds * Yield the processor (requeue for later) 20171da177e4SLinus Torvalds */ 20181da177e4SLinus Torvalds if (active) 20191da177e4SLinus Torvalds return SCSI_MLQUEUE_DEVICE_BUSY; 20201da177e4SLinus Torvalds 2021f858317dSSalyzyn, Mark aac = (struct aac_dev *)sdev->host->hostdata; 20228c867b25SMark Haverkamp if (aac->in_reset) 20238c867b25SMark Haverkamp return SCSI_MLQUEUE_HOST_BUSY; 20248c867b25SMark Haverkamp 20251da177e4SLinus Torvalds /* 20267c00ffa3SMark Haverkamp * Allocate and initialize a Fib 20271da177e4SLinus Torvalds */ 202890ee3466SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(aac))) 20291da177e4SLinus Torvalds return SCSI_MLQUEUE_HOST_BUSY; 20301da177e4SLinus Torvalds 2031bfb35aa8SMark Haverkamp aac_fib_init(cmd_fibcontext); 20321da177e4SLinus Torvalds 20331da177e4SLinus Torvalds synchronizecmd = fib_data(cmd_fibcontext); 20341da177e4SLinus Torvalds synchronizecmd->command = cpu_to_le32(VM_ContainerConfig); 20351da177e4SLinus Torvalds synchronizecmd->type = cpu_to_le32(CT_FLUSH_CACHE); 20369e7c349cSMark Haverkamp synchronizecmd->cid = cpu_to_le32(scmd_id(scsicmd)); 20371da177e4SLinus Torvalds synchronizecmd->count = 20381da177e4SLinus Torvalds cpu_to_le32(sizeof(((struct aac_synchronize_reply *)NULL)->data)); 20391da177e4SLinus Torvalds 20401da177e4SLinus Torvalds /* 20411da177e4SLinus Torvalds * Now send the Fib to the adapter 20421da177e4SLinus Torvalds */ 2043bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 20441da177e4SLinus Torvalds cmd_fibcontext, 20451da177e4SLinus Torvalds sizeof(struct aac_synchronize), 20461da177e4SLinus Torvalds FsaNormal, 20471da177e4SLinus Torvalds 0, 1, 20481da177e4SLinus Torvalds (fib_callback)synchronize_callback, 20491da177e4SLinus Torvalds (void *)scsicmd); 20501da177e4SLinus Torvalds 20511da177e4SLinus Torvalds /* 20521da177e4SLinus Torvalds * Check that the command queued to the controller 20531da177e4SLinus Torvalds */ 205477d644d4SMark Haverkamp if (status == -EINPROGRESS) { 205577d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 20561da177e4SLinus Torvalds return 0; 205777d644d4SMark Haverkamp } 20581da177e4SLinus Torvalds 20591da177e4SLinus Torvalds printk(KERN_WARNING 2060bfb35aa8SMark Haverkamp "aac_synchronize: aac_fib_send failed with status: %d.\n", status); 2061bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 2062bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 20631da177e4SLinus Torvalds return SCSI_MLQUEUE_HOST_BUSY; 20641da177e4SLinus Torvalds } 20651da177e4SLinus Torvalds 2066655d722cSMark Salyzyn static void aac_start_stop_callback(void *context, struct fib *fibptr) 2067655d722cSMark Salyzyn { 2068655d722cSMark Salyzyn struct scsi_cmnd *scsicmd = context; 2069655d722cSMark Salyzyn 2070655d722cSMark Salyzyn if (!aac_valid_context(scsicmd, fibptr)) 2071655d722cSMark Salyzyn return; 2072655d722cSMark Salyzyn 2073655d722cSMark Salyzyn BUG_ON(fibptr == NULL); 2074655d722cSMark Salyzyn 2075655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 2076655d722cSMark Salyzyn 2077655d722cSMark Salyzyn aac_fib_complete(fibptr); 2078655d722cSMark Salyzyn aac_fib_free(fibptr); 2079655d722cSMark Salyzyn scsicmd->scsi_done(scsicmd); 2080655d722cSMark Salyzyn } 2081655d722cSMark Salyzyn 2082655d722cSMark Salyzyn static int aac_start_stop(struct scsi_cmnd *scsicmd) 2083655d722cSMark Salyzyn { 2084655d722cSMark Salyzyn int status; 2085655d722cSMark Salyzyn struct fib *cmd_fibcontext; 2086655d722cSMark Salyzyn struct aac_power_management *pmcmd; 2087655d722cSMark Salyzyn struct scsi_device *sdev = scsicmd->device; 2088655d722cSMark Salyzyn struct aac_dev *aac = (struct aac_dev *)sdev->host->hostdata; 2089655d722cSMark Salyzyn 2090655d722cSMark Salyzyn if (!(aac->supplement_adapter_info.SupportedOptions2 & 2091655d722cSMark Salyzyn AAC_OPTION_POWER_MANAGEMENT)) { 2092655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 2093655d722cSMark Salyzyn SAM_STAT_GOOD; 2094655d722cSMark Salyzyn scsicmd->scsi_done(scsicmd); 2095655d722cSMark Salyzyn return 0; 2096655d722cSMark Salyzyn } 2097655d722cSMark Salyzyn 2098655d722cSMark Salyzyn if (aac->in_reset) 2099655d722cSMark Salyzyn return SCSI_MLQUEUE_HOST_BUSY; 2100655d722cSMark Salyzyn 2101655d722cSMark Salyzyn /* 2102655d722cSMark Salyzyn * Allocate and initialize a Fib 2103655d722cSMark Salyzyn */ 2104655d722cSMark Salyzyn cmd_fibcontext = aac_fib_alloc(aac); 2105655d722cSMark Salyzyn if (!cmd_fibcontext) 2106655d722cSMark Salyzyn return SCSI_MLQUEUE_HOST_BUSY; 2107655d722cSMark Salyzyn 2108655d722cSMark Salyzyn aac_fib_init(cmd_fibcontext); 2109655d722cSMark Salyzyn 2110655d722cSMark Salyzyn pmcmd = fib_data(cmd_fibcontext); 2111655d722cSMark Salyzyn pmcmd->command = cpu_to_le32(VM_ContainerConfig); 2112655d722cSMark Salyzyn pmcmd->type = cpu_to_le32(CT_POWER_MANAGEMENT); 2113655d722cSMark Salyzyn /* Eject bit ignored, not relevant */ 2114655d722cSMark Salyzyn pmcmd->sub = (scsicmd->cmnd[4] & 1) ? 2115655d722cSMark Salyzyn cpu_to_le32(CT_PM_START_UNIT) : cpu_to_le32(CT_PM_STOP_UNIT); 2116655d722cSMark Salyzyn pmcmd->cid = cpu_to_le32(sdev_id(sdev)); 2117655d722cSMark Salyzyn pmcmd->parm = (scsicmd->cmnd[1] & 1) ? 2118655d722cSMark Salyzyn cpu_to_le32(CT_PM_UNIT_IMMEDIATE) : 0; 2119655d722cSMark Salyzyn 2120655d722cSMark Salyzyn /* 2121655d722cSMark Salyzyn * Now send the Fib to the adapter 2122655d722cSMark Salyzyn */ 2123655d722cSMark Salyzyn status = aac_fib_send(ContainerCommand, 2124655d722cSMark Salyzyn cmd_fibcontext, 2125655d722cSMark Salyzyn sizeof(struct aac_power_management), 2126655d722cSMark Salyzyn FsaNormal, 2127655d722cSMark Salyzyn 0, 1, 2128655d722cSMark Salyzyn (fib_callback)aac_start_stop_callback, 2129655d722cSMark Salyzyn (void *)scsicmd); 2130655d722cSMark Salyzyn 2131655d722cSMark Salyzyn /* 2132655d722cSMark Salyzyn * Check that the command queued to the controller 2133655d722cSMark Salyzyn */ 2134655d722cSMark Salyzyn if (status == -EINPROGRESS) { 2135655d722cSMark Salyzyn scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 2136655d722cSMark Salyzyn return 0; 2137655d722cSMark Salyzyn } 2138655d722cSMark Salyzyn 2139655d722cSMark Salyzyn aac_fib_complete(cmd_fibcontext); 2140655d722cSMark Salyzyn aac_fib_free(cmd_fibcontext); 2141655d722cSMark Salyzyn return SCSI_MLQUEUE_HOST_BUSY; 2142655d722cSMark Salyzyn } 2143655d722cSMark Salyzyn 21441da177e4SLinus Torvalds /** 21451da177e4SLinus Torvalds * aac_scsi_cmd() - Process SCSI command 21461da177e4SLinus Torvalds * @scsicmd: SCSI command block 21471da177e4SLinus Torvalds * 21481da177e4SLinus Torvalds * Emulate a SCSI command and queue the required request for the 21491da177e4SLinus Torvalds * aacraid firmware. 21501da177e4SLinus Torvalds */ 21511da177e4SLinus Torvalds 21521da177e4SLinus Torvalds int aac_scsi_cmd(struct scsi_cmnd * scsicmd) 21531da177e4SLinus Torvalds { 21541a655040SSalyzyn, Mark u32 cid; 21551da177e4SLinus Torvalds struct Scsi_Host *host = scsicmd->device->host; 21561da177e4SLinus Torvalds struct aac_dev *dev = (struct aac_dev *)host->hostdata; 21571da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr = dev->fsa_dev; 21581da177e4SLinus Torvalds 215990ee3466SMark Haverkamp if (fsa_dev_ptr == NULL) 216090ee3466SMark Haverkamp return -1; 21611da177e4SLinus Torvalds /* 21621da177e4SLinus Torvalds * If the bus, id or lun is out of range, return fail 21631da177e4SLinus Torvalds * Test does not apply to ID 16, the pseudo id for the controller 21641da177e4SLinus Torvalds * itself. 21651da177e4SLinus Torvalds */ 21661a655040SSalyzyn, Mark cid = scmd_id(scsicmd); 21671a655040SSalyzyn, Mark if (cid != host->this_id) { 21681a655040SSalyzyn, Mark if (scmd_channel(scsicmd) == CONTAINER_CHANNEL) { 21691a655040SSalyzyn, Mark if((cid >= dev->maximum_num_containers) || 2170e5718774SMark Haverkamp (scsicmd->device->lun != 0)) { 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 * If the target container doesn't exist, it may have 21781da177e4SLinus Torvalds * been newly created 21791da177e4SLinus Torvalds */ 2180655d722cSMark Salyzyn if (((fsa_dev_ptr[cid].valid & 1) == 0) || 2181655d722cSMark Salyzyn (fsa_dev_ptr[cid].sense_data.sense_key == 2182655d722cSMark Salyzyn NOT_READY)) { 21831da177e4SLinus Torvalds switch (scsicmd->cmnd[0]) { 21847a8cf29dSMark Haverkamp case SERVICE_ACTION_IN: 21857a8cf29dSMark Haverkamp if (!(dev->raw_io_interface) || 21867a8cf29dSMark Haverkamp !(dev->raw_io_64) || 21877a8cf29dSMark Haverkamp ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16)) 21887a8cf29dSMark Haverkamp break; 21891da177e4SLinus Torvalds case INQUIRY: 21901da177e4SLinus Torvalds case READ_CAPACITY: 21911da177e4SLinus Torvalds case TEST_UNIT_READY: 21928c867b25SMark Haverkamp if (dev->in_reset) 21938c867b25SMark Haverkamp return -1; 2194fe76df42SMark Haverkamp return _aac_probe_container(scsicmd, 2195fe76df42SMark Haverkamp aac_probe_container_callback2); 21961da177e4SLinus Torvalds default: 21971da177e4SLinus Torvalds break; 21981da177e4SLinus Torvalds } 21991da177e4SLinus Torvalds } 22001da177e4SLinus Torvalds } else { /* check for physical non-dasd devices */ 2201cb1042f2SSalyzyn, Mark if (dev->nondasd_support || expose_physicals || 2202cb1042f2SSalyzyn, Mark dev->jbod) { 22038c867b25SMark Haverkamp if (dev->in_reset) 22048c867b25SMark Haverkamp return -1; 22051da177e4SLinus Torvalds return aac_send_srb_fib(scsicmd); 22061da177e4SLinus Torvalds } else { 22071da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16; 22081da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 22091da177e4SLinus Torvalds return 0; 22101da177e4SLinus Torvalds } 22111da177e4SLinus Torvalds } 22121da177e4SLinus Torvalds } 22131da177e4SLinus Torvalds /* 22141da177e4SLinus Torvalds * else Command for the controller itself 22151da177e4SLinus Torvalds */ 22161da177e4SLinus Torvalds else if ((scsicmd->cmnd[0] != INQUIRY) && /* only INQUIRY & TUR cmnd supported for controller */ 22171da177e4SLinus Torvalds (scsicmd->cmnd[0] != TEST_UNIT_READY)) 22181da177e4SLinus Torvalds { 22191da177e4SLinus Torvalds dprintk((KERN_WARNING "Only INQUIRY & TUR command supported for controller, rcvd = 0x%x.\n", scsicmd->cmnd[0])); 22201da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 22218e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 22228e31e607SSalyzyn, Mark ILLEGAL_REQUEST, SENCODE_INVALID_COMMAND, 22238e31e607SSalyzyn, Mark ASENCODE_INVALID_COMMAND, 0, 0); 22241da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 22253ace426fSSalyzyn, Mark min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 22263ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE)); 22271da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 22281da177e4SLinus Torvalds return 0; 22291da177e4SLinus Torvalds } 22301da177e4SLinus Torvalds 22311da177e4SLinus Torvalds 22321da177e4SLinus Torvalds /* Handle commands here that don't really require going out to the adapter */ 22331da177e4SLinus Torvalds switch (scsicmd->cmnd[0]) { 22341da177e4SLinus Torvalds case INQUIRY: 22351da177e4SLinus Torvalds { 22363b2946ccSMark Haverkamp struct inquiry_data inq_data; 22371da177e4SLinus Torvalds 22381a655040SSalyzyn, Mark dprintk((KERN_DEBUG "INQUIRY command, ID: %d.\n", cid)); 22393b2946ccSMark Haverkamp memset(&inq_data, 0, sizeof (struct inquiry_data)); 22401da177e4SLinus Torvalds 2241d8e96507SLeubner, Achim if ((scsicmd->cmnd[1] & 0x1) && aac_wwn) { 224288e2f98eSSalyzyn, Mark char *arr = (char *)&inq_data; 224388e2f98eSSalyzyn, Mark 224488e2f98eSSalyzyn, Mark /* EVPD bit set */ 224588e2f98eSSalyzyn, Mark arr[0] = (scmd_id(scsicmd) == host->this_id) ? 224688e2f98eSSalyzyn, Mark INQD_PDT_PROC : INQD_PDT_DA; 224788e2f98eSSalyzyn, Mark if (scsicmd->cmnd[2] == 0) { 224888e2f98eSSalyzyn, Mark /* supported vital product data pages */ 224988e2f98eSSalyzyn, Mark arr[3] = 2; 225088e2f98eSSalyzyn, Mark arr[4] = 0x0; 225188e2f98eSSalyzyn, Mark arr[5] = 0x80; 225288e2f98eSSalyzyn, Mark arr[1] = scsicmd->cmnd[2]; 2253d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, &inq_data, 225488e2f98eSSalyzyn, Mark sizeof(inq_data)); 225588e2f98eSSalyzyn, Mark scsicmd->result = DID_OK << 16 | 225688e2f98eSSalyzyn, Mark COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 225788e2f98eSSalyzyn, Mark } else if (scsicmd->cmnd[2] == 0x80) { 225888e2f98eSSalyzyn, Mark /* unit serial number page */ 225988e2f98eSSalyzyn, Mark arr[3] = setinqserial(dev, &arr[4], 226088e2f98eSSalyzyn, Mark scmd_id(scsicmd)); 226188e2f98eSSalyzyn, Mark arr[1] = scsicmd->cmnd[2]; 2262d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, &inq_data, 226388e2f98eSSalyzyn, Mark sizeof(inq_data)); 2264d8e96507SLeubner, Achim if (aac_wwn != 2) 2265d8e96507SLeubner, Achim return aac_get_container_serial( 2266d8e96507SLeubner, Achim scsicmd); 2267d8e96507SLeubner, Achim /* SLES 10 SP1 special */ 2268d8e96507SLeubner, Achim scsicmd->result = DID_OK << 16 | 2269d8e96507SLeubner, Achim COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 227088e2f98eSSalyzyn, Mark } else { 227188e2f98eSSalyzyn, Mark /* vpd page not implemented */ 227288e2f98eSSalyzyn, Mark scsicmd->result = DID_OK << 16 | 227388e2f98eSSalyzyn, Mark COMMAND_COMPLETE << 8 | 227488e2f98eSSalyzyn, Mark SAM_STAT_CHECK_CONDITION; 22758e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 22768e31e607SSalyzyn, Mark ILLEGAL_REQUEST, SENCODE_INVALID_CDB_FIELD, 22778e31e607SSalyzyn, Mark ASENCODE_NO_SENSE, 7, 2); 227888e2f98eSSalyzyn, Mark memcpy(scsicmd->sense_buffer, 227988e2f98eSSalyzyn, Mark &dev->fsa_dev[cid].sense_data, 22803ace426fSSalyzyn, Mark min_t(size_t, 22813ace426fSSalyzyn, Mark sizeof(dev->fsa_dev[cid].sense_data), 22823ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE)); 228388e2f98eSSalyzyn, Mark } 228488e2f98eSSalyzyn, Mark scsicmd->scsi_done(scsicmd); 228588e2f98eSSalyzyn, Mark return 0; 228688e2f98eSSalyzyn, Mark } 22873b2946ccSMark Haverkamp inq_data.inqd_ver = 2; /* claim compliance to SCSI-2 */ 22883b2946ccSMark 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 */ 22893b2946ccSMark Haverkamp inq_data.inqd_len = 31; 22901da177e4SLinus Torvalds /*Format for "pad2" is RelAdr | WBus32 | WBus16 | Sync | Linked |Reserved| CmdQue | SftRe */ 22913b2946ccSMark Haverkamp inq_data.inqd_pad2= 0x32 ; /*WBus16|Sync|CmdQue */ 22921da177e4SLinus Torvalds /* 22931da177e4SLinus Torvalds * Set the Vendor, Product, and Revision Level 22941da177e4SLinus Torvalds * see: <vendor>.c i.e. aac.c 22951da177e4SLinus Torvalds */ 22961a655040SSalyzyn, Mark if (cid == host->this_id) { 22976391a113STobias Klauser setinqstr(dev, (void *) (inq_data.inqd_vid), ARRAY_SIZE(container_types)); 22983b2946ccSMark Haverkamp inq_data.inqd_pdt = INQD_PDT_PROC; /* Processor device */ 2299d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, &inq_data, 2300d4345028SFUJITA Tomonori sizeof(inq_data)); 23011da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 23021da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 23031da177e4SLinus Torvalds return 0; 23041da177e4SLinus Torvalds } 23058c867b25SMark Haverkamp if (dev->in_reset) 23068c867b25SMark Haverkamp return -1; 2307794d0601SMark Haverkamp setinqstr(dev, (void *) (inq_data.inqd_vid), fsa_dev_ptr[cid].type); 23083b2946ccSMark Haverkamp inq_data.inqd_pdt = INQD_PDT_DA; /* Direct/random access device */ 2309d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, &inq_data, sizeof(inq_data)); 23109e7c349cSMark Haverkamp return aac_get_container_name(scsicmd); 23111da177e4SLinus Torvalds } 23127a8cf29dSMark Haverkamp case SERVICE_ACTION_IN: 23137a8cf29dSMark Haverkamp if (!(dev->raw_io_interface) || 23147a8cf29dSMark Haverkamp !(dev->raw_io_64) || 23157a8cf29dSMark Haverkamp ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16)) 23167a8cf29dSMark Haverkamp break; 23177a8cf29dSMark Haverkamp { 23187a8cf29dSMark Haverkamp u64 capacity; 231907ce5ebaSMark Haverkamp char cp[13]; 2320b271f1c8SFUJITA Tomonori unsigned int alloc_len; 23217a8cf29dSMark Haverkamp 23227a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "READ CAPACITY_16 command.\n")); 23237a8cf29dSMark Haverkamp capacity = fsa_dev_ptr[cid].size - 1; 23247a8cf29dSMark Haverkamp cp[0] = (capacity >> 56) & 0xff; 23257a8cf29dSMark Haverkamp cp[1] = (capacity >> 48) & 0xff; 23267a8cf29dSMark Haverkamp cp[2] = (capacity >> 40) & 0xff; 23277a8cf29dSMark Haverkamp cp[3] = (capacity >> 32) & 0xff; 23287a8cf29dSMark Haverkamp cp[4] = (capacity >> 24) & 0xff; 23297a8cf29dSMark Haverkamp cp[5] = (capacity >> 16) & 0xff; 23307a8cf29dSMark Haverkamp cp[6] = (capacity >> 8) & 0xff; 23317a8cf29dSMark Haverkamp cp[7] = (capacity >> 0) & 0xff; 23327a8cf29dSMark Haverkamp cp[8] = 0; 23337a8cf29dSMark Haverkamp cp[9] = 0; 23347a8cf29dSMark Haverkamp cp[10] = 2; 23357a8cf29dSMark Haverkamp cp[11] = 0; 233607ce5ebaSMark Haverkamp cp[12] = 0; 233707ce5ebaSMark Haverkamp 2338b271f1c8SFUJITA Tomonori alloc_len = ((scsicmd->cmnd[10] << 24) 2339b271f1c8SFUJITA Tomonori + (scsicmd->cmnd[11] << 16) 2340b271f1c8SFUJITA Tomonori + (scsicmd->cmnd[12] << 8) + scsicmd->cmnd[13]); 2341b271f1c8SFUJITA Tomonori 2342b271f1c8SFUJITA Tomonori alloc_len = min_t(size_t, alloc_len, sizeof(cp)); 2343d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, cp, alloc_len); 2344b271f1c8SFUJITA Tomonori if (alloc_len < scsi_bufflen(scsicmd)) 2345b271f1c8SFUJITA Tomonori scsi_set_resid(scsicmd, 2346b271f1c8SFUJITA Tomonori scsi_bufflen(scsicmd) - alloc_len); 23477a8cf29dSMark Haverkamp 23487a8cf29dSMark Haverkamp /* Do not cache partition table for arrays */ 23497a8cf29dSMark Haverkamp scsicmd->device->removable = 1; 23507a8cf29dSMark Haverkamp 23517a8cf29dSMark Haverkamp scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 23527a8cf29dSMark Haverkamp scsicmd->scsi_done(scsicmd); 23537a8cf29dSMark Haverkamp 23547a8cf29dSMark Haverkamp return 0; 23557a8cf29dSMark Haverkamp } 23567a8cf29dSMark Haverkamp 23571da177e4SLinus Torvalds case READ_CAPACITY: 23581da177e4SLinus Torvalds { 23591da177e4SLinus Torvalds u32 capacity; 23603b2946ccSMark Haverkamp char cp[8]; 23611da177e4SLinus Torvalds 23621da177e4SLinus Torvalds dprintk((KERN_DEBUG "READ CAPACITY command.\n")); 23637a8cf29dSMark Haverkamp if (fsa_dev_ptr[cid].size <= 0x100000000ULL) 23641da177e4SLinus Torvalds capacity = fsa_dev_ptr[cid].size - 1; 23651da177e4SLinus Torvalds else 23661da177e4SLinus Torvalds capacity = (u32)-1; 23673b2946ccSMark Haverkamp 23681da177e4SLinus Torvalds cp[0] = (capacity >> 24) & 0xff; 23691da177e4SLinus Torvalds cp[1] = (capacity >> 16) & 0xff; 23701da177e4SLinus Torvalds cp[2] = (capacity >> 8) & 0xff; 23711da177e4SLinus Torvalds cp[3] = (capacity >> 0) & 0xff; 23721da177e4SLinus Torvalds cp[4] = 0; 23731da177e4SLinus Torvalds cp[5] = 0; 23741da177e4SLinus Torvalds cp[6] = 2; 23751da177e4SLinus Torvalds cp[7] = 0; 2376d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, cp, sizeof(cp)); 23777a8cf29dSMark Haverkamp /* Do not cache partition table for arrays */ 23787a8cf29dSMark Haverkamp scsicmd->device->removable = 1; 2379655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 2380655d722cSMark Salyzyn SAM_STAT_GOOD; 23811da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 23821da177e4SLinus Torvalds 23831da177e4SLinus Torvalds return 0; 23841da177e4SLinus Torvalds } 23851da177e4SLinus Torvalds 23861da177e4SLinus Torvalds case MODE_SENSE: 23871da177e4SLinus Torvalds { 23889d399cc7SSalyzyn, Mark char mode_buf[7]; 23899d399cc7SSalyzyn, Mark int mode_buf_length = 4; 23901da177e4SLinus Torvalds 23911da177e4SLinus Torvalds dprintk((KERN_DEBUG "MODE SENSE command.\n")); 23921da177e4SLinus Torvalds mode_buf[0] = 3; /* Mode data length */ 23931da177e4SLinus Torvalds mode_buf[1] = 0; /* Medium type - default */ 23949d399cc7SSalyzyn, Mark mode_buf[2] = 0; /* Device-specific param, 23959d399cc7SSalyzyn, Mark bit 8: 0/1 = write enabled/protected 23969d399cc7SSalyzyn, Mark bit 4: 0/1 = FUA enabled */ 239795e852e1SSalyzyn, Mark if (dev->raw_io_interface && ((aac_cache & 5) != 1)) 23989d399cc7SSalyzyn, Mark mode_buf[2] = 0x10; 23991da177e4SLinus Torvalds mode_buf[3] = 0; /* Block descriptor length */ 24009d399cc7SSalyzyn, Mark if (((scsicmd->cmnd[2] & 0x3f) == 8) || 24019d399cc7SSalyzyn, Mark ((scsicmd->cmnd[2] & 0x3f) == 0x3f)) { 24029d399cc7SSalyzyn, Mark mode_buf[0] = 6; 24039d399cc7SSalyzyn, Mark mode_buf[4] = 8; 24049d399cc7SSalyzyn, Mark mode_buf[5] = 1; 240595e852e1SSalyzyn, Mark mode_buf[6] = ((aac_cache & 6) == 2) 240695e852e1SSalyzyn, Mark ? 0 : 0x04; /* WCE */ 24079d399cc7SSalyzyn, Mark mode_buf_length = 7; 24089d399cc7SSalyzyn, Mark if (mode_buf_length > scsicmd->cmnd[4]) 24099d399cc7SSalyzyn, Mark mode_buf_length = scsicmd->cmnd[4]; 24109d399cc7SSalyzyn, Mark } 2411d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, mode_buf, mode_buf_length); 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 MODE_SENSE_10: 24181da177e4SLinus Torvalds { 24199d399cc7SSalyzyn, Mark char mode_buf[11]; 24209d399cc7SSalyzyn, Mark int mode_buf_length = 8; 24211da177e4SLinus Torvalds 24221da177e4SLinus Torvalds dprintk((KERN_DEBUG "MODE SENSE 10 byte command.\n")); 24231da177e4SLinus Torvalds mode_buf[0] = 0; /* Mode data length (MSB) */ 24241da177e4SLinus Torvalds mode_buf[1] = 6; /* Mode data length (LSB) */ 24251da177e4SLinus Torvalds mode_buf[2] = 0; /* Medium type - default */ 24269d399cc7SSalyzyn, Mark mode_buf[3] = 0; /* Device-specific param, 24279d399cc7SSalyzyn, Mark bit 8: 0/1 = write enabled/protected 24289d399cc7SSalyzyn, Mark bit 4: 0/1 = FUA enabled */ 242995e852e1SSalyzyn, Mark if (dev->raw_io_interface && ((aac_cache & 5) != 1)) 24309d399cc7SSalyzyn, Mark mode_buf[3] = 0x10; 24311da177e4SLinus Torvalds mode_buf[4] = 0; /* reserved */ 24321da177e4SLinus Torvalds mode_buf[5] = 0; /* reserved */ 24331da177e4SLinus Torvalds mode_buf[6] = 0; /* Block descriptor length (MSB) */ 24341da177e4SLinus Torvalds mode_buf[7] = 0; /* Block descriptor length (LSB) */ 24359d399cc7SSalyzyn, Mark if (((scsicmd->cmnd[2] & 0x3f) == 8) || 24369d399cc7SSalyzyn, Mark ((scsicmd->cmnd[2] & 0x3f) == 0x3f)) { 24379d399cc7SSalyzyn, Mark mode_buf[1] = 9; 24389d399cc7SSalyzyn, Mark mode_buf[8] = 8; 24399d399cc7SSalyzyn, Mark mode_buf[9] = 1; 244095e852e1SSalyzyn, Mark mode_buf[10] = ((aac_cache & 6) == 2) 244195e852e1SSalyzyn, Mark ? 0 : 0x04; /* WCE */ 24429d399cc7SSalyzyn, Mark mode_buf_length = 11; 24439d399cc7SSalyzyn, Mark if (mode_buf_length > scsicmd->cmnd[8]) 24449d399cc7SSalyzyn, Mark mode_buf_length = scsicmd->cmnd[8]; 24459d399cc7SSalyzyn, Mark } 2446d4345028SFUJITA Tomonori scsi_sg_copy_from_buffer(scsicmd, mode_buf, mode_buf_length); 24471da177e4SLinus Torvalds 24481da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 24491da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 24501da177e4SLinus Torvalds 24511da177e4SLinus Torvalds return 0; 24521da177e4SLinus Torvalds } 24531da177e4SLinus Torvalds case REQUEST_SENSE: 24541da177e4SLinus Torvalds dprintk((KERN_DEBUG "REQUEST SENSE command.\n")); 24551da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, sizeof (struct sense_data)); 24561da177e4SLinus Torvalds memset(&dev->fsa_dev[cid].sense_data, 0, sizeof (struct sense_data)); 24571da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 24581da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 24591da177e4SLinus Torvalds return 0; 24601da177e4SLinus Torvalds 24611da177e4SLinus Torvalds case ALLOW_MEDIUM_REMOVAL: 24621da177e4SLinus Torvalds dprintk((KERN_DEBUG "LOCK command.\n")); 24631da177e4SLinus Torvalds if (scsicmd->cmnd[4]) 24641da177e4SLinus Torvalds fsa_dev_ptr[cid].locked = 1; 24651da177e4SLinus Torvalds else 24661da177e4SLinus Torvalds fsa_dev_ptr[cid].locked = 0; 24671da177e4SLinus Torvalds 24681da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 24691da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 24701da177e4SLinus Torvalds return 0; 24711da177e4SLinus Torvalds /* 24721da177e4SLinus Torvalds * These commands are all No-Ops 24731da177e4SLinus Torvalds */ 24741da177e4SLinus Torvalds case TEST_UNIT_READY: 2475655d722cSMark Salyzyn if (fsa_dev_ptr[cid].sense_data.sense_key == NOT_READY) { 2476655d722cSMark Salyzyn scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 2477655d722cSMark Salyzyn SAM_STAT_CHECK_CONDITION; 2478655d722cSMark Salyzyn set_sense(&dev->fsa_dev[cid].sense_data, 2479655d722cSMark Salyzyn NOT_READY, SENCODE_BECOMING_READY, 2480655d722cSMark Salyzyn ASENCODE_BECOMING_READY, 0, 0); 2481655d722cSMark Salyzyn memcpy(scsicmd->sense_buffer, 2482655d722cSMark Salyzyn &dev->fsa_dev[cid].sense_data, 2483655d722cSMark Salyzyn min_t(size_t, 2484655d722cSMark Salyzyn sizeof(dev->fsa_dev[cid].sense_data), 2485655d722cSMark Salyzyn SCSI_SENSE_BUFFERSIZE)); 2486655d722cSMark Salyzyn scsicmd->scsi_done(scsicmd); 2487655d722cSMark Salyzyn return 0; 2488655d722cSMark Salyzyn } 2489655d722cSMark Salyzyn /* FALLTHRU */ 24901da177e4SLinus Torvalds case RESERVE: 24911da177e4SLinus Torvalds case RELEASE: 24921da177e4SLinus Torvalds case REZERO_UNIT: 24931da177e4SLinus Torvalds case REASSIGN_BLOCKS: 24941da177e4SLinus Torvalds case SEEK_10: 24951da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 24961da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 24971da177e4SLinus Torvalds return 0; 2498655d722cSMark Salyzyn 2499655d722cSMark Salyzyn case START_STOP: 2500655d722cSMark Salyzyn return aac_start_stop(scsicmd); 25011da177e4SLinus Torvalds } 25021da177e4SLinus Torvalds 25031da177e4SLinus Torvalds switch (scsicmd->cmnd[0]) 25041da177e4SLinus Torvalds { 25051da177e4SLinus Torvalds case READ_6: 25061da177e4SLinus Torvalds case READ_10: 25077a8cf29dSMark Haverkamp case READ_12: 25087a8cf29dSMark Haverkamp case READ_16: 25098c867b25SMark Haverkamp if (dev->in_reset) 25108c867b25SMark Haverkamp return -1; 25111da177e4SLinus Torvalds /* 25121da177e4SLinus Torvalds * Hack to keep track of ordinal number of the device that 25131da177e4SLinus Torvalds * corresponds to a container. Needed to convert 25141da177e4SLinus Torvalds * containers to /dev/sd device names 25151da177e4SLinus Torvalds */ 25161da177e4SLinus Torvalds 25171da177e4SLinus Torvalds if (scsicmd->request->rq_disk) 25187a8cf29dSMark Haverkamp strlcpy(fsa_dev_ptr[cid].devname, 25191da177e4SLinus Torvalds scsicmd->request->rq_disk->disk_name, 25207a8cf29dSMark Haverkamp min(sizeof(fsa_dev_ptr[cid].devname), 25217a8cf29dSMark Haverkamp sizeof(scsicmd->request->rq_disk->disk_name) + 1)); 252277d644d4SMark Haverkamp 25239e7c349cSMark Haverkamp return aac_read(scsicmd); 25241da177e4SLinus Torvalds 25251da177e4SLinus Torvalds case WRITE_6: 25261da177e4SLinus Torvalds case WRITE_10: 25277a8cf29dSMark Haverkamp case WRITE_12: 25287a8cf29dSMark Haverkamp case WRITE_16: 25298c867b25SMark Haverkamp if (dev->in_reset) 25308c867b25SMark Haverkamp return -1; 25319e7c349cSMark Haverkamp return aac_write(scsicmd); 25321da177e4SLinus Torvalds 25331da177e4SLinus Torvalds case SYNCHRONIZE_CACHE: 253495e852e1SSalyzyn, Mark if (((aac_cache & 6) == 6) && dev->cache_protected) { 253595e852e1SSalyzyn, Mark scsicmd->result = DID_OK << 16 | 253695e852e1SSalyzyn, Mark COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 253795e852e1SSalyzyn, Mark scsicmd->scsi_done(scsicmd); 253895e852e1SSalyzyn, Mark return 0; 253995e852e1SSalyzyn, Mark } 25401da177e4SLinus Torvalds /* Issue FIB to tell Firmware to flush it's cache */ 254195e852e1SSalyzyn, Mark if ((aac_cache & 6) != 2) 25429e7c349cSMark Haverkamp return aac_synchronize(scsicmd); 254395e852e1SSalyzyn, Mark /* FALLTHRU */ 25441da177e4SLinus Torvalds default: 25451da177e4SLinus Torvalds /* 25461da177e4SLinus Torvalds * Unhandled commands 25471da177e4SLinus Torvalds */ 25487c00ffa3SMark Haverkamp dprintk((KERN_WARNING "Unhandled SCSI Command: 0x%x.\n", scsicmd->cmnd[0])); 25491da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 25508e31e607SSalyzyn, Mark set_sense(&dev->fsa_dev[cid].sense_data, 25511da177e4SLinus Torvalds ILLEGAL_REQUEST, SENCODE_INVALID_COMMAND, 25528e31e607SSalyzyn, Mark ASENCODE_INVALID_COMMAND, 0, 0); 25531da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 25543ace426fSSalyzyn, Mark min_t(size_t, 25553ace426fSSalyzyn, Mark sizeof(dev->fsa_dev[cid].sense_data), 25563ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE)); 25571da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 25581da177e4SLinus Torvalds return 0; 25591da177e4SLinus Torvalds } 25601da177e4SLinus Torvalds } 25611da177e4SLinus Torvalds 25621da177e4SLinus Torvalds static int query_disk(struct aac_dev *dev, void __user *arg) 25631da177e4SLinus Torvalds { 25641da177e4SLinus Torvalds struct aac_query_disk qd; 25651da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 25661da177e4SLinus Torvalds 25671da177e4SLinus Torvalds fsa_dev_ptr = dev->fsa_dev; 256890ee3466SMark Haverkamp if (!fsa_dev_ptr) 256965101355SMark Haverkamp return -EBUSY; 25701da177e4SLinus Torvalds if (copy_from_user(&qd, arg, sizeof (struct aac_query_disk))) 25711da177e4SLinus Torvalds return -EFAULT; 25721da177e4SLinus Torvalds if (qd.cnum == -1) 2573e5718774SMark Haverkamp qd.cnum = qd.id; 25741da177e4SLinus Torvalds else if ((qd.bus == -1) && (qd.id == -1) && (qd.lun == -1)) 25751da177e4SLinus Torvalds { 25761da177e4SLinus Torvalds if (qd.cnum < 0 || qd.cnum >= dev->maximum_num_containers) 25771da177e4SLinus Torvalds return -EINVAL; 25781da177e4SLinus Torvalds qd.instance = dev->scsi_host_ptr->host_no; 25791da177e4SLinus Torvalds qd.bus = 0; 25801da177e4SLinus Torvalds qd.id = CONTAINER_TO_ID(qd.cnum); 25811da177e4SLinus Torvalds qd.lun = CONTAINER_TO_LUN(qd.cnum); 25821da177e4SLinus Torvalds } 25831da177e4SLinus Torvalds else return -EINVAL; 25841da177e4SLinus Torvalds 2585fd622b1bSSalyzyn, Mark qd.valid = fsa_dev_ptr[qd.cnum].valid != 0; 25861da177e4SLinus Torvalds qd.locked = fsa_dev_ptr[qd.cnum].locked; 25871da177e4SLinus Torvalds qd.deleted = fsa_dev_ptr[qd.cnum].deleted; 25881da177e4SLinus Torvalds 25891da177e4SLinus Torvalds if (fsa_dev_ptr[qd.cnum].devname[0] == '\0') 25901da177e4SLinus Torvalds qd.unmapped = 1; 25911da177e4SLinus Torvalds else 25921da177e4SLinus Torvalds qd.unmapped = 0; 25931da177e4SLinus Torvalds 25941da177e4SLinus Torvalds strlcpy(qd.name, fsa_dev_ptr[qd.cnum].devname, 25951da177e4SLinus Torvalds min(sizeof(qd.name), sizeof(fsa_dev_ptr[qd.cnum].devname) + 1)); 25961da177e4SLinus Torvalds 25971da177e4SLinus Torvalds if (copy_to_user(arg, &qd, sizeof (struct aac_query_disk))) 25981da177e4SLinus Torvalds return -EFAULT; 25991da177e4SLinus Torvalds return 0; 26001da177e4SLinus Torvalds } 26011da177e4SLinus Torvalds 26021da177e4SLinus Torvalds static int force_delete_disk(struct aac_dev *dev, void __user *arg) 26031da177e4SLinus Torvalds { 26041da177e4SLinus Torvalds struct aac_delete_disk dd; 26051da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 26061da177e4SLinus Torvalds 26071da177e4SLinus Torvalds fsa_dev_ptr = dev->fsa_dev; 260865101355SMark Haverkamp if (!fsa_dev_ptr) 260965101355SMark Haverkamp return -EBUSY; 26101da177e4SLinus Torvalds 26111da177e4SLinus Torvalds if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk))) 26121da177e4SLinus Torvalds return -EFAULT; 26131da177e4SLinus Torvalds 26141da177e4SLinus Torvalds if (dd.cnum >= dev->maximum_num_containers) 26151da177e4SLinus Torvalds return -EINVAL; 26161da177e4SLinus Torvalds /* 26171da177e4SLinus Torvalds * Mark this container as being deleted. 26181da177e4SLinus Torvalds */ 26191da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].deleted = 1; 26201da177e4SLinus Torvalds /* 26211da177e4SLinus Torvalds * Mark the container as no longer valid 26221da177e4SLinus Torvalds */ 26231da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].valid = 0; 26241da177e4SLinus Torvalds return 0; 26251da177e4SLinus Torvalds } 26261da177e4SLinus Torvalds 26271da177e4SLinus Torvalds static int delete_disk(struct aac_dev *dev, void __user *arg) 26281da177e4SLinus Torvalds { 26291da177e4SLinus Torvalds struct aac_delete_disk dd; 26301da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 26311da177e4SLinus Torvalds 26321da177e4SLinus Torvalds fsa_dev_ptr = dev->fsa_dev; 263390ee3466SMark Haverkamp if (!fsa_dev_ptr) 263465101355SMark Haverkamp return -EBUSY; 26351da177e4SLinus Torvalds 26361da177e4SLinus Torvalds if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk))) 26371da177e4SLinus Torvalds return -EFAULT; 26381da177e4SLinus Torvalds 26391da177e4SLinus Torvalds if (dd.cnum >= dev->maximum_num_containers) 26401da177e4SLinus Torvalds return -EINVAL; 26411da177e4SLinus Torvalds /* 26421da177e4SLinus Torvalds * If the container is locked, it can not be deleted by the API. 26431da177e4SLinus Torvalds */ 26441da177e4SLinus Torvalds if (fsa_dev_ptr[dd.cnum].locked) 26451da177e4SLinus Torvalds return -EBUSY; 26461da177e4SLinus Torvalds else { 26471da177e4SLinus Torvalds /* 26481da177e4SLinus Torvalds * Mark the container as no longer being valid. 26491da177e4SLinus Torvalds */ 26501da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].valid = 0; 26511da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].devname[0] = '\0'; 26521da177e4SLinus Torvalds return 0; 26531da177e4SLinus Torvalds } 26541da177e4SLinus Torvalds } 26551da177e4SLinus Torvalds 26561da177e4SLinus Torvalds int aac_dev_ioctl(struct aac_dev *dev, int cmd, void __user *arg) 26571da177e4SLinus Torvalds { 26581da177e4SLinus Torvalds switch (cmd) { 26591da177e4SLinus Torvalds case FSACTL_QUERY_DISK: 26601da177e4SLinus Torvalds return query_disk(dev, arg); 26611da177e4SLinus Torvalds case FSACTL_DELETE_DISK: 26621da177e4SLinus Torvalds return delete_disk(dev, arg); 26631da177e4SLinus Torvalds case FSACTL_FORCE_DELETE_DISK: 26641da177e4SLinus Torvalds return force_delete_disk(dev, arg); 26651da177e4SLinus Torvalds case FSACTL_GET_CONTAINERS: 26661da177e4SLinus Torvalds return aac_get_containers(dev); 26671da177e4SLinus Torvalds default: 26681da177e4SLinus Torvalds return -ENOTTY; 26691da177e4SLinus Torvalds } 26701da177e4SLinus Torvalds } 26711da177e4SLinus Torvalds 26721da177e4SLinus Torvalds /** 26731da177e4SLinus Torvalds * 26741da177e4SLinus Torvalds * aac_srb_callback 26751da177e4SLinus Torvalds * @context: the context set in the fib - here it is scsi cmd 26761da177e4SLinus Torvalds * @fibptr: pointer to the fib 26771da177e4SLinus Torvalds * 26781da177e4SLinus Torvalds * Handles the completion of a scsi command to a non dasd device 26791da177e4SLinus Torvalds * 26801da177e4SLinus Torvalds */ 26811da177e4SLinus Torvalds 26821da177e4SLinus Torvalds static void aac_srb_callback(void *context, struct fib * fibptr) 26831da177e4SLinus Torvalds { 26841da177e4SLinus Torvalds struct aac_dev *dev; 26851da177e4SLinus Torvalds struct aac_srb_reply *srbreply; 26861da177e4SLinus Torvalds struct scsi_cmnd *scsicmd; 26871da177e4SLinus Torvalds 26881da177e4SLinus Torvalds scsicmd = (struct scsi_cmnd *) context; 268903d44337SMark Haverkamp 269003d44337SMark Haverkamp if (!aac_valid_context(scsicmd, fibptr)) 269103d44337SMark Haverkamp return; 269203d44337SMark Haverkamp 2693125e1874SEric Sesterhenn BUG_ON(fibptr == NULL); 26941da177e4SLinus Torvalds 26951a655040SSalyzyn, Mark dev = fibptr->dev; 26961a655040SSalyzyn, Mark 26971da177e4SLinus Torvalds srbreply = (struct aac_srb_reply *) fib_data(fibptr); 26981da177e4SLinus Torvalds 26991da177e4SLinus Torvalds scsicmd->sense_buffer[0] = '\0'; /* Initialize sense valid flag to false */ 270085d22bbfSMahesh Rajashekhara 270185d22bbfSMahesh Rajashekhara if (fibptr->flags & FIB_CONTEXT_FLAG_FASTRESP) { 270285d22bbfSMahesh Rajashekhara /* fast response */ 270385d22bbfSMahesh Rajashekhara srbreply->srb_status = cpu_to_le32(SRB_STATUS_SUCCESS); 270485d22bbfSMahesh Rajashekhara srbreply->scsi_status = cpu_to_le32(SAM_STAT_GOOD); 270585d22bbfSMahesh Rajashekhara } else { 27061da177e4SLinus Torvalds /* 27071da177e4SLinus Torvalds * Calculate resid for sg 27081da177e4SLinus Torvalds */ 2709727eead6SFUJITA Tomonori scsi_set_resid(scsicmd, scsi_bufflen(scsicmd) 2710727eead6SFUJITA Tomonori - le32_to_cpu(srbreply->data_xfer_length)); 271185d22bbfSMahesh Rajashekhara } 27121da177e4SLinus Torvalds 2713727eead6SFUJITA Tomonori scsi_dma_unmap(scsicmd); 27141da177e4SLinus Torvalds 2715e3cc268fSRajashekhara, Mahesh /* expose physical device if expose_physicald flag is on */ 2716e3cc268fSRajashekhara, Mahesh if (scsicmd->cmnd[0] == INQUIRY && !(scsicmd->cmnd[1] & 0x01) 2717e3cc268fSRajashekhara, Mahesh && expose_physicals > 0) 2718e3cc268fSRajashekhara, Mahesh aac_expose_phy_device(scsicmd); 2719e3cc268fSRajashekhara, Mahesh 27201da177e4SLinus Torvalds /* 27211da177e4SLinus Torvalds * First check the fib status 27221da177e4SLinus Torvalds */ 27231da177e4SLinus Torvalds 27241da177e4SLinus Torvalds if (le32_to_cpu(srbreply->status) != ST_OK){ 27251da177e4SLinus Torvalds int len; 27261da177e4SLinus Torvalds printk(KERN_WARNING "aac_srb_callback: srb failed, status = %d\n", le32_to_cpu(srbreply->status)); 27273ace426fSSalyzyn, Mark len = min_t(u32, le32_to_cpu(srbreply->sense_data_size), 27283ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE); 27291da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 27301da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, srbreply->sense_data, len); 27311da177e4SLinus Torvalds } 27321da177e4SLinus Torvalds 27331da177e4SLinus Torvalds /* 27341da177e4SLinus Torvalds * Next check the srb status 27351da177e4SLinus Torvalds */ 27361da177e4SLinus Torvalds switch( (le32_to_cpu(srbreply->srb_status))&0x3f){ 27371da177e4SLinus Torvalds case SRB_STATUS_ERROR_RECOVERY: 27381da177e4SLinus Torvalds case SRB_STATUS_PENDING: 27391da177e4SLinus Torvalds case SRB_STATUS_SUCCESS: 27401da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 27411da177e4SLinus Torvalds break; 27421da177e4SLinus Torvalds case SRB_STATUS_DATA_OVERRUN: 27431da177e4SLinus Torvalds switch(scsicmd->cmnd[0]){ 27441da177e4SLinus Torvalds case READ_6: 27451da177e4SLinus Torvalds case WRITE_6: 27461da177e4SLinus Torvalds case READ_10: 27471da177e4SLinus Torvalds case WRITE_10: 27481da177e4SLinus Torvalds case READ_12: 27491da177e4SLinus Torvalds case WRITE_12: 27507a8cf29dSMark Haverkamp case READ_16: 27517a8cf29dSMark Haverkamp case WRITE_16: 27521da177e4SLinus Torvalds if (le32_to_cpu(srbreply->data_xfer_length) < scsicmd->underflow) { 27531da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: SCSI CMD underflow\n"); 27541da177e4SLinus Torvalds } else { 27551da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: SCSI CMD Data Overrun\n"); 27561da177e4SLinus Torvalds } 27571da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8; 27581da177e4SLinus Torvalds break; 27591da177e4SLinus Torvalds case INQUIRY: { 27601da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 27611da177e4SLinus Torvalds break; 27621da177e4SLinus Torvalds } 27631da177e4SLinus Torvalds default: 27641da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 27651da177e4SLinus Torvalds break; 27661da177e4SLinus Torvalds } 27671da177e4SLinus Torvalds break; 27681da177e4SLinus Torvalds case SRB_STATUS_ABORTED: 27691da177e4SLinus Torvalds scsicmd->result = DID_ABORT << 16 | ABORT << 8; 27701da177e4SLinus Torvalds break; 27711da177e4SLinus Torvalds case SRB_STATUS_ABORT_FAILED: 27721da177e4SLinus Torvalds // Not sure about this one - but assuming the hba was trying to abort for some reason 27731da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | ABORT << 8; 27741da177e4SLinus Torvalds break; 27751da177e4SLinus Torvalds case SRB_STATUS_PARITY_ERROR: 27761da177e4SLinus Torvalds scsicmd->result = DID_PARITY << 16 | MSG_PARITY_ERROR << 8; 27771da177e4SLinus Torvalds break; 27781da177e4SLinus Torvalds case SRB_STATUS_NO_DEVICE: 27791da177e4SLinus Torvalds case SRB_STATUS_INVALID_PATH_ID: 27801da177e4SLinus Torvalds case SRB_STATUS_INVALID_TARGET_ID: 27811da177e4SLinus Torvalds case SRB_STATUS_INVALID_LUN: 27821da177e4SLinus Torvalds case SRB_STATUS_SELECTION_TIMEOUT: 27831da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8; 27841da177e4SLinus Torvalds break; 27851da177e4SLinus Torvalds 27861da177e4SLinus Torvalds case SRB_STATUS_COMMAND_TIMEOUT: 27871da177e4SLinus Torvalds case SRB_STATUS_TIMEOUT: 27881da177e4SLinus Torvalds scsicmd->result = DID_TIME_OUT << 16 | COMMAND_COMPLETE << 8; 27891da177e4SLinus Torvalds break; 27901da177e4SLinus Torvalds 27911da177e4SLinus Torvalds case SRB_STATUS_BUSY: 2792760af100SSalyzyn, Mark scsicmd->result = DID_BUS_BUSY << 16 | COMMAND_COMPLETE << 8; 27931da177e4SLinus Torvalds break; 27941da177e4SLinus Torvalds 27951da177e4SLinus Torvalds case SRB_STATUS_BUS_RESET: 27961da177e4SLinus Torvalds scsicmd->result = DID_RESET << 16 | COMMAND_COMPLETE << 8; 27971da177e4SLinus Torvalds break; 27981da177e4SLinus Torvalds 27991da177e4SLinus Torvalds case SRB_STATUS_MESSAGE_REJECTED: 28001da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | MESSAGE_REJECT << 8; 28011da177e4SLinus Torvalds break; 28021da177e4SLinus Torvalds case SRB_STATUS_REQUEST_FLUSHED: 28031da177e4SLinus Torvalds case SRB_STATUS_ERROR: 28041da177e4SLinus Torvalds case SRB_STATUS_INVALID_REQUEST: 28051da177e4SLinus Torvalds case SRB_STATUS_REQUEST_SENSE_FAILED: 28061da177e4SLinus Torvalds case SRB_STATUS_NO_HBA: 28071da177e4SLinus Torvalds case SRB_STATUS_UNEXPECTED_BUS_FREE: 28081da177e4SLinus Torvalds case SRB_STATUS_PHASE_SEQUENCE_FAILURE: 28091da177e4SLinus Torvalds case SRB_STATUS_BAD_SRB_BLOCK_LENGTH: 28101da177e4SLinus Torvalds case SRB_STATUS_DELAYED_RETRY: 28111da177e4SLinus Torvalds case SRB_STATUS_BAD_FUNCTION: 28121da177e4SLinus Torvalds case SRB_STATUS_NOT_STARTED: 28131da177e4SLinus Torvalds case SRB_STATUS_NOT_IN_USE: 28141da177e4SLinus Torvalds case SRB_STATUS_FORCE_ABORT: 28151da177e4SLinus Torvalds case SRB_STATUS_DOMAIN_VALIDATION_FAIL: 28161da177e4SLinus Torvalds default: 28171da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 28181da177e4SLinus Torvalds printk("aacraid: SRB ERROR(%u) %s scsi cmd 0x%x - scsi status 0x%x\n", 28191da177e4SLinus Torvalds le32_to_cpu(srbreply->srb_status) & 0x3F, 28201da177e4SLinus Torvalds aac_get_status_string( 28211da177e4SLinus Torvalds le32_to_cpu(srbreply->srb_status) & 0x3F), 28221da177e4SLinus Torvalds scsicmd->cmnd[0], 28231da177e4SLinus Torvalds le32_to_cpu(srbreply->scsi_status)); 28241da177e4SLinus Torvalds #endif 28251fc8010aSRajashekhara, Mahesh if ((scsicmd->cmnd[0] == ATA_12) 28261fc8010aSRajashekhara, Mahesh || (scsicmd->cmnd[0] == ATA_16)) { 28271fc8010aSRajashekhara, Mahesh if (scsicmd->cmnd[2] & (0x01 << 5)) { 28281fc8010aSRajashekhara, Mahesh scsicmd->result = DID_OK << 16 28291fc8010aSRajashekhara, Mahesh | COMMAND_COMPLETE << 8; 28301da177e4SLinus Torvalds break; 28311fc8010aSRajashekhara, Mahesh } else { 28321fc8010aSRajashekhara, Mahesh scsicmd->result = DID_ERROR << 16 28331fc8010aSRajashekhara, Mahesh | COMMAND_COMPLETE << 8; 28341fc8010aSRajashekhara, Mahesh break; 28351fc8010aSRajashekhara, Mahesh } 28361fc8010aSRajashekhara, Mahesh } else { 28371fc8010aSRajashekhara, Mahesh scsicmd->result = DID_ERROR << 16 28381fc8010aSRajashekhara, Mahesh | COMMAND_COMPLETE << 8; 28391fc8010aSRajashekhara, Mahesh break; 28401fc8010aSRajashekhara, Mahesh } 28411da177e4SLinus Torvalds } 28428ce3eca4SSalyzyn, Mark if (le32_to_cpu(srbreply->scsi_status) == SAM_STAT_CHECK_CONDITION) { 28431da177e4SLinus Torvalds int len; 28441da177e4SLinus Torvalds scsicmd->result |= SAM_STAT_CHECK_CONDITION; 28453ace426fSSalyzyn, Mark len = min_t(u32, le32_to_cpu(srbreply->sense_data_size), 28463ace426fSSalyzyn, Mark SCSI_SENSE_BUFFERSIZE); 28471da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 28487a8cf29dSMark Haverkamp printk(KERN_WARNING "aac_srb_callback: check condition, status = %d len=%d\n", 28497a8cf29dSMark Haverkamp le32_to_cpu(srbreply->status), len); 28501da177e4SLinus Torvalds #endif 28511da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, srbreply->sense_data, len); 28521da177e4SLinus Torvalds } 28531da177e4SLinus Torvalds /* 28541da177e4SLinus Torvalds * OR in the scsi status (already shifted up a bit) 28551da177e4SLinus Torvalds */ 28561da177e4SLinus Torvalds scsicmd->result |= le32_to_cpu(srbreply->scsi_status); 28571da177e4SLinus Torvalds 2858bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 2859bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 28608e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 28611da177e4SLinus Torvalds } 28621da177e4SLinus Torvalds 28631da177e4SLinus Torvalds /** 28641da177e4SLinus Torvalds * 28651da177e4SLinus Torvalds * aac_send_scb_fib 28661da177e4SLinus Torvalds * @scsicmd: the scsi command block 28671da177e4SLinus Torvalds * 28681da177e4SLinus Torvalds * This routine will form a FIB and fill in the aac_srb from the 28691da177e4SLinus Torvalds * scsicmd passed in. 28701da177e4SLinus Torvalds */ 28711da177e4SLinus Torvalds 28721da177e4SLinus Torvalds static int aac_send_srb_fib(struct scsi_cmnd* scsicmd) 28731da177e4SLinus Torvalds { 28741da177e4SLinus Torvalds struct fib* cmd_fibcontext; 28751da177e4SLinus Torvalds struct aac_dev* dev; 28761da177e4SLinus Torvalds int status; 28771da177e4SLinus Torvalds 287884971738SMark Haverkamp dev = (struct aac_dev *)scsicmd->device->host->hostdata; 2879e5718774SMark Haverkamp if (scmd_id(scsicmd) >= dev->maximum_num_physicals || 288084971738SMark Haverkamp scsicmd->device->lun > 7) { 28811da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16; 28821da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 28831da177e4SLinus Torvalds return 0; 28841da177e4SLinus Torvalds } 28851da177e4SLinus Torvalds 28861da177e4SLinus Torvalds /* 28871da177e4SLinus Torvalds * Allocate and initialize a Fib then setup a BlockWrite command 28881da177e4SLinus Torvalds */ 2889bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) { 28901da177e4SLinus Torvalds return -1; 28911da177e4SLinus Torvalds } 2892e8f32de5SMark Haverkamp status = aac_adapter_scsi(cmd_fibcontext, scsicmd); 28931da177e4SLinus Torvalds 28941da177e4SLinus Torvalds /* 28951da177e4SLinus Torvalds * Check that the command queued to the controller 28961da177e4SLinus Torvalds */ 28971da177e4SLinus Torvalds if (status == -EINPROGRESS) { 289877d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 28991da177e4SLinus Torvalds return 0; 29001da177e4SLinus Torvalds } 29011da177e4SLinus Torvalds 2902bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_srb: aac_fib_send failed with status: %d\n", status); 2903bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 2904bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 29051da177e4SLinus Torvalds 29061da177e4SLinus Torvalds return -1; 29071da177e4SLinus Torvalds } 29081da177e4SLinus Torvalds 29090b433447SMahesh Rajashekhara static long aac_build_sg(struct scsi_cmnd *scsicmd, struct sgmap *psg) 29101da177e4SLinus Torvalds { 29111da177e4SLinus Torvalds struct aac_dev *dev; 29121da177e4SLinus Torvalds unsigned long byte_count = 0; 2913727eead6SFUJITA Tomonori int nseg; 29141da177e4SLinus Torvalds 29151da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 29161da177e4SLinus Torvalds // Get rid of old data 29171da177e4SLinus Torvalds psg->count = 0; 29181da177e4SLinus Torvalds psg->sg[0].addr = 0; 29191da177e4SLinus Torvalds psg->sg[0].count = 0; 2920727eead6SFUJITA Tomonori 2921727eead6SFUJITA Tomonori nseg = scsi_dma_map(scsicmd); 29220b433447SMahesh Rajashekhara if (nseg < 0) 29230b433447SMahesh Rajashekhara return nseg; 2924727eead6SFUJITA Tomonori if (nseg) { 29251da177e4SLinus Torvalds struct scatterlist *sg; 29261da177e4SLinus Torvalds int i; 29271da177e4SLinus Torvalds 2928727eead6SFUJITA Tomonori psg->count = cpu_to_le32(nseg); 29291da177e4SLinus Torvalds 2930727eead6SFUJITA Tomonori scsi_for_each_sg(scsicmd, sg, nseg, i) { 29311da177e4SLinus Torvalds psg->sg[i].addr = cpu_to_le32(sg_dma_address(sg)); 29321da177e4SLinus Torvalds psg->sg[i].count = cpu_to_le32(sg_dma_len(sg)); 29331da177e4SLinus Torvalds byte_count += sg_dma_len(sg); 29341da177e4SLinus Torvalds } 29351da177e4SLinus Torvalds /* hba wants the size to be exact */ 2936727eead6SFUJITA Tomonori if (byte_count > scsi_bufflen(scsicmd)) { 293756b58712SMark Haverkamp u32 temp = le32_to_cpu(psg->sg[i-1].count) - 2938727eead6SFUJITA Tomonori (byte_count - scsi_bufflen(scsicmd)); 293956b58712SMark Haverkamp psg->sg[i-1].count = cpu_to_le32(temp); 2940727eead6SFUJITA Tomonori byte_count = scsi_bufflen(scsicmd); 29411da177e4SLinus Torvalds } 29421da177e4SLinus Torvalds /* Check for command underflow */ 29431da177e4SLinus Torvalds if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 29441da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 29451da177e4SLinus Torvalds byte_count, scsicmd->underflow); 29461da177e4SLinus Torvalds } 29471da177e4SLinus Torvalds } 29481da177e4SLinus Torvalds return byte_count; 29491da177e4SLinus Torvalds } 29501da177e4SLinus Torvalds 29511da177e4SLinus Torvalds 29520b433447SMahesh Rajashekhara static long aac_build_sg64(struct scsi_cmnd *scsicmd, struct sgmap64 *psg) 29531da177e4SLinus Torvalds { 29541da177e4SLinus Torvalds struct aac_dev *dev; 29551da177e4SLinus Torvalds unsigned long byte_count = 0; 295656b58712SMark Haverkamp u64 addr; 2957727eead6SFUJITA Tomonori int nseg; 29581da177e4SLinus Torvalds 29591da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 29601da177e4SLinus Torvalds // Get rid of old data 29611da177e4SLinus Torvalds psg->count = 0; 29621da177e4SLinus Torvalds psg->sg[0].addr[0] = 0; 29631da177e4SLinus Torvalds psg->sg[0].addr[1] = 0; 29641da177e4SLinus Torvalds psg->sg[0].count = 0; 2965727eead6SFUJITA Tomonori 2966727eead6SFUJITA Tomonori nseg = scsi_dma_map(scsicmd); 29670b433447SMahesh Rajashekhara if (nseg < 0) 29680b433447SMahesh Rajashekhara return nseg; 2969727eead6SFUJITA Tomonori if (nseg) { 29701da177e4SLinus Torvalds struct scatterlist *sg; 29711da177e4SLinus Torvalds int i; 29721da177e4SLinus Torvalds 2973727eead6SFUJITA Tomonori scsi_for_each_sg(scsicmd, sg, nseg, i) { 29741241f359SMark Haverkamp int count = sg_dma_len(sg); 297556b58712SMark Haverkamp addr = sg_dma_address(sg); 297656b58712SMark Haverkamp psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff); 297756b58712SMark Haverkamp psg->sg[i].addr[1] = cpu_to_le32(addr>>32); 29781241f359SMark Haverkamp psg->sg[i].count = cpu_to_le32(count); 29791241f359SMark Haverkamp byte_count += count; 29801da177e4SLinus Torvalds } 2981727eead6SFUJITA Tomonori psg->count = cpu_to_le32(nseg); 29821da177e4SLinus Torvalds /* hba wants the size to be exact */ 2983727eead6SFUJITA Tomonori if (byte_count > scsi_bufflen(scsicmd)) { 298456b58712SMark Haverkamp u32 temp = le32_to_cpu(psg->sg[i-1].count) - 2985727eead6SFUJITA Tomonori (byte_count - scsi_bufflen(scsicmd)); 298656b58712SMark Haverkamp psg->sg[i-1].count = cpu_to_le32(temp); 2987727eead6SFUJITA Tomonori byte_count = scsi_bufflen(scsicmd); 29881da177e4SLinus Torvalds } 29891da177e4SLinus Torvalds /* Check for command underflow */ 29901da177e4SLinus Torvalds if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 29911da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 29921da177e4SLinus Torvalds byte_count, scsicmd->underflow); 29931da177e4SLinus Torvalds } 29941da177e4SLinus Torvalds } 29951da177e4SLinus Torvalds return byte_count; 29961da177e4SLinus Torvalds } 29971da177e4SLinus Torvalds 29980b433447SMahesh Rajashekhara static long aac_build_sgraw(struct scsi_cmnd *scsicmd, struct sgmapraw *psg) 29990e68c003SMark Haverkamp { 30000e68c003SMark Haverkamp unsigned long byte_count = 0; 3001727eead6SFUJITA Tomonori int nseg; 30020e68c003SMark Haverkamp 30030e68c003SMark Haverkamp // Get rid of old data 30040e68c003SMark Haverkamp psg->count = 0; 30050e68c003SMark Haverkamp psg->sg[0].next = 0; 30060e68c003SMark Haverkamp psg->sg[0].prev = 0; 30070e68c003SMark Haverkamp psg->sg[0].addr[0] = 0; 30080e68c003SMark Haverkamp psg->sg[0].addr[1] = 0; 30090e68c003SMark Haverkamp psg->sg[0].count = 0; 30100e68c003SMark Haverkamp psg->sg[0].flags = 0; 3011727eead6SFUJITA Tomonori 3012727eead6SFUJITA Tomonori nseg = scsi_dma_map(scsicmd); 30130b433447SMahesh Rajashekhara if (nseg < 0) 30140b433447SMahesh Rajashekhara return nseg; 3015727eead6SFUJITA Tomonori if (nseg) { 30160e68c003SMark Haverkamp struct scatterlist *sg; 30170e68c003SMark Haverkamp int i; 30180e68c003SMark Haverkamp 3019727eead6SFUJITA Tomonori scsi_for_each_sg(scsicmd, sg, nseg, i) { 30200e68c003SMark Haverkamp int count = sg_dma_len(sg); 30210e68c003SMark Haverkamp u64 addr = sg_dma_address(sg); 30220e68c003SMark Haverkamp psg->sg[i].next = 0; 30230e68c003SMark Haverkamp psg->sg[i].prev = 0; 30240e68c003SMark Haverkamp psg->sg[i].addr[1] = cpu_to_le32((u32)(addr>>32)); 30250e68c003SMark Haverkamp psg->sg[i].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff)); 30260e68c003SMark Haverkamp psg->sg[i].count = cpu_to_le32(count); 30270e68c003SMark Haverkamp psg->sg[i].flags = 0; 30280e68c003SMark Haverkamp byte_count += count; 30290e68c003SMark Haverkamp } 3030727eead6SFUJITA Tomonori psg->count = cpu_to_le32(nseg); 30310e68c003SMark Haverkamp /* hba wants the size to be exact */ 3032727eead6SFUJITA Tomonori if (byte_count > scsi_bufflen(scsicmd)) { 30330e68c003SMark Haverkamp u32 temp = le32_to_cpu(psg->sg[i-1].count) - 3034727eead6SFUJITA Tomonori (byte_count - scsi_bufflen(scsicmd)); 30350e68c003SMark Haverkamp psg->sg[i-1].count = cpu_to_le32(temp); 3036727eead6SFUJITA Tomonori byte_count = scsi_bufflen(scsicmd); 30370e68c003SMark Haverkamp } 30380e68c003SMark Haverkamp /* Check for command underflow */ 30390e68c003SMark Haverkamp if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 30400e68c003SMark Haverkamp printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 30410e68c003SMark Haverkamp byte_count, scsicmd->underflow); 30420e68c003SMark Haverkamp } 30430e68c003SMark Haverkamp } 30440e68c003SMark Haverkamp return byte_count; 30450e68c003SMark Haverkamp } 30460e68c003SMark Haverkamp 30470b433447SMahesh Rajashekhara static long aac_build_sgraw2(struct scsi_cmnd *scsicmd, 30480b433447SMahesh Rajashekhara struct aac_raw_io2 *rio2, int sg_max) 304985d22bbfSMahesh Rajashekhara { 305085d22bbfSMahesh Rajashekhara unsigned long byte_count = 0; 305185d22bbfSMahesh Rajashekhara int nseg; 305285d22bbfSMahesh Rajashekhara 305385d22bbfSMahesh Rajashekhara nseg = scsi_dma_map(scsicmd); 30540b433447SMahesh Rajashekhara if (nseg < 0) 30550b433447SMahesh Rajashekhara return nseg; 305685d22bbfSMahesh Rajashekhara if (nseg) { 305785d22bbfSMahesh Rajashekhara struct scatterlist *sg; 305885d22bbfSMahesh Rajashekhara int i, conformable = 0; 305985d22bbfSMahesh Rajashekhara u32 min_size = PAGE_SIZE, cur_size; 306085d22bbfSMahesh Rajashekhara 306185d22bbfSMahesh Rajashekhara scsi_for_each_sg(scsicmd, sg, nseg, i) { 306285d22bbfSMahesh Rajashekhara int count = sg_dma_len(sg); 306385d22bbfSMahesh Rajashekhara u64 addr = sg_dma_address(sg); 306485d22bbfSMahesh Rajashekhara 306585d22bbfSMahesh Rajashekhara BUG_ON(i >= sg_max); 306685d22bbfSMahesh Rajashekhara rio2->sge[i].addrHigh = cpu_to_le32((u32)(addr>>32)); 306785d22bbfSMahesh Rajashekhara rio2->sge[i].addrLow = cpu_to_le32((u32)(addr & 0xffffffff)); 306885d22bbfSMahesh Rajashekhara cur_size = cpu_to_le32(count); 306985d22bbfSMahesh Rajashekhara rio2->sge[i].length = cur_size; 307085d22bbfSMahesh Rajashekhara rio2->sge[i].flags = 0; 307185d22bbfSMahesh Rajashekhara if (i == 0) { 307285d22bbfSMahesh Rajashekhara conformable = 1; 307385d22bbfSMahesh Rajashekhara rio2->sgeFirstSize = cur_size; 307485d22bbfSMahesh Rajashekhara } else if (i == 1) { 307585d22bbfSMahesh Rajashekhara rio2->sgeNominalSize = cur_size; 307685d22bbfSMahesh Rajashekhara min_size = cur_size; 307785d22bbfSMahesh Rajashekhara } else if ((i+1) < nseg && cur_size != rio2->sgeNominalSize) { 307885d22bbfSMahesh Rajashekhara conformable = 0; 307985d22bbfSMahesh Rajashekhara if (cur_size < min_size) 308085d22bbfSMahesh Rajashekhara min_size = cur_size; 308185d22bbfSMahesh Rajashekhara } 308285d22bbfSMahesh Rajashekhara byte_count += count; 308385d22bbfSMahesh Rajashekhara } 308485d22bbfSMahesh Rajashekhara 308585d22bbfSMahesh Rajashekhara /* hba wants the size to be exact */ 308685d22bbfSMahesh Rajashekhara if (byte_count > scsi_bufflen(scsicmd)) { 308785d22bbfSMahesh Rajashekhara u32 temp = le32_to_cpu(rio2->sge[i-1].length) - 308885d22bbfSMahesh Rajashekhara (byte_count - scsi_bufflen(scsicmd)); 308985d22bbfSMahesh Rajashekhara rio2->sge[i-1].length = cpu_to_le32(temp); 309085d22bbfSMahesh Rajashekhara byte_count = scsi_bufflen(scsicmd); 309185d22bbfSMahesh Rajashekhara } 309285d22bbfSMahesh Rajashekhara 309385d22bbfSMahesh Rajashekhara rio2->sgeCnt = cpu_to_le32(nseg); 309485d22bbfSMahesh Rajashekhara rio2->flags |= cpu_to_le16(RIO2_SG_FORMAT_IEEE1212); 309585d22bbfSMahesh Rajashekhara /* not conformable: evaluate required sg elements */ 309685d22bbfSMahesh Rajashekhara if (!conformable) { 309785d22bbfSMahesh Rajashekhara int j, nseg_new = nseg, err_found; 309885d22bbfSMahesh Rajashekhara for (i = min_size / PAGE_SIZE; i >= 1; --i) { 309985d22bbfSMahesh Rajashekhara err_found = 0; 310085d22bbfSMahesh Rajashekhara nseg_new = 2; 310185d22bbfSMahesh Rajashekhara for (j = 1; j < nseg - 1; ++j) { 310285d22bbfSMahesh Rajashekhara if (rio2->sge[j].length % (i*PAGE_SIZE)) { 310385d22bbfSMahesh Rajashekhara err_found = 1; 310485d22bbfSMahesh Rajashekhara break; 310585d22bbfSMahesh Rajashekhara } 310685d22bbfSMahesh Rajashekhara nseg_new += (rio2->sge[j].length / (i*PAGE_SIZE)); 310785d22bbfSMahesh Rajashekhara } 310885d22bbfSMahesh Rajashekhara if (!err_found) 310985d22bbfSMahesh Rajashekhara break; 311085d22bbfSMahesh Rajashekhara } 311185d22bbfSMahesh Rajashekhara if (i > 0 && nseg_new <= sg_max) 311285d22bbfSMahesh Rajashekhara aac_convert_sgraw2(rio2, i, nseg, nseg_new); 311385d22bbfSMahesh Rajashekhara } else 311485d22bbfSMahesh Rajashekhara rio2->flags |= cpu_to_le16(RIO2_SGL_CONFORMANT); 311585d22bbfSMahesh Rajashekhara 311685d22bbfSMahesh Rajashekhara /* Check for command underflow */ 311785d22bbfSMahesh Rajashekhara if (scsicmd->underflow && (byte_count < scsicmd->underflow)) { 311885d22bbfSMahesh Rajashekhara printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 311985d22bbfSMahesh Rajashekhara byte_count, scsicmd->underflow); 312085d22bbfSMahesh Rajashekhara } 312185d22bbfSMahesh Rajashekhara } 312285d22bbfSMahesh Rajashekhara 312385d22bbfSMahesh Rajashekhara return byte_count; 312485d22bbfSMahesh Rajashekhara } 312585d22bbfSMahesh Rajashekhara 312685d22bbfSMahesh Rajashekhara static int aac_convert_sgraw2(struct aac_raw_io2 *rio2, int pages, int nseg, int nseg_new) 312785d22bbfSMahesh Rajashekhara { 312885d22bbfSMahesh Rajashekhara struct sge_ieee1212 *sge; 312985d22bbfSMahesh Rajashekhara int i, j, pos; 313085d22bbfSMahesh Rajashekhara u32 addr_low; 313185d22bbfSMahesh Rajashekhara 313285d22bbfSMahesh Rajashekhara if (aac_convert_sgl == 0) 313385d22bbfSMahesh Rajashekhara return 0; 313485d22bbfSMahesh Rajashekhara 313585d22bbfSMahesh Rajashekhara sge = kmalloc(nseg_new * sizeof(struct sge_ieee1212), GFP_ATOMIC); 313685d22bbfSMahesh Rajashekhara if (sge == NULL) 313785d22bbfSMahesh Rajashekhara return -1; 313885d22bbfSMahesh Rajashekhara 313985d22bbfSMahesh Rajashekhara for (i = 1, pos = 1; i < nseg-1; ++i) { 314085d22bbfSMahesh Rajashekhara for (j = 0; j < rio2->sge[i].length / (pages * PAGE_SIZE); ++j) { 314185d22bbfSMahesh Rajashekhara addr_low = rio2->sge[i].addrLow + j * pages * PAGE_SIZE; 314285d22bbfSMahesh Rajashekhara sge[pos].addrLow = addr_low; 314385d22bbfSMahesh Rajashekhara sge[pos].addrHigh = rio2->sge[i].addrHigh; 314485d22bbfSMahesh Rajashekhara if (addr_low < rio2->sge[i].addrLow) 314585d22bbfSMahesh Rajashekhara sge[pos].addrHigh++; 314685d22bbfSMahesh Rajashekhara sge[pos].length = pages * PAGE_SIZE; 314785d22bbfSMahesh Rajashekhara sge[pos].flags = 0; 314885d22bbfSMahesh Rajashekhara pos++; 314985d22bbfSMahesh Rajashekhara } 315085d22bbfSMahesh Rajashekhara } 315185d22bbfSMahesh Rajashekhara sge[pos] = rio2->sge[nseg-1]; 315285d22bbfSMahesh Rajashekhara memcpy(&rio2->sge[1], &sge[1], (nseg_new-1)*sizeof(struct sge_ieee1212)); 315385d22bbfSMahesh Rajashekhara 315485d22bbfSMahesh Rajashekhara kfree(sge); 315585d22bbfSMahesh Rajashekhara rio2->sgeCnt = cpu_to_le32(nseg_new); 315685d22bbfSMahesh Rajashekhara rio2->flags |= cpu_to_le16(RIO2_SGL_CONFORMANT); 315785d22bbfSMahesh Rajashekhara rio2->sgeNominalSize = pages * PAGE_SIZE; 315885d22bbfSMahesh Rajashekhara return 0; 315985d22bbfSMahesh Rajashekhara } 316085d22bbfSMahesh Rajashekhara 31611da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 31621da177e4SLinus Torvalds 31631da177e4SLinus Torvalds struct aac_srb_status_info { 31641da177e4SLinus Torvalds u32 status; 31651da177e4SLinus Torvalds char *str; 31661da177e4SLinus Torvalds }; 31671da177e4SLinus Torvalds 31681da177e4SLinus Torvalds 31691da177e4SLinus Torvalds static struct aac_srb_status_info srb_status_info[] = { 31701da177e4SLinus Torvalds { SRB_STATUS_PENDING, "Pending Status"}, 31711da177e4SLinus Torvalds { SRB_STATUS_SUCCESS, "Success"}, 31721da177e4SLinus Torvalds { SRB_STATUS_ABORTED, "Aborted Command"}, 31731da177e4SLinus Torvalds { SRB_STATUS_ABORT_FAILED, "Abort Failed"}, 31741da177e4SLinus Torvalds { SRB_STATUS_ERROR, "Error Event"}, 31751da177e4SLinus Torvalds { SRB_STATUS_BUSY, "Device Busy"}, 31761da177e4SLinus Torvalds { SRB_STATUS_INVALID_REQUEST, "Invalid Request"}, 31771da177e4SLinus Torvalds { SRB_STATUS_INVALID_PATH_ID, "Invalid Path ID"}, 31781da177e4SLinus Torvalds { SRB_STATUS_NO_DEVICE, "No Device"}, 31791da177e4SLinus Torvalds { SRB_STATUS_TIMEOUT, "Timeout"}, 31801da177e4SLinus Torvalds { SRB_STATUS_SELECTION_TIMEOUT, "Selection Timeout"}, 31811da177e4SLinus Torvalds { SRB_STATUS_COMMAND_TIMEOUT, "Command Timeout"}, 31821da177e4SLinus Torvalds { SRB_STATUS_MESSAGE_REJECTED, "Message Rejected"}, 31831da177e4SLinus Torvalds { SRB_STATUS_BUS_RESET, "Bus Reset"}, 31841da177e4SLinus Torvalds { SRB_STATUS_PARITY_ERROR, "Parity Error"}, 31851da177e4SLinus Torvalds { SRB_STATUS_REQUEST_SENSE_FAILED,"Request Sense Failed"}, 31861da177e4SLinus Torvalds { SRB_STATUS_NO_HBA, "No HBA"}, 31871da177e4SLinus Torvalds { SRB_STATUS_DATA_OVERRUN, "Data Overrun/Data Underrun"}, 31881da177e4SLinus Torvalds { SRB_STATUS_UNEXPECTED_BUS_FREE,"Unexpected Bus Free"}, 31891da177e4SLinus Torvalds { SRB_STATUS_PHASE_SEQUENCE_FAILURE,"Phase Error"}, 31901da177e4SLinus Torvalds { SRB_STATUS_BAD_SRB_BLOCK_LENGTH,"Bad Srb Block Length"}, 31911da177e4SLinus Torvalds { SRB_STATUS_REQUEST_FLUSHED, "Request Flushed"}, 31921da177e4SLinus Torvalds { SRB_STATUS_DELAYED_RETRY, "Delayed Retry"}, 31931da177e4SLinus Torvalds { SRB_STATUS_INVALID_LUN, "Invalid LUN"}, 31941da177e4SLinus Torvalds { SRB_STATUS_INVALID_TARGET_ID, "Invalid TARGET ID"}, 31951da177e4SLinus Torvalds { SRB_STATUS_BAD_FUNCTION, "Bad Function"}, 31961da177e4SLinus Torvalds { SRB_STATUS_ERROR_RECOVERY, "Error Recovery"}, 31971da177e4SLinus Torvalds { SRB_STATUS_NOT_STARTED, "Not Started"}, 31981da177e4SLinus Torvalds { SRB_STATUS_NOT_IN_USE, "Not In Use"}, 31991da177e4SLinus Torvalds { SRB_STATUS_FORCE_ABORT, "Force Abort"}, 32001da177e4SLinus Torvalds { SRB_STATUS_DOMAIN_VALIDATION_FAIL,"Domain Validation Failure"}, 32011da177e4SLinus Torvalds { 0xff, "Unknown Error"} 32021da177e4SLinus Torvalds }; 32031da177e4SLinus Torvalds 32041da177e4SLinus Torvalds char *aac_get_status_string(u32 status) 32051da177e4SLinus Torvalds { 32061da177e4SLinus Torvalds int i; 32071da177e4SLinus Torvalds 32086391a113STobias Klauser for (i = 0; i < ARRAY_SIZE(srb_status_info); i++) 32096391a113STobias Klauser if (srb_status_info[i].status == status) 32101da177e4SLinus Torvalds return srb_status_info[i].str; 32111da177e4SLinus Torvalds 32121da177e4SLinus Torvalds return "Bad Status Code"; 32131da177e4SLinus Torvalds } 32141da177e4SLinus Torvalds 32151da177e4SLinus Torvalds #endif 3216