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

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

Linux/Unix编程

开发平台：

Unix_Linux

megaraid.c：源码内容
  1. memset (mbox, 0, 16);
  3. /*
  4.  * Try to issue Enquiry3 command
  5.  * if not succeeded, then issue MEGA_MBOXCMD_ADAPTERINQ command and
  6.  * update enquiry3 structure
  7.  */
  8. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  9. enquiry3_dma_handle = pci_map_single (megaCfg->dev,
  10.       (void *) megaCfg->mega_buffer,
  11.       (2 * 1024L), PCI_DMA_FROMDEVICE);
  13. mbox->xferaddr = enquiry3_dma_handle;
  14. #else
  15. /*Taken care */
  16. mbox->xferaddr = virt_to_bus ((void *) megaCfg->mega_buffer);
  17. #endif
  19. /* Initialize mailbox databuffer addr */
  20. enquiry3Pnt = (mega_Enquiry3 *) megaCfg->mega_buffer;
  21. /* point mega_Enguiry3 to the data buf */
  23. mboxData[0] = FC_NEW_CONFIG; /* i.e. mbox->cmd=0xA1 */
  24. mboxData[2] = NC_SUBOP_ENQUIRY3; /* i.e. 0x0F */
  25. mboxData[3] = ENQ3_GET_SOLICITED_FULL; /* i.e. 0x02 */
  27. /* Issue a blocking command to the card */
  28. if ((retval = megaIssueCmd (megaCfg, mboxData, NULL, 0)) != 0) { /* the adapter does not support 40ld */
  29. mega_RAIDINQ adapterInquiryData;
  30. mega_RAIDINQ *adapterInquiryPnt = &adapterInquiryData;
  32. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  33. raid_inq_dma_handle = pci_map_single (megaCfg->dev,
  34.       (void *) adapterInquiryPnt,
  35.       sizeof (mega_RAIDINQ),
  36.       PCI_DMA_FROMDEVICE);
  37. mbox->xferaddr = raid_inq_dma_handle;
  38. #else
  39. /*taken care */
  40. mbox->xferaddr = virt_to_bus ((void *) adapterInquiryPnt);
  41. #endif
  43. mbox->cmd = MEGA_MBOXCMD_ADAPTERINQ; /*issue old 0x05 command to adapter */
  44. /* Issue a blocking command to the card */ ;
  45. retval = megaIssueCmd (megaCfg, mboxData, NULL, 0);
  47. pci_unmap_single (megaCfg->dev,
  48.   raid_inq_dma_handle,
  49.   sizeof (mega_RAIDINQ), PCI_DMA_FROMDEVICE);
  51. /*update Enquiry3 and ProductInfo structures with mega_RAIDINQ structure*/
  52. mega_Convert8ldTo40ld (adapterInquiryPnt,
  53.        enquiry3Pnt,
  54.        (megaRaidProductInfo *) & megaCfg->
  55.        productInfo);
  57. } else { /* adapter supports 40ld */
  58. megaCfg->flag |= BOARD_40LD;
  60. pci_unmap_single (megaCfg->dev,
  61.   enquiry3_dma_handle,
  62.   (2 * 1024L), PCI_DMA_FROMDEVICE);
  63. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  64. /*get productInfo, which is static information and will be unchanged*/
  65. prod_info_dma_handle
  66.     = pci_map_single (megaCfg->dev,
  67.       (void *) &megaCfg->productInfo,
  68.       sizeof (megaRaidProductInfo),
  69.       PCI_DMA_FROMDEVICE);
  70. mbox->xferaddr = prod_info_dma_handle;
  71. #else
  72. /*taken care */
  73. mbox->xferaddr = virt_to_bus ((void *) &megaCfg->productInfo);
  74. #endif
  76. mboxData[0] = FC_NEW_CONFIG; /* i.e. mbox->cmd=0xA1 */
  77. mboxData[2] = NC_SUBOP_PRODUCT_INFO; /* i.e. 0x0E */
  79. if ((retval = megaIssueCmd (megaCfg, mboxData, NULL, 0)) != 0)
  80. printk ("megaraid: Product_info cmd failed with error: %dn",
  81. retval);
  83. pci_unmap_single (megaCfg->dev,
  84.   prod_info_dma_handle,
  85.   sizeof (megaRaidProductInfo),
  86.   PCI_DMA_FROMDEVICE);
  87. }
  89. /*
  90.  * kernel scans the channels from 0 to <= max_channel
  91.  */
  92. megaCfg->host->max_channel =
  93. megaCfg->productInfo.SCSIChanPresent + NVIRT_CHAN -1;
  95. megaCfg->host->max_id = 16; /* max targets per channel */
  96. /*(megaCfg->flag & BOARD_40LD)?FC_MAX_TARGETS_PER_CHANNEL:MAX_TARGET+1; */
  97. #if 0
  98. megaCfg->host->max_lun = /* max lun */
  99.     (megaCfg->flag & BOARD_40LD) ?
  100. FC_MAX_LOGICAL_DRIVES : MAX_LOGICAL_DRIVES;
  101. #endif
  102. megaCfg->host->max_lun = 7; /* Upto 7 luns for non disk devices */
  104. megaCfg->host->cmd_per_lun = MAX_CMD_PER_LUN;
  106. megaCfg->numldrv = enquiry3Pnt->numLDrv;
  107. megaCfg->max_cmds = megaCfg->productInfo.MaxConcCmds;
  108. if (megaCfg->max_cmds > MAX_COMMANDS)
  109. megaCfg->max_cmds = MAX_COMMANDS - 1;
  111. megaCfg->host->can_queue = megaCfg->max_cmds - 1;
  113. #if 0
  114. if (megaCfg->host->can_queue >= MAX_COMMANDS) {
  115. megaCfg->host->can_queue = MAX_COMMANDS - 16;
  116. }
  117. #endif
  119. /* use HP firmware and bios version encoding */
  120. if (megaCfg->productInfo.subSystemVendorID == HP_SUBSYS_ID) {
  121. sprintf (megaCfg->fwVer, "%c%d%d.%d%d",
  122.  megaCfg->productInfo.FwVer[2],
  123.  megaCfg->productInfo.FwVer[1] >> 8,
  124.  megaCfg->productInfo.FwVer[1] & 0x0f,
  125.  megaCfg->productInfo.FwVer[0] >> 8,
  126.  megaCfg->productInfo.FwVer[0] & 0x0f);
  127. sprintf (megaCfg->biosVer, "%c%d%d.%d%d",
  128.  megaCfg->productInfo.BiosVer[2],
  129.  megaCfg->productInfo.BiosVer[1] >> 8,
  130.  megaCfg->productInfo.BiosVer[1] & 0x0f,
  131.  megaCfg->productInfo.BiosVer[0] >> 8,
  132.  megaCfg->productInfo.BiosVer[0] & 0x0f);
  133. } else {
  134. memcpy (megaCfg->fwVer, (char *) megaCfg->productInfo.FwVer, 4);
  135. megaCfg->fwVer[4] = 0;
  137. memcpy (megaCfg->biosVer, (char *) megaCfg->productInfo.BiosVer, 4);
  138. megaCfg->biosVer[4] = 0;
  139. }
  140. megaCfg->support_ext_cdb = mega_support_ext_cdb(megaCfg);
  142. printk (KERN_NOTICE "megaraid: [%s:%s] detected %d logical drives" M_RD_CRLFSTR,
  143. megaCfg->fwVer, megaCfg->biosVer, megaCfg->numldrv);
  145. if ( megaCfg->support_ext_cdb ) {
  146. printk(KERN_NOTICE "megaraid: supports extended CDBs.n");
  147. }
  149. /*
  150.  * I hope that I can unmap here, reason DMA transaction is not required any more
  151.  * after this
  152.  */
  154. return 0;
  155. }
  157. /*-------------------------------------------------------------------------
  158.  *
  159.  *                      Driver interface functions
  160.  *
  161.  *-------------------------------------------------------------------------*/
  163. /*----------------------------------------------------------
  164.  * Returns data to be displayed in /proc/scsi/megaraid/X
  165.  *----------------------------------------------------------*/
  167. int megaraid_proc_info (char *buffer, char **start, off_t offset,
  168.     int length, int host_no, int inout)
  169. {
  170. *start = buffer;
  171. return 0;
  172. }
  174. static int mega_findCard (Scsi_Host_Template * pHostTmpl,
  175.        u16 pciVendor, u16 pciDev, long flag)
  176. {
  177. mega_host_config *megaCfg = NULL;
  178. struct Scsi_Host *host = NULL;
  179. u_char pciBus, pciDevFun, megaIrq;
  181. u16 magic;
  182. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  183. u32 magic64;
  184. #endif
  186. int i;
  188. #if BITS_PER_LONG==64
  189. u64 megaBase;
  190. #else
  191. u32 megaBase;
  192. #endif
  194. u16 pciIdx = 0;
  195. u16 numFound = 0;
  196. u16 subsysid, subsysvid;
  198. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0) /* 0x20100 */
  199. while (!pcibios_find_device
  200.        (pciVendor, pciDev, pciIdx, &pciBus, &pciDevFun)) {
  201. #else
  203. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,3,0) /*0x20300 */
  204. struct pci_dev *pdev = NULL;
  205. #else
  206. struct pci_dev *pdev = pci_devices;
  207. #endif
  209. while ((pdev = pci_find_device (pciVendor, pciDev, pdev))) {
  210. if(pci_enable_device (pdev))
  211. continue;
  212. pciBus = pdev->bus->number;
  213. pciDevFun = pdev->devfn;
  214. #endif
  215. if ((flag & BOARD_QUARTZ) && (skip_id == -1)) {
  216. pcibios_read_config_word (pciBus, pciDevFun,
  217.   PCI_CONF_AMISIG, &magic);
  218. if ((magic != AMI_SIGNATURE)
  219.     && (magic != AMI_SIGNATURE_471)) {
  220. pciIdx++;
  221. continue; /* not an AMI board */
  222. }
  223. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  224. pcibios_read_config_dword (pciBus, pciDevFun,
  225.    PCI_CONF_AMISIG64, &magic64);
  227. if (magic64 == AMI_64BIT_SIGNATURE)
  228. flag |= BOARD_64BIT;
  229. #endif
  230. }
  232. /* Hmmm...Should we not make this more modularized so that in future we dont add
  233.    for each firmware */
  235. if (flag & BOARD_QUARTZ) {
  236. /* Check to see if this is a Dell PERC RAID controller model 466 */
  237. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0) /* 0x20100 */
  238. pcibios_read_config_word (pciBus, pciDevFun,
  239.   PCI_SUBSYSTEM_VENDOR_ID,
  240.   &subsysvid);
  241. pcibios_read_config_word (pciBus, pciDevFun,
  242.   PCI_SUBSYSTEM_ID, &subsysid);
  243. #else
  244. pci_read_config_word (pdev,
  245.       PCI_SUBSYSTEM_VENDOR_ID,
  246.       &subsysvid);
  247. pci_read_config_word (pdev,
  248.       PCI_SUBSYSTEM_ID, &subsysid);
  249. #endif
  251. #if 0
  252. /*
  253.  * This routine is called with well know values and we
  254.  * should not be getting what we have not asked.
  255.  * Also, the check is not right. It should have been for
  256.  * pci_vendor_id not subsysvid - AM
  257.  */
  259. /* If we dont detect this valid subsystem vendor id's 
  260.    we refuse to load the driver 
  261.    PART of PC200X compliance
  262.  */
  264. if ((subsysvid != AMI_SUBSYS_ID)
  265.     && (subsysvid != DELL_SUBSYS_ID)
  266.     && (subsysvid != HP_SUBSYS_ID))
  267. continue;
  268. #endif
  269. }
  271. printk (KERN_NOTICE
  272. "megaraid: found 0x%4.04x:0x%4.04x:idx %d:bus %d:slot %d:func %dn",
  273. pciVendor, pciDev, pciIdx, pciBus, PCI_SLOT (pciDevFun),
  274. PCI_FUNC (pciDevFun));
  275. /* Read the base port and IRQ from PCI */
  276. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0) /* 0x20100 */
  277. pcibios_read_config_dword (pciBus, pciDevFun,
  278.    PCI_BASE_ADDRESS_0,
  279.    (u_int *) & megaBase);
  280. pcibios_read_config_byte (pciBus, pciDevFun,
  281.   PCI_INTERRUPT_LINE, &megaIrq);
  282. #elif LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0) /*0x20300 */
  283. megaBase = pdev->base_address[0];
  284. megaIrq = pdev->irq;
  285. #else
  287. megaBase = pci_resource_start (pdev, 0);
  288. megaIrq = pdev->irq;
  289. #endif
  291. pciIdx++;
  293. if (flag & BOARD_QUARTZ) {
  294. megaBase &= PCI_BASE_ADDRESS_MEM_MASK;
  295. megaBase = (long) ioremap (megaBase, 128);
  296. if (!megaBase)
  297. continue;
  298. } else {
  299. megaBase &= PCI_BASE_ADDRESS_IO_MASK;
  300. megaBase += 0x10;
  301. }
  303. /* Initialize SCSI Host structure */
  304. host = scsi_register (pHostTmpl, sizeof (mega_host_config));
  305. if (!host)
  306. goto err_unmap;
  308. /*
  309.  * Comment the following initialization if you know 'max_sectors' is
  310.  * not defined for this kernel.
  311.  * This field was introduced in Linus's kernel 2.4.7pre3 and it
  312.  * greatly increases the IO performance - AM
  313.  */
  314. host->max_sectors = 1024;
  316. scsi_set_pci_device(host, pdev);
  317. megaCfg = (mega_host_config *) host->hostdata;
  318. memset (megaCfg, 0, sizeof (mega_host_config));
  320. printk (KERN_NOTICE "scsi%d : Found a MegaRAID controller at 0x%x, IRQ: %d"
  321. M_RD_CRLFSTR, host->host_no, (u_int) megaBase, megaIrq);
  323. if (flag & BOARD_64BIT)
  324. printk (KERN_NOTICE "scsi%d : Enabling 64 bit supportn",
  325. host->host_no);
  327. /* Copy resource info into structure */
  328. megaCfg->qCompletedH = NULL;
  329. megaCfg->qCompletedT = NULL;
  330. megaCfg->qPendingH = NULL;
  331. megaCfg->qPendingT = NULL;
  332. megaCfg->qFreeH = NULL;
  333. megaCfg->qFreeT = NULL;
  334. megaCfg->qFcnt = 0;
  335. megaCfg->qPcnt = 0;
  336. megaCfg->qCcnt = 0;
  337. megaCfg->lock_free = SPIN_LOCK_UNLOCKED;
  338. megaCfg->lock_pend = SPIN_LOCK_UNLOCKED;
  339. megaCfg->lock_scsicmd = SPIN_LOCK_UNLOCKED;
  340. megaCfg->flag = flag;
  341. megaCfg->int_qh = NULL;
  342. megaCfg->int_qt = NULL;
  343. megaCfg->int_qlen = 0;
  345. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  346. megaCfg->dev = pdev;
  347. #endif
  348. megaCfg->host = host;
  349. megaCfg->base = megaBase;
  350. megaCfg->host->irq = megaIrq;
  351. megaCfg->host->io_port = megaBase;
  352. megaCfg->host->n_io_port = 16;
  353. megaCfg->host->unique_id = (pciBus << 8) | pciDevFun;
  354. megaCtlrs[numCtlrs] = megaCfg;
  356. if (!(flag & BOARD_QUARTZ)) {
  357. /* Request our IO Range */
  358. if (!request_region(megaBase, 16, "megaraid")) {
  359. printk(KERN_WARNING "megaraid: Couldn't register I/O range!n");
  360. goto err_unregister;
  361. }
  362. }
  364. /* Request our IRQ */
  365. if (request_irq (megaIrq, megaraid_isr, SA_SHIRQ,
  366.  "megaraid", megaCfg)) {
  367. printk (KERN_WARNING
  368. "megaraid: Couldn't register IRQ %d!n",
  369. megaIrq);
  370. goto err_release;
  371. }
  373. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  374. /*
  375.  * unmap while releasing the driver, Is it required to be 
  376.  * PCI_DMA_BIDIRECTIONAL 
  377. */
  379. megaCfg->mailbox64ptr
  380.     = pci_alloc_consistent (megaCfg->dev,
  381.     sizeof (mega_mailbox64),
  382.     &(megaCfg->dma_handle64));
  384. mega_register_mailbox (megaCfg,
  385.        virt_to_bus ((void *) megaCfg->
  386.     mailbox64ptr));
  387. #else
  388. mega_register_mailbox (megaCfg,
  389.        virt_to_bus ((void *) &megaCfg->
  390.     mailbox64));
  391. #endif
  393. mega_i_query_adapter (megaCfg);
  395. if ((subsysid == 0x1111) && (subsysvid == 0x1111)) {
  397. /*
  398.  * Which firmware
  399.  */
  400. if( strcmp(megaCfg->fwVer, "3.00") == 0 ||
  401. strcmp(megaCfg->fwVer, "3.01") == 0 ) {
  403. printk( KERN_WARNING
  404. "megaraid: Your  card is a Dell PERC 2/SC RAID controller "
  405. "with  firmwarenmegaraid: 3.00 or 3.01.  This driver is "
  406. "known to have corruption issuesnmegaraid: with those "
  407. "firmware versions on this specific card.  In ordern"
  408. "megaraid: to protect your data, please upgrade your "
  409. "firmware to versionnmegaraid: 3.10 or later, available "
  410. "from the Dell Technical Support webnmegaraid: site atn"
  411. "http://support.dell.com/us/en/filelib/download/"
  412. "index.asp?fileid=2940n"
  413. );
  414. }
  415. }
  417. /*
  418.  * If we have a HP 1M(0x60E7)/2M(0x60E8) controller with
  419.  * firmware H.01.07 or H.01.08, disable 64 bit support,
  420.  * since this firmware cannot handle 64 bit addressing
  421.  */
  423. if( (subsysvid == HP_SUBSYS_ID) &&
  424. ((subsysid == 0x60E7)||(subsysid == 0x60E8)) ) {
  426. /*
  427.  * which firmware
  428.  */
  429. if( strcmp(megaCfg->fwVer, "H01.07") == 0 || 
  430.     strcmp(megaCfg->fwVer, "H01.08") == 0 ||
  431.     strcmp(megaCfg->fwVer, "H01.09") == 0 )
  432. {
  433. printk(KERN_WARNING
  434. "megaraid: Firmware H.01.07/8/9 on 1M/2M "
  435. "controllersnmegaraid: do not support 64 bit "
  436. "addressing.n"
  437. "megaraid: DISABLING 64 bit support.n");
  438. megaCfg->flag &= ~BOARD_64BIT;
  439. }
  440. }
  442. if (mega_is_bios_enabled (megaCfg)) {
  443. mega_hbas[numCtlrs].is_bios_enabled = 1;
  444. }
  446. /*
  447.  * Find out which channel is raid and which is scsi
  448.  */
  449. mega_enum_raid_scsi(megaCfg);
  450. for( i = 0; i < megaCfg->productInfo.SCSIChanPresent; i++ ) {
  451. if(IS_RAID_CH(i))
  452. printk(KERN_NOTICE"megaraid: channel[%d] is raid.n", i+1);
  453. else
  454. printk(KERN_NOTICE"megaraid: channel[%d] is scsi.n", i+1);
  455. }
  457. /*
  458.  * Find out if a logical drive is set as the boot drive. If there is
  459.  * one, will make that as the first logical drive.
  460.  */
  461. mega_get_boot_ldrv(megaCfg);
  463. mega_hbas[numCtlrs].hostdata_addr = megaCfg;
  465. /*
  466.  * Do we support random deletion and addition of logical drives
  467.  */
  468. megaCfg->read_ldidmap = 0; /* set it after first logdrv delete cmd */
  469. megaCfg->support_random_del = mega_support_random_del(megaCfg);
  471. /* Initialize SCBs */
  472. if (mega_init_scb (megaCfg)) {
  473. pci_free_consistent (megaCfg->dev,
  474.      sizeof (mega_mailbox64),
  475.      (void *) megaCfg->mailbox64ptr,
  476.      megaCfg->dma_handle64);
  477. scsi_unregister (host);
  478. continue;
  479. }
  481. /*
  482.  * Fill in the structure which needs to be passed back to the
  483.  * application when it does an ioctl() for controller related
  484.  * information.
  485.  */
  487. i = numCtlrs;
  488. numCtlrs++;
  490. mcontroller[i].base = megaBase;
  491. mcontroller[i].irq = megaIrq;
  492. mcontroller[i].numldrv = megaCfg->numldrv;
  493. mcontroller[i].pcibus = pciBus;
  494. mcontroller[i].pcidev = pciDev;
  495. mcontroller[i].pcifun = PCI_FUNC (pciDevFun);
  496. mcontroller[i].pciid = pciIdx;
  497. mcontroller[i].pcivendor = pciVendor;
  498. mcontroller[i].pcislot = PCI_SLOT (pciDevFun);
  499. mcontroller[i].uid = (pciBus << 8) | pciDevFun;
  501. numFound++;
  503. /* Set the Mode of addressing to 64 bit */
  504. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  505. if ((megaCfg->flag & BOARD_64BIT) && BITS_PER_LONG == 64)
  506. #if BITS_PER_LONG==64
  507. pdev->dma_mask = 0xffffffffffffffff;
  508. #else
  509. pdev->dma_mask = 0xffffffff;
  510. #endif
  511. #endif
  512. continue;
  513.       err_release:
  514. if (flag & BOARD_QUARTZ)
  515. release_region (megaBase, 16);
  516.       err_unregister:
  517. scsi_unregister (host);
  518.       err_unmap:
  519. if (flag & BOARD_QUARTZ)
  520. iounmap ((void *) megaBase);
  521. }
  522. return numFound;
  523. }
  525. /*---------------------------------------------------------
  526.  * Detects if a megaraid controller exists in this system
  527.  *---------------------------------------------------------*/
  529. int megaraid_detect (Scsi_Host_Template * pHostTmpl)
  530. {
  531. int ctlridx = 0, count = 0;
  533. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0) /*0x20300 */
  534. pHostTmpl->proc_dir = &proc_scsi_megaraid;
  535. #else
  536. pHostTmpl->proc_name = "megaraid";
  537. #endif
  539. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0) /* 0x20100 */
  540. if (!pcibios_present ()) {
  541. printk (KERN_WARNING "megaraid: PCI bios not present."
  542. M_RD_CRLFSTR);
  543. return 0;
  544. }
  545. #endif
  546. skip_id = -1;
  547. if (megaraid && !strncmp (megaraid, "skip", strlen ("skip"))) {
  548. if (megaraid[4] != '') {
  549. skip_id = megaraid[4] - '0';
  550. if (megaraid[5] != '') {
  551. skip_id = (skip_id * 10) + (megaraid[5] - '0');
  552. }
  553. }
  554. skip_id = (skip_id > 15) ? -1 : skip_id;
  555. }
  557. printk (KERN_NOTICE "megaraid: " MEGARAID_VERSION);
  559. memset (mega_hbas, 0, sizeof (mega_hbas));
  561. count += mega_findCard (pHostTmpl, PCI_VENDOR_ID_AMI,
  562. PCI_DEVICE_ID_AMI_MEGARAID, 0);
  563. count += mega_findCard (pHostTmpl, PCI_VENDOR_ID_AMI,
  564. PCI_DEVICE_ID_AMI_MEGARAID2, 0);
  565. count += mega_findCard (pHostTmpl, 0x8086,
  566. PCI_DEVICE_ID_AMI_MEGARAID3, BOARD_QUARTZ);
  567. count += mega_findCard (pHostTmpl, PCI_VENDOR_ID_AMI,
  568. PCI_DEVICE_ID_AMI_MEGARAID3, BOARD_QUARTZ);
  570. mega_reorder_hosts ();
  572. #ifdef CONFIG_PROC_FS
  573. if (count) {
  574. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,3,0) /*0x20300 */
  575. mega_proc_dir_entry = proc_mkdir ("megaraid", &proc_root);
  576. #else
  577. mega_proc_dir_entry = create_proc_entry ("megaraid",
  578.  S_IFDIR | S_IRUGO |
  579.  S_IXUGO, &proc_root);
  580. #endif
  581. if (!mega_proc_dir_entry)
  582. printk ("megaraid: failed to create megaraid rootn");
  583. else
  584. for (ctlridx = 0; ctlridx < count; ctlridx++)
  585. mega_create_proc_entry (ctlridx,
  586. mega_proc_dir_entry);
  587. }
  588. #endif
  590. /*
  591.  * Register the driver as a character device, for applications to access
  592.  * it for ioctls.
  593.  * Ideally, this should go in the init_module() routine, but since it is
  594.  * hidden in the file "scsi_module.c" ( included in the end ), we define
  595.  * it here
  596.  * First argument (major) to register_chrdev implies a dynamic major
  597.  * number allocation.
  598.  */
  599. if (count) {
  600. major = register_chrdev (0, "megadev", &megadev_fops);
  602. /*
  603.  * Register the Shutdown Notification hook in kernel
  604.  */
  605. if (register_reboot_notifier (&mega_notifier)) {
  606. printk ("MegaRAID Shutdown routine not registered!!n");
  607. }
  609. init_MUTEX (&mimd_entry_mtx);
  610. }
  612. return count;
  613. }
  615. /*---------------------------------------------------------------------
  616.  * Release the controller's resources
  617.  *---------------------------------------------------------------------*/
  618. int megaraid_release (struct Scsi_Host *pSHost)
  619. {
  620. mega_host_config *megaCfg;
  621. mega_mailbox *mbox;
  622. u_char mboxData[16];
  623. int i;
  625. megaCfg = (mega_host_config *) pSHost->hostdata;
  626. mbox = (mega_mailbox *) mboxData;
  628. /* Flush cache to disk */
  629. memset (mbox, 0, 16);
  630. mboxData[0] = 0xA;
  632. free_irq (megaCfg->host->irq, megaCfg); /* Must be freed first, otherwise
  633.    extra interrupt is generated */
  635. /* Issue a blocking (interrupts disabled) command to the card */
  636. megaIssueCmd (megaCfg, mboxData, NULL, 0);
  638. /* Free our resources */
  639. if (megaCfg->flag & BOARD_QUARTZ) {
  640. iounmap ((void *) megaCfg->base);
  641. } else {
  642. release_region (megaCfg->host->io_port, 16);
  643. }
  645. mega_freeSgList (megaCfg);
  646. pci_free_consistent (megaCfg->dev,
  647.      sizeof (mega_mailbox64),
  648.      (void *) megaCfg->mailbox64ptr,
  649.      megaCfg->dma_handle64);
  651. #ifdef CONFIG_PROC_FS
  652. if (megaCfg->controller_proc_dir_entry) {
  653. remove_proc_entry ("stat", megaCfg->controller_proc_dir_entry);
  654. remove_proc_entry ("status",
  655.    megaCfg->controller_proc_dir_entry);
  656. remove_proc_entry ("config",
  657.    megaCfg->controller_proc_dir_entry);
  658. remove_proc_entry ("mailbox",
  659.    megaCfg->controller_proc_dir_entry);
  660. for (i = 0; i < numCtlrs; i++) {
  661. char buf[12] = { 0 };
  662. sprintf (buf, "%d", i);
  663. remove_proc_entry (buf, mega_proc_dir_entry);
  664. }
  665. remove_proc_entry ("megaraid", &proc_root);
  666. }
  667. #endif
  669. /*
  670.  * Release the controller memory. A word of warning this frees
  671.  * hostdata and that includes megaCfg-> so be careful what you
  672.  * dereference beyond this point
  673.  */
  674.  
  675. scsi_unregister (pSHost);
  677. /*
  678.  * Unregister the character device interface to the driver. Ideally this
  679.  * should have been done in cleanup_module routine. Since this is hidden
  680.  * in file "scsi_module.c", we do it here.
  681.  * major is the major number of the character device returned by call to
  682.  * register_chrdev() routine.
  683.  */
  685. unregister_chrdev (major, "megadev");
  686. unregister_reboot_notifier (&mega_notifier);
  688. return 0;
  689. }
  691. static int mega_is_bios_enabled (mega_host_config * megacfg)
  692. {
  693. mega_mailbox *mboxpnt;
  694. unsigned char mbox[16];
  695. int ret;
  697. mboxpnt = (mega_mailbox *) mbox;
  699. memset (mbox, 0, sizeof (mbox));
  700. memset ((void *) megacfg->mega_buffer,
  701. 0, sizeof (megacfg->mega_buffer));
  703. /*
  704.  * issue command to find out if the BIOS is enabled for this controller
  705.  */
  706. mbox[0] = IS_BIOS_ENABLED;
  707. mbox[2] = GET_BIOS;
  709. mboxpnt->xferaddr = virt_to_bus ((void *) megacfg->mega_buffer);
  711. ret = megaIssueCmd (megacfg, mbox, NULL, 0);
  713. return (*(char *) megacfg->mega_buffer);
  714. }
  716. /*
  717.  * Find out what channels are RAID/SCSI
  718.  */
  719. void
  720. mega_enum_raid_scsi(mega_host_config *megacfg)
  721. {
  722. mega_mailbox *mboxp;
  723. unsigned char mbox[16];
  724. int i;
  726. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  727. dma_addr_t dma_handle;
  728. #endif
  730. mboxp = (mega_mailbox *)mbox;
  732. memset(mbox, 0, sizeof(mbox));
  733. /*
  734.  * issue command to find out what channels are raid/scsi
  735.  */
  736. mbox[0] = CHNL_CLASS;
  737. mbox[2] = GET_CHNL_CLASS;
  739. memset((void *)megacfg->mega_buffer, 0, sizeof(megacfg->mega_buffer));
  741. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  742. dma_handle = pci_map_single(megacfg->dev, (void *)megacfg->mega_buffer,
  743.       (2 * 1024L), PCI_DMA_FROMDEVICE);
  745. mboxp->xferaddr = dma_handle;
  746. #else
  747. mboxp->xferaddr = virt_to_bus((void *)megacfg->mega_buffer);
  748. #endif
  750. /*
  751.  * Non-ROMB firware fail this command, so all channels
  752.  * must be shown RAID
  753.  */
  754. if( megaIssueCmd(megacfg, mbox, NULL, 0) == 0 ) {
  755. mega_ch_class = *((char *)megacfg->mega_buffer);
  757. for( i = 0; i < NVIRT_CHAN; i++ ) {
  758. /* logical drives channel is RAID */
  759. mega_ch_class |= (0x01 << (megacfg->productInfo.SCSIChanPresent+i));
  760. }
  761. }
  762. else {
  763. mega_ch_class = 0xFF;
  764. }
  767. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  768. pci_unmap_single(megacfg->dev, dma_handle,
  769.   (2 * 1024L), PCI_DMA_FROMDEVICE);
  770. #endif
  772. }
  775. /*
  776.  * get the boot logical drive number if enabled
  777.  */
  778. void
  779. mega_get_boot_ldrv(mega_host_config *megacfg)
  780. {
  781. mega_mailbox *mboxp;
  782. unsigned char mbox[16];
  783. struct private_bios_data *prv_bios_data;
  784. u16 cksum = 0;
  785. char *cksum_p;
  786. int i;
  788. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  789. dma_addr_t dma_handle;
  790. #endif
  792. mboxp = (mega_mailbox *)mbox;
  794. memset(mbox, 0, sizeof(mbox));
  796. mbox[0] = BIOS_PVT_DATA;
  797. mbox[2] = GET_BIOS_PVT_DATA;
  799. memset((void *)megacfg->mega_buffer, 0, sizeof(megacfg->mega_buffer));
  801. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  802. dma_handle = pci_map_single(megacfg->dev, (void *)megacfg->mega_buffer,
  803.       (2 * 1024L), PCI_DMA_FROMDEVICE);
  805. mboxp->xferaddr = dma_handle;
  806. #else
  807. mboxp->xferaddr = virt_to_bus((void *)megacfg->mega_buffer);
  808. #endif
  810. megacfg->boot_ldrv_enabled = 0;
  811. megacfg->boot_ldrv = 0;
  812. if( megaIssueCmd(megacfg, mbox, NULL, 0) == 0 ) {
  814. prv_bios_data = (struct private_bios_data *)megacfg->mega_buffer;
  816. cksum = 0;
  817. cksum_p = (char *)prv_bios_data;
  818. for( i = 0; i < 14; i++ ) {
  819. cksum += (u16)(*cksum_p++);
  820. }
  822. if( prv_bios_data->cksum == (u16)(0-cksum) ) {
  823. megacfg->boot_ldrv_enabled = 1;
  824. megacfg->boot_ldrv = prv_bios_data->boot_ldrv;
  825. }
  826. }
  828. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  829. pci_unmap_single(megacfg->dev, dma_handle,
  830.   (2 * 1024L), PCI_DMA_FROMDEVICE);
  831. #endif
  833. }
  836. static void mega_reorder_hosts (void)
  837. {
  838. struct Scsi_Host *shpnt;
  839. struct Scsi_Host *shone;
  840. struct Scsi_Host *shtwo;
  841. mega_host_config *boot_host;
  842. int i;
  844. /*
  845.  * Find the (first) host which has it's BIOS enabled
  846.  */
  847. boot_host = NULL;
  848. for (i = 0; i < MAX_CONTROLLERS; i++) {
  849. if (mega_hbas[i].is_bios_enabled) {
  850. boot_host = mega_hbas[i].hostdata_addr;
  851. break;
  852. }
  853. }
  855. if (boot_host == NULL) {
  856. printk (KERN_WARNING "megaraid: no BIOS enabled.n");
  857. return;
  858. }
  860. /*
  861.  * Traverse through the list of SCSI hosts for our HBA locations
  862.  */
  863. shone = shtwo = NULL;
  864. for (shpnt = scsi_hostlist; shpnt; shpnt = shpnt->next) {
  865. /* Is it one of ours? */
  866. for (i = 0; i < MAX_CONTROLLERS; i++) {
  867. if ((mega_host_config *) shpnt->hostdata ==
  868.     mega_hbas[i].hostdata_addr) {
  869. /* Does this one has BIOS enabled */
  870. if (mega_hbas[i].hostdata_addr == boot_host) {
  872. /* Are we first */
  873. if (shtwo == NULL) /* Yes! */
  874. return;
  875. else { /* :-( */
  876. shone = shpnt;
  877. }
  878. } else {
  879. if (!shtwo) {
  880. /* were we here before? xchng first */
  881. shtwo = shpnt;
  882. }
  883. }
  884. break;
  885. }
  886. }
  887. /*
  888.  * Have we got the boot host and one which does not have the bios
  889.  * enabled.
  890.  */
  891. if (shone && shtwo)
  892. break;
  893. }
  894. if (shone && shtwo) {
  895. mega_swap_hosts (shone, shtwo);
  896. }
  898. return;
  899. }
  901. static void mega_swap_hosts (struct Scsi_Host *shone, struct Scsi_Host *shtwo)
  902. {
  903. struct Scsi_Host *prevtoshtwo;
  904. struct Scsi_Host *prevtoshone;
  905. struct Scsi_Host *save = NULL;;
  907. /* Are these two nodes adjacent */
  908. if (shtwo->next == shone) {
  910. if (shtwo == scsi_hostlist && shone->next == NULL) {
  912. /* just two nodes */
  913. scsi_hostlist = shone;
  914. shone->next = shtwo;
  915. shtwo->next = NULL;
  916. } else if (shtwo == scsi_hostlist) {
  917. /* first two nodes of the list */
  919. scsi_hostlist = shone;
  920. shtwo->next = shone->next;
  921. scsi_hostlist->next = shtwo;
  922. } else if (shone->next == NULL) {
  923. /* last two nodes of the list */
  925. prevtoshtwo = scsi_hostlist;
  927. while (prevtoshtwo->next != shtwo)
  928. prevtoshtwo = prevtoshtwo->next;
  930. prevtoshtwo->next = shone;
  931. shone->next = shtwo;
  932. shtwo->next = NULL;
  933. } else {
  934. prevtoshtwo = scsi_hostlist;
  936. while (prevtoshtwo->next != shtwo)
  937. prevtoshtwo = prevtoshtwo->next;
  939. prevtoshtwo->next = shone;
  940. shtwo->next = shone->next;
  941. shone->next = shtwo;
  942. }
  944. } else if (shtwo == scsi_hostlist && shone->next == NULL) {
  945. /* shtwo at head, shone at tail, not adjacent */
  947. prevtoshone = scsi_hostlist;
  949. while (prevtoshone->next != shone)
  950. prevtoshone = prevtoshone->next;
  952. scsi_hostlist = shone;
  953. shone->next = shtwo->next;
  954. prevtoshone->next = shtwo;
  955. shtwo->next = NULL;
  956. } else if (shtwo == scsi_hostlist && shone->next != NULL) {
  957. /* shtwo at head, shone is not at tail */
  959. prevtoshone = scsi_hostlist;
  960. while (prevtoshone->next != shone)
  961. prevtoshone = prevtoshone->next;
  963. scsi_hostlist = shone;
  964. prevtoshone->next = shtwo;
  965. save = shtwo->next;
  966. shtwo->next = shone->next;
  967. shone->next = save;
  968. } else if (shone->next == NULL) {
  969. /* shtwo not at head, shone at tail */
  971. prevtoshtwo = scsi_hostlist;
  972. prevtoshone = scsi_hostlist;
  974. while (prevtoshtwo->next != shtwo)
  975. prevtoshtwo = prevtoshtwo->next;
  976. while (prevtoshone->next != shone)
  977. prevtoshone = prevtoshone->next;
  979. prevtoshtwo->next = shone;
  980. shone->next = shtwo->next;
  981. prevtoshone->next = shtwo;
  982. shtwo->next = NULL;
  984. } else {
  985. prevtoshtwo = scsi_hostlist;
  986. prevtoshone = scsi_hostlist;
  987. save = NULL;;
  989. while (prevtoshtwo->next != shtwo)
  990. prevtoshtwo = prevtoshtwo->next;
  991. while (prevtoshone->next != shone)
  992. prevtoshone = prevtoshone->next;
  994. prevtoshtwo->next = shone;
  995. save = shone->next;
  996. shone->next = shtwo->next;
  997. prevtoshone->next = shtwo;
  998. shtwo->next = save;
  999. }
  1000. return;
  1001. }
  1003. static inline void mega_freeSgList (mega_host_config * megaCfg)
  1004. {
  1005. int i;
  1007. for (i = 0; i < megaCfg->max_cmds; i++) {
  1008. if (megaCfg->scbList[i].sgList)
  1009. pci_free_consistent (megaCfg->dev,
  1010.      sizeof (mega_64sglist) *
  1011.      MAX_SGLIST,
  1012.      megaCfg->scbList[i].sgList,
  1013.      megaCfg->scbList[i].
  1014.      dma_sghandle64);
  1015. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0) /* 0x020400 */
  1016. kfree (megaCfg->scbList[i].sgList); /* free sgList */
  1017. #endif
  1018. }
  1019. }
  1021. /*----------------------------------------------
  1022.  * Get information about the card/driver
  1023.  *----------------------------------------------*/
  1024. const char *megaraid_info (struct Scsi_Host *pSHost)
  1025. {
  1026. static char buffer[512];
  1027. mega_host_config *megaCfg;
  1029. megaCfg = (mega_host_config *) pSHost->hostdata;
  1031. sprintf (buffer,
  1032.  "LSI Logic MegaRAID %s %d commands %d targs %d chans %d luns",
  1033.  megaCfg->fwVer, megaCfg->productInfo.MaxConcCmds,
  1034.  megaCfg->host->max_id, megaCfg->host->max_channel,
  1035.  megaCfg->host->max_lun);
  1036. return buffer;
  1037. }
  1039. /*-----------------------------------------------------------------
  1040.  * Perform a SCSI command
  1041.  * Mailbox area:
  1042.  *   00 01 command
  1043.  *   01 01 command id
  1044.  *   02 02 # of sectors
  1045.  *   04 04 logical bus address
  1046.  *   08 04 physical buffer address
  1047.  *   0C 01 logical drive #
  1048.  *   0D 01 length of scatter/gather list
  1049.  *   0E 01 reserved
  1050.  *   0F 01 mailbox busy
  1051.  *   10 01 numstatus byte
  1052.  *   11 01 status byte
  1053.  *-----------------------------------------------------------------*/
  1054. int megaraid_queue (Scsi_Cmnd * SCpnt, void (*pktComp) (Scsi_Cmnd *))
  1055. {
  1056. DRIVER_LOCK_T mega_host_config * megaCfg;
  1057. mega_scb *pScb;
  1058. char *user_area = NULL;
  1060. megaCfg = (mega_host_config *) SCpnt->host->hostdata;
  1061. DRIVER_LOCK (megaCfg);
  1063. if (!(megaCfg->flag & (1L << SCpnt->channel))) {
  1064. if (SCpnt->channel < megaCfg->productInfo.SCSIChanPresent)
  1065. printk ( KERN_NOTICE
  1066. "scsi%d: scanning channel %d for devices.n",
  1067. megaCfg->host->host_no, SCpnt->channel);
  1068. else
  1069. printk ( KERN_NOTICE
  1070. "scsi%d: scanning virtual channel %d for logical drives.n",
  1071. megaCfg->host->host_no,
  1072. SCpnt->channel-megaCfg->productInfo.SCSIChanPresent+1);
  1074. megaCfg->flag |= (1L << SCpnt->channel);
  1075. }
  1077. SCpnt->scsi_done = pktComp;
  1079. if (mega_driver_ioctl (megaCfg, SCpnt))
  1080. return 0;
  1082. /* If driver in abort or reset.. cancel this command */
  1083. if (megaCfg->flag & IN_ABORT) {
  1084. SCpnt->result = (DID_ABORT << 16);
  1085. /* Add Scsi_Command to end of completed queue */
  1086. if (megaCfg->qCompletedH == NULL) {
  1087. megaCfg->qCompletedH = megaCfg->qCompletedT = SCpnt;
  1088. } else {
  1089. megaCfg->qCompletedT->host_scribble =
  1090.     (unsigned char *) SCpnt;
  1091. megaCfg->qCompletedT = SCpnt;
  1092. }
  1093. megaCfg->qCompletedT->host_scribble = (unsigned char *) NULL;
  1094. megaCfg->qCcnt++;
  1096. DRIVER_UNLOCK (megaCfg);
  1097. return 0;
  1098. } else if (megaCfg->flag & IN_RESET) {
  1099. SCpnt->result = (DID_RESET << 16);
  1100. /* Add Scsi_Command to end of completed queue */
  1101. if (megaCfg->qCompletedH == NULL) {
  1102. megaCfg->qCompletedH = megaCfg->qCompletedT = SCpnt;
  1103. } else {
  1104. megaCfg->qCompletedT->host_scribble =
  1105.     (unsigned char *) SCpnt;
  1106. megaCfg->qCompletedT = SCpnt;
  1107. }
  1108. megaCfg->qCompletedT->host_scribble = (unsigned char *) NULL;
  1109. megaCfg->qCcnt++;
  1111. DRIVER_UNLOCK (megaCfg);
  1112. return 0;
  1113. }
  1115. megaCfg->flag |= IN_QUEUE;
  1116. /* Allocate and build a SCB request */
  1117. if ((pScb = mega_build_cmd (megaCfg, SCpnt)) != NULL) {
  1119. /*
  1120.  * Check if the HBA is in quiescent state, e.g., during a delete
  1121.  * logical drive opertion. If it is, queue the commands in the
  1122.  * internal queue until the delete operation is complete.
  1123.  */
  1124. if( ! megaCfg->quiescent ) {
  1125. /* Add SCB to the head of the pending queue */
  1126. if (megaCfg->qPendingH == NULL) {
  1127. megaCfg->qPendingH = megaCfg->qPendingT = pScb;
  1128. } else {
  1129. megaCfg->qPendingT->next = pScb;
  1130. megaCfg->qPendingT = pScb;
  1131. }
  1132. megaCfg->qPendingT->next = NULL;
  1133. megaCfg->qPcnt++;
  1135. if (mega_runpendq (megaCfg) == -1) {
  1136. DRIVER_UNLOCK (megaCfg);
  1137. return 0;
  1138. }
  1139. }
  1140. else {
  1141. /* Add SCB to the internal queue */
  1142. if (megaCfg->int_qh == NULL) {
  1143. megaCfg->int_qh = megaCfg->int_qt = pScb;
  1144. } else {
  1145. megaCfg->int_qt->next = pScb;
  1146. megaCfg->int_qt = pScb;
  1147. }
  1148. megaCfg->int_qt->next = NULL;
  1149. megaCfg->int_qlen++;
  1150. }
  1152. if (pScb->SCpnt->cmnd[0] == M_RD_IOCTL_CMD_NEW) {
  1153. init_MUTEX_LOCKED (&pScb->ioctl_sem);
  1154. spin_unlock_irq (&io_request_lock);
  1155. down (&pScb->ioctl_sem);
  1156.      user_area = (char *)*((u32*)&pScb->SCpnt->cmnd[4]);
  1157. if (copy_to_user
  1158.     (user_area, pScb->buff_ptr, pScb->iDataSize)) {
  1159. printk
  1160.     ("megaraid: Error copying ioctl return value to user buffer.n");
  1161. pScb->SCpnt->result = (DID_ERROR << 16);
  1162. }
  1163. spin_lock_irq (&io_request_lock);
  1164. DRIVER_LOCK (megaCfg);
  1165. kfree (pScb->buff_ptr);
  1166. pScb->buff_ptr = NULL;
  1167. mega_cmd_done (megaCfg, pScb, pScb->SCpnt->result);
  1168. mega_rundoneq (megaCfg);
  1169. mega_runpendq (megaCfg);
  1170. DRIVER_UNLOCK (megaCfg);
  1171. }
  1173. megaCfg->flag &= ~IN_QUEUE;
  1175. }
  1177. DRIVER_UNLOCK (megaCfg);
  1178. return 0;
  1179. }
  1181. /*----------------------------------------------------------------------
  1182.  * Issue a blocking command to the controller
  1183.  *----------------------------------------------------------------------*/
  1184. volatile static int internal_done_flag = 0;
  1185. volatile static int internal_done_errcode = 0;
  1187. static DECLARE_WAIT_QUEUE_HEAD (internal_wait);
  1189. static void internal_done (Scsi_Cmnd * SCpnt)
  1190. {
  1191. internal_done_errcode = SCpnt->result;
  1192. internal_done_flag++;
  1193. wake_up (&internal_wait);
  1194. }
  1196. /* shouldn't be used, but included for completeness */
  1198. int megaraid_command (Scsi_Cmnd * SCpnt)
  1199. {
  1200. internal_done_flag = 0;
  1202. /* Queue command, and wait until it has completed */
  1203. megaraid_queue (SCpnt, internal_done);
  1205. while (!internal_done_flag) {
  1206. interruptible_sleep_on (&internal_wait);
  1207. }
  1209. return internal_done_errcode;
  1210. }
  1212. /*---------------------------------------------------------------------
  1213.  * Abort a previous SCSI request
  1214.  *---------------------------------------------------------------------*/
  1215. int megaraid_abort (Scsi_Cmnd * SCpnt)
  1216. {
  1217. mega_host_config *megaCfg;
  1218. int rc; /*, idx; */
  1219. mega_scb *pScb;
  1221. rc = SCSI_ABORT_NOT_RUNNING;
  1223. megaCfg = (mega_host_config *) SCpnt->host->hostdata;
  1225. megaCfg->flag |= IN_ABORT;
  1227. for (pScb = megaCfg->qPendingH; pScb; pScb = pScb->next) {
  1228. if (pScb->SCpnt == SCpnt) {
  1229. /* Found an aborting command */
  1230. #if DEBUG
  1231. showMbox (pScb);
  1232. #endif
  1234. /*
  1235.  * If the command is queued to be issued to the firmware, abort the scsi cmd,
  1236.  * If the command is already aborted in a previous call to the _abort entry
  1237.  *  point, return SCSI_ABORT_SNOOZE, suggesting a reset.
  1238.  * If the command is issued to the firmware, which might complete after
  1239.  *  some time, we will mark the scb as aborted, and return to the mid layer,
  1240.  *  that abort could not be done.
  1241.  *  In the ISR, when this command actually completes, we will perform a normal
  1242.  *  completion.
  1243.  *
  1244.  * Oct 27, 1999
  1245.  */
  1247. switch (pScb->state) {
  1248. case SCB_ABORTED: /* Already aborted */
  1249. rc = SCSI_ABORT_SNOOZE;
  1250. break;
  1251. case SCB_ISSUED: /* Waiting on ISR result */
  1252. rc = SCSI_ABORT_NOT_RUNNING;
  1253. pScb->state = SCB_ABORTED;
  1254. break;
  1255. case SCB_ACTIVE: /* still on the pending queue */
  1256. mega_freeSCB (megaCfg, pScb);
  1257. SCpnt->result = (DID_ABORT << 16);
  1258. if (megaCfg->qCompletedH == NULL) {
  1259. megaCfg->qCompletedH =
  1260.     megaCfg->qCompletedT = SCpnt;
  1261. } else {
  1262. megaCfg->qCompletedT->host_scribble =
  1263.     (unsigned char *) SCpnt;
  1264. megaCfg->qCompletedT = SCpnt;
  1265. }
  1266. megaCfg->qCompletedT->host_scribble =
  1267.     (unsigned char *) NULL;
  1268. megaCfg->qCcnt++;
  1269. rc = SCSI_ABORT_SUCCESS;
  1270. break;
  1271. default:
  1272. printk
  1273.     ("megaraid_abort: unknown command state!!n");
  1274. rc = SCSI_ABORT_NOT_RUNNING;
  1275. break;
  1276. }
  1277. break;
  1278. }
  1279. }
  1281. megaCfg->flag &= ~IN_ABORT;
  1283. #if DEBUG
  1284. if (megaCfg->flag & IN_QUEUE)
  1285. printk ("ma:flag is in queuen");
  1286. if (megaCfg->qCompletedH == NULL)
  1287. printk ("ma:qchead == nulln");
  1288. #endif
  1290. /*
  1291.  * This is required here to complete any completed requests to be communicated
  1292.  * over to the mid layer.
  1293.  * Calling just mega_rundoneq() did not work.
  1294.  */
  1295. if (megaCfg->qCompletedH) {
  1296. SCpnt = megaCfg->qCompletedH;
  1297. megaCfg->qCompletedH = (Scsi_Cmnd *) SCpnt->host_scribble;
  1298. megaCfg->qCcnt--;
  1300. SCpnt->host_scribble = (unsigned char *) NULL;
  1301. /* Callback */
  1302. callDone (SCpnt);
  1303. }
  1304. mega_rundoneq (megaCfg);
  1306. return rc;
  1307. }
  1309. /*---------------------------------------------------------------------
  1310.  * Reset a previous SCSI request
  1311.  *---------------------------------------------------------------------*/
  1313. int megaraid_reset (Scsi_Cmnd * SCpnt, unsigned int rstflags)
  1314. {
  1315. mega_host_config *megaCfg;
  1316. int idx;
  1317. int rc;
  1318. mega_scb *pScb;
  1320. rc = SCSI_RESET_NOT_RUNNING;
  1321. megaCfg = (mega_host_config *) SCpnt->host->hostdata;
  1323. megaCfg->flag |= IN_RESET;
  1325. printk
  1326.     ("megaraid_RESET: %.08lx cmd=%.02x <c=%d.t=%d.l=%d>, flag = %xn",
  1327.      SCpnt->serial_number, SCpnt->cmnd[0], SCpnt->channel,
  1328.      SCpnt->target, SCpnt->lun, rstflags);
  1330. TRACE (("RESET: %.08lx %.02x <%d.%d.%d>n",
  1331. SCpnt->serial_number, SCpnt->cmnd[0], SCpnt->channel,
  1332. SCpnt->target, SCpnt->lun));
  1334. /*
  1335.  * Walk list of SCBs for any that are still outstanding
  1336.  */
  1337. for (idx = 0; idx < megaCfg->max_cmds; idx++) {
  1338. if (megaCfg->scbList[idx].state != SCB_FREE) {
  1339. SCpnt = megaCfg->scbList[idx].SCpnt;
  1340. pScb = &megaCfg->scbList[idx];
  1341. if (SCpnt != NULL) {
  1342. pScb->state = SCB_RESET;
  1343. break;
  1344. }
  1345. }
  1346. }
  1348. megaCfg->flag &= ~IN_RESET;
  1350. mega_rundoneq (megaCfg);
  1351. return rc;
  1352. }
  1354. #ifdef CONFIG_PROC_FS
  1355. /* Following code handles /proc fs  */
  1356. static int proc_printf (mega_host_config * megaCfg, const char *fmt, ...)
  1357. {
  1358. va_list args;
  1359. int i;
  1361. if (megaCfg->procidx > PROCBUFSIZE)
  1362. return 0;
  1364. va_start (args, fmt);
  1365. i = vsprintf ((megaCfg->procbuf + megaCfg->procidx), fmt, args);
  1366. va_end (args);
  1368. megaCfg->procidx += i;
  1369. return i;
  1370. }
  1372. static int proc_read_config (char *page, char **start, off_t offset,
  1373.   int count, int *eof, void *data)
  1374. {
  1376. mega_host_config *megaCfg = (mega_host_config *) data;
  1378. *start = page;
  1380. if (megaCfg->productInfo.ProductName[0] != 0)
  1381. proc_printf (megaCfg, "%sn", megaCfg->productInfo.ProductName);
  1383. proc_printf (megaCfg, "Controller Type: ");
  1385. if (megaCfg->flag & BOARD_QUARTZ)
  1386. proc_printf (megaCfg, "438/466/467/471/493n");
  1387. else
  1388. proc_printf (megaCfg, "418/428/434n");
  1390. if (megaCfg->flag & BOARD_40LD)
  1391. proc_printf (megaCfg,
  1392.      "Controller Supports 40 Logical Drivesn");
  1394. if (megaCfg->flag & BOARD_64BIT)
  1395. proc_printf (megaCfg,
  1396.      "Controller / Driver uses 64 bit memory addressingn");
  1398. proc_printf (megaCfg, "Base = %08x, Irq = %d, ", megaCfg->base,
  1399.      megaCfg->host->irq);
  1401. proc_printf (megaCfg, "Logical Drives = %d, Channels = %dn",
  1402.      megaCfg->numldrv, megaCfg->productInfo.SCSIChanPresent);
  1404. proc_printf (megaCfg, "Version =%s:%s, DRAM = %dMbn",
  1405.      megaCfg->fwVer, megaCfg->biosVer,
  1406.      megaCfg->productInfo.DramSize);
  1408. proc_printf (megaCfg,
  1409.      "Controller Queue Depth = %d, Driver Queue Depth = %dn",
  1410.      megaCfg->productInfo.MaxConcCmds, megaCfg->max_cmds);
  1411. COPY_BACK;
  1412. return count;
  1413. }
  1415. static int proc_read_stat (char *page, char **start, off_t offset,
  1416. int count, int *eof, void *data)
  1417. {
  1418. int i;
  1419. mega_host_config *megaCfg = (mega_host_config *) data;
  1421. *start = page;
  1423. proc_printf (megaCfg, "Statistical Information for this controllern");
  1424. proc_printf (megaCfg, "Interrupts Collected = %lun",
  1425.      megaCfg->nInterrupts);
  1427. for (i = 0; i < megaCfg->numldrv; i++) {
  1428. proc_printf (megaCfg, "Logical Drive %d:n", i);
  1430. proc_printf (megaCfg,
  1431.      "tReads Issued = %lu, Writes Issued = %lun",
  1432.      megaCfg->nReads[i], megaCfg->nWrites[i]);
  1434. proc_printf (megaCfg,
  1435.      "tSectors Read = %lu, Sectors Written = %lunn",
  1436.      megaCfg->nReadBlocks[i], megaCfg->nWriteBlocks[i]);
  1438. }
  1440. COPY_BACK;
  1441. return count;
  1442. }
  1444. static int proc_read_status (char *page, char **start, off_t offset,
  1445.   int count, int *eof, void *data)
  1446. {
  1447. mega_host_config *megaCfg = (mega_host_config *) data;
  1448. *start = page;
  1450. proc_printf (megaCfg, "TBDn");
  1451. COPY_BACK;
  1452. return count;
  1453. }
  1455. static int proc_read_mbox (char *page, char **start, off_t offset,
  1456. int count, int *eof, void *data)
  1457. {
  1459. mega_host_config *megaCfg = (mega_host_config *) data;
  1460. volatile mega_mailbox *mbox = megaCfg->mbox;
  1462. *start = page;
  1464. proc_printf (megaCfg, "Contents of Mail Box Structuren");
  1465. proc_printf (megaCfg, "  Fw Command   = 0x%02xn", mbox->cmd);
  1466. proc_printf (megaCfg, "  Cmd Sequence = 0x%02xn", mbox->cmdid);
  1467. proc_printf (megaCfg, "  No of Sectors= %04dn", mbox->numsectors);
  1468. proc_printf (megaCfg, "  LBA          = 0x%02xn", mbox->lba);
  1469. proc_printf (megaCfg, "  DTA          = 0x%08xn", mbox->xferaddr);
  1470. proc_printf (megaCfg, "  Logical Drive= 0x%02xn", mbox->logdrv);
  1471. proc_printf (megaCfg, "  No of SG Elmt= 0x%02xn", mbox->numsgelements);
  1472. proc_printf (megaCfg, "  Busy         = %01xn", mbox->busy);
  1473. proc_printf (megaCfg, "  Status       = 0x%02xn", mbox->status);
  1475. /* proc_printf(megaCfg, "Dump of MailBoxn");
  1476. for (i = 0; i < 16; i++)
  1477.          proc_printf(megaCfg, "%02x ",*(mbox + i));
  1479. proc_printf(megaCfg, "nnNumber of Status = %02dn",mbox->numstatus);
  1481. for (i = 0; i < 46; i++) {
  1482.          proc_printf(megaCfg,"%02d ",*(mbox + 16 + i));
  1483.         if (i%16)
  1484.                 proc_printf(megaCfg,"n");
  1485. }
  1487. if (!mbox->numsgelements) {
  1488.         dta = phys_to_virt(mbox->xferaddr);
  1489.         for (i = 0; i < mbox->numsgelements; i++)
  1490.                 if (dta) {
  1491.                         proc_printf(megaCfg,"Addr = %08xn", (ulong)*(dta + i));                        proc_printf(megaCfg,"Length = %08xn",
  1492.                                 (ulong)*(dta + i + 4));
  1493.                 }
  1494. }*/
  1495. COPY_BACK;
  1496. return count;
  1497. }
  1499. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,3,0) /*0x20300 */
  1500. #define CREATE_READ_PROC(string, fxn) create_proc_read_entry(string, 
  1501.                                          S_IRUSR | S_IFREG,
  1502.                                          controller_proc_dir_entry,
  1503.                                          fxn, megaCfg)
  1504. #else
  1505. #define CREATE_READ_PROC(string, fxn) create_proc_read_entry(string,S_IRUSR | S_IFREG, controller_proc_dir_entry, fxn, megaCfg)
  1507. static struct proc_dir_entry *
  1508. create_proc_read_entry (const char *string,
  1509. int mode,
  1510. struct proc_dir_entry *parent,
  1511. read_proc_t * fxn, mega_host_config * megaCfg)
  1512. {
  1513. struct proc_dir_entry *temp = NULL;
  1515. temp = kmalloc (sizeof (struct proc_dir_entry), GFP_KERNEL);
  1516. if (!temp)
  1517. return NULL;
  1518. memset (temp, 0, sizeof (struct proc_dir_entry));
  1520. if ((temp->name = kmalloc (strlen (string) + 1, GFP_KERNEL)) == NULL) {
  1521. kfree (temp);
  1522. return NULL;
  1523. }
  1525. strcpy ((char *) temp->name, string);
  1526. temp->namelen = strlen (string);
  1527. temp->mode = mode; /*S_IFREG | S_IRUSR */ ;
  1528. temp->data = (void *) megaCfg;
  1529. temp->read_proc = fxn;
  1530. proc_register (parent, temp);
  1531. return temp;
  1532. }
  1533. #endif
  1535. static void mega_create_proc_entry (int index, struct proc_dir_entry *parent)
  1536. {
  1537. u_char string[64] = { 0 };
  1538. mega_host_config *megaCfg = megaCtlrs[index];
  1539. struct proc_dir_entry *controller_proc_dir_entry = NULL;
  1541. sprintf (string, "%d", index);
  1543. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,3,0) /*0x20300 */
  1544. controller_proc_dir_entry =
  1545.     megaCfg->controller_proc_dir_entry = proc_mkdir (string, parent);
  1546. #else
  1547. controller_proc_dir_entry =
  1548.     megaCfg->controller_proc_dir_entry =
  1549.     create_proc_entry (string, S_IFDIR | S_IRUGO | S_IXUGO, parent);
  1550. #endif
  1552. if (!controller_proc_dir_entry)
  1553. printk ("nmegaraid: proc_mkdir failedn");
  1554. else {
  1555. megaCfg->proc_read =
  1556.     CREATE_READ_PROC ("config", proc_read_config);
  1557. megaCfg->proc_status =
  1558.     CREATE_READ_PROC ("status", proc_read_status);
  1559. megaCfg->proc_stat = CREATE_READ_PROC ("stat", proc_read_stat);
  1560. megaCfg->proc_mbox =
  1561.     CREATE_READ_PROC ("mailbox", proc_read_mbox);
  1562. }
  1564. }
  1565. #endif /* CONFIG_PROC_FS */
  1567. /*-------------------------------------------------------------
  1568.  * Return the disk geometry for a particular disk
  1569.  * Input:
  1570.  *   Disk *disk - Disk geometry
  1571.  *   kdev_t dev - Device node
  1572.  *   int *geom  - Returns geometry fields
  1573.  *     geom[0] = heads
  1574.  *     geom[1] = sectors
  1575.  *     geom[2] = cylinders
  1576.  *-------------------------------------------------------------*/
  1577. int megaraid_biosparam (Disk * disk, kdev_t dev, int *geom)
  1578. {
  1579. int heads, sectors, cylinders;
  1580. mega_host_config *megaCfg;
  1582. /* Get pointer to host config structure */
  1583. megaCfg = (mega_host_config *) disk->device->host->hostdata;
  1585. if( IS_RAID_CH(disk->device->channel)) {
  1586. /* Default heads (64) & sectors (32) */
  1587. heads = 64;
  1588. sectors = 32;
  1589. cylinders = disk->capacity / (heads * sectors);
  1591. /* Handle extended translation size for logical drives > 1Gb */
  1592. if (disk->capacity >= 0x200000) {
  1593. heads = 255;
  1594. sectors = 63;
  1595. cylinders = disk->capacity / (heads * sectors);
  1596. }
  1598. /* return result */
  1599. geom[0] = heads;
  1600. geom[1] = sectors;
  1601. geom[2] = cylinders;
  1602. }
  1603. else {
  1604. if( mega_partsize(disk, dev, geom) == 0 ) return 0;
  1606. printk(KERN_WARNING
  1607. "megaraid: invalid partition on this disk on channel %dn",
  1608. disk->device->channel);
  1610. /* Default heads (64) & sectors (32) */
  1611. heads = 64;
  1612. sectors = 32;
  1613. cylinders = disk->capacity / (heads * sectors);
  1615. /* Handle extended translation size for logical drives > 1Gb */
  1616. if (disk->capacity >= 0x200000) {
  1617. heads = 255;
  1618. sectors = 63;
  1619. cylinders = disk->capacity / (heads * sectors);
  1620. }
  1622. /* return result */
  1623. geom[0] = heads;
  1624. geom[1] = sectors;
  1625. geom[2] = cylinders;
  1626. }
  1628. return 0;
  1629. }
  1631. /*
  1632.  * Function : static int mega_partsize(Disk * disk, kdev_t dev, int *geom)
  1633.  *
  1634.  * Purpose : to determine the BIOS mapping used to create the partition
  1635.  * table, storing the results (cyls, hds, and secs) in geom
  1636.  *
  1637.  * Note: Code is picked from scsicam.h
  1638.  *
  1639.  * Returns : -1 on failure, 0 on success.
  1640.  */
  1641. static int
  1642. mega_partsize(Disk * disk, kdev_t dev, int *geom)
  1643. {
  1644. struct buffer_head *bh;
  1645. struct partition *p, *largest = NULL;
  1646. int i, largest_cyl;
  1647. int heads, cyls, sectors;
  1648. int capacity = disk->capacity;
  1650. if(!(bh = bread(MKDEV(MAJOR(dev), MINOR(dev)&~0xf), 0, block_size(dev))))
  1651. return -1;
  1653. if( *(unsigned short *)(bh->b_data + 510) == 0xAA55 ) {
  1655. for( largest_cyl = -1, p = (struct partition *)(0x1BE + bh->b_data),
  1656. i = 0; i < 4; ++i, ++p) {
  1658. if (!p->sys_ind) continue;
  1660. cyls = p->end_cyl + ((p->end_sector & 0xc0) << 2);
  1662. if(cyls >= largest_cyl) {
  1663. largest_cyl = cyls;
  1664. largest = p;
  1665. }
  1666. }
  1667. }
  1669. if (largest) {
  1670. heads = largest->end_head + 1;
  1671. sectors = largest->end_sector & 0x3f;
  1673. if (heads == 0 || sectors == 0) {
  1674. brelse(bh);
  1675. return -1;
  1676. }
  1678. cyls = capacity/(heads * sectors);
  1680. geom[0] = heads;
  1681. geom[1] = sectors;
  1682. geom[2] = cyls;
  1684. brelse(bh);
  1685. return 0;
  1686. }
  1688. brelse(bh);
  1689. return -1;
  1690. }
  1693. /*
  1694.  * This routine will be called when the use has done a forced shutdown on the
  1695.  * system. Flush the Adapter cache, that's the most we can do.
  1696.  */
  1697. static int megaraid_reboot_notify (struct notifier_block *this, unsigned long code,
  1698. void *unused)
  1699. {
  1700. struct Scsi_Host *pSHost;
  1701. mega_host_config *megaCfg;
  1702. mega_mailbox *mbox;
  1703. u_char mboxData[16];
  1704. int i;
  1706. if (code == SYS_DOWN || code == SYS_HALT) {
  1707. for (i = 0; i < numCtlrs; i++) {
  1708. pSHost = megaCtlrs[i]->host;
  1710. megaCfg = (mega_host_config *) pSHost->hostdata;
  1711. mbox = (mega_mailbox *) mboxData;
  1713. /* Flush cache to disk */
  1714. memset (mbox, 0, 16);
  1715. mboxData[0] = 0xA;
  1717. /*
  1718.  * Free irq, otherwise extra interrupt is generated
  1719.  */
  1720. free_irq (megaCfg->host->irq, megaCfg);
  1722. /*
  1723.    * Issue a blocking (interrupts disabled) command to
  1724.    * the card
  1725.  */
  1726. megaIssueCmd (megaCfg, mboxData, NULL, 0);
  1727. }
  1728. }
  1729. return NOTIFY_DONE;
  1730. }
  1732. static int mega_init_scb (mega_host_config * megacfg)
  1733. {
  1734. int idx;
  1736. #if DEBUG
  1737. if (megacfg->max_cmds >= MAX_COMMANDS) {
  1738. printk ("megaraid:ctlr max cmds = %x : MAX_CMDS = %x",
  1739. megacfg->max_cmds, MAX_COMMANDS);
  1740. }
  1741. #endif
  1743. for (idx = megacfg->max_cmds - 1; idx >= 0; idx--) {
  1745. megacfg->scbList[idx].idx = idx;
  1747. /*
  1748.  * ISR will make this flag zero to indicate the command has been
  1749.  * completed. This is only for user ioctl calls. Rest of the driver
  1750.  * and the mid-layer operations are not connected with this flag.
  1751.  */
  1753. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  1754. megacfg->scbList[idx].sgList =
  1755.     pci_alloc_consistent (megacfg->dev,
  1756.   sizeof (mega_64sglist) * MAX_SGLIST,
  1757.   &(megacfg->scbList[idx].
  1758.     dma_sghandle64));
  1760. megacfg->scbList[idx].sg64List =
  1761.     (mega_64sglist *) megacfg->scbList[idx].sgList;
  1762. #else
  1763. megacfg->scbList[idx].sgList = kmalloc (sizeof (mega_sglist) * MAX_SGLIST, GFP_ATOMIC | GFP_DMA);
  1764. #endif
  1766. if (megacfg->scbList[idx].sgList == NULL) {
  1767. printk (KERN_WARNING
  1768. "Can't allocate sglist for id %dn", idx);
  1769. mega_freeSgList (megacfg);
  1770. return -1;
  1771. }
  1772. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  1773. megacfg->scbList[idx].pthru = pci_alloc_consistent (megacfg->dev,
  1774.   sizeof (mega_passthru),
  1775.   &(megacfg->scbList[idx].
  1776.     dma_passthruhandle64));
  1778. if (megacfg->scbList[idx].pthru == NULL) {
  1779. printk (KERN_WARNING
  1780. "Can't allocate passthru for id %dn", idx);
  1781. }
  1783. megacfg->scbList[idx].epthru =
  1784. pci_alloc_consistent(
  1785. megacfg->dev, sizeof(mega_ext_passthru),
  1786. &(megacfg->scbList[idx].dma_ext_passthruhandle64)
  1787. );
  1789. if (megacfg->scbList[idx].epthru == NULL) {
  1790. printk (KERN_WARNING
  1791. "Can't allocate extended passthru for id %dn", idx);
  1792. }
  1793. /* 
  1794.  * Allocate a 256 Byte Bounce Buffer for handling INQ/RD_CAPA 
  1795.  */
  1796. megacfg->scbList[idx].bounce_buffer = pci_alloc_consistent (megacfg->dev,
  1797.   256,
  1798.   &(megacfg->scbList[idx].
  1799.     dma_bounce_buffer));
  1801. if (!megacfg->scbList[idx].bounce_buffer)
  1802. printk
  1803.     ("megaraid: allocation for bounce buffer failedn");
  1805. megacfg->scbList[idx].dma_type = M_RD_DMA_TYPE_NONE;
  1806. #endif
  1808. if (idx < MAX_COMMANDS) {
  1809. /*
  1810.  * Link to free list
  1811.  * lock not required since we are loading the driver, so no
  1812.  * commands possible right now.
  1813.  */
  1814. enq_scb_freelist (megacfg, &megacfg->scbList[idx],
  1815.   NO_LOCK, INTR_ENB);
  1817. }
  1818. }
  1820. return 0;
  1821. }
  1823. /*
  1824.  * Enqueues a SCB
  1825.  */
  1826. static void enq_scb_freelist (mega_host_config * megacfg, mega_scb * scb, int lock,
  1827.   int intr)
  1828. {
  1830. if (lock == INTERNAL_LOCK || intr == INTR_DIS) {
  1831. if (intr == INTR_DIS)
  1832. spin_lock_irq (&megacfg->lock_free);
  1833. else
  1834. spin_lock (&megacfg->lock_free);
  1835. }
  1837. scb->state = SCB_FREE;
  1838. scb->SCpnt = NULL;
  1840. if (megacfg->qFreeH == (mega_scb *) NULL) {
  1841. megacfg->qFreeH = megacfg->qFreeT = scb;
  1842. } else {
  1843. megacfg->qFreeT->next = scb;
  1844. megacfg->qFreeT = scb;
  1845. }
  1847. megacfg->qFreeT->next = NULL;
  1848. megacfg->qFcnt++;
  1850. if (lock == INTERNAL_LOCK || intr == INTR_DIS) {
  1851. if (intr == INTR_DIS)
  1852. spin_unlock_irq (&megacfg->lock_free);
  1853. else
  1854. spin_unlock (&megacfg->lock_free);
  1855. }
  1856. }
  1858. /*
  1859.  * Routines for the character/ioctl interface to the driver
  1860.  */
  1861. static int megadev_open (struct inode *inode, struct file *filep)
  1862. {
  1863. MOD_INC_USE_COUNT;
  1864. return 0; /* success */
  1865. }
  1867. static int megadev_ioctl_entry (struct inode *inode, struct file *filep,
  1868.      unsigned int cmd, unsigned long arg)
  1869. {
  1870. int ret = -1;
  1872. /*
  1873.  * We do not allow parallel ioctls to the driver as of now.
  1874.  */
  1875. down (&mimd_entry_mtx);
  1876. ret = megadev_ioctl (inode, filep, cmd, arg);
  1877. up (&mimd_entry_mtx);
  1879. return ret;
  1881. }
  1883. static int megadev_ioctl (struct inode *inode, struct file *filep,
  1884.        unsigned int cmd, unsigned long arg)
  1885. {
  1886. int adapno;
  1887. kdev_t dev;
  1888. u32 inlen;
  1889. struct uioctl_t ioc;
  1890. char *kvaddr = NULL;
  1891. int nadap = numCtlrs;
  1892. u8 opcode;
  1893. u32 outlen;
  1894. int ret;
  1895. u8 subopcode;
  1896. Scsi_Cmnd *scsicmd;
  1897. struct Scsi_Host *shpnt;
  1898. char *uaddr;
  1899. struct uioctl_t *uioc;
  1900. dma_addr_t dma_addr;
  1901. u32 length;
  1902. mega_host_config *megacfg = NULL;
  1903. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) /* 0x020400 */
  1904. struct pci_dev pdev;
  1905. struct pci_dev *pdevp = &pdev;
  1906. #else
  1907. char *pdevp = NULL;
  1908. #endif
  1909. IO_LOCK_T;
  1911. if (!inode || !(dev = inode->i_rdev))
  1912. return -EINVAL;
  1914. if (_IOC_TYPE (cmd) != MEGAIOC_MAGIC)
  1915. return (-EINVAL);
  1917. /*
  1918.  * Get the user ioctl structure
  1919.  */
  1920. ret = verify_area (VERIFY_WRITE, (char *) arg, sizeof (struct uioctl_t));
  1922. if (ret)
  1923. return ret;
  1925. if(copy_from_user (&ioc, (char *) arg, sizeof (struct uioctl_t)))
  1926. return -EFAULT;
  1928. /*
  1929.  * The first call the applications should make is to find out the
  1930.  * number of controllers in the system. The next logical call should
  1931.  * be for getting the list of controllers in the system as detected
  1932.  * by the driver.
  1933.  */
  1935. /*
  1936.  * Get the opcode and subopcode for the commands
  1937.  */
  1938. opcode = ioc.ui.fcs.opcode;
  1939. subopcode = ioc.ui.fcs.subopcode;
  1941. switch (opcode) {
  1942. case M_RD_DRIVER_IOCTL_INTERFACE:
  1943. switch (subopcode) {
  1944. case MEGAIOC_QDRVRVER: /* Query driver version */
  1945. put_user (driver_ver, (u32 *) ioc.data);
  1946. return 0;
  1948. case MEGAIOC_QNADAP: /* Get # of adapters */
  1949. put_user (nadap, (int *) ioc.data);
  1950. return nadap;
  1952. case MEGAIOC_QADAPINFO: /* Get adapter information */
  1953. /*
  1954.  * which adapter?
  1955.  */
  1956. adapno = ioc.ui.fcs.adapno;
  1958. /*
  1959.  * The adapter numbers do not start with 0, at least in
  1960.  * the user space. This is just to make sure, 0 is not the
  1961.  * default value which will refer to adapter 1. So the
  1962.  * user needs to make use of macros MKADAP() and GETADAP()
  1963.  * (See megaraid.h) while making ioctl() call.
  1964.  */
  1965. adapno = GETADAP (adapno);
  1967. if (adapno >= numCtlrs)
  1968. return (-ENODEV);
  1970. ret = verify_area (VERIFY_WRITE,
  1971.    ioc.data,
  1972.    sizeof (struct mcontroller));
  1973. if (ret)
  1974. return ret;
  1976. /*
  1977.  * Copy struct mcontroller to user area
  1978.  */
  1979. copy_to_user (ioc.data,
  1980.       mcontroller + adapno,
  1981.       sizeof (struct mcontroller));
  1982. return 0;
  1984. default:
  1985. return (-EINVAL);
  1987. } /* inner switch */
  1988. break;
  1990. case M_RD_IOCTL_CMD_NEW:
  1992. /*
  1993.  * Deletion of logical drives is only handled in 0x80 commands
  1994.  */
  1995. if( ioc.mbox[0] == FC_DEL_LOGDRV && ioc.mbox[2] == OP_DEL_LOGDRV ) {
  1996. return -EINVAL;
  1997. }
  1999. /* which adapter?  */
  2000. adapno = ioc.ui.fcs.adapno;
  2002. /* See comment above: MEGAIOC_QADAPINFO */
  2003. adapno = GETADAP(adapno);
  2005. if (adapno >= numCtlrs)
  2006. return(-ENODEV);
  2008. length = ioc.ui.fcs.length;
  2010. /* Check for zero length buffer or very large buffers */
  2011. if( !length || length > 32*1024 )
  2012. return -EINVAL;
  2014. /* save the user address */
  2015. uaddr = ioc.ui.fcs.buffer;
  2017. /*
  2018.  * For M_RD_IOCTL_CMD_NEW commands, the fields outlen and inlen of
  2019.  * uioctl_t structure are treated as flags. If outlen is 1, the
  2020.  * data is transferred from the device and if inlen is 1, the data
  2021.  * is transferred to the device.
  2022.  */
  2023. outlen = ioc.outlen;
  2024. inlen = ioc.inlen;
  2026. if(outlen) {
  2027. ret = verify_area(VERIFY_WRITE, (char *)ioc.ui.fcs.buffer, length);
  2028. if (ret) return ret;
  2029. }
  2030. if(inlen) {
  2031. ret = verify_area(VERIFY_READ, (char *) ioc.ui.fcs.buffer, length);
  2032. if (ret) return ret;
  2033. }
  2035. /*
  2036.  * Find this host
  2037.  */
  2038. for( shpnt = scsi_hostlist; shpnt; shpnt = shpnt->next ) {
  2039. if( shpnt->hostdata == (unsigned long *)megaCtlrs[adapno] ) {
  2040. megacfg = (mega_host_config *)shpnt->hostdata;
  2041. break;
  2042. }
  2043. }
  2044. if(shpnt == NULL)  return -ENODEV;
  2046. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  2047. scsicmd = (Scsi_Cmnd *)kmalloc(sizeof(Scsi_Cmnd), GFP_KERNEL|GFP_DMA);
  2048. #else
  2049. scsicmd = (Scsi_Cmnd *)scsi_init_malloc(sizeof(Scsi_Cmnd),
  2050.   GFP_ATOMIC | GFP_DMA);
  2051. #endif
  2052. if(scsicmd == NULL) return -ENOMEM;
  2054. memset(scsicmd, 0, sizeof(Scsi_Cmnd));
  2055. scsicmd->host = shpnt;
  2057. if( outlen || inlen ) {
  2058. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  2059. pdevp = &pdev;
  2060. memcpy(pdevp, megacfg->dev, sizeof(struct pci_dev));
  2061. pdevp->dma_mask = 0xffffffff;
  2062. #else
  2063. pdevp = NULL;
  2064. #endif
  2065. kvaddr = dma_alloc_consistent(pdevp, length, &dma_addr);
  2067. if( kvaddr == NULL ) {
  2068. printk(KERN_WARNING "megaraid:allocation failedn");
  2069. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) /*0x20400 */
  2070. kfree(scsicmd);
  2071. #else
  2072. scsi_init_free((char *)scsicmd, sizeof(Scsi_Cmnd));
  2073. #endif
  2074. return -ENOMEM;
  2075. }
  2077. ioc.ui.fcs.buffer = kvaddr;
  2079. if (inlen) {
  2080. /* copyin the user data */
  2081. copy_from_user(kvaddr, (char *)uaddr, length );
  2082. }
  2083. }
  2085. scsicmd->cmnd[0] = MEGADEVIOC;
  2086. scsicmd->request_buffer = (void *)&ioc;
  2088. init_MUTEX_LOCKED(&mimd_ioctl_sem);
  2090. IO_LOCK;
  2091. megaraid_queue(scsicmd, megadev_ioctl_done);
  2093. IO_UNLOCK;
  2095. down(&mimd_ioctl_sem);
  2097. if( !scsicmd->result && outlen ) {
  2098. copy_to_user(uaddr, kvaddr, length);
  2099. }
  2101. /*
  2102.  * copyout the result
  2103.  */
  2104. uioc = (struct uioctl_t *)arg;
  2106. if( ioc.mbox[0] == MEGA_MBOXCMD_PASSTHRU ) {
  2107. put_user( scsicmd->result, &uioc->pthru.scsistatus );
  2108. } else {
  2109. put_user(1, &uioc->mbox[16]); /* numstatus */
  2110. /* status */
  2111. put_user (scsicmd->result, &uioc->mbox[17]);
  2112. }
  2114. if (kvaddr) {
  2115. dma_free_consistent(pdevp, length, kvaddr, dma_addr);
  2116. }
  2117. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) /*0x20400 */
  2118. kfree (scsicmd);
  2119. #else
  2120. scsi_init_free((char *)scsicmd, sizeof(Scsi_Cmnd));
  2121. #endif
  2123. /* restore the user address */
  2124. ioc.ui.fcs.buffer = uaddr;
  2126. return ret;
  2128. case M_RD_IOCTL_CMD:
  2129. /* which adapter?  */
  2130. adapno = ioc.ui.fcs.adapno;
  2132. /* See comment above: MEGAIOC_QADAPINFO */
  2133. adapno = GETADAP (adapno);
  2135. if (adapno >= numCtlrs)
  2136. return (-ENODEV);
  2138. /* save the user address */
  2139. uaddr = ioc.data;
  2140. outlen = ioc.outlen;
  2141. inlen = ioc.inlen;
  2143. if ((outlen >= IOCTL_MAX_DATALEN) || (inlen >= IOCTL_MAX_DATALEN))
  2144. return (-EINVAL);
  2146. if (outlen) {
  2147. ret = verify_area (VERIFY_WRITE, ioc.data, outlen);
  2148. if (ret) return ret;
  2149. }
  2150. if (inlen) {
  2151. ret = verify_area (VERIFY_READ, ioc.data, inlen);
  2152. if (ret) return ret;
  2153. }
  2155. /*
  2156.  * Find this host
  2157.  */
  2158. for( shpnt = scsi_hostlist; shpnt; shpnt = shpnt->next ) {
  2159. if( shpnt->hostdata == (unsigned long *)megaCtlrs[adapno] ) {
  2160. megacfg = (mega_host_config *)shpnt->hostdata;
  2161. break;
  2162. }
  2163. }
  2164. if(shpnt == NULL)  return -ENODEV;
  2166. /*
  2167.  * ioctls for deleting logical drives is a special case, so check
  2168.  * for it first
  2169.  */
  2170. if( ioc.mbox[0] == FC_DEL_LOGDRV && ioc.mbox[2] == OP_DEL_LOGDRV ) {
  2172. if( !megacfg->support_random_del ) {
  2173. printk("megaraid: logdrv delete on non supporting f/w.n");
  2174. return -EINVAL;
  2175. }
  2177. uioc = (struct uioctl_t *)arg;
  2179. ret = mega_del_logdrv(megacfg, ioc.mbox[3]);
  2181. put_user(1, &uioc->mbox[16]); /* numstatus */
  2182. put_user(ret, &uioc->mbox[17]); /* status */
  2184. /* if deletion failed, let the user know by failing ioctl */
  2185. return ret;
  2186. }
  2188. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  2189. scsicmd = (Scsi_Cmnd *)kmalloc(sizeof(Scsi_Cmnd), GFP_KERNEL|GFP_DMA);
  2190. #else
  2191. scsicmd = (Scsi_Cmnd *)scsi_init_malloc(sizeof(Scsi_Cmnd),
  2192.   GFP_ATOMIC | GFP_DMA);
  2193. #endif
  2194. if(scsicmd == NULL) return -ENOMEM;
  2196. memset(scsicmd, 0, sizeof(Scsi_Cmnd));
  2197. scsicmd->host = shpnt;
  2199. if (outlen || inlen) {
  2200. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  2201. pdevp = &pdev;
  2202. memcpy(pdevp, megacfg->dev, sizeof(struct pci_dev));
  2203. pdevp->dma_mask = 0xffffffff;
  2204. #else
  2205. pdevp = NULL;
  2206. #endif
  2207. /*
  2208.  * Allocate a page of kernel space.
  2209.  */
  2210. kvaddr = dma_alloc_consistent(pdevp, PAGE_SIZE, &dma_addr);
  2212. if( kvaddr == NULL ) {
  2213. printk (KERN_WARNING "megaraid:allocation failedn");
  2214. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) /*0x20400 */
  2215. kfree(scsicmd);
  2216. #else
  2217. scsi_init_free((char *)scsicmd, sizeof(Scsi_Cmnd));
  2218. #endif
  2219. return -ENOMEM;
  2220. }
  2222. ioc.data = kvaddr;
  2224. if (inlen) {
  2225. if (ioc.mbox[0] == MEGA_MBOXCMD_PASSTHRU) {
  2226. /* copyin the user data */
  2227. copy_from_user (kvaddr, uaddr, ioc.pthru.dataxferlen);
  2228. } else {
  2229. copy_from_user (kvaddr, uaddr, inlen);
  2230. }
  2231. }
  2232. }
  2234. scsicmd->cmnd[0] = MEGADEVIOC;
  2235. scsicmd->request_buffer = (void *) &ioc;
  2237. init_MUTEX_LOCKED (&mimd_ioctl_sem);
  2239. IO_LOCK;
  2240. megaraid_queue (scsicmd, megadev_ioctl_done);
  2242. IO_UNLOCK;
  2243. down (&mimd_ioctl_sem);
  2245. if (!scsicmd->result && outlen) {
  2246. if (ioc.mbox[0] == MEGA_MBOXCMD_PASSTHRU) {
  2247. copy_to_user (uaddr, kvaddr, ioc.pthru.dataxferlen);
  2248. } else {
  2249. copy_to_user (uaddr, kvaddr, outlen);
  2250. }
  2251. }
  2253. /*
  2254.  * copyout the result
  2255.  */
  2256. uioc = (struct uioctl_t *) arg;
  2258. if (ioc.mbox[0] == MEGA_MBOXCMD_PASSTHRU) {
  2259. put_user (scsicmd->result, &uioc->pthru.scsistatus);
  2260. } else {
  2261. put_user (1, &uioc->mbox[16]); /* numstatus */
  2262. put_user (scsicmd->result, &uioc->mbox[17]); /* status */
  2263. }
  2265. if (kvaddr) {
  2266. dma_free_consistent(pdevp, PAGE_SIZE, kvaddr, dma_addr );
  2267. }
  2269. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  2270. kfree (scsicmd);
  2271. #else
  2272. scsi_init_free((char *)scsicmd, sizeof(Scsi_Cmnd));
  2273. #endif
  2275. /* restore user pointer */
  2276. ioc.data = uaddr;
  2278. return ret;
  2280. default:
  2281. return (-EINVAL);
  2283. }/* Outer switch */
  2285. return 0;
  2286. }
  2288. static void
  2289. megadev_ioctl_done(Scsi_Cmnd *sc)
  2290. {
  2291. up (&mimd_ioctl_sem);
  2292. }
  2294. static mega_scb *
  2295. megadev_doioctl (mega_host_config * megacfg, Scsi_Cmnd * sc)
  2296. {
  2297. u8 cmd;
  2298. struct uioctl_t *ioc = NULL;
  2299. mega_mailbox *mbox = NULL;
  2300. mega_ioctl_mbox *mboxioc = NULL;
  2301. struct mbox_passthru *mboxpthru = NULL;
  2302. mega_scb *scb = NULL;
  2303. mega_passthru *pthru = NULL;
  2305. if ((scb = mega_allocateSCB (megacfg, sc)) == NULL) {
  2306. sc->result = (DID_ERROR << 16);
  2307. callDone (sc);
  2308. return NULL;
  2309. }
  2311. ioc = (struct uioctl_t *) sc->request_buffer;
  2313. memcpy (scb->mboxData, ioc->mbox, sizeof (scb->mboxData));
  2315. /* The generic mailbox */
  2316. mbox = (mega_mailbox *) ioc->mbox;
  2318. /*
  2319.  * Get the user command
  2320.  */
  2321. cmd = ioc->mbox[0];
  2323. switch (cmd) {
  2324. case MEGA_MBOXCMD_PASSTHRU:
  2325. /*
  2326.    * prepare the SCB with information from the user ioctl structure
  2327.  */
  2328. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  2329. pthru = scb->pthru;
  2330. #else
  2331. pthru = &scb->pthru;
  2332. #endif
  2333. memcpy (pthru, &ioc->pthru, sizeof (mega_passthru));
  2334. mboxpthru = (struct mbox_passthru *) scb->mboxData;
  2335. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  2336. if (megacfg->flag & BOARD_64BIT) {
  2337. /* This is just a sample with one element 
  2338.    * This if executes onlu on 2.4 kernels
  2339.  */
  2340. mboxpthru->dataxferaddr = scb->dma_passthruhandle64;
  2341. scb->sg64List[0].address =
  2342.     pci_map_single (megacfg->dev,
  2343.     ioc->data,
  2344.     4096, PCI_DMA_BIDIRECTIONAL);
  2345. scb->sg64List[0].length = 4096; // TODO: Check this
  2346. pthru->dataxferaddr = scb->dma_sghandle64;
  2347. pthru->numsgelements = 1;
  2348. mboxpthru->cmd = 0xC3;
  2349. } else {
  2350. mboxpthru->dataxferaddr = scb->dma_passthruhandle64;
  2351. pthru->dataxferaddr =
  2352.     pci_map_single (megacfg->dev,
  2353.     ioc->data,
  2354.     4096, PCI_DMA_BIDIRECTIONAL);
  2355. pthru->numsgelements = 0;
  2356. }
  2358. #else
  2359. {
  2360. mboxpthru->dataxferaddr = virt_to_bus (&scb->pthru);
  2361. pthru->dataxferaddr = virt_to_bus (ioc->data);
  2362. pthru->numsgelements = 0;
  2363. }
  2364. #endif
  2366. pthru->reqsenselen = 14;
  2367. break;
  2369. default: /* Normal command */
  2370. mboxioc = (mega_ioctl_mbox *) scb->mboxData;
  2372. if (ioc->ui.fcs.opcode == M_RD_IOCTL_CMD_NEW) {
  2373. scb->buff_ptr = ioc->ui.fcs.buffer;
  2374. scb->iDataSize = ioc->ui.fcs.length;
  2375. } else {
  2376. scb->buff_ptr = ioc->data;
  2377. scb->iDataSize = 4096; // TODO:check it
  2378. }
  2380. set_mbox_xfer_addr (megacfg, scb, mboxioc, FROMTO_DEVICE);
  2381. mboxioc->numsgelements = 0;
  2382. break;
  2383. }
  2385. return scb;
  2386. }
  2388. static int
  2389. megadev_close (struct inode *inode, struct file *filep)
  2390. {
  2391. #ifdef MODULE
  2392. MOD_DEC_USE_COUNT;
  2393. #endif
  2394. return 0;
  2395. }
  2398. static int
  2399. mega_support_ext_cdb(mega_host_config *this_hba)
  2400. {
  2401. mega_mailbox *mboxpnt;
  2402. unsigned char mbox[16];
  2403. int ret;
  2405. mboxpnt = (mega_mailbox *) mbox;
  2407. memset(mbox, 0, sizeof (mbox));
  2408. /*
  2409.  * issue command to find out if controller supports extended CDBs.
  2410.  */
  2411. mbox[0] = 0xA4;
  2412. mbox[2] = 0x16;
  2414. ret = megaIssueCmd(this_hba, mbox, NULL, 0);
  2416. return !ret;
  2417. }
  2420. /*
  2421.  * Find out if this controller supports random deletion and addition of
  2422.  * logical drives
  2423.  */
  2424. static int
  2425. mega_support_random_del(mega_host_config *this_hba)
  2426. {
  2427. mega_mailbox *mboxpnt;
  2428. unsigned char mbox[16];
  2429. int ret;
  2431. mboxpnt = (mega_mailbox *)mbox;
  2433. memset(mbox, 0, sizeof(mbox));
  2435. /*
  2436.  * issue command
  2437.  */
  2438. mbox[0] = FC_DEL_LOGDRV;
  2439. mbox[2] = OP_SUP_DEL_LOGDRV;
  2441. ret = megaIssueCmd(this_hba, mbox, NULL, 0);
  2443. return !ret;
  2444. }
  2446. static int
  2447. mega_del_logdrv(mega_host_config *this_hba, int logdrv)
  2448. {
  2449. int rval;
  2450. IO_LOCK_T;
  2451. DECLARE_WAIT_QUEUE_HEAD(wq);
  2452. mega_scb *scbp;
  2454. /*
  2455.  * Stop sending commands to the controller, queue them internally.
  2456.  * When deletion is complete, ISR will flush the queue.
  2457.  */
  2458. IO_LOCK;
  2459. this_hba->quiescent = 1;
  2460. IO_UNLOCK;
  2462. while( this_hba->qPcnt ) {
  2463. sleep_on_timeout( &wq, 1*HZ ); /* sleep for 1s */
  2464. }
  2465. rval = mega_do_del_logdrv(this_hba, logdrv);
  2467. IO_LOCK;
  2468. /*
  2469.  * Attach the internal queue to the pending queue
  2470.  */
  2471. if( this_hba->qPendingH == NULL ) {
  2472. /*
  2473.  * If pending queue head is null, make internal queue as
  2474.  * pending queue
  2475.  */
  2476. this_hba->qPendingH = this_hba->int_qh;
  2477. this_hba->qPendingT = this_hba->int_qt;
  2478. this_hba->qPcnt = this_hba->int_qlen;
  2479. }
  2480. else {
  2481. /*
  2482.  * Append pending queue to internal queue
  2483.  */
  2484. if( this_hba->int_qt ) {
  2485. this_hba->int_qt->next = this_hba->qPendingH;
  2487. this_hba->qPendingH = this_hba->int_qh;
  2488. this_hba->qPcnt += this_hba->int_qlen;
  2489. }
  2490. }
  2492. this_hba->int_qh = this_hba->int_qt = NULL;
  2493. this_hba->int_qlen = 0;
  2495. /*
  2496.  * If delete operation was successful, add 0x80 to the logical drive
  2497.  * ids for commands in the pending queue.
  2498.  */
  2499. if( this_hba->read_ldidmap) {
  2500. for( scbp = this_hba->qPendingH; scbp; scbp = scbp->next ) {
  2501. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  2502. if( scbp->pthru->logdrv < 0x80 )
  2503. scbp->pthru->logdrv += 0x80;
  2504. #else
  2505. if( scbp->pthru.logdrv < 0x80 )
  2506. scbp->pthru.logdrv += 0x80;
  2507. #endif
  2508. }
  2509. }
  2510. this_hba->quiescent = 0;
  2512. IO_UNLOCK;
  2514. return rval;
  2515. }
  2518. static int
  2519. mega_do_del_logdrv(mega_host_config *this_hba, int logdrv)
  2520. {
  2521. mega_mailbox *mboxpnt;
  2522. unsigned char mbox[16];
  2523. int rval;
  2525. mboxpnt = (mega_mailbox *)mbox;
  2527. memset(mbox, 0, sizeof(mbox));
  2529. mbox[0] = FC_DEL_LOGDRV;
  2530. mbox[2] = OP_DEL_LOGDRV;
  2531. mbox[3] = logdrv;
  2533. rval = megaIssueCmd(this_hba, mbox, NULL, 0);
  2535. /* log this event */
  2536. if( rval != 0 ) {
  2537. printk("megaraid: Attempt to delete logical drive %d failed.",
  2538. logdrv);
  2539. return rval;
  2540. }
  2542. printk("megaraid: logical drive %d deleted.n", logdrv);
  2544. /*
  2545.  * After deleting first logical drive, the logical drives must be
  2546.  * addressed by adding 0x80 to the logical drive id.
  2547.  */
  2548. this_hba->read_ldidmap = 1;
  2550. return rval;
  2551. }
  2553. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
  2554. void *
  2555. dma_alloc_consistent(void *dev, size_t size, dma_addr_t *dma_addr)
  2556. {
  2557. void *_tv;
  2558. int npages;
  2559. int order = 0;
  2561. /*
  2562.  * How many pages application needs
  2563.  */
  2564. npages = size / PAGE_SIZE;
  2566. /* Do we need one more page */
  2567. if(size % PAGE_SIZE)
  2568. npages++;
  2570. order = mega_get_order(npages);
  2572. _tv = (void *)__get_free_pages(GFP_DMA, order);
  2574. if( _tv != NULL ) {
  2575. memset(_tv, 0, size);
  2576. *(dma_addr) = virt_to_bus(_tv);
  2577. }
  2579. return _tv;
  2580. }
  2582. /*
  2583.  * int mega_get_order(int)
  2584.  *
  2585.  * returns the order to be used as 2nd argument to __get_free_pages() - which
  2586.  * return pages equal to pow(2, order) - AM
  2587.  */
  2588. int
  2589. mega_get_order(int n)
  2590. {
  2591. int i = 0;
  2593. while( pow_2(i++) < n )
  2594. ; /* null statement */
  2596. return i-1;
  2597. }
  2599. /*
  2600.  * int pow_2(int)
  2601.  *
  2602.  * calculates pow(2, i)
  2603.  */
  2604. int
  2605. pow_2(int i)
  2606. {
  2607. unsigned int v = 1;
  2609. while(i--)
  2610. v <<= 1;
  2612. return v;
  2613. }
  2615. void
  2616. dma_free_consistent(void *dev, size_t size, void *vaddr, dma_addr_t dma_addr)
  2617. {
  2618. int npages;
  2619. int order = 0;
  2621. npages = size / PAGE_SIZE;
  2623. if(size % PAGE_SIZE)
  2624. npages++;
  2626. if (npages == 1)
  2627. order = 0;
  2628. else if (npages == 2)
  2629. order = 1;
  2630. else if (npages <= 4)
  2631. order = 2;
  2632. else
  2633. order = 3;
  2635. free_pages((unsigned long)vaddr, order);
  2637. }
  2638. #endif
  2640. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  2641. static
  2642. #endif /* LINUX VERSION 2.4.XX */
  2643. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) || defined(MODULE)
  2644. Scsi_Host_Template driver_template = MEGARAID;
  2646. #include "scsi_module.c"
  2647. #endif /* LINUX VERSION 2.4.XX || MODULE */
  2649. /* vi: set ts=4: */