drivers/ccic/max77705_debug.c - LeafOS-Devices/android_kernel_samsung_exynos9820 - Gitiles

 /*
  * Copyright (c) 2017 Maxim Integrated Products, Inc.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */

 #include <linux/module.h>
 #include <linux/device.h>
 #include <linux/miscdevice.h>
 #include <linux/i2c.h>
 #include <linux/stat.h>
 #include <linux/slab.h>
 #include <linux/fs.h>
 #include <linux/delay.h>
 #include <linux/uaccess.h>

 #ifdef CONFIG_COMPAT
 #include <linux/compat.h>
 #endif /* CONFIG_COMPAT */

 #include <linux/ccic/max77705_debug.h>

 #define DEBUG_MXIM
 #ifdef DEBUG_MXIM
 #define msg_maxim(format, args...) \
 pr_info("[MXIM] %s: " format "\n", __func__, ## args)
 #else
 #define msg_maxim(format, args...)
 #endif /* DEBUG_MXIM */

 struct mxim_debug_registers mxim_debug_reg[] = {
 	{
 		.reg = MXIM_REG_UIC_HW_REV,
 		.val = 0,
 		.ignore = 0,
 	},
 	{
 		.reg = MXIM_REG_UIC_FW_REV,
 		.val = 0,
 		.ignore = 0,
 	},
 	{
 		.reg = MXIM_REG_USBC_IRQ,
 		.val = 0,
 		.ignore = 1,
 	},
 	{
 		.reg = MXIM_REG_CC_IRQ,
 		.val = 0,
 		.ignore = 1,
 	},
 	{
 		.reg = MXIM_REG_PD_IRQ,
 		.val = 0,
 		.ignore = 1,
 	},
 	{
 		.reg = MXIM_REG_RSVD1,
 		.val = 0,
 		.ignore = 0,
 	},
 	{
 		.reg = MXIM_REG_USBC_STATUS1,
 		.val = 0,
 		.ignore = 0,
 	},
 	{
 		.reg = MXIM_REG_USBC_STATUS2,
 		.val = 0,
 		.ignore = 0,
 	},
 	{
 		.reg = MXIM_REG_BC_STATUS,
 		.val = 0,
 		.ignore = 0,
 	},
 	{
 		.reg = MXIM_REG_RSVD2,
 		.val = 0,
 		.ignore = 0,
 	},
 	{
 		.reg = MXIM_REG_CC_STATUS1,
 		.val = 0,
 		.ignore = 0,
 	},
 	{
 		.reg = MXIM_REG_CC_STATUS2,
 		.val = 0,
 		.ignore = 0,
 	},
 	{
 		.reg = MXIM_REG_PD_STATUS1,
 		.val = 0,
 		.ignore = 0,
 	},
 	{
 		.reg = MXIM_REG_PD_STATUS2,
 		.val = 0,
 		.ignore = 0,
 	},
 	{
 		.reg = MXIM_REG_USBC_IRQM,
 		.val = 0,
 		.ignore = 0,
 	},
 	{
 		.reg = MXIM_REG_CC_IRQM,
 		.val = 0,
 		.ignore = 0,
 	},
 	{
 		.reg = MXIM_REG_PD_IRQM,
 		.val = 0,
 		.ignore = 0,
 	},
 };

 struct mxim_debug_pdev *mxim_pdev;

 inline int mxim_debug_i2c_burst_write(unsigned char command,
 		unsigned char length, unsigned char *value)
 {
 	int ret;

 	/* Max length 32 bytes */
 	ret = i2c_smbus_write_i2c_block_data(mxim_pdev->client,
 			command, length, value);
 	if (ret < 0)
 		msg_maxim("Failed to write as burst mode");

 	return ret;
 }

 inline int mxim_debug_i2c_write(unsigned char command,
 		unsigned char value)
 {
 	if (!mxim_pdev)
 		return -ENXIO;

 	if (mxim_pdev->client == NULL)
 		return -ENXIO;

 	return i2c_smbus_write_byte_data(mxim_pdev->client,
 			command, value);
 }

 static int mxim_debug_i2c_burst_read(unsigned char command,
 		unsigned char length, unsigned char *value)
 {
 	int ret;

 	/* Max length 32 bytes */
 	ret = i2c_smbus_read_i2c_block_data(mxim_pdev->client,
 			command, length, value);
 	if (ret < 0)
 		msg_maxim("Failed to read as burst mode");

 	return ret;
 }

 static int mxim_debug_i2c_read(unsigned char reg,
 		unsigned char *value)
 {
 	int ret = 0;

 	if (!mxim_pdev)
 		return -ENXIO;

 	if (mxim_pdev->client == NULL)
 		return -ENXIO;

 	ret = i2c_smbus_read_byte_data(mxim_pdev->client, reg);
 	if (ret < 0) {
 		msg_maxim("Failed to read [reg:%02x]. ret=%d",
 				reg, ret);
 	}

 	*value = ret;

 	return ret;
 }

 static ssize_t mxim_debug_reg_show(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	unsigned char token[12] = { 0, };
 	unsigned char dump[12 * (MXIM_REG_MAX + 1)] = { 0, };
 	int index;

 	sprintf(token, "reg   val\n");
 	strcat(dump, token);
 	for (index = 0; index < MXIM_REG_MAX; index++) {
 		if (mxim_debug_reg[index].ignore)
 			continue;
 		memset(token, 0x00, sizeof(token));
 		mxim_debug_i2c_read(mxim_debug_reg[index].reg,
 				&mxim_debug_reg[index].val);
 		sprintf(token, "0x%02x  0x%02x\n",
 				mxim_debug_reg[index].reg,
 				mxim_debug_reg[index].val);
 		strcat(dump, token);
 	}

 	return sprintf(buf, "%s", dump);
 }

 static ssize_t mxim_debug_reg_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t size)
 {
 	unsigned int reg = 0;
 	unsigned int value = 0;
 	unsigned char prev = 0;
 	unsigned char curr = 0;
 	int ret;

 	ret = sscanf(buf, "%x%x", &reg, &value);
 	if (!ret) {
 		msg_maxim("Failed to convert user data");
 		goto error;
 	}

 	mxim_debug_i2c_read((unsigned char)reg, &prev);
 	mxim_debug_i2c_write((unsigned char)reg, (unsigned char)value);
 	mxim_debug_i2c_read((unsigned char)reg, &curr);

 error:
 	return size;
 }

 static DEVICE_ATTR(reg, 0664,
 		mxim_debug_reg_show, mxim_debug_reg_store);

 static ssize_t mxim_debug_opcode_show(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	unsigned char data[OPCODE_READ_MAX_LENGTH] = { 0, };
 	unsigned char dummy = 0x00;
 	char data_str[OPCODE_READ_MAX_LENGTH * 5 + 1] = { 0, };
 	char dummy_str[5 + 1] = { 0, }; /* add null character */
 	int index = 0;

 	for (index = 0; index < OPCODE_READ_MAX_LENGTH; index++) {
 		data[index] = mxim_debug_i2c_read(
 				OPCODE_READ_START_ADDR + index,
 				&dummy);
 		sprintf(dummy_str, "0x%02x ", data[index]);
 		strcat(data_str, dummy_str);
 	}

 	return sprintf(buf, "%s\n", data_str);
 }

 static ssize_t mxim_debug_opcode_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t size)
 {
 	unsigned int data[OPCODE_WRITE_MAX_LENGTH] = { 0, };
 	int index;
 	int ret;

 	ret = sscanf(buf,
 			"%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x",
 			&data[0], /* AP_DATAOUT0 */
 			&data[1], &data[2], &data[3], &data[4],
 			&data[5], &data[6], &data[7], &data[8],
 			&data[9], &data[10], &data[11], &data[12],
 			&data[13], &data[14], &data[15], &data[16],
 			&data[17], &data[18], &data[19], &data[20],
 			&data[21], &data[22], &data[23], &data[24],
 			&data[25], &data[26], &data[27], &data[28],
 			&data[29], &data[30], &data[31], &data[32]);
 	if (!ret) {
 		msg_maxim("Failed to convert user data");
 		goto error;
 	}

 	for (index = 0; index < OPCODE_WRITE_MAX_LENGTH; index++)
 		mxim_debug_i2c_write(OPCODE_WRITE_START_ADDR + index,
 				(unsigned char)data[index]);

 error:
 	return size;
 }

 static DEVICE_ATTR(opcode, 0664,
 		mxim_debug_opcode_show, mxim_debug_opcode_store);

 static struct attribute *mxim_debug_attr[] = {
 	&dev_attr_opcode.attr,
 	&dev_attr_reg.attr,
 	NULL,
 };

 static struct attribute_group mxim_debug_attr_grp = {
 	.attrs = mxim_debug_attr,
 };

 static int mxim_debug_open(struct inode *inode, struct file *filep)
 {
 	return 0;
 }

 static long mxim_debug_ioctl_handler(struct file *file,
 		unsigned int cmd, unsigned int arg,
 		void __user *argp)
 {
 	unsigned char reg = 0;
 	unsigned char val = 0;
 	int ret = -EINVAL;

 	mutex_lock(&mxim_pdev->lock);

 	switch (cmd) {
 	case MXIM_DEBUG_OPCODE_WRITE:
 		/* copy wdata from user */
 		if (copy_from_user(mxim_pdev->opcode_wdata,
 				argp, OPCODE_WRITE_MAX_LENGTH)) {
 			msg_maxim("Failed to copy data buffer from user");
 			ret = -EFAULT;
 			goto error;
 		}

 		/* OPCode */
 		mxim_debug_i2c_write(OPCODE_WRITE_START_ADDR,
 				mxim_pdev->opcode_wdata[0]);

 		/* AP OUT Data */
 		ret = mxim_debug_i2c_burst_write(OPCODE_WRITE_START_ADDR + 1,
 				(OPCODE_WRITE_MAX_LENGTH - 1),
 				&mxim_pdev->opcode_wdata[1]);
 		break;
 	case MXIM_DEBUG_OPCODE_READ:
 		/* OPCode */
 		mxim_debug_i2c_read(OPCODE_READ_START_ADDR,
 				&mxim_pdev->opcode_rdata[0]);

 		/* AP IN Data */
 		ret = mxim_debug_i2c_burst_read(OPCODE_READ_START_ADDR + 1,
 				(OPCODE_READ_MAX_LENGTH - 1),
 				&mxim_pdev->opcode_rdata[1]);

 		/* copy rdata to user */
 		if (copy_to_user(argp, mxim_pdev->opcode_rdata,
 					OPCODE_READ_MAX_LENGTH)) {
 			msg_maxim("Failed to copy data buffer to user");
 			ret = -EFAULT;
 			goto error;
 		}
 		break;
 	case MXIM_DEBUG_REG_WRITE:
 		reg = (unsigned char)(arg & 0x000000FF);
 		val = (unsigned char)((arg & 0x0000FF00) >> 8);
 		ret = mxim_debug_i2c_write(reg, val);
 		break;
 	case MXIM_DEBUG_REG_READ:
 		reg = (unsigned int)(arg & 0x000000FF);
 		mxim_debug_i2c_read(reg, &val);
 		ret = val;
 		if (copy_to_user(argp, &val, sizeof(val)))
 			goto error;
 		break;
 	case MXIM_DEBUG_REG_DUMP:
 		break;
 	default:
 		break;
 	}
 error:
 	mutex_unlock(&mxim_pdev->lock);
 	return ret;
 }

 static long mxim_debug_ioctl(struct file *file,
 		unsigned int cmd, unsigned long arg)
 {
 	return mxim_debug_ioctl_handler(file, cmd, arg,
 			(void __user *)arg);
 }

 #ifdef CONFIG_COMPAT
 static long mxim_debug_compat_ioctl(struct file *file,
 		unsigned int cmd, unsigned long arg)
 {
 	return mxim_debug_ioctl_handler(file, cmd, arg,
 			(void __user *)(unsigned long)arg);
 }
 #endif

 static ssize_t mxim_debug_read(struct file *filep, char __user *buf,
 		size_t count, loff_t *ppos)
 {
 	int ret = 0;

 	if (!mxim_pdev)
 		goto error;

 	ret = copy_to_user(buf, mxim_pdev->opcode_rdata,
 			count > OPCODE_READ_MAX_LENGTH ?
 			OPCODE_READ_MAX_LENGTH : count);
 	if (ret)
 		msg_maxim("Failed to copy user buffer");

 error:
 	return ret;
 }

 static ssize_t mxim_debug_write(struct file *filep, const char __user *buf,
 		size_t count, loff_t *ppos)
 {
 	int ret = 0;

 	if (!mxim_pdev)
 		goto error;

 	if (copy_from_user(mxim_pdev->opcode_wdata, buf,
 				OPCODE_READ_MAX_LENGTH)) {
 		msg_maxim("Failed to copy user buffer");
 		goto error;
 	}

 error:
 	return ret;
 }

 void mxim_debug_set_i2c_client(struct i2c_client *client)
 {
 	if (mxim_pdev) {
 		mxim_pdev->client = client;
 		msg_maxim("Set i2c_client. %pK", mxim_pdev->client);
 	} else
 		msg_maxim("Failed to set i2c_client.");
 }
 EXPORT_SYMBOL_GPL(mxim_debug_set_i2c_client);

 static const struct file_operations mxim_debug_fops = {
 	.owner			= THIS_MODULE,
 	.open			= mxim_debug_open,
 	.release		= NULL,
 	.unlocked_ioctl = mxim_debug_ioctl,
 #ifdef CONFIG_COMPAT
 	.compat_ioctl	= mxim_debug_compat_ioctl,
 #endif /* CONFIG_COMPAT */
 	.read			= mxim_debug_read,
 	.write			= mxim_debug_write,
 	.mmap			= NULL,
 	.poll			= NULL,
 	.fasync			= NULL,
 	.llseek			= NULL,
 };
 static struct miscdevice mxim_debug_miscdev = {
 	.minor = MISC_DYNAMIC_MINOR,
 	.name = "mxim_dev",
 	.fops = &mxim_debug_fops,
 };

 void mxim_debug_exit(void)
 {
 	if (mxim_pdev) {
 		mutex_destroy(&mxim_pdev->lock);
 		sysfs_remove_group(&mxim_pdev->dev->kobj, &mxim_debug_attr_grp);
 		device_destroy(mxim_pdev->class, 1);
 		class_destroy(mxim_pdev->class);
 		kfree(mxim_pdev);
 		mxim_pdev = NULL;
 	}

 	misc_deregister(&mxim_debug_miscdev);
 }
 EXPORT_SYMBOL_GPL(mxim_debug_exit);

 int mxim_debug_init(void)
 {
 	struct mxim_debug_pdev *pdev;
 	int ret;

 	ret = misc_register(&mxim_debug_miscdev);
 	if (ret) {
 		msg_maxim("Failed to register miscdevice");
 		goto error;
 	}

 	pdev = kzalloc(sizeof(struct mxim_debug_pdev), GFP_KERNEL);
 	if (!pdev) {
 		msg_maxim("Failed to allocate memory");
 		ret = -ENOMEM;
 		goto error;
 	}

 	mxim_pdev = pdev;

 	mutex_init(&pdev->lock);

 	pdev->class = class_create(THIS_MODULE, "mxim");
 	if (pdev->class) {
 		pdev->dev = device_create(pdev->class, NULL, 1, NULL, "debug0");
 		if (!IS_ERR(pdev->dev)) {
 			if (sysfs_create_group(&pdev->dev->kobj,
 						&mxim_debug_attr_grp))
 				msg_maxim("Failed to create sysfs group. %d",
 						ret);
 		}
 	}

 error:
 	return ret;
 }
 EXPORT_SYMBOL_GPL(mxim_debug_init);

 MODULE_DESCRIPTION("MAXIM Debug Module");
 MODULE_LICENSE("GPL");
	/*
	* Copyright (c) 2017 Maxim Integrated Products, Inc.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 as
	* published by the Free Software Foundation.
	*/

	#include <linux/module.h>
	#include <linux/device.h>
	#include <linux/miscdevice.h>
	#include <linux/i2c.h>
	#include <linux/stat.h>
	#include <linux/slab.h>
	#include <linux/fs.h>
	#include <linux/delay.h>
	#include <linux/uaccess.h>

	#ifdef CONFIG_COMPAT
	#include <linux/compat.h>
	#endif /* CONFIG_COMPAT */

	#include <linux/ccic/max77705_debug.h>

	#define DEBUG_MXIM
	#ifdef DEBUG_MXIM
	#define msg_maxim(format, args...) \
	pr_info("[MXIM] %s: " format "\n", __func__, ## args)
	#else
	#define msg_maxim(format, args...)
	#endif /* DEBUG_MXIM */

	struct mxim_debug_registers mxim_debug_reg[] = {
	{
	.reg = MXIM_REG_UIC_HW_REV,
	.val = 0,
	.ignore = 0,
	},
	{
	.reg = MXIM_REG_UIC_FW_REV,
	.val = 0,
	.ignore = 0,
	},
	{
	.reg = MXIM_REG_USBC_IRQ,
	.val = 0,
	.ignore = 1,
	},
	{
	.reg = MXIM_REG_CC_IRQ,
	.val = 0,
	.ignore = 1,
	},
	{
	.reg = MXIM_REG_PD_IRQ,
	.val = 0,
	.ignore = 1,
	},
	{
	.reg = MXIM_REG_RSVD1,
	.val = 0,
	.ignore = 0,
	},
	{
	.reg = MXIM_REG_USBC_STATUS1,
	.val = 0,
	.ignore = 0,
	},
	{
	.reg = MXIM_REG_USBC_STATUS2,
	.val = 0,
	.ignore = 0,
	},
	{
	.reg = MXIM_REG_BC_STATUS,
	.val = 0,
	.ignore = 0,
	},
	{
	.reg = MXIM_REG_RSVD2,
	.val = 0,
	.ignore = 0,
	},
	{
	.reg = MXIM_REG_CC_STATUS1,
	.val = 0,
	.ignore = 0,
	},
	{
	.reg = MXIM_REG_CC_STATUS2,
	.val = 0,
	.ignore = 0,
	},
	{
	.reg = MXIM_REG_PD_STATUS1,
	.val = 0,
	.ignore = 0,
	},
	{
	.reg = MXIM_REG_PD_STATUS2,
	.val = 0,
	.ignore = 0,
	},
	{
	.reg = MXIM_REG_USBC_IRQM,
	.val = 0,
	.ignore = 0,
	},
	{
	.reg = MXIM_REG_CC_IRQM,
	.val = 0,
	.ignore = 0,
	},
	{
	.reg = MXIM_REG_PD_IRQM,
	.val = 0,
	.ignore = 0,
	},
	};

	struct mxim_debug_pdev *mxim_pdev;

	inline int mxim_debug_i2c_burst_write(unsigned char command,
	unsigned char length, unsigned char *value)
	{
	int ret;

	/* Max length 32 bytes */
	ret = i2c_smbus_write_i2c_block_data(mxim_pdev->client,
	command, length, value);
	if (ret < 0)
	msg_maxim("Failed to write as burst mode");

	return ret;
	}

	inline int mxim_debug_i2c_write(unsigned char command,
	unsigned char value)
	{
	if (!mxim_pdev)
	return -ENXIO;

	if (mxim_pdev->client == NULL)
	return -ENXIO;

	return i2c_smbus_write_byte_data(mxim_pdev->client,
	command, value);
	}

	static int mxim_debug_i2c_burst_read(unsigned char command,
	unsigned char length, unsigned char *value)
	{
	int ret;

	/* Max length 32 bytes */
	ret = i2c_smbus_read_i2c_block_data(mxim_pdev->client,
	command, length, value);
	if (ret < 0)
	msg_maxim("Failed to read as burst mode");

	return ret;
	}

	static int mxim_debug_i2c_read(unsigned char reg,
	unsigned char *value)
	{
	int ret = 0;

	if (!mxim_pdev)
	return -ENXIO;

	if (mxim_pdev->client == NULL)
	return -ENXIO;

	ret = i2c_smbus_read_byte_data(mxim_pdev->client, reg);
	if (ret < 0) {
	msg_maxim("Failed to read [reg:%02x]. ret=%d",
	reg, ret);
	}

	*value = ret;

	return ret;
	}

	static ssize_t mxim_debug_reg_show(struct device *dev,
	struct device_attribute attr, char buf)
	{
	unsigned char token[12] = { 0, };
	unsigned char dump[12 * (MXIM_REG_MAX + 1)] = { 0, };
	int index;

	sprintf(token, "reg val\n");
	strcat(dump, token);
	for (index = 0; index < MXIM_REG_MAX; index++) {
	if (mxim_debug_reg[index].ignore)
	continue;
	memset(token, 0x00, sizeof(token));
	mxim_debug_i2c_read(mxim_debug_reg[index].reg,
	&mxim_debug_reg[index].val);
	sprintf(token, "0x%02x 0x%02x\n",
	mxim_debug_reg[index].reg,
	mxim_debug_reg[index].val);
	strcat(dump, token);
	}

	return sprintf(buf, "%s", dump);
	}

	static ssize_t mxim_debug_reg_store(struct device *dev,
	struct device_attribute attr, const char buf, size_t size)
	{
	unsigned int reg = 0;
	unsigned int value = 0;
	unsigned char prev = 0;
	unsigned char curr = 0;
	int ret;

	ret = sscanf(buf, "%x%x", &reg, &value);
	if (!ret) {
	msg_maxim("Failed to convert user data");
	goto error;
	}

	mxim_debug_i2c_read((unsigned char)reg, &prev);
	mxim_debug_i2c_write((unsigned char)reg, (unsigned char)value);
	mxim_debug_i2c_read((unsigned char)reg, &curr);

	error:
	return size;
	}

	static DEVICE_ATTR(reg, 0664,
	mxim_debug_reg_show, mxim_debug_reg_store);

	static ssize_t mxim_debug_opcode_show(struct device *dev,
	struct device_attribute attr, char buf)
	{
	unsigned char data[OPCODE_READ_MAX_LENGTH] = { 0, };
	unsigned char dummy = 0x00;
	char data_str[OPCODE_READ_MAX_LENGTH * 5 + 1] = { 0, };
	char dummy_str[5 + 1] = { 0, }; /* add null character */
	int index = 0;

	for (index = 0; index < OPCODE_READ_MAX_LENGTH; index++) {
	data[index] = mxim_debug_i2c_read(
	OPCODE_READ_START_ADDR + index,
	&dummy);
	sprintf(dummy_str, "0x%02x ", data[index]);
	strcat(data_str, dummy_str);
	}

	return sprintf(buf, "%s\n", data_str);
	}

	static ssize_t mxim_debug_opcode_store(struct device *dev,
	struct device_attribute attr, const char buf, size_t size)
	{
	unsigned int data[OPCODE_WRITE_MAX_LENGTH] = { 0, };
	int index;
	int ret;

	ret = sscanf(buf,
	"%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x",
	&data[0], /* AP_DATAOUT0 */
	&data[1], &data[2], &data[3], &data[4],
	&data[5], &data[6], &data[7], &data[8],
	&data[9], &data[10], &data[11], &data[12],
	&data[13], &data[14], &data[15], &data[16],
	&data[17], &data[18], &data[19], &data[20],
	&data[21], &data[22], &data[23], &data[24],
	&data[25], &data[26], &data[27], &data[28],
	&data[29], &data[30], &data[31], &data[32]);
	if (!ret) {
	msg_maxim("Failed to convert user data");
	goto error;
	}

	for (index = 0; index < OPCODE_WRITE_MAX_LENGTH; index++)
	mxim_debug_i2c_write(OPCODE_WRITE_START_ADDR + index,
	(unsigned char)data[index]);

	error:
	return size;
	}

	static DEVICE_ATTR(opcode, 0664,
	mxim_debug_opcode_show, mxim_debug_opcode_store);

	static struct attribute *mxim_debug_attr[] = {
	&dev_attr_opcode.attr,
	&dev_attr_reg.attr,
	NULL,
	};

	static struct attribute_group mxim_debug_attr_grp = {
	.attrs = mxim_debug_attr,
	};

	static int mxim_debug_open(struct inode inode, struct file filep)
	{
	return 0;
	}

	static long mxim_debug_ioctl_handler(struct file *file,
	unsigned int cmd, unsigned int arg,
	void __user *argp)
	{
	unsigned char reg = 0;
	unsigned char val = 0;
	int ret = -EINVAL;

	mutex_lock(&mxim_pdev->lock);

	switch (cmd) {
	case MXIM_DEBUG_OPCODE_WRITE:
	/* copy wdata from user */
	if (copy_from_user(mxim_pdev->opcode_wdata,
	argp, OPCODE_WRITE_MAX_LENGTH)) {
	msg_maxim("Failed to copy data buffer from user");
	ret = -EFAULT;
	goto error;
	}

	/* OPCode */
	mxim_debug_i2c_write(OPCODE_WRITE_START_ADDR,
	mxim_pdev->opcode_wdata[0]);

	/* AP OUT Data */
	ret = mxim_debug_i2c_burst_write(OPCODE_WRITE_START_ADDR + 1,
	(OPCODE_WRITE_MAX_LENGTH - 1),
	&mxim_pdev->opcode_wdata[1]);
	break;
	case MXIM_DEBUG_OPCODE_READ:
	/* OPCode */
	mxim_debug_i2c_read(OPCODE_READ_START_ADDR,
	&mxim_pdev->opcode_rdata[0]);

	/* AP IN Data */
	ret = mxim_debug_i2c_burst_read(OPCODE_READ_START_ADDR + 1,
	(OPCODE_READ_MAX_LENGTH - 1),
	&mxim_pdev->opcode_rdata[1]);

	/* copy rdata to user */
	if (copy_to_user(argp, mxim_pdev->opcode_rdata,
	OPCODE_READ_MAX_LENGTH)) {
	msg_maxim("Failed to copy data buffer to user");
	ret = -EFAULT;
	goto error;
	}
	break;
	case MXIM_DEBUG_REG_WRITE:
	reg = (unsigned char)(arg & 0x000000FF);
	val = (unsigned char)((arg & 0x0000FF00) >> 8);
	ret = mxim_debug_i2c_write(reg, val);
	break;
	case MXIM_DEBUG_REG_READ:
	reg = (unsigned int)(arg & 0x000000FF);
	mxim_debug_i2c_read(reg, &val);
	ret = val;
	if (copy_to_user(argp, &val, sizeof(val)))
	goto error;
	break;
	case MXIM_DEBUG_REG_DUMP:
	break;
	default:
	break;
	}
	error:
	mutex_unlock(&mxim_pdev->lock);
	return ret;
	}

	static long mxim_debug_ioctl(struct file *file,
	unsigned int cmd, unsigned long arg)
	{
	return mxim_debug_ioctl_handler(file, cmd, arg,
	(void __user *)arg);
	}

	#ifdef CONFIG_COMPAT
	static long mxim_debug_compat_ioctl(struct file *file,
	unsigned int cmd, unsigned long arg)
	{
	return mxim_debug_ioctl_handler(file, cmd, arg,
	(void __user *)(unsigned long)arg);
	}
	#endif

	static ssize_t mxim_debug_read(struct file filep, char __user buf,
	size_t count, loff_t *ppos)
	{
	int ret = 0;

	if (!mxim_pdev)
	goto error;

	ret = copy_to_user(buf, mxim_pdev->opcode_rdata,
	count > OPCODE_READ_MAX_LENGTH ?
	OPCODE_READ_MAX_LENGTH : count);
	if (ret)
	msg_maxim("Failed to copy user buffer");

	error:
	return ret;
	}

	static ssize_t mxim_debug_write(struct file filep, const char __user buf,
	size_t count, loff_t *ppos)
	{
	int ret = 0;

	if (!mxim_pdev)
	goto error;

	if (copy_from_user(mxim_pdev->opcode_wdata, buf,
	OPCODE_READ_MAX_LENGTH)) {
	msg_maxim("Failed to copy user buffer");
	goto error;
	}

	error:
	return ret;
	}

	void mxim_debug_set_i2c_client(struct i2c_client *client)
	{
	if (mxim_pdev) {
	mxim_pdev->client = client;
	msg_maxim("Set i2c_client. %pK", mxim_pdev->client);
	} else
	msg_maxim("Failed to set i2c_client.");
	}
	EXPORT_SYMBOL_GPL(mxim_debug_set_i2c_client);

	static const struct file_operations mxim_debug_fops = {
	.owner = THIS_MODULE,
	.open = mxim_debug_open,
	.release = NULL,
	.unlocked_ioctl = mxim_debug_ioctl,
	#ifdef CONFIG_COMPAT
	.compat_ioctl = mxim_debug_compat_ioctl,
	#endif /* CONFIG_COMPAT */
	.read = mxim_debug_read,
	.write = mxim_debug_write,
	.mmap = NULL,
	.poll = NULL,
	.fasync = NULL,
	.llseek = NULL,
	};
	static struct miscdevice mxim_debug_miscdev = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "mxim_dev",
	.fops = &mxim_debug_fops,
	};

	void mxim_debug_exit(void)
	{
	if (mxim_pdev) {
	mutex_destroy(&mxim_pdev->lock);
	sysfs_remove_group(&mxim_pdev->dev->kobj, &mxim_debug_attr_grp);
	device_destroy(mxim_pdev->class, 1);
	class_destroy(mxim_pdev->class);
	kfree(mxim_pdev);
	mxim_pdev = NULL;
	}

	misc_deregister(&mxim_debug_miscdev);
	}
	EXPORT_SYMBOL_GPL(mxim_debug_exit);

	int mxim_debug_init(void)
	{
	struct mxim_debug_pdev *pdev;
	int ret;

	ret = misc_register(&mxim_debug_miscdev);
	if (ret) {
	msg_maxim("Failed to register miscdevice");
	goto error;
	}

	pdev = kzalloc(sizeof(struct mxim_debug_pdev), GFP_KERNEL);
	if (!pdev) {
	msg_maxim("Failed to allocate memory");
	ret = -ENOMEM;
	goto error;
	}

	mxim_pdev = pdev;

	mutex_init(&pdev->lock);

	pdev->class = class_create(THIS_MODULE, "mxim");
	if (pdev->class) {
	pdev->dev = device_create(pdev->class, NULL, 1, NULL, "debug0");
	if (!IS_ERR(pdev->dev)) {
	if (sysfs_create_group(&pdev->dev->kobj,
	&mxim_debug_attr_grp))
	msg_maxim("Failed to create sysfs group. %d",
	ret);
	}
	}

	error:
	return ret;
	}
	EXPORT_SYMBOL_GPL(mxim_debug_init);

	MODULE_DESCRIPTION("MAXIM Debug Module");
	MODULE_LICENSE("GPL");