Merge tag 'fsi-updates-2018-07-27' of... (2d8bc619) · Commits · 戴 / test

drivers/fsi/Kconfig

+15 −0

Original line number	Diff line number	Diff line
		@@ -12,6 +12,21 @@ menuconfig FSI

		if FSI

		config FSI_NEW_DEV_NODE
		bool "Create '/dev/fsi' directory for char devices"
		default n
		---help---
		This option causes char devices created for FSI devices to be
		located under a common /dev/fsi/ directory. Set to N unless your
		userspace has been updated to handle the new location.

		Additionally, it also causes the char device names to be offset
		by one so that chip 0 will have /dev/scom1 and chip1 /dev/scom2
		to match old userspace expectations.

		New userspace will use udev rules to generate predictable access
		symlinks in /dev/fsi/by-path when this option is enabled.

		config FSI_MASTER_GPIO
		tristate "GPIO-based FSI master"
		depends on GPIOLIB

drivers/fsi/fsi-core.c

+320 −55

Original line number	Diff line number	Diff line
		@@ -11,6 +11,11 @@
		* but WITHOUT ANY WARRANTY; without even the implied warranty of
		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		* GNU General Public License for more details.
		*
		* TODO:
		* - Rework topology
		* - s/chip_id/chip_loc
		* - s/cfam/chip (cfam_id -> chip_id etc...)
		*/

		#include <linux/crc4.h>
		@@ -21,6 +26,9 @@
		#include <linux/of.h>
		#include <linux/slab.h>
		#include <linux/bitops.h>
		#include <linux/cdev.h>
		#include <linux/fs.h>
		#include <linux/uaccess.h>

		#include "fsi-master.h"

		@@ -78,8 +86,11 @@ static DEFINE_IDA(master_ida);
		struct fsi_slave {
		struct device dev;
		struct fsi_master *master;
		int id;
		int link;
		struct cdev cdev;
		int cdev_idx;
		int id; /* FSI address */
		int link; /* FSI link# */
		u32 cfam_id;
		int chip_id;
		uint32_t size; /* size of slave address space */
		u8 t_send_delay;
		@@ -92,6 +103,13 @@ struct fsi_slave {
		static const int slave_retries = 2;
		static int discard_errors;

		static dev_t fsi_base_dev;
		static DEFINE_IDA(fsi_minor_ida);
		#define FSI_CHAR_MAX_DEVICES 0x1000

		/* Legacy /dev numbering: 4 devices per chip, 16 chips */
		#define FSI_CHAR_LEGACY_TOP 64

		static int fsi_master_read(struct fsi_master *master, int link,
		uint8_t slave_id, uint32_t addr, void *val, size_t size);
		static int fsi_master_write(struct fsi_master *master, int link,
		@@ -600,33 +618,11 @@ static const struct bin_attribute fsi_slave_raw_attr = {
		.write = fsi_slave_sysfs_raw_write,
		};

		static ssize_t fsi_slave_sysfs_term_write(struct file *file,
		struct kobject kobj, struct bin_attribute attr,
		char *buf, loff_t off, size_t count)
		{
		struct fsi_slave *slave = to_fsi_slave(kobj_to_dev(kobj));
		struct fsi_master *master = slave->master;

		if (!master->term)
		return -ENODEV;

		master->term(master, slave->link, slave->id);
		return count;
		}

		static const struct bin_attribute fsi_slave_term_attr = {
		.attr = {
		.name = "term",
		.mode = 0200,
		},
		.size = 0,
		.write = fsi_slave_sysfs_term_write,
		};

		static void fsi_slave_release(struct device *dev)
		{
		struct fsi_slave *slave = to_fsi_slave(dev);

		fsi_free_minor(slave->dev.devt);
		of_node_put(dev->of_node);
		kfree(slave);
		}
		@@ -674,6 +670,127 @@ static struct device_node fsi_slave_find_of_node(struct fsi_master master,
		return NULL;
		}

		static ssize_t cfam_read(struct file filep, char __user buf, size_t count,
		loff_t *offset)
		{
		struct fsi_slave *slave = filep->private_data;
		size_t total_len, read_len;
		loff_t off = *offset;
		ssize_t rc;

		if (off < 0)
		return -EINVAL;

		if (off > 0xffffffff \|\| count > 0xffffffff \|\| off + count > 0xffffffff)
		return -EINVAL;

		for (total_len = 0; total_len < count; total_len += read_len) {
		__be32 data;

		read_len = min_t(size_t, count, 4);
		read_len -= off & 0x3;

		rc = fsi_slave_read(slave, off, &data, read_len);
		if (rc)
		goto fail;
		rc = copy_to_user(buf + total_len, &data, read_len);
		if (rc) {
		rc = -EFAULT;
		goto fail;
		}
		off += read_len;
		}
		rc = count;
		fail:
		*offset = off;
		return count;
		}

		static ssize_t cfam_write(struct file filep, const char __user buf,
		size_t count, loff_t *offset)
		{
		struct fsi_slave *slave = filep->private_data;
		size_t total_len, write_len;
		loff_t off = *offset;
		ssize_t rc;


		if (off < 0)
		return -EINVAL;

		if (off > 0xffffffff \|\| count > 0xffffffff \|\| off + count > 0xffffffff)
		return -EINVAL;

		for (total_len = 0; total_len < count; total_len += write_len) {
		__be32 data;

		write_len = min_t(size_t, count, 4);
		write_len -= off & 0x3;

		rc = copy_from_user(&data, buf + total_len, write_len);
		if (rc) {
		rc = -EFAULT;
		goto fail;
		}
		rc = fsi_slave_write(slave, off, &data, write_len);
		if (rc)
		goto fail;
		off += write_len;
		}
		rc = count;
		fail:
		*offset = off;
		return count;
		}

		static loff_t cfam_llseek(struct file *file, loff_t offset, int whence)
		{
		switch (whence) {
		case SEEK_CUR:
		break;
		case SEEK_SET:
		file->f_pos = offset;
		break;
		default:
		return -EINVAL;
		}

		return offset;
		}

		static int cfam_open(struct inode inode, struct file file)
		{
		struct fsi_slave *slave = container_of(inode->i_cdev, struct fsi_slave, cdev);

		file->private_data = slave;

		return 0;
		}

		static const struct file_operations cfam_fops = {
		.owner = THIS_MODULE,
		.open = cfam_open,
		.llseek = cfam_llseek,
		.read = cfam_read,
		.write = cfam_write,
		};

		static ssize_t send_term_store(struct device *dev,
		struct device_attribute *attr,
		const char *buf, size_t count)
		{
		struct fsi_slave *slave = to_fsi_slave(dev);
		struct fsi_master *master = slave->master;

		if (!master->term)
		return -ENODEV;

		master->term(master, slave->link, slave->id);
		return count;
		}

		static DEVICE_ATTR_WO(send_term);

		static ssize_t slave_send_echo_show(struct device *dev,
		struct device_attribute *attr,
		char *buf)
		@@ -729,9 +846,124 @@ static ssize_t chip_id_show(struct device *dev,

		static DEVICE_ATTR_RO(chip_id);

		static ssize_t cfam_id_show(struct device *dev,
		struct device_attribute *attr,
		char *buf)
		{
		struct fsi_slave *slave = to_fsi_slave(dev);

		return sprintf(buf, "0x%x\n", slave->cfam_id);
		}

		static DEVICE_ATTR_RO(cfam_id);

		static struct attribute *cfam_attr[] = {
		&dev_attr_send_echo_delays.attr,
		&dev_attr_chip_id.attr,
		&dev_attr_cfam_id.attr,
		&dev_attr_send_term.attr,
		NULL,
		};

		static const struct attribute_group cfam_attr_group = {
		.attrs = cfam_attr,
		};

		static const struct attribute_group *cfam_attr_groups[] = {
		&cfam_attr_group,
		NULL,
		};

		static char cfam_devnode(struct device dev, umode_t *mode,
		kuid_t uid, kgid_t gid)
		{
		struct fsi_slave *slave = to_fsi_slave(dev);

		#ifdef CONFIG_FSI_NEW_DEV_NODE
		return kasprintf(GFP_KERNEL, "fsi/cfam%d", slave->cdev_idx);
		#else
		return kasprintf(GFP_KERNEL, "cfam%d", slave->cdev_idx);
		#endif
		}

		static const struct device_type cfam_type = {
		.name = "cfam",
		.devnode = cfam_devnode,
		.groups = cfam_attr_groups
		};

		static char fsi_cdev_devnode(struct device dev, umode_t *mode,
		kuid_t uid, kgid_t gid)
		{
		#ifdef CONFIG_FSI_NEW_DEV_NODE
		return kasprintf(GFP_KERNEL, "fsi/%s", dev_name(dev));
		#else
		return kasprintf(GFP_KERNEL, "%s", dev_name(dev));
		#endif
		}

		const struct device_type fsi_cdev_type = {
		.name = "fsi-cdev",
		.devnode = fsi_cdev_devnode,
		};
		EXPORT_SYMBOL_GPL(fsi_cdev_type);

		/* Backward compatible /dev/ numbering in "old style" mode */
		static int fsi_adjust_index(int index)
		{
		#ifdef CONFIG_FSI_NEW_DEV_NODE
		return index;
		#else
		return index + 1;
		#endif
		}

		static int __fsi_get_new_minor(struct fsi_slave *slave, enum fsi_dev_type type,
		dev_t out_dev, int out_index)
		{
		int cid = slave->chip_id;
		int id;

		/* Check if we qualify for legacy numbering */
		if (cid >= 0 && cid < 16 && type < 4) {
		/* Try reserving the legacy number */
		id = (cid << 4) \| type;
		id = ida_simple_get(&fsi_minor_ida, id, id + 1, GFP_KERNEL);
		if (id >= 0) {
		*out_index = fsi_adjust_index(cid);
		*out_dev = fsi_base_dev + id;
		return 0;
		}
		/* Other failure */
		if (id != -ENOSPC)
		return id;
		/* Fallback to non-legacy allocation */
		}
		id = ida_simple_get(&fsi_minor_ida, FSI_CHAR_LEGACY_TOP,
		FSI_CHAR_MAX_DEVICES, GFP_KERNEL);
		if (id < 0)
		return id;
		*out_index = fsi_adjust_index(id);
		*out_dev = fsi_base_dev + id;
		return 0;
		}

		int fsi_get_new_minor(struct fsi_device *fdev, enum fsi_dev_type type,
		dev_t out_dev, int out_index)
		{
		return __fsi_get_new_minor(fdev->slave, type, out_dev, out_index);
		}
		EXPORT_SYMBOL_GPL(fsi_get_new_minor);

		void fsi_free_minor(dev_t dev)
		{
		ida_simple_remove(&fsi_minor_ida, MINOR(dev));
		}
		EXPORT_SYMBOL_GPL(fsi_free_minor);

		static int fsi_slave_init(struct fsi_master *master, int link, uint8_t id)
		{
		uint32_t chip_id;
		uint32_t cfam_id;
		struct fsi_slave *slave;
		uint8_t crc;
		__be32 data, llmode;
		@@ -749,17 +981,17 @@ static int fsi_slave_init(struct fsi_master *master, int link, uint8_t id)
		link, id, rc);
		return -ENODEV;
		}
		chip_id = be32_to_cpu(data);
		cfam_id = be32_to_cpu(data);

		crc = crc4(0, chip_id, 32);
		crc = crc4(0, cfam_id, 32);
		if (crc) {
		dev_warn(&master->dev, "slave %02x:%02x invalid chip id CRC!\n",
		dev_warn(&master->dev, "slave %02x:%02x invalid cfam id CRC!\n",
		link, id);
		return -EIO;
		}

		dev_dbg(&master->dev, "fsi: found chip %08x at %02x:%02x:%02x\n",
		chip_id, master->idx, link, id);
		cfam_id, master->idx, link, id);

		/* If we're behind a master that doesn't provide a self-running bus
		* clock, put the slave into async mode
		@@ -782,10 +1014,14 @@ static int fsi_slave_init(struct fsi_master *master, int link, uint8_t id)
		if (!slave)
		return -ENOMEM;

		slave->master = master;
		dev_set_name(&slave->dev, "slave@%02x:%02x", link, id);
		slave->dev.type = &cfam_type;
		slave->dev.parent = &master->dev;
		slave->dev.of_node = fsi_slave_find_of_node(master, link, id);
		slave->dev.release = fsi_slave_release;
		device_initialize(&slave->dev);
		slave->cfam_id = cfam_id;
		slave->master = master;
		slave->link = link;
		slave->id = id;
		slave->size = FSI_SLAVE_SIZE_23b;
		@@ -800,6 +1036,21 @@ static int fsi_slave_init(struct fsi_master *master, int link, uint8_t id)
		slave->chip_id = prop;

		}

		/* Allocate a minor in the FSI space */
		rc = __fsi_get_new_minor(slave, fsi_dev_cfam, &slave->dev.devt,
		&slave->cdev_idx);
		if (rc)
		goto err_free;

		/* Create chardev for userspace access */
		cdev_init(&slave->cdev, &cfam_fops);
		rc = cdev_device_add(&slave->cdev, &slave->dev);
		if (rc) {
		dev_err(&slave->dev, "Error %d creating slave device\n", rc);
		goto err_free;
		}

		rc = fsi_slave_set_smode(slave);
		if (rc) {
		dev_warn(&master->dev,
		@@ -813,30 +1064,11 @@ static int fsi_slave_init(struct fsi_master *master, int link, uint8_t id)
		slave->t_send_delay,
		slave->t_echo_delay);

		dev_set_name(&slave->dev, "slave@%02x:%02x", link, id);
		rc = device_register(&slave->dev);
		if (rc < 0) {
		dev_warn(&master->dev, "failed to create slave device: %d\n",
		rc);
		put_device(&slave->dev);
		return rc;
		}

		/* Legacy raw file -> to be removed */
		rc = device_create_bin_file(&slave->dev, &fsi_slave_raw_attr);
		if (rc)
		dev_warn(&slave->dev, "failed to create raw attr: %d\n", rc);

		rc = device_create_bin_file(&slave->dev, &fsi_slave_term_attr);
		if (rc)
		dev_warn(&slave->dev, "failed to create term attr: %d\n", rc);

		rc = device_create_file(&slave->dev, &dev_attr_send_echo_delays);
		if (rc)
		dev_warn(&slave->dev, "failed to create delay attr: %d\n", rc);

		rc = device_create_file(&slave->dev, &dev_attr_chip_id);
		if (rc)
		dev_warn(&slave->dev, "failed to create chip id: %d\n", rc);

		rc = fsi_slave_scan(slave);
		if (rc)
		@@ -844,6 +1076,10 @@ static int fsi_slave_init(struct fsi_master *master, int link, uint8_t id)
		rc);

		return rc;

		err_free:
		put_device(&slave->dev);
		return rc;
		}

		/* FSI master support */
		@@ -952,8 +1188,11 @@ static int fsi_slave_remove_device(struct device dev, void arg)

		static int fsi_master_remove_slave(struct device dev, void arg)
		{
		struct fsi_slave *slave = to_fsi_slave(dev);

		device_for_each_child(dev, NULL, fsi_slave_remove_device);
		device_unregister(dev);
		cdev_device_del(&slave->cdev, &slave->dev);
		put_device(dev);
		return 0;
		}

		@@ -964,8 +1203,14 @@ static void fsi_master_unscan(struct fsi_master *master)

		int fsi_master_rescan(struct fsi_master *master)
		{
		int rc;

		mutex_lock(&master->scan_lock);
		fsi_master_unscan(master);
		return fsi_master_scan(master);
		rc = fsi_master_scan(master);
		mutex_unlock(&master->scan_lock);

		return rc;
		}
		EXPORT_SYMBOL_GPL(fsi_master_rescan);

		@@ -1001,6 +1246,7 @@ int fsi_master_register(struct fsi_master *master)
		int rc;
		struct device_node *np;

		mutex_init(&master->scan_lock);
		master->idx = ida_simple_get(&master_ida, 0, INT_MAX, GFP_KERNEL);
		dev_set_name(&master->dev, "fsi%d", master->idx);

		@@ -1025,8 +1271,11 @@ int fsi_master_register(struct fsi_master *master)
		}

		np = dev_of_node(&master->dev);
		if (!of_property_read_bool(np, "no-scan-on-init"))
		if (!of_property_read_bool(np, "no-scan-on-init")) {
		mutex_lock(&master->scan_lock);
		fsi_master_scan(master);
		mutex_unlock(&master->scan_lock);
		}

		return 0;
		}
		@@ -1039,7 +1288,9 @@ void fsi_master_unregister(struct fsi_master *master)
		master->idx = -1;
		}

		mutex_lock(&master->scan_lock);
		fsi_master_unscan(master);
		mutex_unlock(&master->scan_lock);
		device_unregister(&master->dev);
		}
		EXPORT_SYMBOL_GPL(fsi_master_unregister);
		@@ -1091,13 +1342,27 @@ EXPORT_SYMBOL_GPL(fsi_bus_type);

		static int __init fsi_init(void)
		{
		return bus_register(&fsi_bus_type);
		int rc;

		rc = alloc_chrdev_region(&fsi_base_dev, 0, FSI_CHAR_MAX_DEVICES, "fsi");
		if (rc)
		return rc;
		rc = bus_register(&fsi_bus_type);
		if (rc)
		goto fail_bus;
		return 0;

		fail_bus:
		unregister_chrdev_region(fsi_base_dev, FSI_CHAR_MAX_DEVICES);
		return rc;
		}
		postcore_initcall(fsi_init);

		static void fsi_exit(void)
		{
		bus_unregister(&fsi_bus_type);
		unregister_chrdev_region(fsi_base_dev, FSI_CHAR_MAX_DEVICES);
		ida_destroy(&fsi_minor_ida);
		}
		module_exit(fsi_exit);
		module_param(discard_errors, int, 0664);

