[mirror_ubuntu-bionic-kernel.git] / drivers / rtc / rtc-puv3.c

/*
 * RTC driver code specific to PKUnity SoC and UniCore ISA
 *
 *	Maintained by GUAN Xue-tao <gxt@mprc.pku.edu.cn>
 *	Copyright (C) 2001-2010 Guan Xuetao
 *
 * 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/fs.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/rtc.h>
#include <linux/bcd.h>
#include <linux/clk.h>
#include <linux/log2.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/io.h>

#include <asm/irq.h>
#include <mach/hardware.h>

static struct resource *puv3_rtc_mem;

static int puv3_rtc_alarmno = IRQ_RTCAlarm;
static int puv3_rtc_tickno  = IRQ_RTC;

static DEFINE_SPINLOCK(puv3_rtc_pie_lock);

/* IRQ Handlers */
static irqreturn_t puv3_rtc_alarmirq(int irq, void *id)
{
	struct rtc_device *rdev = id;

	writel(readl(RTC_RTSR) | RTC_RTSR_AL, RTC_RTSR);
	rtc_update_irq(rdev, 1, RTC_AF | RTC_IRQF);
	return IRQ_HANDLED;
}

static irqreturn_t puv3_rtc_tickirq(int irq, void *id)
{
	struct rtc_device *rdev = id;

	writel(readl(RTC_RTSR) | RTC_RTSR_HZ, RTC_RTSR);
	rtc_update_irq(rdev, 1, RTC_PF | RTC_IRQF);
	return IRQ_HANDLED;
}

/* Update control registers */
static void puv3_rtc_setaie(struct device *dev, int to)
{
	unsigned int tmp;

	dev_dbg(dev, "%s: aie=%d\n", __func__, to);

	tmp = readl(RTC_RTSR) & ~RTC_RTSR_ALE;

	if (to)
		tmp |= RTC_RTSR_ALE;

	writel(tmp, RTC_RTSR);
}

static int puv3_rtc_setpie(struct device *dev, int enabled)
{
	unsigned int tmp;

	dev_dbg(dev, "%s: pie=%d\n", __func__, enabled);

	spin_lock_irq(&puv3_rtc_pie_lock);
	tmp = readl(RTC_RTSR) & ~RTC_RTSR_HZE;

	if (enabled)
		tmp |= RTC_RTSR_HZE;

	writel(tmp, RTC_RTSR);
	spin_unlock_irq(&puv3_rtc_pie_lock);

	return 0;
}

/* Time read/write */
static int puv3_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
{
	rtc_time_to_tm(readl(RTC_RCNR), rtc_tm);

	dev_dbg(dev, "read time %02x.%02x.%02x %02x/%02x/%02x\n",
		 rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday,
		 rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec);

	return 0;
}

static int puv3_rtc_settime(struct device *dev, struct rtc_time *tm)
{
	unsigned long rtc_count = 0;

	dev_dbg(dev, "set time %02d.%02d.%02d %02d/%02d/%02d\n",
		 tm->tm_year, tm->tm_mon, tm->tm_mday,
		 tm->tm_hour, tm->tm_min, tm->tm_sec);

	rtc_tm_to_time(tm, &rtc_count);
	writel(rtc_count, RTC_RCNR);

	return 0;
}

static int puv3_rtc_getalarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct rtc_time *alm_tm = &alrm->time;

	rtc_time_to_tm(readl(RTC_RTAR), alm_tm);

	alrm->enabled = readl(RTC_RTSR) & RTC_RTSR_ALE;

	dev_dbg(dev, "read alarm %02x %02x.%02x.%02x %02x/%02x/%02x\n",
		 alrm->enabled,
		 alm_tm->tm_year, alm_tm->tm_mon, alm_tm->tm_mday,
		 alm_tm->tm_hour, alm_tm->tm_min, alm_tm->tm_sec);

	return 0;
}

