media/spi/rk1608_dev.c

// SPDX-License-Identifier: GPL-2.0
/**
 * Rockchip rk1608 device driver
 *
 * Copyright (C) Rockchip Electronics Co., Ltd.
 *
 */
#include <linux/of_platform.h>
#include <linux/ctype.h>
#include <media/v4l2-ctrls.h>
#include <media/v4l2-fwnode.h>
#include <media/v4l2-subdev.h>
#include <linux/compat.h>
#include <linux/rk-preisp.h>
#include "rk1608_dev.h"

#define DEBUG_DUMP_ALL_SEND_RECV_MSG 0

#define MSG_QUEUE_DEFAULT_SIZE (8 * 1024)

struct msg_queue {
	u32 *buf_head; /* msg buffer head */
	u32 *buf_tail; /* msg buffer tail */
	u32 *cur_send; /* current msg send position */
	u32 *cur_recv; /* current msg receive position */
};

struct rk1608_client {
	s8 id;
	struct msg_queue q;
	struct list_head list;
	wait_queue_head_t wait;
	void *private_data;
};

enum {
	AUTO_ARG_TYPE_STR,
	AUTO_ARG_TYPE_INT32,
};

struct auto_arg {
	int type;
	union {
		s32 m_int32;
		const char *m_str;
	};
};

struct auto_args {
	int argc;
	struct auto_arg *argv;
};

/**
 * msq_init - Initialize msg queue
 *
 * @q: the msg queue to initialize
 * @size: size of msg queue buf
 *
 * It returns zero on success, else a negative error code.
 */
static int msq_init(struct msg_queue *q, int size)
{
	u32 *buf = kmalloc(size, GFP_KERNEL);

	q->buf_head = buf;
	q->buf_tail = buf + size / sizeof(u32);
	q->cur_send = buf;
	q->cur_recv = buf;

	return 0;
}

/**
 * msq_release - release msg queue buf
 *
 * @q: the msg queue to release
 */
static void msq_release(struct msg_queue *q)
{
	kfree(q->buf_head);
	q->buf_head = NULL;
	q->buf_tail = NULL;
	q->cur_send = NULL;
	q->cur_recv = NULL;
}

/**
 * msq_is_empty - tests whether a msg queue is empty
 *
 * @q: the msg queue to test
 *
 * It returns true on msg queue is empty, else false.
 */
static int msq_is_empty(const struct msg_queue *q)
{
	return q->cur_send == q->cur_recv;
}

/**
 * msq_tail_free_size - get msg queue tail unused buf size
 *
 * @q: msg queue
 *
 * It returns size of msg queue tail unused buf size, unit 4 bytes
 */
static u32 msq_tail_free_size(const struct msg_queue *q)
{
	if (q->cur_send >= q->cur_recv)
		return (q->buf_tail - q->cur_send);

	return q->cur_recv - q->cur_send;
}

/**
 * msq_head_free_size - get msg queue head unused buf size
 *
 * @q: msg queue
 *
 * It returns size of msg queue head unused buf size, unit 4 bytes
 */
static u32 msq_head_free_size(const struct msg_queue *q)
{
	if (q->cur_send >= q->cur_recv)
		return (q->cur_recv - q->buf_head);

	return 0;
}

/**
 * msq_send_msg - send a msg to msg queue
 *
 * @q: msg queue
 * @m: a msg to queue
 *
 * It returns zero on success, else a negative error code.
 */
static int msq_send_msg(struct msg_queue *q, const struct msg *m)
{
	int ret = 0;

	if (msq_tail_free_size(q) > m->size) {
		u32 *next_send;

		memcpy(q->cur_send, m, m->size * sizeof(u32));
		next_send = q->cur_send + m->size;
		if (next_send == q->buf_tail)
			next_send = q->buf_head;

		q->cur_send = next_send;
	} else if (msq_head_free_size(q) > m->size) {
		*q->cur_send = 0; /* set size to 0 for skip to head mark */
		memcpy(q->buf_head, m, m->size * sizeof(u32));
		q->cur_send = q->buf_head + m->size;
	} else {
		ret = -1;
	}

	return ret;
}

