#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/spi/spi.h>
#include <linux/module.h>

MODULE_LICENSE("GPL");

static const struct of_device_id tlc5615_ids[] = {
	{ .compatible = "ti,tlc5615" },
	{},
};

static const struct spi_device_id tlc5615_id[] = {
	{"tlc5615", 0},
	{},
};
MODULE_DEVICE_TABLE(spi, tlc5615_id);

static int tlc5615_probe(struct spi_device *spi);
static int tlc5615_remove(struct spi_device *spi);
static struct spi_driver tlc5615_driver = {
	.driver = {
		.owner = THIS_MODULE,
		.name = "tlc5615",
		.of_match_table = of_match_ptr(tlc5615_ids),
	},
	.probe = tlc5615_probe,
	.remove = tlc5615_remove,
	.id_table = tlc5615_id
};
module_spi_driver(tlc5615_driver);

#define TLC_DEVICE_NAME "tlc5615"
static uint tlc_major = 0;
static struct class *tlc_class = NULL;

int tlc5615_open(struct inode *inode, struct file *filp);
ssize_t tlc5615_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_ops);

struct file_operations tlc5615_fops = {
	.owner = THIS_MODULE,
	.write = tlc5615_write,
	.open = tlc5615_open,
};

struct tlc5615 {
	struct mutex lock;       // avoid spi implict
	struct spi_device *spi;  // used when sending data.
	struct cdev cdev;        // per-device data
	struct device* dev;
};

struct spi_message msg = {0, };
struct spi_transfer xfer = {0, };
struct tlc5615 *dac;
uint16_t tx_data = 0x0000;  // initial DAC value
int err;
int devno;

/* spi device settings */
spi->mode = SPI_MODE_0;
spi->max_speed_hz = 10000000;
spi->bits_per_word = 8;
err = spi_setup(spi);
if(err<0) return err;

/* transfer contents */
xfer.tx_nbits = 1;
xfer.tx_buf = &tx_data;
xfer.bits_per_word = 8;
xfer.len = 2;
xfer.speed_hz = 10000000;
spi_message_init(&msg);
spi_message_add_tail(&xfer, &msg);
if((err = spi_sync(spi, &msg))<0) return -EFAULT;

/* device data setup */
dac = devm_kzalloc(&spi->dev, sizeof(struct tlc5615), GFP_KERNEL);
if(dac == NULL)return -ENOMEM;
dac->spi = spi;

/* chrdev setup */
err = alloc_chrdev_region(&devno, 0, 1, TLC_DEVICE_NAME);
if(err<0)return err;        
tlc_major = MAJOR(devno);

tlc_class = class_create(THIS_MODULE, TLC_DEVICE_NAME);
if(IS_ERR(tlc_class)) return PTR_ERR(tlc_class);

cdev_init(&dac->cdev, &tlc5615_fops);
dac->cdev.owner = THIS_MODULE;
err = cdev_add(&dac->cdev, devno, 1);
if(err){
    /* destroy assigned class */
    class_destroy(tlc_class);   
    return err;
}

dac->dev = device_create(tlc_class, NULL, devno, NULL, "tlc5615");
if(IS_ERR(dac->dev)){
    cdev_del(&dac->cdev);
    class_destroy(tlc_class);
    return PTR_ERR(dac->dev);
}
/* set device data to driver. */
spi_set_drvdata(spi, dac);
return 0;	

struct tlc5615 *dac = spi_get_drvdata(spi);
device_del(dac->dev);
cdev_del(&dac->cdev);
class_destroy(tlc_class);
unregister_chrdev_region(MKDEV(tlc_major, 0), 1);
mutex_destroy(&dac->lock);
return 0;

filp->private_data = container_of(inode->i_cdev, struct tlc5615, cdev);
return 0;

struct tlc5615 *dac = filp->private_data;
struct spi_transfer xfer = {0, };
struct spi_message msg = {0, };
uint16_t* buffer;
int i;
/* 10bits DAC, padding to 16bits */
if(count % 2)return -EINVAL;
/* alloc space for operating */
buffer = kmalloc(count, GFP_KERNEL);
if(buffer == NULL)return -ENOMEM;
/* move data to kernel space */
if(copy_from_user(buffer, buf, count)!=0){
    kfree(buffer);
    return -EFAULT;
} 
/* fit chip's data format */
for(i = 0; i < (count << 1); i++){
    buffer[i] = __builtin_bswap16((buffer[i] & 0x3ff) << 2);
}
/* transfer */
xfer.tx_buf = buffer;
xfer.len = count;
xfer.bits_per_word = 8;
xfer.speed_hz = 10000000;
spi_message_init(&msg);
spi_message_add_tail(&xfer, &msg);
i = spi_sync(dac->spi, &msg);

/* cleanup and return. */
kfree(buffer);
if(i < 0)return i;
return count;