Commit cc146410 authored by Arnd Bergmann's avatar Arnd Bergmann
Browse files

ARM: s3c: remove adc.c 



This driver could not be enabled on s3c64xx for a long time
because of the ARCH_MULTIPLATFORM dependency, so remove it.

Acked-by: default avatarMark Brown <broonie@kernel.org>
Reviewed-by: default avatarKrzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
Signed-off-by: default avatarArnd Bergmann <arnd@arndb.de>
parent 743c8fbb

arch/arm/mach-s3c/Kconfig

+0 −15
Original line number Diff line number Diff line
@@ -63,16 +63,6 @@ config S3C_GPIO_TRACK 
	  Internal configuration option to enable the s3c specific gpio

	  chip tracking if the platform requires it.



# ADC driver



config S3C_ADC

	bool "ADC common driver support"

	depends on !ARCH_MULTIPLATFORM

	help

	  Core support for the ADC block found in the Samsung SoC systems

	  for drivers such as the touchscreen and hwmon to use to share

	  this resource.



# device definitions to compile in



config S3C_DEV_HSMMC
@@ -165,11 +155,6 @@ config S3C_DEV_RTC 
	help

	  Compile in platform device definition for RTC



config SAMSUNG_DEV_ADC

	bool

	help

	  Compile in platform device definition for ADC controller



config S3C64XX_DEV_SPI0

	bool

	help

arch/arm/mach-s3c/Kconfig.s3c64xx

+0 −1
Original line number Diff line number Diff line
@@ -125,7 +125,6 @@ config MACH_WLF_CRAGG_6410 
	select S3C_DEV_USB_HOST

	select S3C_DEV_USB_HSOTG

	select S3C_DEV_WDT

	select SAMSUNG_DEV_ADC

	select SAMSUNG_DEV_KEYPAD

	select SAMSUNG_DEV_PWM

	help

arch/arm/mach-s3c/Makefile

+0 −4
Original line number Diff line number Diff line
@@ -8,10 +8,6 @@ include $(src)/Makefile.s3c64xx 


obj-y				+= init.o cpu.o



# ADC



obj-$(CONFIG_S3C_ADC)	+= adc.o



# devices



obj-$(CONFIG_SAMSUNG_ATAGS)	+= platformdata.o

arch/arm/mach-s3c/adc.c

deleted100644 → 0
+0 −510
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-1.0+

//

// Copyright (c) 2008 Simtec Electronics

//	http://armlinux.simtec.co.uk/

//	Ben Dooks <ben@simtec.co.uk>, <ben-linux@fluff.org>

//

// Samsung ADC device core



#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/mod_devicetable.h>

#include <linux/platform_device.h>

#include <linux/sched.h>

#include <linux/list.h>

#include <linux/slab.h>

#include <linux/err.h>

#include <linux/clk.h>

#include <linux/interrupt.h>

#include <linux/io.h>

#include <linux/regulator/consumer.h>



#include "regs-adc.h"

#include <linux/soc/samsung/s3c-adc.h>



/* This driver is designed to control the usage of the ADC block between

 * the touchscreen and any other drivers that may need to use it, such as

 * the hwmon driver.

 *

 * Priority will be given to the touchscreen driver, but as this itself is

 * rate limited it should not starve other requests which are processed in

 * order that they are received.

 *

 * Each user registers to get a client block which uniquely identifies it

 * and stores information such as the necessary functions to callback when

 * action is required.

 */



enum s3c_cpu_type {

	TYPE_ADCV1, /* S3C24XX */

	TYPE_ADCV11, /* S3C2443 */

	TYPE_ADCV12, /* S3C2416, S3C2450 */

	TYPE_ADCV2, /* S3C64XX */

	TYPE_ADCV3, /* S5PV210, S5PC110, Exynos4210 */

};



struct s3c_adc_client {

	struct platform_device	*pdev;

	struct list_head	 pend;

	wait_queue_head_t	*wait;



	unsigned int		 nr_samples;

	int			 result;

	unsigned char		 is_ts;

	unsigned char		 channel;



	void	(*select_cb)(struct s3c_adc_client *c, unsigned selected);

	void	(*convert_cb)(struct s3c_adc_client *c,

			      unsigned val1, unsigned val2,

			      unsigned *samples_left);

};



struct adc_device {

	struct platform_device	*pdev;

	struct platform_device	*owner;

	struct clk		*clk;

	struct s3c_adc_client	*cur;

	struct s3c_adc_client	*ts_pend;

	void __iomem		*regs;

	spinlock_t		 lock;



	unsigned int		 prescale;



	int			 irq;

