2 * AHCI SATA platform library
4 * Copyright 2004-2005 Red Hat, Inc.
5 * Jeff Garzik <jgarzik@pobox.com>
6 * Copyright 2010 MontaVista Software, LLC.
7 * Anton Vorontsov <avorontsov@ru.mvista.com>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2, or (at your option)
15 #include <linux/clk.h>
16 #include <linux/kernel.h>
17 #include <linux/gfp.h>
18 #include <linux/module.h>
20 #include <linux/interrupt.h>
21 #include <linux/device.h>
22 #include <linux/platform_device.h>
23 #include <linux/libata.h>
24 #include <linux/ahci_platform.h>
25 #include <linux/phy/phy.h>
26 #include <linux/pm_runtime.h>
27 #include <linux/of_platform.h>
30 static void ahci_host_stop(struct ata_host *host);
32 struct ata_port_operations ahci_platform_ops = {
33 .inherits = &ahci_ops,
34 .host_stop = ahci_host_stop,
36 EXPORT_SYMBOL_GPL(ahci_platform_ops);
39 * ahci_platform_enable_phys - Enable PHYs
40 * @hpriv: host private area to store config values
42 * This function enables all the PHYs found in hpriv->phys, if any.
43 * If a PHY fails to be enabled, it disables all the PHYs already
44 * enabled in reverse order and returns an error.
47 * 0 on success otherwise a negative error code
49 int ahci_platform_enable_phys(struct ahci_host_priv *hpriv)
53 for (i = 0; i < hpriv->nports; i++) {
54 rc = phy_init(hpriv->phys[i]);
58 rc = phy_power_on(hpriv->phys[i]);
60 phy_exit(hpriv->phys[i]);
69 phy_power_off(hpriv->phys[i]);
70 phy_exit(hpriv->phys[i]);
74 EXPORT_SYMBOL_GPL(ahci_platform_enable_phys);
77 * ahci_platform_disable_phys - Disable PHYs
78 * @hpriv: host private area to store config values
80 * This function disables all PHYs found in hpriv->phys.
82 void ahci_platform_disable_phys(struct ahci_host_priv *hpriv)
86 for (i = 0; i < hpriv->nports; i++) {
87 phy_power_off(hpriv->phys[i]);
88 phy_exit(hpriv->phys[i]);
91 EXPORT_SYMBOL_GPL(ahci_platform_disable_phys);
94 * ahci_platform_enable_clks - Enable platform clocks
95 * @hpriv: host private area to store config values
97 * This function enables all the clks found in hpriv->clks, starting at
98 * index 0. If any clk fails to enable it disables all the clks already
99 * enabled in reverse order, and then returns an error.
102 * 0 on success otherwise a negative error code
104 int ahci_platform_enable_clks(struct ahci_host_priv *hpriv)
108 for (c = 0; c < AHCI_MAX_CLKS && hpriv->clks[c]; c++) {
109 rc = clk_prepare_enable(hpriv->clks[c]);
111 goto disable_unprepare_clk;
115 disable_unprepare_clk:
117 clk_disable_unprepare(hpriv->clks[c]);
120 EXPORT_SYMBOL_GPL(ahci_platform_enable_clks);
123 * ahci_platform_disable_clks - Disable platform clocks
124 * @hpriv: host private area to store config values
126 * This function disables all the clks found in hpriv->clks, in reverse
127 * order of ahci_platform_enable_clks (starting at the end of the array).
129 void ahci_platform_disable_clks(struct ahci_host_priv *hpriv)
133 for (c = AHCI_MAX_CLKS - 1; c >= 0; c--)
135 clk_disable_unprepare(hpriv->clks[c]);
137 EXPORT_SYMBOL_GPL(ahci_platform_disable_clks);
140 * ahci_platform_enable_regulators - Enable regulators
141 * @hpriv: host private area to store config values
143 * This function enables all the regulators found in
144 * hpriv->target_pwrs, if any. If a regulator fails to be enabled, it
145 * disables all the regulators already enabled in reverse order and
149 * 0 on success otherwise a negative error code
151 int ahci_platform_enable_regulators(struct ahci_host_priv *hpriv)
155 for (i = 0; i < hpriv->nports; i++) {
156 if (!hpriv->target_pwrs[i])
159 rc = regulator_enable(hpriv->target_pwrs[i]);
161 goto disable_target_pwrs;
168 if (hpriv->target_pwrs[i])
169 regulator_disable(hpriv->target_pwrs[i]);
173 EXPORT_SYMBOL_GPL(ahci_platform_enable_regulators);
176 * ahci_platform_disable_regulators - Disable regulators
177 * @hpriv: host private area to store config values
179 * This function disables all regulators found in hpriv->target_pwrs.
181 void ahci_platform_disable_regulators(struct ahci_host_priv *hpriv)
185 for (i = 0; i < hpriv->nports; i++) {
186 if (!hpriv->target_pwrs[i])
188 regulator_disable(hpriv->target_pwrs[i]);
191 EXPORT_SYMBOL_GPL(ahci_platform_disable_regulators);
193 * ahci_platform_enable_resources - Enable platform resources
194 * @hpriv: host private area to store config values
196 * This function enables all ahci_platform managed resources in the
199 * 2) Clocks (through ahci_platform_enable_clks)
202 * If resource enabling fails at any point the previous enabled resources
203 * are disabled in reverse order.
206 * 0 on success otherwise a negative error code
208 int ahci_platform_enable_resources(struct ahci_host_priv *hpriv)
212 rc = ahci_platform_enable_regulators(hpriv);
216 rc = ahci_platform_enable_clks(hpriv);
218 goto disable_regulator;
220 rc = ahci_platform_enable_phys(hpriv);
227 ahci_platform_disable_clks(hpriv);
230 ahci_platform_disable_regulators(hpriv);
234 EXPORT_SYMBOL_GPL(ahci_platform_enable_resources);
237 * ahci_platform_disable_resources - Disable platform resources
238 * @hpriv: host private area to store config values
240 * This function disables all ahci_platform managed resources in the
243 * 2) Clocks (through ahci_platform_disable_clks)
246 void ahci_platform_disable_resources(struct ahci_host_priv *hpriv)
248 ahci_platform_disable_phys(hpriv);
250 ahci_platform_disable_clks(hpriv);
252 ahci_platform_disable_regulators(hpriv);
254 EXPORT_SYMBOL_GPL(ahci_platform_disable_resources);
256 static void ahci_platform_put_resources(struct device *dev, void *res)
258 struct ahci_host_priv *hpriv = res;
261 if (hpriv->got_runtime_pm) {
262 pm_runtime_put_sync(dev);
263 pm_runtime_disable(dev);
266 for (c = 0; c < AHCI_MAX_CLKS && hpriv->clks[c]; c++)
267 clk_put(hpriv->clks[c]);
269 * The regulators are tied to child node device and not to the
270 * SATA device itself. So we can't use devm for automatically
271 * releasing them. We have to do it manually here.
273 for (c = 0; c < hpriv->nports; c++)
274 if (hpriv->target_pwrs && hpriv->target_pwrs[c])
275 regulator_put(hpriv->target_pwrs[c]);
277 kfree(hpriv->target_pwrs);
280 static int ahci_platform_get_phy(struct ahci_host_priv *hpriv, u32 port,
281 struct device *dev, struct device_node *node)
285 hpriv->phys[port] = devm_of_phy_get(dev, node, NULL);
287 if (!IS_ERR(hpriv->phys[port]))
290 rc = PTR_ERR(hpriv->phys[port]);
293 /* No PHY support. Check if PHY is required. */
294 if (of_find_property(node, "phys", NULL)) {
296 "couldn't get PHY in node %s: ENOSYS\n",
301 /* continue normally */
302 hpriv->phys[port] = NULL;
306 /* Do not complain yet */
311 "couldn't get PHY in node %s: %d\n",
320 static int ahci_platform_get_regulator(struct ahci_host_priv *hpriv, u32 port,
323 struct regulator *target_pwr;
326 target_pwr = regulator_get_optional(dev, "target");
328 if (!IS_ERR(target_pwr))
329 hpriv->target_pwrs[port] = target_pwr;
331 rc = PTR_ERR(target_pwr);
337 * ahci_platform_get_resources - Get platform resources
338 * @pdev: platform device to get resources for
340 * This function allocates an ahci_host_priv struct, and gets the following
341 * resources, storing a reference to them inside the returned struct:
343 * 1) mmio registers (IORESOURCE_MEM 0, mandatory)
344 * 2) regulator for controlling the targets power (optional)
345 * 3) 0 - AHCI_MAX_CLKS clocks, as specified in the devs devicetree node,
346 * or for non devicetree enabled platforms a single clock
350 * The allocated ahci_host_priv on success, otherwise an ERR_PTR value
352 struct ahci_host_priv *ahci_platform_get_resources(struct platform_device *pdev)
354 struct device *dev = &pdev->dev;
355 struct ahci_host_priv *hpriv;
357 struct device_node *child;
358 int i, sz, enabled_ports = 0, rc = -ENOMEM, child_nodes;
359 u32 mask_port_map = 0;
361 if (!devres_open_group(dev, NULL, GFP_KERNEL))
362 return ERR_PTR(-ENOMEM);
364 hpriv = devres_alloc(ahci_platform_put_resources, sizeof(*hpriv),
369 devres_add(dev, hpriv);
371 hpriv->mmio = devm_ioremap_resource(dev,
372 platform_get_resource(pdev, IORESOURCE_MEM, 0));
373 if (IS_ERR(hpriv->mmio)) {
374 dev_err(dev, "no mmio space\n");
375 rc = PTR_ERR(hpriv->mmio);
379 for (i = 0; i < AHCI_MAX_CLKS; i++) {
381 * For now we must use clk_get(dev, NULL) for the first clock,
382 * because some platforms (da850, spear13xx) are not yet
383 * converted to use devicetree for clocks. For new platforms
384 * this is equivalent to of_clk_get(dev->of_node, 0).
387 clk = clk_get(dev, NULL);
389 clk = of_clk_get(dev->of_node, i);
393 if (rc == -EPROBE_DEFER)
397 hpriv->clks[i] = clk;
400 hpriv->nports = child_nodes = of_get_child_count(dev->of_node);
403 * If no sub-node was found, we still need to set nports to
404 * one in order to be able to use the
405 * ahci_platform_[en|dis]able_[phys|regulators] functions.
410 sz = hpriv->nports * sizeof(*hpriv->phys);
411 hpriv->phys = devm_kzalloc(dev, sz, GFP_KERNEL);
416 sz = hpriv->nports * sizeof(*hpriv->target_pwrs);
417 hpriv->target_pwrs = kzalloc(sz, GFP_KERNEL);
418 if (!hpriv->target_pwrs) {
424 for_each_child_of_node(dev->of_node, child) {
426 struct platform_device *port_dev __maybe_unused;
428 if (!of_device_is_available(child))
431 if (of_property_read_u32(child, "reg", &port)) {
436 if (port >= hpriv->nports) {
437 dev_warn(dev, "invalid port number %d\n", port);
440 mask_port_map |= BIT(port);
442 #ifdef CONFIG_OF_ADDRESS
443 of_platform_device_create(child, NULL, NULL);
445 port_dev = of_find_device_by_node(child);
448 rc = ahci_platform_get_regulator(hpriv, port,
450 if (rc == -EPROBE_DEFER)
455 rc = ahci_platform_get_phy(hpriv, port, dev, child);
461 if (!enabled_ports) {
462 dev_warn(dev, "No port enabled\n");
467 if (!hpriv->mask_port_map)
468 hpriv->mask_port_map = mask_port_map;
471 * If no sub-node was found, keep this for device tree
474 rc = ahci_platform_get_phy(hpriv, 0, dev, dev->of_node);
478 rc = ahci_platform_get_regulator(hpriv, 0, dev);
479 if (rc == -EPROBE_DEFER)
482 pm_runtime_enable(dev);
483 pm_runtime_get_sync(dev);
484 hpriv->got_runtime_pm = true;
486 devres_remove_group(dev, NULL);
490 devres_release_group(dev, NULL);
493 EXPORT_SYMBOL_GPL(ahci_platform_get_resources);
496 * ahci_platform_init_host - Bring up an ahci-platform host
497 * @pdev: platform device pointer for the host
498 * @hpriv: ahci-host private data for the host
499 * @pi_template: template for the ata_port_info to use
500 * @sht: scsi_host_template to use when registering
502 * This function does all the usual steps needed to bring up an
503 * ahci-platform host, note any necessary resources (ie clks, phys, etc.)
504 * must be initialized / enabled before calling this.
507 * 0 on success otherwise a negative error code
509 int ahci_platform_init_host(struct platform_device *pdev,
510 struct ahci_host_priv *hpriv,
511 const struct ata_port_info *pi_template,
512 struct scsi_host_template *sht)
514 struct device *dev = &pdev->dev;
515 struct ata_port_info pi = *pi_template;
516 const struct ata_port_info *ppi[] = { &pi, NULL };
517 struct ata_host *host;
518 int i, irq, n_ports, rc;
520 irq = platform_get_irq(pdev, 0);
522 if (irq != -EPROBE_DEFER)
523 dev_err(dev, "no irq\n");
532 pi.private_data = (void *)(unsigned long)hpriv->flags;
534 ahci_save_initial_config(dev, hpriv);
536 if (hpriv->cap & HOST_CAP_NCQ)
537 pi.flags |= ATA_FLAG_NCQ;
539 if (hpriv->cap & HOST_CAP_PMP)
540 pi.flags |= ATA_FLAG_PMP;
542 ahci_set_em_messages(hpriv, &pi);
544 /* CAP.NP sometimes indicate the index of the last enabled
545 * port, at other times, that of the last possible port, so
546 * determining the maximum port number requires looking at
547 * both CAP.NP and port_map.
549 n_ports = max(ahci_nr_ports(hpriv->cap), fls(hpriv->port_map));
551 host = ata_host_alloc_pinfo(dev, ppi, n_ports);
555 host->private_data = hpriv;
557 if (!(hpriv->cap & HOST_CAP_SSS) || ahci_ignore_sss)
558 host->flags |= ATA_HOST_PARALLEL_SCAN;
560 dev_info(dev, "SSS flag set, parallel bus scan disabled\n");
562 if (pi.flags & ATA_FLAG_EM)
565 for (i = 0; i < host->n_ports; i++) {
566 struct ata_port *ap = host->ports[i];
568 ata_port_desc(ap, "mmio %pR",
569 platform_get_resource(pdev, IORESOURCE_MEM, 0));
570 ata_port_desc(ap, "port 0x%x", 0x100 + ap->port_no * 0x80);
572 /* set enclosure management message type */
573 if (ap->flags & ATA_FLAG_EM)
574 ap->em_message_type = hpriv->em_msg_type;
576 /* disabled/not-implemented port */
577 if (!(hpriv->port_map & (1 << i)))
578 ap->ops = &ata_dummy_port_ops;
581 if (hpriv->cap & HOST_CAP_64) {
582 rc = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(64));
584 rc = dma_coerce_mask_and_coherent(dev,
587 dev_err(dev, "Failed to enable 64-bit DMA.\n");
590 dev_warn(dev, "Enable 32-bit DMA instead of 64-bit.\n");
594 rc = ahci_reset_controller(host);
598 ahci_init_controller(host);
599 ahci_print_info(host, "platform");
601 return ahci_host_activate(host, sht);
603 EXPORT_SYMBOL_GPL(ahci_platform_init_host);
605 static void ahci_host_stop(struct ata_host *host)
607 struct ahci_host_priv *hpriv = host->private_data;
609 ahci_platform_disable_resources(hpriv);
612 #ifdef CONFIG_PM_SLEEP
614 * ahci_platform_suspend_host - Suspend an ahci-platform host
615 * @dev: device pointer for the host
617 * This function does all the usual steps needed to suspend an
618 * ahci-platform host, note any necessary resources (ie clks, phys, etc.)
619 * must be disabled after calling this.
622 * 0 on success otherwise a negative error code
624 int ahci_platform_suspend_host(struct device *dev)
626 struct ata_host *host = dev_get_drvdata(dev);
627 struct ahci_host_priv *hpriv = host->private_data;
628 void __iomem *mmio = hpriv->mmio;
631 if (hpriv->flags & AHCI_HFLAG_NO_SUSPEND) {
632 dev_err(dev, "firmware update required for suspend/resume\n");
637 * AHCI spec rev1.1 section 8.3.3:
638 * Software must disable interrupts prior to requesting a
639 * transition of the HBA to D3 state.
641 ctl = readl(mmio + HOST_CTL);
643 writel(ctl, mmio + HOST_CTL);
644 readl(mmio + HOST_CTL); /* flush */
646 return ata_host_suspend(host, PMSG_SUSPEND);
648 EXPORT_SYMBOL_GPL(ahci_platform_suspend_host);
651 * ahci_platform_resume_host - Resume an ahci-platform host
652 * @dev: device pointer for the host
654 * This function does all the usual steps needed to resume an ahci-platform
655 * host, note any necessary resources (ie clks, phys, etc.) must be
656 * initialized / enabled before calling this.
659 * 0 on success otherwise a negative error code
661 int ahci_platform_resume_host(struct device *dev)
663 struct ata_host *host = dev_get_drvdata(dev);
666 if (dev->power.power_state.event == PM_EVENT_SUSPEND) {
667 rc = ahci_reset_controller(host);
671 ahci_init_controller(host);
674 ata_host_resume(host);
678 EXPORT_SYMBOL_GPL(ahci_platform_resume_host);
681 * ahci_platform_suspend - Suspend an ahci-platform device
682 * @dev: the platform device to suspend
684 * This function suspends the host associated with the device, followed by
685 * disabling all the resources of the device.
688 * 0 on success otherwise a negative error code
690 int ahci_platform_suspend(struct device *dev)
692 struct ata_host *host = dev_get_drvdata(dev);
693 struct ahci_host_priv *hpriv = host->private_data;
696 rc = ahci_platform_suspend_host(dev);
700 ahci_platform_disable_resources(hpriv);
704 EXPORT_SYMBOL_GPL(ahci_platform_suspend);
707 * ahci_platform_resume - Resume an ahci-platform device
708 * @dev: the platform device to resume
710 * This function enables all the resources of the device followed by
711 * resuming the host associated with the device.
714 * 0 on success otherwise a negative error code
716 int ahci_platform_resume(struct device *dev)
718 struct ata_host *host = dev_get_drvdata(dev);
719 struct ahci_host_priv *hpriv = host->private_data;
722 rc = ahci_platform_enable_resources(hpriv);
726 rc = ahci_platform_resume_host(dev);
728 goto disable_resources;
730 /* We resumed so update PM runtime state */
731 pm_runtime_disable(dev);
732 pm_runtime_set_active(dev);
733 pm_runtime_enable(dev);
738 ahci_platform_disable_resources(hpriv);
742 EXPORT_SYMBOL_GPL(ahci_platform_resume);
745 MODULE_DESCRIPTION("AHCI SATA platform library");
746 MODULE_AUTHOR("Anton Vorontsov <avorontsov@ru.mvista.com>");
747 MODULE_LICENSE("GPL");