static unsigned int s3c_adc_get_value(int channel, int prescaler, int delay)
{
int i = 5000;
unsigned long ctrl, val;
ctrl = S3C_ADCCON_PRSCEN | S3C_ADCCON_PRSCVL(prescaler);
writel(ctrl, base_addr + S3C_ADCCON);
writel((delay & 0xffff), base_addr + S3C_ADCDLY);
writel((channel & 0x000f), base_addr + S3C_ADCMUX);
ctrl |= S3C_ADCCON_RESSEL_12BIT;
writel(ctrl, base_addr + S3C_ADCCON);
//start adc
ctrl |= S3C_ADCCON_ENABLE_START;
writel(ctrl, base_addr + S3C_ADCCON);
//wait for adc done
do {
val = readl(base_addr + S3C_ADCCON);
} while (i-- > 0 && !(val & S3C_ADCCON_ECFLG));
val = readl(base_addr + S3C_ADCDAT0);
ctrl |= S3C_ADCCON_STDBM;
ctrl &= ~(S3C_ADCCON_PRSCEN | S3C_ADCCON_ENABLE_START);
writel(ctrl, base_addr + S3C_ADCCON);
return (val & S3C_ADCDAT0_XPDATA_MASK_12BIT);
}
void s5p_adc_setup(void)
{
//delay = 10000,
//presc = 49,
//resolution = 12,
writel(S3C_ADCCON_PRSCEN | S3C_ADCCON_PRSCVL(ADC_PRESC),
base_addr + S3C_ADCCON);
writel(ADC_DELAY, base_addr + S3C_ADCDLY);
writel(readl(base_addr + S3C_ADCCON) |S3C_ADCCON_RESSEL_12BIT,
base_addr + S3C_ADCCON);
writel((readl(base_addr + S3C_ADCCON) | S3C_ADCCON_STDBM) &
~S3C_ADCCON_PRSCEN, base_addr + S3C_ADCCON);
}
static int __init s3c_adc_probe(struct platform_device *pdev)
{
struct resource *res;
struct device *dev;
int ret;
int size;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
dev = &pdev->dev;
if(res == NULL){
dev_err(dev,"no memory resource specified\n");
return -ENOENT;
}
size = (res->end - res->start) + 1;
#ifndef ADC_WITH_TOUCHSCREEN
adc_mem = request_mem_region(res->start, size, pdev->name);
if(adc_mem == NULL){
dev_err(dev, "failed to get memory region\n");
ret = -ENOENT;
goto err_req;
}
#endif
base_addr = ioremap(res->start, size);
if(base_addr == NULL){
dev_err(dev,"fail to ioremap() region\n");
ret = -ENOENT;
goto err_map;
}
adc_clock = clk_get(&pdev->dev, "adc");
if(IS_ERR(adc_clock)){
dev_err(dev,"failed to fine ADC clock source\n");
ret = PTR_ERR(adc_clock);
goto err_clk;
}
clk_enable(adc_clock);
/* read platform data from device struct */
plat_data = s3c_adc_get_platdata(&pdev->dev);
if ((plat_data->presc & 0xff) > 0)
writel(S3C_ADCCON_PRSCEN | S3C_ADCCON_PRSCVL(plat_data->presc & 0xff), base_addr + S3C_ADCCON);
else
writel(0, base_addr+S3C_ADCCON);
/* Initialise registers */
if ((plat_data->delay & 0xffff) > 0)
writel(plat_data->delay & 0xffff, base_addr + S3C_ADCDLY);
if (plat_data->resolution == 12)
writel(readl(base_addr + S3C_ADCCON) | S3C_ADCCON_RESSEL_12BIT, base_addr + S3C_ADCCON);
ret = misc_register(&s3c_adc_miscdev);
if (ret) {
printk (KERN_ERR "cannot register miscdev on minor=%d (%d)\n",
ADC_MINOR, ret);
goto err_clk;
}
ready_to_work = 1;
printk(KERN_INFO "S3C64XX ADC driver successfully probed !\n");
return 0;
err_clk:
clk_disable(adc_clock);
clk_put(adc_clock);
err_map:
iounmap(base_addr);
#ifndef ADC_WITH_TOUCHSCREEN
err_req:
release_resource(adc_mem);
kfree(adc_mem);
#endif
return ret;
}
/*
* The functions for inserting/removing us as a module.
*/
static int __init s3c_ts_probe(struct platform_device *pdev)
{
struct resource *res;
struct device *dev;
struct input_dev *input_dev;
struct s3c_ts_mach_info *s3c_ts_cfg;
int ret, size;
int irq_flags = 0;
#ifdef CONFIG_TOUCHSCREEN_ADC1
int tmp;
#endif
dev = &pdev->dev;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res == NULL) {
dev_err(dev, "no memory resource specified\n");
return -ENOENT;
}
size = (res->end - res->start) + 1;
ts_mem = request_mem_region(res->start, size, pdev->name);
if (ts_mem == NULL) {
dev_err(dev, "failed to get memory region\n");
ret = -ENOENT;
goto err_req;
}
ts_base = ioremap(res->start, size);
#ifdef CONFIG_TOUCHSCREEN_ADC1
//Set TSADCCON0 bit 17
tmp = readl(ts_base);
tmp |= (0x01 << 17);
writel(tmp, ts_base);
//remap ts_base to 0xE1701000
iounmap(ts_base);
release_resource(ts_mem);
ts_mem = request_mem_region(res->start + 0x1000, size, pdev->name);
ts_base = ioremap(res->start + 0x1000, size);
printk("remap to 0xE1701000. done\n");
#endif
if (ts_base == NULL) {
dev_err(dev, "failed to ioremap() region\n");
ret = -EINVAL;
goto err_map;
}
ts_clock = clk_get(&pdev->dev, "adc");
if (IS_ERR(ts_clock)) {
dev_err(dev, "failed to find watchdog clock source\n");
ret = PTR_ERR(ts_clock);
goto err_clk;
}
clk_enable(ts_clock);
s3c_ts_cfg = s3c_ts_get_platdata(&pdev->dev);
if ((s3c_ts_cfg->presc & 0xff) > 0)
writel(S3C_ADCCON_PRSCEN | S3C_ADCCON_PRSCVL(s3c_ts_cfg->presc & 0xFF), ts_base+S3C_ADCCON);
else
writel(0, ts_base + S3C_ADCCON);
/* Initialise registers */
if ((s3c_ts_cfg->delay & 0xffff) > 0)
writel(s3c_ts_cfg->delay & 0xffff, ts_base + S3C_ADCDLY);
if (s3c_ts_cfg->resol_bit == 12) {
switch (s3c_ts_cfg->s3c_adc_con) {
case ADC_TYPE_2:
writel(readl(ts_base + S3C_ADCCON) |
S3C_ADCCON_RESSEL_12BIT,
ts_base + S3C_ADCCON);
break;
case ADC_TYPE_1:
writel(readl(ts_base + S3C_ADCCON) |
S3C_ADCCON_RESSEL_12BIT_1,
ts_base + S3C_ADCCON);
break;
default:
dev_err(dev, "this type of AP isn't supported !\n");
break;
}
}
writel(WAIT4INT(0), ts_base + S3C_ADCTSC);
ts = kzalloc(sizeof(struct s3c_ts_info), GFP_KERNEL);
input_dev = input_allocate_device();
if (!input_dev) {
ret = -ENOMEM;
goto err_alloc;
}
ts->dev = input_dev;
ts->dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
ts->dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
if (s3c_ts_cfg->resol_bit == 12) {
input_set_abs_params(ts->dev, ABS_X, 0, 0xFFF, 0, 0);
input_set_abs_params(ts->dev, ABS_Y, 0, 0xFFF, 0, 0);
} else {
input_set_abs_params(ts->dev, ABS_X, 0, 0x3FF, 0, 0);
input_set_abs_params(ts->dev, ABS_Y, 0, 0x3FF, 0, 0);
}
input_set_abs_params(ts->dev, ABS_PRESSURE, 0, 1, 0, 0);
sprintf(ts->phys, "input-ts");
ts->dev->name = s3c_ts_name;
ts->dev->phys = ts->phys;
ts->dev->id.bustype = BUS_RS232;
ts->dev->id.vendor = 0xDEAD;
ts->dev->id.product = 0xBEEF;
ts->dev->id.version = S3C_TSVERSION;
ts->shift = s3c_ts_cfg->oversampling_shift;
ts->resol_bit = s3c_ts_cfg->resol_bit;
ts->s3c_adc_con = s3c_ts_cfg->s3c_adc_con;
/* For IRQ_PENDUP */
ts_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (ts_irq == NULL) {
dev_err(dev, "no irq resource specified\n");
ret = -ENOENT;
goto err_irq;
}
ret = request_irq(ts_irq->start, stylus_updown, irq_flags,
"s3c_updown", ts);
if (ret != 0) {
dev_err(dev, "s3c_ts.c: Could not allocate ts IRQ_PENDN !\n");
ret = -EIO;
goto err_irq;
}
/* For IRQ_ADC */
ts_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
if (ts_irq == NULL) {
dev_err(dev, "no irq resource specified\n");
ret = -ENOENT;
goto err_irq;
}
ret = request_irq(ts_irq->start, stylus_action, irq_flags,
"s3c_action", ts);
if (ret != 0) {
dev_err(dev, "s3c_ts.c: Could not allocate ts IRQ_ADC !\n");
ret = -EIO;
goto err_irq;
}
printk(KERN_INFO "%s got loaded successfully : %d bits\n",
s3c_ts_name, s3c_ts_cfg->resol_bit);
/* All went ok, so register to the input system */
ret = input_register_device(ts->dev);
if (ret) {
dev_err(dev, "Could not register input device(touchscreen)!\n");
ret = -EIO;
goto fail;
}
return 0;
fail:
free_irq(ts_irq->start, ts->dev);
free_irq(ts_irq->end, ts->dev);
err_irq:
input_free_device(input_dev);
kfree(ts);
err_alloc:
clk_disable(ts_clock);
clk_put(ts_clock);
err_clk:
iounmap(ts_base);
err_map:
release_resource(ts_mem);
kfree(ts_mem);
err_req:
return ret;
}
static int __devinit s3c_adc_probe(struct platform_device *pdev)
{
struct resource *res;
struct device *dev;
int ret;
int size;
g_ts0_base = ioremap(0xE1700000, 1024);
if (g_ts0_base == NULL) {
printk("ts0 base map failed\n");
return -ENOENT;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
dev = &pdev->dev;
if (res == NULL) {
dev_err(dev, "no memory resource specified\n");
return -ENOENT;
}
size = (res->end - res->start) + 1;
adc_mem = request_mem_region(res->start, size, pdev->name);
if (adc_mem == NULL) {
dev_err(dev, "failed to get memory region\n");
ret = -ENOENT;
goto err_req;
}
base_addr = ioremap(res->start, size);
if (base_addr == NULL) {
dev_err(dev, "fail to ioremap() region\n");
ret = -ENOENT;
goto err_map;
}
adc_clock = clk_get(&pdev->dev, "adc");
if (IS_ERR(adc_clock)) {
dev_err(dev, "failed to fine ADC clock source\n");
ret = PTR_ERR(adc_clock);
goto err_clk;
}
clk_enable(adc_clock);
/* read platform data from device struct */
plat_data = s3c_adc_get_platdata(&pdev->dev);
if ((plat_data->presc & 0xff) > 0)
writel(S3C_ADCCON_PRSCEN |
S3C_ADCCON_PRSCVL(plat_data->presc & 0xff),
base_addr + S3C_ADCCON);
else
writel(0, base_addr + S3C_ADCCON);
/* Initialise registers */
if ((plat_data->delay & 0xffff) > 0)
writel(plat_data->delay & 0xffff, base_addr + S3C_ADCDLY);
if (plat_data->resolution == 12)
writel(readl(base_addr + S3C_ADCCON) |
S3C_ADCCON_RESSEL_12BIT, base_addr + S3C_ADCCON);
//writel((readl(base_addr + S3C_ADCCON) | S3C_ADCCON_STDBM) & ~S3C_ADCCON_PRSCEN,
//base_addr + S3C_ADCCON);
s3c_adc_restore_SFR_on_ADC();
ret = misc_register(&s3c_adc_miscdev);
if (ret) {
printk(KERN_ERR "cannot register miscdev on minor=%d (%d)\n",
ADC_MINOR, ret);
goto err_clk;
}
return 0;
err_clk:
clk_disable(adc_clock);
clk_put(adc_clock);
err_map:
iounmap(base_addr);
err_req:
release_resource(adc_mem);
kfree(adc_mem);
return ret;
}
/*
* The functions for inserting/removing us as a module.
*/
static int __init s3c_ts_probe(struct platform_device *pdev)
{
struct resource *res;
struct device *dev;
struct input_dev *input_dev;
struct s3c_ts_mach_info *s3c_ts_cfg;
int ret, size;
int irq_flags = 0;
dev = &pdev->dev;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res == NULL) {
dev_err(dev, "no memory resource specified\n");
return -ENOENT;
}
size = (res->end - res->start) + 1;
ts_mem = request_mem_region(res->start, size, pdev->name);
if (ts_mem == NULL) {
dev_err(dev, "failed to get memory region\n");
ret = -ENOENT;
goto err_req;
}
ts_base = ioremap(res->start, size);
if (ts_base == NULL) {
dev_err(dev, "failed to ioremap() region\n");
ret = -EINVAL;
goto err_map;
}
ts_clock = clk_get(&pdev->dev, "adc");
if (IS_ERR(ts_clock)) {
dev_err(dev, "failed to find watchdog clock source\n");
ret = PTR_ERR(ts_clock);
goto err_clk;
}
clk_enable(ts_clock);
s3c_ts_cfg = s3c_ts_get_platdata(&pdev->dev);
if ((s3c_ts_cfg->presc&0xff) > 0)
writel(S3C_ADCCON_PRSCEN | S3C_ADCCON_PRSCVL(s3c_ts_cfg->presc&0xFF),\
ts_base+S3C_ADCCON);
else
writel(0, ts_base+S3C_ADCCON);
/* Initialise registers */
if ((s3c_ts_cfg->delay&0xffff) > 0)
writel(s3c_ts_cfg->delay & 0xffff, ts_base+S3C_ADCDLY);
if (s3c_ts_cfg->resol_bit == 12) {
switch (s3c_ts_cfg->s3c_adc_con) {
case ADC_TYPE_2:
writel(readl(ts_base+S3C_ADCCON)|S3C_ADCCON_RESSEL_12BIT, ts_base+S3C_ADCCON);
break;
case ADC_TYPE_1:
writel(readl(ts_base+S3C_ADCCON)|S3C_ADCCON_RESSEL_12BIT_1, ts_base+S3C_ADCCON);
break;
default:
dev_err(dev, "Touchscreen over this type of AP isn't supported !\n");
break;
}
}
writel(WAIT4INT(0), ts_base+S3C_ADCTSC);
ts = kzalloc(sizeof(struct s3c_ts_info), GFP_KERNEL);
input_dev = input_allocate_device();
if (!input_dev) {
ret = -ENOMEM;
goto err_alloc;
}
ts->dev = input_dev;
ts->dev->evbit[0] = ts->dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
ts->dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
if (s3c_ts_cfg->resol_bit==12) {
#ifdef CONFIG_ANDROID
#ifndef CONFIG_CPU_S5PV210_EVT1
input_set_abs_params(ts->dev, ABS_X, 0, 800, 0, 0);
input_set_abs_params(ts->dev, ABS_Y, 0, 480, 0, 0);
// input_set_abs_params(ts->dev, ABS_Z, 0, 0, 0, 0);
set_bit(0,ts->dev->evbit);
set_bit(1,ts->dev->evbit);
set_bit(2,ts->dev->evbit);
set_bit(3,ts->dev->evbit);
set_bit(5,ts->dev->evbit);
set_bit(0,ts->dev->relbit);
set_bit(1,ts->dev->relbit);
set_bit(0,ts->dev->absbit);
set_bit(1,ts->dev->absbit);
set_bit(2,ts->dev->absbit);
set_bit(0,ts->dev->swbit);
for (err=0; err < 512; err++)
set_bit(err,ts->dev->keybit);
input_event(ts->dev,5,0,1);
#else /* !CONFIG_CPU_S5PV210_EVT1 */
input_set_abs_params(ts->dev, ABS_X, X_COOR_MIN, X_COOR_MAX, X_COOR_FUZZ, 0);
input_set_abs_params(ts->dev, ABS_Y, Y_COOR_MIN, Y_COOR_MAX, Y_COOR_FUZZ, 0);
#endif /* !CONFIG_CPU_S5PV210_EVT1 */
#else /* CONFIG_ANDROID */
input_set_abs_params(ts->dev, ABS_X, 0, 0xFFF, 0, 0);
input_set_abs_params(ts->dev, ABS_Y, 0, 0xFFF, 0, 0);
#endif /* CONFIG_ANDROID */
} else {
input_set_abs_params(ts->dev, ABS_X, 0, 0x3FF, 0, 0);
input_set_abs_params(ts->dev, ABS_Y, 0, 0x3FF, 0, 0);
}
input_set_abs_params(ts->dev, ABS_PRESSURE, 0, 1, 0, 0);
sprintf(ts->phys, "input(ts)");
ts->dev->name = s3c_ts_name;
ts->dev->phys = ts->phys;
ts->dev->id.bustype = BUS_RS232;
ts->dev->id.vendor = 0xDEAD;
ts->dev->id.product = 0xBEEF;
ts->dev->id.version = S3C_TSVERSION;
ts->shift = s3c_ts_cfg->oversampling_shift;
ts->resol_bit = s3c_ts_cfg->resol_bit;
ts->s3c_adc_con = s3c_ts_cfg->s3c_adc_con;
#ifdef CONFIG_HAS_EARLYSUSPEND
ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
ts->early_suspend.suspend = ts_early_suspend;
ts->early_suspend.resume =ts_late_resume;
register_early_suspend(&ts->early_suspend);
#endif /* CONFIG_HAS_EARLYSUSPEND */
/* For IRQ_PENDUP */
ts_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (ts_irq == NULL) {
dev_err(dev, "no irq resource specified\n");
ret = -ENOENT;
goto err_irq;
}
ret = request_irq(ts_irq->start, stylus_updown, irq_flags, "s3c_updown", ts);
if (ret != 0) {
dev_err(dev, "s3c_ts.c: Could not allocate ts IRQ_PENDN !\n");
ret = -EIO;
goto err_irq;
}
/* For IRQ_ADC */
ts_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
if (ts_irq == NULL) {
dev_err(dev, "no irq resource specified\n");
ret = -ENOENT;
goto err_irq;
}
ret = request_irq(ts_irq->start, stylus_action, irq_flags, "s3c_action", ts);
if (ret != 0) {
dev_err(dev, "s3c_ts.c: Could not allocate ts IRQ_ADC !\n");
ret = -EIO;
goto err_irq;
}
printk(KERN_INFO "%s got loaded successfully : %d bits\n", s3c_ts_name, s3c_ts_cfg->resol_bit);
/* All went ok, so register to the input system */
ret = input_register_device(ts->dev);
if (ret) {
dev_err(dev, "s3c_ts.c: Could not register input device(touchscreen)!\n");
ret = -EIO;
goto fail;
}
return 0;
fail:
free_irq(ts_irq->start, ts->dev);
free_irq(ts_irq->end, ts->dev);
err_irq:
input_free_device(input_dev);
kfree(ts);
err_alloc:
clk_disable(ts_clock);
clk_put(ts_clock);
err_clk:
iounmap(ts_base);
err_map:
release_resource(ts_mem);
kfree(ts_mem);
err_req:
return ret;
}
