[linux-block.git] / arch / mips / lasat / picvue_proc.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Picvue PVC160206 display driver
 *
 * Brian Murphy <brian.murphy@eicon.com>
 *
 */
#include <linux/bug.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/errno.h>

#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/interrupt.h>

#include <linux/timer.h>
#include <linux/mutex.h>
#include <linux/uaccess.h>

#include "picvue.h"

static DEFINE_MUTEX(pvc_mutex);
static char pvc_lines[PVC_NLINES][PVC_LINELEN+1];
static int pvc_linedata[PVC_NLINES];
static char *pvc_linename[PVC_NLINES] = {"line1", "line2"};
#define DISPLAY_DIR_NAME "display"
static int scroll_dir, scroll_interval;

static struct timer_list timer;

static void pvc_display(unsigned long data)
{
	int i;

	pvc_clear();
	for (i = 0; i < PVC_NLINES; i++)
		pvc_write_string(pvc_lines[i], 0, i);
}

static DECLARE_TASKLET(pvc_display_tasklet, &pvc_display, 0);

static int pvc_line_proc_show(struct seq_file *m, void *v)
{
	int lineno = *(int *)m->private;

	if (lineno < 0 || lineno >= PVC_NLINES) {
		printk(KERN_WARNING "proc_read_line: invalid lineno %d\n", lineno);
		return 0;
	}

	mutex_lock(&pvc_mutex);
	seq_printf(m, "%s\n", pvc_lines[lineno]);
	mutex_unlock(&pvc_mutex);

	return 0;
}

static int pvc_line_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, pvc_line_proc_show, PDE_DATA(inode));
}

static ssize_t pvc_line_proc_write(struct file *file, const char __user *buf,
				   size_t count, loff_t *pos)
{
	int lineno = *(int *)PDE_DATA(file_inode(file));
	char kbuf[PVC_LINELEN];
	size_t len;

	BUG_ON(lineno < 0 || lineno >= PVC_NLINES);

	len = min(count, sizeof(kbuf) - 1);
	if (copy_from_user(kbuf, buf, len))
		return -EFAULT;
	kbuf[len] = '\0';

	if (len > 0 && kbuf[len - 1] == '\n')
		len--;

	mutex_lock(&pvc_mutex);
	strncpy(pvc_lines[lineno], kbuf, len);
	pvc_lines[lineno][len] = '\0';
	mutex_unlock(&pvc_mutex);

	tasklet_schedule(&pvc_display_tasklet);

	return count;
}

static const struct file_operations pvc_line_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= pvc_line_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= pvc_line_proc_write,
};

static ssize_t pvc_scroll_proc_write(struct file *file, const char __user *buf,
				     size_t count, loff_t *pos)
{
	char kbuf[42];
	size_t len;
	int cmd;

	len = min(count, sizeof(kbuf) - 1);
	if (copy_from_user(kbuf, buf, len))
		return -EFAULT;
	kbuf[len] = '\0';

	cmd = simple_strtol(kbuf, NULL, 10);

	mutex_lock(&pvc_mutex);
	if (scroll_interval != 0)
		del_timer(&timer);

	if (cmd == 0) {
		scroll_dir = 0;
		scroll_interval = 0;
	} else {
		if (cmd < 0) {
			scroll_dir = -1;
			scroll_interval = -cmd;
		} else {
			scroll_dir = 1;
			scroll_interval = cmd;
		}
		add_timer(&timer);
	}
	mutex_unlock(&pvc_mutex);

	return count;
}

static int pvc_scroll_proc_show(struct seq_file *m, void *v)
{
	mutex_lock(&pvc_mutex);
	seq_printf(m, "%d\n", scroll_dir * scroll_interval);
	mutex_unlock(&pvc_mutex);

	return 0;
}

static int pvc_scroll_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, pvc_scroll_proc_show, NULL);
}

static const struct file_operations pvc_scroll_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= pvc_scroll_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= pvc_scroll_proc_write,
};

void pvc_proc_timerfunc(struct timer_list *unused)
{
	if (scroll_dir < 0)
		pvc_move(DISPLAY|RIGHT);
	else if (scroll_dir > 0)
		pvc_move(DISPLAY|LEFT);

	timer.expires = jiffies + scroll_interval;
	add_timer(&timer);
}

static void pvc_proc_cleanup(void)
{
	remove_proc_subtree(DISPLAY_DIR_NAME, NULL);
	del_timer_sync(&timer);
}

