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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 驱动编程 > 查看源码
cciss.c
资源名称：block.rar　[点击查看]
上传用户：ajay2009
上传日期：2009-05-22
资源大小：495k
文件大小：90k
源码类别：

驱动编程

开发平台：

Unix_Linux

cciss.c：源码内容
  1. /*
  2.  *    Disk Array driver for HP SA 5xxx and 6xxx Controllers
  3.  *    Copyright 2000, 2005 Hewlett-Packard Development Company, L.P.
  4.  *
  5.  *    This program is free software; you can redistribute it and/or modify
  6.  *    it under the terms of the GNU General Public License as published by
  7.  *    the Free Software Foundation; either version 2 of the License, or
  8.  *    (at your option) any later version.
  9.  *
  10.  *    This program is distributed in the hope that it will be useful,
  11.  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  13.  *    NON INFRINGEMENT.  See the GNU General Public License for more details.
  14.  *
  15.  *    You should have received a copy of the GNU General Public License
  16.  *    along with this program; if not, write to the Free Software
  17.  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  *
  19.  *    Questions/Comments/Bugfixes to iss_storagedev@hp.com
  20.  *
  21.  */
  23. #include <linux/config.h> /* CONFIG_PROC_FS */
  24. #include <linux/module.h>
  25. #include <linux/interrupt.h>
  26. #include <linux/types.h>
  27. #include <linux/pci.h>
  28. #include <linux/kernel.h>
  29. #include <linux/slab.h>
  30. #include <linux/delay.h>
  31. #include <linux/major.h>
  32. #include <linux/fs.h>
  33. #include <linux/bio.h>
  34. #include <linux/blkpg.h>
  35. #include <linux/timer.h>
  36. #include <linux/proc_fs.h>
  37. #include <linux/init.h> 
  38. #include <linux/hdreg.h>
  39. #include <linux/spinlock.h>
  40. #include <linux/compat.h>
  41. #include <asm/uaccess.h>
  42. #include <asm/io.h>
  44. #include <linux/dma-mapping.h>
  45. #include <linux/blkdev.h>
  46. #include <linux/genhd.h>
  47. #include <linux/completion.h>
  49. #define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
  50. #define DRIVER_NAME "HP CISS Driver (v 2.6.8)"
  51. #define DRIVER_VERSION CCISS_DRIVER_VERSION(2,6,8)
  53. /* Embedded module documentation macros - see modules.h */
  54. MODULE_AUTHOR("Hewlett-Packard Company");
  55. MODULE_DESCRIPTION("Driver for HP Controller SA5xxx SA6xxx version 2.6.8");
  56. MODULE_SUPPORTED_DEVICE("HP SA5i SA5i+ SA532 SA5300 SA5312 SA641 SA642 SA6400"
  57. " SA6i P600 P800 P400 P400i E200 E200i");
  58. MODULE_LICENSE("GPL");
  60. #include "cciss_cmd.h"
  61. #include "cciss.h"
  62. #include <linux/cciss_ioctl.h>
  64. /* define the PCI info for the cards we can control */
  65. static const struct pci_device_id cciss_pci_device_id[] = {
  66. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS,
  67. 0x0E11, 0x4070, 0, 0, 0},
  68. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
  69.                         0x0E11, 0x4080, 0, 0, 0},
  70. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
  71.                         0x0E11, 0x4082, 0, 0, 0},
  72. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
  73.                         0x0E11, 0x4083, 0, 0, 0},
  74. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
  75. 0x0E11, 0x409A, 0, 0, 0},
  76. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
  77. 0x0E11, 0x409B, 0, 0, 0},
  78. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
  79. 0x0E11, 0x409C, 0, 0, 0},
  80. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
  81. 0x0E11, 0x409D, 0, 0, 0},
  82. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
  83. 0x0E11, 0x4091, 0, 0, 0},
  84. { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSA,
  85. 0x103C, 0x3225, 0, 0, 0},
  86. { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
  87. 0x103c, 0x3223, 0, 0, 0},
  88. { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
  89. 0x103c, 0x3234, 0, 0, 0},
  90. { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
  91. 0x103c, 0x3235, 0, 0, 0},
  92. { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
  93. 0x103c, 0x3211, 0, 0, 0},
  94. { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
  95. 0x103c, 0x3212, 0, 0, 0},
  96. { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
  97. 0x103c, 0x3213, 0, 0, 0},
  98. { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
  99. 0x103c, 0x3214, 0, 0, 0},
  100. { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
  101. 0x103c, 0x3215, 0, 0, 0},
  102. {0,}
  103. };
  104. MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);
  106. #define NR_PRODUCTS (sizeof(products)/sizeof(struct board_type))
  108. /*  board_id = Subsystem Device ID & Vendor ID
  109.  *  product = Marketing Name for the board
  110.  *  access = Address of the struct of function pointers 
  111.  */
  112. static struct board_type products[] = {
  113. { 0x40700E11, "Smart Array 5300", &SA5_access },
  114. { 0x40800E11, "Smart Array 5i", &SA5B_access},
  115. { 0x40820E11, "Smart Array 532", &SA5B_access},
  116. { 0x40830E11, "Smart Array 5312", &SA5B_access},
  117. { 0x409A0E11, "Smart Array 641", &SA5_access},
  118. { 0x409B0E11, "Smart Array 642", &SA5_access},
  119. { 0x409C0E11, "Smart Array 6400", &SA5_access},
  120. { 0x409D0E11, "Smart Array 6400 EM", &SA5_access},
  121. { 0x40910E11, "Smart Array 6i", &SA5_access},
  122. { 0x3225103C, "Smart Array P600", &SA5_access},
  123. { 0x3223103C, "Smart Array P800", &SA5_access},
  124. { 0x3234103C, "Smart Array P400", &SA5_access},
  125. { 0x3235103C, "Smart Array P400i", &SA5_access},
  126. { 0x3211103C, "Smart Array E200i", &SA5_access},
  127. { 0x3212103C, "Smart Array E200", &SA5_access},
  128. { 0x3213103C, "Smart Array E200i", &SA5_access},
  129. { 0x3214103C, "Smart Array E200i", &SA5_access},
  130. { 0x3215103C, "Smart Array E200i", &SA5_access},
  131. };
  133. /* How long to wait (in millesconds) for board to go into simple mode */
  134. #define MAX_CONFIG_WAIT 30000 
  135. #define MAX_IOCTL_CONFIG_WAIT 1000
  137. /*define how many times we will try a command because of bus resets */
  138. #define MAX_CMD_RETRIES 3
  140. #define READ_AHEAD   1024
  141. #define NR_CMDS  384 /* #commands that can be outstanding */
  142. #define MAX_CTLR 32
  144. /* Originally cciss driver only supports 8 major numbers */
  145. #define MAX_CTLR_ORIG  8
  148. static ctlr_info_t *hba[MAX_CTLR];
  150. static void do_cciss_request(request_queue_t *q);
  151. static int cciss_open(struct inode *inode, struct file *filep);
  152. static int cciss_release(struct inode *inode, struct file *filep);
  153. static int cciss_ioctl(struct inode *inode, struct file *filep, 
  154. unsigned int cmd, unsigned long arg);
  156. static int revalidate_allvol(ctlr_info_t *host);
  157. static int cciss_revalidate(struct gendisk *disk);
  158. static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk);
  159. static int deregister_disk(struct gendisk *disk, drive_info_struct *drv, int clear_all);
  161. static void cciss_read_capacity(int ctlr, int logvol, ReadCapdata_struct *buf,
  162. int withirq, unsigned int *total_size, unsigned int *block_size);
  163. static void cciss_geometry_inquiry(int ctlr, int logvol,
  164. int withirq, unsigned int total_size,
  165. unsigned int block_size, InquiryData_struct *inq_buff,
  166. drive_info_struct *drv);
  167. static void cciss_getgeometry(int cntl_num);
  169. static void start_io( ctlr_info_t *h);
  170. static int sendcmd( __u8 cmd, int ctlr, void *buff, size_t size,
  171. unsigned int use_unit_num, unsigned int log_unit, __u8 page_code,
  172. unsigned char *scsi3addr, int cmd_type);
  173. static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
  174. unsigned int use_unit_num, unsigned int log_unit, __u8 page_code,
  175. int cmd_type);
  177. static void fail_all_cmds(unsigned long ctlr);
  179. #ifdef CONFIG_PROC_FS
  180. static int cciss_proc_get_info(char *buffer, char **start, off_t offset, 
  181. int length, int *eof, void *data);
  182. static void cciss_procinit(int i);
  183. #else
  184. static void cciss_procinit(int i) {}
  185. #endif /* CONFIG_PROC_FS */
  187. #ifdef CONFIG_COMPAT
  188. static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg);
  189. #endif
  191. static struct block_device_operations cciss_fops  = {
  192. .owner = THIS_MODULE,
  193. .open = cciss_open, 
  194. .release        = cciss_release,
  195.         .ioctl = cciss_ioctl,
  196. #ifdef CONFIG_COMPAT
  197. .compat_ioctl   = cciss_compat_ioctl,
  198. #endif
  199. .revalidate_disk= cciss_revalidate,
  200. };
  202. /*
  203.  * Enqueuing and dequeuing functions for cmdlists.
  204.  */
  205. static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c)
  206. {
  207.         if (*Qptr == NULL) {
  208.                 *Qptr = c;
  209.                 c->next = c->prev = c;
  210.         } else {
  211.                 c->prev = (*Qptr)->prev;
  212.                 c->next = (*Qptr);
  213.                 (*Qptr)->prev->next = c;
  214.                 (*Qptr)->prev = c;
  215.         }
  216. }
  218. static inline CommandList_struct *removeQ(CommandList_struct **Qptr, 
  219. CommandList_struct *c)
  220. {
  221.         if (c && c->next != c) {
  222.                 if (*Qptr == c) *Qptr = c->next;
  223.                 c->prev->next = c->next;
  224.                 c->next->prev = c->prev;
  225.         } else {
  226.                 *Qptr = NULL;
  227.         }
  228.         return c;
  229. }
  231. #include "cciss_scsi.c" /* For SCSI tape support */
  233. #ifdef CONFIG_PROC_FS
  235. /*
  236.  * Report information about this controller.
  237.  */
  238. #define ENG_GIG 1000000000
  239. #define ENG_GIG_FACTOR (ENG_GIG/512)
  240. #define RAID_UNKNOWN 6
  241. static const char *raid_label[] = {"0","4","1(1+0)","5","5+1","ADG",
  242.                                    "UNKNOWN"};
  244. static struct proc_dir_entry *proc_cciss;
  246. static int cciss_proc_get_info(char *buffer, char **start, off_t offset, 
  247. int length, int *eof, void *data)
  248. {
  249.         off_t pos = 0;
  250.         off_t len = 0;
  251.         int size, i, ctlr;
  252.         ctlr_info_t *h = (ctlr_info_t*)data;
  253.         drive_info_struct *drv;
  254. unsigned long flags;
  255.         sector_t vol_sz, vol_sz_frac;
  257.         ctlr = h->ctlr;
  259. /* prevent displaying bogus info during configuration
  260.  * or deconfiguration of a logical volume
  261.  */
  262. spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
  263. if (h->busy_configuring) {
  264. spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
  265. return -EBUSY;
  266. }
  267. h->busy_configuring = 1;
  268. spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
  270.         size = sprintf(buffer, "%s: HP %s Controllern"
  271. "Board ID: 0x%08lxn"
  272. "Firmware Version: %c%c%c%cn"
  273. "IRQ: %dn"
  274. "Logical drives: %dn"
  275. "Current Q depth: %dn"
  276. "Current # commands on controller: %dn"
  277. "Max Q depth since init: %dn"
  278. "Max # commands on controller since init: %dn"
  279. "Max SG entries since init: %dnn",
  280.                 h->devname,
  281.                 h->product_name,
  282.                 (unsigned long)h->board_id,
  283. h->firm_ver[0], h->firm_ver[1], h->firm_ver[2], h->firm_ver[3],
  284.                 (unsigned int)h->intr,
  285.                 h->num_luns, 
  286. h->Qdepth, h->commands_outstanding,
  287. h->maxQsinceinit, h->max_outstanding, h->maxSG);
  289.         pos += size; len += size;
  290. cciss_proc_tape_report(ctlr, buffer, &pos, &len);
  291. for(i=0; i<=h->highest_lun; i++) {
  293.                 drv = &h->drv[i];
  294. if (drv->heads == 0)
  295. continue;
  297. vol_sz = drv->nr_blocks;
  298. vol_sz_frac = sector_div(vol_sz, ENG_GIG_FACTOR);
  299. vol_sz_frac *= 100;
  300. sector_div(vol_sz_frac, ENG_GIG_FACTOR);
  302. if (drv->raid_level > 5)
  303. drv->raid_level = RAID_UNKNOWN;
  304. size = sprintf(buffer+len, "cciss/c%dd%d:"
  305. "t%4u.%02uGBtRAID %sn",
  306. ctlr, i, (int)vol_sz, (int)vol_sz_frac,
  307. raid_label[drv->raid_level]);
  308.                 pos += size; len += size;
  309.         }
  311.         *eof = 1;
  312.         *start = buffer+offset;
  313.         len -= offset;
  314.         if (len>length)
  315.                 len = length;
  316. h->busy_configuring = 0;
  317.         return len;
  318. }
  320. static int 
  321. cciss_proc_write(struct file *file, const char __user *buffer, 
  322. unsigned long count, void *data)
  323. {
  324. unsigned char cmd[80];
  325. int len;
  326. #ifdef CONFIG_CISS_SCSI_TAPE
  327. ctlr_info_t *h = (ctlr_info_t *) data;
  328. int rc;
  329. #endif
  331. if (count > sizeof(cmd)-1) return -EINVAL;
  332. if (copy_from_user(cmd, buffer, count)) return -EFAULT;
  333. cmd[count] = '';
  334. len = strlen(cmd); // above 3 lines ensure safety
  335. if (len && cmd[len-1] == 'n')
  336. cmd[--len] = '';
  337. # ifdef CONFIG_CISS_SCSI_TAPE
  338. if (strcmp("engage scsi", cmd)==0) {
  339. rc = cciss_engage_scsi(h->ctlr);
  340. if (rc != 0) return -rc;
  341. return count;
  342. }
  343. /* might be nice to have "disengage" too, but it's not 
  344.    safely possible. (only 1 module use count, lock issues.) */
  345. # endif
  346. return -EINVAL;
  347. }
  349. /*
  350.  * Get us a file in /proc/cciss that says something about each controller.
  351.  * Create /proc/cciss if it doesn't exist yet.
  352.  */
  353. static void __devinit cciss_procinit(int i)
  354. {
  355. struct proc_dir_entry *pde;
  357.         if (proc_cciss == NULL) {
  358.                 proc_cciss = proc_mkdir("cciss", proc_root_driver);
  359.                 if (!proc_cciss) 
  360. return;
  361.         }
  363. pde = create_proc_read_entry(hba[i]->devname, 
  364. S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH, 
  365. proc_cciss, cciss_proc_get_info, hba[i]);
  366. pde->write_proc = cciss_proc_write;
  367. }
  368. #endif /* CONFIG_PROC_FS */
  370. /* 
  371.  * For operations that cannot sleep, a command block is allocated at init, 
  372.  * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
  373.  * which ones are free or in use.  For operations that can wait for kmalloc 
  374.  * to possible sleep, this routine can be called with get_from_pool set to 0. 
  375.  * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was. 
  376.  */ 
  377. static CommandList_struct * cmd_alloc(ctlr_info_t *h, int get_from_pool)
  378. {
  379. CommandList_struct *c;
  380. int i; 
  381. u64bit temp64;
  382. dma_addr_t cmd_dma_handle, err_dma_handle;
  384. if (!get_from_pool)
  385. {
  386. c = (CommandList_struct *) pci_alloc_consistent(
  387. h->pdev, sizeof(CommandList_struct), &cmd_dma_handle); 
  388.          if(c==NULL)
  389.                   return NULL;
  390. memset(c, 0, sizeof(CommandList_struct));
  392. c->cmdindex = -1;
  394. c->err_info = (ErrorInfo_struct *)pci_alloc_consistent(
  395. h->pdev, sizeof(ErrorInfo_struct), 
  396. &err_dma_handle);
  398. if (c->err_info == NULL)
  399. {
  400. pci_free_consistent(h->pdev, 
  401. sizeof(CommandList_struct), c, cmd_dma_handle);
  402. return NULL;
  403. }
  404. memset(c->err_info, 0, sizeof(ErrorInfo_struct));
  405. } else /* get it out of the controllers pool */ 
  406. {
  407.       do {
  408.                  i = find_first_zero_bit(h->cmd_pool_bits, NR_CMDS);
  409.                         if (i == NR_CMDS)
  410.                                 return NULL;
  411.                 } while(test_and_set_bit(i & (BITS_PER_LONG - 1), h->cmd_pool_bits+(i/BITS_PER_LONG)) != 0);
  412. #ifdef CCISS_DEBUG
  413. printk(KERN_DEBUG "cciss: using command buffer %dn", i);
  414. #endif
  415.                 c = h->cmd_pool + i;
  416. memset(c, 0, sizeof(CommandList_struct));
  417. cmd_dma_handle = h->cmd_pool_dhandle 
  418. + i*sizeof(CommandList_struct);
  419. c->err_info = h->errinfo_pool + i;
  420. memset(c->err_info, 0, sizeof(ErrorInfo_struct));
  421. err_dma_handle = h->errinfo_pool_dhandle 
  422. + i*sizeof(ErrorInfo_struct);
  423.                 h->nr_allocs++;
  425. c->cmdindex = i;
  426.         }
  428. c->busaddr = (__u32) cmd_dma_handle;
  429. temp64.val = (__u64) err_dma_handle;
  430. c->ErrDesc.Addr.lower = temp64.val32.lower;
  431. c->ErrDesc.Addr.upper = temp64.val32.upper;
  432. c->ErrDesc.Len = sizeof(ErrorInfo_struct);
  434. c->ctlr = h->ctlr;
  435.         return c;
  438. }
  440. /* 
  441.  * Frees a command block that was previously allocated with cmd_alloc(). 
  442.  */
  443. static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
  444. {
  445. int i;
  446. u64bit temp64;
  448. if( !got_from_pool)
  449. { 
  450. temp64.val32.lower = c->ErrDesc.Addr.lower;
  451. temp64.val32.upper = c->ErrDesc.Addr.upper;
  452. pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct), 
  453. c->err_info, (dma_addr_t) temp64.val);
  454. pci_free_consistent(h->pdev, sizeof(CommandList_struct), 
  455. c, (dma_addr_t) c->busaddr);
  456. } else 
  457. {
  458. i = c - h->cmd_pool;
  459. clear_bit(i&(BITS_PER_LONG-1), h->cmd_pool_bits+(i/BITS_PER_LONG));
  460.                 h->nr_frees++;
  461.         }
  462. }
  464. static inline ctlr_info_t *get_host(struct gendisk *disk)
  465. {
  466. return disk->queue->queuedata; 
  467. }
  469. static inline drive_info_struct *get_drv(struct gendisk *disk)
  470. {
  471. return disk->private_data;
  472. }
  474. /*
  475.  * Open.  Make sure the device is really there.
  476.  */
  477. static int cciss_open(struct inode *inode, struct file *filep)
  478. {
  479. ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
  480. drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
  482. #ifdef CCISS_DEBUG
  483. printk(KERN_DEBUG "cciss_open %sn", inode->i_bdev->bd_disk->disk_name);
  484. #endif /* CCISS_DEBUG */ 
  486. if (host->busy_initializing || drv->busy_configuring)
  487. return -EBUSY;
  488. /*
  489.  * Root is allowed to open raw volume zero even if it's not configured
  490.  * so array config can still work. Root is also allowed to open any
  491.  * volume that has a LUN ID, so it can issue IOCTL to reread the
  492.  * disk information.  I don't think I really like this
  493.  * but I'm already using way to many device nodes to claim another one
  494.  * for "raw controller".
  495.  */
  496. if (drv->nr_blocks == 0) {
  497. if (iminor(inode) != 0) {  /* not node 0? */
  498. /* if not node 0 make sure it is a partition = 0 */
  499. if (iminor(inode) & 0x0f) {
  500. return -ENXIO;
  501. /* if it is, make sure we have a LUN ID */
  502. } else if (drv->LunID == 0) {
  503. return -ENXIO;
  504. }
  505. }
  506. if (!capable(CAP_SYS_ADMIN))
  507. return -EPERM;
  508. }
  509. drv->usage_count++;
  510. host->usage_count++;
  511. return 0;
  512. }
  513. /*
  514.  * Close.  Sync first.
  515.  */
  516. static int cciss_release(struct inode *inode, struct file *filep)
  517. {
  518. ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
  519. drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
  521. #ifdef CCISS_DEBUG
  522. printk(KERN_DEBUG "cciss_release %sn", inode->i_bdev->bd_disk->disk_name);
  523. #endif /* CCISS_DEBUG */
  525. drv->usage_count--;
  526. host->usage_count--;
  527. return 0;
  528. }
  530. #ifdef CONFIG_COMPAT
  532. static int do_ioctl(struct file *f, unsigned cmd, unsigned long arg)
  533. {
  534. int ret;
  535. lock_kernel();
  536. ret = cciss_ioctl(f->f_dentry->d_inode, f, cmd, arg);
  537. unlock_kernel();
  538. return ret;
  539. }
  541. static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long arg);
  542. static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd, unsigned long arg);
  544. static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
  545. {
  546. switch (cmd) {
  547. case CCISS_GETPCIINFO:
  548. case CCISS_GETINTINFO:
  549. case CCISS_SETINTINFO:
  550. case CCISS_GETNODENAME:
  551. case CCISS_SETNODENAME:
  552. case CCISS_GETHEARTBEAT:
  553. case CCISS_GETBUSTYPES:
  554. case CCISS_GETFIRMVER:
  555. case CCISS_GETDRIVVER:
  556. case CCISS_REVALIDVOLS:
  557. case CCISS_DEREGDISK:
  558. case CCISS_REGNEWDISK:
  559. case CCISS_REGNEWD:
  560. case CCISS_RESCANDISK:
  561. case CCISS_GETLUNINFO:
  562. return do_ioctl(f, cmd, arg);
  564. case CCISS_PASSTHRU32:
  565. return cciss_ioctl32_passthru(f, cmd, arg);
  566. case CCISS_BIG_PASSTHRU32:
  567. return cciss_ioctl32_big_passthru(f, cmd, arg);
  569. default:
  570. return -ENOIOCTLCMD;
  571. }
  572. }
  574. static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long arg)
  575. {
  576. IOCTL32_Command_struct __user *arg32 =
  577. (IOCTL32_Command_struct __user *) arg;
  578. IOCTL_Command_struct arg64;
  579. IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
  580. int err;
  581. u32 cp;
  583. err = 0;
  584. err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info, sizeof(arg64.LUN_info));
  585. err |= copy_from_user(&arg64.Request, &arg32->Request, sizeof(arg64.Request));
  586. err |= copy_from_user(&arg64.error_info, &arg32->error_info, sizeof(arg64.error_info));
  587. err |= get_user(arg64.buf_size, &arg32->buf_size);
  588. err |= get_user(cp, &arg32->buf);
  589. arg64.buf = compat_ptr(cp);
  590. err |= copy_to_user(p, &arg64, sizeof(arg64));
  592. if (err)
  593. return -EFAULT;
  595. err = do_ioctl(f, CCISS_PASSTHRU, (unsigned long) p);
  596. if (err)
  597. return err;
  598. err |= copy_in_user(&arg32->error_info, &p->error_info, sizeof(arg32->error_info));
  599. if (err)
  600. return -EFAULT;
  601. return err;
  602. }
  604. static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd, unsigned long arg)
  605. {
  606. BIG_IOCTL32_Command_struct __user *arg32 =
  607. (BIG_IOCTL32_Command_struct __user *) arg;
  608. BIG_IOCTL_Command_struct arg64;
  609. BIG_IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
  610. int err;
  611. u32 cp;
  613. err = 0;
  614. err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info, sizeof(arg64.LUN_info));
  615. err |= copy_from_user(&arg64.Request, &arg32->Request, sizeof(arg64.Request));
  616. err |= copy_from_user(&arg64.error_info, &arg32->error_info, sizeof(arg64.error_info));
  617. err |= get_user(arg64.buf_size, &arg32->buf_size);
  618. err |= get_user(arg64.malloc_size, &arg32->malloc_size);
  619. err |= get_user(cp, &arg32->buf);
  620. arg64.buf = compat_ptr(cp);
  621. err |= copy_to_user(p, &arg64, sizeof(arg64));
  623. if (err)
  624.  return -EFAULT;
  626. err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long) p);
  627. if (err)
  628. return err;
  629. err |= copy_in_user(&arg32->error_info, &p->error_info, sizeof(arg32->error_info));
  630. if (err)
  631. return -EFAULT;
  632. return err;
  633. }
  634. #endif
  635. /*
  636.  * ioctl 
  637.  */
  638. static int cciss_ioctl(struct inode *inode, struct file *filep, 
  639. unsigned int cmd, unsigned long arg)
  640. {
  641. struct block_device *bdev = inode->i_bdev;
  642. struct gendisk *disk = bdev->bd_disk;
  643. ctlr_info_t *host = get_host(disk);
  644. drive_info_struct *drv = get_drv(disk);
  645. int ctlr = host->ctlr;
  646. void __user *argp = (void __user *)arg;
  648. #ifdef CCISS_DEBUG
  649. printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lxn", cmd, arg);
  650. #endif /* CCISS_DEBUG */ 
  652. switch(cmd) {
  653. case HDIO_GETGEO:
  654. {
  655.                 struct hd_geometry driver_geo;
  656.                 if (drv->cylinders) {
  657.                         driver_geo.heads = drv->heads;
  658.                         driver_geo.sectors = drv->sectors;
  659.                         driver_geo.cylinders = drv->cylinders;
  660.                 } else
  661. return -ENXIO;
  662.                 driver_geo.start= get_start_sect(inode->i_bdev);
  663.                 if (copy_to_user(argp, &driver_geo, sizeof(struct hd_geometry)))
  664.                         return  -EFAULT;
  665.                 return(0);
  666. }
  668. case CCISS_GETPCIINFO:
  669. {
  670. cciss_pci_info_struct pciinfo;
  672. if (!arg) return -EINVAL;
  673. pciinfo.domain = pci_domain_nr(host->pdev->bus);
  674. pciinfo.bus = host->pdev->bus->number;
  675. pciinfo.dev_fn = host->pdev->devfn;
  676. pciinfo.board_id = host->board_id;
  677. if (copy_to_user(argp, &pciinfo,  sizeof( cciss_pci_info_struct )))
  678. return  -EFAULT;
  679. return(0);
  680. }
  681. case CCISS_GETINTINFO:
  682. {
  683. cciss_coalint_struct intinfo;
  684. if (!arg) return -EINVAL;
  685. intinfo.delay = readl(&host->cfgtable->HostWrite.CoalIntDelay);
  686. intinfo.count = readl(&host->cfgtable->HostWrite.CoalIntCount);
  687. if (copy_to_user(argp, &intinfo, sizeof( cciss_coalint_struct )))
  688. return -EFAULT;
  689.                 return(0);
  690.         }
  691. case CCISS_SETINTINFO:
  692.         {
  693.                 cciss_coalint_struct intinfo;
  694. unsigned long flags;
  695. int i;
  697. if (!arg) return -EINVAL;
  698. if (!capable(CAP_SYS_ADMIN)) return -EPERM;
  699. if (copy_from_user(&intinfo, argp, sizeof( cciss_coalint_struct)))
  700. return -EFAULT;
  701. if ( (intinfo.delay == 0 ) && (intinfo.count == 0))
  703. {
  704. // printk("cciss_ioctl: delay and count cannot be 0n");
  705. return( -EINVAL);
  706. }
  707. spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
  708. /* Update the field, and then ring the doorbell */ 
  709. writel( intinfo.delay, 
  710. &(host->cfgtable->HostWrite.CoalIntDelay));
  711. writel( intinfo.count, 
  712.                         &(host->cfgtable->HostWrite.CoalIntCount));
  713. writel( CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
  715. for(i=0;i<MAX_IOCTL_CONFIG_WAIT;i++) {
  716. if (!(readl(host->vaddr + SA5_DOORBELL) 
  717. & CFGTBL_ChangeReq))
  718. break;
  719. /* delay and try again */
  720. udelay(1000);
  721. }
  722. spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
  723. if (i >= MAX_IOCTL_CONFIG_WAIT)
  724. return -EAGAIN;
  725.                 return(0);
  726.         }
  727. case CCISS_GETNODENAME:
  728.         {
  729.                 NodeName_type NodeName;
  730. int i; 
  732. if (!arg) return -EINVAL;
  733. for(i=0;i<16;i++)
  734. NodeName[i] = readb(&host->cfgtable->ServerName[i]);
  735.                 if (copy_to_user(argp, NodeName, sizeof( NodeName_type)))
  736.                  return  -EFAULT;
  737.                 return(0);
  738.         }
  739. case CCISS_SETNODENAME:
  740. {
  741. NodeName_type NodeName;
  742. unsigned long flags;
  743. int i;
  745. if (!arg) return -EINVAL;
  746. if (!capable(CAP_SYS_ADMIN)) return -EPERM;
  748. if (copy_from_user(NodeName, argp, sizeof( NodeName_type)))
  749. return -EFAULT;
  751. spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
  753. /* Update the field, and then ring the doorbell */ 
  754. for(i=0;i<16;i++)
  755. writeb( NodeName[i], &host->cfgtable->ServerName[i]);
  757. writel( CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
  759. for(i=0;i<MAX_IOCTL_CONFIG_WAIT;i++) {
  760. if (!(readl(host->vaddr + SA5_DOORBELL) 
  761. & CFGTBL_ChangeReq))
  762. break;
  763. /* delay and try again */
  764. udelay(1000);
  765. }
  766. spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
  767. if (i >= MAX_IOCTL_CONFIG_WAIT)
  768. return -EAGAIN;
  769.                 return(0);
  770.         }
  772. case CCISS_GETHEARTBEAT:
  773.         {
  774.                 Heartbeat_type heartbeat;
  776. if (!arg) return -EINVAL;
  777.                 heartbeat = readl(&host->cfgtable->HeartBeat);
  778.                 if (copy_to_user(argp, &heartbeat, sizeof( Heartbeat_type)))
  779.                  return -EFAULT;
  780.                 return(0);
  781.         }
  782. case CCISS_GETBUSTYPES:
  783.         {
  784.                 BusTypes_type BusTypes;
  786. if (!arg) return -EINVAL;
  787.                 BusTypes = readl(&host->cfgtable->BusTypes);
  788.                 if (copy_to_user(argp, &BusTypes, sizeof( BusTypes_type) ))
  789.                  return  -EFAULT;
  790.                 return(0);
  791.         }
  792. case CCISS_GETFIRMVER:
  793.         {
  794. FirmwareVer_type firmware;
  796. if (!arg) return -EINVAL;
  797. memcpy(firmware, host->firm_ver, 4);
  799.                 if (copy_to_user(argp, firmware, sizeof( FirmwareVer_type)))
  800.                  return -EFAULT;
  801.                 return(0);
  802.         }
  803.         case CCISS_GETDRIVVER:
  804.         {
  805. DriverVer_type DriverVer = DRIVER_VERSION;
  807.                 if (!arg) return -EINVAL;
  809.                 if (copy_to_user(argp, &DriverVer, sizeof( DriverVer_type) ))
  810.                  return -EFAULT;
  811.                 return(0);
  812.         }
  814. case CCISS_REVALIDVOLS:
  815. if (bdev != bdev->bd_contains || drv != host->drv)
  816. return -ENXIO;
  817.                 return revalidate_allvol(host);
  819.   case CCISS_GETLUNINFO: {
  820.   LogvolInfo_struct luninfo;
  821.  
  822.   luninfo.LunID = drv->LunID;
  823.   luninfo.num_opens = drv->usage_count;
  824.   luninfo.num_parts = 0;
  825.   if (copy_to_user(argp, &luninfo,
  826.   sizeof(LogvolInfo_struct)))
  827.   return -EFAULT;
  828.   return(0);
  829.   }
  830. case CCISS_DEREGDISK:
  831. return rebuild_lun_table(host, disk);
  833. case CCISS_REGNEWD:
  834. return rebuild_lun_table(host, NULL);
  836. case CCISS_PASSTHRU:
  837. {
  838. IOCTL_Command_struct iocommand;
  839. CommandList_struct *c;
  840. char  *buff = NULL;
  841. u64bit temp64;
  842. unsigned long flags;
  843. DECLARE_COMPLETION(wait);
  845. if (!arg) return -EINVAL;
  847. if (!capable(CAP_SYS_RAWIO)) return -EPERM;
  849. if (copy_from_user(&iocommand, argp, sizeof( IOCTL_Command_struct) ))
  850. return -EFAULT;
  851. if((iocommand.buf_size < 1) && 
  852. (iocommand.Request.Type.Direction != XFER_NONE))
  853. {
  854. return -EINVAL;
  855. } 
  856. #if 0 /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */
  857. /* Check kmalloc limits */
  858. if(iocommand.buf_size > 128000)
  859. return -EINVAL;
  860. #endif
  861. if(iocommand.buf_size > 0)
  862. {
  863. buff =  kmalloc(iocommand.buf_size, GFP_KERNEL);
  864. if( buff == NULL) 
  865. return -EFAULT;
  866. }
  867. if (iocommand.Request.Type.Direction == XFER_WRITE)
  868. {
  869. /* Copy the data into the buffer we created */ 
  870. if (copy_from_user(buff, iocommand.buf, iocommand.buf_size))
  871. {
  872. kfree(buff);
  873. return -EFAULT;
  874. }
  875. } else {
  876. memset(buff, 0, iocommand.buf_size);
  877. }
  878. if ((c = cmd_alloc(host , 0)) == NULL)
  879. {
  880. kfree(buff);
  881. return -ENOMEM;
  882. }
  883. // Fill in the command type 
  884. c->cmd_type = CMD_IOCTL_PEND;
  885. // Fill in Command Header 
  886. c->Header.ReplyQueue = 0;  // unused in simple mode
  887. if( iocommand.buf_size > 0)  // buffer to fill 
  888. {
  889. c->Header.SGList = 1;
  890. c->Header.SGTotal= 1;
  891. } else // no buffers to fill  
  892. {
  893. c->Header.SGList = 0;
  894.                  c->Header.SGTotal= 0;
  895. }
  896. c->Header.LUN = iocommand.LUN_info;
  897. c->Header.Tag.lower = c->busaddr;  // use the kernel address the cmd block for tag
  899. // Fill in Request block 
  900. c->Request = iocommand.Request; 
  902. // Fill in the scatter gather information
  903. if (iocommand.buf_size > 0 ) 
  904. {
  905. temp64.val = pci_map_single( host->pdev, buff,
  906.                                         iocommand.buf_size, 
  907.                                 PCI_DMA_BIDIRECTIONAL);
  908. c->SG[0].Addr.lower = temp64.val32.lower;
  909. c->SG[0].Addr.upper = temp64.val32.upper;
  910. c->SG[0].Len = iocommand.buf_size;
  911. c->SG[0].Ext = 0;  // we are not chaining
  912. }
  913. c->waiting = &wait;
  915. /* Put the request on the tail of the request queue */
  916. spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
  917. addQ(&host->reqQ, c);
  918. host->Qdepth++;
  919. start_io(host);
  920. spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
  922. wait_for_completion(&wait);
  924. /* unlock the buffers from DMA */
  925. temp64.val32.lower = c->SG[0].Addr.lower;
  926.                 temp64.val32.upper = c->SG[0].Addr.upper;
  927.                 pci_unmap_single( host->pdev, (dma_addr_t) temp64.val,
  928.                  iocommand.buf_size, PCI_DMA_BIDIRECTIONAL);
  930. /* Copy the error information out */ 
  931. iocommand.error_info = *(c->err_info);
  932. if ( copy_to_user(argp, &iocommand, sizeof( IOCTL_Command_struct) ) )
  933. {
  934. kfree(buff);
  935. cmd_free(host, c, 0);
  936. return( -EFAULT);
  937. } 
  939. if (iocommand.Request.Type.Direction == XFER_READ)
  940.                 {
  941.                         /* Copy the data out of the buffer we created */
  942.                         if (copy_to_user(iocommand.buf, buff, iocommand.buf_size))
  943. {
  944.                          kfree(buff);
  945. cmd_free(host, c, 0);
  946. return -EFAULT;
  947. }
  948.                 }
  949.                 kfree(buff);
  950. cmd_free(host, c, 0);
  951.                 return(0);
  952. } 
  953. case CCISS_BIG_PASSTHRU: {
  954. BIG_IOCTL_Command_struct *ioc;
  955. CommandList_struct *c;
  956. unsigned char **buff = NULL;
  957. int *buff_size = NULL;
  958. u64bit temp64;
  959. unsigned long flags;
  960. BYTE sg_used = 0;
  961. int status = 0;
  962. int i;
  963. DECLARE_COMPLETION(wait);
  964. __u32   left;
  965. __u32 sz;
  966. BYTE    __user *data_ptr;
  968. if (!arg)
  969. return -EINVAL;
  970. if (!capable(CAP_SYS_RAWIO))
  971. return -EPERM;
  972. ioc = (BIG_IOCTL_Command_struct *) 
  973. kmalloc(sizeof(*ioc), GFP_KERNEL);
  974. if (!ioc) {
  975. status = -ENOMEM;
  976. goto cleanup1;
  977. }
  978. if (copy_from_user(ioc, argp, sizeof(*ioc))) {
  979. status = -EFAULT;
  980. goto cleanup1;
  981. }
  982. if ((ioc->buf_size < 1) &&
  983. (ioc->Request.Type.Direction != XFER_NONE)) {
  984. status = -EINVAL;
  985. goto cleanup1;
  986. }
  987. /* Check kmalloc limits  using all SGs */
  988. if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
  989. status = -EINVAL;
  990. goto cleanup1;
  991. }
  992. if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
  993. status = -EINVAL;
  994. goto cleanup1;
  995. }
  996. buff = (unsigned char **) kmalloc(MAXSGENTRIES * 
  997. sizeof(char *), GFP_KERNEL);
  998. if (!buff) {
  999. status = -ENOMEM;
  1000. goto cleanup1;
  1001. }
  1002. memset(buff, 0, MAXSGENTRIES);
  1003. buff_size = (int *) kmalloc(MAXSGENTRIES * sizeof(int), 
  1004. GFP_KERNEL);
  1005. if (!buff_size) {
  1006. status = -ENOMEM;
  1007. goto cleanup1;
  1008. }
  1009. left = ioc->buf_size;
  1010. data_ptr = ioc->buf;
  1011. while (left) {
  1012. sz = (left > ioc->malloc_size) ? ioc->malloc_size : left;
  1013. buff_size[sg_used] = sz;
  1014. buff[sg_used] = kmalloc(sz, GFP_KERNEL);
  1015. if (buff[sg_used] == NULL) {
  1016. status = -ENOMEM;
  1017. goto cleanup1;
  1018. }
  1019. if (ioc->Request.Type.Direction == XFER_WRITE &&
  1020. copy_from_user(buff[sg_used], data_ptr, sz)) {
  1021. status = -ENOMEM;
  1022. goto cleanup1;
  1023. } else {
  1024. memset(buff[sg_used], 0, sz);
  1025. }
  1026. left -= sz;
  1027. data_ptr += sz;
  1028. sg_used++;
  1029. }
  1030. if ((c = cmd_alloc(host , 0)) == NULL) {
  1031. status = -ENOMEM;
  1032. goto cleanup1;
  1033. }
  1034. c->cmd_type = CMD_IOCTL_PEND;
  1035. c->Header.ReplyQueue = 0;
  1037. if( ioc->buf_size > 0) {
  1038. c->Header.SGList = sg_used;
  1039. c->Header.SGTotal= sg_used;
  1040. } else { 
  1041. c->Header.SGList = 0;
  1042. c->Header.SGTotal= 0;
  1043. }
  1044. c->Header.LUN = ioc->LUN_info;
  1045. c->Header.Tag.lower = c->busaddr;
  1047. c->Request = ioc->Request;
  1048. if (ioc->buf_size > 0 ) {
  1049. int i;
  1050. for(i=0; i<sg_used; i++) {
  1051. temp64.val = pci_map_single( host->pdev, buff[i],
  1052. buff_size[i],
  1053. PCI_DMA_BIDIRECTIONAL);
  1054. c->SG[i].Addr.lower = temp64.val32.lower;
  1055. c->SG[i].Addr.upper = temp64.val32.upper;
  1056. c->SG[i].Len = buff_size[i];
  1057. c->SG[i].Ext = 0;  /* we are not chaining */
  1058. }
  1059. }
  1060. c->waiting = &wait;
  1061. /* Put the request on the tail of the request queue */
  1062. spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
  1063. addQ(&host->reqQ, c);
  1064. host->Qdepth++;
  1065. start_io(host);
  1066. spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
  1067. wait_for_completion(&wait);
  1068. /* unlock the buffers from DMA */
  1069. for(i=0; i<sg_used; i++) {
  1070. temp64.val32.lower = c->SG[i].Addr.lower;
  1071. temp64.val32.upper = c->SG[i].Addr.upper;
  1072. pci_unmap_single( host->pdev, (dma_addr_t) temp64.val,
  1073. buff_size[i], PCI_DMA_BIDIRECTIONAL);
  1074. }
  1075. /* Copy the error information out */
  1076. ioc->error_info = *(c->err_info);
  1077. if (copy_to_user(argp, ioc, sizeof(*ioc))) {
  1078. cmd_free(host, c, 0);
  1079. status = -EFAULT;
  1080. goto cleanup1;
  1081. }
  1082. if (ioc->Request.Type.Direction == XFER_READ) {
  1083. /* Copy the data out of the buffer we created */
  1084. BYTE __user *ptr = ioc->buf;
  1085.          for(i=0; i< sg_used; i++) {
  1086. if (copy_to_user(ptr, buff[i], buff_size[i])) {
  1087. cmd_free(host, c, 0);
  1088. status = -EFAULT;
  1089. goto cleanup1;
  1090. }
  1091. ptr += buff_size[i];
  1092. }
  1093. }
  1094. cmd_free(host, c, 0);
  1095. status = 0;
  1096. cleanup1:
  1097. if (buff) {
  1098. for(i=0; i<sg_used; i++)
  1099. if(buff[i] != NULL)
  1100. kfree(buff[i]);
  1101. kfree(buff);
  1102. }
  1103. if (buff_size)
  1104. kfree(buff_size);
  1105. if (ioc)
  1106. kfree(ioc);
  1107. return(status);
  1108. }
  1109. default:
  1110. return -ENOTTY;
  1111. }
  1113. }
  1115. /*
  1116.  * revalidate_allvol is for online array config utilities.  After a
  1117.  * utility reconfigures the drives in the array, it can use this function
  1118.  * (through an ioctl) to make the driver zap any previous disk structs for
  1119.  * that controller and get new ones.
  1120.  *
  1121.  * Right now I'm using the getgeometry() function to do this, but this
  1122.  * function should probably be finer grained and allow you to revalidate one
  1123.  * particualar logical volume (instead of all of them on a particular
  1124.  * controller).
  1125.  */
  1126. static int revalidate_allvol(ctlr_info_t *host)
  1127. {
  1128. int ctlr = host->ctlr, i;
  1129. unsigned long flags;
  1131.         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
  1132.         if (host->usage_count > 1) {
  1133.                 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
  1134.                 printk(KERN_WARNING "cciss: Device busy for volume"
  1135.                         " revalidation (usage=%d)n", host->usage_count);
  1136.                 return -EBUSY;
  1137.         }
  1138.         host->usage_count++;
  1139. spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
  1141. for(i=0; i< NWD; i++) {
  1142. struct gendisk *disk = host->gendisk[i];
  1143. if (disk->flags & GENHD_FL_UP)
  1144. del_gendisk(disk);
  1145. }
  1147.         /*
  1148.          * Set the partition and block size structures for all volumes
  1149.          * on this controller to zero.  We will reread all of this data
  1150.          */
  1151.         memset(host->drv,        0, sizeof(drive_info_struct)
  1152. * CISS_MAX_LUN);
  1153.         /*
  1154.          * Tell the array controller not to give us any interrupts while
  1155.          * we check the new geometry.  Then turn interrupts back on when
  1156.          * we're done.
  1157.          */
  1158.         host->access.set_intr_mask(host, CCISS_INTR_OFF);
  1159.         cciss_getgeometry(ctlr);
  1160.         host->access.set_intr_mask(host, CCISS_INTR_ON);
  1162. /* Loop through each real device */ 
  1163. for (i = 0; i < NWD; i++) {
  1164. struct gendisk *disk = host->gendisk[i];
  1165. drive_info_struct *drv = &(host->drv[i]);
  1166. /* we must register the controller even if no disks exist */
  1167. /* this is for the online array utilities */
  1168. if (!drv->heads && i)
  1169. continue;
  1170. blk_queue_hardsect_size(drv->queue, drv->block_size);
  1171. set_capacity(disk, drv->nr_blocks);
  1172. add_disk(disk);
  1173. }
  1174.         host->usage_count--;
  1175.         return 0;
  1176. }
  1178. /* This function will check the usage_count of the drive to be updated/added.
  1179.  * If the usage_count is zero then the drive information will be updated and
  1180.  * the disk will be re-registered with the kernel.  If not then it will be
  1181.  * left alone for the next reboot.  The exception to this is disk 0 which
  1182.  * will always be left registered with the kernel since it is also the
  1183.  * controller node.  Any changes to disk 0 will show up on the next
  1184.  * reboot.
  1185. */
  1186. static void cciss_update_drive_info(int ctlr, int drv_index)
  1187.   {
  1188. ctlr_info_t *h = hba[ctlr];
  1189. struct gendisk *disk;
  1190. ReadCapdata_struct *size_buff = NULL;
  1191. InquiryData_struct *inq_buff = NULL;
  1192. unsigned int block_size;
  1193. unsigned int total_size;
  1194. unsigned long flags = 0;
  1195. int ret = 0;
  1197. /* if the disk already exists then deregister it before proceeding*/
  1198. if (h->drv[drv_index].raid_level != -1){
  1199. spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
  1200. h->drv[drv_index].busy_configuring = 1;
  1201. spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
  1202. ret = deregister_disk(h->gendisk[drv_index],
  1203. &h->drv[drv_index], 0);
  1204. h->drv[drv_index].busy_configuring = 0;
  1205. }
  1207. /* If the disk is in use return */
  1208. if (ret)
  1209. return;
  1212. /* Get information about the disk and modify the driver sturcture */
  1213. size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
  1214.         if (size_buff == NULL)
  1215. goto mem_msg;
  1216. inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
  1217. if (inq_buff == NULL)
  1218. goto mem_msg;
  1220. cciss_read_capacity(ctlr, drv_index, size_buff, 1,
  1221. &total_size, &block_size);
  1222. cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
  1223. inq_buff, &h->drv[drv_index]);
  1225. ++h->num_luns;
  1226. disk = h->gendisk[drv_index];
  1227. set_capacity(disk, h->drv[drv_index].nr_blocks);
  1230. /* if it's the controller it's already added */
  1231. if (drv_index){
  1232. disk->queue = blk_init_queue(do_cciss_request, &h->lock);
  1234. /* Set up queue information */
  1235. disk->queue->backing_dev_info.ra_pages = READ_AHEAD;
  1236. blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask);
  1238. /* This is a hardware imposed limit. */
  1239. blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);
  1241. /* This is a limit in the driver and could be eliminated. */
  1242. blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
  1244. blk_queue_max_sectors(disk->queue, 512);
  1246. disk->queue->queuedata = hba[ctlr];
  1248. blk_queue_hardsect_size(disk->queue,
  1249. hba[ctlr]->drv[drv_index].block_size);
  1251. h->drv[drv_index].queue = disk->queue;
  1252. add_disk(disk);
  1253. }
  1255. freeret:
  1256. kfree(size_buff);
  1257. kfree(inq_buff);
  1258. return;
  1259. mem_msg:
  1260. printk(KERN_ERR "cciss: out of memoryn");
  1261. goto freeret;
  1262. }
  1264. /* This function will find the first index of the controllers drive array
  1265.  * that has a -1 for the raid_level and will return that index.  This is
  1266.  * where new drives will be added.  If the index to be returned is greater
  1267.  * than the highest_lun index for the controller then highest_lun is set
  1268.  * to this new index.  If there are no available indexes then -1 is returned.
  1269. */
  1270. static int cciss_find_free_drive_index(int ctlr)
  1271. {
  1272. int i;
  1274. for (i=0; i < CISS_MAX_LUN; i++){
  1275. if (hba[ctlr]->drv[i].raid_level == -1){
  1276. if (i > hba[ctlr]->highest_lun)
  1277. hba[ctlr]->highest_lun = i;
  1278. return i;
  1279. }
  1280. }
  1281. return -1;
  1282. }
  1284. /* This function will add and remove logical drives from the Logical
  1285.  * drive array of the controller and maintain persistancy of ordering
  1286.  * so that mount points are preserved until the next reboot.  This allows
  1287.  * for the removal of logical drives in the middle of the drive array
  1288.  * without a re-ordering of those drives.
  1289.  * INPUT
  1290.  * h = The controller to perform the operations on
  1291.  * del_disk = The disk to remove if specified.  If the value given
  1292.  *   is NULL then no disk is removed.
  1293. */
  1294. static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
  1295. {
  1296. int ctlr = h->ctlr;
  1297. int num_luns;
  1298. ReportLunData_struct *ld_buff = NULL;
  1299. drive_info_struct *drv = NULL;
  1300. int return_code;
  1301. int listlength = 0;
  1302. int i;
  1303. int drv_found;
  1304. int drv_index = 0;
  1305. __u32 lunid = 0;
  1306. unsigned long flags;
  1308. /* Set busy_configuring flag for this operation */
  1309. spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
  1310. if (h->num_luns >= CISS_MAX_LUN){
  1311. spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
  1312. return -EINVAL;
  1313. }
  1315. if (h->busy_configuring){
  1316. spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
  1317. return -EBUSY;
  1318. }
  1319. h->busy_configuring = 1;
  1321. /* if del_disk is NULL then we are being called to add a new disk
  1322.  * and update the logical drive table.  If it is not NULL then
  1323.  * we will check if the disk is in use or not.
  1324.  */
  1325. if (del_disk != NULL){
  1326. drv = get_drv(del_disk);
  1327. drv->busy_configuring = 1;
  1328. spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
  1329. return_code = deregister_disk(del_disk, drv, 1);
  1330. drv->busy_configuring = 0;
  1331. h->busy_configuring = 0;
  1332. return return_code;
  1333. } else {
  1334. spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
  1335. if (!capable(CAP_SYS_RAWIO))
  1336. return -EPERM;
  1338. ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
  1339. if (ld_buff == NULL)
  1340. goto mem_msg;
  1342. return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
  1343. sizeof(ReportLunData_struct), 0, 0, 0,
  1344. TYPE_CMD);
  1346. if (return_code == IO_OK){
  1347. listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
  1348. listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
  1349. listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
  1350. listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
  1351. } else{ /* reading number of logical volumes failed */
  1352. printk(KERN_WARNING "cciss: report logical volume"
  1353. " command failedn");
  1354. listlength = 0;
  1355. goto freeret;
  1356. }
  1358. num_luns = listlength / 8; /* 8 bytes per entry */
  1359. if (num_luns > CISS_MAX_LUN){
  1360. num_luns = CISS_MAX_LUN;
  1361. printk(KERN_WARNING "cciss: more luns configured"
  1362. " on controller than can be handled by"
  1363. " this driver.n");
  1364. }
  1366. /* Compare controller drive array to drivers drive array.
  1367.   * Check for updates in the drive information and any new drives
  1368.   * on the controller.
  1369.   */
  1370. for (i=0; i < num_luns; i++){
  1371. int j;
  1373. drv_found = 0;
  1375.    lunid = (0xff &
  1376. (unsigned int)(ld_buff->LUN[i][3])) << 24;
  1377.          lunid |= (0xff &
  1378. (unsigned int)(ld_buff->LUN[i][2])) << 16;
  1379.          lunid |= (0xff &
  1380. (unsigned int)(ld_buff->LUN[i][1])) << 8;
  1381.          lunid |= 0xff &
  1382. (unsigned int)(ld_buff->LUN[i][0]);
  1384. /* Find if the LUN is already in the drive array
  1385.  * of the controller.  If so then update its info
  1386.  * if not is use.  If it does not exist then find
  1387.  * the first free index and add it.
  1388. */
  1389. for (j=0; j <= h->highest_lun; j++){
  1390. if (h->drv[j].LunID == lunid){
  1391. drv_index = j;
  1392. drv_found = 1;
  1393. }
  1394. }
  1396. /* check if the drive was found already in the array */
  1397. if (!drv_found){
  1398. drv_index = cciss_find_free_drive_index(ctlr);
  1399. if (drv_index == -1)
  1400. goto freeret;
  1402. }
  1403. h->drv[drv_index].LunID = lunid;
  1404. cciss_update_drive_info(ctlr, drv_index);
  1405. } /* end for */
  1406. } /* end else */
  1408. freeret:
  1409. kfree(ld_buff);
  1410. h->busy_configuring = 0;
  1411. /* We return -1 here to tell the ACU that we have registered/updated
  1412.  * all of the drives that we can and to keep it from calling us
  1413.  * additional times.
  1414. */
  1415. return -1;
  1416. mem_msg:
  1417. printk(KERN_ERR "cciss: out of memoryn");
  1418. goto freeret;
  1419. }
  1421. /* This function will deregister the disk and it's queue from the
  1422.  * kernel.  It must be called with the controller lock held and the
  1423.  * drv structures busy_configuring flag set.  It's parameters are:
  1424.  *
  1425.  * disk = This is the disk to be deregistered
  1426.  * drv  = This is the drive_info_struct associated with the disk to be
  1427.  *        deregistered.  It contains information about the disk used
  1428.  *        by the driver.
  1429.  * clear_all = This flag determines whether or not the disk information
  1430.  *             is going to be completely cleared out and the highest_lun
  1431.  *             reset.  Sometimes we want to clear out information about
  1432.  *             the disk in preperation for re-adding it.  In this case
  1433.  *             the highest_lun should be left unchanged and the LunID
  1434.  *             should not be cleared.
  1435. */
  1436. static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
  1437.    int clear_all)
  1438. {
  1439. ctlr_info_t *h = get_host(disk);
  1441. if (!capable(CAP_SYS_RAWIO))
  1442. return -EPERM;
  1444. /* make sure logical volume is NOT is use */
  1445. if(clear_all || (h->gendisk[0] == disk)) {
  1446. if (drv->usage_count > 1)
  1447.                 return -EBUSY;
  1448. }
  1449.         else
  1450.          if( drv->usage_count > 0 )
  1451.                  return -EBUSY;
  1453. /* invalidate the devices and deregister the disk.  If it is disk
  1454.  * zero do not deregister it but just zero out it's values.  This
  1455.  * allows us to delete disk zero but keep the controller registered.
  1456. */
  1457. if (h->gendisk[0] != disk){
  1458. if (disk->flags & GENHD_FL_UP){
  1459. blk_cleanup_queue(disk->queue);
  1460. del_gendisk(disk);
  1461. drv->queue = NULL;
  1462. }
  1463. }
  1465. --h->num_luns;
  1466. /* zero out the disk size info */
  1467. drv->nr_blocks = 0;
  1468. drv->block_size = 0;
  1469. drv->heads = 0;
  1470. drv->sectors = 0;
  1471. drv->cylinders = 0;
  1472. drv->raid_level = -1; /* This can be used as a flag variable to
  1473.  * indicate that this element of the drive
  1474.  * array is free.
  1475. */
  1477. if (clear_all){
  1478. /* check to see if it was the last disk */
  1479. if (drv == h->drv + h->highest_lun) {
  1480. /* if so, find the new hightest lun */
  1481. int i, newhighest =-1;
  1482. for(i=0; i<h->highest_lun; i++) {
  1483. /* if the disk has size > 0, it is available */
  1484. if (h->drv[i].heads)
  1485. newhighest = i;
  1486. }
  1487. h->highest_lun = newhighest;
  1488. }
  1490. drv->LunID = 0;
  1491. }
  1492. return(0);
  1493. }
  1495. static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
  1496. size_t size,
  1497. unsigned int use_unit_num, /* 0: address the controller,
  1498.       1: address logical volume log_unit,
  1499.       2: periph device address is scsi3addr */
  1500. unsigned int log_unit, __u8 page_code, unsigned char *scsi3addr,
  1501. int cmd_type)
  1502. {
  1503. ctlr_info_t *h= hba[ctlr];
  1504. u64bit buff_dma_handle;
  1505. int status = IO_OK;
  1507. c->cmd_type = CMD_IOCTL_PEND;
  1508. c->Header.ReplyQueue = 0;
  1509. if( buff != NULL) {
  1510. c->Header.SGList = 1;
  1511. c->Header.SGTotal= 1;
  1512. } else {
  1513. c->Header.SGList = 0;
  1514.                 c->Header.SGTotal= 0;
  1515. }
  1516. c->Header.Tag.lower = c->busaddr;
  1518. c->Request.Type.Type = cmd_type;
  1519. if (cmd_type == TYPE_CMD) {
  1520. switch(cmd) {
  1521. case  CISS_INQUIRY:
  1522. /* If the logical unit number is 0 then, this is going
  1523. to controller so It's a physical command
  1524. mode = 0 target = 0.  So we have nothing to write.
  1525. otherwise, if use_unit_num == 1,
  1526. mode = 1(volume set addressing) target = LUNID
  1527. otherwise, if use_unit_num == 2,
  1528. mode = 0(periph dev addr) target = scsi3addr */
  1529. if (use_unit_num == 1) {
  1530. c->Header.LUN.LogDev.VolId=
  1531. h->drv[log_unit].LunID;
  1532.                          c->Header.LUN.LogDev.Mode = 1;
  1533. } else if (use_unit_num == 2) {
  1534. memcpy(c->Header.LUN.LunAddrBytes,scsi3addr,8);
  1535. c->Header.LUN.LogDev.Mode = 0;
  1536. }
  1537. /* are we trying to read a vital product page */
  1538. if(page_code != 0) {
  1539. c->Request.CDB[1] = 0x01;
  1540. c->Request.CDB[2] = page_code;
  1541. }
  1542. c->Request.CDBLen = 6;
  1543. c->Request.Type.Attribute = ATTR_SIMPLE;  
  1544. c->Request.Type.Direction = XFER_READ;
  1545. c->Request.Timeout = 0;
  1546. c->Request.CDB[0] =  CISS_INQUIRY;
  1547. c->Request.CDB[4] = size  & 0xFF;  
  1548. break;
  1549. case CISS_REPORT_LOG:
  1550. case CISS_REPORT_PHYS:
  1551.                         /* Talking to controller so It's a physical command
  1552.    mode = 00 target = 0.  Nothing to write.
  1553.                         */
  1554. c->Request.CDBLen = 12;
  1555. c->Request.Type.Attribute = ATTR_SIMPLE;
  1556. c->Request.Type.Direction = XFER_READ;
  1557. c->Request.Timeout = 0;
  1558. c->Request.CDB[0] = cmd;
  1559. c->Request.CDB[6] = (size >> 24) & 0xFF;  //MSB
  1560. c->Request.CDB[7] = (size >> 16) & 0xFF;
  1561. c->Request.CDB[8] = (size >> 8) & 0xFF;
  1562. c->Request.CDB[9] = size & 0xFF;
  1563. break;
  1565. case CCISS_READ_CAPACITY:
  1566. c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
  1567. c->Header.LUN.LogDev.Mode = 1;
  1568. c->Request.CDBLen = 10;
  1569. c->Request.Type.Attribute = ATTR_SIMPLE;
  1570. c->Request.Type.Direction = XFER_READ;
  1571. c->Request.Timeout = 0;
  1572. c->Request.CDB[0] = cmd;
  1573. break;
  1574. case CCISS_CACHE_FLUSH:
  1575. c->Request.CDBLen = 12;
  1576. c->Request.Type.Attribute = ATTR_SIMPLE;
  1577. c->Request.Type.Direction = XFER_WRITE;
  1578. c->Request.Timeout = 0;
  1579. c->Request.CDB[0] = BMIC_WRITE;
  1580. c->Request.CDB[6] = BMIC_CACHE_FLUSH;
  1581. break;
  1582. default:
  1583. printk(KERN_WARNING
  1584. "cciss%d:  Unknown Command 0x%cn", ctlr, cmd);
  1585. return(IO_ERROR);
  1586. }
  1587. } else if (cmd_type == TYPE_MSG) {
  1588. switch (cmd) {
  1589. case 3: /* No-Op message */
  1590. c->Request.CDBLen = 1;
  1591. c->Request.Type.Attribute = ATTR_SIMPLE;
  1592. c->Request.Type.Direction = XFER_WRITE;
  1593. c->Request.Timeout = 0;
  1594. c->Request.CDB[0] = cmd;
  1595. break;
  1596. default:
  1597. printk(KERN_WARNING
  1598. "cciss%d: unknown message type %dn",
  1599. ctlr, cmd);
  1600. return IO_ERROR;
  1601. }
  1602. } else {
  1603. printk(KERN_WARNING
  1604. "cciss%d: unknown command type %dn", ctlr, cmd_type);
  1605. return IO_ERROR;
  1606. }
  1607. /* Fill in the scatter gather information */
  1608. if (size > 0) {
  1609. buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
  1610. buff, size, PCI_DMA_BIDIRECTIONAL);
  1611. c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
  1612. c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
  1613. c->SG[0].Len = size;
  1614. c->SG[0].Ext = 0;  /* we are not chaining */
  1615. }
  1616. return status;
  1617. }
  1618. static int sendcmd_withirq(__u8 cmd,
  1619. int ctlr,
  1620. void *buff,
  1621. size_t size,
  1622. unsigned int use_unit_num,
  1623. unsigned int log_unit,
  1624. __u8 page_code,
  1625. int cmd_type)
  1626. {
  1627. ctlr_info_t *h = hba[ctlr];
  1628. CommandList_struct *c;
  1629. u64bit buff_dma_handle;
  1630. unsigned long flags;
  1631. int return_status;
  1632. DECLARE_COMPLETION(wait);
  1634. if ((c = cmd_alloc(h , 0)) == NULL)
  1635. return -ENOMEM;
  1636. return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
  1637. log_unit, page_code, NULL, cmd_type);
  1638. if (return_status != IO_OK) {
  1639. cmd_free(h, c, 0);
  1640. return return_status;
  1641. }
  1642. resend_cmd2:
  1643. c->waiting = &wait;
  1645. /* Put the request on the tail of the queue and send it */
  1646. spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
  1647. addQ(&h->reqQ, c);
  1648. h->Qdepth++;
  1649. start_io(h);
  1650. spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
  1652. wait_for_completion(&wait);
  1654. if(c->err_info->CommandStatus != 0) 
  1655. { /* an error has occurred */ 
  1656. switch(c->err_info->CommandStatus)
  1657. {
  1658. case CMD_TARGET_STATUS:
  1659. printk(KERN_WARNING "cciss: cmd %p has "
  1660. " completed with errorsn", c);
  1661. if( c->err_info->ScsiStatus)
  1662.                  {
  1663.                      printk(KERN_WARNING "cciss: cmd %p "
  1664. "has SCSI Status = %xn",
  1665.                          c,  
  1666. c->err_info->ScsiStatus);
  1667.                  }
  1669. break;
  1670. case CMD_DATA_UNDERRUN:
  1671. case CMD_DATA_OVERRUN:
  1672. /* expected for inquire and report lun commands */
  1673. break;
  1674. case CMD_INVALID:
  1675. printk(KERN_WARNING "cciss: Cmd %p is "
  1676. "reported invalidn", c);
  1677. return_status = IO_ERROR;
  1678. break;
  1679. case CMD_PROTOCOL_ERR:
  1680.                                 printk(KERN_WARNING "cciss: cmd %p has "
  1681. "protocol error n", c);
  1682.                                 return_status = IO_ERROR;
  1683.                         break;
  1684. case CMD_HARDWARE_ERR:
  1685.                                 printk(KERN_WARNING "cciss: cmd %p had " 
  1686.                                         " hardware errorn", c);
  1687.                                 return_status = IO_ERROR;
  1688.                         break;
  1689. case CMD_CONNECTION_LOST:
  1690. printk(KERN_WARNING "cciss: cmd %p had "
  1691. "connection lostn", c);
  1692. return_status = IO_ERROR;
  1693. break;
  1694. case CMD_ABORTED:
  1695. printk(KERN_WARNING "cciss: cmd %p was "
  1696. "abortedn", c);
  1697. return_status = IO_ERROR;
  1698. break;
  1699. case CMD_ABORT_FAILED:
  1700. printk(KERN_WARNING "cciss: cmd %p reports "
  1701. "abort failedn", c);
  1702. return_status = IO_ERROR;
  1703. break;
  1704. case CMD_UNSOLICITED_ABORT:
  1705. printk(KERN_WARNING 
  1706. "cciss%d: unsolicited abort %pn",
  1707. ctlr, c);
  1708. if (c->retry_count < MAX_CMD_RETRIES) {
  1709. printk(KERN_WARNING 
  1710. "cciss%d: retrying %pn", 
  1711. ctlr, c);
  1712. c->retry_count++;
  1713. /* erase the old error information */
  1714. memset(c->err_info, 0,
  1715. sizeof(ErrorInfo_struct));
  1716. return_status = IO_OK;
  1717. INIT_COMPLETION(wait);
  1718. goto resend_cmd2;
  1719. }
  1720. return_status = IO_ERROR;
  1721. break;
  1722. default:
  1723. printk(KERN_WARNING "cciss: cmd %p returned "
  1724. "unknown status %xn", c, 
  1725. c->err_info->CommandStatus); 
  1726. return_status = IO_ERROR;
  1727. }
  1728. }
  1729. /* unlock the buffers from DMA */
  1730. buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
  1731. buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
  1732. pci_unmap_single( h->pdev, (dma_addr_t) buff_dma_handle.val,
  1733. c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
  1734. cmd_free(h, c, 0);
  1735.         return(return_status);
  1737. }
  1738. static void cciss_geometry_inquiry(int ctlr, int logvol,
  1739. int withirq, unsigned int total_size,
  1740. unsigned int block_size, InquiryData_struct *inq_buff,
  1741. drive_info_struct *drv)
  1742. {
  1743. int return_code;
  1744. memset(inq_buff, 0, sizeof(InquiryData_struct));
  1745. if (withirq)
  1746. return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
  1747. inq_buff, sizeof(*inq_buff), 1, logvol ,0xC1, TYPE_CMD);
  1748. else
  1749. return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
  1750. sizeof(*inq_buff), 1, logvol ,0xC1, NULL, TYPE_CMD);
  1751. if (return_code == IO_OK) {
  1752. if(inq_buff->data_byte[8] == 0xFF) {
  1753. printk(KERN_WARNING
  1754. "cciss: reading geometry failed, volume "
  1755. "does not support reading geometryn");
  1756. drv->block_size = block_size;
  1757. drv->nr_blocks = total_size;
  1758. drv->heads = 255;
  1759. drv->sectors = 32; // Sectors per track
  1760. drv->cylinders = total_size / 255 / 32;
  1761. } else {
  1762. unsigned int t;
  1764. drv->block_size = block_size;
  1765. drv->nr_blocks = total_size;
  1766. drv->heads = inq_buff->data_byte[6];
  1767. drv->sectors = inq_buff->data_byte[7];
  1768. drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
  1769. drv->cylinders += inq_buff->data_byte[5];
  1770. drv->raid_level = inq_buff->data_byte[8];
  1771. t = drv->heads * drv->sectors;
  1772. if (t > 1) {
  1773. drv->cylinders = total_size/t;
  1774. }
  1775. }
  1776. } else { /* Get geometry failed */
  1777. printk(KERN_WARNING "cciss: reading geometry failedn");
  1778. }
  1779. printk(KERN_INFO "      heads= %d, sectors= %d, cylinders= %dnn",
  1780. drv->heads, drv->sectors, drv->cylinders);
  1781. }
  1782. static void
  1783. cciss_read_capacity(int ctlr, int logvol, ReadCapdata_struct *buf,
  1784. int withirq, unsigned int *total_size, unsigned int *block_size)
  1785. {
  1786. int return_code;
  1787. memset(buf, 0, sizeof(*buf));
  1788. if (withirq)
  1789. return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
  1790. ctlr, buf, sizeof(*buf), 1, logvol, 0, TYPE_CMD);
  1791. else
  1792. return_code = sendcmd(CCISS_READ_CAPACITY,
  1793. ctlr, buf, sizeof(*buf), 1, logvol, 0, NULL, TYPE_CMD);
  1794. if (return_code == IO_OK) {
  1795. *total_size = be32_to_cpu(*((__be32 *) &buf->total_size[0]))+1;
  1796. *block_size = be32_to_cpu(*((__be32 *) &buf->block_size[0]));
  1797. } else { /* read capacity command failed */
  1798. printk(KERN_WARNING "cciss: read capacity failedn");
  1799. *total_size = 0;
  1800. *block_size = BLOCK_SIZE;
  1801. }
  1802. printk(KERN_INFO "      blocks= %u block_size= %dn",
  1803. *total_size, *block_size);
  1804. return;
  1805. }
  1807. static int cciss_revalidate(struct gendisk *disk)
  1808. {
  1809. ctlr_info_t *h = get_host(disk);
  1810. drive_info_struct *drv = get_drv(disk);
  1811. int logvol;
  1812. int FOUND=0;
  1813. unsigned int block_size;
  1814. unsigned int total_size;
  1815. ReadCapdata_struct *size_buff = NULL;
  1816. InquiryData_struct *inq_buff = NULL;
  1818. for(logvol=0; logvol < CISS_MAX_LUN; logvol++)
  1819. {
  1820. if(h->drv[logvol].LunID == drv->LunID) {
  1821. FOUND=1;
  1822. break;
  1823. }
  1824. }
  1826. if (!FOUND) return 1;
  1828. size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
  1829.         if (size_buff == NULL)
  1830.         {
  1831.                 printk(KERN_WARNING "cciss: out of memoryn");
  1832.                 return 1;
  1833.         }
  1834. inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
  1835.         if (inq_buff == NULL)
  1836.         {
  1837.                 printk(KERN_WARNING "cciss: out of memoryn");
  1838. kfree(size_buff);
  1839.                 return 1;
  1840.         }
  1842. cciss_read_capacity(h->ctlr, logvol, size_buff, 1, &total_size, &block_size);
  1843. cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size, inq_buff, drv);
  1845. blk_queue_hardsect_size(drv->queue, drv->block_size);
  1846. set_capacity(disk, drv->nr_blocks);
  1848. kfree(size_buff);
  1849. kfree(inq_buff);
  1850. return 0;
  1851. }
  1853. /*
  1854.  *   Wait polling for a command to complete.
  1855.  *   The memory mapped FIFO is polled for the completion.
  1856.  *   Used only at init time, interrupts from the HBA are disabled.
  1857.  */
  1858. static unsigned long pollcomplete(int ctlr)
  1859. {
  1860. unsigned long done;
  1861. int i;
  1863. /* Wait (up to 20 seconds) for a command to complete */
  1865. for (i = 20 * HZ; i > 0; i--) {
  1866. done = hba[ctlr]->access.command_completed(hba[ctlr]);
  1867. if (done == FIFO_EMPTY)
  1868. schedule_timeout_uninterruptible(1);
  1869. else
  1870. return (done);
  1871. }
  1872. /* Invalid address to tell caller we ran out of time */
  1873. return 1;
  1874. }
  1875. /*
  1876.  * Send a command to the controller, and wait for it to complete.  
  1877.  * Only used at init time. 
  1878.  */
  1879. static int sendcmd(
  1880. __u8 cmd,
  1881. int ctlr,
  1882. void *buff,
  1883. size_t size,
  1884. unsigned int use_unit_num, /* 0: address the controller,
  1885.       1: address logical volume log_unit, 
  1886.       2: periph device address is scsi3addr */
  1887. unsigned int log_unit,
  1888. __u8 page_code,
  1889. unsigned char *scsi3addr,
  1890. int cmd_type)
  1891. {
  1892. CommandList_struct *c;
  1893. int i;
  1894. unsigned long complete;
  1895. ctlr_info_t *info_p= hba[ctlr];
  1896. u64bit buff_dma_handle;
  1897. int status;
  1899. if ((c = cmd_alloc(info_p, 1)) == NULL) {
  1900. printk(KERN_WARNING "cciss: unable to get memory");
  1901. return(IO_ERROR);
  1902. }
  1903. status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
  1904. log_unit, page_code, scsi3addr, cmd_type);
  1905. if (status != IO_OK) {
  1906. cmd_free(info_p, c, 1);
  1907. return status;
  1908. }
  1909. resend_cmd1:
  1910. /*
  1911.          * Disable interrupt
  1912.          */
  1913. #ifdef CCISS_DEBUG
  1914. printk(KERN_DEBUG "cciss: turning intr offn");
  1915. #endif /* CCISS_DEBUG */ 
  1916.         info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
  1918. /* Make sure there is room in the command FIFO */
  1919.         /* Actually it should be completely empty at this time. */
  1920.         for (i = 200000; i > 0; i--) 
  1921. {
  1922. /* if fifo isn't full go */
  1923.                 if (!(info_p->access.fifo_full(info_p))) 
  1924. {
  1926.                         break;
  1927.                 }
  1928.                 udelay(10);
  1929.                 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
  1930.                         " waiting!n", ctlr);
  1931.         }
  1932.         /*
  1933.          * Send the cmd
  1934.          */
  1935.         info_p->access.submit_command(info_p, c);
  1936.         complete = pollcomplete(ctlr);
  1938. #ifdef CCISS_DEBUG
  1939. printk(KERN_DEBUG "cciss: command completedn");
  1940. #endif /* CCISS_DEBUG */
  1942. if (complete != 1) {
  1943. if ( (complete & CISS_ERROR_BIT)
  1944.      && (complete & ~CISS_ERROR_BIT) == c->busaddr)
  1945.      {
  1946. /* if data overrun or underun on Report command 
  1947. ignore it 
  1948. */
  1949. if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
  1950.      (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
  1951.      (c->Request.CDB[0] == CISS_INQUIRY)) &&
  1952. ((c->err_info->CommandStatus == 
  1953. CMD_DATA_OVERRUN) || 
  1954.  (c->err_info->CommandStatus == 
  1955. CMD_DATA_UNDERRUN)
  1956.   ))
  1957. {
  1958. complete = c->busaddr;
  1959. } else {
  1960. if (c->err_info->CommandStatus ==
  1961. CMD_UNSOLICITED_ABORT) {
  1962. printk(KERN_WARNING "cciss%d: "
  1963. "unsolicited abort %pn",
  1964. ctlr, c);
  1965. if (c->retry_count < MAX_CMD_RETRIES) {
  1966. printk(KERN_WARNING
  1967.    "cciss%d: retrying %pn",
  1968.    ctlr, c);
  1969. c->retry_count++;
  1970. /* erase the old error */
  1971. /* information */
  1972. memset(c->err_info, 0,
  1973.    sizeof(ErrorInfo_struct));
  1974. goto resend_cmd1;
  1975. } else {
  1976. printk(KERN_WARNING
  1977.    "cciss%d: retried %p too "
  1978.    "many timesn", ctlr, c);
  1979. status = IO_ERROR;
  1980. goto cleanup1;
  1981. }
  1982. }
  1983. printk(KERN_WARNING "ciss ciss%d: sendcmd"
  1984. " Error %x n", ctlr, 
  1985. c->err_info->CommandStatus); 
  1986. printk(KERN_WARNING "ciss ciss%d: sendcmd"
  1987. " offensive infon"
  1988. "  size %xn   num %x   value %xn", ctlr,
  1989.   c->err_info->MoreErrInfo.Invalid_Cmd.offense_size,
  1990.   c->err_info->MoreErrInfo.Invalid_Cmd.offense_num,
  1991.   c->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
  1992. status = IO_ERROR;
  1993. goto cleanup1;
  1994. }
  1995. }
  1996.                 if (complete != c->busaddr) {
  1997.                         printk( KERN_WARNING "cciss cciss%d: SendCmd "
  1998.                       "Invalid command list address returned! (%lx)n",
  1999.                                 ctlr, complete);
  2000. status = IO_ERROR;
  2001. goto cleanup1;
  2002.                 }
  2003.         } else {
  2004.                 printk( KERN_WARNING
  2005.                         "cciss cciss%d: SendCmd Timeout out, "
  2006.                         "No command list address returned!n",
  2007.                         ctlr);
  2008. status = IO_ERROR;
  2009.         }
  2011. cleanup1:
  2012. /* unlock the data buffer from DMA */
  2013. buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
  2014. buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
  2015. pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
  2016. c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
  2017. cmd_free(info_p, c, 1);
  2018. return (status);
  2019. } 
  2020. /*
  2021.  * Map (physical) PCI mem into (virtual) kernel space
  2022.  */
  2023. static void __iomem *remap_pci_mem(ulong base, ulong size)
  2024. {
  2025.         ulong page_base        = ((ulong) base) & PAGE_MASK;
  2026.         ulong page_offs        = ((ulong) base) - page_base;
  2027.         void __iomem *page_remapped = ioremap(page_base, page_offs+size);
  2029.         return page_remapped ? (page_remapped + page_offs) : NULL;
  2030. }
  2032. /* 
  2033.  * Takes jobs of the Q and sends them to the hardware, then puts it on 
  2034.  * the Q to wait for completion. 
  2035.  */ 
  2036. static void start_io( ctlr_info_t *h)
  2037. {
  2038. CommandList_struct *c;
  2040. while(( c = h->reqQ) != NULL )
  2041. {
  2042. /* can't do anything if fifo is full */
  2043. if ((h->access.fifo_full(h))) {
  2044. printk(KERN_WARNING "cciss: fifo fulln");
  2045. break;
  2046. }
  2048. /* Get the frist entry from the Request Q */ 
  2049. removeQ(&(h->reqQ), c);
  2050. h->Qdepth--;
  2052. /* Tell the controller execute command */ 
  2053. h->access.submit_command(h, c);
  2055. /* Put job onto the completed Q */ 
  2056. addQ (&(h->cmpQ), c); 
  2057. }
  2058. }
  2060. static inline void complete_buffers(struct bio *bio, int status)
  2061. {
  2062. while (bio) {
  2063. struct bio *xbh = bio->bi_next; 
  2064. int nr_sectors = bio_sectors(bio);
  2066. bio->bi_next = NULL; 
  2067. blk_finished_io(len);
  2068. bio_endio(bio, nr_sectors << 9, status ? 0 : -EIO);
  2069. bio = xbh;
  2070. }
  2072. } 
  2073. /* Assumes that CCISS_LOCK(h->ctlr) is held. */
  2074. /* Zeros out the error record and then resends the command back */
  2075. /* to the controller */
  2076. static inline void resend_cciss_cmd( ctlr_info_t *h, CommandList_struct *c)
  2077. {
  2078. /* erase the old error information */
  2079. memset(c->err_info, 0, sizeof(ErrorInfo_struct));
  2081. /* add it to software queue and then send it to the controller */
  2082. addQ(&(h->reqQ),c);
  2083. h->Qdepth++;
  2084. if(h->Qdepth > h->maxQsinceinit)
  2085. h->maxQsinceinit = h->Qdepth;
  2087. start_io(h);
  2088. }
  2089. /* checks the status of the job and calls complete buffers to mark all 
  2090.  * buffers for the completed job. 
  2091.  */ 
  2092. static inline void complete_command( ctlr_info_t *h, CommandList_struct *cmd,
  2093. int timeout)
  2094. {
  2095. int status = 1;
  2096. int i;
  2097. int retry_cmd = 0;
  2098. u64bit temp64;
  2100. if (timeout)
  2101. status = 0; 
  2103. if(cmd->err_info->CommandStatus != 0) 
  2104. { /* an error has occurred */ 
  2105. switch(cmd->err_info->CommandStatus)
  2106. {
  2107. unsigned char sense_key;
  2108. case CMD_TARGET_STATUS:
  2109. status = 0;
  2111. if( cmd->err_info->ScsiStatus == 0x02)
  2112. {
  2113. printk(KERN_WARNING "cciss: cmd %p "
  2114.                                          "has CHECK CONDITION "
  2115. " byte 2 = 0x%xn", cmd,
  2116. cmd->err_info->SenseInfo[2]
  2117. );
  2118. /* check the sense key */
  2119. sense_key = 0xf & 
  2120. cmd->err_info->SenseInfo[2];
  2121. /* no status or recovered error */
  2122. if((sense_key == 0x0) ||
  2123.     (sense_key == 0x1))
  2124. {
  2125. status = 1;
  2126. }
  2127. } else
  2128. {
  2129. printk(KERN_WARNING "cciss: cmd %p "
  2130.                                                 "has SCSI Status 0x%xn",
  2131. cmd, cmd->err_info->ScsiStatus);
  2132. }
  2133. break;
  2134. case CMD_DATA_UNDERRUN:
  2135. printk(KERN_WARNING "cciss: cmd %p has"
  2136. " completed with data underrun "
  2137. "reportedn", cmd);
  2138. break;
  2139. case CMD_DATA_OVERRUN:
  2140. printk(KERN_WARNING "cciss: cmd %p has"
  2141. " completed with data overrun "
  2142. "reportedn", cmd);
  2143. break;
  2144. case CMD_INVALID:
  2145. printk(KERN_WARNING "cciss: cmd %p is "
  2146. "reported invalidn", cmd);
  2147. status = 0;
  2148. break;
  2149. case CMD_PROTOCOL_ERR:
  2150.                                 printk(KERN_WARNING "cciss: cmd %p has "
  2151. "protocol error n", cmd);
  2152.                                 status = 0;
  2153.                         break;
  2154. case CMD_HARDWARE_ERR:
  2155.                                 printk(KERN_WARNING "cciss: cmd %p had " 
  2156.                                         " hardware errorn", cmd);
  2157.                                 status = 0;
  2158.                         break;
  2159. case CMD_CONNECTION_LOST:
  2160. printk(KERN_WARNING "cciss: cmd %p had "
  2161. "connection lostn", cmd);
  2162. status=0;
  2163. break;
  2164. case CMD_ABORTED:
  2165. printk(KERN_WARNING "cciss: cmd %p was "
  2166. "abortedn", cmd);
  2167. status=0;
  2168. break;
  2169. case CMD_ABORT_FAILED:
  2170. printk(KERN_WARNING "cciss: cmd %p reports "
  2171. "abort failedn", cmd);
  2172. status=0;
  2173. break;
  2174. case CMD_UNSOLICITED_ABORT:
  2175. printk(KERN_WARNING "cciss%d: unsolicited "
  2176. "abort %pn", h->ctlr, cmd);
  2177. if (cmd->retry_count < MAX_CMD_RETRIES) {
  2178. retry_cmd=1;
  2179. printk(KERN_WARNING
  2180. "cciss%d: retrying %pn",
  2181. h->ctlr, cmd);
  2182. cmd->retry_count++;
  2183. } else
  2184. printk(KERN_WARNING
  2185. "cciss%d: %p retried too "
  2186. "many timesn", h->ctlr, cmd);
  2187. status=0;
  2188. break;
  2189. case CMD_TIMEOUT:
  2190. printk(KERN_WARNING "cciss: cmd %p timedoutn",
  2191. cmd);
  2192. status=0;
  2193. break;
  2194. default:
  2195. printk(KERN_WARNING "cciss: cmd %p returned "
  2196. "unknown status %xn", cmd, 
  2197. cmd->err_info->CommandStatus); 
  2198. status=0;
  2199. }
  2200. }
  2201. /* We need to return this command */
  2202. if(retry_cmd) {
  2203. resend_cciss_cmd(h,cmd);
  2204. return;
  2205. }
  2206. /* command did not need to be retried */
  2207. /* unmap the DMA mapping for all the scatter gather elements */
  2208. for(i=0; i<cmd->Header.SGList; i++) {
  2209. temp64.val32.lower = cmd->SG[i].Addr.lower;
  2210. temp64.val32.upper = cmd->SG[i].Addr.upper;
  2211. pci_unmap_page(hba[cmd->ctlr]->pdev,
  2212. temp64.val, cmd->SG[i].Len,
  2213. (cmd->Request.Type.Direction == XFER_READ) ?
  2214. PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE);
  2215. }
  2216. complete_buffers(cmd->rq->bio, status);
  2218. #ifdef CCISS_DEBUG
  2219. printk("Done with %pn", cmd->rq);
  2220. #endif /* CCISS_DEBUG */ 
  2222. end_that_request_last(cmd->rq);
  2223. cmd_free(h,cmd,1);
  2224. }
  2226. /* 
  2227.  * Get a request and submit it to the controller. 
  2228.  */
  2229. static void do_cciss_request(request_queue_t *q)
  2230. {
  2231. ctlr_info_t *h= q->queuedata; 
  2232. CommandList_struct *c;
  2233. int start_blk, seg;
  2234. struct request *creq;
  2235. u64bit temp64;
  2236. struct scatterlist tmp_sg[MAXSGENTRIES];
  2237. drive_info_struct *drv;
  2238. int i, dir;
  2240. /* We call start_io here in case there is a command waiting on the
  2241.  * queue that has not been sent.
  2242. */
  2243. if (blk_queue_plugged(q))
  2244. goto startio;
  2246. queue:
  2247. creq = elv_next_request(q);
  2248. if (!creq)
  2249. goto startio;
  2251. if (creq->nr_phys_segments > MAXSGENTRIES)
  2252.                 BUG();
  2254. if (( c = cmd_alloc(h, 1)) == NULL)
  2255. goto full;
  2257. blkdev_dequeue_request(creq);
  2259. spin_unlock_irq(q->queue_lock);
  2261. c->cmd_type = CMD_RWREQ;
  2262. c->rq = creq;
  2264. /* fill in the request */ 
  2265. drv = creq->rq_disk->private_data;
  2266. c->Header.ReplyQueue = 0;  // unused in simple mode
  2267. /* got command from pool, so use the command block index instead */
  2268. /* for direct lookups. */
  2269. /* The first 2 bits are reserved for controller error reporting. */
  2270. c->Header.Tag.lower = (c->cmdindex << 3);
  2271. c->Header.Tag.lower |= 0x04; /* flag for direct lookup. */
  2272. c->Header.LUN.LogDev.VolId= drv->LunID;
  2273. c->Header.LUN.LogDev.Mode = 1;
  2274. c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
  2275. c->Request.Type.Type =  TYPE_CMD; // It is a command. 
  2276. c->Request.Type.Attribute = ATTR_SIMPLE; 
  2277. c->Request.Type.Direction = 
  2278. (rq_data_dir(creq) == READ) ? XFER_READ: XFER_WRITE; 
  2279. c->Request.Timeout = 0; // Don't time out
  2280. c->Request.CDB[0] = (rq_data_dir(creq) == READ) ? CCISS_READ : CCISS_WRITE;
  2281. start_blk = creq->sector;
  2282. #ifdef CCISS_DEBUG
  2283. printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%dn",(int) creq->sector,
  2284. (int) creq->nr_sectors);
  2285. #endif /* CCISS_DEBUG */
  2287. seg = blk_rq_map_sg(q, creq, tmp_sg);
  2289. /* get the DMA records for the setup */ 
  2290. if (c->Request.Type.Direction == XFER_READ)
  2291. dir = PCI_DMA_FROMDEVICE;
  2292. else
  2293. dir = PCI_DMA_TODEVICE;
  2295. for (i=0; i<seg; i++)
  2296. {
  2297. c->SG[i].Len = tmp_sg[i].length;
  2298. temp64.val = (__u64) pci_map_page(h->pdev, tmp_sg[i].page,
  2299.     tmp_sg[i].offset, tmp_sg[i].length,
  2300.   dir);
  2301. c->SG[i].Addr.lower = temp64.val32.lower;
  2302.                 c->SG[i].Addr.upper = temp64.val32.upper;
  2303.                 c->SG[i].Ext = 0;  // we are not chaining
  2304. }
  2305. /* track how many SG entries we are using */ 
  2306. if( seg > h->maxSG)
  2307. h->maxSG = seg; 
  2309. #ifdef CCISS_DEBUG
  2310. printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segmentsn", creq->nr_sectors, seg);
  2311. #endif /* CCISS_DEBUG */
  2313. c->Header.SGList = c->Header.SGTotal = seg;
  2314. c->Request.CDB[1]= 0;
  2315. c->Request.CDB[2]= (start_blk >> 24) & 0xff; //MSB
  2316. c->Request.CDB[3]= (start_blk >> 16) & 0xff;
  2317. c->Request.CDB[4]= (start_blk >>  8) & 0xff;
  2318. c->Request.CDB[5]= start_blk & 0xff;
  2319. c->Request.CDB[6]= 0; // (sect >> 24) & 0xff; MSB
  2320. c->Request.CDB[7]= (creq->nr_sectors >>  8) & 0xff; 
  2321. c->Request.CDB[8]= creq->nr_sectors & 0xff; 
  2322. c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
  2324. spin_lock_irq(q->queue_lock);
  2326. addQ(&(h->reqQ),c);
  2327. h->Qdepth++;
  2328. if(h->Qdepth > h->maxQsinceinit)
  2329. h->maxQsinceinit = h->Qdepth; 
  2331. goto queue;
  2332. full:
  2333. blk_stop_queue(q);
  2334. startio:
  2335. /* We will already have the driver lock here so not need
  2336.  * to lock it.
  2337. */
  2338. start_io(h);
  2339. }
  2341. static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs)
  2342. {
  2343. ctlr_info_t *h = dev_id;
  2344. CommandList_struct *c;
  2345. unsigned long flags;
  2346. __u32 a, a1, a2;
  2347. int j;
  2348. int start_queue = h->next_to_run;
  2350. /* Is this interrupt for us? */
  2351. if (( h->access.intr_pending(h) == 0) || (h->interrupts_enabled == 0))
  2352. return IRQ_NONE;
  2354. /*
  2355.  * If there are completed commands in the completion queue,
  2356.  * we had better do something about it.
  2357.  */
  2358. spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
  2359. while( h->access.intr_pending(h))
  2360. {
  2361. while((a = h->access.command_completed(h)) != FIFO_EMPTY) 
  2362. {
  2363. a1 = a;
  2364. if ((a & 0x04)) {
  2365. a2 = (a >> 3);
  2366. if (a2 >= NR_CMDS) {
  2367. printk(KERN_WARNING "cciss: controller cciss%d failed, stopping.n", h->ctlr);
  2368. fail_all_cmds(h->ctlr);
  2369. return IRQ_HANDLED;
  2370. }
  2372. c = h->cmd_pool + a2;
  2373. a = c->busaddr;
  2375. } else {
  2376. a &= ~3;
  2377. if ((c = h->cmpQ) == NULL) {
  2378. printk(KERN_WARNING "cciss: Completion of %08x ignoredn", a1);
  2379. continue;
  2380. } 
  2381. while(c->busaddr != a) {
  2382. c = c->next;
  2383. if (c == h->cmpQ) 
  2384. break;
  2385. }
  2386. }
  2387. /*
  2388.  * If we've found the command, take it off the
  2389.  * completion Q and free it
  2390.  */
  2391.  if (c->busaddr == a) {
  2392. removeQ(&h->cmpQ, c);
  2393. if (c->cmd_type == CMD_RWREQ) {
  2394. complete_command(h, c, 0);
  2395. } else if (c->cmd_type == CMD_IOCTL_PEND) {
  2396. complete(c->waiting);
  2397. }
  2398. # ifdef CONFIG_CISS_SCSI_TAPE
  2399. else if (c->cmd_type == CMD_SCSI)
  2400. complete_scsi_command(c, 0, a1);
  2401. # endif
  2402. continue;
  2403. }
  2404. }
  2405. }
  2407.   /* check to see if we have maxed out the number of commands that can
  2408.    * be placed on the queue.  If so then exit.  We do this check here
  2409.    * in case the interrupt we serviced was from an ioctl and did not
  2410.    * free any new commands.
  2411.  */
  2412.   if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
  2413.   goto cleanup;
  2415.   /* We have room on the queue for more commands.  Now we need to queue
  2416.    * them up.  We will also keep track of the next queue to run so
  2417.    * that every queue gets a chance to be started first.
  2418.   */
  2419. for (j=0; j < h->highest_lun + 1; j++){
  2420. int curr_queue = (start_queue + j) % (h->highest_lun + 1);
  2421.   /* make sure the disk has been added and the drive is real
  2422.    * because this can be called from the middle of init_one.
  2423.   */
  2424. if(!(h->drv[curr_queue].queue) ||
  2425.      !(h->drv[curr_queue].heads))
  2426.   continue;
  2427.   blk_start_queue(h->gendisk[curr_queue]->queue);
  2429.   /* check to see if we have maxed out the number of commands
  2430.    * that can be placed on the queue.
  2431.   */
  2432.   if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
  2433.   {
  2434.   if (curr_queue == start_queue){
  2435. h->next_to_run = (start_queue + 1) % (h->highest_lun + 1);
  2436.   goto cleanup;
  2437.   } else {
  2438.   h->next_to_run = curr_queue;
  2439.   goto cleanup;
  2440.   }
  2441.   } else {
  2442. curr_queue = (curr_queue + 1) % (h->highest_lun + 1);
  2443.   }
  2444.   }
  2446. cleanup:
  2447. spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
  2448. return IRQ_HANDLED;
  2449. }
  2450. /* 
  2451.  *  We cannot read the structure directly, for portablity we must use 
  2452.  *   the io functions.
  2453.  *   This is for debug only. 
  2454.  */
  2455. #ifdef CCISS_DEBUG
  2456. static void print_cfg_table( CfgTable_struct *tb)
  2457. {
  2458. int i;
  2459. char temp_name[17];
  2461. printk("Controller Configuration informationn");
  2462. printk("------------------------------------n");
  2463. for(i=0;i<4;i++)
  2464. temp_name[i] = readb(&(tb->Signature[i]));
  2465. temp_name[4]='';
  2466. printk("   Signature = %sn", temp_name); 
  2467. printk("   Spec Number = %dn", readl(&(tb->SpecValence)));
  2468. printk("   Transport methods supported = 0x%xn", 
  2469. readl(&(tb-> TransportSupport)));
  2470. printk("   Transport methods active = 0x%xn", 
  2471. readl(&(tb->TransportActive)));
  2472. printk("   Requested transport Method = 0x%xn", 
  2473. readl(&(tb->HostWrite.TransportRequest)));
  2474. printk("   Coalese Interrupt Delay = 0x%xn", 
  2475. readl(&(tb->HostWrite.CoalIntDelay)));
  2476. printk("   Coalese Interrupt Count = 0x%xn", 
  2477. readl(&(tb->HostWrite.CoalIntCount)));
  2478. printk("   Max outstanding commands = 0x%dn", 
  2479. readl(&(tb->CmdsOutMax)));
  2480. printk("   Bus Types = 0x%xn", readl(&(tb-> BusTypes)));
  2481. for(i=0;i<16;i++)
  2482. temp_name[i] = readb(&(tb->ServerName[i]));
  2483. temp_name[16] = '';
  2484. printk("   Server Name = %sn", temp_name);
  2485. printk("   Heartbeat Counter = 0x%xnnn", 
  2486. readl(&(tb->HeartBeat)));
  2487. }
  2488. #endif /* CCISS_DEBUG */ 
  2490. static void release_io_mem(ctlr_info_t *c)
  2491. {
  2492. /* if IO mem was not protected do nothing */
  2493. if( c->io_mem_addr == 0)
  2494. return;
  2495. release_region(c->io_mem_addr, c->io_mem_length);
  2496. c->io_mem_addr = 0;
  2497. c->io_mem_length = 0;
  2498. }
  2500. static int find_PCI_BAR_index(struct pci_dev *pdev,
  2501. unsigned long pci_bar_addr)
  2502. {
  2503. int i, offset, mem_type, bar_type;
  2504. if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
  2505. return 0;
  2506. offset = 0;
  2507. for (i=0; i<DEVICE_COUNT_RESOURCE; i++) {
  2508. bar_type = pci_resource_flags(pdev, i) &
  2509. PCI_BASE_ADDRESS_SPACE;
  2510. if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
  2511. offset += 4;
  2512. else {
  2513. mem_type = pci_resource_flags(pdev, i) &
  2514. PCI_BASE_ADDRESS_MEM_TYPE_MASK;
  2515. switch (mem_type) {
  2516. case PCI_BASE_ADDRESS_MEM_TYPE_32:
  2517. case PCI_BASE_ADDRESS_MEM_TYPE_1M:
  2518. offset += 4; /* 32 bit */
  2519. break;
  2520. case PCI_BASE_ADDRESS_MEM_TYPE_64:
  2521. offset += 8;
  2522. break;
  2523. default: /* reserved in PCI 2.2 */
  2524. printk(KERN_WARNING "Base address is invalidn");
  2525.         return -1;
  2526. break;
  2527. }
  2528. }
  2529.   if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
  2530. return i+1;
  2531. }
  2532. return -1;
  2533. }
  2535. static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
  2536. {
  2537. ushort subsystem_vendor_id, subsystem_device_id, command;
  2538. __u32 board_id, scratchpad = 0;
  2539. __u64 cfg_offset;
  2540. __u32 cfg_base_addr;
  2541. __u64 cfg_base_addr_index;
  2542. int i;
  2544. /* check to see if controller has been disabled */
  2545. /* BEFORE trying to enable it */
  2546. (void) pci_read_config_word(pdev, PCI_COMMAND,&command);
  2547. if(!(command & 0x02))
  2548. {
  2549. printk(KERN_WARNING "cciss: controller appears to be disabledn");
  2550. return(-1);
  2551. }
  2553. if (pci_enable_device(pdev))
  2554. {
  2555. printk(KERN_ERR "cciss: Unable to Enable PCI devicen");
  2556. return( -1);
  2557. }
  2559. subsystem_vendor_id = pdev->subsystem_vendor;
  2560. subsystem_device_id = pdev->subsystem_device;
  2561. board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
  2562. subsystem_vendor_id);
  2564. /* search for our IO range so we can protect it */
  2565. for(i=0; i<DEVICE_COUNT_RESOURCE; i++)
  2566. {
  2567. /* is this an IO range */ 
  2568. if( pci_resource_flags(pdev, i) & 0x01 ) {
  2569. c->io_mem_addr = pci_resource_start(pdev, i);
  2570. c->io_mem_length = pci_resource_end(pdev, i) -
  2571. pci_resource_start(pdev, i) +1;
  2572. #ifdef CCISS_DEBUG
  2573. printk("IO value found base_addr[%d] %lx %lxn", i,
  2574. c->io_mem_addr, c->io_mem_length);
  2575. #endif /* CCISS_DEBUG */
  2576. /* register the IO range */ 
  2577. if(!request_region( c->io_mem_addr,
  2578.                                         c->io_mem_length, "cciss"))
  2579. {
  2580. printk(KERN_WARNING "cciss I/O memory range already in use addr=%lx length=%ldn",
  2581. c->io_mem_addr, c->io_mem_length);
  2582. c->io_mem_addr= 0;
  2583. c->io_mem_length = 0;
  2584. } 
  2585. break;
  2586. }
  2587. }
  2589. #ifdef CCISS_DEBUG
  2590. printk("command = %xn", command);
  2591. printk("irq = %xn", pdev->irq);
  2592. printk("board_id = %xn", board_id);
  2593. #endif /* CCISS_DEBUG */ 
  2595. c->intr = pdev->irq;
  2597. /*
  2598.  * Memory base addr is first addr , the second points to the config
  2599.          *   table
  2600.  */
  2602. c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
  2603. #ifdef CCISS_DEBUG
  2604. printk("address 0 = %xn", c->paddr);
  2605. #endif /* CCISS_DEBUG */ 
  2606. c->vaddr = remap_pci_mem(c->paddr, 200);
  2608. /* Wait for the board to become ready.  (PCI hotplug needs this.)
  2609.  * We poll for up to 120 secs, once per 100ms. */
  2610. for (i=0; i < 1200; i++) {
  2611. scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
  2612. if (scratchpad == CCISS_FIRMWARE_READY)
  2613. break;
  2614. set_current_state(TASK_INTERRUPTIBLE);
  2615. schedule_timeout(HZ / 10); /* wait 100ms */
  2616. }
  2617. if (scratchpad != CCISS_FIRMWARE_READY) {
  2618. printk(KERN_WARNING "cciss: Board not ready.  Timed out.n");
  2619. return -1;
  2620. }
  2622. /* get the address index number */
  2623. cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET);
  2624. cfg_base_addr &= (__u32) 0x0000ffff;
  2625. #ifdef CCISS_DEBUG
  2626. printk("cfg base address = %xn", cfg_base_addr);
  2627. #endif /* CCISS_DEBUG */
  2628. cfg_base_addr_index =
  2629. find_PCI_BAR_index(pdev, cfg_base_addr);
  2630. #ifdef CCISS_DEBUG
  2631. printk("cfg base address index = %xn", cfg_base_addr_index);
  2632. #endif /* CCISS_DEBUG */
  2633. if (cfg_base_addr_index == -1) {
  2634. printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_indexn");
  2635. release_io_mem(c);
  2636. return -1;
  2637. }
  2639. cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
  2640. #ifdef CCISS_DEBUG
  2641. printk("cfg offset = %xn", cfg_offset);
  2642. #endif /* CCISS_DEBUG */
  2643. c->cfgtable =  remap_pci_mem(pci_resource_start(pdev,
  2644. cfg_base_addr_index) + cfg_offset,
  2645. sizeof(CfgTable_struct));
  2646. c->board_id = board_id;
  2648. #ifdef CCISS_DEBUG
  2649. print_cfg_table(c->cfgtable); 
  2650. #endif /* CCISS_DEBUG */
  2652. for(i=0; i<NR_PRODUCTS; i++) {
  2653. if (board_id == products[i].board_id) {
  2654. c->product_name = products[i].product_name;
  2655. c->access = *(products[i].access);
  2656. break;
  2657. }
  2658. }
  2659. if (i == NR_PRODUCTS) {
  2660. printk(KERN_WARNING "cciss: Sorry, I don't know how"
  2661. " to access the Smart Array controller %08lxn", 
  2662. (unsigned long)board_id);
  2663. return -1;
  2664. }
  2665. if (  (readb(&c->cfgtable->Signature[0]) != 'C') ||
  2666.       (readb(&c->cfgtable->Signature[1]) != 'I') ||
  2667.       (readb(&c->cfgtable->Signature[2]) != 'S') ||
  2668.       (readb(&c->cfgtable->Signature[3]) != 'S') )
  2669. {
  2670. printk("Does not appear to be a valid CISS config tablen");
  2671. return -1;
  2672. }
  2674. #ifdef CONFIG_X86
  2675. {
  2676. /* Need to enable prefetch in the SCSI core for 6400 in x86 */
  2677. __u32 prefetch;
  2678. prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
  2679. prefetch |= 0x100;
  2680. writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
  2681. }
  2682. #endif
  2684. #ifdef CCISS_DEBUG
  2685. printk("Trying to put board into Simple moden");
  2686. #endif /* CCISS_DEBUG */ 
  2687. c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
  2688. /* Update the field, and then ring the doorbell */ 
  2689. writel( CFGTBL_Trans_Simple, 
  2690. &(c->cfgtable->HostWrite.TransportRequest));
  2691. writel( CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
  2693. /* under certain very rare conditions, this can take awhile.
  2694.  * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
  2695.  * as we enter this code.) */
  2696. for(i=0;i<MAX_CONFIG_WAIT;i++) {
  2697. if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
  2698. break;
  2699. /* delay and try again */
  2700. set_current_state(TASK_INTERRUPTIBLE);
  2701. schedule_timeout(10);
  2702. }
  2704. #ifdef CCISS_DEBUG
  2705. printk(KERN_DEBUG "I counter got to %d %xn", i, readl(c->vaddr + SA5_DOORBELL));
  2706. #endif /* CCISS_DEBUG */
  2707. #ifdef CCISS_DEBUG
  2708. print_cfg_table(c->cfgtable);
  2709. #endif /* CCISS_DEBUG */ 
  2711. if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple))
  2712. {
  2713. printk(KERN_WARNING "cciss: unable to get board into"
  2714. " simple moden");
  2715. return -1;
  2716. }
  2717. return 0;
  2719. }
  2721. /* 
  2722.  * Gets information about the local volumes attached to the controller. 
  2723.  */ 
  2724. static void cciss_getgeometry(int cntl_num)
  2725. {
  2726. ReportLunData_struct *ld_buff;
  2727. ReadCapdata_struct *size_buff;
  2728. InquiryData_struct *inq_buff;
  2729. int return_code;
  2730. int i;
  2731. int listlength = 0;
  2732. __u32 lunid = 0;
  2733. int block_size;
  2734. int total_size; 
  2736. ld_buff = kmalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
  2737. if (ld_buff == NULL)
  2738. {
  2739. printk(KERN_ERR "cciss: out of memoryn");
  2740. return;
  2741. }
  2742. memset(ld_buff, 0, sizeof(ReportLunData_struct));
  2743. size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
  2744.         if (size_buff == NULL)
  2745.         {
  2746.                 printk(KERN_ERR "cciss: out of memoryn");
  2747. kfree(ld_buff);
  2748.                 return;
  2749.         }
  2750. inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
  2751.         if (inq_buff == NULL)
  2752.         {
  2753.                 printk(KERN_ERR "cciss: out of memoryn");
  2754.                 kfree(ld_buff);
  2755. kfree(size_buff);
  2756.                 return;
  2757.         }
  2758. /* Get the firmware version */ 
  2759. return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff, 
  2760. sizeof(InquiryData_struct), 0, 0 ,0, NULL, TYPE_CMD);
  2761. if (return_code == IO_OK)
  2762. {
  2763. hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
  2764. hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
  2765. hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
  2766. hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
  2767. } else /* send command failed */
  2768. {
  2769. printk(KERN_WARNING "cciss: unable to determine firmware"
  2770. " version of controllern");
  2771. }
  2772. /* Get the number of logical volumes */ 
  2773. return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff, 
  2774. sizeof(ReportLunData_struct), 0, 0, 0, NULL, TYPE_CMD);
  2776. if( return_code == IO_OK)
  2777. {
  2778. #ifdef CCISS_DEBUG
  2779. printk("LUN Datan--------------------------n");
  2780. #endif /* CCISS_DEBUG */ 
  2782. listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
  2783. listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
  2784. listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
  2785. listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
  2786. } else /* reading number of logical volumes failed */
  2787. {
  2788. printk(KERN_WARNING "cciss: report logical volume"
  2789. " command failedn");
  2790. listlength = 0;
  2791. }
  2792. hba[cntl_num]->num_luns = listlength / 8; // 8 bytes pre entry
  2793. if (hba[cntl_num]->num_luns > CISS_MAX_LUN)
  2794. {
  2795. printk(KERN_ERR "ciss:  only %d number of logical volumes supportedn",
  2796. CISS_MAX_LUN);
  2797. hba[cntl_num]->num_luns = CISS_MAX_LUN;
  2798. }
  2799. #ifdef CCISS_DEBUG
  2800. printk(KERN_DEBUG "Length = %x %x %x %x = %dn", ld_buff->LUNListLength[0],
  2801. ld_buff->LUNListLength[1], ld_buff->LUNListLength[2],
  2802. ld_buff->LUNListLength[3],  hba[cntl_num]->num_luns);
  2803. #endif /* CCISS_DEBUG */
  2805. hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns-1;
  2806. // for(i=0; i<  hba[cntl_num]->num_luns; i++)
  2807. for(i=0; i < CISS_MAX_LUN; i++)
  2808. {
  2809. if (i < hba[cntl_num]->num_luns){
  2810.    lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
  2811.  << 24;
  2812.          lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
  2813.  << 16;
  2814.          lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
  2815.  << 8;
  2816.          lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
  2818. hba[cntl_num]->drv[i].LunID = lunid;
  2821. #ifdef CCISS_DEBUG
  2822.    printk(KERN_DEBUG "LUN[%d]:  %x %x %x %x = %xn", i, 
  2823. ld_buff->LUN[i][0], ld_buff->LUN[i][1],
  2824. ld_buff->LUN[i][2], ld_buff->LUN[i][3],
  2825. hba[cntl_num]->drv[i].LunID);
  2826. #endif /* CCISS_DEBUG */
  2827. cciss_read_capacity(cntl_num, i, size_buff, 0,
  2828. &total_size, &block_size);
  2829. cciss_geometry_inquiry(cntl_num, i, 0, total_size,
  2830. block_size, inq_buff, &hba[cntl_num]->drv[i]);
  2831. } else {
  2832. /* initialize raid_level to indicate a free space */
  2833. hba[cntl_num]->drv[i].raid_level = -1;
  2834. }
  2835. }
  2836. kfree(ld_buff);
  2837. kfree(size_buff);
  2838. kfree(inq_buff);
  2839. }
  2841. /* Function to find the first free pointer into our hba[] array */
  2842. /* Returns -1 if no free entries are left.  */
  2843. static int alloc_cciss_hba(void)
  2844. {
  2845. struct gendisk *disk[NWD];
  2846. int i, n;
  2847. for (n = 0; n < NWD; n++) {
  2848. disk[n] = alloc_disk(1 << NWD_SHIFT);
  2849. if (!disk[n])
  2850. goto out;
  2851. }
  2853. for(i=0; i< MAX_CTLR; i++) {
  2854. if (!hba[i]) {
  2855. ctlr_info_t *p;
  2856. p = kmalloc(sizeof(ctlr_info_t), GFP_KERNEL);
  2857. if (!p)
  2858. goto Enomem;
  2859. memset(p, 0, sizeof(ctlr_info_t));
  2860. for (n = 0; n < NWD; n++)
  2861. p->gendisk[n] = disk[n];
  2862. hba[i] = p;
  2863. return i;
  2864. }
  2865. }
  2866. printk(KERN_WARNING "cciss: This driver supports a maximum"
  2867. " of %d controllers.n", MAX_CTLR);
  2868. goto out;
  2869. Enomem:
  2870. printk(KERN_ERR "cciss: out of memory.n");
  2871. out:
  2872. while (n--)
  2873. put_disk(disk[n]);
  2874. return -1;
  2875. }
  2877. static void free_hba(int i)
  2878. {
  2879. ctlr_info_t *p = hba[i];
  2880. int n;
  2882. hba[i] = NULL;
  2883. for (n = 0; n < NWD; n++)
  2884. put_disk(p->gendisk[n]);
  2885. kfree(p);
  2886. }
  2888. /*
  2889.  *  This is it.  Find all the controllers and register them.  I really hate
  2890.  *  stealing all these major device numbers.
  2891.  *  returns the number of block devices registered.
  2892.  */
  2893. static int __devinit cciss_init_one(struct pci_dev *pdev,
  2894. const struct pci_device_id *ent)
  2895. {
  2896. request_queue_t *q;
  2897. int i;
  2898. int j;
  2899. int rc;
  2901. printk(KERN_DEBUG "cciss: Device 0x%x has been found at"
  2902. " bus %d dev %d func %dn",
  2903. pdev->device, pdev->bus->number, PCI_SLOT(pdev->devfn),
  2904. PCI_FUNC(pdev->devfn));
  2905. i = alloc_cciss_hba();
  2906. if(i < 0)
  2907. return (-1);
  2909. hba[i]->busy_initializing = 1;
  2911. if (cciss_pci_init(hba[i], pdev) != 0)
  2912. goto clean1;
  2914. sprintf(hba[i]->devname, "cciss%d", i);
  2915. hba[i]->ctlr = i;
  2916. hba[i]->pdev = pdev;
  2918. /* configure PCI DMA stuff */
  2919. if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
  2920. printk("cciss: using DAC cyclesn");
  2921. else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
  2922. printk("cciss: not using DAC cyclesn");
  2923. else {
  2924. printk("cciss: no suitable DMA availablen");
  2925. goto clean1;
  2926. }
  2928. /*
  2929.  * register with the major number, or get a dynamic major number
  2930.  * by passing 0 as argument.  This is done for greater than
  2931.  * 8 controller support.
  2932.  */
  2933. if (i < MAX_CTLR_ORIG)
  2934. hba[i]->major = MAJOR_NR + i;
  2935. rc = register_blkdev(hba[i]->major, hba[i]->devname);
  2936. if(rc == -EBUSY || rc == -EINVAL) {
  2937. printk(KERN_ERR
  2938. "cciss:  Unable to get major number %d for %s "
  2939. "on hba %dn", hba[i]->major, hba[i]->devname, i);
  2940. goto clean1;
  2941. }
  2942. else {
  2943. if (i >= MAX_CTLR_ORIG)
  2944. hba[i]->major = rc;
  2945. }
  2947. /* make sure the board interrupts are off */
  2948. hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
  2949. if( request_irq(hba[i]->intr, do_cciss_intr, 
  2950. SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM, 
  2951. hba[i]->devname, hba[i])) {
  2952. printk(KERN_ERR "cciss: Unable to get irq %d for %sn",
  2953. hba[i]->intr, hba[i]->devname);
  2954. goto clean2;
  2955. }
  2956. hba[i]->cmd_pool_bits = kmalloc(((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long), GFP_KERNEL);
  2957. hba[i]->cmd_pool = (CommandList_struct *)pci_alloc_consistent(
  2958. hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct), 
  2959. &(hba[i]->cmd_pool_dhandle));
  2960. hba[i]->errinfo_pool = (ErrorInfo_struct *)pci_alloc_consistent(
  2961. hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct), 
  2962. &(hba[i]->errinfo_pool_dhandle));
  2963. if((hba[i]->cmd_pool_bits == NULL) 
  2964. || (hba[i]->cmd_pool == NULL)
  2965. || (hba[i]->errinfo_pool == NULL)) {
  2966.                 printk( KERN_ERR "cciss: out of memory");
  2967. goto clean4;
  2968. }
  2970. spin_lock_init(&hba[i]->lock);
  2972. /* Initialize the pdev driver private data. 
  2973. have it point to hba[i].  */
  2974. pci_set_drvdata(pdev, hba[i]);
  2975. /* command and error info recs zeroed out before 
  2976. they are used */
  2977.         memset(hba[i]->cmd_pool_bits, 0, ((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long));
  2979. #ifdef CCISS_DEBUG
  2980. printk(KERN_DEBUG "Scanning for drives on controller cciss%dn",i);
  2981. #endif /* CCISS_DEBUG */
  2983. cciss_getgeometry(i);
  2985. cciss_scsi_setup(i);
  2987. /* Turn the interrupts on so we can service requests */
  2988. hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
  2990. cciss_procinit(i);
  2991. hba[i]->busy_initializing = 0;
  2993. for(j=0; j < NWD; j++) { /* mfm */
  2994. drive_info_struct *drv = &(hba[i]->drv[j]);
  2995. struct gendisk *disk = hba[i]->gendisk[j];
  2997. q = blk_init_queue(do_cciss_request, &hba[i]->lock);
  2998. if (!q) {
  2999. printk(KERN_ERR
  3000.    "cciss:  unable to allocate queue for disk %dn",
  3001.    j);
  3002. break;
  3003. }
  3004. drv->queue = q;
  3006. q->backing_dev_info.ra_pages = READ_AHEAD;
  3007. blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
  3009. /* This is a hardware imposed limit. */
  3010. blk_queue_max_hw_segments(q, MAXSGENTRIES);
  3012. /* This is a limit in the driver and could be eliminated. */
  3013. blk_queue_max_phys_segments(q, MAXSGENTRIES);
  3015. blk_queue_max_sectors(q, 512);
  3017. q->queuedata = hba[i];
  3018. sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
  3019. sprintf(disk->devfs_name, "cciss/host%d/target%d", i, j);
  3020. disk->major = hba[i]->major;
  3021. disk->first_minor = j << NWD_SHIFT;
  3022. disk->fops = &cciss_fops;
  3023. disk->queue = q;
  3024. disk->private_data = drv;
  3025. /* we must register the controller even if no disks exist */
  3026. /* this is for the online array utilities */
  3027. if(!drv->heads && j)
  3028. continue;
  3029. blk_queue_hardsect_size(q, drv->block_size);
  3030. set_capacity(disk, drv->nr_blocks);
  3031. add_disk(disk);
  3032. }
  3034. return(1);
  3036. clean4:
  3037. if(hba[i]->cmd_pool_bits)
  3038.                 kfree(hba[i]->cmd_pool_bits);
  3039. if(hba[i]->cmd_pool)
  3040. pci_free_consistent(hba[i]->pdev,
  3041. NR_CMDS * sizeof(CommandList_struct),
  3042. hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
  3043. if(hba[i]->errinfo_pool)
  3044. pci_free_consistent(hba[i]->pdev,
  3045. NR_CMDS * sizeof( ErrorInfo_struct),
  3046. hba[i]->errinfo_pool,
  3047. hba[i]->errinfo_pool_dhandle);
  3048. free_irq(hba[i]->intr, hba[i]);
  3049. clean2:
  3050. unregister_blkdev(hba[i]->major, hba[i]->devname);
  3051. clean1:
  3052. release_io_mem(hba[i]);
  3053. free_hba(i);
  3054. hba[i]->busy_initializing = 0;
  3055. return(-1);
  3056. }
  3058. static void __devexit cciss_remove_one (struct pci_dev *pdev)
  3059. {
  3060. ctlr_info_t *tmp_ptr;
  3061. int i, j;
  3062. char flush_buf[4];
  3063. int return_code; 
  3065. if (pci_get_drvdata(pdev) == NULL)
  3066. {
  3067. printk( KERN_ERR "cciss: Unable to remove device n");
  3068. return;
  3069. }
  3070. tmp_ptr = pci_get_drvdata(pdev);
  3071. i = tmp_ptr->ctlr;
  3072. if (hba[i] == NULL) 
  3073. {
  3074. printk(KERN_ERR "cciss: device appears to "
  3075. "already be removed n");
  3076. return;
  3077. }
  3078. /* Turn board interrupts off  and send the flush cache command */
  3079. /* sendcmd will turn off interrupt, and send the flush...
  3080. * To write all data in the battery backed cache to disks */
  3081. memset(flush_buf, 0, 4);
  3082. return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
  3083. TYPE_CMD);
  3084. if(return_code != IO_OK)
  3085. {
  3086. printk(KERN_WARNING "Error Flushing cache on controller %dn", 
  3087. i);
  3088. }
  3089. free_irq(hba[i]->intr, hba[i]);
  3090. pci_set_drvdata(pdev, NULL);
  3091. iounmap(hba[i]->vaddr);
  3092. cciss_unregister_scsi(i);  /* unhook from SCSI subsystem */
  3093. unregister_blkdev(hba[i]->major, hba[i]->devname);
  3094. remove_proc_entry(hba[i]->devname, proc_cciss);
  3096. /* remove it from the disk list */
  3097. for (j = 0; j < NWD; j++) {
  3098. struct gendisk *disk = hba[i]->gendisk[j];
  3099. if (disk->flags & GENHD_FL_UP) {
  3100. del_gendisk(disk);
  3101. blk_cleanup_queue(disk->queue);
  3102. }
  3103. }
  3105. pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct),
  3106.     hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
  3107. pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct),
  3108. hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
  3109. kfree(hba[i]->cmd_pool_bits);
  3110.   release_io_mem(hba[i]);
  3111. free_hba(i);
  3112. }
  3114. static struct pci_driver cciss_pci_driver = {
  3115. .name = "cciss",
  3116. .probe = cciss_init_one,
  3117. .remove = __devexit_p(cciss_remove_one),
  3118. .id_table = cciss_pci_device_id, /* id_table */
  3119. };
  3121. /*
  3122.  *  This is it.  Register the PCI driver information for the cards we control
  3123.  *  the OS will call our registered routines when it finds one of our cards. 
  3124.  */
  3125. static int __init cciss_init(void)
  3126. {
  3127. printk(KERN_INFO DRIVER_NAME "n");
  3129. /* Register for our PCI devices */
  3130. return pci_module_init(&cciss_pci_driver);
  3131. }
  3133. static void __exit cciss_cleanup(void)
  3134. {
  3135. int i;
  3137. pci_unregister_driver(&cciss_pci_driver);
  3138. /* double check that all controller entrys have been removed */
  3139. for (i=0; i< MAX_CTLR; i++) 
  3140. {
  3141. if (hba[i] != NULL)
  3142. {
  3143. printk(KERN_WARNING "cciss: had to remove"
  3144. " controller %dn", i);
  3145. cciss_remove_one(hba[i]->pdev);
  3146. }
  3147. }
  3148. remove_proc_entry("cciss", proc_root_driver);
  3149. }
  3151. static void fail_all_cmds(unsigned long ctlr)
  3152. {
  3153. /* If we get here, the board is apparently dead. */
  3154. ctlr_info_t *h = hba[ctlr];
  3155. CommandList_struct *c;
  3156. unsigned long flags;
  3158. printk(KERN_WARNING "cciss%d: controller not responding.n", h->ctlr);
  3159. h->alive = 0; /* the controller apparently died... */
  3161. spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
  3163. pci_disable_device(h->pdev); /* Make sure it is really dead. */
  3165. /* move everything off the request queue onto the completed queue */
  3166. while( (c = h->reqQ) != NULL ) {
  3167. removeQ(&(h->reqQ), c);
  3168. h->Qdepth--;
  3169. addQ (&(h->cmpQ), c);
  3170. }
  3172. /* Now, fail everything on the completed queue with a HW error */
  3173. while( (c = h->cmpQ) != NULL ) {
  3174. removeQ(&h->cmpQ, c);
  3175. c->err_info->CommandStatus = CMD_HARDWARE_ERR;
  3176. if (c->cmd_type == CMD_RWREQ) {
  3177. complete_command(h, c, 0);
  3178. } else if (c->cmd_type == CMD_IOCTL_PEND)
  3179. complete(c->waiting);
  3180. #ifdef CONFIG_CISS_SCSI_TAPE
  3181. else if (c->cmd_type == CMD_SCSI)
  3182. complete_scsi_command(c, 0, 0);
  3183. #endif
  3184. }
  3185. spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
  3186. return;
  3187. }
  3189. module_init(cciss_init);
  3190. module_exit(cciss_cleanup);