omap_device.rar_V2

/* * omap_device implementation * * Copyright (C) 2009-2010 Nokia Corporation * Paul Walmsley, Kevin Hilman * * Developed in collaboration with (alphabetical order): Benoit * Cousson, Thara Gopinath, Tony Lindgren, Rajendra Nayak, Vikram * Pandita, Sakari Poussa, Anand Sawant, Santosh Shilimkar, Richard * Woodruff * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This code provides a consistent interface for OMAP device drivers * to control power management and interconnect properties of their * devices. * * In the medium- to long-term, this code should be implemented as a * proper omap_bus/omap_device in Linux, no more platform_data func * pointers * * */ #undef DEBUG #include <linux/kernel.h> #include <linux/platform_device.h> #include <linux/slab.h> #include <linux/err.h> #include <linux/io.h> #include <linux/clk.h> #include <linux/clkdev.h> #include <linux/pm_runtime.h> #include <linux/of.h> #include <linux/notifier.h> #include "common.h" #include "soc.h" #include "omap_device.h" #include "omap_hwmod.h" /* Private functions */ static void _add_clkdev(struct omap_device *od, const char *clk_alias, const char *clk_name) { struct clk *r; struct clk_lookup *l; if (!clk_alias || !clk_name) return; dev_dbg(&od->pdev->dev, "Creating %s -> %s\n", clk_alias, clk_name); r = clk_get_sys(dev_name(&od->pdev->dev), clk_alias); if (!IS_ERR(r)) { dev_dbg(&od->pdev->dev, "alias %s already exists\n", clk_alias); clk_put(r); return; } r = clk_get(NULL, clk_name); if (IS_ERR(r)) { dev_err(&od->pdev->dev, "clk_get for %s failed\n", clk_name); return; } l = clkdev_alloc(r, clk_alias, dev_name(&od->pdev->dev)); if (!l) { dev_err(&od->pdev->dev, "clkdev_alloc for %s failed\n", clk_alias); return; } clkdev_add(l); } /** * _add_hwmod_clocks_clkdev - Add clkdev entry for hwmod optional clocks * and main clock * @od: struct omap_device *od * @oh: struct omap_hwmod *oh * * For the main clock and every optional clock present per hwmod per * omap_device, this function adds an entry in the clkdev table of the * form <dev-id=dev_name, con-id=role> if it does not exist already. * * The function is called from inside omap_device_build_ss(), after * omap_device_register. * * This allows drivers to get a pointer to its optional clocks based on its role * by calling clk_get(<dev*>, <role>). * In the case of the main clock, a "fck" alias is used. * * No return value. */ static void _add_hwmod_clocks_clkdev(struct omap_device *od, struct omap_hwmod *oh) { int i; _add_clkdev(od, "fck", oh->main_clk); for (i = 0; i < oh->opt_clks_cnt; i++) _add_clkdev(od, oh->opt_clks[i].role, oh->opt_clks[i].clk); } /** * omap_device_build_from_dt - build an omap_device with multiple hwmods * @pdev_name: name of the platform_device driver to use * @pdev_id: this platform_device's connection ID * @oh: ptr to the single omap_hwmod that backs this omap_device * @pdata: platform_data ptr to associate with the platform_device * @pdata_len: amount of memory pointed to by @pdata * * Function for building an omap_device already registered from device-tree * * Returns 0 or PTR_ERR() on error. */ static int omap_device_build_from_dt(struct platform_device *pdev) { struct omap_hwmod **hwmods; struct omap_device *od; struct omap_hwmod *oh; struct device_node *node = pdev->dev.of_node; const char *oh_name; int oh_cnt, i, ret = 0; bool device_active = false; oh_cnt = of_property_count_strings(node, "ti,hwmods"); if (oh_cnt <= 0) { dev_dbg(&pdev->dev, "No 'hwmods' to build omap_device\n"); return -ENODEV; } hwmods = kzalloc(sizeof(struct omap_hwmod *) * oh_cnt, GFP_KERNEL); if (!hwmods) { ret = -ENOMEM; goto odbfd_exit; } for (i = 0; i < oh_cnt; i++) { of_property_read_string_index(node, "ti,hwmods", i, &oh_name); oh = omap_hwmod_lookup(oh_name); if (!oh) { dev_err(&pdev->dev, "Cannot lookup hwmod '%s'\n", oh_name); ret = -EINVAL; goto odbfd_exit1; } hwmods[i] = oh; if (oh->flags & HWMOD_INIT_NO_IDLE) device_active = true; } od = omap_device_alloc(pdev, hwmods, oh_cnt); if (IS_ERR(od)) { dev_err(&pdev->dev, "Cannot allocate omap_device for :%s\n", oh_name); ret = PTR_ERR(od); goto odbfd_exit1; } /* Fix up missing resource names */ for (i = 0; i < pdev->num_resources; i++) { struct resource *r = &pdev->resource[i]; if (r->name == NULL) r->name = dev_name(&pdev->dev); } pdev->dev.pm_domain = &omap_device_pm_domain; if (device_active) { omap_device_enable(pdev); pm_runtime_set_active(&pdev->dev); } odbfd_exit1: kfree(hwmods); odbfd_exit: /* if data/we are at fault.. load up a fail handler */ if (ret) pdev->dev.pm_domain = &omap_device_fail_pm_domain; return ret; } static int _omap_device_notifier_call(struct notifier_block *nb, unsigned long event, void *dev) { struct platform_device *pdev = to_platform_device(dev); struct omap_device *od; switch (event) { case BUS_NOTIFY_DEL_DEVICE: if (pdev->archdata.od) omap_device_delete(pdev->archdata.od); break; case BUS_NOTIFY_ADD_DEVICE: if (pdev->dev.of_node) omap_device_build_from_dt(pdev); omap_auxdata_legacy_init(dev); /* fall through */ default: od = to_omap_device(pdev); if (od) od->_driver_status = event; } return NOTIFY_DONE; } /** * _omap_device_enable_hwmods - call omap_hwmod_enable() on all hwmods * @od: struct omap_device *od * * Enable all underlying hwmods. Returns 0. */ static int _omap_device_enable_hwmods(struct omap_device *od) { int i; for (i = 0; i < od->hwmods_cnt; i++) omap_hwmod_enable(od->hwmods[i]); /* XXX pass along return value here? */ return 0; } /** * _omap_device_idle_hwmods - call omap_hwmod_idle() on all hwmods * @od: struct omap_device *od * * Idle all underlying hwmods. Returns 0. */ static int _omap_device_idle_hwmods(struct omap_device *od) { int i; for (i = 0; i < od->hwmods_cnt; i++) omap_hwmod_idle(od->hwmods[i]); /* XXX pass along return value here? */ return 0; } /* Public functions for use by core code */ /** * omap_device_get_context_loss_count - get lost context count * @od: struct omap_device * * * Using the primary hwmod, query the context loss count for this * device. * * Callers should consider context for this device lost any time this * function returns a value different than the value the caller got * the last time it called this function. * * If any hwmods exist for the omap_device assoiated with @pdev, * return the context loss counter for that hwmod, otherwise return * zero. */ int omap_device_get_context_loss_count(struct platform_device *pdev) { struct omap_device *od; u32 ret = 0; od = to_omap_device(pdev); if (od->hwmods_cnt) ret = omap_hwmod_get_context_loss_count(od->hwmods[0]); return ret; } /** * omap_device_count_resources - count number of struct resource entries needed * @od: struct omap_device * * @flags: Type of resources to include when counting (IRQ/DMA/MEM) * * Count the number of struct resource entries needed for this * omap_device @od. Used by omap_device_build_ss() to determine how * much memory to allocate before calling * omap_device_fill_resources(). Returns the count. */ static int omap_device_count_resources(struct omap_device *od, unsigned long flags) { int c = 0; int i; for (i = 0; i < od->hwmods_cnt; i++) c += omap_hwmod_count_resources(od->hwmods[i], flags); pr_debug("omap_device: %s: counted %d total resources across %d hwmods\n", od->pdev->name, c, od->hwmods_cnt); return c; } /** * omap_device_fill_resources - fill in array of struct resource * @od: struct omap_device * * @res: pointer to an array of struct resource to be filled in * * Populate one or more empty struct resource pointed to by @r