static int __init pvc_proc_init(void)
{
	struct proc_dir_entry *dir, *proc_entry;
	int i;

	dir = proc_mkdir(DISPLAY_DIR_NAME, NULL);
	if (dir == NULL)
		goto error;

	for (i = 0; i < PVC_NLINES; i++) {
		strcpy(pvc_lines[i], "");
		pvc_linedata[i] = i;
	}
	for (i = 0; i < PVC_NLINES; i++) {
		proc_entry = proc_create_data(pvc_linename[i], 0644, dir,
					&pvc_line_proc_fops, &pvc_linedata[i]);
		if (proc_entry == NULL)
			goto error;
	}
	proc_entry = proc_create("scroll", 0644, dir,
				 &pvc_scroll_proc_fops);
	if (proc_entry == NULL)
		goto error;

	timer_setup(&timer, pvc_proc_timerfunc, 0);

	return 0;
error:
	pvc_proc_cleanup();
	return -ENOMEM;
}

module_init(pvc_proc_init);
module_exit(pvc_proc_cleanup);
MODULE_LICENSE("GPL");
Commit	Line	Data
09c434b8	1	// SPDX-License-Identifier: GPL-2.0-only
1f21d2bd BM	2	/*
	3	* Picvue PVC160206 display driver
	4	*
	5	* Brian Murphy <brian.murphy@eicon.com>
	6	*
	7	*/
c0b4abdd	8	#include <linux/bug.h>
1f21d2bd BM	9	#include <linux/kernel.h>
	10	#include <linux/module.h>
	11	#include <linux/init.h>
	12	#include <linux/errno.h>
	13
	14	#include <linux/proc_fs.h>
c0b4abdd	15	#include <linux/seq_file.h>
1f21d2bd BM	16	#include <linux/interrupt.h>
	17
	18	#include <linux/timer.h>
8a39c520	19	#include <linux/mutex.h>
29abfbd9	20	#include <linux/uaccess.h>
1f21d2bd BM	21
	22	#include "picvue.h"
	23
8a39c520	24	static DEFINE_MUTEX(pvc_mutex);
1f21d2bd BM	25	static char pvc_lines[PVC_NLINES][PVC_LINELEN+1];
1f21d2bd BM	26	static int pvc_linedata[PVC_NLINES];
1f21d2bd BM	27	static char *pvc_linename[PVC_NLINES] = {"line1", "line2"};
	28	#define DISPLAY_DIR_NAME "display"
	29	static int scroll_dir, scroll_interval;
	30
	31	static struct timer_list timer;
	32
	33	static void pvc_display(unsigned long data)
	34	{
	35	int i;
	36
	37	pvc_clear();
	38	for (i = 0; i < PVC_NLINES; i++)
	39	pvc_write_string(pvc_lines[i], 0, i);
	40	}
	41
	42	static DECLARE_TASKLET(pvc_display_tasklet, &pvc_display, 0);
	43
c0b4abdd	44	static int pvc_line_proc_show(struct seq_file m, void v)
1f21d2bd	45	{
c0b4abdd	46	int lineno = (int )m->private;
1f21d2bd	47
9b987c4d	48	if (lineno < 0 \|\| lineno >= PVC_NLINES) {
1f21d2bd BM	49	printk(KERN_WARNING "proc_read_line: invalid lineno %d\n", lineno);
	50	return 0;
	51	}
	52
8a39c520	53	mutex_lock(&pvc_mutex);
c0b4abdd	54	seq_printf(m, "%s\n", pvc_lines[lineno]);
8a39c520	55	mutex_unlock(&pvc_mutex);
1f21d2bd	56
c0b4abdd	57	return 0;
1f21d2bd BM	58	}
1f21d2bd BM	59
c0b4abdd	60	static int pvc_line_proc_open(struct inode inode, struct file file)
1f21d2bd	61	{
d9dda78b	62	return single_open(file, pvc_line_proc_show, PDE_DATA(inode));
c0b4abdd	63	}
1f21d2bd	64
c0b4abdd AD	65	static ssize_t pvc_line_proc_write(struct file file, const char __user buf,
	66	size_t count, loff_t *pos)
	67	{
d9dda78b	68	int lineno = (int )PDE_DATA(file_inode(file));
c0b4abdd AD	69	char kbuf[PVC_LINELEN];
	70	size_t len;
	71
9b987c4d	72	BUG_ON(lineno < 0 \|\| lineno >= PVC_NLINES);
1f21d2bd	73
c0b4abdd AD	74	len = min(count, sizeof(kbuf) - 1);
	75	if (copy_from_user(kbuf, buf, len))
	76	return -EFAULT;
	77	kbuf[len] = '\0';
1f21d2bd	78
c0b4abdd AD	79	if (len > 0 && kbuf[len - 1] == '\n')
c0b4abdd AD	80	len--;
1f21d2bd	81
8a39c520	82	mutex_lock(&pvc_mutex);
c0b4abdd AD	83	strncpy(pvc_lines[lineno], kbuf, len);
c0b4abdd AD	84	pvc_lines[lineno][len] = '\0';
8a39c520	85	mutex_unlock(&pvc_mutex);
1f21d2bd BM	86
	87	tasklet_schedule(&pvc_display_tasklet);
	88
c0b4abdd	89	return count;
1f21d2bd BM	90	}
1f21d2bd BM	91
c0b4abdd AD	92	static const struct file_operations pvc_line_proc_fops = {
	93	.owner = THIS_MODULE,
	94	.open = pvc_line_proc_open,
	95	.read = seq_read,
	96	.llseek = seq_lseek,
	97	.release = single_release,
	98	.write = pvc_line_proc_write,
	99	};
	100
	101	static ssize_t pvc_scroll_proc_write(struct file file, const char __user buf,
	102	size_t count, loff_t *pos)
