Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547// SPDX-License-Identifier: GPL-2.0/* * cdev.c - Character device component for Mostcore * * Copyright (C) 2013-2015 Microchip Technology Germany II GmbH & Co. KG */
#include <linux/module.h>#include <linux/sched.h>#include <linux/fs.h>#include <linux/slab.h>#include <linux/device.h>#include <linux/cdev.h>#include <linux/poll.h>#include <linux/kfifo.h>#include <linux/uaccess.h>#include <linux/idr.h>#include <linux/most.h>
#define CHRDEV_REGION_SIZE 50
static const struct class most_cdev_class = { .name = "most_cdev"};
static struct cdev_component { dev_t devno; struct ida minor_id; unsigned int major; struct most_component cc;} comp;
struct comp_channel { wait_queue_head_t wq; spinlock_t unlink; /* synchronization lock to unlink channels */ struct cdev cdev; struct device *dev; struct mutex io_mutex; struct most_interface *iface; struct most_channel_config *cfg; unsigned int channel_id; dev_t devno; size_t mbo_offs; DECLARE_KFIFO_PTR(fifo, typeof(struct mbo *)); int access_ref; struct list_head list;};
#define to_channel(d) container_of(d, struct comp_channel, cdev)static LIST_HEAD(channel_list);static DEFINE_SPINLOCK(ch_list_lock);
static inline bool ch_has_mbo(struct comp_channel *c){ return channel_has_mbo(c->iface, c->channel_id, &comp.cc) > 0;}
static inline struct mbo *ch_get_mbo(struct comp_channel *c, struct mbo **mbo){ if (!kfifo_peek(&c->fifo, mbo)) { *mbo = most_get_mbo(c->iface, c->channel_id, &comp.cc); if (*mbo) kfifo_in(&c->fifo, mbo, 1); } return *mbo;}
static struct comp_channel *get_channel(struct most_interface *iface, int id){ struct comp_channel *c, *tmp; unsigned long flags;
spin_lock_irqsave(&ch_list_lock, flags); list_for_each_entry_safe(c, tmp, &channel_list, list) { if ((c->iface == iface) && (c->channel_id == id)) { spin_unlock_irqrestore(&ch_list_lock, flags); return c; } } spin_unlock_irqrestore(&ch_list_lock, flags); return NULL;}
static void stop_channel(struct comp_channel *c){ struct mbo *mbo;
while (kfifo_out((struct kfifo *)&c->fifo, &mbo, 1)) most_put_mbo(mbo); most_stop_channel(c->iface, c->channel_id, &comp.cc);}
static void destroy_cdev(struct comp_channel *c){ unsigned long flags;
device_destroy(&most_cdev_class, c->devno); cdev_del(&c->cdev); spin_lock_irqsave(&ch_list_lock, flags); list_del(&c->list); spin_unlock_irqrestore(&ch_list_lock, flags);}
static void destroy_channel(struct comp_channel *c){ ida_free(&comp.minor_id, MINOR(c->devno)); kfifo_free(&c->fifo); kfree(c);}
/** * comp_open - implements the syscall to open the device * @inode: inode pointer * @filp: file pointer * * This stores the channel pointer in the private data field of * the file structure and activates the channel within the core. */static int comp_open(struct inode *inode, struct file *filp){ struct comp_channel *c; int ret;
c = to_channel(inode->i_cdev); filp->private_data = c;
if (((c->cfg->direction == MOST_CH_RX) && ((filp->f_flags & O_ACCMODE) != O_RDONLY)) || ((c->cfg->direction == MOST_CH_TX) && ((filp->f_flags & O_ACCMODE) != O_WRONLY))) { return -EACCES; }
mutex_lock(&c->io_mutex); if (!c->dev) { mutex_unlock(&c->io_mutex); return -ENODEV; }
if (c->access_ref) { mutex_unlock(&c->io_mutex); return -EBUSY; }
c->mbo_offs = 0; ret = most_start_channel(c->iface, c->channel_id, &comp.cc); if (!ret) c->access_ref = 1; mutex_unlock(&c->io_mutex); return ret;}
/** * comp_close - implements the syscall to close the device * @inode: inode pointer * @filp: file pointer * * This stops the channel within the core. */static int comp_close(struct inode *inode, struct file *filp){ struct comp_channel *c = to_channel(inode->i_cdev);
mutex_lock(&c->io_mutex); spin_lock(&c->unlink); c->access_ref = 0; spin_unlock(&c->unlink); if (c->dev) { stop_channel(c); mutex_unlock(&c->io_mutex); } else { mutex_unlock(&c->io_mutex); destroy_channel(c); } return 0;}
/** * comp_write - implements the syscall to write to the device * @filp: file pointer * @buf: pointer to user buffer * @count: number of bytes to write * @offset: offset from where to start writing */static ssize_t comp_write(struct file *filp, const char __user *buf, size_t count, loff_t *offset){ int ret; size_t to_copy, left; struct mbo *mbo = NULL; struct comp_channel *c = filp->private_data;
mutex_lock(&c->io_mutex); while (c->dev && !ch_get_mbo(c, &mbo)) { mutex_unlock(&c->io_mutex);
if ((filp->f_flags & O_NONBLOCK)) return -EAGAIN; if (wait_event_interruptible(c->wq, ch_has_mbo(c) || !c->dev)) return -ERESTARTSYS; mutex_lock(&c->io_mutex); }
if (unlikely(!c->dev)) { ret = -ENODEV; goto unlock; }
to_copy = min(count, c->cfg->buffer_size - c->mbo_offs); left = copy_from_user(mbo->virt_address + c->mbo_offs, buf, to_copy); if (left == to_copy) { ret = -EFAULT; goto unlock; }
c->mbo_offs += to_copy - left; if (c->mbo_offs >= c->cfg->buffer_size || c->cfg->data_type == MOST_CH_CONTROL || c->cfg->data_type == MOST_CH_ASYNC) { kfifo_skip(&c->fifo); mbo->buffer_length = c->mbo_offs; c->mbo_offs = 0; most_submit_mbo(mbo); }
ret = to_copy - left;unlock: mutex_unlock(&c->io_mutex); return ret;}
/** * comp_read - implements the syscall to read from the device * @filp: file pointer * @buf: pointer to user buffer * @count: number of bytes to read * @offset: offset from where to start reading */static ssize_tcomp_read(struct file *filp, char __user *buf, size_t count, loff_t *offset){ size_t to_copy, not_copied, copied; struct mbo *mbo = NULL; struct comp_channel *c = filp->private_data;
mutex_lock(&c->io_mutex); while (c->dev && !kfifo_peek(&c->fifo, &mbo)) { mutex_unlock(&c->io_mutex); if (filp->f_flags & O_NONBLOCK) return -EAGAIN; if (wait_event_interruptible(c->wq, (!kfifo_is_empty(&c->fifo) || (!c->dev)))) return -ERESTARTSYS; mutex_lock(&c->io_mutex); }
/* make sure we don't submit to gone devices */ if (unlikely(!c->dev)) { mutex_unlock(&c->io_mutex); return -ENODEV; }
to_copy = min_t(size_t, count, mbo->processed_length - c->mbo_offs);
not_copied = copy_to_user(buf, mbo->virt_address + c->mbo_offs, to_copy);
copied = to_copy - not_copied;
c->mbo_offs += copied; if (c->mbo_offs >= mbo->processed_length) { kfifo_skip(&c->fifo); most_put_mbo(mbo); c->mbo_offs = 0; } mutex_unlock(&c->io_mutex); return copied;}
static __poll_t comp_poll(struct file *filp, poll_table *wait){ struct comp_channel *c = filp->private_data; __poll_t mask = 0;
poll_wait(filp, &c->wq, wait);
mutex_lock(&c->io_mutex); if (c->cfg->direction == MOST_CH_RX) { if (!c->dev || !kfifo_is_empty(&c->fifo)) mask |= EPOLLIN | EPOLLRDNORM; } else { if (!c->dev || !kfifo_is_empty(&c->fifo) || ch_has_mbo(c)) mask |= EPOLLOUT | EPOLLWRNORM; } mutex_unlock(&c->io_mutex); return mask;}
/* * Initialization of struct file_operations */static const struct file_operations channel_fops = { .owner = THIS_MODULE, .read = comp_read, .write = comp_write, .open = comp_open, .release = comp_close, .poll = comp_poll,};
/** * comp_disconnect_channel - disconnect a channel * @iface: pointer to interface instance * @channel_id: channel index * * This frees allocated memory and removes the cdev that represents this * channel in user space. */static int comp_disconnect_channel(struct most_interface *iface, int channel_id){ struct comp_channel *c;
c = get_channel(iface, channel_id); if (!c) return -EINVAL;
mutex_lock(&c->io_mutex); spin_lock(&c->unlink); c->dev = NULL; spin_unlock(&c->unlink); destroy_cdev(c); if (c->access_ref) { stop_channel(c); wake_up_interruptible(&c->wq); mutex_unlock(&c->io_mutex); } else { mutex_unlock(&c->io_mutex); destroy_channel(c); } return 0;}
/** * comp_rx_completion - completion handler for rx channels * @mbo: pointer to buffer object that has completed * * This searches for the channel linked to this MBO and stores it in the local * fifo buffer. */static int comp_rx_completion(struct mbo *mbo){ struct comp_channel *c;
if (!mbo) return -EINVAL;
c = get_channel(mbo->ifp, mbo->hdm_channel_id); if (!c) return -EINVAL;
spin_lock(&c->unlink); if (!c->access_ref || !c->dev) { spin_unlock(&c->unlink); return -ENODEV; } kfifo_in(&c->fifo, &mbo, 1); spin_unlock(&c->unlink);#ifdef DEBUG_MESG if (kfifo_is_full(&c->fifo)) dev_warn(c->dev, "Fifo is full\n");#endif wake_up_interruptible(&c->wq); return 0;}
/** * comp_tx_completion - completion handler for tx channels * @iface: pointer to interface instance * @channel_id: channel index/ID * * This wakes sleeping processes in the wait-queue. */static int comp_tx_completion(struct most_interface *iface, int channel_id){ struct comp_channel *c;
c = get_channel(iface, channel_id); if (!c) return -EINVAL;
if ((channel_id < 0) || (channel_id >= iface->num_channels)) { dev_warn(c->dev, "Channel ID out of range\n"); return -EINVAL; }
wake_up_interruptible(&c->wq); return 0;}
/** * comp_probe - probe function of the driver module * @iface: pointer to interface instance * @channel_id: channel index/ID * @cfg: pointer to actual channel configuration * @name: name of the device to be created * @args: pointer to array of component parameters (from configfs) * * This allocates a channel object and creates the device node in /dev * * Returns 0 on success or error code otherwise. */static int comp_probe(struct most_interface *iface, int channel_id, struct most_channel_config *cfg, char *name, char *args){ struct comp_channel *c; unsigned long cl_flags; int retval; int current_minor;
if (!cfg || !name) return -EINVAL;
c = get_channel(iface, channel_id); if (c) return -EEXIST;
current_minor = ida_alloc(&comp.minor_id, GFP_KERNEL); if (current_minor < 0) return current_minor;
c = kzalloc_obj(*c); if (!c) { retval = -ENOMEM; goto err_remove_ida; }
c->devno = MKDEV(comp.major, current_minor); cdev_init(&c->cdev, &channel_fops); c->cdev.owner = THIS_MODULE; retval = cdev_add(&c->cdev, c->devno, 1); if (retval < 0) goto err_free_c; c->iface = iface; c->cfg = cfg; c->channel_id = channel_id; c->access_ref = 0; spin_lock_init(&c->unlink); INIT_KFIFO(c->fifo); retval = kfifo_alloc(&c->fifo, cfg->num_buffers, GFP_KERNEL); if (retval) goto err_del_cdev_and_free_channel; init_waitqueue_head(&c->wq); mutex_init(&c->io_mutex); spin_lock_irqsave(&ch_list_lock, cl_flags); list_add_tail(&c->list, &channel_list); spin_unlock_irqrestore(&ch_list_lock, cl_flags); c->dev = device_create(&most_cdev_class, NULL, c->devno, NULL, "%s", name);
if (IS_ERR(c->dev)) { retval = PTR_ERR(c->dev); goto err_free_kfifo_and_del_list; } kobject_uevent(&c->dev->kobj, KOBJ_ADD); return 0;
err_free_kfifo_and_del_list: kfifo_free(&c->fifo); list_del(&c->list);err_del_cdev_and_free_channel: cdev_del(&c->cdev);err_free_c: kfree(c);err_remove_ida: ida_free(&comp.minor_id, current_minor); return retval;}
static struct cdev_component comp = { .cc = { .mod = THIS_MODULE, .name = "cdev", .probe_channel = comp_probe, .disconnect_channel = comp_disconnect_channel, .rx_completion = comp_rx_completion, .tx_completion = comp_tx_completion, },};
static int __init most_cdev_init(void){ int err;
err = class_register(&most_cdev_class); if (err) return err;
ida_init(&comp.minor_id);
err = alloc_chrdev_region(&comp.devno, 0, CHRDEV_REGION_SIZE, "cdev"); if (err < 0) goto dest_ida; comp.major = MAJOR(comp.devno); err = most_register_component(&comp.cc); if (err) goto free_cdev; err = most_register_configfs_subsys(&comp.cc); if (err) goto deregister_comp; return 0;
deregister_comp: most_deregister_component(&comp.cc);free_cdev: unregister_chrdev_region(comp.devno, CHRDEV_REGION_SIZE);dest_ida: ida_destroy(&comp.minor_id); class_unregister(&most_cdev_class); return err;}
static void __exit most_cdev_exit(void){ struct comp_channel *c, *tmp;
most_deregister_configfs_subsys(&comp.cc); most_deregister_component(&comp.cc);
list_for_each_entry_safe(c, tmp, &channel_list, list) { destroy_cdev(c); destroy_channel(c); } unregister_chrdev_region(comp.devno, CHRDEV_REGION_SIZE); ida_destroy(&comp.minor_id); class_unregister(&most_cdev_class);}
module_init(most_cdev_init);module_exit(most_cdev_exit);MODULE_AUTHOR("Christian Gromm <christian.gromm@microchip.com>");MODULE_LICENSE("GPL");MODULE_DESCRIPTION("character device component for mostcore");