Commit a1867f85 authored by Min Li's avatar Min Li Committed by Lee Jones
Browse files

mfd: Add Renesas Synchronization Management Unit (SMU) support 



Add support for ClockMatrix(TM) and 82P33xxx families of timing
and synchronization devices. The access interface can be either
SPI or I2C. Currently, it will create 2 types of MFD devices,
which are to be used by the corresponding rsmu character device
driver and the PTP hardware clock driver, respectively.

Signed-off-by: default avatarMin Li <min.li.xe@renesas.com>
Signed-off-by: default avatarLee Jones <lee.jones@linaro.org>
parent e73f0f0e

drivers/mfd/Kconfig

+28 −0
Original line number Diff line number Diff line
@@ -2183,5 +2183,33 @@ config MFD_INTEL_M10_BMC 
	  additional drivers must be enabled in order to use the functionality

	  of the device.



config MFD_RSMU_I2C

	tristate "Renesas Synchronization Management Unit with I2C"

	depends on I2C && OF

	select MFD_CORE

	select REGMAP_I2C

	help

	  Support for the Renesas Synchronization Management Unit, such as

	  Clockmatrix and 82P33XXX series. This option supports I2C as

	  the control interface.



	  This driver provides common support for accessing the device.

	  Additional drivers must be enabled in order to use the functionality

	  of the device.



config MFD_RSMU_SPI

	tristate "Renesas Synchronization Management Unit with SPI"

	depends on SPI && OF

	select MFD_CORE

	select REGMAP_SPI

	help

	  Support for the Renesas Synchronization Management Unit, such as

	  Clockmatrix and 82P33XXX series. This option supports SPI as

	  the control interface.



	  This driver provides common support for accessing the device.

	  Additional drivers must be enabled in order to use the functionality

	  of the device.



endmenu

endif

drivers/mfd/Makefile

+5 −0
Original line number Diff line number Diff line
@@ -272,3 +272,8 @@ obj-$(CONFIG_MFD_INTEL_M10_BMC) += intel-m10-bmc.o 


obj-$(CONFIG_MFD_ATC260X)	+= atc260x-core.o

obj-$(CONFIG_MFD_ATC260X_I2C)	+= atc260x-i2c.o



rsmu-i2c-objs			:= rsmu_core.o rsmu_i2c.o

rsmu-spi-objs			:= rsmu_core.o rsmu_spi.o

obj-$(CONFIG_MFD_RSMU_I2C)	+= rsmu-i2c.o

obj-$(CONFIG_MFD_RSMU_SPI)	+= rsmu-spi.o

drivers/mfd/rsmu.h

0 → 100644
+16 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0+ */

/*

 * Renesas Synchronization Management Unit (SMU) devices.

 *

 * Copyright (C) 2021 Integrated Device Technology, Inc., a Renesas Company.

 */



#ifndef __RSMU_MFD_H

#define __RSMU_MFD_H



#include <linux/mfd/rsmu.h>



int rsmu_core_init(struct rsmu_ddata *rsmu);

void rsmu_core_exit(struct rsmu_ddata *rsmu);



#endif /* __RSMU_MFD_H */

drivers/mfd/rsmu_core.c

0 → 100644
+88 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0+

/*

 * Core driver for Renesas Synchronization Management Unit (SMU) devices.

 *

 * Copyright (C) 2021 Integrated Device Technology, Inc., a Renesas Company.

 */



#include <linux/init.h>

#include <linux/kernel.h>

#include <linux/mfd/core.h>

#include <linux/mfd/rsmu.h>

#include <linux/module.h>

#include <linux/of.h>

#include <linux/regmap.h>

#include <linux/slab.h>



#include "rsmu.h"



enum {

	RSMU_PHC = 0,

	RSMU_CDEV = 1,

	RSMU_N_DEVS = 2,

};



static struct mfd_cell rsmu_cm_devs[] = {

	[RSMU_PHC] = {

		.name = "8a3400x-phc",

	},

	[RSMU_CDEV] = {

		.name = "8a3400x-cdev",

	},

};



static struct mfd_cell rsmu_sabre_devs[] = {

	[RSMU_PHC] = {

		.name = "82p33x1x-phc",

	},

