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

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

嵌入式Linux

开发平台：

Unix_Linux

g_NCR5380.c：源码内容
  1. /*
  2.  * Generic Generic NCR5380 driver
  3.  *
  4.  * Copyright 1993, Drew Eckhardt
  5.  * Visionary Computing
  6.  * (Unix and Linux consulting and custom programming)
  7.  * drew@colorado.edu
  8.  *      +1 (303) 440-4894
  9.  *
  10.  * NCR53C400 extensions (c) 1994,1995,1996, Kevin Lentin
  11.  *    K.Lentin@cs.monash.edu.au
  12.  *
  13.  * NCR53C400A extensions (c) 1996, Ingmar Baumgart
  14.  *    ingmar@gonzo.schwaben.de
  15.  *
  16.  * DTC3181E extensions (c) 1997, Ronald van Cuijlenborg
  17.  * ronald.van.cuijlenborg@tip.nl or nutty@dds.nl
  18.  *
  19.  * Added ISAPNP support for DTC436 adapters,
  20.  * Thomas Sailer, sailer@ife.ee.ethz.ch
  21.  *
  22.  * ALPHA RELEASE 1. 
  23.  *
  24.  * For more information, please consult 
  25.  *
  26.  * NCR 5380 Family
  27.  * SCSI Protocol Controller
  28.  * Databook
  29.  *
  30.  * NCR Microelectronics
  31.  * 1635 Aeroplaza Drive
  32.  * Colorado Springs, CO 80916
  33.  * 1+ (719) 578-3400
  34.  * 1+ (800) 334-5454
  35.  */
  37. /* 
  38.  * TODO : flesh out DMA support, find some one actually using this (I have
  39.  *  a memory mapped Trantor board that works fine)
  40.  */
  42. /*
  43.  * Options :
  44.  *
  45.  * PARITY - enable parity checking.  Not supported.
  46.  *
  47.  * SCSI2 - enable support for SCSI-II tagged queueing.  Untested.
  48.  *
  49.  * USLEEP - enable support for devices that don't disconnect.  Untested.
  50.  *
  51.  * The card is detected and initialized in one of several ways : 
  52.  * 1.  With command line overrides - NCR5380=port,irq may be 
  53.  *     used on the LILO command line to override the defaults.
  54.  *
  55.  * 2.  With the GENERIC_NCR5380_OVERRIDE compile time define.  This is 
  56.  *     specified as an array of address, irq, dma, board tuples.  Ie, for
  57.  *     one board at 0x350, IRQ5, no dma, I could say  
  58.  *     -DGENERIC_NCR5380_OVERRIDE={{0xcc000, 5, DMA_NONE, BOARD_NCR5380}}
  59.  * 
  60.  * -1 should be specified for no or DMA interrupt, -2 to autoprobe for an 
  61.  *  IRQ line if overridden on the command line.
  62.  *
  63.  * 3.  When included as a module, with arguments passed on the command line:
  64.  *         ncr_irq=xx the interrupt
  65.  *         ncr_addr=xx  the port or base address (for port or memory
  66.  *               mapped, resp.)
  67.  *         ncr_dma=xx the DMA
  68.  *         ncr_5380=1 to set up for a NCR5380 board
  69.  *         ncr_53c400=1 to set up for a NCR53C400 board
  70.  *     e.g.
  71.  *     modprobe g_NCR5380 ncr_irq=5 ncr_addr=0x350 ncr_5380=1
  72.  *       for a port mapped NCR5380 board or
  73.  *     modprobe g_NCR5380 ncr_irq=255 ncr_addr=0xc8000 ncr_53c400=1
  74.  *       for a memory mapped NCR53C400 board with interrupts disabled.
  75.  * 
  76.  * 255 should be specified for no or DMA interrupt, 254 to autoprobe for an 
  77.  *  IRQ line if overridden on the command line.
  78.  *     
  79.  */
  81. /*
  82.  * $Log: generic_NCR5380.c,v $
  83.  */
  85. /* settings for DTC3181E card with only Mustek scanner attached */
  86. #define USLEEP
  87. #define USLEEP_POLL 1
  88. #define USLEEP_SLEEP 20
  89. #define USLEEP_WAITLONG 500
  91. #define AUTOPROBE_IRQ
  92. #define AUTOSENSE
  94. #include <linux/config.h>
  96. #ifdef CONFIG_SCSI_GENERIC_NCR53C400
  97. #define NCR53C400_PSEUDO_DMA 1
  98. #define PSEUDO_DMA
  99. #define NCR53C400
  100. #define NCR5380_STATS
  101. #undef NCR5380_STAT_LIMIT
  102. #endif
  103. #if defined(CONFIG_SCSI_G_NCR5380_PORT) && defined(CONFIG_SCSI_G_NCR5380_MEM)
  104. #error You can not configure the Generic NCR 5380 SCSI Driver for memory mapped I/O and port mapped I/O at the same time (yet)
  105. #endif
  106. #if !defined(CONFIG_SCSI_G_NCR5380_PORT) && !defined(CONFIG_SCSI_G_NCR5380_MEM)
  107. #error You must configure the Generic NCR 5380 SCSI Driver for one of memory mapped I/O and port mapped I/O.
  108. #endif
  110. #include <asm/system.h>
  111. #include <asm/io.h>
  112. #include <linux/signal.h>
  113. #include <linux/sched.h>
  114. #include <linux/blk.h>
  115. #include "scsi.h"
  116. #include "hosts.h"
  117. #include "g_NCR5380.h"
  118. #include "NCR5380.h"
  119. #include "constants.h"
  120. #include "sd.h"
  121. #include <linux/stat.h>
  122. #include <linux/init.h>
  123. #include <linux/ioport.h>
  124. #include <linux/isapnp.h>
  126. #define NCR_NOT_SET 0
  127. static int ncr_irq = NCR_NOT_SET;
  128. static int ncr_dma = NCR_NOT_SET;
  129. static int ncr_addr = NCR_NOT_SET;
  130. static int ncr_5380 = NCR_NOT_SET;
  131. static int ncr_53c400 = NCR_NOT_SET;
  132. static int ncr_53c400a = NCR_NOT_SET;
  133. static int dtc_3181e = NCR_NOT_SET;
  135. static struct override {
  136. NCR5380_implementation_fields;
  137. int irq;
  138. int dma;
  139. int board; /* Use NCR53c400, Ricoh, etc. extensions ? */
  140. } overrides
  141. #ifdef GENERIC_NCR5380_OVERRIDE
  142. [] __initdata = GENERIC_NCR5380_OVERRIDE;
  143. #else
  144. [1] __initdata = { { 0,},};
  145. #endif
  147. #define NO_OVERRIDES (sizeof(overrides) / sizeof(struct override))
  149. /**
  150.  * internal_setup - handle lilo command string override
  151.  * @board: BOARD_* identifier for the board
  152.  * @str: unused
  153.  * @ints: numeric parameters
  154.  *
  155.  *  Do LILO command line initialization of the overrides array. Display
  156.  * errors when needed
  157.  *
  158.  * Locks: none
  159.  */
  161. static void __init internal_setup(int board, char *str, int *ints)
  162. {
  163. static int commandline_current = 0;
  164. switch (board) {
  165. case BOARD_NCR5380:
  166. if (ints[0] != 2 && ints[0] != 3) {
  167. printk(KERN_ERR "generic_NCR5380_setup : usage ncr5380=" STRVAL(NCR5380_map_name) ",irq,dman");
  168. return;
  169. }
  170. break;
  171. case BOARD_NCR53C400:
  172. if (ints[0] != 2) {
  173. printk(KERN_ERR "generic_NCR53C400_setup : usage ncr53c400=" STRVAL(NCR5380_map_name) ",irqn");
  174. return;
  175. }
  176. break;
  177. case BOARD_NCR53C400A:
  178. if (ints[0] != 2) {
  179. printk(KERN_ERR "generic_NCR53C400A_setup : usage ncr53c400a=" STRVAL(NCR5380_map_name) ",irqn");
  180. return;
  181. }
  182. break;
  183. case BOARD_DTC3181E:
  184. if (ints[0] != 2) {
  185. printk("generic_DTC3181E_setup : usage dtc3181e=" STRVAL(NCR5380_map_name) ",irqn");
  186. return;
  187. }
  188. break;
  189. }
  191. if (commandline_current < NO_OVERRIDES) {
  192. overrides[commandline_current].NCR5380_map_name = (NCR5380_map_type) ints[1];
  193. overrides[commandline_current].irq = ints[2];
  194. if (ints[0] == 3)
  195. overrides[commandline_current].dma = ints[3];
  196. else
  197. overrides[commandline_current].dma = DMA_NONE;
  198. overrides[commandline_current].board = board;
  199. ++commandline_current;
  200. }
  201. }
  203. /**
  204.  *  do_NCR53C80_setup - set up entry point
  205.  * @str: unused
  206.  *
  207.  * Setup function invoked at boot to parse the ncr5380= command
  208.  * line.
  209.  */
  211. static int __init do_NCR5380_setup(char *str)
  212. {
  213. int ints[10];
  215. get_options(str, sizeof(ints) / sizeof(int), ints);
  216. internal_setup(BOARD_NCR5380, str, ints);
  217. return 1;
  218. }
  220. /**
  221.  *  do_NCR53C400_setup - set up entry point
  222.  * @str: unused
  223.  * @ints: integer parameters from kernel setup code 
  224.  *
  225.  * Setup function invoked at boot to parse the ncr53c400= command
  226.  * line.
  227.  */
  229. static int __init do_NCR53C400_setup(char *str)
  230. {
  231. int ints[10];
  233. get_options(str, sizeof(ints) / sizeof(int), ints);
  234. internal_setup(BOARD_NCR53C400, str, ints);
  235. return 1;
  236. }
  238. /**
  239.  *  do_NCR53C400A_setup - set up entry point
  240.  * @str: unused
  241.  * @ints: integer parameters from kernel setup code 
  242.  *
  243.  * Setup function invoked at boot to parse the ncr53c400a= command
  244.  * line.
  245.  */
  247. static int __init do_NCR53C400A_setup(char *str)
  248. {
  249. int ints[10];
  251. get_options(str, sizeof(ints) / sizeof(int), ints);
  252. internal_setup(BOARD_NCR53C400A, str, ints);
  253. return 1;
  254. }
  256. /**
  257.  *  do_DTC3181E_setup - set up entry point
  258.  * @str: unused
  259.  * @ints: integer parameters from kernel setup code 
  260.  *
  261.  * Setup function invoked at boot to parse the dtc3181e= command
  262.  * line.
  263.  */
  265. static int __init do_DTC3181E_setup(char *str)
  266. {
  267. int ints[10];
  269. get_options(str, sizeof(ints) / sizeof(int), ints);
  270. internal_setup(BOARD_DTC3181E, str, ints);
  271. return 1;
  272. }
  274. /**
  275.  *  generic_NCR5380_detect - look for NCR5380 controllers
  276.  * @tpnt: the scsi template
  277.  *
  278.  * Scan for the present of NCR5380, NCR53C400, NCR53C400A, DTC3181E
  279.  * and DTC436(ISAPnP) controllers. If overrides have been set we use
  280.  * them.
  281.  *
  282.  * The caller supplied NCR5380_init function is invoked from here, before
  283.  * the interrupt line is taken.
  284.  *
  285.  * Locks: none
  286.  */
  288. int __init generic_NCR5380_detect(Scsi_Host_Template * tpnt)
  289. {
  290. static int current_override = 0;
  291. int count, i;
  292. unsigned int *ports;
  293. static unsigned int __initdata ncr_53c400a_ports[] = {
  294. 0x280, 0x290, 0x300, 0x310, 0x330, 0x340, 0x348, 0x350, 0
  295. };
  296. static unsigned int __initdata dtc_3181e_ports[] = {
  297. 0x220, 0x240, 0x280, 0x2a0, 0x2c0, 0x300, 0x320, 0x340, 0
  298. };
  299. int flags = 0;
  300. struct Scsi_Host *instance;
  302. if (ncr_irq != NCR_NOT_SET)
  303. overrides[0].irq = ncr_irq;
  304. if (ncr_dma != NCR_NOT_SET)
  305. overrides[0].dma = ncr_dma;
  306. if (ncr_addr != NCR_NOT_SET)
  307. overrides[0].NCR5380_map_name = (NCR5380_map_type) ncr_addr;
  308. if (ncr_5380 != NCR_NOT_SET)
  309. overrides[0].board = BOARD_NCR5380;
  310. else if (ncr_53c400 != NCR_NOT_SET)
  311. overrides[0].board = BOARD_NCR53C400;
  312. else if (ncr_53c400a != NCR_NOT_SET)
  313. overrides[0].board = BOARD_NCR53C400A;
  314. else if (dtc_3181e != NCR_NOT_SET)
  315. overrides[0].board = BOARD_DTC3181E;
  317. if (!current_override && isapnp_present()) {
  318. struct pci_dev *dev = NULL;
  319. count = 0;
  320. while ((dev = isapnp_find_dev(NULL, ISAPNP_VENDOR('D', 'T', 'C'), ISAPNP_FUNCTION(0x436e), dev))) {
  321. if (count >= NO_OVERRIDES)
  322. break;
  323. if (!dev->active && dev->prepare(dev) < 0) {
  324. printk(KERN_ERR "dtc436e probe: prepare failedn");
  325. continue;
  326. }
  327. if (!(dev->resource[0].flags & IORESOURCE_IO))
  328. continue;
  329. if (!dev->active && dev->activate(dev) < 0) {
  330. printk(KERN_ERR "dtc436e probe: activate failedn");
  331. continue;
  332. }
  333. if (dev->irq_resource[0].flags & IORESOURCE_IRQ)
  334. overrides[count].irq = dev->irq_resource[0].start;
  335. else
  336. overrides[count].irq = IRQ_NONE;
  337. if (dev->dma_resource[0].flags & IORESOURCE_DMA)
  338. overrides[count].dma = dev->dma_resource[0].start;
  339. else
  340. overrides[count].dma = DMA_NONE;
  341. overrides[count].NCR5380_map_name = (NCR5380_map_type) dev->resource[0].start;
  342. overrides[count].board = BOARD_DTC3181E;
  343. count++;
  344. }
  345. }
  347. tpnt->proc_name = "g_NCR5380";
  349. for (count = 0; current_override < NO_OVERRIDES; ++current_override) {
  350. if (!(overrides[current_override].NCR5380_map_name))
  351. continue;
  353. ports = 0;
  354. switch (overrides[current_override].board) {
  355. case BOARD_NCR5380:
  356. flags = FLAG_NO_PSEUDO_DMA;
  357. break;
  358. case BOARD_NCR53C400:
  359. flags = FLAG_NCR53C400;
  360. break;
  361. case BOARD_NCR53C400A:
  362. flags = FLAG_NO_PSEUDO_DMA;
  363. ports = ncr_53c400a_ports;
  364. break;
  365. case BOARD_DTC3181E:
  366. flags = FLAG_NO_PSEUDO_DMA | FLAG_DTC3181E;
  367. ports = dtc_3181e_ports;
  368. break;
  369. }
  371. #ifdef CONFIG_SCSI_G_NCR5380_PORT
  372. if (ports) {
  373. /* wakeup sequence for the NCR53C400A and DTC3181E */
  375. /* Disable the adapter and look for a free io port */
  376. outb(0x59, 0x779);
  377. outb(0xb9, 0x379);
  378. outb(0xc5, 0x379);
  379. outb(0xae, 0x379);
  380. outb(0xa6, 0x379);
  381. outb(0x00, 0x379);
  383. if (overrides[current_override].NCR5380_map_name != PORT_AUTO)
  384. for (i = 0; ports[i]; i++) {
  385. if (overrides[current_override].NCR5380_map_name == ports[i])
  386. break;
  387. } else
  388. for (i = 0; ports[i]; i++) {
  389. if ((!check_region(ports[i], 16)) && (inb(ports[i]) == 0xff))
  390. break;
  391. }
  392. if (ports[i]) {
  393. outb(0x59, 0x779);
  394. outb(0xb9, 0x379);
  395. outb(0xc5, 0x379);
  396. outb(0xae, 0x379);
  397. outb(0xa6, 0x379);
  398. outb(0x80 | i, 0x379); /* set io port to be used */
  399. outb(0xc0, ports[i] + 9);
  400. if (inb(ports[i] + 9) != 0x80)
  401. continue;
  402. else
  403. overrides[current_override].NCR5380_map_name = ports[i];
  404. } else
  405. continue;
  406. }
  408. request_region(overrides[current_override].NCR5380_map_name, NCR5380_region_size, "ncr5380");
  409. #else
  410. if (check_mem_region(overrides[current_override].NCR5380_map_name, NCR5380_region_size))
  411. continue;
  412. request_mem_region(overrides[current_override].NCR5380_map_name, NCR5380_region_size, "ncr5380");
  413. #endif
  414. instance = scsi_register(tpnt, sizeof(struct NCR5380_hostdata));
  415. if (instance == NULL) {
  416. #ifdef CONFIG_SCSI_G_NCR5380_PORT
  417. release_region(overrides[current_override].NCR5380_map_name, NCR5380_region_size);
  418. #else
  419. release_mem_region(overrides[current_override].NCR5380_map_name, NCR5380_region_size);
  420. #endif
  421. continue;
  422. }
  424. instance->NCR5380_instance_name = overrides[current_override].NCR5380_map_name;
  426. NCR5380_init(instance, flags);
  428. if (overrides[current_override].irq != IRQ_AUTO)
  429. instance->irq = overrides[current_override].irq;
  430. else
  431. instance->irq = NCR5380_probe_irq(instance, 0xffff);
  433. if (instance->irq != IRQ_NONE)
  434. if (request_irq(instance->irq, do_generic_NCR5380_intr, SA_INTERRUPT, "NCR5380", NULL)) {
  435. printk(KERN_WARNING "scsi%d : IRQ%d not free, interrupts disabledn", instance->host_no, instance->irq);
  436. instance->irq = IRQ_NONE;
  437. }
  439. if (instance->irq == IRQ_NONE) {
  440. printk(KERN_INFO "scsi%d : interrupts not enabled. for better interactive performance,n", instance->host_no);
  441. printk(KERN_INFO "scsi%d : please jumper the board for a free IRQ.n", instance->host_no);
  442. }
  444. printk(KERN_INFO "scsi%d : at " STRVAL(NCR5380_map_name) " 0x%x", instance->host_no, (unsigned int) instance->NCR5380_instance_name);
  445. if (instance->irq == IRQ_NONE)
  446. printk(" interrupts disabled");
  447. else
  448. printk(" irq %d", instance->irq);
  449. printk(" options CAN_QUEUE=%d  CMD_PER_LUN=%d release=%d", CAN_QUEUE, CMD_PER_LUN, GENERIC_NCR5380_PUBLIC_RELEASE);
  450. NCR5380_print_options(instance);
  451. printk("n");
  453. ++current_override;
  454. ++count;
  455. }
  456. return count;
  457. }
  459. /**
  460.  * generic_NCR5380_info - reporting string
  461.  * @host: NCR5380 to report on
  462.  *
  463.  * Report driver information for the NCR5380
  464.  */
  465.  
  466. const char *generic_NCR5380_info(struct Scsi_Host *host)
  467. {
  468. static const char string[] = "Generic NCR5380/53C400 Driver";
  469. return string;
  470. }
  472. /**
  473.  * generic_NCR5380_release_resources - free resources
  474.  * @instance: host adapter to clean up 
  475.  *
  476.  * Free the generic interface resources from this adapter.
  477.  *
  478.  * Locks: none
  479.  */
  480.  
  481. int generic_NCR5380_release_resources(struct Scsi_Host *instance)
  482. {
  483. NCR5380_local_declare();
  484. NCR5380_setup(instance);
  486. #ifdef CONFIG_SCSI_G_NCR5380_PORT
  487. release_region(instance->NCR5380_instance_name, NCR5380_region_size);
  488. #else
  489. release_mem_region(instance->NCR5380_instance_name, NCR5380_region_size);
  490. #endif
  492. if (instance->irq != IRQ_NONE)
  493. free_irq(instance->irq, NULL);
  495. return 0;
  496. }
  498. #ifdef BIOSPARAM
  499. /**
  500.  * generic_NCR5380_biosparam
  501.  * @disk: disk to compute geometry for
  502.  * @dev: device identifier for this disk
  503.  * @ip: sizes to fill in
  504.  *
  505.  * Generates a BIOS / DOS compatible H-C-S mapping for the specified 
  506.  * device / size.
  507.  * 
  508.  *  XXX Most SCSI boards use this mapping, I could be incorrect.  Someone
  509.  * using hard disks on a trantor should verify that this mapping
  510.  * corresponds to that used by the BIOS / ASPI driver by running the linux
  511.  * fdisk program and matching the H_C_S coordinates to what DOS uses.
  512.  *
  513.  * Locks: none
  514.  */
  516. int generic_NCR5380_biosparam(Disk * disk, kdev_t dev, int *ip)
  517. {
  518. int size = disk->capacity;
  519. ip[0] = 64;
  520. ip[1] = 32;
  521. ip[2] = size >> 11;
  522. return 0;
  523. }
  524. #endif
  526. #if NCR53C400_PSEUDO_DMA
  528. /**
  529.  * NCR5380_pread - pseudo DMA read
  530.  * @instance: adapter to read from
  531.  * @dst: buffer to read into
  532.  * @len: buffer length
  533.  *
  534.  * Perform a psuedo DMA mode read from an NCR53C400 or equivalent
  535.  * controller
  536.  */
  537.  
  538. static inline int NCR5380_pread(struct Scsi_Host *instance, unsigned char *dst, int len)
  539. {
  540. int blocks = len / 128;
  541. int start = 0;
  542. int bl;
  544. NCR5380_local_declare();
  545. NCR5380_setup(instance);
  547. NCR5380_write(C400_CONTROL_STATUS_REG, CSR_BASE | CSR_TRANS_DIR);
  548. NCR5380_write(C400_BLOCK_COUNTER_REG, blocks);
  549. while (1) {
  550. if ((bl = NCR5380_read(C400_BLOCK_COUNTER_REG)) == 0) {
  551. break;
  552. }
  553. if (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_GATED_53C80_IRQ) {
  554. printk(KERN_ERR "53C400r: Got 53C80_IRQ start=%d, blocks=%dn", start, blocks);
  555. return -1;
  556. }
  557. while (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_HOST_BUF_NOT_RDY);
  559. #ifdef CONFIG_SCSI_G_NCR5380_PORT
  560. {
  561. int i;
  562. for (i = 0; i < 128; i++)
  563. dst[start + i] = NCR5380_read(C400_HOST_BUFFER);
  564. }
  565. #else
  566. /* implies CONFIG_SCSI_G_NCR5380_MEM */
  567. isa_memcpy_fromio(dst + start, NCR53C400_host_buffer + NCR5380_map_name, 128);
  568. #endif
  569. start += 128;
  570. blocks--;
  571. }
  573. if (blocks) {
  574. while (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_HOST_BUF_NOT_RDY)
  575. {
  576. // FIXME - no timeout
  577. }
  579. #ifdef CONFIG_SCSI_G_NCR5380_PORT
  580. {
  581. int i;
  582. for (i = 0; i < 128; i++)
  583. dst[start + i] = NCR5380_read(C400_HOST_BUFFER);
  584. }
  585. #else
  586. /* implies CONFIG_SCSI_G_NCR5380_MEM */
  587. isa_memcpy_fromio(dst + start, NCR53C400_host_buffer + NCR5380_map_name, 128);
  588. #endif
  589. start += 128;
  590. blocks--;
  591. }
  593. if (!(NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_GATED_53C80_IRQ))
  594. printk("53C400r: no 53C80 gated irq after transfer");
  596. #if 0
  597. /*
  598.  * DON'T DO THIS - THEY NEVER ARRIVE!
  599.  */
  600. printk("53C400r: Waiting for 53C80 registersn");
  601. while (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_53C80_REG)
  602. ;
  603. #endif
  604. if (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_END_DMA_TRANSFER))
  605. printk(KERN_ERR "53C400r: no end dma signaln");
  607. NCR5380_write(MODE_REG, MR_BASE);
  608. NCR5380_read(RESET_PARITY_INTERRUPT_REG);
  609. return 0;
  610. }
  612. /**
  613.  * NCR5380_write - pseudo DMA write
  614.  * @instance: adapter to read from
  615.  * @dst: buffer to read into
  616.  * @len: buffer length
  617.  *
  618.  * Perform a psuedo DMA mode read from an NCR53C400 or equivalent
  619.  * controller
  620.  */
  622. static inline int NCR5380_pwrite(struct Scsi_Host *instance, unsigned char *src, int len)
  623. {
  624. int blocks = len / 128;
  625. int start = 0;
  626. int bl;
  627. int i;
  629. NCR5380_local_declare();
  630. NCR5380_setup(instance);
  632. NCR5380_write(C400_CONTROL_STATUS_REG, CSR_BASE);
  633. NCR5380_write(C400_BLOCK_COUNTER_REG, blocks);
  634. while (1) {
  635. if (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_GATED_53C80_IRQ) {
  636. printk(KERN_ERR "53C400w: Got 53C80_IRQ start=%d, blocks=%dn", start, blocks);
  637. return -1;
  638. }
  640. if ((bl = NCR5380_read(C400_BLOCK_COUNTER_REG)) == 0) {
  641. break;
  642. }
  643. while (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_HOST_BUF_NOT_RDY)
  644. ; // FIXME - timeout
  645. #ifdef CONFIG_SCSI_G_NCR5380_PORT
  646. {
  647. for (i = 0; i < 128; i++)
  648. NCR5380_write(C400_HOST_BUFFER, src[start + i]);
  649. }
  650. #else
  651. /* implies CONFIG_SCSI_G_NCR5380_MEM */
  652. isa_memcpy_toio(NCR53C400_host_buffer + NCR5380_map_name, src + start, 128);
  653. #endif
  654. start += 128;
  655. blocks--;
  656. }
  657. if (blocks) {
  658. while (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_HOST_BUF_NOT_RDY)
  659. ; // FIXME - no timeout
  661. #ifdef CONFIG_SCSI_G_NCR5380_PORT
  662. {
  663. for (i = 0; i < 128; i++)
  664. NCR5380_write(C400_HOST_BUFFER, src[start + i]);
  665. }
  666. #else
  667. /* implies CONFIG_SCSI_G_NCR5380_MEM */
  668. isa_memcpy_toio(NCR53C400_host_buffer + NCR5380_map_name, src + start, 128);
  669. #endif
  670. start += 128;
  671. blocks--;
  672. }
  674. #if 0
  675. printk("53C400w: waiting for registers to be availablen");
  676. THEY NEVER DO ! while (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_53C80_REG);
  677. printk("53C400w: Got emn");
  678. #endif
  680. /* Let's wait for this instead - could be ugly */
  681. /* All documentation says to check for this. Maybe my hardware is too
  682.  * fast. Waiting for it seems to work fine! KLL
  683.  */
  684. while (!(i = NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_GATED_53C80_IRQ))
  685. ; // FIXME - no timeout
  687. /*
  688.  * I know. i is certainly != 0 here but the loop is new. See previous
  689.  * comment.
  690.  */
  691. if (i) {
  692. if (!((i = NCR5380_read(BUS_AND_STATUS_REG)) & BASR_END_DMA_TRANSFER))
  693. printk(KERN_ERR "53C400w: No END OF DMA bit - WHOOPS! BASR=%0xn", i);
  694. } else
  695. printk(KERN_ERR "53C400w: no 53C80 gated irq after transfer (last block)n");
  697. #if 0
  698. if (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_END_DMA_TRANSFER)) {
  699. printk(KERN_ERR "53C400w: no end dma signaln");
  700. }
  701. #endif
  702. while (!(NCR5380_read(TARGET_COMMAND_REG) & TCR_LAST_BYTE_SENT))
  703. ;  // TIMEOUT
  704. return 0;
  705. }
  706. #endif /* PSEUDO_DMA */
  708. /*
  709.  * Include the NCR5380 core code that we build our driver around
  710.  */
  711.  
  712. #include "NCR5380.c"
  714. #define PRINTP(x) len += sprintf(buffer+len, x)
  715. #define ANDP ,
  717. static int sprint_opcode(char *buffer, int len, int opcode)
  718. {
  719. int start = len;
  720. PRINTP("0x%02x " ANDP opcode);
  721. return len - start;
  722. }
  724. static int sprint_command(char *buffer, int len, unsigned char *command)
  725. {
  726. int i, s, start = len;
  727. len += sprint_opcode(buffer, len, command[0]);
  728. for (i = 1, s = COMMAND_SIZE(command[0]); i < s; ++i)
  729. PRINTP("%02x " ANDP command[i]);
  730. PRINTP("n");
  731. return len - start;
  732. }
  734. /**
  735.  * sprintf_Scsi_Cmnd - print a scsi command
  736.  * @buffer: buffr to print into
  737.  * @len: buffer length
  738.  * @cmd: SCSI command block
  739.  *
  740.  * Print out the target and command data in hex
  741.  */
  743. static int sprint_Scsi_Cmnd(char *buffer, int len, Scsi_Cmnd * cmd)
  744. {
  745. int start = len;
  746. PRINTP("host number %d destination target %d, lun %dn" ANDP cmd->host->host_no ANDP cmd->target ANDP cmd->lun);
  747. PRINTP("        command = ");
  748. len += sprint_command(buffer, len, cmd->cmnd);
  749. return len - start;
  750. }
  752. /**
  753.  * generic_NCR5380_proc_info - /proc for NCR5380 driver
  754.  * @buffer: buffer to print into
  755.  * @start: start position
  756.  * @offset: offset into buffer
  757.  * @len: length
  758.  * @hostno: instance to affect
  759.  * @inout: read/write
  760.  *
  761.  * Provide the procfs information for the 5380 controller. We fill
  762.  * this with useful debugging information including the commands
  763.  * being executed, disconnected command queue and the statistical
  764.  * data
  765.  *
  766.  * Locks: global cli/lock for queue walk
  767.  */
  768.  
  769. int generic_NCR5380_proc_info(char *buffer, char **start, off_t offset, int length, int hostno, int inout)
  770. {
  771. int len = 0;
  772. NCR5380_local_declare();
  773. unsigned long flags;
  774. unsigned char status;
  775. int i;
  776. struct Scsi_Host *scsi_ptr;
  777. Scsi_Cmnd *ptr;
  778. struct NCR5380_hostdata *hostdata;
  779. #ifdef NCR5380_STATS
  780. Scsi_Device *dev;
  781. extern const char *const scsi_device_types[MAX_SCSI_DEVICE_CODE];
  782. #endif
  783. save_flags(flags);
  784. cli();
  786. for (scsi_ptr = first_instance; scsi_ptr; scsi_ptr = scsi_ptr->next)
  787. if (scsi_ptr->host_no == hostno)
  788. break;
  789. NCR5380_setup(scsi_ptr);
  790. hostdata = (struct NCR5380_hostdata *) scsi_ptr->hostdata;
  792. PRINTP("SCSI host number %d : %sn" ANDP scsi_ptr->host_no ANDP scsi_ptr->hostt->name);
  793. PRINTP("Generic NCR5380 driver version %dn" ANDP GENERIC_NCR5380_PUBLIC_RELEASE);
  794. PRINTP("NCR5380 core version %dn" ANDP NCR5380_PUBLIC_RELEASE);
  795. #ifdef NCR53C400
  796. PRINTP("NCR53C400 extension version %dn" ANDP NCR53C400_PUBLIC_RELEASE);
  797. PRINTP("NCR53C400 card%s detectedn" ANDP(((struct NCR5380_hostdata *) scsi_ptr->hostdata)->flags & FLAG_NCR53C400) ? "" : " not");
  798. # if NCR53C400_PSEUDO_DMA
  799. PRINTP("NCR53C400 pseudo DMA usedn");
  800. # endif
  801. #else
  802. PRINTP("NO NCR53C400 driver extensionsn");
  803. #endif
  804. PRINTP("Using %s mapping at %s 0x%lx, " ANDP STRVAL(NCR5380_map_config) ANDP STRVAL(NCR5380_map_name) ANDP scsi_ptr->NCR5380_instance_name);
  805. if (scsi_ptr->irq == IRQ_NONE)
  806. PRINTP("no interruptn");
  807. else
  808. PRINTP("on interrupt %dn" ANDP scsi_ptr->irq);
  810. #ifdef NCR5380_STATS
  811. if (hostdata->connected || hostdata->issue_queue || hostdata->disconnected_queue)
  812. PRINTP("There are commands pending, transfer rates may be crudn");
  813. if (hostdata->pendingr)
  814. PRINTP("  %d pending reads" ANDP hostdata->pendingr);
  815. if (hostdata->pendingw)
  816. PRINTP("  %d pending writes" ANDP hostdata->pendingw);
  817. if (hostdata->pendingr || hostdata->pendingw)
  818. PRINTP("n");
  819. for (dev = scsi_ptr->host_queue; dev; dev = dev->next) {
  820. unsigned long br = hostdata->bytes_read[dev->id];
  821. unsigned long bw = hostdata->bytes_write[dev->id];
  822. long tr = hostdata->time_read[dev->id] / HZ;
  823. long tw = hostdata->time_write[dev->id] / HZ;
  825. PRINTP("  T:%d %s " ANDP dev->id ANDP(dev->type < MAX_SCSI_DEVICE_CODE) ? scsi_device_types[(int) dev->type] : "Unknown");
  826. for (i = 0; i < 8; i++)
  827. if (dev->vendor[i] >= 0x20)
  828. *(buffer + (len++)) = dev->vendor[i];
  829. *(buffer + (len++)) = ' ';
  830. for (i = 0; i < 16; i++)
  831. if (dev->model[i] >= 0x20)
  832. *(buffer + (len++)) = dev->model[i];
  833. *(buffer + (len++)) = ' ';
  834. for (i = 0; i < 4; i++)
  835. if (dev->rev[i] >= 0x20)
  836. *(buffer + (len++)) = dev->rev[i];
  837. *(buffer + (len++)) = ' ';
  839. PRINTP("n%10ld kb read    in %5ld secs" ANDP br / 1024 ANDP tr);
  840. if (tr)
  841. PRINTP(" @ %5ld bps" ANDP br / tr);
  843. PRINTP("n%10ld kb written in %5ld secs" ANDP bw / 1024 ANDP tw);
  844. if (tw)
  845. PRINTP(" @ %5ld bps" ANDP bw / tw);
  846. PRINTP("n");
  847. }
  848. #endif
  850. status = NCR5380_read(STATUS_REG);
  851. if (!(status & SR_REQ))
  852. PRINTP("REQ not asserted, phase unknown.n");
  853. else {
  854. for (i = 0; (phases[i].value != PHASE_UNKNOWN) && (phases[i].value != (status & PHASE_MASK)); ++i);
  855. PRINTP("Phase %sn" ANDP phases[i].name);
  856. }
  858. if (!hostdata->connected) {
  859. PRINTP("No currently connected commandn");
  860. } else {
  861. len += sprint_Scsi_Cmnd(buffer, len, (Scsi_Cmnd *) hostdata->connected);
  862. }
  864. PRINTP("issue_queuen");
  866. for (ptr = (Scsi_Cmnd *) hostdata->issue_queue; ptr; ptr = (Scsi_Cmnd *) ptr->host_scribble)
  867. len += sprint_Scsi_Cmnd(buffer, len, ptr);
  869. PRINTP("disconnected_queuen");
  871. for (ptr = (Scsi_Cmnd *) hostdata->disconnected_queue; ptr; ptr = (Scsi_Cmnd *) ptr->host_scribble)
  872. len += sprint_Scsi_Cmnd(buffer, len, ptr);
  874. *start = buffer + offset;
  875. len -= offset;
  876. if (len > length)
  877. len = length;
  878. restore_flags(flags);
  879. return len;
  880. }
  882. #undef PRINTP
  883. #undef ANDP
  885. /*
  886.  * Eventually this will go into an include file, but this will be later 
  887.  */
  888. static Scsi_Host_Template driver_template = GENERIC_NCR5380;
  890. #include <linux/module.h>
  891. #include "scsi_module.c"
  893. MODULE_PARM(ncr_irq, "i");
  894. MODULE_PARM(ncr_dma, "i");
  895. MODULE_PARM(ncr_addr, "i");
  896. MODULE_PARM(ncr_5380, "i");
  897. MODULE_PARM(ncr_53c400, "i");
  898. MODULE_PARM(ncr_53c400a, "i");
  899. MODULE_PARM(dtc_3181e, "i");
  900. MODULE_LICENSE("GPL");
  903. static struct isapnp_device_id id_table[] __devinitdata = {
  904. {
  905.  ISAPNP_ANY_ID, ISAPNP_ANY_ID,
  906.  ISAPNP_VENDOR('D', 'T', 'C'), ISAPNP_FUNCTION(0x436e),
  907.  0},
  908. {0}
  909. };
  911. MODULE_DEVICE_TABLE(isapnp, id_table);
  914. __setup("ncr5380=", do_NCR5380_setup);
  915. __setup("ncr53c400=", do_NCR53C400_setup);
  916. __setup("ncr53c400a=", do_NCR53C400A_setup);
  917. __setup("dtc3181e=", do_DTC3181E_setup);