/**
 * msq_recv_msg - receive a msg from msg queue
 *
 * @q: msg queue
 * @m: a msg pointer buf [out]
 *
 * need call msq_recv_msg_free to free msg after msg use done
 *
 * It returns zero on success, else a negative error code.
 */
static int msq_recv_msg(struct msg_queue *q, struct msg **m)
{
	*m = NULL;
	if (msq_is_empty(q))
		return -1;

	/* skip to head when size is 0 */
	if (*q->cur_recv == 0)
		*m = (struct msg *)q->buf_head;
	else
		*m = (struct msg *)q->cur_recv;

	return 0;
}

/**
 * msq_free_received_msg - free a received msg to msg queue
 *
 * @q: msg queue
 * @m: a msg
 *
 * It returns zero on success, else a negative error code.
 */
static int msq_free_received_msg(struct msg_queue *q, const struct msg *m)
{
	/* skip to head when size is 0 */
	if (*q->cur_recv == 0) {
		q->cur_recv = q->buf_head + m->size;
	} else {
		u32 *next_recv;

		next_recv = q->cur_recv + m->size;
		if (next_recv == q->buf_tail)
			next_recv = q->buf_head;

		q->cur_recv = next_recv;
	}

	return 0;
}

static void rk1608_client_list_init(struct rk1608_client_list *s)
{
	mutex_init(&s->mutex);
	INIT_LIST_HEAD(&s->list);
}

static struct rk1608_client *rk1608_client_new(void)
{
	struct rk1608_client *c = kzalloc(sizeof(*c), GFP_KERNEL);

	if (!c)
		return NULL;

	c->id = INVALID_ID;
	INIT_LIST_HEAD(&c->list);
	msq_init(&c->q, MSG_QUEUE_DEFAULT_SIZE);
	init_waitqueue_head(&c->wait);

	return c;
}

static void rk1608_client_release(struct rk1608_client *c)
{
	msq_release(&c->q);
	kfree(c);
}

static struct rk1608_client *
rk1608_client_find(struct rk1608_client_list *s,
		   struct rk1608_client *c)
{
	struct rk1608_client *client = NULL;

	list_for_each_entry(client, &s->list, list) {
		if (c == client)
			return c;
	}

	return NULL;
}

static int rk1608_client_connect(struct rk1608_state *pdata,
				 struct rk1608_client *c)
{
	struct rk1608_client_list *s = &pdata->clients;

	mutex_lock(&s->mutex);
	if (rk1608_client_find(s, c)) {
		mutex_unlock(&s->mutex);
		return -1;
	}

	list_add_tail(&c->list, &s->list);
	mutex_unlock(&s->mutex);

	return 0;
}

static void rk1608_client_disconnect(struct rk1608_state *pdata,
				     struct rk1608_client *c)
{
	struct rk1608_client_list *s = &pdata->clients;

	mutex_lock(&s->mutex);
	if (rk1608_client_find(s, c))
		list_del_init(&c->list);
	mutex_unlock(&s->mutex);
}

static int parse_arg(const char *s, struct auto_arg *arg)
{
	if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) {
		long v;

		v = simple_strtol(s, NULL, 16);
		arg->type = AUTO_ARG_TYPE_INT32;
		arg->m_int32 = v;
	} else if (isdigit(s[0])) {
		long v;

		v = simple_strtol(s, NULL, 10);
		arg->type = AUTO_ARG_TYPE_INT32;
		arg->m_int32 = v;
	} else {
		arg->type = AUTO_ARG_TYPE_STR;
		arg->m_str = s;
	}

	return 0;
}