static int puv3_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	struct rtc_time *tm = &alrm->time;
	unsigned long rtcalarm_count = 0;

	dev_dbg(dev, "puv3_rtc_setalarm: %d, %02x/%02x/%02x %02x.%02x.%02x\n",
		 alrm->enabled,
		 tm->tm_mday & 0xff, tm->tm_mon & 0xff, tm->tm_year & 0xff,
		 tm->tm_hour & 0xff, tm->tm_min & 0xff, tm->tm_sec);

	rtc_tm_to_time(tm, &rtcalarm_count);
	writel(rtcalarm_count, RTC_RTAR);

	puv3_rtc_setaie(dev, alrm->enabled);

	if (alrm->enabled)
		enable_irq_wake(puv3_rtc_alarmno);
	else
		disable_irq_wake(puv3_rtc_alarmno);

	return 0;
}

static int puv3_rtc_proc(struct device *dev, struct seq_file *seq)
{
	seq_printf(seq, "periodic_IRQ\t: %s\n",
		     (readl(RTC_RTSR) & RTC_RTSR_HZE) ? "yes" : "no");
	return 0;
}

static const struct rtc_class_ops puv3_rtcops = {
	.read_time	= puv3_rtc_gettime,
	.set_time	= puv3_rtc_settime,
	.read_alarm	= puv3_rtc_getalarm,
	.set_alarm	= puv3_rtc_setalarm,
	.proc	        = puv3_rtc_proc,
};

static void puv3_rtc_enable(struct device *dev, int en)
{
	if (!en) {
		writel(readl(RTC_RTSR) & ~RTC_RTSR_HZE, RTC_RTSR);
	} else {
		/* re-enable the device, and check it is ok */
		if ((readl(RTC_RTSR) & RTC_RTSR_HZE) == 0) {
			dev_info(dev, "rtc disabled, re-enabling\n");
			writel(readl(RTC_RTSR) | RTC_RTSR_HZE, RTC_RTSR);
		}
	}
}

static int puv3_rtc_remove(struct platform_device *dev)
{
	puv3_rtc_setpie(&dev->dev, 0);
	puv3_rtc_setaie(&dev->dev, 0);

	release_resource(puv3_rtc_mem);
	kfree(puv3_rtc_mem);

	return 0;
}

static int puv3_rtc_probe(struct platform_device *pdev)
{
	struct rtc_device *rtc;
	struct resource *res;
	int ret;

	dev_dbg(&pdev->dev, "%s: probe=%p\n", __func__, pdev);

	/* find the IRQs */
	puv3_rtc_tickno = platform_get_irq(pdev, 1);
	if (puv3_rtc_tickno < 0) {
		dev_err(&pdev->dev, "no irq for rtc tick\n");
		return -ENOENT;
	}

	puv3_rtc_alarmno = platform_get_irq(pdev, 0);
	if (puv3_rtc_alarmno < 0) {
		dev_err(&pdev->dev, "no irq for alarm\n");
		return -ENOENT;
	}

	dev_dbg(&pdev->dev, "PKUnity_rtc: tick irq %d, alarm irq %d\n",
		 puv3_rtc_tickno, puv3_rtc_alarmno);

	rtc = devm_rtc_allocate_device(&pdev->dev);
	if (IS_ERR(rtc))
		return PTR_ERR(rtc);

	ret = devm_request_irq(&pdev->dev, puv3_rtc_alarmno, puv3_rtc_alarmirq,
			       0, "pkunity-rtc alarm", rtc);
	if (ret) {
		dev_err(&pdev->dev, "IRQ%d error %d\n", puv3_rtc_alarmno, ret);
		return ret;
	}

	ret = devm_request_irq(&pdev->dev, puv3_rtc_tickno, puv3_rtc_tickirq,
			       0, "pkunity-rtc tick", rtc);
	if (ret) {
		dev_err(&pdev->dev, "IRQ%d error %d\n", puv3_rtc_tickno, ret);
		return ret;
	}

	/* get the memory region */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (res == NULL) {
		dev_err(&pdev->dev, "failed to get memory region resource\n");
		return -ENOENT;
	}

	puv3_rtc_mem = request_mem_region(res->start, resource_size(res),
					  pdev->name);

	if (puv3_rtc_mem == NULL) {
		dev_err(&pdev->dev, "failed to reserve memory region\n");
		ret = -ENOENT;
		goto err_nores;
	}

	puv3_rtc_enable(&pdev->dev, 1);

	/* register RTC and exit */
	rtc->ops = &puv3_rtcops;
	ret = rtc_register_device(rtc);
	if (ret) {
		dev_err(&pdev->dev, "cannot attach rtc\n");
		goto err_nortc;
	}

	/* platform setup code should have handled this; sigh */
	if (!device_can_wakeup(&pdev->dev))
		device_init_wakeup(&pdev->dev, 1);

	platform_set_drvdata(pdev, rtc);
	return 0;

 err_nortc:
	puv3_rtc_enable(&pdev->dev, 0);
	release_resource(puv3_rtc_mem);

 err_nores:
	return ret;
}

