Commit 130650e8 authored by Andy Shevchenko's avatar Andy Shevchenko Committed by Jonathan Cameron
Browse files

iio: frequency: adf4350: Make use of device properties 



Convert the module to be property provider agnostic and allow
it to be used on non-OF platforms.

Signed-off-by: default avatarAndy Shevchenko <andriy.shevchenko@linux.intel.com>
Link: https://lore.kernel.org/r/20220203110006.4291-1-andriy.shevchenko@linux.intel.com


Signed-off-by: default avatarJonathan Cameron <Jonathan.Cameron@huawei.com>
parent 201d11c5

drivers/iio/frequency/adf4350.c

+42 −61
Original line number Diff line number Diff line
@@ -7,17 +7,18 @@ 


#include <linux/device.h>

#include <linux/kernel.h>

#include <linux/mod_devicetable.h>

#include <linux/module.h>

#include <linux/property.h>

#include <linux/slab.h>

#include <linux/sysfs.h>

#include <linux/spi/spi.h>

#include <linux/regulator/consumer.h>

#include <linux/err.h>

#include <linux/module.h>

#include <linux/gcd.h>

#include <linux/gpio/consumer.h>

#include <asm/div64.h>

#include <linux/clk.h>

#include <linux/of.h>



#include <linux/iio/iio.h>

#include <linux/iio/sysfs.h>
@@ -381,10 +382,8 @@ static const struct iio_info adf4350_info = { 
	.debugfs_reg_access = &adf4350_reg_access,

};



#ifdef CONFIG_OF

static struct adf4350_platform_data *adf4350_parse_dt(struct device *dev)

{

	struct device_node *np = dev->of_node;

	struct adf4350_platform_data *pdata;

	unsigned int tmp;
@@ -392,101 +391,83 @@ static struct adf4350_platform_data *adf4350_parse_dt(struct device *dev) 
	if (!pdata)

		return NULL;



	snprintf(&pdata->name[0], SPI_NAME_SIZE - 1, "%pOFn", np);

	snprintf(pdata->name, sizeof(pdata->name), "%pfw", dev_fwnode(dev));



	tmp = 10000;

	of_property_read_u32(np, "adi,channel-spacing", &tmp);

	device_property_read_u32(dev, "adi,channel-spacing", &tmp);

	pdata->channel_spacing = tmp;



	tmp = 0;

	of_property_read_u32(np, "adi,power-up-frequency", &tmp);

	device_property_read_u32(dev, "adi,power-up-frequency", &tmp);

	pdata->power_up_frequency = tmp;



	tmp = 0;

	of_property_read_u32(np, "adi,reference-div-factor", &tmp);

	device_property_read_u32(dev, "adi,reference-div-factor", &tmp);

	pdata->ref_div_factor = tmp;



	pdata->ref_doubler_en = of_property_read_bool(np,

			"adi,reference-doubler-enable");

	pdata->ref_div2_en = of_property_read_bool(np,

			"adi,reference-div2-enable");

	pdata->ref_doubler_en = device_property_read_bool(dev, "adi,reference-doubler-enable");

	pdata->ref_div2_en = device_property_read_bool(dev, "adi,reference-div2-enable");



	/* r2_user_settings */

	pdata->r2_user_settings = of_property_read_bool(np,

			"adi,phase-detector-polarity-positive-enable") ?

			ADF4350_REG2_PD_POLARITY_POS : 0;

	pdata->r2_user_settings |= of_property_read_bool(np,

			"adi,lock-detect-precision-6ns-enable") ?

			ADF4350_REG2_LDP_6ns : 0;

	pdata->r2_user_settings |= of_property_read_bool(np,

			"adi,lock-detect-function-integer-n-enable") ?

			ADF4350_REG2_LDF_INT_N : 0;

	pdata->r2_user_settings = 0;

	if (device_property_read_bool(dev, "adi,phase-detector-polarity-positive-enable"))

		pdata->r2_user_settings |= ADF4350_REG2_PD_POLARITY_POS;

	if (device_property_read_bool(dev, "adi,lock-detect-precision-6ns-enable"))

		pdata->r2_user_settings |= ADF4350_REG2_LDP_6ns;

	if (device_property_read_bool(dev, "adi,lock-detect-function-integer-n-enable"))

		pdata->r2_user_settings |= ADF4350_REG2_LDF_INT_N;



	tmp = 2500;

	of_property_read_u32(np, "adi,charge-pump-current", &tmp);

	device_property_read_u32(dev, "adi,charge-pump-current", &tmp);

	pdata->r2_user_settings |= ADF4350_REG2_CHARGE_PUMP_CURR_uA(tmp);



	tmp = 0;

	of_property_read_u32(np, "adi,muxout-select", &tmp);

	device_property_read_u32(dev, "adi,muxout-select", &tmp);

	pdata->r2_user_settings |= ADF4350_REG2_MUXOUT(tmp);



	pdata->r2_user_settings |= of_property_read_bool(np,

			"adi,low-spur-mode-enable") ?

			ADF4350_REG2_NOISE_MODE(0x3) : 0;