static int parse_auto_args(char *s, struct auto_args *args)
{
	int i = 0;
	char c = 0;
	int last_is_arg_flag = 0;
	const char *last_arg;

	args->argc = 0;

	i = -1;
	do {
		c = s[++i];
		if (c == ' ' || c == ',' || c == '\n' || c == '\r' || c == 0) {
			if (last_is_arg_flag)
				args->argc++;

			last_is_arg_flag = 0;
		} else {
			last_is_arg_flag = 1;
		}
	} while (c != 0 && c != '\n' && c != '\r');

	args->argv =
		kmalloc_array(args->argc, sizeof(struct auto_arg), GFP_KERNEL);
	if (!args->argv)
		return -ENOMEM;

	i = -1;
	last_is_arg_flag = 0;
	last_arg = s;
	args->argc = 0;
	do {
		c = s[++i];
		if (c == ' ' || c == ',' || c == '\n' || c == '\r' || c == 0) {
			if (last_is_arg_flag) {
				parse_arg(last_arg, args->argv + args->argc++);
				s[i] = 0;
			}
			last_is_arg_flag = 0;
		} else {
			if (last_is_arg_flag == 0)
				last_arg = s + i;

			last_is_arg_flag = 1;
		}
	} while (c != 0 && c != '\n' && c != '\r');

	return c == 0 ? i : i + 1;
}

static void free_auto_args(struct auto_args *args)
{
	kfree(args->argv);
	args->argv = NULL;
	args->argc = 0;
}

static void int32_hexdump(const char *prefix, s32 *data, int len)
{
	pr_err("%s\n", prefix);
	print_hex_dump(KERN_ERR, "offset ", DUMP_PREFIX_OFFSET,
		       16, 4, data, len, false);
	pr_err("\n");
}