#ifdef CONFIG_PM_SLEEP
static int ticnt_save;

static int puv3_rtc_suspend(struct device *dev)
{
	/* save RTAR for anyone using periodic interrupts */
	ticnt_save = readl(RTC_RTAR);
	puv3_rtc_enable(dev, 0);
	return 0;
}

static int puv3_rtc_resume(struct device *dev)
{
	puv3_rtc_enable(dev, 1);
	writel(ticnt_save, RTC_RTAR);
	return 0;
}
#endif

static SIMPLE_DEV_PM_OPS(puv3_rtc_pm_ops, puv3_rtc_suspend, puv3_rtc_resume);

static struct platform_driver puv3_rtc_driver = {
	.probe		= puv3_rtc_probe,
	.remove		= puv3_rtc_remove,
	.driver		= {
		.name	= "PKUnity-v3-RTC",
		.pm	= &puv3_rtc_pm_ops,
	}
};

module_platform_driver(puv3_rtc_driver);

MODULE_DESCRIPTION("RTC Driver for the PKUnity v3 chip");
MODULE_AUTHOR("Hu Dongliang");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
02b2ee16	1	/*
2809e80b	2	* RTC driver code specific to PKUnity SoC and UniCore ISA
02b2ee16 G	3	*
	4	* Maintained by GUAN Xue-tao <gxt@mprc.pku.edu.cn>
	5	* Copyright (C) 2001-2010 Guan Xuetao
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11
	12	#include <linux/module.h>
	13	#include <linux/fs.h>
	14	#include <linux/string.h>
	15	#include <linux/init.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/interrupt.h>
	18	#include <linux/rtc.h>
	19	#include <linux/bcd.h>
	20	#include <linux/clk.h>
	21	#include <linux/log2.h>
	22	#include <linux/slab.h>
	23	#include <linux/uaccess.h>
	24	#include <linux/io.h>
	25
	26	#include <asm/irq.h>
	27	#include <mach/hardware.h>
	28
	29	static struct resource *puv3_rtc_mem;
	30
	31	static int puv3_rtc_alarmno = IRQ_RTCAlarm;
	32	static int puv3_rtc_tickno = IRQ_RTC;
	33
	34	static DEFINE_SPINLOCK(puv3_rtc_pie_lock);
	35
	36	/* IRQ Handlers */
02b2ee16 G	37	static irqreturn_t puv3_rtc_alarmirq(int irq, void *id)
	38	{
	39	struct rtc_device *rdev = id;
	40
e5abf78b	41	writel(readl(RTC_RTSR) \| RTC_RTSR_AL, RTC_RTSR);
02b2ee16 G	42	rtc_update_irq(rdev, 1, RTC_AF \| RTC_IRQF);
	43	return IRQ_HANDLED;
	44	}
	45
	46	static irqreturn_t puv3_rtc_tickirq(int irq, void *id)
	47	{
	48	struct rtc_device *rdev = id;
	49
e5abf78b	50	writel(readl(RTC_RTSR) \| RTC_RTSR_HZ, RTC_RTSR);
02b2ee16 G	51	rtc_update_irq(rdev, 1, RTC_PF \| RTC_IRQF);
	52	return IRQ_HANDLED;
	53	}
	54
	55	/* Update control registers */
