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

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

Linux/Unix编程

开发平台：

Unix_Linux

ide.c：源码内容
  1. /* $Id: ide.c,v 1.24 2002/04/22 11:47:21 johana Exp $
  2.  *
  3.  * Etrax specific IDE functions, like init and PIO-mode setting etc.
  4.  * Almost the entire ide.c is used for the rest of the Etrax ATA driver.
  5.  * Copyright (c) 2000, 2001, 2002 Axis Communications AB 
  6.  *
  7.  * Authors:    Bjorn Wesen        (initial version)
  8.  *             Mikael Starvik     (pio setup stuff)
  9.  *
  10.  * $Log: ide.c,v $
  11.  * Revision 1.24  2002/04/22 11:47:21  johana
  12.  * Fix according to 2.4.19-pre7. time_after/time_before and
  13.  * missing end of comment.
  14.  * The patch has a typo for ethernet.c in e100_clear_network_leds(),
  15.  *  that is fixed here.
  16.  *
  17.  * Revision 1.23  2002/03/19 15:35:51  bjornw
  18.  * Cleaned up the bus-reset code a bit and made G27-reset work
  19.  *
  20.  * Revision 1.22  2002/03/19 15:23:05  bjornw
  21.  * Added flush_etrax_cache before starting the receiving DMA
  22.  *
  23.  * Revision 1.21  2002/03/06 15:37:56  hp
  24.  *  * ide.c (OUT_BYTE): If timing out in the first busy-loop, do a
  25.  *  printk, fall through and still do the write.
  26.  *  (IN_BYTE): If timing out in the first loop, and reg indicated it's
  27.  *  the ATA status register in the device being read, return BUSY_STAT.
  28.  *
  29.  * Revision 1.20  2002/02/22 11:47:56  bjornw
  30.  * Added a timeout to IN_BYTE and OUT_BYTE
  31.  *
  32.  * Revision 1.19  2001/05/09 12:53:16  johana
  33.  * Added #include <asm/dma.h>
  34.  *
  35.  * Revision 1.18  2001/05/09 12:37:00  johana
  36.  * Use DMA_NBR macros from dma.h.
  37.  *
  38.  * Revision 1.17  2001/04/23 13:36:30  matsfg
  39.  * Changed CONFIG_IDE_DELAY to CONFIG_ETRAX_IDE_DELAY
  40.  *
  41.  * Revision 1.16  2001/04/05 08:30:07  matsfg
  42.  * Corrected cse1 and csp0 reset.
  43.  *
  44.  * Revision 1.15  2001/04/04 14:34:06  bjornw
  45.  * Re-instated code that mysteriously disappeared during review updates.
  46.  *
  47.  * Revision 1.14  2001/04/04 13:45:12  matsfg
  48.  * Calls REG_SHADOW_SET for cse1 reset so only the resetbit is affected
  49.  *
  50.  * Revision 1.13  2001/04/04 13:26:40  matsfg
  51.  * memmapping is done in init.c
  52.  *
  53.  * Revision 1.12  2001/04/04 11:37:56  markusl
  54.  * Updated according to review remarks
  55.  *
  56.  * Revision 1.11  2001/03/29 12:49:14  matsfg
  57.  * Changed check for ata_tot_size from >= to >.
  58.  * Sets sw_len to 0 if size is exactly 65536.
  59.  *
  60.  * Revision 1.10  2001/03/16 09:39:30  matsfg
  61.  * Support for reset on port CSP0
  62.  *
  63.  * Revision 1.9  2001/03/01 13:11:18  bjornw
  64.  * 100 -> HZ
  65.  *
  66.  * Revision 1.8  2001/03/01 09:32:56  matsfg
  67.  * Moved IDE delay to a CONFIG-parameter instead
  68.  *
  69.  * Revision 1.7  2001/02/23 13:46:38  bjornw
  70.  * Spellling check
  71.  *
  72.  * Revision 1.6  2001/02/22 15:44:30  bjornw
  73.  * * Use ioremap when mapping the CSE1 memory-mapped reset-line for LX v2
  74.  * * sw_len for a 65536 descriptor is 0, not 65536
  75.  * * Express concern for G27 reset code
  76.  *
  77.  * Revision 1.5  2001/02/16 07:35:38  matsfg
  78.  * Now handles DMA request blocks between 64k and 128k by split into two descriptors.
  79.  *
  80.  * Revision 1.4  2001/01/10 21:14:32  bjornw
  81.  * Initialize hwif->ideproc, for the new way of handling ide_xxx_data
  82.  *
  83.  * Revision 1.3  2000/12/01 17:48:18  bjornw
  84.  * - atapi_output_bytes now uses DMA
  85.  * - dma_active check removed - the kernel does proper serializing and it had
  86.  *   a race-condition anyway
  87.  * - ide_build_dmatable had a nameclash
  88.  * - re-added the RESET_DMA thingys because sometimes the interface can get
  89.  *   stuck apparently
  90.  * - added ide_release_dma
  91.  *
  92.  * Revision 1.2  2000/11/29 17:31:29  bjornw
  93.  * 2.4 port
  94.  *
  95.  * - The "register addresses" stored in the hwif are now 32-bit fields that
  96.  *   don't need to be shifted into correct positions in R_ATA_CTRL_DATA
  97.  * - PIO-mode detection temporarily disabled since ide-modes.c is not compiled
  98.  * - All DMA uses virt_to_phys conversions for DMA buffers and descriptor ptrs
  99.  * - Probably correct ide_dma_begin semantics in dmaproc now for ATAPI devices
  100.  * - Removed RESET_DMA when starting a new transfer - why was this necessary ?
  101.  * - Indentation fix
  102.  *
  103.  *
  104.  */
  106. /* Regarding DMA: 
  107.  *
  108.  * There are two forms of DMA - "DMA handshaking" between the interface and the drive,
  109.  * and DMA between the memory and the interface. We can ALWAYS use the latter, since it's
  110.  * something built-in in the Etrax. However only some drives support the DMA-mode handshaking
  111.  * on the ATA-bus. The normal PC driver and Triton interface disables memory-if DMA when the
  112.  * device can't do DMA handshaking for some stupid reason. We don't need to do that.
  113.  */ 
  115. #undef REALLY_SLOW_IO           /* most systems can safely undef this */
  117. #include <linux/config.h>
  118. #include <linux/types.h>
  119. #include <linux/kernel.h>
  120. #include <linux/timer.h>
  121. #include <linux/mm.h>
  122. #include <linux/interrupt.h>
  123. #include <linux/delay.h>
  124. #include <linux/blkdev.h>
  125. #include <linux/hdreg.h>
  126. #include <linux/ide.h>
  127. #include <linux/init.h>
  129. #include <asm/io.h>
  130. #include <asm/svinto.h>
  131. #include <asm/dma.h>
  133. /* number of Etrax DMA descriptors */
  134. #define MAX_DMA_DESCRS 64
  136. /* number of times to retry busy-flags when reading/writing IDE-registers 
  137.  * this can't be too high because a hung harddisk might cause the watchdog
  138.  * to trigger (sometimes IN_BYTE and OUT_BYTE are called with irq's disabled)
  139.  */
  141. #define IDE_REGISTER_TIMEOUT 300
  143. #ifdef CONFIG_ETRAX_IDE_CSE1_16_RESET
  144. /* address where the memory-mapped IDE reset bit lives, if used */
  145. static volatile unsigned long *reset_addr;
  146. #endif
  148. #define LOWDB(x)
  149. #define D(x) 
  151. void 
  152. OUT_BYTE(unsigned char data, ide_ioreg_t reg) {
  153. int timeleft;
  154. LOWDB(printk("ob: data 0x%x, reg 0x%xn", data, reg));
  156. /* note the lack of handling any timeouts. we stop waiting, but we don't
  157.  * really notify anybody.
  158.  */
  160. timeleft = IDE_REGISTER_TIMEOUT;
  161. /* wait for busy flag */
  162. while(timeleft && (*R_ATA_STATUS_DATA & IO_MASK(R_ATA_STATUS_DATA, busy)))
  163. timeleft--;
  165. /*
  166.  * Fall through at a timeout, so the ongoing command will be
  167.  * aborted by the write below, which is expected to be a dummy
  168.  * command to the command register.  This happens when a faulty
  169.  * drive times out on a command.  See comment on timeout in
  170.  * IN_BYTE.
  171.  */
  172. if(!timeleft)
  173. printk("ATA timeout reg 0x%lx := 0x%xn", reg, data);
  175. *R_ATA_CTRL_DATA = reg | data; /* write data to the drive's register */
  177. timeleft = IDE_REGISTER_TIMEOUT;
  178. /* wait for transmitter ready */
  179. while(timeleft && !(*R_ATA_STATUS_DATA &
  180.     IO_MASK(R_ATA_STATUS_DATA, tr_rdy)))
  181. timeleft--;
  182. }
  184. unsigned char 
  185. IN_BYTE(ide_ioreg_t reg) {
  186. int status;
  187. int timeleft;
  189. timeleft = IDE_REGISTER_TIMEOUT;
  190. /* wait for busy flag */
  191. while(timeleft && (*R_ATA_STATUS_DATA & IO_MASK(R_ATA_STATUS_DATA, busy)))
  192. timeleft--;
  194. if(!timeleft) {
  195. /*
  196.  * If we're asked to read the status register, like for
  197.  * example when a command does not complete for an
  198.  * extended time, but the ATA interface is stuck in a
  199.  * busy state at the *ETRAX* ATA interface level (as has
  200.  * happened repeatedly with at least one bad disk), then
  201.  * the best thing to do is to pretend that we read
  202.  * "busy" in the status register, so the IDE driver will
  203.  * time-out, abort the ongoing command and perform a
  204.  * reset sequence.  Note that the subsequent OUT_BYTE
  205.  * call will also timeout on busy, but as long as the
  206.  * write is still performed, everything will be fine.
  207.  */
  208. if ((reg & IO_MASK (R_ATA_CTRL_DATA, addr))
  209.     == IO_FIELD (R_ATA_CTRL_DATA, addr, IDE_STATUS_OFFSET))
  210. return BUSY_STAT;
  211. else
  212. /* For other rare cases we assume 0 is good enough.  */
  213. return 0;
  214. }
  216. *R_ATA_CTRL_DATA = reg | IO_STATE(R_ATA_CTRL_DATA, rw, read); /* read data */ 
  218. timeleft = IDE_REGISTER_TIMEOUT;
  219. /* wait for available */
  220. while(timeleft && !((status = *R_ATA_STATUS_DATA) &
  221.     IO_MASK(R_ATA_STATUS_DATA, dav)))
  222. timeleft--;
  224. if(!timeleft)
  225. return 0;
  227. LOWDB(printk("inb: 0x%x from reg 0x%xn", status & 0xff, reg));
  229. return (unsigned char)status; /* data was in the lower 16 bits in the status reg */
  230. }
  232. /* PIO timing (in R_ATA_CONFIG)
  233.  *
  234.  *                        _____________________________
  235.  * ADDRESS :     ________/
  236.  *
  237.  *                            _______________
  238.  * DIOR    :     ____________/               __________
  239.  *
  240.  *                               _______________
  241.  * DATA    :     XXXXXXXXXXXXXXXX_______________XXXXXXXX
  242.  *
  243.  *
  244.  * DIOR is unbuffered while address and data is buffered.
  245.  * This creates two problems:
  246.  * 1. The DIOR pulse is to early (because it is unbuffered)
  247.  * 2. The rise time of DIOR is long
  248.  *
  249.  * There are at least three different plausible solutions
  250.  * 1. Use a pad capable of larger currents in Etrax
  251.  * 2. Use an external buffer
  252.  * 3. Make the strobe pulse longer
  253.  *
  254.  * Some of the strobe timings below are modified to compensate
  255.  * for this. This implies a slight performance decrease.
  256.  *
  257.  * THIS SHOULD NEVER BE CHANGED!
  258.  *
  259.  * TODO: Is this true for the latest LX boards still ?
  260.  */
  262. #define ATA_DMA2_STROBE  4 
  263. #define ATA_DMA2_HOLD    0
  264. #define ATA_DMA1_STROBE  4 
  265. #define ATA_DMA1_HOLD    1
  266. #define ATA_DMA0_STROBE 12 
  267. #define ATA_DMA0_HOLD    9
  268. #define ATA_PIO4_SETUP   1
  269. #define ATA_PIO4_STROBE  5
  270. #define ATA_PIO4_HOLD    0
  271. #define ATA_PIO3_SETUP   1
  272. #define ATA_PIO3_STROBE  5
  273. #define ATA_PIO3_HOLD    1
  274. #define ATA_PIO2_SETUP   1
  275. #define ATA_PIO2_STROBE  6
  276. #define ATA_PIO2_HOLD    2
  277. #define ATA_PIO1_SETUP   2
  278. #define ATA_PIO1_STROBE 11
  279. #define ATA_PIO1_HOLD    4
  280. #define ATA_PIO0_SETUP   4
  281. #define ATA_PIO0_STROBE 19
  282. #define ATA_PIO0_HOLD    4
  284. static int e100_dmaproc (ide_dma_action_t func, ide_drive_t *drive);
  285. static void e100_ideproc (ide_ide_action_t func, ide_drive_t *drive,
  286.   void *buffer, unsigned int length);
  288. /*
  289.  * good_dma_drives() lists the model names (from "hdparm -i")
  290.  * of drives which do not support mword2 DMA but which are
  291.  * known to work fine with this interface under Linux.
  292.  */
  294. const char *good_dma_drives[] = {"Micropolis 2112A",
  295.  "CONNER CTMA 4000",
  296.  "CONNER CTT8000-A",
  297.  NULL};
  299. static void tune_e100_ide(ide_drive_t *drive, byte pio)
  300. {
  301. unsigned long flags;
  303. pio = 4;
  304. /* pio = ide_get_best_pio_mode(drive, pio, 4, NULL); */
  306. save_flags(flags);
  307. cli();
  309. /* set pio mode! */
  310.     
  311. switch(pio) {
  312. case 0:
  313. *R_ATA_CONFIG = ( IO_FIELD( R_ATA_CONFIG, enable,     1 ) |
  314.   IO_FIELD( R_ATA_CONFIG, dma_strobe, ATA_DMA2_STROBE ) |
  315.   IO_FIELD( R_ATA_CONFIG, dma_hold,   ATA_DMA2_HOLD ) |
  316.   IO_FIELD( R_ATA_CONFIG, pio_setup,  ATA_PIO0_SETUP ) |
  317.   IO_FIELD( R_ATA_CONFIG, pio_strobe, ATA_PIO0_STROBE ) |
  318.   IO_FIELD( R_ATA_CONFIG, pio_hold,   ATA_PIO0_HOLD ) );
  319. break;
  320. case 1:
  321. *R_ATA_CONFIG = ( IO_FIELD( R_ATA_CONFIG, enable,     1 ) |
  322.   IO_FIELD( R_ATA_CONFIG, dma_strobe, ATA_DMA2_STROBE ) |
  323.   IO_FIELD( R_ATA_CONFIG, dma_hold,   ATA_DMA2_HOLD ) |
  324.   IO_FIELD( R_ATA_CONFIG, pio_setup,  ATA_PIO1_SETUP ) |
  325.   IO_FIELD( R_ATA_CONFIG, pio_strobe, ATA_PIO1_STROBE ) |
  326.   IO_FIELD( R_ATA_CONFIG, pio_hold,   ATA_PIO1_HOLD ) );
  327. break;
  328. case 2:
  329. *R_ATA_CONFIG = ( IO_FIELD( R_ATA_CONFIG, enable,     1 ) |
  330.   IO_FIELD( R_ATA_CONFIG, dma_strobe, ATA_DMA2_STROBE ) |
  331.   IO_FIELD( R_ATA_CONFIG, dma_hold,   ATA_DMA2_HOLD ) |
  332.   IO_FIELD( R_ATA_CONFIG, pio_setup,  ATA_PIO2_SETUP ) |
  333.   IO_FIELD( R_ATA_CONFIG, pio_strobe, ATA_PIO2_STROBE ) |
  334.   IO_FIELD( R_ATA_CONFIG, pio_hold,   ATA_PIO2_HOLD ) );
  335. break;
  336. case 3:
  337. *R_ATA_CONFIG = ( IO_FIELD( R_ATA_CONFIG, enable,     1 ) |
  338.   IO_FIELD( R_ATA_CONFIG, dma_strobe, ATA_DMA2_STROBE ) |
  339.   IO_FIELD( R_ATA_CONFIG, dma_hold,   ATA_DMA2_HOLD ) |
  340.   IO_FIELD( R_ATA_CONFIG, pio_setup,  ATA_PIO3_SETUP ) |
  341.   IO_FIELD( R_ATA_CONFIG, pio_strobe, ATA_PIO3_STROBE ) |
  342.   IO_FIELD( R_ATA_CONFIG, pio_hold,   ATA_PIO3_HOLD ) );
  343. break;
  344. case 4:
  345. *R_ATA_CONFIG = ( IO_FIELD( R_ATA_CONFIG, enable,     1 ) |
  346.   IO_FIELD( R_ATA_CONFIG, dma_strobe, ATA_DMA2_STROBE ) |
  347.   IO_FIELD( R_ATA_CONFIG, dma_hold,   ATA_DMA2_HOLD ) |
  348.   IO_FIELD( R_ATA_CONFIG, pio_setup,  ATA_PIO4_SETUP ) |
  349.   IO_FIELD( R_ATA_CONFIG, pio_strobe, ATA_PIO4_STROBE ) |
  350.   IO_FIELD( R_ATA_CONFIG, pio_hold,   ATA_PIO4_HOLD ) );
  351. break;
  352. }
  353. restore_flags(flags);
  354. }
  356. void __init 
  357. init_e100_ide (void)
  358. {
  359. volatile unsigned int dummy;
  360. int h;
  362. printk("ide: ETRAX 100LX built-in ATA DMA controllern");
  364. /* first fill in some stuff in the ide_hwifs fields */
  366. for(h = 0; h < MAX_HWIFS; h++) {
  367. ide_hwif_t *hwif = &ide_hwifs[h];
  368. hwif->chipset = ide_etrax100;
  369. hwif->tuneproc = &tune_e100_ide;
  370. hwif->dmaproc = &e100_dmaproc;
  371. hwif->ideproc = &e100_ideproc;
  372. }
  374. /* actually reset and configure the etrax100 ide/ata interface */
  376. *R_ATA_CTRL_DATA = 0;
  377. *R_ATA_TRANSFER_CNT = 0;
  378. *R_ATA_CONFIG = 0;
  380. genconfig_shadow = (genconfig_shadow & 
  381.     ~IO_MASK(R_GEN_CONFIG, dma2) &
  382.     ~IO_MASK(R_GEN_CONFIG, dma3) &
  383.     ~IO_MASK(R_GEN_CONFIG, ata)) | 
  384. ( IO_STATE( R_GEN_CONFIG, dma3, ata    ) |
  385.   IO_STATE( R_GEN_CONFIG, dma2, ata    ) |
  386.   IO_STATE( R_GEN_CONFIG, ata,  select ) );
  388. *R_GEN_CONFIG = genconfig_shadow;
  390.         /* pull the chosen /reset-line low */
  391.         
  392. #ifdef CONFIG_ETRAX_IDE_G27_RESET
  393.         REG_SHADOW_SET(R_PORT_G_DATA, port_g_data_shadow, 27, 0);
  394. #endif 
  395. #ifdef CONFIG_ETRAX_IDE_CSE1_16_RESET
  396.         init_ioremap();
  397.         REG_SHADOW_SET(port_cse1_addr, port_cse1_shadow, 16, 0);
  398. #endif
  399. #ifdef CONFIG_ETRAX_IDE_CSP0_8_RESET
  400.         init_ioremap();
  401.         REG_SHADOW_SET(port_csp0_addr, port_csp0_shadow, 8, 0);
  402. #endif
  403. #ifdef CONFIG_ETRAX_IDE_PB7_RESET  
  404. port_pb_dir_shadow = port_pb_dir_shadow | 
  405. IO_STATE(R_PORT_PB_DIR, dir7, output);
  406. *R_PORT_PB_DIR = port_pb_dir_shadow;
  407. REG_SHADOW_SET(R_PORT_PB_DATA, port_pb_data_shadow, 7, 1);
  408. #endif
  410. /* wait some */
  412. udelay(25);
  414. /* de-assert bus-reset */
  416. #ifdef CONFIG_ETRAX_IDE_CSE1_16_RESET
  417. REG_SHADOW_SET(port_cse1_addr, port_cse1_shadow, 16, 1);
  418. #endif
  419. #ifdef CONFIG_ETRAX_IDE_CSP0_8_RESET
  420. REG_SHADOW_SET(port_csp0_addr, port_csp0_shadow, 8, 1);
  421. #endif
  422. #ifdef CONFIG_ETRAX_IDE_G27_RESET
  423. REG_SHADOW_SET(R_PORT_G_DATA, port_g_data_shadow, 27, 1);
  424. #endif 
  426. /* make a dummy read to set the ata controller in a proper state */
  427. dummy = *R_ATA_STATUS_DATA;
  428.   
  429. *R_ATA_CONFIG = ( IO_FIELD( R_ATA_CONFIG, enable,     1 ) |
  430.   IO_FIELD( R_ATA_CONFIG, dma_strobe, ATA_DMA2_STROBE ) |
  431.   IO_FIELD( R_ATA_CONFIG, dma_hold,   ATA_DMA2_HOLD ) |
  432.   IO_FIELD( R_ATA_CONFIG, pio_setup,  ATA_PIO4_SETUP ) |
  433.   IO_FIELD( R_ATA_CONFIG, pio_strobe, ATA_PIO4_STROBE ) |
  434.   IO_FIELD( R_ATA_CONFIG, pio_hold,   ATA_PIO4_HOLD ) );
  436. *R_ATA_CTRL_DATA = ( IO_STATE( R_ATA_CTRL_DATA, rw,   read) |
  437.      IO_FIELD( R_ATA_CTRL_DATA, addr, 1   ) );
  439. while(*R_ATA_STATUS_DATA & IO_MASK(R_ATA_STATUS_DATA, busy)); /* wait for busy flag*/
  441. *R_IRQ_MASK0_SET = ( IO_STATE( R_IRQ_MASK0_SET, ata_irq0, set ) |
  442.      IO_STATE( R_IRQ_MASK0_SET, ata_irq1, set ) |
  443.      IO_STATE( R_IRQ_MASK0_SET, ata_irq2, set ) |
  444.      IO_STATE( R_IRQ_MASK0_SET, ata_irq3, set ) );
  446. printk("ide: waiting %d seconds for drives to regain consciousnessn",
  447.        CONFIG_ETRAX_IDE_DELAY);
  449. h = jiffies + (CONFIG_ETRAX_IDE_DELAY * HZ);
  450. while(time_before(jiffies, h)) /* nothing */ ;
  452. /* reset the dma channels we will use */
  454. RESET_DMA(ATA_TX_DMA_NBR);
  455. RESET_DMA(ATA_RX_DMA_NBR);
  456. WAIT_DMA(ATA_TX_DMA_NBR);
  457. WAIT_DMA(ATA_RX_DMA_NBR);
  459. }
  461. static etrax_dma_descr mydescr;
  463. /*
  464.  * The following routines are mainly used by the ATAPI drivers.
  465.  *
  466.  * These routines will round up any request for an odd number of bytes,
  467.  * so if an odd bytecount is specified, be sure that there's at least one
  468.  * extra byte allocated for the buffer.
  469.  */
  470. static void 
  471. e100_atapi_input_bytes (ide_drive_t *drive, void *buffer, unsigned int bytecount)
  472. {
  473. ide_ioreg_t data_reg = IDE_DATA_REG;
  475. D(printk("atapi_input_bytes, dreg 0x%x, buffer 0x%x, count %dn",
  476.  data_reg, buffer, bytecount));
  478. if(bytecount & 1) {
  479. printk("warning, odd bytecount in cdrom_in_bytes = %d.n", bytecount);
  480. bytecount++; /* to round off */
  481. }
  483. /* make sure the DMA channel is available */
  484. RESET_DMA(ATA_RX_DMA_NBR);
  485. WAIT_DMA(ATA_RX_DMA_NBR); 
  487. /* setup DMA descriptor */
  489. mydescr.sw_len = bytecount;
  490. mydescr.ctrl   = d_eol;
  491. mydescr.buf    = virt_to_phys(buffer);
  493. /* start the dma channel */
  495. *R_DMA_CH3_FIRST = virt_to_phys(&mydescr);
  496. *R_DMA_CH3_CMD   = IO_STATE(R_DMA_CH3_CMD, cmd, start);
  498. /* initiate a multi word dma read using PIO handshaking */
  500. *R_ATA_TRANSFER_CNT = IO_FIELD(R_ATA_TRANSFER_CNT, count, bytecount >> 1);
  502. *R_ATA_CTRL_DATA = data_reg |
  503. IO_STATE(R_ATA_CTRL_DATA, rw,       read) |
  504. IO_STATE(R_ATA_CTRL_DATA, src_dst,  dma) |
  505. IO_STATE(R_ATA_CTRL_DATA, handsh,   pio) |
  506. IO_STATE(R_ATA_CTRL_DATA, multi,    on) |
  507. IO_STATE(R_ATA_CTRL_DATA, dma_size, word);
  509. /* wait for completion */
  511. LED_DISK_READ(1);
  512. WAIT_DMA(ATA_RX_DMA_NBR);
  513. LED_DISK_READ(0);
  515. #if 0
  516.         /* old polled transfer code
  517.  * this should be moved into a new function that can do polled
  518.  * transfers if DMA is not available
  519.  */
  520.         
  521.         /* initiate a multi word read */
  522.         
  523.         *R_ATA_TRANSFER_CNT = wcount << 1;
  524.         
  525.         *R_ATA_CTRL_DATA = data_reg |
  526.                 IO_STATE(R_ATA_CTRL_DATA, rw,       read) |
  527.                 IO_STATE(R_ATA_CTRL_DATA, src_dst,  register) |
  528.                 IO_STATE(R_ATA_CTRL_DATA, handsh,   pio) |
  529.                 IO_STATE(R_ATA_CTRL_DATA, multi,    on) |
  530.                 IO_STATE(R_ATA_CTRL_DATA, dma_size, word);
  531.         
  532.         /* svinto has a latency until the busy bit actually is set */
  533.         
  534.         nop(); nop();
  535.         nop(); nop();
  536.         nop(); nop();
  537.         nop(); nop();
  538.         nop(); nop();
  539.         
  540.         /* unit should be busy during multi transfer */
  541.         while((status = *R_ATA_STATUS_DATA) & IO_MASK(R_ATA_STATUS_DATA, busy)) {
  542.                 while(!(status & IO_MASK(R_ATA_STATUS_DATA, dav)))
  543.                         status = *R_ATA_STATUS_DATA;
  544.                 *ptr++ = (unsigned short)(status & 0xffff);
  545.         }
  546. #endif
  547. }
  549. static void 
  550. e100_atapi_output_bytes (ide_drive_t *drive, void *buffer, unsigned int bytecount)
  551. {
  552. ide_ioreg_t data_reg = IDE_DATA_REG;
  554. D(printk("atapi_output_bytes, dreg 0x%x, buffer 0x%x, count %dn",
  555.  data_reg, buffer, bytecount));
  557. if(bytecount & 1) {
  558. printk("odd bytecount %d in atapi_out_bytes!n", bytecount);
  559. bytecount++;
  560. }
  562. /* make sure the DMA channel is available */
  563. RESET_DMA(ATA_TX_DMA_NBR);
  564. WAIT_DMA(ATA_TX_DMA_NBR); 
  566. /* setup DMA descriptor */
  568. mydescr.sw_len = bytecount;
  569. mydescr.ctrl   = d_eol;
  570. mydescr.buf    = virt_to_phys(buffer);
  572. /* start the dma channel */
  574. *R_DMA_CH2_FIRST = virt_to_phys(&mydescr);
  575. *R_DMA_CH2_CMD   = IO_STATE(R_DMA_CH2_CMD, cmd, start);
  577. /* initiate a multi word dma write using PIO handshaking */
  579. *R_ATA_TRANSFER_CNT = IO_FIELD(R_ATA_TRANSFER_CNT, count, bytecount >> 1);
  581. *R_ATA_CTRL_DATA = data_reg |
  582. IO_STATE(R_ATA_CTRL_DATA, rw,       write) |
  583. IO_STATE(R_ATA_CTRL_DATA, src_dst,  dma) |
  584. IO_STATE(R_ATA_CTRL_DATA, handsh,   pio) |
  585. IO_STATE(R_ATA_CTRL_DATA, multi,    on) |
  586. IO_STATE(R_ATA_CTRL_DATA, dma_size, word);
  588. /* wait for completion */
  590. LED_DISK_WRITE(1);
  591. WAIT_DMA(ATA_TX_DMA_NBR);
  592. LED_DISK_WRITE(0);
  594. #if 0
  595.         /* old polled write code - see comment in input_bytes */
  597. /* wait for busy flag */
  598.         while(*R_ATA_STATUS_DATA & IO_MASK(R_ATA_STATUS_DATA, busy)); 
  600.         /* initiate a multi word write */
  602.         *R_ATA_TRANSFER_CNT = bytecount >> 1;
  604.         ctrl = data_reg |
  605.                 IO_STATE(R_ATA_CTRL_DATA, rw,       write) |
  606.                 IO_STATE(R_ATA_CTRL_DATA, src_dst,  register) |
  607.                 IO_STATE(R_ATA_CTRL_DATA, handsh,   pio) |
  608.                 IO_STATE(R_ATA_CTRL_DATA, multi,    on) |
  609.                 IO_STATE(R_ATA_CTRL_DATA, dma_size, word);
  610.         
  611.         LED_DISK_WRITE(1);
  612.         
  613.         /* Etrax will set busy = 1 until the multi pio transfer has finished
  614.          * and tr_rdy = 1 after each succesful word transfer. 
  615.          * When the last byte has been transferred Etrax will first set tr_tdy = 1 
  616.          * and then busy = 0 (not in the same cycle). If we read busy before it
  617.          * has been set to 0 we will think that we should transfer more bytes 
  618.          * and then tr_rdy would be 0 forever. This is solved by checking busy
  619.          * in the inner loop.
  620.          */
  621.         
  622.         do {
  623.                 *R_ATA_CTRL_DATA = ctrl | *ptr++;
  624.                 while(!(*R_ATA_STATUS_DATA & IO_MASK(R_ATA_STATUS_DATA, tr_rdy)) &&
  625.                       (*R_ATA_STATUS_DATA & IO_MASK(R_ATA_STATUS_DATA, busy)));
  626.         } while(*R_ATA_STATUS_DATA & IO_MASK(R_ATA_STATUS_DATA, busy));
  628.         LED_DISK_WRITE(0);
  629. #endif  
  631. }
  633. /*
  634.  * This is used for most PIO data transfers *from* the IDE interface
  635.  */
  636. static void 
  637. e100_ide_input_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
  638. {
  639. e100_atapi_input_bytes(drive, buffer, wcount << 2);
  640. }
  642. /*
  643.  * This is used for most PIO data transfers *to* the IDE interface
  644.  */
  645. static void
  646. e100_ide_output_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
  647. {
  648. e100_atapi_output_bytes(drive, buffer, wcount << 2);
  649. }
  651. /*
  652.  * The multiplexor for ide_xxxput_data and atapi calls
  653.  */
  654. static void 
  655. e100_ideproc (ide_ide_action_t func, ide_drive_t *drive,
  656.       void *buffer, unsigned int length)
  657. {
  658. switch (func) {
  659. case ideproc_ide_input_data:
  660. e100_ide_input_data(drive, buffer, length);
  661. break;
  662. case ideproc_ide_output_data:
  663. e100_ide_input_data(drive, buffer, length);
  664. break;
  665. case ideproc_atapi_input_bytes:
  666. e100_atapi_input_bytes(drive, buffer, length);
  667. break;
  668. case ideproc_atapi_output_bytes:
  669. e100_atapi_output_bytes(drive, buffer, length);
  670. break;
  671. default:
  672. printk("e100_ideproc: unsupported func %d!n", func);
  673. break;
  674. }
  675. }
  677. /* we only have one DMA channel on the chip for ATA, so we can keep these statically */
  678. static etrax_dma_descr ata_descrs[MAX_DMA_DESCRS];
  679. static unsigned int ata_tot_size;
  681. /*
  682.  * e100_ide_build_dmatable() prepares a dma request.
  683.  * Returns 0 if all went okay, returns 1 otherwise.
  684.  */
  685. static int e100_ide_build_dmatable (ide_drive_t *drive)
  686. {
  687. struct request *rq = HWGROUP(drive)->rq;
  688. struct buffer_head *bh = rq->bh;
  689. unsigned long size, addr;
  690. unsigned int count = 0;
  692. ata_tot_size = 0;
  694. do {
  695. /*
  696.  * Determine addr and size of next buffer area.  We assume that
  697.  * individual virtual buffers are always composed linearly in
  698.  * physical memory.  For example, we assume that any 8kB buffer
  699.  * is always composed of two adjacent physical 4kB pages rather
  700.  * than two possibly non-adjacent physical 4kB pages.
  701.  */
  702. if (bh == NULL) {  /* paging and tape requests have (rq->bh == NULL) */
  703. addr = virt_to_phys (rq->buffer);
  704. size = rq->nr_sectors << 9;
  705. } else {
  706. /* group sequential buffers into one large buffer */
  707. addr = virt_to_phys (bh->b_data);
  708. size = bh->b_size;
  709. while ((bh = bh->b_reqnext) != NULL) {
  710. if ((addr + size) != virt_to_phys (bh->b_data))
  711. break;
  712. size += bh->b_size;
  713. }
  714. }
  716. /* did we run out of descriptors? */
  718. if(count >= MAX_DMA_DESCRS) {
  719. printk("%s: too few DMA descriptorsn", drive->name);
  720. return 1;
  721. }
  723. /* however, this case is more difficult - R_ATA_TRANSFER_CNT cannot be more
  724.    than 65536 words per transfer, so in that case we need to either 
  725.    1) use a DMA interrupt to re-trigger R_ATA_TRANSFER_CNT and continue with
  726.       the descriptors, or
  727.    2) simply do the request here, and get dma_intr to only ide_end_request on 
  728.       those blocks that were actually set-up for transfer.
  729. */
  731. if(ata_tot_size + size > 131072) {
  732. printk("too large total ATA DMA request, %d + %d!n", ata_tot_size, size);
  733. return 1;
  734. }
  736. /* If size > 65536 it has to be splitted into new descriptors. Since we don't handle 
  737.                    size > 131072 only one split is necessary */
  739. if(size > 65536) {
  740.           /* ok we want to do IO at addr, size bytes. set up a new descriptor entry */
  741.                         ata_descrs[count].sw_len = 0;  /* 0 means 65536, this is a 16-bit field */
  742.                         ata_descrs[count].ctrl = 0;
  743.                         ata_descrs[count].buf = addr;
  744.                         ata_descrs[count].next = virt_to_phys(&ata_descrs[count + 1]);
  745.                         count++;
  746.                         ata_tot_size += 65536;
  747.                         /* size and addr should refere to not handled data */
  748.                         size -= 65536;
  749.                         addr += 65536;
  750.                 }
  751. /* ok we want to do IO at addr, size bytes. set up a new descriptor entry */
  752.                 if(size == 65536) {
  753. ata_descrs[count].sw_len = 0;  /* 0 means 65536, this is a 16-bit field */
  754.                 } else {
  755. ata_descrs[count].sw_len = size;
  756.                 }
  757. ata_descrs[count].ctrl = 0;
  758. ata_descrs[count].buf = addr;
  759. ata_descrs[count].next = virt_to_phys(&ata_descrs[count + 1]);
  760. count++;
  761. ata_tot_size += size;
  763. } while (bh != NULL);
  765. if (count) {
  766. /* set the end-of-list flag on the last descriptor */
  767. ata_descrs[count - 1].ctrl |= d_eol;
  768. /* return and say all is ok */
  769. return 0;
  770. }
  772. printk("%s: empty DMA table?n", drive->name);
  773. return 1; /* let the PIO routines handle this weirdness */
  774. }
  776. static int config_drive_for_dma (ide_drive_t *drive)
  777. {
  778.         const char **list;
  779.         struct hd_driveid *id = drive->id;
  781.         if (id && (id->capability & 1)) {
  782.                 /* Enable DMA on any drive that supports mword2 DMA */
  783.                 if ((id->field_valid & 2) && (id->dma_mword & 0x404) == 0x404) {
  784.                         drive->using_dma = 1;
  785.                         return 0;               /* DMA enabled */
  786.                 }
  788.                 /* Consult the list of known "good" drives */
  789.                 list = good_dma_drives;
  790.                 while (*list) {
  791.                         if (!strcmp(*list++,id->model)) {
  792.                                 drive->using_dma = 1;
  793.                                 return 0;       /* DMA enabled */
  794.                         }
  795.                 }
  796.         }
  797.         return 1;       /* DMA not enabled */
  798. }
  800. /*
  801.  * etrax_dma_intr() is the handler for disk read/write DMA interrupts
  802.  */
  803. static ide_startstop_t etrax_dma_intr (ide_drive_t *drive)
  804. {
  805. int i, dma_stat;
  806. byte stat;
  808. LED_DISK_READ(0);
  809. LED_DISK_WRITE(0);
  811. dma_stat = HWIF(drive)->dmaproc(ide_dma_end, drive);
  812. stat = GET_STAT(); /* get drive status */
  813. if (OK_STAT(stat,DRIVE_READY,drive->bad_wstat|DRQ_STAT)) {
  814. if (!dma_stat) {
  815. struct request *rq;
  816. rq = HWGROUP(drive)->rq;
  817. for (i = rq->nr_sectors; i > 0;) {
  818. i -= rq->current_nr_sectors;
  819. ide_end_request(1, HWGROUP(drive));
  820. }
  821. return ide_stopped;
  822. }
  823. printk("%s: bad DMA statusn", drive->name);
  824. }
  825. return ide_error(drive, "dma_intr", stat);
  826. }
  828. /*
  829.  * e100_dmaproc() initiates/aborts DMA read/write operations on a drive.
  830.  *
  831.  * The caller is assumed to have selected the drive and programmed the drive's
  832.  * sector address using CHS or LBA.  All that remains is to prepare for DMA
  833.  * and then issue the actual read/write DMA/PIO command to the drive.
  834.  *
  835.  * For ATAPI devices, we just prepare for DMA and return. The caller should
  836.  * then issue the packet command to the drive and call us again with
  837.  * ide_dma_begin afterwards.
  838.  *
  839.  * Returns 0 if all went well.
  840.  * Returns 1 if DMA read/write could not be started, in which case
  841.  * the caller should revert to PIO for the current request.
  842.  */
  844. static int e100_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
  845. {
  846.         static unsigned int reading; /* static to support ide_dma_begin semantics */
  847. int atapi = 0;
  849. D(printk("e100_dmaproc func %dn", func));
  851.         switch (func) {
  852. case ide_dma_verbose:
  853. return 0;
  854.                 case ide_dma_check:
  855.                         return config_drive_for_dma (drive);
  856. case ide_dma_off:
  857. case ide_dma_off_quietly:
  858. /* ok.. we don't really need to do anything I think. */
  859. return 0;
  860.                 case ide_dma_write:
  861.                         reading = 0;
  862. break;
  863.                 case ide_dma_read:
  864. reading = 1;
  865.                         break;
  866.                 case ide_dma_begin:
  867. /* begin DMA, used by ATAPI devices which want to issue the 
  868.  * appropriate IDE command themselves.
  869.  *
  870.  * they have already called ide_dma_read/write to set the
  871.  * static reading flag, now they call ide_dma_begin to do
  872.  * the real stuff. we tell our code below not to issue
  873.  * any IDE commands itself and jump into it. 
  874.  */
  875. atapi++;
  876. goto dma_begin;
  877. case ide_dma_end: /* returns 1 on error, 0 otherwise */
  878. /* TODO: check if something went wrong with the DMA */
  879. return 0;
  881.                 default:
  882.                         printk("e100_dmaproc: unsupported func %dn", func);
  883.                         return 1;
  884.         }
  886. /* ATAPI-devices (not disks) first call ide_dma_read/write to set the direction
  887.  * then they call ide_dma_begin after they have issued the appropriate drive command
  888.  * themselves to actually start the chipset DMA. so we just return here if we're
  889.  * not a diskdrive.
  890.  */
  892.         if (drive->media != ide_disk)
  893.                 return 0;
  895.  dma_begin:
  897. if(reading) {
  899. RESET_DMA(ATA_RX_DMA_NBR); /* sometimes the DMA channel get stuck so we need to do this */
  900. WAIT_DMA(ATA_RX_DMA_NBR);
  902. /* set up the Etrax DMA descriptors */
  904. if(e100_ide_build_dmatable (drive))
  905. return 1;
  907. if(!atapi) {
  908. /* set the irq handler which will finish the request when DMA is done */
  910. ide_set_handler(drive, &etrax_dma_intr, WAIT_CMD, NULL);
  912. /* issue cmd to drive */
  914. OUT_BYTE(WIN_READDMA, IDE_COMMAND_REG);
  915. }
  917. /* begin DMA */
  919. /* need to do this before RX DMA due to a chip bug
  920.  * it is enough to just flush the part of the cache that
  921.  * corresponds to the buffers we start, but since HD transfers
  922.  * usually are more than 8 kB, it is easier to optimize for the
  923.  * normal case and just flush the entire cache. its the only
  924.  * way to be sure! (OB movie quote)
  925.  */
  926. flush_etrax_cache();  
  927. *R_DMA_CH3_FIRST = virt_to_phys(ata_descrs);
  928. *R_DMA_CH3_CMD   = IO_STATE(R_DMA_CH3_CMD, cmd, start);
  930. /* initiate a multi word dma read using DMA handshaking */
  932. *R_ATA_TRANSFER_CNT =
  933. IO_FIELD(R_ATA_TRANSFER_CNT, count, ata_tot_size >> 1);
  935. *R_ATA_CTRL_DATA =
  936. IO_FIELD(R_ATA_CTRL_DATA, data, IDE_DATA_REG) |
  937. IO_STATE(R_ATA_CTRL_DATA, rw,       read) |
  938. IO_STATE(R_ATA_CTRL_DATA, src_dst,  dma)  |
  939. IO_STATE(R_ATA_CTRL_DATA, handsh,   dma)  |
  940. IO_STATE(R_ATA_CTRL_DATA, multi,    on)   |
  941. IO_STATE(R_ATA_CTRL_DATA, dma_size, word);
  943. LED_DISK_READ(1);
  945. D(printk("dma read of %d bytes.n", ata_tot_size));
  946.  
  947. } else {
  948. /* writing */
  950. RESET_DMA(ATA_TX_DMA_NBR); /* sometimes the DMA channel get stuck so we need to do this */
  951. WAIT_DMA(ATA_TX_DMA_NBR);
  953. /* set up the Etrax DMA descriptors */
  955. if(e100_ide_build_dmatable (drive))
  956. return 1;
  958. if(!atapi) {
  959. /* set the irq handler which will finish the request when DMA is done */
  961. ide_set_handler(drive, &etrax_dma_intr, WAIT_CMD, NULL);
  963. /* issue cmd to drive */
  965. OUT_BYTE(WIN_WRITEDMA, IDE_COMMAND_REG);
  966. }
  968. /* begin DMA */
  970. *R_DMA_CH2_FIRST = virt_to_phys(ata_descrs);
  971. *R_DMA_CH2_CMD   = IO_STATE(R_DMA_CH2_CMD, cmd, start);
  973. /* initiate a multi word dma write using DMA handshaking */
  975. *R_ATA_TRANSFER_CNT =
  976. IO_FIELD(R_ATA_TRANSFER_CNT, count, ata_tot_size >> 1);
  978. *R_ATA_CTRL_DATA =
  979. IO_FIELD(R_ATA_CTRL_DATA, data,     IDE_DATA_REG) |
  980. IO_STATE(R_ATA_CTRL_DATA, rw,       write) |
  981. IO_STATE(R_ATA_CTRL_DATA, src_dst,  dma) |
  982. IO_STATE(R_ATA_CTRL_DATA, handsh,   dma) |
  983. IO_STATE(R_ATA_CTRL_DATA, multi,    on) |
  984. IO_STATE(R_ATA_CTRL_DATA, dma_size, word);
  986. LED_DISK_WRITE(1);
  988. D(printk("dma write of %d bytes.n", ata_tot_size));
  989. }
  991. /* DMA started successfully */
  992. return 0;
  993. }
  995. /* ide.c calls this, but we don't need to do anything particular */
  997. int ide_release_dma (ide_hwif_t *hwif)
  998. {
  999. return 1;
  1000. }