static int do_cmd_write(struct rk1608_state *pdata,
			const struct auto_args *args)
{
	s32 addr;
	s32 len = (args->argc - 2) * sizeof(s32);
	s32 *data;
	int i;

	if (args->argc < 3 || args->argv[1].type != AUTO_ARG_TYPE_INT32) {
		dev_err(pdata->dev, "Mis or unknown args!\n");
		return -1;
	}

	len = MIN(len, RK1608_MAX_OP_BYTES);

	addr = args->argv[1].m_int32;
	data = kmalloc(len, GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	for (i = 0; i < len / 4; i++) {
		if (args->argv[i + 2].type != AUTO_ARG_TYPE_INT32) {
			dev_err(pdata->dev, "Unknown args!\n");
			kfree(data);
			return -1;
		}

		data[i] = args->argv[i + 2].m_int32;
	}

	rk1608_write(pdata->spi, addr, data, len);

	kfree(data);

	dev_info(pdata->dev, "write addr: 0x%x, len: %d bytes\n", addr, len);
	return 0;
}

static int do_cmd_read(struct rk1608_state *pdata,
		       const struct auto_args *args)
{
	s32 addr;
	s32 len;
	s32 *data;

	if (args->argc < 3 || args->argv[1].type != AUTO_ARG_TYPE_INT32) {
		dev_err(pdata->dev, "Mis or unknown args!\n");
		return -1;
	}

	addr = args->argv[1].m_int32;
	if (args->argc == 2) {
		len = 32;
	} else {
		if (args->argv[2].type != AUTO_ARG_TYPE_INT32) {
			dev_err(pdata->dev, "Unknown args!\n");
			return -1;
		}
		len = args->argv[2].m_int32 * sizeof(s32);
		len = MIN(len, RK1608_MAX_OP_BYTES);
	}

	data = kmalloc(len, GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	dev_info(pdata->dev, "\nread addr: %x, len: %d bytes\n", addr, len);
	rk1608_read(pdata->spi, addr, data, len);
	int32_hexdump("read data:", data, len);
	kfree(data);

	return 0;
}

static int do_cmd_set_spi_rate(struct rk1608_state *pdata,
			       const struct auto_args *args)
{
	if (args->argc < 2 || args->argv[1].type != AUTO_ARG_TYPE_INT32) {
		dev_err(pdata->dev, "Mis or unknown args!\n");
		return -1;
	}

	pdata->max_speed_hz = args->argv[1].m_int32;
	dev_info(pdata->dev, "set spi max speed to %d!\n", pdata->max_speed_hz);

	if (args->argc == 3 && args->argv[2].type == AUTO_ARG_TYPE_INT32) {
		pdata->min_speed_hz = args->argv[2].m_int32;
		dev_info(pdata->dev, "set spi min speed to %d!\n",
			 pdata->min_speed_hz);
	}

	return 0;
}

static int do_cmd_query(struct rk1608_state *pdata,
			const struct auto_args *args)
{
	s32 state;

	rk1608_operation_query(pdata->spi, &state);
	dev_info(pdata->dev, "state %x\n", state);
	return 0;
}

static int do_cmd_download_fw(struct rk1608_state *pdata,
			      const struct auto_args *args)
{
	int ret = 0;
	const char *fw_name = NULL;

	if (args->argc == 2 && args->argv[1].type == AUTO_ARG_TYPE_STR)
		fw_name = args->argv[1].m_str;

	ret = rk1608_download_fw(pdata, pdata->spi, fw_name);
	if (ret)
		dev_err(pdata->dev, "download firmware failed!\n");
	else
		dev_info(pdata->dev, "download firmware success!\n");

	return 0;
}

static int do_cmd_fast_write(struct rk1608_state *pdata,
			     const struct auto_args *args)
{
	int ret = 0;
	s32 reg;

	if (args->argc != 2 || args->argv[1].type != AUTO_ARG_TYPE_INT32) {
		dev_err(pdata->dev, "Mis or unknown args!\n");
		return -1;
	}

	reg = args->argv[1].m_int32;

	ret = rk1608_interrupt_request(pdata->spi, reg);
	dev_info(pdata->dev, "interrupt request reg1:%x ret:%x\n", reg, ret);

	return 0;
}

static int do_cmd_fast_read(struct rk1608_state *pdata,
			    const struct auto_args *args)
{
	s32 state;

	rk1608_state_query(pdata->spi, &state);
	dev_info(pdata->dev, "dsp state %x\n", state);

	return 0;
}

static int do_cmd_send_msg(struct rk1608_state *pdata,
			   const struct auto_args *args)
{
	struct msg *m;
	int ret = 0;
	int msg_len;
	u32 i = 0;

	if (args->argc < 2) {
		dev_err(pdata->dev, "need more args\n");
		return -1;
	}

	msg_len = args->argc * sizeof(u32);

	m = kmalloc(msg_len, GFP_KERNEL);
	if (!m)
		return -ENOMEM;

	m->size = msg_len / 4;
	for (i = 1; i < m->size; i++) {
		if (args->argv[i].type != AUTO_ARG_TYPE_INT32) {
			dev_err(pdata->dev, "Unknown args!\n");
			kfree(m);
			return -1;
		}

		*((s32 *)m + i) = args->argv[i].m_int32;
	}

	ret = rk1608_send_msg_to_dsp(pdata, m);

	dev_info(pdata->dev, "send msg len: %d, ret: %x\n", m->size, ret);

	kfree(m);

	return 0;
}

static int do_cmd_recv_msg(struct rk1608_state *pdata,
			   const struct auto_args *args)
{
	struct msg *m;
	char buf[256] = "";
	int ret = 0;

	ret = rk1608_msq_recv_msg(pdata, pdata->spi, &m);
	if (ret || !m)
		return 0;

	dev_info(pdata->dev, "\nrecv msg len: %d, ret: %x\n", m->size, ret);
	int32_hexdump("recv msg:", (s32 *)m, m->size * 4);

	dev_info(pdata->dev, buf);

	kfree(m);

	return 0;
}

static int do_cmd_power_on(struct rk1608_state *pdata,
			   const struct auto_args *args)
{
	int ret;

	ret = rk1608_set_power(pdata, 1);
	dev_info(pdata->dev, "do cmd power on, count++\n");

	return ret;
}

static int do_cmd_power_off(struct rk1608_state *pdata,
			    const struct auto_args *args)
{
	int ret;

	ret = rk1608_set_power(pdata, 0);
	dev_info(pdata->dev, "do cmd power off, count--\n");

	return ret;
}

static int do_cmd_set_dsp_log_level(struct rk1608_state *pdata,
				    const struct auto_args *args)
{
	int ret;

	if (args->argc != 2 || args->argv[1].type != AUTO_ARG_TYPE_INT32) {
		dev_err(pdata->dev, "Mis or unknown args!\n");
		return -1;
	}

	pdata->log_level = args->argv[1].m_int32;
	ret = rk1608_set_log_level(pdata, pdata->log_level);

	dev_info(pdata->dev, "set dsp log level %d, ret: %d\n",
		 pdata->log_level, ret);

	return ret;
}

static int do_cmd_version(struct rk1608_state *pdata,
			  const struct auto_args *args)
{
	dev_info(pdata->dev, "driver version: v%02x.%02x.%02x\n",
		 RK1608_VERSION >> 16,
		 (RK1608_VERSION & 0xff00) >> 8,
		 RK1608_VERSION & 0x00ff);
	return 0;
}

static int do_cmd_help(struct rk1608_state *pdata)
{
	dev_info(pdata->dev, "\n"
		 "support debug commands:\n"
		 "v            -- rk1608 driver version.\n"
		 "log level    -- set rk1608 log level.\n"
		 "on           -- power count + 1.\n"
		 "off          -- power count - 1.\n"
		 "f [fw_name]  -- download fw.\n"
		 "q            -- query operation status.\n"
		 "r addr [length=32] -- read addr.\n"
		 "w addr value,...   -- write addr.\n"
		 "s type,...         -- send msg.\n"
		 "rate max [min]     -- set spi speed.\n\n");
	return 0;
}

static int do_cmd(struct rk1608_state *pdata, const struct auto_args *args)
{
	const char *s;

	if (args->argv->type != AUTO_ARG_TYPE_STR)
		return 0;

	s = args->argv->m_str;
	/* echo c > /dev/rk_preisp */
	if (!strcmp(s, "c"))
		return do_cmd_recv_msg(pdata, args);
	/* echo f [fw_name] > /dev/rk_preisp */
	if (!strcmp(s, "f"))
		return do_cmd_download_fw(pdata, args);
	/* echo fw reg1 > /dev/rk_preisp */
	if (!strcmp(s, "fw"))
		return do_cmd_fast_write(pdata, args);
	/* echo fr > /dev/rk_preisp */
	if (!strcmp(s, "fr"))
		return do_cmd_fast_read(pdata, args);
	/* echo log level > /dev/rk_preisp */
	if (!strcmp(s, "log"))
		return do_cmd_set_dsp_log_level(pdata, args);
	/* echo on > /dev/rk_preisp */
	if (!strcmp(s, "on"))
		return do_cmd_power_on(pdata, args);
	/* echo off > /dev/rk_preisp */
	if (!strcmp(s, "off"))
		return do_cmd_power_off(pdata, args);
	/* echo q > /dev/rk_preisp */
	if (!strcmp(s, "q"))
		return do_cmd_query(pdata, args);
	/* echo r addr [length] > /dev/rk_preisp */
	if (!strcmp(s, "r"))
		return do_cmd_read(pdata, args);
	/* echo rate > /dev/rk_preisp */
	if (!strcmp(s, "rate"))
		return do_cmd_set_spi_rate(pdata, args);
	/* echo s type,... > /dev/rk_preisp */
	if (!strcmp(s, "s"))
		return do_cmd_send_msg(pdata, args);
	/* echo v > /dev/rk_preisp */
	if (!strcmp(s, "v"))
		return do_cmd_version(pdata, args);
	/* echo w addr value,... > /dev/rk_preisp */
	if (!strcmp(s, "w"))
		return do_cmd_write(pdata, args);

	dev_err(pdata->dev, "unknown commands:%s\n", s);
	do_cmd_help(pdata);

	return 0;
}

static int rk1608_dev_open(struct inode *inode, struct file *file)
{
	struct rk1608_state *pdata =
		container_of(file->private_data, struct rk1608_state, misc);
	struct rk1608_client *client = rk1608_client_new();

	client->private_data = pdata;
	file->private_data = client;

	rk1608_set_power(pdata, 1);

	return 0;
}

static int rk1608_dev_release(struct inode *inode, struct file *file)
{
	struct rk1608_client *client = file->private_data;
	struct rk1608_state *pdata = client->private_data;

	rk1608_client_disconnect(pdata, client);
	rk1608_client_release(client);
	rk1608_set_power(pdata, 0);

	return 0;
}

static ssize_t rk1608_dev_write(struct file *file, const char __user *user_buf,
				size_t count, loff_t *ppos)
{
	char *buf;
	struct auto_args args;
	int i;
	struct rk1608_client *client = file->private_data;
	struct rk1608_state *pdata = client->private_data;

	buf = kmalloc(count + 1, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	if (copy_from_user(buf, user_buf, count))
		return -EFAULT;

	buf[count] = 0;

	i = 0;
	while (buf[i] != 0) {
		int ret = parse_auto_args(buf + i, &args);

		if (ret < 0)
			break;

		i += ret;
		if (args.argc == 0)
			continue;

		do_cmd(pdata, &args);
		free_auto_args(&args);
	}

	kfree(buf);

	return count;
}

static long rk1608_dev_ioctl(struct file *file, unsigned int cmd,
			     unsigned long arg)
{
	int ret = 0;
	void __user *ubuf = (void __user *)arg;
	struct rk1608_client *client = file->private_data;
	struct rk1608_state *pdata = client->private_data;

	switch (cmd) {
	case PREISP_POWER_ON:
		ret = rk1608_set_power(pdata, 1);
		break;
	case PREISP_POWER_OFF:
		ret = rk1608_set_power(pdata, 0);
		break;
	case PREISP_DOWNLOAD_FW: {
		char fw_name[PREISP_FW_NAME_LEN];

		if (strncpy_from_user(fw_name, ubuf, PREISP_FW_NAME_LEN) <= 0) {
			ret = -EFAULT;
			break;
		}
		dev_info(pdata->dev, "download fw:%s\n", fw_name);
		ret = rk1608_download_fw(pdata, pdata->spi, fw_name);
		break;
	}
	case PREISP_WRITE: {
		struct preisp_apb_pkt pkt;
		s32 *data;

		if (copy_from_user(&pkt, ubuf, sizeof(pkt))) {
			ret = -EFAULT;
			break;
		}
		pkt.data_len = MIN(pkt.data_len, RK1608_MAX_OP_BYTES);
		data = memdup_user((void __user *)pkt.data, pkt.data_len);
		if (IS_ERR(data)) {
			ret = (long)ERR_PTR((long)data);
			break;
		}

		ret = rk1608_safe_write(pdata, pdata->spi, pkt.addr, data, pkt.data_len);
		kfree(data);
		break;
	}
	case PREISP_READ: {
		struct preisp_apb_pkt pkt;
		s32 *data;

		if (copy_from_user(&pkt, ubuf, sizeof(pkt))) {
			ret = -EFAULT;
			break;
		}
		pkt.data_len = MIN(pkt.data_len, RK1608_MAX_OP_BYTES);
		data = kmalloc(pkt.data_len, GFP_KERNEL);
		if (!data) {
			ret = -ENOMEM;
			break;
		}

		ret = rk1608_safe_read(pdata, pdata->spi, pkt.addr, data, pkt.data_len);
		if (ret) {
			kfree(data);
			break;
		}
		ret = copy_to_user((void __user *)pkt.data, data, pkt.data_len);

		kfree(data);
		break;
	}
	case PREISP_ST_QUERY: {
		s32 state;

		ret = rk1608_state_query(pdata->spi, &state);
		if (ret)
			break;

		ret = put_user(state, (s32 __user *)ubuf);
		break;
	}
	case PREISP_IRQ_REQUEST: {
		int int_num = arg;

		ret = rk1608_interrupt_request(pdata->spi, int_num);
		break;
	}
	case PREISP_SEND_MSG: {
		struct msg *msg;
		u32 len;

		if (get_user(len, (u32 __user *)ubuf)) {
			ret = -EFAULT;
			break;
		}
		len = len * sizeof(s32);
		msg = memdup_user(ubuf, len);
		if (IS_ERR(msg)) {
			ret = (long)ERR_PTR((long)msg);
			break;
		}

#if DEBUG_DUMP_ALL_SEND_RECV_MSG == 1
		int32_hexdump("send msg:", (s32 *)msg, len);
#endif

		ret = rk1608_send_msg_to_dsp(pdata, msg);
		kfree(msg);
		break;
	}
	case PREISP_QUERY_MSG: {
		struct msg *msg;

		ret = msq_recv_msg(&client->q, &msg);
		if (ret)
			break;

		ret = put_user(msg->size, (u32 __user *)ubuf);
		break;
	}
	case PREISP_RECV_MSG: {
		struct msg *msg;

		ret = msq_recv_msg(&client->q, &msg);
		if (ret)
			break;

		ret = copy_to_user(ubuf, msg, msg->size * sizeof(u32));
		msq_free_received_msg(&client->q, msg);
		break;
	}
	case PREISP_CLIENT_CONNECT: {
		client->id = (int)arg;
		ret = rk1608_client_connect(pdata, client);
		break;
	}
	case PREISP_CLIENT_DISCONNECT: {
		rk1608_client_disconnect(pdata, client);
		client->id = INVALID_ID;
		break;
	}
	default:
		ret = -EFAULT;
		break;
	}

	return ret;
}

#ifdef CONFIG_COMPAT
#define PREISP_WRITE32		_IOW('p', 6, struct preisp_apb_pkt32)
#define PREISP_READ32		_IOR('p', 7, struct preisp_apb_pkt32)

struct preisp_apb_pkt32 {
	s32 data_len;
	s32 addr;
	compat_uptr_t data;
};

static long rk1608_compat_ioctl(struct file *file, unsigned int cmd,
				unsigned long arg)
{
	int ret = 0;
	struct preisp_apb_pkt32 pkt32;
	struct preisp_apb_pkt *pkt;

	switch (cmd) {
	case PREISP_WRITE32:
		cmd = PREISP_WRITE;
		break;
	case PREISP_READ32:
		cmd = PREISP_READ;
		break;
	default:
		break;
	}

	switch (cmd) {
	case PREISP_WRITE:
	case PREISP_READ:
		if (copy_from_user(&pkt32, (void __user *)arg, sizeof(pkt32)))
			return -EFAULT;

		pkt = compat_alloc_user_space(sizeof(*pkt));
		if (!pkt ||
		    put_user(pkt32.data_len, &pkt->data_len) ||
		    put_user(pkt32.addr, &pkt->addr) ||
		    put_user(compat_ptr(pkt32.data), &pkt->data))
			return -EFAULT;

		ret = rk1608_dev_ioctl(file, cmd, (unsigned long)pkt);
		break;
	default:
		ret = rk1608_dev_ioctl(file, cmd, arg);
		break;
	}

	return ret;
}
#endif

static unsigned int rk1608_dev_poll(struct file *file, poll_table *wait)
{
	struct rk1608_client *client = file->private_data;
	unsigned int mask = 0;

	poll_wait(file, &client->wait, wait);

	if (!msq_is_empty(&client->q))
		mask |= POLLIN;

	return mask;
}

static const struct file_operations rk1608_fops = {
	.owner = THIS_MODULE,
	.open = rk1608_dev_open,
	.release = rk1608_dev_release,
	.write = rk1608_dev_write,
	.poll = rk1608_dev_poll,
	.unlocked_ioctl = rk1608_dev_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = rk1608_compat_ioctl,
#endif
};

void rk1608_dev_receive_msg(struct rk1608_state *pdata, struct msg *msg)
{
	struct rk1608_client_list *s = &pdata->clients;
	struct rk1608_client *client;

#if DEBUG_DUMP_ALL_SEND_RECV_MSG == 1
	int32_hexdump("recv msg:", (s32 *)msg, msg->size * 4);
#endif

	mutex_lock(&s->mutex);
	list_for_each_entry(client, &s->list, list) {
		if (client->id == msg->id.camera_id) {
			msq_send_msg(&client->q, msg);
			wake_up_interruptible(&client->wait);
		}
	}
	mutex_unlock(&s->mutex);
}

int rk1608_dev_register(struct rk1608_state *pdata)
{
	int ret;

	rk1608_client_list_init(&pdata->clients);

	pdata->misc.minor = MISC_DYNAMIC_MINOR;
	pdata->misc.name = "rk_preisp";
	pdata->misc.fops = &rk1608_fops;

	ret = misc_register(&pdata->misc);
	if (ret < 0)
		dev_err(pdata->dev, "Error: misc_register returned %d\n", ret);

	return 0;
}

void rk1608_dev_unregister(struct rk1608_state *pdata)
{
	misc_deregister(&pdata->misc);
}