1fbc4c4d	56	static void puv3_rtc_setaie(struct device *dev, int to)
02b2ee16 G	57	{
	58	unsigned int tmp;
	59
1fbc4c4d	60	dev_dbg(dev, "%s: aie=%d\n", __func__, to);
02b2ee16	61
e5abf78b	62	tmp = readl(RTC_RTSR) & ~RTC_RTSR_ALE;
02b2ee16 G	63
	64	if (to)
	65	tmp \|= RTC_RTSR_ALE;
	66
e5abf78b	67	writel(tmp, RTC_RTSR);
02b2ee16 G	68	}
	69
	70	static int puv3_rtc_setpie(struct device *dev, int enabled)
	71	{
	72	unsigned int tmp;
	73
c863810c	74	dev_dbg(dev, "%s: pie=%d\n", __func__, enabled);
02b2ee16 G	75
02b2ee16 G	76	spin_lock_irq(&puv3_rtc_pie_lock);
e5abf78b	77	tmp = readl(RTC_RTSR) & ~RTC_RTSR_HZE;
02b2ee16 G	78
	79	if (enabled)
	80	tmp \|= RTC_RTSR_HZE;
	81
e5abf78b	82	writel(tmp, RTC_RTSR);
02b2ee16 G	83	spin_unlock_irq(&puv3_rtc_pie_lock);
	84
	85	return 0;
	86	}
	87
02b2ee16	88	/* Time read/write */
02b2ee16 G	89	static int puv3_rtc_gettime(struct device dev, struct rtc_time rtc_tm)
02b2ee16 G	90	{
e5abf78b	91	rtc_time_to_tm(readl(RTC_RCNR), rtc_tm);
02b2ee16	92
1fbc4c4d	93	dev_dbg(dev, "read time %02x.%02x.%02x %02x/%02x/%02x\n",
02b2ee16 G	94	rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday,
	95	rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec);
	96
	97	return 0;
	98	}
	99
	100	static int puv3_rtc_settime(struct device dev, struct rtc_time tm)
	101	{
	102	unsigned long rtc_count = 0;
	103
1fbc4c4d	104	dev_dbg(dev, "set time %02d.%02d.%02d %02d/%02d/%02d\n",
02b2ee16 G	105	tm->tm_year, tm->tm_mon, tm->tm_mday,
	106	tm->tm_hour, tm->tm_min, tm->tm_sec);
	107
	108	rtc_tm_to_time(tm, &rtc_count);
e5abf78b	109	writel(rtc_count, RTC_RCNR);
02b2ee16 G	110
	111	return 0;
	112	}
	113
	114	static int puv3_rtc_getalarm(struct device dev, struct rtc_wkalrm alrm)
	115	{
	116	struct rtc_time *alm_tm = &alrm->time;
	117
e5abf78b	118	rtc_time_to_tm(readl(RTC_RTAR), alm_tm);
02b2ee16	119
e5abf78b	120	alrm->enabled = readl(RTC_RTSR) & RTC_RTSR_ALE;
02b2ee16	121
1fbc4c4d	122	dev_dbg(dev, "read alarm %02x %02x.%02x.%02x %02x/%02x/%02x\n",
02b2ee16 G	123	alrm->enabled,
	124	alm_tm->tm_year, alm_tm->tm_mon, alm_tm->tm_mday,
	125	alm_tm->tm_hour, alm_tm->tm_min, alm_tm->tm_sec);
	126
	127	return 0;
	128	}
	129
	130	static int puv3_rtc_setalarm(struct device dev, struct rtc_wkalrm alrm)
	131	{
	132	struct rtc_time *tm = &alrm->time;
	133	unsigned long rtcalarm_count = 0;
	134
1fbc4c4d	135	dev_dbg(dev, "puv3_rtc_setalarm: %d, %02x/%02x/%02x %02x.%02x.%02x\n",
02b2ee16 G	136	alrm->enabled,
	137	tm->tm_mday & 0xff, tm->tm_mon & 0xff, tm->tm_year & 0xff,
	138	tm->tm_hour & 0xff, tm->tm_min & 0xff, tm->tm_sec);
	139
	140	rtc_tm_to_time(tm, &rtcalarm_count);
e5abf78b	141	writel(rtcalarm_count, RTC_RTAR);
02b2ee16	142
73fa5406	143	puv3_rtc_setaie(dev, alrm->enabled);
02b2ee16 G	144
	145	if (alrm->enabled)
	146	enable_irq_wake(puv3_rtc_alarmno);
	147	else
	148	disable_irq_wake(puv3_rtc_alarmno);
	149
	150	return 0;
	151	}
	152
	153	static int puv3_rtc_proc(struct device dev, struct seq_file seq)
	154	{
	155	seq_printf(seq, "periodic_IRQ\t: %s\n",
e5abf78b	156	(readl(RTC_RTSR) & RTC_RTSR_HZE) ? "yes" : "no");
02b2ee16 G	157	return 0;
	158	}
	159
