mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 17:30:02 +00:00
![Linus Torvalds](/assets/img/avatar_default.png)
- Core: - sdw_transfer_defer() API change to dropan argument - Reset page address rework - Exporting sdw_nwrite_no_pm and sdw_nread_no_pm APIs - Drivers: - Cadence and related intel driver updates for FIFO handling and low level msg transfers -----BEGIN PGP SIGNATURE----- iQIyBAABCAAdFiEE+vs47OPLdNbVcHzyfBQHDyUjg0cFAmP4wIkACgkQfBQHDyUj g0eScA/4r/l0qC6z3xDq4LDHoXgAY5Q1qrlfdhj8/Dv3DDkIf4uChkZBJxiQVQsL zzS8lULiRhTdGLoLb/EM3Lit3WIHk7sAxld06Pwk/SUKRGraDXtqSD3hypJGzHy8 EkYbKLD0nGhDgdj1SNoHxl3HZEijssZmVTI6rWLqvAjsAPhbDTrf1ONTRkkXdm7K UsQ0FOvrhFyC5dNTWDXb8yrRA/W/o5HX0YAr6FQGV0d9eur9jJLSbw/TYEuzIbE8 tlqD6qfU43b/5efbURK/cJ0MdnFBLXjBytQBo8A4VYm+qZ99BbL+N+iU8+3b1xWu EHuGg5ztruI6tVdW17dtt9niVEg4Zil2tZqbkwl3GJBisiH6bb6hJU9TceyBBig7 FbDzT9jFB13UMZE1zbJZ6XpFyBHoGlhsdOtaTmx3vjZDVnkP/SCMBY7tblIg3NE7 1lzLDwAXWqBLE2jkqjHdb1o9bCrfzI74bJY3ZvvrRIhkliDqDkLvwiSK3PD/Ic7M 4dLYUdN9OCHhV9T0txm5tguYE6wpJzt1wyuOEKlrncB1J+V8MCPZY1/QbpOiREzq 6VSHk5IIrDk0pfOQCukktJQX6OO/plRTLNmUGCJpD9EuNhjLDCwYxgu3PqaAaHG0 k0U0DqJv9XoUMlcbnA0dvwn2iiW7fSMxF+g2TXEckVrlFz3uhg== =LwuQ -----END PGP SIGNATURE----- Merge tag 'soundwire-6.3-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/vkoul/soundwire Pull soundwire updates from Vinod Koul: "This is a small update which features a bit of core changes and driver updates in Intel and cadence driver. Core: - sdw_transfer_defer() API change to drop an argument - Reset page address rework - Export sdw_nwrite_no_pm and sdw_nread_no_pm APIs Drivers: - Cadence and related intel driver updates for FIFO handling and low level msg transfers" * tag 'soundwire-6.3-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/vkoul/soundwire: soundwire: cadence: further simplify low-level xfer_msg_defer() callback soundwire: cadence: use directly bus sdw_defer structure soundwire: bus: remove sdw_defer argument in sdw_transfer_defer() soundwire: stream: use consistent pattern for freeing buffers soundwire: bus: Remove unused reset_page_addr() callback soundwire: bus: Don't zero page registers after every transaction soundwire: bus_type: Avoid lockdep assert in sdw_drv_probe() soundwire: stream: Move remaining register accesses over to no_pm soundwire: debugfs: Switch to sdw_read_no_pm soundwire: Provide build stubs for common functions soundwire: bus: export sdw_nwrite_no_pm and sdw_nread_no_pm functions soundwire: cadence: remove unused sdw_cdns_master_ops declaration soundwire: enable optional clock registers for SoundWire 1.2 devices ASoC/soundwire: remove is_sdca boolean property soundwire: cadence: Drain the RX FIFO after an IO timeout soundwire: cadence: Remove wasted space in response_buf soundwire: cadence: Don't overflow the command FIFOs soundwire: intel: remove DAI startup/shutdown
246 lines
5.6 KiB
C
246 lines
5.6 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
// Copyright(c) 2015-17 Intel Corporation.
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/mod_devicetable.h>
|
|
#include <linux/pm_domain.h>
|
|
#include <linux/soundwire/sdw.h>
|
|
#include <linux/soundwire/sdw_type.h>
|
|
#include "bus.h"
|
|
#include "sysfs_local.h"
|
|
|
|
/**
|
|
* sdw_get_device_id - find the matching SoundWire device id
|
|
* @slave: SoundWire Slave Device
|
|
* @drv: SoundWire Slave Driver
|
|
*
|
|
* The match is done by comparing the mfg_id and part_id from the
|
|
* struct sdw_device_id.
|
|
*/
|
|
static const struct sdw_device_id *
|
|
sdw_get_device_id(struct sdw_slave *slave, struct sdw_driver *drv)
|
|
{
|
|
const struct sdw_device_id *id;
|
|
|
|
for (id = drv->id_table; id && id->mfg_id; id++)
|
|
if (slave->id.mfg_id == id->mfg_id &&
|
|
slave->id.part_id == id->part_id &&
|
|
(!id->sdw_version ||
|
|
slave->id.sdw_version == id->sdw_version) &&
|
|
(!id->class_id ||
|
|
slave->id.class_id == id->class_id))
|
|
return id;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static int sdw_bus_match(struct device *dev, struct device_driver *ddrv)
|
|
{
|
|
struct sdw_slave *slave;
|
|
struct sdw_driver *drv;
|
|
int ret = 0;
|
|
|
|
if (is_sdw_slave(dev)) {
|
|
slave = dev_to_sdw_dev(dev);
|
|
drv = drv_to_sdw_driver(ddrv);
|
|
|
|
ret = !!sdw_get_device_id(slave, drv);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int sdw_slave_modalias(const struct sdw_slave *slave, char *buf, size_t size)
|
|
{
|
|
/* modalias is sdw:m<mfg_id>p<part_id>v<version>c<class_id> */
|
|
|
|
return snprintf(buf, size, "sdw:m%04Xp%04Xv%02Xc%02X\n",
|
|
slave->id.mfg_id, slave->id.part_id,
|
|
slave->id.sdw_version, slave->id.class_id);
|
|
}
|
|
|
|
int sdw_slave_uevent(const struct device *dev, struct kobj_uevent_env *env)
|
|
{
|
|
const struct sdw_slave *slave = dev_to_sdw_dev(dev);
|
|
char modalias[32];
|
|
|
|
sdw_slave_modalias(slave, modalias, sizeof(modalias));
|
|
|
|
if (add_uevent_var(env, "MODALIAS=%s", modalias))
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
struct bus_type sdw_bus_type = {
|
|
.name = "soundwire",
|
|
.match = sdw_bus_match,
|
|
};
|
|
EXPORT_SYMBOL_GPL(sdw_bus_type);
|
|
|
|
static int sdw_drv_probe(struct device *dev)
|
|
{
|
|
struct sdw_slave *slave = dev_to_sdw_dev(dev);
|
|
struct sdw_driver *drv = drv_to_sdw_driver(dev->driver);
|
|
const struct sdw_device_id *id;
|
|
const char *name;
|
|
int ret;
|
|
|
|
/*
|
|
* fw description is mandatory to bind
|
|
*/
|
|
if (!dev->fwnode)
|
|
return -ENODEV;
|
|
|
|
if (!IS_ENABLED(CONFIG_ACPI) && !dev->of_node)
|
|
return -ENODEV;
|
|
|
|
id = sdw_get_device_id(slave, drv);
|
|
if (!id)
|
|
return -ENODEV;
|
|
|
|
/*
|
|
* attach to power domain but don't turn on (last arg)
|
|
*/
|
|
ret = dev_pm_domain_attach(dev, false);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = drv->probe(slave, id);
|
|
if (ret) {
|
|
name = drv->name;
|
|
if (!name)
|
|
name = drv->driver.name;
|
|
|
|
dev_err(dev, "Probe of %s failed: %d\n", name, ret);
|
|
dev_pm_domain_detach(dev, false);
|
|
return ret;
|
|
}
|
|
|
|
mutex_lock(&slave->sdw_dev_lock);
|
|
|
|
/* device is probed so let's read the properties now */
|
|
if (drv->ops && drv->ops->read_prop)
|
|
drv->ops->read_prop(slave);
|
|
|
|
/* init the sysfs as we have properties now */
|
|
ret = sdw_slave_sysfs_init(slave);
|
|
if (ret < 0)
|
|
dev_warn(dev, "Slave sysfs init failed:%d\n", ret);
|
|
|
|
/*
|
|
* Check for valid clk_stop_timeout, use DisCo worst case value of
|
|
* 300ms
|
|
*
|
|
* TODO: check the timeouts and driver removal case
|
|
*/
|
|
if (slave->prop.clk_stop_timeout == 0)
|
|
slave->prop.clk_stop_timeout = 300;
|
|
|
|
slave->bus->clk_stop_timeout = max_t(u32, slave->bus->clk_stop_timeout,
|
|
slave->prop.clk_stop_timeout);
|
|
|
|
slave->probed = true;
|
|
|
|
/*
|
|
* if the probe happened after the bus was started, notify the codec driver
|
|
* of the current hardware status to e.g. start the initialization.
|
|
* Errors are only logged as warnings to avoid failing the probe.
|
|
*/
|
|
if (drv->ops && drv->ops->update_status) {
|
|
ret = drv->ops->update_status(slave, slave->status);
|
|
if (ret < 0)
|
|
dev_warn(dev, "%s: update_status failed with status %d\n", __func__, ret);
|
|
}
|
|
|
|
mutex_unlock(&slave->sdw_dev_lock);
|
|
|
|
dev_dbg(dev, "probe complete\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int sdw_drv_remove(struct device *dev)
|
|
{
|
|
struct sdw_slave *slave = dev_to_sdw_dev(dev);
|
|
struct sdw_driver *drv = drv_to_sdw_driver(dev->driver);
|
|
int ret = 0;
|
|
|
|
mutex_lock(&slave->sdw_dev_lock);
|
|
slave->probed = false;
|
|
mutex_unlock(&slave->sdw_dev_lock);
|
|
|
|
if (drv->remove)
|
|
ret = drv->remove(slave);
|
|
|
|
dev_pm_domain_detach(dev, false);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void sdw_drv_shutdown(struct device *dev)
|
|
{
|
|
struct sdw_slave *slave = dev_to_sdw_dev(dev);
|
|
struct sdw_driver *drv = drv_to_sdw_driver(dev->driver);
|
|
|
|
if (drv->shutdown)
|
|
drv->shutdown(slave);
|
|
}
|
|
|
|
/**
|
|
* __sdw_register_driver() - register a SoundWire Slave driver
|
|
* @drv: driver to register
|
|
* @owner: owning module/driver
|
|
*
|
|
* Return: zero on success, else a negative error code.
|
|
*/
|
|
int __sdw_register_driver(struct sdw_driver *drv, struct module *owner)
|
|
{
|
|
const char *name;
|
|
|
|
drv->driver.bus = &sdw_bus_type;
|
|
|
|
if (!drv->probe) {
|
|
name = drv->name;
|
|
if (!name)
|
|
name = drv->driver.name;
|
|
|
|
pr_err("driver %s didn't provide SDW probe routine\n", name);
|
|
return -EINVAL;
|
|
}
|
|
|
|
drv->driver.owner = owner;
|
|
drv->driver.probe = sdw_drv_probe;
|
|
drv->driver.remove = sdw_drv_remove;
|
|
drv->driver.shutdown = sdw_drv_shutdown;
|
|
|
|
return driver_register(&drv->driver);
|
|
}
|
|
EXPORT_SYMBOL_GPL(__sdw_register_driver);
|
|
|
|
/**
|
|
* sdw_unregister_driver() - unregisters the SoundWire Slave driver
|
|
* @drv: driver to unregister
|
|
*/
|
|
void sdw_unregister_driver(struct sdw_driver *drv)
|
|
{
|
|
driver_unregister(&drv->driver);
|
|
}
|
|
EXPORT_SYMBOL_GPL(sdw_unregister_driver);
|
|
|
|
static int __init sdw_bus_init(void)
|
|
{
|
|
sdw_debugfs_init();
|
|
return bus_register(&sdw_bus_type);
|
|
}
|
|
|
|
static void __exit sdw_bus_exit(void)
|
|
{
|
|
sdw_debugfs_exit();
|
|
bus_unregister(&sdw_bus_type);
|
|
}
|
|
|
|
postcore_initcall(sdw_bus_init);
|
|
module_exit(sdw_bus_exit);
|
|
|
|
MODULE_DESCRIPTION("SoundWire bus");
|
|
MODULE_LICENSE("GPL v2");
|