// 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/serdev.h>#include <linux/slab.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(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 %d\n",			dev_name(&serdev->dev), 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; 	if (!ctrl || !ctrl->ops->open)		return -EINVAL; 	return ctrl->ops->open(ctrl);}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; 	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); 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); int serdev_device_write(struct serdev_device *serdev,			const unsigned char *buf, size_t count,			unsigned long timeout){	struct serdev_controller *ctrl = serdev->ctrl;	int ret; 	if (!ctrl || !ctrl->ops->write_buf ||	    (timeout && !serdev->ops->write_wakeup))		return -EINVAL; 	mutex_lock(&serdev->write_lock);	do {		reinit_completion(&serdev->write_comp); 		ret = ctrl->ops->write_buf(ctrl, buf, count);		if (ret < 0)			break; 		buf += ret;		count -= ret; 	} while (count &&		 (timeout = wait_for_completion_timeout(&serdev->write_comp,							timeout)));	mutex_unlock(&serdev->write_lock);	return ret < 0 ? ret : (count ? -ETIMEDOUT : 0);}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); 	return sdrv->probe(to_serdev_device(dev));} static int 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));	return 0;} 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;	ctrl->dev.parent = parent;	ctrl->dev.of_node = parent->of_node;	serdev_controller_set_drvdata(ctrl, &ctrl[1]); 	dev_set_name(&ctrl->dev, "serial%d", id); 	dev_dbg(&ctrl->dev, "allocated controller 0x%p id %d\n", ctrl, id);	return ctrl; err_free:	kfree(ctrl); 	return NULL;}EXPORT_SYMBOL_GPL(serdev_controller_alloc); static int of_serdev_register_devices(struct serdev_controller *ctrl){	struct device_node *node;	struct serdev_device *serdev = NULL;	int err;	bool found = false; 	for_each_available_child_of_node(ctrl->dev.of_node, node) {		if (!of_get_property(node, "compatible", NULL))			continue; 		dev_dbg(&ctrl->dev, "adding child %pOF\n", node); 		serdev = serdev_device_alloc(ctrl);		if (!serdev)			continue; 		serdev->dev.of_node = node; 		err = serdev_device_add(serdev);		if (err) {			dev_err(&serdev->dev,				"failure adding device. status %d\n", err);			serdev_device_put(serdev);		} else			found = true;	}	if (!found)		return -ENODEV; 	return 0;} #ifdef CONFIG_ACPIstatic acpi_status acpi_serdev_register_device(struct serdev_controller *ctrl,					    struct acpi_device *adev){	struct serdev_device *serdev = NULL;	int err; 	if (acpi_bus_get_status(adev) || !adev->status.present ||	    acpi_device_enumerated(adev))		return AE_OK; 	serdev = serdev_device_alloc(ctrl);	if (!serdev) {		dev_err(&ctrl->dev, "failed to allocate serdev device for %s\n",			dev_name(&adev->dev));		return AE_NO_MEMORY;	} 	ACPI_COMPANION_SET(&serdev->dev, adev);	acpi_device_set_enumerated(adev); 	err = serdev_device_add(serdev);	if (err) {		dev_err(&serdev->dev,			"failure adding ACPI serdev device. status %d\n", err);		serdev_device_put(serdev);	} 	return AE_OK;} static acpi_status acpi_serdev_add_device(acpi_handle handle, u32 level,				       void *data, void **return_value){	struct serdev_controller *ctrl = data;	struct acpi_device *adev; 	if (acpi_bus_get_device(handle, &adev))		return AE_OK;

Lines 1–500 of 640. Load more