02b2ee16	160	static const struct rtc_class_ops puv3_rtcops = {
02b2ee16 G	161	.read_time = puv3_rtc_gettime,
	162	.set_time = puv3_rtc_settime,
	163	.read_alarm = puv3_rtc_getalarm,
	164	.set_alarm = puv3_rtc_setalarm,
02b2ee16 G	165	.proc = puv3_rtc_proc,
	166	};
	167
5936fdb9	168	static void puv3_rtc_enable(struct device *dev, int en)
02b2ee16 G	169	{
02b2ee16 G	170	if (!en) {
e5abf78b	171	writel(readl(RTC_RTSR) & ~RTC_RTSR_HZE, RTC_RTSR);
02b2ee16 G	172	} else {
02b2ee16 G	173	/* re-enable the device, and check it is ok */
e5abf78b	174	if ((readl(RTC_RTSR) & RTC_RTSR_HZE) == 0) {
5936fdb9	175	dev_info(dev, "rtc disabled, re-enabling\n");
e5abf78b	176	writel(readl(RTC_RTSR) \| RTC_RTSR_HZE, RTC_RTSR);
02b2ee16 G	177	}
	178	}
	179	}
	180
5a167f45	181	static int puv3_rtc_remove(struct platform_device *dev)
02b2ee16	182	{
02b2ee16	183	puv3_rtc_setpie(&dev->dev, 0);
1fbc4c4d	184	puv3_rtc_setaie(&dev->dev, 0);
02b2ee16 G	185
	186	release_resource(puv3_rtc_mem);
	187	kfree(puv3_rtc_mem);
	188
	189	return 0;
	190	}
	191
