/*
|
* drivers/media/tsc/tscdrv.c
|
* (C) Copyright 2010-2015
|
* Allwinner Technology Co., Ltd. <www.allwinnertech.com>
|
* csjamesdeng <csjamesdeng@allwinnertech.com>
|
*
|
* This program is free software; you can redistribute it and/or
|
* modify it under the terms of the GNU General Public License as
|
* published by the Free Software Foundation; either version 2 of
|
* the License, or (at your option) any later version.
|
*
|
*/
|
#include <linux/init.h>
|
#include <linux/ioctl.h>
|
#include <linux/fs.h>
|
#include <linux/err.h>
|
#include <linux/list.h>
|
#include <linux/device.h>
|
#include <linux/kernel.h>
|
#include <linux/dma-mapping.h>
|
#include <linux/interrupt.h>
|
#include <linux/pinctrl/consumer.h>
|
#include <linux/clk.h>
|
#include <linux/cdev.h>
|
#include <linux/rmap.h>
|
#include <linux/poll.h>
|
#include <linux/module.h>
|
#include <asm-generic/gpio.h>
|
#include <asm/current.h>
|
//#include <linux/sys_config.h>
|
#include <linux/platform_device.h>
|
#include <linux/clk/sunxi.h>
|
//#include <linux/clk-private.h>
|
#include "dvb_drv_sunxi.h"
|
#include "tscdrv.h"
|
#include <asm/io.h>
|
#include <linux/mm.h>
|
#include <linux/of.h>
|
#include <linux/of_address.h>
|
#include <linux/of_irq.h>
|
#include <linux/pinctrl/pinctrl.h>
|
#include <linux/pinctrl/consumer.h>
|
//#include <linux/pinctrl/pinconf-sunxi.h>
|
|
#define TSC_MSG(fmt, arg...) pr_warn("[tsc]: "fmt, ##arg)
|
#define TSC_DBG(fmt, arg...) \
|
pr_debug("[tsc]: %s()%d - "fmt, __func__, __LINE__, ##arg)
|
#define TSC_ERR(fmt, arg...) \
|
pr_warn("[tsc]: %s()%d - "fmt, __func__, __LINE__, ##arg)
|
#define TSC_INFO(fmt, arg...) \
|
pr_warn("[tsc]: %s()%d - "fmt, __func__, __LINE__, ##arg)
|
|
static struct tsc_dev *tsc_devp;
|
static struct of_device_id sunxi_tsc_match[] = {
|
{ .compatible = "allwinner,sun8i-tsc",},
|
{ .compatible = "allwinner,sun50i-tsc",},
|
{}
|
};
|
|
#define TSC_MODULE_CLK_RATE 120000000
|
|
MODULE_DEVICE_TABLE(of, sunxi_tsc_match);
|
|
static DECLARE_WAIT_QUEUE_HEAD(wait_proc);
|
|
int sunxi_tsc_enable_hw_clk(void)
|
{
|
unsigned long flags;
|
int ret = 0;
|
|
spin_lock_irqsave(&tsc_devp->lock, flags);
|
if (clk_prepare_enable(tsc_devp->mclk)) {
|
TSC_MSG("enable mclk failed.\n");
|
ret = -EFAULT;
|
goto enable_out;
|
}
|
enable_out:
|
spin_unlock_irqrestore(&tsc_devp->lock, flags);
|
return ret;
|
}
|
|
int sunxi_tsc_disable_hw_clk(void)
|
{
|
unsigned long flags;
|
int ret = 0;
|
|
spin_lock_irqsave(&tsc_devp->lock, flags);
|
if ((NULL == tsc_devp->mclk)
|
|| (IS_ERR(tsc_devp->mclk))) {
|
TSC_MSG("mclk is invalid!\n");
|
ret = -EFAULT;
|
} else {
|
clk_disable_unprepare(tsc_devp->mclk);
|
}
|
|
spin_unlock_irqrestore(&tsc_devp->lock, flags);
|
return ret;
|
}
|
|
/*
|
* interrupt service routine
|
* To wake up wait queue
|
*/
|
static irqreturn_t sunxi_tsc_irq_handle(int irq, void *dev_id)
|
{
|
struct iomap_para addrs = tsc_devp->iomap_addrs;
|
unsigned long tsc_int_status_reg;
|
unsigned long tsc_int_ctrl_reg;
|
unsigned int tsc_status;
|
unsigned int tsc_interrupt_enable;
|
|
tsc_int_ctrl_reg = (unsigned long)(addrs.regs_macc + 0x80 + 0x08);
|
tsc_int_status_reg = (unsigned long)(addrs.regs_macc + 0x80 + 0x18);
|
tsc_interrupt_enable = ioread32((void *)(tsc_int_ctrl_reg));
|
tsc_status = ioread32((void *)(tsc_int_status_reg));
|
iowrite32(tsc_interrupt_enable, (void *)(tsc_int_ctrl_reg));
|
iowrite32(tsc_status, (void *)(tsc_int_status_reg));
|
tsc_devp->irq_flag = 1;
|
wake_up_interruptible(&wait_proc);
|
|
return IRQ_HANDLED;
|
}
|
|
static void sunxi_tsc_close_all_filters(struct tsc_dev *devp)
|
{
|
int i;
|
unsigned int value = 0;
|
struct iomap_para addrs = tsc_devp->iomap_addrs;
|
|
/*close tsf0*/
|
iowrite32(0, (void *)(addrs.regs_macc + 0x80 + 0x10));
|
iowrite32(0, (void *)(addrs.regs_macc + 0x80 + 0x30));
|
for (i = 0; i < 32; i++) {
|
iowrite32(i, (void *)(addrs.regs_macc + 0x80 + 0x3c));
|
value = (0<<16 | 0x1fff);
|
iowrite32(value, (void *)(addrs.regs_macc + 0x80 + 0x4c));
|
}
|
}
|
|
static int sunxi_tsc_select_gpio_state(struct pinctrl *pctrl, char *name)
|
{
|
int ret = 0;
|
struct pinctrl_state *pctrl_state = NULL;
|
|
pctrl_state = pinctrl_lookup_state(pctrl, name);
|
if (IS_ERR(pctrl_state)) {
|
TSC_MSG("pinctrl lookup state(%s) failed!\n", name);
|
return -1;
|
}
|
|
ret = pinctrl_select_state(pctrl, pctrl_state);
|
if (ret < 0)
|
TSC_MSG("pintrcl select state(%s) failed\n", name);
|
|
return ret;
|
}
|
|
|
static int sunxi_tsc_request_gpio(struct platform_device *pdev)
|
{
|
int ret = 0;
|
#ifdef CONFIG_ARCH_SUN50IW2
|
if ((tsc_devp->port_config.port0config &&
|
tsc_devp->port_config.port1config)
|
|| (tsc_devp->port_config.port2config &&
|
tsc_devp->port_config.port3config)) {
|
TSC_MSG("port config error!\n");
|
return -EINVAL;
|
}
|
#endif
|
if (tsc_devp->port_config.port0config
|
|| tsc_devp->port_config.port1config
|
|| tsc_devp->port_config.port2config
|
|| tsc_devp->port_config.port3config) {
|
if (!tsc_devp->pinctrl) {
|
tsc_devp->pinctrl = devm_pinctrl_get(&pdev->dev);
|
if (IS_ERR_OR_NULL(tsc_devp->pinctrl)) {
|
TSC_MSG("request pinctrl handle failed!\n");
|
return -EINVAL;
|
}
|
}
|
}
|
if (tsc_devp->port_config.port0config) {
|
ret = sunxi_tsc_select_gpio_state(tsc_devp->pinctrl,
|
"ts0-default");
|
if (ret)
|
TSC_MSG("set gpio default err!\n");
|
}
|
if (tsc_devp->port_config.port1config) {
|
ret = sunxi_tsc_select_gpio_state(tsc_devp->pinctrl,
|
"ts1-default");
|
if (ret)
|
TSC_MSG("set gpio default err!\n");
|
}
|
if (tsc_devp->port_config.port2config) {
|
ret = sunxi_tsc_select_gpio_state(tsc_devp->pinctrl,
|
"ts2-default");
|
if (ret)
|
TSC_MSG("set gpio default err!\n");
|
}
|
if (tsc_devp->port_config.port3config) {
|
ret = sunxi_tsc_select_gpio_state(tsc_devp->pinctrl,
|
"ts3-default");
|
if (ret)
|
TSC_MSG("set gpio default err!\n");
|
}
|
|
return ret;
|
}
|
|
static void sunxi_tsc_release_gpio(void)
|
{
|
devm_pinctrl_put(tsc_devp->pinctrl);
|
tsc_devp->pinctrl = NULL;
|
}
|
|
static int sunxi_tsc_disable_gpio(void)
|
{
|
int ret = 0;
|
if (tsc_devp->port_config.port0config) {
|
ret = sunxi_tsc_select_gpio_state(tsc_devp->pinctrl,
|
"ts0-sleep");
|
if (ret) {
|
TSC_ERR("select sleep state failed!\n");
|
return ret;
|
}
|
}
|
if (tsc_devp->port_config.port1config) {
|
ret = sunxi_tsc_select_gpio_state(tsc_devp->pinctrl,
|
"ts1-sleep");
|
if (ret) {
|
TSC_ERR("select sleep state failed!\n");
|
return ret;
|
}
|
}
|
if (tsc_devp->port_config.port2config) {
|
ret = sunxi_tsc_select_gpio_state(tsc_devp->pinctrl,
|
"ts2-sleep");
|
if (ret) {
|
TSC_ERR("select sleep state failed!\n");
|
return ret;
|
}
|
|
}
|
if (tsc_devp->port_config.port3config) {
|
ret = sunxi_tsc_select_gpio_state(tsc_devp->pinctrl,
|
"ts3-sleep");
|
if (ret) {
|
TSC_ERR("select sleep state failed!\n");
|
return ret;
|
}
|
|
}
|
return ret;
|
}
|
|
static int sunxi_tsc_hw_clk_init(struct platform_device *pdev)
|
{
|
struct device_node *node;
|
unsigned int mclk_rate;
|
int ret = 0;
|
|
node = pdev->dev.of_node;
|
tsc_devp->pclk = of_clk_get(node, 0);
|
if ((!tsc_devp->pclk) || IS_ERR(tsc_devp->pclk)) {
|
TSC_MSG("try to get parent pll clk failed!\n");
|
ret = -EINVAL;
|
return ret;
|
}
|
tsc_devp->mclk = of_clk_get(node, 1);
|
if (!tsc_devp->mclk || IS_ERR(tsc_devp->mclk)) {
|
TSC_MSG("get mclk failed.\n");
|
ret = -EINVAL;
|
return ret;
|
}
|
ret = of_property_read_u32(pdev->dev.of_node, "clock-frequency",
|
&mclk_rate);
|
if (ret) {
|
TSC_MSG("don't set clock-frequency by dts\n");
|
mclk_rate = TSC_MODULE_CLK_RATE;
|
}
|
/* reset tsc module. */
|
sunxi_periph_reset_assert(tsc_devp->mclk);
|
clk_set_parent(tsc_devp->mclk, tsc_devp->pclk);
|
|
if (clk_set_rate(tsc_devp->mclk, mclk_rate) < 0) {
|
TSC_MSG("set clk rate failed\n");
|
ret = -EINVAL;
|
}
|
TSC_MSG("set clock rate is %ld\n", clk_get_rate(tsc_devp->mclk));
|
|
if (clk_prepare_enable(tsc_devp->mclk)) {
|
TSC_MSG("enable moudule clock failed\n");
|
return -EBUSY;
|
}
|
|
return clk_get_rate(tsc_devp->mclk);
|
}
|
|
|
static int sunxi_tsc_get_port_config(struct platform_device *pdev)
|
{
|
int ret = 0;
|
unsigned int temp_val = 0;
|
struct device_node *node;
|
|
node = pdev->dev.of_node;
|
ret = of_property_read_u32(node, "ts0config", &temp_val);
|
if (ret < 0) {
|
TSC_MSG("ts0config missing or invalid.\n");
|
tsc_devp->port_config.port0config = 0;
|
} else {
|
tsc_devp->port_config.port0config = temp_val;
|
}
|
ret = of_property_read_u32(node, "ts1config", &temp_val);
|
if (ret < 0) {
|
TSC_MSG("ts1config missing or invalid.\n");
|
tsc_devp->port_config.port1config = 0;
|
} else {
|
tsc_devp->port_config.port1config = temp_val;
|
}
|
ret = of_property_read_u32(node, "ts2config", &temp_val);
|
if (ret < 0) {
|
TSC_MSG("ts2config missing or invalid.\n");
|
tsc_devp->port_config.port2config = 0;
|
} else {
|
tsc_devp->port_config.port2config = temp_val;
|
}
|
ret = of_property_read_u32(node, "ts3config", &temp_val);
|
if (ret < 0) {
|
TSC_MSG("ts3config missing or invalid.\n");
|
tsc_devp->port_config.port3config = 0;
|
} else {
|
tsc_devp->port_config.port3config = temp_val;
|
}
|
|
if (tsc_devp->port_config.port0config ||
|
tsc_devp->port_config.port1config ||
|
tsc_devp->port_config.port2config ||
|
tsc_devp->port_config.port3config)
|
return 0;
|
else
|
return -EINVAL;
|
}
|
/*
|
* poll operateion for wait for TS irq
|
*/
|
unsigned int tscdev_poll(struct file *filp, struct poll_table_struct *wait)
|
{
|
int mask = 0;
|
|
poll_wait(filp, &tsc_devp->wq, wait);
|
if (tsc_devp->irq_flag == 1)
|
mask |= POLLIN | POLLRDNORM;
|
return mask;
|
}
|
|
/*
|
* ioctl function
|
*/
|
long tscdev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
|
{
|
long ret;
|
struct intrstatus statusdata;
|
int arg_rate = (int)arg;
|
unsigned long tsc_pclk_rate;
|
|
ret = 0;
|
if (_IOC_TYPE(cmd) != TSCDEV_IOC_MAGIC)
|
return -EINVAL;
|
if (_IOC_NR(cmd) > TSCDEV_IOC_MAXNR)
|
return -EINVAL;
|
|
switch (cmd) {
|
case TSCDEV_WAIT_INT:
|
ret = wait_event_interruptible_timeout(wait_proc,
|
tsc_devp->irq_flag, HZ * 1);
|
if (!ret && !tsc_devp->irq_flag) {
|
/* case: wait timeout. */
|
TSC_MSG("wait interrupt timeout.\n");
|
memset(&statusdata, 0, sizeof(statusdata));
|
} else {
|
/* case: interrupt occured. */
|
tsc_devp->irq_flag = 0;
|
statusdata.port0chan = tsc_devp->intstatus.port0chan;
|
statusdata.port0pcr = tsc_devp->intstatus.port0pcr;
|
}
|
/* copy status data to user. */
|
if (copy_to_user((struct intrstatus *)arg,
|
&(tsc_devp->intstatus),
|
sizeof(struct intrstatus))) {
|
return -EFAULT;
|
}
|
break;
|
|
case TSCDEV_GET_PHYSICS:
|
return 0;
|
|
case TSCDEV_ENABLE_INT:
|
enable_irq(tsc_devp->irq);
|
break;
|
|
case TSCDEV_DISABLE_INT:
|
tsc_devp->irq_flag = 1;
|
wake_up_interruptible(&wait_proc);
|
disable_irq(tsc_devp->irq);
|
break;
|
|
case TSCDEV_RELEASE_SEM:
|
tsc_devp->irq_flag = 1;
|
wake_up_interruptible(&wait_proc);
|
break;
|
|
case TSCDEV_GET_CLK:
|
if (!tsc_devp->mclk || IS_ERR(tsc_devp->mclk)) {
|
TSC_MSG("get tsc clk failed.\n");
|
ret = -EINVAL;
|
}
|
break;
|
|
case TSCDEV_PUT_CLK:
|
|
clk_put(tsc_devp->mclk);
|
|
break;
|
|
case TSCDEV_ENABLE_CLK:
|
/* clk_prepare_enable(tsc_devp->mclk); */
|
ret = sunxi_tsc_enable_hw_clk();
|
if (ret < 0) {
|
TSC_ERR("tsc clk enable failed!\n");
|
return -EFAULT;
|
}
|
break;
|
|
case TSCDEV_DISABLE_CLK:
|
/* clk_disable_unprepare(tsc_devp->mclk); */
|
ret = sunxi_tsc_disable_hw_clk();
|
if (ret < 0) {
|
TSC_ERR("tsc clk disable failed!\n");
|
}
|
break;
|
|
case TSCDEV_GET_CLK_FREQ:
|
ret = clk_get_rate(tsc_devp->mclk);
|
break;
|
|
case TSCDEV_SET_SRC_CLK_FREQ:
|
writel(0x1, tsc_devp->iomap_addrs.regs_macc);
|
break;
|
|
case TSCDEV_SET_CLK_FREQ:
|
if (clk_get_rate(tsc_devp->mclk)/1000000 != arg_rate) {
|
if (!clk_set_rate(tsc_devp->pclk, arg_rate*1000000)) {
|
tsc_pclk_rate = clk_get_rate(tsc_devp->pclk);
|
if (clk_set_rate(tsc_devp->mclk, tsc_pclk_rate))
|
TSC_MSG("set tsc clock failed!\n");
|
} else
|
TSC_MSG("set pll4 clock failed!\n");
|
}
|
ret = clk_get_rate(tsc_devp->mclk);
|
break;
|
|
default:
|
TSC_MSG("invalid cmd!\n");
|
ret = -EINVAL;
|
break;
|
}
|
|
return ret;
|
}
|
|
static int tscdev_open(struct inode *inode, struct file *filp)
|
{
|
/* unsigned long clk_rate; */
|
if (down_interruptible(&tsc_devp->sem)) {
|
TSC_MSG("down interruptible failed!\n");
|
return -ERESTARTSYS;
|
}
|
/* init other resource here */
|
tsc_devp->irq_flag = 0;
|
up(&tsc_devp->sem);
|
nonseekable_open(inode, filp);
|
return 0;
|
}
|
|
static int tscdev_release(struct inode *inode, struct file *filp)
|
{
|
if (down_interruptible(&tsc_devp->sem))
|
return -ERESTARTSYS;
|
sunxi_tsc_close_all_filters(tsc_devp);
|
/* release other resource here */
|
tsc_devp->irq_flag = 1;
|
up(&tsc_devp->sem);
|
return 0;
|
}
|
|
void tscdev_vma_open(struct vm_area_struct *vma)
|
{
|
TSC_INFO();
|
}
|
|
void tscdev_vma_close(struct vm_area_struct *vma)
|
{
|
TSC_INFO();
|
}
|
|
static struct vm_operations_struct tscdev_remap_vm_ops = {
|
.open = tscdev_vma_open,
|
.close = tscdev_vma_close,
|
};
|
|
static int tscdev_mmap(struct file *filp, struct vm_area_struct *vma)
|
{
|
unsigned long temp_pfn;
|
|
if (vma->vm_end - vma->vm_start == 0) {
|
TSC_MSG("vm_end is equal vm_start : %lx\n", vma->vm_start);
|
return 0;
|
}
|
if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT)) {
|
TSC_MSG(
|
"vm_pgoff is %lx,it is large than the largest page number\n",
|
vma->vm_pgoff);
|
return -EINVAL;
|
}
|
temp_pfn = tsc_devp->mapbase >> 12;
|
/* Set reserved and I/O flag for the area. */
|
vma->vm_flags |= /*VM_RESERVED | */VM_IO;
|
/* Select uncached access. */
|
vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
|
if (io_remap_pfn_range(vma, vma->vm_start, temp_pfn,
|
(vma->vm_end - vma->vm_start), vma->vm_page_prot)) {
|
return -EAGAIN;
|
}
|
vma->vm_ops = &tscdev_remap_vm_ops;
|
tscdev_vma_open(vma);
|
return 0;
|
}
|
|
|
static struct file_operations tscdev_fops = {
|
.owner = THIS_MODULE,
|
.mmap = tscdev_mmap,
|
.poll = tscdev_poll,
|
.open = tscdev_open,
|
.release = tscdev_release,
|
.llseek = no_llseek,
|
.unlocked_ioctl = tscdev_ioctl,
|
};
|
|
static int tscdev_init(struct platform_device *pdev)
|
{
|
int ret = 0;
|
int devno;
|
struct device_node *node;
|
struct resource *mem_res;
|
dev_t dev;
|
|
dev = 0;
|
node = pdev->dev.of_node;
|
|
tsc_devp = kmalloc(sizeof(struct tsc_dev), GFP_KERNEL);
|
if (tsc_devp == NULL) {
|
TSC_MSG("malloc mem for tsc device err\n");
|
ret = -ENOMEM;
|
goto error0;
|
}
|
memset(tsc_devp, 0, sizeof(struct tsc_dev));
|
/* register or alloc the device number. */
|
tsc_devp->major = TSCDEV_MAJOR;
|
tsc_devp->minor = TSCDEV_MINOR;
|
if (tsc_devp->major) {
|
dev = MKDEV(tsc_devp->major, tsc_devp->minor);
|
ret = register_chrdev_region(dev, 1, "ts0");
|
} else {
|
ret = alloc_chrdev_region(&dev, tsc_devp->minor, 1, "ts0");
|
tsc_devp->major = MAJOR(dev);
|
tsc_devp->minor = MINOR(dev);
|
}
|
if (ret < 0) {
|
TSC_MSG("ts0: can't get major: %d.\n", tsc_devp->major);
|
ret = -EINVAL;
|
goto error0;
|
}
|
spin_lock_init(&tsc_devp->lock);
|
|
|
printk("[tsc] %s() - %d \n", __func__, __LINE__);
|
/* get physical address */
|
mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
if (mem_res == NULL) {
|
TSC_MSG("get memory resource failed\n");
|
ret = -ENOMEM;
|
goto error0;
|
}
|
tsc_devp->mapbase = mem_res->start;
|
|
tsc_devp->irq = irq_of_parse_and_map(node, 0);
|
if (tsc_devp->irq <= 0) {
|
TSC_MSG("can not parse irq.\n");
|
ret = -EINVAL;
|
goto error0;
|
}
|
|
printk("[tsc] %s() - %d \n", __func__, __LINE__);
|
sema_init(&tsc_devp->sem, 1);
|
init_waitqueue_head(&tsc_devp->wq);
|
memset(&tsc_devp->iomap_addrs, 0, sizeof(struct iomap_para));
|
ret = request_irq(tsc_devp->irq, sunxi_tsc_irq_handle, 0, "ts0", NULL);
|
if (ret < 0) {
|
TSC_MSG("request irq err\n");
|
ret = -EINVAL;
|
goto error0;
|
}
|
/* map for macc io space */
|
tsc_devp->iomap_addrs.regs_macc = of_iomap(node, 0);
|
if (!tsc_devp->iomap_addrs.regs_macc) {
|
TSC_MSG("tsc can't map registers.\n");
|
ret = -EINVAL;
|
goto error0;
|
}
|
/* init tsc hw clk */
|
sunxi_tsc_hw_clk_init(pdev);
|
/* Create char device */
|
devno = MKDEV(tsc_devp->major, tsc_devp->minor);
|
cdev_init(&tsc_devp->cdev, &tscdev_fops);
|
tsc_devp->cdev.owner = THIS_MODULE;
|
ret = cdev_add(&tsc_devp->cdev, devno, 1);
|
if (ret) {
|
TSC_MSG("err:%d add tscdev.", ret);
|
ret = -EINVAL;
|
goto error0;
|
}
|
tsc_devp->tsc_class = class_create(THIS_MODULE, "ts0");
|
tsc_devp->dev = device_create(tsc_devp->tsc_class, NULL, devno, NULL, "ts0");
|
|
if (sunxi_tsc_get_port_config(pdev) < 0) {
|
TSC_ERR("get tsc port config failed!\n");
|
ret = -EINVAL;
|
goto error0;
|
}
|
|
if (sunxi_tsc_request_gpio(pdev)) {
|
TSC_ERR("request tsc pio failed!\n");
|
ret = -EINVAL;
|
goto error0;
|
}
|
|
printk("[tsc] %s() - %d \n", __func__, __LINE__);
|
TSC_MSG("init succussful\n");
|
return 0;
|
|
error0:
|
if (tsc_devp) {
|
kfree(tsc_devp);
|
tsc_devp = NULL;
|
}
|
return ret;
|
}
|
|
static void tscdev_exit(void)
|
{
|
dev_t dev;
|
int ret = 0;
|
|
dev = MKDEV(tsc_devp->major, tsc_devp->minor);
|
free_irq(tsc_devp->irq, NULL);
|
iounmap(tsc_devp->iomap_addrs.regs_macc);
|
/* Destroy char device */
|
if (tsc_devp) {
|
cdev_del(&tsc_devp->cdev);
|
device_destroy(tsc_devp->tsc_class, dev);
|
class_destroy(tsc_devp->tsc_class);
|
}
|
if (NULL == tsc_devp->mclk
|
|| IS_ERR(tsc_devp->mclk)) {
|
TSC_MSG("mclk handle is invalid.\n");
|
} else {
|
/* clk_disable_unprepare(tsc_devp->mclk); */
|
ret = sunxi_tsc_disable_hw_clk();
|
if (ret < 0) {
|
TSC_ERR("tsc clk disable failed.\n");
|
}
|
clk_put(tsc_devp->mclk);
|
tsc_devp->mclk = NULL;
|
}
|
if (NULL == tsc_devp->pclk
|
|| IS_ERR(tsc_devp->pclk)) {
|
TSC_MSG("parent pll clk handle is invalid.\n");
|
} else {
|
clk_put(tsc_devp->pclk);
|
}
|
/* release ts pin */
|
sunxi_tsc_disable_gpio();
|
sunxi_tsc_release_gpio();
|
unregister_chrdev_region(dev, 1);
|
if (tsc_devp) {
|
kfree(tsc_devp);
|
tsc_devp = NULL;
|
}
|
}
|
|
|
#ifdef CONFIG_PM
|
static int sw_tsc_suspend(struct platform_device *pdev, pm_message_t state)
|
{
|
int ret = 0;
|
|
ret = sunxi_tsc_disable_gpio();
|
if (ret < 0) {
|
TSC_MSG("tsc release gpio failed!\n");
|
return -EFAULT;
|
}
|
ret = sunxi_tsc_disable_hw_clk();
|
if (ret < 0) {
|
TSC_ERR("tsc clk disable failed!\n");
|
return -EFAULT;
|
}
|
TSC_MSG("standby suspend succeed!\n");
|
return 0;
|
}
|
static int sw_tsc_resume(struct platform_device *pdev)
|
{
|
int ret = 0;
|
|
ret = sunxi_tsc_enable_hw_clk();
|
if (ret < 0) {
|
TSC_ERR("tsc clk enable failed!\n");
|
return -EFAULT;
|
}
|
ret = sunxi_tsc_request_gpio(pdev);
|
if (ret < 0) {
|
TSC_ERR("request tsc pio failed!\n");
|
return -EFAULT;
|
}
|
TSC_MSG("standby resume succeed!\n");
|
return 0;
|
}
|
#endif
|
|
static int sunxi_tsc_remove(struct platform_device *pdev)
|
{
|
tscdev_exit();
|
return 0;
|
}
|
|
static int sunxi_tsc_probe(struct platform_device *pdev)
|
{
|
printk("[tsc] %s() - %d \n", __func__, __LINE__);
|
tscdev_init(pdev);
|
return 0;
|
}
|
|
static struct platform_driver sunxi_tsc_driver = {
|
.probe = sunxi_tsc_probe,
|
.remove = sunxi_tsc_remove,
|
#ifdef CONFIG_PM
|
.suspend = sw_tsc_suspend,
|
.resume = sw_tsc_resume,
|
#endif
|
.driver = {
|
.name = "ts0",
|
.owner = THIS_MODULE,
|
.of_match_table = sunxi_tsc_match,
|
},
|
};
|
|
static int __init sunxi_tsc_init(void)
|
|
{
|
int ret;
|
ret = platform_driver_register(&sunxi_tsc_driver);
|
return ret;
|
}
|
|
static void __exit sunxi_tsc_exit(void)
|
{
|
platform_driver_unregister(&sunxi_tsc_driver);
|
}
|
|
module_init(sunxi_tsc_init);
|
module_exit(sunxi_tsc_exit);
|
MODULE_AUTHOR("Soft-Reuuimlla");
|
MODULE_DESCRIPTION("User mode tsc device interface");
|
MODULE_LICENSE("GPL");
|
MODULE_VERSION(DRV_VERSION);
|
MODULE_ALIAS("platform:tsc-sunxi");
|