	[RSMU_CDEV] = {

		.name = "82p33x1x-cdev",

	},

};



static struct mfd_cell rsmu_sl_devs[] = {

	[RSMU_PHC] = {

		.name = "8v19n85x-phc",

	},

	[RSMU_CDEV] = {

		.name = "8v19n85x-cdev",

	},

};



int rsmu_core_init(struct rsmu_ddata *rsmu)

{

	struct mfd_cell *cells;

	int ret;



	switch (rsmu->type) {

	case RSMU_CM:

		cells = rsmu_cm_devs;

		break;

	case RSMU_SABRE:

		cells = rsmu_sabre_devs;

		break;

	case RSMU_SL:

		cells = rsmu_sl_devs;

		break;

	default:

		dev_err(rsmu->dev, "Unsupported RSMU device type: %d\n", rsmu->type);

		return -ENODEV;

	}



	mutex_init(&rsmu->lock);



	ret = devm_mfd_add_devices(rsmu->dev, PLATFORM_DEVID_AUTO, cells,

				   RSMU_N_DEVS, NULL, 0, NULL);

	if (ret < 0)

		dev_err(rsmu->dev, "Failed to register sub-devices: %d\n", ret);



	return ret;

}



void rsmu_core_exit(struct rsmu_ddata *rsmu)

{

	mutex_destroy(&rsmu->lock);

}



MODULE_DESCRIPTION("Renesas SMU core driver");

MODULE_LICENSE("GPL");

drivers/mfd/rsmu_i2c.c

0 → 100644
+203 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0+

/*

 * I2C driver for Renesas Synchronization Management Unit (SMU) devices.

 *

 * Copyright (C) 2021 Integrated Device Technology, Inc., a Renesas Company.

 */



#include <linux/i2c.h>

#include <linux/init.h>

#include <linux/kernel.h>

#include <linux/mfd/core.h>

#include <linux/mfd/rsmu.h>

#include <linux/module.h>

#include <linux/of.h>

#include <linux/regmap.h>

#include <linux/slab.h>



#include "rsmu.h"



/*

 * 16-bit register address: the lower 8 bits of the register address come

 * from the offset addr byte and the upper 8 bits come from the page register.

 */

#define	RSMU_CM_PAGE_ADDR		0xFD

#define	RSMU_CM_PAGE_WINDOW		256



/*

 * 15-bit register address: the lower 7 bits of the register address come

 * from the offset addr byte and the upper 8 bits come from the page register.

 */

#define	RSMU_SABRE_PAGE_ADDR		0x7F

#define	RSMU_SABRE_PAGE_WINDOW		128



static const struct regmap_range_cfg rsmu_cm_range_cfg[] = {

	{

		.range_min = 0,

		.range_max = 0xD000,

		.selector_reg = RSMU_CM_PAGE_ADDR,

		.selector_mask = 0xFF,

		.selector_shift = 0,

		.window_start = 0,

		.window_len = RSMU_CM_PAGE_WINDOW,

	}

};



static const struct regmap_range_cfg rsmu_sabre_range_cfg[] = {

	{

		.range_min = 0,

		.range_max = 0x400,

		.selector_reg = RSMU_SABRE_PAGE_ADDR,

		.selector_mask = 0xFF,

		.selector_shift = 0,

		.window_start = 0,

		.window_len = RSMU_SABRE_PAGE_WINDOW,

	}

};



static bool rsmu_cm_volatile_reg(struct device *dev, unsigned int reg)

{

	switch (reg) {

	case RSMU_CM_PAGE_ADDR:

		return false;

	default:

		return true;

	}

}



static bool rsmu_sabre_volatile_reg(struct device *dev, unsigned int reg)

{

	switch (reg) {

	case RSMU_SABRE_PAGE_ADDR:

		return false;

	default:

		return true;

	}

}



static const struct regmap_config rsmu_cm_regmap_config = {

	.reg_bits = 8,

	.val_bits = 8,

	.max_register = 0xD000,

	.ranges = rsmu_cm_range_cfg,

	.num_ranges = ARRAY_SIZE(rsmu_cm_range_cfg),

	.volatile_reg = rsmu_cm_volatile_reg,

	.cache_type = REGCACHE_RBTREE,

	.can_multi_write = true,

};



