arch/sh/drivers/platform_early.c

   1 // SPDX--License-Identifier: GPL-2.0
   2
   3 #include <asm/platform_early.h>
   4 #include <linux/mod_devicetable.h>
   5 #include <linux/pm.h>
   6
   7 static __initdata LIST_HEAD(sh_early_platform_driver_list);
   8 static __initdata LIST_HEAD(sh_early_platform_device_list);
   9
  10 static const struct platform_device_id *
  11 platform_match_id(const struct platform_device_id *id,
  12                   struct platform_device *pdev)
  13 {
  14         while (id->name[0]) {
  15                 if (strcmp(pdev->name, id->name) == 0) {
  16                         pdev->id_entry = id;
  17                         return id;
  18                 }
  19                 id++;
  20         }
  21         return NULL;
  22 }
  23
  24 static int platform_match(struct device *dev, struct device_driver *drv)
  25 {
  26         struct platform_device *pdev = to_platform_device(dev);
  27         struct platform_driver *pdrv = to_platform_driver(drv);
  28
  29         /* When driver_override is set, only bind to the matching driver */
  30         if (pdev->driver_override)
  31                 return !strcmp(pdev->driver_override, drv->name);
  32
  33         /* Then try to match against the id table */
  34         if (pdrv->id_table)
  35                 return platform_match_id(pdrv->id_table, pdev) != NULL;
  36
  37         /* fall-back to driver name match */
  38         return (strcmp(pdev->name, drv->name) == 0);
  39 }
  40
  41 #ifdef CONFIG_PM
  42 static void device_pm_init_common(struct device *dev)
  43 {
  44         if (!dev->power.early_init) {
  45                 spin_lock_init(&dev->power.lock);
  46                 dev->power.qos = NULL;
  47                 dev->power.early_init = true;
  48         }
  49 }
  50
  51 static void pm_runtime_early_init(struct device *dev)
  52 {
  53         dev->power.disable_depth = 1;
  54         device_pm_init_common(dev);
  55 }
  56 #else
  57 static void pm_runtime_early_init(struct device *dev) {}
  58 #endif
  59
  60 /**
  61  * sh_early_platform_driver_register - register early platform driver
  62  * @epdrv: sh_early_platform driver structure
  63  * @buf: string passed from early_param()
  64  *
  65  * Helper function for sh_early_platform_init() / sh_early_platform_init_buffer()
  66  */
  67 int __init sh_early_platform_driver_register(struct sh_early_platform_driver *epdrv,
  68                                           char *buf)
  69 {
  70         char *tmp;
  71         int n;
  72
  73         /* Simply add the driver to the end of the global list.
  74          * Drivers will by default be put on the list in compiled-in order.
  75          */
  76         if (!epdrv->list.next) {
  77                 INIT_LIST_HEAD(&epdrv->list);
  78                 list_add_tail(&epdrv->list, &sh_early_platform_driver_list);
  79         }
  80
  81         /* If the user has specified device then make sure the driver
  82          * gets prioritized. The driver of the last device specified on
  83          * command line will be put first on the list.
  84          */
  85         n = strlen(epdrv->pdrv->driver.name);
  86         if (buf && !strncmp(buf, epdrv->pdrv->driver.name, n)) {
  87                 list_move(&epdrv->list, &sh_early_platform_driver_list);
  88
  89                 /* Allow passing parameters after device name */
  90                 if (buf[n] == '\0' || buf[n] == ',')
  91                         epdrv->requested_id = -1;
  92                 else {
  93                         epdrv->requested_id = simple_strtoul(&buf[n + 1],
  94                                                              &tmp, 10);
  95
  96                         if (buf[n] != '.' || (tmp == &buf[n + 1])) {
  97                                 epdrv->requested_id = EARLY_PLATFORM_ID_ERROR;
  98                                 n = 0;
  99                         } else
 100                                 n += strcspn(&buf[n + 1], ",") + 1;
 101                 }
 102
 103                 if (buf[n] == ',')
 104                         n++;
 105
 106                 if (epdrv->bufsize) {
 107                         memcpy(epdrv->buffer, &buf[n],
 108                                min_t(int, epdrv->bufsize, strlen(&buf[n]) + 1));
 109                         epdrv->buffer[epdrv->bufsize - 1] = '\0';
 110                 }
 111         }
 112
 113         return 0;
 114 }
 115
 116 /**
 117  * sh_early_platform_add_devices - adds a number of early platform devices
 118  * @devs: array of early platform devices to add
 119  * @num: number of early platform devices in array
 120  *
 121  * Used by early architecture code to register early platform devices and
 122  * their platform data.
 123  */
 124 void __init sh_early_platform_add_devices(struct platform_device **devs, int num)
 125 {
 126         struct device *dev;
 127         int i;
 128
 129         /* simply add the devices to list */
 130         for (i = 0; i < num; i++) {
 131                 dev = &devs[i]->dev;
 132
 133                 if (!dev->devres_head.next) {
 134                         pm_runtime_early_init(dev);
 135                         INIT_LIST_HEAD(&dev->devres_head);
 136                         list_add_tail(&dev->devres_head,
 137                                       &sh_early_platform_device_list);
 138                 }
 139         }
 140 }
 141
 142 /**
 143  * sh_early_platform_driver_register_all - register early platform drivers
 144  * @class_str: string to identify early platform driver class
 145  *
 146  * Used by architecture code to register all early platform drivers
 147  * for a certain class. If omitted then only early platform drivers
 148  * with matching kernel command line class parameters will be registered.
 149  */
 150 void __init sh_early_platform_driver_register_all(char *class_str)
 151 {
 152         /* The "class_str" parameter may or may not be present on the kernel
 153          * command line. If it is present then there may be more than one
 154          * matching parameter.
 155          *
 156          * Since we register our early platform drivers using early_param()
 157          * we need to make sure that they also get registered in the case
 158          * when the parameter is missing from the kernel command line.
 159          *
 160          * We use parse_early_options() to make sure the early_param() gets
 161          * called at least once. The early_param() may be called more than
 162          * once since the name of the preferred device may be specified on
 163          * the kernel command line. sh_early_platform_driver_register() handles
 164          * this case for us.
 165          */
 166         parse_early_options(class_str);
 167 }
 168
 169 /**
 170  * sh_early_platform_match - find early platform device matching driver
 171  * @epdrv: early platform driver structure
 172  * @id: id to match against
 173  */
 174 static struct platform_device * __init
 175 sh_early_platform_match(struct sh_early_platform_driver *epdrv, int id)
 176 {
 177         struct platform_device *pd;
 178
 179         list_for_each_entry(pd, &sh_early_platform_device_list, dev.devres_head)
 180                 if (platform_match(&pd->dev, &epdrv->pdrv->driver))
 181                         if (pd->id == id)
 182                                 return pd;
 183
 184         return NULL;
 185 }
 186
 187 /**
 188  * sh_early_platform_left - check if early platform driver has matching devices
 189  * @epdrv: early platform driver structure
 190  * @id: return true if id or above exists
 191  */
 192 static int __init sh_early_platform_left(struct sh_early_platform_driver *epdrv,
 193                                        int id)
 194 {
 195         struct platform_device *pd;
 196
 197         list_for_each_entry(pd, &sh_early_platform_device_list, dev.devres_head)
 198                 if (platform_match(&pd->dev, &epdrv->pdrv->driver))
 199                         if (pd->id >= id)
 200                                 return 1;
 201
 202         return 0;
 203 }
 204
 205 /**
 206  * sh_early_platform_driver_probe_id - probe drivers matching class_str and id
 207  * @class_str: string to identify early platform driver class
 208  * @id: id to match against
 209  * @nr_probe: number of platform devices to successfully probe before exiting
 210  */
 211 static int __init sh_early_platform_driver_probe_id(char *class_str,
 212                                                  int id,
 213                                                  int nr_probe)
 214 {
 215         struct sh_early_platform_driver *epdrv;
 216         struct platform_device *match;
 217         int match_id;
 218         int n = 0;
 219         int left = 0;
 220
 221         list_for_each_entry(epdrv, &sh_early_platform_driver_list, list) {
 222                 /* only use drivers matching our class_str */
 223                 if (strcmp(class_str, epdrv->class_str))
 224                         continue;
 225
 226                 if (id == -2) {
 227                         match_id = epdrv->requested_id;
 228                         left = 1;
 229
 230                 } else {
 231                         match_id = id;
 232                         left += sh_early_platform_left(epdrv, id);
 233
 234                         /* skip requested id */
 235                         switch (epdrv->requested_id) {
 236                         case EARLY_PLATFORM_ID_ERROR:
 237                         case EARLY_PLATFORM_ID_UNSET:
 238                                 break;
 239                         default:
 240                                 if (epdrv->requested_id == id)
 241                                         match_id = EARLY_PLATFORM_ID_UNSET;
 242                         }
 243                 }
 244
 245                 switch (match_id) {
 246                 case EARLY_PLATFORM_ID_ERROR:
 247                         pr_warn("%s: unable to parse %s parameter\n",
 248                                 class_str, epdrv->pdrv->driver.name);
 249                         fallthrough;
 250                 case EARLY_PLATFORM_ID_UNSET:
 251                         match = NULL;
 252                         break;
 253                 default:
 254                         match = sh_early_platform_match(epdrv, match_id);
 255                 }
 256
 257                 if (match) {
 258                         /*
 259                          * Set up a sensible init_name to enable
 260                          * dev_name() and others to be used before the
 261                          * rest of the driver core is initialized.
 262                          */
 263                         if (!match->dev.init_name && slab_is_available()) {
 264                                 if (match->id != -1)
 265                                         match->dev.init_name =
 266                                                 kasprintf(GFP_KERNEL, "%s.%d",
 267                                                           match->name,
 268                                                           match->id);
 269                                 else
 270                                         match->dev.init_name =
 271                                                 kasprintf(GFP_KERNEL, "%s",
 272                                                           match->name);
 273
 274                                 if (!match->dev.init_name)
 275                                         return -ENOMEM;
 276                         }
 277
 278                         if (epdrv->pdrv->probe(match))
 279                                 pr_warn("%s: unable to probe %s early.\n",
 280                                         class_str, match->name);
 281                         else
 282                                 n++;
 283                 }
 284
 285                 if (n >= nr_probe)
 286                         break;
 287         }
 288
 289         if (left)
 290                 return n;
 291         else
 292                 return -ENODEV;
 293 }
 294
 295 /**
 296  * sh_early_platform_driver_probe - probe a class of registered drivers
 297  * @class_str: string to identify early platform driver class
 298  * @nr_probe: number of platform devices to successfully probe before exiting
 299  * @user_only: only probe user specified early platform devices
 300  *
 301  * Used by architecture code to probe registered early platform drivers
 302  * within a certain class. For probe to happen a registered early platform
 303  * device matching a registered early platform driver is needed.
 304  */
 305 int __init sh_early_platform_driver_probe(char *class_str,
 306                                        int nr_probe,
 307                                        int user_only)
 308 {
 309         int k, n, i;
 310
 311         n = 0;
 312         for (i = -2; n < nr_probe; i++) {
 313                 k = sh_early_platform_driver_probe_id(class_str, i, nr_probe - n);
 314
 315                 if (k < 0)
 316                         break;
 317
 318                 n += k;
 319
 320                 if (user_only)
 321                         break;
 322         }
 323
 324         return n;
 325 }
 326
 327 /**
 328  * early_platform_cleanup - clean up early platform code
 329  */
 330 void __init early_platform_cleanup(void)
 331 {
 332         struct platform_device *pd, *pd2;
 333
 334         /* clean up the devres list used to chain devices */
 335         list_for_each_entry_safe(pd, pd2, &sh_early_platform_device_list,
 336                                  dev.devres_head) {
 337                 list_del(&pd->dev.devres_head);
 338                 memset(&pd->dev.devres_head, 0, sizeof(pd->dev.devres_head));
 339         }
 340 }