Release 4.16 drivers/tty/serdev/core.c

Directory: drivers/tty/serdev
// 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);
}
Contributors
Person Tokens Prop Commits CommitProp
Johan Hovold 56 100.00% 1 100.00%
Total 56 100.00% 1 100.00%

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);
}

Contributors
Person Tokens Prop Commits CommitProp
Johan Hovold 47 100.00% 1 100.00%
Total 47 100.00% 1 100.00%



static void serdev_device_release(struct device *dev)
{
	struct serdev_device *serdev = to_serdev_device(dev);
	kfree(serdev);
}

Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%


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;
}

Contributors
Person Tokens Prop Commits CommitProp
Johan Hovold 20 100.00% 1 100.00%
Total 20 100.00% 1 100.00%



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);
}

Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 36 100.00% 1 100.00%
Total 36 100.00% 1 100.00%


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);
}

Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 29 60.42% 1 33.33%
Frederic Danis 16 33.33% 1 33.33%
Johan Hovold 3 6.25% 1 33.33%
Total 48 100.00% 3 100.00%

/**
 * 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;
}
Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 105 68.18% 1 50.00%
Johan Hovold 49 31.82% 1 50.00%
Total 154 100.00% 2 100.00%

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;
}
Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 18 54.55% 1 50.00%
Johan Hovold 15 45.45% 1 50.00%
Total 33 100.00% 2 100.00%

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);
}
Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 45 100.00% 1 100.00%
Total 45 100.00% 1 100.00%

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);
}
Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 41 100.00% 1 100.00%
Total 41 100.00% 1 100.00%

EXPORT_SYMBOL_GPL(serdev_device_close);



static void devm_serdev_device_release(struct device *dev, void *dr)
{
	serdev_device_close(*(struct serdev_device **)dr);
}

Contributors
Person Tokens Prop Commits CommitProp
Andrey Smirnov 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%



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;
}
Contributors
Person Tokens Prop Commits CommitProp
Andrey Smirnov 84 100.00% 1 100.00%
Total 84 100.00% 1 100.00%

EXPORT_SYMBOL_GPL(devm_serdev_device_open);



void serdev_device_write_wakeup(struct serdev_device *serdev)
{
	complete(&serdev->write_comp);
}
Contributors
Person Tokens Prop Commits CommitProp
Andrey Smirnov 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%

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);
}
Contributors
Person Tokens Prop Commits CommitProp
Stefan Wahren 58 100.00% 1 100.00%
Total 58 100.00% 1 100.00%

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);
}
Contributors
Person Tokens Prop Commits CommitProp
Andrey Smirnov 98 63.64% 1 50.00%
Rob Herring 56 36.36% 1 50.00%
Total 154 100.00% 2 100.00%

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);
}
Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 41 100.00% 1 100.00%
Total 41 100.00% 1 100.00%

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);
}
Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 46 100.00% 1 100.00%
Total 46 100.00% 1 100.00%

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);

}
Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 51 100.00% 1 100.00%
Total 51 100.00% 1 100.00%

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);
}
Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 46 100.00% 1 100.00%
Total 46 100.00% 1 100.00%

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);
}
Contributors
Person Tokens Prop Commits CommitProp
Ulrich Hecht 51 100.00% 1 100.00%
Total 51 100.00% 1 100.00%

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);
}
Contributors
Person Tokens Prop Commits CommitProp
Sebastian Reichel 46 100.00% 1 100.00%
Total 46 100.00% 1 100.00%

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);
}
Contributors
Person Tokens Prop Commits CommitProp
Sebastian Reichel 45 100.00% 1 100.00%
Total 45 100.00% 1 100.00%

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);
}
Contributors
Person Tokens Prop Commits CommitProp
Sebastian Reichel 55 100.00% 1 100.00%
Total 55 100.00% 1 100.00%

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));
}

Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 37 86.05% 1 50.00%
Andrey Smirnov 6 13.95% 1 50.00%
Total 43 100.00% 2 100.00%


static struct bus_type serdev_bus_type = {
	.name		= "serial",
	.match		= serdev_device_match,
	.probe		= serdev_drv_probe,
	.remove		= serdev_drv_remove,
};

/**
 * serdev_controller_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;
}
Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 84 84.00% 1 50.00%
Andrey Smirnov 16 16.00% 1 50.00%
Total 100 100.00% 2 100.00%

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;
}
Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 141 74.60% 1 50.00%
Johan Hovold 48 25.40% 1 50.00%
Total 189 100.00% 2 100.00%

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;
}

Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 132 100.00% 2 100.00%
Total 132 100.00% 2 100.00%

#ifdef CONFIG_ACPI


static 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;
}

Contributors
Person Tokens Prop Commits CommitProp
Frederic Danis 131 100.00% 1 100.00%
Total 131 100.00% 1 100.00%



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;

	return acpi_serdev_register_device(ctrl, adev);
}

Contributors
Person Tokens Prop Commits CommitProp
Frederic Danis 54 100.00% 1 100.00%
Total 54 100.00% 1 100.00%



static int acpi_serdev_register_devices(struct serdev_controller *ctrl)
{
	acpi_status status;
	acpi_handle handle;

	handle = ACPI_HANDLE(ctrl->dev.parent);
	if (!handle)
		return -ENODEV;

	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
				     acpi_serdev_add_device, NULL, ctrl, NULL);
	if (ACPI_FAILURE(status))
		dev_dbg(&ctrl->dev, "failed to enumerate serdev slaves\n");

	if (!ctrl->serdev)
		return -ENODEV;

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Frederic Danis 87 100.00% 1 100.00%
Total 87 100.00% 1 100.00%

#else


static inline int acpi_serdev_register_devices(struct serdev_controller *ctrl)
{
	return -ENODEV;
}
Contributors
Person Tokens Prop Commits CommitProp
Frederic Danis 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%

#endif /* CONFIG_ACPI */