	if (device_property_read_bool(dev, "adi,low-spur-mode-enable"))

		pdata->r2_user_settings |= ADF4350_REG2_NOISE_MODE(0x3);



	/* r3_user_settings */



	pdata->r3_user_settings = of_property_read_bool(np,

			"adi,cycle-slip-reduction-enable") ?

			ADF4350_REG3_12BIT_CSR_EN : 0;

	pdata->r3_user_settings |= of_property_read_bool(np,

			"adi,charge-cancellation-enable") ?

			ADF4351_REG3_CHARGE_CANCELLATION_EN : 0;



	pdata->r3_user_settings |= of_property_read_bool(np,

			"adi,anti-backlash-3ns-enable") ?

			ADF4351_REG3_ANTI_BACKLASH_3ns_EN : 0;

	pdata->r3_user_settings |= of_property_read_bool(np,

			"adi,band-select-clock-mode-high-enable") ?

			ADF4351_REG3_BAND_SEL_CLOCK_MODE_HIGH : 0;

	pdata->r3_user_settings = 0;

	if (device_property_read_bool(dev, "adi,cycle-slip-reduction-enable"))

		pdata->r3_user_settings |= ADF4350_REG3_12BIT_CSR_EN;

	if (device_property_read_bool(dev, "adi,charge-cancellation-enable"))

		pdata->r3_user_settings |= ADF4351_REG3_CHARGE_CANCELLATION_EN;

	if (device_property_read_bool(dev, "adi,anti-backlash-3ns-enable"))

		pdata->r3_user_settings |= ADF4351_REG3_ANTI_BACKLASH_3ns_EN;

	if (device_property_read_bool(dev, "adi,band-select-clock-mode-high-enable"))

		pdata->r3_user_settings |= ADF4351_REG3_BAND_SEL_CLOCK_MODE_HIGH;



	tmp = 0;

	of_property_read_u32(np, "adi,12bit-clk-divider", &tmp);

	device_property_read_u32(dev, "adi,12bit-clk-divider", &tmp);

	pdata->r3_user_settings |= ADF4350_REG3_12BIT_CLKDIV(tmp);



	tmp = 0;

	of_property_read_u32(np, "adi,clk-divider-mode", &tmp);

	device_property_read_u32(dev, "adi,clk-divider-mode", &tmp);

	pdata->r3_user_settings |= ADF4350_REG3_12BIT_CLKDIV_MODE(tmp);



	/* r4_user_settings */



	pdata->r4_user_settings = of_property_read_bool(np,

			"adi,aux-output-enable") ?

			ADF4350_REG4_AUX_OUTPUT_EN : 0;

	pdata->r4_user_settings |= of_property_read_bool(np,

			"adi,aux-output-fundamental-enable") ?

			ADF4350_REG4_AUX_OUTPUT_FUND : 0;

	pdata->r4_user_settings |= of_property_read_bool(np,

			"adi,mute-till-lock-enable") ?

			ADF4350_REG4_MUTE_TILL_LOCK_EN : 0;

	pdata->r4_user_settings = 0;

	if (device_property_read_bool(dev, "adi,aux-output-enable"))

		pdata->r4_user_settings |= ADF4350_REG4_AUX_OUTPUT_EN;

	if (device_property_read_bool(dev, "adi,aux-output-fundamental-enable"))

		pdata->r4_user_settings |= ADF4350_REG4_AUX_OUTPUT_FUND;

	if (device_property_read_bool(dev, "adi,mute-till-lock-enable"))

		pdata->r4_user_settings |= ADF4350_REG4_MUTE_TILL_LOCK_EN;



	tmp = 0;

	of_property_read_u32(np, "adi,output-power", &tmp);

	device_property_read_u32(dev, "adi,output-power", &tmp);

	pdata->r4_user_settings |= ADF4350_REG4_OUTPUT_PWR(tmp);



	tmp = 0;

	of_property_read_u32(np, "adi,aux-output-power", &tmp);

	device_property_read_u32(dev, "adi,aux-output-power", &tmp);

	pdata->r4_user_settings |= ADF4350_REG4_AUX_OUTPUT_PWR(tmp);



	return pdata;

}

#else

static

struct adf4350_platform_data *adf4350_parse_dt(struct device *dev)

{

	return NULL;

}

#endif



static int adf4350_probe(struct spi_device *spi)

{
@@ -496,7 +477,7 @@ static int adf4350_probe(struct spi_device *spi) 
	struct clk *clk = NULL;

	int ret;



	if (spi->dev.of_node) {

	if (dev_fwnode(&spi->dev)) {

		pdata = adf4350_parse_dt(&spi->dev);

		if (pdata == NULL)

			return -EINVAL;
@@ -625,7 +606,7 @@ MODULE_DEVICE_TABLE(spi, adf4350_id); 
static struct spi_driver adf4350_driver = {

	.driver = {

		.name	= "adf4350",

		.of_match_table = of_match_ptr(adf4350_of_match),

		.of_match_table = adf4350_of_match,

	},

	.probe		= adf4350_probe,

	.remove		= adf4350_remove,