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

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

嵌入式Linux

开发平台：

Unix_Linux

psi240i.c：源码内容
  1. /*+M*************************************************************************
  2.  * Perceptive Solutions, Inc. PSI-240I device driver proc support for Linux.
  3.  *
  4.  * Copyright (c) 1997 Perceptive Solutions, Inc.
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2, or (at your option)
  9.  * any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; see the file COPYING.  If not, write to
  18.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  *
  21.  * File Name: psi240i.c
  22.  *
  23.  * Description: SCSI driver for the PSI240I EIDE interface card.
  24.  *
  25.  *-M*************************************************************************/
  27. #include <linux/module.h>
  29. #include <linux/kernel.h>
  30. #include <linux/types.h>
  31. #include <linux/string.h>
  32. #include <linux/ioport.h>
  33. #include <linux/delay.h>
  34. #include <linux/sched.h>
  35. #include <linux/proc_fs.h>
  36. #include <linux/spinlock.h>
  37. #include <asm/dma.h>
  38. #include <asm/system.h>
  39. #include <asm/io.h>
  40. #include <linux/blk.h>
  41. #include "scsi.h"
  42. #include "hosts.h"
  44. #include "psi240i.h"
  45. #include "psi_chip.h"
  47. #include<linux/stat.h>
  49. //#define DEBUG 1
  51. #ifdef DEBUG
  52. #define DEB(x) x
  53. #else
  54. #define DEB(x)
  55. #endif
  57. #define MAXBOARDS 2 /* Increase this and the sizes of the arrays below, if you need more. */
  59. #define PORT_DATA 0
  60. #define PORT_ERROR 1
  61. #define PORT_SECTOR_COUNT 2
  62. #define PORT_LBA_0 3
  63. #define PORT_LBA_8 4
  64. #define PORT_LBA_16 5
  65. #define PORT_LBA_24 6
  66. #define PORT_STAT_CMD 7
  67. #define PORT_SEL_FAIL 8
  68. #define PORT_IRQ_STATUS 9
  69. #define PORT_ADDRESS 10
  70. #define PORT_FAIL 11
  71. #define PORT_ALT_STAT     12
  73. typedef struct
  74. {
  75. UCHAR     device; // device code
  76. UCHAR byte6; // device select register image
  77. UCHAR spigot; // spigot number
  78. UCHAR expectingIRQ; // flag for expecting and interrupt
  79. USHORT sectors; // number of sectors per track
  80. USHORT heads; // number of heads
  81. USHORT cylinders; // number of cylinders for this device
  82. USHORT spareword; // placeholder
  83. ULONG blocks; // number of blocks on device
  84. } OUR_DEVICE, *POUR_DEVICE;
  86. typedef struct
  87. {
  88. USHORT  ports[13];
  89. OUR_DEVICE  device[8];
  90. Scsi_Cmnd *pSCmnd;
  91. IDE_STRUCT  ide;
  92. ULONG  startSector;
  93. USHORT  sectorCount;
  94. Scsi_Cmnd *SCpnt;
  95. VOID *buffer;
  96. USHORT  expectingIRQ;
  97. } ADAPTER240I, *PADAPTER240I;
  99. #define HOSTDATA(host) ((PADAPTER240I)&host->hostdata)
  101. static struct Scsi_Host *PsiHost[6] = {NULL,};  /* One for each IRQ level (10-15) */
  102. static IDENTIFY_DATA identifyData;
  103. static SETUP ChipSetup;
  105. static USHORT portAddr[6] = {CHIP_ADRS_0, CHIP_ADRS_1, CHIP_ADRS_2, CHIP_ADRS_3, CHIP_ADRS_4, CHIP_ADRS_5};
  107. /****************************************************************
  108.  * Name: WriteData :LOCAL
  109.  *
  110.  * Description: Write data to device.
  111.  *
  112.  * Parameters: padapter - Pointer adapter data structure.
  113.  *
  114.  * Returns: TRUE if drive does not assert DRQ in time.
  115.  *
  116.  ****************************************************************/
  117. static int WriteData (PADAPTER240I padapter)
  118. {
  119. ULONG timer;
  120. USHORT *pports = padapter->ports;
  122. timer = jiffies + TIMEOUT_DRQ; // calculate the timeout value
  123. do  {
  124. if ( inb_p (pports[PORT_STAT_CMD]) & IDE_STATUS_DRQ )
  125. {
  126. outsw (pports[PORT_DATA], padapter->buffer, (USHORT)padapter->ide.ide.ide[2] * 256);
  127. return 0;
  128. }
  129. } while ( time_after(timer, jiffies) ); // test for timeout
  131. padapter->ide.ide.ides.cmd = 0; // null out the command byte
  132. return 1;
  133. }
  134. /****************************************************************
  135.  * Name: IdeCmd :LOCAL
  136.  *
  137.  * Description: Process a queued command from the SCSI manager.
  138.  *
  139.  * Parameters: padapter - Pointer adapter data structure.
  140.  *
  141.  * Returns: Zero if no error or status register contents on error.
  142.  *
  143.  ****************************************************************/
  144. static UCHAR IdeCmd (PADAPTER240I padapter)
  145. {
  146. ULONG timer;
  147. USHORT *pports = padapter->ports;
  148. UCHAR status;
  150. outb_p (padapter->ide.ide.ides.spigot, pports[PORT_SEL_FAIL]); // select the spigot
  151. outb_p (padapter->ide.ide.ide[6], pports[PORT_LBA_24]); // select the drive
  152. timer = jiffies + TIMEOUT_READY; // calculate the timeout value
  153. do  {
  154. status = inb_p (padapter->ports[PORT_STAT_CMD]);
  155. if ( status & IDE_STATUS_DRDY )
  156. {
  157. outb_p (padapter->ide.ide.ide[2], pports[PORT_SECTOR_COUNT]);
  158. outb_p (padapter->ide.ide.ide[3], pports[PORT_LBA_0]);
  159. outb_p (padapter->ide.ide.ide[4], pports[PORT_LBA_8]);
  160. outb_p (padapter->ide.ide.ide[5], pports[PORT_LBA_16]);
  161. padapter->expectingIRQ = 1;
  162. outb_p (padapter->ide.ide.ide[7], pports[PORT_STAT_CMD]);
  164. if ( padapter->ide.ide.ides.cmd == IDE_CMD_WRITE_MULTIPLE )
  165. return (WriteData (padapter));
  167. return 0;
  168. }
  169. } while ( time_after(timer, jiffies) ); // test for timeout
  171. padapter->ide.ide.ides.cmd = 0; // null out the command byte
  172. return status;
  173. }
  174. /****************************************************************
  175.  * Name: SetupTransfer :LOCAL
  176.  *
  177.  * Description: Setup a data transfer command.
  178.  *
  179.  * Parameters: padapter - Pointer adapter data structure.
  180.  * drive  - Drive/head register upper nibble only.
  181.  *
  182.  * Returns: TRUE if no data to transfer.
  183.  *
  184.  ****************************************************************/
  185. static int SetupTransfer (PADAPTER240I padapter, UCHAR drive)
  186. {
  187. if ( padapter->sectorCount )
  188. {
  189. *(ULONG *)padapter->ide.ide.ides.lba = padapter->startSector;
  190. padapter->ide.ide.ide[6] |= drive;
  191. padapter->ide.ide.ides.sectors = ( padapter->sectorCount > SECTORSXFER ) ? SECTORSXFER : padapter->sectorCount;
  192. padapter->sectorCount -= padapter->ide.ide.ides.sectors; // bump the start and count for next xfer
  193. padapter->startSector += padapter->ide.ide.ides.sectors;
  194. return 0;
  195. }
  196. else
  197. {
  198. padapter->ide.ide.ides.cmd = 0; // null out the command byte
  199. padapter->SCpnt = NULL;
  200. return 1;
  201. }
  202. }
  203. /****************************************************************
  204.  * Name: DecodeError :LOCAL
  205.  *
  206.  * Description: Decode and process device errors.
  207.  *
  208.  * Parameters: pshost - Pointer to host data block.
  209.  * status - Status register code.
  210.  *
  211.  * Returns: The driver status code.
  212.  *
  213.  ****************************************************************/
  214. static ULONG DecodeError (struct Scsi_Host *pshost, UCHAR status)
  215. {
  216. PADAPTER240I padapter = HOSTDATA(pshost);
  217. UCHAR error;
  219. padapter->expectingIRQ = 0;
  220. padapter->SCpnt = NULL;
  221. if ( status & IDE_STATUS_WRITE_FAULT )
  222. {
  223. return DID_PARITY << 16;
  224. }
  225. if ( status & IDE_STATUS_BUSY )
  226. return DID_BUS_BUSY << 16;
  228. error = inb_p (padapter->ports[PORT_ERROR]);
  229. DEB(printk ("npsi240i error register: %x", error));
  230. switch ( error )
  231. {
  232. case IDE_ERROR_AMNF:
  233. case IDE_ERROR_TKONF:
  234. case IDE_ERROR_ABRT:
  235. case IDE_ERROR_IDFN:
  236. case IDE_ERROR_UNC:
  237. case IDE_ERROR_BBK:
  238. default:
  239. return DID_ERROR << 16;
  240. }
  241. return DID_ERROR << 16;
  242. }
  243. /****************************************************************
  244.  * Name: Irq_Handler :LOCAL
  245.  *
  246.  * Description: Interrupt handler.
  247.  *
  248.  * Parameters: irq - Hardware IRQ number.
  249.  * dev_id -
  250.  * regs -
  251.  *
  252.  * Returns: TRUE if drive is not ready in time.
  253.  *
  254.  ****************************************************************/
  255. static void Irq_Handler (int irq, void *dev_id, struct pt_regs *regs)
  256. {
  257. struct Scsi_Host   *shost; // Pointer to host data block
  258. PADAPTER240I padapter; // Pointer to adapter control structure
  259. USHORT      *pports; // I/O port array
  260. Scsi_Cmnd    *SCpnt;
  261. UCHAR status;
  262. int z;
  264. DEB(printk ("npsi240i received interruptn"));
  266. shost = PsiHost[irq - 10];
  267. if ( !shost )
  268. panic ("Splunge!");
  270. padapter = HOSTDATA(shost);
  271. pports = padapter->ports;
  272. SCpnt = padapter->SCpnt;
  274. if ( !padapter->expectingIRQ )
  275. {
  276. DEB(printk ("npsi240i Unsolicited interruptn"));
  277. return;
  278. }
  279. padapter->expectingIRQ = 0;
  281. status = inb_p (padapter->ports[PORT_STAT_CMD]); // read the device status
  282. if ( status & (IDE_STATUS_ERROR | IDE_STATUS_WRITE_FAULT) )
  283. goto irqerror;
  285. DEB(printk ("npsi240i processing interrupt"));
  286. switch ( padapter->ide.ide.ides.cmd ) // decide how to handle the interrupt
  287. {
  288. case IDE_CMD_READ_MULTIPLE:
  289. if ( status & IDE_STATUS_DRQ )
  290. {
  291. insw (pports[PORT_DATA], padapter->buffer, (USHORT)padapter->ide.ide.ides.sectors * 256);
  292. padapter->buffer += padapter->ide.ide.ides.sectors * 512;
  293. if ( SetupTransfer (padapter, padapter->ide.ide.ide[6] & 0xF0) )
  294. {
  295. SCpnt->result = DID_OK << 16;
  296. padapter->SCpnt = NULL;
  297. SCpnt->scsi_done (SCpnt);
  298. return;
  299. }
  300. if ( !(status = IdeCmd (padapter)) )
  301. return;
  302. }
  303. break;
  305. case IDE_CMD_WRITE_MULTIPLE:
  306. padapter->buffer += padapter->ide.ide.ides.sectors * 512;
  307. if ( SetupTransfer (padapter, padapter->ide.ide.ide[6] & 0xF0) )
  308. {
  309. SCpnt->result = DID_OK << 16;
  310. padapter->SCpnt = NULL;
  311. SCpnt->scsi_done (SCpnt);
  312. return;
  313. }
  314. if ( !(status = IdeCmd (padapter)) )
  315. return;
  316. break;
  318. case IDE_COMMAND_IDENTIFY:
  319. {
  320. PINQUIRYDATA pinquiryData  = SCpnt->request_buffer;
  322. if ( status & IDE_STATUS_DRQ )
  323. {
  324. insw (pports[PORT_DATA], &identifyData, sizeof (identifyData) >> 1);
  326. memset (pinquiryData, 0, SCpnt->request_bufflen); // Zero INQUIRY data structure.
  327. pinquiryData->DeviceType = 0;
  328. pinquiryData->Versions = 2;
  329. pinquiryData->AdditionalLength = 35 - 4;
  331. // Fill in vendor identification fields.
  332. for ( z = 0;  z < 20;  z += 2 )
  333. {
  334. pinquiryData->VendorId[z]   = ((UCHAR *)identifyData.ModelNumber)[z + 1];
  335. pinquiryData->VendorId[z + 1] = ((UCHAR *)identifyData.ModelNumber)[z];
  336. }
  338. // Initialize unused portion of product id.
  339. for ( z = 0;  z < 4;  z++ )
  340. pinquiryData->ProductId[12 + z] = ' ';
  342. // Move firmware revision from IDENTIFY data to
  343. // product revision in INQUIRY data.
  344. for ( z = 0;  z < 4;  z += 2 )
  345. {
  346. pinquiryData->ProductRevisionLevel[z]  = ((UCHAR *)identifyData.FirmwareRevision)[z + 1];
  347. pinquiryData->ProductRevisionLevel[z + 1] = ((UCHAR *)identifyData.FirmwareRevision)[z];
  348. }
  350. SCpnt->result = DID_OK << 16;
  351. padapter->SCpnt = NULL;
  352. SCpnt->scsi_done (SCpnt);
  353. return;
  354. }
  355. break;
  356. }
  358. default:
  359. SCpnt->result = DID_OK << 16;
  360. padapter->SCpnt = NULL;
  361. SCpnt->scsi_done (SCpnt);
  362. return;
  363. }
  365. irqerror:;
  366. DEB(printk ("npsi240i error  Device Status: %Xn", status));
  367. SCpnt->result = DecodeError (shost, status);
  368. SCpnt->scsi_done (SCpnt);
  369. }
  370. static void do_Irq_Handler (int irq, void *dev_id, struct pt_regs *regs)
  371. {
  372. unsigned long flags;
  374. spin_lock_irqsave(&io_request_lock, flags);
  375. Irq_Handler(irq, dev_id, regs);
  376. spin_unlock_irqrestore(&io_request_lock, flags);
  377. }
  378. /****************************************************************
  379.  * Name: Psi240i_QueueCommand
  380.  *
  381.  * Description: Process a queued command from the SCSI manager.
  382.  *
  383.  * Parameters: SCpnt - Pointer to SCSI command structure.
  384.  * done  - Pointer to done function to call.
  385.  *
  386.  * Returns: Status code.
  387.  *
  388.  ****************************************************************/
  389. int Psi240i_QueueCommand (Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
  390. {
  391. UCHAR    *cdb = (UCHAR *)SCpnt->cmnd; // Pointer to SCSI CDB
  392. PADAPTER240I padapter = HOSTDATA(SCpnt->host); // Pointer to adapter control structure
  393. POUR_DEVICE pdev  = &padapter->device[SCpnt->target];// Pointer to device information
  394. UCHAR rc; // command return code
  396. SCpnt->scsi_done = done;
  397. padapter->ide.ide.ides.spigot = pdev->spigot;
  398. padapter->buffer = SCpnt->request_buffer;
  399. if (done)
  400. {
  401. if ( !pdev->device )
  402. {
  403. SCpnt->result = DID_BAD_TARGET << 16;
  404. done (SCpnt);
  405. return 0;
  406. }
  407. }
  408. else
  409. {
  410. printk("psi240i_queuecommand: %02X: done can't be NULLn", *cdb);
  411. return 0;
  412. }
  414. switch ( *cdb )
  415. {
  416. case SCSIOP_INQUIRY:    // inquiry CDB
  417. {
  418. padapter->ide.ide.ide[6] = pdev->byte6;
  419. padapter->ide.ide.ides.cmd = IDE_COMMAND_IDENTIFY;
  420. break;
  421. }
  423. case SCSIOP_TEST_UNIT_READY: // test unit ready CDB
  424. SCpnt->result = DID_OK << 16;
  425. done (SCpnt);
  426. return 0;
  428. case SCSIOP_READ_CAPACITY:    // read capctiy CDB
  429. {
  430. PREAD_CAPACITY_DATA pdata = (PREAD_CAPACITY_DATA)SCpnt->request_buffer;
  432. pdata->blksiz = 0x20000;
  433. XANY2SCSI ((UCHAR *)&pdata->blks, pdev->blocks);
  434. SCpnt->result = DID_OK << 16;
  435. done (SCpnt);
  436. return 0;
  437. }
  439. case SCSIOP_VERIFY: // verify CDB
  440. *(ULONG *)padapter->ide.ide.ides.lba = XSCSI2LONG (&cdb[2]);
  441. padapter->ide.ide.ide[6] |= pdev->byte6;
  442. padapter->ide.ide.ide[2] = (UCHAR)((USHORT)cdb[8] | ((USHORT)cdb[7] << 8));
  443. padapter->ide.ide.ides.cmd = IDE_COMMAND_VERIFY;
  444. break;
  446. case SCSIOP_READ: // read10 CDB
  447. padapter->startSector = XSCSI2LONG (&cdb[2]);
  448. padapter->sectorCount = (USHORT)cdb[8] | ((USHORT)cdb[7] << 8);
  449. SetupTransfer (padapter, pdev->byte6);
  450. padapter->ide.ide.ides.cmd = IDE_CMD_READ_MULTIPLE;
  451. break;
  453. case SCSIOP_READ6: // read6  CDB
  454. padapter->startSector = SCSI2LONG (&cdb[1]);
  455. padapter->sectorCount = cdb[4];
  456. SetupTransfer (padapter, pdev->byte6);
  457. padapter->ide.ide.ides.cmd = IDE_CMD_READ_MULTIPLE;
  458. break;
  460. case SCSIOP_WRITE: // write10 CDB
  461. padapter->startSector = XSCSI2LONG (&cdb[2]);
  462. padapter->sectorCount = (USHORT)cdb[8] | ((USHORT)cdb[7] << 8);
  463. SetupTransfer (padapter, pdev->byte6);
  464. padapter->ide.ide.ides.cmd = IDE_CMD_WRITE_MULTIPLE;
  465. break;
  466. case SCSIOP_WRITE6: // write6  CDB
  467. padapter->startSector = SCSI2LONG (&cdb[1]);
  468. padapter->sectorCount = cdb[4];
  469. SetupTransfer (padapter, pdev->byte6);
  470. padapter->ide.ide.ides.cmd = IDE_CMD_WRITE_MULTIPLE;
  471. break;
  473. default:
  474. DEB (printk ("psi240i_queuecommand: Unsupported command %02Xn", *cdb));
  475. SCpnt->result = DID_ERROR << 16;
  476. done (SCpnt);
  477. return 0;
  478. }
  480. padapter->SCpnt = SCpnt;   // Save this command data
  482. rc = IdeCmd (padapter);
  483. if ( rc )
  484. {
  485. padapter->expectingIRQ = 0;
  486. DEB (printk ("psi240i_queuecommand: %02X, %02X: Device failed to respond for commandn", *cdb, padapter->ide.ide.ides.cmd));
  487. SCpnt->result = DID_ERROR << 16;
  488. done (SCpnt);
  489. return 0;
  490. }
  491. DEB (printk("psi240i_queuecommand: %02X, %02X now waiting for interrupt ", *cdb, padapter->ide.ide.ides.cmd));
  492. return 0;
  493. }
  495. static void internal_done(Scsi_Cmnd * SCpnt)
  496. {
  497. SCpnt->SCp.Status++;
  498. }
  499. /****************************************************************
  500.  * Name: Psi240i_Command
  501.  *
  502.  * Description: Process a command from the SCSI manager.
  503.  *
  504.  * Parameters: SCpnt - Pointer to SCSI command structure.
  505.  *
  506.  * Returns: Status code.
  507.  *
  508.  ****************************************************************/
  509. int Psi240i_Command (Scsi_Cmnd *SCpnt)
  510. {
  511. DEB(printk("psi240i_command: ..calling psi240i_queuecommandn"));
  513. Psi240i_QueueCommand (SCpnt, internal_done);
  515.     SCpnt->SCp.Status = 0;
  516. while (!SCpnt->SCp.Status)
  517. barrier ();
  518. return SCpnt->result;
  519. }
  520. /***************************************************************************
  521.  * Name: ReadChipMemory
  522.  *
  523.  * Description: Read information from controller memory.
  524.  *
  525.  * Parameters: psetup - Pointer to memory image of setup information.
  526.  * base - base address of memory.
  527.  * length - lenght of data space in bytes.
  528.  * port - I/O address of data port.
  529.  *
  530.  * Returns: Nothing.
  531.  *
  532.  **************************************************************************/
  533. void ReadChipMemory (void *pdata, USHORT base, USHORT length, USHORT port)
  534. {
  535. USHORT z, zz;
  536. UCHAR *pd = (UCHAR *)pdata;
  537. outb_p (SEL_NONE, port + REG_SEL_FAIL); // setup data port
  538. zz = 0;
  539. while ( zz < length )
  540. {
  541. outw_p (base, port + REG_ADDRESS); // setup address
  543. for ( z = 0;  z < 8;  z++ )
  544. {
  545. if ( (zz + z) < length )
  546. *pd++ = inb_p (port + z); // read data byte
  547. }
  548. zz += 8;
  549. base += 8;
  550. }
  551. }
  552. /****************************************************************
  553.  * Name: Psi240i_Detect
  554.  *
  555.  * Description: Detect and initialize our boards.
  556.  *
  557.  * Parameters: tpnt - Pointer to SCSI host template structure.
  558.  *
  559.  * Returns: Number of adapters found.
  560.  *
  561.  ****************************************************************/
  562. int Psi240i_Detect (Scsi_Host_Template *tpnt)
  563. {
  564. int board;
  565. int count = 0;
  566. int unit;
  567. int z;
  568. USHORT port;
  569. CHIP_CONFIG_N chipConfig;
  570. CHIP_DEVICE_N chipDevice[8];
  571. struct Scsi_Host   *pshost;
  572. ULONG flags;
  574. for ( board = 0;  board < 6;  board++ ) // scan for I/O ports
  575. {
  576. port = portAddr[board]; // get base address to test
  577. if ( check_region (port, 16) ) // test for I/O addresses available
  578. continue; //   nope
  579. if ( inb_p (port + REG_FAIL) != CHIP_ID ) // do the first test for likley hood that it is us
  580. continue;
  581. outb_p (SEL_NONE, port + REG_SEL_FAIL); // setup EEPROM/RAM access
  582. outw (0, port + REG_ADDRESS); // setup EEPROM address zero
  583. if ( inb_p (port) != 0x55 ) // test 1st byte
  584. continue; //   nope
  585. if ( inb_p (port + 1) != 0xAA ) // test 2nd byte
  586. continue; //   nope
  588. // at this point our board is found and can be accessed.  Now we need to initialize
  589. // our informatation and register with the kernel.
  592. ReadChipMemory (&chipConfig, CHIP_CONFIG, sizeof (chipConfig), port);
  593. ReadChipMemory (&chipDevice, CHIP_DEVICE, sizeof (chipDevice), port);
  594. ReadChipMemory (&ChipSetup, CHIP_EEPROM_DATA, sizeof (ChipSetup), port);
  596. if ( !chipConfig.numDrives ) // if no devices on this board
  597. continue;
  599. pshost = scsi_register (tpnt, sizeof(ADAPTER240I));
  600. if(pshost == NULL)
  601. continue;
  603. save_flags (flags);
  604. cli ();
  605. if ( request_irq (chipConfig.irq, do_Irq_Handler, 0, "psi240i", NULL) )
  606. {
  607. printk ("Unable to allocate IRQ for PSI-240I controller.n");
  608. restore_flags (flags);
  609. goto unregister;
  610. }
  612. PsiHost[chipConfig.irq - 10] = pshost;
  613. pshost->unique_id = port;
  614. pshost->io_port = port;
  615. pshost->n_io_port = 16;  /* Number of bytes of I/O space used */
  616. pshost->irq = chipConfig.irq;
  618. for ( z = 0;  z < 11;  z++ ) // build regester address array
  619. HOSTDATA(pshost)->ports[z] = port + z;
  620. HOSTDATA(pshost)->ports[11] = port + REG_FAIL;
  621. HOSTDATA(pshost)->ports[12] = port + REG_ALT_STAT;
  622. DEB (printk ("nPorts ="));
  623. DEB (for (z=0;z<13;z++) printk(" %#04X",HOSTDATA(pshost)->ports[z]););
  625. for ( z = 0;  z < chipConfig.numDrives;  ++z )
  626. {
  627. unit = chipDevice[z].channel & 0x0F;
  628. HOSTDATA(pshost)->device[unit].device  = ChipSetup.setupDevice[unit].device;
  629. HOSTDATA(pshost)->device[unit].byte6  = (UCHAR)(((unit & 1) << 4) | 0xE0);
  630. HOSTDATA(pshost)->device[unit].spigot  = (UCHAR)(1 << (unit >> 1));
  631. HOSTDATA(pshost)->device[unit].sectors  = ChipSetup.setupDevice[unit].sectors;
  632. HOSTDATA(pshost)->device[unit].heads  = ChipSetup.setupDevice[unit].heads;
  633. HOSTDATA(pshost)->device[unit].cylinders = ChipSetup.setupDevice[unit].cylinders;
  634. HOSTDATA(pshost)->device[unit].blocks  = ChipSetup.setupDevice[unit].blocks;
  635. DEB (printk ("nHOSTDATA->device    = %X", HOSTDATA(pshost)->device[unit].device));
  636. DEB (printk ("n          byte6     = %X", HOSTDATA(pshost)->device[unit].byte6));
  637. DEB (printk ("n          spigot    = %X", HOSTDATA(pshost)->device[unit].spigot));
  638. DEB (printk ("n          sectors   = %X", HOSTDATA(pshost)->device[unit].sectors));
  639. DEB (printk ("n          heads     = %X", HOSTDATA(pshost)->device[unit].heads));
  640. DEB (printk ("n          cylinders = %X", HOSTDATA(pshost)->device[unit].cylinders));
  641. DEB (printk ("n          blocks    = %lX", HOSTDATA(pshost)->device[unit].blocks));
  642. }
  644. restore_flags (flags);
  645. printk("nPSI-240I EIDE CONTROLLER: at I/O = %x  IRQ = %dn", port, chipConfig.irq);
  646. printk("(C) 1997 Perceptive Solutions, Inc. All rights reservednn");
  647. count++;
  648. continue;
  650. unregister:;
  651. scsi_unregister (pshost);
  652. }
  653. return count;
  654. }
  655. /****************************************************************
  656.  * Name: Psi240i_Abort
  657.  *
  658.  * Description: Process the Abort command from the SCSI manager.
  659.  *
  660.  * Parameters: SCpnt - Pointer to SCSI command structure.
  661.  *
  662.  * Returns: Allways snooze.
  663.  *
  664.  ****************************************************************/
  665. int Psi240i_Abort (Scsi_Cmnd *SCpnt)
  666. {
  667. DEB (printk ("psi240i_abortn"));
  668. return SCSI_ABORT_SNOOZE;
  669. }
  670. /****************************************************************
  671.  * Name: Psi240i_Reset
  672.  *
  673.  * Description: Process the Reset command from the SCSI manager.
  674.  *
  675.  * Parameters: SCpnt - Pointer to SCSI command structure.
  676.  * flags - Flags about the reset command
  677.  *
  678.  * Returns: No active command at this time, so this means
  679.  * that each time we got some kind of response the
  680.  * last time through.  Tell the mid-level code to
  681.  * request sense information in order to decide what
  682.  * to do next.
  683.  *
  684.  ****************************************************************/
  685. int Psi240i_Reset (Scsi_Cmnd *SCpnt, unsigned int reset_flags)
  686. {
  687. return SCSI_RESET_PUNT;
  688. }
  690. #include "sd.h"
  692. /****************************************************************
  693.  * Name: Psi240i_BiosParam
  694.  *
  695.  * Description: Process the biosparam request from the SCSI manager to
  696.  * return C/H/S data.
  697.  *
  698.  * Parameters: disk - Pointer to SCSI disk structure.
  699.  * dev  - Major/minor number from kernel.
  700.  * geom - Pointer to integer array to place geometry data.
  701.  *
  702.  * Returns: zero.
  703.  *
  704.  ****************************************************************/
  705. int Psi240i_BiosParam (Scsi_Disk *disk, kdev_t dev, int geom[])
  706. {
  707. POUR_DEVICE pdev;
  709. pdev = &(HOSTDATA(disk->device->host)->device[disk->device->id]);
  711. geom[0] = pdev->heads;
  712. geom[1] = pdev->sectors;
  713. geom[2] = pdev->cylinders;
  714. return 0;
  715. }
  717. MODULE_LICENSE("GPL");
  719. /* Eventually this will go into an include file, but this will be later */
  720. static Scsi_Host_Template driver_template = PSI240I;
  722. #include "scsi_module.c"