	struct regulator	*vdd;

};



static struct adc_device *adc_dev;



static LIST_HEAD(adc_pending);	/* protected by adc_device.lock */



#define adc_dbg(_adc, msg...) dev_dbg(&(_adc)->pdev->dev, msg)



static inline void s3c_adc_convert(struct adc_device *adc)

{

	unsigned con = readl(adc->regs + S3C2410_ADCCON);



	con |= S3C2410_ADCCON_ENABLE_START;

	writel(con, adc->regs + S3C2410_ADCCON);

}



static inline void s3c_adc_select(struct adc_device *adc,

				  struct s3c_adc_client *client)

{

	unsigned con = readl(adc->regs + S3C2410_ADCCON);

	enum s3c_cpu_type cpu = platform_get_device_id(adc->pdev)->driver_data;



	client->select_cb(client, 1);



	if (cpu == TYPE_ADCV1 || cpu == TYPE_ADCV2)

		con &= ~S3C2410_ADCCON_MUXMASK;

	con &= ~S3C2410_ADCCON_STDBM;

	con &= ~S3C2410_ADCCON_STARTMASK;



	if (!client->is_ts) {

		if (cpu == TYPE_ADCV3)

			writel(client->channel & 0xf, adc->regs + S5P_ADCMUX);

		else if (cpu == TYPE_ADCV11 || cpu == TYPE_ADCV12)

			writel(client->channel & 0xf,

						adc->regs + S3C2443_ADCMUX);

		else

			con |= S3C2410_ADCCON_SELMUX(client->channel);

	}



	writel(con, adc->regs + S3C2410_ADCCON);

}



static void s3c_adc_dbgshow(struct adc_device *adc)

{

	adc_dbg(adc, "CON=%08x, TSC=%08x, DLY=%08x\n",

		readl(adc->regs + S3C2410_ADCCON),

		readl(adc->regs + S3C2410_ADCTSC),

		readl(adc->regs + S3C2410_ADCDLY));

}



static void s3c_adc_try(struct adc_device *adc)

{

	struct s3c_adc_client *next = adc->ts_pend;



	if (!next && !list_empty(&adc_pending)) {

		next = list_first_entry(&adc_pending,

					struct s3c_adc_client, pend);

		list_del(&next->pend);

	} else

		adc->ts_pend = NULL;



	if (next) {

		adc_dbg(adc, "new client is %p\n", next);

		adc->cur = next;

		s3c_adc_select(adc, next);

		s3c_adc_convert(adc);

		s3c_adc_dbgshow(adc);

	}

}



int s3c_adc_start(struct s3c_adc_client *client,

		  unsigned int channel, unsigned int nr_samples)

{

	struct adc_device *adc = adc_dev;

	unsigned long flags;



	if (!adc) {

		printk(KERN_ERR "%s: failed to find adc\n", __func__);

		return -EINVAL;

	}



	spin_lock_irqsave(&adc->lock, flags);



	if (client->is_ts && adc->ts_pend) {

		spin_unlock_irqrestore(&adc->lock, flags);

		return -EAGAIN;

	}



	client->channel = channel;

	client->nr_samples = nr_samples;



	if (client->is_ts)

		adc->ts_pend = client;

	else

		list_add_tail(&client->pend, &adc_pending);



	if (!adc->cur)

		s3c_adc_try(adc);



	spin_unlock_irqrestore(&adc->lock, flags);



	return 0;

}

EXPORT_SYMBOL_GPL(s3c_adc_start);



static void s3c_convert_done(struct s3c_adc_client *client,

			     unsigned v, unsigned u, unsigned *left)

{

	client->result = v;

	wake_up(client->wait);

}



int s3c_adc_read(struct s3c_adc_client *client, unsigned int ch)

{

	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wake);

	int ret;



	client->convert_cb = s3c_convert_done;

	client->wait = &wake;

	client->result = -1;



	ret = s3c_adc_start(client, ch, 1);

	if (ret < 0)

		goto err;



	ret = wait_event_timeout(wake, client->result >= 0, HZ / 2);

	if (client->result < 0) {

		ret = -ETIMEDOUT;

		goto err;

	}



	client->convert_cb = NULL;

	return client->result;



err:

	return ret;

}

EXPORT_SYMBOL_GPL(s3c_adc_read);



static void s3c_adc_default_select(struct s3c_adc_client *client,

				   unsigned select)

{

}



struct s3c_adc_client *s3c_adc_register(struct platform_device *pdev,

					void (*select)(struct s3c_adc_client *client,

						       unsigned int selected),

					void (*conv)(struct s3c_adc_client *client,

						     unsigned d0, unsigned d1,

						     unsigned *samples_left),

					unsigned int is_ts)

