| // SPDX-License-Identifier: GPL-2.0-only |
| /* |
| * Copyright (C) 2016 Robert Jarzmik <robert.jarzmik@free.fr> |
| */ |
| |
| #include <linux/module.h> |
| #include <linux/bitops.h> |
| #include <linux/clk.h> |
| #include <linux/device.h> |
| #include <linux/idr.h> |
| #include <linux/list.h> |
| #include <linux/mutex.h> |
| #include <linux/of.h> |
| #include <linux/pm.h> |
| #include <linux/pm_runtime.h> |
| #include <linux/slab.h> |
| #include <linux/sysfs.h> |
| #include <sound/ac97/codec.h> |
| #include <sound/ac97/controller.h> |
| #include <sound/ac97/regs.h> |
| |
| #include "ac97_core.h" |
| |
| /* |
| * Protects ac97_controllers and each ac97_controller structure. |
| */ |
| static DEFINE_MUTEX(ac97_controllers_mutex); |
| static DEFINE_IDR(ac97_adapter_idr); |
| static LIST_HEAD(ac97_controllers); |
| |
| static struct bus_type ac97_bus_type; |
| |
| static inline struct ac97_controller* |
| to_ac97_controller(struct device *ac97_adapter) |
| { |
| return container_of(ac97_adapter, struct ac97_controller, adap); |
| } |
| |
| static int ac97_unbound_ctrl_write(struct ac97_controller *adrv, int slot, |
| unsigned short reg, unsigned short val) |
| { |
| return -ENODEV; |
| } |
| |
| static int ac97_unbound_ctrl_read(struct ac97_controller *adrv, int slot, |
| unsigned short reg) |
| { |
| return -ENODEV; |
| } |
| |
| static const struct ac97_controller_ops ac97_unbound_ctrl_ops = { |
| .write = ac97_unbound_ctrl_write, |
| .read = ac97_unbound_ctrl_read, |
| }; |
| |
| static struct ac97_controller ac97_unbound_ctrl = { |
| .ops = &ac97_unbound_ctrl_ops, |
| }; |
| |
| static struct ac97_codec_device * |
| ac97_codec_find(struct ac97_controller *ac97_ctrl, unsigned int codec_num) |
| { |
| if (codec_num >= AC97_BUS_MAX_CODECS) |
| return ERR_PTR(-EINVAL); |
| |
| return ac97_ctrl->codecs[codec_num]; |
| } |
| |
| static struct device_node * |
| ac97_of_get_child_device(struct ac97_controller *ac97_ctrl, int idx, |
| unsigned int vendor_id) |
| { |
| struct device_node *node; |
| u32 reg; |
| char compat[] = "ac97,0000,0000"; |
| |
| snprintf(compat, sizeof(compat), "ac97,%04x,%04x", |
| vendor_id >> 16, vendor_id & 0xffff); |
| |
| for_each_child_of_node(ac97_ctrl->parent->of_node, node) { |
| if ((idx != of_property_read_u32(node, "reg", ®)) || |
| !of_device_is_compatible(node, compat)) |
| continue; |
| return node; |
| } |
| |
| return NULL; |
| } |
| |
| static void ac97_codec_release(struct device *dev) |
| { |
| struct ac97_codec_device *adev; |
| struct ac97_controller *ac97_ctrl; |
| |
| adev = to_ac97_device(dev); |
| ac97_ctrl = adev->ac97_ctrl; |
| ac97_ctrl->codecs[adev->num] = NULL; |
| of_node_put(dev->of_node); |
| kfree(adev); |
| } |
| |
| static int ac97_codec_add(struct ac97_controller *ac97_ctrl, int idx, |
| unsigned int vendor_id) |
| { |
| struct ac97_codec_device *codec; |
| int ret; |
| |
| codec = kzalloc(sizeof(*codec), GFP_KERNEL); |
| if (!codec) |
| return -ENOMEM; |
| ac97_ctrl->codecs[idx] = codec; |
| codec->vendor_id = vendor_id; |
| codec->dev.release = ac97_codec_release; |
| codec->dev.bus = &ac97_bus_type; |
| codec->dev.parent = &ac97_ctrl->adap; |
| codec->num = idx; |
| codec->ac97_ctrl = ac97_ctrl; |
| |
| device_initialize(&codec->dev); |
| dev_set_name(&codec->dev, "%s:%u", dev_name(ac97_ctrl->parent), idx); |
| codec->dev.of_node = ac97_of_get_child_device(ac97_ctrl, idx, |
| vendor_id); |
| |
| ret = device_add(&codec->dev); |
| if (ret) { |
| put_device(&codec->dev); |
| return ret; |
| } |
| |
| return 0; |
| } |
| |
| unsigned int snd_ac97_bus_scan_one(struct ac97_controller *adrv, |
| unsigned int codec_num) |
| { |
| unsigned short vid1, vid2; |
| int ret; |
| |
| ret = adrv->ops->read(adrv, codec_num, AC97_VENDOR_ID1); |
| vid1 = (ret & 0xffff); |
| if (ret < 0) |
| return 0; |
| |
| ret = adrv->ops->read(adrv, codec_num, AC97_VENDOR_ID2); |
| vid2 = (ret & 0xffff); |
| if (ret < 0) |
| return 0; |
| |
| dev_dbg(&adrv->adap, "%s(codec_num=%u): vendor_id=0x%08x\n", |
| __func__, codec_num, AC97_ID(vid1, vid2)); |
| return AC97_ID(vid1, vid2); |
| } |
| |
| static int ac97_bus_scan(struct ac97_controller *ac97_ctrl) |
| { |
| int ret, i; |
| unsigned int vendor_id; |
| |
| for (i = 0; i < AC97_BUS_MAX_CODECS; i++) { |
| if (ac97_codec_find(ac97_ctrl, i)) |
| continue; |
| if (!(ac97_ctrl->slots_available & BIT(i))) |
| continue; |
| vendor_id = snd_ac97_bus_scan_one(ac97_ctrl, i); |
| if (!vendor_id) |
| continue; |
| |
| ret = ac97_codec_add(ac97_ctrl, i, vendor_id); |
| if (ret < 0) |
| return ret; |
| } |
| return 0; |
| } |
| |
| static int ac97_bus_reset(struct ac97_controller *ac97_ctrl) |
| { |
| ac97_ctrl->ops->reset(ac97_ctrl); |
| |
| return 0; |
| } |
| |
| /** |
| * snd_ac97_codec_driver_register - register an AC97 codec driver |
| * @dev: AC97 driver codec to register |
| * |
| * Register an AC97 codec driver to the ac97 bus driver, aka. the AC97 digital |
| * controller. |
| * |
| * Returns 0 on success or error code |
| */ |
| int snd_ac97_codec_driver_register(struct ac97_codec_driver *drv) |
| { |
| drv->driver.bus = &ac97_bus_type; |
| return driver_register(&drv->driver); |
| } |
| EXPORT_SYMBOL_GPL(snd_ac97_codec_driver_register); |
| |
| /** |
| * snd_ac97_codec_driver_unregister - unregister an AC97 codec driver |
| * @dev: AC97 codec driver to unregister |
| * |
| * Unregister a previously registered ac97 codec driver. |
| */ |
| void snd_ac97_codec_driver_unregister(struct ac97_codec_driver *drv) |
| { |
| driver_unregister(&drv->driver); |
| } |
| EXPORT_SYMBOL_GPL(snd_ac97_codec_driver_unregister); |
| |
| /** |
| * snd_ac97_codec_get_platdata - get platform_data |
| * @adev: the ac97 codec device |
| * |
| * For legacy platforms, in order to have platform_data in codec drivers |
| * available, while ac97 device are auto-created upon probe, this retrieves the |
| * platdata which was setup on ac97 controller registration. |
| * |
| * Returns the platform data pointer |
| */ |
| void *snd_ac97_codec_get_platdata(const struct ac97_codec_device *adev) |
| { |
| struct ac97_controller *ac97_ctrl = adev->ac97_ctrl; |
| |
| return ac97_ctrl->codecs_pdata[adev->num]; |
| } |
| EXPORT_SYMBOL_GPL(snd_ac97_codec_get_platdata); |
| |
| static void ac97_ctrl_codecs_unregister(struct ac97_controller *ac97_ctrl) |
| { |
| int i; |
| |
| for (i = 0; i < AC97_BUS_MAX_CODECS; i++) |
| if (ac97_ctrl->codecs[i]) { |
| ac97_ctrl->codecs[i]->ac97_ctrl = &ac97_unbound_ctrl; |
| device_unregister(&ac97_ctrl->codecs[i]->dev); |
| } |
| } |
| |
| static ssize_t cold_reset_store(struct device *dev, |
| struct device_attribute *attr, const char *buf, |
| size_t len) |
| { |
| struct ac97_controller *ac97_ctrl; |
| |
| mutex_lock(&ac97_controllers_mutex); |
| ac97_ctrl = to_ac97_controller(dev); |
| ac97_ctrl->ops->reset(ac97_ctrl); |
| mutex_unlock(&ac97_controllers_mutex); |
| return len; |
| } |
| static DEVICE_ATTR_WO(cold_reset); |
| |
| static ssize_t warm_reset_store(struct device *dev, |
| struct device_attribute *attr, const char *buf, |
| size_t len) |
| { |
| struct ac97_controller *ac97_ctrl; |
| |
| if (!dev) |
| return -ENODEV; |
| |
| mutex_lock(&ac97_controllers_mutex); |
| ac97_ctrl = to_ac97_controller(dev); |
| ac97_ctrl->ops->warm_reset(ac97_ctrl); |
| mutex_unlock(&ac97_controllers_mutex); |
| return len; |
| } |
| static DEVICE_ATTR_WO(warm_reset); |
| |
| static struct attribute *ac97_controller_device_attrs[] = { |
| &dev_attr_cold_reset.attr, |
| &dev_attr_warm_reset.attr, |
| NULL |
| }; |
| |
| static const struct attribute_group ac97_adapter_attr_group = { |
| .name = "ac97_operations", |
| .attrs = ac97_controller_device_attrs, |
| }; |
| |
| static const struct attribute_group *ac97_adapter_groups[] = { |
| &ac97_adapter_attr_group, |
| NULL, |
| }; |
| |
| static void ac97_del_adapter(struct ac97_controller *ac97_ctrl) |
| { |
| mutex_lock(&ac97_controllers_mutex); |
| ac97_ctrl_codecs_unregister(ac97_ctrl); |
| list_del(&ac97_ctrl->controllers); |
| mutex_unlock(&ac97_controllers_mutex); |
| |
| device_unregister(&ac97_ctrl->adap); |
| } |
| |
| static void ac97_adapter_release(struct device *dev) |
| { |
| struct ac97_controller *ac97_ctrl; |
| |
| ac97_ctrl = to_ac97_controller(dev); |
| idr_remove(&ac97_adapter_idr, ac97_ctrl->nr); |
| dev_dbg(&ac97_ctrl->adap, "adapter unregistered by %s\n", |
| dev_name(ac97_ctrl->parent)); |
| } |
| |
| static const struct device_type ac97_adapter_type = { |
| .groups = ac97_adapter_groups, |
| .release = ac97_adapter_release, |
| }; |
| |
| static int ac97_add_adapter(struct ac97_controller *ac97_ctrl) |
| { |
| int ret; |
| |
| mutex_lock(&ac97_controllers_mutex); |
| ret = idr_alloc(&ac97_adapter_idr, ac97_ctrl, 0, 0, GFP_KERNEL); |
| ac97_ctrl->nr = ret; |
| if (ret >= 0) { |
| dev_set_name(&ac97_ctrl->adap, "ac97-%d", ret); |
| ac97_ctrl->adap.type = &ac97_adapter_type; |
| ac97_ctrl->adap.parent = ac97_ctrl->parent; |
| ret = device_register(&ac97_ctrl->adap); |
| if (ret) |
| put_device(&ac97_ctrl->adap); |
| } |
| if (!ret) |
| list_add(&ac97_ctrl->controllers, &ac97_controllers); |
| mutex_unlock(&ac97_controllers_mutex); |
| |
| if (!ret) |
| dev_dbg(&ac97_ctrl->adap, "adapter registered by %s\n", |
| dev_name(ac97_ctrl->parent)); |
| return ret; |
| } |
| |
| /** |
| * snd_ac97_controller_register - register an ac97 controller |
| * @ops: the ac97 bus operations |
| * @dev: the device providing the ac97 DC function |
| * @slots_available: mask of the ac97 codecs that can be scanned and probed |
| * bit0 => codec 0, bit1 => codec 1 ... bit 3 => codec 3 |
| * |
| * Register a digital controller which can control up to 4 ac97 codecs. This is |
| * the controller side of the AC97 AC-link, while the slave side are the codecs. |
| * |
| * Returns a valid controller upon success, negative pointer value upon error |
| */ |
| struct ac97_controller *snd_ac97_controller_register( |
| const struct ac97_controller_ops *ops, struct device *dev, |
| unsigned short slots_available, void **codecs_pdata) |
| { |
| struct ac97_controller *ac97_ctrl; |
| int ret, i; |
| |
| ac97_ctrl = kzalloc(sizeof(*ac97_ctrl), GFP_KERNEL); |
| if (!ac97_ctrl) |
| return ERR_PTR(-ENOMEM); |
| |
| for (i = 0; i < AC97_BUS_MAX_CODECS && codecs_pdata; i++) |
| ac97_ctrl->codecs_pdata[i] = codecs_pdata[i]; |
| |
| ac97_ctrl->ops = ops; |
| ac97_ctrl->slots_available = slots_available; |
| ac97_ctrl->parent = dev; |
| ret = ac97_add_adapter(ac97_ctrl); |
| |
| if (ret) |
| goto err; |
| ac97_bus_reset(ac97_ctrl); |
| ac97_bus_scan(ac97_ctrl); |
| |
| return ac97_ctrl; |
| err: |
| kfree(ac97_ctrl); |
| return ERR_PTR(ret); |
| } |
| EXPORT_SYMBOL_GPL(snd_ac97_controller_register); |
| |
| /** |
| * snd_ac97_controller_unregister - unregister an ac97 controller |
| * @ac97_ctrl: the device previously provided to ac97_controller_register() |
| * |
| */ |
| void snd_ac97_controller_unregister(struct ac97_controller *ac97_ctrl) |
| { |
| ac97_del_adapter(ac97_ctrl); |
| } |
| EXPORT_SYMBOL_GPL(snd_ac97_controller_unregister); |
| |
| #ifdef CONFIG_PM |
| static int ac97_pm_runtime_suspend(struct device *dev) |
| { |
| struct ac97_codec_device *codec = to_ac97_device(dev); |
| int ret = pm_generic_runtime_suspend(dev); |
| |
| if (ret == 0 && dev->driver) { |
| if (pm_runtime_is_irq_safe(dev)) |
| clk_disable(codec->clk); |
| else |
| clk_disable_unprepare(codec->clk); |
| } |
| |
| return ret; |
| } |
| |
| static int ac97_pm_runtime_resume(struct device *dev) |
| { |
| struct ac97_codec_device *codec = to_ac97_device(dev); |
| int ret; |
| |
| if (dev->driver) { |
| if (pm_runtime_is_irq_safe(dev)) |
| ret = clk_enable(codec->clk); |
| else |
| ret = clk_prepare_enable(codec->clk); |
| if (ret) |
| return ret; |
| } |
| |
| return pm_generic_runtime_resume(dev); |
| } |
| #endif /* CONFIG_PM */ |
| |
| static const struct dev_pm_ops ac97_pm = { |
| .suspend = pm_generic_suspend, |
| .resume = pm_generic_resume, |
| .freeze = pm_generic_freeze, |
| .thaw = pm_generic_thaw, |
| .poweroff = pm_generic_poweroff, |
| .restore = pm_generic_restore, |
| SET_RUNTIME_PM_OPS( |
| ac97_pm_runtime_suspend, |
| ac97_pm_runtime_resume, |
| NULL) |
| }; |
| |
| static int ac97_get_enable_clk(struct ac97_codec_device *adev) |
| { |
| int ret; |
| |
| adev->clk = clk_get(&adev->dev, "ac97_clk"); |
| if (IS_ERR(adev->clk)) |
| return PTR_ERR(adev->clk); |
| |
| ret = clk_prepare_enable(adev->clk); |
| if (ret) |
| clk_put(adev->clk); |
| |
| return ret; |
| } |
| |
| static void ac97_put_disable_clk(struct ac97_codec_device *adev) |
| { |
| clk_disable_unprepare(adev->clk); |
| clk_put(adev->clk); |
| } |
| |
| static ssize_t vendor_id_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct ac97_codec_device *codec = to_ac97_device(dev); |
| |
| return sprintf(buf, "%08x", codec->vendor_id); |
| } |
| DEVICE_ATTR_RO(vendor_id); |
| |
| static struct attribute *ac97_dev_attrs[] = { |
| &dev_attr_vendor_id.attr, |
| NULL, |
| }; |
| ATTRIBUTE_GROUPS(ac97_dev); |
| |
| static int ac97_bus_match(struct device *dev, struct device_driver *drv) |
| { |
| struct ac97_codec_device *adev = to_ac97_device(dev); |
| struct ac97_codec_driver *adrv = to_ac97_driver(drv); |
| const struct ac97_id *id = adrv->id_table; |
| int i = 0; |
| |
| if (adev->vendor_id == 0x0 || adev->vendor_id == 0xffffffff) |
| return false; |
| |
| do { |
| if (ac97_ids_match(id[i].id, adev->vendor_id, id[i].mask)) |
| return true; |
| } while (id[i++].id); |
| |
| return false; |
| } |
| |
| static int ac97_bus_probe(struct device *dev) |
| { |
| struct ac97_codec_device *adev = to_ac97_device(dev); |
| struct ac97_codec_driver *adrv = to_ac97_driver(dev->driver); |
| int ret; |
| |
| ret = ac97_get_enable_clk(adev); |
| if (ret) |
| return ret; |
| |
| pm_runtime_get_noresume(dev); |
| pm_runtime_set_active(dev); |
| pm_runtime_enable(dev); |
| |
| ret = adrv->probe(adev); |
| if (ret == 0) |
| return 0; |
| |
| pm_runtime_disable(dev); |
| pm_runtime_set_suspended(dev); |
| pm_runtime_put_noidle(dev); |
| ac97_put_disable_clk(adev); |
| |
| return ret; |
| } |
| |
| static int ac97_bus_remove(struct device *dev) |
| { |
| struct ac97_codec_device *adev = to_ac97_device(dev); |
| struct ac97_codec_driver *adrv = to_ac97_driver(dev->driver); |
| int ret; |
| |
| ret = pm_runtime_resume_and_get(dev); |
| if (ret < 0) |
| return ret; |
| |
| ret = adrv->remove(adev); |
| pm_runtime_put_noidle(dev); |
| if (ret == 0) |
| ac97_put_disable_clk(adev); |
| |
| pm_runtime_disable(dev); |
| |
| return ret; |
| } |
| |
| static struct bus_type ac97_bus_type = { |
| .name = "ac97bus", |
| .dev_groups = ac97_dev_groups, |
| .match = ac97_bus_match, |
| .pm = &ac97_pm, |
| .probe = ac97_bus_probe, |
| .remove = ac97_bus_remove, |
| }; |
| |
| static int __init ac97_bus_init(void) |
| { |
| return bus_register(&ac97_bus_type); |
| } |
| subsys_initcall(ac97_bus_init); |
| |
| static void __exit ac97_bus_exit(void) |
| { |
| bus_unregister(&ac97_bus_type); |
| } |
| module_exit(ac97_bus_exit); |
| |
| MODULE_LICENSE("GPL"); |
| MODULE_AUTHOR("Robert Jarzmik <robert.jarzmik@free.fr>"); |