pata_platform.c 6.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242
  1. /*
  2. * Generic platform device PATA driver
  3. *
  4. * Copyright (C) 2006 - 2007 Paul Mundt
  5. *
  6. * Based on pata_pcmcia:
  7. *
  8. * Copyright 2005-2006 Red Hat Inc, all rights reserved.
  9. *
  10. * This file is subject to the terms and conditions of the GNU General Public
  11. * License. See the file "COPYING" in the main directory of this archive
  12. * for more details.
  13. */
  14. #include <linux/kernel.h>
  15. #include <linux/module.h>
  16. #include <linux/blkdev.h>
  17. #include <scsi/scsi_host.h>
  18. #include <linux/ata.h>
  19. #include <linux/libata.h>
  20. #include <linux/platform_device.h>
  21. #include <linux/ata_platform.h>
  22. #define DRV_NAME "pata_platform"
  23. #define DRV_VERSION "1.2"
  24. static int pio_mask = 1;
  25. /*
  26. * Provide our own set_mode() as we don't want to change anything that has
  27. * already been configured..
  28. */
  29. static int pata_platform_set_mode(struct ata_link *link, struct ata_device **unused)
  30. {
  31. struct ata_device *dev;
  32. ata_for_each_dev(dev, link, ENABLED) {
  33. /* We don't really care */
  34. dev->pio_mode = dev->xfer_mode = XFER_PIO_0;
  35. dev->xfer_shift = ATA_SHIFT_PIO;
  36. dev->flags |= ATA_DFLAG_PIO;
  37. ata_dev_info(dev, "configured for PIO\n");
  38. }
  39. return 0;
  40. }
  41. static struct scsi_host_template pata_platform_sht = {
  42. ATA_PIO_SHT(DRV_NAME),
  43. };
  44. static void pata_platform_setup_port(struct ata_ioports *ioaddr,
  45. unsigned int shift)
  46. {
  47. /* Fixup the port shift for platforms that need it */
  48. ioaddr->data_addr = ioaddr->cmd_addr + (ATA_REG_DATA << shift);
  49. ioaddr->error_addr = ioaddr->cmd_addr + (ATA_REG_ERR << shift);
  50. ioaddr->feature_addr = ioaddr->cmd_addr + (ATA_REG_FEATURE << shift);
  51. ioaddr->nsect_addr = ioaddr->cmd_addr + (ATA_REG_NSECT << shift);
  52. ioaddr->lbal_addr = ioaddr->cmd_addr + (ATA_REG_LBAL << shift);
  53. ioaddr->lbam_addr = ioaddr->cmd_addr + (ATA_REG_LBAM << shift);
  54. ioaddr->lbah_addr = ioaddr->cmd_addr + (ATA_REG_LBAH << shift);
  55. ioaddr->device_addr = ioaddr->cmd_addr + (ATA_REG_DEVICE << shift);
  56. ioaddr->status_addr = ioaddr->cmd_addr + (ATA_REG_STATUS << shift);
  57. ioaddr->command_addr = ioaddr->cmd_addr + (ATA_REG_CMD << shift);
  58. }
  59. /**
  60. * __pata_platform_probe - attach a platform interface
  61. * @dev: device
  62. * @io_res: Resource representing I/O base
  63. * @ctl_res: Resource representing CTL base
  64. * @irq_res: Resource representing IRQ and its flags
  65. * @ioport_shift: I/O port shift
  66. * @__pio_mask: PIO mask
  67. * @sht: scsi_host_template to use when registering
  68. * @use16bit: Flag to indicate 16-bit IO instead of 32-bit
  69. *
  70. * Register a platform bus IDE interface. Such interfaces are PIO and we
  71. * assume do not support IRQ sharing.
  72. *
  73. * Platform devices are expected to contain at least 2 resources per port:
  74. *
  75. * - I/O Base (IORESOURCE_IO or IORESOURCE_MEM)
  76. * - CTL Base (IORESOURCE_IO or IORESOURCE_MEM)
  77. *
  78. * and optionally:
  79. *
  80. * - IRQ (IORESOURCE_IRQ)
  81. *
  82. * If the base resources are both mem types, the ioremap() is handled
  83. * here. For IORESOURCE_IO, it's assumed that there's no remapping
  84. * necessary.
  85. *
  86. * If no IRQ resource is present, PIO polling mode is used instead.
  87. */
  88. int __pata_platform_probe(struct device *dev, struct resource *io_res,
  89. struct resource *ctl_res, struct resource *irq_res,
  90. unsigned int ioport_shift, int __pio_mask,
  91. struct scsi_host_template *sht, bool use16bit)
  92. {
  93. struct ata_host *host;
  94. struct ata_port *ap;
  95. unsigned int mmio;
  96. int irq = 0;
  97. int irq_flags = 0;
  98. /*
  99. * Check for MMIO
  100. */
  101. mmio = (( io_res->flags == IORESOURCE_MEM) &&
  102. (ctl_res->flags == IORESOURCE_MEM));
  103. /*
  104. * And the IRQ
  105. */
  106. if (irq_res && irq_res->start > 0) {
  107. irq = irq_res->start;
  108. irq_flags = (irq_res->flags & IRQF_TRIGGER_MASK) | IRQF_SHARED;
  109. }
  110. /*
  111. * Now that that's out of the way, wire up the port..
  112. */
  113. host = ata_host_alloc(dev, 1);
  114. if (!host)
  115. return -ENOMEM;
  116. ap = host->ports[0];
  117. ap->ops = devm_kzalloc(dev, sizeof(*ap->ops), GFP_KERNEL);
  118. ap->ops->inherits = &ata_sff_port_ops;
  119. ap->ops->cable_detect = ata_cable_unknown;
  120. ap->ops->set_mode = pata_platform_set_mode;
  121. if (use16bit)
  122. ap->ops->sff_data_xfer = ata_sff_data_xfer;
  123. else
  124. ap->ops->sff_data_xfer = ata_sff_data_xfer32;
  125. ap->pio_mask = __pio_mask;
  126. ap->flags |= ATA_FLAG_SLAVE_POSS;
  127. /*
  128. * Use polling mode if there's no IRQ
  129. */
  130. if (!irq) {
  131. ap->flags |= ATA_FLAG_PIO_POLLING;
  132. ata_port_desc(ap, "no IRQ, using PIO polling");
  133. }
  134. /*
  135. * Handle the MMIO case
  136. */
  137. if (mmio) {
  138. ap->ioaddr.cmd_addr = devm_ioremap(dev, io_res->start,
  139. resource_size(io_res));
  140. ap->ioaddr.ctl_addr = devm_ioremap(dev, ctl_res->start,
  141. resource_size(ctl_res));
  142. } else {
  143. ap->ioaddr.cmd_addr = devm_ioport_map(dev, io_res->start,
  144. resource_size(io_res));
  145. ap->ioaddr.ctl_addr = devm_ioport_map(dev, ctl_res->start,
  146. resource_size(ctl_res));
  147. }
  148. if (!ap->ioaddr.cmd_addr || !ap->ioaddr.ctl_addr) {
  149. dev_err(dev, "failed to map IO/CTL base\n");
  150. return -ENOMEM;
  151. }
  152. ap->ioaddr.altstatus_addr = ap->ioaddr.ctl_addr;
  153. pata_platform_setup_port(&ap->ioaddr, ioport_shift);
  154. ata_port_desc(ap, "%s cmd 0x%llx ctl 0x%llx", mmio ? "mmio" : "ioport",
  155. (unsigned long long)io_res->start,
  156. (unsigned long long)ctl_res->start);
  157. /* activate */
  158. return ata_host_activate(host, irq, irq ? ata_sff_interrupt : NULL,
  159. irq_flags, sht);
  160. }
  161. EXPORT_SYMBOL_GPL(__pata_platform_probe);
  162. static int pata_platform_probe(struct platform_device *pdev)
  163. {
  164. struct resource *io_res;
  165. struct resource *ctl_res;
  166. struct resource *irq_res;
  167. struct pata_platform_info *pp_info = dev_get_platdata(&pdev->dev);
  168. /*
  169. * Simple resource validation ..
  170. */
  171. if ((pdev->num_resources != 3) && (pdev->num_resources != 2)) {
  172. dev_err(&pdev->dev, "invalid number of resources\n");
  173. return -EINVAL;
  174. }
  175. /*
  176. * Get the I/O base first
  177. */
  178. io_res = platform_get_resource(pdev, IORESOURCE_IO, 0);
  179. if (io_res == NULL) {
  180. io_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  181. if (unlikely(io_res == NULL))
  182. return -EINVAL;
  183. }
  184. /*
  185. * Then the CTL base
  186. */
  187. ctl_res = platform_get_resource(pdev, IORESOURCE_IO, 1);
  188. if (ctl_res == NULL) {
  189. ctl_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
  190. if (unlikely(ctl_res == NULL))
  191. return -EINVAL;
  192. }
  193. /*
  194. * And the IRQ
  195. */
  196. irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
  197. return __pata_platform_probe(&pdev->dev, io_res, ctl_res, irq_res,
  198. pp_info ? pp_info->ioport_shift : 0,
  199. pio_mask, &pata_platform_sht, false);
  200. }
  201. static struct platform_driver pata_platform_driver = {
  202. .probe = pata_platform_probe,
  203. .remove = ata_platform_remove_one,
  204. .driver = {
  205. .name = DRV_NAME,
  206. },
  207. };
  208. module_platform_driver(pata_platform_driver);
  209. module_param(pio_mask, int, 0);
  210. MODULE_AUTHOR("Paul Mundt");
  211. MODULE_DESCRIPTION("low-level driver for platform device ATA");
  212. MODULE_LICENSE("GPL");
  213. MODULE_VERSION(DRV_VERSION);
  214. MODULE_ALIAS("platform:" DRV_NAME);