// SPDX-License-Identifier: GPL-2.0/* * Copyright (C) 2016-2017 Linaro Ltd., Rob Herring <robh@kernel.org> * * Based on drivers/spmi/spmi.c: * Copyright (c) 2012-2015, The Linux Foundation. All rights reserved. */ #include <linux/acpi.h>#include <linux/errno.h>#include <linux/idr.h>#include <linux/kernel.h>#include <linux/module.h>#include <linux/of.h>#include <linux/of_device.h>#include <linux/pm_domain.h>#include <linux/pm_runtime.h>#include <linux/sched.h>#include <linux/serdev.h>#include <linux/slab.h>#include <linux/platform_data/x86/apple.h> static bool is_registered;static DEFINE_IDA(ctrl_ida); static ssize_t modalias_show(struct device *dev,			     struct device_attribute *attr, char *buf){	int len; 	len = acpi_device_modalias(dev, buf, PAGE_SIZE - 1);	if (len != -ENODEV)		return len; 	return of_device_modalias(dev, buf, PAGE_SIZE);}static DEVICE_ATTR_RO(modalias); static struct attribute *serdev_device_attrs[] = {	&dev_attr_modalias.attr,	NULL,};ATTRIBUTE_GROUPS(serdev_device); static int serdev_device_uevent(const struct device *dev, struct kobj_uevent_env *env){	int rc; 	/* TODO: platform modalias */ 	rc = acpi_device_uevent_modalias(dev, env);	if (rc != -ENODEV)		return rc; 	return of_device_uevent_modalias(dev, env);} static void serdev_device_release(struct device *dev){	struct serdev_device *serdev = to_serdev_device(dev);	kfree(serdev);} static const struct device_type serdev_device_type = {	.groups		= serdev_device_groups,	.uevent		= serdev_device_uevent,	.release	= serdev_device_release,}; static bool is_serdev_device(const struct device *dev){	return dev->type == &serdev_device_type;} static void serdev_ctrl_release(struct device *dev){	struct serdev_controller *ctrl = to_serdev_controller(dev);	ida_simple_remove(&ctrl_ida, ctrl->nr);	kfree(ctrl);} static const struct device_type serdev_ctrl_type = {	.release	= serdev_ctrl_release,}; static int serdev_device_match(struct device *dev, struct device_driver *drv){	if (!is_serdev_device(dev))		return 0; 	/* TODO: platform matching */	if (acpi_driver_match_device(dev, drv))		return 1; 	return of_driver_match_device(dev, drv);} /** * serdev_device_add() - add a device previously constructed via serdev_device_alloc() * @serdev:	serdev_device to be added */int serdev_device_add(struct serdev_device *serdev){	struct serdev_controller *ctrl = serdev->ctrl;	struct device *parent = serdev->dev.parent;	int err; 	dev_set_name(&serdev->dev, "%s-%d", dev_name(parent), serdev->nr); 	/* Only a single slave device is currently supported. */	if (ctrl->serdev) {		dev_err(&serdev->dev, "controller busy\n");		return -EBUSY;	}	ctrl->serdev = serdev; 	err = device_add(&serdev->dev);	if (err < 0) {		dev_err(&serdev->dev, "Can't add %s, status %pe\n",			dev_name(&serdev->dev), ERR_PTR(err));		goto err_clear_serdev;	} 	dev_dbg(&serdev->dev, "device %s registered\n", dev_name(&serdev->dev)); 	return 0; err_clear_serdev:	ctrl->serdev = NULL;	return err;}EXPORT_SYMBOL_GPL(serdev_device_add); /** * serdev_device_remove(): remove an serdev device * @serdev:	serdev_device to be removed */void serdev_device_remove(struct serdev_device *serdev){	struct serdev_controller *ctrl = serdev->ctrl; 	device_unregister(&serdev->dev);	ctrl->serdev = NULL;}EXPORT_SYMBOL_GPL(serdev_device_remove); int serdev_device_open(struct serdev_device *serdev){	struct serdev_controller *ctrl = serdev->ctrl;	int ret; 	if (!ctrl || !ctrl->ops->open)		return -EINVAL; 	ret = ctrl->ops->open(ctrl);	if (ret)		return ret; 	ret = pm_runtime_get_sync(&ctrl->dev);	if (ret < 0) {		pm_runtime_put_noidle(&ctrl->dev);		goto err_close;	} 	return 0; err_close:	if (ctrl->ops->close)		ctrl->ops->close(ctrl); 	return ret;}EXPORT_SYMBOL_GPL(serdev_device_open); void serdev_device_close(struct serdev_device *serdev){	struct serdev_controller *ctrl = serdev->ctrl; 	if (!ctrl || !ctrl->ops->close)		return; 	pm_runtime_put(&ctrl->dev); 	ctrl->ops->close(ctrl);}EXPORT_SYMBOL_GPL(serdev_device_close); static void devm_serdev_device_release(struct device *dev, void *dr){	serdev_device_close(*(struct serdev_device **)dr);} int devm_serdev_device_open(struct device *dev, struct serdev_device *serdev){	struct serdev_device **dr;	int ret; 	dr = devres_alloc(devm_serdev_device_release, sizeof(*dr), GFP_KERNEL);	if (!dr)		return -ENOMEM; 	ret = serdev_device_open(serdev);	if (ret) {		devres_free(dr);		return ret;	} 	*dr = serdev;	devres_add(dev, dr); 	return 0;}EXPORT_SYMBOL_GPL(devm_serdev_device_open); void serdev_device_write_wakeup(struct serdev_device *serdev){	complete(&serdev->write_comp);}EXPORT_SYMBOL_GPL(serdev_device_write_wakeup); /** * serdev_device_write_buf() - write data asynchronously * @serdev:	serdev device * @buf:	data to be written * @count:	number of bytes to write * * Write data to the device asynchronously. * * Note that any accepted data has only been buffered by the controller; use * serdev_device_wait_until_sent() to make sure the controller write buffer * has actually been emptied. * * Return: The number of bytes written (less than count if not enough room in * the write buffer), or a negative errno on errors. */int serdev_device_write_buf(struct serdev_device *serdev,			    const unsigned char *buf, size_t count){	struct serdev_controller *ctrl = serdev->ctrl; 	if (!ctrl || !ctrl->ops->write_buf)		return -EINVAL; 	return ctrl->ops->write_buf(ctrl, buf, count);}EXPORT_SYMBOL_GPL(serdev_device_write_buf); /** * serdev_device_write() - write data synchronously * @serdev:	serdev device * @buf:	data to be written * @count:	number of bytes to write * @timeout:	timeout in jiffies, or 0 to wait indefinitely * * Write data to the device synchronously by repeatedly calling * serdev_device_write() until the controller has accepted all data (unless * interrupted by a timeout or a signal). * * Note that any accepted data has only been buffered by the controller; use * serdev_device_wait_until_sent() to make sure the controller write buffer * has actually been emptied. * * Note that this function depends on serdev_device_write_wakeup() being * called in the serdev driver write_wakeup() callback. * * Return: The number of bytes written (less than count if interrupted), * -ETIMEDOUT or -ERESTARTSYS if interrupted before any bytes were written, or * a negative errno on errors. */int serdev_device_write(struct serdev_device *serdev,			const unsigned char *buf, size_t count,			long timeout){	struct serdev_controller *ctrl = serdev->ctrl;	int written = 0;	int ret; 	if (!ctrl || !ctrl->ops->write_buf || !serdev->ops->write_wakeup)		return -EINVAL; 	if (timeout == 0)		timeout = MAX_SCHEDULE_TIMEOUT; 	mutex_lock(&serdev->write_lock);	do {		reinit_completion(&serdev->write_comp); 		ret = ctrl->ops->write_buf(ctrl, buf, count);		if (ret < 0)			break; 		written += ret;		buf += ret;		count -= ret; 		if (count == 0)			break; 		timeout = wait_for_completion_interruptible_timeout(&serdev->write_comp,								    timeout);	} while (timeout > 0);	mutex_unlock(&serdev->write_lock); 	if (ret < 0)		return ret; 	if (timeout <= 0 && written == 0) {		if (timeout == -ERESTARTSYS)			return -ERESTARTSYS;		else			return -ETIMEDOUT;	} 	return written;}EXPORT_SYMBOL_GPL(serdev_device_write); void serdev_device_write_flush(struct serdev_device *serdev){	struct serdev_controller *ctrl = serdev->ctrl; 	if (!ctrl || !ctrl->ops->write_flush)		return; 	ctrl->ops->write_flush(ctrl);}EXPORT_SYMBOL_GPL(serdev_device_write_flush); int serdev_device_write_room(struct serdev_device *serdev){	struct serdev_controller *ctrl = serdev->ctrl; 	if (!ctrl || !ctrl->ops->write_room)		return 0; 	return serdev->ctrl->ops->write_room(ctrl);}EXPORT_SYMBOL_GPL(serdev_device_write_room); unsigned int serdev_device_set_baudrate(struct serdev_device *serdev, unsigned int speed){	struct serdev_controller *ctrl = serdev->ctrl; 	if (!ctrl || !ctrl->ops->set_baudrate)		return 0; 	return ctrl->ops->set_baudrate(ctrl, speed); }EXPORT_SYMBOL_GPL(serdev_device_set_baudrate); void serdev_device_set_flow_control(struct serdev_device *serdev, bool enable){	struct serdev_controller *ctrl = serdev->ctrl; 	if (!ctrl || !ctrl->ops->set_flow_control)		return; 	ctrl->ops->set_flow_control(ctrl, enable);}EXPORT_SYMBOL_GPL(serdev_device_set_flow_control); int serdev_device_set_parity(struct serdev_device *serdev,			     enum serdev_parity parity){	struct serdev_controller *ctrl = serdev->ctrl; 	if (!ctrl || !ctrl->ops->set_parity)		return -ENOTSUPP; 	return ctrl->ops->set_parity(ctrl, parity);}EXPORT_SYMBOL_GPL(serdev_device_set_parity); void serdev_device_wait_until_sent(struct serdev_device *serdev, long timeout){	struct serdev_controller *ctrl = serdev->ctrl; 	if (!ctrl || !ctrl->ops->wait_until_sent)		return; 	ctrl->ops->wait_until_sent(ctrl, timeout);}EXPORT_SYMBOL_GPL(serdev_device_wait_until_sent); int serdev_device_get_tiocm(struct serdev_device *serdev){	struct serdev_controller *ctrl = serdev->ctrl; 	if (!ctrl || !ctrl->ops->get_tiocm)		return -ENOTSUPP; 	return ctrl->ops->get_tiocm(ctrl);}EXPORT_SYMBOL_GPL(serdev_device_get_tiocm); int serdev_device_set_tiocm(struct serdev_device *serdev, int set, int clear){	struct serdev_controller *ctrl = serdev->ctrl; 	if (!ctrl || !ctrl->ops->set_tiocm)		return -ENOTSUPP; 	return ctrl->ops->set_tiocm(ctrl, set, clear);}EXPORT_SYMBOL_GPL(serdev_device_set_tiocm); static int serdev_drv_probe(struct device *dev){	const struct serdev_device_driver *sdrv = to_serdev_device_driver(dev->driver);	int ret; 	ret = dev_pm_domain_attach(dev, true);	if (ret)		return ret; 	ret = sdrv->probe(to_serdev_device(dev));	if (ret)		dev_pm_domain_detach(dev, true); 	return ret;} static void serdev_drv_remove(struct device *dev){	const struct serdev_device_driver *sdrv = to_serdev_device_driver(dev->driver);	if (sdrv->remove)		sdrv->remove(to_serdev_device(dev)); 	dev_pm_domain_detach(dev, true);} static struct bus_type serdev_bus_type = {	.name		= "serial",	.match		= serdev_device_match,	.probe		= serdev_drv_probe,	.remove		= serdev_drv_remove,}; /** * serdev_device_alloc() - Allocate a new serdev device * @ctrl:	associated controller * * Caller is responsible for either calling serdev_device_add() to add the * newly allocated controller, or calling serdev_device_put() to discard it. */struct serdev_device *serdev_device_alloc(struct serdev_controller *ctrl){	struct serdev_device *serdev; 	serdev = kzalloc(sizeof(*serdev), GFP_KERNEL);	if (!serdev)		return NULL; 	serdev->ctrl = ctrl;	device_initialize(&serdev->dev);	serdev->dev.parent = &ctrl->dev;	serdev->dev.bus = &serdev_bus_type;	serdev->dev.type = &serdev_device_type;	init_completion(&serdev->write_comp);	mutex_init(&serdev->write_lock);	return serdev;}EXPORT_SYMBOL_GPL(serdev_device_alloc); /** * serdev_controller_alloc() - Allocate a new serdev controller * @parent:	parent device * @size:	size of private data * * Caller is responsible for either calling serdev_controller_add() to add the * newly allocated controller, or calling serdev_controller_put() to discard it. * The allocated private data region may be accessed via * serdev_controller_get_drvdata() */struct serdev_controller *serdev_controller_alloc(struct device *parent,					      size_t size){	struct serdev_controller *ctrl;	int id; 	if (WARN_ON(!parent))		return NULL; 	ctrl = kzalloc(sizeof(*ctrl) + size, GFP_KERNEL);	if (!ctrl)		return NULL; 	id = ida_simple_get(&ctrl_ida, 0, 0, GFP_KERNEL);	if (id < 0) {		dev_err(parent,			"unable to allocate serdev controller identifier.\n");		goto err_free;	} 	ctrl->nr = id; 	device_initialize(&ctrl->dev);	ctrl->dev.type = &serdev_ctrl_type;	ctrl->dev.bus = &serdev_bus_type;

Lines 1–500 of 874. Load more