开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
aachba.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：48k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

aachba.c：源码内容
  1. /*
  2.  * Adaptec AAC series RAID controller driver
  3.  * (c) Copyright 2001 Red Hat Inc. <alan@redhat.com>
  4.  *
  5.  * based on the old aacraid driver that is..
  6.  * Adaptec aacraid device driver for Linux.
  7.  * Copyright (c) 2000 Adaptec, Inc. (aacraid@adaptec.com)
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2, or (at your option)
  12.  * any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; see the file COPYING.  If not, write to
  21.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  22.  *
  23.  */
  25. #include <linux/config.h>
  26. #include <linux/kernel.h>
  27. #include <linux/init.h>
  28. #include <linux/types.h>
  29. #include <linux/sched.h>
  30. #include <linux/pci.h>
  31. #include <linux/spinlock.h>
  32. #include <linux/slab.h>
  33. #include <linux/completion.h>
  34. #include <asm/semaphore.h>
  35. #include <asm/uaccess.h>
  36. #define MAJOR_NR SCSI_DISK0_MAJOR /* For DEVICE_NR() */
  37. #include <linux/blk.h>
  38. #include "scsi.h"
  39. #include "hosts.h"
  40. #include "sd.h"
  42. #include "aacraid.h"
  44. /* SCSI Commands */
  45. /* TODO:  dmb - use the ones defined in include/scsi/scsi.h */
  47. #define SS_TEST 0x00 /* Test unit ready */
  48. #define SS_REZERO 0x01 /* Rezero unit */
  49. #define SS_REQSEN 0x03 /* Request Sense */
  50. #define SS_REASGN 0x07 /* Reassign blocks */
  51. #define SS_READ 0x08 /* Read 6   */
  52. #define SS_WRITE 0x0A /* Write 6  */
  53. #define SS_INQUIR 0x12 /* inquiry */
  54. #define SS_ST_SP 0x1B /* Start/Stop unit */
  55. #define SS_LOCK 0x1E /* prevent/allow medium removal */
  56. #define SS_RESERV 0x16 /* Reserve */
  57. #define SS_RELES 0x17 /* Release */
  58. #define SS_MODESEN 0x1A /* Mode Sense 6 */
  59. #define SS_RDCAP 0x25 /* Read Capacity */
  60. #define SM_READ 0x28 /* Read 10  */
  61. #define SM_WRITE 0x2A /* Write 10 */
  62. #define SS_SEEK 0x2B /* Seek */
  64. /* values for inqd_pdt: Peripheral device type in plain English */
  65. #define INQD_PDT_DA 0x00 /* Direct-access (DISK) device */
  66. #define INQD_PDT_PROC 0x03 /* Processor device */
  67. #define INQD_PDT_CHNGR 0x08 /* Changer (jukebox, scsi2) */
  68. #define INQD_PDT_COMM 0x09 /* Communication device (scsi2) */
  69. #define INQD_PDT_NOLUN2 0x1f /* Unknown Device (scsi2) */
  70. #define INQD_PDT_NOLUN 0x7f /* Logical Unit Not Present */
  72. #define INQD_PDT_DMASK 0x1F /* Peripheral Device Type Mask */
  73. #define INQD_PDT_QMASK 0xE0 /* Peripheral Device Qualifer Mask */
  75. #define TARGET_LUN_TO_CONTAINER(target, lun) (target)
  76. #define CONTAINER_TO_TARGET(cont) ((cont))
  77. #define CONTAINER_TO_LUN(cont) (0)
  79. #define MAX_FIB_DATA (sizeof(struct hw_fib) - sizeof(FIB_HEADER))
  81. #define MAX_DRIVER_SG_SEGMENT_COUNT 17
  83. /*
  84.  * Sense keys
  85.  */
  86. #define SENKEY_NO_SENSE       0x00
  87. #define SENKEY_UNDEFINED      0x01
  88. #define SENKEY_NOT_READY      0x02
  89. #define SENKEY_MEDIUM_ERR     0x03
  90. #define SENKEY_HW_ERR         0x04
  91. #define SENKEY_ILLEGAL        0x05
  92. #define SENKEY_ATTENTION      0x06
  93. #define SENKEY_PROTECTED      0x07
  94. #define SENKEY_BLANK          0x08
  95. #define SENKEY_V_UNIQUE       0x09
  96. #define SENKEY_CPY_ABORT      0x0A
  97. #define SENKEY_ABORT          0x0B
  98. #define SENKEY_EQUAL          0x0C
  99. #define SENKEY_VOL_OVERFLOW   0x0D
  100. #define SENKEY_MISCOMP        0x0E
  101. #define SENKEY_RESERVED       0x0F
  103. /*
  104.  * Sense codes
  105.  */
  106.  
  107. #define SENCODE_NO_SENSE                        0x00
  108. #define SENCODE_END_OF_DATA                     0x00
  109. #define SENCODE_BECOMING_READY                  0x04
  110. #define SENCODE_INIT_CMD_REQUIRED               0x04
  111. #define SENCODE_PARAM_LIST_LENGTH_ERROR         0x1A
  112. #define SENCODE_INVALID_COMMAND                 0x20
  113. #define SENCODE_LBA_OUT_OF_RANGE                0x21
  114. #define SENCODE_INVALID_CDB_FIELD               0x24
  115. #define SENCODE_LUN_NOT_SUPPORTED               0x25
  116. #define SENCODE_INVALID_PARAM_FIELD             0x26
  117. #define SENCODE_PARAM_NOT_SUPPORTED             0x26
  118. #define SENCODE_PARAM_VALUE_INVALID             0x26
  119. #define SENCODE_RESET_OCCURRED                  0x29
  120. #define SENCODE_LUN_NOT_SELF_CONFIGURED_YET     0x3E
  121. #define SENCODE_INQUIRY_DATA_CHANGED            0x3F
  122. #define SENCODE_SAVING_PARAMS_NOT_SUPPORTED     0x39
  123. #define SENCODE_DIAGNOSTIC_FAILURE              0x40
  124. #define SENCODE_INTERNAL_TARGET_FAILURE         0x44
  125. #define SENCODE_INVALID_MESSAGE_ERROR           0x49
  126. #define SENCODE_LUN_FAILED_SELF_CONFIG          0x4c
  127. #define SENCODE_OVERLAPPED_COMMAND              0x4E
  129. /*
  130.  * Additional sense codes
  131.  */
  132.  
  133. #define ASENCODE_NO_SENSE                       0x00
  134. #define ASENCODE_END_OF_DATA                    0x05
  135. #define ASENCODE_BECOMING_READY                 0x01
  136. #define ASENCODE_INIT_CMD_REQUIRED              0x02
  137. #define ASENCODE_PARAM_LIST_LENGTH_ERROR        0x00
  138. #define ASENCODE_INVALID_COMMAND                0x00
  139. #define ASENCODE_LBA_OUT_OF_RANGE               0x00
  140. #define ASENCODE_INVALID_CDB_FIELD              0x00
  141. #define ASENCODE_LUN_NOT_SUPPORTED              0x00
  142. #define ASENCODE_INVALID_PARAM_FIELD            0x00
  143. #define ASENCODE_PARAM_NOT_SUPPORTED            0x01
  144. #define ASENCODE_PARAM_VALUE_INVALID            0x02
  145. #define ASENCODE_RESET_OCCURRED                 0x00
  146. #define ASENCODE_LUN_NOT_SELF_CONFIGURED_YET    0x00
  147. #define ASENCODE_INQUIRY_DATA_CHANGED           0x03
  148. #define ASENCODE_SAVING_PARAMS_NOT_SUPPORTED    0x00
  149. #define ASENCODE_DIAGNOSTIC_FAILURE             0x80
  150. #define ASENCODE_INTERNAL_TARGET_FAILURE        0x00
  151. #define ASENCODE_INVALID_MESSAGE_ERROR          0x00
  152. #define ASENCODE_LUN_FAILED_SELF_CONFIG         0x00
  153. #define ASENCODE_OVERLAPPED_COMMAND             0x00
  155. #define BYTE0(x) (unsigned char)(x)
  156. #define BYTE1(x) (unsigned char)((x) >> 8)
  157. #define BYTE2(x) (unsigned char)((x) >> 16)
  158. #define BYTE3(x) (unsigned char)((x) >> 24)
  160. /*------------------------------------------------------------------------------
  161.  *              S T R U C T S / T Y P E D E F S
  162.  *----------------------------------------------------------------------------*/
  163. /* SCSI inquiry data */
  164. struct inquiry_data {
  165. u8 inqd_pdt; /* Peripheral qualifier | Peripheral Device Type  */
  166. u8 inqd_dtq; /* RMB | Device Type Qualifier  */
  167. u8 inqd_ver; /* ISO version | ECMA version | ANSI-approved version */
  168. u8 inqd_rdf; /* AENC | TrmIOP | Response data format */
  169. u8 inqd_len; /* Additional length (n-4) */
  170. u8 inqd_pad1[2]; /* Reserved - must be zero */
  171. u8 inqd_pad2; /* RelAdr | WBus32 | WBus16 |  Sync  | Linked |Reserved| CmdQue | SftRe */
  172. u8 inqd_vid[8]; /* Vendor ID */
  173. u8 inqd_pid[16]; /* Product ID */
  174. u8 inqd_prl[4]; /* Product Revision Level */
  175. };
  177. struct sense_data {
  178. u8 error_code; /* 70h (current errors), 71h(deferred errors) */
  179. u8 valid:1; /* A valid bit of one indicates that the information  */
  180. /* field contains valid information as defined in the
  181.  * SCSI-2 Standard.
  182.  */
  183. u8 segment_number; /* Only used for COPY, COMPARE, or COPY AND VERIFY Commands */
  184. u8 sense_key:4; /* Sense Key */
  185. u8 reserved:1;
  186. u8 ILI:1; /* Incorrect Length Indicator */
  187. u8 EOM:1; /* End Of Medium - reserved for random access devices */
  188. u8 filemark:1; /* Filemark - reserved for random access devices */
  190. u8 information[4]; /* for direct-access devices, contains the unsigned 
  191.  * logical block address or residue associated with 
  192.  * the sense key 
  193.  */
  194. u8 add_sense_len; /* number of additional sense bytes to follow this field */
  195. u8 cmnd_info[4]; /* not used */
  196. u8 ASC; /* Additional Sense Code */
  197. u8 ASCQ; /* Additional Sense Code Qualifier */
  198. u8 FRUC; /* Field Replaceable Unit Code - not used */
  199. u8 bit_ptr:3; /* indicates which byte of the CDB or parameter data
  200.  * was in error
  201.  */
  202. u8 BPV:1; /* bit pointer valid (BPV): 1- indicates that 
  203.  * the bit_ptr field has valid value
  204.  */
  205. u8 reserved2:2;
  206. u8 CD:1; /* command data bit: 1- illegal parameter in CDB.
  207.  * 0- illegal parameter in data.
  208.  */
  209. u8 SKSV:1;
  210. u8 field_ptr[2]; /* byte of the CDB or parameter data in error */
  211. };
  213. /*
  214.  *              M O D U L E   G L O B A L S
  215.  */
  216.  
  217. static struct fsa_scsi_hba *fsa_dev[MAXIMUM_NUM_ADAPTERS]; /*  SCSI Device Instance Pointers */
  218. static struct sense_data sense_data[MAXIMUM_NUM_CONTAINERS];
  219. static void get_sd_devname(int disknum, char *buffer);
  220. static unsigned long aac_build_sg(Scsi_Cmnd* scsicmd, struct sgmap* sgmap);
  221. static unsigned long aac_build_sg64(Scsi_Cmnd* scsicmd, struct sgmap64* psg);
  222. static int aac_send_srb_fib(Scsi_Cmnd* scsicmd);
  223. #ifdef AAC_DETAILED_STATUS_INFO
  224. static char *aac_get_status_string(u32 status);
  225. #endif
  227. /**
  228.  * aac_get_containers - list containers
  229.  * @common: adapter to probe
  230.  *
  231.  * Make a list of all containers on this controller
  232.  */
  233. int aac_get_containers(struct aac_dev *dev)
  234. {
  235. struct fsa_scsi_hba *fsa_dev_ptr;
  236. u32 index, status = 0;
  237. struct aac_query_mount *dinfo;
  238. struct aac_mount *dresp;
  239. struct fib * fibptr;
  240. unsigned instance;
  242. fsa_dev_ptr = &(dev->fsa_dev);
  243. instance = dev->scsi_host_ptr->unique_id;
  245. if (!(fibptr = fib_alloc(dev)))
  246. return -ENOMEM;
  248. for (index = 0; index < MAXIMUM_NUM_CONTAINERS; index++) {
  249. fib_init(fibptr);
  250. dinfo = (struct aac_query_mount *) fib_data(fibptr);
  252. dinfo->command = cpu_to_le32(VM_NameServe);
  253. dinfo->count = cpu_to_le32(index);
  254. dinfo->type = cpu_to_le32(FT_FILESYS);
  256. status = fib_send(ContainerCommand,
  257.     fibptr,
  258.     sizeof (struct aac_query_mount),
  259.     FsaNormal,
  260.     1, 1,
  261.     NULL, NULL);
  262. if (status < 0 ) {
  263. printk(KERN_WARNING "ProbeContainers: SendFIB failed.n");
  264. break;
  265. }
  266. dresp = (struct aac_mount *)fib_data(fibptr);
  268. if ((le32_to_cpu(dresp->status) == ST_OK) &&
  269.     (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE)) {
  270. fsa_dev_ptr->valid[index] = 1;
  271. fsa_dev_ptr->type[index] = le32_to_cpu(dresp->mnt[0].vol);
  272. fsa_dev_ptr->size[index] = le32_to_cpu(dresp->mnt[0].capacity);
  273. if (le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY)
  274.     fsa_dev_ptr->ro[index] = 1;
  275. }
  276. fib_complete(fibptr);
  277. /*
  278.  * If there are no more containers, then stop asking.
  279.  */
  280. if ((index + 1) >= le32_to_cpu(dresp->count))
  281. break;
  282. }
  283. fib_free(fibptr);
  284. fsa_dev[instance] = fsa_dev_ptr;
  285. return status;
  286. }
  288. /**
  289.  * probe_container - query a logical volume
  290.  * @dev: device to query
  291.  * @cid: container identifier
  292.  *
  293.  * Queries the controller about the given volume. The volume information
  294.  * is updated in the struct fsa_scsi_hba structure rather than returned.
  295.  */
  296.  
  297. static int probe_container(struct aac_dev *dev, int cid)
  298. {
  299. struct fsa_scsi_hba *fsa_dev_ptr;
  300. int status;
  301. struct aac_query_mount *dinfo;
  302. struct aac_mount *dresp;
  303. struct fib * fibptr;
  304. unsigned instance;
  306. fsa_dev_ptr = &(dev->fsa_dev);
  307. instance = dev->scsi_host_ptr->unique_id;
  309. if (!(fibptr = fib_alloc(dev)))
  310. return -ENOMEM;
  312. fib_init(fibptr);
  314. dinfo = (struct aac_query_mount *)fib_data(fibptr);
  316. dinfo->command = cpu_to_le32(VM_NameServe);
  317. dinfo->count = cpu_to_le32(cid);
  318. dinfo->type = cpu_to_le32(FT_FILESYS);
  320. status = fib_send(ContainerCommand,
  321.     fibptr,
  322.     sizeof(struct aac_query_mount),
  323.     FsaNormal,
  324.     1, 1,
  325.     NULL, NULL);
  326. if (status < 0) {
  327. printk(KERN_WARNING "aacraid: probe_containers query failed.n");
  328. goto error;
  329. }
  331. dresp = (struct aac_mount *) fib_data(fibptr);
  333. if ((le32_to_cpu(dresp->status) == ST_OK) &&
  334.     (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE)) {
  335. fsa_dev_ptr->valid[cid] = 1;
  336. fsa_dev_ptr->type[cid] = le32_to_cpu(dresp->mnt[0].vol);
  337. fsa_dev_ptr->size[cid] = le32_to_cpu(dresp->mnt[0].capacity);
  338. if (le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY)
  339. fsa_dev_ptr->ro[cid] = 1;
  340. }
  342. error:
  343. fib_complete(fibptr);
  344. fib_free(fibptr);
  346. return status;
  347. }
  349. /* Local Structure to set SCSI inquiry data strings */
  350. struct scsi_inq {
  351. char vid[8];         /* Vendor ID */
  352. char pid[16];        /* Product ID */
  353. char prl[4];         /* Product Revision Level */
  354. };
  356. /**
  357.  * InqStrCopy - string merge
  358.  * @a: string to copy from
  359.  * @b: string to copy to
  360.  *
  361.  *  Copy a String from one location to another
  362.  * without copying 
  363.  */
  365. static void inqstrcpy(char *a, char *b)
  366. {
  368. while(*a != (char)0) 
  369. *b++ = *a++;
  370. }
  372. static char *container_types[] = {
  373.         "None",
  374.         "Volume",
  375.         "Mirror",
  376.         "Stripe",
  377.         "RAID5",
  378.         "SSRW",
  379.         "SSRO",
  380.         "Morph",
  381.         "Legacy",
  382.         "RAID4",
  383.         "RAID10",             
  384.         "RAID00",             
  385.         "V-MIRRORS",          
  386.         "PSEUDO R4",          
  387. "RAID50",
  388.         "Unknown"
  389. };
  393. /* Function: setinqstr
  394.  *
  395.  * Arguments: [1] pointer to void [1] int
  396.  *
  397.  * Purpose: Sets SCSI inquiry data strings for vendor, product
  398.  * and revision level. Allows strings to be set in platform dependant
  399.  * files instead of in OS dependant driver source.
  400.  */
  402. static void setinqstr(int devtype, void *data, int tindex)
  403. {
  404. struct scsi_inq *str;
  405. char *findit;
  406. struct aac_driver_ident *mp;
  408. mp = aac_get_driver_ident(devtype);
  409.    
  410. str = (struct scsi_inq *)(data); /* cast data to scsi inq block */
  412. inqstrcpy (mp->vname, str->vid); 
  413. inqstrcpy (mp->model, str->pid); /* last six chars reserved for vol type */
  415. findit = str->pid;
  417. for ( ; *findit != ' '; findit++); /* walk till we find a space then incr by 1 */
  418. findit++;
  420. if (tindex < (sizeof(container_types)/sizeof(char *))){
  421. inqstrcpy (container_types[tindex], findit);
  422. }
  423. inqstrcpy ("V1.0", str->prl);
  424. }
  426. void set_sense(u8 *sense_buf, u8 sense_key, u8 sense_code,
  427.     u8 a_sense_code, u8 incorrect_length,
  428.     u8 bit_pointer, u16 field_pointer,
  429.     u32 residue)
  430. {
  431. sense_buf[0] = 0xF0; /* Sense data valid, err code 70h (current error) */
  432. sense_buf[1] = 0; /* Segment number, always zero */
  434. if (incorrect_length) {
  435. sense_buf[2] = sense_key | 0x20; /* Set ILI bit | sense key */
  436. sense_buf[3] = BYTE3(residue);
  437. sense_buf[4] = BYTE2(residue);
  438. sense_buf[5] = BYTE1(residue);
  439. sense_buf[6] = BYTE0(residue);
  440. } else
  441. sense_buf[2] = sense_key; /* Sense key */
  443. if (sense_key == SENKEY_ILLEGAL)
  444. sense_buf[7] = 10; /* Additional sense length */
  445. else
  446. sense_buf[7] = 6; /* Additional sense length */
  448. sense_buf[12] = sense_code; /* Additional sense code */
  449. sense_buf[13] = a_sense_code; /* Additional sense code qualifier */
  450. if (sense_key == SENKEY_ILLEGAL) {
  451. sense_buf[15] = 0;
  453. if (sense_code == SENCODE_INVALID_PARAM_FIELD)
  454. sense_buf[15] = 0x80; /* Std sense key specific field */
  455. /* Illegal parameter is in the parameter block */
  457. if (sense_code == SENCODE_INVALID_CDB_FIELD)
  458. sense_buf[15] = 0xc0; /* Std sense key specific field */
  459. /* Illegal parameter is in the CDB block */
  460. sense_buf[15] |= bit_pointer;
  461. sense_buf[16] = field_pointer >> 8; /* MSB */
  462. sense_buf[17] = field_pointer; /* LSB */
  463. }
  464. }
  466. static void aac_io_done(Scsi_Cmnd * scsicmd)
  467. {
  468. unsigned long cpu_flags;
  469. spin_lock_irqsave(&io_request_lock, cpu_flags);
  470. scsicmd->scsi_done(scsicmd);
  471. spin_unlock_irqrestore(&io_request_lock, cpu_flags);
  472. }
  474. static void __aac_io_done(Scsi_Cmnd * scsicmd)
  475. {
  476. scsicmd->scsi_done(scsicmd);
  477. }
  479. int aac_get_adapter_info(struct aac_dev* dev)
  480. {
  481. struct fib* fibptr;
  482. struct aac_adapter_info* info;
  483. int rcode;
  484. u32 tmp;
  485. if (!(fibptr = fib_alloc(dev)))
  486. return -ENOMEM;
  488. fib_init(fibptr);
  489. info = (struct aac_adapter_info*) fib_data(fibptr);
  491. memset(info,0,sizeof(struct aac_adapter_info));
  493. rcode = fib_send(RequestAdapterInfo,
  494. fibptr, 
  495. sizeof(struct aac_adapter_info),
  496. FsaNormal, 
  497. 1, 1, 
  498. NULL, 
  499. NULL);
  501. memcpy(&dev->adapter_info, info, sizeof(struct aac_adapter_info));
  503. tmp = dev->adapter_info.kernelrev;
  504. printk(KERN_INFO "%s%d: kernel %d.%d.%d build %dn", 
  505. dev->name, dev->id,
  506. tmp>>24,(tmp>>16)&0xff,(tmp>>8)&0xff,
  507. dev->adapter_info.kernelbuild);
  508. tmp = dev->adapter_info.monitorrev;
  509. printk(KERN_INFO "%s%d: monitor %d.%d.%d build %dn", 
  510. dev->name, dev->id,
  511. tmp>>24,(tmp>>16)&0xff,(tmp>>8)&0xff,
  512. dev->adapter_info.monitorbuild);
  513. tmp = dev->adapter_info.biosrev;
  514. printk(KERN_INFO "%s%d: bios %d.%d.%d build %dn", 
  515. dev->name, dev->id,
  516. tmp>>24,(tmp>>16)&0xff,(tmp>>8)&0xff,
  517. dev->adapter_info.biosbuild);
  518. printk(KERN_INFO "%s%d: serial %x%xn",
  519. dev->name, dev->id,
  520. dev->adapter_info.serial[0],
  521. dev->adapter_info.serial[1]);
  522. dev->pae_support = 0;
  523. dev->nondasd_support = 0;
  524. if( BITS_PER_LONG >= 64 && 
  525.   (dev->adapter_info.options & AAC_OPT_SGMAP_HOST64)){
  526. printk(KERN_INFO "%s%d: 64 Bit PAE enabledn", dev->name, dev->id);
  527. dev->pae_support = 1;
  528. }
  529. /* TODO - dmb temporary until fw can set this bit  */
  530. dev->pae_support = (BITS_PER_LONG >= 64);
  531. if(dev->pae_support != 0) {
  532. printk(KERN_INFO "%s%d: 64 Bit PAE enabledn", dev->name, dev->id);
  533. }
  535. if(dev->adapter_info.options & AAC_OPT_NONDASD){
  536. dev->nondasd_support = 1;
  537. }
  538. return rcode;
  539. }
  542. static void read_callback(void *context, struct fib * fibptr)
  543. {
  544. struct aac_dev *dev;
  545. struct aac_read_reply *readreply;
  546. Scsi_Cmnd *scsicmd;
  547. u32 lba;
  548. u32 cid;
  550. scsicmd = (Scsi_Cmnd *) context;
  552. dev = (struct aac_dev *)scsicmd->host->hostdata;
  553. cid =TARGET_LUN_TO_CONTAINER(scsicmd->target, scsicmd->lun);
  555. lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3];
  556. dprintk((KERN_DEBUG "read_callback[cpu %d]: lba = %d, t = %ld.n", smp_processor_id(), lba, jiffies));
  558. if (fibptr == NULL)
  559. BUG();
  561. if(scsicmd->use_sg)
  562. pci_unmap_sg(dev->pdev, 
  563. (struct scatterlist *)scsicmd->buffer,
  564. scsicmd->use_sg,
  565. scsi_to_pci_dma_dir(scsicmd->sc_data_direction));
  566. else if(scsicmd->request_bufflen)
  567. pci_unmap_single(dev->pdev, (dma_addr_t)(unsigned long)scsicmd->SCp.ptr,
  568.  scsicmd->request_bufflen,
  569.  scsi_to_pci_dma_dir(scsicmd->sc_data_direction));
  570. readreply = (struct aac_read_reply *)fib_data(fibptr);
  571. if (le32_to_cpu(readreply->status) == ST_OK)
  572. scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | GOOD;
  573. else {
  574. printk(KERN_WARNING "read_callback: read failed, status = %dn", readreply->status);
  575. scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | CHECK_CONDITION;
  576. set_sense((u8 *) &sense_data[cid],
  577.     SENKEY_HW_ERR,
  578.     SENCODE_INTERNAL_TARGET_FAILURE,
  579.     ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0,
  580.     0, 0);
  581. }
  582. fib_complete(fibptr);
  583. fib_free(fibptr);
  585. aac_io_done(scsicmd);
  586. }
  588. static void write_callback(void *context, struct fib * fibptr)
  589. {
  590. struct aac_dev *dev;
  591. struct aac_write_reply *writereply;
  592. Scsi_Cmnd *scsicmd;
  593. u32 lba;
  594. u32 cid;
  596. scsicmd = (Scsi_Cmnd *) context;
  597. dev = (struct aac_dev *)scsicmd->host->hostdata;
  598. cid = TARGET_LUN_TO_CONTAINER(scsicmd->target, scsicmd->lun);
  600. lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3];
  601. dprintk((KERN_DEBUG "write_callback[cpu %d]: lba = %d, t = %ld.n", smp_processor_id(), lba, jiffies));
  602. if (fibptr == NULL)
  603. BUG();
  605. if(scsicmd->use_sg)
  606. pci_unmap_sg(dev->pdev, 
  607. (struct scatterlist *)scsicmd->buffer,
  608. scsicmd->use_sg,
  609. scsi_to_pci_dma_dir(scsicmd->sc_data_direction));
  610. else if(scsicmd->request_bufflen)
  611. pci_unmap_single(dev->pdev, (dma_addr_t)(unsigned long)scsicmd->SCp.ptr,
  612.  scsicmd->request_bufflen,
  613.  scsi_to_pci_dma_dir(scsicmd->sc_data_direction));
  615. writereply = (struct aac_write_reply *) fib_data(fibptr);
  616. if (le32_to_cpu(writereply->status) == ST_OK)
  617. scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | GOOD;
  618. else {
  619. printk(KERN_WARNING "write_callback: write failed, status = %dn", writereply->status);
  620. scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | CHECK_CONDITION;
  621. set_sense((u8 *) &sense_data[cid],
  622.     SENKEY_HW_ERR,
  623.     SENCODE_INTERNAL_TARGET_FAILURE,
  624.     ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0,
  625.     0, 0);
  626. }
  628. fib_complete(fibptr);
  629. fib_free(fibptr);
  630. aac_io_done(scsicmd);
  631. }
  633. int aac_read(Scsi_Cmnd * scsicmd, int cid)
  634. {
  635. u32 lba;
  636. u32 count;
  637. int status;
  639. u16 fibsize;
  640. struct aac_dev *dev;
  641. struct fib * cmd_fibcontext;
  643. dev = (struct aac_dev *)scsicmd->host->hostdata;
  644. /*
  645.  * Get block address and transfer length
  646.  */
  647. if (scsicmd->cmnd[0] == SS_READ) /* 6 byte command */
  648. {
  649. dprintk((KERN_DEBUG "aachba: received a read(6) command on target %d.n", cid));
  651. lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3];
  652. count = scsicmd->cmnd[4];
  654. if (count == 0)
  655. count = 256;
  656. } else {
  657. dprintk((KERN_DEBUG "aachba: received a read(10) command on target %d.n", cid));
  659. lba = (scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
  660. count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8];
  661. }
  662. dprintk((KERN_DEBUG "aac_read[cpu %d]: lba = %u, t = %ld.n", smp_processor_id(), lba, jiffies));
  663. /*
  664.  * Alocate and initialize a Fib
  665.  */
  666. if (!(cmd_fibcontext = fib_alloc(dev))) {
  667. scsicmd->result = DID_ERROR << 16;
  668. aac_io_done(scsicmd);
  669. return (-1);
  670. }
  672. fib_init(cmd_fibcontext);
  674. if(dev->pae_support == 1){
  675. struct aac_read64 *readcmd;
  676. readcmd = (struct aac_read64 *) fib_data(cmd_fibcontext);
  677. readcmd->command = cpu_to_le32(VM_CtHostRead64);
  678. readcmd->cid = cpu_to_le16(cid);
  679. readcmd->sector_count = cpu_to_le16(count);
  680. readcmd->block = cpu_to_le32(lba);
  681. readcmd->pad   = cpu_to_le16(0);
  682. readcmd->flags = cpu_to_le16(0); 
  684. aac_build_sg64(scsicmd, &readcmd->sg);
  685. if(readcmd->sg.count > MAX_DRIVER_SG_SEGMENT_COUNT)
  686. BUG();
  687. fibsize = sizeof(struct aac_read64) + ((readcmd->sg.count - 1) * sizeof (struct sgentry64));
  688. /*
  689.  * Now send the Fib to the adapter
  690.  */
  691. status = fib_send(ContainerCommand64, 
  692.   cmd_fibcontext, 
  693.   fibsize, 
  694.   FsaNormal, 
  695.   0, 1, 
  696.   (fib_callback) read_callback, 
  697.   (void *) scsicmd);
  698. } else {
  699. struct aac_read *readcmd;
  700. readcmd = (struct aac_read *) fib_data(cmd_fibcontext);
  701. readcmd->command = cpu_to_le32(VM_CtBlockRead);
  702. readcmd->cid = cpu_to_le32(cid);
  703. readcmd->block = cpu_to_le32(lba);
  704. readcmd->count = cpu_to_le32(count * 512);
  706. if (count * 512 > (64 * 1024))
  707. BUG();
  709. aac_build_sg(scsicmd, &readcmd->sg);
  710. if(readcmd->sg.count > MAX_DRIVER_SG_SEGMENT_COUNT)
  711. BUG();
  712. fibsize = sizeof(struct aac_read) + ((readcmd->sg.count - 1) * sizeof (struct sgentry));
  713. /*
  714.  * Now send the Fib to the adapter
  715.  */
  716. status = fib_send(ContainerCommand, 
  717.   cmd_fibcontext, 
  718.   fibsize, 
  719.   FsaNormal, 
  720.   0, 1, 
  721.   (fib_callback) read_callback, 
  722.   (void *) scsicmd);
  723. }
  726. /*
  727.  * Check that the command queued to the controller
  728.  */
  729. if (status == -EINPROGRESS) 
  730. return 0;
  732. printk(KERN_WARNING "aac_read: fib_send failed with status: %d.n", status);
  733. /*
  734.  * For some reason, the Fib didn't queue, return QUEUE_FULL
  735.  */
  736. scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | QUEUE_FULL;
  737. aac_io_done(scsicmd);
  738. fib_complete(cmd_fibcontext);
  739. fib_free(cmd_fibcontext);
  740. return -1;
  741. }
  743. static int aac_write(Scsi_Cmnd * scsicmd, int cid)
  744. {
  745. u32 lba;
  746. u32 count;
  747. int status;
  748. u16 fibsize;
  749. struct aac_dev *dev;
  750. struct fib * cmd_fibcontext;
  752. dev = (struct aac_dev *)scsicmd->host->hostdata;
  753. /*
  754.  * Get block address and transfer length
  755.  */
  756. if (scsicmd->cmnd[0] == SS_WRITE) /* 6 byte command */
  757. {
  758. lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3];
  759. count = scsicmd->cmnd[4];
  760. if (count == 0)
  761. count = 256;
  762. } else {
  763. dprintk((KERN_DEBUG "aachba: received a write(10) command on target %d.n", cid));
  764. lba = (scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
  765. count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8];
  766. }
  767. dprintk((KERN_DEBUG "aac_write[cpu %d]: lba = %lu, t = %ld.n", smp_processor_id(), lba, jiffies));
  768. /*
  769.  * Allocate and initialize a Fib then setup a BlockWrite command
  770.  */
  771. if (!(cmd_fibcontext = fib_alloc(dev))) {
  772. scsicmd->result = DID_ERROR << 16;
  773. aac_io_done(scsicmd);
  774. return -1;
  775. }
  776. fib_init(cmd_fibcontext);
  778. if(dev->pae_support == 1)
  779. {
  780. struct aac_write64 *writecmd;
  781. writecmd = (struct aac_write64 *) fib_data(cmd_fibcontext);
  782. writecmd->command = cpu_to_le32(VM_CtHostWrite64);
  783. writecmd->cid = cpu_to_le16(cid);
  784. writecmd->sector_count = cpu_to_le16(count); 
  785. writecmd->block = cpu_to_le32(lba);
  786. writecmd->pad = cpu_to_le16(0);
  787. writecmd->flags = cpu_to_le16(0);
  789. aac_build_sg64(scsicmd, &writecmd->sg);
  790. if(writecmd->sg.count > MAX_DRIVER_SG_SEGMENT_COUNT)
  791. BUG();
  792. fibsize = sizeof(struct aac_write64) + ((writecmd->sg.count - 1) * sizeof (struct sgentry64));
  793. /*
  794.  * Now send the Fib to the adapter
  795.  */
  796. status = fib_send(ContainerCommand64, 
  797.   cmd_fibcontext, 
  798.   fibsize, 
  799.   FsaNormal, 
  800.   0, 1, 
  801.   (fib_callback) write_callback, 
  802.   (void *) scsicmd);
  803. }
  804. else 
  805. {
  806. struct aac_write *writecmd;
  807. writecmd = (struct aac_write *) fib_data(cmd_fibcontext);
  808. writecmd->command = cpu_to_le32(VM_CtBlockWrite);
  809. writecmd->cid = cpu_to_le32(cid);
  810. writecmd->block = cpu_to_le32(lba);
  811. writecmd->count = cpu_to_le32(count * 512);
  812. writecmd->sg.count = cpu_to_le32(1);
  813. /* ->stable is not used - it did mean which type of write */
  815. if (count * 512 > (64 * 1024))
  816. BUG();
  817. aac_build_sg(scsicmd, &writecmd->sg);
  818. if(writecmd->sg.count > MAX_DRIVER_SG_SEGMENT_COUNT)
  819. BUG();
  820. fibsize = sizeof(struct aac_write) + ((writecmd->sg.count - 1) * sizeof (struct sgentry));
  821. /*
  822.  * Now send the Fib to the adapter
  823.  */
  824. status = fib_send(ContainerCommand, 
  825.   cmd_fibcontext, 
  826.   fibsize, 
  827.   FsaNormal, 
  828.   0, 1, 
  829.   (fib_callback) write_callback, 
  830.   (void *) scsicmd);
  831. }
  833. /*
  834.  * Check that the command queued to the controller
  835.  */
  836. if (status == -EINPROGRESS)
  837. return 0;
  839. printk(KERN_WARNING "aac_write: fib_send failed with status: %dn", status);
  840. /*
  841.  * For some reason, the Fib didn't queue, return QUEUE_FULL
  842.  */
  843. scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | QUEUE_FULL;
  844. aac_io_done(scsicmd);
  846. fib_complete(cmd_fibcontext);
  847. fib_free(cmd_fibcontext);
  848. return -1;
  849. }
  852. /**
  853.  * aac_scsi_cmd() - Process SCSI command
  854.  * @scsicmd: SCSI command block
  855.  * @wait: 1 if the user wants to await completion
  856.  *
  857.  * Emulate a SCSI command and queue the required request for the
  858.  * aacraid firmware.
  859.  */
  860.  
  861. int aac_scsi_cmd(Scsi_Cmnd * scsicmd)
  862. {
  863. u32 cid = 0;
  864. struct fsa_scsi_hba *fsa_dev_ptr;
  865. int cardtype;
  866. int ret;
  867. struct aac_dev *dev = (struct aac_dev *)scsicmd->host->hostdata;
  869. cardtype = dev->cardtype;
  871. fsa_dev_ptr = fsa_dev[scsicmd->host->unique_id];
  873. /*
  874.  * If the bus, target or lun is out of range, return fail
  875.  * Test does not apply to ID 16, the pseudo id for the controller
  876.  * itself.
  877.  */
  878. if (scsicmd->target != scsicmd->host->this_id) {
  879. if ((scsicmd->channel == 0) ){
  880. if( (scsicmd->target >= AAC_MAX_TARGET) || (scsicmd->lun != 0)){ 
  881. scsicmd->result = DID_NO_CONNECT << 16;
  882. __aac_io_done(scsicmd);
  883. return 0;
  884. }
  885. cid = TARGET_LUN_TO_CONTAINER(scsicmd->target, scsicmd->lun);
  887. /*
  888.  * If the target container doesn't exist, it may have
  889.  * been newly created
  890.  */
  891. if (fsa_dev_ptr->valid[cid] == 0) {
  892. switch (scsicmd->cmnd[0]) {
  893. case SS_INQUIR:
  894. case SS_RDCAP:
  895. case SS_TEST:
  896. spin_unlock_irq(&io_request_lock);
  897. probe_container(dev, cid);
  898. spin_lock_irq(&io_request_lock);
  899. if (fsa_dev_ptr->valid[cid] == 0) {
  900. scsicmd->result = DID_NO_CONNECT << 16;
  901. __aac_io_done(scsicmd);
  902. return 0;
  903. }
  904. default:
  905. break;
  906. }
  907. }
  908. /*
  909.  * If the target container still doesn't exist, 
  910.  * return failure
  911.  */
  912. if (fsa_dev_ptr->valid[cid] == 0) {
  913. scsicmd->result = DID_BAD_TARGET << 16;
  914. __aac_io_done(scsicmd);
  915. return -1;
  916. }
  917. } else {  /* check for physical non-dasd devices */
  918. if(dev->nondasd_support == 1){
  919. return aac_send_srb_fib(scsicmd);
  920. } else {
  921. scsicmd->result = DID_NO_CONNECT << 16;
  922. __aac_io_done(scsicmd);
  923. return 0;
  924. }
  925. }
  926. }
  927. /*
  928.  * else Command for the controller itself
  929.  */
  930. else if ((scsicmd->cmnd[0] != SS_INQUIR) && /* only INQUIRY & TUR cmnd supported for controller */
  931. (scsicmd->cmnd[0] != SS_TEST)) 
  932. {
  933. dprintk((KERN_WARNING "Only INQUIRY & TUR command supported for controller, rcvd = 0x%x.n", scsicmd->cmnd[0]));
  934. scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | CHECK_CONDITION;
  935. set_sense((u8 *) &sense_data[cid],
  936.     SENKEY_ILLEGAL,
  937.     SENCODE_INVALID_COMMAND,
  938.     ASENCODE_INVALID_COMMAND, 0, 0, 0, 0);
  939. __aac_io_done(scsicmd);
  940. return -1;
  941. }
  944. /* Handle commands here that don't really require going out to the adapter */
  945. switch (scsicmd->cmnd[0]) {
  946. case SS_INQUIR:
  947. {
  948. struct inquiry_data *inq_data_ptr;
  950. dprintk((KERN_DEBUG "INQUIRY command, ID: %d.n", scsicmd->target));
  951. inq_data_ptr = (struct inquiry_data *)scsicmd->request_buffer;
  952. memset(inq_data_ptr, 0, sizeof (struct inquiry_data));
  954. inq_data_ptr->inqd_ver = 2; /* claim compliance to SCSI-2 */
  955. inq_data_ptr->inqd_dtq = 0x80; /* set RMB bit to one indicating that the medium is removable */
  956. inq_data_ptr->inqd_rdf = 2; /* A response data format value of two indicates that the data shall be in the format specified in SCSI-2 */
  957. inq_data_ptr->inqd_len = 31;
  958. /*Format for "pad2" is  RelAdr | WBus32 | WBus16 |  Sync  | Linked |Reserved| CmdQue | SftRe */
  959. inq_data_ptr->inqd_pad2= 0x32 ;  /*WBus16|Sync|CmdQue */
  960. /*
  961.  * Set the Vendor, Product, and Revision Level
  962.  * see: <vendor>.c i.e. aac.c
  963.  */
  964. setinqstr(cardtype, (void *) (inq_data_ptr->inqd_vid), fsa_dev_ptr->type[cid]);
  965. if (scsicmd->target == scsicmd->host->this_id)
  966. inq_data_ptr->inqd_pdt = INQD_PDT_PROC; /* Processor device */
  967. else
  968. inq_data_ptr->inqd_pdt = INQD_PDT_DA; /* Direct/random access device */
  969. scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | GOOD;
  970. __aac_io_done(scsicmd);
  971. return 0;
  972. }
  973. case SS_RDCAP:
  974. {
  975. int capacity;
  976. char *cp;
  978. dprintk((KERN_DEBUG "READ CAPACITY command.n"));
  979. capacity = fsa_dev_ptr->size[cid] - 1;
  980. cp = scsicmd->request_buffer;
  981. cp[0] = (capacity >> 24) & 0xff;
  982. cp[1] = (capacity >> 16) & 0xff;
  983. cp[2] = (capacity >> 8) & 0xff;
  984. cp[3] = (capacity >> 0) & 0xff;
  985. cp[4] = 0;
  986. cp[5] = 0;
  987. cp[6] = 2;
  988. cp[7] = 0;
  990. scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | GOOD;
  991. __aac_io_done(scsicmd);
  993. return 0;
  994. }
  996. case SS_MODESEN:
  997. {
  998. char *mode_buf;
  1000. dprintk((KERN_DEBUG "MODE SENSE command.n"));
  1001. mode_buf = scsicmd->request_buffer;
  1002. mode_buf[0] = 0; /* Mode data length (MSB) */
  1003. mode_buf[1] = 6; /* Mode data length (LSB) */
  1004. mode_buf[2] = 0; /* Medium type - default */
  1005. mode_buf[3] = 0; /* Device-specific param, bit 8: 0/1 = write enabled/protected */
  1006. mode_buf[4] = 0; /* reserved */
  1007. mode_buf[5] = 0; /* reserved */
  1008. mode_buf[6] = 0; /* Block descriptor length (MSB) */
  1009. mode_buf[7] = 0; /* Block descriptor length (LSB) */
  1011. scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | GOOD;
  1012. __aac_io_done(scsicmd);
  1014. return 0;
  1015. }
  1016. case SS_REQSEN:
  1017. dprintk((KERN_DEBUG "REQUEST SENSE command.n"));
  1018. memcpy(scsicmd->sense_buffer, &sense_data[cid], sizeof (struct sense_data));
  1019. memset(&sense_data[cid], 0, sizeof (struct sense_data));
  1020. scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | GOOD;
  1021. __aac_io_done(scsicmd);
  1022. return (0);
  1024. case SS_LOCK:
  1025. dprintk((KERN_DEBUG "LOCK command.n"));
  1026. if (scsicmd->cmnd[4])
  1027. fsa_dev_ptr->locked[cid] = 1;
  1028. else
  1029. fsa_dev_ptr->locked[cid] = 0;
  1031. scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | GOOD;
  1032. __aac_io_done(scsicmd);
  1033. return 0;
  1034. /*
  1035.  * These commands are all No-Ops
  1036.  */
  1037. case SS_TEST:
  1038. case SS_RESERV:
  1039. case SS_RELES:
  1040. case SS_REZERO:
  1041. case SS_REASGN:
  1042. case SS_SEEK:
  1043. case SS_ST_SP:
  1044. scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | GOOD;
  1045. __aac_io_done(scsicmd);
  1046. return (0);
  1047. }
  1049. switch (scsicmd->cmnd[0]) 
  1050. {
  1051. case SS_READ:
  1052. case SM_READ:
  1053. /*
  1054.  * Hack to keep track of ordinal number of the device that
  1055.  * corresponds to a container. Needed to convert
  1056.  * containers to /dev/sd device names
  1057.  */
  1058.  
  1059. spin_unlock_irq(&io_request_lock);
  1060. fsa_dev_ptr->devno[cid] = DEVICE_NR(scsicmd->request.rq_dev);
  1061. ret = aac_read(scsicmd, cid);
  1062. spin_lock_irq(&io_request_lock);
  1063. return ret;
  1065. case SS_WRITE:
  1066. case SM_WRITE:
  1067. spin_unlock_irq(&io_request_lock);
  1068. ret = aac_write(scsicmd, cid);
  1069. spin_lock_irq(&io_request_lock);
  1070. return ret;
  1071. default:
  1072. /*
  1073.  * Unhandled commands
  1074.  */
  1075. printk(KERN_WARNING "Unhandled SCSI Command: 0x%x.n", scsicmd->cmnd[0]);
  1076. scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | CHECK_CONDITION;
  1077. set_sense((u8 *) &sense_data[cid],
  1078. SENKEY_ILLEGAL, SENCODE_INVALID_COMMAND,
  1079. ASENCODE_INVALID_COMMAND, 0, 0, 0, 0);
  1080. __aac_io_done(scsicmd);
  1081. return -1;
  1082. }
  1083. }
  1085. static int query_disk(struct aac_dev *dev, void *arg)
  1086. {
  1087. struct aac_query_disk qd;
  1088. struct fsa_scsi_hba *fsa_dev_ptr;
  1090. fsa_dev_ptr = &(dev->fsa_dev);
  1091. if (copy_from_user(&qd, arg, sizeof (struct aac_query_disk)))
  1092. return -EFAULT;
  1093. if (qd.cnum == -1)
  1094. qd.cnum = TARGET_LUN_TO_CONTAINER(qd.target, qd.lun);
  1095. else if ((qd.bus == -1) && (qd.target == -1) && (qd.lun == -1)) 
  1096. {
  1097. if (qd.cnum < 0 || qd.cnum > MAXIMUM_NUM_CONTAINERS)
  1098. return -EINVAL;
  1099. qd.instance = dev->scsi_host_ptr->host_no;
  1100. qd.bus = 0;
  1101. qd.target = CONTAINER_TO_TARGET(qd.cnum);
  1102. qd.lun = CONTAINER_TO_LUN(qd.cnum);
  1103. }
  1104. else return -EINVAL;
  1106. qd.valid = fsa_dev_ptr->valid[qd.cnum];
  1107. qd.locked = fsa_dev_ptr->locked[qd.cnum];
  1108. qd.deleted = fsa_dev_ptr->deleted[qd.cnum];
  1110. if (fsa_dev_ptr->devno[qd.cnum] == -1)
  1111. qd.unmapped = 1;
  1112. else
  1113. qd.unmapped = 0;
  1115. get_sd_devname(fsa_dev_ptr->devno[qd.cnum], qd.name);
  1117. if (copy_to_user(arg, &qd, sizeof (struct aac_query_disk)))
  1118. return -EFAULT;
  1119. return 0;
  1120. }
  1122. static void get_sd_devname(int disknum, char *buffer)
  1123. {
  1124. if (disknum < 0) {
  1125. sprintf(buffer, "%s", "");
  1126. return;
  1127. }
  1129. if (disknum < 26)
  1130. sprintf(buffer, "sd%c", 'a' + disknum);
  1131. else {
  1132. unsigned int min1;
  1133. unsigned int min2;
  1134. /*
  1135.  * For larger numbers of disks, we need to go to a new
  1136.  * naming scheme.
  1137.  */
  1138. min1 = disknum / 26;
  1139. min2 = disknum % 26;
  1140. sprintf(buffer, "sd%c%c", 'a' + min1 - 1, 'a' + min2);
  1141. }
  1142. }
  1144. static int force_delete_disk(struct aac_dev *dev, void *arg)
  1145. {
  1146. struct aac_delete_disk dd;
  1147. struct fsa_scsi_hba *fsa_dev_ptr;
  1149. fsa_dev_ptr = &(dev->fsa_dev);
  1151. if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk)))
  1152. return -EFAULT;
  1154. if (dd.cnum > MAXIMUM_NUM_CONTAINERS)
  1155. return -EINVAL;
  1156. /*
  1157.  * Mark this container as being deleted.
  1158.  */
  1159. fsa_dev_ptr->deleted[dd.cnum] = 1;
  1160. /*
  1161.  * Mark the container as no longer valid
  1162.  */
  1163. fsa_dev_ptr->valid[dd.cnum] = 0;
  1164. return 0;
  1165. }
  1167. static int delete_disk(struct aac_dev *dev, void *arg)
  1168. {
  1169. struct aac_delete_disk dd;
  1170. struct fsa_scsi_hba *fsa_dev_ptr;
  1172. fsa_dev_ptr = &(dev->fsa_dev);
  1174. if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk)))
  1175. return -EFAULT;
  1177. if (dd.cnum > MAXIMUM_NUM_CONTAINERS)
  1178. return -EINVAL;
  1179. /*
  1180.  * If the container is locked, it can not be deleted by the API.
  1181.  */
  1182. if (fsa_dev_ptr->locked[dd.cnum])
  1183. return -EBUSY;
  1184. else {
  1185. /*
  1186.  * Mark the container as no longer being valid.
  1187.  */
  1188. fsa_dev_ptr->valid[dd.cnum] = 0;
  1189. fsa_dev_ptr->devno[dd.cnum] = -1;
  1190. return 0;
  1191. }
  1192. }
  1194. int aac_dev_ioctl(struct aac_dev *dev, int cmd, void *arg)
  1195. {
  1196. switch (cmd) {
  1197. case FSACTL_QUERY_DISK:
  1198. return query_disk(dev, arg);
  1199. case FSACTL_DELETE_DISK:
  1200. return delete_disk(dev, arg);
  1201. case FSACTL_FORCE_DELETE_DISK:
  1202. return force_delete_disk(dev, arg);
  1203. case 2131:
  1204. return aac_get_containers(dev);
  1205. default:
  1206. return -ENOTTY;
  1207. }
  1208. }
  1210. /**
  1211.  *
  1212.  * aac_srb_callback
  1213.  * @context: the context set in the fib - here it is scsi cmd
  1214.  * @fibptr: pointer to the fib
  1215.  *
  1216.  * Handles the completion of a scsi command to a non dasd device
  1217.  *
  1218.  */
  1220. static void aac_srb_callback(void *context, struct fib * fibptr)
  1221. {
  1222. struct aac_dev *dev;
  1223. struct aac_srb_reply *srbreply;
  1224. Scsi_Cmnd *scsicmd;
  1226. scsicmd = (Scsi_Cmnd *) context;
  1227. dev = (struct aac_dev *)scsicmd->host->hostdata;
  1229. if (fibptr == NULL)
  1230. BUG();
  1232. srbreply = (struct aac_srb_reply *) fib_data(fibptr);
  1234. scsicmd->sense_buffer[0] = '';  // initialize sense valid flag to false
  1235. // calculate resid for sg 
  1236. scsicmd->resid = scsicmd->request_bufflen - srbreply->data_xfer_length;
  1238. if(scsicmd->use_sg)
  1239. pci_unmap_sg(dev->pdev, 
  1240. (struct scatterlist *)scsicmd->buffer,
  1241. scsicmd->use_sg,
  1242. scsi_to_pci_dma_dir(scsicmd->sc_data_direction));
  1243. else if(scsicmd->request_bufflen)
  1244. pci_unmap_single(dev->pdev, (ulong)scsicmd->SCp.ptr, scsicmd->request_bufflen,
  1245. scsi_to_pci_dma_dir(scsicmd->sc_data_direction));
  1247. /*
  1248.  * First check the fib status
  1249.  */
  1251. if (le32_to_cpu(srbreply->status) != ST_OK){
  1252. int len;
  1253. printk(KERN_WARNING "aac_srb_callback: srb failed, status = %dn", le32_to_cpu(srbreply->status));
  1254. len = (srbreply->sense_data_size > sizeof(scsicmd->sense_buffer))?
  1255. sizeof(scsicmd->sense_buffer):srbreply->sense_data_size;
  1256. scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8 | CHECK_CONDITION;
  1257. memcpy(scsicmd->sense_buffer, srbreply->sense_data, len);
  1258. }
  1260. /*
  1261.  * Next check the srb status
  1262.  */
  1263. switch(le32_to_cpu(srbreply->srb_status)){
  1264. case SRB_STATUS_ERROR_RECOVERY:
  1265. case SRB_STATUS_PENDING:
  1266. case SRB_STATUS_SUCCESS:
  1267. if(scsicmd->cmnd[0] == INQUIRY ){
  1268. u8 b;
  1269. /* We can't expose disk devices because we can't tell whether they
  1270.  * are the raw container drives or stand alone drives
  1271.  */
  1272. b = *(u8*)scsicmd->buffer;
  1273. if( (b & 0x0f) == TYPE_DISK ){
  1274. scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8;
  1275. }
  1276. } else {
  1277. scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
  1278. }
  1279. break;
  1280. case SRB_STATUS_DATA_OVERRUN:
  1281. switch(scsicmd->cmnd[0]){
  1282. case  READ_6:
  1283. case  WRITE_6:
  1284. case  READ_10:
  1285. case  WRITE_10:
  1286. case  READ_12:
  1287. case  WRITE_12:
  1288. if(le32_to_cpu(srbreply->data_xfer_length) < scsicmd->underflow ) {
  1289. printk(KERN_WARNING"aacraid: SCSI CMD underflown");
  1290. } else {
  1291. printk(KERN_WARNING"aacraid: SCSI CMD Data Overrunn");
  1292. }
  1293. scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8;
  1294. break;
  1295. default:
  1296. scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
  1297. break;
  1298. }
  1299. break;
  1300. case SRB_STATUS_ABORTED:
  1301. scsicmd->result = DID_ABORT << 16 | ABORT << 8;
  1302. break;
  1303. case SRB_STATUS_ABORT_FAILED:
  1304. // Not sure about this one - but assuming the hba was trying to abort for some reason
  1305. scsicmd->result = DID_ERROR << 16 | ABORT << 8;
  1306. break;
  1307. case SRB_STATUS_PARITY_ERROR:
  1308. scsicmd->result = DID_PARITY << 16 | MSG_PARITY_ERROR << 8;
  1309. break;
  1310. case SRB_STATUS_NO_DEVICE:
  1311. case SRB_STATUS_INVALID_PATH_ID:
  1312. case SRB_STATUS_INVALID_TARGET_ID:
  1313. case SRB_STATUS_INVALID_LUN:
  1314. case SRB_STATUS_SELECTION_TIMEOUT:
  1315. scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8;
  1316. break;
  1318. case SRB_STATUS_COMMAND_TIMEOUT:
  1319. case SRB_STATUS_TIMEOUT:
  1320. scsicmd->result = DID_TIME_OUT << 16 | COMMAND_COMPLETE << 8;
  1321. break;
  1323. case SRB_STATUS_BUSY:
  1324. scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8;
  1325. break;
  1327. case SRB_STATUS_BUS_RESET:
  1328. scsicmd->result = DID_RESET << 16 | COMMAND_COMPLETE << 8;
  1329. break;
  1331. case SRB_STATUS_MESSAGE_REJECTED:
  1332. scsicmd->result = DID_ERROR << 16 | MESSAGE_REJECT << 8;
  1333. break;
  1334. case SRB_STATUS_REQUEST_FLUSHED:
  1335. case SRB_STATUS_ERROR:
  1336. case SRB_STATUS_INVALID_REQUEST:
  1337. case SRB_STATUS_REQUEST_SENSE_FAILED:
  1338. case SRB_STATUS_NO_HBA:
  1339. case SRB_STATUS_UNEXPECTED_BUS_FREE:
  1340. case SRB_STATUS_PHASE_SEQUENCE_FAILURE:
  1341. case SRB_STATUS_BAD_SRB_BLOCK_LENGTH:
  1342. case SRB_STATUS_DELAYED_RETRY:
  1343. case SRB_STATUS_BAD_FUNCTION:
  1344. case SRB_STATUS_NOT_STARTED:
  1345. case SRB_STATUS_NOT_IN_USE:
  1346. case SRB_STATUS_FORCE_ABORT:
  1347. case SRB_STATUS_DOMAIN_VALIDATION_FAIL:
  1348. default:
  1349. #ifdef AAC_DETAILED_STATUS_INFO
  1350. printk("aacraid: SRB ERROR (%s)n",aac_get_status_string(le32_to_cpu(srbreply->srb_status)));
  1351. #endif
  1352. scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8;
  1353. break;
  1354. }
  1355. if (le32_to_cpu(srbreply->scsi_status) == 0x02 ){  // Check Condition
  1356. int len;
  1357. len = (srbreply->sense_data_size > sizeof(scsicmd->sense_buffer))?
  1358. sizeof(scsicmd->sense_buffer):srbreply->sense_data_size;
  1359. printk(KERN_WARNING "aac_srb_callback: check condition, status = %d len=%dn", le32_to_cpu(srbreply->status), len);
  1360. memcpy(scsicmd->sense_buffer, srbreply->sense_data, len);
  1361. }
  1362. /*
  1363.  * OR in the scsi status (already shifted up a bit)
  1364.  */
  1365. scsicmd->result |= le32_to_cpu(srbreply->scsi_status);
  1367. fib_complete(fibptr);
  1368. fib_free(fibptr);
  1369. aac_io_done(scsicmd);
  1370. }
  1372. /**
  1373.  *
  1374.  * aac_send_scb_fib
  1375.  * @scsicmd: the scsi command block
  1376.  *
  1377.  * This routine will form a FIB and fill in the aac_srb from the 
  1378.  * scsicmd passed in.
  1379.  */
  1381. static int aac_send_srb_fib(Scsi_Cmnd* scsicmd)
  1382. {
  1383. struct fib* cmd_fibcontext;
  1384. struct aac_dev* dev;
  1385. int status;
  1386. struct aac_srb *srbcmd;
  1387. u16 fibsize;
  1388. u32 flag;
  1390. if( scsicmd->target > 15 || scsicmd->lun > 7) {
  1391. scsicmd->result = DID_NO_CONNECT << 16;
  1392. __aac_io_done(scsicmd);
  1393. return 0;
  1394. }
  1396. dev = (struct aac_dev *)scsicmd->host->hostdata;
  1397. switch(scsicmd->sc_data_direction){
  1398. case SCSI_DATA_WRITE:
  1399. flag = SRB_DataOut;
  1400. break;
  1401. case SCSI_DATA_UNKNOWN:  
  1402. flag = SRB_DataIn | SRB_DataOut;
  1403. break;
  1404. case SCSI_DATA_READ:
  1405. flag = SRB_DataIn;
  1406. break;
  1407. case SCSI_DATA_NONE: 
  1408. default:
  1409. flag = SRB_NoDataXfer;
  1410. break;
  1411. }
  1414. /*
  1415.  * Allocate and initialize a Fib then setup a BlockWrite command
  1416.  */
  1417. if (!(cmd_fibcontext = fib_alloc(dev))) {
  1418. scsicmd->result = DID_ERROR << 16;
  1419. __aac_io_done(scsicmd);
  1420. return -1;
  1421. }
  1422. fib_init(cmd_fibcontext);
  1424. srbcmd = (struct aac_srb*) fib_data(cmd_fibcontext);
  1425. srbcmd->function = cpu_to_le32(SRBF_ExecuteScsi);
  1426. srbcmd->channel  = cpu_to_le32(aac_logical_to_phys(scsicmd->channel));
  1427. srbcmd->target   = cpu_to_le32(scsicmd->target);
  1428. srbcmd->lun      = cpu_to_le32(scsicmd->lun);
  1429. srbcmd->flags    = cpu_to_le32(flag);
  1430. srbcmd->timeout  = cpu_to_le32(0);  // timeout not used
  1431. srbcmd->retry_limit =cpu_to_le32(0); // Obsolete parameter
  1432. srbcmd->cdb_size = cpu_to_le32(scsicmd->cmd_len);
  1434. if( dev->pae_support ==1 ) {
  1435. aac_build_sg64(scsicmd, (struct sgmap64*) &srbcmd->sg);
  1436. srbcmd->count = cpu_to_le32(scsicmd->request_bufflen);
  1438. memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb));
  1439. memcpy(srbcmd->cdb, scsicmd->cmnd, scsicmd->cmd_len);
  1440. /*
  1441.  * Build Scatter/Gather list
  1442.  */
  1443. fibsize = sizeof (struct aac_srb) + (((srbcmd->sg.count & 0xff) - 1) * sizeof (struct sgentry64));
  1445. /*
  1446.  * Now send the Fib to the adapter
  1447.  */
  1448. status = fib_send(ScsiPortCommand64, cmd_fibcontext, fibsize, FsaNormal, 0, 1,
  1449.   (fib_callback) aac_srb_callback, (void *) scsicmd);
  1450. } else {
  1451. aac_build_sg(scsicmd, (struct sgmap*)&srbcmd->sg);
  1452. srbcmd->count = cpu_to_le32(scsicmd->request_bufflen);
  1454. memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb));
  1455. memcpy(srbcmd->cdb, scsicmd->cmnd, scsicmd->cmd_len);
  1456. /*
  1457.  * Build Scatter/Gather list
  1458.  */
  1459. fibsize = sizeof (struct aac_srb) + (((srbcmd->sg.count & 0xff) - 1) * sizeof (struct sgentry));
  1461. /*
  1462.  * Now send the Fib to the adapter
  1463.  */
  1464. status = fib_send(ScsiPortCommand, cmd_fibcontext, fibsize, FsaNormal, 0, 1,
  1465.   (fib_callback) aac_srb_callback, (void *) scsicmd);
  1466. }
  1467. /*
  1468.  * Check that the command queued to the controller
  1469.  */
  1470. if (status == -EINPROGRESS){
  1471. return 0;
  1472. }
  1474. printk(KERN_WARNING "aac_srb: fib_send failed with status: %dn", status);
  1475. /*
  1476.  * For some reason, the Fib didn't queue, return QUEUE_FULL
  1477.  */
  1478. scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | QUEUE_FULL;
  1479. __aac_io_done(scsicmd);
  1481. fib_complete(cmd_fibcontext);
  1482. fib_free(cmd_fibcontext);
  1484. return -1;
  1485. }
  1487. static unsigned long aac_build_sg(Scsi_Cmnd* scsicmd, struct sgmap* psg)
  1488. {
  1489. struct aac_dev *dev;
  1490. unsigned long byte_count = 0;
  1492. dev = (struct aac_dev *)scsicmd->host->hostdata;
  1493. // Get rid of old data
  1494. psg->count = cpu_to_le32(0);
  1495. psg->sg[0].addr = cpu_to_le32(NULL);
  1496. psg->sg[0].count = cpu_to_le32(0);  
  1497. if (scsicmd->use_sg) {
  1498. struct scatterlist *sg;
  1499. int i;
  1500. int sg_count;
  1501. sg = (struct scatterlist *) scsicmd->request_buffer;
  1503. sg_count = pci_map_sg(dev->pdev, sg, scsicmd->use_sg,
  1504. scsi_to_pci_dma_dir(scsicmd->sc_data_direction));
  1505. psg->count = cpu_to_le32(sg_count);
  1507. byte_count = 0;
  1509. for (i = 0; i < sg_count; i++) {
  1510. psg->sg[i].addr = cpu_to_le32(sg_dma_address(sg));
  1511. psg->sg[i].count = cpu_to_le32(sg_dma_len(sg));
  1512. byte_count += sg_dma_len(sg);
  1513. sg++;
  1514. }
  1515. /* hba wants the size to be exact */
  1516. if(byte_count > scsicmd->request_bufflen){
  1517. psg->sg[i-1].count -= (byte_count - scsicmd->request_bufflen);
  1518. byte_count = scsicmd->request_bufflen;
  1519. }
  1520. /* Check for command underflow */
  1521. if(scsicmd->underflow && (byte_count < scsicmd->underflow)){
  1522. printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08Xn",
  1523. byte_count, scsicmd->underflow);
  1524. }
  1525. }
  1526. else if(scsicmd->request_bufflen) {
  1527. dma_addr_t addr; 
  1528. addr = pci_map_single(dev->pdev,
  1529. scsicmd->request_buffer,
  1530. scsicmd->request_bufflen,
  1531. scsi_to_pci_dma_dir(scsicmd->sc_data_direction));
  1532. psg->count = cpu_to_le32(1);
  1533. psg->sg[0].addr = cpu_to_le32(addr);
  1534. psg->sg[0].count = cpu_to_le32(scsicmd->request_bufflen);  
  1535. scsicmd->SCp.ptr = (void *)addr;
  1536. byte_count = scsicmd->request_bufflen;
  1537. }
  1538. return byte_count;
  1539. }
  1542. static unsigned long aac_build_sg64(Scsi_Cmnd* scsicmd, struct sgmap64* psg)
  1543. {
  1544. struct aac_dev *dev;
  1545. unsigned long byte_count = 0;
  1546. u64 le_addr;
  1548. dev = (struct aac_dev *)scsicmd->host->hostdata;
  1549. // Get rid of old data
  1550. psg->count = cpu_to_le32(0);
  1551. psg->sg[0].addr[0] = cpu_to_le32(NULL);
  1552. psg->sg[0].addr[1] = cpu_to_le32(NULL);
  1553. psg->sg[0].count = cpu_to_le32(0);  
  1554. if (scsicmd->use_sg) {
  1555. struct scatterlist *sg;
  1556. int i;
  1557. int sg_count;
  1558. sg = (struct scatterlist *) scsicmd->request_buffer;
  1560. sg_count = pci_map_sg(dev->pdev, sg, scsicmd->use_sg,
  1561. scsi_to_pci_dma_dir(scsicmd->sc_data_direction));
  1562. psg->count = cpu_to_le32(sg_count);
  1564. byte_count = 0;
  1566. for (i = 0; i < sg_count; i++) {
  1567. le_addr = cpu_to_le64(sg_dma_address(sg));
  1568. psg->sg[i].addr[1] = (u32)(le_addr>>32);
  1569. psg->sg[i].addr[0] = (u32)(le_addr & 0xffffffff);
  1570. psg->sg[i].count = cpu_to_le32(sg_dma_len(sg));
  1571. byte_count += sg_dma_len(sg);
  1572. sg++;
  1573. }
  1574. /* hba wants the size to be exact */
  1575. if(byte_count > scsicmd->request_bufflen){
  1576. psg->sg[i-1].count -= (byte_count - scsicmd->request_bufflen);
  1577. byte_count = scsicmd->request_bufflen;
  1578. }
  1579. /* Check for command underflow */
  1580. if(scsicmd->underflow && (byte_count < scsicmd->underflow)){
  1581. printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08Xn",
  1582. byte_count, scsicmd->underflow);
  1583. }
  1584. }
  1585. else if(scsicmd->request_bufflen) {
  1586. dma_addr_t addr; 
  1587. addr = pci_map_single(dev->pdev,
  1588. scsicmd->request_buffer,
  1589. scsicmd->request_bufflen,
  1590. scsi_to_pci_dma_dir(scsicmd->sc_data_direction));
  1591. psg->count = cpu_to_le32(1);
  1592. le_addr = cpu_to_le64(addr);
  1593. psg->sg[0].addr[1] = (u32)(le_addr>>32);
  1594. psg->sg[0].addr[0] = (u32)(le_addr & 0xffffffff);
  1595. psg->sg[0].count = cpu_to_le32(scsicmd->request_bufflen);  
  1596. scsicmd->SCp.ptr = (void *)addr;
  1597. byte_count = scsicmd->request_bufflen;
  1598. }
  1599. return byte_count;
  1600. }
  1602. #ifdef AAC_DETAILED_STATUS_INFO
  1604. struct aac_srb_status_info {
  1605. u32 status;
  1606. char *str;
  1607. };
  1610. static struct aac_srb_status_info srb_status_info[] = {
  1611. { SRB_STATUS_PENDING, "Pending Status"},
  1612. { SRB_STATUS_SUCCESS, "Success"},
  1613. { SRB_STATUS_ABORTED, "Aborted Command"},
  1614. { SRB_STATUS_ABORT_FAILED, "Abort Failed"},
  1615. { SRB_STATUS_ERROR, "Error Event"}, 
  1616. { SRB_STATUS_BUSY, "Device Busy"},
  1617. { SRB_STATUS_INVALID_REQUEST, "Invalid Request"},
  1618. { SRB_STATUS_INVALID_PATH_ID, "Invalid Path ID"},
  1619. { SRB_STATUS_NO_DEVICE, "No Device"},
  1620. { SRB_STATUS_TIMEOUT, "Timeout"},
  1621. { SRB_STATUS_SELECTION_TIMEOUT, "Selection Timeout"},
  1622. { SRB_STATUS_COMMAND_TIMEOUT, "Command Timeout"},
  1623. { SRB_STATUS_MESSAGE_REJECTED, "Message Rejected"},
  1624. { SRB_STATUS_BUS_RESET, "Bus Reset"},
  1625. { SRB_STATUS_PARITY_ERROR, "Parity Error"},
  1626. { SRB_STATUS_REQUEST_SENSE_FAILED,"Request Sense Failed"},
  1627. { SRB_STATUS_NO_HBA, "No HBA"},
  1628. { SRB_STATUS_DATA_OVERRUN, "Data Overrun/Data Underrun"},
  1629. { SRB_STATUS_UNEXPECTED_BUS_FREE,"Unexpected Bus Free"},
  1630. { SRB_STATUS_PHASE_SEQUENCE_FAILURE,"Phase Error"},
  1631. { SRB_STATUS_BAD_SRB_BLOCK_LENGTH,"Bad Srb Block Length"},
  1632. { SRB_STATUS_REQUEST_FLUSHED, "Request Flushed"},
  1633. { SRB_STATUS_DELAYED_RETRY, "Delayed Retry"},
  1634. { SRB_STATUS_INVALID_LUN, "Invalid LUN"}, 
  1635. { SRB_STATUS_INVALID_TARGET_ID, "Invalid TARGET ID"},
  1636. { SRB_STATUS_BAD_FUNCTION, "Bad Function"},
  1637. { SRB_STATUS_ERROR_RECOVERY, "Error Recovery"},
  1638. { SRB_STATUS_NOT_STARTED, "Not Started"},
  1639. { SRB_STATUS_NOT_IN_USE, "Not In Use"},
  1640.      { SRB_STATUS_FORCE_ABORT, "Force Abort"},
  1641. { SRB_STATUS_DOMAIN_VALIDATION_FAIL,"Domain Validation Failure"},
  1642. { 0xff, "Unknown Error"}
  1643. };
  1645. char *aac_get_status_string(u32 status)
  1646. {
  1647. int i;
  1649. for(i=0; i < (sizeof(srb_status_info)/sizeof(struct aac_srb_status_info)); i++ ){
  1650. if(srb_status_info[i].status == status){
  1651. return srb_status_info[i].str;
  1652. }
  1653. }
  1655. return "Bad Status Code";
  1656. }
  1658. #endif