1f21d2bd	103	{
c0b4abdd AD	104	char kbuf[42];
	105	size_t len;
	106	int cmd;
	107
	108	len = min(count, sizeof(kbuf) - 1);
	109	if (copy_from_user(kbuf, buf, len))
	110	return -EFAULT;
	111	kbuf[len] = '\0';
	112
	113	cmd = simple_strtol(kbuf, NULL, 10);
1f21d2bd	114
8a39c520	115	mutex_lock(&pvc_mutex);
1f21d2bd BM	116	if (scroll_interval != 0)
	117	del_timer(&timer);
	118
	119	if (cmd == 0) {
	120	scroll_dir = 0;
	121	scroll_interval = 0;
	122	} else {
	123	if (cmd < 0) {
	124	scroll_dir = -1;
	125	scroll_interval = -cmd;
	126	} else {
	127	scroll_dir = 1;
	128	scroll_interval = cmd;
	129	}
	130	add_timer(&timer);
	131	}
8a39c520	132	mutex_unlock(&pvc_mutex);
1f21d2bd	133
c0b4abdd	134	return count;
1f21d2bd BM	135	}
1f21d2bd BM	136
c0b4abdd	137	static int pvc_scroll_proc_show(struct seq_file m, void v)
1f21d2bd	138	{
8a39c520	139	mutex_lock(&pvc_mutex);
c0b4abdd	140	seq_printf(m, "%d\n", scroll_dir * scroll_interval);
8a39c520	141	mutex_unlock(&pvc_mutex);
1f21d2bd	142
c0b4abdd	143	return 0;
1f21d2bd BM	144	}
1f21d2bd BM	145
c0b4abdd AD	146	static int pvc_scroll_proc_open(struct inode inode, struct file file)
	147	{
	148	return single_open(file, pvc_scroll_proc_show, NULL);
	149	}
	150
	151	static const struct file_operations pvc_scroll_proc_fops = {
	152	.owner = THIS_MODULE,
	153	.open = pvc_scroll_proc_open,
	154	.read = seq_read,
	155	.llseek = seq_lseek,
	156	.release = single_release,
	157	.write = pvc_scroll_proc_write,
	158	};
1f21d2bd	159
e99e88a9	160	void pvc_proc_timerfunc(struct timer_list *unused)
1f21d2bd BM	161	{
	162	if (scroll_dir < 0)
	163	pvc_move(DISPLAY\|RIGHT);
	164	else if (scroll_dir > 0)
	165	pvc_move(DISPLAY\|LEFT);
	166
	167	timer.expires = jiffies + scroll_interval;
	168	add_timer(&timer);
	169	}
	170
	171	static void pvc_proc_cleanup(void)
	172	{
c62432b4	173	remove_proc_subtree(DISPLAY_DIR_NAME, NULL);
49992cb1	174	del_timer_sync(&timer);
1f21d2bd BM	175	}
	176
	177	static int __init pvc_proc_init(void)
	178	{
c62432b4	179	struct proc_dir_entry dir, proc_entry;
1f21d2bd BM	180	int i;
1f21d2bd BM	181
c62432b4 AV	182	dir = proc_mkdir(DISPLAY_DIR_NAME, NULL);
c62432b4 AV	183	if (dir == NULL)
1f21d2bd BM	184	goto error;
	185
	186	for (i = 0; i < PVC_NLINES; i++) {
	187	strcpy(pvc_lines[i], "");
	188	pvc_linedata[i] = i;
	189	}
	190	for (i = 0; i < PVC_NLINES; i++) {
c62432b4	191	proc_entry = proc_create_data(pvc_linename[i], 0644, dir,
c0b4abdd	192	&pvc_line_proc_fops, &pvc_linedata[i]);
1f21d2bd BM	193	if (proc_entry == NULL)
1f21d2bd BM	194	goto error;
1f21d2bd	195	}
c62432b4	196	proc_entry = proc_create("scroll", 0644, dir,
c0b4abdd	197	&pvc_scroll_proc_fops);
1f21d2bd BM	198	if (proc_entry == NULL)
	199	goto error;
	200
e99e88a9	201	timer_setup(&timer, pvc_proc_timerfunc, 0);
1f21d2bd BM	202
	203	return 0;
	204	error:
	205	pvc_proc_cleanup();
	206	return -ENOMEM;
	207	}
	208
	209	module_init(pvc_proc_init);
	210	module_exit(pvc_proc_cleanup);
	211	MODULE_LICENSE("GPL");