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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
cciss.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：60k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

cciss.c：源码内容
  1. /*
  2.  *    Disk Array driver for Compaq SMART2 Controllers
  3.  *    Copyright 2000 Compaq Computer Corporation
  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 arrays@compaq.com
  20.  *
  21.  */
  23. #include <linux/config.h> /* CONFIG_PROC_FS */
  24. #include <linux/module.h>
  25. #include <linux/version.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/blkpg.h>
  34. #include <linux/timer.h>
  35. #include <linux/proc_fs.h>
  36. #include <linux/init.h> 
  37. #include <linux/hdreg.h>
  38. #include <linux/spinlock.h>
  39. #include <asm/uaccess.h>
  40. #include <asm/io.h>
  42. #include <linux/blk.h>
  43. #include <linux/blkdev.h>
  44. #include <linux/genhd.h>
  46. #define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
  47. #define DRIVER_NAME "Compaq CISS Driver (v 2.4.5)"
  48. #define DRIVER_VERSION CCISS_DRIVER_VERSION(2,4,5)
  50. /* Embedded module documentation macros - see modules.h */
  51. MODULE_AUTHOR("Charles M. White III - Compaq Computer Corporation");
  52. MODULE_DESCRIPTION("Driver for Compaq Smart Array Controller 5300");
  53. MODULE_LICENSE("GPL");
  55. #include "cciss_cmd.h"
  56. #include "cciss.h"
  57. #include <linux/cciss_ioctl.h>
  59. /* define the PCI info for the cards we can control */
  60. const struct pci_device_id cciss_pci_device_id[] = {
  61. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS,
  62. 0x0E11, 0x4070, 0, 0, 0},
  63. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
  64.                         0x0E11, 0x4080, 0, 0, 0},
  65. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
  66.                         0x0E11, 0x4082, 0, 0, 0},
  67. {0,}
  68. };
  69. MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);
  71. #define NR_PRODUCTS (sizeof(products)/sizeof(struct board_type))
  73. /*  board_id = Subsystem Device ID & Vendor ID
  74.  *  product = Marketing Name for the board
  75.  *  access = Address of the struct of function pointers 
  76.  */
  77. static struct board_type products[] = {
  78. { 0x40700E11, "Smart Array 5300", &SA5_access },
  79. { 0x40800E11, "Smart Array 5i", &SA5B_access},
  80. { 0x40820E11, "Smart Array 532", &SA5B_access},
  81. };
  83. /* How long to wait (in millesconds) for board to go into simple mode */
  84. #define MAX_CONFIG_WAIT 1000 
  86. #define READ_AHEAD   128
  87. #define NR_CMDS  128 /* #commands that can be outstanding */
  88. #define MAX_CTLR 8
  90. #define CCISS_DMA_MASK 0xFFFFFFFF /* 32 bit DMA */
  92. static ctlr_info_t *hba[MAX_CTLR];
  94. static struct proc_dir_entry *proc_cciss;
  96. static void do_cciss_request(request_queue_t *q);
  97. static int cciss_open(struct inode *inode, struct file *filep);
  98. static int cciss_release(struct inode *inode, struct file *filep);
  99. static int cciss_ioctl(struct inode *inode, struct file *filep, 
  100. unsigned int cmd, unsigned long arg);
  102. static int revalidate_allvol(kdev_t dev);
  103. static int revalidate_logvol(kdev_t dev, int maxusage);
  104. static int frevalidate_logvol(kdev_t dev);
  106. static void cciss_getgeometry(int cntl_num);
  108. static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c);
  109. static void start_io( ctlr_info_t *h);
  111. #ifdef CONFIG_PROC_FS
  112. static int cciss_proc_get_info(char *buffer, char **start, off_t offset, 
  113. int length, int *eof, void *data);
  114. static void cciss_procinit(int i);
  115. #else
  116. static int cciss_proc_get_info(char *buffer, char **start, off_t offset, 
  117. int length, int *eof, void *data) { return 0;}
  118. static void cciss_procinit(int i) {}
  119. #endif /* CONFIG_PROC_FS */
  121. static struct block_device_operations cciss_fops  = {
  122. owner: THIS_MODULE,
  123. open: cciss_open, 
  124. release:         cciss_release,
  125.         ioctl: cciss_ioctl,
  126. revalidate: frevalidate_logvol,
  127. };
  129. /*
  130.  * Report information about this controller.
  131.  */
  132. #ifdef CONFIG_PROC_FS
  133. static int cciss_proc_get_info(char *buffer, char **start, off_t offset, 
  134. int length, int *eof, void *data)
  135. {
  136.         off_t pos = 0;
  137.         off_t len = 0;
  138.         int size, i, ctlr;
  139.         ctlr_info_t *h = (ctlr_info_t*)data;
  140.         drive_info_struct *drv;
  142.         ctlr = h->ctlr;
  143.         size = sprintf(buffer, "%s:  Compaq %s Controllern"
  144.                 "       Board ID: 0x%08lxn"
  145. "       Firmware Version: %c%c%c%cn"
  146.                 "       Memory Address: 0x%08lxn"
  147.                 "       IRQ: %dn"
  148.                 "       Logical drives: %dn"
  149.                 "       Current Q depth: %dn"
  150. "       Current # commands on controller %dn"
  151.                 "       Max Q depth since init: %dn"
  152. "       Max # commands on controller since init: %dn"
  153. "       Max SG entries since init: %dnn",
  154.                 h->devname,
  155.                 h->product_name,
  156.                 (unsigned long)h->board_id,
  157. h->firm_ver[0], h->firm_ver[1], h->firm_ver[2], h->firm_ver[3],
  158.                 (unsigned long)h->vaddr,
  159.                 (unsigned int)h->intr,
  160.                 h->num_luns, 
  161.                 h->Qdepth, h->commands_outstanding,
  162. h->maxQsinceinit, h->max_outstanding, h->maxSG);
  164.         pos += size; len += size;
  165. for(i=0; i<h->num_luns; i++) {
  166.                 drv = &h->drv[i];
  167.                 size = sprintf(buffer+len, "cciss/c%dd%d: blksz=%d nr_blocks=%dn",
  168.                                 ctlr, i, drv->block_size, drv->nr_blocks);
  169.                 pos += size; len += size;
  170.         }
  172. size = sprintf(buffer+len, "nr_allocs = %dnnr_frees = %dn",
  173.                         h->nr_allocs, h->nr_frees);
  174.         pos += size; len += size;
  176.         *eof = 1;
  177.         *start = buffer+offset;
  178.         len -= offset;
  179.         if (len>length)
  180.                 len = length;
  181.         return len;
  182. }
  184. /*
  185.  * Get us a file in /proc/cciss that says something about each controller.
  186.  * Create /proc/cciss if it doesn't exist yet.
  187.  */
  188. static void __init cciss_procinit(int i)
  189. {
  190.         if (proc_cciss == NULL) {
  191.                 proc_cciss = proc_mkdir("cciss", proc_root_driver);
  192.                 if (!proc_cciss) 
  193. return;
  194.         }
  196.         create_proc_read_entry(hba[i]->devname, 0, proc_cciss,
  197.          cciss_proc_get_info, hba[i]);
  198. }
  199. #endif /* CONFIG_PROC_FS */
  201. /* 
  202.  * For operations that cannot sleep, a command block is allocated at init, 
  203.  * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
  204.  * which ones are free or in use.  For operations that can wait for kmalloc 
  205.  * to possible sleep, this routine can be called with get_from_pool set to 0. 
  206.  * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was. 
  207.  */ 
  208. static CommandList_struct * cmd_alloc(ctlr_info_t *h, int get_from_pool)
  209. {
  210. CommandList_struct *c;
  211. int i; 
  212. u64bit temp64;
  213. dma_addr_t cmd_dma_handle, err_dma_handle;
  215. if (!get_from_pool)
  216. {
  217. c = (CommandList_struct *) pci_alloc_consistent(
  218. h->pdev, sizeof(CommandList_struct), &cmd_dma_handle); 
  219.          if(c==NULL)
  220.                   return NULL;
  221. memset(c, 0, sizeof(CommandList_struct));
  223. c->err_info = (ErrorInfo_struct *)pci_alloc_consistent(
  224. h->pdev, sizeof(ErrorInfo_struct), 
  225. &err_dma_handle);
  227. if (c->err_info == NULL)
  228. {
  229. pci_free_consistent(h->pdev, 
  230. sizeof(CommandList_struct), c, cmd_dma_handle);
  231. return NULL;
  232. }
  233. memset(c->err_info, 0, sizeof(ErrorInfo_struct));
  234. } else /* get it out of the controllers pool */ 
  235. {
  236.       do {
  237.                  i = find_first_zero_bit(h->cmd_pool_bits, NR_CMDS);
  238.                         if (i == NR_CMDS)
  239.                                 return NULL;
  240.                 } while(test_and_set_bit(i%32, h->cmd_pool_bits+(i/32)) != 0);
  241. #ifdef CCISS_DEBUG
  242. printk(KERN_DEBUG "cciss: using command buffer %dn", i);
  243. #endif
  244.                 c = h->cmd_pool + i;
  245. memset(c, 0, sizeof(CommandList_struct));
  246. cmd_dma_handle = h->cmd_pool_dhandle 
  247. + i*sizeof(CommandList_struct);
  248. c->err_info = h->errinfo_pool + i;
  249. memset(c->err_info, 0, sizeof(ErrorInfo_struct));
  250. err_dma_handle = h->errinfo_pool_dhandle 
  251. + i*sizeof(ErrorInfo_struct);
  252.                 h->nr_allocs++;
  253.         }
  255. c->busaddr = (__u32) cmd_dma_handle;
  256. temp64.val = (__u64) err_dma_handle;
  257. c->ErrDesc.Addr.lower = temp64.val32.lower;
  258. c->ErrDesc.Addr.upper = temp64.val32.upper;
  259. c->ErrDesc.Len = sizeof(ErrorInfo_struct);
  261. c->ctlr = h->ctlr;
  262.         return c;
  265. }
  267. /* 
  268.  * Frees a command block that was previously allocated with cmd_alloc(). 
  269.  */
  270. static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
  271. {
  272. int i;
  273. u64bit temp64;
  275. if( !got_from_pool)
  276. { 
  277. temp64.val32.lower = c->ErrDesc.Addr.lower;
  278. temp64.val32.upper = c->ErrDesc.Addr.upper;
  279. pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct), 
  280. c->err_info, (dma_addr_t) temp64.val);
  281. pci_free_consistent(h->pdev, sizeof(CommandList_struct), 
  282. c, (dma_addr_t) c->busaddr);
  283. } else 
  284. {
  285. i = c - h->cmd_pool;
  286. clear_bit(i%32, h->cmd_pool_bits+(i/32));
  287.                 h->nr_frees++;
  288.         }
  289. }
  291. /*  
  292.  * fills in the disk information. 
  293.  */
  294. static void cciss_geninit( int ctlr)
  295. {
  296. drive_info_struct *drv;
  297. int i,j;
  299. /* Loop through each real device */ 
  300. hba[ctlr]->gendisk.nr_real = 0; 
  301. for(i=0; i< NWD; i++)
  302. {
  303. drv = &(hba[ctlr]->drv[i]);
  304. if( !(drv->nr_blocks))
  305. continue;
  306. hba[ctlr]->hd[i << NWD_SHIFT].nr_sects = 
  307. hba[ctlr]->sizes[i << NWD_SHIFT] = drv->nr_blocks;
  309. /* for each partition */ 
  310. for(j=0; j<MAX_PART; j++)
  311. {
  312. hba[ctlr]->blocksizes[(i<<NWD_SHIFT) + j] = 1024; 
  314. hba[ctlr]->hardsizes[ (i<<NWD_SHIFT) + j] = 
  315. drv->block_size;
  316. }
  317. hba[ctlr]->gendisk.nr_real++;
  318. }
  319. }
  320. /*
  321.  * Open.  Make sure the device is really there.
  322.  */
  323. static int cciss_open(struct inode *inode, struct file *filep)
  324. {
  325. int ctlr = MAJOR(inode->i_rdev) - MAJOR_NR;
  326. int dsk  = MINOR(inode->i_rdev) >> NWD_SHIFT;
  328. #ifdef CCISS_DEBUG
  329. printk(KERN_DEBUG "cciss_open %x (%x:%x)n", inode->i_rdev, ctlr, dsk);
  330. #endif /* CCISS_DEBUG */ 
  332. if (ctlr > MAX_CTLR || hba[ctlr] == NULL)
  333. return -ENXIO;
  335. if (!suser() && hba[ctlr]->sizes[ MINOR(inode->i_rdev)] == 0)
  336. return -ENXIO;
  338. /*
  339.  * Root is allowed to open raw volume zero even if its not configured
  340.  * so array config can still work.  I don't think I really like this,
  341.  * but I'm already using way to many device nodes to claim another one
  342.  * for "raw controller".
  343.  */
  344. if (suser()
  345. && (hba[ctlr]->sizes[MINOR(inode->i_rdev)] == 0) 
  346. && (MINOR(inode->i_rdev)!= 0))
  347. return -ENXIO;
  349. hba[ctlr]->drv[dsk].usage_count++;
  350. hba[ctlr]->usage_count++;
  351. return 0;
  352. }
  353. /*
  354.  * Close.  Sync first.
  355.  */
  356. static int cciss_release(struct inode *inode, struct file *filep)
  357. {
  358. int ctlr = MAJOR(inode->i_rdev) - MAJOR_NR;
  359. int dsk  = MINOR(inode->i_rdev) >> NWD_SHIFT;
  361. #ifdef CCISS_DEBUG
  362. printk(KERN_DEBUG "cciss_release %x (%x:%x)n", inode->i_rdev, ctlr, dsk);
  363. #endif /* CCISS_DEBUG */
  365. /* fsync_dev(inode->i_rdev); */
  367. hba[ctlr]->drv[dsk].usage_count--;
  368. hba[ctlr]->usage_count--;
  369. return 0;
  370. }
  372. /*
  373.  * ioctl 
  374.  */
  375. static int cciss_ioctl(struct inode *inode, struct file *filep, 
  376. unsigned int cmd, unsigned long arg)
  377. {
  378. int ctlr = MAJOR(inode->i_rdev) - MAJOR_NR;
  379. int dsk  = MINOR(inode->i_rdev) >> NWD_SHIFT;
  380. int diskinfo[4];
  381. struct hd_geometry *geo = (struct hd_geometry *)arg;
  383. #ifdef CCISS_DEBUG
  384. printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lxn", cmd, arg);
  385. #endif /* CCISS_DEBUG */ 
  387. switch(cmd) {
  388. case HDIO_GETGEO:
  389. if (hba[ctlr]->drv[dsk].cylinders) {
  390. diskinfo[0] = hba[ctlr]->drv[dsk].heads;
  391. diskinfo[1] = hba[ctlr]->drv[dsk].sectors;
  392. diskinfo[2] = hba[ctlr]->drv[dsk].cylinders;
  393. } else {
  394. diskinfo[0] = 0xff;
  395. diskinfo[1] = 0x3f;
  396. diskinfo[2] = hba[ctlr]->drv[dsk].nr_blocks / (0xff*0x3f); }
  397. put_user(diskinfo[0], &geo->heads);
  398. put_user(diskinfo[1], &geo->sectors);
  399. put_user(diskinfo[2], &geo->cylinders);
  400. put_user(hba[ctlr]->hd[MINOR(inode->i_rdev)].start_sect, &geo->start);
  401. return 0;
  402. case BLKGETSIZE:
  403. put_user(hba[ctlr]->hd[MINOR(inode->i_rdev)].nr_sects, (unsigned long *)arg);
  404. return 0;
  405. case BLKGETSIZE64:
  406. put_user((u64)hba[ctlr]->hd[MINOR(inode->i_rdev)].nr_sects << 9, (u64*)arg);
  407. return 0;
  408. case BLKRRPART:
  409. return revalidate_logvol(inode->i_rdev, 1);
  410. case BLKFLSBUF:
  411. case BLKBSZSET:
  412. case BLKBSZGET:
  413. case BLKROSET:
  414. case BLKROGET:
  415. case BLKRASET:
  416. case BLKRAGET:
  417. case BLKPG:
  418. case BLKELVGET:
  419. case BLKELVSET:
  420. return( blk_ioctl(inode->i_rdev, cmd, arg));
  421. case CCISS_GETPCIINFO:
  422. {
  423. cciss_pci_info_struct pciinfo;
  425. if (!arg) return -EINVAL;
  426. pciinfo.bus = hba[ctlr]->pdev->bus->number;
  427. pciinfo.dev_fn = hba[ctlr]->pdev->devfn;
  428. pciinfo.board_id = hba[ctlr]->board_id;
  429. if (copy_to_user((void *) arg, &pciinfo,  sizeof( cciss_pci_info_struct )))
  430. return  -EFAULT;
  431. return(0);
  432. }
  433. case CCISS_GETINTINFO:
  434. {
  435. cciss_coalint_struct intinfo;
  436. ctlr_info_t *c = hba[ctlr];
  438. if (!arg) return -EINVAL;
  439. intinfo.delay = readl(&c->cfgtable->HostWrite.CoalIntDelay);
  440. intinfo.count = readl(&c->cfgtable->HostWrite.CoalIntCount);
  441. if (copy_to_user((void *) arg, &intinfo, sizeof( cciss_coalint_struct )))
  442. return -EFAULT;
  443.                 return(0);
  444.         }
  445. case CCISS_SETINTINFO:
  446.         {
  447.                 cciss_coalint_struct intinfo;
  448.                 ctlr_info_t *c = hba[ctlr];
  449. unsigned long flags;
  450. int i;
  452. if (!arg) return -EINVAL;
  453. if (!capable(CAP_SYS_ADMIN)) return -EPERM;
  454. if (copy_from_user(&intinfo, (void *) arg, sizeof( cciss_coalint_struct)))
  455. return -EFAULT;
  456. if ( (intinfo.delay == 0 ) && (intinfo.count == 0))
  458. {
  459. // printk("cciss_ioctl: delay and count cannot be 0n");
  460. return( -EINVAL);
  461. }
  462. spin_lock_irqsave(&io_request_lock, flags);
  463. /* Can only safely update if no commands outstanding */ 
  464. if (c->commands_outstanding > 0 )
  465. {
  466. // printk("cciss_ioctl: cannot change coalasing "
  467. // "%d commands outstanding on controllern", 
  468. // c->commands_outstanding);
  469. spin_unlock_irqrestore(&io_request_lock, flags);
  470. return(-EINVAL);
  471. }
  472. /* Update the field, and then ring the doorbell */ 
  473. writel( intinfo.delay, 
  474. &(c->cfgtable->HostWrite.CoalIntDelay));
  475. writel( intinfo.count, 
  476.                         &(c->cfgtable->HostWrite.CoalIntCount));
  477. writel( CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
  479. for(i=0;i<MAX_CONFIG_WAIT;i++)
  480. {
  481. if (!(readl(c->vaddr + SA5_DOORBELL) 
  482. & CFGTBL_ChangeReq))
  483. break;
  484. /* delay and try again */
  485. udelay(1000);
  486. }
  487. spin_unlock_irqrestore(&io_request_lock, flags);
  488. if (i >= MAX_CONFIG_WAIT)
  489. return( -EFAULT);
  490.                 return(0);
  491.         }
  492. case CCISS_GETNODENAME:
  493.         {
  494.                 NodeName_type NodeName;
  495.                 ctlr_info_t *c = hba[ctlr];
  496. int i; 
  498. if (!arg) return -EINVAL;
  499. for(i=0;i<16;i++)
  500. NodeName[i] = readb(&c->cfgtable->ServerName[i]);
  501.                 if (copy_to_user((void *) arg, NodeName, sizeof( NodeName_type)))
  502.                  return  -EFAULT;
  503.                 return(0);
  504.         }
  505. case CCISS_SETNODENAME:
  506. {
  507. NodeName_type NodeName;
  508. ctlr_info_t *c = hba[ctlr];
  509. unsigned long flags;
  510. int i;
  512. if (!arg) return -EINVAL;
  513. if (!capable(CAP_SYS_ADMIN)) return -EPERM;
  515. if (copy_from_user(NodeName, (void *) arg, sizeof( NodeName_type)))
  516. return -EFAULT;
  518. spin_lock_irqsave(&io_request_lock, flags);
  520. /* Update the field, and then ring the doorbell */ 
  521. for(i=0;i<16;i++)
  522. writeb( NodeName[i], &c->cfgtable->ServerName[i]);
  524. writel( CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
  526. for(i=0;i<MAX_CONFIG_WAIT;i++)
  527. {
  528. if (!(readl(c->vaddr + SA5_DOORBELL) 
  529. & CFGTBL_ChangeReq))
  530. break;
  531. /* delay and try again */
  532. udelay(1000);
  533. }
  534. spin_unlock_irqrestore(&io_request_lock, flags);
  535. if (i >= MAX_CONFIG_WAIT)
  536. return( -EFAULT);
  537.                 return(0);
  538.         }
  540. case CCISS_GETHEARTBEAT:
  541.         {
  542.                 Heartbeat_type heartbeat;
  543.                 ctlr_info_t *c = hba[ctlr];
  545. if (!arg) return -EINVAL;
  546.                 heartbeat = readl(&c->cfgtable->HeartBeat);
  547.                 if (copy_to_user((void *) arg, &heartbeat, sizeof( Heartbeat_type)))
  548.                  return -EFAULT;
  549.                 return(0);
  550.         }
  551. case CCISS_GETBUSTYPES:
  552.         {
  553.                 BusTypes_type BusTypes;
  554.                 ctlr_info_t *c = hba[ctlr];
  556. if (!arg) return -EINVAL;
  557.                 BusTypes = readl(&c->cfgtable->BusTypes);
  558.                 if (copy_to_user((void *) arg, &BusTypes, sizeof( BusTypes_type) ))
  559.                  return  -EFAULT;
  560.                 return(0);
  561.         }
  562. case CCISS_GETFIRMVER:
  563.         {
  564. FirmwareVer_type firmware;
  566. if (!arg) return -EINVAL;
  567. memcpy(firmware, hba[ctlr]->firm_ver, 4);
  569.                 if (copy_to_user((void *) arg, firmware, sizeof( FirmwareVer_type)))
  570.                  return -EFAULT;
  571.                 return(0);
  572.         }
  573.         case CCISS_GETDRIVVER:
  574.         {
  575. DriverVer_type DriverVer = DRIVER_VERSION;
  577.                 if (!arg) return -EINVAL;
  579.                 if (copy_to_user((void *) arg, &DriverVer, sizeof( DriverVer_type) ))
  580.                  return -EFAULT;
  581.                 return(0);
  582.         }
  584. case CCISS_REVALIDVOLS:
  585.                 return( revalidate_allvol(inode->i_rdev));
  587. case CCISS_PASSTHRU:
  588. {
  589. IOCTL_Command_struct iocommand;
  590. ctlr_info_t *h = hba[ctlr];
  591. CommandList_struct *c;
  592. char  *buff = NULL;
  593. u64bit temp64;
  594. unsigned long flags;
  596. if (!arg) return -EINVAL;
  598. if (!capable(CAP_SYS_RAWIO)) return -EPERM;
  600. if (copy_from_user(&iocommand, (void *) arg, sizeof( IOCTL_Command_struct) ))
  601. return -EFAULT;
  602. if((iocommand.buf_size < 1) && 
  603. (iocommand.Request.Type.Direction != XFER_NONE))
  604. {
  605. return -EINVAL;
  606. } 
  607. /* Check kmalloc limits */
  608. if(iocommand.buf_size > 128000)
  609. return -EINVAL;
  610. if(iocommand.buf_size > 0)
  611. {
  612. buff =  kmalloc(iocommand.buf_size, GFP_KERNEL);
  613. if( buff == NULL) 
  614. return -EFAULT;
  615. }
  616. if (iocommand.Request.Type.Direction == XFER_WRITE)
  617. {
  618. /* Copy the data into the buffer we created */ 
  619. if (copy_from_user(buff, iocommand.buf, iocommand.buf_size))
  620. {
  621. kfree(buff);
  622. return -EFAULT;
  623. }
  624. }
  625. if ((c = cmd_alloc(h , 0)) == NULL)
  626. {
  627. kfree(buff);
  628. return -ENOMEM;
  629. }
  630. // Fill in the command type 
  631. c->cmd_type = CMD_IOCTL_PEND;
  632. // Fill in Command Header 
  633. c->Header.ReplyQueue = 0;  // unused in simple mode
  634. if( iocommand.buf_size > 0)  // buffer to fill 
  635. {
  636. c->Header.SGList = 1;
  637. c->Header.SGTotal= 1;
  638. } else // no buffers to fill  
  639. {
  640. c->Header.SGList = 0;
  641.                  c->Header.SGTotal= 0;
  642. }
  643. c->Header.LUN = iocommand.LUN_info;
  644. c->Header.Tag.lower = c->busaddr;  // use the kernel address the cmd block for tag
  646. // Fill in Request block 
  647. c->Request = iocommand.Request; 
  649. // Fill in the scatter gather information
  650. if (iocommand.buf_size > 0 ) 
  651. {
  652. temp64.val = pci_map_single( h->pdev, buff,
  653.                                         iocommand.buf_size, 
  654.                                 PCI_DMA_BIDIRECTIONAL);
  655. c->SG[0].Addr.lower = temp64.val32.lower;
  656. c->SG[0].Addr.upper = temp64.val32.upper;
  657. c->SG[0].Len = iocommand.buf_size;
  658. c->SG[0].Ext = 0;  // we are not chaining
  659. }
  660. /* Put the request on the tail of the request queue */
  661. spin_lock_irqsave(&io_request_lock, flags);
  662. addQ(&h->reqQ, c);
  663. h->Qdepth++;
  664. start_io(h);
  665. spin_unlock_irqrestore(&io_request_lock, flags);
  667. /* Wait for completion */
  668. while(c->cmd_type != CMD_IOCTL_DONE)
  669. schedule_timeout(1);
  671. /* unlock the buffers from DMA */
  672. temp64.val32.lower = c->SG[0].Addr.lower;
  673.                 temp64.val32.upper = c->SG[0].Addr.upper;
  674.                 pci_unmap_single( h->pdev, (dma_addr_t) temp64.val,
  675.                  iocommand.buf_size, PCI_DMA_BIDIRECTIONAL);
  677. /* Copy the error information out */ 
  678. iocommand.error_info = *(c->err_info);
  679. if ( copy_to_user((void *) arg, &iocommand, sizeof( IOCTL_Command_struct) ) )
  680. {
  681. kfree(buff);
  682. cmd_free(h, c, 0);
  683. return( -EFAULT);
  684. } 
  686. if (iocommand.Request.Type.Direction == XFER_READ)
  687.                 {
  688.                         /* Copy the data out of the buffer we created */
  689.                         if (copy_to_user(iocommand.buf, buff, iocommand.buf_size))
  690. {
  691.                          kfree(buff);
  692. cmd_free(h, c, 0);
  693. return -EFAULT;
  694. }
  695.                 }
  696.                 kfree(buff);
  697. cmd_free(h, c, 0);
  698.                 return(0);
  699. } 
  701. default:
  702. return -EBADRQC;
  703. }
  705. }
  707. /* Borrowed and adapted from sd.c */
  708. static int revalidate_logvol(kdev_t dev, int maxusage)
  709. {
  710.         int ctlr, target;
  711.         struct gendisk *gdev;
  712.         unsigned long flags;
  713.         int max_p;
  714.         int start;
  715.         int i;
  717.         target = MINOR(dev) >> NWD_SHIFT;
  718.         ctlr = MAJOR(dev) - MAJOR_NR;
  719.         gdev = &(hba[ctlr]->gendisk);
  721.         spin_lock_irqsave(&io_request_lock, flags);
  722.         if (hba[ctlr]->drv[target].usage_count > maxusage) {
  723.                 spin_unlock_irqrestore(&io_request_lock, flags);
  724.                 printk(KERN_WARNING "cciss: Device busy for "
  725.                         "revalidation (usage=%d)n",
  726.                         hba[ctlr]->drv[target].usage_count);
  727.                 return -EBUSY;
  728.         }
  729.         hba[ctlr]->drv[target].usage_count++;
  730.         spin_unlock_irqrestore(&io_request_lock, flags);
  732.         max_p = gdev->max_p;
  733.         start = target << gdev->minor_shift;
  735.         for(i=max_p-1; i>=0; i--) {
  736.                 int minor = start+i;
  737.                 invalidate_device(MKDEV(MAJOR_NR + ctlr, minor), 1);
  738.                 gdev->part[minor].start_sect = 0;
  739.                 gdev->part[minor].nr_sects = 0;
  741.                 /* reset the blocksize so we can read the partition table */
  742.                 blksize_size[MAJOR_NR+ctlr][minor] = 1024;
  743.         }
  744. /* setup partitions per disk */
  745. grok_partitions(gdev, target, MAX_PART, 
  746. hba[ctlr]->drv[target].nr_blocks);
  747.         hba[ctlr]->drv[target].usage_count--;
  748.         return 0;
  749. }
  751. static int frevalidate_logvol(kdev_t dev)
  752. {
  753. #ifdef CCISS_DEBUG
  754. printk(KERN_DEBUG "cciss: frevalidate has been calledn");
  755. #endif /* CCISS_DEBUG */ 
  756. return revalidate_logvol(dev, 0);
  757. }
  759. /*
  760.  * revalidate_allvol is for online array config utilities.  After a
  761.  * utility reconfigures the drives in the array, it can use this function
  762.  * (through an ioctl) to make the driver zap any previous disk structs for
  763.  * that controller and get new ones.
  764.  *
  765.  * Right now I'm using the getgeometry() function to do this, but this
  766.  * function should probably be finer grained and allow you to revalidate one
  767.  * particualar logical volume (instead of all of them on a particular
  768.  * controller).
  769.  */
  770. static int revalidate_allvol(kdev_t dev)
  771. {
  772. int ctlr, i;
  773. unsigned long flags;
  775. ctlr = MAJOR(dev) - MAJOR_NR;
  776.         if (MINOR(dev) != 0)
  777.                 return -ENXIO;
  779.         spin_lock_irqsave(&io_request_lock, flags);
  780.         if (hba[ctlr]->usage_count > 1) {
  781.                 spin_unlock_irqrestore(&io_request_lock, flags);
  782.                 printk(KERN_WARNING "cciss: Device busy for volume"
  783.                         " revalidation (usage=%d)n", hba[ctlr]->usage_count);
  784.                 return -EBUSY;
  785.         }
  786.         spin_unlock_irqrestore(&io_request_lock, flags);
  787.         hba[ctlr]->usage_count++;
  789.         /*
  790.          * Set the partition and block size structures for all volumes
  791.          * on this controller to zero.  We will reread all of this data
  792.          */
  793. memset(hba[ctlr]->hd,         0, sizeof(struct hd_struct) * 256);
  794.         memset(hba[ctlr]->sizes,      0, sizeof(int) * 256);
  795.         memset(hba[ctlr]->blocksizes, 0, sizeof(int) * 256);
  796.         memset(hba[ctlr]->hardsizes,  0, sizeof(int) * 256);
  797.         memset(hba[ctlr]->drv,        0, sizeof(drive_info_struct)
  798. * CISS_MAX_LUN);
  799.         hba[ctlr]->gendisk.nr_real = 0;
  801.         /*
  802.          * Tell the array controller not to give us any interrupts while
  803.          * we check the new geometry.  Then turn interrupts back on when
  804.          * we're done.
  805.          */
  806.         hba[ctlr]->access.set_intr_mask(hba[ctlr], CCISS_INTR_OFF);
  807.         cciss_getgeometry(ctlr);
  808.         hba[ctlr]->access.set_intr_mask(hba[ctlr], CCISS_INTR_ON);
  810.         cciss_geninit(ctlr);
  811.         for(i=0; i<NWD; i++)
  812.                 if (hba[ctlr]->sizes[ i<<NWD_SHIFT ])
  813.                         revalidate_logvol(dev+(i<<NWD_SHIFT), 2);
  815.         hba[ctlr]->usage_count--;
  816.         return 0;
  817. }
  821. /*
  822.  *   Wait polling for a command to complete.
  823.  *   The memory mapped FIFO is polled for the completion.
  824.  *   Used only at init time, interrupts disabled.
  825.  */
  826. static unsigned long pollcomplete(int ctlr)
  827. {
  828.         unsigned long done;
  829.         int i;
  831.         /* Wait (up to 2 seconds) for a command to complete */
  833.         for (i = 200000; i > 0; i--) {
  834.                 done = hba[ctlr]->access.command_completed(hba[ctlr]);
  835.                 if (done == FIFO_EMPTY) {
  836.                         udelay(10);     /* a short fixed delay */
  837.                 } else
  838.                         return (done);
  839.         }
  840.         /* Invalid address to tell caller we ran out of time */
  841.         return 1;
  842. }
  843. /*
  844.  * Send a command to the controller, and wait for it to complete.  
  845.  * Only used at init time. 
  846.  */
  847. static int sendcmd(
  848. __u8 cmd,
  849. int ctlr,
  850. void *buff,
  851. size_t size,
  852. unsigned int use_unit_num,
  853. unsigned int log_unit,
  854. __u8 page_code )
  855. {
  856. CommandList_struct *c;
  857. int i;
  858. unsigned long complete;
  859. ctlr_info_t *info_p= hba[ctlr];
  860. u64bit buff_dma_handle;
  862. c = cmd_alloc(info_p, 1);
  863. if (c == NULL)
  864. {
  865. printk(KERN_WARNING "cciss: unable to get memory");
  866. return(IO_ERROR);
  867. }
  868. // Fill in Command Header 
  869. c->Header.ReplyQueue = 0;  // unused in simple mode
  870. if( buff != NULL)  // buffer to fill 
  871. {
  872. c->Header.SGList = 1;
  873. c->Header.SGTotal= 1;
  874. } else // no buffers to fill  
  875. {
  876. c->Header.SGList = 0;
  877.                 c->Header.SGTotal= 0;
  878. }
  879. c->Header.Tag.lower = c->busaddr;  // use the kernel address the cmd block for tag
  880. // Fill in Request block 
  881. switch(cmd)
  882. {
  883. case  CISS_INQUIRY:
  884. /* If the logical unit number is 0 then, this is going
  885. to controller so It's a physical command
  886. mode = 0 target = 0.
  887. So we have nothing to write. 
  888. Otherwise 
  889. mode = 1  target = LUNID
  890. */
  891. if(use_unit_num != 0)
  892. {
  893. c->Header.LUN.LogDev.VolId=
  894.                                  hba[ctlr]->drv[log_unit].LunID;
  895.                          c->Header.LUN.LogDev.Mode = 1;
  896. }
  897. /* are we trying to read a vital product page */
  898. if(page_code != 0)
  899. {
  900. c->Request.CDB[1] = 0x01;
  901. c->Request.CDB[2] = page_code;
  902. }
  903. c->Request.CDBLen = 6;
  904. c->Request.Type.Type =  TYPE_CMD; // It is a command. 
  905. c->Request.Type.Attribute = ATTR_SIMPLE;  
  906. c->Request.Type.Direction = XFER_READ; // Read 
  907. c->Request.Timeout = 0; // Don't time out 
  908. c->Request.CDB[0] =  CISS_INQUIRY;
  909. c->Request.CDB[4] = size  & 0xFF;  
  910. break;
  911. case CISS_REPORT_LOG:
  912.                         /* Talking to controller so It's a physical command
  913.                                 mode = 00 target = 0.
  914.                                 So we have nothing to write.
  915.                         */
  916.                         c->Request.CDBLen = 12;
  917.                         c->Request.Type.Type =  TYPE_CMD; // It is a command.
  918.                         c->Request.Type.Attribute = ATTR_SIMPLE; 
  919.                         c->Request.Type.Direction = XFER_READ; // Read
  920.                         c->Request.Timeout = 0; // Don't time out
  921.                         c->Request.CDB[0] = CISS_REPORT_LOG;
  922.                         c->Request.CDB[6] = (size >> 24) & 0xFF;  //MSB
  923.                         c->Request.CDB[7] = (size >> 16) & 0xFF;
  924.                         c->Request.CDB[8] = (size >> 8) & 0xFF;
  925.                         c->Request.CDB[9] = size & 0xFF;
  926.                 break;
  928. case CCISS_READ_CAPACITY:
  929. c->Header.LUN.LogDev.VolId= 
  930. hba[ctlr]->drv[log_unit].LunID;
  931. c->Header.LUN.LogDev.Mode = 1;
  932. c->Request.CDBLen = 10;
  933.                         c->Request.Type.Type =  TYPE_CMD; // It is a command.
  934.                         c->Request.Type.Attribute = ATTR_SIMPLE; 
  935.                         c->Request.Type.Direction = XFER_READ; // Read
  936.                         c->Request.Timeout = 0; // Don't time out
  937.                         c->Request.CDB[0] = CCISS_READ_CAPACITY;
  938. break;
  939. default:
  940. printk(KERN_WARNING
  941. "cciss:  Unknown Command 0x%c sent attemptedn",
  942.   cmd);
  943. cmd_free(info_p, c, 1);
  944. return(IO_ERROR);
  945. };
  946. // Fill in the scatter gather information
  947. if (size > 0 ) 
  948. {
  949. buff_dma_handle.val = (__u64) pci_map_single( info_p->pdev, 
  950. buff, size, PCI_DMA_BIDIRECTIONAL);
  951. c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
  952. c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
  953. c->SG[0].Len = size;
  954. c->SG[0].Ext = 0;  // we are not chaining
  955. }
  956. /*
  957.          * Disable interrupt
  958.          */
  959. #ifdef CCISS_DEBUG
  960. printk(KERN_DEBUG "cciss: turning intr offn");
  961. #endif /* CCISS_DEBUG */ 
  962.         info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
  964. /* Make sure there is room in the command FIFO */
  965.         /* Actually it should be completely empty at this time. */
  966.         for (i = 200000; i > 0; i--) 
  967. {
  968. /* if fifo isn't full go */
  969.                 if (!(info_p->access.fifo_full(info_p))) 
  970. {
  972.                         break;
  973.                 }
  974.                 udelay(10);
  975.                 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
  976.                         " waiting!n", ctlr);
  977.         }
  978.         /*
  979.          * Send the cmd
  980.          */
  981.         info_p->access.submit_command(info_p, c);
  982.         complete = pollcomplete(ctlr);
  984. #ifdef CCISS_DEBUG
  985. printk(KERN_DEBUG "cciss: command completedn");
  986. #endif /* CCISS_DEBUG */
  988. /* unlock the data buffer from DMA */
  989. pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
  990.                                 size, PCI_DMA_BIDIRECTIONAL);
  991. if (complete != 1) {
  992. if ( (complete & CISS_ERROR_BIT)
  993.      && (complete & ~CISS_ERROR_BIT) == c->busaddr)
  994.      {
  995. /* if data overrun or underun on Report command 
  996. ignore it 
  997. */
  998. if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
  999.      (c->Request.CDB[0] == CISS_INQUIRY)) &&
  1000. ((c->err_info->CommandStatus == 
  1001. CMD_DATA_OVERRUN) || 
  1002.  (c->err_info->CommandStatus == 
  1003. CMD_DATA_UNDERRUN)
  1004.   ))
  1005. {
  1006. complete = c->busaddr;
  1007. } else
  1008. {
  1009. printk(KERN_WARNING "ciss ciss%d: sendcmd"
  1010. " Error %x n", ctlr, 
  1011. c->err_info->CommandStatus); 
  1012. printk(KERN_WARNING "ciss ciss%d: sendcmd"
  1013. " offensive infon"
  1014. "  size %xn   num %x   value %xn", ctlr,
  1015.   c->err_info->MoreErrInfo.Invalid_Cmd.offense_size,
  1016.   c->err_info->MoreErrInfo.Invalid_Cmd.offense_num,
  1017.   c->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
  1018. cmd_free(info_p,c, 1);
  1019. return(IO_ERROR);
  1020. }
  1021. }
  1022.                 if (complete != c->busaddr) {
  1023.                         printk( KERN_WARNING "cciss cciss%d: SendCmd "
  1024.                       "Invalid command list address returned! (%lx)n",
  1025.                                 ctlr, complete);
  1026.                         cmd_free(info_p, c, 1);
  1027.                         return (IO_ERROR);
  1028.                 }
  1029.         } else {
  1030.                 printk( KERN_WARNING
  1031.                         "cciss cciss%d: SendCmd Timeout out, "
  1032.                         "No command list address returned!n",
  1033.                         ctlr);
  1034.                 cmd_free(info_p, c, 1);
  1035.                 return (IO_ERROR);
  1036.         }
  1037. cmd_free(info_p, c, 1);
  1038.         return (IO_OK);
  1039. } 
  1040. /*
  1041.  * Map (physical) PCI mem into (virtual) kernel space
  1042.  */
  1043. static ulong remap_pci_mem(ulong base, ulong size)
  1044. {
  1045.         ulong page_base        = ((ulong) base) & PAGE_MASK;
  1046.         ulong page_offs        = ((ulong) base) - page_base;
  1047.         ulong page_remapped    = (ulong) ioremap(page_base, page_offs+size);
  1049.         return (ulong) (page_remapped ? (page_remapped + page_offs) : 0UL);
  1050. }
  1052. /*
  1053.  * Enqueuing and dequeuing functions for cmdlists.
  1054.  */
  1055. static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c)
  1056. {
  1057.         if (*Qptr == NULL) {
  1058.                 *Qptr = c;
  1059.                 c->next = c->prev = c;
  1060.         } else {
  1061.                 c->prev = (*Qptr)->prev;
  1062.                 c->next = (*Qptr);
  1063.                 (*Qptr)->prev->next = c;
  1064.                 (*Qptr)->prev = c;
  1065.         }
  1066. }
  1068. static inline CommandList_struct *removeQ(CommandList_struct **Qptr, 
  1069. CommandList_struct *c)
  1070. {
  1071.         if (c && c->next != c) {
  1072.                 if (*Qptr == c) *Qptr = c->next;
  1073.                 c->prev->next = c->next;
  1074.                 c->next->prev = c->prev;
  1075.         } else {
  1076.                 *Qptr = NULL;
  1077.         }
  1078.         return c;
  1079. }
  1081. /* 
  1082.  * Takes jobs of the Q and sends them to the hardware, then puts it on 
  1083.  * the Q to wait for completion. 
  1084.  */ 
  1085. static void start_io( ctlr_info_t *h)
  1086. {
  1087. CommandList_struct *c;
  1089. while(( c = h->reqQ) != NULL )
  1090. {
  1091. /* can't do anything if fifo is full */
  1092. if ((h->access.fifo_full(h)))
  1093. {
  1094. printk(KERN_WARNING "cciss: fifo full n");
  1095. return;
  1096. }
  1097. /* Get the frist entry from the Request Q */ 
  1098. removeQ(&(h->reqQ), c);
  1099. h->Qdepth--;
  1101. /* Tell the controller execute command */ 
  1102. h->access.submit_command(h, c);
  1104. /* Put job onto the completed Q */ 
  1105. addQ (&(h->cmpQ), c); 
  1106. }
  1107. }
  1109. static inline void complete_buffers( struct buffer_head *bh, int status)
  1110. {
  1111. struct buffer_head *xbh;
  1113. while(bh)
  1114. {
  1115. xbh = bh->b_reqnext; 
  1116. bh->b_reqnext = NULL; 
  1117. blk_finished_io(bh->b_size >> 9);
  1118. bh->b_end_io(bh, status);
  1119. bh = xbh;
  1120. }
  1121. } 
  1122. /* checks the status of the job and calls complete buffers to mark all 
  1123.  * buffers for the completed job. 
  1124.  */ 
  1125. static inline void complete_command( CommandList_struct *cmd, int timeout)
  1126. {
  1127. int status = 1;
  1128. int i;
  1129. u64bit temp64;
  1131. if (timeout)
  1132. status = 0; 
  1133. /* unmap the DMA mapping for all the scatter gather elements */
  1134. for(i=0; i<cmd->Header.SGList; i++)
  1135. {
  1136. temp64.val32.lower = cmd->SG[i].Addr.lower;
  1137. temp64.val32.upper = cmd->SG[i].Addr.upper;
  1138. pci_unmap_single(hba[cmd->ctlr]->pdev,
  1139. temp64.val, cmd->SG[i].Len, 
  1140. (cmd->Request.Type.Direction == XFER_READ) ? 
  1141. PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE);
  1142. }
  1144. if(cmd->err_info->CommandStatus != 0) 
  1145. { /* an error has occurred */ 
  1146. switch(cmd->err_info->CommandStatus)
  1147. {
  1148. case CMD_TARGET_STATUS:
  1149. printk(KERN_WARNING "cciss: cmd %p has "
  1150. " completed with errorsn", cmd);
  1151. if( cmd->err_info->ScsiStatus)
  1152.                  {
  1153.                      printk(KERN_WARNING "cciss: cmd %p "
  1154. "has SCSI Status = %xn",
  1155.                          cmd,  
  1156. cmd->err_info->ScsiStatus);
  1157.                  }
  1159. break;
  1160. case CMD_DATA_UNDERRUN:
  1161. printk(KERN_WARNING "cciss: cmd %p has"
  1162. " completed with data underrun "
  1163. "reportedn", cmd);
  1164. break;
  1165. case CMD_DATA_OVERRUN:
  1166. printk(KERN_WARNING "cciss: cmd %p has"
  1167. " completed with data overrun "
  1168. "reportedn", cmd);
  1169. break;
  1170. case CMD_INVALID:
  1171. printk(KERN_WARNING "cciss: cmd %p is "
  1172. "reported invalidn", cmd);
  1173. status = 0;
  1174. break;
  1175. case CMD_PROTOCOL_ERR:
  1176.                                 printk(KERN_WARNING "cciss: cmd %p has "
  1177. "protocol error n", cmd);
  1178.                                 status = 0;
  1179.                         break;
  1180. case CMD_HARDWARE_ERR:
  1181.                                 printk(KERN_WARNING "cciss: cmd %p had " 
  1182.                                         " hardware errorn", cmd);
  1183.                                 status = 0;
  1184.                         break;
  1185. case CMD_CONNECTION_LOST:
  1186. printk(KERN_WARNING "cciss: cmd %p had "
  1187. "connection lostn", cmd);
  1188. status=0;
  1189. break;
  1190. case CMD_ABORTED:
  1191. printk(KERN_WARNING "cciss: cmd %p was "
  1192. "abortedn", cmd);
  1193. status=0;
  1194. break;
  1195. case CMD_ABORT_FAILED:
  1196. printk(KERN_WARNING "cciss: cmd %p reports "
  1197. "abort failedn", cmd);
  1198. status=0;
  1199. break;
  1200. case CMD_UNSOLICITED_ABORT:
  1201. printk(KERN_WARNING "cciss: cmd %p aborted "
  1202. "do to an unsolicited abortn", cmd);
  1203. status=0;
  1204. break;
  1205. case CMD_TIMEOUT:
  1206. printk(KERN_WARNING "cciss: cmd %p timedoutn",
  1207. cmd);
  1208. status=0;
  1209. break;
  1210. default:
  1211. printk(KERN_WARNING "cciss: cmd %p returned "
  1212. "unknown status %xn", cmd, 
  1213. cmd->err_info->CommandStatus); 
  1214. status=0;
  1215. }
  1216. }
  1217. complete_buffers(cmd->rq->bh, status);
  1219. #ifdef CCISS_DEBUG
  1220. printk("Done with %pn", cmd->rq);
  1221. #endif /* CCISS_DEBUG */ 
  1222. end_that_request_last(cmd->rq);
  1223. }
  1226. static inline int cpq_new_segment(request_queue_t *q, struct request *rq,
  1227.                                   int max_segments)
  1228. {
  1229.         if (rq->nr_segments < MAXSGENTRIES) {
  1230.                 rq->nr_segments++;
  1231.                 return 1;
  1232.         }
  1233.         return 0;
  1234. }
  1236. static int cpq_back_merge_fn(request_queue_t *q, struct request *rq,
  1237.                              struct buffer_head *bh, int max_segments)
  1238. {
  1239.         if (rq->bhtail->b_data + rq->bhtail->b_size == bh->b_data)
  1240.                 return 1;
  1241.         return cpq_new_segment(q, rq, max_segments);
  1242. }
  1244. static int cpq_front_merge_fn(request_queue_t *q, struct request *rq,
  1245.                              struct buffer_head *bh, int max_segments)
  1246. {
  1247.         if (bh->b_data + bh->b_size == rq->bh->b_data)
  1248.                 return 1;
  1249.         return cpq_new_segment(q, rq, max_segments);
  1250. }
  1252. static int cpq_merge_requests_fn(request_queue_t *q, struct request *rq,
  1253.                                  struct request *nxt, int max_segments)
  1254. {
  1255.         int total_segments = rq->nr_segments + nxt->nr_segments;
  1257.         if (rq->bhtail->b_data + rq->bhtail->b_size == nxt->bh->b_data)
  1258.                 total_segments--;
  1260.         if (total_segments > MAXSGENTRIES)
  1261.                 return 0;
  1263.         rq->nr_segments = total_segments;
  1264.         return 1;
  1265. }
  1267. /* 
  1268.  * Get a request and submit it to the controller. 
  1269.  * Currently we do one request at a time.  Ideally we would like to send
  1270.  * everything to the controller on the first call, but there is a danger
  1271.  * of holding the io_request_lock for to long.  
  1272.  */
  1273. static void do_cciss_request(request_queue_t *q)
  1274. {
  1275. ctlr_info_t *h= q->queuedata; 
  1276. CommandList_struct *c;
  1277. int log_unit, start_blk, seg;
  1278. char *lastdataend;
  1279. struct buffer_head *bh;
  1280. struct list_head *queue_head = &q->queue_head;
  1281. struct request *creq;
  1282. u64bit temp64;
  1283. struct my_sg tmp_sg[MAXSGENTRIES];
  1284. int i;
  1286. if (q->plugged)
  1287. goto startio;
  1289. queue_next:
  1290. if (list_empty(queue_head))
  1291. goto startio;
  1293. creq = blkdev_entry_next_request(queue_head); 
  1294. if (creq->nr_segments > MAXSGENTRIES)
  1295.                 BUG();
  1297.         if (h->ctlr != MAJOR(creq->rq_dev)-MAJOR_NR )
  1298.         {
  1299.                 printk(KERN_WARNING "doreq cmd for %d, %x at %pn",
  1300.                                 h->ctlr, creq->rq_dev, creq);
  1301.                 blkdev_dequeue_request(creq);
  1302.                 complete_buffers(creq->bh, 0);
  1303. end_that_request_last(creq);
  1304. goto startio;
  1305.         }
  1307. if (( c = cmd_alloc(h, 1)) == NULL)
  1308. goto startio;
  1310. blkdev_dequeue_request(creq);
  1312. spin_unlock_irq(&io_request_lock);
  1314. c->cmd_type = CMD_RWREQ;      
  1315. bh = creq->bh;
  1316. c->rq = creq;
  1318. /* fill in the request */ 
  1319. log_unit = MINOR(creq->rq_dev) >> NWD_SHIFT; 
  1320. c->Header.ReplyQueue = 0;  // unused in simple mode
  1321. c->Header.Tag.lower = c->busaddr;  // use the physical address the cmd block for tag
  1322. c->Header.LUN.LogDev.VolId= hba[h->ctlr]->drv[log_unit].LunID;
  1323. c->Header.LUN.LogDev.Mode = 1;
  1324. c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
  1325. c->Request.Type.Type =  TYPE_CMD; // It is a command. 
  1326. c->Request.Type.Attribute = ATTR_SIMPLE; 
  1327. c->Request.Type.Direction = 
  1328. (creq->cmd == READ) ? XFER_READ: XFER_WRITE; 
  1329. c->Request.Timeout = 0; // Don't time out
  1330. c->Request.CDB[0] = (creq->cmd == READ) ? CCISS_READ : CCISS_WRITE;
  1331. start_blk = hba[h->ctlr]->hd[MINOR(creq->rq_dev)].start_sect + creq->sector;
  1332. #ifdef CCISS_DEBUG
  1333. if (bh == NULL)
  1334. panic("cciss: bh== NULL?");
  1335. printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%dn",(int) creq->sector,
  1336. (int) creq->nr_sectors);
  1337. #endif /* CCISS_DEBUG */
  1338. seg = 0; 
  1339. lastdataend = NULL;
  1340. while(bh)
  1341. {
  1342. if (bh->b_data == lastdataend)
  1343. {  // tack it on to the last segment 
  1344. tmp_sg[seg-1].len +=bh->b_size;
  1345. lastdataend += bh->b_size;
  1346. } else
  1347. {
  1348. if (seg == MAXSGENTRIES)
  1349. BUG();
  1350. tmp_sg[seg].len = bh->b_size;
  1351. tmp_sg[seg].start_addr = bh->b_data;
  1352. lastdataend = bh->b_data + bh->b_size;
  1353. seg++;
  1354. }
  1355. bh = bh->b_reqnext;
  1356. }
  1357. /* get the DMA records for the setup */ 
  1358. for (i=0; i<seg; i++)
  1359. {
  1360. c->SG[i].Len = tmp_sg[i].len;
  1361. temp64.val = (__u64) pci_map_single( h->pdev,
  1362. tmp_sg[i].start_addr,
  1363. tmp_sg[i].len,
  1364. (c->Request.Type.Direction == XFER_READ) ? 
  1365.                                 PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE);
  1366. c->SG[i].Addr.lower = temp64.val32.lower;
  1367.                 c->SG[i].Addr.upper = temp64.val32.upper;
  1368.                 c->SG[i].Ext = 0;  // we are not chaining
  1369. }
  1370. /* track how many SG entries we are using */ 
  1371. if( seg > h->maxSG)
  1372. h->maxSG = seg; 
  1374. #ifdef CCISS_DEBUG
  1375. printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segmentsn", creq->nr_sectors, seg);
  1376. #endif /* CCISS_DEBUG */
  1378. c->Header.SGList = c->Header.SGTotal = seg;
  1379. c->Request.CDB[1]= 0;
  1380. c->Request.CDB[2]= (start_blk >> 24) & 0xff; //MSB
  1381. c->Request.CDB[3]= (start_blk >> 16) & 0xff;
  1382. c->Request.CDB[4]= (start_blk >>  8) & 0xff;
  1383. c->Request.CDB[5]= start_blk & 0xff;
  1384. c->Request.CDB[6]= 0; // (sect >> 24) & 0xff; MSB
  1385. c->Request.CDB[7]= (creq->nr_sectors >>  8) & 0xff; 
  1386. c->Request.CDB[8]= creq->nr_sectors & 0xff; 
  1387. c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
  1389. spin_lock_irq(&io_request_lock);
  1391. addQ(&(h->reqQ),c);
  1392. h->Qdepth++;
  1393. if(h->Qdepth > h->maxQsinceinit)
  1394. h->maxQsinceinit = h->Qdepth; 
  1396. goto queue_next;
  1397. startio:
  1398. start_io(h);
  1399. }
  1401. static void do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs)
  1402. {
  1403. ctlr_info_t *h = dev_id;
  1404. CommandList_struct *c;
  1405. unsigned long flags;
  1406. __u32 a, a1;
  1409. /* Is this interrupt for us? */
  1410. if ( h->access.intr_pending(h) == 0)
  1411. return;
  1413. /*
  1414.  * If there are completed commands in the completion queue,
  1415.  * we had better do something about it.
  1416.  */
  1417. spin_lock_irqsave(&io_request_lock, flags);
  1418. while( h->access.intr_pending(h))
  1419. {
  1420. while((a = h->access.command_completed(h)) != FIFO_EMPTY) 
  1421. {
  1422. a1 = a;
  1423. a &= ~3;
  1424. if ((c = h->cmpQ) == NULL)
  1425. {  
  1426. printk(KERN_WARNING "cciss: Completion of %08lx ignoredn", (unsigned long)a1);
  1427. continue;
  1428. } 
  1429. while(c->busaddr != a) {
  1430. c = c->next;
  1431. if (c == h->cmpQ) 
  1432. break;
  1433. }
  1434. /*
  1435.  * If we've found the command, take it off the
  1436.  * completion Q and free it
  1437.  */
  1438.  if (c->busaddr == a) {
  1439. removeQ(&h->cmpQ, c);
  1440. if (c->cmd_type == CMD_RWREQ) {
  1441. complete_command(c, 0);
  1442. cmd_free(h, c, 1);
  1443. } else if (c->cmd_type == CMD_IOCTL_PEND) {
  1444. c->cmd_type = CMD_IOCTL_DONE;
  1445. }
  1446. continue;
  1447. }
  1448. }
  1449. }
  1450. /*
  1451.  * See if we can queue up some more IO
  1452.  */
  1453. do_cciss_request(BLK_DEFAULT_QUEUE(MAJOR_NR + h->ctlr));
  1454. spin_unlock_irqrestore(&io_request_lock, flags);
  1455. }
  1456. /* 
  1457.  *  We cannot read the structure directly, for portablity we must use 
  1458.  *   the io functions.
  1459.  *   This is for debug only. 
  1460.  */
  1461. #ifdef CCISS_DEBUG
  1462. static void print_cfg_table( CfgTable_struct *tb)
  1463. {
  1464. int i;
  1465. char temp_name[17];
  1467. printk("Controller Configuration informationn");
  1468. printk("------------------------------------n");
  1469. for(i=0;i<4;i++)
  1470. temp_name[i] = readb(&(tb->Signature[i]));
  1471. temp_name[4]='';
  1472. printk("   Signature = %sn", temp_name); 
  1473. printk("   Spec Number = %dn", readl(&(tb->SpecValence)));
  1474. printk("   Transport methods supported = 0x%xn", 
  1475. readl(&(tb-> TransportSupport)));
  1476. printk("   Transport methods active = 0x%xn", 
  1477. readl(&(tb->TransportActive)));
  1478. printk("   Requested transport Method = 0x%xn", 
  1479. readl(&(tb->HostWrite.TransportRequest)));
  1480. printk("   Coalese Interrupt Delay = 0x%xn", 
  1481. readl(&(tb->HostWrite.CoalIntDelay)));
  1482. printk("   Coalese Interrupt Count = 0x%xn", 
  1483. readl(&(tb->HostWrite.CoalIntCount)));
  1484. printk("   Max outstanding commands = 0x%dn", 
  1485. readl(&(tb->CmdsOutMax)));
  1486. printk("   Bus Types = 0x%xn", readl(&(tb-> BusTypes)));
  1487. for(i=0;i<16;i++)
  1488. temp_name[i] = readb(&(tb->ServerName[i]));
  1489. temp_name[16] = '';
  1490. printk("   Server Name = %sn", temp_name);
  1491. printk("   Heartbeat Counter = 0x%xnnn", 
  1492. readl(&(tb->HeartBeat)));
  1493. }
  1494. #endif /* CCISS_DEBUG */ 
  1496. static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
  1497. {
  1498. ushort vendor_id, device_id, command;
  1499. unchar cache_line_size, latency_timer;
  1500. unchar irq, revision;
  1501. uint addr[6];
  1502. __u32 board_id;
  1503. int cfg_offset;
  1504. int cfg_base_addr;
  1505. int cfg_base_addr_index;
  1506. int i;
  1508. vendor_id = pdev->vendor;
  1509. device_id = pdev->device;
  1510. irq = pdev->irq;
  1512. for(i=0; i<6; i++)
  1513. addr[i] = pdev->resource[i].start;
  1515. if (pci_enable_device(pdev))
  1516. {
  1517. printk(KERN_ERR "cciss: Unable to Enable PCI devicen");
  1518. return( -1);
  1519. }
  1520. if (pci_set_dma_mask(pdev, CCISS_DMA_MASK ) != 0)
  1521. {
  1522. printk(KERN_ERR "cciss:  Unable to set DMA maskn");
  1523. return(-1);
  1524. }
  1526. (void) pci_read_config_word(pdev, PCI_COMMAND,&command);
  1527. (void) pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
  1528. (void) pci_read_config_byte(pdev, PCI_CACHE_LINE_SIZE,
  1529. &cache_line_size);
  1530. (void) pci_read_config_byte(pdev, PCI_LATENCY_TIMER,
  1531. &latency_timer);
  1533. (void) pci_read_config_dword(pdev, PCI_SUBSYSTEM_VENDOR_ID, 
  1534. &board_id);
  1536. #ifdef CCISS_DEBUG
  1537. printk("vendor_id = %xn", vendor_id);
  1538. printk("device_id = %xn", device_id);
  1539. printk("command = %xn", command);
  1540. for(i=0; i<6; i++)
  1541. printk("addr[%d] = %xn", i, addr[i]);
  1542. printk("revision = %xn", revision);
  1543. printk("irq = %xn", irq);
  1544. printk("cache_line_size = %xn", cache_line_size);
  1545. printk("latency_timer = %xn", latency_timer);
  1546. printk("board_id = %xn", board_id);
  1547. #endif /* CCISS_DEBUG */ 
  1549. c->intr = irq;
  1551. /*
  1552.  * Memory base addr is first addr , the second points to the config
  1553.          *   table
  1554.  */
  1556. c->paddr = addr[0] & 0xfffffff0; /* remove the addressing mode bits */
  1557. #ifdef CCISS_DEBUG
  1558. printk("address 0 = %xn", c->paddr);
  1559. #endif /* CCISS_DEBUG */ 
  1560. c->vaddr = remap_pci_mem(c->paddr, 200);
  1562. /* get the address index number */
  1563. cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET);
  1564. /* I am not prepared to deal with a 64 bit address value */
  1565. cfg_base_addr &= 0xffff;
  1566. #ifdef CCISS_DEBUG
  1567. printk("cfg base address = %xn", cfg_base_addr);
  1568. #endif /* CCISS_DEBUG */
  1569. cfg_base_addr_index = (cfg_base_addr  - PCI_BASE_ADDRESS_0)/4;
  1570. #ifdef CCISS_DEBUG
  1571. printk("cfg base address index = %xn", cfg_base_addr_index);
  1572. #endif /* CCISS_DEBUG */
  1574. cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
  1575. #ifdef CCISS_DEBUG
  1576. printk("cfg offset = %xn", cfg_offset);
  1577. #endif /* CCISS_DEBUG */
  1578. c->cfgtable = (CfgTable_struct *) 
  1579. remap_pci_mem((addr[cfg_base_addr_index] & 0xfffffff0)
  1580. + cfg_offset, sizeof(CfgTable_struct));
  1581. c->board_id = board_id;
  1583. #ifdef CCISS_DEBUG
  1584. print_cfg_table(c->cfgtable); 
  1585. #endif /* CCISS_DEBUG */
  1587. for(i=0; i<NR_PRODUCTS; i++) {
  1588. if (board_id == products[i].board_id) {
  1589. c->product_name = products[i].product_name;
  1590. c->access = *(products[i].access);
  1591. break;
  1592. }
  1593. }
  1594. if (i == NR_PRODUCTS) {
  1595. printk(KERN_WARNING "cciss: Sorry, I don't know how"
  1596. " to access the Smart Array controller %08lxn", 
  1597. (unsigned long)board_id);
  1598. return -1;
  1599. }
  1600. if (  (readb(&c->cfgtable->Signature[0]) != 'C') ||
  1601.       (readb(&c->cfgtable->Signature[1]) != 'I') ||
  1602.       (readb(&c->cfgtable->Signature[2]) != 'S') ||
  1603.       (readb(&c->cfgtable->Signature[3]) != 'S') )
  1604. {
  1605. printk("Does not appear to be a valid CISS config tablen");
  1606. return -1;
  1607. }
  1608. #ifdef CCISS_DEBUG
  1609. printk("Trying to put board into Simple moden");
  1610. #endif /* CCISS_DEBUG */ 
  1611. c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
  1612. /* Update the field, and then ring the doorbell */ 
  1613. writel( CFGTBL_Trans_Simple, 
  1614. &(c->cfgtable->HostWrite.TransportRequest));
  1615. writel( CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
  1617. for(i=0;i<MAX_CONFIG_WAIT;i++)
  1618. {
  1619. if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
  1620. break;
  1621. /* delay and try again */
  1622. udelay(1000);
  1623. }
  1625. #ifdef CCISS_DEBUG
  1626. printk(KERN_DEBUG "I counter got to %d %xn", i, readl(c->vaddr + SA5_DOORBELL));
  1627. #endif /* CCISS_DEBUG */
  1628. #ifdef CCISS_DEBUG
  1629. print_cfg_table(c->cfgtable);
  1630. #endif /* CCISS_DEBUG */ 
  1632. if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple))
  1633. {
  1634. printk(KERN_WARNING "cciss: unable to get board into"
  1635. " simple moden");
  1636. return -1;
  1637. }
  1638. return 0;
  1640. }
  1642. /* 
  1643.  * Gets information about the local volumes attached to the controller. 
  1644.  */ 
  1645. static void cciss_getgeometry(int cntl_num)
  1646. {
  1647. ReportLunData_struct *ld_buff;
  1648. ReadCapdata_struct *size_buff;
  1649. InquiryData_struct *inq_buff;
  1650. int return_code;
  1651. int i;
  1652. int listlength = 0;
  1653. int lunid = 0;
  1654. int block_size;
  1655. int total_size; 
  1657. ld_buff = kmalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
  1658. if (ld_buff == NULL)
  1659. {
  1660. printk(KERN_ERR "cciss: out of memoryn");
  1661. return;
  1662. }
  1663. memset(ld_buff, 0, sizeof(ReportLunData_struct));
  1664. size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
  1665.         if (size_buff == NULL)
  1666.         {
  1667.                 printk(KERN_ERR "cciss: out of memoryn");
  1668. kfree(ld_buff);
  1669.                 return;
  1670.         }
  1671. inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
  1672.         if (inq_buff == NULL)
  1673.         {
  1674.                 printk(KERN_ERR "cciss: out of memoryn");
  1675.                 kfree(ld_buff);
  1676. kfree(size_buff);
  1677.                 return;
  1678.         }
  1679. /* Get the firmware version */ 
  1680. return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff, 
  1681. sizeof(InquiryData_struct), 0, 0 ,0 );
  1682. if (return_code == IO_OK)
  1683. {
  1684. hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
  1685. hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
  1686. hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
  1687. hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
  1688. } else /* send command failed */
  1689. {
  1690. printk(KERN_WARNING "cciss: unable to determine firmware"
  1691. " version of controllern");
  1692. }
  1693. /* Get the number of logical volumes */ 
  1694. return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff, 
  1695. sizeof(ReportLunData_struct), 0, 0, 0 );
  1697. if( return_code == IO_OK)
  1698. {
  1699. #ifdef CCISS_DEBUG
  1700. printk("LUN Datan--------------------------n");
  1701. #endif /* CCISS_DEBUG */ 
  1703. listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
  1704. listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
  1705. listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
  1706. listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
  1707. } else /* reading number of logical volumes failed */
  1708. {
  1709. printk(KERN_WARNING "cciss: report logical volume"
  1710. " command failedn");
  1711. listlength = 0;
  1712. }
  1713. hba[cntl_num]->num_luns = listlength / 8; // 8 bytes pre entry
  1714. if (hba[cntl_num]->num_luns > CISS_MAX_LUN)
  1715. {
  1716. printk(KERN_ERR "ciss:  only %d number of logical volumes supportedn",
  1717. CISS_MAX_LUN);
  1718. hba[cntl_num]->num_luns = CISS_MAX_LUN;
  1719. }
  1720. #ifdef CCISS_DEBUG
  1721. printk(KERN_DEBUG "Length = %x %x %x %x = %dn", ld_buff->LUNListLength[0],
  1722. ld_buff->LUNListLength[1], ld_buff->LUNListLength[2],
  1723. ld_buff->LUNListLength[3],  hba[cntl_num]->num_luns);
  1724. #endif /* CCISS_DEBUG */
  1725. for(i=0; i<  hba[cntl_num]->num_luns ; i++)
  1726. {
  1727.    lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3])) << 24;
  1728.          lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2])) << 16;
  1729.          lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1])) << 8;
  1730.          lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
  1731. hba[cntl_num]->drv[i].LunID = lunid;
  1733. #ifdef CCISS_DEBUG
  1734.    printk(KERN_DEBUG "LUN[%d]:  %x %x %x %x = %xn", i, 
  1735. ld_buff->LUN[i][0], ld_buff->LUN[i][1],ld_buff->LUN[i][2], 
  1736. ld_buff->LUN[i][3], hba[cntl_num]->drv[i].LunID);
  1737. #endif /* CCISS_DEBUG */
  1739.    memset(size_buff, 0, sizeof(ReadCapdata_struct));
  1740.    return_code = sendcmd(CCISS_READ_CAPACITY, cntl_num, size_buff, 
  1741. sizeof( ReadCapdata_struct), 1, i, 0 );
  1742.    if (return_code == IO_OK)
  1743. {
  1744. total_size = (0xff & 
  1745. (unsigned int)(size_buff->total_size[0])) << 24;
  1746. total_size |= (0xff & 
  1747. (unsigned int)(size_buff->total_size[1])) << 16;
  1748. total_size |= (0xff & 
  1749. (unsigned int)(size_buff->total_size[2])) << 8;
  1750. total_size |= (0xff & (unsigned int)
  1751. (size_buff->total_size[3])); 
  1752. total_size++; // command returns highest block address
  1754. block_size = (0xff & 
  1755. (unsigned int)(size_buff->block_size[0])) << 24;
  1756.                  block_size |= (0xff & 
  1757. (unsigned int)(size_buff->block_size[1])) << 16;
  1758.                  block_size |= (0xff & 
  1759. (unsigned int)(size_buff->block_size[2])) << 8;
  1760.                  block_size |= (0xff & 
  1761. (unsigned int)(size_buff->block_size[3]));
  1762. } else /* read capacity command failed */ 
  1763. {
  1764. printk(KERN_WARNING "cciss: read capacity failedn");
  1765. total_size = block_size = 0; 
  1766. }
  1767. printk(KERN_INFO "      blocks= %d block_size= %dn", 
  1768. total_size, block_size);
  1770. /* Execute the command to read the disk geometry */
  1771. memset(inq_buff, 0, sizeof(InquiryData_struct));
  1772. return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
  1773.                  sizeof(InquiryData_struct), 1, i ,0xC1 );
  1774.    if (return_code == IO_OK)
  1775. {
  1776. if(inq_buff->data_byte[8] == 0xFF)
  1777. {
  1778.    printk(KERN_WARNING "cciss: reading geometry failed, volume does not support reading geometryn");
  1780.                            hba[cntl_num]->drv[i].block_size = block_size;
  1781.                            hba[cntl_num]->drv[i].nr_blocks = total_size;
  1782.                            hba[cntl_num]->drv[i].heads = 255;
  1783.                            hba[cntl_num]->drv[i].sectors = 32; // Sectors per track
  1784.                            hba[cntl_num]->drv[i].cylinders = total_size / 255 / 32;                 } else
  1785. {
  1787.      hba[cntl_num]->drv[i].block_size = block_size;
  1788.                            hba[cntl_num]->drv[i].nr_blocks = total_size;
  1789.                            hba[cntl_num]->drv[i].heads = 
  1790. inq_buff->data_byte[6]; 
  1791.                            hba[cntl_num]->drv[i].sectors = 
  1792. inq_buff->data_byte[7]; 
  1793.    hba[cntl_num]->drv[i].cylinders = 
  1794. (inq_buff->data_byte[4] & 0xff) << 8;
  1795.    hba[cntl_num]->drv[i].cylinders += 
  1796.                                         inq_buff->data_byte[5];
  1797. }
  1798. }
  1799. else /* Get geometry failed */
  1800. {
  1801. printk(KERN_WARNING "cciss: reading geometry failed, continuing with default geometryn"); 
  1803. hba[cntl_num]->drv[i].block_size = block_size;
  1804. hba[cntl_num]->drv[i].nr_blocks = total_size;
  1805. hba[cntl_num]->drv[i].heads = 255;
  1806. hba[cntl_num]->drv[i].sectors = 32; // Sectors per track 
  1807. hba[cntl_num]->drv[i].cylinders = total_size / 255 / 32;
  1808. }
  1809. printk(KERN_INFO "      heads= %d, sectors= %d, cylinders= %dnn",
  1810. hba[cntl_num]->drv[i].heads, 
  1811. hba[cntl_num]->drv[i].sectors,
  1812. hba[cntl_num]->drv[i].cylinders);
  1814. }
  1815. kfree(ld_buff);
  1816. kfree(size_buff);
  1817. }
  1819. /* Function to find the first free pointer into our hba[] array */
  1820. /* Returns -1 if no free entries are left.  */
  1821. static int alloc_cciss_hba(void)
  1822. {
  1823. int i;
  1824. for(i=0; i< MAX_CTLR; i++)
  1825. {
  1826. if (hba[i] == NULL)
  1827. {
  1828. hba[i] = kmalloc(sizeof(ctlr_info_t), GFP_KERNEL);
  1829. if(hba[i]==NULL)
  1830. {
  1831. printk(KERN_ERR "cciss: out of memory.n");
  1832. return (-1);
  1833. }
  1834. return (i);
  1835. }
  1836. }
  1837. printk(KERN_WARNING "cciss: This driver supports a maximum"
  1838. " of 8 controllers.n");
  1839. return(-1);
  1840. }
  1842. static void free_hba(int i)
  1843. {
  1844. kfree(hba[i]);
  1845. hba[i]=NULL;
  1846. }
  1848. /*
  1849.  *  This is it.  Find all the controllers and register them.  I really hate
  1850.  *  stealing all these major device numbers.
  1851.  *  returns the number of block devices registered.
  1852.  */
  1853. static int __init cciss_init_one(struct pci_dev *pdev,
  1854. const struct pci_device_id *ent)
  1855. {
  1856. request_queue_t *q;
  1857. int i;
  1858. int j;
  1860. printk(KERN_DEBUG "cciss: Device 0x%x has been found at"
  1861. " bus %d dev %d func %dn",
  1862. pdev->device, pdev->bus->number, PCI_SLOT(pdev->devfn),
  1863. PCI_FUNC(pdev->devfn));
  1864. i = alloc_cciss_hba();
  1865. if( i < 0 ) 
  1866. return (-1);
  1867. memset(hba[i], 0, sizeof(ctlr_info_t));
  1868. if (cciss_pci_init(hba[i], pdev) != 0)
  1869. {
  1870. free_hba(i);
  1871. return (-1);
  1872. }
  1873. sprintf(hba[i]->devname, "cciss%d", i);
  1874. hba[i]->ctlr = i;
  1875. hba[i]->pdev = pdev;
  1877. if( register_blkdev(MAJOR_NR+i, hba[i]->devname, &cciss_fops))
  1878. {
  1879. printk(KERN_ERR "cciss:  Unable to get major number "
  1880. "%d for %sn", MAJOR_NR+i, hba[i]->devname);
  1881. free_hba(i);
  1882. return(-1);
  1883. }
  1884. /* make sure the board interrupts are off */
  1885. hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
  1886. if( request_irq(hba[i]->intr, do_cciss_intr, 
  1887. SA_INTERRUPT|SA_SHIRQ, hba[i]->devname, hba[i]))
  1888. {
  1889. printk(KERN_ERR "ciss: Unable to get irq %d for %sn",
  1890. hba[i]->intr, hba[i]->devname);
  1891. unregister_blkdev( MAJOR_NR+i, hba[i]->devname);
  1892. free_hba(i);
  1893. return(-1);
  1894. }
  1895. hba[i]->cmd_pool_bits = (__u32*)kmalloc(
  1896.          ((NR_CMDS+31)/32)*sizeof(__u32), GFP_KERNEL);
  1897. hba[i]->cmd_pool = (CommandList_struct *)pci_alloc_consistent(
  1898. hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct), 
  1899. &(hba[i]->cmd_pool_dhandle));
  1900. hba[i]->errinfo_pool = (ErrorInfo_struct *)pci_alloc_consistent(
  1901. hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct), 
  1902. &(hba[i]->errinfo_pool_dhandle));
  1903. if((hba[i]->cmd_pool_bits == NULL) 
  1904. || (hba[i]->cmd_pool == NULL)
  1905. || (hba[i]->errinfo_pool == NULL))
  1906.         {
  1907. if(hba[i]->cmd_pool_bits)
  1908.                  kfree(hba[i]->cmd_pool_bits);
  1909.                 if(hba[i]->cmd_pool)
  1910.                  pci_free_consistent(hba[i]->pdev,  
  1911. NR_CMDS * sizeof(CommandList_struct), 
  1912. hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
  1913. if(hba[i]->errinfo_pool)
  1914. pci_free_consistent(hba[i]->pdev,
  1915. NR_CMDS * sizeof( ErrorInfo_struct),
  1916. hba[i]->errinfo_pool, 
  1917. hba[i]->errinfo_pool_dhandle);
  1918.                 free_irq(hba[i]->intr, hba[i]);
  1919.                 unregister_blkdev(MAJOR_NR+i, hba[i]->devname);
  1920. free_hba(i);
  1921.                 printk( KERN_ERR "cciss: out of memory");
  1922. return(-1);
  1923. }
  1925. /* Initialize the pdev driver private data. 
  1926. have it point to hba[i].  */
  1927. pci_set_drvdata(pdev, hba[i]);
  1928. /* command and error info recs zeroed out before 
  1929. they are used */
  1930.         memset(hba[i]->cmd_pool_bits, 0, ((NR_CMDS+31)/32)*sizeof(__u32));
  1932. #ifdef CCISS_DEBUG
  1933. printk(KERN_DEBUG "Scanning for drives on controller cciss%dn",i);
  1934. #endif /* CCISS_DEBUG */
  1936. cciss_getgeometry(i);
  1938. /* Turn the interrupts on so we can service requests */
  1939. hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
  1941. cciss_procinit(i);
  1943. q = BLK_DEFAULT_QUEUE(MAJOR_NR + i);
  1944.         q->queuedata = hba[i];
  1945.         blk_init_queue(q, do_cciss_request);
  1946.         blk_queue_headactive(q, 0);
  1948. /* fill in the other Kernel structs */
  1949. blksize_size[MAJOR_NR+i] = hba[i]->blocksizes;
  1950.         hardsect_size[MAJOR_NR+i] = hba[i]->hardsizes;
  1951.         read_ahead[MAJOR_NR+i] = READ_AHEAD;
  1953. /* Set the pointers to queue functions */ 
  1954. q->back_merge_fn = cpq_back_merge_fn;
  1955.         q->front_merge_fn = cpq_front_merge_fn;
  1956.         q->merge_requests_fn = cpq_merge_requests_fn;
  1959. /* Fill in the gendisk data */ 
  1960. hba[i]->gendisk.major = MAJOR_NR + i;
  1961. hba[i]->gendisk.major_name = "cciss";
  1962. hba[i]->gendisk.minor_shift = NWD_SHIFT;
  1963. hba[i]->gendisk.max_p = MAX_PART;
  1964. hba[i]->gendisk.part = hba[i]->hd;
  1965. hba[i]->gendisk.sizes = hba[i]->sizes;
  1966. hba[i]->gendisk.nr_real = hba[i]->num_luns;
  1968. /* Get on the disk list */ 
  1969. add_gendisk(&(hba[i]->gendisk));
  1971. cciss_geninit(i);
  1972. for(j=0; j<NWD; j++)
  1973. register_disk(&(hba[i]->gendisk),
  1974. MKDEV(MAJOR_NR+i, j <<4), 
  1975. MAX_PART, &cciss_fops, 
  1976. hba[i]->drv[j].nr_blocks);
  1978. return(1);
  1979. }
  1981. static void __devexit cciss_remove_one (struct pci_dev *pdev)
  1982. {
  1983. ctlr_info_t *tmp_ptr;
  1984. int i;
  1986. if (pci_get_drvdata(pdev) == NULL)
  1987. {
  1988. printk( KERN_ERR "cciss: Unable to remove device n");
  1989. return;
  1990. }
  1991. tmp_ptr = pci_get_drvdata(pdev);
  1992. i = tmp_ptr->ctlr;
  1993. if (hba[i] == NULL) 
  1994. {
  1995. printk(KERN_ERR "cciss: device appears to "
  1996. "already be removed n");
  1997. return;
  1998. }
  1999. /* Turn board interrupts off */
  2000. hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
  2001. free_irq(hba[i]->intr, hba[i]);
  2002. pci_set_drvdata(pdev, NULL);
  2003. iounmap((void*)hba[i]->vaddr);
  2004. unregister_blkdev(MAJOR_NR+i, hba[i]->devname);
  2005. remove_proc_entry(hba[i]->devname, proc_cciss);
  2008. /* remove it from the disk list */
  2009. del_gendisk(&(hba[i]->gendisk));
  2011. pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct), 
  2012. hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
  2013. pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct),
  2014. hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
  2015. kfree(hba[i]->cmd_pool_bits);
  2016. free_hba(i);
  2017. }
  2019. static struct pci_driver cciss_pci_driver = {
  2020.  name:   "cciss",
  2021. probe:  cciss_init_one,
  2022. remove:  __devexit_p(cciss_remove_one),
  2023. id_table:  cciss_pci_device_id, /* id_table */
  2024. };
  2026. /*
  2027. *  This is it.  Register the PCI driver information for the cards we control
  2028. *  the OS will call our registered routines when it finds one of our cards. 
  2029. */
  2030. int __init cciss_init(void)
  2031. {
  2033. printk(KERN_INFO DRIVER_NAME "n");
  2034. /* Register for out PCI devices */
  2035. if (pci_register_driver(&cciss_pci_driver) > 0 )
  2036. return 0;
  2037. else 
  2038. return -ENODEV;
  2040.  }
  2042. EXPORT_NO_SYMBOLS;
  2043. static int __init init_cciss_module(void)
  2044. {
  2046. return ( cciss_init());
  2047. }
  2049. static void __exit cleanup_cciss_module(void)
  2050. {
  2051. int i;
  2053. pci_unregister_driver(&cciss_pci_driver);
  2054. /* double check that all controller entrys have been removed */
  2055. for (i=0; i< MAX_CTLR; i++) 
  2056. {
  2057. if (hba[i] != NULL)
  2058. {
  2059. printk(KERN_WARNING "cciss: had to remove"
  2060. " controller %dn", i);
  2061. cciss_remove_one(hba[i]->pdev);
  2062. }
  2063. }
  2064. remove_proc_entry("cciss", proc_root_driver);
  2065. }
  2067. module_init(init_cciss_module);
  2068. module_exit(cleanup_cciss_module);