/**
 * serdev_controller_add() - Add an serdev controller
 * @ctrl:       controller to be registered.
 *
 * Register a controller previously allocated via serdev_controller_alloc() with
 * the serdev core.
 */


int serdev_controller_add(struct serdev_controller *ctrl)
{
	int ret_of, ret_acpi, ret;

	/* Can't register until after driver model init */
	if (WARN_ON(!is_registered))
		return -EAGAIN;

	ret = device_add(&ctrl->dev);
	if (ret)
		return ret;

	ret_of = of_serdev_register_devices(ctrl);
	ret_acpi = acpi_serdev_register_devices(ctrl);
	if (ret_of && ret_acpi) {
		dev_dbg(&ctrl->dev, "no devices registered: of:%d acpi:%d\n",
			ret_of, ret_acpi);
		ret = -ENODEV;
		goto out_dev_del;
	}

	dev_dbg(&ctrl->dev, "serdev%d registered: dev:%p\n",
		ctrl->nr, &ctrl->dev);
	return 0;

out_dev_del:
	device_del(&ctrl->dev);
	return ret;
}Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 90 71.43% 1 50.00%
Frederic Danis 36 28.57% 1 50.00%
Total 126 100.00% 2 100.00%

;
EXPORT_SYMBOL_GPL(serdev_controller_add);

/* Remove a device associated with a controller */


static int serdev_remove_device(struct device *dev, void *data)
{
	struct serdev_device *serdev = to_serdev_device(dev);
	if (dev->type == &serdev_device_type)
		serdev_device_remove(serdev);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 42 100.00% 1 100.00%
Total 42 100.00% 1 100.00%

/**
 * serdev_controller_remove(): remove an serdev controller
 * @ctrl:       controller to remove
 *
 * Remove a serdev controller.  Caller is responsible for calling
 * serdev_controller_put() to discard the allocated controller.
 */


void serdev_controller_remove(struct serdev_controller *ctrl)
{
	int dummy;

	if (!ctrl)
		return;

	dummy = device_for_each_child(&ctrl->dev, NULL,
				      serdev_remove_device);
	device_del(&ctrl->dev);
}
Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 41 100.00% 1 100.00%
Total 41 100.00% 1 100.00%

EXPORT_SYMBOL_GPL(serdev_controller_remove);

/**
 * serdev_driver_register() - Register client driver with serdev core
 * @sdrv:       client driver to be associated with client-device.
 *
 * This API will register the client driver with the serdev framework.
 * It is typically called from the driver's module-init function.
 */


int __serdev_device_driver_register(struct serdev_device_driver *sdrv, struct module *owner)
{
	sdrv->driver.bus = &serdev_bus_type;
	sdrv->driver.owner = owner;

	/* force drivers to async probe so I/O is possible in probe */
        sdrv->driver.probe_type = PROBE_PREFER_ASYNCHRONOUS;

	return driver_register(&sdrv->driver);
}
Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 50 100.00% 1 100.00%
Total 50 100.00% 1 100.00%

EXPORT_SYMBOL_GPL(__serdev_device_driver_register);



static void __exit serdev_exit(void)
{
	bus_unregister(&serdev_bus_type);
}
Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%

module_exit(serdev_exit);



static int __init serdev_init(void)
{
	int ret;

	ret = bus_register(&serdev_bus_type);
	if (ret)
		return ret;

	is_registered = true;
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 34 100.00% 1 100.00%
Total 34 100.00% 1 100.00%

/* Must be before serial drivers register */
postcore_initcall(serdev_init);

MODULE_AUTHOR("Rob Herring <robh@kernel.org>");
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("Serial attached device bus");
Overall Contributors
Person Tokens Prop Commits CommitProp
Rob Herring 1432 55.08% 2 12.50%
Frederic Danis 351 13.50% 1 6.25%
Johan Hovold 275 10.58% 4 25.00%
Andrey Smirnov 260 10.00% 3 18.75%
Sebastian Reichel 161 6.19% 2 12.50%
Stefan Wahren 63 2.42% 1 6.25%
Ulrich Hecht 56 2.15% 1 6.25%
Greg Kroah-Hartman 2 0.08% 2 12.50%
Total 2600 100.00% 16 100.00%
Directory: drivers/tty/serdev

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Johan Hovold	56	100.00%	1	100.00%
Total	56	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.16 drivers/tty/serdev/core.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