{

	struct s3c_adc_client *client;



	WARN_ON(!pdev);



	if (!select)

		select = s3c_adc_default_select;



	if (!pdev)

		return ERR_PTR(-EINVAL);



	client = kzalloc(sizeof(*client), GFP_KERNEL);

	if (!client)

		return ERR_PTR(-ENOMEM);



	client->pdev = pdev;

	client->is_ts = is_ts;

	client->select_cb = select;

	client->convert_cb = conv;



	return client;

}

EXPORT_SYMBOL_GPL(s3c_adc_register);



void s3c_adc_release(struct s3c_adc_client *client)

{

	unsigned long flags;



	spin_lock_irqsave(&adc_dev->lock, flags);



	/* We should really check that nothing is in progress. */

	if (adc_dev->cur == client)

		adc_dev->cur = NULL;

	if (adc_dev->ts_pend == client)

		adc_dev->ts_pend = NULL;

	else {

		struct list_head *p, *n;

		struct s3c_adc_client *tmp;



		list_for_each_safe(p, n, &adc_pending) {

			tmp = list_entry(p, struct s3c_adc_client, pend);

			if (tmp == client)

				list_del(&tmp->pend);

		}

	}



	if (adc_dev->cur == NULL)

		s3c_adc_try(adc_dev);



	spin_unlock_irqrestore(&adc_dev->lock, flags);

	kfree(client);

}

EXPORT_SYMBOL_GPL(s3c_adc_release);



static irqreturn_t s3c_adc_irq(int irq, void *pw)

{

	struct adc_device *adc = pw;

	struct s3c_adc_client *client = adc->cur;

	enum s3c_cpu_type cpu = platform_get_device_id(adc->pdev)->driver_data;

	unsigned data0, data1;



	if (!client) {

		dev_warn(&adc->pdev->dev, "%s: no adc pending\n", __func__);

		goto exit;

	}



	data0 = readl(adc->regs + S3C2410_ADCDAT0);

	data1 = readl(adc->regs + S3C2410_ADCDAT1);

	adc_dbg(adc, "read %d: 0x%04x, 0x%04x\n", client->nr_samples, data0, data1);



	client->nr_samples--;



	if (cpu == TYPE_ADCV1 || cpu == TYPE_ADCV11) {

		data0 &= 0x3ff;

		data1 &= 0x3ff;

	} else {

		/* S3C2416/S3C64XX/S5P ADC resolution is 12-bit */

		data0 &= 0xfff;

		data1 &= 0xfff;

	}



	if (client->convert_cb)

		(client->convert_cb)(client, data0, data1, &client->nr_samples);



	if (client->nr_samples > 0) {

		/* fire another conversion for this */



		client->select_cb(client, 1);

		s3c_adc_convert(adc);

	} else {

		spin_lock(&adc->lock);

		(client->select_cb)(client, 0);

		adc->cur = NULL;



		s3c_adc_try(adc);

		spin_unlock(&adc->lock);

	}



exit:

	if (cpu == TYPE_ADCV2 || cpu == TYPE_ADCV3) {

		/* Clear ADC interrupt */

		writel(0, adc->regs + S3C64XX_ADCCLRINT);

	}

	return IRQ_HANDLED;

}



static int s3c_adc_probe(struct platform_device *pdev)

{

	struct device *dev = &pdev->dev;

	struct adc_device *adc;

	enum s3c_cpu_type cpu = platform_get_device_id(pdev)->driver_data;

	int ret;

	unsigned tmp;



	adc = devm_kzalloc(dev, sizeof(*adc), GFP_KERNEL);

	if (!adc)

		return -ENOMEM;



	spin_lock_init(&adc->lock);



	adc->pdev = pdev;

	adc->prescale = S3C2410_ADCCON_PRSCVL(49);



	adc->vdd = devm_regulator_get(dev, "vdd");

	if (IS_ERR(adc->vdd)) {

		dev_err(dev, "operating without regulator \"vdd\" .\n");

		return PTR_ERR(adc->vdd);

	}



	adc->irq = platform_get_irq(pdev, 1);

	if (adc->irq <= 0)

		return -ENOENT;



	ret = devm_request_irq(dev, adc->irq, s3c_adc_irq, 0, dev_name(dev),

				adc);

	if (ret < 0) {

		dev_err(dev, "failed to attach adc irq\n");

		return ret;

	}



	adc->clk = devm_clk_get(dev, "adc");

	if (IS_ERR(adc->clk)) {

		dev_err(dev, "failed to get adc clock\n");

		return PTR_ERR(adc->clk);

	}



	adc->regs = devm_platform_ioremap_resource(pdev, 0);

	if (IS_ERR(adc->regs))

		return PTR_ERR(adc->regs);



	ret = regulator_enable(adc->vdd);

	if (ret)

		return ret;



	clk_prepare_enable(adc->clk);



	tmp = adc->prescale | S3C2410_ADCCON_PRSCEN;



	/* Enable 12-bit ADC resolution */

	if (cpu == TYPE_ADCV12)

		tmp |= S3C2416_ADCCON_RESSEL;

	if (cpu == TYPE_ADCV2 || cpu == TYPE_ADCV3)

		tmp |= S3C64XX_ADCCON_RESSEL;



	writel(tmp, adc->regs + S3C2410_ADCCON);



	dev_info(dev, "attached adc driver\n");



	platform_set_drvdata(pdev, adc);

	adc_dev = adc;



	return 0;

}