static const struct regmap_config rsmu_sabre_regmap_config = {

	.reg_bits = 8,

	.val_bits = 8,

	.max_register = 0x400,

	.ranges = rsmu_sabre_range_cfg,

	.num_ranges = ARRAY_SIZE(rsmu_sabre_range_cfg),

	.volatile_reg = rsmu_sabre_volatile_reg,

	.cache_type = REGCACHE_RBTREE,

	.can_multi_write = true,

};



static const struct regmap_config rsmu_sl_regmap_config = {

	.reg_bits = 16,

	.val_bits = 8,

	.reg_format_endian = REGMAP_ENDIAN_BIG,

	.max_register = 0x339,

	.cache_type = REGCACHE_NONE,

	.can_multi_write = true,

};



static int rsmu_i2c_probe(struct i2c_client *client,

			  const struct i2c_device_id *id)

{

	const struct regmap_config *cfg;

	struct rsmu_ddata *rsmu;

	int ret;



	rsmu = devm_kzalloc(&client->dev, sizeof(*rsmu), GFP_KERNEL);

	if (!rsmu)

		return -ENOMEM;



	i2c_set_clientdata(client, rsmu);



	rsmu->dev = &client->dev;

	rsmu->type = (enum rsmu_type)id->driver_data;



	switch (rsmu->type) {

	case RSMU_CM:

		cfg = &rsmu_cm_regmap_config;

		break;

	case RSMU_SABRE:

		cfg = &rsmu_sabre_regmap_config;

		break;

	case RSMU_SL:

		cfg = &rsmu_sl_regmap_config;

		break;

	default:

		dev_err(rsmu->dev, "Unsupported RSMU device type: %d\n", rsmu->type);

		return -ENODEV;

	}

	rsmu->regmap = devm_regmap_init_i2c(client, cfg);

	if (IS_ERR(rsmu->regmap)) {

		ret = PTR_ERR(rsmu->regmap);

		dev_err(rsmu->dev, "Failed to allocate register map: %d\n", ret);

		return ret;

	}



	return rsmu_core_init(rsmu);

}



static int rsmu_i2c_remove(struct i2c_client *client)

{

	struct rsmu_ddata *rsmu = i2c_get_clientdata(client);



	rsmu_core_exit(rsmu);



	return 0;

}



static const struct i2c_device_id rsmu_i2c_id[] = {

	{ "8a34000",  RSMU_CM },

	{ "8a34001",  RSMU_CM },

	{ "82p33810", RSMU_SABRE },

	{ "82p33811", RSMU_SABRE },

	{ "8v19n850", RSMU_SL },

	{ "8v19n851", RSMU_SL },

	{}

};

MODULE_DEVICE_TABLE(i2c, rsmu_i2c_id);



static const struct of_device_id rsmu_i2c_of_match[] = {

	{ .compatible = "idt,8a34000",  .data = (void *)RSMU_CM },

	{ .compatible = "idt,8a34001",  .data = (void *)RSMU_CM },

	{ .compatible = "idt,82p33810", .data = (void *)RSMU_SABRE },

	{ .compatible = "idt,82p33811", .data = (void *)RSMU_SABRE },

	{ .compatible = "idt,8v19n850", .data = (void *)RSMU_SL },

	{ .compatible = "idt,8v19n851", .data = (void *)RSMU_SL },

	{}

};

MODULE_DEVICE_TABLE(of, rsmu_i2c_of_match);



static struct i2c_driver rsmu_i2c_driver = {

	.driver = {

		.name = "rsmu-i2c",

		.of_match_table = of_match_ptr(rsmu_i2c_of_match),

	},

	.probe = rsmu_i2c_probe,

	.remove	= rsmu_i2c_remove,

	.id_table = rsmu_i2c_id,

};



static int __init rsmu_i2c_init(void)

{

	return i2c_add_driver(&rsmu_i2c_driver);

}

subsys_initcall(rsmu_i2c_init);



static void __exit rsmu_i2c_exit(void)

{

	i2c_del_driver(&rsmu_i2c_driver);

}

module_exit(rsmu_i2c_exit);



MODULE_DESCRIPTION("Renesas SMU I2C driver");

MODULE_LICENSE("GPL");