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