11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * Adaptec AAC series RAID controller driver 31da177e4SLinus Torvalds * (c) Copyright 2001 Red Hat Inc. <alan@redhat.com> 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * based on the old aacraid driver that is.. 61da177e4SLinus Torvalds * Adaptec aacraid device driver for Linux. 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * Copyright (c) 2000 Adaptec, Inc. (aacraid@adaptec.com) 91da177e4SLinus Torvalds * 101da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or modify 111da177e4SLinus Torvalds * it under the terms of the GNU General Public License as published by 121da177e4SLinus Torvalds * the Free Software Foundation; either version 2, or (at your option) 131da177e4SLinus Torvalds * any later version. 141da177e4SLinus Torvalds * 151da177e4SLinus Torvalds * This program is distributed in the hope that it will be useful, 161da177e4SLinus Torvalds * but WITHOUT ANY WARRANTY; without even the implied warranty of 171da177e4SLinus Torvalds * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 181da177e4SLinus Torvalds * GNU General Public License for more details. 191da177e4SLinus Torvalds * 201da177e4SLinus Torvalds * You should have received a copy of the GNU General Public License 211da177e4SLinus Torvalds * along with this program; see the file COPYING. If not, write to 221da177e4SLinus Torvalds * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 231da177e4SLinus Torvalds * 241da177e4SLinus Torvalds */ 251da177e4SLinus Torvalds 261da177e4SLinus Torvalds #include <linux/kernel.h> 271da177e4SLinus Torvalds #include <linux/init.h> 281da177e4SLinus Torvalds #include <linux/types.h> 291da177e4SLinus Torvalds #include <linux/pci.h> 301da177e4SLinus Torvalds #include <linux/spinlock.h> 311da177e4SLinus Torvalds #include <linux/slab.h> 321da177e4SLinus Torvalds #include <linux/completion.h> 331da177e4SLinus Torvalds #include <linux/blkdev.h> 34910638aeSMatthias Gehre #include <linux/dma-mapping.h> 351da177e4SLinus Torvalds #include <asm/semaphore.h> 361da177e4SLinus Torvalds #include <asm/uaccess.h> 371da177e4SLinus Torvalds 381da177e4SLinus Torvalds #include <scsi/scsi.h> 391da177e4SLinus Torvalds #include <scsi/scsi_cmnd.h> 401da177e4SLinus Torvalds #include <scsi/scsi_device.h> 411da177e4SLinus Torvalds #include <scsi/scsi_host.h> 421da177e4SLinus Torvalds 431da177e4SLinus Torvalds #include "aacraid.h" 441da177e4SLinus Torvalds 451da177e4SLinus Torvalds /* values for inqd_pdt: Peripheral device type in plain English */ 461da177e4SLinus Torvalds #define INQD_PDT_DA 0x00 /* Direct-access (DISK) device */ 471da177e4SLinus Torvalds #define INQD_PDT_PROC 0x03 /* Processor device */ 481da177e4SLinus Torvalds #define INQD_PDT_CHNGR 0x08 /* Changer (jukebox, scsi2) */ 491da177e4SLinus Torvalds #define INQD_PDT_COMM 0x09 /* Communication device (scsi2) */ 501da177e4SLinus Torvalds #define INQD_PDT_NOLUN2 0x1f /* Unknown Device (scsi2) */ 511da177e4SLinus Torvalds #define INQD_PDT_NOLUN 0x7f /* Logical Unit Not Present */ 521da177e4SLinus Torvalds 531da177e4SLinus Torvalds #define INQD_PDT_DMASK 0x1F /* Peripheral Device Type Mask */ 541da177e4SLinus Torvalds #define INQD_PDT_QMASK 0xE0 /* Peripheral Device Qualifer Mask */ 551da177e4SLinus Torvalds 561da177e4SLinus Torvalds /* 571da177e4SLinus Torvalds * Sense codes 581da177e4SLinus Torvalds */ 591da177e4SLinus Torvalds 601da177e4SLinus Torvalds #define SENCODE_NO_SENSE 0x00 611da177e4SLinus Torvalds #define SENCODE_END_OF_DATA 0x00 621da177e4SLinus Torvalds #define SENCODE_BECOMING_READY 0x04 631da177e4SLinus Torvalds #define SENCODE_INIT_CMD_REQUIRED 0x04 641da177e4SLinus Torvalds #define SENCODE_PARAM_LIST_LENGTH_ERROR 0x1A 651da177e4SLinus Torvalds #define SENCODE_INVALID_COMMAND 0x20 661da177e4SLinus Torvalds #define SENCODE_LBA_OUT_OF_RANGE 0x21 671da177e4SLinus Torvalds #define SENCODE_INVALID_CDB_FIELD 0x24 681da177e4SLinus Torvalds #define SENCODE_LUN_NOT_SUPPORTED 0x25 691da177e4SLinus Torvalds #define SENCODE_INVALID_PARAM_FIELD 0x26 701da177e4SLinus Torvalds #define SENCODE_PARAM_NOT_SUPPORTED 0x26 711da177e4SLinus Torvalds #define SENCODE_PARAM_VALUE_INVALID 0x26 721da177e4SLinus Torvalds #define SENCODE_RESET_OCCURRED 0x29 731da177e4SLinus Torvalds #define SENCODE_LUN_NOT_SELF_CONFIGURED_YET 0x3E 741da177e4SLinus Torvalds #define SENCODE_INQUIRY_DATA_CHANGED 0x3F 751da177e4SLinus Torvalds #define SENCODE_SAVING_PARAMS_NOT_SUPPORTED 0x39 761da177e4SLinus Torvalds #define SENCODE_DIAGNOSTIC_FAILURE 0x40 771da177e4SLinus Torvalds #define SENCODE_INTERNAL_TARGET_FAILURE 0x44 781da177e4SLinus Torvalds #define SENCODE_INVALID_MESSAGE_ERROR 0x49 791da177e4SLinus Torvalds #define SENCODE_LUN_FAILED_SELF_CONFIG 0x4c 801da177e4SLinus Torvalds #define SENCODE_OVERLAPPED_COMMAND 0x4E 811da177e4SLinus Torvalds 821da177e4SLinus Torvalds /* 831da177e4SLinus Torvalds * Additional sense codes 841da177e4SLinus Torvalds */ 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds #define ASENCODE_NO_SENSE 0x00 871da177e4SLinus Torvalds #define ASENCODE_END_OF_DATA 0x05 881da177e4SLinus Torvalds #define ASENCODE_BECOMING_READY 0x01 891da177e4SLinus Torvalds #define ASENCODE_INIT_CMD_REQUIRED 0x02 901da177e4SLinus Torvalds #define ASENCODE_PARAM_LIST_LENGTH_ERROR 0x00 911da177e4SLinus Torvalds #define ASENCODE_INVALID_COMMAND 0x00 921da177e4SLinus Torvalds #define ASENCODE_LBA_OUT_OF_RANGE 0x00 931da177e4SLinus Torvalds #define ASENCODE_INVALID_CDB_FIELD 0x00 941da177e4SLinus Torvalds #define ASENCODE_LUN_NOT_SUPPORTED 0x00 951da177e4SLinus Torvalds #define ASENCODE_INVALID_PARAM_FIELD 0x00 961da177e4SLinus Torvalds #define ASENCODE_PARAM_NOT_SUPPORTED 0x01 971da177e4SLinus Torvalds #define ASENCODE_PARAM_VALUE_INVALID 0x02 981da177e4SLinus Torvalds #define ASENCODE_RESET_OCCURRED 0x00 991da177e4SLinus Torvalds #define ASENCODE_LUN_NOT_SELF_CONFIGURED_YET 0x00 1001da177e4SLinus Torvalds #define ASENCODE_INQUIRY_DATA_CHANGED 0x03 1011da177e4SLinus Torvalds #define ASENCODE_SAVING_PARAMS_NOT_SUPPORTED 0x00 1021da177e4SLinus Torvalds #define ASENCODE_DIAGNOSTIC_FAILURE 0x80 1031da177e4SLinus Torvalds #define ASENCODE_INTERNAL_TARGET_FAILURE 0x00 1041da177e4SLinus Torvalds #define ASENCODE_INVALID_MESSAGE_ERROR 0x00 1051da177e4SLinus Torvalds #define ASENCODE_LUN_FAILED_SELF_CONFIG 0x00 1061da177e4SLinus Torvalds #define ASENCODE_OVERLAPPED_COMMAND 0x00 1071da177e4SLinus Torvalds 1081da177e4SLinus Torvalds #define BYTE0(x) (unsigned char)(x) 1091da177e4SLinus Torvalds #define BYTE1(x) (unsigned char)((x) >> 8) 1101da177e4SLinus Torvalds #define BYTE2(x) (unsigned char)((x) >> 16) 1111da177e4SLinus Torvalds #define BYTE3(x) (unsigned char)((x) >> 24) 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds /*------------------------------------------------------------------------------ 1141da177e4SLinus Torvalds * S T R U C T S / T Y P E D E F S 1151da177e4SLinus Torvalds *----------------------------------------------------------------------------*/ 1161da177e4SLinus Torvalds /* SCSI inquiry data */ 1171da177e4SLinus Torvalds struct inquiry_data { 1181da177e4SLinus Torvalds u8 inqd_pdt; /* Peripheral qualifier | Peripheral Device Type */ 1191da177e4SLinus Torvalds u8 inqd_dtq; /* RMB | Device Type Qualifier */ 1201da177e4SLinus Torvalds u8 inqd_ver; /* ISO version | ECMA version | ANSI-approved version */ 1211da177e4SLinus Torvalds u8 inqd_rdf; /* AENC | TrmIOP | Response data format */ 1221da177e4SLinus Torvalds u8 inqd_len; /* Additional length (n-4) */ 1231da177e4SLinus Torvalds u8 inqd_pad1[2];/* Reserved - must be zero */ 1241da177e4SLinus Torvalds u8 inqd_pad2; /* RelAdr | WBus32 | WBus16 | Sync | Linked |Reserved| CmdQue | SftRe */ 1251da177e4SLinus Torvalds u8 inqd_vid[8]; /* Vendor ID */ 1261da177e4SLinus Torvalds u8 inqd_pid[16];/* Product ID */ 1271da177e4SLinus Torvalds u8 inqd_prl[4]; /* Product Revision Level */ 1281da177e4SLinus Torvalds }; 1291da177e4SLinus Torvalds 1301da177e4SLinus Torvalds /* 1311da177e4SLinus Torvalds * M O D U L E G L O B A L S 1321da177e4SLinus Torvalds */ 1331da177e4SLinus Torvalds 1341da177e4SLinus Torvalds static unsigned long aac_build_sg(struct scsi_cmnd* scsicmd, struct sgmap* sgmap); 1351da177e4SLinus Torvalds static unsigned long aac_build_sg64(struct scsi_cmnd* scsicmd, struct sgmap64* psg); 1360e68c003SMark Haverkamp static unsigned long aac_build_sgraw(struct scsi_cmnd* scsicmd, struct sgmapraw* psg); 1371da177e4SLinus Torvalds static int aac_send_srb_fib(struct scsi_cmnd* scsicmd); 1381da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 1391da177e4SLinus Torvalds static char *aac_get_status_string(u32 status); 1401da177e4SLinus Torvalds #endif 1411da177e4SLinus Torvalds 1421da177e4SLinus Torvalds /* 1431da177e4SLinus Torvalds * Non dasd selection is handled entirely in aachba now 1441da177e4SLinus Torvalds */ 1451da177e4SLinus Torvalds 1461da177e4SLinus Torvalds static int nondasd = -1; 1471da177e4SLinus Torvalds static int dacmode = -1; 1481da177e4SLinus Torvalds 1491da177e4SLinus Torvalds static int commit = -1; 150404d9a90SMark Haverkamp int startup_timeout = 180; 151404d9a90SMark Haverkamp int aif_timeout = 120; 1521da177e4SLinus Torvalds 1539a72f976SMark Haverkamp module_param(nondasd, int, S_IRUGO|S_IWUSR); 1541da177e4SLinus Torvalds MODULE_PARM_DESC(nondasd, "Control scanning of hba for nondasd devices. 0=off, 1=on"); 1559a72f976SMark Haverkamp module_param(dacmode, int, S_IRUGO|S_IWUSR); 1561da177e4SLinus Torvalds MODULE_PARM_DESC(dacmode, "Control whether dma addressing is using 64 bit DAC. 0=off, 1=on"); 1579a72f976SMark Haverkamp module_param(commit, int, S_IRUGO|S_IWUSR); 1581da177e4SLinus Torvalds MODULE_PARM_DESC(commit, "Control whether a COMMIT_CONFIG is issued to the adapter for foreign arrays.\nThis is typically needed in systems that do not have a BIOS. 0=off, 1=on"); 159404d9a90SMark Haverkamp module_param(startup_timeout, int, S_IRUGO|S_IWUSR); 160404d9a90SMark Haverkamp MODULE_PARM_DESC(startup_timeout, "The duration of time in seconds to wait for adapter to have it's kernel up and\nrunning. This is typically adjusted for large systems that do not have a BIOS."); 161404d9a90SMark Haverkamp module_param(aif_timeout, int, S_IRUGO|S_IWUSR); 162404d9a90SMark Haverkamp MODULE_PARM_DESC(aif_timeout, "The duration of time in seconds to wait for applications to pick up AIFs before\nderegistering them. This is typically adjusted for heavily burdened systems."); 1631da177e4SLinus Torvalds 1647c00ffa3SMark Haverkamp int numacb = -1; 1657c00ffa3SMark Haverkamp module_param(numacb, int, S_IRUGO|S_IWUSR); 1669a72f976SMark Haverkamp MODULE_PARM_DESC(numacb, "Request a limit to the number of adapter control blocks (FIB) allocated. Valid values are 512 and down. Default is to use suggestion from Firmware."); 1677c00ffa3SMark Haverkamp 1687c00ffa3SMark Haverkamp int acbsize = -1; 1697c00ffa3SMark Haverkamp module_param(acbsize, int, S_IRUGO|S_IWUSR); 1709a72f976SMark Haverkamp MODULE_PARM_DESC(acbsize, "Request a specific adapter control block (FIB) size. Valid values are 512, 2048, 4096 and 8192. Default is to use suggestion from Firmware."); 171653ba58dSMark Haverkamp 172e37ee4beSMark Haverkamp int expose_physicals = -1; 173653ba58dSMark Haverkamp module_param(expose_physicals, int, S_IRUGO|S_IWUSR); 174e37ee4beSMark Haverkamp MODULE_PARM_DESC(expose_physicals, "Expose physical components of the arrays. -1=protect 0=off, 1=on"); 1751da177e4SLinus Torvalds /** 1761da177e4SLinus Torvalds * aac_get_config_status - check the adapter configuration 1771da177e4SLinus Torvalds * @common: adapter to query 1781da177e4SLinus Torvalds * 1791da177e4SLinus Torvalds * Query config status, and commit the configuration if needed. 1801da177e4SLinus Torvalds */ 1818c867b25SMark Haverkamp int aac_get_config_status(struct aac_dev *dev, int commit_flag) 1821da177e4SLinus Torvalds { 1831da177e4SLinus Torvalds int status = 0; 1841da177e4SLinus Torvalds struct fib * fibptr; 1851da177e4SLinus Torvalds 186bfb35aa8SMark Haverkamp if (!(fibptr = aac_fib_alloc(dev))) 1871da177e4SLinus Torvalds return -ENOMEM; 1881da177e4SLinus Torvalds 189bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 1901da177e4SLinus Torvalds { 1911da177e4SLinus Torvalds struct aac_get_config_status *dinfo; 1921da177e4SLinus Torvalds dinfo = (struct aac_get_config_status *) fib_data(fibptr); 1931da177e4SLinus Torvalds 1941da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 1951da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_GET_CONFIG_STATUS); 1961da177e4SLinus Torvalds dinfo->count = cpu_to_le32(sizeof(((struct aac_get_config_status_resp *)NULL)->data)); 1971da177e4SLinus Torvalds } 1981da177e4SLinus Torvalds 199bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 2001da177e4SLinus Torvalds fibptr, 2011da177e4SLinus Torvalds sizeof (struct aac_get_config_status), 2021da177e4SLinus Torvalds FsaNormal, 2031da177e4SLinus Torvalds 1, 1, 2041da177e4SLinus Torvalds NULL, NULL); 2051da177e4SLinus Torvalds if (status < 0 ) { 2061da177e4SLinus Torvalds printk(KERN_WARNING "aac_get_config_status: SendFIB failed.\n"); 2071da177e4SLinus Torvalds } else { 2081da177e4SLinus Torvalds struct aac_get_config_status_resp *reply 2091da177e4SLinus Torvalds = (struct aac_get_config_status_resp *) fib_data(fibptr); 2101da177e4SLinus Torvalds dprintk((KERN_WARNING 2111da177e4SLinus Torvalds "aac_get_config_status: response=%d status=%d action=%d\n", 2121da177e4SLinus Torvalds le32_to_cpu(reply->response), 2131da177e4SLinus Torvalds le32_to_cpu(reply->status), 2141da177e4SLinus Torvalds le32_to_cpu(reply->data.action))); 2151da177e4SLinus Torvalds if ((le32_to_cpu(reply->response) != ST_OK) || 2161da177e4SLinus Torvalds (le32_to_cpu(reply->status) != CT_OK) || 2171da177e4SLinus Torvalds (le32_to_cpu(reply->data.action) > CFACT_PAUSE)) { 2181da177e4SLinus Torvalds printk(KERN_WARNING "aac_get_config_status: Will not issue the Commit Configuration\n"); 2191da177e4SLinus Torvalds status = -EINVAL; 2201da177e4SLinus Torvalds } 2211da177e4SLinus Torvalds } 222bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 2231da177e4SLinus Torvalds /* Send a CT_COMMIT_CONFIG to enable discovery of devices */ 2241da177e4SLinus Torvalds if (status >= 0) { 2258c867b25SMark Haverkamp if ((commit == 1) || commit_flag) { 2261da177e4SLinus Torvalds struct aac_commit_config * dinfo; 227bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 2281da177e4SLinus Torvalds dinfo = (struct aac_commit_config *) fib_data(fibptr); 2291da177e4SLinus Torvalds 2301da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 2311da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_COMMIT_CONFIG); 2321da177e4SLinus Torvalds 233bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 2341da177e4SLinus Torvalds fibptr, 2351da177e4SLinus Torvalds sizeof (struct aac_commit_config), 2361da177e4SLinus Torvalds FsaNormal, 2371da177e4SLinus Torvalds 1, 1, 2381da177e4SLinus Torvalds NULL, NULL); 239bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 2401da177e4SLinus Torvalds } else if (commit == 0) { 2411da177e4SLinus Torvalds printk(KERN_WARNING 2421da177e4SLinus Torvalds "aac_get_config_status: Foreign device configurations are being ignored\n"); 2431da177e4SLinus Torvalds } 2441da177e4SLinus Torvalds } 245bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 2461da177e4SLinus Torvalds return status; 2471da177e4SLinus Torvalds } 2481da177e4SLinus Torvalds 2491da177e4SLinus Torvalds /** 2501da177e4SLinus Torvalds * aac_get_containers - list containers 2511da177e4SLinus Torvalds * @common: adapter to probe 2521da177e4SLinus Torvalds * 2531da177e4SLinus Torvalds * Make a list of all containers on this controller 2541da177e4SLinus Torvalds */ 2551da177e4SLinus Torvalds int aac_get_containers(struct aac_dev *dev) 2561da177e4SLinus Torvalds { 2571da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 2581da177e4SLinus Torvalds u32 index; 2591da177e4SLinus Torvalds int status = 0; 2601da177e4SLinus Torvalds struct fib * fibptr; 2611da177e4SLinus Torvalds struct aac_get_container_count *dinfo; 2621da177e4SLinus Torvalds struct aac_get_container_count_resp *dresp; 2631da177e4SLinus Torvalds int maximum_num_containers = MAXIMUM_NUM_CONTAINERS; 2641da177e4SLinus Torvalds 265bfb35aa8SMark Haverkamp if (!(fibptr = aac_fib_alloc(dev))) 2661da177e4SLinus Torvalds return -ENOMEM; 2671da177e4SLinus Torvalds 268bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 2691da177e4SLinus Torvalds dinfo = (struct aac_get_container_count *) fib_data(fibptr); 2701da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 2711da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_GET_CONTAINER_COUNT); 2721da177e4SLinus Torvalds 273bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 2741da177e4SLinus Torvalds fibptr, 2751da177e4SLinus Torvalds sizeof (struct aac_get_container_count), 2761da177e4SLinus Torvalds FsaNormal, 2771da177e4SLinus Torvalds 1, 1, 2781da177e4SLinus Torvalds NULL, NULL); 2791da177e4SLinus Torvalds if (status >= 0) { 2801da177e4SLinus Torvalds dresp = (struct aac_get_container_count_resp *)fib_data(fibptr); 2811da177e4SLinus Torvalds maximum_num_containers = le32_to_cpu(dresp->ContainerSwitchEntries); 282bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 2831da177e4SLinus Torvalds } 284fe76df42SMark Haverkamp aac_fib_free(fibptr); 2851da177e4SLinus Torvalds 2861da177e4SLinus Torvalds if (maximum_num_containers < MAXIMUM_NUM_CONTAINERS) 2871da177e4SLinus Torvalds maximum_num_containers = MAXIMUM_NUM_CONTAINERS; 288fe76df42SMark Haverkamp fsa_dev_ptr = kmalloc(sizeof(*fsa_dev_ptr) * maximum_num_containers, 289fe76df42SMark Haverkamp GFP_KERNEL); 290fe76df42SMark Haverkamp if (!fsa_dev_ptr) 2911da177e4SLinus Torvalds return -ENOMEM; 2921da177e4SLinus Torvalds memset(fsa_dev_ptr, 0, sizeof(*fsa_dev_ptr) * maximum_num_containers); 2931da177e4SLinus Torvalds 2941da177e4SLinus Torvalds dev->fsa_dev = fsa_dev_ptr; 2951da177e4SLinus Torvalds dev->maximum_num_containers = maximum_num_containers; 2961da177e4SLinus Torvalds 297fe76df42SMark Haverkamp for (index = 0; index < dev->maximum_num_containers; ) { 2981da177e4SLinus Torvalds fsa_dev_ptr[index].devname[0] = '\0'; 2991da177e4SLinus Torvalds 300fe76df42SMark Haverkamp status = aac_probe_container(dev, index); 3011da177e4SLinus Torvalds 3021da177e4SLinus Torvalds if (status < 0) { 3031da177e4SLinus Torvalds printk(KERN_WARNING "aac_get_containers: SendFIB failed.\n"); 3041da177e4SLinus Torvalds break; 3051da177e4SLinus Torvalds } 3061da177e4SLinus Torvalds 3071da177e4SLinus Torvalds /* 3081da177e4SLinus Torvalds * If there are no more containers, then stop asking. 3091da177e4SLinus Torvalds */ 310fe76df42SMark Haverkamp if (++index >= status) 3111da177e4SLinus Torvalds break; 3121da177e4SLinus Torvalds } 3131da177e4SLinus Torvalds return status; 3141da177e4SLinus Torvalds } 3151da177e4SLinus Torvalds 3163b2946ccSMark Haverkamp static void aac_internal_transfer(struct scsi_cmnd *scsicmd, void *data, unsigned int offset, unsigned int len) 3173b2946ccSMark Haverkamp { 3183b2946ccSMark Haverkamp void *buf; 3193b2946ccSMark Haverkamp unsigned int transfer_len; 3203b2946ccSMark Haverkamp struct scatterlist *sg = scsicmd->request_buffer; 3213b2946ccSMark Haverkamp 3223b2946ccSMark Haverkamp if (scsicmd->use_sg) { 3233b2946ccSMark Haverkamp buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset; 3243b2946ccSMark Haverkamp transfer_len = min(sg->length, len + offset); 3253b2946ccSMark Haverkamp } else { 3263b2946ccSMark Haverkamp buf = scsicmd->request_buffer; 3273b2946ccSMark Haverkamp transfer_len = min(scsicmd->request_bufflen, len + offset); 3283b2946ccSMark Haverkamp } 3293b2946ccSMark Haverkamp 3303b2946ccSMark Haverkamp memcpy(buf + offset, data, transfer_len - offset); 3313b2946ccSMark Haverkamp 3323b2946ccSMark Haverkamp if (scsicmd->use_sg) 3333b2946ccSMark Haverkamp kunmap_atomic(buf - sg->offset, KM_IRQ0); 3343b2946ccSMark Haverkamp 3353b2946ccSMark Haverkamp } 3363b2946ccSMark Haverkamp 3371da177e4SLinus Torvalds static void get_container_name_callback(void *context, struct fib * fibptr) 3381da177e4SLinus Torvalds { 3391da177e4SLinus Torvalds struct aac_get_name_resp * get_name_reply; 3401da177e4SLinus Torvalds struct scsi_cmnd * scsicmd; 3411da177e4SLinus Torvalds 3421da177e4SLinus Torvalds scsicmd = (struct scsi_cmnd *) context; 34377d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL; 3441da177e4SLinus Torvalds 3451da177e4SLinus Torvalds dprintk((KERN_DEBUG "get_container_name_callback[cpu %d]: t = %ld.\n", smp_processor_id(), jiffies)); 346125e1874SEric Sesterhenn BUG_ON(fibptr == NULL); 3471da177e4SLinus Torvalds 3481da177e4SLinus Torvalds get_name_reply = (struct aac_get_name_resp *) fib_data(fibptr); 3491da177e4SLinus Torvalds /* Failure is irrelevant, using default value instead */ 3501da177e4SLinus Torvalds if ((le32_to_cpu(get_name_reply->status) == CT_OK) 3511da177e4SLinus Torvalds && (get_name_reply->data[0] != '\0')) { 3521da177e4SLinus Torvalds char *sp = get_name_reply->data; 3531da177e4SLinus Torvalds sp[sizeof(((struct aac_get_name_resp *)NULL)->data)-1] = '\0'; 3541da177e4SLinus Torvalds while (*sp == ' ') 3551da177e4SLinus Torvalds ++sp; 3563b2946ccSMark Haverkamp if (*sp) { 3573b2946ccSMark Haverkamp char d[sizeof(((struct inquiry_data *)NULL)->inqd_pid)]; 3583b2946ccSMark Haverkamp int count = sizeof(d); 3593b2946ccSMark Haverkamp char *dp = d; 3603b2946ccSMark Haverkamp do { 3611da177e4SLinus Torvalds *dp++ = (*sp) ? *sp++ : ' '; 3621da177e4SLinus Torvalds } while (--count > 0); 3633b2946ccSMark Haverkamp aac_internal_transfer(scsicmd, d, 3643b2946ccSMark Haverkamp offsetof(struct inquiry_data, inqd_pid), sizeof(d)); 3651da177e4SLinus Torvalds } 3663b2946ccSMark Haverkamp } 3673b2946ccSMark Haverkamp 3681da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 3691da177e4SLinus Torvalds 370bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 371bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 3728e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 3731da177e4SLinus Torvalds } 3741da177e4SLinus Torvalds 3751da177e4SLinus Torvalds /** 3761da177e4SLinus Torvalds * aac_get_container_name - get container name, none blocking. 3771da177e4SLinus Torvalds */ 3781da177e4SLinus Torvalds static int aac_get_container_name(struct scsi_cmnd * scsicmd, int cid) 3791da177e4SLinus Torvalds { 3801da177e4SLinus Torvalds int status; 3811da177e4SLinus Torvalds struct aac_get_name *dinfo; 3821da177e4SLinus Torvalds struct fib * cmd_fibcontext; 3831da177e4SLinus Torvalds struct aac_dev * dev; 3841da177e4SLinus Torvalds 3851da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 3861da177e4SLinus Torvalds 387bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) 3881da177e4SLinus Torvalds return -ENOMEM; 3891da177e4SLinus Torvalds 390bfb35aa8SMark Haverkamp aac_fib_init(cmd_fibcontext); 3911da177e4SLinus Torvalds dinfo = (struct aac_get_name *) fib_data(cmd_fibcontext); 3921da177e4SLinus Torvalds 3931da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 3941da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_READ_NAME); 3951da177e4SLinus Torvalds dinfo->cid = cpu_to_le32(cid); 3961da177e4SLinus Torvalds dinfo->count = cpu_to_le32(sizeof(((struct aac_get_name_resp *)NULL)->data)); 3971da177e4SLinus Torvalds 398bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 3991da177e4SLinus Torvalds cmd_fibcontext, 4001da177e4SLinus Torvalds sizeof (struct aac_get_name), 4011da177e4SLinus Torvalds FsaNormal, 4021da177e4SLinus Torvalds 0, 1, 4031da177e4SLinus Torvalds (fib_callback) get_container_name_callback, 4041da177e4SLinus Torvalds (void *) scsicmd); 4051da177e4SLinus Torvalds 4061da177e4SLinus Torvalds /* 4071da177e4SLinus Torvalds * Check that the command queued to the controller 4081da177e4SLinus Torvalds */ 40977d644d4SMark Haverkamp if (status == -EINPROGRESS) { 41077d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 4111da177e4SLinus Torvalds return 0; 41277d644d4SMark Haverkamp } 4131da177e4SLinus Torvalds 414bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_get_container_name: aac_fib_send failed with status: %d.\n", status); 415bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 416bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 4171da177e4SLinus Torvalds return -1; 4181da177e4SLinus Torvalds } 4191da177e4SLinus Torvalds 420fe76df42SMark Haverkamp static int aac_probe_container_callback2(struct scsi_cmnd * scsicmd) 421fe76df42SMark Haverkamp { 422fe76df42SMark Haverkamp struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev; 423fe76df42SMark Haverkamp 424fe76df42SMark Haverkamp if (fsa_dev_ptr[scmd_id(scsicmd)].valid) 425fe76df42SMark Haverkamp return aac_scsi_cmd(scsicmd); 426fe76df42SMark Haverkamp 427fe76df42SMark Haverkamp scsicmd->result = DID_NO_CONNECT << 16; 428fe76df42SMark Haverkamp scsicmd->scsi_done(scsicmd); 429fe76df42SMark Haverkamp return 0; 430fe76df42SMark Haverkamp } 431fe76df42SMark Haverkamp 432fe76df42SMark Haverkamp static int _aac_probe_container2(void * context, struct fib * fibptr) 433fe76df42SMark Haverkamp { 434fe76df42SMark Haverkamp struct scsi_cmnd * scsicmd = (struct scsi_cmnd *)context; 435fe76df42SMark Haverkamp struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev; 436fe76df42SMark Haverkamp int (*callback)(struct scsi_cmnd *); 437fe76df42SMark Haverkamp 438fe76df42SMark Haverkamp scsicmd->SCp.Status = 0; 439fe76df42SMark Haverkamp if (fsa_dev_ptr) { 440fe76df42SMark Haverkamp struct aac_mount * dresp = (struct aac_mount *) fib_data(fibptr); 441fe76df42SMark Haverkamp fsa_dev_ptr += scmd_id(scsicmd); 442fe76df42SMark Haverkamp 443fe76df42SMark Haverkamp if ((le32_to_cpu(dresp->status) == ST_OK) && 444fe76df42SMark Haverkamp (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE) && 445fe76df42SMark Haverkamp (le32_to_cpu(dresp->mnt[0].state) != FSCS_HIDDEN)) { 446fe76df42SMark Haverkamp fsa_dev_ptr->valid = 1; 447fe76df42SMark Haverkamp fsa_dev_ptr->type = le32_to_cpu(dresp->mnt[0].vol); 448fe76df42SMark Haverkamp fsa_dev_ptr->size 449fe76df42SMark Haverkamp = ((u64)le32_to_cpu(dresp->mnt[0].capacity)) + 450fe76df42SMark Haverkamp (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32); 451fe76df42SMark Haverkamp fsa_dev_ptr->ro = ((le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY) != 0); 452fe76df42SMark Haverkamp } 453fe76df42SMark Haverkamp if ((fsa_dev_ptr->valid & 1) == 0) 454fe76df42SMark Haverkamp fsa_dev_ptr->valid = 0; 455fe76df42SMark Haverkamp scsicmd->SCp.Status = le32_to_cpu(dresp->count); 456fe76df42SMark Haverkamp } 457fe76df42SMark Haverkamp aac_fib_complete(fibptr); 458fe76df42SMark Haverkamp aac_fib_free(fibptr); 459fe76df42SMark Haverkamp callback = (int (*)(struct scsi_cmnd *))(scsicmd->SCp.ptr); 460fe76df42SMark Haverkamp scsicmd->SCp.ptr = NULL; 461fe76df42SMark Haverkamp return (*callback)(scsicmd); 462fe76df42SMark Haverkamp } 463fe76df42SMark Haverkamp 464fe76df42SMark Haverkamp static int _aac_probe_container1(void * context, struct fib * fibptr) 465fe76df42SMark Haverkamp { 466fe76df42SMark Haverkamp struct scsi_cmnd * scsicmd; 467fe76df42SMark Haverkamp struct aac_mount * dresp; 468fe76df42SMark Haverkamp struct aac_query_mount *dinfo; 469fe76df42SMark Haverkamp int status; 470fe76df42SMark Haverkamp 471fe76df42SMark Haverkamp dresp = (struct aac_mount *) fib_data(fibptr); 472fe76df42SMark Haverkamp dresp->mnt[0].capacityhigh = 0; 473fe76df42SMark Haverkamp if ((le32_to_cpu(dresp->status) != ST_OK) || 474fe76df42SMark Haverkamp ((le32_to_cpu(dresp->mnt[0].vol) != CT_NONE) && 475fe76df42SMark Haverkamp (le32_to_cpu(dresp->mnt[0].state) == FSCS_HIDDEN))) 476fe76df42SMark Haverkamp return _aac_probe_container2(context, fibptr); 477fe76df42SMark Haverkamp scsicmd = (struct scsi_cmnd *) context; 478fe76df42SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL; 479fe76df42SMark Haverkamp 480fe76df42SMark Haverkamp aac_fib_init(fibptr); 481fe76df42SMark Haverkamp 482fe76df42SMark Haverkamp dinfo = (struct aac_query_mount *)fib_data(fibptr); 483fe76df42SMark Haverkamp 484fe76df42SMark Haverkamp dinfo->command = cpu_to_le32(VM_NameServe64); 485fe76df42SMark Haverkamp dinfo->count = cpu_to_le32(scmd_id(scsicmd)); 486fe76df42SMark Haverkamp dinfo->type = cpu_to_le32(FT_FILESYS); 487fe76df42SMark Haverkamp 488fe76df42SMark Haverkamp status = aac_fib_send(ContainerCommand, 489fe76df42SMark Haverkamp fibptr, 490fe76df42SMark Haverkamp sizeof(struct aac_query_mount), 491fe76df42SMark Haverkamp FsaNormal, 492fe76df42SMark Haverkamp 0, 1, 493fe76df42SMark Haverkamp (fib_callback) _aac_probe_container2, 494fe76df42SMark Haverkamp (void *) scsicmd); 495fe76df42SMark Haverkamp /* 496fe76df42SMark Haverkamp * Check that the command queued to the controller 497fe76df42SMark Haverkamp */ 498fe76df42SMark Haverkamp if (status == -EINPROGRESS) { 499fe76df42SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 500fe76df42SMark Haverkamp return 0; 501fe76df42SMark Haverkamp } 502fe76df42SMark Haverkamp if (status < 0) { 503fe76df42SMark Haverkamp /* Inherit results from VM_NameServe, if any */ 504fe76df42SMark Haverkamp dresp->status = cpu_to_le32(ST_OK); 505fe76df42SMark Haverkamp return _aac_probe_container2(context, fibptr); 506fe76df42SMark Haverkamp } 507fe76df42SMark Haverkamp return 0; 508fe76df42SMark Haverkamp } 509fe76df42SMark Haverkamp 510fe76df42SMark Haverkamp static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(struct scsi_cmnd *)) 511fe76df42SMark Haverkamp { 512fe76df42SMark Haverkamp struct fib * fibptr; 513fe76df42SMark Haverkamp int status = -ENOMEM; 514fe76df42SMark Haverkamp 515fe76df42SMark Haverkamp if ((fibptr = aac_fib_alloc((struct aac_dev *)scsicmd->device->host->hostdata))) { 516fe76df42SMark Haverkamp struct aac_query_mount *dinfo; 517fe76df42SMark Haverkamp 518fe76df42SMark Haverkamp aac_fib_init(fibptr); 519fe76df42SMark Haverkamp 520fe76df42SMark Haverkamp dinfo = (struct aac_query_mount *)fib_data(fibptr); 521fe76df42SMark Haverkamp 522fe76df42SMark Haverkamp dinfo->command = cpu_to_le32(VM_NameServe); 523fe76df42SMark Haverkamp dinfo->count = cpu_to_le32(scmd_id(scsicmd)); 524fe76df42SMark Haverkamp dinfo->type = cpu_to_le32(FT_FILESYS); 525fe76df42SMark Haverkamp scsicmd->SCp.ptr = (char *)callback; 526fe76df42SMark Haverkamp 527fe76df42SMark Haverkamp status = aac_fib_send(ContainerCommand, 528fe76df42SMark Haverkamp fibptr, 529fe76df42SMark Haverkamp sizeof(struct aac_query_mount), 530fe76df42SMark Haverkamp FsaNormal, 531fe76df42SMark Haverkamp 0, 1, 532fe76df42SMark Haverkamp (fib_callback) _aac_probe_container1, 533fe76df42SMark Haverkamp (void *) scsicmd); 534fe76df42SMark Haverkamp /* 535fe76df42SMark Haverkamp * Check that the command queued to the controller 536fe76df42SMark Haverkamp */ 537fe76df42SMark Haverkamp if (status == -EINPROGRESS) { 538fe76df42SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 539fe76df42SMark Haverkamp return 0; 540fe76df42SMark Haverkamp } 541fe76df42SMark Haverkamp if (status < 0) { 542fe76df42SMark Haverkamp scsicmd->SCp.ptr = NULL; 543fe76df42SMark Haverkamp aac_fib_complete(fibptr); 544fe76df42SMark Haverkamp aac_fib_free(fibptr); 545fe76df42SMark Haverkamp } 546fe76df42SMark Haverkamp } 547fe76df42SMark Haverkamp if (status < 0) { 548fe76df42SMark Haverkamp struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev; 549fe76df42SMark Haverkamp if (fsa_dev_ptr) { 550fe76df42SMark Haverkamp fsa_dev_ptr += scmd_id(scsicmd); 551fe76df42SMark Haverkamp if ((fsa_dev_ptr->valid & 1) == 0) { 552fe76df42SMark Haverkamp fsa_dev_ptr->valid = 0; 553fe76df42SMark Haverkamp return (*callback)(scsicmd); 554fe76df42SMark Haverkamp } 555fe76df42SMark Haverkamp } 556fe76df42SMark Haverkamp } 557fe76df42SMark Haverkamp return status; 558fe76df42SMark Haverkamp } 559fe76df42SMark Haverkamp 5601da177e4SLinus Torvalds /** 561bfb35aa8SMark Haverkamp * aac_probe_container - query a logical volume 5621da177e4SLinus Torvalds * @dev: device to query 5631da177e4SLinus Torvalds * @cid: container identifier 5641da177e4SLinus Torvalds * 5651da177e4SLinus Torvalds * Queries the controller about the given volume. The volume information 5661da177e4SLinus Torvalds * is updated in the struct fsa_dev_info structure rather than returned. 5671da177e4SLinus Torvalds */ 568fe76df42SMark Haverkamp static int aac_probe_container_callback1(struct scsi_cmnd * scsicmd) 569fe76df42SMark Haverkamp { 570fe76df42SMark Haverkamp scsicmd->device = NULL; 571fe76df42SMark Haverkamp return 0; 572fe76df42SMark Haverkamp } 5731da177e4SLinus Torvalds 574bfb35aa8SMark Haverkamp int aac_probe_container(struct aac_dev *dev, int cid) 5751da177e4SLinus Torvalds { 576fe76df42SMark Haverkamp struct scsi_cmnd *scsicmd = kmalloc(sizeof(*scsicmd), GFP_KERNEL); 577fe76df42SMark Haverkamp struct scsi_device *scsidev = kmalloc(sizeof(*scsidev), GFP_KERNEL); 5781da177e4SLinus Torvalds int status; 5791da177e4SLinus Torvalds 580fe76df42SMark Haverkamp if (!scsicmd || !scsidev) { 581fe76df42SMark Haverkamp kfree(scsicmd); 582fe76df42SMark Haverkamp kfree(scsidev); 58390ee3466SMark Haverkamp return -ENOMEM; 5841da177e4SLinus Torvalds } 585fe76df42SMark Haverkamp scsicmd->list.next = NULL; 586fe76df42SMark Haverkamp scsicmd->scsi_done = (void (*)(struct scsi_cmnd*))_aac_probe_container1; 5871da177e4SLinus Torvalds 588fe76df42SMark Haverkamp scsicmd->device = scsidev; 589fe76df42SMark Haverkamp scsidev->sdev_state = 0; 590fe76df42SMark Haverkamp scsidev->id = cid; 591fe76df42SMark Haverkamp scsidev->host = dev->scsi_host_ptr; 5921da177e4SLinus Torvalds 593fe76df42SMark Haverkamp if (_aac_probe_container(scsicmd, aac_probe_container_callback1) == 0) 594fe76df42SMark Haverkamp while (scsicmd->device == scsidev) 595fe76df42SMark Haverkamp schedule(); 596fe76df42SMark Haverkamp status = scsicmd->SCp.Status; 597fe76df42SMark Haverkamp kfree(scsicmd); 598fe76df42SMark Haverkamp kfree(scsidev); 5991da177e4SLinus Torvalds return status; 6001da177e4SLinus Torvalds } 6011da177e4SLinus Torvalds 6021da177e4SLinus Torvalds /* Local Structure to set SCSI inquiry data strings */ 6031da177e4SLinus Torvalds struct scsi_inq { 6041da177e4SLinus Torvalds char vid[8]; /* Vendor ID */ 6051da177e4SLinus Torvalds char pid[16]; /* Product ID */ 6061da177e4SLinus Torvalds char prl[4]; /* Product Revision Level */ 6071da177e4SLinus Torvalds }; 6081da177e4SLinus Torvalds 6091da177e4SLinus Torvalds /** 6101da177e4SLinus Torvalds * InqStrCopy - string merge 6111da177e4SLinus Torvalds * @a: string to copy from 6121da177e4SLinus Torvalds * @b: string to copy to 6131da177e4SLinus Torvalds * 6141da177e4SLinus Torvalds * Copy a String from one location to another 6151da177e4SLinus Torvalds * without copying \0 6161da177e4SLinus Torvalds */ 6171da177e4SLinus Torvalds 6181da177e4SLinus Torvalds static void inqstrcpy(char *a, char *b) 6191da177e4SLinus Torvalds { 6201da177e4SLinus Torvalds 6211da177e4SLinus Torvalds while(*a != (char)0) 6221da177e4SLinus Torvalds *b++ = *a++; 6231da177e4SLinus Torvalds } 6241da177e4SLinus Torvalds 6251da177e4SLinus Torvalds static char *container_types[] = { 6261da177e4SLinus Torvalds "None", 6271da177e4SLinus Torvalds "Volume", 6281da177e4SLinus Torvalds "Mirror", 6291da177e4SLinus Torvalds "Stripe", 6301da177e4SLinus Torvalds "RAID5", 6311da177e4SLinus Torvalds "SSRW", 6321da177e4SLinus Torvalds "SSRO", 6331da177e4SLinus Torvalds "Morph", 6341da177e4SLinus Torvalds "Legacy", 6351da177e4SLinus Torvalds "RAID4", 6361da177e4SLinus Torvalds "RAID10", 6371da177e4SLinus Torvalds "RAID00", 6381da177e4SLinus Torvalds "V-MIRRORS", 6391da177e4SLinus Torvalds "PSEUDO R4", 6401da177e4SLinus Torvalds "RAID50", 64184971738SMark Haverkamp "RAID5D", 64284971738SMark Haverkamp "RAID5D0", 64384971738SMark Haverkamp "RAID1E", 64484971738SMark Haverkamp "RAID6", 64584971738SMark Haverkamp "RAID60", 6461da177e4SLinus Torvalds "Unknown" 6471da177e4SLinus Torvalds }; 6481da177e4SLinus Torvalds 6491da177e4SLinus Torvalds 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds /* Function: setinqstr 6521da177e4SLinus Torvalds * 6531da177e4SLinus Torvalds * Arguments: [1] pointer to void [1] int 6541da177e4SLinus Torvalds * 6551da177e4SLinus Torvalds * Purpose: Sets SCSI inquiry data strings for vendor, product 6561da177e4SLinus Torvalds * and revision level. Allows strings to be set in platform dependant 6571da177e4SLinus Torvalds * files instead of in OS dependant driver source. 6581da177e4SLinus Torvalds */ 6591da177e4SLinus Torvalds 660794d0601SMark Haverkamp static void setinqstr(struct aac_dev *dev, void *data, int tindex) 6611da177e4SLinus Torvalds { 6621da177e4SLinus Torvalds struct scsi_inq *str; 6631da177e4SLinus Torvalds 6641da177e4SLinus Torvalds str = (struct scsi_inq *)(data); /* cast data to scsi inq block */ 665794d0601SMark Haverkamp memset(str, ' ', sizeof(*str)); 666794d0601SMark Haverkamp 667794d0601SMark Haverkamp if (dev->supplement_adapter_info.AdapterTypeText[0]) { 668794d0601SMark Haverkamp char * cp = dev->supplement_adapter_info.AdapterTypeText; 669794d0601SMark Haverkamp int c = sizeof(str->vid); 670794d0601SMark Haverkamp while (*cp && *cp != ' ' && --c) 671794d0601SMark Haverkamp ++cp; 672794d0601SMark Haverkamp c = *cp; 673794d0601SMark Haverkamp *cp = '\0'; 674794d0601SMark Haverkamp inqstrcpy (dev->supplement_adapter_info.AdapterTypeText, 675794d0601SMark Haverkamp str->vid); 676794d0601SMark Haverkamp *cp = c; 677794d0601SMark Haverkamp while (*cp && *cp != ' ') 678794d0601SMark Haverkamp ++cp; 679794d0601SMark Haverkamp while (*cp == ' ') 680794d0601SMark Haverkamp ++cp; 681794d0601SMark Haverkamp /* last six chars reserved for vol type */ 682794d0601SMark Haverkamp c = 0; 683794d0601SMark Haverkamp if (strlen(cp) > sizeof(str->pid)) { 684794d0601SMark Haverkamp c = cp[sizeof(str->pid)]; 685794d0601SMark Haverkamp cp[sizeof(str->pid)] = '\0'; 686794d0601SMark Haverkamp } 687794d0601SMark Haverkamp inqstrcpy (cp, str->pid); 688794d0601SMark Haverkamp if (c) 689794d0601SMark Haverkamp cp[sizeof(str->pid)] = c; 690794d0601SMark Haverkamp } else { 691794d0601SMark Haverkamp struct aac_driver_ident *mp = aac_get_driver_ident(dev->cardtype); 6921da177e4SLinus Torvalds 6931da177e4SLinus Torvalds inqstrcpy (mp->vname, str->vid); 694794d0601SMark Haverkamp /* last six chars reserved for vol type */ 695794d0601SMark Haverkamp inqstrcpy (mp->model, str->pid); 696794d0601SMark Haverkamp } 6971da177e4SLinus Torvalds 6986391a113STobias Klauser if (tindex < ARRAY_SIZE(container_types)){ 6991da177e4SLinus Torvalds char *findit = str->pid; 7001da177e4SLinus Torvalds 7011da177e4SLinus Torvalds for ( ; *findit != ' '; findit++); /* walk till we find a space */ 7021da177e4SLinus Torvalds /* RAID is superfluous in the context of a RAID device */ 7031da177e4SLinus Torvalds if (memcmp(findit-4, "RAID", 4) == 0) 7041da177e4SLinus Torvalds *(findit -= 4) = ' '; 705794d0601SMark Haverkamp if (((findit - str->pid) + strlen(container_types[tindex])) 706794d0601SMark Haverkamp < (sizeof(str->pid) + sizeof(str->prl))) 7071da177e4SLinus Torvalds inqstrcpy (container_types[tindex], findit + 1); 7081da177e4SLinus Torvalds } 7091da177e4SLinus Torvalds inqstrcpy ("V1.0", str->prl); 7101da177e4SLinus Torvalds } 7111da177e4SLinus Torvalds 7124833869eSAdrian Bunk static void set_sense(u8 *sense_buf, u8 sense_key, u8 sense_code, 7131da177e4SLinus Torvalds u8 a_sense_code, u8 incorrect_length, 7141da177e4SLinus Torvalds u8 bit_pointer, u16 field_pointer, 7151da177e4SLinus Torvalds u32 residue) 7161da177e4SLinus Torvalds { 7171da177e4SLinus Torvalds sense_buf[0] = 0xF0; /* Sense data valid, err code 70h (current error) */ 7181da177e4SLinus Torvalds sense_buf[1] = 0; /* Segment number, always zero */ 7191da177e4SLinus Torvalds 7201da177e4SLinus Torvalds if (incorrect_length) { 7211da177e4SLinus Torvalds sense_buf[2] = sense_key | 0x20;/* Set ILI bit | sense key */ 7221da177e4SLinus Torvalds sense_buf[3] = BYTE3(residue); 7231da177e4SLinus Torvalds sense_buf[4] = BYTE2(residue); 7241da177e4SLinus Torvalds sense_buf[5] = BYTE1(residue); 7251da177e4SLinus Torvalds sense_buf[6] = BYTE0(residue); 7261da177e4SLinus Torvalds } else 7271da177e4SLinus Torvalds sense_buf[2] = sense_key; /* Sense key */ 7281da177e4SLinus Torvalds 7291da177e4SLinus Torvalds if (sense_key == ILLEGAL_REQUEST) 7301da177e4SLinus Torvalds sense_buf[7] = 10; /* Additional sense length */ 7311da177e4SLinus Torvalds else 7321da177e4SLinus Torvalds sense_buf[7] = 6; /* Additional sense length */ 7331da177e4SLinus Torvalds 7341da177e4SLinus Torvalds sense_buf[12] = sense_code; /* Additional sense code */ 7351da177e4SLinus Torvalds sense_buf[13] = a_sense_code; /* Additional sense code qualifier */ 7361da177e4SLinus Torvalds if (sense_key == ILLEGAL_REQUEST) { 7371da177e4SLinus Torvalds sense_buf[15] = 0; 7381da177e4SLinus Torvalds 7391da177e4SLinus Torvalds if (sense_code == SENCODE_INVALID_PARAM_FIELD) 7401da177e4SLinus Torvalds sense_buf[15] = 0x80;/* Std sense key specific field */ 7411da177e4SLinus Torvalds /* Illegal parameter is in the parameter block */ 7421da177e4SLinus Torvalds 7431da177e4SLinus Torvalds if (sense_code == SENCODE_INVALID_CDB_FIELD) 7441da177e4SLinus Torvalds sense_buf[15] = 0xc0;/* Std sense key specific field */ 7451da177e4SLinus Torvalds /* Illegal parameter is in the CDB block */ 7461da177e4SLinus Torvalds sense_buf[15] |= bit_pointer; 7471da177e4SLinus Torvalds sense_buf[16] = field_pointer >> 8; /* MSB */ 7481da177e4SLinus Torvalds sense_buf[17] = field_pointer; /* LSB */ 7491da177e4SLinus Torvalds } 7501da177e4SLinus Torvalds } 7511da177e4SLinus Torvalds 752e8f32de5SMark Haverkamp static int aac_bounds_32(struct aac_dev * dev, struct scsi_cmnd * cmd, u64 lba) 753e8f32de5SMark Haverkamp { 754e8f32de5SMark Haverkamp if (lba & 0xffffffff00000000LL) { 755e8f32de5SMark Haverkamp int cid = scmd_id(cmd); 756e8f32de5SMark Haverkamp dprintk((KERN_DEBUG "aacraid: Illegal lba\n")); 757e8f32de5SMark Haverkamp cmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 758e8f32de5SMark Haverkamp SAM_STAT_CHECK_CONDITION; 759e8f32de5SMark Haverkamp set_sense((u8 *) &dev->fsa_dev[cid].sense_data, 760e8f32de5SMark Haverkamp HARDWARE_ERROR, 761e8f32de5SMark Haverkamp SENCODE_INTERNAL_TARGET_FAILURE, 762e8f32de5SMark Haverkamp ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0, 763e8f32de5SMark Haverkamp 0, 0); 764e8f32de5SMark Haverkamp memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 765e8f32de5SMark Haverkamp (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(cmd->sense_buffer)) 766e8f32de5SMark Haverkamp ? sizeof(cmd->sense_buffer) 767e8f32de5SMark Haverkamp : sizeof(dev->fsa_dev[cid].sense_data)); 768e8f32de5SMark Haverkamp cmd->scsi_done(cmd); 769e8f32de5SMark Haverkamp return 1; 770e8f32de5SMark Haverkamp } 771e8f32de5SMark Haverkamp return 0; 772e8f32de5SMark Haverkamp } 773e8f32de5SMark Haverkamp 774e8f32de5SMark Haverkamp static int aac_bounds_64(struct aac_dev * dev, struct scsi_cmnd * cmd, u64 lba) 775e8f32de5SMark Haverkamp { 776e8f32de5SMark Haverkamp return 0; 777e8f32de5SMark Haverkamp } 778e8f32de5SMark Haverkamp 779e8f32de5SMark Haverkamp static void io_callback(void *context, struct fib * fibptr); 780e8f32de5SMark Haverkamp 781e8f32de5SMark Haverkamp static int aac_read_raw_io(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 782e8f32de5SMark Haverkamp { 783e8f32de5SMark Haverkamp u16 fibsize; 784e8f32de5SMark Haverkamp struct aac_raw_io *readcmd; 785e8f32de5SMark Haverkamp aac_fib_init(fib); 786e8f32de5SMark Haverkamp readcmd = (struct aac_raw_io *) fib_data(fib); 787e8f32de5SMark Haverkamp readcmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff)); 788e8f32de5SMark Haverkamp readcmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 789e8f32de5SMark Haverkamp readcmd->count = cpu_to_le32(count<<9); 790e8f32de5SMark Haverkamp readcmd->cid = cpu_to_le16(scmd_id(cmd)); 791e8f32de5SMark Haverkamp readcmd->flags = cpu_to_le16(1); 792e8f32de5SMark Haverkamp readcmd->bpTotal = 0; 793e8f32de5SMark Haverkamp readcmd->bpComplete = 0; 794e8f32de5SMark Haverkamp 795e8f32de5SMark Haverkamp aac_build_sgraw(cmd, &readcmd->sg); 796e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_raw_io) + ((le32_to_cpu(readcmd->sg.count) - 1) * sizeof (struct sgentryraw)); 797e8f32de5SMark Haverkamp BUG_ON(fibsize > (fib->dev->max_fib_size - sizeof(struct aac_fibhdr))); 798e8f32de5SMark Haverkamp /* 799e8f32de5SMark Haverkamp * Now send the Fib to the adapter 800e8f32de5SMark Haverkamp */ 801e8f32de5SMark Haverkamp return aac_fib_send(ContainerRawIo, 802e8f32de5SMark Haverkamp fib, 803e8f32de5SMark Haverkamp fibsize, 804e8f32de5SMark Haverkamp FsaNormal, 805e8f32de5SMark Haverkamp 0, 1, 806e8f32de5SMark Haverkamp (fib_callback) io_callback, 807e8f32de5SMark Haverkamp (void *) cmd); 808e8f32de5SMark Haverkamp } 809e8f32de5SMark Haverkamp 810e8f32de5SMark Haverkamp static int aac_read_block64(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 811e8f32de5SMark Haverkamp { 812e8f32de5SMark Haverkamp u16 fibsize; 813e8f32de5SMark Haverkamp struct aac_read64 *readcmd; 814e8f32de5SMark Haverkamp aac_fib_init(fib); 815e8f32de5SMark Haverkamp readcmd = (struct aac_read64 *) fib_data(fib); 816e8f32de5SMark Haverkamp readcmd->command = cpu_to_le32(VM_CtHostRead64); 817e8f32de5SMark Haverkamp readcmd->cid = cpu_to_le16(scmd_id(cmd)); 818e8f32de5SMark Haverkamp readcmd->sector_count = cpu_to_le16(count); 819e8f32de5SMark Haverkamp readcmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 820e8f32de5SMark Haverkamp readcmd->pad = 0; 821e8f32de5SMark Haverkamp readcmd->flags = 0; 822e8f32de5SMark Haverkamp 823e8f32de5SMark Haverkamp aac_build_sg64(cmd, &readcmd->sg); 824e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_read64) + 825e8f32de5SMark Haverkamp ((le32_to_cpu(readcmd->sg.count) - 1) * 826e8f32de5SMark Haverkamp sizeof (struct sgentry64)); 827e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 828e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 829e8f32de5SMark Haverkamp /* 830e8f32de5SMark Haverkamp * Now send the Fib to the adapter 831e8f32de5SMark Haverkamp */ 832e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand64, 833e8f32de5SMark Haverkamp fib, 834e8f32de5SMark Haverkamp fibsize, 835e8f32de5SMark Haverkamp FsaNormal, 836e8f32de5SMark Haverkamp 0, 1, 837e8f32de5SMark Haverkamp (fib_callback) io_callback, 838e8f32de5SMark Haverkamp (void *) cmd); 839e8f32de5SMark Haverkamp } 840e8f32de5SMark Haverkamp 841e8f32de5SMark Haverkamp static int aac_read_block(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 842e8f32de5SMark Haverkamp { 843e8f32de5SMark Haverkamp u16 fibsize; 844e8f32de5SMark Haverkamp struct aac_read *readcmd; 845e8f32de5SMark Haverkamp aac_fib_init(fib); 846e8f32de5SMark Haverkamp readcmd = (struct aac_read *) fib_data(fib); 847e8f32de5SMark Haverkamp readcmd->command = cpu_to_le32(VM_CtBlockRead); 848e8f32de5SMark Haverkamp readcmd->cid = cpu_to_le16(scmd_id(cmd)); 849e8f32de5SMark Haverkamp readcmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 850e8f32de5SMark Haverkamp readcmd->count = cpu_to_le32(count * 512); 851e8f32de5SMark Haverkamp 852e8f32de5SMark Haverkamp aac_build_sg(cmd, &readcmd->sg); 853e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_read) + 854e8f32de5SMark Haverkamp ((le32_to_cpu(readcmd->sg.count) - 1) * 855e8f32de5SMark Haverkamp sizeof (struct sgentry)); 856e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 857e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 858e8f32de5SMark Haverkamp /* 859e8f32de5SMark Haverkamp * Now send the Fib to the adapter 860e8f32de5SMark Haverkamp */ 861e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand, 862e8f32de5SMark Haverkamp fib, 863e8f32de5SMark Haverkamp fibsize, 864e8f32de5SMark Haverkamp FsaNormal, 865e8f32de5SMark Haverkamp 0, 1, 866e8f32de5SMark Haverkamp (fib_callback) io_callback, 867e8f32de5SMark Haverkamp (void *) cmd); 868e8f32de5SMark Haverkamp } 869e8f32de5SMark Haverkamp 870e8f32de5SMark Haverkamp static int aac_write_raw_io(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 871e8f32de5SMark Haverkamp { 872e8f32de5SMark Haverkamp u16 fibsize; 873e8f32de5SMark Haverkamp struct aac_raw_io *writecmd; 874e8f32de5SMark Haverkamp aac_fib_init(fib); 875e8f32de5SMark Haverkamp writecmd = (struct aac_raw_io *) fib_data(fib); 876e8f32de5SMark Haverkamp writecmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff)); 877e8f32de5SMark Haverkamp writecmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 878e8f32de5SMark Haverkamp writecmd->count = cpu_to_le32(count<<9); 879e8f32de5SMark Haverkamp writecmd->cid = cpu_to_le16(scmd_id(cmd)); 880e8f32de5SMark Haverkamp writecmd->flags = 0; 881e8f32de5SMark Haverkamp writecmd->bpTotal = 0; 882e8f32de5SMark Haverkamp writecmd->bpComplete = 0; 883e8f32de5SMark Haverkamp 884e8f32de5SMark Haverkamp aac_build_sgraw(cmd, &writecmd->sg); 885e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_raw_io) + ((le32_to_cpu(writecmd->sg.count) - 1) * sizeof (struct sgentryraw)); 886e8f32de5SMark Haverkamp BUG_ON(fibsize > (fib->dev->max_fib_size - sizeof(struct aac_fibhdr))); 887e8f32de5SMark Haverkamp /* 888e8f32de5SMark Haverkamp * Now send the Fib to the adapter 889e8f32de5SMark Haverkamp */ 890e8f32de5SMark Haverkamp return aac_fib_send(ContainerRawIo, 891e8f32de5SMark Haverkamp fib, 892e8f32de5SMark Haverkamp fibsize, 893e8f32de5SMark Haverkamp FsaNormal, 894e8f32de5SMark Haverkamp 0, 1, 895e8f32de5SMark Haverkamp (fib_callback) io_callback, 896e8f32de5SMark Haverkamp (void *) cmd); 897e8f32de5SMark Haverkamp } 898e8f32de5SMark Haverkamp 899e8f32de5SMark Haverkamp static int aac_write_block64(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 900e8f32de5SMark Haverkamp { 901e8f32de5SMark Haverkamp u16 fibsize; 902e8f32de5SMark Haverkamp struct aac_write64 *writecmd; 903e8f32de5SMark Haverkamp aac_fib_init(fib); 904e8f32de5SMark Haverkamp writecmd = (struct aac_write64 *) fib_data(fib); 905e8f32de5SMark Haverkamp writecmd->command = cpu_to_le32(VM_CtHostWrite64); 906e8f32de5SMark Haverkamp writecmd->cid = cpu_to_le16(scmd_id(cmd)); 907e8f32de5SMark Haverkamp writecmd->sector_count = cpu_to_le16(count); 908e8f32de5SMark Haverkamp writecmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 909e8f32de5SMark Haverkamp writecmd->pad = 0; 910e8f32de5SMark Haverkamp writecmd->flags = 0; 911e8f32de5SMark Haverkamp 912e8f32de5SMark Haverkamp aac_build_sg64(cmd, &writecmd->sg); 913e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_write64) + 914e8f32de5SMark Haverkamp ((le32_to_cpu(writecmd->sg.count) - 1) * 915e8f32de5SMark Haverkamp sizeof (struct sgentry64)); 916e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 917e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 918e8f32de5SMark Haverkamp /* 919e8f32de5SMark Haverkamp * Now send the Fib to the adapter 920e8f32de5SMark Haverkamp */ 921e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand64, 922e8f32de5SMark Haverkamp fib, 923e8f32de5SMark Haverkamp fibsize, 924e8f32de5SMark Haverkamp FsaNormal, 925e8f32de5SMark Haverkamp 0, 1, 926e8f32de5SMark Haverkamp (fib_callback) io_callback, 927e8f32de5SMark Haverkamp (void *) cmd); 928e8f32de5SMark Haverkamp } 929e8f32de5SMark Haverkamp 930e8f32de5SMark Haverkamp static int aac_write_block(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 931e8f32de5SMark Haverkamp { 932e8f32de5SMark Haverkamp u16 fibsize; 933e8f32de5SMark Haverkamp struct aac_write *writecmd; 934e8f32de5SMark Haverkamp aac_fib_init(fib); 935e8f32de5SMark Haverkamp writecmd = (struct aac_write *) fib_data(fib); 936e8f32de5SMark Haverkamp writecmd->command = cpu_to_le32(VM_CtBlockWrite); 937e8f32de5SMark Haverkamp writecmd->cid = cpu_to_le16(scmd_id(cmd)); 938e8f32de5SMark Haverkamp writecmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 939e8f32de5SMark Haverkamp writecmd->count = cpu_to_le32(count * 512); 940e8f32de5SMark Haverkamp writecmd->sg.count = cpu_to_le32(1); 941e8f32de5SMark Haverkamp /* ->stable is not used - it did mean which type of write */ 942e8f32de5SMark Haverkamp 943e8f32de5SMark Haverkamp aac_build_sg(cmd, &writecmd->sg); 944e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_write) + 945e8f32de5SMark Haverkamp ((le32_to_cpu(writecmd->sg.count) - 1) * 946e8f32de5SMark Haverkamp sizeof (struct sgentry)); 947e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 948e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 949e8f32de5SMark Haverkamp /* 950e8f32de5SMark Haverkamp * Now send the Fib to the adapter 951e8f32de5SMark Haverkamp */ 952e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand, 953e8f32de5SMark Haverkamp fib, 954e8f32de5SMark Haverkamp fibsize, 955e8f32de5SMark Haverkamp FsaNormal, 956e8f32de5SMark Haverkamp 0, 1, 957e8f32de5SMark Haverkamp (fib_callback) io_callback, 958e8f32de5SMark Haverkamp (void *) cmd); 959e8f32de5SMark Haverkamp } 960e8f32de5SMark Haverkamp 961e8f32de5SMark Haverkamp static struct aac_srb * aac_scsi_common(struct fib * fib, struct scsi_cmnd * cmd) 962e8f32de5SMark Haverkamp { 963e8f32de5SMark Haverkamp struct aac_srb * srbcmd; 964e8f32de5SMark Haverkamp u32 flag; 965e8f32de5SMark Haverkamp u32 timeout; 966e8f32de5SMark Haverkamp 967e8f32de5SMark Haverkamp aac_fib_init(fib); 968e8f32de5SMark Haverkamp switch(cmd->sc_data_direction){ 969e8f32de5SMark Haverkamp case DMA_TO_DEVICE: 970e8f32de5SMark Haverkamp flag = SRB_DataOut; 971e8f32de5SMark Haverkamp break; 972e8f32de5SMark Haverkamp case DMA_BIDIRECTIONAL: 973e8f32de5SMark Haverkamp flag = SRB_DataIn | SRB_DataOut; 974e8f32de5SMark Haverkamp break; 975e8f32de5SMark Haverkamp case DMA_FROM_DEVICE: 976e8f32de5SMark Haverkamp flag = SRB_DataIn; 977e8f32de5SMark Haverkamp break; 978e8f32de5SMark Haverkamp case DMA_NONE: 979e8f32de5SMark Haverkamp default: /* shuts up some versions of gcc */ 980e8f32de5SMark Haverkamp flag = SRB_NoDataXfer; 981e8f32de5SMark Haverkamp break; 982e8f32de5SMark Haverkamp } 983e8f32de5SMark Haverkamp 984e8f32de5SMark Haverkamp srbcmd = (struct aac_srb*) fib_data(fib); 985e8f32de5SMark Haverkamp srbcmd->function = cpu_to_le32(SRBF_ExecuteScsi); 986e8f32de5SMark Haverkamp srbcmd->channel = cpu_to_le32(aac_logical_to_phys(scmd_channel(cmd))); 987e8f32de5SMark Haverkamp srbcmd->id = cpu_to_le32(scmd_id(cmd)); 988e8f32de5SMark Haverkamp srbcmd->lun = cpu_to_le32(cmd->device->lun); 989e8f32de5SMark Haverkamp srbcmd->flags = cpu_to_le32(flag); 990e8f32de5SMark Haverkamp timeout = cmd->timeout_per_command/HZ; 991e8f32de5SMark Haverkamp if (timeout == 0) 992e8f32de5SMark Haverkamp timeout = 1; 993e8f32de5SMark Haverkamp srbcmd->timeout = cpu_to_le32(timeout); // timeout in seconds 994e8f32de5SMark Haverkamp srbcmd->retry_limit = 0; /* Obsolete parameter */ 995e8f32de5SMark Haverkamp srbcmd->cdb_size = cpu_to_le32(cmd->cmd_len); 996e8f32de5SMark Haverkamp return srbcmd; 997e8f32de5SMark Haverkamp } 998e8f32de5SMark Haverkamp 999e8f32de5SMark Haverkamp static void aac_srb_callback(void *context, struct fib * fibptr); 1000e8f32de5SMark Haverkamp 1001e8f32de5SMark Haverkamp static int aac_scsi_64(struct fib * fib, struct scsi_cmnd * cmd) 1002e8f32de5SMark Haverkamp { 1003e8f32de5SMark Haverkamp u16 fibsize; 1004e8f32de5SMark Haverkamp struct aac_srb * srbcmd = aac_scsi_common(fib, cmd); 1005e8f32de5SMark Haverkamp 1006e8f32de5SMark Haverkamp aac_build_sg64(cmd, (struct sgmap64*) &srbcmd->sg); 1007e8f32de5SMark Haverkamp srbcmd->count = cpu_to_le32(cmd->request_bufflen); 1008e8f32de5SMark Haverkamp 1009e8f32de5SMark Haverkamp memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb)); 1010e8f32de5SMark Haverkamp memcpy(srbcmd->cdb, cmd->cmnd, cmd->cmd_len); 1011e8f32de5SMark Haverkamp /* 1012e8f32de5SMark Haverkamp * Build Scatter/Gather list 1013e8f32de5SMark Haverkamp */ 1014e8f32de5SMark Haverkamp fibsize = sizeof (struct aac_srb) - sizeof (struct sgentry) + 1015e8f32de5SMark Haverkamp ((le32_to_cpu(srbcmd->sg.count) & 0xff) * 1016e8f32de5SMark Haverkamp sizeof (struct sgentry64)); 1017e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1018e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1019e8f32de5SMark Haverkamp 1020e8f32de5SMark Haverkamp /* 1021e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1022e8f32de5SMark Haverkamp */ 1023e8f32de5SMark Haverkamp return aac_fib_send(ScsiPortCommand64, fib, 1024e8f32de5SMark Haverkamp fibsize, FsaNormal, 0, 1, 1025e8f32de5SMark Haverkamp (fib_callback) aac_srb_callback, 1026e8f32de5SMark Haverkamp (void *) cmd); 1027e8f32de5SMark Haverkamp } 1028e8f32de5SMark Haverkamp 1029e8f32de5SMark Haverkamp static int aac_scsi_32(struct fib * fib, struct scsi_cmnd * cmd) 1030e8f32de5SMark Haverkamp { 1031e8f32de5SMark Haverkamp u16 fibsize; 1032e8f32de5SMark Haverkamp struct aac_srb * srbcmd = aac_scsi_common(fib, cmd); 1033e8f32de5SMark Haverkamp 1034e8f32de5SMark Haverkamp aac_build_sg(cmd, (struct sgmap*)&srbcmd->sg); 1035e8f32de5SMark Haverkamp srbcmd->count = cpu_to_le32(cmd->request_bufflen); 1036e8f32de5SMark Haverkamp 1037e8f32de5SMark Haverkamp memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb)); 1038e8f32de5SMark Haverkamp memcpy(srbcmd->cdb, cmd->cmnd, cmd->cmd_len); 1039e8f32de5SMark Haverkamp /* 1040e8f32de5SMark Haverkamp * Build Scatter/Gather list 1041e8f32de5SMark Haverkamp */ 1042e8f32de5SMark Haverkamp fibsize = sizeof (struct aac_srb) + 1043e8f32de5SMark Haverkamp (((le32_to_cpu(srbcmd->sg.count) & 0xff) - 1) * 1044e8f32de5SMark Haverkamp sizeof (struct sgentry)); 1045e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1046e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1047e8f32de5SMark Haverkamp 1048e8f32de5SMark Haverkamp /* 1049e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1050e8f32de5SMark Haverkamp */ 1051e8f32de5SMark Haverkamp return aac_fib_send(ScsiPortCommand, fib, fibsize, FsaNormal, 0, 1, 1052e8f32de5SMark Haverkamp (fib_callback) aac_srb_callback, (void *) cmd); 1053e8f32de5SMark Haverkamp } 1054e8f32de5SMark Haverkamp 10551da177e4SLinus Torvalds int aac_get_adapter_info(struct aac_dev* dev) 10561da177e4SLinus Torvalds { 10571da177e4SLinus Torvalds struct fib* fibptr; 10581da177e4SLinus Torvalds int rcode; 10591da177e4SLinus Torvalds u32 tmp; 10607c00ffa3SMark Haverkamp struct aac_adapter_info *info; 106184971738SMark Haverkamp struct aac_bus_info *command; 106284971738SMark Haverkamp struct aac_bus_info_response *bus_info; 10637c00ffa3SMark Haverkamp 1064bfb35aa8SMark Haverkamp if (!(fibptr = aac_fib_alloc(dev))) 10651da177e4SLinus Torvalds return -ENOMEM; 10661da177e4SLinus Torvalds 1067bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 10681da177e4SLinus Torvalds info = (struct aac_adapter_info *) fib_data(fibptr); 10697c00ffa3SMark Haverkamp memset(info,0,sizeof(*info)); 10701da177e4SLinus Torvalds 1071bfb35aa8SMark Haverkamp rcode = aac_fib_send(RequestAdapterInfo, 10721da177e4SLinus Torvalds fibptr, 10737c00ffa3SMark Haverkamp sizeof(*info), 10741da177e4SLinus Torvalds FsaNormal, 10759203344cSMark Haverkamp -1, 1, /* First `interrupt' command uses special wait */ 10761da177e4SLinus Torvalds NULL, 10771da177e4SLinus Torvalds NULL); 10781da177e4SLinus Torvalds 10797c00ffa3SMark Haverkamp if (rcode < 0) { 1080bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1081bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 10827c00ffa3SMark Haverkamp return rcode; 10837c00ffa3SMark Haverkamp } 10847c00ffa3SMark Haverkamp memcpy(&dev->adapter_info, info, sizeof(*info)); 10857c00ffa3SMark Haverkamp 10867c00ffa3SMark Haverkamp if (dev->adapter_info.options & AAC_OPT_SUPPLEMENT_ADAPTER_INFO) { 10877c00ffa3SMark Haverkamp struct aac_supplement_adapter_info * info; 10887c00ffa3SMark Haverkamp 1089bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 10907c00ffa3SMark Haverkamp 10917c00ffa3SMark Haverkamp info = (struct aac_supplement_adapter_info *) fib_data(fibptr); 10927c00ffa3SMark Haverkamp 10937c00ffa3SMark Haverkamp memset(info,0,sizeof(*info)); 10947c00ffa3SMark Haverkamp 1095bfb35aa8SMark Haverkamp rcode = aac_fib_send(RequestSupplementAdapterInfo, 10967c00ffa3SMark Haverkamp fibptr, 10977c00ffa3SMark Haverkamp sizeof(*info), 10987c00ffa3SMark Haverkamp FsaNormal, 10997c00ffa3SMark Haverkamp 1, 1, 11007c00ffa3SMark Haverkamp NULL, 11017c00ffa3SMark Haverkamp NULL); 11027c00ffa3SMark Haverkamp 11037c00ffa3SMark Haverkamp if (rcode >= 0) 11047c00ffa3SMark Haverkamp memcpy(&dev->supplement_adapter_info, info, sizeof(*info)); 11057c00ffa3SMark Haverkamp } 11061da177e4SLinus Torvalds 110784971738SMark Haverkamp 110884971738SMark Haverkamp /* 110984971738SMark Haverkamp * GetBusInfo 111084971738SMark Haverkamp */ 111184971738SMark Haverkamp 1112bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 111384971738SMark Haverkamp 111484971738SMark Haverkamp bus_info = (struct aac_bus_info_response *) fib_data(fibptr); 111584971738SMark Haverkamp 111684971738SMark Haverkamp memset(bus_info, 0, sizeof(*bus_info)); 111784971738SMark Haverkamp 111884971738SMark Haverkamp command = (struct aac_bus_info *)bus_info; 111984971738SMark Haverkamp 112084971738SMark Haverkamp command->Command = cpu_to_le32(VM_Ioctl); 112184971738SMark Haverkamp command->ObjType = cpu_to_le32(FT_DRIVE); 112284971738SMark Haverkamp command->MethodId = cpu_to_le32(1); 112384971738SMark Haverkamp command->CtlCmd = cpu_to_le32(GetBusInfo); 112484971738SMark Haverkamp 1125bfb35aa8SMark Haverkamp rcode = aac_fib_send(ContainerCommand, 112684971738SMark Haverkamp fibptr, 112784971738SMark Haverkamp sizeof (*bus_info), 112884971738SMark Haverkamp FsaNormal, 112984971738SMark Haverkamp 1, 1, 113084971738SMark Haverkamp NULL, NULL); 113184971738SMark Haverkamp 113284971738SMark Haverkamp if (rcode >= 0 && le32_to_cpu(bus_info->Status) == ST_OK) { 113384971738SMark Haverkamp dev->maximum_num_physicals = le32_to_cpu(bus_info->TargetsPerBus); 113484971738SMark Haverkamp dev->maximum_num_channels = le32_to_cpu(bus_info->BusCount); 113584971738SMark Haverkamp } 113684971738SMark Haverkamp 11378c867b25SMark Haverkamp if (!dev->in_reset) { 11381da177e4SLinus Torvalds tmp = le32_to_cpu(dev->adapter_info.kernelrev); 11397c00ffa3SMark Haverkamp printk(KERN_INFO "%s%d: kernel %d.%d-%d[%d] %.*s\n", 11401da177e4SLinus Torvalds dev->name, 11411da177e4SLinus Torvalds dev->id, 11421da177e4SLinus Torvalds tmp>>24, 11431da177e4SLinus Torvalds (tmp>>16)&0xff, 11441da177e4SLinus Torvalds tmp&0xff, 11457c00ffa3SMark Haverkamp le32_to_cpu(dev->adapter_info.kernelbuild), 11467c00ffa3SMark Haverkamp (int)sizeof(dev->supplement_adapter_info.BuildDate), 11477c00ffa3SMark Haverkamp dev->supplement_adapter_info.BuildDate); 11481da177e4SLinus Torvalds tmp = le32_to_cpu(dev->adapter_info.monitorrev); 11491da177e4SLinus Torvalds printk(KERN_INFO "%s%d: monitor %d.%d-%d[%d]\n", 11501da177e4SLinus Torvalds dev->name, dev->id, 11511da177e4SLinus Torvalds tmp>>24,(tmp>>16)&0xff,tmp&0xff, 11521da177e4SLinus Torvalds le32_to_cpu(dev->adapter_info.monitorbuild)); 11531da177e4SLinus Torvalds tmp = le32_to_cpu(dev->adapter_info.biosrev); 11541da177e4SLinus Torvalds printk(KERN_INFO "%s%d: bios %d.%d-%d[%d]\n", 11551da177e4SLinus Torvalds dev->name, dev->id, 11561da177e4SLinus Torvalds tmp>>24,(tmp>>16)&0xff,tmp&0xff, 11571da177e4SLinus Torvalds le32_to_cpu(dev->adapter_info.biosbuild)); 11581da177e4SLinus Torvalds if (le32_to_cpu(dev->adapter_info.serial[0]) != 0xBAD0) 11591da177e4SLinus Torvalds printk(KERN_INFO "%s%d: serial %x\n", 11601da177e4SLinus Torvalds dev->name, dev->id, 11611da177e4SLinus Torvalds le32_to_cpu(dev->adapter_info.serial[0])); 11628c867b25SMark Haverkamp } 11631da177e4SLinus Torvalds 11641da177e4SLinus Torvalds dev->nondasd_support = 0; 11651da177e4SLinus Torvalds dev->raid_scsi_mode = 0; 11661da177e4SLinus Torvalds if(dev->adapter_info.options & AAC_OPT_NONDASD){ 11671da177e4SLinus Torvalds dev->nondasd_support = 1; 11681da177e4SLinus Torvalds } 11691da177e4SLinus Torvalds 11701da177e4SLinus Torvalds /* 11711da177e4SLinus Torvalds * If the firmware supports ROMB RAID/SCSI mode and we are currently 11721da177e4SLinus Torvalds * in RAID/SCSI mode, set the flag. For now if in this mode we will 11731da177e4SLinus Torvalds * force nondasd support on. If we decide to allow the non-dasd flag 11741da177e4SLinus Torvalds * additional changes changes will have to be made to support 11751da177e4SLinus Torvalds * RAID/SCSI. the function aac_scsi_cmd in this module will have to be 11761da177e4SLinus Torvalds * changed to support the new dev->raid_scsi_mode flag instead of 11771da177e4SLinus Torvalds * leaching off of the dev->nondasd_support flag. Also in linit.c the 11781da177e4SLinus Torvalds * function aac_detect will have to be modified where it sets up the 11791da177e4SLinus Torvalds * max number of channels based on the aac->nondasd_support flag only. 11801da177e4SLinus Torvalds */ 11811da177e4SLinus Torvalds if ((dev->adapter_info.options & AAC_OPT_SCSI_MANAGED) && 11821da177e4SLinus Torvalds (dev->adapter_info.options & AAC_OPT_RAID_SCSI_MODE)) { 11831da177e4SLinus Torvalds dev->nondasd_support = 1; 11841da177e4SLinus Torvalds dev->raid_scsi_mode = 1; 11851da177e4SLinus Torvalds } 11861da177e4SLinus Torvalds if (dev->raid_scsi_mode != 0) 11871da177e4SLinus Torvalds printk(KERN_INFO "%s%d: ROMB RAID/SCSI mode enabled\n", 11881da177e4SLinus Torvalds dev->name, dev->id); 11891da177e4SLinus Torvalds 11901da177e4SLinus Torvalds if(nondasd != -1) { 11911da177e4SLinus Torvalds dev->nondasd_support = (nondasd!=0); 11921da177e4SLinus Torvalds } 11931da177e4SLinus Torvalds if(dev->nondasd_support != 0){ 11941da177e4SLinus Torvalds printk(KERN_INFO "%s%d: Non-DASD support enabled.\n",dev->name, dev->id); 11951da177e4SLinus Torvalds } 11961da177e4SLinus Torvalds 11971da177e4SLinus Torvalds dev->dac_support = 0; 11981da177e4SLinus Torvalds if( (sizeof(dma_addr_t) > 4) && (dev->adapter_info.options & AAC_OPT_SGMAP_HOST64)){ 11991da177e4SLinus Torvalds printk(KERN_INFO "%s%d: 64bit support enabled.\n", dev->name, dev->id); 12001da177e4SLinus Torvalds dev->dac_support = 1; 12011da177e4SLinus Torvalds } 12021da177e4SLinus Torvalds 12031da177e4SLinus Torvalds if(dacmode != -1) { 12041da177e4SLinus Torvalds dev->dac_support = (dacmode!=0); 12051da177e4SLinus Torvalds } 12061da177e4SLinus Torvalds if(dev->dac_support != 0) { 120771e0f32fSJames Bottomley if (!pci_set_dma_mask(dev->pdev, DMA_64BIT_MASK) && 120871e0f32fSJames Bottomley !pci_set_consistent_dma_mask(dev->pdev, DMA_64BIT_MASK)) { 12091da177e4SLinus Torvalds printk(KERN_INFO"%s%d: 64 Bit DAC enabled\n", 12101da177e4SLinus Torvalds dev->name, dev->id); 121171e0f32fSJames Bottomley } else if (!pci_set_dma_mask(dev->pdev, DMA_32BIT_MASK) && 121271e0f32fSJames Bottomley !pci_set_consistent_dma_mask(dev->pdev, DMA_32BIT_MASK)) { 12131da177e4SLinus Torvalds printk(KERN_INFO"%s%d: DMA mask set failed, 64 Bit DAC disabled\n", 12141da177e4SLinus Torvalds dev->name, dev->id); 12151da177e4SLinus Torvalds dev->dac_support = 0; 12161da177e4SLinus Torvalds } else { 12171da177e4SLinus Torvalds printk(KERN_WARNING"%s%d: No suitable DMA available.\n", 12181da177e4SLinus Torvalds dev->name, dev->id); 12191da177e4SLinus Torvalds rcode = -ENOMEM; 12201da177e4SLinus Torvalds } 12211da177e4SLinus Torvalds } 12227c00ffa3SMark Haverkamp /* 1223e8f32de5SMark Haverkamp * Deal with configuring for the individualized limits of each packet 1224e8f32de5SMark Haverkamp * interface. 12257c00ffa3SMark Haverkamp */ 1226e8f32de5SMark Haverkamp dev->a_ops.adapter_scsi = (dev->dac_support) 1227e8f32de5SMark Haverkamp ? aac_scsi_64 1228e8f32de5SMark Haverkamp : aac_scsi_32; 1229e8f32de5SMark Haverkamp if (dev->raw_io_interface) { 1230e8f32de5SMark Haverkamp dev->a_ops.adapter_bounds = (dev->raw_io_64) 1231e8f32de5SMark Haverkamp ? aac_bounds_64 1232e8f32de5SMark Haverkamp : aac_bounds_32; 1233e8f32de5SMark Haverkamp dev->a_ops.adapter_read = aac_read_raw_io; 1234e8f32de5SMark Haverkamp dev->a_ops.adapter_write = aac_write_raw_io; 1235e8f32de5SMark Haverkamp } else { 1236e8f32de5SMark Haverkamp dev->a_ops.adapter_bounds = aac_bounds_32; 12377c00ffa3SMark Haverkamp dev->scsi_host_ptr->sg_tablesize = (dev->max_fib_size - 12387c00ffa3SMark Haverkamp sizeof(struct aac_fibhdr) - 123963a70eeaSMark Haverkamp sizeof(struct aac_write) + sizeof(struct sgentry)) / 124063a70eeaSMark Haverkamp sizeof(struct sgentry); 12417c00ffa3SMark Haverkamp if (dev->dac_support) { 1242e8f32de5SMark Haverkamp dev->a_ops.adapter_read = aac_read_block64; 1243e8f32de5SMark Haverkamp dev->a_ops.adapter_write = aac_write_block64; 12447c00ffa3SMark Haverkamp /* 12457c00ffa3SMark Haverkamp * 38 scatter gather elements 12467c00ffa3SMark Haverkamp */ 12477c00ffa3SMark Haverkamp dev->scsi_host_ptr->sg_tablesize = 12487c00ffa3SMark Haverkamp (dev->max_fib_size - 12497c00ffa3SMark Haverkamp sizeof(struct aac_fibhdr) - 12507c00ffa3SMark Haverkamp sizeof(struct aac_write64) + 125163a70eeaSMark Haverkamp sizeof(struct sgentry64)) / 125263a70eeaSMark Haverkamp sizeof(struct sgentry64); 1253e8f32de5SMark Haverkamp } else { 1254e8f32de5SMark Haverkamp dev->a_ops.adapter_read = aac_read_block; 1255e8f32de5SMark Haverkamp dev->a_ops.adapter_write = aac_write_block; 12567c00ffa3SMark Haverkamp } 12577c00ffa3SMark Haverkamp dev->scsi_host_ptr->max_sectors = AAC_MAX_32BIT_SGBCOUNT; 12587c00ffa3SMark Haverkamp if(!(dev->adapter_info.options & AAC_OPT_NEW_COMM)) { 12597c00ffa3SMark Haverkamp /* 12607c00ffa3SMark Haverkamp * Worst case size that could cause sg overflow when 12617c00ffa3SMark Haverkamp * we break up SG elements that are larger than 64KB. 12627c00ffa3SMark Haverkamp * Would be nice if we could tell the SCSI layer what 12637c00ffa3SMark Haverkamp * the maximum SG element size can be. Worst case is 12647c00ffa3SMark Haverkamp * (sg_tablesize-1) 4KB elements with one 64KB 12657c00ffa3SMark Haverkamp * element. 12667c00ffa3SMark Haverkamp * 32bit -> 468 or 238KB 64bit -> 424 or 212KB 12677c00ffa3SMark Haverkamp */ 12687c00ffa3SMark Haverkamp dev->scsi_host_ptr->max_sectors = 12697c00ffa3SMark Haverkamp (dev->scsi_host_ptr->sg_tablesize * 8) + 112; 12707c00ffa3SMark Haverkamp } 12710e68c003SMark Haverkamp } 12721da177e4SLinus Torvalds 1273bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1274bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 12751da177e4SLinus Torvalds 12761da177e4SLinus Torvalds return rcode; 12771da177e4SLinus Torvalds } 12781da177e4SLinus Torvalds 12791da177e4SLinus Torvalds 1280e53cb35aSMark Haverkamp static void io_callback(void *context, struct fib * fibptr) 12811da177e4SLinus Torvalds { 12821da177e4SLinus Torvalds struct aac_dev *dev; 12831da177e4SLinus Torvalds struct aac_read_reply *readreply; 12841da177e4SLinus Torvalds struct scsi_cmnd *scsicmd; 12851da177e4SLinus Torvalds u32 cid; 12861da177e4SLinus Torvalds 12871da177e4SLinus Torvalds scsicmd = (struct scsi_cmnd *) context; 128877d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL; 12891da177e4SLinus Torvalds 12901da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 1291e5718774SMark Haverkamp cid = scmd_id(scsicmd); 12921da177e4SLinus Torvalds 12937a8cf29dSMark Haverkamp if (nblank(dprintk(x))) { 12947a8cf29dSMark Haverkamp u64 lba; 12957a8cf29dSMark Haverkamp switch (scsicmd->cmnd[0]) { 12967a8cf29dSMark Haverkamp case WRITE_6: 12977a8cf29dSMark Haverkamp case READ_6: 12987a8cf29dSMark Haverkamp lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | 12997a8cf29dSMark Haverkamp (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 13007a8cf29dSMark Haverkamp break; 13017a8cf29dSMark Haverkamp case WRITE_16: 13027a8cf29dSMark Haverkamp case READ_16: 13037a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 56) | 13047a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[3] << 48) | 13057a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[4] << 40) | 13067a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[5] << 32) | 13077a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[6] << 24) | 13087a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 13097a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 13107a8cf29dSMark Haverkamp break; 13117a8cf29dSMark Haverkamp case WRITE_12: 13127a8cf29dSMark Haverkamp case READ_12: 13137a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 13147a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 13157a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 13167a8cf29dSMark Haverkamp break; 13177a8cf29dSMark Haverkamp default: 13187a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 13197a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 13207a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 13217a8cf29dSMark Haverkamp break; 13227a8cf29dSMark Haverkamp } 13237a8cf29dSMark Haverkamp printk(KERN_DEBUG 13247a8cf29dSMark Haverkamp "io_callback[cpu %d]: lba = %llu, t = %ld.\n", 13257a8cf29dSMark Haverkamp smp_processor_id(), (unsigned long long)lba, jiffies); 13267a8cf29dSMark Haverkamp } 13271da177e4SLinus Torvalds 1328125e1874SEric Sesterhenn BUG_ON(fibptr == NULL); 13291da177e4SLinus Torvalds 13301da177e4SLinus Torvalds if(scsicmd->use_sg) 13311da177e4SLinus Torvalds pci_unmap_sg(dev->pdev, 13325d5ff44fSChristoph Hellwig (struct scatterlist *)scsicmd->request_buffer, 13331da177e4SLinus Torvalds scsicmd->use_sg, 13341da177e4SLinus Torvalds scsicmd->sc_data_direction); 13351da177e4SLinus Torvalds else if(scsicmd->request_bufflen) 13361da177e4SLinus Torvalds pci_unmap_single(dev->pdev, scsicmd->SCp.dma_handle, 13371da177e4SLinus Torvalds scsicmd->request_bufflen, 13381da177e4SLinus Torvalds scsicmd->sc_data_direction); 13391da177e4SLinus Torvalds readreply = (struct aac_read_reply *)fib_data(fibptr); 13401da177e4SLinus Torvalds if (le32_to_cpu(readreply->status) == ST_OK) 13411da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 13421da177e4SLinus Torvalds else { 13437c00ffa3SMark Haverkamp #ifdef AAC_DETAILED_STATUS_INFO 1344e53cb35aSMark Haverkamp printk(KERN_WARNING "io_callback: io failed, status = %d\n", 13451da177e4SLinus Torvalds le32_to_cpu(readreply->status)); 13467c00ffa3SMark Haverkamp #endif 13471da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 13481da177e4SLinus Torvalds set_sense((u8 *) &dev->fsa_dev[cid].sense_data, 13491da177e4SLinus Torvalds HARDWARE_ERROR, 13501da177e4SLinus Torvalds SENCODE_INTERNAL_TARGET_FAILURE, 13511da177e4SLinus Torvalds ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0, 13521da177e4SLinus Torvalds 0, 0); 13531da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 13541da177e4SLinus Torvalds (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(scsicmd->sense_buffer)) 13551da177e4SLinus Torvalds ? sizeof(scsicmd->sense_buffer) 13561da177e4SLinus Torvalds : sizeof(dev->fsa_dev[cid].sense_data)); 13571da177e4SLinus Torvalds } 1358bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1359bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 13601da177e4SLinus Torvalds 13618e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 13621da177e4SLinus Torvalds } 13631da177e4SLinus Torvalds 13644833869eSAdrian Bunk static int aac_read(struct scsi_cmnd * scsicmd, int cid) 13651da177e4SLinus Torvalds { 13667a8cf29dSMark Haverkamp u64 lba; 13671da177e4SLinus Torvalds u32 count; 13681da177e4SLinus Torvalds int status; 13691da177e4SLinus Torvalds struct aac_dev *dev; 13701da177e4SLinus Torvalds struct fib * cmd_fibcontext; 13711da177e4SLinus Torvalds 13721da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 13731da177e4SLinus Torvalds /* 13741da177e4SLinus Torvalds * Get block address and transfer length 13751da177e4SLinus Torvalds */ 13767a8cf29dSMark Haverkamp switch (scsicmd->cmnd[0]) { 13777a8cf29dSMark Haverkamp case READ_6: 13781da177e4SLinus Torvalds dprintk((KERN_DEBUG "aachba: received a read(6) command on id %d.\n", cid)); 13791da177e4SLinus Torvalds 13807a8cf29dSMark Haverkamp lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | 13817a8cf29dSMark Haverkamp (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 13821da177e4SLinus Torvalds count = scsicmd->cmnd[4]; 13831da177e4SLinus Torvalds 13841da177e4SLinus Torvalds if (count == 0) 13851da177e4SLinus Torvalds count = 256; 13867a8cf29dSMark Haverkamp break; 13877a8cf29dSMark Haverkamp case READ_16: 13887a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a read(16) command on id %d.\n", cid)); 13897a8cf29dSMark Haverkamp 13907a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 56) | 13917a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[3] << 48) | 13927a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[4] << 40) | 13937a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[5] << 32) | 13947a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[6] << 24) | 13957a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 13967a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 13977a8cf29dSMark Haverkamp count = (scsicmd->cmnd[10] << 24) | 13987a8cf29dSMark Haverkamp (scsicmd->cmnd[11] << 16) | 13997a8cf29dSMark Haverkamp (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13]; 14007a8cf29dSMark Haverkamp break; 14017a8cf29dSMark Haverkamp case READ_12: 14027a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a read(12) command on id %d.\n", cid)); 14037a8cf29dSMark Haverkamp 14047a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 14057a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 14067a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 14077a8cf29dSMark Haverkamp count = (scsicmd->cmnd[6] << 24) | 14087a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 14097a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 14107a8cf29dSMark Haverkamp break; 14117a8cf29dSMark Haverkamp default: 14121da177e4SLinus Torvalds dprintk((KERN_DEBUG "aachba: received a read(10) command on id %d.\n", cid)); 14131da177e4SLinus Torvalds 14147a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 14157a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 14167a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 14171da177e4SLinus Torvalds count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 14187a8cf29dSMark Haverkamp break; 14191da177e4SLinus Torvalds } 14207a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aac_read[cpu %d]: lba = %llu, t = %ld.\n", 14217c00ffa3SMark Haverkamp smp_processor_id(), (unsigned long long)lba, jiffies)); 1422e8f32de5SMark Haverkamp if (aac_adapter_bounds(dev,scsicmd,lba)) 14237a8cf29dSMark Haverkamp return 0; 14241da177e4SLinus Torvalds /* 14251da177e4SLinus Torvalds * Alocate and initialize a Fib 14261da177e4SLinus Torvalds */ 1427bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) { 14281da177e4SLinus Torvalds return -1; 14291da177e4SLinus Torvalds } 14301da177e4SLinus Torvalds 1431e8f32de5SMark Haverkamp status = aac_adapter_read(cmd_fibcontext, scsicmd, lba, count); 14321da177e4SLinus Torvalds 14331da177e4SLinus Torvalds /* 14341da177e4SLinus Torvalds * Check that the command queued to the controller 14351da177e4SLinus Torvalds */ 143677d644d4SMark Haverkamp if (status == -EINPROGRESS) { 143777d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 14381da177e4SLinus Torvalds return 0; 143977d644d4SMark Haverkamp } 14401da177e4SLinus Torvalds 1441bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_read: aac_fib_send failed with status: %d.\n", status); 14421da177e4SLinus Torvalds /* 14431da177e4SLinus Torvalds * For some reason, the Fib didn't queue, return QUEUE_FULL 14441da177e4SLinus Torvalds */ 14451da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL; 14468e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 1447bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 1448bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 14491da177e4SLinus Torvalds return 0; 14501da177e4SLinus Torvalds } 14511da177e4SLinus Torvalds 14521da177e4SLinus Torvalds static int aac_write(struct scsi_cmnd * scsicmd, int cid) 14531da177e4SLinus Torvalds { 14547a8cf29dSMark Haverkamp u64 lba; 14551da177e4SLinus Torvalds u32 count; 14561da177e4SLinus Torvalds int status; 14571da177e4SLinus Torvalds struct aac_dev *dev; 14581da177e4SLinus Torvalds struct fib * cmd_fibcontext; 14591da177e4SLinus Torvalds 14601da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 14611da177e4SLinus Torvalds /* 14621da177e4SLinus Torvalds * Get block address and transfer length 14631da177e4SLinus Torvalds */ 14641da177e4SLinus Torvalds if (scsicmd->cmnd[0] == WRITE_6) /* 6 byte command */ 14651da177e4SLinus Torvalds { 14661da177e4SLinus Torvalds lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 14671da177e4SLinus Torvalds count = scsicmd->cmnd[4]; 14681da177e4SLinus Torvalds if (count == 0) 14691da177e4SLinus Torvalds count = 256; 14707a8cf29dSMark Haverkamp } else if (scsicmd->cmnd[0] == WRITE_16) { /* 16 byte command */ 14717a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a write(16) command on id %d.\n", cid)); 14727a8cf29dSMark Haverkamp 14737a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 56) | 14747a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[3] << 48) | 14757a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[4] << 40) | 14767a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[5] << 32) | 14777a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[6] << 24) | 14787a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 14797a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 14807a8cf29dSMark Haverkamp count = (scsicmd->cmnd[10] << 24) | (scsicmd->cmnd[11] << 16) | 14817a8cf29dSMark Haverkamp (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13]; 14827a8cf29dSMark Haverkamp } else if (scsicmd->cmnd[0] == WRITE_12) { /* 12 byte command */ 14837a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a write(12) command on id %d.\n", cid)); 14847a8cf29dSMark Haverkamp 14857a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) 14867a8cf29dSMark Haverkamp | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 14877a8cf29dSMark Haverkamp count = (scsicmd->cmnd[6] << 24) | (scsicmd->cmnd[7] << 16) 14887a8cf29dSMark Haverkamp | (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 14891da177e4SLinus Torvalds } else { 14901da177e4SLinus Torvalds dprintk((KERN_DEBUG "aachba: received a write(10) command on id %d.\n", cid)); 14917a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 14921da177e4SLinus Torvalds count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 14931da177e4SLinus Torvalds } 14947a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aac_write[cpu %d]: lba = %llu, t = %ld.\n", 14951da177e4SLinus Torvalds smp_processor_id(), (unsigned long long)lba, jiffies)); 1496e8f32de5SMark Haverkamp if (aac_adapter_bounds(dev,scsicmd,lba)) 14977a8cf29dSMark Haverkamp return 0; 14981da177e4SLinus Torvalds /* 14991da177e4SLinus Torvalds * Allocate and initialize a Fib then setup a BlockWrite command 15001da177e4SLinus Torvalds */ 1501bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) { 15021da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16; 15038e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 15041da177e4SLinus Torvalds return 0; 15051da177e4SLinus Torvalds } 15061da177e4SLinus Torvalds 1507e8f32de5SMark Haverkamp status = aac_adapter_write(cmd_fibcontext, scsicmd, lba, count); 15081da177e4SLinus Torvalds 15091da177e4SLinus Torvalds /* 15101da177e4SLinus Torvalds * Check that the command queued to the controller 15111da177e4SLinus Torvalds */ 151277d644d4SMark Haverkamp if (status == -EINPROGRESS) { 151377d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 15141da177e4SLinus Torvalds return 0; 15151da177e4SLinus Torvalds } 15161da177e4SLinus Torvalds 1517bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_write: aac_fib_send failed with status: %d\n", status); 15181da177e4SLinus Torvalds /* 15191da177e4SLinus Torvalds * For some reason, the Fib didn't queue, return QUEUE_FULL 15201da177e4SLinus Torvalds */ 15211da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL; 15228e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 15231da177e4SLinus Torvalds 1524bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 1525bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 15261da177e4SLinus Torvalds return 0; 15271da177e4SLinus Torvalds } 15281da177e4SLinus Torvalds 15291da177e4SLinus Torvalds static void synchronize_callback(void *context, struct fib *fibptr) 15301da177e4SLinus Torvalds { 15311da177e4SLinus Torvalds struct aac_synchronize_reply *synchronizereply; 15321da177e4SLinus Torvalds struct scsi_cmnd *cmd; 15331da177e4SLinus Torvalds 15341da177e4SLinus Torvalds cmd = context; 153577d644d4SMark Haverkamp cmd->SCp.phase = AAC_OWNER_MIDLEVEL; 15361da177e4SLinus Torvalds 15371da177e4SLinus Torvalds dprintk((KERN_DEBUG "synchronize_callback[cpu %d]: t = %ld.\n", 15381da177e4SLinus Torvalds smp_processor_id(), jiffies)); 15391da177e4SLinus Torvalds BUG_ON(fibptr == NULL); 15401da177e4SLinus Torvalds 15411da177e4SLinus Torvalds 15421da177e4SLinus Torvalds synchronizereply = fib_data(fibptr); 15431da177e4SLinus Torvalds if (le32_to_cpu(synchronizereply->status) == CT_OK) 15441da177e4SLinus Torvalds cmd->result = DID_OK << 16 | 15451da177e4SLinus Torvalds COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 15461da177e4SLinus Torvalds else { 15471da177e4SLinus Torvalds struct scsi_device *sdev = cmd->device; 15481da177e4SLinus Torvalds struct aac_dev *dev = (struct aac_dev *)sdev->host->hostdata; 1549e5718774SMark Haverkamp u32 cid = sdev_id(sdev); 15501da177e4SLinus Torvalds printk(KERN_WARNING 15511da177e4SLinus Torvalds "synchronize_callback: synchronize failed, status = %d\n", 15521da177e4SLinus Torvalds le32_to_cpu(synchronizereply->status)); 15531da177e4SLinus Torvalds cmd->result = DID_OK << 16 | 15541da177e4SLinus Torvalds COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 15551da177e4SLinus Torvalds set_sense((u8 *)&dev->fsa_dev[cid].sense_data, 15561da177e4SLinus Torvalds HARDWARE_ERROR, 15571da177e4SLinus Torvalds SENCODE_INTERNAL_TARGET_FAILURE, 15581da177e4SLinus Torvalds ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0, 15591da177e4SLinus Torvalds 0, 0); 15601da177e4SLinus Torvalds memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 15611da177e4SLinus Torvalds min(sizeof(dev->fsa_dev[cid].sense_data), 15621da177e4SLinus Torvalds sizeof(cmd->sense_buffer))); 15631da177e4SLinus Torvalds } 15641da177e4SLinus Torvalds 1565bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1566bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 15678e0c5ebdSMark Haverkamp cmd->scsi_done(cmd); 15681da177e4SLinus Torvalds } 15691da177e4SLinus Torvalds 15701da177e4SLinus Torvalds static int aac_synchronize(struct scsi_cmnd *scsicmd, int cid) 15711da177e4SLinus Torvalds { 15721da177e4SLinus Torvalds int status; 15731da177e4SLinus Torvalds struct fib *cmd_fibcontext; 15741da177e4SLinus Torvalds struct aac_synchronize *synchronizecmd; 15751da177e4SLinus Torvalds struct scsi_cmnd *cmd; 15761da177e4SLinus Torvalds struct scsi_device *sdev = scsicmd->device; 15771da177e4SLinus Torvalds int active = 0; 157890ee3466SMark Haverkamp struct aac_dev *aac; 15791da177e4SLinus Torvalds unsigned long flags; 15801da177e4SLinus Torvalds 15811da177e4SLinus Torvalds /* 158277d644d4SMark Haverkamp * Wait for all outstanding queued commands to complete to this 158377d644d4SMark Haverkamp * specific target (block). 15841da177e4SLinus Torvalds */ 15851da177e4SLinus Torvalds spin_lock_irqsave(&sdev->list_lock, flags); 15861da177e4SLinus Torvalds list_for_each_entry(cmd, &sdev->cmd_list, list) 158777d644d4SMark Haverkamp if (cmd != scsicmd && cmd->SCp.phase == AAC_OWNER_FIRMWARE) { 15881da177e4SLinus Torvalds ++active; 15891da177e4SLinus Torvalds break; 15901da177e4SLinus Torvalds } 15911da177e4SLinus Torvalds 15921da177e4SLinus Torvalds spin_unlock_irqrestore(&sdev->list_lock, flags); 15931da177e4SLinus Torvalds 15941da177e4SLinus Torvalds /* 15951da177e4SLinus Torvalds * Yield the processor (requeue for later) 15961da177e4SLinus Torvalds */ 15971da177e4SLinus Torvalds if (active) 15981da177e4SLinus Torvalds return SCSI_MLQUEUE_DEVICE_BUSY; 15991da177e4SLinus Torvalds 160090ee3466SMark Haverkamp aac = (struct aac_dev *)scsicmd->device->host->hostdata; 16018c867b25SMark Haverkamp if (aac->in_reset) 16028c867b25SMark Haverkamp return SCSI_MLQUEUE_HOST_BUSY; 16038c867b25SMark Haverkamp 16041da177e4SLinus Torvalds /* 16057c00ffa3SMark Haverkamp * Allocate and initialize a Fib 16061da177e4SLinus Torvalds */ 160790ee3466SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(aac))) 16081da177e4SLinus Torvalds return SCSI_MLQUEUE_HOST_BUSY; 16091da177e4SLinus Torvalds 1610bfb35aa8SMark Haverkamp aac_fib_init(cmd_fibcontext); 16111da177e4SLinus Torvalds 16121da177e4SLinus Torvalds synchronizecmd = fib_data(cmd_fibcontext); 16131da177e4SLinus Torvalds synchronizecmd->command = cpu_to_le32(VM_ContainerConfig); 16141da177e4SLinus Torvalds synchronizecmd->type = cpu_to_le32(CT_FLUSH_CACHE); 16151da177e4SLinus Torvalds synchronizecmd->cid = cpu_to_le32(cid); 16161da177e4SLinus Torvalds synchronizecmd->count = 16171da177e4SLinus Torvalds cpu_to_le32(sizeof(((struct aac_synchronize_reply *)NULL)->data)); 16181da177e4SLinus Torvalds 16191da177e4SLinus Torvalds /* 16201da177e4SLinus Torvalds * Now send the Fib to the adapter 16211da177e4SLinus Torvalds */ 1622bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 16231da177e4SLinus Torvalds cmd_fibcontext, 16241da177e4SLinus Torvalds sizeof(struct aac_synchronize), 16251da177e4SLinus Torvalds FsaNormal, 16261da177e4SLinus Torvalds 0, 1, 16271da177e4SLinus Torvalds (fib_callback)synchronize_callback, 16281da177e4SLinus Torvalds (void *)scsicmd); 16291da177e4SLinus Torvalds 16301da177e4SLinus Torvalds /* 16311da177e4SLinus Torvalds * Check that the command queued to the controller 16321da177e4SLinus Torvalds */ 163377d644d4SMark Haverkamp if (status == -EINPROGRESS) { 163477d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 16351da177e4SLinus Torvalds return 0; 163677d644d4SMark Haverkamp } 16371da177e4SLinus Torvalds 16381da177e4SLinus Torvalds printk(KERN_WARNING 1639bfb35aa8SMark Haverkamp "aac_synchronize: aac_fib_send failed with status: %d.\n", status); 1640bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 1641bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 16421da177e4SLinus Torvalds return SCSI_MLQUEUE_HOST_BUSY; 16431da177e4SLinus Torvalds } 16441da177e4SLinus Torvalds 16451da177e4SLinus Torvalds /** 16461da177e4SLinus Torvalds * aac_scsi_cmd() - Process SCSI command 16471da177e4SLinus Torvalds * @scsicmd: SCSI command block 16481da177e4SLinus Torvalds * 16491da177e4SLinus Torvalds * Emulate a SCSI command and queue the required request for the 16501da177e4SLinus Torvalds * aacraid firmware. 16511da177e4SLinus Torvalds */ 16521da177e4SLinus Torvalds 16531da177e4SLinus Torvalds int aac_scsi_cmd(struct scsi_cmnd * scsicmd) 16541da177e4SLinus Torvalds { 16551da177e4SLinus Torvalds u32 cid = 0; 16561da177e4SLinus Torvalds struct Scsi_Host *host = scsicmd->device->host; 16571da177e4SLinus Torvalds struct aac_dev *dev = (struct aac_dev *)host->hostdata; 16581da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr = dev->fsa_dev; 16591da177e4SLinus Torvalds 166090ee3466SMark Haverkamp if (fsa_dev_ptr == NULL) 166190ee3466SMark Haverkamp return -1; 16621da177e4SLinus Torvalds /* 16631da177e4SLinus Torvalds * If the bus, id or lun is out of range, return fail 16641da177e4SLinus Torvalds * Test does not apply to ID 16, the pseudo id for the controller 16651da177e4SLinus Torvalds * itself. 16661da177e4SLinus Torvalds */ 1667422c0d61SJeff Garzik if (scmd_id(scsicmd) != host->this_id) { 1668e5718774SMark Haverkamp if ((scmd_channel(scsicmd) == CONTAINER_CHANNEL)) { 1669e5718774SMark Haverkamp if((scmd_id(scsicmd) >= dev->maximum_num_containers) || 1670e5718774SMark Haverkamp (scsicmd->device->lun != 0)) { 16711da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16; 16721da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 16731da177e4SLinus Torvalds return 0; 16741da177e4SLinus Torvalds } 1675e5718774SMark Haverkamp cid = scmd_id(scsicmd); 16761da177e4SLinus Torvalds 16771da177e4SLinus Torvalds /* 16781da177e4SLinus Torvalds * If the target container doesn't exist, it may have 16791da177e4SLinus Torvalds * been newly created 16801da177e4SLinus Torvalds */ 16811da177e4SLinus Torvalds if ((fsa_dev_ptr[cid].valid & 1) == 0) { 16821da177e4SLinus Torvalds switch (scsicmd->cmnd[0]) { 16837a8cf29dSMark Haverkamp case SERVICE_ACTION_IN: 16847a8cf29dSMark Haverkamp if (!(dev->raw_io_interface) || 16857a8cf29dSMark Haverkamp !(dev->raw_io_64) || 16867a8cf29dSMark Haverkamp ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16)) 16877a8cf29dSMark Haverkamp break; 16881da177e4SLinus Torvalds case INQUIRY: 16891da177e4SLinus Torvalds case READ_CAPACITY: 16901da177e4SLinus Torvalds case TEST_UNIT_READY: 16918c867b25SMark Haverkamp if (dev->in_reset) 16928c867b25SMark Haverkamp return -1; 1693fe76df42SMark Haverkamp return _aac_probe_container(scsicmd, 1694fe76df42SMark Haverkamp aac_probe_container_callback2); 16951da177e4SLinus Torvalds default: 16961da177e4SLinus Torvalds break; 16971da177e4SLinus Torvalds } 16981da177e4SLinus Torvalds } 16991da177e4SLinus Torvalds } else { /* check for physical non-dasd devices */ 1700653ba58dSMark Haverkamp if ((dev->nondasd_support == 1) || expose_physicals) { 17018c867b25SMark Haverkamp if (dev->in_reset) 17028c867b25SMark Haverkamp return -1; 17031da177e4SLinus Torvalds return aac_send_srb_fib(scsicmd); 17041da177e4SLinus Torvalds } else { 17051da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16; 17061da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 17071da177e4SLinus Torvalds return 0; 17081da177e4SLinus Torvalds } 17091da177e4SLinus Torvalds } 17101da177e4SLinus Torvalds } 17111da177e4SLinus Torvalds /* 17121da177e4SLinus Torvalds * else Command for the controller itself 17131da177e4SLinus Torvalds */ 17141da177e4SLinus Torvalds else if ((scsicmd->cmnd[0] != INQUIRY) && /* only INQUIRY & TUR cmnd supported for controller */ 17151da177e4SLinus Torvalds (scsicmd->cmnd[0] != TEST_UNIT_READY)) 17161da177e4SLinus Torvalds { 17171da177e4SLinus Torvalds dprintk((KERN_WARNING "Only INQUIRY & TUR command supported for controller, rcvd = 0x%x.\n", scsicmd->cmnd[0])); 17181da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 17191da177e4SLinus Torvalds set_sense((u8 *) &dev->fsa_dev[cid].sense_data, 17201da177e4SLinus Torvalds ILLEGAL_REQUEST, 17211da177e4SLinus Torvalds SENCODE_INVALID_COMMAND, 17221da177e4SLinus Torvalds ASENCODE_INVALID_COMMAND, 0, 0, 0, 0); 17231da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 17241da177e4SLinus Torvalds (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(scsicmd->sense_buffer)) 17251da177e4SLinus Torvalds ? sizeof(scsicmd->sense_buffer) 17261da177e4SLinus Torvalds : sizeof(dev->fsa_dev[cid].sense_data)); 17271da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 17281da177e4SLinus Torvalds return 0; 17291da177e4SLinus Torvalds } 17301da177e4SLinus Torvalds 17311da177e4SLinus Torvalds 17321da177e4SLinus Torvalds /* Handle commands here that don't really require going out to the adapter */ 17331da177e4SLinus Torvalds switch (scsicmd->cmnd[0]) { 17341da177e4SLinus Torvalds case INQUIRY: 17351da177e4SLinus Torvalds { 17363b2946ccSMark Haverkamp struct inquiry_data inq_data; 17371da177e4SLinus Torvalds 1738e5718774SMark Haverkamp dprintk((KERN_DEBUG "INQUIRY command, ID: %d.\n", scmd_id(scsicmd))); 17393b2946ccSMark Haverkamp memset(&inq_data, 0, sizeof (struct inquiry_data)); 17401da177e4SLinus Torvalds 17413b2946ccSMark Haverkamp inq_data.inqd_ver = 2; /* claim compliance to SCSI-2 */ 17423b2946ccSMark 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 */ 17433b2946ccSMark Haverkamp inq_data.inqd_len = 31; 17441da177e4SLinus Torvalds /*Format for "pad2" is RelAdr | WBus32 | WBus16 | Sync | Linked |Reserved| CmdQue | SftRe */ 17453b2946ccSMark Haverkamp inq_data.inqd_pad2= 0x32 ; /*WBus16|Sync|CmdQue */ 17461da177e4SLinus Torvalds /* 17471da177e4SLinus Torvalds * Set the Vendor, Product, and Revision Level 17481da177e4SLinus Torvalds * see: <vendor>.c i.e. aac.c 17491da177e4SLinus Torvalds */ 1750422c0d61SJeff Garzik if (scmd_id(scsicmd) == host->this_id) { 17516391a113STobias Klauser setinqstr(dev, (void *) (inq_data.inqd_vid), ARRAY_SIZE(container_types)); 17523b2946ccSMark Haverkamp inq_data.inqd_pdt = INQD_PDT_PROC; /* Processor device */ 17533b2946ccSMark Haverkamp aac_internal_transfer(scsicmd, &inq_data, 0, sizeof(inq_data)); 17541da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 17551da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 17561da177e4SLinus Torvalds return 0; 17571da177e4SLinus Torvalds } 17588c867b25SMark Haverkamp if (dev->in_reset) 17598c867b25SMark Haverkamp return -1; 1760794d0601SMark Haverkamp setinqstr(dev, (void *) (inq_data.inqd_vid), fsa_dev_ptr[cid].type); 17613b2946ccSMark Haverkamp inq_data.inqd_pdt = INQD_PDT_DA; /* Direct/random access device */ 17623b2946ccSMark Haverkamp aac_internal_transfer(scsicmd, &inq_data, 0, sizeof(inq_data)); 17631da177e4SLinus Torvalds return aac_get_container_name(scsicmd, cid); 17641da177e4SLinus Torvalds } 17657a8cf29dSMark Haverkamp case SERVICE_ACTION_IN: 17667a8cf29dSMark Haverkamp if (!(dev->raw_io_interface) || 17677a8cf29dSMark Haverkamp !(dev->raw_io_64) || 17687a8cf29dSMark Haverkamp ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16)) 17697a8cf29dSMark Haverkamp break; 17707a8cf29dSMark Haverkamp { 17717a8cf29dSMark Haverkamp u64 capacity; 177207ce5ebaSMark Haverkamp char cp[13]; 17737a8cf29dSMark Haverkamp 17747a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "READ CAPACITY_16 command.\n")); 17757a8cf29dSMark Haverkamp capacity = fsa_dev_ptr[cid].size - 1; 17767a8cf29dSMark Haverkamp cp[0] = (capacity >> 56) & 0xff; 17777a8cf29dSMark Haverkamp cp[1] = (capacity >> 48) & 0xff; 17787a8cf29dSMark Haverkamp cp[2] = (capacity >> 40) & 0xff; 17797a8cf29dSMark Haverkamp cp[3] = (capacity >> 32) & 0xff; 17807a8cf29dSMark Haverkamp cp[4] = (capacity >> 24) & 0xff; 17817a8cf29dSMark Haverkamp cp[5] = (capacity >> 16) & 0xff; 17827a8cf29dSMark Haverkamp cp[6] = (capacity >> 8) & 0xff; 17837a8cf29dSMark Haverkamp cp[7] = (capacity >> 0) & 0xff; 17847a8cf29dSMark Haverkamp cp[8] = 0; 17857a8cf29dSMark Haverkamp cp[9] = 0; 17867a8cf29dSMark Haverkamp cp[10] = 2; 17877a8cf29dSMark Haverkamp cp[11] = 0; 178807ce5ebaSMark Haverkamp cp[12] = 0; 178907ce5ebaSMark Haverkamp aac_internal_transfer(scsicmd, cp, 0, 17901241f359SMark Haverkamp min_t(size_t, scsicmd->cmnd[13], sizeof(cp))); 179107ce5ebaSMark Haverkamp if (sizeof(cp) < scsicmd->cmnd[13]) { 179207ce5ebaSMark Haverkamp unsigned int len, offset = sizeof(cp); 179307ce5ebaSMark Haverkamp 179407ce5ebaSMark Haverkamp memset(cp, 0, offset); 179507ce5ebaSMark Haverkamp do { 17961241f359SMark Haverkamp len = min_t(size_t, scsicmd->cmnd[13] - offset, 17971241f359SMark Haverkamp sizeof(cp)); 179807ce5ebaSMark Haverkamp aac_internal_transfer(scsicmd, cp, offset, len); 179907ce5ebaSMark Haverkamp } while ((offset += len) < scsicmd->cmnd[13]); 180007ce5ebaSMark Haverkamp } 18017a8cf29dSMark Haverkamp 18027a8cf29dSMark Haverkamp /* Do not cache partition table for arrays */ 18037a8cf29dSMark Haverkamp scsicmd->device->removable = 1; 18047a8cf29dSMark Haverkamp 18057a8cf29dSMark Haverkamp scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 18067a8cf29dSMark Haverkamp scsicmd->scsi_done(scsicmd); 18077a8cf29dSMark Haverkamp 18087a8cf29dSMark Haverkamp return 0; 18097a8cf29dSMark Haverkamp } 18107a8cf29dSMark Haverkamp 18111da177e4SLinus Torvalds case READ_CAPACITY: 18121da177e4SLinus Torvalds { 18131da177e4SLinus Torvalds u32 capacity; 18143b2946ccSMark Haverkamp char cp[8]; 18151da177e4SLinus Torvalds 18161da177e4SLinus Torvalds dprintk((KERN_DEBUG "READ CAPACITY command.\n")); 18177a8cf29dSMark Haverkamp if (fsa_dev_ptr[cid].size <= 0x100000000ULL) 18181da177e4SLinus Torvalds capacity = fsa_dev_ptr[cid].size - 1; 18191da177e4SLinus Torvalds else 18201da177e4SLinus Torvalds capacity = (u32)-1; 18213b2946ccSMark Haverkamp 18221da177e4SLinus Torvalds cp[0] = (capacity >> 24) & 0xff; 18231da177e4SLinus Torvalds cp[1] = (capacity >> 16) & 0xff; 18241da177e4SLinus Torvalds cp[2] = (capacity >> 8) & 0xff; 18251da177e4SLinus Torvalds cp[3] = (capacity >> 0) & 0xff; 18261da177e4SLinus Torvalds cp[4] = 0; 18271da177e4SLinus Torvalds cp[5] = 0; 18281da177e4SLinus Torvalds cp[6] = 2; 18291da177e4SLinus Torvalds cp[7] = 0; 18303b2946ccSMark Haverkamp aac_internal_transfer(scsicmd, cp, 0, sizeof(cp)); 18317a8cf29dSMark Haverkamp /* Do not cache partition table for arrays */ 18327a8cf29dSMark Haverkamp scsicmd->device->removable = 1; 18331da177e4SLinus Torvalds 18341da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 18351da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 18361da177e4SLinus Torvalds 18371da177e4SLinus Torvalds return 0; 18381da177e4SLinus Torvalds } 18391da177e4SLinus Torvalds 18401da177e4SLinus Torvalds case MODE_SENSE: 18411da177e4SLinus Torvalds { 18423b2946ccSMark Haverkamp char mode_buf[4]; 18431da177e4SLinus Torvalds 18441da177e4SLinus Torvalds dprintk((KERN_DEBUG "MODE SENSE command.\n")); 18451da177e4SLinus Torvalds mode_buf[0] = 3; /* Mode data length */ 18461da177e4SLinus Torvalds mode_buf[1] = 0; /* Medium type - default */ 18471da177e4SLinus Torvalds mode_buf[2] = 0; /* Device-specific param, bit 8: 0/1 = write enabled/protected */ 18481da177e4SLinus Torvalds mode_buf[3] = 0; /* Block descriptor length */ 18491da177e4SLinus Torvalds 18503b2946ccSMark Haverkamp aac_internal_transfer(scsicmd, mode_buf, 0, sizeof(mode_buf)); 18511da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 18521da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 18531da177e4SLinus Torvalds 18541da177e4SLinus Torvalds return 0; 18551da177e4SLinus Torvalds } 18561da177e4SLinus Torvalds case MODE_SENSE_10: 18571da177e4SLinus Torvalds { 18583b2946ccSMark Haverkamp char mode_buf[8]; 18591da177e4SLinus Torvalds 18601da177e4SLinus Torvalds dprintk((KERN_DEBUG "MODE SENSE 10 byte command.\n")); 18611da177e4SLinus Torvalds mode_buf[0] = 0; /* Mode data length (MSB) */ 18621da177e4SLinus Torvalds mode_buf[1] = 6; /* Mode data length (LSB) */ 18631da177e4SLinus Torvalds mode_buf[2] = 0; /* Medium type - default */ 18641da177e4SLinus Torvalds mode_buf[3] = 0; /* Device-specific param, bit 8: 0/1 = write enabled/protected */ 18651da177e4SLinus Torvalds mode_buf[4] = 0; /* reserved */ 18661da177e4SLinus Torvalds mode_buf[5] = 0; /* reserved */ 18671da177e4SLinus Torvalds mode_buf[6] = 0; /* Block descriptor length (MSB) */ 18681da177e4SLinus Torvalds mode_buf[7] = 0; /* Block descriptor length (LSB) */ 18693b2946ccSMark Haverkamp aac_internal_transfer(scsicmd, mode_buf, 0, sizeof(mode_buf)); 18701da177e4SLinus Torvalds 18711da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 18721da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 18731da177e4SLinus Torvalds 18741da177e4SLinus Torvalds return 0; 18751da177e4SLinus Torvalds } 18761da177e4SLinus Torvalds case REQUEST_SENSE: 18771da177e4SLinus Torvalds dprintk((KERN_DEBUG "REQUEST SENSE command.\n")); 18781da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, sizeof (struct sense_data)); 18791da177e4SLinus Torvalds memset(&dev->fsa_dev[cid].sense_data, 0, sizeof (struct sense_data)); 18801da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 18811da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 18821da177e4SLinus Torvalds return 0; 18831da177e4SLinus Torvalds 18841da177e4SLinus Torvalds case ALLOW_MEDIUM_REMOVAL: 18851da177e4SLinus Torvalds dprintk((KERN_DEBUG "LOCK command.\n")); 18861da177e4SLinus Torvalds if (scsicmd->cmnd[4]) 18871da177e4SLinus Torvalds fsa_dev_ptr[cid].locked = 1; 18881da177e4SLinus Torvalds else 18891da177e4SLinus Torvalds fsa_dev_ptr[cid].locked = 0; 18901da177e4SLinus Torvalds 18911da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 18921da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 18931da177e4SLinus Torvalds return 0; 18941da177e4SLinus Torvalds /* 18951da177e4SLinus Torvalds * These commands are all No-Ops 18961da177e4SLinus Torvalds */ 18971da177e4SLinus Torvalds case TEST_UNIT_READY: 18981da177e4SLinus Torvalds case RESERVE: 18991da177e4SLinus Torvalds case RELEASE: 19001da177e4SLinus Torvalds case REZERO_UNIT: 19011da177e4SLinus Torvalds case REASSIGN_BLOCKS: 19021da177e4SLinus Torvalds case SEEK_10: 19031da177e4SLinus Torvalds case START_STOP: 19041da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 19051da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 19061da177e4SLinus Torvalds return 0; 19071da177e4SLinus Torvalds } 19081da177e4SLinus Torvalds 19091da177e4SLinus Torvalds switch (scsicmd->cmnd[0]) 19101da177e4SLinus Torvalds { 19111da177e4SLinus Torvalds case READ_6: 19121da177e4SLinus Torvalds case READ_10: 19137a8cf29dSMark Haverkamp case READ_12: 19147a8cf29dSMark Haverkamp case READ_16: 19158c867b25SMark Haverkamp if (dev->in_reset) 19168c867b25SMark Haverkamp return -1; 19171da177e4SLinus Torvalds /* 19181da177e4SLinus Torvalds * Hack to keep track of ordinal number of the device that 19191da177e4SLinus Torvalds * corresponds to a container. Needed to convert 19201da177e4SLinus Torvalds * containers to /dev/sd device names 19211da177e4SLinus Torvalds */ 19221da177e4SLinus Torvalds 19231da177e4SLinus Torvalds if (scsicmd->request->rq_disk) 19247a8cf29dSMark Haverkamp strlcpy(fsa_dev_ptr[cid].devname, 19251da177e4SLinus Torvalds scsicmd->request->rq_disk->disk_name, 19267a8cf29dSMark Haverkamp min(sizeof(fsa_dev_ptr[cid].devname), 19277a8cf29dSMark Haverkamp sizeof(scsicmd->request->rq_disk->disk_name) + 1)); 192877d644d4SMark Haverkamp 192977d644d4SMark Haverkamp return aac_read(scsicmd, cid); 19301da177e4SLinus Torvalds 19311da177e4SLinus Torvalds case WRITE_6: 19321da177e4SLinus Torvalds case WRITE_10: 19337a8cf29dSMark Haverkamp case WRITE_12: 19347a8cf29dSMark Haverkamp case WRITE_16: 19358c867b25SMark Haverkamp if (dev->in_reset) 19368c867b25SMark Haverkamp return -1; 193777d644d4SMark Haverkamp return aac_write(scsicmd, cid); 19381da177e4SLinus Torvalds 19391da177e4SLinus Torvalds case SYNCHRONIZE_CACHE: 19401da177e4SLinus Torvalds /* Issue FIB to tell Firmware to flush it's cache */ 19411da177e4SLinus Torvalds return aac_synchronize(scsicmd, cid); 19421da177e4SLinus Torvalds 19431da177e4SLinus Torvalds default: 19441da177e4SLinus Torvalds /* 19451da177e4SLinus Torvalds * Unhandled commands 19461da177e4SLinus Torvalds */ 19477c00ffa3SMark Haverkamp dprintk((KERN_WARNING "Unhandled SCSI Command: 0x%x.\n", scsicmd->cmnd[0])); 19481da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 19491da177e4SLinus Torvalds set_sense((u8 *) &dev->fsa_dev[cid].sense_data, 19501da177e4SLinus Torvalds ILLEGAL_REQUEST, SENCODE_INVALID_COMMAND, 19511da177e4SLinus Torvalds ASENCODE_INVALID_COMMAND, 0, 0, 0, 0); 19521da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 19531da177e4SLinus Torvalds (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(scsicmd->sense_buffer)) 19541da177e4SLinus Torvalds ? sizeof(scsicmd->sense_buffer) 19551da177e4SLinus Torvalds : sizeof(dev->fsa_dev[cid].sense_data)); 19561da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 19571da177e4SLinus Torvalds return 0; 19581da177e4SLinus Torvalds } 19591da177e4SLinus Torvalds } 19601da177e4SLinus Torvalds 19611da177e4SLinus Torvalds static int query_disk(struct aac_dev *dev, void __user *arg) 19621da177e4SLinus Torvalds { 19631da177e4SLinus Torvalds struct aac_query_disk qd; 19641da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 19651da177e4SLinus Torvalds 19661da177e4SLinus Torvalds fsa_dev_ptr = dev->fsa_dev; 196790ee3466SMark Haverkamp if (!fsa_dev_ptr) 196865101355SMark Haverkamp return -EBUSY; 19691da177e4SLinus Torvalds if (copy_from_user(&qd, arg, sizeof (struct aac_query_disk))) 19701da177e4SLinus Torvalds return -EFAULT; 19711da177e4SLinus Torvalds if (qd.cnum == -1) 1972e5718774SMark Haverkamp qd.cnum = qd.id; 19731da177e4SLinus Torvalds else if ((qd.bus == -1) && (qd.id == -1) && (qd.lun == -1)) 19741da177e4SLinus Torvalds { 19751da177e4SLinus Torvalds if (qd.cnum < 0 || qd.cnum >= dev->maximum_num_containers) 19761da177e4SLinus Torvalds return -EINVAL; 19771da177e4SLinus Torvalds qd.instance = dev->scsi_host_ptr->host_no; 19781da177e4SLinus Torvalds qd.bus = 0; 19791da177e4SLinus Torvalds qd.id = CONTAINER_TO_ID(qd.cnum); 19801da177e4SLinus Torvalds qd.lun = CONTAINER_TO_LUN(qd.cnum); 19811da177e4SLinus Torvalds } 19821da177e4SLinus Torvalds else return -EINVAL; 19831da177e4SLinus Torvalds 19841da177e4SLinus Torvalds qd.valid = fsa_dev_ptr[qd.cnum].valid; 19851da177e4SLinus Torvalds qd.locked = fsa_dev_ptr[qd.cnum].locked; 19861da177e4SLinus Torvalds qd.deleted = fsa_dev_ptr[qd.cnum].deleted; 19871da177e4SLinus Torvalds 19881da177e4SLinus Torvalds if (fsa_dev_ptr[qd.cnum].devname[0] == '\0') 19891da177e4SLinus Torvalds qd.unmapped = 1; 19901da177e4SLinus Torvalds else 19911da177e4SLinus Torvalds qd.unmapped = 0; 19921da177e4SLinus Torvalds 19931da177e4SLinus Torvalds strlcpy(qd.name, fsa_dev_ptr[qd.cnum].devname, 19941da177e4SLinus Torvalds min(sizeof(qd.name), sizeof(fsa_dev_ptr[qd.cnum].devname) + 1)); 19951da177e4SLinus Torvalds 19961da177e4SLinus Torvalds if (copy_to_user(arg, &qd, sizeof (struct aac_query_disk))) 19971da177e4SLinus Torvalds return -EFAULT; 19981da177e4SLinus Torvalds return 0; 19991da177e4SLinus Torvalds } 20001da177e4SLinus Torvalds 20011da177e4SLinus Torvalds static int force_delete_disk(struct aac_dev *dev, void __user *arg) 20021da177e4SLinus Torvalds { 20031da177e4SLinus Torvalds struct aac_delete_disk dd; 20041da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 20051da177e4SLinus Torvalds 20061da177e4SLinus Torvalds fsa_dev_ptr = dev->fsa_dev; 200765101355SMark Haverkamp if (!fsa_dev_ptr) 200865101355SMark Haverkamp return -EBUSY; 20091da177e4SLinus Torvalds 20101da177e4SLinus Torvalds if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk))) 20111da177e4SLinus Torvalds return -EFAULT; 20121da177e4SLinus Torvalds 20131da177e4SLinus Torvalds if (dd.cnum >= dev->maximum_num_containers) 20141da177e4SLinus Torvalds return -EINVAL; 20151da177e4SLinus Torvalds /* 20161da177e4SLinus Torvalds * Mark this container as being deleted. 20171da177e4SLinus Torvalds */ 20181da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].deleted = 1; 20191da177e4SLinus Torvalds /* 20201da177e4SLinus Torvalds * Mark the container as no longer valid 20211da177e4SLinus Torvalds */ 20221da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].valid = 0; 20231da177e4SLinus Torvalds return 0; 20241da177e4SLinus Torvalds } 20251da177e4SLinus Torvalds 20261da177e4SLinus Torvalds static int delete_disk(struct aac_dev *dev, void __user *arg) 20271da177e4SLinus Torvalds { 20281da177e4SLinus Torvalds struct aac_delete_disk dd; 20291da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 20301da177e4SLinus Torvalds 20311da177e4SLinus Torvalds fsa_dev_ptr = dev->fsa_dev; 203290ee3466SMark Haverkamp if (!fsa_dev_ptr) 203365101355SMark Haverkamp return -EBUSY; 20341da177e4SLinus Torvalds 20351da177e4SLinus Torvalds if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk))) 20361da177e4SLinus Torvalds return -EFAULT; 20371da177e4SLinus Torvalds 20381da177e4SLinus Torvalds if (dd.cnum >= dev->maximum_num_containers) 20391da177e4SLinus Torvalds return -EINVAL; 20401da177e4SLinus Torvalds /* 20411da177e4SLinus Torvalds * If the container is locked, it can not be deleted by the API. 20421da177e4SLinus Torvalds */ 20431da177e4SLinus Torvalds if (fsa_dev_ptr[dd.cnum].locked) 20441da177e4SLinus Torvalds return -EBUSY; 20451da177e4SLinus Torvalds else { 20461da177e4SLinus Torvalds /* 20471da177e4SLinus Torvalds * Mark the container as no longer being valid. 20481da177e4SLinus Torvalds */ 20491da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].valid = 0; 20501da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].devname[0] = '\0'; 20511da177e4SLinus Torvalds return 0; 20521da177e4SLinus Torvalds } 20531da177e4SLinus Torvalds } 20541da177e4SLinus Torvalds 20551da177e4SLinus Torvalds int aac_dev_ioctl(struct aac_dev *dev, int cmd, void __user *arg) 20561da177e4SLinus Torvalds { 20571da177e4SLinus Torvalds switch (cmd) { 20581da177e4SLinus Torvalds case FSACTL_QUERY_DISK: 20591da177e4SLinus Torvalds return query_disk(dev, arg); 20601da177e4SLinus Torvalds case FSACTL_DELETE_DISK: 20611da177e4SLinus Torvalds return delete_disk(dev, arg); 20621da177e4SLinus Torvalds case FSACTL_FORCE_DELETE_DISK: 20631da177e4SLinus Torvalds return force_delete_disk(dev, arg); 20641da177e4SLinus Torvalds case FSACTL_GET_CONTAINERS: 20651da177e4SLinus Torvalds return aac_get_containers(dev); 20661da177e4SLinus Torvalds default: 20671da177e4SLinus Torvalds return -ENOTTY; 20681da177e4SLinus Torvalds } 20691da177e4SLinus Torvalds } 20701da177e4SLinus Torvalds 20711da177e4SLinus Torvalds /** 20721da177e4SLinus Torvalds * 20731da177e4SLinus Torvalds * aac_srb_callback 20741da177e4SLinus Torvalds * @context: the context set in the fib - here it is scsi cmd 20751da177e4SLinus Torvalds * @fibptr: pointer to the fib 20761da177e4SLinus Torvalds * 20771da177e4SLinus Torvalds * Handles the completion of a scsi command to a non dasd device 20781da177e4SLinus Torvalds * 20791da177e4SLinus Torvalds */ 20801da177e4SLinus Torvalds 20811da177e4SLinus Torvalds static void aac_srb_callback(void *context, struct fib * fibptr) 20821da177e4SLinus Torvalds { 20831da177e4SLinus Torvalds struct aac_dev *dev; 20841da177e4SLinus Torvalds struct aac_srb_reply *srbreply; 20851da177e4SLinus Torvalds struct scsi_cmnd *scsicmd; 20861da177e4SLinus Torvalds 20871da177e4SLinus Torvalds scsicmd = (struct scsi_cmnd *) context; 208877d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL; 20891da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 20901da177e4SLinus Torvalds 2091125e1874SEric Sesterhenn BUG_ON(fibptr == NULL); 20921da177e4SLinus Torvalds 20931da177e4SLinus Torvalds srbreply = (struct aac_srb_reply *) fib_data(fibptr); 20941da177e4SLinus Torvalds 20951da177e4SLinus Torvalds scsicmd->sense_buffer[0] = '\0'; /* Initialize sense valid flag to false */ 20961da177e4SLinus Torvalds /* 20971da177e4SLinus Torvalds * Calculate resid for sg 20981da177e4SLinus Torvalds */ 20991da177e4SLinus Torvalds 21001da177e4SLinus Torvalds scsicmd->resid = scsicmd->request_bufflen - 21011da177e4SLinus Torvalds le32_to_cpu(srbreply->data_xfer_length); 21021da177e4SLinus Torvalds 21031da177e4SLinus Torvalds if(scsicmd->use_sg) 21041da177e4SLinus Torvalds pci_unmap_sg(dev->pdev, 21055d5ff44fSChristoph Hellwig (struct scatterlist *)scsicmd->request_buffer, 21061da177e4SLinus Torvalds scsicmd->use_sg, 21071da177e4SLinus Torvalds scsicmd->sc_data_direction); 21081da177e4SLinus Torvalds else if(scsicmd->request_bufflen) 21091da177e4SLinus Torvalds pci_unmap_single(dev->pdev, scsicmd->SCp.dma_handle, scsicmd->request_bufflen, 21101da177e4SLinus Torvalds scsicmd->sc_data_direction); 21111da177e4SLinus Torvalds 21121da177e4SLinus Torvalds /* 21131da177e4SLinus Torvalds * First check the fib status 21141da177e4SLinus Torvalds */ 21151da177e4SLinus Torvalds 21161da177e4SLinus Torvalds if (le32_to_cpu(srbreply->status) != ST_OK){ 21171da177e4SLinus Torvalds int len; 21181da177e4SLinus Torvalds printk(KERN_WARNING "aac_srb_callback: srb failed, status = %d\n", le32_to_cpu(srbreply->status)); 21191da177e4SLinus Torvalds len = (le32_to_cpu(srbreply->sense_data_size) > 21201da177e4SLinus Torvalds sizeof(scsicmd->sense_buffer)) ? 21211da177e4SLinus Torvalds sizeof(scsicmd->sense_buffer) : 21221da177e4SLinus Torvalds le32_to_cpu(srbreply->sense_data_size); 21231da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 21241da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, srbreply->sense_data, len); 21251da177e4SLinus Torvalds } 21261da177e4SLinus Torvalds 21271da177e4SLinus Torvalds /* 21281da177e4SLinus Torvalds * Next check the srb status 21291da177e4SLinus Torvalds */ 21301da177e4SLinus Torvalds switch( (le32_to_cpu(srbreply->srb_status))&0x3f){ 21311da177e4SLinus Torvalds case SRB_STATUS_ERROR_RECOVERY: 21321da177e4SLinus Torvalds case SRB_STATUS_PENDING: 21331da177e4SLinus Torvalds case SRB_STATUS_SUCCESS: 21341da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 21351da177e4SLinus Torvalds break; 21361da177e4SLinus Torvalds case SRB_STATUS_DATA_OVERRUN: 21371da177e4SLinus Torvalds switch(scsicmd->cmnd[0]){ 21381da177e4SLinus Torvalds case READ_6: 21391da177e4SLinus Torvalds case WRITE_6: 21401da177e4SLinus Torvalds case READ_10: 21411da177e4SLinus Torvalds case WRITE_10: 21421da177e4SLinus Torvalds case READ_12: 21431da177e4SLinus Torvalds case WRITE_12: 21447a8cf29dSMark Haverkamp case READ_16: 21457a8cf29dSMark Haverkamp case WRITE_16: 21461da177e4SLinus Torvalds if(le32_to_cpu(srbreply->data_xfer_length) < scsicmd->underflow ) { 21471da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: SCSI CMD underflow\n"); 21481da177e4SLinus Torvalds } else { 21491da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: SCSI CMD Data Overrun\n"); 21501da177e4SLinus Torvalds } 21511da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8; 21521da177e4SLinus Torvalds break; 21531da177e4SLinus Torvalds case INQUIRY: { 21541da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 21551da177e4SLinus Torvalds break; 21561da177e4SLinus Torvalds } 21571da177e4SLinus Torvalds default: 21581da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 21591da177e4SLinus Torvalds break; 21601da177e4SLinus Torvalds } 21611da177e4SLinus Torvalds break; 21621da177e4SLinus Torvalds case SRB_STATUS_ABORTED: 21631da177e4SLinus Torvalds scsicmd->result = DID_ABORT << 16 | ABORT << 8; 21641da177e4SLinus Torvalds break; 21651da177e4SLinus Torvalds case SRB_STATUS_ABORT_FAILED: 21661da177e4SLinus Torvalds // Not sure about this one - but assuming the hba was trying to abort for some reason 21671da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | ABORT << 8; 21681da177e4SLinus Torvalds break; 21691da177e4SLinus Torvalds case SRB_STATUS_PARITY_ERROR: 21701da177e4SLinus Torvalds scsicmd->result = DID_PARITY << 16 | MSG_PARITY_ERROR << 8; 21711da177e4SLinus Torvalds break; 21721da177e4SLinus Torvalds case SRB_STATUS_NO_DEVICE: 21731da177e4SLinus Torvalds case SRB_STATUS_INVALID_PATH_ID: 21741da177e4SLinus Torvalds case SRB_STATUS_INVALID_TARGET_ID: 21751da177e4SLinus Torvalds case SRB_STATUS_INVALID_LUN: 21761da177e4SLinus Torvalds case SRB_STATUS_SELECTION_TIMEOUT: 21771da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8; 21781da177e4SLinus Torvalds break; 21791da177e4SLinus Torvalds 21801da177e4SLinus Torvalds case SRB_STATUS_COMMAND_TIMEOUT: 21811da177e4SLinus Torvalds case SRB_STATUS_TIMEOUT: 21821da177e4SLinus Torvalds scsicmd->result = DID_TIME_OUT << 16 | COMMAND_COMPLETE << 8; 21831da177e4SLinus Torvalds break; 21841da177e4SLinus Torvalds 21851da177e4SLinus Torvalds case SRB_STATUS_BUSY: 21861da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8; 21871da177e4SLinus Torvalds break; 21881da177e4SLinus Torvalds 21891da177e4SLinus Torvalds case SRB_STATUS_BUS_RESET: 21901da177e4SLinus Torvalds scsicmd->result = DID_RESET << 16 | COMMAND_COMPLETE << 8; 21911da177e4SLinus Torvalds break; 21921da177e4SLinus Torvalds 21931da177e4SLinus Torvalds case SRB_STATUS_MESSAGE_REJECTED: 21941da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | MESSAGE_REJECT << 8; 21951da177e4SLinus Torvalds break; 21961da177e4SLinus Torvalds case SRB_STATUS_REQUEST_FLUSHED: 21971da177e4SLinus Torvalds case SRB_STATUS_ERROR: 21981da177e4SLinus Torvalds case SRB_STATUS_INVALID_REQUEST: 21991da177e4SLinus Torvalds case SRB_STATUS_REQUEST_SENSE_FAILED: 22001da177e4SLinus Torvalds case SRB_STATUS_NO_HBA: 22011da177e4SLinus Torvalds case SRB_STATUS_UNEXPECTED_BUS_FREE: 22021da177e4SLinus Torvalds case SRB_STATUS_PHASE_SEQUENCE_FAILURE: 22031da177e4SLinus Torvalds case SRB_STATUS_BAD_SRB_BLOCK_LENGTH: 22041da177e4SLinus Torvalds case SRB_STATUS_DELAYED_RETRY: 22051da177e4SLinus Torvalds case SRB_STATUS_BAD_FUNCTION: 22061da177e4SLinus Torvalds case SRB_STATUS_NOT_STARTED: 22071da177e4SLinus Torvalds case SRB_STATUS_NOT_IN_USE: 22081da177e4SLinus Torvalds case SRB_STATUS_FORCE_ABORT: 22091da177e4SLinus Torvalds case SRB_STATUS_DOMAIN_VALIDATION_FAIL: 22101da177e4SLinus Torvalds default: 22111da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 22121da177e4SLinus Torvalds printk("aacraid: SRB ERROR(%u) %s scsi cmd 0x%x - scsi status 0x%x\n", 22131da177e4SLinus Torvalds le32_to_cpu(srbreply->srb_status) & 0x3F, 22141da177e4SLinus Torvalds aac_get_status_string( 22151da177e4SLinus Torvalds le32_to_cpu(srbreply->srb_status) & 0x3F), 22161da177e4SLinus Torvalds scsicmd->cmnd[0], 22171da177e4SLinus Torvalds le32_to_cpu(srbreply->scsi_status)); 22181da177e4SLinus Torvalds #endif 22191da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8; 22201da177e4SLinus Torvalds break; 22211da177e4SLinus Torvalds } 22221da177e4SLinus Torvalds if (le32_to_cpu(srbreply->scsi_status) == 0x02 ){ // Check Condition 22231da177e4SLinus Torvalds int len; 22241da177e4SLinus Torvalds scsicmd->result |= SAM_STAT_CHECK_CONDITION; 22251da177e4SLinus Torvalds len = (le32_to_cpu(srbreply->sense_data_size) > 22261da177e4SLinus Torvalds sizeof(scsicmd->sense_buffer)) ? 22271da177e4SLinus Torvalds sizeof(scsicmd->sense_buffer) : 22281da177e4SLinus Torvalds le32_to_cpu(srbreply->sense_data_size); 22291da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 22307a8cf29dSMark Haverkamp printk(KERN_WARNING "aac_srb_callback: check condition, status = %d len=%d\n", 22317a8cf29dSMark Haverkamp le32_to_cpu(srbreply->status), len); 22321da177e4SLinus Torvalds #endif 22331da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, srbreply->sense_data, len); 22341da177e4SLinus Torvalds 22351da177e4SLinus Torvalds } 22361da177e4SLinus Torvalds /* 22371da177e4SLinus Torvalds * OR in the scsi status (already shifted up a bit) 22381da177e4SLinus Torvalds */ 22391da177e4SLinus Torvalds scsicmd->result |= le32_to_cpu(srbreply->scsi_status); 22401da177e4SLinus Torvalds 2241bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 2242bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 22438e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 22441da177e4SLinus Torvalds } 22451da177e4SLinus Torvalds 22461da177e4SLinus Torvalds /** 22471da177e4SLinus Torvalds * 22481da177e4SLinus Torvalds * aac_send_scb_fib 22491da177e4SLinus Torvalds * @scsicmd: the scsi command block 22501da177e4SLinus Torvalds * 22511da177e4SLinus Torvalds * This routine will form a FIB and fill in the aac_srb from the 22521da177e4SLinus Torvalds * scsicmd passed in. 22531da177e4SLinus Torvalds */ 22541da177e4SLinus Torvalds 22551da177e4SLinus Torvalds static int aac_send_srb_fib(struct scsi_cmnd* scsicmd) 22561da177e4SLinus Torvalds { 22571da177e4SLinus Torvalds struct fib* cmd_fibcontext; 22581da177e4SLinus Torvalds struct aac_dev* dev; 22591da177e4SLinus Torvalds int status; 22601da177e4SLinus Torvalds 226184971738SMark Haverkamp dev = (struct aac_dev *)scsicmd->device->host->hostdata; 2262e5718774SMark Haverkamp if (scmd_id(scsicmd) >= dev->maximum_num_physicals || 226384971738SMark Haverkamp scsicmd->device->lun > 7) { 22641da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16; 22651da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 22661da177e4SLinus Torvalds return 0; 22671da177e4SLinus Torvalds } 22681da177e4SLinus Torvalds 22691da177e4SLinus Torvalds /* 22701da177e4SLinus Torvalds * Allocate and initialize a Fib then setup a BlockWrite command 22711da177e4SLinus Torvalds */ 2272bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) { 22731da177e4SLinus Torvalds return -1; 22741da177e4SLinus Torvalds } 2275e8f32de5SMark Haverkamp status = aac_adapter_scsi(cmd_fibcontext, scsicmd); 22761da177e4SLinus Torvalds 22771da177e4SLinus Torvalds /* 22781da177e4SLinus Torvalds * Check that the command queued to the controller 22791da177e4SLinus Torvalds */ 22801da177e4SLinus Torvalds if (status == -EINPROGRESS) { 228177d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 22821da177e4SLinus Torvalds return 0; 22831da177e4SLinus Torvalds } 22841da177e4SLinus Torvalds 2285bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_srb: aac_fib_send failed with status: %d\n", status); 2286bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 2287bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 22881da177e4SLinus Torvalds 22891da177e4SLinus Torvalds return -1; 22901da177e4SLinus Torvalds } 22911da177e4SLinus Torvalds 22921da177e4SLinus Torvalds static unsigned long aac_build_sg(struct scsi_cmnd* scsicmd, struct sgmap* psg) 22931da177e4SLinus Torvalds { 22941da177e4SLinus Torvalds struct aac_dev *dev; 22951da177e4SLinus Torvalds unsigned long byte_count = 0; 22961da177e4SLinus Torvalds 22971da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 22981da177e4SLinus Torvalds // Get rid of old data 22991da177e4SLinus Torvalds psg->count = 0; 23001da177e4SLinus Torvalds psg->sg[0].addr = 0; 23011da177e4SLinus Torvalds psg->sg[0].count = 0; 23021da177e4SLinus Torvalds if (scsicmd->use_sg) { 23031da177e4SLinus Torvalds struct scatterlist *sg; 23041da177e4SLinus Torvalds int i; 23051da177e4SLinus Torvalds int sg_count; 23061da177e4SLinus Torvalds sg = (struct scatterlist *) scsicmd->request_buffer; 23071da177e4SLinus Torvalds 23081da177e4SLinus Torvalds sg_count = pci_map_sg(dev->pdev, sg, scsicmd->use_sg, 23091da177e4SLinus Torvalds scsicmd->sc_data_direction); 23101da177e4SLinus Torvalds psg->count = cpu_to_le32(sg_count); 23111da177e4SLinus Torvalds 23121da177e4SLinus Torvalds for (i = 0; i < sg_count; i++) { 23131da177e4SLinus Torvalds psg->sg[i].addr = cpu_to_le32(sg_dma_address(sg)); 23141da177e4SLinus Torvalds psg->sg[i].count = cpu_to_le32(sg_dma_len(sg)); 23151da177e4SLinus Torvalds byte_count += sg_dma_len(sg); 23161da177e4SLinus Torvalds sg++; 23171da177e4SLinus Torvalds } 23181da177e4SLinus Torvalds /* hba wants the size to be exact */ 23191da177e4SLinus Torvalds if(byte_count > scsicmd->request_bufflen){ 232056b58712SMark Haverkamp u32 temp = le32_to_cpu(psg->sg[i-1].count) - 232156b58712SMark Haverkamp (byte_count - scsicmd->request_bufflen); 232256b58712SMark Haverkamp psg->sg[i-1].count = cpu_to_le32(temp); 23231da177e4SLinus Torvalds byte_count = scsicmd->request_bufflen; 23241da177e4SLinus Torvalds } 23251da177e4SLinus Torvalds /* Check for command underflow */ 23261da177e4SLinus Torvalds if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 23271da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 23281da177e4SLinus Torvalds byte_count, scsicmd->underflow); 23291da177e4SLinus Torvalds } 23301da177e4SLinus Torvalds } 23311da177e4SLinus Torvalds else if(scsicmd->request_bufflen) { 23323c1e0ccaSMark Haverkamp u32 addr; 23333c1e0ccaSMark Haverkamp scsicmd->SCp.dma_handle = pci_map_single(dev->pdev, 23341da177e4SLinus Torvalds scsicmd->request_buffer, 23351da177e4SLinus Torvalds scsicmd->request_bufflen, 23361da177e4SLinus Torvalds scsicmd->sc_data_direction); 23373c1e0ccaSMark Haverkamp addr = scsicmd->SCp.dma_handle; 23381da177e4SLinus Torvalds psg->count = cpu_to_le32(1); 23391da177e4SLinus Torvalds psg->sg[0].addr = cpu_to_le32(addr); 23401da177e4SLinus Torvalds psg->sg[0].count = cpu_to_le32(scsicmd->request_bufflen); 23411da177e4SLinus Torvalds byte_count = scsicmd->request_bufflen; 23421da177e4SLinus Torvalds } 23431da177e4SLinus Torvalds return byte_count; 23441da177e4SLinus Torvalds } 23451da177e4SLinus Torvalds 23461da177e4SLinus Torvalds 23471da177e4SLinus Torvalds static unsigned long aac_build_sg64(struct scsi_cmnd* scsicmd, struct sgmap64* psg) 23481da177e4SLinus Torvalds { 23491da177e4SLinus Torvalds struct aac_dev *dev; 23501da177e4SLinus Torvalds unsigned long byte_count = 0; 235156b58712SMark Haverkamp u64 addr; 23521da177e4SLinus Torvalds 23531da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 23541da177e4SLinus Torvalds // Get rid of old data 23551da177e4SLinus Torvalds psg->count = 0; 23561da177e4SLinus Torvalds psg->sg[0].addr[0] = 0; 23571da177e4SLinus Torvalds psg->sg[0].addr[1] = 0; 23581da177e4SLinus Torvalds psg->sg[0].count = 0; 23591da177e4SLinus Torvalds if (scsicmd->use_sg) { 23601da177e4SLinus Torvalds struct scatterlist *sg; 23611da177e4SLinus Torvalds int i; 23621da177e4SLinus Torvalds int sg_count; 23631da177e4SLinus Torvalds sg = (struct scatterlist *) scsicmd->request_buffer; 23641da177e4SLinus Torvalds 23651da177e4SLinus Torvalds sg_count = pci_map_sg(dev->pdev, sg, scsicmd->use_sg, 23661da177e4SLinus Torvalds scsicmd->sc_data_direction); 23671da177e4SLinus Torvalds 23681da177e4SLinus Torvalds for (i = 0; i < sg_count; i++) { 23691241f359SMark Haverkamp int count = sg_dma_len(sg); 237056b58712SMark Haverkamp addr = sg_dma_address(sg); 237156b58712SMark Haverkamp psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff); 237256b58712SMark Haverkamp psg->sg[i].addr[1] = cpu_to_le32(addr>>32); 23731241f359SMark Haverkamp psg->sg[i].count = cpu_to_le32(count); 23741241f359SMark Haverkamp byte_count += count; 23751da177e4SLinus Torvalds sg++; 23761da177e4SLinus Torvalds } 23771241f359SMark Haverkamp psg->count = cpu_to_le32(sg_count); 23781da177e4SLinus Torvalds /* hba wants the size to be exact */ 23791da177e4SLinus Torvalds if(byte_count > scsicmd->request_bufflen){ 238056b58712SMark Haverkamp u32 temp = le32_to_cpu(psg->sg[i-1].count) - 238156b58712SMark Haverkamp (byte_count - scsicmd->request_bufflen); 238256b58712SMark Haverkamp psg->sg[i-1].count = cpu_to_le32(temp); 23831da177e4SLinus Torvalds byte_count = scsicmd->request_bufflen; 23841da177e4SLinus Torvalds } 23851da177e4SLinus Torvalds /* Check for command underflow */ 23861da177e4SLinus Torvalds if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 23871da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 23881da177e4SLinus Torvalds byte_count, scsicmd->underflow); 23891da177e4SLinus Torvalds } 23901da177e4SLinus Torvalds } 23911da177e4SLinus Torvalds else if(scsicmd->request_bufflen) { 23921241f359SMark Haverkamp scsicmd->SCp.dma_handle = pci_map_single(dev->pdev, 23931da177e4SLinus Torvalds scsicmd->request_buffer, 23941da177e4SLinus Torvalds scsicmd->request_bufflen, 23951da177e4SLinus Torvalds scsicmd->sc_data_direction); 23961241f359SMark Haverkamp addr = scsicmd->SCp.dma_handle; 23971da177e4SLinus Torvalds psg->count = cpu_to_le32(1); 239856b58712SMark Haverkamp psg->sg[0].addr[0] = cpu_to_le32(addr & 0xffffffff); 239956b58712SMark Haverkamp psg->sg[0].addr[1] = cpu_to_le32(addr >> 32); 24001da177e4SLinus Torvalds psg->sg[0].count = cpu_to_le32(scsicmd->request_bufflen); 24011da177e4SLinus Torvalds byte_count = scsicmd->request_bufflen; 24021da177e4SLinus Torvalds } 24031da177e4SLinus Torvalds return byte_count; 24041da177e4SLinus Torvalds } 24051da177e4SLinus Torvalds 24060e68c003SMark Haverkamp static unsigned long aac_build_sgraw(struct scsi_cmnd* scsicmd, struct sgmapraw* psg) 24070e68c003SMark Haverkamp { 24080e68c003SMark Haverkamp struct Scsi_Host *host = scsicmd->device->host; 24090e68c003SMark Haverkamp struct aac_dev *dev = (struct aac_dev *)host->hostdata; 24100e68c003SMark Haverkamp unsigned long byte_count = 0; 24110e68c003SMark Haverkamp 24120e68c003SMark Haverkamp // Get rid of old data 24130e68c003SMark Haverkamp psg->count = 0; 24140e68c003SMark Haverkamp psg->sg[0].next = 0; 24150e68c003SMark Haverkamp psg->sg[0].prev = 0; 24160e68c003SMark Haverkamp psg->sg[0].addr[0] = 0; 24170e68c003SMark Haverkamp psg->sg[0].addr[1] = 0; 24180e68c003SMark Haverkamp psg->sg[0].count = 0; 24190e68c003SMark Haverkamp psg->sg[0].flags = 0; 24200e68c003SMark Haverkamp if (scsicmd->use_sg) { 24210e68c003SMark Haverkamp struct scatterlist *sg; 24220e68c003SMark Haverkamp int i; 24230e68c003SMark Haverkamp int sg_count; 24240e68c003SMark Haverkamp sg = (struct scatterlist *) scsicmd->request_buffer; 24250e68c003SMark Haverkamp 24260e68c003SMark Haverkamp sg_count = pci_map_sg(dev->pdev, sg, scsicmd->use_sg, 24270e68c003SMark Haverkamp scsicmd->sc_data_direction); 24280e68c003SMark Haverkamp 24290e68c003SMark Haverkamp for (i = 0; i < sg_count; i++) { 24300e68c003SMark Haverkamp int count = sg_dma_len(sg); 24310e68c003SMark Haverkamp u64 addr = sg_dma_address(sg); 24320e68c003SMark Haverkamp psg->sg[i].next = 0; 24330e68c003SMark Haverkamp psg->sg[i].prev = 0; 24340e68c003SMark Haverkamp psg->sg[i].addr[1] = cpu_to_le32((u32)(addr>>32)); 24350e68c003SMark Haverkamp psg->sg[i].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff)); 24360e68c003SMark Haverkamp psg->sg[i].count = cpu_to_le32(count); 24370e68c003SMark Haverkamp psg->sg[i].flags = 0; 24380e68c003SMark Haverkamp byte_count += count; 24390e68c003SMark Haverkamp sg++; 24400e68c003SMark Haverkamp } 24410e68c003SMark Haverkamp psg->count = cpu_to_le32(sg_count); 24420e68c003SMark Haverkamp /* hba wants the size to be exact */ 24430e68c003SMark Haverkamp if(byte_count > scsicmd->request_bufflen){ 24440e68c003SMark Haverkamp u32 temp = le32_to_cpu(psg->sg[i-1].count) - 24450e68c003SMark Haverkamp (byte_count - scsicmd->request_bufflen); 24460e68c003SMark Haverkamp psg->sg[i-1].count = cpu_to_le32(temp); 24470e68c003SMark Haverkamp byte_count = scsicmd->request_bufflen; 24480e68c003SMark Haverkamp } 24490e68c003SMark Haverkamp /* Check for command underflow */ 24500e68c003SMark Haverkamp if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 24510e68c003SMark Haverkamp printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 24520e68c003SMark Haverkamp byte_count, scsicmd->underflow); 24530e68c003SMark Haverkamp } 24540e68c003SMark Haverkamp } 24550e68c003SMark Haverkamp else if(scsicmd->request_bufflen) { 24560e68c003SMark Haverkamp int count; 24570e68c003SMark Haverkamp u64 addr; 24580e68c003SMark Haverkamp scsicmd->SCp.dma_handle = pci_map_single(dev->pdev, 24590e68c003SMark Haverkamp scsicmd->request_buffer, 24600e68c003SMark Haverkamp scsicmd->request_bufflen, 24610e68c003SMark Haverkamp scsicmd->sc_data_direction); 24620e68c003SMark Haverkamp addr = scsicmd->SCp.dma_handle; 24630e68c003SMark Haverkamp count = scsicmd->request_bufflen; 24640e68c003SMark Haverkamp psg->count = cpu_to_le32(1); 24650e68c003SMark Haverkamp psg->sg[0].next = 0; 24660e68c003SMark Haverkamp psg->sg[0].prev = 0; 24670e68c003SMark Haverkamp psg->sg[0].addr[1] = cpu_to_le32((u32)(addr>>32)); 24680e68c003SMark Haverkamp psg->sg[0].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff)); 24690e68c003SMark Haverkamp psg->sg[0].count = cpu_to_le32(count); 24700e68c003SMark Haverkamp psg->sg[0].flags = 0; 24710e68c003SMark Haverkamp byte_count = scsicmd->request_bufflen; 24720e68c003SMark Haverkamp } 24730e68c003SMark Haverkamp return byte_count; 24740e68c003SMark Haverkamp } 24750e68c003SMark Haverkamp 24761da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 24771da177e4SLinus Torvalds 24781da177e4SLinus Torvalds struct aac_srb_status_info { 24791da177e4SLinus Torvalds u32 status; 24801da177e4SLinus Torvalds char *str; 24811da177e4SLinus Torvalds }; 24821da177e4SLinus Torvalds 24831da177e4SLinus Torvalds 24841da177e4SLinus Torvalds static struct aac_srb_status_info srb_status_info[] = { 24851da177e4SLinus Torvalds { SRB_STATUS_PENDING, "Pending Status"}, 24861da177e4SLinus Torvalds { SRB_STATUS_SUCCESS, "Success"}, 24871da177e4SLinus Torvalds { SRB_STATUS_ABORTED, "Aborted Command"}, 24881da177e4SLinus Torvalds { SRB_STATUS_ABORT_FAILED, "Abort Failed"}, 24891da177e4SLinus Torvalds { SRB_STATUS_ERROR, "Error Event"}, 24901da177e4SLinus Torvalds { SRB_STATUS_BUSY, "Device Busy"}, 24911da177e4SLinus Torvalds { SRB_STATUS_INVALID_REQUEST, "Invalid Request"}, 24921da177e4SLinus Torvalds { SRB_STATUS_INVALID_PATH_ID, "Invalid Path ID"}, 24931da177e4SLinus Torvalds { SRB_STATUS_NO_DEVICE, "No Device"}, 24941da177e4SLinus Torvalds { SRB_STATUS_TIMEOUT, "Timeout"}, 24951da177e4SLinus Torvalds { SRB_STATUS_SELECTION_TIMEOUT, "Selection Timeout"}, 24961da177e4SLinus Torvalds { SRB_STATUS_COMMAND_TIMEOUT, "Command Timeout"}, 24971da177e4SLinus Torvalds { SRB_STATUS_MESSAGE_REJECTED, "Message Rejected"}, 24981da177e4SLinus Torvalds { SRB_STATUS_BUS_RESET, "Bus Reset"}, 24991da177e4SLinus Torvalds { SRB_STATUS_PARITY_ERROR, "Parity Error"}, 25001da177e4SLinus Torvalds { SRB_STATUS_REQUEST_SENSE_FAILED,"Request Sense Failed"}, 25011da177e4SLinus Torvalds { SRB_STATUS_NO_HBA, "No HBA"}, 25021da177e4SLinus Torvalds { SRB_STATUS_DATA_OVERRUN, "Data Overrun/Data Underrun"}, 25031da177e4SLinus Torvalds { SRB_STATUS_UNEXPECTED_BUS_FREE,"Unexpected Bus Free"}, 25041da177e4SLinus Torvalds { SRB_STATUS_PHASE_SEQUENCE_FAILURE,"Phase Error"}, 25051da177e4SLinus Torvalds { SRB_STATUS_BAD_SRB_BLOCK_LENGTH,"Bad Srb Block Length"}, 25061da177e4SLinus Torvalds { SRB_STATUS_REQUEST_FLUSHED, "Request Flushed"}, 25071da177e4SLinus Torvalds { SRB_STATUS_DELAYED_RETRY, "Delayed Retry"}, 25081da177e4SLinus Torvalds { SRB_STATUS_INVALID_LUN, "Invalid LUN"}, 25091da177e4SLinus Torvalds { SRB_STATUS_INVALID_TARGET_ID, "Invalid TARGET ID"}, 25101da177e4SLinus Torvalds { SRB_STATUS_BAD_FUNCTION, "Bad Function"}, 25111da177e4SLinus Torvalds { SRB_STATUS_ERROR_RECOVERY, "Error Recovery"}, 25121da177e4SLinus Torvalds { SRB_STATUS_NOT_STARTED, "Not Started"}, 25131da177e4SLinus Torvalds { SRB_STATUS_NOT_IN_USE, "Not In Use"}, 25141da177e4SLinus Torvalds { SRB_STATUS_FORCE_ABORT, "Force Abort"}, 25151da177e4SLinus Torvalds { SRB_STATUS_DOMAIN_VALIDATION_FAIL,"Domain Validation Failure"}, 25161da177e4SLinus Torvalds { 0xff, "Unknown Error"} 25171da177e4SLinus Torvalds }; 25181da177e4SLinus Torvalds 25191da177e4SLinus Torvalds char *aac_get_status_string(u32 status) 25201da177e4SLinus Torvalds { 25211da177e4SLinus Torvalds int i; 25221da177e4SLinus Torvalds 25236391a113STobias Klauser for (i = 0; i < ARRAY_SIZE(srb_status_info); i++) 25246391a113STobias Klauser if (srb_status_info[i].status == status) 25251da177e4SLinus Torvalds return srb_status_info[i].str; 25261da177e4SLinus Torvalds 25271da177e4SLinus Torvalds return "Bad Status Code"; 25281da177e4SLinus Torvalds } 25291da177e4SLinus Torvalds 25301da177e4SLinus Torvalds #endif 2531