static int s3c_adc_remove(struct platform_device *pdev)

{

	struct adc_device *adc = platform_get_drvdata(pdev);



	clk_disable_unprepare(adc->clk);

	regulator_disable(adc->vdd);



	return 0;

}



#ifdef CONFIG_PM

static int s3c_adc_suspend(struct device *dev)

{

	struct adc_device *adc = dev_get_drvdata(dev);

	unsigned long flags;

	u32 con;



	spin_lock_irqsave(&adc->lock, flags);



	con = readl(adc->regs + S3C2410_ADCCON);

	con |= S3C2410_ADCCON_STDBM;

	writel(con, adc->regs + S3C2410_ADCCON);



	disable_irq(adc->irq);

	spin_unlock_irqrestore(&adc->lock, flags);

	clk_disable(adc->clk);

	regulator_disable(adc->vdd);



	return 0;

}



static int s3c_adc_resume(struct device *dev)

{

	struct platform_device *pdev = to_platform_device(dev);

	struct adc_device *adc = platform_get_drvdata(pdev);

	enum s3c_cpu_type cpu = platform_get_device_id(pdev)->driver_data;

	int ret;

	unsigned long tmp;



	ret = regulator_enable(adc->vdd);

	if (ret)

		return ret;

	clk_enable(adc->clk);

	enable_irq(adc->irq);



	tmp = adc->prescale | S3C2410_ADCCON_PRSCEN;



	/* Enable 12-bit ADC resolution */

	if (cpu == TYPE_ADCV12)

		tmp |= S3C2416_ADCCON_RESSEL;

	if (cpu == TYPE_ADCV2 || cpu == TYPE_ADCV3)

		tmp |= S3C64XX_ADCCON_RESSEL;



	writel(tmp, adc->regs + S3C2410_ADCCON);



	return 0;

}



#else

#define s3c_adc_suspend NULL

#define s3c_adc_resume NULL

#endif



static const struct platform_device_id s3c_adc_driver_ids[] = {

	{

		.name           = "s3c24xx-adc",

		.driver_data    = TYPE_ADCV1,

	}, {

		.name		= "s3c2443-adc",

		.driver_data	= TYPE_ADCV11,

	}, {

		.name		= "s3c2416-adc",

		.driver_data	= TYPE_ADCV12,

	}, {

		.name           = "s3c64xx-adc",

		.driver_data    = TYPE_ADCV2,

	}, {

		.name		= "samsung-adc-v3",

		.driver_data	= TYPE_ADCV3,

	},

	{ }

};

MODULE_DEVICE_TABLE(platform, s3c_adc_driver_ids);



static const struct dev_pm_ops adc_pm_ops = {

	.suspend	= s3c_adc_suspend,

	.resume		= s3c_adc_resume,

};



static struct platform_driver s3c_adc_driver = {

	.id_table	= s3c_adc_driver_ids,

	.driver		= {

		.name	= "s3c-adc",

		.pm	= &adc_pm_ops,

	},

	.probe		= s3c_adc_probe,

	.remove		= s3c_adc_remove,

};



static int __init adc_init(void)

{

	int ret;



	ret = platform_driver_register(&s3c_adc_driver);

	if (ret)

		printk(KERN_ERR "%s: failed to add adc driver\n", __func__);



	return ret;

}



module_init(adc_init);

arch/arm/mach-s3c/mach-crag6410.c

+0 −1
Original line number Diff line number Diff line
@@ -58,7 +58,6 @@ 
#include "keypad.h"

#include "devs.h"

#include "cpu.h"

#include <linux/soc/samsung/s3c-adc.h>

#include <linux/platform_data/i2c-s3c2410.h>

#include "pm.h"