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

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

嵌入式Linux

开发平台：

Unix_Linux

ide-pmac.c：源码内容
  1. /*
  2.  * linux/drivers/ide/ide-pmac.c
  3.  *
  4.  * Support for IDE interfaces on PowerMacs.
  5.  * These IDE interfaces are memory-mapped and have a DBDMA channel
  6.  * for doing DMA.
  7.  *
  8.  *  Copyright (C) 1998-2001 Paul Mackerras & Ben. Herrenschmidt
  9.  *
  10.  *  This program is free software; you can redistribute it and/or
  11.  *  modify it under the terms of the GNU General Public License
  12.  *  as published by the Free Software Foundation; either version
  13.  *  2 of the License, or (at your option) any later version.
  14.  *
  15.  * Some code taken from drivers/ide/ide-dma.c:
  16.  *
  17.  *  Copyright (c) 1995-1998  Mark Lord
  18.  *
  19.  */
  20. #include <linux/config.h>
  21. #include <linux/types.h>
  22. #include <linux/kernel.h>
  23. #include <linux/sched.h>
  24. #include <linux/init.h>
  25. #include <linux/delay.h>
  26. #include <linux/ide.h>
  27. #include <linux/notifier.h>
  28. #include <linux/reboot.h>
  29. #include <asm/prom.h>
  30. #include <asm/io.h>
  31. #include <asm/dbdma.h>
  32. #include <asm/ide.h>
  33. #include <asm/mediabay.h>
  34. #include <asm/machdep.h>
  35. #include <asm/pmac_feature.h>
  36. #include <asm/sections.h>
  37. #include <asm/irq.h>
  38. #ifdef CONFIG_PMAC_PBOOK
  39. #include <linux/adb.h>
  40. #include <linux/pmu.h>
  41. #endif
  42. #include "ide_modes.h"
  44. extern char *ide_dmafunc_verbose(ide_dma_action_t dmafunc);
  45. extern void ide_do_request(ide_hwgroup_t *hwgroup, int masked_irq);
  47. #define IDE_PMAC_DEBUG
  49. #define DMA_WAIT_TIMEOUT 500
  51. struct pmac_ide_hwif {
  52. ide_ioreg_t regbase;
  53. int irq;
  54. int kind;
  55. int aapl_bus_id;
  56. struct device_node* node;
  57. u32 timings[2];
  58. struct resource* reg_resource;
  59. #ifdef CONFIG_BLK_DEV_IDEDMA_PMAC
  60. volatile struct dbdma_regs* dma_regs;
  61. struct dbdma_cmd* dma_table;
  62. struct resource* dma_resource;
  63. #endif
  65. } pmac_ide[MAX_HWIFS] __pmacdata;
  67. static int pmac_ide_count;
  69. enum {
  70. controller_ohare, /* OHare based */
  71. controller_heathrow, /* Heathrow/Paddington */
  72. controller_kl_ata3, /* KeyLargo ATA-3 */
  73. controller_kl_ata4, /* KeyLargo ATA-4 */
  74. controller_kl_ata4_80 /* KeyLargo ATA-4 with 80 conductor cable */
  75. };
  77. /*
  78.  * Extra registers, both 32-bit little-endian
  79.  */
  80. #define IDE_TIMING_CONFIG 0x200
  81. #define IDE_INTERRUPT 0x300
  83. /*
  84.  * Timing configuration register definitions
  85.  */
  87. /* Number of IDE_SYSCLK_NS ticks, argument is in nanoseconds */
  88. #define SYSCLK_TICKS(t) (((t) + IDE_SYSCLK_NS - 1) / IDE_SYSCLK_NS)
  89. #define SYSCLK_TICKS_66(t) (((t) + IDE_SYSCLK_66_NS - 1) / IDE_SYSCLK_66_NS)
  90. #define IDE_SYSCLK_NS 30 /* 33Mhz cell */
  91. #define IDE_SYSCLK_66_NS 15 /* 66Mhz cell */
  93. /* 66Mhz cell, found in KeyLargo. Can do ultra mode 0 to 2 on
  94.  * 40 connector cable and to 4 on 80 connector one.
  95.  * Clock unit is 15ns (66Mhz)
  96.  * 
  97.  * 3 Values can be programmed:
  98.  *  - Write data setup, which appears to match the cycle time. They
  99.  *    also call it DIOW setup.
  100.  *  - Ready to pause time (from spec)
  101.  *  - Address setup. That one is weird. I don't see where exactly
  102.  *    it fits in UDMA cycles, I got it's name from an obscure piece
  103.  *    of commented out code in Darwin. They leave it to 0, we do as
  104.  *    well, despite a comment that would lead to think it has a
  105.  *    min value of 45ns.
  106.  * Apple also add 60ns to the write data setup (or cycle time ?) on
  107.  * reads. I can't explain that, I tried it and it broke everything
  108.  * here.
  109.  */
  110. #define TR_66_UDMA_MASK 0xfff00000
  111. #define TR_66_UDMA_EN 0x00100000 /* Enable Ultra mode for DMA */
  112. #define TR_66_UDMA_ADDRSETUP_MASK 0xe0000000 /* Address setup */
  113. #define TR_66_UDMA_ADDRSETUP_SHIFT 29
  114. #define TR_66_UDMA_RDY2PAUS_MASK 0x1e000000 /* Ready 2 pause time */
  115. #define TR_66_UDMA_RDY2PAUS_SHIFT 25
  116. #define TR_66_UDMA_WRDATASETUP_MASK 0x01e00000 /* Write data setup time */
  117. #define TR_66_UDMA_WRDATASETUP_SHIFT 21
  118. #define TR_66_MDMA_MASK 0x000ffc00
  119. #define TR_66_MDMA_RECOVERY_MASK 0x000f8000
  120. #define TR_66_MDMA_RECOVERY_SHIFT 15
  121. #define TR_66_MDMA_ACCESS_MASK 0x00007c00
  122. #define TR_66_MDMA_ACCESS_SHIFT 10
  123. #define TR_66_PIO_MASK 0x000003ff
  124. #define TR_66_PIO_RECOVERY_MASK 0x000003e0
  125. #define TR_66_PIO_RECOVERY_SHIFT 5
  126. #define TR_66_PIO_ACCESS_MASK 0x0000001f
  127. #define TR_66_PIO_ACCESS_SHIFT 0
  129. /* 33Mhz cell, found in OHare, Heathrow (& Paddington) and KeyLargo
  130.  * Can do pio & mdma modes, clock unit is 30ns (33Mhz)
  131.  * 
  132.  * The access time and recovery time can be programmed. Some older
  133.  * Darwin code base limit OHare to 150ns cycle time. I decided to do
  134.  * the same here fore safety against broken old hardware ;)
  135.  * The HalfTick bit, when set, adds half a clock (15ns) to the access
  136.  * time and removes one from recovery. It's not supported on KeyLargo
  137.  * implementation afaik. The E bit appears to be set for PIO mode 0 and
  138.  * is used to reach long timings used in this mode.
  139.  */
  140. #define TR_33_MDMA_MASK 0x003ff800
  141. #define TR_33_MDMA_RECOVERY_MASK 0x001f0000
  142. #define TR_33_MDMA_RECOVERY_SHIFT 16
  143. #define TR_33_MDMA_ACCESS_MASK 0x0000f800
  144. #define TR_33_MDMA_ACCESS_SHIFT 11
  145. #define TR_33_MDMA_HALFTICK 0x00200000
  146. #define TR_33_PIO_MASK 0x000007ff
  147. #define TR_33_PIO_E 0x00000400
  148. #define TR_33_PIO_RECOVERY_MASK 0x000003e0
  149. #define TR_33_PIO_RECOVERY_SHIFT 5
  150. #define TR_33_PIO_ACCESS_MASK 0x0000001f
  151. #define TR_33_PIO_ACCESS_SHIFT 0
  153. /*
  154.  * Interrupt register definitions
  155.  */
  156. #define IDE_INTR_DMA 0x80000000
  157. #define IDE_INTR_DEVICE 0x40000000
  159. #ifdef CONFIG_BLK_DEV_IDEDMA_PMAC
  161. /* Rounded Multiword DMA timings
  162.  * 
  163.  * I gave up finding a generic formula for all controller
  164.  * types and instead, built tables based on timing values
  165.  * used by Apple in Darwin's implementation.
  166.  */
  167. struct mdma_timings_t {
  168. int accessTime;
  169. int recoveryTime;
  170. int cycleTime;
  171. };
  173. struct mdma_timings_t mdma_timings_33[] __pmacdata =
  174. {
  175.     { 240, 240, 480 },
  176.     { 180, 180, 360 },
  177.     { 135, 135, 270 },
  178.     { 120, 120, 240 },
  179.     { 105, 105, 210 },
  180.     {  90,  90, 180 },
  181.     {  75,  75, 150 },
  182.     {  75,  45, 120 },
  183.     {   0,   0,   0 }
  184. };
  186. struct mdma_timings_t mdma_timings_33k[] __pmacdata =
  187. {
  188.     { 240, 240, 480 },
  189.     { 180, 180, 360 },
  190.     { 150, 150, 300 },
  191.     { 120, 120, 240 },
  192.     {  90, 120, 210 },
  193.     {  90,  90, 180 },
  194.     {  90,  60, 150 },
  195.     {  90,  30, 120 },
  196.     {   0,   0,   0 }
  197. };
  199. struct mdma_timings_t mdma_timings_66[] __pmacdata =
  200. {
  201.     { 240, 240, 480 },
  202.     { 180, 180, 360 },
  203.     { 135, 135, 270 },
  204.     { 120, 120, 240 },
  205.     { 105, 105, 210 },
  206.     {  90,  90, 180 },
  207.     {  90,  75, 165 },
  208.     {  75,  45, 120 },
  209.     {   0,   0,   0 }
  210. };
  212. /* Ultra DMA timings (rounded) */
  213. struct {
  214. int addrSetup; /* ??? */
  215. int rdy2pause;
  216. int wrDataSetup;
  217. } udma_timings[] __pmacdata =
  218. {
  219.     {   0, 180,  120 }, /* Mode 0 */
  220.     {   0, 150,  90 }, /*      1 */
  221.     {   0, 120,  60 }, /*      2 */
  222.     {   0, 90,   45 }, /*      3 */
  223.     {   0, 90,   30 } /*      4 */
  224. };
  226. /* allow up to 256 DBDMA commands per xfer */
  227. #define MAX_DCMDS 256
  229. /* Wait 2s for disk to answer on IDE bus after
  230.  * enable operation.
  231.  * NOTE: There is at least one case I know of a disk that needs about 10sec
  232.  *       before anwering on the bus. I beleive we could add a kernel command
  233.  *       line arg to override this delay for such cases.
  234.  */
  235. #define IDE_WAKEUP_DELAY_MS 2000
  237. static void pmac_ide_setup_dma(struct device_node *np, int ix);
  238. static int pmac_ide_dmaproc(ide_dma_action_t func, ide_drive_t *drive);
  239. static int pmac_ide_build_dmatable(ide_drive_t *drive, int ix, int wr);
  240. static int pmac_ide_tune_chipset(ide_drive_t *drive, byte speed);
  241. static void pmac_ide_tuneproc(ide_drive_t *drive, byte pio);
  242. static void pmac_ide_selectproc(ide_drive_t *drive);
  244. #endif /* CONFIG_BLK_DEV_IDEDMA_PMAC */
  246. #ifdef CONFIG_PMAC_PBOOK
  247. static int idepmac_notify_sleep(struct pmu_sleep_notifier *self, int when);
  248. struct pmu_sleep_notifier idepmac_sleep_notifier = {
  249. idepmac_notify_sleep, SLEEP_LEVEL_BLOCK,
  250. };
  251. #endif /* CONFIG_PMAC_PBOOK */
  253. static int pmac_ide_notify_reboot(struct notifier_block *, unsigned long, void *);
  254. static struct notifier_block pmac_ide_reboot_notifier = {
  255. pmac_ide_notify_reboot,
  256. NULL,
  257. 0
  258. };
  260. static int __pmac
  261. pmac_ide_find(ide_drive_t *drive)
  262. {
  263. ide_hwif_t *hwif = HWIF(drive);
  264. ide_ioreg_t base;
  265. int i;
  267. for (i=0; i<pmac_ide_count; i++) {
  268. base = pmac_ide[i].regbase;
  269. if (base && base == hwif->io_ports[0])
  270. return i;
  271. }
  272. return -1;
  273. }
  275. /*
  276.  * N.B. this can't be an initfunc, because the media-bay task can
  277.  * call ide_[un]register at any time.
  278.  */
  279. void __pmac
  280. pmac_ide_init_hwif_ports(hw_regs_t *hw,
  281.       ide_ioreg_t data_port, ide_ioreg_t ctrl_port,
  282.       int *irq)
  283. {
  284. int i, ix;
  286. if (data_port == 0)
  287. return;
  289. for (ix = 0; ix < MAX_HWIFS; ++ix)
  290. if (data_port == pmac_ide[ix].regbase)
  291. break;
  293. if (ix >= MAX_HWIFS) {
  294. /* Probably a PCI interface... */
  295. for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; ++i)
  296. hw->io_ports[i] = data_port + i - IDE_DATA_OFFSET;
  297. hw->io_ports[IDE_CONTROL_OFFSET] = ctrl_port;
  298. return;
  299. }
  301. for (i = 0; i < 8; ++i)
  302. hw->io_ports[i] = data_port + i * 0x10;
  303. hw->io_ports[8] = data_port + 0x160;
  305. if (irq != NULL)
  306. *irq = pmac_ide[ix].irq;
  308. ide_hwifs[ix].tuneproc = pmac_ide_tuneproc;
  309. ide_hwifs[ix].selectproc = pmac_ide_selectproc;
  310. ide_hwifs[ix].speedproc = &pmac_ide_tune_chipset;
  311. if (pmac_ide[ix].dma_regs && pmac_ide[ix].dma_table) {
  312. ide_hwifs[ix].dmaproc = &pmac_ide_dmaproc;
  313. #ifdef CONFIG_BLK_DEV_IDEDMA_PMAC_AUTO
  314. if (!noautodma)
  315. ide_hwifs[ix].autodma = 1;
  316. #endif
  317. }
  318. }
  320. #if 0
  321. /* This one could be later extended to handle CMD IDE and be used by some kind
  322.  * of /proc interface. I want to be able to get the devicetree path of a block
  323.  * device for yaboot configuration
  324.  */
  325. struct device_node*
  326. pmac_ide_get_devnode(ide_drive_t *drive)
  327. {
  328. int i = pmac_ide_find(drive);
  329. if (i < 0)
  330. return NULL;
  331. return pmac_ide[i].node;
  332. }
  333. #endif
  335. /* Setup timings for the selected drive (master/slave). I still need to verify if this
  336.  * is enough, I beleive selectproc will be called whenever an IDE command is started,
  337.  * but... */
  338. static void __pmac
  339. pmac_ide_selectproc(ide_drive_t *drive)
  340. {
  341. int i = pmac_ide_find(drive);
  342. if (i < 0)
  343. return;
  345. if (drive->select.b.unit & 0x01)
  346. out_le32((unsigned *)(IDE_DATA_REG + IDE_TIMING_CONFIG + _IO_BASE),
  347. pmac_ide[i].timings[1]);
  348. else
  349. out_le32((unsigned *)(IDE_DATA_REG + IDE_TIMING_CONFIG + _IO_BASE),
  350. pmac_ide[i].timings[0]);
  351. (void)in_le32((unsigned *)(IDE_DATA_REG + IDE_TIMING_CONFIG + _IO_BASE));
  352. }
  355. /* Note: We don't use the generic routine here because for some
  356.  * yet unexplained reasons, it cause some media-bay CD-ROMs to
  357.  * lockup the bus. Strangely, this new version of the code is
  358.  * almost identical to the generic one and works, I've not yet
  359.  * managed to figure out what bit is causing the lockup in the
  360.  * generic code, possibly a timing issue...
  361.  * 
  362.  * --BenH
  363.  */
  364. static int __pmac
  365. wait_for_ready(ide_drive_t *drive)
  366. {
  367. /* Timeout bumped for some powerbooks */
  368. int timeout = 2000;
  369. byte stat;
  371. while(--timeout) {
  372. stat = GET_STAT();
  373. if(!(stat & BUSY_STAT)) {
  374. if (drive->ready_stat == 0)
  375. break;
  376. else if((stat & drive->ready_stat) || (stat & ERR_STAT))
  377. break;
  378. }
  379. mdelay(1);
  380. }
  381. if((stat & ERR_STAT) || timeout <= 0) {
  382. if (stat & ERR_STAT) {
  383. printk(KERN_ERR "ide_pmac: wait_for_ready, error status: %xn", stat);
  384. }
  385. return 1;
  386. }
  387. return 0;
  388. }
  390. static int __pmac
  391. pmac_ide_do_setfeature(ide_drive_t *drive, byte command)
  392. {
  393. int result = 1;
  394. unsigned long flags;
  395. ide_hwif_t *hwif = HWIF(drive);
  397. disable_irq(hwif->irq); /* disable_irq_nosync ?? */
  398. udelay(1);
  399. SELECT_DRIVE(HWIF(drive), drive);
  400. SELECT_MASK(HWIF(drive), drive, 0);
  401. udelay(1);
  402. (void)GET_STAT(); /* Get rid of pending error state */
  403. if(wait_for_ready(drive)) {
  404. printk(KERN_ERR "pmac_ide_do_setfeature disk not ready before SET_FEATURE!n");
  405. goto out;
  406. }
  407. udelay(10);
  408. OUT_BYTE(drive->ctl | 2, IDE_CONTROL_REG);
  409. OUT_BYTE(command, IDE_NSECTOR_REG);
  410. OUT_BYTE(SETFEATURES_XFER, IDE_FEATURE_REG);
  411. OUT_BYTE(WIN_SETFEATURES, IDE_COMMAND_REG);
  412. udelay(1);
  413. __save_flags(flags); /* local CPU only */
  414. ide__sti(); /* local CPU only -- for jiffies */
  415. result = wait_for_ready(drive);
  416. __restore_flags(flags); /* local CPU only */
  417. OUT_BYTE(drive->ctl, IDE_CONTROL_REG);
  418. if (result)
  419. printk(KERN_ERR "pmac_ide_do_setfeature disk not ready after SET_FEATURE !n");
  420. out:
  421. SELECT_MASK(HWIF(drive), drive, 0);
  422. if (result == 0) {
  423. drive->id->dma_ultra &= ~0xFF00;
  424. drive->id->dma_mword &= ~0x0F00;
  425. drive->id->dma_1word &= ~0x0F00;
  426. switch(command) {
  427. case XFER_UDMA_7:   drive->id->dma_ultra |= 0x8080; break;
  428. case XFER_UDMA_6:   drive->id->dma_ultra |= 0x4040; break;
  429. case XFER_UDMA_5:   drive->id->dma_ultra |= 0x2020; break;
  430. case XFER_UDMA_4:   drive->id->dma_ultra |= 0x1010; break;
  431. case XFER_UDMA_3:   drive->id->dma_ultra |= 0x0808; break;
  432. case XFER_UDMA_2:   drive->id->dma_ultra |= 0x0404; break;
  433. case XFER_UDMA_1:   drive->id->dma_ultra |= 0x0202; break;
  434. case XFER_UDMA_0:   drive->id->dma_ultra |= 0x0101; break;
  435. case XFER_MW_DMA_2: drive->id->dma_mword |= 0x0404; break;
  436. case XFER_MW_DMA_1: drive->id->dma_mword |= 0x0202; break;
  437. case XFER_MW_DMA_0: drive->id->dma_mword |= 0x0101; break;
  438. case XFER_SW_DMA_2: drive->id->dma_1word |= 0x0404; break;
  439. case XFER_SW_DMA_1: drive->id->dma_1word |= 0x0202; break;
  440. case XFER_SW_DMA_0: drive->id->dma_1word |= 0x0101; break;
  441. default: break;
  442. }
  443. }
  444. enable_irq(hwif->irq);
  445. return result;
  446. }
  448. /* Calculate PIO timings */
  449. static void __pmac
  450. pmac_ide_tuneproc(ide_drive_t *drive, byte pio)
  451. {
  452. ide_pio_data_t d;
  453. int i;
  454. u32 *timings;
  455. unsigned accessTicks, recTicks;
  456. unsigned accessTime, recTime;
  458. i = pmac_ide_find(drive);
  459. if (i < 0)
  460. return;
  462. pio = ide_get_best_pio_mode(drive, pio, 4, &d);
  463. accessTicks = SYSCLK_TICKS(ide_pio_timings[pio].active_time);
  464. if (drive->select.b.unit & 0x01)
  465. timings = &pmac_ide[i].timings[1];
  466. else
  467. timings = &pmac_ide[i].timings[0];
  469. recTime = d.cycle_time - ide_pio_timings[pio].active_time
  470. - ide_pio_timings[pio].setup_time;
  471. recTime = max(recTime, 150U);
  472. accessTime = ide_pio_timings[pio].active_time;
  473. accessTime = max(accessTime, 150U);
  474. if (pmac_ide[i].kind == controller_kl_ata4 ||
  475. pmac_ide[i].kind == controller_kl_ata4_80) {
  476. /* 66Mhz cell */
  477. accessTicks = SYSCLK_TICKS_66(accessTime);
  478. accessTicks = min(accessTicks, 0x1fU);
  479. recTicks = SYSCLK_TICKS_66(recTime);
  480. recTicks = min(recTicks, 0x1fU);
  481. *timings = ((*timings) & ~TR_66_PIO_MASK) |
  482. (accessTicks << TR_66_PIO_ACCESS_SHIFT) |
  483. (recTicks << TR_66_PIO_RECOVERY_SHIFT);
  484. } else {
  485. /* 33Mhz cell */
  486. int ebit = 0;
  487. accessTicks = SYSCLK_TICKS(accessTime);
  488. accessTicks = min(accessTicks, 0x1fU);
  489. accessTicks = max(accessTicks, 4U);
  490. recTicks = SYSCLK_TICKS(recTime);
  491. recTicks = min(recTicks, 0x1fU);
  492. recTicks = max(recTicks, 5U) - 4;
  493. if (recTicks > 9) {
  494. recTicks--; /* guess, but it's only for PIO0, so... */
  495. ebit = 1;
  496. }
  497. *timings = ((*timings) & ~TR_33_PIO_MASK) |
  498. (accessTicks << TR_33_PIO_ACCESS_SHIFT) |
  499. (recTicks << TR_33_PIO_RECOVERY_SHIFT);
  500. if (ebit)
  501. *timings |= TR_33_PIO_E;
  502. }
  504. #ifdef IDE_PMAC_DEBUG
  505. printk(KERN_ERR "ide_pmac: Set PIO timing for mode %d, reg: 0x%08xn",
  506. pio,  *timings);
  507. #endif
  509. if (drive->select.all == IN_BYTE(IDE_SELECT_REG))
  510. pmac_ide_selectproc(drive);
  511. }
  513. #ifdef CONFIG_BLK_DEV_IDEDMA_PMAC
  514. static int __pmac
  515. set_timings_udma(u32 *timings, byte speed)
  516. {
  517. unsigned rdyToPauseTicks, wrDataSetupTicks, addrTicks;
  519. rdyToPauseTicks = SYSCLK_TICKS_66(udma_timings[speed & 0xf].rdy2pause);
  520. wrDataSetupTicks = SYSCLK_TICKS_66(udma_timings[speed & 0xf].wrDataSetup);
  521. addrTicks = SYSCLK_TICKS_66(udma_timings[speed & 0xf].addrSetup);
  523. *timings = ((*timings) & ~(TR_66_UDMA_MASK | TR_66_MDMA_MASK)) |
  524. (wrDataSetupTicks << TR_66_UDMA_WRDATASETUP_SHIFT) | 
  525. (rdyToPauseTicks << TR_66_UDMA_RDY2PAUS_SHIFT) |
  526. (addrTicks <<TR_66_UDMA_ADDRSETUP_SHIFT) |
  527. TR_66_UDMA_EN;
  528. #ifdef IDE_PMAC_DEBUG
  529. printk(KERN_ERR "ide_pmac: Set UDMA timing for mode %d, reg: 0x%08xn",
  530. speed & 0xf,  *timings);
  531. #endif
  533. return 0;
  534. }
  536. static int __pmac
  537. set_timings_mdma(int intf_type, u32 *timings, byte speed, int drive_cycle_time)
  538. {
  539. int cycleTime, accessTime, recTime;
  540. unsigned accessTicks, recTicks;
  541. struct mdma_timings_t* tm;
  542. int i;
  544. /* Get default cycle time for mode */
  545. switch(speed & 0xf) {
  546. case 0: cycleTime = 480; break;
  547. case 1: cycleTime = 150; break;
  548. case 2: cycleTime = 120; break;
  549. default:
  550. return -1;
  551. }
  552. /* Adjust for drive */
  553. if (drive_cycle_time && drive_cycle_time > cycleTime)
  554. cycleTime = drive_cycle_time;
  555. /* OHare limits according to some old Apple sources */
  556. if ((intf_type == controller_ohare) && (cycleTime < 150))
  557. cycleTime = 150;
  558. /* Get the proper timing array for this controller */
  559. switch(intf_type) {
  560. case controller_kl_ata4:
  561. case controller_kl_ata4_80:
  562. tm = mdma_timings_66;
  563. break;
  564. case controller_kl_ata3:
  565. tm = mdma_timings_33k;
  566. break;
  567. default:
  568. tm = mdma_timings_33;
  569. break;
  570. }
  571. /* Lookup matching access & recovery times */
  572. i = -1;
  573. for (;;) {
  574. if (tm[i+1].cycleTime < cycleTime)
  575. break;
  576. i++;
  577. }
  578. if (i < 0)
  579. return -1;
  580. cycleTime = tm[i].cycleTime;
  581. accessTime = tm[i].accessTime;
  582. recTime = tm[i].recoveryTime;
  584. #ifdef IDE_PMAC_DEBUG
  585. printk(KERN_ERR "ide_pmac: MDMA, cycleTime: %d, accessTime: %d, recTime: %dn",
  586. cycleTime, accessTime, recTime);
  587. #endif
  588. if (intf_type == controller_kl_ata4 || intf_type == controller_kl_ata4_80) {
  589. /* 66Mhz cell */
  590. accessTicks = SYSCLK_TICKS_66(accessTime);
  591. accessTicks = min(accessTicks, 0x1fU);
  592. accessTicks = max(accessTicks, 0x1U);
  593. recTicks = SYSCLK_TICKS_66(recTime);
  594. recTicks = min(recTicks, 0x1fU);
  595. recTicks = max(recTicks, 0x3U);
  596. /* Clear out mdma bits and disable udma */
  597. *timings = ((*timings) & ~(TR_66_MDMA_MASK | TR_66_UDMA_MASK)) |
  598. (accessTicks << TR_66_MDMA_ACCESS_SHIFT) |
  599. (recTicks << TR_66_MDMA_RECOVERY_SHIFT);
  600. } else if (intf_type == controller_kl_ata3) {
  601. /* 33Mhz cell on KeyLargo */
  602. accessTicks = SYSCLK_TICKS(accessTime);
  603. accessTicks = max(accessTicks, 1U);
  604. accessTicks = min(accessTicks, 0x1fU);
  605. accessTime = accessTicks * IDE_SYSCLK_NS;
  606. recTicks = SYSCLK_TICKS(recTime);
  607. recTicks = max(recTicks, 1U);
  608. recTicks = min(recTicks, 0x1fU);
  609. *timings = ((*timings) & ~TR_33_MDMA_MASK) |
  610. (accessTicks << TR_33_MDMA_ACCESS_SHIFT) |
  611. (recTicks << TR_33_MDMA_RECOVERY_SHIFT);
  612. } else {
  613. /* 33Mhz cell on others */
  614. int halfTick = 0;
  615. int origAccessTime = accessTime;
  616. int origRecTime = recTime;
  618. accessTicks = SYSCLK_TICKS(accessTime);
  619. accessTicks = max(accessTicks, 1U);
  620. accessTicks = min(accessTicks, 0x1fU);
  621. accessTime = accessTicks * IDE_SYSCLK_NS;
  622. recTicks = SYSCLK_TICKS(recTime);
  623. recTicks = max(recTicks, 2U) - 1;
  624. recTicks = min(recTicks, 0x1fU);
  625. recTime = (recTicks + 1) * IDE_SYSCLK_NS;
  626. if ((accessTicks > 1) &&
  627.     ((accessTime - IDE_SYSCLK_NS/2) >= origAccessTime) &&
  628.     ((recTime - IDE_SYSCLK_NS/2) >= origRecTime)) {
  629.              halfTick = 1;
  630. accessTicks--;
  631. }
  632. *timings = ((*timings) & ~TR_33_MDMA_MASK) |
  633. (accessTicks << TR_33_MDMA_ACCESS_SHIFT) |
  634. (recTicks << TR_33_MDMA_RECOVERY_SHIFT);
  635. if (halfTick)
  636. *timings |= TR_33_MDMA_HALFTICK;
  637. }
  638. #ifdef IDE_PMAC_DEBUG
  639. printk(KERN_ERR "ide_pmac: Set MDMA timing for mode %d, reg: 0x%08xn",
  640. speed & 0xf,  *timings);
  641. #endif
  642. return 0;
  643. }
  644. #endif /* #ifdef CONFIG_BLK_DEV_IDEDMA_PMAC */
  646. /* You may notice we don't use this function on normal operation,
  647.  * our, normal mdma function is supposed to be more precise
  648.  */
  649. static int __pmac
  650. pmac_ide_tune_chipset (ide_drive_t *drive, byte speed)
  651. {
  652. int intf = pmac_ide_find(drive);
  653. int unit = (drive->select.b.unit & 0x01);
  654. int ret = 0;
  655. u32 *timings;
  657. if (intf < 0)
  658. return 1;
  660. timings = &pmac_ide[intf].timings[unit];
  662. switch(speed) {
  663. #ifdef CONFIG_BLK_DEV_IDEDMA_PMAC
  664. case XFER_UDMA_4:
  665. case XFER_UDMA_3:
  666. if (pmac_ide[intf].kind != controller_kl_ata4_80)
  667. return 1;
  668. case XFER_UDMA_2:
  669. case XFER_UDMA_1:
  670. case XFER_UDMA_0:
  671. if (pmac_ide[intf].kind != controller_kl_ata4 &&
  672. pmac_ide[intf].kind != controller_kl_ata4_80)
  673. return 1;
  674. ret = set_timings_udma(timings, speed);
  675. break;
  676. case XFER_MW_DMA_2:
  677. case XFER_MW_DMA_1:
  678. case XFER_MW_DMA_0:
  679. ret = set_timings_mdma(pmac_ide[intf].kind, timings, speed, 0);
  680. break;
  681. case XFER_SW_DMA_2:
  682. case XFER_SW_DMA_1:
  683. case XFER_SW_DMA_0:
  684. return 1;
  685. #endif /* CONFIG_BLK_DEV_IDEDMA_PMAC */
  686. case XFER_PIO_4:
  687. case XFER_PIO_3:
  688. case XFER_PIO_2:
  689. case XFER_PIO_1:
  690. case XFER_PIO_0:
  691. pmac_ide_tuneproc(drive, speed & 0x07);
  692. break;
  693. default:
  694. ret = 1;
  695. }
  696. if (ret)
  697. return ret;
  699. ret = pmac_ide_do_setfeature(drive, speed);
  700. if (ret)
  701. return ret;
  703. pmac_ide_selectproc(drive);
  704. drive->current_speed = speed;
  706. return 0;
  707. }
  709. static void __pmac
  710. sanitize_timings(int i)
  711. {
  712. unsigned value;
  714. switch(pmac_ide[i].kind) {
  715. case controller_kl_ata4:
  716. case controller_kl_ata4_80:
  717. value = 0x0008438c;
  718. break;
  719. case controller_kl_ata3:
  720. value = 0x00084526;
  721. break;
  722. case controller_heathrow:
  723. case controller_ohare:
  724. default:
  725. value = 0x00074526;
  726. break;
  727. }
  728. pmac_ide[i].timings[0] = pmac_ide[i].timings[1] = value;
  729. }
  731. ide_ioreg_t __pmac
  732. pmac_ide_get_base(int index)
  733. {
  734. return pmac_ide[index].regbase;
  735. }
  737. int __pmac
  738. pmac_ide_check_base(ide_ioreg_t base)
  739. {
  740. int ix;
  742.   for (ix = 0; ix < MAX_HWIFS; ++ix)
  743. if (base == pmac_ide[ix].regbase)
  744. return ix;
  745. return -1;
  746. }
  748. int __pmac
  749. pmac_ide_get_irq(ide_ioreg_t base)
  750. {
  751. int ix;
  753. for (ix = 0; ix < MAX_HWIFS; ++ix)
  754. if (base == pmac_ide[ix].regbase)
  755. return pmac_ide[ix].irq;
  756. return 0;
  757. }
  759. static int ide_majors[]  __pmacdata = { 3, 22, 33, 34, 56, 57 };
  761. kdev_t __init
  762. pmac_find_ide_boot(char *bootdevice, int n)
  763. {
  764. int i;
  766. /*
  767.  * Look through the list of IDE interfaces for this one.
  768.  */
  769. for (i = 0; i < pmac_ide_count; ++i) {
  770. char *name;
  771. if (!pmac_ide[i].node || !pmac_ide[i].node->full_name)
  772. continue;
  773. name = pmac_ide[i].node->full_name;
  774. if (memcmp(name, bootdevice, n) == 0 && name[n] == 0) {
  775. /* XXX should cope with the 2nd drive as well... */
  776. return MKDEV(ide_majors[i], 0);
  777. }
  778. }
  780. return 0;
  781. }
  783. void __init
  784. pmac_ide_probe(void)
  785. {
  786. struct device_node *np;
  787. int i;
  788. struct device_node *atas;
  789. struct device_node *p, **pp, *removables, **rp;
  790. unsigned long base;
  791. int irq, big_delay;
  792. ide_hwif_t *hwif;
  794. if (_machine != _MACH_Pmac)
  795. return;
  796. pp = &atas;
  797. rp = &removables;
  798. p = find_devices("ATA");
  799. if (p == NULL)
  800. p = find_devices("IDE");
  801. if (p == NULL)
  802. p = find_type_devices("ide");
  803. if (p == NULL)
  804. p = find_type_devices("ata");
  805. /* Move removable devices such as the media-bay CDROM
  806.    on the PB3400 to the end of the list. */
  807. for (; p != NULL; p = p->next) {
  808. if (p->parent && p->parent->type
  809.     && strcasecmp(p->parent->type, "media-bay") == 0) {
  810. *rp = p;
  811. rp = &p->next;
  812. } else {
  813. *pp = p;
  814. pp = &p->next;
  815. }
  816. }
  817. *rp = NULL;
  818. *pp = removables;
  819. big_delay = 0;
  821. for (i = 0, np = atas; i < MAX_HWIFS && np != NULL; np = np->next) {
  822. struct device_node *tp;
  823. struct pmac_ide_hwif* pmhw;
  824. int *bidp;
  825. int in_bay = 0;
  827. /*
  828.  * If this node is not under a mac-io or dbdma node,
  829.  * leave it to the generic PCI driver.
  830.  */
  831. for (tp = np->parent; tp != 0; tp = tp->parent)
  832. if (tp->type && (strcmp(tp->type, "mac-io") == 0
  833.  || strcmp(tp->type, "dbdma") == 0))
  834. break;
  835. if (tp == 0)
  836. continue;
  838. if (np->n_addrs == 0) {
  839. printk(KERN_WARNING "ide: no address for device %sn",
  840.        np->full_name);
  841. continue;
  842. }
  844. /*
  845.  * If this slot is taken (e.g. by ide-pci.c) try the next one.
  846.  */
  847. while (i < MAX_HWIFS
  848.        && ide_hwifs[i].io_ports[IDE_DATA_OFFSET] != 0)
  849. ++i;
  850. if (i >= MAX_HWIFS)
  851. break;
  852. pmhw = &pmac_ide[i];
  854. /*
  855.  * Some older OFs have bogus sizes, causing request_OF_resource
  856.  * to fail. We fix them up here
  857.  */
  858. if (np->addrs[0].size > 0x1000)
  859. np->addrs[0].size = 0x1000;
  860. if (np->n_addrs > 1 && np->addrs[1].size > 0x100)
  861. np->addrs[1].size = 0x100;
  863. pmhw->reg_resource = request_OF_resource(np, 0, "  (mac-io IDE IO)");
  864. if (!pmhw->reg_resource) {
  865. printk(KERN_ERR "ide-pmac(%s): can't request IO resource !n", np->name);
  866. continue;
  867. }
  869. base = (unsigned long) ioremap(np->addrs[0].address, 0x400) - _IO_BASE;
  871. /* XXX This is bogus. Should be fixed in the registry by checking
  872.    the kind of host interrupt controller, a bit like gatwick
  873.    fixes in irq.c
  874.  */
  875. if (np->n_intrs == 0) {
  876. printk(KERN_WARNING "ide: no intrs for device %s, using 13n",
  877.        np->full_name);
  878. irq = 13;
  879. } else {
  880. irq = np->intrs[0].line;
  881. }
  882. pmhw->regbase = base;
  883. pmhw->irq = irq;
  884. pmhw->node = np;
  885. if (device_is_compatible(np, "keylargo-ata")) {
  886. if (strcmp(np->name, "ata-4") == 0)
  887. pmhw->kind = controller_kl_ata4;
  888. else
  889. pmhw->kind = controller_kl_ata3;
  890. } else if (device_is_compatible(np, "heathrow-ata"))
  891. pmhw->kind = controller_heathrow;
  892. else
  893. pmhw->kind = controller_ohare;
  895. bidp = (int *)get_property(np, "AAPL,bus-id", NULL);
  896. pmhw->aapl_bus_id =  bidp ? *bidp : 0;
  898. if (pmhw->kind == controller_kl_ata4) {
  899. char* cable = get_property(np, "cable-type", NULL);
  900. if (cable && !strncmp(cable, "80-", 3))
  901. pmhw->kind = controller_kl_ata4_80;
  902. }
  904. /* Make sure we have sane timings */
  905. sanitize_timings(i);
  907. if (np->parent && np->parent->name
  908.     && strcasecmp(np->parent->name, "media-bay") == 0) {
  909. #ifdef CONFIG_PMAC_PBOOK
  910. media_bay_set_ide_infos(np->parent,base,irq,i);
  911. #endif /* CONFIG_PMAC_PBOOK */
  912. in_bay = 1;
  913. if (!bidp)
  914. pmhw->aapl_bus_id = 1;
  915. } else if (pmhw->kind == controller_ohare) {
  916. /* The code below is having trouble on some ohare machines
  917.  * (timing related ?). Until I can put my hand on one of these
  918.  * units, I keep the old way
  919.  */
  920. ppc_md.feature_call(PMAC_FTR_IDE_ENABLE, np, 0, 1);
  921. } else {
  922.   /* This is necessary to enable IDE when net-booting */
  923. printk(KERN_INFO "pmac_ide: enabling IDE bus ID %dn",
  924. pmhw->aapl_bus_id);
  925. ppc_md.feature_call(PMAC_FTR_IDE_RESET, np, pmhw->aapl_bus_id, 1);
  926. ppc_md.feature_call(PMAC_FTR_IDE_ENABLE, np, pmhw->aapl_bus_id, 1);
  927. mdelay(10);
  928. ppc_md.feature_call(PMAC_FTR_IDE_RESET, np, pmhw->aapl_bus_id, 0);
  929. big_delay = 1;
  930. }
  932. hwif = &ide_hwifs[i];
  933. pmac_ide_init_hwif_ports(&hwif->hw, base, 0, &hwif->irq);
  934. memcpy(hwif->io_ports, hwif->hw.io_ports, sizeof(hwif->io_ports));
  935. hwif->chipset = ide_pmac;
  936. hwif->noprobe = !hwif->io_ports[IDE_DATA_OFFSET] || in_bay;
  937. hwif->udma_four = (pmhw->kind == controller_kl_ata4_80);
  938. #ifdef CONFIG_PMAC_PBOOK
  939. if (in_bay && check_media_bay_by_base(base, MB_CD) == 0)
  940. hwif->noprobe = 0;
  941. #endif /* CONFIG_PMAC_PBOOK */
  943. #ifdef CONFIG_BLK_DEV_IDEDMA_PMAC
  944. if (np->n_addrs >= 2) {
  945. /* has a DBDMA controller channel */
  946. pmac_ide_setup_dma(np, i);
  947. }
  948. #endif /* CONFIG_BLK_DEV_IDEDMA_PMAC */
  950. ++i;
  951. }
  952. pmac_ide_count = i;
  953. if (big_delay)
  954. mdelay(IDE_WAKEUP_DELAY_MS);
  956. #ifdef CONFIG_PMAC_PBOOK
  957. pmu_register_sleep_notifier(&idepmac_sleep_notifier);
  958. #endif /* CONFIG_PMAC_PBOOK */
  959. register_reboot_notifier(&pmac_ide_reboot_notifier);
  960. }
  962. #ifdef CONFIG_BLK_DEV_IDEDMA_PMAC
  964. static void __init 
  965. pmac_ide_setup_dma(struct device_node *np, int ix)
  966. {
  967. pmac_ide[ix].dma_resource = request_OF_resource(np, 1, " (mac-io IDE DMA)");
  968. if (!pmac_ide[ix].dma_resource) {
  969. printk(KERN_ERR "ide-pmac(%s): can't request DMA resource !n", np->name);
  970. return;
  971. }
  973. pmac_ide[ix].dma_regs =
  974. (volatile struct dbdma_regs*)ioremap(np->addrs[1].address, 0x200);
  976. /*
  977.  * Allocate space for the DBDMA commands.
  978.  * The +2 is +1 for the stop command and +1 to allow for
  979.  * aligning the start address to a multiple of 16 bytes.
  980.  */
  981. pmac_ide[ix].dma_table = (struct dbdma_cmd*)
  982.        kmalloc((MAX_DCMDS + 2) * sizeof(struct dbdma_cmd), GFP_KERNEL);
  983. if (pmac_ide[ix].dma_table == 0) {
  984. printk(KERN_ERR "%s: unable to allocate DMA command listn",
  985.        ide_hwifs[ix].name);
  986. return;
  987. }
  989. ide_hwifs[ix].dmaproc = &pmac_ide_dmaproc;
  990. #ifdef CONFIG_BLK_DEV_IDEDMA_PMAC_AUTO
  991. if (!noautodma)
  992. ide_hwifs[ix].autodma = 1;
  993. #endif
  994. }
  996. /*
  997.  * pmac_ide_build_dmatable builds the DBDMA command list
  998.  * for a transfer and sets the DBDMA channel to point to it.
  999.  */
  1000. static int __pmac
  1001. pmac_ide_build_dmatable(ide_drive_t *drive, int ix, int wr)
  1002. {
  1003. struct dbdma_cmd *table, *tstart;
  1004. int count = 0;
  1005. struct request *rq = HWGROUP(drive)->rq;
  1006. struct buffer_head *bh = rq->bh;
  1007. unsigned int size, addr;
  1008. volatile struct dbdma_regs *dma = pmac_ide[ix].dma_regs;
  1010. table = tstart = (struct dbdma_cmd *) DBDMA_ALIGN(pmac_ide[ix].dma_table);
  1012. #ifdef IDE_PMAC_DEBUG
  1013. if (in_le32(&dma->status) & (RUN|ACTIVE))
  1014. printk("ide-pmac: channel status not stopped ! (%x)n",
  1015. in_le32(&dma->status));
  1016. #endif
  1017. /* Make sure channel is stopped and all error conditions are clear */
  1018. out_le32(&dma->control, (RUN|PAUSE|FLUSH|WAKE|DEAD) << 16);
  1019. while (in_le32(&dma->status) & RUN)
  1020. udelay(1);
  1022. do {
  1023. /*
  1024.  * Determine addr and size of next buffer area.  We assume that
  1025.  * individual virtual buffers are always composed linearly in
  1026.  * physical memory.  For example, we assume that any 8kB buffer
  1027.  * is always composed of two adjacent physical 4kB pages rather
  1028.  * than two possibly non-adjacent physical 4kB pages.
  1029.  */
  1030. if (bh == NULL) {  /* paging requests have (rq->bh == NULL) */
  1031. addr = virt_to_bus(rq->buffer);
  1032. size = rq->nr_sectors << 9;
  1033. } else {
  1034. /* group sequential buffers into one large buffer */
  1035. addr = virt_to_bus(bh->b_data);
  1036. size = bh->b_size;
  1037. while ((bh = bh->b_reqnext) != NULL) {
  1038. if ((addr + size) != virt_to_bus(bh->b_data))
  1039. break;
  1040. size += bh->b_size;
  1041. }
  1042. }
  1044. /*
  1045.  * Fill in the next DBDMA command block.
  1046.  * Note that one DBDMA command can transfer
  1047.  * at most 65535 bytes.
  1048.  */
  1049. #ifdef IDE_PMAC_DEBUG
  1050. if (size & 0x01)
  1051. printk("ide-pmac: odd size transfer ! (%d)n", size);
  1052. #endif
  1053. while (size) {
  1054. unsigned int tc = (size < 0xfe00)? size: 0xfe00;
  1056. if (++count >= MAX_DCMDS) {
  1057. printk(KERN_WARNING "%s: DMA table too smalln",
  1058.        drive->name);
  1059. return 0; /* revert to PIO for this request */
  1060. }
  1061. st_le16(&table->command, wr? OUTPUT_MORE: INPUT_MORE);
  1062. st_le16(&table->req_count, tc);
  1063. st_le32(&table->phy_addr, addr);
  1064. table->cmd_dep = 0;
  1065. table->xfer_status = 0;
  1066. table->res_count = 0;
  1067. addr += tc;
  1068. size -= tc;
  1069. ++table;
  1070. }
  1071. } while (bh != NULL);
  1073. /* convert the last command to an input/output last command */
  1074. if (count)
  1075. st_le16(&table[-1].command, wr? OUTPUT_LAST: INPUT_LAST);
  1076. else
  1077. printk(KERN_DEBUG "%s: empty DMA table?n", drive->name);
  1079. /* add the stop command to the end of the list */
  1080. memset(table, 0, sizeof(struct dbdma_cmd));
  1081. out_le16(&table->command, DBDMA_STOP);
  1083. out_le32(&dma->cmdptr, virt_to_bus(tstart));
  1084. return 1;
  1085. }
  1088. static __inline__ unsigned char
  1089. dma_bits_to_command(unsigned char bits)
  1090. {
  1091. if(bits & 0x04)
  1092. return XFER_MW_DMA_2;
  1093. if(bits & 0x02)
  1094. return XFER_MW_DMA_1;
  1095. if(bits & 0x01)
  1096. return XFER_MW_DMA_0;
  1097. return 0;
  1098. }
  1100. static __inline__ unsigned char
  1101. udma_bits_to_command(unsigned char bits, int high_speed)
  1102. {
  1103. if (high_speed) {
  1104. if(bits & 0x10)
  1105. return XFER_UDMA_4;
  1106. if(bits & 0x08)
  1107. return XFER_UDMA_3;
  1108. }
  1109. if(bits & 0x04)
  1110. return XFER_UDMA_2;
  1111. if(bits & 0x02)
  1112. return XFER_UDMA_1;
  1113. if(bits & 0x01)
  1114. return XFER_UDMA_0;
  1115. return 0;
  1116. }
  1118. /* Calculate MultiWord DMA timings */
  1119. static int __pmac
  1120. pmac_ide_mdma_enable(ide_drive_t *drive, int idx)
  1121. {
  1122. byte bits = drive->id->dma_mword & 0x07;
  1123. byte feature = dma_bits_to_command(bits);
  1124. u32 *timings;
  1125. int drive_cycle_time;
  1126. struct hd_driveid *id = drive->id;
  1127. int ret;
  1129. /* Set feature on drive */
  1130.      printk(KERN_INFO "%s: Enabling MultiWord DMA %dn", drive->name, feature & 0xf);
  1131. ret = pmac_ide_do_setfeature(drive, feature);
  1132. if (ret) {
  1133.      printk(KERN_WARNING "%s: Failed !n", drive->name);
  1134.      return 0;
  1135. }
  1137. if (!drive->init_speed)
  1138. drive->init_speed = feature;
  1140. /* which drive is it ? */
  1141. if (drive->select.b.unit & 0x01)
  1142. timings = &pmac_ide[idx].timings[1];
  1143. else
  1144. timings = &pmac_ide[idx].timings[0];
  1146. /* Check if drive provide explicit cycle time */
  1147. if ((id->field_valid & 2) && (id->eide_dma_time))
  1148. drive_cycle_time = id->eide_dma_time;
  1149. else
  1150. drive_cycle_time = 0;
  1152. /* Calculate controller timings */
  1153. set_timings_mdma(pmac_ide[idx].kind, timings, feature, drive_cycle_time);
  1155. drive->current_speed = feature;
  1156. return 1;
  1157. }
  1159. /* Calculate Ultra DMA timings */
  1160. static int __pmac
  1161. pmac_ide_udma_enable(ide_drive_t *drive, int idx, int high_speed)
  1162. {
  1163. byte bits = drive->id->dma_ultra & 0x1f;
  1164. byte feature = udma_bits_to_command(bits, high_speed);
  1165. u32 *timings;
  1166. int ret;
  1168. /* Set feature on drive */
  1169.      printk(KERN_INFO "%s: Enabling Ultra DMA %dn", drive->name, feature & 0xf);
  1170. ret = pmac_ide_do_setfeature(drive, feature);
  1171. if (ret) {
  1172. printk(KERN_WARNING "%s: Failed !n", drive->name);
  1173. return 0;
  1174. }
  1176. if (!drive->init_speed)
  1177. drive->init_speed = feature;
  1179. /* which drive is it ? */
  1180. if (drive->select.b.unit & 0x01)
  1181. timings = &pmac_ide[idx].timings[1];
  1182. else
  1183. timings = &pmac_ide[idx].timings[0];
  1185. set_timings_udma(timings, feature);
  1187. drive->current_speed = feature;
  1188. return 1;
  1189. }
  1191. static int __pmac
  1192. pmac_ide_check_dma(ide_drive_t *drive)
  1193. {
  1194. int ata4, udma, idx;
  1195. struct hd_driveid *id = drive->id;
  1196. int enable = 1;
  1198. drive->using_dma = 0;
  1200. idx = pmac_ide_find(drive);
  1201. if (idx < 0)
  1202. return 0;
  1204. if (drive->media == ide_floppy)
  1205. enable = 0;
  1206. if (((id->capability & 1) == 0) && !check_drive_lists(drive, GOOD_DMA_DRIVE))
  1207. enable = 0;
  1208. if (check_drive_lists(drive, BAD_DMA_DRIVE))
  1209. enable = 0;
  1211. udma = 0;
  1212. ata4 = (pmac_ide[idx].kind == controller_kl_ata4 ||
  1213. pmac_ide[idx].kind == controller_kl_ata4_80);
  1215. if(enable) {
  1216. if (ata4 && (drive->media == ide_disk) &&
  1217.     (id->field_valid & 0x0004) && (id->dma_ultra & 0x1f)) {
  1218. /* UltraDMA modes. */
  1219. drive->using_dma = pmac_ide_udma_enable(drive, idx,
  1220. pmac_ide[idx].kind == controller_kl_ata4_80);
  1221. }
  1222. if (!drive->using_dma && (id->dma_mword & 0x0007)) {
  1223. /* Normal MultiWord DMA modes. */
  1224. drive->using_dma = pmac_ide_mdma_enable(drive, idx);
  1225. }
  1226. OUT_BYTE(0, IDE_CONTROL_REG);
  1227. /* Apply settings to controller */
  1228. pmac_ide_selectproc(drive);
  1229. }
  1230. return 0;
  1231. }
  1233. static int __pmac
  1234. pmac_ide_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
  1235. {
  1236. int ix, dstat;
  1237. volatile struct dbdma_regs *dma;
  1238. byte unit = (drive->select.b.unit & 0x01);
  1239. byte ata4;
  1241. /* Can we stuff a pointer to our intf structure in config_data
  1242.  * or select_data in hwif ?
  1243.  */
  1244. ix = pmac_ide_find(drive);
  1245. if (ix < 0)
  1246. return 0;
  1247. dma = pmac_ide[ix].dma_regs;
  1248. ata4 = (pmac_ide[ix].kind == controller_kl_ata4 ||
  1249. pmac_ide[ix].kind == controller_kl_ata4_80);
  1251. switch (func) {
  1252. case ide_dma_off:
  1253. printk(KERN_INFO "%s: DMA disabledn", drive->name);
  1254. case ide_dma_off_quietly:
  1255. drive->using_dma = 0;
  1256. break;
  1257. case ide_dma_on:
  1258. case ide_dma_check:
  1259. pmac_ide_check_dma(drive);
  1260. break;
  1261. case ide_dma_read:
  1262. case ide_dma_write:
  1263. if (!pmac_ide_build_dmatable(drive, ix, func==ide_dma_write))
  1264. return 1;
  1265. /* Apple adds 60ns to wrDataSetup on reads */
  1266. if (ata4 && (pmac_ide[ix].timings[unit] & TR_66_UDMA_EN)) {
  1267. out_le32((unsigned *)(IDE_DATA_REG + IDE_TIMING_CONFIG + _IO_BASE),
  1268. pmac_ide[ix].timings[unit] + 
  1269. ((func == ide_dma_read) ? 0x00800000UL : 0));
  1270. (void)in_le32((unsigned *)(IDE_DATA_REG + IDE_TIMING_CONFIG + _IO_BASE));
  1271. }
  1272. drive->waiting_for_dma = 1;
  1273. if (drive->media != ide_disk)
  1274. return 0;
  1275. ide_set_handler(drive, &ide_dma_intr, WAIT_CMD, NULL);
  1276. OUT_BYTE(func==ide_dma_write? WIN_WRITEDMA: WIN_READDMA,
  1277.  IDE_COMMAND_REG);
  1278. case ide_dma_begin:
  1279. out_le32(&dma->control, (RUN << 16) | RUN);
  1280. /* Make sure it gets to the controller right now */
  1281. (void)in_le32(&dma->control);
  1282. break;
  1283. case ide_dma_end: /* returns 1 on error, 0 otherwise */
  1284. drive->waiting_for_dma = 0;
  1285. dstat = in_le32(&dma->status);
  1286. out_le32(&dma->control, ((RUN|WAKE|DEAD) << 16));
  1287. /* verify good dma status */
  1288. return (dstat & (RUN|DEAD|ACTIVE)) != RUN;
  1289. case ide_dma_test_irq: /* returns 1 if dma irq issued, 0 otherwise */
  1290. /* We have to things to deal with here:
  1291.  * 
  1292.  * - The dbdma won't stop if the command was started
  1293.  * but completed with an error without transfering all
  1294.  * datas. This happens when bad blocks are met during
  1295.  * a multi-block transfer.
  1296.  * 
  1297.  * - The dbdma fifo hasn't yet finished flushing to
  1298.  * to system memory when the disk interrupt occurs.
  1299.  * 
  1300.  * The trick here is to increment drive->waiting_for_dma,
  1301.  * and return as if no interrupt occured. If the counter
  1302.  * reach a certain timeout value, we then return 1. If
  1303.  * we really got the interrupt, it will happen right away
  1304.  * again.
  1305.  * Apple's solution here may be more elegant. They issue
  1306.  * a DMA channel interrupt (a separate irq line) via a DBDMA
  1307.  * NOP command just before the STOP, and wait for both the
  1308.  * disk and DBDMA interrupts to have completed.
  1309.  */
  1310.  
  1311. /* If ACTIVE is cleared, the STOP command have passed and
  1312.  * transfer is complete.
  1313.  */
  1314. if (!(in_le32(&dma->status) & ACTIVE))
  1315. return 1;
  1316. if (!drive->waiting_for_dma)
  1317. printk(KERN_WARNING "ide%d, ide_dma_test_irq 
  1318. called while not waitingn", ix);
  1320. /* If dbdma didn't execute the STOP command yet, the
  1321.  * active bit is still set */
  1322. drive->waiting_for_dma++;
  1323. if (drive->waiting_for_dma >= DMA_WAIT_TIMEOUT) {
  1324. printk(KERN_WARNING "ide%d, timeout waiting 
  1325. for dbdma command stopn", ix);
  1326. return 1;
  1327. }
  1328. udelay(1);
  1329. return 0;
  1331. /* Let's implement tose just in case someone wants them */
  1332. case ide_dma_bad_drive:
  1333. case ide_dma_good_drive:
  1334. return check_drive_lists(drive, (func == ide_dma_good_drive));
  1335. case ide_dma_verbose:
  1336. return report_drive_dmaing(drive);
  1337. case ide_dma_retune:
  1338. case ide_dma_lostirq:
  1339. case ide_dma_timeout:
  1340. printk(KERN_WARNING "ide_pmac_dmaproc: chipset supported %s func only: %dn", ide_dmafunc_verbose(func),  func);
  1341. return 1;
  1342. default:
  1343. printk(KERN_WARNING "ide_pmac_dmaproc: unsupported %s func: %dn", ide_dmafunc_verbose(func), func);
  1344. return 1;
  1345. }
  1346. return 0;
  1347. }
  1348. #endif /* CONFIG_BLK_DEV_IDEDMA_PMAC */
  1350. static void __pmac
  1351. idepmac_sleep_device(ide_drive_t *drive, int i, unsigned base)
  1352. {
  1353. int j;
  1355. /* FIXME: We only handle the master IDE disk, we shoud
  1356.  *        try to fix CD-ROMs here
  1357.  */
  1358. switch (drive->media) {
  1359. case ide_disk:
  1360. /* Spin down the drive */
  1361. outb(drive->select.all, base+0x60);
  1362. (void)inb(base+0x60);
  1363. udelay(100);
  1364. outb(0x0, base+0x30);
  1365. outb(0x0, base+0x20);
  1366. outb(0x0, base+0x40);
  1367. outb(0x0, base+0x50);
  1368. outb(0xe0, base+0x70);
  1369. outb(0x2, base+0x160);   
  1370. for (j = 0; j < 10; j++) {
  1371. int status;
  1372. mdelay(100);
  1373. status = inb(base+0x70);
  1374. if (!(status & BUSY_STAT) && (status & DRQ_STAT))
  1375. break;
  1376. }
  1377. break;
  1378. case ide_cdrom:
  1379. // todo
  1380. break;
  1381. case ide_floppy:
  1382. // todo
  1383. break;
  1384. }
  1385. }
  1387. #ifdef CONFIG_PMAC_PBOOK
  1388. static void __pmac
  1389. idepmac_wake_device(ide_drive_t *drive, int used_dma)
  1390. {
  1391. /* We force the IDE subdriver to check for a media change
  1392.  * This must be done first or we may lost the condition
  1393.  *
  1394.  * Problem: This can schedule. I moved the block device
  1395.  * wakeup almost late by priority because of that.
  1396.  */
  1397. if (DRIVER(drive) && DRIVER(drive)->media_change)
  1398. DRIVER(drive)->media_change(drive);
  1400. /* We kick the VFS too (see fix in ide.c revalidate) */
  1401. check_disk_change(MKDEV(HWIF(drive)->major, (drive->select.b.unit) << PARTN_BITS));
  1403. #ifdef CONFIG_BLK_DEV_IDEDMA_PMAC
  1404. /* We re-enable DMA on the drive if it was active. */
  1405. /* This doesn't work with the CD-ROM in the media-bay, probably
  1406.  * because of a pending unit attention. The problem if that if I
  1407.  * clear the error, the filesystem dies.
  1408.  */
  1409. if (used_dma && !ide_spin_wait_hwgroup(drive)) {
  1410. /* Lock HW group */
  1411. HWGROUP(drive)->busy = 1;
  1412. pmac_ide_check_dma(drive);
  1413. HWGROUP(drive)->busy = 0;
  1414. if (!list_empty(&drive->queue.queue_head))
  1415. ide_do_request(HWGROUP(drive), 0);
  1416. spin_unlock_irq(&io_request_lock);
  1417. }
  1418. #endif /* CONFIG_BLK_DEV_IDEDMA_PMAC */
  1419. }
  1421. static void __pmac
  1422. idepmac_sleep_interface(int i, unsigned base, int mediabay)
  1423. {
  1424. struct device_node* np = pmac_ide[i].node;
  1426. /* We clear the timings */
  1427. pmac_ide[i].timings[0] = 0;
  1428. pmac_ide[i].timings[1] = 0;
  1430. /* The media bay will handle itself just fine */
  1431. if (mediabay)
  1432. return;
  1434. /* Disable the bus */
  1435. ppc_md.feature_call(PMAC_FTR_IDE_ENABLE, np, pmac_ide[i].aapl_bus_id, 0);
  1436. }
  1438. static void __pmac
  1439. idepmac_wake_interface(int i, unsigned long base, int mediabay)
  1440. {
  1441. struct device_node* np = pmac_ide[i].node;
  1443. if (!mediabay) {
  1444. /* Revive IDE disk and controller */
  1445. ppc_md.feature_call(PMAC_FTR_IDE_RESET, np, pmac_ide[i].aapl_bus_id, 1);
  1446. ppc_md.feature_call(PMAC_FTR_IDE_ENABLE, np, pmac_ide[i].aapl_bus_id, 1);
  1447. mdelay(10);
  1448. ppc_md.feature_call(PMAC_FTR_IDE_RESET, np, pmac_ide[i].aapl_bus_id, 0);
  1449. }
  1450. }
  1452. static void
  1453. idepmac_sleep_drive(ide_drive_t *drive, int idx, unsigned long base)
  1454. {
  1455. int unlock = 0;
  1457. /* Wait for HW group to complete operations */
  1458. if (ide_spin_wait_hwgroup(drive)) {
  1459. // What can we do here ? Wake drive we had already
  1460. // put to sleep and return an error ?
  1461. } else {
  1462. unlock = 1;
  1463. /* Lock HW group */
  1464. HWGROUP(drive)->busy = 1;
  1465. /* Stop the device */
  1466. idepmac_sleep_device(drive, idx, base);
  1467. }
  1468. if (unlock)
  1469. spin_unlock_irq(&io_request_lock);
  1470. }
  1472. static void
  1473. idepmac_wake_drive(ide_drive_t *drive, unsigned long base)
  1474. {
  1475. unsigned long flags;
  1476. int j;
  1478. /* Reset timings */
  1479. pmac_ide_selectproc(drive);
  1480. mdelay(10);
  1482. /* Wait up to 20 seconds for the drive to be ready */
  1483. for (j = 0; j < 200; j++) {
  1484. int status;
  1485. mdelay(100);
  1486. outb(drive->select.all, base + 0x60);
  1487. if (inb(base + 0x60) != drive->select.all)
  1488. continue;
  1489. status = inb(base + 0x70);
  1490. if (!(status & BUSY_STAT))
  1491. break;
  1492. }
  1494. /* We resume processing on the HW group */
  1495. spin_lock_irqsave(&io_request_lock, flags);
  1496. HWGROUP(drive)->busy = 0;
  1497. if (!list_empty(&drive->queue.queue_head))
  1498. ide_do_request(HWGROUP(drive), 0);
  1499. spin_unlock_irqrestore(&io_request_lock, flags);
  1500. }
  1502. /* Note: We support only master drives for now. This will have to be
  1503.  * improved if we want to handle sleep on the iMacDV where the CD-ROM
  1504.  * is a slave
  1505.  */
  1506. static int __pmac
  1507. idepmac_notify_sleep(struct pmu_sleep_notifier *self, int when)
  1508. {
  1509. int i, ret;
  1510. unsigned long base;
  1511. int big_delay;
  1512.  
  1513. switch (when) {
  1514. case PBOOK_SLEEP_REQUEST:
  1515. break;
  1516. case PBOOK_SLEEP_REJECT:
  1517. break;
  1518. case PBOOK_SLEEP_NOW:
  1519. for (i = 0; i < pmac_ide_count; ++i) {
  1520. ide_hwif_t *hwif;
  1521. int dn;
  1523. if ((base = pmac_ide[i].regbase) == 0)
  1524. continue;
  1526. hwif = &ide_hwifs[i];
  1527. for (dn=0; dn<MAX_DRIVES; dn++) {
  1528. if (!hwif->drives[dn].present)
  1529. continue;
  1530. idepmac_sleep_drive(&hwif->drives[dn], i, base);
  1531. }
  1532. /* Disable irq during sleep */
  1533. disable_irq(pmac_ide[i].irq);
  1535. /* Check if this is a media bay with an IDE device or not
  1536.  * a media bay.
  1537.  */
  1538. ret = check_media_bay_by_base(base, MB_CD);
  1539. if ((ret == 0) || (ret == -ENODEV))
  1540. idepmac_sleep_interface(i, base, (ret == 0));
  1541. }
  1542. break;
  1543. case PBOOK_WAKE:
  1544. big_delay = 0;
  1545. for (i = 0; i < pmac_ide_count; ++i) {
  1547. if ((base = pmac_ide[i].regbase) == 0)
  1548. continue;
  1550. /* Make sure we have sane timings */
  1551. sanitize_timings(i);
  1553. /* Check if this is a media bay with an IDE device or not
  1554.  * a media bay
  1555.  */
  1556. ret = check_media_bay_by_base(base, MB_CD);
  1557. if ((ret == 0) || (ret == -ENODEV)) {
  1558. idepmac_wake_interface(i, base, (ret == 0));
  1559. big_delay = 1;
  1560. }
  1562. }
  1563. /* Let hardware get up to speed */
  1564. if (big_delay)
  1565. mdelay(IDE_WAKEUP_DELAY_MS);
  1567. for (i = 0; i < pmac_ide_count; ++i) {
  1568. ide_hwif_t *hwif;
  1569. int used_dma, dn;
  1570. int irq_on = 0;
  1572. if ((base = pmac_ide[i].regbase) == 0)
  1573. continue;
  1575. hwif = &ide_hwifs[i];
  1576. for (dn=0; dn<MAX_DRIVES; dn++) {
  1577. ide_drive_t *drive = &hwif->drives[dn];
  1578. if (!drive->present)
  1579. continue;
  1580. /* We don't have re-configured DMA yet */
  1581. used_dma = drive->using_dma;
  1582. drive->using_dma = 0;
  1583. idepmac_wake_drive(drive, base);
  1584. if (!irq_on) {
  1585. enable_irq(pmac_ide[i].irq);
  1586. irq_on = 1;
  1587. }
  1588. idepmac_wake_device(drive, used_dma);
  1589. }
  1590. if (!irq_on)
  1591. enable_irq(pmac_ide[i].irq);
  1592. }
  1593. break;
  1594. }
  1595. return PBOOK_SLEEP_OK;
  1596. }
  1597. #endif /* CONFIG_PMAC_PBOOK */
  1599. static int __pmac
  1600. pmac_ide_notify_reboot(struct notifier_block *this, unsigned long code, void *x)
  1601. {
  1602. int i, gotone;
  1603. unsigned long base;
  1605. if (code != SYS_HALT && code != SYS_POWER_OFF)
  1606. return 0;
  1608. gotone = 0;
  1609. for (i = 0; i < pmac_ide_count; ++i) {
  1610. ide_hwif_t *hwif;
  1611. ide_drive_t *drive;
  1612. int unlock = 0;
  1613. int dn;
  1615. if ((base = pmac_ide[i].regbase) == 0)
  1616. continue;
  1618. hwif = &ide_hwifs[i];
  1619. for (dn=0; dn<MAX_DRIVES; dn++) {
  1620. drive = &hwif->drives[dn];
  1621. if (drive->present) {
  1622. gotone = 1;
  1623. /* Wait for HW group to complete operations */
  1624. if (ide_spin_wait_hwgroup(drive)) {
  1625. // What can we do here ? Wake drive we had already
  1626. // put to sleep and return an error ?
  1627. } else {
  1628. unlock = 1;
  1629. /* Lock HW group */
  1630. HWGROUP(drive)->busy = 1;
  1632. /* Stop the device */
  1633. idepmac_sleep_device(drive, i, base);
  1634. }
  1635. }
  1636. if (unlock)
  1637. spin_unlock_irq(&io_request_lock);
  1638. }
  1639. }
  1640. if (gotone)
  1641. mdelay(1000);
  1643. return NOTIFY_DONE;
  1644. }