1 /*
2  * omap_device implementation
3  *
4  * Copyright (C) 2009-2010 Nokia Corporation
5  * Paul Walmsley, Kevin Hilman
6  *
7  * Developed in collaboration with (alphabetical order): Benoit
8  * Cousson, Thara Gopinath, Tony Lindgren, Rajendra Nayak, Vikram
9  * Pandita, Sakari Poussa, Anand Sawant, Santosh Shilimkar, Richard
10  * Woodruff
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License version 2 as
14  * published by the Free Software Foundation.
15  *
16  * This code provides a consistent interface for OMAP device drivers
17  * to control power management and interconnect properties of their
18  * devices.
19  *
20  * In the medium- to long-term, this code should be implemented as a
21  * proper omap_bus/omap_device in Linux, no more platform_data func
22  * pointers
23  *
24  *
25  */
26 #undef DEBUG
27 
28 #include <linux/kernel.h>
29 #include <linux/platform_device.h>
30 #include <linux/slab.h>
31 #include <linux/err.h>
32 #include <linux/io.h>
33 #include <linux/clk.h>
34 #include <linux/clkdev.h>
35 #include <linux/pm_domain.h>
36 #include <linux/pm_runtime.h>
37 #include <linux/of.h>
38 #include <linux/notifier.h>
39 
40 #include "common.h"
41 #include "soc.h"
42 #include "omap_device.h"
43 #include "omap_hwmod.h"
44 
45 /* Private functions */
46 
47 static void _add_clkdev(struct omap_device *od, const char *clk_alias,
48 		       const char *clk_name)
49 {
50 	struct clk *r;
51 	int rc;
52 
53 	if (!clk_alias || !clk_name)
54 		return;
55 
56 	dev_dbg(&od->pdev->dev, "Creating %s -> %s\n", clk_alias, clk_name);
57 
58 	r = clk_get_sys(dev_name(&od->pdev->dev), clk_alias);
59 	if (!IS_ERR(r)) {
60 		dev_dbg(&od->pdev->dev,
61 			 "alias %s already exists\n", clk_alias);
62 		clk_put(r);
63 		return;
64 	}
65 
66 	rc = clk_add_alias(clk_alias, dev_name(&od->pdev->dev), clk_name, NULL);
67 	if (rc) {
68 		if (rc == -ENODEV || rc == -ENOMEM)
69 			dev_err(&od->pdev->dev,
70 				"clkdev_alloc for %s failed\n", clk_alias);
71 		else
72 			dev_err(&od->pdev->dev,
73 				"clk_get for %s failed\n", clk_name);
74 	}
75 }
76 
77 /**
78  * _add_hwmod_clocks_clkdev - Add clkdev entry for hwmod optional clocks
79  * and main clock
80  * @od: struct omap_device *od
81  * @oh: struct omap_hwmod *oh
82  *
83  * For the main clock and every optional clock present per hwmod per
84  * omap_device, this function adds an entry in the clkdev table of the
85  * form <dev-id=dev_name, con-id=role> if it does not exist already.
86  *
87  * The function is called from inside omap_device_build_ss(), after
88  * omap_device_register.
89  *
90  * This allows drivers to get a pointer to its optional clocks based on its role
91  * by calling clk_get(<dev*>, <role>).
92  * In the case of the main clock, a "fck" alias is used.
93  *
94  * No return value.
95  */
96 static void _add_hwmod_clocks_clkdev(struct omap_device *od,
97 				     struct omap_hwmod *oh)
98 {
99 	int i;
100 
101 	_add_clkdev(od, "fck", oh->main_clk);
102 
103 	for (i = 0; i < oh->opt_clks_cnt; i++)
104 		_add_clkdev(od, oh->opt_clks[i].role, oh->opt_clks[i].clk);
105 }
106 
107 
108 /**
109  * omap_device_build_from_dt - build an omap_device with multiple hwmods
110  * @pdev_name: name of the platform_device driver to use
111  * @pdev_id: this platform_device's connection ID
112  * @oh: ptr to the single omap_hwmod that backs this omap_device
113  * @pdata: platform_data ptr to associate with the platform_device
114  * @pdata_len: amount of memory pointed to by @pdata
115  *
116  * Function for building an omap_device already registered from device-tree
117  *
118  * Returns 0 or PTR_ERR() on error.
119  */
120 static int omap_device_build_from_dt(struct platform_device *pdev)
121 {
122 	struct omap_hwmod **hwmods;
123 	struct omap_device *od;
124 	struct omap_hwmod *oh;
125 	struct device_node *node = pdev->dev.of_node;
126 	const char *oh_name;
127 	int oh_cnt, i, ret = 0;
128 	bool device_active = false;
129 
130 	oh_cnt = of_property_count_strings(node, "ti,hwmods");
131 	if (oh_cnt <= 0) {
132 		dev_dbg(&pdev->dev, "No 'hwmods' to build omap_device\n");
133 		return -ENODEV;
134 	}
135 
136 	hwmods = kzalloc(sizeof(struct omap_hwmod *) * oh_cnt, GFP_KERNEL);
137 	if (!hwmods) {
138 		ret = -ENOMEM;
139 		goto odbfd_exit;
140 	}
141 
142 	for (i = 0; i < oh_cnt; i++) {
143 		of_property_read_string_index(node, "ti,hwmods", i, &oh_name);
144 		oh = omap_hwmod_lookup(oh_name);
145 		if (!oh) {
146 			dev_err(&pdev->dev, "Cannot lookup hwmod '%s'\n",
147 				oh_name);
148 			ret = -EINVAL;
149 			goto odbfd_exit1;
150 		}
151 		hwmods[i] = oh;
152 		if (oh->flags & HWMOD_INIT_NO_IDLE)
153 			device_active = true;
154 	}
155 
156 	od = omap_device_alloc(pdev, hwmods, oh_cnt);
157 	if (IS_ERR(od)) {
158 		dev_err(&pdev->dev, "Cannot allocate omap_device for :%s\n",
159 			oh_name);
160 		ret = PTR_ERR(od);
161 		goto odbfd_exit1;
162 	}
163 
164 	/* Fix up missing resource names */
165 	for (i = 0; i < pdev->num_resources; i++) {
166 		struct resource *r = &pdev->resource[i];
167 
168 		if (r->name == NULL)
169 			r->name = dev_name(&pdev->dev);
170 	}
171 
172 	dev_pm_domain_set(&pdev->dev, &omap_device_pm_domain);
173 
174 	if (device_active) {
175 		omap_device_enable(pdev);
176 		pm_runtime_set_active(&pdev->dev);
177 	}
178 
179 odbfd_exit1:
180 	kfree(hwmods);
181 odbfd_exit:
182 	/* if data/we are at fault.. load up a fail handler */
183 	if (ret)
184 		dev_pm_domain_set(&pdev->dev, &omap_device_fail_pm_domain);
185 
186 	return ret;
187 }
188 
189 static int _omap_device_notifier_call(struct notifier_block *nb,
190 				      unsigned long event, void *dev)
191 {
192 	struct platform_device *pdev = to_platform_device(dev);
193 	struct omap_device *od;
194 
195 	switch (event) {
196 	case BUS_NOTIFY_DEL_DEVICE:
197 		if (pdev->archdata.od)
198 			omap_device_delete(pdev->archdata.od);
199 		break;
200 	case BUS_NOTIFY_ADD_DEVICE:
201 		if (pdev->dev.of_node)
202 			omap_device_build_from_dt(pdev);
203 		omap_auxdata_legacy_init(dev);
204 		/* fall through */
205 	default:
206 		od = to_omap_device(pdev);
207 		if (od)
208 			od->_driver_status = event;
209 	}
210 
211 	return NOTIFY_DONE;
212 }
213 
214 /**
215  * _omap_device_enable_hwmods - call omap_hwmod_enable() on all hwmods
216  * @od: struct omap_device *od
217  *
218  * Enable all underlying hwmods.  Returns 0.
219  */
220 static int _omap_device_enable_hwmods(struct omap_device *od)
221 {
222 	int ret = 0;
223 	int i;
224 
225 	for (i = 0; i < od->hwmods_cnt; i++)
226 		ret |= omap_hwmod_enable(od->hwmods[i]);
227 
228 	return ret;
229 }
230 
231 /**
232  * _omap_device_idle_hwmods - call omap_hwmod_idle() on all hwmods
233  * @od: struct omap_device *od
234  *
235  * Idle all underlying hwmods.  Returns 0.
236  */
237 static int _omap_device_idle_hwmods(struct omap_device *od)
238 {
239 	int ret = 0;
240 	int i;
241 
242 	for (i = 0; i < od->hwmods_cnt; i++)
243 		ret |= omap_hwmod_idle(od->hwmods[i]);
244 
245 	return ret;
246 }
247 
248 /* Public functions for use by core code */
249 
250 /**
251  * omap_device_get_context_loss_count - get lost context count
252  * @od: struct omap_device *
253  *
254  * Using the primary hwmod, query the context loss count for this
255  * device.
256  *
257  * Callers should consider context for this device lost any time this
258  * function returns a value different than the value the caller got
259  * the last time it called this function.
260  *
261  * If any hwmods exist for the omap_device assoiated with @pdev,
262  * return the context loss counter for that hwmod, otherwise return
263  * zero.
264  */
265 int omap_device_get_context_loss_count(struct platform_device *pdev)
266 {
267 	struct omap_device *od;
268 	u32 ret = 0;
269 
270 	od = to_omap_device(pdev);
271 
272 	if (od->hwmods_cnt)
273 		ret = omap_hwmod_get_context_loss_count(od->hwmods[0]);
274 
275 	return ret;
276 }
277 
278 /**
279  * omap_device_count_resources - count number of struct resource entries needed
280  * @od: struct omap_device *
281  * @flags: Type of resources to include when counting (IRQ/DMA/MEM)
282  *
283  * Count the number of struct resource entries needed for this
284  * omap_device @od.  Used by omap_device_build_ss() to determine how
285  * much memory to allocate before calling
286  * omap_device_fill_resources().  Returns the count.
287  */
288 static int omap_device_count_resources(struct omap_device *od,
289 				       unsigned long flags)
290 {
291 	int c = 0;
292 	int i;
293 
294 	for (i = 0; i < od->hwmods_cnt; i++)
295 		c += omap_hwmod_count_resources(od->hwmods[i], flags);
296 
297 	pr_debug("omap_device: %s: counted %d total resources across %d hwmods\n",
298 		 od->pdev->name, c, od->hwmods_cnt);
299 
300 	return c;
301 }
302 
303 /**
304  * omap_device_fill_resources - fill in array of struct resource
305  * @od: struct omap_device *
306  * @res: pointer to an array of struct resource to be filled in
307  *
308  * Populate one or more empty struct resource pointed to by @res with
309  * the resource data for this omap_device @od.  Used by
310  * omap_device_build_ss() after calling omap_device_count_resources().
311  * Ideally this function would not be needed at all.  If omap_device
312  * replaces platform_device, then we can specify our own
313  * get_resource()/ get_irq()/etc functions that use the underlying
314  * omap_hwmod information.  Or if platform_device is extended to use
315  * subarchitecture-specific function pointers, the various
316  * platform_device functions can simply call omap_device internal
317  * functions to get device resources.  Hacking around the existing
318  * platform_device code wastes memory.  Returns 0.
319  */
320 static int omap_device_fill_resources(struct omap_device *od,
321 				      struct resource *res)
322 {
323 	int i, r;
324 
325 	for (i = 0; i < od->hwmods_cnt; i++) {
326 		r = omap_hwmod_fill_resources(od->hwmods[i], res);
327 		res += r;
328 	}
329 
330 	return 0;
331 }
332 
333 /**
334  * _od_fill_dma_resources - fill in array of struct resource with dma resources
335  * @od: struct omap_device *
336  * @res: pointer to an array of struct resource to be filled in
337  *
338  * Populate one or more empty struct resource pointed to by @res with
339  * the dma resource data for this omap_device @od.  Used by
340  * omap_device_alloc() after calling omap_device_count_resources().
341  *
342  * Ideally this function would not be needed at all.  If we have
343  * mechanism to get dma resources from DT.
344  *
345  * Returns 0.
346  */
347 static int _od_fill_dma_resources(struct omap_device *od,
348 				      struct resource *res)
349 {
350 	int i, r;
351 
352 	for (i = 0; i < od->hwmods_cnt; i++) {
353 		r = omap_hwmod_fill_dma_resources(od->hwmods[i], res);
354 		res += r;
355 	}
356 
357 	return 0;
358 }
359 
360 /**
361  * omap_device_alloc - allocate an omap_device
362  * @pdev: platform_device that will be included in this omap_device
363  * @oh: ptr to the single omap_hwmod that backs this omap_device
364  * @pdata: platform_data ptr to associate with the platform_device
365  * @pdata_len: amount of memory pointed to by @pdata
366  *
367  * Convenience function for allocating an omap_device structure and filling
368  * hwmods, and resources.
369  *
370  * Returns an struct omap_device pointer or ERR_PTR() on error;
371  */
372 struct omap_device *omap_device_alloc(struct platform_device *pdev,
373 					struct omap_hwmod **ohs, int oh_cnt)
374 {
375 	int ret = -ENOMEM;
376 	struct omap_device *od;
377 	struct resource *res = NULL;
378 	int i, res_count;
379 	struct omap_hwmod **hwmods;
380 
381 	od = kzalloc(sizeof(struct omap_device), GFP_KERNEL);
382 	if (!od) {
383 		ret = -ENOMEM;
384 		goto oda_exit1;
385 	}
386 	od->hwmods_cnt = oh_cnt;
387 
388 	hwmods = kmemdup(ohs, sizeof(struct omap_hwmod *) * oh_cnt, GFP_KERNEL);
389 	if (!hwmods)
390 		goto oda_exit2;
391 
392 	od->hwmods = hwmods;
393 	od->pdev = pdev;
394 
395 	/*
396 	 * Non-DT Boot:
397 	 *   Here, pdev->num_resources = 0, and we should get all the
398 	 *   resources from hwmod.
399 	 *
400 	 * DT Boot:
401 	 *   OF framework will construct the resource structure (currently
402 	 *   does for MEM & IRQ resource) and we should respect/use these
403 	 *   resources, killing hwmod dependency.
404 	 *   If pdev->num_resources > 0, we assume that MEM & IRQ resources
405 	 *   have been allocated by OF layer already (through DTB).
406 	 *   As preparation for the future we examine the OF provided resources
407 	 *   to see if we have DMA resources provided already. In this case
408 	 *   there is no need to update the resources for the device, we use the
409 	 *   OF provided ones.
410 	 *
411 	 * TODO: Once DMA resource is available from OF layer, we should
412 	 *   kill filling any resources from hwmod.
413 	 */
414 	if (!pdev->num_resources) {
415 		/* Count all resources for the device */
416 		res_count = omap_device_count_resources(od, IORESOURCE_IRQ |
417 							    IORESOURCE_DMA |
418 							    IORESOURCE_MEM);
419 	} else {
420 		/* Take a look if we already have DMA resource via DT */
421 		for (i = 0; i < pdev->num_resources; i++) {
422 			struct resource *r = &pdev->resource[i];
423 
424 			/* We have it, no need to touch the resources */
425 			if (r->flags == IORESOURCE_DMA)
426 				goto have_everything;
427 		}
428 		/* Count only DMA resources for the device */
429 		res_count = omap_device_count_resources(od, IORESOURCE_DMA);
430 		/* The device has no DMA resource, no need for update */
431 		if (!res_count)
432 			goto have_everything;
433 
434 		res_count += pdev->num_resources;
435 	}
436 
437 	/* Allocate resources memory to account for new resources */
438 	res = kzalloc(sizeof(struct resource) * res_count, GFP_KERNEL);
439 	if (!res)
440 		goto oda_exit3;
441 
442 	if (!pdev->num_resources) {
443 		dev_dbg(&pdev->dev, "%s: using %d resources from hwmod\n",
444 			__func__, res_count);
445 		omap_device_fill_resources(od, res);
446 	} else {
447 		dev_dbg(&pdev->dev,
448 			"%s: appending %d DMA resources from hwmod\n",
449 			__func__, res_count - pdev->num_resources);
450 		memcpy(res, pdev->resource,
451 		       sizeof(struct resource) * pdev->num_resources);
452 		_od_fill_dma_resources(od, &res[pdev->num_resources]);
453 	}
454 
455 	ret = platform_device_add_resources(pdev, res, res_count);
456 	kfree(res);
457 
458 	if (ret)
459 		goto oda_exit3;
460 
461 have_everything:
462 	pdev->archdata.od = od;
463 
464 	for (i = 0; i < oh_cnt; i++) {
465 		hwmods[i]->od = od;
466 		_add_hwmod_clocks_clkdev(od, hwmods[i]);
467 	}
468 
469 	return od;
470 
471 oda_exit3:
472 	kfree(hwmods);
473 oda_exit2:
474 	kfree(od);
475 oda_exit1:
476 	dev_err(&pdev->dev, "omap_device: build failed (%d)\n", ret);
477 
478 	return ERR_PTR(ret);
479 }
480 
481 void omap_device_delete(struct omap_device *od)
482 {
483 	if (!od)
484 		return;
485 
486 	od->pdev->archdata.od = NULL;
487 	kfree(od->hwmods);
488 	kfree(od);
489 }
490 
491 /**
492  * omap_device_build - build and register an omap_device with one omap_hwmod
493  * @pdev_name: name of the platform_device driver to use
494  * @pdev_id: this platform_device's connection ID
495  * @oh: ptr to the single omap_hwmod that backs this omap_device
496  * @pdata: platform_data ptr to associate with the platform_device
497  * @pdata_len: amount of memory pointed to by @pdata
498  *
499  * Convenience function for building and registering a single
500  * omap_device record, which in turn builds and registers a
501  * platform_device record.  See omap_device_build_ss() for more
502  * information.  Returns ERR_PTR(-EINVAL) if @oh is NULL; otherwise,
503  * passes along the return value of omap_device_build_ss().
504  */
505 struct platform_device __init *omap_device_build(const char *pdev_name,
506 						 int pdev_id,
507 						 struct omap_hwmod *oh,
508 						 void *pdata, int pdata_len)
509 {
510 	struct omap_hwmod *ohs[] = { oh };
511 
512 	if (!oh)
513 		return ERR_PTR(-EINVAL);
514 
515 	return omap_device_build_ss(pdev_name, pdev_id, ohs, 1, pdata,
516 				    pdata_len);
517 }
518 
519 /**
520  * omap_device_build_ss - build and register an omap_device with multiple hwmods
521  * @pdev_name: name of the platform_device driver to use
522  * @pdev_id: this platform_device's connection ID
523  * @oh: ptr to the single omap_hwmod that backs this omap_device
524  * @pdata: platform_data ptr to associate with the platform_device
525  * @pdata_len: amount of memory pointed to by @pdata
526  *
527  * Convenience function for building and registering an omap_device
528  * subsystem record.  Subsystem records consist of multiple
529  * omap_hwmods.  This function in turn builds and registers a
530  * platform_device record.  Returns an ERR_PTR() on error, or passes
531  * along the return value of omap_device_register().
532  */
533 struct platform_device __init *omap_device_build_ss(const char *pdev_name,
534 						    int pdev_id,
535 						    struct omap_hwmod **ohs,
536 						    int oh_cnt, void *pdata,
537 						    int pdata_len)
538 {
539 	int ret = -ENOMEM;
540 	struct platform_device *pdev;
541 	struct omap_device *od;
542 
543 	if (!ohs || oh_cnt == 0 || !pdev_name)
544 		return ERR_PTR(-EINVAL);
545 
546 	if (!pdata && pdata_len > 0)
547 		return ERR_PTR(-EINVAL);
548 
549 	pdev = platform_device_alloc(pdev_name, pdev_id);
550 	if (!pdev) {
551 		ret = -ENOMEM;
552 		goto odbs_exit;
553 	}
554 
555 	/* Set the dev_name early to allow dev_xxx in omap_device_alloc */
556 	if (pdev->id != -1)
557 		dev_set_name(&pdev->dev, "%s.%d", pdev->name,  pdev->id);
558 	else
559 		dev_set_name(&pdev->dev, "%s", pdev->name);
560 
561 	od = omap_device_alloc(pdev, ohs, oh_cnt);
562 	if (IS_ERR(od))
563 		goto odbs_exit1;
564 
565 	ret = platform_device_add_data(pdev, pdata, pdata_len);
566 	if (ret)
567 		goto odbs_exit2;
568 
569 	ret = omap_device_register(pdev);
570 	if (ret)
571 		goto odbs_exit2;
572 
573 	return pdev;
574 
575 odbs_exit2:
576 	omap_device_delete(od);
577 odbs_exit1:
578 	platform_device_put(pdev);
579 odbs_exit:
580 
581 	pr_err("omap_device: %s: build failed (%d)\n", pdev_name, ret);
582 
583 	return ERR_PTR(ret);
584 }
585 
586 #ifdef CONFIG_PM
587 static int _od_runtime_suspend(struct device *dev)
588 {
589 	struct platform_device *pdev = to_platform_device(dev);
590 	int ret;
591 
592 	ret = pm_generic_runtime_suspend(dev);
593 	if (ret)
594 		return ret;
595 
596 	return omap_device_idle(pdev);
597 }
598 
599 static int _od_runtime_resume(struct device *dev)
600 {
601 	struct platform_device *pdev = to_platform_device(dev);
602 	int ret;
603 
604 	ret = omap_device_enable(pdev);
605 	if (ret)
606 		return ret;
607 
608 	return pm_generic_runtime_resume(dev);
609 }
610 
611 static int _od_fail_runtime_suspend(struct device *dev)
612 {
613 	dev_warn(dev, "%s: FIXME: missing hwmod/omap_dev info\n", __func__);
614 	return -ENODEV;
615 }
616 
617 static int _od_fail_runtime_resume(struct device *dev)
618 {
619 	dev_warn(dev, "%s: FIXME: missing hwmod/omap_dev info\n", __func__);
620 	return -ENODEV;
621 }
622 
623 #endif
624 
625 #ifdef CONFIG_SUSPEND
626 static int _od_suspend_noirq(struct device *dev)
627 {
628 	struct platform_device *pdev = to_platform_device(dev);
629 	struct omap_device *od = to_omap_device(pdev);
630 	int ret;
631 
632 	/* Don't attempt late suspend on a driver that is not bound */
633 	if (od->_driver_status != BUS_NOTIFY_BOUND_DRIVER)
634 		return 0;
635 
636 	ret = pm_generic_suspend_noirq(dev);
637 
638 	if (!ret && !pm_runtime_status_suspended(dev)) {
639 		if (pm_generic_runtime_suspend(dev) == 0) {
640 			pm_runtime_set_suspended(dev);
641 			omap_device_idle(pdev);
642 			od->flags |= OMAP_DEVICE_SUSPENDED;
643 		}
644 	}
645 
646 	return ret;
647 }
648 
649 static int _od_resume_noirq(struct device *dev)
650 {
651 	struct platform_device *pdev = to_platform_device(dev);
652 	struct omap_device *od = to_omap_device(pdev);
653 
654 	if (od->flags & OMAP_DEVICE_SUSPENDED) {
655 		od->flags &= ~OMAP_DEVICE_SUSPENDED;
656 		omap_device_enable(pdev);
657 		/*
658 		 * XXX: we run before core runtime pm has resumed itself. At
659 		 * this point in time, we just restore the runtime pm state and
660 		 * considering symmetric operations in resume, we donot expect
661 		 * to fail. If we failed, something changed in core runtime_pm
662 		 * framework OR some device driver messed things up, hence, WARN
663 		 */
664 		WARN(pm_runtime_set_active(dev),
665 		     "Could not set %s runtime state active\n", dev_name(dev));
666 		pm_generic_runtime_resume(dev);
667 	}
668 
669 	return pm_generic_resume_noirq(dev);
670 }
671 #else
672 #define _od_suspend_noirq NULL
673 #define _od_resume_noirq NULL
674 #endif
675 
676 struct dev_pm_domain omap_device_fail_pm_domain = {
677 	.ops = {
678 		SET_RUNTIME_PM_OPS(_od_fail_runtime_suspend,
679 				   _od_fail_runtime_resume, NULL)
680 	}
681 };
682 
683 struct dev_pm_domain omap_device_pm_domain = {
684 	.ops = {
685 		SET_RUNTIME_PM_OPS(_od_runtime_suspend, _od_runtime_resume,
686 				   NULL)
687 		USE_PLATFORM_PM_SLEEP_OPS
688 		SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(_od_suspend_noirq,
689 					      _od_resume_noirq)
690 	}
691 };
692 
693 /**
694  * omap_device_register - register an omap_device with one omap_hwmod
695  * @od: struct omap_device * to register
696  *
697  * Register the omap_device structure.  This currently just calls
698  * platform_device_register() on the underlying platform_device.
699  * Returns the return value of platform_device_register().
700  */
701 int omap_device_register(struct platform_device *pdev)
702 {
703 	pr_debug("omap_device: %s: registering\n", pdev->name);
704 
705 	dev_pm_domain_set(&pdev->dev, &omap_device_pm_domain);
706 	return platform_device_add(pdev);
707 }
708 
709 
710 /* Public functions for use by device drivers through struct platform_data */
711 
712 /**
713  * omap_device_enable - fully activate an omap_device
714  * @od: struct omap_device * to activate
715  *
716  * Do whatever is necessary for the hwmods underlying omap_device @od
717  * to be accessible and ready to operate.  This generally involves
718  * enabling clocks, setting SYSCONFIG registers; and in the future may
719  * involve remuxing pins.  Device drivers should call this function
720  * indirectly via pm_runtime_get*().  Returns -EINVAL if called when
721  * the omap_device is already enabled, or passes along the return
722  * value of _omap_device_enable_hwmods().
723  */
724 int omap_device_enable(struct platform_device *pdev)
725 {
726 	int ret;
727 	struct omap_device *od;
728 
729 	od = to_omap_device(pdev);
730 
731 	if (od->_state == OMAP_DEVICE_STATE_ENABLED) {
732 		dev_warn(&pdev->dev,
733 			 "omap_device: %s() called from invalid state %d\n",
734 			 __func__, od->_state);
735 		return -EINVAL;
736 	}
737 
738 	ret = _omap_device_enable_hwmods(od);
739 
740 	if (ret == 0)
741 		od->_state = OMAP_DEVICE_STATE_ENABLED;
742 
743 	return ret;
744 }
745 
746 /**
747  * omap_device_idle - idle an omap_device
748  * @od: struct omap_device * to idle
749  *
750  * Idle omap_device @od.  Device drivers call this function indirectly
751  * via pm_runtime_put*().  Returns -EINVAL if the omap_device is not
752  * currently enabled, or passes along the return value of
753  * _omap_device_idle_hwmods().
754  */
755 int omap_device_idle(struct platform_device *pdev)
756 {
757 	int ret;
758 	struct omap_device *od;
759 
760 	od = to_omap_device(pdev);
761 
762 	if (od->_state != OMAP_DEVICE_STATE_ENABLED) {
763 		dev_warn(&pdev->dev,
764 			 "omap_device: %s() called from invalid state %d\n",
765 			 __func__, od->_state);
766 		return -EINVAL;
767 	}
768 
769 	ret = _omap_device_idle_hwmods(od);
770 
771 	if (ret == 0)
772 		od->_state = OMAP_DEVICE_STATE_IDLE;
773 
774 	return ret;
775 }
776 
777 /**
778  * omap_device_assert_hardreset - set a device's hardreset line
779  * @pdev: struct platform_device * to reset
780  * @name: const char * name of the reset line
781  *
782  * Set the hardreset line identified by @name on the IP blocks
783  * associated with the hwmods backing the platform_device @pdev.  All
784  * of the hwmods associated with @pdev must have the same hardreset
785  * line linked to them for this to work.  Passes along the return value
786  * of omap_hwmod_assert_hardreset() in the event of any failure, or
787  * returns 0 upon success.
788  */
789 int omap_device_assert_hardreset(struct platform_device *pdev, const char *name)
790 {
791 	struct omap_device *od = to_omap_device(pdev);
792 	int ret = 0;
793 	int i;
794 
795 	for (i = 0; i < od->hwmods_cnt; i++) {
796 		ret = omap_hwmod_assert_hardreset(od->hwmods[i], name);
797 		if (ret)
798 			break;
799 	}
800 
801 	return ret;
802 }
803 
804 /**
805  * omap_device_deassert_hardreset - release a device's hardreset line
806  * @pdev: struct platform_device * to reset
807  * @name: const char * name of the reset line
808  *
809  * Release the hardreset line identified by @name on the IP blocks
810  * associated with the hwmods backing the platform_device @pdev.  All
811  * of the hwmods associated with @pdev must have the same hardreset
812  * line linked to them for this to work.  Passes along the return
813  * value of omap_hwmod_deassert_hardreset() in the event of any
814  * failure, or returns 0 upon success.
815  */
816 int omap_device_deassert_hardreset(struct platform_device *pdev,
817 				   const char *name)
818 {
819 	struct omap_device *od = to_omap_device(pdev);
820 	int ret = 0;
821 	int i;
822 
823 	for (i = 0; i < od->hwmods_cnt; i++) {
824 		ret = omap_hwmod_deassert_hardreset(od->hwmods[i], name);
825 		if (ret)
826 			break;
827 	}
828 
829 	return ret;
830 }
831 
832 /**
833  * omap_device_get_by_hwmod_name() - convert a hwmod name to
834  * device pointer.
835  * @oh_name: name of the hwmod device
836  *
837  * Returns back a struct device * pointer associated with a hwmod
838  * device represented by a hwmod_name
839  */
840 struct device *omap_device_get_by_hwmod_name(const char *oh_name)
841 {
842 	struct omap_hwmod *oh;
843 
844 	if (!oh_name) {
845 		WARN(1, "%s: no hwmod name!\n", __func__);
846 		return ERR_PTR(-EINVAL);
847 	}
848 
849 	oh = omap_hwmod_lookup(oh_name);
850 	if (!oh) {
851 		WARN(1, "%s: no hwmod for %s\n", __func__,
852 			oh_name);
853 		return ERR_PTR(-ENODEV);
854 	}
855 	if (!oh->od) {
856 		WARN(1, "%s: no omap_device for %s\n", __func__,
857 			oh_name);
858 		return ERR_PTR(-ENODEV);
859 	}
860 
861 	return &oh->od->pdev->dev;
862 }
863 
864 static struct notifier_block platform_nb = {
865 	.notifier_call = _omap_device_notifier_call,
866 };
867 
868 static int __init omap_device_init(void)
869 {
870 	bus_register_notifier(&platform_bus_type, &platform_nb);
871 	return 0;
872 }
873 omap_postcore_initcall(omap_device_init);
874 
875 /**
876  * omap_device_late_idle - idle devices without drivers
877  * @dev: struct device * associated with omap_device
878  * @data: unused
879  *
880  * Check the driver bound status of this device, and idle it
881  * if there is no driver attached.
882  */
883 static int __init omap_device_late_idle(struct device *dev, void *data)
884 {
885 	struct platform_device *pdev = to_platform_device(dev);
886 	struct omap_device *od = to_omap_device(pdev);
887 	int i;
888 
889 	if (!od)
890 		return 0;
891 
892 	/*
893 	 * If omap_device state is enabled, but has no driver bound,
894 	 * idle it.
895 	 */
896 
897 	/*
898 	 * Some devices (like memory controllers) are always kept
899 	 * enabled, and should not be idled even with no drivers.
900 	 */
901 	for (i = 0; i < od->hwmods_cnt; i++)
902 		if (od->hwmods[i]->flags & HWMOD_INIT_NO_IDLE)
903 			return 0;
904 
905 	if (od->_driver_status != BUS_NOTIFY_BOUND_DRIVER &&
906 	    od->_driver_status != BUS_NOTIFY_BIND_DRIVER) {
907 		if (od->_state == OMAP_DEVICE_STATE_ENABLED) {
908 			dev_warn(dev, "%s: enabled but no driver.  Idling\n",
909 				 __func__);
910 			omap_device_idle(pdev);
911 		}
912 	}
913 
914 	return 0;
915 }
916 
917 static int __init omap_device_late_init(void)
918 {
919 	bus_for_each_dev(&platform_bus_type, NULL, NULL, omap_device_late_idle);
920 
921 	WARN(!of_have_populated_dt(),
922 		"legacy booting deprecated, please update to boot with .dts\n");
923 
924 	return 0;
925 }
926 omap_late_initcall_sync(omap_device_late_init);
927