drivers/phy/phy-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2017 Texas Instruments Incorporated - http://www.ti.com/
   4  * Written by Jean-Jacques Hiblot  <jjhiblot@ti.com>
   5  */
   6
   7 #include <common.h>
   8 #include <dm.h>
   9 #include <dm/device_compat.h>
  10 #include <dm/devres.h>
  11 #include <generic-phy.h>
  12
  13 static inline struct phy_ops *phy_dev_ops(struct udevice *dev)
  14 {
  15         return (struct phy_ops *)dev->driver->ops;
  16 }
  17
  18 static int generic_phy_xlate_offs_flags(struct phy *phy,
  19                                         struct ofnode_phandle_args *args)
  20 {
  21         debug("%s(phy=%p)\n", __func__, phy);
  22
  23         if (args->args_count > 1) {
  24                 debug("Invaild args_count: %d\n", args->args_count);
  25                 return -EINVAL;
  26         }
  27
  28         if (args->args_count)
  29                 phy->id = args->args[0];
  30         else
  31                 phy->id = 0;
  32
  33         return 0;
  34 }
  35
  36 int generic_phy_get_by_index_nodev(ofnode node, int index, struct phy *phy)
  37 {
  38         struct ofnode_phandle_args args;
  39         struct phy_ops *ops;
  40         struct udevice *phydev;
  41         int i, ret;
  42
  43         debug("%s(node=%s, index=%d, phy=%p)\n",
  44               __func__, ofnode_get_name(node), index, phy);
  45
  46         assert(phy);
  47         phy->dev = NULL;
  48         ret = ofnode_parse_phandle_with_args(node, "phys", "#phy-cells", 0,
  49                                              index, &args);
  50         if (ret) {
  51                 debug("%s: dev_read_phandle_with_args failed: err=%d\n",
  52                       __func__, ret);
  53                 return ret;
  54         }
  55
  56         ret = uclass_get_device_by_ofnode(UCLASS_PHY, args.node, &phydev);
  57         if (ret) {
  58                 debug("%s: uclass_get_device_by_ofnode failed: err=%d\n",
  59                       __func__, ret);
  60
  61                 /* Check if args.node's parent is a PHY provider */
  62                 ret = uclass_get_device_by_ofnode(UCLASS_PHY,
  63                                                   ofnode_get_parent(args.node),
  64                                                   &phydev);
  65                 if (ret)
  66                         return ret;
  67
  68                 /* insert phy idx at first position into args array */
  69                 for (i = args.args_count; i >= 1 ; i--)
  70                         args.args[i] = args.args[i - 1];
  71
  72                 args.args_count++;
  73                 args.args[0] = ofnode_read_u32_default(args.node, "reg", -1);
  74         }
  75
  76         phy->dev = phydev;
  77
  78         ops = phy_dev_ops(phydev);
  79
  80         if (ops->of_xlate)
  81                 ret = ops->of_xlate(phy, &args);
  82         else
  83                 ret = generic_phy_xlate_offs_flags(phy, &args);
  84         if (ret) {
  85                 debug("of_xlate() failed: %d\n", ret);
  86                 goto err;
  87         }
  88
  89         return 0;
  90
  91 err:
  92         return ret;
  93 }
  94
  95 int generic_phy_get_by_index(struct udevice *dev, int index,
  96                              struct phy *phy)
  97 {
  98         return generic_phy_get_by_index_nodev(dev_ofnode(dev), index, phy);
  99 }
 100
 101 int generic_phy_get_by_name(struct udevice *dev, const char *phy_name,
 102                             struct phy *phy)
 103 {
 104         int index;
 105
 106         debug("%s(dev=%p, name=%s, phy=%p)\n", __func__, dev, phy_name, phy);
 107
 108         index = dev_read_stringlist_search(dev, "phy-names", phy_name);
 109         if (index < 0) {
 110                 debug("dev_read_stringlist_search() failed: %d\n", index);
 111                 return index;
 112         }
 113
 114         return generic_phy_get_by_index(dev, index, phy);
 115 }
 116
 117 int generic_phy_init(struct phy *phy)
 118 {
 119         struct phy_ops const *ops;
 120         int ret;
 121
 122         if (!generic_phy_valid(phy))
 123                 return 0;
 124         ops = phy_dev_ops(phy->dev);
 125         if (!ops->init)
 126                 return 0;
 127         ret = ops->init(phy);
 128         if (ret)
 129                 dev_err(phy->dev, "PHY: Failed to init %s: %d.\n",
 130                         phy->dev->name, ret);
 131
 132         return ret;
 133 }
 134
 135 int generic_phy_reset(struct phy *phy)
 136 {
 137         struct phy_ops const *ops;
 138         int ret;
 139
 140         if (!generic_phy_valid(phy))
 141                 return 0;
 142         ops = phy_dev_ops(phy->dev);
 143         if (!ops->reset)
 144                 return 0;
 145         ret = ops->reset(phy);
 146         if (ret)
 147                 dev_err(phy->dev, "PHY: Failed to reset %s: %d.\n",
 148                         phy->dev->name, ret);
 149
 150         return ret;
 151 }
 152
 153 int generic_phy_exit(struct phy *phy)
 154 {
 155         struct phy_ops const *ops;
 156         int ret;
 157
 158         if (!generic_phy_valid(phy))
 159                 return 0;
 160         ops = phy_dev_ops(phy->dev);
 161         if (!ops->exit)
 162                 return 0;
 163         ret = ops->exit(phy);
 164         if (ret)
 165                 dev_err(phy->dev, "PHY: Failed to exit %s: %d.\n",
 166                         phy->dev->name, ret);
 167
 168         return ret;
 169 }
 170
 171 int generic_phy_power_on(struct phy *phy)
 172 {
 173         struct phy_ops const *ops;
 174         int ret;
 175
 176         if (!generic_phy_valid(phy))
 177                 return 0;
 178         ops = phy_dev_ops(phy->dev);
 179         if (!ops->power_on)
 180                 return 0;
 181         ret = ops->power_on(phy);
 182         if (ret)
 183                 dev_err(phy->dev, "PHY: Failed to power on %s: %d.\n",
 184                         phy->dev->name, ret);
 185
 186         return ret;
 187 }
 188
 189 int generic_phy_power_off(struct phy *phy)
 190 {
 191         struct phy_ops const *ops;
 192         int ret;
 193
 194         if (!generic_phy_valid(phy))
 195                 return 0;
 196         ops = phy_dev_ops(phy->dev);
 197         if (!ops->power_off)
 198                 return 0;
 199         ret = ops->power_off(phy);
 200         if (ret)
 201                 dev_err(phy->dev, "PHY: Failed to power off %s: %d.\n",
 202                         phy->dev->name, ret);
 203
 204         return ret;
 205 }
 206
 207 int generic_phy_configure(struct phy *phy, void *params)
 208 {
 209         struct phy_ops const *ops;
 210
 211         if (!generic_phy_valid(phy))
 212                 return 0;
 213         ops = phy_dev_ops(phy->dev);
 214
 215         return ops->configure ? ops->configure(phy, params) : 0;
 216 }
 217
 218 int generic_phy_get_bulk(struct udevice *dev, struct phy_bulk *bulk)
 219 {
 220         int i, ret, count;
 221
 222         bulk->count = 0;
 223
 224         /* Return if no phy declared */
 225         if (!dev_read_prop(dev, "phys", NULL))
 226                 return 0;
 227
 228         count = dev_count_phandle_with_args(dev, "phys", "#phy-cells", 0);
 229         if (count < 1)
 230                 return count;
 231
 232         bulk->phys = devm_kcalloc(dev, count, sizeof(struct phy), GFP_KERNEL);
 233         if (!bulk->phys)
 234                 return -ENOMEM;
 235
 236         for (i = 0; i < count; i++) {
 237                 ret = generic_phy_get_by_index(dev, i, &bulk->phys[i]);
 238                 if (ret) {
 239                         pr_err("Failed to get PHY%d for %s\n", i, dev->name);
 240                         return ret;
 241                 }
 242                 bulk->count++;
 243         }
 244
 245         return 0;
 246 }
 247
 248 int generic_phy_init_bulk(struct phy_bulk *bulk)
 249 {
 250         struct phy *phys = bulk->phys;
 251         int i, ret;
 252
 253         for (i = 0; i < bulk->count; i++) {
 254                 ret = generic_phy_init(&phys[i]);
 255                 if (ret) {
 256                         pr_err("Can't init PHY%d\n", i);
 257                         goto phys_init_err;
 258                 }
 259         }
 260
 261         return 0;
 262
 263 phys_init_err:
 264         for (; i > 0; i--)
 265                 generic_phy_exit(&phys[i - 1]);
 266
 267         return ret;
 268 }
 269
 270 int generic_phy_exit_bulk(struct phy_bulk *bulk)
 271 {
 272         struct phy *phys = bulk->phys;
 273         int i, ret = 0;
 274
 275         for (i = 0; i < bulk->count; i++)
 276                 ret |= generic_phy_exit(&phys[i]);
 277
 278         return ret;
 279 }
 280
 281 int generic_phy_power_on_bulk(struct phy_bulk *bulk)
 282 {
 283         struct phy *phys = bulk->phys;
 284         int i, ret;
 285
 286         for (i = 0; i < bulk->count; i++) {
 287                 ret = generic_phy_power_on(&phys[i]);
 288                 if (ret) {
 289                         pr_err("Can't power on PHY%d\n", i);
 290                         goto phys_poweron_err;
 291                 }
 292         }
 293
 294         return 0;
 295
 296 phys_poweron_err:
 297         for (; i > 0; i--)
 298                 generic_phy_power_off(&phys[i - 1]);
 299
 300         return ret;
 301 }
 302
 303 int generic_phy_power_off_bulk(struct phy_bulk *bulk)
 304 {
 305         struct phy *phys = bulk->phys;
 306         int i, ret = 0;
 307
 308         for (i = 0; i < bulk->count; i++)
 309                 ret |= generic_phy_power_off(&phys[i]);
 310
 311         return ret;
 312 }
 313
 314 UCLASS_DRIVER(phy) = {
 315         .id             = UCLASS_PHY,
 316         .name           = "phy",
 317 };