drivers/ata/libahci_platform.c

   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 <[email protected]>
   7  * Copyright 2010  MontaVista Software, LLC.
   8  *   Anton Vorontsov <[email protected]>
   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         u32 port;
 414
 415         if (!of_property_read_u32(dev->of_node, "hba-cap", &hpriv->saved_cap))
 416                 hpriv->saved_cap &= (HOST_CAP_SSS | HOST_CAP_MPS);
 417
 418         of_property_read_u32(dev->of_node,
 419                              "ports-implemented", &hpriv->saved_port_map);
 420
 421         for_each_child_of_node_scoped(dev->of_node, child) {
 422                 if (!of_device_is_available(child))
 423                         continue;
 424
 425                 if (of_property_read_u32(child, "reg", &port))
 426                         return -EINVAL;
 427
 428                 if (!of_property_read_u32(child, "hba-port-cap", &hpriv->saved_port_cap[port]))
 429                         hpriv->saved_port_cap[port] &= PORT_CMD_CAP;
 430         }
 431
 432         return 0;
 433 }
 434
 435 /**
 436  * ahci_platform_get_resources - Get platform resources
 437  * @pdev: platform device to get resources for
 438  * @flags: bitmap representing the resource to get
 439  *
 440  * This function allocates an ahci_host_priv struct, and gets the following
 441  * resources, storing a reference to them inside the returned struct:
 442  *
 443  * 1) mmio registers (IORESOURCE_MEM 0, mandatory)
 444  * 2) regulator for controlling the targets power (optional)
 445  *    regulator for controlling the AHCI controller (optional)
 446  * 3) all clocks specified in the devicetree node, or a single
 447  *    clock for non-OF platforms (optional)
 448  * 4) resets, if flags has AHCI_PLATFORM_GET_RESETS (optional)
 449  * 5) phys (optional)
 450  *
 451  * RETURNS:
 452  * The allocated ahci_host_priv on success, otherwise an ERR_PTR value
 453  */
 454 struct ahci_host_priv *ahci_platform_get_resources(struct platform_device *pdev,
 455                                                    unsigned int flags)
 456 {
 457         int child_nodes, rc = -ENOMEM, enabled_ports = 0;
 458         struct device *dev = &pdev->dev;
 459         struct ahci_host_priv *hpriv;
 460         u32 mask_port_map = 0;
 461
 462         if (!devres_open_group(dev, NULL, GFP_KERNEL))
 463                 return ERR_PTR(-ENOMEM);
 464
 465         hpriv = devres_alloc(ahci_platform_put_resources, sizeof(*hpriv),
 466                              GFP_KERNEL);
 467         if (!hpriv)
 468                 goto err_out;
 469
 470         devres_add(dev, hpriv);
 471
 472         /*
 473          * If the DT provided an "ahci" named resource, use it. Otherwise,
 474          * fallback to using the default first resource for the device node.
 475          */
 476         if (platform_get_resource_byname(pdev, IORESOURCE_MEM, "ahci"))
 477                 hpriv->mmio = devm_platform_ioremap_resource_byname(pdev, "ahci");
 478         else
 479                 hpriv->mmio = devm_platform_ioremap_resource(pdev, 0);
 480         if (IS_ERR(hpriv->mmio)) {
 481                 rc = PTR_ERR(hpriv->mmio);
 482                 goto err_out;
 483         }
 484
 485         /*
 486          * Bulk clocks getting procedure can fail to find any clock due to
 487          * running on a non-OF platform or due to the clocks being defined in
 488          * bypass of the DT firmware (like da850, spear13xx). In that case we
 489          * fallback to getting a single clock source right from the dev clocks
 490          * list.
 491          */
 492         rc = devm_clk_bulk_get_all(dev, &hpriv->clks);
 493         if (rc < 0)
 494                 goto err_out;
 495
 496         if (rc > 0) {
 497                 /* Got clocks in bulk */
 498                 hpriv->n_clks = rc;
 499         } else {
 500                 /*
 501                  * No clock bulk found: fallback to manually getting
 502                  * the optional clock.
 503                  */
 504                 hpriv->clks = devm_kzalloc(dev, sizeof(*hpriv->clks), GFP_KERNEL);
 505                 if (!hpriv->clks) {
 506                         rc = -ENOMEM;
 507                         goto err_out;
 508                 }
 509                 hpriv->clks->clk = devm_clk_get_optional(dev, NULL);
 510                 if (IS_ERR(hpriv->clks->clk)) {
 511                         rc = PTR_ERR(hpriv->clks->clk);
 512                         goto err_out;
 513                 } else if (hpriv->clks->clk) {
 514                         hpriv->clks->id = "ahci";
 515                         hpriv->n_clks = 1;
 516                 }
 517         }
 518
 519         hpriv->ahci_regulator = devm_regulator_get(dev, "ahci");
 520         if (IS_ERR(hpriv->ahci_regulator)) {
 521                 rc = PTR_ERR(hpriv->ahci_regulator);
 522                 if (rc != 0)
 523                         goto err_out;
 524         }
 525
 526         hpriv->phy_regulator = devm_regulator_get(dev, "phy");
 527         if (IS_ERR(hpriv->phy_regulator)) {
 528                 rc = PTR_ERR(hpriv->phy_regulator);
 529                 goto err_out;
 530         }
 531
 532         if (flags & AHCI_PLATFORM_GET_RESETS) {
 533                 hpriv->rsts = devm_reset_control_array_get_optional_shared(dev);
 534                 if (IS_ERR(hpriv->rsts)) {
 535                         rc = PTR_ERR(hpriv->rsts);
 536                         goto err_out;
 537                 }
 538
 539                 hpriv->f_rsts = flags & AHCI_PLATFORM_RST_TRIGGER;
 540         }
 541
 542         /*
 543          * Too many sub-nodes most likely means having something wrong with
 544          * the firmware.
 545          */
 546         child_nodes = of_get_child_count(dev->of_node);
 547         if (child_nodes > AHCI_MAX_PORTS) {
 548                 rc = -EINVAL;
 549                 goto err_out;
 550         }
 551
 552         /*
 553          * If no sub-node was found, we still need to set nports to
 554          * one in order to be able to use the
 555          * ahci_platform_[en|dis]able_[phys|regulators] functions.
 556          */
 557         if (child_nodes)
 558                 hpriv->nports = child_nodes;
 559         else
 560                 hpriv->nports = 1;
 561
 562         hpriv->phys = devm_kcalloc(dev, hpriv->nports, sizeof(*hpriv->phys), GFP_KERNEL);
 563         if (!hpriv->phys) {
 564                 rc = -ENOMEM;
 565                 goto err_out;
 566         }
 567         /*
 568          * We cannot use devm_ here, since ahci_platform_put_resources() uses
 569          * target_pwrs after devm_ have freed memory
 570          */
 571         hpriv->target_pwrs = kcalloc(hpriv->nports, sizeof(*hpriv->target_pwrs), GFP_KERNEL);
 572         if (!hpriv->target_pwrs) {
 573                 rc = -ENOMEM;
 574                 goto err_out;
 575         }
 576
 577         if (child_nodes) {
 578                 for_each_child_of_node_scoped(dev->of_node, child) {
 579                         u32 port;
 580                         struct platform_device *port_dev __maybe_unused;
 581
 582                         if (!of_device_is_available(child))
 583                                 continue;
 584
 585                         if (of_property_read_u32(child, "reg", &port)) {
 586                                 rc = -EINVAL;
 587                                 goto err_out;
 588                         }
 589
 590                         if (port >= hpriv->nports) {
 591                                 dev_warn(dev, "invalid port number %d\n", port);
 592                                 continue;
 593                         }
 594                         mask_port_map |= BIT(port);
 595
 596 #ifdef CONFIG_OF_ADDRESS
 597                         of_platform_device_create(child, NULL, NULL);
 598
 599                         port_dev = of_find_device_by_node(child);
 600
 601                         if (port_dev) {
 602                                 rc = ahci_platform_get_regulator(hpriv, port,
 603                                                                 &port_dev->dev);
 604                                 if (rc == -EPROBE_DEFER)
 605                                         goto err_out;
 606                         }
 607 #endif
 608
 609                         rc = ahci_platform_get_phy(hpriv, port, dev, child);
 610                         if (rc)
 611                                 goto err_out;
 612
 613                         enabled_ports++;
 614                 }
 615                 if (!enabled_ports) {
 616                         dev_warn(dev, "No port enabled\n");
 617                         rc = -ENODEV;
 618                         goto err_out;
 619                 }
 620
 621                 if (!hpriv->mask_port_map)
 622                         hpriv->mask_port_map = mask_port_map;
 623         } else {
 624                 /*
 625                  * If no sub-node was found, keep this for device tree
 626                  * compatibility
 627                  */
 628                 rc = ahci_platform_get_phy(hpriv, 0, dev, dev->of_node);
 629                 if (rc)
 630                         goto err_out;
 631
 632                 rc = ahci_platform_get_regulator(hpriv, 0, dev);
 633                 if (rc == -EPROBE_DEFER)
 634                         goto err_out;
 635         }
 636
 637         /*
 638          * Retrieve firmware-specific flags which then will be used to set
 639          * the HW-init fields of HBA and its ports
 640          */
 641         rc = ahci_platform_get_firmware(hpriv, dev);
 642         if (rc)
 643                 goto err_out;
 644
 645         pm_runtime_enable(dev);
 646         pm_runtime_get_sync(dev);
 647         hpriv->got_runtime_pm = true;
 648
 649         devres_remove_group(dev, NULL);
 650         return hpriv;
 651
 652 err_out:
 653         devres_release_group(dev, NULL);
 654         return ERR_PTR(rc);
 655 }
 656 EXPORT_SYMBOL_GPL(ahci_platform_get_resources);
 657
 658 /**
 659  * ahci_platform_init_host - Bring up an ahci-platform host
 660  * @pdev: platform device pointer for the host
 661  * @hpriv: ahci-host private data for the host
 662  * @pi_template: template for the ata_port_info to use
 663  * @sht: scsi_host_template to use when registering
 664  *
 665  * This function does all the usual steps needed to bring up an
 666  * ahci-platform host, note any necessary resources (ie clks, phys, etc.)
 667  * must be initialized / enabled before calling this.
 668  *
 669  * RETURNS:
 670  * 0 on success otherwise a negative error code
 671  */
 672 int ahci_platform_init_host(struct platform_device *pdev,
 673                             struct ahci_host_priv *hpriv,
 674                             const struct ata_port_info *pi_template,
 675                             const struct scsi_host_template *sht)
 676 {
 677         struct device *dev = &pdev->dev;
 678         struct ata_port_info pi = *pi_template;
 679         const struct ata_port_info *ppi[] = { &pi, NULL };
 680         struct ata_host *host;
 681         int i, irq, n_ports, rc;
 682
 683         irq = platform_get_irq(pdev, 0);
 684         if (irq < 0)
 685                 return irq;
 686         if (!irq)
 687                 return -EINVAL;
 688
 689         hpriv->irq = irq;
 690
 691         /* prepare host */
 692         pi.private_data = (void *)(unsigned long)hpriv->flags;
 693
 694         ahci_save_initial_config(dev, hpriv);
 695
 696         if (hpriv->cap & HOST_CAP_NCQ)
 697                 pi.flags |= ATA_FLAG_NCQ;
 698
 699         if (hpriv->cap & HOST_CAP_PMP)
 700                 pi.flags |= ATA_FLAG_PMP;
 701
 702         ahci_set_em_messages(hpriv, &pi);
 703
 704         /* CAP.NP sometimes indicate the index of the last enabled
 705          * port, at other times, that of the last possible port, so
 706          * determining the maximum port number requires looking at
 707          * both CAP.NP and port_map.
 708          */
 709         n_ports = max(ahci_nr_ports(hpriv->cap), fls(hpriv->port_map));
 710
 711         host = ata_host_alloc_pinfo(dev, ppi, n_ports);
 712         if (!host)
 713                 return -ENOMEM;
 714
 715         host->private_data = hpriv;
 716
 717         if (!(hpriv->cap & HOST_CAP_SSS) || ahci_ignore_sss)
 718                 host->flags |= ATA_HOST_PARALLEL_SCAN;
 719         else
 720                 dev_info(dev, "SSS flag set, parallel bus scan disabled\n");
 721
 722         if (pi.flags & ATA_FLAG_EM)
 723                 ahci_reset_em(host);
 724
 725         for (i = 0; i < host->n_ports; i++) {
 726                 struct ata_port *ap = host->ports[i];
 727
 728                 ata_port_desc(ap, "mmio %pR",
 729                               platform_get_resource(pdev, IORESOURCE_MEM, 0));
 730                 ata_port_desc(ap, "port 0x%x", 0x100 + ap->port_no * 0x80);
 731
 732                 /* set enclosure management message type */
 733                 if (ap->flags & ATA_FLAG_EM)
 734                         ap->em_message_type = hpriv->em_msg_type;
 735
 736                 /* disabled/not-implemented port */
 737                 if (!(hpriv->port_map & (1 << i)))
 738                         ap->ops = &ata_dummy_port_ops;
 739         }
 740
 741         if (hpriv->cap & HOST_CAP_64) {
 742                 rc = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(64));
 743                 if (rc) {
 744                         dev_err(dev, "Failed to enable 64-bit DMA.\n");
 745                         return rc;
 746                 }
 747         }
 748
 749         rc = ahci_reset_controller(host);
 750         if (rc)
 751                 return rc;
 752
 753         ahci_init_controller(host);
 754         ahci_print_info(host, "platform");
 755
 756         return ahci_host_activate(host, sht);
 757 }
 758 EXPORT_SYMBOL_GPL(ahci_platform_init_host);
 759
 760 static void ahci_host_stop(struct ata_host *host)
 761 {
 762         struct ahci_host_priv *hpriv = host->private_data;
 763
 764         ahci_platform_disable_resources(hpriv);
 765 }
 766
 767 /**
 768  * ahci_platform_shutdown - Disable interrupts and stop DMA for host ports
 769  * @pdev: platform device pointer for the host
 770  *
 771  * This function is called during system shutdown and performs the minimal
 772  * deconfiguration required to ensure that an ahci_platform host cannot
 773  * corrupt or otherwise interfere with a new kernel being started with kexec.
 774  */
 775 void ahci_platform_shutdown(struct platform_device *pdev)
 776 {
 777         struct ata_host *host = platform_get_drvdata(pdev);
 778         struct ahci_host_priv *hpriv = host->private_data;
 779         void __iomem *mmio = hpriv->mmio;
 780         int i;
 781
 782         for (i = 0; i < host->n_ports; i++) {
 783                 struct ata_port *ap = host->ports[i];
 784
 785                 /* Disable port interrupts */
 786                 if (ap->ops->freeze)
 787                         ap->ops->freeze(ap);
 788
 789                 /* Stop the port DMA engines */
 790                 if (ap->ops->port_stop)
 791                         ap->ops->port_stop(ap);
 792         }
 793
 794         /* Disable and clear host interrupts */
 795         writel(readl(mmio + HOST_CTL) & ~HOST_IRQ_EN, mmio + HOST_CTL);
 796         readl(mmio + HOST_CTL); /* flush */
 797         writel(GENMASK(host->n_ports, 0), mmio + HOST_IRQ_STAT);
 798 }
 799 EXPORT_SYMBOL_GPL(ahci_platform_shutdown);
 800
 801 #ifdef CONFIG_PM_SLEEP
 802 /**
 803  * ahci_platform_suspend_host - Suspend an ahci-platform host
 804  * @dev: device pointer for the host
 805  *
 806  * This function does all the usual steps needed to suspend an
 807  * ahci-platform host, note any necessary resources (ie clks, phys, etc.)
 808  * must be disabled after calling this.
 809  *
 810  * RETURNS:
 811  * 0 on success otherwise a negative error code
 812  */
 813 int ahci_platform_suspend_host(struct device *dev)
 814 {
 815         struct ata_host *host = dev_get_drvdata(dev);
 816         struct ahci_host_priv *hpriv = host->private_data;
 817         void __iomem *mmio = hpriv->mmio;
 818         u32 ctl;
 819
 820         if (hpriv->flags & AHCI_HFLAG_NO_SUSPEND) {
 821                 dev_err(dev, "firmware update required for suspend/resume\n");
 822                 return -EIO;
 823         }
 824
 825         /*
 826          * AHCI spec rev1.1 section 8.3.3:
 827          * Software must disable interrupts prior to requesting a
 828          * transition of the HBA to D3 state.
 829          */
 830         ctl = readl(mmio + HOST_CTL);
 831         ctl &= ~HOST_IRQ_EN;
 832         writel(ctl, mmio + HOST_CTL);
 833         readl(mmio + HOST_CTL); /* flush */
 834
 835         if (hpriv->flags & AHCI_HFLAG_SUSPEND_PHYS)
 836                 ahci_platform_disable_phys(hpriv);
 837
 838         ata_host_suspend(host, PMSG_SUSPEND);
 839         return 0;
 840 }
 841 EXPORT_SYMBOL_GPL(ahci_platform_suspend_host);
 842
 843 /**
 844  * ahci_platform_resume_host - Resume an ahci-platform host
 845  * @dev: device pointer for the host
 846  *
 847  * This function does all the usual steps needed to resume an ahci-platform
 848  * host, note any necessary resources (ie clks, phys, etc.)  must be
 849  * initialized / enabled before calling this.
 850  *
 851  * RETURNS:
 852  * 0 on success otherwise a negative error code
 853  */
 854 int ahci_platform_resume_host(struct device *dev)
 855 {
 856         struct ata_host *host = dev_get_drvdata(dev);
 857         struct ahci_host_priv *hpriv = host->private_data;
 858         int rc;
 859
 860         if (dev->power.power_state.event == PM_EVENT_SUSPEND) {
 861                 rc = ahci_reset_controller(host);
 862                 if (rc)
 863                         return rc;
 864
 865                 ahci_init_controller(host);
 866         }
 867
 868         if (hpriv->flags & AHCI_HFLAG_SUSPEND_PHYS)
 869                 ahci_platform_enable_phys(hpriv);
 870
 871         ata_host_resume(host);
 872
 873         return 0;
 874 }
 875 EXPORT_SYMBOL_GPL(ahci_platform_resume_host);
 876
 877 /**
 878  * ahci_platform_suspend - Suspend an ahci-platform device
 879  * @dev: the platform device to suspend
 880  *
 881  * This function suspends the host associated with the device, followed by
 882  * disabling all the resources of the device.
 883  *
 884  * RETURNS:
 885  * 0 on success otherwise a negative error code
 886  */
 887 int ahci_platform_suspend(struct device *dev)
 888 {
 889         struct ata_host *host = dev_get_drvdata(dev);
 890         struct ahci_host_priv *hpriv = host->private_data;
 891         int rc;
 892
 893         rc = ahci_platform_suspend_host(dev);
 894         if (rc)
 895                 return rc;
 896
 897         ahci_platform_disable_resources(hpriv);
 898
 899         return 0;
 900 }
 901 EXPORT_SYMBOL_GPL(ahci_platform_suspend);
 902
 903 /**
 904  * ahci_platform_resume - Resume an ahci-platform device
 905  * @dev: the platform device to resume
 906  *
 907  * This function enables all the resources of the device followed by
 908  * resuming the host associated with the device.
 909  *
 910  * RETURNS:
 911  * 0 on success otherwise a negative error code
 912  */
 913 int ahci_platform_resume(struct device *dev)
 914 {
 915         struct ata_host *host = dev_get_drvdata(dev);
 916         struct ahci_host_priv *hpriv = host->private_data;
 917         int rc;
 918
 919         rc = ahci_platform_enable_resources(hpriv);
 920         if (rc)
 921                 return rc;
 922
 923         rc = ahci_platform_resume_host(dev);
 924         if (rc)
 925                 goto disable_resources;
 926
 927         /* We resumed so update PM runtime state */
 928         pm_runtime_disable(dev);
 929         pm_runtime_set_active(dev);
 930         pm_runtime_enable(dev);
 931
 932         return 0;
 933
 934 disable_resources:
 935         ahci_platform_disable_resources(hpriv);
 936
 937         return rc;
 938 }
 939 EXPORT_SYMBOL_GPL(ahci_platform_resume);
 940 #endif
 941
 942 MODULE_DESCRIPTION("AHCI SATA platform library");
 943 MODULE_AUTHOR("Anton Vorontsov <[email protected]>");
 944 MODULE_LICENSE("GPL");