1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * AHCI SATA platform library
4  *
5  * Copyright 2004-2005  Red Hat, Inc.
6  *   Jeff Garzik <jgarzik@pobox.com>
7  * Copyright 2010  MontaVista Software, LLC.
8  *   Anton Vorontsov <avorontsov@ru.mvista.com>
9  */
10 
11 #include <linux/clk.h>
12 #include <linux/kernel.h>
13 #include <linux/gfp.h>
14 #include <linux/module.h>
15 #include <linux/pm.h>
16 #include <linux/interrupt.h>
17 #include <linux/device.h>
18 #include <linux/platform_device.h>
19 #include <linux/libata.h>
20 #include <linux/ahci_platform.h>
21 #include <linux/phy/phy.h>
22 #include <linux/pm_runtime.h>
23 #include <linux/of.h>
24 #include <linux/of_platform.h>
25 #include <linux/reset.h>
26 #include "ahci.h"
27 
28 static void ahci_host_stop(struct ata_host *host);
29 
30 struct ata_port_operations ahci_platform_ops = {
31 	.inherits	= &ahci_ops,
32 	.host_stop	= ahci_host_stop,
33 };
34 EXPORT_SYMBOL_GPL(ahci_platform_ops);
35 
36 /**
37  * ahci_platform_enable_phys - Enable PHYs
38  * @hpriv: host private area to store config values
39  *
40  * This function enables all the PHYs found in hpriv->phys, if any.
41  * If a PHY fails to be enabled, it disables all the PHYs already
42  * enabled in reverse order and returns an error.
43  *
44  * RETURNS:
45  * 0 on success otherwise a negative error code
46  */
47 int ahci_platform_enable_phys(struct ahci_host_priv *hpriv)
48 {
49 	int rc, i;
50 
51 	for (i = 0; i < hpriv->nports; i++) {
52 		rc = phy_init(hpriv->phys[i]);
53 		if (rc)
54 			goto disable_phys;
55 
56 		rc = phy_set_mode(hpriv->phys[i], PHY_MODE_SATA);
57 		if (rc) {
58 			phy_exit(hpriv->phys[i]);
59 			goto disable_phys;
60 		}
61 
62 		rc = phy_power_on(hpriv->phys[i]);
63 		if (rc) {
64 			phy_exit(hpriv->phys[i]);
65 			goto disable_phys;
66 		}
67 	}
68 
69 	return 0;
70 
71 disable_phys:
72 	while (--i >= 0) {
73 		phy_power_off(hpriv->phys[i]);
74 		phy_exit(hpriv->phys[i]);
75 	}
76 	return rc;
77 }
78 EXPORT_SYMBOL_GPL(ahci_platform_enable_phys);
79 
80 /**
81  * ahci_platform_disable_phys - Disable PHYs
82  * @hpriv: host private area to store config values
83  *
84  * This function disables all PHYs found in hpriv->phys.
85  */
86 void ahci_platform_disable_phys(struct ahci_host_priv *hpriv)
87 {
88 	int i;
89 
90 	for (i = 0; i < hpriv->nports; i++) {
91 		phy_power_off(hpriv->phys[i]);
92 		phy_exit(hpriv->phys[i]);
93 	}
94 }
95 EXPORT_SYMBOL_GPL(ahci_platform_disable_phys);
96 
97 /**
98  * ahci_platform_find_clk - Find platform clock
99  * @hpriv: host private area to store config values
100  * @con_id: clock connection ID
101  *
102  * This function returns a pointer to the clock descriptor of the clock with
103  * the passed ID.
104  *
105  * RETURNS:
106  * Pointer to the clock descriptor on success otherwise NULL
107  */
108 struct clk *ahci_platform_find_clk(struct ahci_host_priv *hpriv, const char *con_id)
109 {
110 	int i;
111 
112 	for (i = 0; i < hpriv->n_clks; i++) {
113 		if (hpriv->clks[i].id && !strcmp(hpriv->clks[i].id, con_id))
114 			return hpriv->clks[i].clk;
115 	}
116 
117 	return NULL;
118 }
119 EXPORT_SYMBOL_GPL(ahci_platform_find_clk);
120 
121 /**
122  * ahci_platform_enable_clks - Enable platform clocks
123  * @hpriv: host private area to store config values
124  *
125  * This function enables all the clks found for the AHCI device.
126  *
127  * RETURNS:
128  * 0 on success otherwise a negative error code
129  */
130 int ahci_platform_enable_clks(struct ahci_host_priv *hpriv)
131 {
132 	return clk_bulk_prepare_enable(hpriv->n_clks, hpriv->clks);
133 }
134 EXPORT_SYMBOL_GPL(ahci_platform_enable_clks);
135 
136 /**
137  * ahci_platform_disable_clks - Disable platform clocks
138  * @hpriv: host private area to store config values
139  *
140  * This function disables all the clocks enabled before
141  * (bulk-clocks-disable function is supposed to do that in reverse
142  * from the enabling procedure order).
143  */
144 void ahci_platform_disable_clks(struct ahci_host_priv *hpriv)
145 {
146 	clk_bulk_disable_unprepare(hpriv->n_clks, hpriv->clks);
147 }
148 EXPORT_SYMBOL_GPL(ahci_platform_disable_clks);
149 
150 /**
151  * ahci_platform_deassert_rsts - Deassert/trigger platform resets
152  * @hpriv: host private area to store config values
153  *
154  * This function deasserts or triggers all the reset lines found for
155  * the AHCI device.
156  *
157  * RETURNS:
158  * 0 on success otherwise a negative error code
159  */
160 int ahci_platform_deassert_rsts(struct ahci_host_priv *hpriv)
161 {
162 	if (hpriv->f_rsts & AHCI_PLATFORM_RST_TRIGGER)
163 		return reset_control_reset(hpriv->rsts);
164 
165 	return reset_control_deassert(hpriv->rsts);
166 }
167 EXPORT_SYMBOL_GPL(ahci_platform_deassert_rsts);
168 
169 /**
170  * ahci_platform_assert_rsts - Assert/rearm platform resets
171  * @hpriv: host private area to store config values
172  *
173  * This function asserts or rearms (for self-deasserting resets) all
174  * the reset controls found for the AHCI device.
175  *
176  * RETURNS:
177  * 0 on success otherwise a negative error code
178  */
179 int ahci_platform_assert_rsts(struct ahci_host_priv *hpriv)
180 {
181 	if (hpriv->f_rsts & AHCI_PLATFORM_RST_TRIGGER)
182 		return reset_control_rearm(hpriv->rsts);
183 
184 	return reset_control_assert(hpriv->rsts);
185 }
186 EXPORT_SYMBOL_GPL(ahci_platform_assert_rsts);
187 
188 /**
189  * ahci_platform_enable_regulators - Enable regulators
190  * @hpriv: host private area to store config values
191  *
192  * This function enables all the regulators found in controller and
193  * hpriv->target_pwrs, if any.  If a regulator fails to be enabled, it
194  * disables all the regulators already enabled in reverse order and
195  * returns an error.
196  *
197  * RETURNS:
198  * 0 on success otherwise a negative error code
199  */
200 int ahci_platform_enable_regulators(struct ahci_host_priv *hpriv)
201 {
202 	int rc, i;
203 
204 	rc = regulator_enable(hpriv->ahci_regulator);
205 	if (rc)
206 		return rc;
207 
208 	rc = regulator_enable(hpriv->phy_regulator);
209 	if (rc)
210 		goto disable_ahci_pwrs;
211 
212 	for (i = 0; i < hpriv->nports; i++) {
213 		if (!hpriv->target_pwrs[i])
214 			continue;
215 
216 		rc = regulator_enable(hpriv->target_pwrs[i]);
217 		if (rc)
218 			goto disable_target_pwrs;
219 	}
220 
221 	return 0;
222 
223 disable_target_pwrs:
224 	while (--i >= 0)
225 		if (hpriv->target_pwrs[i])
226 			regulator_disable(hpriv->target_pwrs[i]);
227 
228 	regulator_disable(hpriv->phy_regulator);
229 disable_ahci_pwrs:
230 	regulator_disable(hpriv->ahci_regulator);
231 	return rc;
232 }
233 EXPORT_SYMBOL_GPL(ahci_platform_enable_regulators);
234 
235 /**
236  * ahci_platform_disable_regulators - Disable regulators
237  * @hpriv: host private area to store config values
238  *
239  * This function disables all regulators found in hpriv->target_pwrs and
240  * AHCI controller.
241  */
242 void ahci_platform_disable_regulators(struct ahci_host_priv *hpriv)
243 {
244 	int i;
245 
246 	for (i = 0; i < hpriv->nports; i++) {
247 		if (!hpriv->target_pwrs[i])
248 			continue;
249 		regulator_disable(hpriv->target_pwrs[i]);
250 	}
251 
252 	regulator_disable(hpriv->ahci_regulator);
253 	regulator_disable(hpriv->phy_regulator);
254 }
255 EXPORT_SYMBOL_GPL(ahci_platform_disable_regulators);
256 /**
257  * ahci_platform_enable_resources - Enable platform resources
258  * @hpriv: host private area to store config values
259  *
260  * This function enables all ahci_platform managed resources in the
261  * following order:
262  * 1) Regulator
263  * 2) Clocks (through ahci_platform_enable_clks)
264  * 3) Resets
265  * 4) Phys
266  *
267  * If resource enabling fails at any point the previous enabled resources
268  * are disabled in reverse order.
269  *
270  * RETURNS:
271  * 0 on success otherwise a negative error code
272  */
273 int ahci_platform_enable_resources(struct ahci_host_priv *hpriv)
274 {
275 	int rc;
276 
277 	rc = ahci_platform_enable_regulators(hpriv);
278 	if (rc)
279 		return rc;
280 
281 	rc = ahci_platform_enable_clks(hpriv);
282 	if (rc)
283 		goto disable_regulator;
284 
285 	rc = ahci_platform_deassert_rsts(hpriv);
286 	if (rc)
287 		goto disable_clks;
288 
289 	rc = ahci_platform_enable_phys(hpriv);
290 	if (rc)
291 		goto disable_rsts;
292 
293 	return 0;
294 
295 disable_rsts:
296 	ahci_platform_assert_rsts(hpriv);
297 
298 disable_clks:
299 	ahci_platform_disable_clks(hpriv);
300 
301 disable_regulator:
302 	ahci_platform_disable_regulators(hpriv);
303 
304 	return rc;
305 }
306 EXPORT_SYMBOL_GPL(ahci_platform_enable_resources);
307 
308 /**
309  * ahci_platform_disable_resources - Disable platform resources
310  * @hpriv: host private area to store config values
311  *
312  * This function disables all ahci_platform managed resources in the
313  * following order:
314  * 1) Phys
315  * 2) Resets
316  * 3) Clocks (through ahci_platform_disable_clks)
317  * 4) Regulator
318  */
319 void ahci_platform_disable_resources(struct ahci_host_priv *hpriv)
320 {
321 	ahci_platform_disable_phys(hpriv);
322 
323 	ahci_platform_assert_rsts(hpriv);
324 
325 	ahci_platform_disable_clks(hpriv);
326 
327 	ahci_platform_disable_regulators(hpriv);
328 }
329 EXPORT_SYMBOL_GPL(ahci_platform_disable_resources);
330 
331 static void ahci_platform_put_resources(struct device *dev, void *res)
332 {
333 	struct ahci_host_priv *hpriv = res;
334 	int c;
335 
336 	if (hpriv->got_runtime_pm) {
337 		pm_runtime_put_sync(dev);
338 		pm_runtime_disable(dev);
339 	}
340 
341 	/*
342 	 * The regulators are tied to child node device and not to the
343 	 * SATA device itself. So we can't use devm for automatically
344 	 * releasing them. We have to do it manually here.
345 	 */
346 	for (c = 0; c < hpriv->nports; c++)
347 		if (hpriv->target_pwrs && hpriv->target_pwrs[c])
348 			regulator_put(hpriv->target_pwrs[c]);
349 
350 	kfree(hpriv->target_pwrs);
351 }
352 
353 static int ahci_platform_get_phy(struct ahci_host_priv *hpriv, u32 port,
354 				struct device *dev, struct device_node *node)
355 {
356 	int rc;
357 
358 	hpriv->phys[port] = devm_of_phy_get(dev, node, NULL);
359 
360 	if (!IS_ERR(hpriv->phys[port]))
361 		return 0;
362 
363 	rc = PTR_ERR(hpriv->phys[port]);
364 	switch (rc) {
365 	case -ENOSYS:
366 		/* No PHY support. Check if PHY is required. */
367 		if (of_property_present(node, "phys")) {
368 			dev_err(dev,
369 				"couldn't get PHY in node %pOFn: ENOSYS\n",
370 				node);
371 			break;
372 		}
373 		fallthrough;
374 	case -ENODEV:
375 		/* continue normally */
376 		hpriv->phys[port] = NULL;
377 		rc = 0;
378 		break;
379 	case -EPROBE_DEFER:
380 		/* Do not complain yet */
381 		break;
382 
383 	default:
384 		dev_err(dev,
385 			"couldn't get PHY in node %pOFn: %d\n",
386 			node, rc);
387 
388 		break;
389 	}
390 
391 	return rc;
392 }
393 
394 static int ahci_platform_get_regulator(struct ahci_host_priv *hpriv, u32 port,
395 				struct device *dev)
396 {
397 	struct regulator *target_pwr;
398 	int rc = 0;
399 
400 	target_pwr = regulator_get(dev, "target");
401 
402 	if (!IS_ERR(target_pwr))
403 		hpriv->target_pwrs[port] = target_pwr;
404 	else
405 		rc = PTR_ERR(target_pwr);
406 
407 	return rc;
408 }
409 
410 static int ahci_platform_get_firmware(struct ahci_host_priv *hpriv,
411 				      struct device *dev)
412 {
413 	struct device_node *child;
414 	u32 port;
415 
416 	if (!of_property_read_u32(dev->of_node, "hba-cap", &hpriv->saved_cap))
417 		hpriv->saved_cap &= (HOST_CAP_SSS | HOST_CAP_MPS);
418 
419 	of_property_read_u32(dev->of_node,
420 			     "ports-implemented", &hpriv->saved_port_map);
421 
422 	for_each_child_of_node(dev->of_node, child) {
423 		if (!of_device_is_available(child))
424 			continue;
425 
426 		if (of_property_read_u32(child, "reg", &port)) {
427 			of_node_put(child);
428 			return -EINVAL;
429 		}
430 
431 		if (!of_property_read_u32(child, "hba-port-cap", &hpriv->saved_port_cap[port]))
432 			hpriv->saved_port_cap[port] &= PORT_CMD_CAP;
433 	}
434 
435 	return 0;
436 }
437 
438 /**
439  * ahci_platform_get_resources - Get platform resources
440  * @pdev: platform device to get resources for
441  * @flags: bitmap representing the resource to get
442  *
443  * This function allocates an ahci_host_priv struct, and gets the following
444  * resources, storing a reference to them inside the returned struct:
445  *
446  * 1) mmio registers (IORESOURCE_MEM 0, mandatory)
447  * 2) regulator for controlling the targets power (optional)
448  *    regulator for controlling the AHCI controller (optional)
449  * 3) all clocks specified in the devicetree node, or a single
450  *    clock for non-OF platforms (optional)
451  * 4) resets, if flags has AHCI_PLATFORM_GET_RESETS (optional)
452  * 5) phys (optional)
453  *
454  * RETURNS:
455  * The allocated ahci_host_priv on success, otherwise an ERR_PTR value
456  */
457 struct ahci_host_priv *ahci_platform_get_resources(struct platform_device *pdev,
458 						   unsigned int flags)
459 {
460 	int child_nodes, rc = -ENOMEM, enabled_ports = 0;
461 	struct device *dev = &pdev->dev;
462 	struct ahci_host_priv *hpriv;
463 	struct device_node *child;
464 	u32 mask_port_map = 0;
465 
466 	if (!devres_open_group(dev, NULL, GFP_KERNEL))
467 		return ERR_PTR(-ENOMEM);
468 
469 	hpriv = devres_alloc(ahci_platform_put_resources, sizeof(*hpriv),
470 			     GFP_KERNEL);
471 	if (!hpriv)
472 		goto err_out;
473 
474 	devres_add(dev, hpriv);
475 
476 	/*
477 	 * If the DT provided an "ahci" named resource, use it. Otherwise,
478 	 * fallback to using the default first resource for the device node.
479 	 */
480 	if (platform_get_resource_byname(pdev, IORESOURCE_MEM, "ahci"))
481 		hpriv->mmio = devm_platform_ioremap_resource_byname(pdev, "ahci");
482 	else
483 		hpriv->mmio = devm_platform_ioremap_resource(pdev, 0);
484 	if (IS_ERR(hpriv->mmio)) {
485 		rc = PTR_ERR(hpriv->mmio);
486 		goto err_out;
487 	}
488 
489 	/*
490 	 * Bulk clocks getting procedure can fail to find any clock due to
491 	 * running on a non-OF platform or due to the clocks being defined in
492 	 * bypass of the DT firmware (like da850, spear13xx). In that case we
493 	 * fallback to getting a single clock source right from the dev clocks
494 	 * list.
495 	 */
496 	rc = devm_clk_bulk_get_all(dev, &hpriv->clks);
497 	if (rc < 0)
498 		goto err_out;
499 
500 	if (rc > 0) {
501 		/* Got clocks in bulk */
502 		hpriv->n_clks = rc;
503 	} else {
504 		/*
505 		 * No clock bulk found: fallback to manually getting
506 		 * the optional clock.
507 		 */
508 		hpriv->clks = devm_kzalloc(dev, sizeof(*hpriv->clks), GFP_KERNEL);
509 		if (!hpriv->clks) {
510 			rc = -ENOMEM;
511 			goto err_out;
512 		}
513 		hpriv->clks->clk = devm_clk_get_optional(dev, NULL);
514 		if (IS_ERR(hpriv->clks->clk)) {
515 			rc = PTR_ERR(hpriv->clks->clk);
516 			goto err_out;
517 		} else if (hpriv->clks->clk) {
518 			hpriv->clks->id = "ahci";
519 			hpriv->n_clks = 1;
520 		}
521 	}
522 
523 	hpriv->ahci_regulator = devm_regulator_get(dev, "ahci");
524 	if (IS_ERR(hpriv->ahci_regulator)) {
525 		rc = PTR_ERR(hpriv->ahci_regulator);
526 		if (rc != 0)
527 			goto err_out;
528 	}
529 
530 	hpriv->phy_regulator = devm_regulator_get(dev, "phy");
531 	if (IS_ERR(hpriv->phy_regulator)) {
532 		rc = PTR_ERR(hpriv->phy_regulator);
533 		goto err_out;
534 	}
535 
536 	if (flags & AHCI_PLATFORM_GET_RESETS) {
537 		hpriv->rsts = devm_reset_control_array_get_optional_shared(dev);
538 		if (IS_ERR(hpriv->rsts)) {
539 			rc = PTR_ERR(hpriv->rsts);
540 			goto err_out;
541 		}
542 
543 		hpriv->f_rsts = flags & AHCI_PLATFORM_RST_TRIGGER;
544 	}
545 
546 	/*
547 	 * Too many sub-nodes most likely means having something wrong with
548 	 * the firmware.
549 	 */
550 	child_nodes = of_get_child_count(dev->of_node);
551 	if (child_nodes > AHCI_MAX_PORTS) {
552 		rc = -EINVAL;
553 		goto err_out;
554 	}
555 
556 	/*
557 	 * If no sub-node was found, we still need to set nports to
558 	 * one in order to be able to use the
559 	 * ahci_platform_[en|dis]able_[phys|regulators] functions.
560 	 */
561 	if (child_nodes)
562 		hpriv->nports = child_nodes;
563 	else
564 		hpriv->nports = 1;
565 
566 	hpriv->phys = devm_kcalloc(dev, hpriv->nports, sizeof(*hpriv->phys), GFP_KERNEL);
567 	if (!hpriv->phys) {
568 		rc = -ENOMEM;
569 		goto err_out;
570 	}
571 	/*
572 	 * We cannot use devm_ here, since ahci_platform_put_resources() uses
573 	 * target_pwrs after devm_ have freed memory
574 	 */
575 	hpriv->target_pwrs = kcalloc(hpriv->nports, sizeof(*hpriv->target_pwrs), GFP_KERNEL);
576 	if (!hpriv->target_pwrs) {
577 		rc = -ENOMEM;
578 		goto err_out;
579 	}
580 
581 	if (child_nodes) {
582 		for_each_child_of_node(dev->of_node, child) {
583 			u32 port;
584 			struct platform_device *port_dev __maybe_unused;
585 
586 			if (!of_device_is_available(child))
587 				continue;
588 
589 			if (of_property_read_u32(child, "reg", &port)) {
590 				rc = -EINVAL;
591 				of_node_put(child);
592 				goto err_out;
593 			}
594 
595 			if (port >= hpriv->nports) {
596 				dev_warn(dev, "invalid port number %d\n", port);
597 				continue;
598 			}
599 			mask_port_map |= BIT(port);
600 
601 #ifdef CONFIG_OF_ADDRESS
602 			of_platform_device_create(child, NULL, NULL);
603 
604 			port_dev = of_find_device_by_node(child);
605 
606 			if (port_dev) {
607 				rc = ahci_platform_get_regulator(hpriv, port,
608 								&port_dev->dev);
609 				if (rc == -EPROBE_DEFER) {
610 					of_node_put(child);
611 					goto err_out;
612 				}
613 			}
614 #endif
615 
616 			rc = ahci_platform_get_phy(hpriv, port, dev, child);
617 			if (rc) {
618 				of_node_put(child);
619 				goto err_out;
620 			}
621 
622 			enabled_ports++;
623 		}
624 		if (!enabled_ports) {
625 			dev_warn(dev, "No port enabled\n");
626 			rc = -ENODEV;
627 			goto err_out;
628 		}
629 
630 		if (!hpriv->mask_port_map)
631 			hpriv->mask_port_map = mask_port_map;
632 	} else {
633 		/*
634 		 * If no sub-node was found, keep this for device tree
635 		 * compatibility
636 		 */
637 		rc = ahci_platform_get_phy(hpriv, 0, dev, dev->of_node);
638 		if (rc)
639 			goto err_out;
640 
641 		rc = ahci_platform_get_regulator(hpriv, 0, dev);
642 		if (rc == -EPROBE_DEFER)
643 			goto err_out;
644 	}
645 
646 	/*
647 	 * Retrieve firmware-specific flags which then will be used to set
648 	 * the HW-init fields of HBA and its ports
649 	 */
650 	rc = ahci_platform_get_firmware(hpriv, dev);
651 	if (rc)
652 		goto err_out;
653 
654 	pm_runtime_enable(dev);
655 	pm_runtime_get_sync(dev);
656 	hpriv->got_runtime_pm = true;
657 
658 	devres_remove_group(dev, NULL);
659 	return hpriv;
660 
661 err_out:
662 	devres_release_group(dev, NULL);
663 	return ERR_PTR(rc);
664 }
665 EXPORT_SYMBOL_GPL(ahci_platform_get_resources);
666 
667 /**
668  * ahci_platform_init_host - Bring up an ahci-platform host
669  * @pdev: platform device pointer for the host
670  * @hpriv: ahci-host private data for the host
671  * @pi_template: template for the ata_port_info to use
672  * @sht: scsi_host_template to use when registering
673  *
674  * This function does all the usual steps needed to bring up an
675  * ahci-platform host, note any necessary resources (ie clks, phys, etc.)
676  * must be initialized / enabled before calling this.
677  *
678  * RETURNS:
679  * 0 on success otherwise a negative error code
680  */
681 int ahci_platform_init_host(struct platform_device *pdev,
682 			    struct ahci_host_priv *hpriv,
683 			    const struct ata_port_info *pi_template,
684 			    const struct scsi_host_template *sht)
685 {
686 	struct device *dev = &pdev->dev;
687 	struct ata_port_info pi = *pi_template;
688 	const struct ata_port_info *ppi[] = { &pi, NULL };
689 	struct ata_host *host;
690 	int i, irq, n_ports, rc;
691 
692 	irq = platform_get_irq(pdev, 0);
693 	if (irq < 0)
694 		return irq;
695 	if (!irq)
696 		return -EINVAL;
697 
698 	hpriv->irq = irq;
699 
700 	/* prepare host */
701 	pi.private_data = (void *)(unsigned long)hpriv->flags;
702 
703 	ahci_save_initial_config(dev, hpriv);
704 
705 	if (hpriv->cap & HOST_CAP_NCQ)
706 		pi.flags |= ATA_FLAG_NCQ;
707 
708 	if (hpriv->cap & HOST_CAP_PMP)
709 		pi.flags |= ATA_FLAG_PMP;
710 
711 	ahci_set_em_messages(hpriv, &pi);
712 
713 	/* CAP.NP sometimes indicate the index of the last enabled
714 	 * port, at other times, that of the last possible port, so
715 	 * determining the maximum port number requires looking at
716 	 * both CAP.NP and port_map.
717 	 */
718 	n_ports = max(ahci_nr_ports(hpriv->cap), fls(hpriv->port_map));
719 
720 	host = ata_host_alloc_pinfo(dev, ppi, n_ports);
721 	if (!host)
722 		return -ENOMEM;
723 
724 	host->private_data = hpriv;
725 
726 	if (!(hpriv->cap & HOST_CAP_SSS) || ahci_ignore_sss)
727 		host->flags |= ATA_HOST_PARALLEL_SCAN;
728 	else
729 		dev_info(dev, "SSS flag set, parallel bus scan disabled\n");
730 
731 	if (pi.flags & ATA_FLAG_EM)
732 		ahci_reset_em(host);
733 
734 	for (i = 0; i < host->n_ports; i++) {
735 		struct ata_port *ap = host->ports[i];
736 
737 		ata_port_desc(ap, "mmio %pR",
738 			      platform_get_resource(pdev, IORESOURCE_MEM, 0));
739 		ata_port_desc(ap, "port 0x%x", 0x100 + ap->port_no * 0x80);
740 
741 		/* set enclosure management message type */
742 		if (ap->flags & ATA_FLAG_EM)
743 			ap->em_message_type = hpriv->em_msg_type;
744 
745 		/* disabled/not-implemented port */
746 		if (!(hpriv->port_map & (1 << i)))
747 			ap->ops = &ata_dummy_port_ops;
748 	}
749 
750 	if (hpriv->cap & HOST_CAP_64) {
751 		rc = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(64));
752 		if (rc) {
753 			dev_err(dev, "Failed to enable 64-bit DMA.\n");
754 			return rc;
755 		}
756 	}
757 
758 	rc = ahci_reset_controller(host);
759 	if (rc)
760 		return rc;
761 
762 	ahci_init_controller(host);
763 	ahci_print_info(host, "platform");
764 
765 	return ahci_host_activate(host, sht);
766 }
767 EXPORT_SYMBOL_GPL(ahci_platform_init_host);
768 
769 static void ahci_host_stop(struct ata_host *host)
770 {
771 	struct ahci_host_priv *hpriv = host->private_data;
772 
773 	ahci_platform_disable_resources(hpriv);
774 }
775 
776 /**
777  * ahci_platform_shutdown - Disable interrupts and stop DMA for host ports
778  * @pdev: platform device pointer for the host
779  *
780  * This function is called during system shutdown and performs the minimal
781  * deconfiguration required to ensure that an ahci_platform host cannot
782  * corrupt or otherwise interfere with a new kernel being started with kexec.
783  */
784 void ahci_platform_shutdown(struct platform_device *pdev)
785 {
786 	struct ata_host *host = platform_get_drvdata(pdev);
787 	struct ahci_host_priv *hpriv = host->private_data;
788 	void __iomem *mmio = hpriv->mmio;
789 	int i;
790 
791 	for (i = 0; i < host->n_ports; i++) {
792 		struct ata_port *ap = host->ports[i];
793 
794 		/* Disable port interrupts */
795 		if (ap->ops->freeze)
796 			ap->ops->freeze(ap);
797 
798 		/* Stop the port DMA engines */
799 		if (ap->ops->port_stop)
800 			ap->ops->port_stop(ap);
801 	}
802 
803 	/* Disable and clear host interrupts */
804 	writel(readl(mmio + HOST_CTL) & ~HOST_IRQ_EN, mmio + HOST_CTL);
805 	readl(mmio + HOST_CTL); /* flush */
806 	writel(GENMASK(host->n_ports, 0), mmio + HOST_IRQ_STAT);
807 }
808 EXPORT_SYMBOL_GPL(ahci_platform_shutdown);
809 
810 #ifdef CONFIG_PM_SLEEP
811 /**
812  * ahci_platform_suspend_host - Suspend an ahci-platform host
813  * @dev: device pointer for the host
814  *
815  * This function does all the usual steps needed to suspend an
816  * ahci-platform host, note any necessary resources (ie clks, phys, etc.)
817  * must be disabled after calling this.
818  *
819  * RETURNS:
820  * 0 on success otherwise a negative error code
821  */
822 int ahci_platform_suspend_host(struct device *dev)
823 {
824 	struct ata_host *host = dev_get_drvdata(dev);
825 	struct ahci_host_priv *hpriv = host->private_data;
826 	void __iomem *mmio = hpriv->mmio;
827 	u32 ctl;
828 
829 	if (hpriv->flags & AHCI_HFLAG_NO_SUSPEND) {
830 		dev_err(dev, "firmware update required for suspend/resume\n");
831 		return -EIO;
832 	}
833 
834 	/*
835 	 * AHCI spec rev1.1 section 8.3.3:
836 	 * Software must disable interrupts prior to requesting a
837 	 * transition of the HBA to D3 state.
838 	 */
839 	ctl = readl(mmio + HOST_CTL);
840 	ctl &= ~HOST_IRQ_EN;
841 	writel(ctl, mmio + HOST_CTL);
842 	readl(mmio + HOST_CTL); /* flush */
843 
844 	if (hpriv->flags & AHCI_HFLAG_SUSPEND_PHYS)
845 		ahci_platform_disable_phys(hpriv);
846 
847 	ata_host_suspend(host, PMSG_SUSPEND);
848 	return 0;
849 }
850 EXPORT_SYMBOL_GPL(ahci_platform_suspend_host);
851 
852 /**
853  * ahci_platform_resume_host - Resume an ahci-platform host
854  * @dev: device pointer for the host
855  *
856  * This function does all the usual steps needed to resume an ahci-platform
857  * host, note any necessary resources (ie clks, phys, etc.)  must be
858  * initialized / enabled before calling this.
859  *
860  * RETURNS:
861  * 0 on success otherwise a negative error code
862  */
863 int ahci_platform_resume_host(struct device *dev)
864 {
865 	struct ata_host *host = dev_get_drvdata(dev);
866 	struct ahci_host_priv *hpriv = host->private_data;
867 	int rc;
868 
869 	if (dev->power.power_state.event == PM_EVENT_SUSPEND) {
870 		rc = ahci_reset_controller(host);
871 		if (rc)
872 			return rc;
873 
874 		ahci_init_controller(host);
875 	}
876 
877 	if (hpriv->flags & AHCI_HFLAG_SUSPEND_PHYS)
878 		ahci_platform_enable_phys(hpriv);
879 
880 	ata_host_resume(host);
881 
882 	return 0;
883 }
884 EXPORT_SYMBOL_GPL(ahci_platform_resume_host);
885 
886 /**
887  * ahci_platform_suspend - Suspend an ahci-platform device
888  * @dev: the platform device to suspend
889  *
890  * This function suspends the host associated with the device, followed by
891  * disabling all the resources of the device.
892  *
893  * RETURNS:
894  * 0 on success otherwise a negative error code
895  */
896 int ahci_platform_suspend(struct device *dev)
897 {
898 	struct ata_host *host = dev_get_drvdata(dev);
899 	struct ahci_host_priv *hpriv = host->private_data;
900 	int rc;
901 
902 	rc = ahci_platform_suspend_host(dev);
903 	if (rc)
904 		return rc;
905 
906 	ahci_platform_disable_resources(hpriv);
907 
908 	return 0;
909 }
910 EXPORT_SYMBOL_GPL(ahci_platform_suspend);
911 
912 /**
913  * ahci_platform_resume - Resume an ahci-platform device
914  * @dev: the platform device to resume
915  *
916  * This function enables all the resources of the device followed by
917  * resuming the host associated with the device.
918  *
919  * RETURNS:
920  * 0 on success otherwise a negative error code
921  */
922 int ahci_platform_resume(struct device *dev)
923 {
924 	struct ata_host *host = dev_get_drvdata(dev);
925 	struct ahci_host_priv *hpriv = host->private_data;
926 	int rc;
927 
928 	rc = ahci_platform_enable_resources(hpriv);
929 	if (rc)
930 		return rc;
931 
932 	rc = ahci_platform_resume_host(dev);
933 	if (rc)
934 		goto disable_resources;
935 
936 	/* We resumed so update PM runtime state */
937 	pm_runtime_disable(dev);
938 	pm_runtime_set_active(dev);
939 	pm_runtime_enable(dev);
940 
941 	return 0;
942 
943 disable_resources:
944 	ahci_platform_disable_resources(hpriv);
945 
946 	return rc;
947 }
948 EXPORT_SYMBOL_GPL(ahci_platform_resume);
949 #endif
950 
951 MODULE_DESCRIPTION("AHCI SATA platform library");
952 MODULE_AUTHOR("Anton Vorontsov <avorontsov@ru.mvista.com>");
953 MODULE_LICENSE("GPL");
954