tc86c001.c 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270
  1. /*
  2. * Copyright (C) 2002 Toshiba Corporation
  3. * Copyright (C) 2005-2006 MontaVista Software, Inc. <source@mvista.com>
  4. *
  5. * This file is licensed under the terms of the GNU General Public
  6. * License version 2. This program is licensed "as is" without any
  7. * warranty of any kind, whether express or implied.
  8. */
  9. #include <linux/types.h>
  10. #include <linux/pci.h>
  11. #include <linux/ide.h>
  12. #include <linux/module.h>
  13. #define DRV_NAME "tc86c001"
  14. static void tc86c001_set_mode(ide_hwif_t *hwif, ide_drive_t *drive)
  15. {
  16. unsigned long scr_port = hwif->config_data + (drive->dn ? 0x02 : 0x00);
  17. u16 mode, scr = inw(scr_port);
  18. const u8 speed = drive->dma_mode;
  19. switch (speed) {
  20. case XFER_UDMA_4: mode = 0x00c0; break;
  21. case XFER_UDMA_3: mode = 0x00b0; break;
  22. case XFER_UDMA_2: mode = 0x00a0; break;
  23. case XFER_UDMA_1: mode = 0x0090; break;
  24. case XFER_UDMA_0: mode = 0x0080; break;
  25. case XFER_MW_DMA_2: mode = 0x0070; break;
  26. case XFER_MW_DMA_1: mode = 0x0060; break;
  27. case XFER_MW_DMA_0: mode = 0x0050; break;
  28. case XFER_PIO_4: mode = 0x0400; break;
  29. case XFER_PIO_3: mode = 0x0300; break;
  30. case XFER_PIO_2: mode = 0x0200; break;
  31. case XFER_PIO_1: mode = 0x0100; break;
  32. case XFER_PIO_0:
  33. default: mode = 0x0000; break;
  34. }
  35. scr &= (speed < XFER_MW_DMA_0) ? 0xf8ff : 0xff0f;
  36. scr |= mode;
  37. outw(scr, scr_port);
  38. }
  39. static void tc86c001_set_pio_mode(ide_hwif_t *hwif, ide_drive_t *drive)
  40. {
  41. drive->dma_mode = drive->pio_mode;
  42. tc86c001_set_mode(hwif, drive);
  43. }
  44. /*
  45. * HACKITY HACK
  46. *
  47. * This is a workaround for the limitation 5 of the TC86C001 IDE controller:
  48. * if a DMA transfer terminates prematurely, the controller leaves the device's
  49. * interrupt request (INTRQ) pending and does not generate a PCI interrupt (or
  50. * set the interrupt bit in the DMA status register), thus no PCI interrupt
  51. * will occur until a DMA transfer has been successfully completed.
  52. *
  53. * We work around this by initiating dummy, zero-length DMA transfer on
  54. * a DMA timeout expiration. I found no better way to do this with the current
  55. * IDE core than to temporarily replace a higher level driver's timer expiry
  56. * handler with our own backing up to that handler in case our recovery fails.
  57. */
  58. static int tc86c001_timer_expiry(ide_drive_t *drive)
  59. {
  60. ide_hwif_t *hwif = drive->hwif;
  61. ide_expiry_t *expiry = ide_get_hwifdata(hwif);
  62. u8 dma_stat = inb(hwif->dma_base + ATA_DMA_STATUS);
  63. /* Restore a higher level driver's expiry handler first. */
  64. hwif->expiry = expiry;
  65. if ((dma_stat & 5) == 1) { /* DMA active and no interrupt */
  66. unsigned long sc_base = hwif->config_data;
  67. unsigned long twcr_port = sc_base + (drive->dn ? 0x06 : 0x04);
  68. u8 dma_cmd = inb(hwif->dma_base + ATA_DMA_CMD);
  69. printk(KERN_WARNING "%s: DMA interrupt possibly stuck, "
  70. "attempting recovery...\n", drive->name);
  71. /* Stop DMA */
  72. outb(dma_cmd & ~0x01, hwif->dma_base + ATA_DMA_CMD);
  73. /* Setup the dummy DMA transfer */
  74. outw(0, sc_base + 0x0a); /* Sector Count */
  75. outw(0, twcr_port); /* Transfer Word Count 1 or 2 */
  76. /* Start the dummy DMA transfer */
  77. /* clear R_OR_WCTR for write */
  78. outb(0x00, hwif->dma_base + ATA_DMA_CMD);
  79. /* set START_STOPBM */
  80. outb(0x01, hwif->dma_base + ATA_DMA_CMD);
  81. /*
  82. * If an interrupt was pending, it should come thru shortly.
  83. * If not, a higher level driver's expiry handler should
  84. * eventually cause some kind of recovery from the DMA stall.
  85. */
  86. return WAIT_MIN_SLEEP;
  87. }
  88. /* Chain to the restored expiry handler if DMA wasn't active. */
  89. if (likely(expiry != NULL))
  90. return expiry(drive);
  91. /* If there was no handler, "emulate" that for ide_timer_expiry()... */
  92. return -1;
  93. }
  94. static void tc86c001_dma_start(ide_drive_t *drive)
  95. {
  96. ide_hwif_t *hwif = drive->hwif;
  97. unsigned long sc_base = hwif->config_data;
  98. unsigned long twcr_port = sc_base + (drive->dn ? 0x06 : 0x04);
  99. unsigned long nsectors = blk_rq_sectors(hwif->rq);
  100. /*
  101. * We have to manually load the sector count and size into
  102. * the appropriate system control registers for DMA to work
  103. * with LBA48 and ATAPI devices...
  104. */
  105. outw(nsectors, sc_base + 0x0a); /* Sector Count */
  106. outw(SECTOR_SIZE / 2, twcr_port); /* Transfer Word Count 1/2 */
  107. /* Install our timeout expiry hook, saving the current handler... */
  108. ide_set_hwifdata(hwif, hwif->expiry);
  109. hwif->expiry = &tc86c001_timer_expiry;
  110. ide_dma_start(drive);
  111. }
  112. static u8 tc86c001_cable_detect(ide_hwif_t *hwif)
  113. {
  114. struct pci_dev *dev = to_pci_dev(hwif->dev);
  115. unsigned long sc_base = pci_resource_start(dev, 5);
  116. u16 scr1 = inw(sc_base + 0x00);
  117. /*
  118. * System Control 1 Register bit 13 (PDIAGN):
  119. * 0=80-pin cable, 1=40-pin cable
  120. */
  121. return (scr1 & 0x2000) ? ATA_CBL_PATA40 : ATA_CBL_PATA80;
  122. }
  123. static void init_hwif_tc86c001(ide_hwif_t *hwif)
  124. {
  125. struct pci_dev *dev = to_pci_dev(hwif->dev);
  126. unsigned long sc_base = pci_resource_start(dev, 5);
  127. u16 scr1 = inw(sc_base + 0x00);
  128. /* System Control 1 Register bit 15 (Soft Reset) set */
  129. outw(scr1 | 0x8000, sc_base + 0x00);
  130. /* System Control 1 Register bit 14 (FIFO Reset) set */
  131. outw(scr1 | 0x4000, sc_base + 0x00);
  132. /* System Control 1 Register: reset clear */
  133. outw(scr1 & ~0xc000, sc_base + 0x00);
  134. /* Store the system control register base for convenience... */
  135. hwif->config_data = sc_base;
  136. if (!hwif->dma_base)
  137. return;
  138. /*
  139. * Sector Count Control Register bits 0 and 1 set:
  140. * software sets Sector Count Register for master and slave device
  141. */
  142. outw(0x0003, sc_base + 0x0c);
  143. /* Sector Count Register limit */
  144. hwif->rqsize = 0xffff;
  145. }
  146. static const struct ide_port_ops tc86c001_port_ops = {
  147. .set_pio_mode = tc86c001_set_pio_mode,
  148. .set_dma_mode = tc86c001_set_mode,
  149. .cable_detect = tc86c001_cable_detect,
  150. };
  151. static const struct ide_dma_ops tc86c001_dma_ops = {
  152. .dma_host_set = ide_dma_host_set,
  153. .dma_setup = ide_dma_setup,
  154. .dma_start = tc86c001_dma_start,
  155. .dma_end = ide_dma_end,
  156. .dma_test_irq = ide_dma_test_irq,
  157. .dma_lost_irq = ide_dma_lost_irq,
  158. .dma_timer_expiry = ide_dma_sff_timer_expiry,
  159. .dma_sff_read_status = ide_dma_sff_read_status,
  160. };
  161. static const struct ide_port_info tc86c001_chipset = {
  162. .name = DRV_NAME,
  163. .init_hwif = init_hwif_tc86c001,
  164. .port_ops = &tc86c001_port_ops,
  165. .dma_ops = &tc86c001_dma_ops,
  166. .host_flags = IDE_HFLAG_SINGLE | IDE_HFLAG_OFF_BOARD,
  167. .pio_mask = ATA_PIO4,
  168. .mwdma_mask = ATA_MWDMA2,
  169. .udma_mask = ATA_UDMA4,
  170. };
  171. static int tc86c001_init_one(struct pci_dev *dev,
  172. const struct pci_device_id *id)
  173. {
  174. int rc;
  175. rc = pci_enable_device(dev);
  176. if (rc)
  177. goto out;
  178. rc = pci_request_region(dev, 5, DRV_NAME);
  179. if (rc) {
  180. printk(KERN_ERR DRV_NAME ": system control regs already in use");
  181. goto out_disable;
  182. }
  183. rc = ide_pci_init_one(dev, &tc86c001_chipset, NULL);
  184. if (rc)
  185. goto out_release;
  186. goto out;
  187. out_release:
  188. pci_release_region(dev, 5);
  189. out_disable:
  190. pci_disable_device(dev);
  191. out:
  192. return rc;
  193. }
  194. static void tc86c001_remove(struct pci_dev *dev)
  195. {
  196. ide_pci_remove(dev);
  197. pci_release_region(dev, 5);
  198. pci_disable_device(dev);
  199. }
  200. static const struct pci_device_id tc86c001_pci_tbl[] = {
  201. { PCI_VDEVICE(TOSHIBA_2, PCI_DEVICE_ID_TOSHIBA_TC86C001_IDE), 0 },
  202. { 0, }
  203. };
  204. MODULE_DEVICE_TABLE(pci, tc86c001_pci_tbl);
  205. static struct pci_driver tc86c001_pci_driver = {
  206. .name = "TC86C001",
  207. .id_table = tc86c001_pci_tbl,
  208. .probe = tc86c001_init_one,
  209. .remove = tc86c001_remove,
  210. };
  211. static int __init tc86c001_ide_init(void)
  212. {
  213. return ide_pci_register_driver(&tc86c001_pci_driver);
  214. }
  215. static void __exit tc86c001_ide_exit(void)
  216. {
  217. pci_unregister_driver(&tc86c001_pci_driver);
  218. }
  219. module_init(tc86c001_ide_init);
  220. module_exit(tc86c001_ide_exit);
  221. MODULE_AUTHOR("MontaVista Software, Inc. <source@mvista.com>");
  222. MODULE_DESCRIPTION("PCI driver module for TC86C001 IDE");
  223. MODULE_LICENSE("GPL");