5a167f45	192	static int puv3_rtc_probe(struct platform_device *pdev)
02b2ee16 G	193	{
	194	struct rtc_device *rtc;
	195	struct resource *res;
	196	int ret;
	197
1fbc4c4d	198	dev_dbg(&pdev->dev, "%s: probe=%p\n", __func__, pdev);
02b2ee16 G	199
02b2ee16 G	200	/* find the IRQs */
02b2ee16 G	201	puv3_rtc_tickno = platform_get_irq(pdev, 1);
	202	if (puv3_rtc_tickno < 0) {
	203	dev_err(&pdev->dev, "no irq for rtc tick\n");
	204	return -ENOENT;
	205	}
	206
	207	puv3_rtc_alarmno = platform_get_irq(pdev, 0);
	208	if (puv3_rtc_alarmno < 0) {
	209	dev_err(&pdev->dev, "no irq for alarm\n");
	210	return -ENOENT;
	211	}
	212
1fbc4c4d	213	dev_dbg(&pdev->dev, "PKUnity_rtc: tick irq %d, alarm irq %d\n",
02b2ee16 G	214	puv3_rtc_tickno, puv3_rtc_alarmno);
02b2ee16 G	215
5539ba54 AB	216	rtc = devm_rtc_allocate_device(&pdev->dev);
	217	if (IS_ERR(rtc))
	218	return PTR_ERR(rtc);
	219
60d34552 AB	220	ret = devm_request_irq(&pdev->dev, puv3_rtc_alarmno, puv3_rtc_alarmirq,
	221	0, "pkunity-rtc alarm", rtc);
	222	if (ret) {
	223	dev_err(&pdev->dev, "IRQ%d error %d\n", puv3_rtc_alarmno, ret);
	224	return ret;
	225	}
	226
	227	ret = devm_request_irq(&pdev->dev, puv3_rtc_tickno, puv3_rtc_tickirq,
	228	0, "pkunity-rtc tick", rtc);
	229	if (ret) {
	230	dev_err(&pdev->dev, "IRQ%d error %d\n", puv3_rtc_tickno, ret);
	231	return ret;
	232	}
	233
02b2ee16	234	/* get the memory region */
02b2ee16 G	235	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	236	if (res == NULL) {
	237	dev_err(&pdev->dev, "failed to get memory region resource\n");
	238	return -ENOENT;
	239	}
	240
28f65c11 JP	241	puv3_rtc_mem = request_mem_region(res->start, resource_size(res),
28f65c11 JP	242	pdev->name);
02b2ee16 G	243
	244	if (puv3_rtc_mem == NULL) {
	245	dev_err(&pdev->dev, "failed to reserve memory region\n");
	246	ret = -ENOENT;
	247	goto err_nores;
	248	}
	249
5936fdb9	250	puv3_rtc_enable(&pdev->dev, 1);
02b2ee16	251
02b2ee16	252	/* register RTC and exit */
5539ba54 AB	253	rtc->ops = &puv3_rtcops;
	254	ret = rtc_register_device(rtc);
	255	if (ret) {
02b2ee16	256	dev_err(&pdev->dev, "cannot attach rtc\n");
02b2ee16 G	257	goto err_nortc;
	258	}
	259
	260	/* platform setup code should have handled this; sigh */
	261	if (!device_can_wakeup(&pdev->dev))
	262	device_init_wakeup(&pdev->dev, 1);
	263
	264	platform_set_drvdata(pdev, rtc);
	265	return 0;
	266
	267	err_nortc:
5936fdb9	268	puv3_rtc_enable(&pdev->dev, 0);
02b2ee16 G	269	release_resource(puv3_rtc_mem);
	270
	271	err_nores:
	272	return ret;
	273	}
	274
5936fdb9	275	#ifdef CONFIG_PM_SLEEP
02b2ee16 G	276	static int ticnt_save;
02b2ee16 G	277
5936fdb9	278	static int puv3_rtc_suspend(struct device *dev)
02b2ee16 G	279	{
02b2ee16 G	280	/* save RTAR for anyone using periodic interrupts */
e5abf78b	281	ticnt_save = readl(RTC_RTAR);
5936fdb9	282	puv3_rtc_enable(dev, 0);
02b2ee16 G	283	return 0;
	284	}
	285
5936fdb9	286	static int puv3_rtc_resume(struct device *dev)
02b2ee16	287	{
5936fdb9	288	puv3_rtc_enable(dev, 1);
e5abf78b	289	writel(ticnt_save, RTC_RTAR);
02b2ee16 G	290	return 0;
02b2ee16 G	291	}
02b2ee16 G	292	#endif
02b2ee16 G	293
5936fdb9 JH	294	static SIMPLE_DEV_PM_OPS(puv3_rtc_pm_ops, puv3_rtc_suspend, puv3_rtc_resume);
5936fdb9 JH	295
b3a0aa3a	296	static struct platform_driver puv3_rtc_driver = {
02b2ee16	297	.probe = puv3_rtc_probe,
5a167f45	298	.remove = puv3_rtc_remove,
02b2ee16 G	299	.driver = {
02b2ee16 G	300	.name = "PKUnity-v3-RTC",
5936fdb9	301	.pm = &puv3_rtc_pm_ops,
02b2ee16 G	302	}
	303	};
	304
b3a0aa3a	305	module_platform_driver(puv3_rtc_driver);
02b2ee16 G	306
	307	MODULE_DESCRIPTION("RTC Driver for the PKUnity v3 chip");
	308	MODULE_AUTHOR("Hu Dongliang");
	309	MODULE_LICENSE("GPL v2");