drivers/fsi/fsi-master-ast-cf.c

+13 −11

Original line number	Diff line number	Diff line
		@@ -377,8 +377,8 @@ static int send_request(struct fsi_master_acf master, struct fsi_msg cmd,
		static int read_copro_response(struct fsi_master_acf *master, uint8_t size,
		uint32_t response, u8 tag)
		{
		uint8_t rtag = ioread8(master->sram + STAT_RTAG);
		uint8_t rcrc = ioread8(master->sram + STAT_RCRC);
		uint8_t rtag = ioread8(master->sram + STAT_RTAG) & 0xf;
		uint8_t rcrc = ioread8(master->sram + STAT_RCRC) & 0xf;
		uint32_t rdata = 0;
		uint32_t crc;
		uint8_t ack;
		@@ -437,7 +437,7 @@ static int send_term(struct fsi_master_acf *master, uint8_t slave)
		return 0;
		}

		static void dump_trace(struct fsi_master_acf *master)
		static void dump_ucode_trace(struct fsi_master_acf *master)
		{
		char trbuf[52];
		char *p;
		@@ -488,7 +488,7 @@ retry:
		}
		trace_fsi_master_acf_crc_rsp_error(master, crc_err_retries);
		if (master->trace_enabled)
		dump_trace(master);
		dump_ucode_trace(master);
		rc = clock_zeros(master, FSI_MASTER_EPOLL_CLOCKS);
		if (rc) {
		dev_warn(master->dev,
		@@ -525,7 +525,7 @@ retry:
		*/
		dev_dbg(master->dev, "Busy, retrying...\n");
		if (master->trace_enabled)
		dump_trace(master);
		dump_ucode_trace(master);
		rc = clock_zeros(master, FSI_MASTER_DPOLL_CLOCKS);
		if (rc) {
		dev_warn(master->dev,
		@@ -550,13 +550,13 @@ retry:
		case FSI_RESP_ERRA:
		dev_dbg(master->dev, "ERRA received\n");
		if (master->trace_enabled)
		dump_trace(master);
		dump_ucode_trace(master);
		rc = -EIO;
		break;
		case FSI_RESP_ERRC:
		dev_dbg(master->dev, "ERRC received\n");
		if (master->trace_enabled)
		dump_trace(master);
		dump_ucode_trace(master);
		rc = -EAGAIN;
		break;
		}
		@@ -606,7 +606,7 @@ static int fsi_master_acf_read(struct fsi_master *_master, int link,
		return -ENODEV;

		mutex_lock(&master->lock);
		dev_dbg(master->dev, "read id %d addr %x size %ud\n", id, addr, size);
		dev_dbg(master->dev, "read id %d addr %x size %zd\n", id, addr, size);
		build_ar_command(master, &cmd, id, addr, size, NULL);
		rc = fsi_master_acf_xfer(master, id, &cmd, size, val);
		last_address_update(master, id, rc == 0, addr);
		@@ -631,7 +631,7 @@ static int fsi_master_acf_write(struct fsi_master *_master, int link,

		mutex_lock(&master->lock);
		build_ar_command(master, &cmd, id, addr, size, val);
		dev_dbg(master->dev, "write id %d addr %x size %ud raw_data: %08x\n",
		dev_dbg(master->dev, "write id %d addr %x size %zd raw_data: %08x\n",
		id, addr, size, (uint32_t )val);
		rc = fsi_master_acf_xfer(master, id, &cmd, 0, NULL);
		last_address_update(master, id, rc == 0, addr);
		@@ -861,7 +861,8 @@ static int load_copro_firmware(struct fsi_master_acf *master)
		if (sig != wanted_sig) {
		dev_err(master->dev, "Failed to locate image sig %04x in FW blob\n",
		wanted_sig);
		return -ENODEV;
		rc = -ENODEV;
		goto release_fw;
		}
		if (size > master->cf_mem_size) {
		dev_err(master->dev, "FW size (%zd) bigger than memory reserve (%zd)\n",
		@@ -870,8 +871,9 @@ static int load_copro_firmware(struct fsi_master_acf *master)
		} else {
		memcpy_toio(master->cf_mem, data, size);
		}
		release_firmware(fw);

		release_fw:
		release_firmware(fw);
		return rc;
		}

drivers/fsi/fsi-master.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@
		#define DRIVERS_FSI_MASTER_H

		#include <linux/device.h>
		#include <linux/mutex.h>

		/* Various protocol delays */
		#define FSI_ECHO_DELAY_CLOCKS 16 /* Number clocks for echo delay */
		@@ -59,6 +60,7 @@ struct fsi_master {
		int idx;
		int n_links;
		int flags;
		struct mutex scan_lock;
		int (read)(struct fsi_master , int link, uint8_t id,
		uint32_t addr, void *val, size_t size);
		int (write)(struct fsi_master , int link, uint8_t id,

drivers/fsi/fsi-sbefifo.c

+55 −29

Original line number	Diff line number	Diff line
		@@ -17,9 +17,8 @@
		#include <linux/fs.h>
		#include <linux/fsi.h>
		#include <linux/fsi-sbefifo.h>
		#include <linux/idr.h>
		#include <linux/kernel.h>
		#include <linux/miscdevice.h>
		#include <linux/cdev.h>
		#include <linux/module.h>
		#include <linux/mutex.h>
		#include <linux/of.h>
		@@ -118,11 +117,11 @@ struct sbefifo {
		uint32_t magic;
		#define SBEFIFO_MAGIC 0x53424546 /* "SBEF" */
		struct fsi_device *fsi_dev;
		struct miscdevice mdev;
		struct device dev;
		struct cdev cdev;
		struct mutex lock;
		char name[32];
		int idx;
		bool broken;
		bool dead;
		bool async_ffdc;
		};

		@@ -133,9 +132,9 @@ struct sbefifo_user {
		size_t pending_len;
		};

		static DEFINE_IDA(sbefifo_ida);
		static DEFINE_MUTEX(sbefifo_ffdc_mutex);


		static void __sbefifo_dump_ffdc(struct device dev, const __be32 ffdc,
		size_t ffdc_sz, bool internal)
		{
		@@ -667,6 +666,9 @@ static int __sbefifo_submit(struct sbefifo *sbefifo,
		struct device *dev = &sbefifo->fsi_dev->dev;
		int rc;

		if (sbefifo->dead)
		return -ENODEV;

		if (cmd_len < 2 \|\| be32_to_cpu(command[0]) != cmd_len) {
		dev_vdbg(dev, "Invalid command len %zd (header: %d)\n",
		cmd_len, be32_to_cpu(command[0]));
		@@ -751,8 +753,7 @@ EXPORT_SYMBOL_GPL(sbefifo_submit);
		*/
		static int sbefifo_user_open(struct inode inode, struct file file)
		{
		struct sbefifo *sbefifo = container_of(file->private_data,
		struct sbefifo, mdev);
		struct sbefifo *sbefifo = container_of(inode->i_cdev, struct sbefifo, cdev);
		struct sbefifo_user *user;

		user = kzalloc(sizeof(struct sbefifo_user), GFP_KERNEL);
		@@ -889,6 +890,14 @@ static const struct file_operations sbefifo_fops = {
		.release = sbefifo_user_release,
		};

		static void sbefifo_free(struct device *dev)
		{
		struct sbefifo *sbefifo = container_of(dev, struct sbefifo, dev);

		put_device(&sbefifo->fsi_dev->dev);
		kfree(sbefifo);
		}

		/*
		* Probe/remove
		*/
		@@ -900,15 +909,23 @@ static int sbefifo_probe(struct device *dev)
		struct device_node *np;
		struct platform_device *child;
		char child_name[32];
		int rc, child_idx = 0;
		int rc, didx, child_idx = 0;

		dev_dbg(dev, "Found sbefifo device\n");

		sbefifo = devm_kzalloc(dev, sizeof(*sbefifo), GFP_KERNEL);
		sbefifo = kzalloc(sizeof(*sbefifo), GFP_KERNEL);
		if (!sbefifo)
		return -ENOMEM;

		/* Grab a reference to the device (parent of our cdev), we'll drop it later */
		if (!get_device(dev)) {
		kfree(sbefifo);
		return -ENODEV;
		}

		sbefifo->magic = SBEFIFO_MAGIC;
		sbefifo->fsi_dev = fsi_dev;
		dev_set_drvdata(dev, sbefifo);
		mutex_init(&sbefifo->lock);

		/*
		@@ -919,28 +936,30 @@ static int sbefifo_probe(struct device *dev)
		if (rc && rc != -ESHUTDOWN)
		dev_err(dev, "Initial HW cleanup failed, will retry later\n");

		sbefifo->idx = ida_simple_get(&sbefifo_ida, 1, INT_MAX, GFP_KERNEL);
		snprintf(sbefifo->name, sizeof(sbefifo->name), "sbefifo%d",
		sbefifo->idx);
		/* Create chardev for userspace access */
		sbefifo->dev.type = &fsi_cdev_type;
		sbefifo->dev.parent = dev;
		sbefifo->dev.release = sbefifo_free;
		device_initialize(&sbefifo->dev);

		dev_set_drvdata(dev, sbefifo);
		/* Allocate a minor in the FSI space */
		rc = fsi_get_new_minor(fsi_dev, fsi_dev_sbefifo, &sbefifo->dev.devt, &didx);
		if (rc)
		goto err;

		/* Create misc chardev for userspace access */
		sbefifo->mdev.minor = MISC_DYNAMIC_MINOR;
		sbefifo->mdev.fops = &sbefifo_fops;
		sbefifo->mdev.name = sbefifo->name;
		sbefifo->mdev.parent = dev;
		rc = misc_register(&sbefifo->mdev);
		dev_set_name(&sbefifo->dev, "sbefifo%d", didx);
		cdev_init(&sbefifo->cdev, &sbefifo_fops);
		rc = cdev_device_add(&sbefifo->cdev, &sbefifo->dev);
		if (rc) {
		dev_err(dev, "Failed to register miscdevice: %d\n", rc);
		ida_simple_remove(&sbefifo_ida, sbefifo->idx);
		return rc;
		dev_err(dev, "Error %d creating char device %s\n",
		rc, dev_name(&sbefifo->dev));
		goto err_free_minor;
		}

		/* Create platform devs for dts child nodes (occ, etc) */
		for_each_available_child_of_node(dev->of_node, np) {
		snprintf(child_name, sizeof(child_name), "%s-dev%d",
		sbefifo->name, child_idx++);
		dev_name(&sbefifo->dev), child_idx++);
		child = of_platform_device_create(np, child_name, dev);
		if (!child)
		dev_warn(dev, "failed to create child %s dev\n",
		@@ -948,6 +967,11 @@ static int sbefifo_probe(struct device *dev)
		}

		return 0;
		err_free_minor:
		fsi_free_minor(sbefifo->dev.devt);
		err:
		put_device(&sbefifo->dev);
		return rc;
		}

		static int sbefifo_unregister_child(struct device dev, void data)
		@@ -967,10 +991,14 @@ static int sbefifo_remove(struct device *dev)

		dev_dbg(dev, "Removing sbefifo device...\n");

		misc_deregister(&sbefifo->mdev);
		device_for_each_child(dev, NULL, sbefifo_unregister_child);
		mutex_lock(&sbefifo->lock);
		sbefifo->dead = true;
		mutex_unlock(&sbefifo->lock);

		ida_simple_remove(&sbefifo_ida, sbefifo->idx);
		cdev_device_del(&sbefifo->cdev, &sbefifo->dev);
		fsi_free_minor(sbefifo->dev.devt);
		device_for_each_child(dev, NULL, sbefifo_unregister_child);
		put_device(&sbefifo->dev);

		return 0;
		}
		@@ -1001,8 +1029,6 @@ static int sbefifo_init(void)
		static void sbefifo_exit(void)
		{
		fsi_driver_unregister(&sbefifo_drv);

		ida_destroy(&sbefifo_ida);
		}

		module_init(sbefifo_init);

Admin message