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/sched.h> 301da177e4SLinus Torvalds #include <linux/pci.h> 311da177e4SLinus Torvalds #include <linux/spinlock.h> 321da177e4SLinus Torvalds #include <linux/slab.h> 331da177e4SLinus Torvalds #include <linux/completion.h> 341da177e4SLinus Torvalds #include <linux/blkdev.h> 35910638aeSMatthias Gehre #include <linux/dma-mapping.h> 361da177e4SLinus Torvalds #include <asm/semaphore.h> 371da177e4SLinus Torvalds #include <asm/uaccess.h> 381da177e4SLinus Torvalds 391da177e4SLinus Torvalds #include <scsi/scsi.h> 401da177e4SLinus Torvalds #include <scsi/scsi_cmnd.h> 411da177e4SLinus Torvalds #include <scsi/scsi_device.h> 421da177e4SLinus Torvalds #include <scsi/scsi_host.h> 431da177e4SLinus Torvalds 441da177e4SLinus Torvalds #include "aacraid.h" 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds /* values for inqd_pdt: Peripheral device type in plain English */ 471da177e4SLinus Torvalds #define INQD_PDT_DA 0x00 /* Direct-access (DISK) device */ 481da177e4SLinus Torvalds #define INQD_PDT_PROC 0x03 /* Processor device */ 491da177e4SLinus Torvalds #define INQD_PDT_CHNGR 0x08 /* Changer (jukebox, scsi2) */ 501da177e4SLinus Torvalds #define INQD_PDT_COMM 0x09 /* Communication device (scsi2) */ 511da177e4SLinus Torvalds #define INQD_PDT_NOLUN2 0x1f /* Unknown Device (scsi2) */ 521da177e4SLinus Torvalds #define INQD_PDT_NOLUN 0x7f /* Logical Unit Not Present */ 531da177e4SLinus Torvalds 541da177e4SLinus Torvalds #define INQD_PDT_DMASK 0x1F /* Peripheral Device Type Mask */ 551da177e4SLinus Torvalds #define INQD_PDT_QMASK 0xE0 /* Peripheral Device Qualifer Mask */ 561da177e4SLinus Torvalds 571da177e4SLinus Torvalds /* 581da177e4SLinus Torvalds * Sense codes 591da177e4SLinus Torvalds */ 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds #define SENCODE_NO_SENSE 0x00 621da177e4SLinus Torvalds #define SENCODE_END_OF_DATA 0x00 631da177e4SLinus Torvalds #define SENCODE_BECOMING_READY 0x04 641da177e4SLinus Torvalds #define SENCODE_INIT_CMD_REQUIRED 0x04 651da177e4SLinus Torvalds #define SENCODE_PARAM_LIST_LENGTH_ERROR 0x1A 661da177e4SLinus Torvalds #define SENCODE_INVALID_COMMAND 0x20 671da177e4SLinus Torvalds #define SENCODE_LBA_OUT_OF_RANGE 0x21 681da177e4SLinus Torvalds #define SENCODE_INVALID_CDB_FIELD 0x24 691da177e4SLinus Torvalds #define SENCODE_LUN_NOT_SUPPORTED 0x25 701da177e4SLinus Torvalds #define SENCODE_INVALID_PARAM_FIELD 0x26 711da177e4SLinus Torvalds #define SENCODE_PARAM_NOT_SUPPORTED 0x26 721da177e4SLinus Torvalds #define SENCODE_PARAM_VALUE_INVALID 0x26 731da177e4SLinus Torvalds #define SENCODE_RESET_OCCURRED 0x29 741da177e4SLinus Torvalds #define SENCODE_LUN_NOT_SELF_CONFIGURED_YET 0x3E 751da177e4SLinus Torvalds #define SENCODE_INQUIRY_DATA_CHANGED 0x3F 761da177e4SLinus Torvalds #define SENCODE_SAVING_PARAMS_NOT_SUPPORTED 0x39 771da177e4SLinus Torvalds #define SENCODE_DIAGNOSTIC_FAILURE 0x40 781da177e4SLinus Torvalds #define SENCODE_INTERNAL_TARGET_FAILURE 0x44 791da177e4SLinus Torvalds #define SENCODE_INVALID_MESSAGE_ERROR 0x49 801da177e4SLinus Torvalds #define SENCODE_LUN_FAILED_SELF_CONFIG 0x4c 811da177e4SLinus Torvalds #define SENCODE_OVERLAPPED_COMMAND 0x4E 821da177e4SLinus Torvalds 831da177e4SLinus Torvalds /* 841da177e4SLinus Torvalds * Additional sense codes 851da177e4SLinus Torvalds */ 861da177e4SLinus Torvalds 871da177e4SLinus Torvalds #define ASENCODE_NO_SENSE 0x00 881da177e4SLinus Torvalds #define ASENCODE_END_OF_DATA 0x05 891da177e4SLinus Torvalds #define ASENCODE_BECOMING_READY 0x01 901da177e4SLinus Torvalds #define ASENCODE_INIT_CMD_REQUIRED 0x02 911da177e4SLinus Torvalds #define ASENCODE_PARAM_LIST_LENGTH_ERROR 0x00 921da177e4SLinus Torvalds #define ASENCODE_INVALID_COMMAND 0x00 931da177e4SLinus Torvalds #define ASENCODE_LBA_OUT_OF_RANGE 0x00 941da177e4SLinus Torvalds #define ASENCODE_INVALID_CDB_FIELD 0x00 951da177e4SLinus Torvalds #define ASENCODE_LUN_NOT_SUPPORTED 0x00 961da177e4SLinus Torvalds #define ASENCODE_INVALID_PARAM_FIELD 0x00 971da177e4SLinus Torvalds #define ASENCODE_PARAM_NOT_SUPPORTED 0x01 981da177e4SLinus Torvalds #define ASENCODE_PARAM_VALUE_INVALID 0x02 991da177e4SLinus Torvalds #define ASENCODE_RESET_OCCURRED 0x00 1001da177e4SLinus Torvalds #define ASENCODE_LUN_NOT_SELF_CONFIGURED_YET 0x00 1011da177e4SLinus Torvalds #define ASENCODE_INQUIRY_DATA_CHANGED 0x03 1021da177e4SLinus Torvalds #define ASENCODE_SAVING_PARAMS_NOT_SUPPORTED 0x00 1031da177e4SLinus Torvalds #define ASENCODE_DIAGNOSTIC_FAILURE 0x80 1041da177e4SLinus Torvalds #define ASENCODE_INTERNAL_TARGET_FAILURE 0x00 1051da177e4SLinus Torvalds #define ASENCODE_INVALID_MESSAGE_ERROR 0x00 1061da177e4SLinus Torvalds #define ASENCODE_LUN_FAILED_SELF_CONFIG 0x00 1071da177e4SLinus Torvalds #define ASENCODE_OVERLAPPED_COMMAND 0x00 1081da177e4SLinus Torvalds 1091da177e4SLinus Torvalds #define BYTE0(x) (unsigned char)(x) 1101da177e4SLinus Torvalds #define BYTE1(x) (unsigned char)((x) >> 8) 1111da177e4SLinus Torvalds #define BYTE2(x) (unsigned char)((x) >> 16) 1121da177e4SLinus Torvalds #define BYTE3(x) (unsigned char)((x) >> 24) 1131da177e4SLinus Torvalds 1141da177e4SLinus Torvalds /*------------------------------------------------------------------------------ 1151da177e4SLinus Torvalds * S T R U C T S / T Y P E D E F S 1161da177e4SLinus Torvalds *----------------------------------------------------------------------------*/ 1171da177e4SLinus Torvalds /* SCSI inquiry data */ 1181da177e4SLinus Torvalds struct inquiry_data { 1191da177e4SLinus Torvalds u8 inqd_pdt; /* Peripheral qualifier | Peripheral Device Type */ 1201da177e4SLinus Torvalds u8 inqd_dtq; /* RMB | Device Type Qualifier */ 1211da177e4SLinus Torvalds u8 inqd_ver; /* ISO version | ECMA version | ANSI-approved version */ 1221da177e4SLinus Torvalds u8 inqd_rdf; /* AENC | TrmIOP | Response data format */ 1231da177e4SLinus Torvalds u8 inqd_len; /* Additional length (n-4) */ 1241da177e4SLinus Torvalds u8 inqd_pad1[2];/* Reserved - must be zero */ 1251da177e4SLinus Torvalds u8 inqd_pad2; /* RelAdr | WBus32 | WBus16 | Sync | Linked |Reserved| CmdQue | SftRe */ 1261da177e4SLinus Torvalds u8 inqd_vid[8]; /* Vendor ID */ 1271da177e4SLinus Torvalds u8 inqd_pid[16];/* Product ID */ 1281da177e4SLinus Torvalds u8 inqd_prl[4]; /* Product Revision Level */ 1291da177e4SLinus Torvalds }; 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds /* 1321da177e4SLinus Torvalds * M O D U L E G L O B A L S 1331da177e4SLinus Torvalds */ 1341da177e4SLinus Torvalds 1351da177e4SLinus Torvalds static unsigned long aac_build_sg(struct scsi_cmnd* scsicmd, struct sgmap* sgmap); 1361da177e4SLinus Torvalds static unsigned long aac_build_sg64(struct scsi_cmnd* scsicmd, struct sgmap64* psg); 1370e68c003SMark Haverkamp static unsigned long aac_build_sgraw(struct scsi_cmnd* scsicmd, struct sgmapraw* psg); 1381da177e4SLinus Torvalds static int aac_send_srb_fib(struct scsi_cmnd* scsicmd); 1391da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 1401da177e4SLinus Torvalds static char *aac_get_status_string(u32 status); 1411da177e4SLinus Torvalds #endif 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds /* 1441da177e4SLinus Torvalds * Non dasd selection is handled entirely in aachba now 1451da177e4SLinus Torvalds */ 1461da177e4SLinus Torvalds 1471da177e4SLinus Torvalds static int nondasd = -1; 1481da177e4SLinus Torvalds static int dacmode = -1; 1491da177e4SLinus Torvalds 1501da177e4SLinus Torvalds static int commit = -1; 151404d9a90SMark Haverkamp int startup_timeout = 180; 152404d9a90SMark Haverkamp int aif_timeout = 120; 1531da177e4SLinus Torvalds 1549a72f976SMark Haverkamp module_param(nondasd, int, S_IRUGO|S_IWUSR); 1551da177e4SLinus Torvalds MODULE_PARM_DESC(nondasd, "Control scanning of hba for nondasd devices. 0=off, 1=on"); 1569a72f976SMark Haverkamp module_param(dacmode, int, S_IRUGO|S_IWUSR); 1571da177e4SLinus Torvalds MODULE_PARM_DESC(dacmode, "Control whether dma addressing is using 64 bit DAC. 0=off, 1=on"); 1589a72f976SMark Haverkamp module_param(commit, int, S_IRUGO|S_IWUSR); 1591da177e4SLinus 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"); 160404d9a90SMark Haverkamp module_param(startup_timeout, int, S_IRUGO|S_IWUSR); 161404d9a90SMark 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."); 162404d9a90SMark Haverkamp module_param(aif_timeout, int, S_IRUGO|S_IWUSR); 163404d9a90SMark 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."); 1641da177e4SLinus Torvalds 1657c00ffa3SMark Haverkamp int numacb = -1; 1667c00ffa3SMark Haverkamp module_param(numacb, int, S_IRUGO|S_IWUSR); 1679a72f976SMark 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."); 1687c00ffa3SMark Haverkamp 1697c00ffa3SMark Haverkamp int acbsize = -1; 1707c00ffa3SMark Haverkamp module_param(acbsize, int, S_IRUGO|S_IWUSR); 1719a72f976SMark 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."); 172653ba58dSMark Haverkamp 173e37ee4beSMark Haverkamp int expose_physicals = -1; 174653ba58dSMark Haverkamp module_param(expose_physicals, int, S_IRUGO|S_IWUSR); 175e37ee4beSMark Haverkamp MODULE_PARM_DESC(expose_physicals, "Expose physical components of the arrays. -1=protect 0=off, 1=on"); 1761da177e4SLinus Torvalds /** 1771da177e4SLinus Torvalds * aac_get_config_status - check the adapter configuration 1781da177e4SLinus Torvalds * @common: adapter to query 1791da177e4SLinus Torvalds * 1801da177e4SLinus Torvalds * Query config status, and commit the configuration if needed. 1811da177e4SLinus Torvalds */ 1828c867b25SMark Haverkamp int aac_get_config_status(struct aac_dev *dev, int commit_flag) 1831da177e4SLinus Torvalds { 1841da177e4SLinus Torvalds int status = 0; 1851da177e4SLinus Torvalds struct fib * fibptr; 1861da177e4SLinus Torvalds 187bfb35aa8SMark Haverkamp if (!(fibptr = aac_fib_alloc(dev))) 1881da177e4SLinus Torvalds return -ENOMEM; 1891da177e4SLinus Torvalds 190bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 1911da177e4SLinus Torvalds { 1921da177e4SLinus Torvalds struct aac_get_config_status *dinfo; 1931da177e4SLinus Torvalds dinfo = (struct aac_get_config_status *) fib_data(fibptr); 1941da177e4SLinus Torvalds 1951da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 1961da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_GET_CONFIG_STATUS); 1971da177e4SLinus Torvalds dinfo->count = cpu_to_le32(sizeof(((struct aac_get_config_status_resp *)NULL)->data)); 1981da177e4SLinus Torvalds } 1991da177e4SLinus Torvalds 200bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 2011da177e4SLinus Torvalds fibptr, 2021da177e4SLinus Torvalds sizeof (struct aac_get_config_status), 2031da177e4SLinus Torvalds FsaNormal, 2041da177e4SLinus Torvalds 1, 1, 2051da177e4SLinus Torvalds NULL, NULL); 2061da177e4SLinus Torvalds if (status < 0 ) { 2071da177e4SLinus Torvalds printk(KERN_WARNING "aac_get_config_status: SendFIB failed.\n"); 2081da177e4SLinus Torvalds } else { 2091da177e4SLinus Torvalds struct aac_get_config_status_resp *reply 2101da177e4SLinus Torvalds = (struct aac_get_config_status_resp *) fib_data(fibptr); 2111da177e4SLinus Torvalds dprintk((KERN_WARNING 2121da177e4SLinus Torvalds "aac_get_config_status: response=%d status=%d action=%d\n", 2131da177e4SLinus Torvalds le32_to_cpu(reply->response), 2141da177e4SLinus Torvalds le32_to_cpu(reply->status), 2151da177e4SLinus Torvalds le32_to_cpu(reply->data.action))); 2161da177e4SLinus Torvalds if ((le32_to_cpu(reply->response) != ST_OK) || 2171da177e4SLinus Torvalds (le32_to_cpu(reply->status) != CT_OK) || 2181da177e4SLinus Torvalds (le32_to_cpu(reply->data.action) > CFACT_PAUSE)) { 2191da177e4SLinus Torvalds printk(KERN_WARNING "aac_get_config_status: Will not issue the Commit Configuration\n"); 2201da177e4SLinus Torvalds status = -EINVAL; 2211da177e4SLinus Torvalds } 2221da177e4SLinus Torvalds } 223bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 2241da177e4SLinus Torvalds /* Send a CT_COMMIT_CONFIG to enable discovery of devices */ 2251da177e4SLinus Torvalds if (status >= 0) { 2268c867b25SMark Haverkamp if ((commit == 1) || commit_flag) { 2271da177e4SLinus Torvalds struct aac_commit_config * dinfo; 228bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 2291da177e4SLinus Torvalds dinfo = (struct aac_commit_config *) fib_data(fibptr); 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 2321da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_COMMIT_CONFIG); 2331da177e4SLinus Torvalds 234bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 2351da177e4SLinus Torvalds fibptr, 2361da177e4SLinus Torvalds sizeof (struct aac_commit_config), 2371da177e4SLinus Torvalds FsaNormal, 2381da177e4SLinus Torvalds 1, 1, 2391da177e4SLinus Torvalds NULL, NULL); 240bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 2411da177e4SLinus Torvalds } else if (commit == 0) { 2421da177e4SLinus Torvalds printk(KERN_WARNING 2431da177e4SLinus Torvalds "aac_get_config_status: Foreign device configurations are being ignored\n"); 2441da177e4SLinus Torvalds } 2451da177e4SLinus Torvalds } 246bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 2471da177e4SLinus Torvalds return status; 2481da177e4SLinus Torvalds } 2491da177e4SLinus Torvalds 2501da177e4SLinus Torvalds /** 2511da177e4SLinus Torvalds * aac_get_containers - list containers 2521da177e4SLinus Torvalds * @common: adapter to probe 2531da177e4SLinus Torvalds * 2541da177e4SLinus Torvalds * Make a list of all containers on this controller 2551da177e4SLinus Torvalds */ 2561da177e4SLinus Torvalds int aac_get_containers(struct aac_dev *dev) 2571da177e4SLinus Torvalds { 2581da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 2591da177e4SLinus Torvalds u32 index; 2601da177e4SLinus Torvalds int status = 0; 2611da177e4SLinus Torvalds struct fib * fibptr; 2621da177e4SLinus Torvalds unsigned instance; 2631da177e4SLinus Torvalds struct aac_get_container_count *dinfo; 2641da177e4SLinus Torvalds struct aac_get_container_count_resp *dresp; 2651da177e4SLinus Torvalds int maximum_num_containers = MAXIMUM_NUM_CONTAINERS; 2661da177e4SLinus Torvalds 2671da177e4SLinus Torvalds instance = dev->scsi_host_ptr->unique_id; 2681da177e4SLinus Torvalds 269bfb35aa8SMark Haverkamp if (!(fibptr = aac_fib_alloc(dev))) 2701da177e4SLinus Torvalds return -ENOMEM; 2711da177e4SLinus Torvalds 272bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 2731da177e4SLinus Torvalds dinfo = (struct aac_get_container_count *) fib_data(fibptr); 2741da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 2751da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_GET_CONTAINER_COUNT); 2761da177e4SLinus Torvalds 277bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 2781da177e4SLinus Torvalds fibptr, 2791da177e4SLinus Torvalds sizeof (struct aac_get_container_count), 2801da177e4SLinus Torvalds FsaNormal, 2811da177e4SLinus Torvalds 1, 1, 2821da177e4SLinus Torvalds NULL, NULL); 2831da177e4SLinus Torvalds if (status >= 0) { 2841da177e4SLinus Torvalds dresp = (struct aac_get_container_count_resp *)fib_data(fibptr); 2851da177e4SLinus Torvalds maximum_num_containers = le32_to_cpu(dresp->ContainerSwitchEntries); 286bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 2871da177e4SLinus Torvalds } 2881da177e4SLinus Torvalds 2891da177e4SLinus Torvalds if (maximum_num_containers < MAXIMUM_NUM_CONTAINERS) 2901da177e4SLinus Torvalds maximum_num_containers = MAXIMUM_NUM_CONTAINERS; 2915cbded58SRobert P. J. Day fsa_dev_ptr = kmalloc( 2921da177e4SLinus Torvalds sizeof(*fsa_dev_ptr) * maximum_num_containers, GFP_KERNEL); 2931da177e4SLinus Torvalds if (!fsa_dev_ptr) { 294bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 2951da177e4SLinus Torvalds return -ENOMEM; 2961da177e4SLinus Torvalds } 2971da177e4SLinus Torvalds memset(fsa_dev_ptr, 0, sizeof(*fsa_dev_ptr) * maximum_num_containers); 2981da177e4SLinus Torvalds 2991da177e4SLinus Torvalds dev->fsa_dev = fsa_dev_ptr; 3001da177e4SLinus Torvalds dev->maximum_num_containers = maximum_num_containers; 3011da177e4SLinus Torvalds 3021da177e4SLinus Torvalds for (index = 0; index < dev->maximum_num_containers; index++) { 3031da177e4SLinus Torvalds struct aac_query_mount *dinfo; 3041da177e4SLinus Torvalds struct aac_mount *dresp; 3051da177e4SLinus Torvalds 3061da177e4SLinus Torvalds fsa_dev_ptr[index].devname[0] = '\0'; 3071da177e4SLinus Torvalds 308bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 3091da177e4SLinus Torvalds dinfo = (struct aac_query_mount *) fib_data(fibptr); 3101da177e4SLinus Torvalds 3111da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_NameServe); 3121da177e4SLinus Torvalds dinfo->count = cpu_to_le32(index); 3131da177e4SLinus Torvalds dinfo->type = cpu_to_le32(FT_FILESYS); 3141da177e4SLinus Torvalds 315bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 3161da177e4SLinus Torvalds fibptr, 3171da177e4SLinus Torvalds sizeof (struct aac_query_mount), 3181da177e4SLinus Torvalds FsaNormal, 3191da177e4SLinus Torvalds 1, 1, 3201da177e4SLinus Torvalds NULL, NULL); 3211da177e4SLinus Torvalds if (status < 0 ) { 3221da177e4SLinus Torvalds printk(KERN_WARNING "aac_get_containers: SendFIB failed.\n"); 3231da177e4SLinus Torvalds break; 3241da177e4SLinus Torvalds } 3251da177e4SLinus Torvalds dresp = (struct aac_mount *)fib_data(fibptr); 3261da177e4SLinus Torvalds 3277a8cf29dSMark Haverkamp if ((le32_to_cpu(dresp->status) == ST_OK) && 3287a8cf29dSMark Haverkamp (le32_to_cpu(dresp->mnt[0].vol) == CT_NONE)) { 3297a8cf29dSMark Haverkamp dinfo->command = cpu_to_le32(VM_NameServe64); 3307a8cf29dSMark Haverkamp dinfo->count = cpu_to_le32(index); 3317a8cf29dSMark Haverkamp dinfo->type = cpu_to_le32(FT_FILESYS); 3327a8cf29dSMark Haverkamp 333bfb35aa8SMark Haverkamp if (aac_fib_send(ContainerCommand, 3347a8cf29dSMark Haverkamp fibptr, 3357a8cf29dSMark Haverkamp sizeof(struct aac_query_mount), 3367a8cf29dSMark Haverkamp FsaNormal, 3377a8cf29dSMark Haverkamp 1, 1, 3387a8cf29dSMark Haverkamp NULL, NULL) < 0) 3397a8cf29dSMark Haverkamp continue; 3407a8cf29dSMark Haverkamp } else 3417a8cf29dSMark Haverkamp dresp->mnt[0].capacityhigh = 0; 3427a8cf29dSMark Haverkamp 3431da177e4SLinus Torvalds dprintk ((KERN_DEBUG 3447a8cf29dSMark Haverkamp "VM_NameServe cid=%d status=%d vol=%d state=%d cap=%llu\n", 3451da177e4SLinus Torvalds (int)index, (int)le32_to_cpu(dresp->status), 3461da177e4SLinus Torvalds (int)le32_to_cpu(dresp->mnt[0].vol), 3471da177e4SLinus Torvalds (int)le32_to_cpu(dresp->mnt[0].state), 3487a8cf29dSMark Haverkamp ((u64)le32_to_cpu(dresp->mnt[0].capacity)) + 3497a8cf29dSMark Haverkamp (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32))); 3501da177e4SLinus Torvalds if ((le32_to_cpu(dresp->status) == ST_OK) && 3511da177e4SLinus Torvalds (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE) && 3521da177e4SLinus Torvalds (le32_to_cpu(dresp->mnt[0].state) != FSCS_HIDDEN)) { 3531da177e4SLinus Torvalds fsa_dev_ptr[index].valid = 1; 3541da177e4SLinus Torvalds fsa_dev_ptr[index].type = le32_to_cpu(dresp->mnt[0].vol); 3557a8cf29dSMark Haverkamp fsa_dev_ptr[index].size 3567a8cf29dSMark Haverkamp = ((u64)le32_to_cpu(dresp->mnt[0].capacity)) + 3577a8cf29dSMark Haverkamp (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32); 3581da177e4SLinus Torvalds if (le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY) 3591da177e4SLinus Torvalds fsa_dev_ptr[index].ro = 1; 3601da177e4SLinus Torvalds } 361bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 3621da177e4SLinus Torvalds /* 3631da177e4SLinus Torvalds * If there are no more containers, then stop asking. 3641da177e4SLinus Torvalds */ 3651da177e4SLinus Torvalds if ((index + 1) >= le32_to_cpu(dresp->count)){ 3661da177e4SLinus Torvalds break; 3671da177e4SLinus Torvalds } 3681da177e4SLinus Torvalds } 369bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 3701da177e4SLinus Torvalds return status; 3711da177e4SLinus Torvalds } 3721da177e4SLinus Torvalds 3733b2946ccSMark Haverkamp static void aac_internal_transfer(struct scsi_cmnd *scsicmd, void *data, unsigned int offset, unsigned int len) 3743b2946ccSMark Haverkamp { 3753b2946ccSMark Haverkamp void *buf; 3763b2946ccSMark Haverkamp unsigned int transfer_len; 3773b2946ccSMark Haverkamp struct scatterlist *sg = scsicmd->request_buffer; 3783b2946ccSMark Haverkamp 3793b2946ccSMark Haverkamp if (scsicmd->use_sg) { 3803b2946ccSMark Haverkamp buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset; 3813b2946ccSMark Haverkamp transfer_len = min(sg->length, len + offset); 3823b2946ccSMark Haverkamp } else { 3833b2946ccSMark Haverkamp buf = scsicmd->request_buffer; 3843b2946ccSMark Haverkamp transfer_len = min(scsicmd->request_bufflen, len + offset); 3853b2946ccSMark Haverkamp } 3863b2946ccSMark Haverkamp 3873b2946ccSMark Haverkamp memcpy(buf + offset, data, transfer_len - offset); 3883b2946ccSMark Haverkamp 3893b2946ccSMark Haverkamp if (scsicmd->use_sg) 3903b2946ccSMark Haverkamp kunmap_atomic(buf - sg->offset, KM_IRQ0); 3913b2946ccSMark Haverkamp 3923b2946ccSMark Haverkamp } 3933b2946ccSMark Haverkamp 3941da177e4SLinus Torvalds static void get_container_name_callback(void *context, struct fib * fibptr) 3951da177e4SLinus Torvalds { 3961da177e4SLinus Torvalds struct aac_get_name_resp * get_name_reply; 3971da177e4SLinus Torvalds struct scsi_cmnd * scsicmd; 3981da177e4SLinus Torvalds 3991da177e4SLinus Torvalds scsicmd = (struct scsi_cmnd *) context; 40077d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL; 4011da177e4SLinus Torvalds 4021da177e4SLinus Torvalds dprintk((KERN_DEBUG "get_container_name_callback[cpu %d]: t = %ld.\n", smp_processor_id(), jiffies)); 403125e1874SEric Sesterhenn BUG_ON(fibptr == NULL); 4041da177e4SLinus Torvalds 4051da177e4SLinus Torvalds get_name_reply = (struct aac_get_name_resp *) fib_data(fibptr); 4061da177e4SLinus Torvalds /* Failure is irrelevant, using default value instead */ 4071da177e4SLinus Torvalds if ((le32_to_cpu(get_name_reply->status) == CT_OK) 4081da177e4SLinus Torvalds && (get_name_reply->data[0] != '\0')) { 4091da177e4SLinus Torvalds char *sp = get_name_reply->data; 4101da177e4SLinus Torvalds sp[sizeof(((struct aac_get_name_resp *)NULL)->data)-1] = '\0'; 4111da177e4SLinus Torvalds while (*sp == ' ') 4121da177e4SLinus Torvalds ++sp; 4133b2946ccSMark Haverkamp if (*sp) { 4143b2946ccSMark Haverkamp char d[sizeof(((struct inquiry_data *)NULL)->inqd_pid)]; 4153b2946ccSMark Haverkamp int count = sizeof(d); 4163b2946ccSMark Haverkamp char *dp = d; 4173b2946ccSMark Haverkamp do { 4181da177e4SLinus Torvalds *dp++ = (*sp) ? *sp++ : ' '; 4191da177e4SLinus Torvalds } while (--count > 0); 4203b2946ccSMark Haverkamp aac_internal_transfer(scsicmd, d, 4213b2946ccSMark Haverkamp offsetof(struct inquiry_data, inqd_pid), sizeof(d)); 4221da177e4SLinus Torvalds } 4233b2946ccSMark Haverkamp } 4243b2946ccSMark Haverkamp 4251da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 4261da177e4SLinus Torvalds 427bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 428bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 4298e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 4301da177e4SLinus Torvalds } 4311da177e4SLinus Torvalds 4321da177e4SLinus Torvalds /** 4331da177e4SLinus Torvalds * aac_get_container_name - get container name, none blocking. 4341da177e4SLinus Torvalds */ 4351da177e4SLinus Torvalds static int aac_get_container_name(struct scsi_cmnd * scsicmd, int cid) 4361da177e4SLinus Torvalds { 4371da177e4SLinus Torvalds int status; 4381da177e4SLinus Torvalds struct aac_get_name *dinfo; 4391da177e4SLinus Torvalds struct fib * cmd_fibcontext; 4401da177e4SLinus Torvalds struct aac_dev * dev; 4411da177e4SLinus Torvalds 4421da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 4431da177e4SLinus Torvalds 444bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) 4451da177e4SLinus Torvalds return -ENOMEM; 4461da177e4SLinus Torvalds 447bfb35aa8SMark Haverkamp aac_fib_init(cmd_fibcontext); 4481da177e4SLinus Torvalds dinfo = (struct aac_get_name *) fib_data(cmd_fibcontext); 4491da177e4SLinus Torvalds 4501da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_ContainerConfig); 4511da177e4SLinus Torvalds dinfo->type = cpu_to_le32(CT_READ_NAME); 4521da177e4SLinus Torvalds dinfo->cid = cpu_to_le32(cid); 4531da177e4SLinus Torvalds dinfo->count = cpu_to_le32(sizeof(((struct aac_get_name_resp *)NULL)->data)); 4541da177e4SLinus Torvalds 455bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 4561da177e4SLinus Torvalds cmd_fibcontext, 4571da177e4SLinus Torvalds sizeof (struct aac_get_name), 4581da177e4SLinus Torvalds FsaNormal, 4591da177e4SLinus Torvalds 0, 1, 4601da177e4SLinus Torvalds (fib_callback) get_container_name_callback, 4611da177e4SLinus Torvalds (void *) scsicmd); 4621da177e4SLinus Torvalds 4631da177e4SLinus Torvalds /* 4641da177e4SLinus Torvalds * Check that the command queued to the controller 4651da177e4SLinus Torvalds */ 46677d644d4SMark Haverkamp if (status == -EINPROGRESS) { 46777d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 4681da177e4SLinus Torvalds return 0; 46977d644d4SMark Haverkamp } 4701da177e4SLinus Torvalds 471bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_get_container_name: aac_fib_send failed with status: %d.\n", status); 472bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 473bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 4741da177e4SLinus Torvalds return -1; 4751da177e4SLinus Torvalds } 4761da177e4SLinus Torvalds 4771da177e4SLinus Torvalds /** 478bfb35aa8SMark Haverkamp * aac_probe_container - query a logical volume 4791da177e4SLinus Torvalds * @dev: device to query 4801da177e4SLinus Torvalds * @cid: container identifier 4811da177e4SLinus Torvalds * 4821da177e4SLinus Torvalds * Queries the controller about the given volume. The volume information 4831da177e4SLinus Torvalds * is updated in the struct fsa_dev_info structure rather than returned. 4841da177e4SLinus Torvalds */ 4851da177e4SLinus Torvalds 486bfb35aa8SMark Haverkamp int aac_probe_container(struct aac_dev *dev, int cid) 4871da177e4SLinus Torvalds { 4881da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 4891da177e4SLinus Torvalds int status; 4901da177e4SLinus Torvalds struct aac_query_mount *dinfo; 4911da177e4SLinus Torvalds struct aac_mount *dresp; 4921da177e4SLinus Torvalds struct fib * fibptr; 4931da177e4SLinus Torvalds unsigned instance; 4941da177e4SLinus Torvalds 4951da177e4SLinus Torvalds fsa_dev_ptr = dev->fsa_dev; 49690ee3466SMark Haverkamp if (!fsa_dev_ptr) 49790ee3466SMark Haverkamp return -ENOMEM; 4981da177e4SLinus Torvalds instance = dev->scsi_host_ptr->unique_id; 4991da177e4SLinus Torvalds 500bfb35aa8SMark Haverkamp if (!(fibptr = aac_fib_alloc(dev))) 5011da177e4SLinus Torvalds return -ENOMEM; 5021da177e4SLinus Torvalds 503bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 5041da177e4SLinus Torvalds 5051da177e4SLinus Torvalds dinfo = (struct aac_query_mount *)fib_data(fibptr); 5061da177e4SLinus Torvalds 5071da177e4SLinus Torvalds dinfo->command = cpu_to_le32(VM_NameServe); 5081da177e4SLinus Torvalds dinfo->count = cpu_to_le32(cid); 5091da177e4SLinus Torvalds dinfo->type = cpu_to_le32(FT_FILESYS); 5101da177e4SLinus Torvalds 511bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 5121da177e4SLinus Torvalds fibptr, 5131da177e4SLinus Torvalds sizeof(struct aac_query_mount), 5141da177e4SLinus Torvalds FsaNormal, 5151da177e4SLinus Torvalds 1, 1, 5161da177e4SLinus Torvalds NULL, NULL); 5171da177e4SLinus Torvalds if (status < 0) { 518bfb35aa8SMark Haverkamp printk(KERN_WARNING "aacraid: aac_probe_container query failed.\n"); 5191da177e4SLinus Torvalds goto error; 5201da177e4SLinus Torvalds } 5211da177e4SLinus Torvalds 5221da177e4SLinus Torvalds dresp = (struct aac_mount *) fib_data(fibptr); 5231da177e4SLinus Torvalds 5241da177e4SLinus Torvalds if ((le32_to_cpu(dresp->status) == ST_OK) && 5257a8cf29dSMark Haverkamp (le32_to_cpu(dresp->mnt[0].vol) == CT_NONE)) { 5267a8cf29dSMark Haverkamp dinfo->command = cpu_to_le32(VM_NameServe64); 5277a8cf29dSMark Haverkamp dinfo->count = cpu_to_le32(cid); 5287a8cf29dSMark Haverkamp dinfo->type = cpu_to_le32(FT_FILESYS); 5297a8cf29dSMark Haverkamp 530bfb35aa8SMark Haverkamp if (aac_fib_send(ContainerCommand, 5317a8cf29dSMark Haverkamp fibptr, 5327a8cf29dSMark Haverkamp sizeof(struct aac_query_mount), 5337a8cf29dSMark Haverkamp FsaNormal, 5347a8cf29dSMark Haverkamp 1, 1, 5357a8cf29dSMark Haverkamp NULL, NULL) < 0) 5367a8cf29dSMark Haverkamp goto error; 5377a8cf29dSMark Haverkamp } else 5387a8cf29dSMark Haverkamp dresp->mnt[0].capacityhigh = 0; 5397a8cf29dSMark Haverkamp 5407a8cf29dSMark Haverkamp if ((le32_to_cpu(dresp->status) == ST_OK) && 5411da177e4SLinus Torvalds (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE) && 5421da177e4SLinus Torvalds (le32_to_cpu(dresp->mnt[0].state) != FSCS_HIDDEN)) { 5431da177e4SLinus Torvalds fsa_dev_ptr[cid].valid = 1; 5441da177e4SLinus Torvalds fsa_dev_ptr[cid].type = le32_to_cpu(dresp->mnt[0].vol); 5457a8cf29dSMark Haverkamp fsa_dev_ptr[cid].size 5467a8cf29dSMark Haverkamp = ((u64)le32_to_cpu(dresp->mnt[0].capacity)) + 5477a8cf29dSMark Haverkamp (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32); 5481da177e4SLinus Torvalds if (le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY) 5491da177e4SLinus Torvalds fsa_dev_ptr[cid].ro = 1; 5501da177e4SLinus Torvalds } 5511da177e4SLinus Torvalds 5521da177e4SLinus Torvalds error: 553bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 554bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 5551da177e4SLinus Torvalds 5561da177e4SLinus Torvalds return status; 5571da177e4SLinus Torvalds } 5581da177e4SLinus Torvalds 5591da177e4SLinus Torvalds /* Local Structure to set SCSI inquiry data strings */ 5601da177e4SLinus Torvalds struct scsi_inq { 5611da177e4SLinus Torvalds char vid[8]; /* Vendor ID */ 5621da177e4SLinus Torvalds char pid[16]; /* Product ID */ 5631da177e4SLinus Torvalds char prl[4]; /* Product Revision Level */ 5641da177e4SLinus Torvalds }; 5651da177e4SLinus Torvalds 5661da177e4SLinus Torvalds /** 5671da177e4SLinus Torvalds * InqStrCopy - string merge 5681da177e4SLinus Torvalds * @a: string to copy from 5691da177e4SLinus Torvalds * @b: string to copy to 5701da177e4SLinus Torvalds * 5711da177e4SLinus Torvalds * Copy a String from one location to another 5721da177e4SLinus Torvalds * without copying \0 5731da177e4SLinus Torvalds */ 5741da177e4SLinus Torvalds 5751da177e4SLinus Torvalds static void inqstrcpy(char *a, char *b) 5761da177e4SLinus Torvalds { 5771da177e4SLinus Torvalds 5781da177e4SLinus Torvalds while(*a != (char)0) 5791da177e4SLinus Torvalds *b++ = *a++; 5801da177e4SLinus Torvalds } 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds static char *container_types[] = { 5831da177e4SLinus Torvalds "None", 5841da177e4SLinus Torvalds "Volume", 5851da177e4SLinus Torvalds "Mirror", 5861da177e4SLinus Torvalds "Stripe", 5871da177e4SLinus Torvalds "RAID5", 5881da177e4SLinus Torvalds "SSRW", 5891da177e4SLinus Torvalds "SSRO", 5901da177e4SLinus Torvalds "Morph", 5911da177e4SLinus Torvalds "Legacy", 5921da177e4SLinus Torvalds "RAID4", 5931da177e4SLinus Torvalds "RAID10", 5941da177e4SLinus Torvalds "RAID00", 5951da177e4SLinus Torvalds "V-MIRRORS", 5961da177e4SLinus Torvalds "PSEUDO R4", 5971da177e4SLinus Torvalds "RAID50", 59884971738SMark Haverkamp "RAID5D", 59984971738SMark Haverkamp "RAID5D0", 60084971738SMark Haverkamp "RAID1E", 60184971738SMark Haverkamp "RAID6", 60284971738SMark Haverkamp "RAID60", 6031da177e4SLinus Torvalds "Unknown" 6041da177e4SLinus Torvalds }; 6051da177e4SLinus Torvalds 6061da177e4SLinus Torvalds 6071da177e4SLinus Torvalds 6081da177e4SLinus Torvalds /* Function: setinqstr 6091da177e4SLinus Torvalds * 6101da177e4SLinus Torvalds * Arguments: [1] pointer to void [1] int 6111da177e4SLinus Torvalds * 6121da177e4SLinus Torvalds * Purpose: Sets SCSI inquiry data strings for vendor, product 6131da177e4SLinus Torvalds * and revision level. Allows strings to be set in platform dependant 6141da177e4SLinus Torvalds * files instead of in OS dependant driver source. 6151da177e4SLinus Torvalds */ 6161da177e4SLinus Torvalds 617794d0601SMark Haverkamp static void setinqstr(struct aac_dev *dev, void *data, int tindex) 6181da177e4SLinus Torvalds { 6191da177e4SLinus Torvalds struct scsi_inq *str; 6201da177e4SLinus Torvalds 6211da177e4SLinus Torvalds str = (struct scsi_inq *)(data); /* cast data to scsi inq block */ 622794d0601SMark Haverkamp memset(str, ' ', sizeof(*str)); 623794d0601SMark Haverkamp 624794d0601SMark Haverkamp if (dev->supplement_adapter_info.AdapterTypeText[0]) { 625794d0601SMark Haverkamp char * cp = dev->supplement_adapter_info.AdapterTypeText; 626794d0601SMark Haverkamp int c = sizeof(str->vid); 627794d0601SMark Haverkamp while (*cp && *cp != ' ' && --c) 628794d0601SMark Haverkamp ++cp; 629794d0601SMark Haverkamp c = *cp; 630794d0601SMark Haverkamp *cp = '\0'; 631794d0601SMark Haverkamp inqstrcpy (dev->supplement_adapter_info.AdapterTypeText, 632794d0601SMark Haverkamp str->vid); 633794d0601SMark Haverkamp *cp = c; 634794d0601SMark Haverkamp while (*cp && *cp != ' ') 635794d0601SMark Haverkamp ++cp; 636794d0601SMark Haverkamp while (*cp == ' ') 637794d0601SMark Haverkamp ++cp; 638794d0601SMark Haverkamp /* last six chars reserved for vol type */ 639794d0601SMark Haverkamp c = 0; 640794d0601SMark Haverkamp if (strlen(cp) > sizeof(str->pid)) { 641794d0601SMark Haverkamp c = cp[sizeof(str->pid)]; 642794d0601SMark Haverkamp cp[sizeof(str->pid)] = '\0'; 643794d0601SMark Haverkamp } 644794d0601SMark Haverkamp inqstrcpy (cp, str->pid); 645794d0601SMark Haverkamp if (c) 646794d0601SMark Haverkamp cp[sizeof(str->pid)] = c; 647794d0601SMark Haverkamp } else { 648794d0601SMark Haverkamp struct aac_driver_ident *mp = aac_get_driver_ident(dev->cardtype); 6491da177e4SLinus Torvalds 6501da177e4SLinus Torvalds inqstrcpy (mp->vname, str->vid); 651794d0601SMark Haverkamp /* last six chars reserved for vol type */ 652794d0601SMark Haverkamp inqstrcpy (mp->model, str->pid); 653794d0601SMark Haverkamp } 6541da177e4SLinus Torvalds 6556391a113STobias Klauser if (tindex < ARRAY_SIZE(container_types)){ 6561da177e4SLinus Torvalds char *findit = str->pid; 6571da177e4SLinus Torvalds 6581da177e4SLinus Torvalds for ( ; *findit != ' '; findit++); /* walk till we find a space */ 6591da177e4SLinus Torvalds /* RAID is superfluous in the context of a RAID device */ 6601da177e4SLinus Torvalds if (memcmp(findit-4, "RAID", 4) == 0) 6611da177e4SLinus Torvalds *(findit -= 4) = ' '; 662794d0601SMark Haverkamp if (((findit - str->pid) + strlen(container_types[tindex])) 663794d0601SMark Haverkamp < (sizeof(str->pid) + sizeof(str->prl))) 6641da177e4SLinus Torvalds inqstrcpy (container_types[tindex], findit + 1); 6651da177e4SLinus Torvalds } 6661da177e4SLinus Torvalds inqstrcpy ("V1.0", str->prl); 6671da177e4SLinus Torvalds } 6681da177e4SLinus Torvalds 6694833869eSAdrian Bunk static void set_sense(u8 *sense_buf, u8 sense_key, u8 sense_code, 6701da177e4SLinus Torvalds u8 a_sense_code, u8 incorrect_length, 6711da177e4SLinus Torvalds u8 bit_pointer, u16 field_pointer, 6721da177e4SLinus Torvalds u32 residue) 6731da177e4SLinus Torvalds { 6741da177e4SLinus Torvalds sense_buf[0] = 0xF0; /* Sense data valid, err code 70h (current error) */ 6751da177e4SLinus Torvalds sense_buf[1] = 0; /* Segment number, always zero */ 6761da177e4SLinus Torvalds 6771da177e4SLinus Torvalds if (incorrect_length) { 6781da177e4SLinus Torvalds sense_buf[2] = sense_key | 0x20;/* Set ILI bit | sense key */ 6791da177e4SLinus Torvalds sense_buf[3] = BYTE3(residue); 6801da177e4SLinus Torvalds sense_buf[4] = BYTE2(residue); 6811da177e4SLinus Torvalds sense_buf[5] = BYTE1(residue); 6821da177e4SLinus Torvalds sense_buf[6] = BYTE0(residue); 6831da177e4SLinus Torvalds } else 6841da177e4SLinus Torvalds sense_buf[2] = sense_key; /* Sense key */ 6851da177e4SLinus Torvalds 6861da177e4SLinus Torvalds if (sense_key == ILLEGAL_REQUEST) 6871da177e4SLinus Torvalds sense_buf[7] = 10; /* Additional sense length */ 6881da177e4SLinus Torvalds else 6891da177e4SLinus Torvalds sense_buf[7] = 6; /* Additional sense length */ 6901da177e4SLinus Torvalds 6911da177e4SLinus Torvalds sense_buf[12] = sense_code; /* Additional sense code */ 6921da177e4SLinus Torvalds sense_buf[13] = a_sense_code; /* Additional sense code qualifier */ 6931da177e4SLinus Torvalds if (sense_key == ILLEGAL_REQUEST) { 6941da177e4SLinus Torvalds sense_buf[15] = 0; 6951da177e4SLinus Torvalds 6961da177e4SLinus Torvalds if (sense_code == SENCODE_INVALID_PARAM_FIELD) 6971da177e4SLinus Torvalds sense_buf[15] = 0x80;/* Std sense key specific field */ 6981da177e4SLinus Torvalds /* Illegal parameter is in the parameter block */ 6991da177e4SLinus Torvalds 7001da177e4SLinus Torvalds if (sense_code == SENCODE_INVALID_CDB_FIELD) 7011da177e4SLinus Torvalds sense_buf[15] = 0xc0;/* Std sense key specific field */ 7021da177e4SLinus Torvalds /* Illegal parameter is in the CDB block */ 7031da177e4SLinus Torvalds sense_buf[15] |= bit_pointer; 7041da177e4SLinus Torvalds sense_buf[16] = field_pointer >> 8; /* MSB */ 7051da177e4SLinus Torvalds sense_buf[17] = field_pointer; /* LSB */ 7061da177e4SLinus Torvalds } 7071da177e4SLinus Torvalds } 7081da177e4SLinus Torvalds 709e8f32de5SMark Haverkamp static int aac_bounds_32(struct aac_dev * dev, struct scsi_cmnd * cmd, u64 lba) 710e8f32de5SMark Haverkamp { 711e8f32de5SMark Haverkamp if (lba & 0xffffffff00000000LL) { 712e8f32de5SMark Haverkamp int cid = scmd_id(cmd); 713e8f32de5SMark Haverkamp dprintk((KERN_DEBUG "aacraid: Illegal lba\n")); 714e8f32de5SMark Haverkamp cmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 715e8f32de5SMark Haverkamp SAM_STAT_CHECK_CONDITION; 716e8f32de5SMark Haverkamp set_sense((u8 *) &dev->fsa_dev[cid].sense_data, 717e8f32de5SMark Haverkamp HARDWARE_ERROR, 718e8f32de5SMark Haverkamp SENCODE_INTERNAL_TARGET_FAILURE, 719e8f32de5SMark Haverkamp ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0, 720e8f32de5SMark Haverkamp 0, 0); 721e8f32de5SMark Haverkamp memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 722e8f32de5SMark Haverkamp (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(cmd->sense_buffer)) 723e8f32de5SMark Haverkamp ? sizeof(cmd->sense_buffer) 724e8f32de5SMark Haverkamp : sizeof(dev->fsa_dev[cid].sense_data)); 725e8f32de5SMark Haverkamp cmd->scsi_done(cmd); 726e8f32de5SMark Haverkamp return 1; 727e8f32de5SMark Haverkamp } 728e8f32de5SMark Haverkamp return 0; 729e8f32de5SMark Haverkamp } 730e8f32de5SMark Haverkamp 731e8f32de5SMark Haverkamp static int aac_bounds_64(struct aac_dev * dev, struct scsi_cmnd * cmd, u64 lba) 732e8f32de5SMark Haverkamp { 733e8f32de5SMark Haverkamp return 0; 734e8f32de5SMark Haverkamp } 735e8f32de5SMark Haverkamp 736e8f32de5SMark Haverkamp static void io_callback(void *context, struct fib * fibptr); 737e8f32de5SMark Haverkamp 738e8f32de5SMark Haverkamp static int aac_read_raw_io(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 739e8f32de5SMark Haverkamp { 740e8f32de5SMark Haverkamp u16 fibsize; 741e8f32de5SMark Haverkamp struct aac_raw_io *readcmd; 742e8f32de5SMark Haverkamp aac_fib_init(fib); 743e8f32de5SMark Haverkamp readcmd = (struct aac_raw_io *) fib_data(fib); 744e8f32de5SMark Haverkamp readcmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff)); 745e8f32de5SMark Haverkamp readcmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 746e8f32de5SMark Haverkamp readcmd->count = cpu_to_le32(count<<9); 747e8f32de5SMark Haverkamp readcmd->cid = cpu_to_le16(scmd_id(cmd)); 748e8f32de5SMark Haverkamp readcmd->flags = cpu_to_le16(1); 749e8f32de5SMark Haverkamp readcmd->bpTotal = 0; 750e8f32de5SMark Haverkamp readcmd->bpComplete = 0; 751e8f32de5SMark Haverkamp 752e8f32de5SMark Haverkamp aac_build_sgraw(cmd, &readcmd->sg); 753e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_raw_io) + ((le32_to_cpu(readcmd->sg.count) - 1) * sizeof (struct sgentryraw)); 754e8f32de5SMark Haverkamp BUG_ON(fibsize > (fib->dev->max_fib_size - sizeof(struct aac_fibhdr))); 755e8f32de5SMark Haverkamp /* 756e8f32de5SMark Haverkamp * Now send the Fib to the adapter 757e8f32de5SMark Haverkamp */ 758e8f32de5SMark Haverkamp return aac_fib_send(ContainerRawIo, 759e8f32de5SMark Haverkamp fib, 760e8f32de5SMark Haverkamp fibsize, 761e8f32de5SMark Haverkamp FsaNormal, 762e8f32de5SMark Haverkamp 0, 1, 763e8f32de5SMark Haverkamp (fib_callback) io_callback, 764e8f32de5SMark Haverkamp (void *) cmd); 765e8f32de5SMark Haverkamp } 766e8f32de5SMark Haverkamp 767e8f32de5SMark Haverkamp static int aac_read_block64(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 768e8f32de5SMark Haverkamp { 769e8f32de5SMark Haverkamp u16 fibsize; 770e8f32de5SMark Haverkamp struct aac_read64 *readcmd; 771e8f32de5SMark Haverkamp aac_fib_init(fib); 772e8f32de5SMark Haverkamp readcmd = (struct aac_read64 *) fib_data(fib); 773e8f32de5SMark Haverkamp readcmd->command = cpu_to_le32(VM_CtHostRead64); 774e8f32de5SMark Haverkamp readcmd->cid = cpu_to_le16(scmd_id(cmd)); 775e8f32de5SMark Haverkamp readcmd->sector_count = cpu_to_le16(count); 776e8f32de5SMark Haverkamp readcmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 777e8f32de5SMark Haverkamp readcmd->pad = 0; 778e8f32de5SMark Haverkamp readcmd->flags = 0; 779e8f32de5SMark Haverkamp 780e8f32de5SMark Haverkamp aac_build_sg64(cmd, &readcmd->sg); 781e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_read64) + 782e8f32de5SMark Haverkamp ((le32_to_cpu(readcmd->sg.count) - 1) * 783e8f32de5SMark Haverkamp sizeof (struct sgentry64)); 784e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 785e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 786e8f32de5SMark Haverkamp /* 787e8f32de5SMark Haverkamp * Now send the Fib to the adapter 788e8f32de5SMark Haverkamp */ 789e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand64, 790e8f32de5SMark Haverkamp fib, 791e8f32de5SMark Haverkamp fibsize, 792e8f32de5SMark Haverkamp FsaNormal, 793e8f32de5SMark Haverkamp 0, 1, 794e8f32de5SMark Haverkamp (fib_callback) io_callback, 795e8f32de5SMark Haverkamp (void *) cmd); 796e8f32de5SMark Haverkamp } 797e8f32de5SMark Haverkamp 798e8f32de5SMark Haverkamp static int aac_read_block(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 799e8f32de5SMark Haverkamp { 800e8f32de5SMark Haverkamp u16 fibsize; 801e8f32de5SMark Haverkamp struct aac_read *readcmd; 802e8f32de5SMark Haverkamp aac_fib_init(fib); 803e8f32de5SMark Haverkamp readcmd = (struct aac_read *) fib_data(fib); 804e8f32de5SMark Haverkamp readcmd->command = cpu_to_le32(VM_CtBlockRead); 805e8f32de5SMark Haverkamp readcmd->cid = cpu_to_le16(scmd_id(cmd)); 806e8f32de5SMark Haverkamp readcmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 807e8f32de5SMark Haverkamp readcmd->count = cpu_to_le32(count * 512); 808e8f32de5SMark Haverkamp 809e8f32de5SMark Haverkamp aac_build_sg(cmd, &readcmd->sg); 810e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_read) + 811e8f32de5SMark Haverkamp ((le32_to_cpu(readcmd->sg.count) - 1) * 812e8f32de5SMark Haverkamp sizeof (struct sgentry)); 813e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 814e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 815e8f32de5SMark Haverkamp /* 816e8f32de5SMark Haverkamp * Now send the Fib to the adapter 817e8f32de5SMark Haverkamp */ 818e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand, 819e8f32de5SMark Haverkamp fib, 820e8f32de5SMark Haverkamp fibsize, 821e8f32de5SMark Haverkamp FsaNormal, 822e8f32de5SMark Haverkamp 0, 1, 823e8f32de5SMark Haverkamp (fib_callback) io_callback, 824e8f32de5SMark Haverkamp (void *) cmd); 825e8f32de5SMark Haverkamp } 826e8f32de5SMark Haverkamp 827e8f32de5SMark Haverkamp static int aac_write_raw_io(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 828e8f32de5SMark Haverkamp { 829e8f32de5SMark Haverkamp u16 fibsize; 830e8f32de5SMark Haverkamp struct aac_raw_io *writecmd; 831e8f32de5SMark Haverkamp aac_fib_init(fib); 832e8f32de5SMark Haverkamp writecmd = (struct aac_raw_io *) fib_data(fib); 833e8f32de5SMark Haverkamp writecmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff)); 834e8f32de5SMark Haverkamp writecmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 835e8f32de5SMark Haverkamp writecmd->count = cpu_to_le32(count<<9); 836e8f32de5SMark Haverkamp writecmd->cid = cpu_to_le16(scmd_id(cmd)); 837e8f32de5SMark Haverkamp writecmd->flags = 0; 838e8f32de5SMark Haverkamp writecmd->bpTotal = 0; 839e8f32de5SMark Haverkamp writecmd->bpComplete = 0; 840e8f32de5SMark Haverkamp 841e8f32de5SMark Haverkamp aac_build_sgraw(cmd, &writecmd->sg); 842e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_raw_io) + ((le32_to_cpu(writecmd->sg.count) - 1) * sizeof (struct sgentryraw)); 843e8f32de5SMark Haverkamp BUG_ON(fibsize > (fib->dev->max_fib_size - sizeof(struct aac_fibhdr))); 844e8f32de5SMark Haverkamp /* 845e8f32de5SMark Haverkamp * Now send the Fib to the adapter 846e8f32de5SMark Haverkamp */ 847e8f32de5SMark Haverkamp return aac_fib_send(ContainerRawIo, 848e8f32de5SMark Haverkamp fib, 849e8f32de5SMark Haverkamp fibsize, 850e8f32de5SMark Haverkamp FsaNormal, 851e8f32de5SMark Haverkamp 0, 1, 852e8f32de5SMark Haverkamp (fib_callback) io_callback, 853e8f32de5SMark Haverkamp (void *) cmd); 854e8f32de5SMark Haverkamp } 855e8f32de5SMark Haverkamp 856e8f32de5SMark Haverkamp static int aac_write_block64(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 857e8f32de5SMark Haverkamp { 858e8f32de5SMark Haverkamp u16 fibsize; 859e8f32de5SMark Haverkamp struct aac_write64 *writecmd; 860e8f32de5SMark Haverkamp aac_fib_init(fib); 861e8f32de5SMark Haverkamp writecmd = (struct aac_write64 *) fib_data(fib); 862e8f32de5SMark Haverkamp writecmd->command = cpu_to_le32(VM_CtHostWrite64); 863e8f32de5SMark Haverkamp writecmd->cid = cpu_to_le16(scmd_id(cmd)); 864e8f32de5SMark Haverkamp writecmd->sector_count = cpu_to_le16(count); 865e8f32de5SMark Haverkamp writecmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 866e8f32de5SMark Haverkamp writecmd->pad = 0; 867e8f32de5SMark Haverkamp writecmd->flags = 0; 868e8f32de5SMark Haverkamp 869e8f32de5SMark Haverkamp aac_build_sg64(cmd, &writecmd->sg); 870e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_write64) + 871e8f32de5SMark Haverkamp ((le32_to_cpu(writecmd->sg.count) - 1) * 872e8f32de5SMark Haverkamp sizeof (struct sgentry64)); 873e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 874e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 875e8f32de5SMark Haverkamp /* 876e8f32de5SMark Haverkamp * Now send the Fib to the adapter 877e8f32de5SMark Haverkamp */ 878e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand64, 879e8f32de5SMark Haverkamp fib, 880e8f32de5SMark Haverkamp fibsize, 881e8f32de5SMark Haverkamp FsaNormal, 882e8f32de5SMark Haverkamp 0, 1, 883e8f32de5SMark Haverkamp (fib_callback) io_callback, 884e8f32de5SMark Haverkamp (void *) cmd); 885e8f32de5SMark Haverkamp } 886e8f32de5SMark Haverkamp 887e8f32de5SMark Haverkamp static int aac_write_block(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 888e8f32de5SMark Haverkamp { 889e8f32de5SMark Haverkamp u16 fibsize; 890e8f32de5SMark Haverkamp struct aac_write *writecmd; 891e8f32de5SMark Haverkamp aac_fib_init(fib); 892e8f32de5SMark Haverkamp writecmd = (struct aac_write *) fib_data(fib); 893e8f32de5SMark Haverkamp writecmd->command = cpu_to_le32(VM_CtBlockWrite); 894e8f32de5SMark Haverkamp writecmd->cid = cpu_to_le16(scmd_id(cmd)); 895e8f32de5SMark Haverkamp writecmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 896e8f32de5SMark Haverkamp writecmd->count = cpu_to_le32(count * 512); 897e8f32de5SMark Haverkamp writecmd->sg.count = cpu_to_le32(1); 898e8f32de5SMark Haverkamp /* ->stable is not used - it did mean which type of write */ 899e8f32de5SMark Haverkamp 900e8f32de5SMark Haverkamp aac_build_sg(cmd, &writecmd->sg); 901e8f32de5SMark Haverkamp fibsize = sizeof(struct aac_write) + 902e8f32de5SMark Haverkamp ((le32_to_cpu(writecmd->sg.count) - 1) * 903e8f32de5SMark Haverkamp sizeof (struct sgentry)); 904e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 905e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 906e8f32de5SMark Haverkamp /* 907e8f32de5SMark Haverkamp * Now send the Fib to the adapter 908e8f32de5SMark Haverkamp */ 909e8f32de5SMark Haverkamp return aac_fib_send(ContainerCommand, 910e8f32de5SMark Haverkamp fib, 911e8f32de5SMark Haverkamp fibsize, 912e8f32de5SMark Haverkamp FsaNormal, 913e8f32de5SMark Haverkamp 0, 1, 914e8f32de5SMark Haverkamp (fib_callback) io_callback, 915e8f32de5SMark Haverkamp (void *) cmd); 916e8f32de5SMark Haverkamp } 917e8f32de5SMark Haverkamp 918e8f32de5SMark Haverkamp static struct aac_srb * aac_scsi_common(struct fib * fib, struct scsi_cmnd * cmd) 919e8f32de5SMark Haverkamp { 920e8f32de5SMark Haverkamp struct aac_srb * srbcmd; 921e8f32de5SMark Haverkamp u32 flag; 922e8f32de5SMark Haverkamp u32 timeout; 923e8f32de5SMark Haverkamp 924e8f32de5SMark Haverkamp aac_fib_init(fib); 925e8f32de5SMark Haverkamp switch(cmd->sc_data_direction){ 926e8f32de5SMark Haverkamp case DMA_TO_DEVICE: 927e8f32de5SMark Haverkamp flag = SRB_DataOut; 928e8f32de5SMark Haverkamp break; 929e8f32de5SMark Haverkamp case DMA_BIDIRECTIONAL: 930e8f32de5SMark Haverkamp flag = SRB_DataIn | SRB_DataOut; 931e8f32de5SMark Haverkamp break; 932e8f32de5SMark Haverkamp case DMA_FROM_DEVICE: 933e8f32de5SMark Haverkamp flag = SRB_DataIn; 934e8f32de5SMark Haverkamp break; 935e8f32de5SMark Haverkamp case DMA_NONE: 936e8f32de5SMark Haverkamp default: /* shuts up some versions of gcc */ 937e8f32de5SMark Haverkamp flag = SRB_NoDataXfer; 938e8f32de5SMark Haverkamp break; 939e8f32de5SMark Haverkamp } 940e8f32de5SMark Haverkamp 941e8f32de5SMark Haverkamp srbcmd = (struct aac_srb*) fib_data(fib); 942e8f32de5SMark Haverkamp srbcmd->function = cpu_to_le32(SRBF_ExecuteScsi); 943e8f32de5SMark Haverkamp srbcmd->channel = cpu_to_le32(aac_logical_to_phys(scmd_channel(cmd))); 944e8f32de5SMark Haverkamp srbcmd->id = cpu_to_le32(scmd_id(cmd)); 945e8f32de5SMark Haverkamp srbcmd->lun = cpu_to_le32(cmd->device->lun); 946e8f32de5SMark Haverkamp srbcmd->flags = cpu_to_le32(flag); 947e8f32de5SMark Haverkamp timeout = cmd->timeout_per_command/HZ; 948e8f32de5SMark Haverkamp if (timeout == 0) 949e8f32de5SMark Haverkamp timeout = 1; 950e8f32de5SMark Haverkamp srbcmd->timeout = cpu_to_le32(timeout); // timeout in seconds 951e8f32de5SMark Haverkamp srbcmd->retry_limit = 0; /* Obsolete parameter */ 952e8f32de5SMark Haverkamp srbcmd->cdb_size = cpu_to_le32(cmd->cmd_len); 953e8f32de5SMark Haverkamp return srbcmd; 954e8f32de5SMark Haverkamp } 955e8f32de5SMark Haverkamp 956e8f32de5SMark Haverkamp static void aac_srb_callback(void *context, struct fib * fibptr); 957e8f32de5SMark Haverkamp 958e8f32de5SMark Haverkamp static int aac_scsi_64(struct fib * fib, struct scsi_cmnd * cmd) 959e8f32de5SMark Haverkamp { 960e8f32de5SMark Haverkamp u16 fibsize; 961e8f32de5SMark Haverkamp struct aac_srb * srbcmd = aac_scsi_common(fib, cmd); 962e8f32de5SMark Haverkamp 963e8f32de5SMark Haverkamp aac_build_sg64(cmd, (struct sgmap64*) &srbcmd->sg); 964e8f32de5SMark Haverkamp srbcmd->count = cpu_to_le32(cmd->request_bufflen); 965e8f32de5SMark Haverkamp 966e8f32de5SMark Haverkamp memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb)); 967e8f32de5SMark Haverkamp memcpy(srbcmd->cdb, cmd->cmnd, cmd->cmd_len); 968e8f32de5SMark Haverkamp /* 969e8f32de5SMark Haverkamp * Build Scatter/Gather list 970e8f32de5SMark Haverkamp */ 971e8f32de5SMark Haverkamp fibsize = sizeof (struct aac_srb) - sizeof (struct sgentry) + 972e8f32de5SMark Haverkamp ((le32_to_cpu(srbcmd->sg.count) & 0xff) * 973e8f32de5SMark Haverkamp sizeof (struct sgentry64)); 974e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 975e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 976e8f32de5SMark Haverkamp 977e8f32de5SMark Haverkamp /* 978e8f32de5SMark Haverkamp * Now send the Fib to the adapter 979e8f32de5SMark Haverkamp */ 980e8f32de5SMark Haverkamp return aac_fib_send(ScsiPortCommand64, fib, 981e8f32de5SMark Haverkamp fibsize, FsaNormal, 0, 1, 982e8f32de5SMark Haverkamp (fib_callback) aac_srb_callback, 983e8f32de5SMark Haverkamp (void *) cmd); 984e8f32de5SMark Haverkamp } 985e8f32de5SMark Haverkamp 986e8f32de5SMark Haverkamp static int aac_scsi_32(struct fib * fib, struct scsi_cmnd * cmd) 987e8f32de5SMark Haverkamp { 988e8f32de5SMark Haverkamp u16 fibsize; 989e8f32de5SMark Haverkamp struct aac_srb * srbcmd = aac_scsi_common(fib, cmd); 990e8f32de5SMark Haverkamp 991e8f32de5SMark Haverkamp aac_build_sg(cmd, (struct sgmap*)&srbcmd->sg); 992e8f32de5SMark Haverkamp srbcmd->count = cpu_to_le32(cmd->request_bufflen); 993e8f32de5SMark Haverkamp 994e8f32de5SMark Haverkamp memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb)); 995e8f32de5SMark Haverkamp memcpy(srbcmd->cdb, cmd->cmnd, cmd->cmd_len); 996e8f32de5SMark Haverkamp /* 997e8f32de5SMark Haverkamp * Build Scatter/Gather list 998e8f32de5SMark Haverkamp */ 999e8f32de5SMark Haverkamp fibsize = sizeof (struct aac_srb) + 1000e8f32de5SMark Haverkamp (((le32_to_cpu(srbcmd->sg.count) & 0xff) - 1) * 1001e8f32de5SMark Haverkamp sizeof (struct sgentry)); 1002e8f32de5SMark Haverkamp BUG_ON (fibsize > (fib->dev->max_fib_size - 1003e8f32de5SMark Haverkamp sizeof(struct aac_fibhdr))); 1004e8f32de5SMark Haverkamp 1005e8f32de5SMark Haverkamp /* 1006e8f32de5SMark Haverkamp * Now send the Fib to the adapter 1007e8f32de5SMark Haverkamp */ 1008e8f32de5SMark Haverkamp return aac_fib_send(ScsiPortCommand, fib, fibsize, FsaNormal, 0, 1, 1009e8f32de5SMark Haverkamp (fib_callback) aac_srb_callback, (void *) cmd); 1010e8f32de5SMark Haverkamp } 1011e8f32de5SMark Haverkamp 10121da177e4SLinus Torvalds int aac_get_adapter_info(struct aac_dev* dev) 10131da177e4SLinus Torvalds { 10141da177e4SLinus Torvalds struct fib* fibptr; 10151da177e4SLinus Torvalds int rcode; 10161da177e4SLinus Torvalds u32 tmp; 10177c00ffa3SMark Haverkamp struct aac_adapter_info *info; 101884971738SMark Haverkamp struct aac_bus_info *command; 101984971738SMark Haverkamp struct aac_bus_info_response *bus_info; 10207c00ffa3SMark Haverkamp 1021bfb35aa8SMark Haverkamp if (!(fibptr = aac_fib_alloc(dev))) 10221da177e4SLinus Torvalds return -ENOMEM; 10231da177e4SLinus Torvalds 1024bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 10251da177e4SLinus Torvalds info = (struct aac_adapter_info *) fib_data(fibptr); 10267c00ffa3SMark Haverkamp memset(info,0,sizeof(*info)); 10271da177e4SLinus Torvalds 1028bfb35aa8SMark Haverkamp rcode = aac_fib_send(RequestAdapterInfo, 10291da177e4SLinus Torvalds fibptr, 10307c00ffa3SMark Haverkamp sizeof(*info), 10311da177e4SLinus Torvalds FsaNormal, 10329203344cSMark Haverkamp -1, 1, /* First `interrupt' command uses special wait */ 10331da177e4SLinus Torvalds NULL, 10341da177e4SLinus Torvalds NULL); 10351da177e4SLinus Torvalds 10367c00ffa3SMark Haverkamp if (rcode < 0) { 1037bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1038bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 10397c00ffa3SMark Haverkamp return rcode; 10407c00ffa3SMark Haverkamp } 10417c00ffa3SMark Haverkamp memcpy(&dev->adapter_info, info, sizeof(*info)); 10427c00ffa3SMark Haverkamp 10437c00ffa3SMark Haverkamp if (dev->adapter_info.options & AAC_OPT_SUPPLEMENT_ADAPTER_INFO) { 10447c00ffa3SMark Haverkamp struct aac_supplement_adapter_info * info; 10457c00ffa3SMark Haverkamp 1046bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 10477c00ffa3SMark Haverkamp 10487c00ffa3SMark Haverkamp info = (struct aac_supplement_adapter_info *) fib_data(fibptr); 10497c00ffa3SMark Haverkamp 10507c00ffa3SMark Haverkamp memset(info,0,sizeof(*info)); 10517c00ffa3SMark Haverkamp 1052bfb35aa8SMark Haverkamp rcode = aac_fib_send(RequestSupplementAdapterInfo, 10537c00ffa3SMark Haverkamp fibptr, 10547c00ffa3SMark Haverkamp sizeof(*info), 10557c00ffa3SMark Haverkamp FsaNormal, 10567c00ffa3SMark Haverkamp 1, 1, 10577c00ffa3SMark Haverkamp NULL, 10587c00ffa3SMark Haverkamp NULL); 10597c00ffa3SMark Haverkamp 10607c00ffa3SMark Haverkamp if (rcode >= 0) 10617c00ffa3SMark Haverkamp memcpy(&dev->supplement_adapter_info, info, sizeof(*info)); 10627c00ffa3SMark Haverkamp } 10631da177e4SLinus Torvalds 106484971738SMark Haverkamp 106584971738SMark Haverkamp /* 106684971738SMark Haverkamp * GetBusInfo 106784971738SMark Haverkamp */ 106884971738SMark Haverkamp 1069bfb35aa8SMark Haverkamp aac_fib_init(fibptr); 107084971738SMark Haverkamp 107184971738SMark Haverkamp bus_info = (struct aac_bus_info_response *) fib_data(fibptr); 107284971738SMark Haverkamp 107384971738SMark Haverkamp memset(bus_info, 0, sizeof(*bus_info)); 107484971738SMark Haverkamp 107584971738SMark Haverkamp command = (struct aac_bus_info *)bus_info; 107684971738SMark Haverkamp 107784971738SMark Haverkamp command->Command = cpu_to_le32(VM_Ioctl); 107884971738SMark Haverkamp command->ObjType = cpu_to_le32(FT_DRIVE); 107984971738SMark Haverkamp command->MethodId = cpu_to_le32(1); 108084971738SMark Haverkamp command->CtlCmd = cpu_to_le32(GetBusInfo); 108184971738SMark Haverkamp 1082bfb35aa8SMark Haverkamp rcode = aac_fib_send(ContainerCommand, 108384971738SMark Haverkamp fibptr, 108484971738SMark Haverkamp sizeof (*bus_info), 108584971738SMark Haverkamp FsaNormal, 108684971738SMark Haverkamp 1, 1, 108784971738SMark Haverkamp NULL, NULL); 108884971738SMark Haverkamp 108984971738SMark Haverkamp if (rcode >= 0 && le32_to_cpu(bus_info->Status) == ST_OK) { 109084971738SMark Haverkamp dev->maximum_num_physicals = le32_to_cpu(bus_info->TargetsPerBus); 109184971738SMark Haverkamp dev->maximum_num_channels = le32_to_cpu(bus_info->BusCount); 109284971738SMark Haverkamp } 109384971738SMark Haverkamp 10948c867b25SMark Haverkamp if (!dev->in_reset) { 10951da177e4SLinus Torvalds tmp = le32_to_cpu(dev->adapter_info.kernelrev); 10967c00ffa3SMark Haverkamp printk(KERN_INFO "%s%d: kernel %d.%d-%d[%d] %.*s\n", 10971da177e4SLinus Torvalds dev->name, 10981da177e4SLinus Torvalds dev->id, 10991da177e4SLinus Torvalds tmp>>24, 11001da177e4SLinus Torvalds (tmp>>16)&0xff, 11011da177e4SLinus Torvalds tmp&0xff, 11027c00ffa3SMark Haverkamp le32_to_cpu(dev->adapter_info.kernelbuild), 11037c00ffa3SMark Haverkamp (int)sizeof(dev->supplement_adapter_info.BuildDate), 11047c00ffa3SMark Haverkamp dev->supplement_adapter_info.BuildDate); 11051da177e4SLinus Torvalds tmp = le32_to_cpu(dev->adapter_info.monitorrev); 11061da177e4SLinus Torvalds printk(KERN_INFO "%s%d: monitor %d.%d-%d[%d]\n", 11071da177e4SLinus Torvalds dev->name, dev->id, 11081da177e4SLinus Torvalds tmp>>24,(tmp>>16)&0xff,tmp&0xff, 11091da177e4SLinus Torvalds le32_to_cpu(dev->adapter_info.monitorbuild)); 11101da177e4SLinus Torvalds tmp = le32_to_cpu(dev->adapter_info.biosrev); 11111da177e4SLinus Torvalds printk(KERN_INFO "%s%d: bios %d.%d-%d[%d]\n", 11121da177e4SLinus Torvalds dev->name, dev->id, 11131da177e4SLinus Torvalds tmp>>24,(tmp>>16)&0xff,tmp&0xff, 11141da177e4SLinus Torvalds le32_to_cpu(dev->adapter_info.biosbuild)); 11151da177e4SLinus Torvalds if (le32_to_cpu(dev->adapter_info.serial[0]) != 0xBAD0) 11161da177e4SLinus Torvalds printk(KERN_INFO "%s%d: serial %x\n", 11171da177e4SLinus Torvalds dev->name, dev->id, 11181da177e4SLinus Torvalds le32_to_cpu(dev->adapter_info.serial[0])); 11198c867b25SMark Haverkamp } 11201da177e4SLinus Torvalds 11211da177e4SLinus Torvalds dev->nondasd_support = 0; 11221da177e4SLinus Torvalds dev->raid_scsi_mode = 0; 11231da177e4SLinus Torvalds if(dev->adapter_info.options & AAC_OPT_NONDASD){ 11241da177e4SLinus Torvalds dev->nondasd_support = 1; 11251da177e4SLinus Torvalds } 11261da177e4SLinus Torvalds 11271da177e4SLinus Torvalds /* 11281da177e4SLinus Torvalds * If the firmware supports ROMB RAID/SCSI mode and we are currently 11291da177e4SLinus Torvalds * in RAID/SCSI mode, set the flag. For now if in this mode we will 11301da177e4SLinus Torvalds * force nondasd support on. If we decide to allow the non-dasd flag 11311da177e4SLinus Torvalds * additional changes changes will have to be made to support 11321da177e4SLinus Torvalds * RAID/SCSI. the function aac_scsi_cmd in this module will have to be 11331da177e4SLinus Torvalds * changed to support the new dev->raid_scsi_mode flag instead of 11341da177e4SLinus Torvalds * leaching off of the dev->nondasd_support flag. Also in linit.c the 11351da177e4SLinus Torvalds * function aac_detect will have to be modified where it sets up the 11361da177e4SLinus Torvalds * max number of channels based on the aac->nondasd_support flag only. 11371da177e4SLinus Torvalds */ 11381da177e4SLinus Torvalds if ((dev->adapter_info.options & AAC_OPT_SCSI_MANAGED) && 11391da177e4SLinus Torvalds (dev->adapter_info.options & AAC_OPT_RAID_SCSI_MODE)) { 11401da177e4SLinus Torvalds dev->nondasd_support = 1; 11411da177e4SLinus Torvalds dev->raid_scsi_mode = 1; 11421da177e4SLinus Torvalds } 11431da177e4SLinus Torvalds if (dev->raid_scsi_mode != 0) 11441da177e4SLinus Torvalds printk(KERN_INFO "%s%d: ROMB RAID/SCSI mode enabled\n", 11451da177e4SLinus Torvalds dev->name, dev->id); 11461da177e4SLinus Torvalds 11471da177e4SLinus Torvalds if(nondasd != -1) { 11481da177e4SLinus Torvalds dev->nondasd_support = (nondasd!=0); 11491da177e4SLinus Torvalds } 11501da177e4SLinus Torvalds if(dev->nondasd_support != 0){ 11511da177e4SLinus Torvalds printk(KERN_INFO "%s%d: Non-DASD support enabled.\n",dev->name, dev->id); 11521da177e4SLinus Torvalds } 11531da177e4SLinus Torvalds 11541da177e4SLinus Torvalds dev->dac_support = 0; 11551da177e4SLinus Torvalds if( (sizeof(dma_addr_t) > 4) && (dev->adapter_info.options & AAC_OPT_SGMAP_HOST64)){ 11561da177e4SLinus Torvalds printk(KERN_INFO "%s%d: 64bit support enabled.\n", dev->name, dev->id); 11571da177e4SLinus Torvalds dev->dac_support = 1; 11581da177e4SLinus Torvalds } 11591da177e4SLinus Torvalds 11601da177e4SLinus Torvalds if(dacmode != -1) { 11611da177e4SLinus Torvalds dev->dac_support = (dacmode!=0); 11621da177e4SLinus Torvalds } 11631da177e4SLinus Torvalds if(dev->dac_support != 0) { 116471e0f32fSJames Bottomley if (!pci_set_dma_mask(dev->pdev, DMA_64BIT_MASK) && 116571e0f32fSJames Bottomley !pci_set_consistent_dma_mask(dev->pdev, DMA_64BIT_MASK)) { 11661da177e4SLinus Torvalds printk(KERN_INFO"%s%d: 64 Bit DAC enabled\n", 11671da177e4SLinus Torvalds dev->name, dev->id); 116871e0f32fSJames Bottomley } else if (!pci_set_dma_mask(dev->pdev, DMA_32BIT_MASK) && 116971e0f32fSJames Bottomley !pci_set_consistent_dma_mask(dev->pdev, DMA_32BIT_MASK)) { 11701da177e4SLinus Torvalds printk(KERN_INFO"%s%d: DMA mask set failed, 64 Bit DAC disabled\n", 11711da177e4SLinus Torvalds dev->name, dev->id); 11721da177e4SLinus Torvalds dev->dac_support = 0; 11731da177e4SLinus Torvalds } else { 11741da177e4SLinus Torvalds printk(KERN_WARNING"%s%d: No suitable DMA available.\n", 11751da177e4SLinus Torvalds dev->name, dev->id); 11761da177e4SLinus Torvalds rcode = -ENOMEM; 11771da177e4SLinus Torvalds } 11781da177e4SLinus Torvalds } 11797c00ffa3SMark Haverkamp /* 1180e8f32de5SMark Haverkamp * Deal with configuring for the individualized limits of each packet 1181e8f32de5SMark Haverkamp * interface. 11827c00ffa3SMark Haverkamp */ 1183e8f32de5SMark Haverkamp dev->a_ops.adapter_scsi = (dev->dac_support) 1184e8f32de5SMark Haverkamp ? aac_scsi_64 1185e8f32de5SMark Haverkamp : aac_scsi_32; 1186e8f32de5SMark Haverkamp if (dev->raw_io_interface) { 1187e8f32de5SMark Haverkamp dev->a_ops.adapter_bounds = (dev->raw_io_64) 1188e8f32de5SMark Haverkamp ? aac_bounds_64 1189e8f32de5SMark Haverkamp : aac_bounds_32; 1190e8f32de5SMark Haverkamp dev->a_ops.adapter_read = aac_read_raw_io; 1191e8f32de5SMark Haverkamp dev->a_ops.adapter_write = aac_write_raw_io; 1192e8f32de5SMark Haverkamp } else { 1193e8f32de5SMark Haverkamp dev->a_ops.adapter_bounds = aac_bounds_32; 11947c00ffa3SMark Haverkamp dev->scsi_host_ptr->sg_tablesize = (dev->max_fib_size - 11957c00ffa3SMark Haverkamp sizeof(struct aac_fibhdr) - 119663a70eeaSMark Haverkamp sizeof(struct aac_write) + sizeof(struct sgentry)) / 119763a70eeaSMark Haverkamp sizeof(struct sgentry); 11987c00ffa3SMark Haverkamp if (dev->dac_support) { 1199e8f32de5SMark Haverkamp dev->a_ops.adapter_read = aac_read_block64; 1200e8f32de5SMark Haverkamp dev->a_ops.adapter_write = aac_write_block64; 12017c00ffa3SMark Haverkamp /* 12027c00ffa3SMark Haverkamp * 38 scatter gather elements 12037c00ffa3SMark Haverkamp */ 12047c00ffa3SMark Haverkamp dev->scsi_host_ptr->sg_tablesize = 12057c00ffa3SMark Haverkamp (dev->max_fib_size - 12067c00ffa3SMark Haverkamp sizeof(struct aac_fibhdr) - 12077c00ffa3SMark Haverkamp sizeof(struct aac_write64) + 120863a70eeaSMark Haverkamp sizeof(struct sgentry64)) / 120963a70eeaSMark Haverkamp sizeof(struct sgentry64); 1210e8f32de5SMark Haverkamp } else { 1211e8f32de5SMark Haverkamp dev->a_ops.adapter_read = aac_read_block; 1212e8f32de5SMark Haverkamp dev->a_ops.adapter_write = aac_write_block; 12137c00ffa3SMark Haverkamp } 12147c00ffa3SMark Haverkamp dev->scsi_host_ptr->max_sectors = AAC_MAX_32BIT_SGBCOUNT; 12157c00ffa3SMark Haverkamp if(!(dev->adapter_info.options & AAC_OPT_NEW_COMM)) { 12167c00ffa3SMark Haverkamp /* 12177c00ffa3SMark Haverkamp * Worst case size that could cause sg overflow when 12187c00ffa3SMark Haverkamp * we break up SG elements that are larger than 64KB. 12197c00ffa3SMark Haverkamp * Would be nice if we could tell the SCSI layer what 12207c00ffa3SMark Haverkamp * the maximum SG element size can be. Worst case is 12217c00ffa3SMark Haverkamp * (sg_tablesize-1) 4KB elements with one 64KB 12227c00ffa3SMark Haverkamp * element. 12237c00ffa3SMark Haverkamp * 32bit -> 468 or 238KB 64bit -> 424 or 212KB 12247c00ffa3SMark Haverkamp */ 12257c00ffa3SMark Haverkamp dev->scsi_host_ptr->max_sectors = 12267c00ffa3SMark Haverkamp (dev->scsi_host_ptr->sg_tablesize * 8) + 112; 12277c00ffa3SMark Haverkamp } 12280e68c003SMark Haverkamp } 12291da177e4SLinus Torvalds 1230bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1231bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 12321da177e4SLinus Torvalds 12331da177e4SLinus Torvalds return rcode; 12341da177e4SLinus Torvalds } 12351da177e4SLinus Torvalds 12361da177e4SLinus Torvalds 1237e53cb35aSMark Haverkamp static void io_callback(void *context, struct fib * fibptr) 12381da177e4SLinus Torvalds { 12391da177e4SLinus Torvalds struct aac_dev *dev; 12401da177e4SLinus Torvalds struct aac_read_reply *readreply; 12411da177e4SLinus Torvalds struct scsi_cmnd *scsicmd; 12421da177e4SLinus Torvalds u32 cid; 12431da177e4SLinus Torvalds 12441da177e4SLinus Torvalds scsicmd = (struct scsi_cmnd *) context; 124577d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL; 12461da177e4SLinus Torvalds 12471da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 1248e5718774SMark Haverkamp cid = scmd_id(scsicmd); 12491da177e4SLinus Torvalds 12507a8cf29dSMark Haverkamp if (nblank(dprintk(x))) { 12517a8cf29dSMark Haverkamp u64 lba; 12527a8cf29dSMark Haverkamp switch (scsicmd->cmnd[0]) { 12537a8cf29dSMark Haverkamp case WRITE_6: 12547a8cf29dSMark Haverkamp case READ_6: 12557a8cf29dSMark Haverkamp lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | 12567a8cf29dSMark Haverkamp (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 12577a8cf29dSMark Haverkamp break; 12587a8cf29dSMark Haverkamp case WRITE_16: 12597a8cf29dSMark Haverkamp case READ_16: 12607a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 56) | 12617a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[3] << 48) | 12627a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[4] << 40) | 12637a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[5] << 32) | 12647a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[6] << 24) | 12657a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 12667a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 12677a8cf29dSMark Haverkamp break; 12687a8cf29dSMark Haverkamp case WRITE_12: 12697a8cf29dSMark Haverkamp case READ_12: 12707a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 12717a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 12727a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 12737a8cf29dSMark Haverkamp break; 12747a8cf29dSMark Haverkamp default: 12757a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 12767a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 12777a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 12787a8cf29dSMark Haverkamp break; 12797a8cf29dSMark Haverkamp } 12807a8cf29dSMark Haverkamp printk(KERN_DEBUG 12817a8cf29dSMark Haverkamp "io_callback[cpu %d]: lba = %llu, t = %ld.\n", 12827a8cf29dSMark Haverkamp smp_processor_id(), (unsigned long long)lba, jiffies); 12837a8cf29dSMark Haverkamp } 12841da177e4SLinus Torvalds 1285125e1874SEric Sesterhenn BUG_ON(fibptr == NULL); 12861da177e4SLinus Torvalds 12871da177e4SLinus Torvalds if(scsicmd->use_sg) 12881da177e4SLinus Torvalds pci_unmap_sg(dev->pdev, 12895d5ff44fSChristoph Hellwig (struct scatterlist *)scsicmd->request_buffer, 12901da177e4SLinus Torvalds scsicmd->use_sg, 12911da177e4SLinus Torvalds scsicmd->sc_data_direction); 12921da177e4SLinus Torvalds else if(scsicmd->request_bufflen) 12931da177e4SLinus Torvalds pci_unmap_single(dev->pdev, scsicmd->SCp.dma_handle, 12941da177e4SLinus Torvalds scsicmd->request_bufflen, 12951da177e4SLinus Torvalds scsicmd->sc_data_direction); 12961da177e4SLinus Torvalds readreply = (struct aac_read_reply *)fib_data(fibptr); 12971da177e4SLinus Torvalds if (le32_to_cpu(readreply->status) == ST_OK) 12981da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 12991da177e4SLinus Torvalds else { 13007c00ffa3SMark Haverkamp #ifdef AAC_DETAILED_STATUS_INFO 1301e53cb35aSMark Haverkamp printk(KERN_WARNING "io_callback: io failed, status = %d\n", 13021da177e4SLinus Torvalds le32_to_cpu(readreply->status)); 13037c00ffa3SMark Haverkamp #endif 13041da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 13051da177e4SLinus Torvalds set_sense((u8 *) &dev->fsa_dev[cid].sense_data, 13061da177e4SLinus Torvalds HARDWARE_ERROR, 13071da177e4SLinus Torvalds SENCODE_INTERNAL_TARGET_FAILURE, 13081da177e4SLinus Torvalds ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0, 13091da177e4SLinus Torvalds 0, 0); 13101da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 13111da177e4SLinus Torvalds (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(scsicmd->sense_buffer)) 13121da177e4SLinus Torvalds ? sizeof(scsicmd->sense_buffer) 13131da177e4SLinus Torvalds : sizeof(dev->fsa_dev[cid].sense_data)); 13141da177e4SLinus Torvalds } 1315bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1316bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 13171da177e4SLinus Torvalds 13188e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 13191da177e4SLinus Torvalds } 13201da177e4SLinus Torvalds 13214833869eSAdrian Bunk static int aac_read(struct scsi_cmnd * scsicmd, int cid) 13221da177e4SLinus Torvalds { 13237a8cf29dSMark Haverkamp u64 lba; 13241da177e4SLinus Torvalds u32 count; 13251da177e4SLinus Torvalds int status; 13261da177e4SLinus Torvalds struct aac_dev *dev; 13271da177e4SLinus Torvalds struct fib * cmd_fibcontext; 13281da177e4SLinus Torvalds 13291da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 13301da177e4SLinus Torvalds /* 13311da177e4SLinus Torvalds * Get block address and transfer length 13321da177e4SLinus Torvalds */ 13337a8cf29dSMark Haverkamp switch (scsicmd->cmnd[0]) { 13347a8cf29dSMark Haverkamp case READ_6: 13351da177e4SLinus Torvalds dprintk((KERN_DEBUG "aachba: received a read(6) command on id %d.\n", cid)); 13361da177e4SLinus Torvalds 13377a8cf29dSMark Haverkamp lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | 13387a8cf29dSMark Haverkamp (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 13391da177e4SLinus Torvalds count = scsicmd->cmnd[4]; 13401da177e4SLinus Torvalds 13411da177e4SLinus Torvalds if (count == 0) 13421da177e4SLinus Torvalds count = 256; 13437a8cf29dSMark Haverkamp break; 13447a8cf29dSMark Haverkamp case READ_16: 13457a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a read(16) command on id %d.\n", cid)); 13467a8cf29dSMark Haverkamp 13477a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 56) | 13487a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[3] << 48) | 13497a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[4] << 40) | 13507a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[5] << 32) | 13517a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[6] << 24) | 13527a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 13537a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 13547a8cf29dSMark Haverkamp count = (scsicmd->cmnd[10] << 24) | 13557a8cf29dSMark Haverkamp (scsicmd->cmnd[11] << 16) | 13567a8cf29dSMark Haverkamp (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13]; 13577a8cf29dSMark Haverkamp break; 13587a8cf29dSMark Haverkamp case READ_12: 13597a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a read(12) command on id %d.\n", cid)); 13607a8cf29dSMark Haverkamp 13617a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 13627a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 13637a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 13647a8cf29dSMark Haverkamp count = (scsicmd->cmnd[6] << 24) | 13657a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 13667a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 13677a8cf29dSMark Haverkamp break; 13687a8cf29dSMark Haverkamp default: 13691da177e4SLinus Torvalds dprintk((KERN_DEBUG "aachba: received a read(10) command on id %d.\n", cid)); 13701da177e4SLinus Torvalds 13717a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | 13727a8cf29dSMark Haverkamp (scsicmd->cmnd[3] << 16) | 13737a8cf29dSMark Haverkamp (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 13741da177e4SLinus Torvalds count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 13757a8cf29dSMark Haverkamp break; 13761da177e4SLinus Torvalds } 13777a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aac_read[cpu %d]: lba = %llu, t = %ld.\n", 13787c00ffa3SMark Haverkamp smp_processor_id(), (unsigned long long)lba, jiffies)); 1379e8f32de5SMark Haverkamp if (aac_adapter_bounds(dev,scsicmd,lba)) 13807a8cf29dSMark Haverkamp return 0; 13811da177e4SLinus Torvalds /* 13821da177e4SLinus Torvalds * Alocate and initialize a Fib 13831da177e4SLinus Torvalds */ 1384bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) { 13851da177e4SLinus Torvalds return -1; 13861da177e4SLinus Torvalds } 13871da177e4SLinus Torvalds 1388e8f32de5SMark Haverkamp status = aac_adapter_read(cmd_fibcontext, scsicmd, lba, count); 13891da177e4SLinus Torvalds 13901da177e4SLinus Torvalds /* 13911da177e4SLinus Torvalds * Check that the command queued to the controller 13921da177e4SLinus Torvalds */ 139377d644d4SMark Haverkamp if (status == -EINPROGRESS) { 139477d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 13951da177e4SLinus Torvalds return 0; 139677d644d4SMark Haverkamp } 13971da177e4SLinus Torvalds 1398bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_read: aac_fib_send failed with status: %d.\n", status); 13991da177e4SLinus Torvalds /* 14001da177e4SLinus Torvalds * For some reason, the Fib didn't queue, return QUEUE_FULL 14011da177e4SLinus Torvalds */ 14021da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL; 14038e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 1404bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 1405bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 14061da177e4SLinus Torvalds return 0; 14071da177e4SLinus Torvalds } 14081da177e4SLinus Torvalds 14091da177e4SLinus Torvalds static int aac_write(struct scsi_cmnd * scsicmd, int cid) 14101da177e4SLinus Torvalds { 14117a8cf29dSMark Haverkamp u64 lba; 14121da177e4SLinus Torvalds u32 count; 14131da177e4SLinus Torvalds int status; 14141da177e4SLinus Torvalds struct aac_dev *dev; 14151da177e4SLinus Torvalds struct fib * cmd_fibcontext; 14161da177e4SLinus Torvalds 14171da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 14181da177e4SLinus Torvalds /* 14191da177e4SLinus Torvalds * Get block address and transfer length 14201da177e4SLinus Torvalds */ 14211da177e4SLinus Torvalds if (scsicmd->cmnd[0] == WRITE_6) /* 6 byte command */ 14221da177e4SLinus Torvalds { 14231da177e4SLinus Torvalds lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 14241da177e4SLinus Torvalds count = scsicmd->cmnd[4]; 14251da177e4SLinus Torvalds if (count == 0) 14261da177e4SLinus Torvalds count = 256; 14277a8cf29dSMark Haverkamp } else if (scsicmd->cmnd[0] == WRITE_16) { /* 16 byte command */ 14287a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a write(16) command on id %d.\n", cid)); 14297a8cf29dSMark Haverkamp 14307a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 56) | 14317a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[3] << 48) | 14327a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[4] << 40) | 14337a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[5] << 32) | 14347a8cf29dSMark Haverkamp ((u64)scsicmd->cmnd[6] << 24) | 14357a8cf29dSMark Haverkamp (scsicmd->cmnd[7] << 16) | 14367a8cf29dSMark Haverkamp (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 14377a8cf29dSMark Haverkamp count = (scsicmd->cmnd[10] << 24) | (scsicmd->cmnd[11] << 16) | 14387a8cf29dSMark Haverkamp (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13]; 14397a8cf29dSMark Haverkamp } else if (scsicmd->cmnd[0] == WRITE_12) { /* 12 byte command */ 14407a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aachba: received a write(12) command on id %d.\n", cid)); 14417a8cf29dSMark Haverkamp 14427a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) 14437a8cf29dSMark Haverkamp | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 14447a8cf29dSMark Haverkamp count = (scsicmd->cmnd[6] << 24) | (scsicmd->cmnd[7] << 16) 14457a8cf29dSMark Haverkamp | (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 14461da177e4SLinus Torvalds } else { 14471da177e4SLinus Torvalds dprintk((KERN_DEBUG "aachba: received a write(10) command on id %d.\n", cid)); 14487a8cf29dSMark Haverkamp lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 14491da177e4SLinus Torvalds count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 14501da177e4SLinus Torvalds } 14517a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "aac_write[cpu %d]: lba = %llu, t = %ld.\n", 14521da177e4SLinus Torvalds smp_processor_id(), (unsigned long long)lba, jiffies)); 1453e8f32de5SMark Haverkamp if (aac_adapter_bounds(dev,scsicmd,lba)) 14547a8cf29dSMark Haverkamp return 0; 14551da177e4SLinus Torvalds /* 14561da177e4SLinus Torvalds * Allocate and initialize a Fib then setup a BlockWrite command 14571da177e4SLinus Torvalds */ 1458bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) { 14591da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16; 14608e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 14611da177e4SLinus Torvalds return 0; 14621da177e4SLinus Torvalds } 14631da177e4SLinus Torvalds 1464e8f32de5SMark Haverkamp status = aac_adapter_write(cmd_fibcontext, scsicmd, lba, count); 14651da177e4SLinus Torvalds 14661da177e4SLinus Torvalds /* 14671da177e4SLinus Torvalds * Check that the command queued to the controller 14681da177e4SLinus Torvalds */ 146977d644d4SMark Haverkamp if (status == -EINPROGRESS) { 147077d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 14711da177e4SLinus Torvalds return 0; 14721da177e4SLinus Torvalds } 14731da177e4SLinus Torvalds 1474bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_write: aac_fib_send failed with status: %d\n", status); 14751da177e4SLinus Torvalds /* 14761da177e4SLinus Torvalds * For some reason, the Fib didn't queue, return QUEUE_FULL 14771da177e4SLinus Torvalds */ 14781da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL; 14798e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 14801da177e4SLinus Torvalds 1481bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 1482bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 14831da177e4SLinus Torvalds return 0; 14841da177e4SLinus Torvalds } 14851da177e4SLinus Torvalds 14861da177e4SLinus Torvalds static void synchronize_callback(void *context, struct fib *fibptr) 14871da177e4SLinus Torvalds { 14881da177e4SLinus Torvalds struct aac_synchronize_reply *synchronizereply; 14891da177e4SLinus Torvalds struct scsi_cmnd *cmd; 14901da177e4SLinus Torvalds 14911da177e4SLinus Torvalds cmd = context; 149277d644d4SMark Haverkamp cmd->SCp.phase = AAC_OWNER_MIDLEVEL; 14931da177e4SLinus Torvalds 14941da177e4SLinus Torvalds dprintk((KERN_DEBUG "synchronize_callback[cpu %d]: t = %ld.\n", 14951da177e4SLinus Torvalds smp_processor_id(), jiffies)); 14961da177e4SLinus Torvalds BUG_ON(fibptr == NULL); 14971da177e4SLinus Torvalds 14981da177e4SLinus Torvalds 14991da177e4SLinus Torvalds synchronizereply = fib_data(fibptr); 15001da177e4SLinus Torvalds if (le32_to_cpu(synchronizereply->status) == CT_OK) 15011da177e4SLinus Torvalds cmd->result = DID_OK << 16 | 15021da177e4SLinus Torvalds COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 15031da177e4SLinus Torvalds else { 15041da177e4SLinus Torvalds struct scsi_device *sdev = cmd->device; 15051da177e4SLinus Torvalds struct aac_dev *dev = (struct aac_dev *)sdev->host->hostdata; 1506e5718774SMark Haverkamp u32 cid = sdev_id(sdev); 15071da177e4SLinus Torvalds printk(KERN_WARNING 15081da177e4SLinus Torvalds "synchronize_callback: synchronize failed, status = %d\n", 15091da177e4SLinus Torvalds le32_to_cpu(synchronizereply->status)); 15101da177e4SLinus Torvalds cmd->result = DID_OK << 16 | 15111da177e4SLinus Torvalds COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 15121da177e4SLinus Torvalds set_sense((u8 *)&dev->fsa_dev[cid].sense_data, 15131da177e4SLinus Torvalds HARDWARE_ERROR, 15141da177e4SLinus Torvalds SENCODE_INTERNAL_TARGET_FAILURE, 15151da177e4SLinus Torvalds ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0, 15161da177e4SLinus Torvalds 0, 0); 15171da177e4SLinus Torvalds memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 15181da177e4SLinus Torvalds min(sizeof(dev->fsa_dev[cid].sense_data), 15191da177e4SLinus Torvalds sizeof(cmd->sense_buffer))); 15201da177e4SLinus Torvalds } 15211da177e4SLinus Torvalds 1522bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 1523bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 15248e0c5ebdSMark Haverkamp cmd->scsi_done(cmd); 15251da177e4SLinus Torvalds } 15261da177e4SLinus Torvalds 15271da177e4SLinus Torvalds static int aac_synchronize(struct scsi_cmnd *scsicmd, int cid) 15281da177e4SLinus Torvalds { 15291da177e4SLinus Torvalds int status; 15301da177e4SLinus Torvalds struct fib *cmd_fibcontext; 15311da177e4SLinus Torvalds struct aac_synchronize *synchronizecmd; 15321da177e4SLinus Torvalds struct scsi_cmnd *cmd; 15331da177e4SLinus Torvalds struct scsi_device *sdev = scsicmd->device; 15341da177e4SLinus Torvalds int active = 0; 153590ee3466SMark Haverkamp struct aac_dev *aac; 15361da177e4SLinus Torvalds unsigned long flags; 15371da177e4SLinus Torvalds 15381da177e4SLinus Torvalds /* 153977d644d4SMark Haverkamp * Wait for all outstanding queued commands to complete to this 154077d644d4SMark Haverkamp * specific target (block). 15411da177e4SLinus Torvalds */ 15421da177e4SLinus Torvalds spin_lock_irqsave(&sdev->list_lock, flags); 15431da177e4SLinus Torvalds list_for_each_entry(cmd, &sdev->cmd_list, list) 154477d644d4SMark Haverkamp if (cmd != scsicmd && cmd->SCp.phase == AAC_OWNER_FIRMWARE) { 15451da177e4SLinus Torvalds ++active; 15461da177e4SLinus Torvalds break; 15471da177e4SLinus Torvalds } 15481da177e4SLinus Torvalds 15491da177e4SLinus Torvalds spin_unlock_irqrestore(&sdev->list_lock, flags); 15501da177e4SLinus Torvalds 15511da177e4SLinus Torvalds /* 15521da177e4SLinus Torvalds * Yield the processor (requeue for later) 15531da177e4SLinus Torvalds */ 15541da177e4SLinus Torvalds if (active) 15551da177e4SLinus Torvalds return SCSI_MLQUEUE_DEVICE_BUSY; 15561da177e4SLinus Torvalds 155790ee3466SMark Haverkamp aac = (struct aac_dev *)scsicmd->device->host->hostdata; 15588c867b25SMark Haverkamp if (aac->in_reset) 15598c867b25SMark Haverkamp return SCSI_MLQUEUE_HOST_BUSY; 15608c867b25SMark Haverkamp 15611da177e4SLinus Torvalds /* 15627c00ffa3SMark Haverkamp * Allocate and initialize a Fib 15631da177e4SLinus Torvalds */ 156490ee3466SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(aac))) 15651da177e4SLinus Torvalds return SCSI_MLQUEUE_HOST_BUSY; 15661da177e4SLinus Torvalds 1567bfb35aa8SMark Haverkamp aac_fib_init(cmd_fibcontext); 15681da177e4SLinus Torvalds 15691da177e4SLinus Torvalds synchronizecmd = fib_data(cmd_fibcontext); 15701da177e4SLinus Torvalds synchronizecmd->command = cpu_to_le32(VM_ContainerConfig); 15711da177e4SLinus Torvalds synchronizecmd->type = cpu_to_le32(CT_FLUSH_CACHE); 15721da177e4SLinus Torvalds synchronizecmd->cid = cpu_to_le32(cid); 15731da177e4SLinus Torvalds synchronizecmd->count = 15741da177e4SLinus Torvalds cpu_to_le32(sizeof(((struct aac_synchronize_reply *)NULL)->data)); 15751da177e4SLinus Torvalds 15761da177e4SLinus Torvalds /* 15771da177e4SLinus Torvalds * Now send the Fib to the adapter 15781da177e4SLinus Torvalds */ 1579bfb35aa8SMark Haverkamp status = aac_fib_send(ContainerCommand, 15801da177e4SLinus Torvalds cmd_fibcontext, 15811da177e4SLinus Torvalds sizeof(struct aac_synchronize), 15821da177e4SLinus Torvalds FsaNormal, 15831da177e4SLinus Torvalds 0, 1, 15841da177e4SLinus Torvalds (fib_callback)synchronize_callback, 15851da177e4SLinus Torvalds (void *)scsicmd); 15861da177e4SLinus Torvalds 15871da177e4SLinus Torvalds /* 15881da177e4SLinus Torvalds * Check that the command queued to the controller 15891da177e4SLinus Torvalds */ 159077d644d4SMark Haverkamp if (status == -EINPROGRESS) { 159177d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 15921da177e4SLinus Torvalds return 0; 159377d644d4SMark Haverkamp } 15941da177e4SLinus Torvalds 15951da177e4SLinus Torvalds printk(KERN_WARNING 1596bfb35aa8SMark Haverkamp "aac_synchronize: aac_fib_send failed with status: %d.\n", status); 1597bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 1598bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 15991da177e4SLinus Torvalds return SCSI_MLQUEUE_HOST_BUSY; 16001da177e4SLinus Torvalds } 16011da177e4SLinus Torvalds 16021da177e4SLinus Torvalds /** 16031da177e4SLinus Torvalds * aac_scsi_cmd() - Process SCSI command 16041da177e4SLinus Torvalds * @scsicmd: SCSI command block 16051da177e4SLinus Torvalds * 16061da177e4SLinus Torvalds * Emulate a SCSI command and queue the required request for the 16071da177e4SLinus Torvalds * aacraid firmware. 16081da177e4SLinus Torvalds */ 16091da177e4SLinus Torvalds 16101da177e4SLinus Torvalds int aac_scsi_cmd(struct scsi_cmnd * scsicmd) 16111da177e4SLinus Torvalds { 16121da177e4SLinus Torvalds u32 cid = 0; 16131da177e4SLinus Torvalds struct Scsi_Host *host = scsicmd->device->host; 16141da177e4SLinus Torvalds struct aac_dev *dev = (struct aac_dev *)host->hostdata; 16151da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr = dev->fsa_dev; 16161da177e4SLinus Torvalds 161790ee3466SMark Haverkamp if (fsa_dev_ptr == NULL) 161890ee3466SMark Haverkamp return -1; 16191da177e4SLinus Torvalds /* 16201da177e4SLinus Torvalds * If the bus, id or lun is out of range, return fail 16211da177e4SLinus Torvalds * Test does not apply to ID 16, the pseudo id for the controller 16221da177e4SLinus Torvalds * itself. 16231da177e4SLinus Torvalds */ 1624422c0d61SJeff Garzik if (scmd_id(scsicmd) != host->this_id) { 1625e5718774SMark Haverkamp if ((scmd_channel(scsicmd) == CONTAINER_CHANNEL)) { 1626e5718774SMark Haverkamp if((scmd_id(scsicmd) >= dev->maximum_num_containers) || 1627e5718774SMark Haverkamp (scsicmd->device->lun != 0)) { 16281da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16; 16291da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 16301da177e4SLinus Torvalds return 0; 16311da177e4SLinus Torvalds } 1632e5718774SMark Haverkamp cid = scmd_id(scsicmd); 16331da177e4SLinus Torvalds 16341da177e4SLinus Torvalds /* 16351da177e4SLinus Torvalds * If the target container doesn't exist, it may have 16361da177e4SLinus Torvalds * been newly created 16371da177e4SLinus Torvalds */ 16381da177e4SLinus Torvalds if ((fsa_dev_ptr[cid].valid & 1) == 0) { 16391da177e4SLinus Torvalds switch (scsicmd->cmnd[0]) { 16407a8cf29dSMark Haverkamp case SERVICE_ACTION_IN: 16417a8cf29dSMark Haverkamp if (!(dev->raw_io_interface) || 16427a8cf29dSMark Haverkamp !(dev->raw_io_64) || 16437a8cf29dSMark Haverkamp ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16)) 16447a8cf29dSMark Haverkamp break; 16451da177e4SLinus Torvalds case INQUIRY: 16461da177e4SLinus Torvalds case READ_CAPACITY: 16471da177e4SLinus Torvalds case TEST_UNIT_READY: 16488c867b25SMark Haverkamp if (dev->in_reset) 16498c867b25SMark Haverkamp return -1; 16501da177e4SLinus Torvalds spin_unlock_irq(host->host_lock); 1651bfb35aa8SMark Haverkamp aac_probe_container(dev, cid); 1652131256cfSMark Haverkamp if ((fsa_dev_ptr[cid].valid & 1) == 0) 1653131256cfSMark Haverkamp fsa_dev_ptr[cid].valid = 0; 16541da177e4SLinus Torvalds spin_lock_irq(host->host_lock); 16551da177e4SLinus Torvalds if (fsa_dev_ptr[cid].valid == 0) { 16561da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16; 16571da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 16581da177e4SLinus Torvalds return 0; 16591da177e4SLinus Torvalds } 16601da177e4SLinus Torvalds default: 16611da177e4SLinus Torvalds break; 16621da177e4SLinus Torvalds } 16631da177e4SLinus Torvalds } 16641da177e4SLinus Torvalds /* 16651da177e4SLinus Torvalds * If the target container still doesn't exist, 16661da177e4SLinus Torvalds * return failure 16671da177e4SLinus Torvalds */ 16681da177e4SLinus Torvalds if (fsa_dev_ptr[cid].valid == 0) { 16691da177e4SLinus Torvalds scsicmd->result = DID_BAD_TARGET << 16; 16701da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 16711da177e4SLinus Torvalds return 0; 16721da177e4SLinus Torvalds } 16731da177e4SLinus Torvalds } else { /* check for physical non-dasd devices */ 1674653ba58dSMark Haverkamp if ((dev->nondasd_support == 1) || expose_physicals) { 16758c867b25SMark Haverkamp if (dev->in_reset) 16768c867b25SMark Haverkamp return -1; 16771da177e4SLinus Torvalds return aac_send_srb_fib(scsicmd); 16781da177e4SLinus Torvalds } else { 16791da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16; 16801da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 16811da177e4SLinus Torvalds return 0; 16821da177e4SLinus Torvalds } 16831da177e4SLinus Torvalds } 16841da177e4SLinus Torvalds } 16851da177e4SLinus Torvalds /* 16861da177e4SLinus Torvalds * else Command for the controller itself 16871da177e4SLinus Torvalds */ 16881da177e4SLinus Torvalds else if ((scsicmd->cmnd[0] != INQUIRY) && /* only INQUIRY & TUR cmnd supported for controller */ 16891da177e4SLinus Torvalds (scsicmd->cmnd[0] != TEST_UNIT_READY)) 16901da177e4SLinus Torvalds { 16911da177e4SLinus Torvalds dprintk((KERN_WARNING "Only INQUIRY & TUR command supported for controller, rcvd = 0x%x.\n", scsicmd->cmnd[0])); 16921da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 16931da177e4SLinus Torvalds set_sense((u8 *) &dev->fsa_dev[cid].sense_data, 16941da177e4SLinus Torvalds ILLEGAL_REQUEST, 16951da177e4SLinus Torvalds SENCODE_INVALID_COMMAND, 16961da177e4SLinus Torvalds ASENCODE_INVALID_COMMAND, 0, 0, 0, 0); 16971da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 16981da177e4SLinus Torvalds (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(scsicmd->sense_buffer)) 16991da177e4SLinus Torvalds ? sizeof(scsicmd->sense_buffer) 17001da177e4SLinus Torvalds : sizeof(dev->fsa_dev[cid].sense_data)); 17011da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 17021da177e4SLinus Torvalds return 0; 17031da177e4SLinus Torvalds } 17041da177e4SLinus Torvalds 17051da177e4SLinus Torvalds 17061da177e4SLinus Torvalds /* Handle commands here that don't really require going out to the adapter */ 17071da177e4SLinus Torvalds switch (scsicmd->cmnd[0]) { 17081da177e4SLinus Torvalds case INQUIRY: 17091da177e4SLinus Torvalds { 17103b2946ccSMark Haverkamp struct inquiry_data inq_data; 17111da177e4SLinus Torvalds 1712e5718774SMark Haverkamp dprintk((KERN_DEBUG "INQUIRY command, ID: %d.\n", scmd_id(scsicmd))); 17133b2946ccSMark Haverkamp memset(&inq_data, 0, sizeof (struct inquiry_data)); 17141da177e4SLinus Torvalds 17153b2946ccSMark Haverkamp inq_data.inqd_ver = 2; /* claim compliance to SCSI-2 */ 17163b2946ccSMark 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 */ 17173b2946ccSMark Haverkamp inq_data.inqd_len = 31; 17181da177e4SLinus Torvalds /*Format for "pad2" is RelAdr | WBus32 | WBus16 | Sync | Linked |Reserved| CmdQue | SftRe */ 17193b2946ccSMark Haverkamp inq_data.inqd_pad2= 0x32 ; /*WBus16|Sync|CmdQue */ 17201da177e4SLinus Torvalds /* 17211da177e4SLinus Torvalds * Set the Vendor, Product, and Revision Level 17221da177e4SLinus Torvalds * see: <vendor>.c i.e. aac.c 17231da177e4SLinus Torvalds */ 1724422c0d61SJeff Garzik if (scmd_id(scsicmd) == host->this_id) { 17256391a113STobias Klauser setinqstr(dev, (void *) (inq_data.inqd_vid), ARRAY_SIZE(container_types)); 17263b2946ccSMark Haverkamp inq_data.inqd_pdt = INQD_PDT_PROC; /* Processor device */ 17273b2946ccSMark Haverkamp aac_internal_transfer(scsicmd, &inq_data, 0, sizeof(inq_data)); 17281da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 17291da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 17301da177e4SLinus Torvalds return 0; 17311da177e4SLinus Torvalds } 17328c867b25SMark Haverkamp if (dev->in_reset) 17338c867b25SMark Haverkamp return -1; 1734794d0601SMark Haverkamp setinqstr(dev, (void *) (inq_data.inqd_vid), fsa_dev_ptr[cid].type); 17353b2946ccSMark Haverkamp inq_data.inqd_pdt = INQD_PDT_DA; /* Direct/random access device */ 17363b2946ccSMark Haverkamp aac_internal_transfer(scsicmd, &inq_data, 0, sizeof(inq_data)); 17371da177e4SLinus Torvalds return aac_get_container_name(scsicmd, cid); 17381da177e4SLinus Torvalds } 17397a8cf29dSMark Haverkamp case SERVICE_ACTION_IN: 17407a8cf29dSMark Haverkamp if (!(dev->raw_io_interface) || 17417a8cf29dSMark Haverkamp !(dev->raw_io_64) || 17427a8cf29dSMark Haverkamp ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16)) 17437a8cf29dSMark Haverkamp break; 17447a8cf29dSMark Haverkamp { 17457a8cf29dSMark Haverkamp u64 capacity; 174607ce5ebaSMark Haverkamp char cp[13]; 17477a8cf29dSMark Haverkamp 17487a8cf29dSMark Haverkamp dprintk((KERN_DEBUG "READ CAPACITY_16 command.\n")); 17497a8cf29dSMark Haverkamp capacity = fsa_dev_ptr[cid].size - 1; 17507a8cf29dSMark Haverkamp cp[0] = (capacity >> 56) & 0xff; 17517a8cf29dSMark Haverkamp cp[1] = (capacity >> 48) & 0xff; 17527a8cf29dSMark Haverkamp cp[2] = (capacity >> 40) & 0xff; 17537a8cf29dSMark Haverkamp cp[3] = (capacity >> 32) & 0xff; 17547a8cf29dSMark Haverkamp cp[4] = (capacity >> 24) & 0xff; 17557a8cf29dSMark Haverkamp cp[5] = (capacity >> 16) & 0xff; 17567a8cf29dSMark Haverkamp cp[6] = (capacity >> 8) & 0xff; 17577a8cf29dSMark Haverkamp cp[7] = (capacity >> 0) & 0xff; 17587a8cf29dSMark Haverkamp cp[8] = 0; 17597a8cf29dSMark Haverkamp cp[9] = 0; 17607a8cf29dSMark Haverkamp cp[10] = 2; 17617a8cf29dSMark Haverkamp cp[11] = 0; 176207ce5ebaSMark Haverkamp cp[12] = 0; 176307ce5ebaSMark Haverkamp aac_internal_transfer(scsicmd, cp, 0, 17641241f359SMark Haverkamp min_t(size_t, scsicmd->cmnd[13], sizeof(cp))); 176507ce5ebaSMark Haverkamp if (sizeof(cp) < scsicmd->cmnd[13]) { 176607ce5ebaSMark Haverkamp unsigned int len, offset = sizeof(cp); 176707ce5ebaSMark Haverkamp 176807ce5ebaSMark Haverkamp memset(cp, 0, offset); 176907ce5ebaSMark Haverkamp do { 17701241f359SMark Haverkamp len = min_t(size_t, scsicmd->cmnd[13] - offset, 17711241f359SMark Haverkamp sizeof(cp)); 177207ce5ebaSMark Haverkamp aac_internal_transfer(scsicmd, cp, offset, len); 177307ce5ebaSMark Haverkamp } while ((offset += len) < scsicmd->cmnd[13]); 177407ce5ebaSMark Haverkamp } 17757a8cf29dSMark Haverkamp 17767a8cf29dSMark Haverkamp /* Do not cache partition table for arrays */ 17777a8cf29dSMark Haverkamp scsicmd->device->removable = 1; 17787a8cf29dSMark Haverkamp 17797a8cf29dSMark Haverkamp scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 17807a8cf29dSMark Haverkamp scsicmd->scsi_done(scsicmd); 17817a8cf29dSMark Haverkamp 17827a8cf29dSMark Haverkamp return 0; 17837a8cf29dSMark Haverkamp } 17847a8cf29dSMark Haverkamp 17851da177e4SLinus Torvalds case READ_CAPACITY: 17861da177e4SLinus Torvalds { 17871da177e4SLinus Torvalds u32 capacity; 17883b2946ccSMark Haverkamp char cp[8]; 17891da177e4SLinus Torvalds 17901da177e4SLinus Torvalds dprintk((KERN_DEBUG "READ CAPACITY command.\n")); 17917a8cf29dSMark Haverkamp if (fsa_dev_ptr[cid].size <= 0x100000000ULL) 17921da177e4SLinus Torvalds capacity = fsa_dev_ptr[cid].size - 1; 17931da177e4SLinus Torvalds else 17941da177e4SLinus Torvalds capacity = (u32)-1; 17953b2946ccSMark Haverkamp 17961da177e4SLinus Torvalds cp[0] = (capacity >> 24) & 0xff; 17971da177e4SLinus Torvalds cp[1] = (capacity >> 16) & 0xff; 17981da177e4SLinus Torvalds cp[2] = (capacity >> 8) & 0xff; 17991da177e4SLinus Torvalds cp[3] = (capacity >> 0) & 0xff; 18001da177e4SLinus Torvalds cp[4] = 0; 18011da177e4SLinus Torvalds cp[5] = 0; 18021da177e4SLinus Torvalds cp[6] = 2; 18031da177e4SLinus Torvalds cp[7] = 0; 18043b2946ccSMark Haverkamp aac_internal_transfer(scsicmd, cp, 0, sizeof(cp)); 18057a8cf29dSMark Haverkamp /* Do not cache partition table for arrays */ 18067a8cf29dSMark Haverkamp scsicmd->device->removable = 1; 18071da177e4SLinus Torvalds 18081da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 18091da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 18101da177e4SLinus Torvalds 18111da177e4SLinus Torvalds return 0; 18121da177e4SLinus Torvalds } 18131da177e4SLinus Torvalds 18141da177e4SLinus Torvalds case MODE_SENSE: 18151da177e4SLinus Torvalds { 18163b2946ccSMark Haverkamp char mode_buf[4]; 18171da177e4SLinus Torvalds 18181da177e4SLinus Torvalds dprintk((KERN_DEBUG "MODE SENSE command.\n")); 18191da177e4SLinus Torvalds mode_buf[0] = 3; /* Mode data length */ 18201da177e4SLinus Torvalds mode_buf[1] = 0; /* Medium type - default */ 18211da177e4SLinus Torvalds mode_buf[2] = 0; /* Device-specific param, bit 8: 0/1 = write enabled/protected */ 18221da177e4SLinus Torvalds mode_buf[3] = 0; /* Block descriptor length */ 18231da177e4SLinus Torvalds 18243b2946ccSMark Haverkamp aac_internal_transfer(scsicmd, mode_buf, 0, sizeof(mode_buf)); 18251da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 18261da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 18271da177e4SLinus Torvalds 18281da177e4SLinus Torvalds return 0; 18291da177e4SLinus Torvalds } 18301da177e4SLinus Torvalds case MODE_SENSE_10: 18311da177e4SLinus Torvalds { 18323b2946ccSMark Haverkamp char mode_buf[8]; 18331da177e4SLinus Torvalds 18341da177e4SLinus Torvalds dprintk((KERN_DEBUG "MODE SENSE 10 byte command.\n")); 18351da177e4SLinus Torvalds mode_buf[0] = 0; /* Mode data length (MSB) */ 18361da177e4SLinus Torvalds mode_buf[1] = 6; /* Mode data length (LSB) */ 18371da177e4SLinus Torvalds mode_buf[2] = 0; /* Medium type - default */ 18381da177e4SLinus Torvalds mode_buf[3] = 0; /* Device-specific param, bit 8: 0/1 = write enabled/protected */ 18391da177e4SLinus Torvalds mode_buf[4] = 0; /* reserved */ 18401da177e4SLinus Torvalds mode_buf[5] = 0; /* reserved */ 18411da177e4SLinus Torvalds mode_buf[6] = 0; /* Block descriptor length (MSB) */ 18421da177e4SLinus Torvalds mode_buf[7] = 0; /* Block descriptor length (LSB) */ 18433b2946ccSMark Haverkamp aac_internal_transfer(scsicmd, mode_buf, 0, sizeof(mode_buf)); 18441da177e4SLinus Torvalds 18451da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 18461da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 18471da177e4SLinus Torvalds 18481da177e4SLinus Torvalds return 0; 18491da177e4SLinus Torvalds } 18501da177e4SLinus Torvalds case REQUEST_SENSE: 18511da177e4SLinus Torvalds dprintk((KERN_DEBUG "REQUEST SENSE command.\n")); 18521da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, sizeof (struct sense_data)); 18531da177e4SLinus Torvalds memset(&dev->fsa_dev[cid].sense_data, 0, sizeof (struct sense_data)); 18541da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 18551da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 18561da177e4SLinus Torvalds return 0; 18571da177e4SLinus Torvalds 18581da177e4SLinus Torvalds case ALLOW_MEDIUM_REMOVAL: 18591da177e4SLinus Torvalds dprintk((KERN_DEBUG "LOCK command.\n")); 18601da177e4SLinus Torvalds if (scsicmd->cmnd[4]) 18611da177e4SLinus Torvalds fsa_dev_ptr[cid].locked = 1; 18621da177e4SLinus Torvalds else 18631da177e4SLinus Torvalds fsa_dev_ptr[cid].locked = 0; 18641da177e4SLinus Torvalds 18651da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 18661da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 18671da177e4SLinus Torvalds return 0; 18681da177e4SLinus Torvalds /* 18691da177e4SLinus Torvalds * These commands are all No-Ops 18701da177e4SLinus Torvalds */ 18711da177e4SLinus Torvalds case TEST_UNIT_READY: 18721da177e4SLinus Torvalds case RESERVE: 18731da177e4SLinus Torvalds case RELEASE: 18741da177e4SLinus Torvalds case REZERO_UNIT: 18751da177e4SLinus Torvalds case REASSIGN_BLOCKS: 18761da177e4SLinus Torvalds case SEEK_10: 18771da177e4SLinus Torvalds case START_STOP: 18781da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 18791da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 18801da177e4SLinus Torvalds return 0; 18811da177e4SLinus Torvalds } 18821da177e4SLinus Torvalds 18831da177e4SLinus Torvalds switch (scsicmd->cmnd[0]) 18841da177e4SLinus Torvalds { 18851da177e4SLinus Torvalds case READ_6: 18861da177e4SLinus Torvalds case READ_10: 18877a8cf29dSMark Haverkamp case READ_12: 18887a8cf29dSMark Haverkamp case READ_16: 18898c867b25SMark Haverkamp if (dev->in_reset) 18908c867b25SMark Haverkamp return -1; 18911da177e4SLinus Torvalds /* 18921da177e4SLinus Torvalds * Hack to keep track of ordinal number of the device that 18931da177e4SLinus Torvalds * corresponds to a container. Needed to convert 18941da177e4SLinus Torvalds * containers to /dev/sd device names 18951da177e4SLinus Torvalds */ 18961da177e4SLinus Torvalds 18971da177e4SLinus Torvalds if (scsicmd->request->rq_disk) 18987a8cf29dSMark Haverkamp strlcpy(fsa_dev_ptr[cid].devname, 18991da177e4SLinus Torvalds scsicmd->request->rq_disk->disk_name, 19007a8cf29dSMark Haverkamp min(sizeof(fsa_dev_ptr[cid].devname), 19017a8cf29dSMark Haverkamp sizeof(scsicmd->request->rq_disk->disk_name) + 1)); 190277d644d4SMark Haverkamp 190377d644d4SMark Haverkamp return aac_read(scsicmd, cid); 19041da177e4SLinus Torvalds 19051da177e4SLinus Torvalds case WRITE_6: 19061da177e4SLinus Torvalds case WRITE_10: 19077a8cf29dSMark Haverkamp case WRITE_12: 19087a8cf29dSMark Haverkamp case WRITE_16: 19098c867b25SMark Haverkamp if (dev->in_reset) 19108c867b25SMark Haverkamp return -1; 191177d644d4SMark Haverkamp return aac_write(scsicmd, cid); 19121da177e4SLinus Torvalds 19131da177e4SLinus Torvalds case SYNCHRONIZE_CACHE: 19141da177e4SLinus Torvalds /* Issue FIB to tell Firmware to flush it's cache */ 19151da177e4SLinus Torvalds return aac_synchronize(scsicmd, cid); 19161da177e4SLinus Torvalds 19171da177e4SLinus Torvalds default: 19181da177e4SLinus Torvalds /* 19191da177e4SLinus Torvalds * Unhandled commands 19201da177e4SLinus Torvalds */ 19217c00ffa3SMark Haverkamp dprintk((KERN_WARNING "Unhandled SCSI Command: 0x%x.\n", scsicmd->cmnd[0])); 19221da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 19231da177e4SLinus Torvalds set_sense((u8 *) &dev->fsa_dev[cid].sense_data, 19241da177e4SLinus Torvalds ILLEGAL_REQUEST, SENCODE_INVALID_COMMAND, 19251da177e4SLinus Torvalds ASENCODE_INVALID_COMMAND, 0, 0, 0, 0); 19261da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 19271da177e4SLinus Torvalds (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(scsicmd->sense_buffer)) 19281da177e4SLinus Torvalds ? sizeof(scsicmd->sense_buffer) 19291da177e4SLinus Torvalds : sizeof(dev->fsa_dev[cid].sense_data)); 19301da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 19311da177e4SLinus Torvalds return 0; 19321da177e4SLinus Torvalds } 19331da177e4SLinus Torvalds } 19341da177e4SLinus Torvalds 19351da177e4SLinus Torvalds static int query_disk(struct aac_dev *dev, void __user *arg) 19361da177e4SLinus Torvalds { 19371da177e4SLinus Torvalds struct aac_query_disk qd; 19381da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 19391da177e4SLinus Torvalds 19401da177e4SLinus Torvalds fsa_dev_ptr = dev->fsa_dev; 194190ee3466SMark Haverkamp if (!fsa_dev_ptr) 194265101355SMark Haverkamp return -EBUSY; 19431da177e4SLinus Torvalds if (copy_from_user(&qd, arg, sizeof (struct aac_query_disk))) 19441da177e4SLinus Torvalds return -EFAULT; 19451da177e4SLinus Torvalds if (qd.cnum == -1) 1946e5718774SMark Haverkamp qd.cnum = qd.id; 19471da177e4SLinus Torvalds else if ((qd.bus == -1) && (qd.id == -1) && (qd.lun == -1)) 19481da177e4SLinus Torvalds { 19491da177e4SLinus Torvalds if (qd.cnum < 0 || qd.cnum >= dev->maximum_num_containers) 19501da177e4SLinus Torvalds return -EINVAL; 19511da177e4SLinus Torvalds qd.instance = dev->scsi_host_ptr->host_no; 19521da177e4SLinus Torvalds qd.bus = 0; 19531da177e4SLinus Torvalds qd.id = CONTAINER_TO_ID(qd.cnum); 19541da177e4SLinus Torvalds qd.lun = CONTAINER_TO_LUN(qd.cnum); 19551da177e4SLinus Torvalds } 19561da177e4SLinus Torvalds else return -EINVAL; 19571da177e4SLinus Torvalds 19581da177e4SLinus Torvalds qd.valid = fsa_dev_ptr[qd.cnum].valid; 19591da177e4SLinus Torvalds qd.locked = fsa_dev_ptr[qd.cnum].locked; 19601da177e4SLinus Torvalds qd.deleted = fsa_dev_ptr[qd.cnum].deleted; 19611da177e4SLinus Torvalds 19621da177e4SLinus Torvalds if (fsa_dev_ptr[qd.cnum].devname[0] == '\0') 19631da177e4SLinus Torvalds qd.unmapped = 1; 19641da177e4SLinus Torvalds else 19651da177e4SLinus Torvalds qd.unmapped = 0; 19661da177e4SLinus Torvalds 19671da177e4SLinus Torvalds strlcpy(qd.name, fsa_dev_ptr[qd.cnum].devname, 19681da177e4SLinus Torvalds min(sizeof(qd.name), sizeof(fsa_dev_ptr[qd.cnum].devname) + 1)); 19691da177e4SLinus Torvalds 19701da177e4SLinus Torvalds if (copy_to_user(arg, &qd, sizeof (struct aac_query_disk))) 19711da177e4SLinus Torvalds return -EFAULT; 19721da177e4SLinus Torvalds return 0; 19731da177e4SLinus Torvalds } 19741da177e4SLinus Torvalds 19751da177e4SLinus Torvalds static int force_delete_disk(struct aac_dev *dev, void __user *arg) 19761da177e4SLinus Torvalds { 19771da177e4SLinus Torvalds struct aac_delete_disk dd; 19781da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 19791da177e4SLinus Torvalds 19801da177e4SLinus Torvalds fsa_dev_ptr = dev->fsa_dev; 198165101355SMark Haverkamp if (!fsa_dev_ptr) 198265101355SMark Haverkamp return -EBUSY; 19831da177e4SLinus Torvalds 19841da177e4SLinus Torvalds if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk))) 19851da177e4SLinus Torvalds return -EFAULT; 19861da177e4SLinus Torvalds 19871da177e4SLinus Torvalds if (dd.cnum >= dev->maximum_num_containers) 19881da177e4SLinus Torvalds return -EINVAL; 19891da177e4SLinus Torvalds /* 19901da177e4SLinus Torvalds * Mark this container as being deleted. 19911da177e4SLinus Torvalds */ 19921da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].deleted = 1; 19931da177e4SLinus Torvalds /* 19941da177e4SLinus Torvalds * Mark the container as no longer valid 19951da177e4SLinus Torvalds */ 19961da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].valid = 0; 19971da177e4SLinus Torvalds return 0; 19981da177e4SLinus Torvalds } 19991da177e4SLinus Torvalds 20001da177e4SLinus Torvalds static int delete_disk(struct aac_dev *dev, void __user *arg) 20011da177e4SLinus Torvalds { 20021da177e4SLinus Torvalds struct aac_delete_disk dd; 20031da177e4SLinus Torvalds struct fsa_dev_info *fsa_dev_ptr; 20041da177e4SLinus Torvalds 20051da177e4SLinus Torvalds fsa_dev_ptr = dev->fsa_dev; 200690ee3466SMark Haverkamp if (!fsa_dev_ptr) 200765101355SMark Haverkamp return -EBUSY; 20081da177e4SLinus Torvalds 20091da177e4SLinus Torvalds if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk))) 20101da177e4SLinus Torvalds return -EFAULT; 20111da177e4SLinus Torvalds 20121da177e4SLinus Torvalds if (dd.cnum >= dev->maximum_num_containers) 20131da177e4SLinus Torvalds return -EINVAL; 20141da177e4SLinus Torvalds /* 20151da177e4SLinus Torvalds * If the container is locked, it can not be deleted by the API. 20161da177e4SLinus Torvalds */ 20171da177e4SLinus Torvalds if (fsa_dev_ptr[dd.cnum].locked) 20181da177e4SLinus Torvalds return -EBUSY; 20191da177e4SLinus Torvalds else { 20201da177e4SLinus Torvalds /* 20211da177e4SLinus Torvalds * Mark the container as no longer being valid. 20221da177e4SLinus Torvalds */ 20231da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].valid = 0; 20241da177e4SLinus Torvalds fsa_dev_ptr[dd.cnum].devname[0] = '\0'; 20251da177e4SLinus Torvalds return 0; 20261da177e4SLinus Torvalds } 20271da177e4SLinus Torvalds } 20281da177e4SLinus Torvalds 20291da177e4SLinus Torvalds int aac_dev_ioctl(struct aac_dev *dev, int cmd, void __user *arg) 20301da177e4SLinus Torvalds { 20311da177e4SLinus Torvalds switch (cmd) { 20321da177e4SLinus Torvalds case FSACTL_QUERY_DISK: 20331da177e4SLinus Torvalds return query_disk(dev, arg); 20341da177e4SLinus Torvalds case FSACTL_DELETE_DISK: 20351da177e4SLinus Torvalds return delete_disk(dev, arg); 20361da177e4SLinus Torvalds case FSACTL_FORCE_DELETE_DISK: 20371da177e4SLinus Torvalds return force_delete_disk(dev, arg); 20381da177e4SLinus Torvalds case FSACTL_GET_CONTAINERS: 20391da177e4SLinus Torvalds return aac_get_containers(dev); 20401da177e4SLinus Torvalds default: 20411da177e4SLinus Torvalds return -ENOTTY; 20421da177e4SLinus Torvalds } 20431da177e4SLinus Torvalds } 20441da177e4SLinus Torvalds 20451da177e4SLinus Torvalds /** 20461da177e4SLinus Torvalds * 20471da177e4SLinus Torvalds * aac_srb_callback 20481da177e4SLinus Torvalds * @context: the context set in the fib - here it is scsi cmd 20491da177e4SLinus Torvalds * @fibptr: pointer to the fib 20501da177e4SLinus Torvalds * 20511da177e4SLinus Torvalds * Handles the completion of a scsi command to a non dasd device 20521da177e4SLinus Torvalds * 20531da177e4SLinus Torvalds */ 20541da177e4SLinus Torvalds 20551da177e4SLinus Torvalds static void aac_srb_callback(void *context, struct fib * fibptr) 20561da177e4SLinus Torvalds { 20571da177e4SLinus Torvalds struct aac_dev *dev; 20581da177e4SLinus Torvalds struct aac_srb_reply *srbreply; 20591da177e4SLinus Torvalds struct scsi_cmnd *scsicmd; 20601da177e4SLinus Torvalds 20611da177e4SLinus Torvalds scsicmd = (struct scsi_cmnd *) context; 206277d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL; 20631da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 20641da177e4SLinus Torvalds 2065125e1874SEric Sesterhenn BUG_ON(fibptr == NULL); 20661da177e4SLinus Torvalds 20671da177e4SLinus Torvalds srbreply = (struct aac_srb_reply *) fib_data(fibptr); 20681da177e4SLinus Torvalds 20691da177e4SLinus Torvalds scsicmd->sense_buffer[0] = '\0'; /* Initialize sense valid flag to false */ 20701da177e4SLinus Torvalds /* 20711da177e4SLinus Torvalds * Calculate resid for sg 20721da177e4SLinus Torvalds */ 20731da177e4SLinus Torvalds 20741da177e4SLinus Torvalds scsicmd->resid = scsicmd->request_bufflen - 20751da177e4SLinus Torvalds le32_to_cpu(srbreply->data_xfer_length); 20761da177e4SLinus Torvalds 20771da177e4SLinus Torvalds if(scsicmd->use_sg) 20781da177e4SLinus Torvalds pci_unmap_sg(dev->pdev, 20795d5ff44fSChristoph Hellwig (struct scatterlist *)scsicmd->request_buffer, 20801da177e4SLinus Torvalds scsicmd->use_sg, 20811da177e4SLinus Torvalds scsicmd->sc_data_direction); 20821da177e4SLinus Torvalds else if(scsicmd->request_bufflen) 20831da177e4SLinus Torvalds pci_unmap_single(dev->pdev, scsicmd->SCp.dma_handle, scsicmd->request_bufflen, 20841da177e4SLinus Torvalds scsicmd->sc_data_direction); 20851da177e4SLinus Torvalds 20861da177e4SLinus Torvalds /* 20871da177e4SLinus Torvalds * First check the fib status 20881da177e4SLinus Torvalds */ 20891da177e4SLinus Torvalds 20901da177e4SLinus Torvalds if (le32_to_cpu(srbreply->status) != ST_OK){ 20911da177e4SLinus Torvalds int len; 20921da177e4SLinus Torvalds printk(KERN_WARNING "aac_srb_callback: srb failed, status = %d\n", le32_to_cpu(srbreply->status)); 20931da177e4SLinus Torvalds len = (le32_to_cpu(srbreply->sense_data_size) > 20941da177e4SLinus Torvalds sizeof(scsicmd->sense_buffer)) ? 20951da177e4SLinus Torvalds sizeof(scsicmd->sense_buffer) : 20961da177e4SLinus Torvalds le32_to_cpu(srbreply->sense_data_size); 20971da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 20981da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, srbreply->sense_data, len); 20991da177e4SLinus Torvalds } 21001da177e4SLinus Torvalds 21011da177e4SLinus Torvalds /* 21021da177e4SLinus Torvalds * Next check the srb status 21031da177e4SLinus Torvalds */ 21041da177e4SLinus Torvalds switch( (le32_to_cpu(srbreply->srb_status))&0x3f){ 21051da177e4SLinus Torvalds case SRB_STATUS_ERROR_RECOVERY: 21061da177e4SLinus Torvalds case SRB_STATUS_PENDING: 21071da177e4SLinus Torvalds case SRB_STATUS_SUCCESS: 21081da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 21091da177e4SLinus Torvalds break; 21101da177e4SLinus Torvalds case SRB_STATUS_DATA_OVERRUN: 21111da177e4SLinus Torvalds switch(scsicmd->cmnd[0]){ 21121da177e4SLinus Torvalds case READ_6: 21131da177e4SLinus Torvalds case WRITE_6: 21141da177e4SLinus Torvalds case READ_10: 21151da177e4SLinus Torvalds case WRITE_10: 21161da177e4SLinus Torvalds case READ_12: 21171da177e4SLinus Torvalds case WRITE_12: 21187a8cf29dSMark Haverkamp case READ_16: 21197a8cf29dSMark Haverkamp case WRITE_16: 21201da177e4SLinus Torvalds if(le32_to_cpu(srbreply->data_xfer_length) < scsicmd->underflow ) { 21211da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: SCSI CMD underflow\n"); 21221da177e4SLinus Torvalds } else { 21231da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: SCSI CMD Data Overrun\n"); 21241da177e4SLinus Torvalds } 21251da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8; 21261da177e4SLinus Torvalds break; 21271da177e4SLinus Torvalds case INQUIRY: { 21281da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 21291da177e4SLinus Torvalds break; 21301da177e4SLinus Torvalds } 21311da177e4SLinus Torvalds default: 21321da177e4SLinus Torvalds scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 21331da177e4SLinus Torvalds break; 21341da177e4SLinus Torvalds } 21351da177e4SLinus Torvalds break; 21361da177e4SLinus Torvalds case SRB_STATUS_ABORTED: 21371da177e4SLinus Torvalds scsicmd->result = DID_ABORT << 16 | ABORT << 8; 21381da177e4SLinus Torvalds break; 21391da177e4SLinus Torvalds case SRB_STATUS_ABORT_FAILED: 21401da177e4SLinus Torvalds // Not sure about this one - but assuming the hba was trying to abort for some reason 21411da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | ABORT << 8; 21421da177e4SLinus Torvalds break; 21431da177e4SLinus Torvalds case SRB_STATUS_PARITY_ERROR: 21441da177e4SLinus Torvalds scsicmd->result = DID_PARITY << 16 | MSG_PARITY_ERROR << 8; 21451da177e4SLinus Torvalds break; 21461da177e4SLinus Torvalds case SRB_STATUS_NO_DEVICE: 21471da177e4SLinus Torvalds case SRB_STATUS_INVALID_PATH_ID: 21481da177e4SLinus Torvalds case SRB_STATUS_INVALID_TARGET_ID: 21491da177e4SLinus Torvalds case SRB_STATUS_INVALID_LUN: 21501da177e4SLinus Torvalds case SRB_STATUS_SELECTION_TIMEOUT: 21511da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8; 21521da177e4SLinus Torvalds break; 21531da177e4SLinus Torvalds 21541da177e4SLinus Torvalds case SRB_STATUS_COMMAND_TIMEOUT: 21551da177e4SLinus Torvalds case SRB_STATUS_TIMEOUT: 21561da177e4SLinus Torvalds scsicmd->result = DID_TIME_OUT << 16 | COMMAND_COMPLETE << 8; 21571da177e4SLinus Torvalds break; 21581da177e4SLinus Torvalds 21591da177e4SLinus Torvalds case SRB_STATUS_BUSY: 21601da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8; 21611da177e4SLinus Torvalds break; 21621da177e4SLinus Torvalds 21631da177e4SLinus Torvalds case SRB_STATUS_BUS_RESET: 21641da177e4SLinus Torvalds scsicmd->result = DID_RESET << 16 | COMMAND_COMPLETE << 8; 21651da177e4SLinus Torvalds break; 21661da177e4SLinus Torvalds 21671da177e4SLinus Torvalds case SRB_STATUS_MESSAGE_REJECTED: 21681da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | MESSAGE_REJECT << 8; 21691da177e4SLinus Torvalds break; 21701da177e4SLinus Torvalds case SRB_STATUS_REQUEST_FLUSHED: 21711da177e4SLinus Torvalds case SRB_STATUS_ERROR: 21721da177e4SLinus Torvalds case SRB_STATUS_INVALID_REQUEST: 21731da177e4SLinus Torvalds case SRB_STATUS_REQUEST_SENSE_FAILED: 21741da177e4SLinus Torvalds case SRB_STATUS_NO_HBA: 21751da177e4SLinus Torvalds case SRB_STATUS_UNEXPECTED_BUS_FREE: 21761da177e4SLinus Torvalds case SRB_STATUS_PHASE_SEQUENCE_FAILURE: 21771da177e4SLinus Torvalds case SRB_STATUS_BAD_SRB_BLOCK_LENGTH: 21781da177e4SLinus Torvalds case SRB_STATUS_DELAYED_RETRY: 21791da177e4SLinus Torvalds case SRB_STATUS_BAD_FUNCTION: 21801da177e4SLinus Torvalds case SRB_STATUS_NOT_STARTED: 21811da177e4SLinus Torvalds case SRB_STATUS_NOT_IN_USE: 21821da177e4SLinus Torvalds case SRB_STATUS_FORCE_ABORT: 21831da177e4SLinus Torvalds case SRB_STATUS_DOMAIN_VALIDATION_FAIL: 21841da177e4SLinus Torvalds default: 21851da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 21861da177e4SLinus Torvalds printk("aacraid: SRB ERROR(%u) %s scsi cmd 0x%x - scsi status 0x%x\n", 21871da177e4SLinus Torvalds le32_to_cpu(srbreply->srb_status) & 0x3F, 21881da177e4SLinus Torvalds aac_get_status_string( 21891da177e4SLinus Torvalds le32_to_cpu(srbreply->srb_status) & 0x3F), 21901da177e4SLinus Torvalds scsicmd->cmnd[0], 21911da177e4SLinus Torvalds le32_to_cpu(srbreply->scsi_status)); 21921da177e4SLinus Torvalds #endif 21931da177e4SLinus Torvalds scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8; 21941da177e4SLinus Torvalds break; 21951da177e4SLinus Torvalds } 21961da177e4SLinus Torvalds if (le32_to_cpu(srbreply->scsi_status) == 0x02 ){ // Check Condition 21971da177e4SLinus Torvalds int len; 21981da177e4SLinus Torvalds scsicmd->result |= SAM_STAT_CHECK_CONDITION; 21991da177e4SLinus Torvalds len = (le32_to_cpu(srbreply->sense_data_size) > 22001da177e4SLinus Torvalds sizeof(scsicmd->sense_buffer)) ? 22011da177e4SLinus Torvalds sizeof(scsicmd->sense_buffer) : 22021da177e4SLinus Torvalds le32_to_cpu(srbreply->sense_data_size); 22031da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 22047a8cf29dSMark Haverkamp printk(KERN_WARNING "aac_srb_callback: check condition, status = %d len=%d\n", 22057a8cf29dSMark Haverkamp le32_to_cpu(srbreply->status), len); 22061da177e4SLinus Torvalds #endif 22071da177e4SLinus Torvalds memcpy(scsicmd->sense_buffer, srbreply->sense_data, len); 22081da177e4SLinus Torvalds 22091da177e4SLinus Torvalds } 22101da177e4SLinus Torvalds /* 22111da177e4SLinus Torvalds * OR in the scsi status (already shifted up a bit) 22121da177e4SLinus Torvalds */ 22131da177e4SLinus Torvalds scsicmd->result |= le32_to_cpu(srbreply->scsi_status); 22141da177e4SLinus Torvalds 2215bfb35aa8SMark Haverkamp aac_fib_complete(fibptr); 2216bfb35aa8SMark Haverkamp aac_fib_free(fibptr); 22178e0c5ebdSMark Haverkamp scsicmd->scsi_done(scsicmd); 22181da177e4SLinus Torvalds } 22191da177e4SLinus Torvalds 22201da177e4SLinus Torvalds /** 22211da177e4SLinus Torvalds * 22221da177e4SLinus Torvalds * aac_send_scb_fib 22231da177e4SLinus Torvalds * @scsicmd: the scsi command block 22241da177e4SLinus Torvalds * 22251da177e4SLinus Torvalds * This routine will form a FIB and fill in the aac_srb from the 22261da177e4SLinus Torvalds * scsicmd passed in. 22271da177e4SLinus Torvalds */ 22281da177e4SLinus Torvalds 22291da177e4SLinus Torvalds static int aac_send_srb_fib(struct scsi_cmnd* scsicmd) 22301da177e4SLinus Torvalds { 22311da177e4SLinus Torvalds struct fib* cmd_fibcontext; 22321da177e4SLinus Torvalds struct aac_dev* dev; 22331da177e4SLinus Torvalds int status; 22341da177e4SLinus Torvalds 223584971738SMark Haverkamp dev = (struct aac_dev *)scsicmd->device->host->hostdata; 2236e5718774SMark Haverkamp if (scmd_id(scsicmd) >= dev->maximum_num_physicals || 223784971738SMark Haverkamp scsicmd->device->lun > 7) { 22381da177e4SLinus Torvalds scsicmd->result = DID_NO_CONNECT << 16; 22391da177e4SLinus Torvalds scsicmd->scsi_done(scsicmd); 22401da177e4SLinus Torvalds return 0; 22411da177e4SLinus Torvalds } 22421da177e4SLinus Torvalds 22431da177e4SLinus Torvalds /* 22441da177e4SLinus Torvalds * Allocate and initialize a Fib then setup a BlockWrite command 22451da177e4SLinus Torvalds */ 2246bfb35aa8SMark Haverkamp if (!(cmd_fibcontext = aac_fib_alloc(dev))) { 22471da177e4SLinus Torvalds return -1; 22481da177e4SLinus Torvalds } 2249e8f32de5SMark Haverkamp status = aac_adapter_scsi(cmd_fibcontext, scsicmd); 22501da177e4SLinus Torvalds 22511da177e4SLinus Torvalds /* 22521da177e4SLinus Torvalds * Check that the command queued to the controller 22531da177e4SLinus Torvalds */ 22541da177e4SLinus Torvalds if (status == -EINPROGRESS) { 225577d644d4SMark Haverkamp scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 22561da177e4SLinus Torvalds return 0; 22571da177e4SLinus Torvalds } 22581da177e4SLinus Torvalds 2259bfb35aa8SMark Haverkamp printk(KERN_WARNING "aac_srb: aac_fib_send failed with status: %d\n", status); 2260bfb35aa8SMark Haverkamp aac_fib_complete(cmd_fibcontext); 2261bfb35aa8SMark Haverkamp aac_fib_free(cmd_fibcontext); 22621da177e4SLinus Torvalds 22631da177e4SLinus Torvalds return -1; 22641da177e4SLinus Torvalds } 22651da177e4SLinus Torvalds 22661da177e4SLinus Torvalds static unsigned long aac_build_sg(struct scsi_cmnd* scsicmd, struct sgmap* psg) 22671da177e4SLinus Torvalds { 22681da177e4SLinus Torvalds struct aac_dev *dev; 22691da177e4SLinus Torvalds unsigned long byte_count = 0; 22701da177e4SLinus Torvalds 22711da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 22721da177e4SLinus Torvalds // Get rid of old data 22731da177e4SLinus Torvalds psg->count = 0; 22741da177e4SLinus Torvalds psg->sg[0].addr = 0; 22751da177e4SLinus Torvalds psg->sg[0].count = 0; 22761da177e4SLinus Torvalds if (scsicmd->use_sg) { 22771da177e4SLinus Torvalds struct scatterlist *sg; 22781da177e4SLinus Torvalds int i; 22791da177e4SLinus Torvalds int sg_count; 22801da177e4SLinus Torvalds sg = (struct scatterlist *) scsicmd->request_buffer; 22811da177e4SLinus Torvalds 22821da177e4SLinus Torvalds sg_count = pci_map_sg(dev->pdev, sg, scsicmd->use_sg, 22831da177e4SLinus Torvalds scsicmd->sc_data_direction); 22841da177e4SLinus Torvalds psg->count = cpu_to_le32(sg_count); 22851da177e4SLinus Torvalds 22861da177e4SLinus Torvalds for (i = 0; i < sg_count; i++) { 22871da177e4SLinus Torvalds psg->sg[i].addr = cpu_to_le32(sg_dma_address(sg)); 22881da177e4SLinus Torvalds psg->sg[i].count = cpu_to_le32(sg_dma_len(sg)); 22891da177e4SLinus Torvalds byte_count += sg_dma_len(sg); 22901da177e4SLinus Torvalds sg++; 22911da177e4SLinus Torvalds } 22921da177e4SLinus Torvalds /* hba wants the size to be exact */ 22931da177e4SLinus Torvalds if(byte_count > scsicmd->request_bufflen){ 229456b58712SMark Haverkamp u32 temp = le32_to_cpu(psg->sg[i-1].count) - 229556b58712SMark Haverkamp (byte_count - scsicmd->request_bufflen); 229656b58712SMark Haverkamp psg->sg[i-1].count = cpu_to_le32(temp); 22971da177e4SLinus Torvalds byte_count = scsicmd->request_bufflen; 22981da177e4SLinus Torvalds } 22991da177e4SLinus Torvalds /* Check for command underflow */ 23001da177e4SLinus Torvalds if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 23011da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 23021da177e4SLinus Torvalds byte_count, scsicmd->underflow); 23031da177e4SLinus Torvalds } 23041da177e4SLinus Torvalds } 23051da177e4SLinus Torvalds else if(scsicmd->request_bufflen) { 23063c1e0ccaSMark Haverkamp u32 addr; 23073c1e0ccaSMark Haverkamp scsicmd->SCp.dma_handle = pci_map_single(dev->pdev, 23081da177e4SLinus Torvalds scsicmd->request_buffer, 23091da177e4SLinus Torvalds scsicmd->request_bufflen, 23101da177e4SLinus Torvalds scsicmd->sc_data_direction); 23113c1e0ccaSMark Haverkamp addr = scsicmd->SCp.dma_handle; 23121da177e4SLinus Torvalds psg->count = cpu_to_le32(1); 23131da177e4SLinus Torvalds psg->sg[0].addr = cpu_to_le32(addr); 23141da177e4SLinus Torvalds psg->sg[0].count = cpu_to_le32(scsicmd->request_bufflen); 23151da177e4SLinus Torvalds byte_count = scsicmd->request_bufflen; 23161da177e4SLinus Torvalds } 23171da177e4SLinus Torvalds return byte_count; 23181da177e4SLinus Torvalds } 23191da177e4SLinus Torvalds 23201da177e4SLinus Torvalds 23211da177e4SLinus Torvalds static unsigned long aac_build_sg64(struct scsi_cmnd* scsicmd, struct sgmap64* psg) 23221da177e4SLinus Torvalds { 23231da177e4SLinus Torvalds struct aac_dev *dev; 23241da177e4SLinus Torvalds unsigned long byte_count = 0; 232556b58712SMark Haverkamp u64 addr; 23261da177e4SLinus Torvalds 23271da177e4SLinus Torvalds dev = (struct aac_dev *)scsicmd->device->host->hostdata; 23281da177e4SLinus Torvalds // Get rid of old data 23291da177e4SLinus Torvalds psg->count = 0; 23301da177e4SLinus Torvalds psg->sg[0].addr[0] = 0; 23311da177e4SLinus Torvalds psg->sg[0].addr[1] = 0; 23321da177e4SLinus Torvalds psg->sg[0].count = 0; 23331da177e4SLinus Torvalds if (scsicmd->use_sg) { 23341da177e4SLinus Torvalds struct scatterlist *sg; 23351da177e4SLinus Torvalds int i; 23361da177e4SLinus Torvalds int sg_count; 23371da177e4SLinus Torvalds sg = (struct scatterlist *) scsicmd->request_buffer; 23381da177e4SLinus Torvalds 23391da177e4SLinus Torvalds sg_count = pci_map_sg(dev->pdev, sg, scsicmd->use_sg, 23401da177e4SLinus Torvalds scsicmd->sc_data_direction); 23411da177e4SLinus Torvalds 23421da177e4SLinus Torvalds for (i = 0; i < sg_count; i++) { 23431241f359SMark Haverkamp int count = sg_dma_len(sg); 234456b58712SMark Haverkamp addr = sg_dma_address(sg); 234556b58712SMark Haverkamp psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff); 234656b58712SMark Haverkamp psg->sg[i].addr[1] = cpu_to_le32(addr>>32); 23471241f359SMark Haverkamp psg->sg[i].count = cpu_to_le32(count); 23481241f359SMark Haverkamp byte_count += count; 23491da177e4SLinus Torvalds sg++; 23501da177e4SLinus Torvalds } 23511241f359SMark Haverkamp psg->count = cpu_to_le32(sg_count); 23521da177e4SLinus Torvalds /* hba wants the size to be exact */ 23531da177e4SLinus Torvalds if(byte_count > scsicmd->request_bufflen){ 235456b58712SMark Haverkamp u32 temp = le32_to_cpu(psg->sg[i-1].count) - 235556b58712SMark Haverkamp (byte_count - scsicmd->request_bufflen); 235656b58712SMark Haverkamp psg->sg[i-1].count = cpu_to_le32(temp); 23571da177e4SLinus Torvalds byte_count = scsicmd->request_bufflen; 23581da177e4SLinus Torvalds } 23591da177e4SLinus Torvalds /* Check for command underflow */ 23601da177e4SLinus Torvalds if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 23611da177e4SLinus Torvalds printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 23621da177e4SLinus Torvalds byte_count, scsicmd->underflow); 23631da177e4SLinus Torvalds } 23641da177e4SLinus Torvalds } 23651da177e4SLinus Torvalds else if(scsicmd->request_bufflen) { 23661241f359SMark Haverkamp scsicmd->SCp.dma_handle = pci_map_single(dev->pdev, 23671da177e4SLinus Torvalds scsicmd->request_buffer, 23681da177e4SLinus Torvalds scsicmd->request_bufflen, 23691da177e4SLinus Torvalds scsicmd->sc_data_direction); 23701241f359SMark Haverkamp addr = scsicmd->SCp.dma_handle; 23711da177e4SLinus Torvalds psg->count = cpu_to_le32(1); 237256b58712SMark Haverkamp psg->sg[0].addr[0] = cpu_to_le32(addr & 0xffffffff); 237356b58712SMark Haverkamp psg->sg[0].addr[1] = cpu_to_le32(addr >> 32); 23741da177e4SLinus Torvalds psg->sg[0].count = cpu_to_le32(scsicmd->request_bufflen); 23751da177e4SLinus Torvalds byte_count = scsicmd->request_bufflen; 23761da177e4SLinus Torvalds } 23771da177e4SLinus Torvalds return byte_count; 23781da177e4SLinus Torvalds } 23791da177e4SLinus Torvalds 23800e68c003SMark Haverkamp static unsigned long aac_build_sgraw(struct scsi_cmnd* scsicmd, struct sgmapraw* psg) 23810e68c003SMark Haverkamp { 23820e68c003SMark Haverkamp struct Scsi_Host *host = scsicmd->device->host; 23830e68c003SMark Haverkamp struct aac_dev *dev = (struct aac_dev *)host->hostdata; 23840e68c003SMark Haverkamp unsigned long byte_count = 0; 23850e68c003SMark Haverkamp 23860e68c003SMark Haverkamp // Get rid of old data 23870e68c003SMark Haverkamp psg->count = 0; 23880e68c003SMark Haverkamp psg->sg[0].next = 0; 23890e68c003SMark Haverkamp psg->sg[0].prev = 0; 23900e68c003SMark Haverkamp psg->sg[0].addr[0] = 0; 23910e68c003SMark Haverkamp psg->sg[0].addr[1] = 0; 23920e68c003SMark Haverkamp psg->sg[0].count = 0; 23930e68c003SMark Haverkamp psg->sg[0].flags = 0; 23940e68c003SMark Haverkamp if (scsicmd->use_sg) { 23950e68c003SMark Haverkamp struct scatterlist *sg; 23960e68c003SMark Haverkamp int i; 23970e68c003SMark Haverkamp int sg_count; 23980e68c003SMark Haverkamp sg = (struct scatterlist *) scsicmd->request_buffer; 23990e68c003SMark Haverkamp 24000e68c003SMark Haverkamp sg_count = pci_map_sg(dev->pdev, sg, scsicmd->use_sg, 24010e68c003SMark Haverkamp scsicmd->sc_data_direction); 24020e68c003SMark Haverkamp 24030e68c003SMark Haverkamp for (i = 0; i < sg_count; i++) { 24040e68c003SMark Haverkamp int count = sg_dma_len(sg); 24050e68c003SMark Haverkamp u64 addr = sg_dma_address(sg); 24060e68c003SMark Haverkamp psg->sg[i].next = 0; 24070e68c003SMark Haverkamp psg->sg[i].prev = 0; 24080e68c003SMark Haverkamp psg->sg[i].addr[1] = cpu_to_le32((u32)(addr>>32)); 24090e68c003SMark Haverkamp psg->sg[i].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff)); 24100e68c003SMark Haverkamp psg->sg[i].count = cpu_to_le32(count); 24110e68c003SMark Haverkamp psg->sg[i].flags = 0; 24120e68c003SMark Haverkamp byte_count += count; 24130e68c003SMark Haverkamp sg++; 24140e68c003SMark Haverkamp } 24150e68c003SMark Haverkamp psg->count = cpu_to_le32(sg_count); 24160e68c003SMark Haverkamp /* hba wants the size to be exact */ 24170e68c003SMark Haverkamp if(byte_count > scsicmd->request_bufflen){ 24180e68c003SMark Haverkamp u32 temp = le32_to_cpu(psg->sg[i-1].count) - 24190e68c003SMark Haverkamp (byte_count - scsicmd->request_bufflen); 24200e68c003SMark Haverkamp psg->sg[i-1].count = cpu_to_le32(temp); 24210e68c003SMark Haverkamp byte_count = scsicmd->request_bufflen; 24220e68c003SMark Haverkamp } 24230e68c003SMark Haverkamp /* Check for command underflow */ 24240e68c003SMark Haverkamp if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 24250e68c003SMark Haverkamp printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 24260e68c003SMark Haverkamp byte_count, scsicmd->underflow); 24270e68c003SMark Haverkamp } 24280e68c003SMark Haverkamp } 24290e68c003SMark Haverkamp else if(scsicmd->request_bufflen) { 24300e68c003SMark Haverkamp int count; 24310e68c003SMark Haverkamp u64 addr; 24320e68c003SMark Haverkamp scsicmd->SCp.dma_handle = pci_map_single(dev->pdev, 24330e68c003SMark Haverkamp scsicmd->request_buffer, 24340e68c003SMark Haverkamp scsicmd->request_bufflen, 24350e68c003SMark Haverkamp scsicmd->sc_data_direction); 24360e68c003SMark Haverkamp addr = scsicmd->SCp.dma_handle; 24370e68c003SMark Haverkamp count = scsicmd->request_bufflen; 24380e68c003SMark Haverkamp psg->count = cpu_to_le32(1); 24390e68c003SMark Haverkamp psg->sg[0].next = 0; 24400e68c003SMark Haverkamp psg->sg[0].prev = 0; 24410e68c003SMark Haverkamp psg->sg[0].addr[1] = cpu_to_le32((u32)(addr>>32)); 24420e68c003SMark Haverkamp psg->sg[0].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff)); 24430e68c003SMark Haverkamp psg->sg[0].count = cpu_to_le32(count); 24440e68c003SMark Haverkamp psg->sg[0].flags = 0; 24450e68c003SMark Haverkamp byte_count = scsicmd->request_bufflen; 24460e68c003SMark Haverkamp } 24470e68c003SMark Haverkamp return byte_count; 24480e68c003SMark Haverkamp } 24490e68c003SMark Haverkamp 24501da177e4SLinus Torvalds #ifdef AAC_DETAILED_STATUS_INFO 24511da177e4SLinus Torvalds 24521da177e4SLinus Torvalds struct aac_srb_status_info { 24531da177e4SLinus Torvalds u32 status; 24541da177e4SLinus Torvalds char *str; 24551da177e4SLinus Torvalds }; 24561da177e4SLinus Torvalds 24571da177e4SLinus Torvalds 24581da177e4SLinus Torvalds static struct aac_srb_status_info srb_status_info[] = { 24591da177e4SLinus Torvalds { SRB_STATUS_PENDING, "Pending Status"}, 24601da177e4SLinus Torvalds { SRB_STATUS_SUCCESS, "Success"}, 24611da177e4SLinus Torvalds { SRB_STATUS_ABORTED, "Aborted Command"}, 24621da177e4SLinus Torvalds { SRB_STATUS_ABORT_FAILED, "Abort Failed"}, 24631da177e4SLinus Torvalds { SRB_STATUS_ERROR, "Error Event"}, 24641da177e4SLinus Torvalds { SRB_STATUS_BUSY, "Device Busy"}, 24651da177e4SLinus Torvalds { SRB_STATUS_INVALID_REQUEST, "Invalid Request"}, 24661da177e4SLinus Torvalds { SRB_STATUS_INVALID_PATH_ID, "Invalid Path ID"}, 24671da177e4SLinus Torvalds { SRB_STATUS_NO_DEVICE, "No Device"}, 24681da177e4SLinus Torvalds { SRB_STATUS_TIMEOUT, "Timeout"}, 24691da177e4SLinus Torvalds { SRB_STATUS_SELECTION_TIMEOUT, "Selection Timeout"}, 24701da177e4SLinus Torvalds { SRB_STATUS_COMMAND_TIMEOUT, "Command Timeout"}, 24711da177e4SLinus Torvalds { SRB_STATUS_MESSAGE_REJECTED, "Message Rejected"}, 24721da177e4SLinus Torvalds { SRB_STATUS_BUS_RESET, "Bus Reset"}, 24731da177e4SLinus Torvalds { SRB_STATUS_PARITY_ERROR, "Parity Error"}, 24741da177e4SLinus Torvalds { SRB_STATUS_REQUEST_SENSE_FAILED,"Request Sense Failed"}, 24751da177e4SLinus Torvalds { SRB_STATUS_NO_HBA, "No HBA"}, 24761da177e4SLinus Torvalds { SRB_STATUS_DATA_OVERRUN, "Data Overrun/Data Underrun"}, 24771da177e4SLinus Torvalds { SRB_STATUS_UNEXPECTED_BUS_FREE,"Unexpected Bus Free"}, 24781da177e4SLinus Torvalds { SRB_STATUS_PHASE_SEQUENCE_FAILURE,"Phase Error"}, 24791da177e4SLinus Torvalds { SRB_STATUS_BAD_SRB_BLOCK_LENGTH,"Bad Srb Block Length"}, 24801da177e4SLinus Torvalds { SRB_STATUS_REQUEST_FLUSHED, "Request Flushed"}, 24811da177e4SLinus Torvalds { SRB_STATUS_DELAYED_RETRY, "Delayed Retry"}, 24821da177e4SLinus Torvalds { SRB_STATUS_INVALID_LUN, "Invalid LUN"}, 24831da177e4SLinus Torvalds { SRB_STATUS_INVALID_TARGET_ID, "Invalid TARGET ID"}, 24841da177e4SLinus Torvalds { SRB_STATUS_BAD_FUNCTION, "Bad Function"}, 24851da177e4SLinus Torvalds { SRB_STATUS_ERROR_RECOVERY, "Error Recovery"}, 24861da177e4SLinus Torvalds { SRB_STATUS_NOT_STARTED, "Not Started"}, 24871da177e4SLinus Torvalds { SRB_STATUS_NOT_IN_USE, "Not In Use"}, 24881da177e4SLinus Torvalds { SRB_STATUS_FORCE_ABORT, "Force Abort"}, 24891da177e4SLinus Torvalds { SRB_STATUS_DOMAIN_VALIDATION_FAIL,"Domain Validation Failure"}, 24901da177e4SLinus Torvalds { 0xff, "Unknown Error"} 24911da177e4SLinus Torvalds }; 24921da177e4SLinus Torvalds 24931da177e4SLinus Torvalds char *aac_get_status_string(u32 status) 24941da177e4SLinus Torvalds { 24951da177e4SLinus Torvalds int i; 24961da177e4SLinus Torvalds 24976391a113STobias Klauser for (i = 0; i < ARRAY_SIZE(srb_status_info); i++) 24986391a113STobias Klauser if (srb_status_info[i].status == status) 24991da177e4SLinus Torvalds return srb_status_info[i].str; 25001da177e4SLinus Torvalds 25011da177e4SLinus Torvalds return "Bad Status Code"; 25021da177e4SLinus Torvalds } 25031da177e4SLinus Torvalds 25041da177e4SLinus Torvalds #endif 2505