1a1867f85SMin Li // SPDX-License-Identifier: GPL-2.0+
2a1867f85SMin Li /*
3a1867f85SMin Li * I2C driver for Renesas Synchronization Management Unit (SMU) devices.
4a1867f85SMin Li *
5a1867f85SMin Li * Copyright (C) 2021 Integrated Device Technology, Inc., a Renesas Company.
6a1867f85SMin Li */
7a1867f85SMin Li
8a1867f85SMin Li #include <linux/i2c.h>
9a1867f85SMin Li #include <linux/init.h>
10a1867f85SMin Li #include <linux/kernel.h>
11a1867f85SMin Li #include <linux/mfd/core.h>
12a1867f85SMin Li #include <linux/mfd/rsmu.h>
13a1867f85SMin Li #include <linux/module.h>
14a1867f85SMin Li #include <linux/of.h>
15a1867f85SMin Li #include <linux/regmap.h>
16a1867f85SMin Li #include <linux/slab.h>
17a1867f85SMin Li
18a1867f85SMin Li #include "rsmu.h"
19a1867f85SMin Li
20a1867f85SMin Li /*
2167d6c76fSMin Li * 32-bit register address: the lower 8 bits of the register address come
2267d6c76fSMin Li * from the offset addr byte and the upper 24 bits come from the page register.
23a1867f85SMin Li */
2467d6c76fSMin Li #define RSMU_CM_PAGE_ADDR 0xFC
2567d6c76fSMin Li #define RSMU_CM_PAGE_MASK 0xFFFFFF00
2667d6c76fSMin Li #define RSMU_CM_ADDRESS_MASK 0x000000FF
27a1867f85SMin Li
28a1867f85SMin Li /*
29a1867f85SMin Li * 15-bit register address: the lower 7 bits of the register address come
30a1867f85SMin Li * from the offset addr byte and the upper 8 bits come from the page register.
31a1867f85SMin Li */
32a1867f85SMin Li #define RSMU_SABRE_PAGE_ADDR 0x7F
33a1867f85SMin Li #define RSMU_SABRE_PAGE_WINDOW 128
34a1867f85SMin Li
35a1867f85SMin Li static const struct regmap_range_cfg rsmu_sabre_range_cfg[] = {
36a1867f85SMin Li {
37a1867f85SMin Li .range_min = 0,
38a1867f85SMin Li .range_max = 0x400,
39a1867f85SMin Li .selector_reg = RSMU_SABRE_PAGE_ADDR,
40a1867f85SMin Li .selector_mask = 0xFF,
41a1867f85SMin Li .selector_shift = 0,
42a1867f85SMin Li .window_start = 0,
43a1867f85SMin Li .window_len = RSMU_SABRE_PAGE_WINDOW,
44a1867f85SMin Li }
45a1867f85SMin Li };
46a1867f85SMin Li
rsmu_sabre_volatile_reg(struct device * dev,unsigned int reg)47a1867f85SMin Li static bool rsmu_sabre_volatile_reg(struct device *dev, unsigned int reg)
48a1867f85SMin Li {
49a1867f85SMin Li switch (reg) {
50a1867f85SMin Li case RSMU_SABRE_PAGE_ADDR:
51a1867f85SMin Li return false;
52a1867f85SMin Li default:
53a1867f85SMin Li return true;
54a1867f85SMin Li }
55a1867f85SMin Li }
56a1867f85SMin Li
rsmu_read_device(struct rsmu_ddata * rsmu,u8 reg,u8 * buf,u16 bytes)5767d6c76fSMin Li static int rsmu_read_device(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u16 bytes)
5867d6c76fSMin Li {
5967d6c76fSMin Li struct i2c_client *client = to_i2c_client(rsmu->dev);
6067d6c76fSMin Li struct i2c_msg msg[2];
6167d6c76fSMin Li int cnt;
6267d6c76fSMin Li
6367d6c76fSMin Li msg[0].addr = client->addr;
6467d6c76fSMin Li msg[0].flags = 0;
6567d6c76fSMin Li msg[0].len = 1;
6667d6c76fSMin Li msg[0].buf = ®
6767d6c76fSMin Li
6867d6c76fSMin Li msg[1].addr = client->addr;
6967d6c76fSMin Li msg[1].flags = I2C_M_RD;
7067d6c76fSMin Li msg[1].len = bytes;
7167d6c76fSMin Li msg[1].buf = buf;
7267d6c76fSMin Li
7367d6c76fSMin Li cnt = i2c_transfer(client->adapter, msg, 2);
7467d6c76fSMin Li
7567d6c76fSMin Li if (cnt < 0) {
7667d6c76fSMin Li dev_err(rsmu->dev, "i2c_transfer failed at addr: %04x!", reg);
7767d6c76fSMin Li return cnt;
7867d6c76fSMin Li } else if (cnt != 2) {
7967d6c76fSMin Li dev_err(rsmu->dev,
8067d6c76fSMin Li "i2c_transfer sent only %d of 2 messages", cnt);
8167d6c76fSMin Li return -EIO;
8267d6c76fSMin Li }
8367d6c76fSMin Li
8467d6c76fSMin Li return 0;
8567d6c76fSMin Li }
8667d6c76fSMin Li
rsmu_write_device(struct rsmu_ddata * rsmu,u8 reg,u8 * buf,u16 bytes)8767d6c76fSMin Li static int rsmu_write_device(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u16 bytes)
8867d6c76fSMin Li {
8967d6c76fSMin Li struct i2c_client *client = to_i2c_client(rsmu->dev);
9067d6c76fSMin Li u8 msg[RSMU_MAX_WRITE_COUNT + 1]; /* 1 Byte added for the device register */
9167d6c76fSMin Li int cnt;
9267d6c76fSMin Li
9367d6c76fSMin Li if (bytes > RSMU_MAX_WRITE_COUNT)
9467d6c76fSMin Li return -EINVAL;
9567d6c76fSMin Li
9667d6c76fSMin Li msg[0] = reg;
9767d6c76fSMin Li memcpy(&msg[1], buf, bytes);
9867d6c76fSMin Li
9967d6c76fSMin Li cnt = i2c_master_send(client, msg, bytes + 1);
10067d6c76fSMin Li
10167d6c76fSMin Li if (cnt < 0) {
10267d6c76fSMin Li dev_err(&client->dev,
10367d6c76fSMin Li "i2c_master_send failed at addr: %04x!", reg);
10467d6c76fSMin Li return cnt;
10567d6c76fSMin Li }
10667d6c76fSMin Li
10767d6c76fSMin Li return 0;
10867d6c76fSMin Li }
10967d6c76fSMin Li
rsmu_write_page_register(struct rsmu_ddata * rsmu,u32 reg)11067d6c76fSMin Li static int rsmu_write_page_register(struct rsmu_ddata *rsmu, u32 reg)
11167d6c76fSMin Li {
11267d6c76fSMin Li u32 page = reg & RSMU_CM_PAGE_MASK;
11367d6c76fSMin Li u8 buf[4];
11467d6c76fSMin Li int err;
11567d6c76fSMin Li
11667d6c76fSMin Li /* Do not modify offset register for none-scsr registers */
11767d6c76fSMin Li if (reg < RSMU_CM_SCSR_BASE)
11867d6c76fSMin Li return 0;
11967d6c76fSMin Li
12067d6c76fSMin Li /* Simply return if we are on the same page */
12167d6c76fSMin Li if (rsmu->page == page)
12267d6c76fSMin Li return 0;
12367d6c76fSMin Li
12467d6c76fSMin Li buf[0] = 0x0;
12567d6c76fSMin Li buf[1] = (u8)((page >> 8) & 0xFF);
12667d6c76fSMin Li buf[2] = (u8)((page >> 16) & 0xFF);
12767d6c76fSMin Li buf[3] = (u8)((page >> 24) & 0xFF);
12867d6c76fSMin Li
12967d6c76fSMin Li err = rsmu_write_device(rsmu, RSMU_CM_PAGE_ADDR, buf, sizeof(buf));
13067d6c76fSMin Li if (err)
13167d6c76fSMin Li dev_err(rsmu->dev, "Failed to set page offset 0x%x\n", page);
13267d6c76fSMin Li else
13367d6c76fSMin Li /* Remember the last page */
13467d6c76fSMin Li rsmu->page = page;
13567d6c76fSMin Li
13667d6c76fSMin Li return err;
13767d6c76fSMin Li }
13867d6c76fSMin Li
rsmu_reg_read(void * context,unsigned int reg,unsigned int * val)13967d6c76fSMin Li static int rsmu_reg_read(void *context, unsigned int reg, unsigned int *val)
14067d6c76fSMin Li {
14167d6c76fSMin Li struct rsmu_ddata *rsmu = i2c_get_clientdata((struct i2c_client *)context);
14267d6c76fSMin Li u8 addr = (u8)(reg & RSMU_CM_ADDRESS_MASK);
14367d6c76fSMin Li int err;
14467d6c76fSMin Li
14567d6c76fSMin Li err = rsmu_write_page_register(rsmu, reg);
14667d6c76fSMin Li if (err)
14767d6c76fSMin Li return err;
14867d6c76fSMin Li
14967d6c76fSMin Li err = rsmu_read_device(rsmu, addr, (u8 *)val, 1);
15067d6c76fSMin Li if (err)
15167d6c76fSMin Li dev_err(rsmu->dev, "Failed to read offset address 0x%x\n", addr);
15267d6c76fSMin Li
15367d6c76fSMin Li return err;
15467d6c76fSMin Li }
15567d6c76fSMin Li
rsmu_reg_write(void * context,unsigned int reg,unsigned int val)15667d6c76fSMin Li static int rsmu_reg_write(void *context, unsigned int reg, unsigned int val)
15767d6c76fSMin Li {
15867d6c76fSMin Li struct rsmu_ddata *rsmu = i2c_get_clientdata((struct i2c_client *)context);
15967d6c76fSMin Li u8 addr = (u8)(reg & RSMU_CM_ADDRESS_MASK);
16067d6c76fSMin Li u8 data = (u8)val;
16167d6c76fSMin Li int err;
16267d6c76fSMin Li
16367d6c76fSMin Li err = rsmu_write_page_register(rsmu, reg);
16467d6c76fSMin Li if (err)
16567d6c76fSMin Li return err;
16667d6c76fSMin Li
16767d6c76fSMin Li err = rsmu_write_device(rsmu, addr, &data, 1);
16867d6c76fSMin Li if (err)
16967d6c76fSMin Li dev_err(rsmu->dev,
17067d6c76fSMin Li "Failed to write offset address 0x%x\n", addr);
17167d6c76fSMin Li
17267d6c76fSMin Li return err;
17367d6c76fSMin Li }
17467d6c76fSMin Li
175a1867f85SMin Li static const struct regmap_config rsmu_cm_regmap_config = {
17667d6c76fSMin Li .reg_bits = 32,
177a1867f85SMin Li .val_bits = 8,
17867d6c76fSMin Li .max_register = 0x20120000,
17967d6c76fSMin Li .reg_read = rsmu_reg_read,
18067d6c76fSMin Li .reg_write = rsmu_reg_write,
18167d6c76fSMin Li .cache_type = REGCACHE_NONE,
182a1867f85SMin Li };
183a1867f85SMin Li
184a1867f85SMin Li static const struct regmap_config rsmu_sabre_regmap_config = {
185a1867f85SMin Li .reg_bits = 8,
186a1867f85SMin Li .val_bits = 8,
187a1867f85SMin Li .max_register = 0x400,
188a1867f85SMin Li .ranges = rsmu_sabre_range_cfg,
189a1867f85SMin Li .num_ranges = ARRAY_SIZE(rsmu_sabre_range_cfg),
190a1867f85SMin Li .volatile_reg = rsmu_sabre_volatile_reg,
191a1867f85SMin Li .cache_type = REGCACHE_RBTREE,
192a1867f85SMin Li .can_multi_write = true,
193a1867f85SMin Li };
194a1867f85SMin Li
195a1867f85SMin Li static const struct regmap_config rsmu_sl_regmap_config = {
196a1867f85SMin Li .reg_bits = 16,
197a1867f85SMin Li .val_bits = 8,
198a1867f85SMin Li .reg_format_endian = REGMAP_ENDIAN_BIG,
19967d6c76fSMin Li .max_register = 0x340,
200a1867f85SMin Li .cache_type = REGCACHE_NONE,
201a1867f85SMin Li .can_multi_write = true,
202a1867f85SMin Li };
203a1867f85SMin Li
rsmu_i2c_probe(struct i2c_client * client)204a29f5a3eSUwe Kleine-König static int rsmu_i2c_probe(struct i2c_client *client)
205a1867f85SMin Li {
206a29f5a3eSUwe Kleine-König const struct i2c_device_id *id = i2c_client_get_device_id(client);
207a1867f85SMin Li const struct regmap_config *cfg;
208a1867f85SMin Li struct rsmu_ddata *rsmu;
209a1867f85SMin Li int ret;
210a1867f85SMin Li
211a1867f85SMin Li rsmu = devm_kzalloc(&client->dev, sizeof(*rsmu), GFP_KERNEL);
212a1867f85SMin Li if (!rsmu)
213a1867f85SMin Li return -ENOMEM;
214a1867f85SMin Li
215a1867f85SMin Li i2c_set_clientdata(client, rsmu);
216a1867f85SMin Li
217a1867f85SMin Li rsmu->dev = &client->dev;
218a1867f85SMin Li rsmu->type = (enum rsmu_type)id->driver_data;
219a1867f85SMin Li
220a1867f85SMin Li switch (rsmu->type) {
221a1867f85SMin Li case RSMU_CM:
222a1867f85SMin Li cfg = &rsmu_cm_regmap_config;
223a1867f85SMin Li break;
224a1867f85SMin Li case RSMU_SABRE:
225a1867f85SMin Li cfg = &rsmu_sabre_regmap_config;
226a1867f85SMin Li break;
227a1867f85SMin Li case RSMU_SL:
228a1867f85SMin Li cfg = &rsmu_sl_regmap_config;
229a1867f85SMin Li break;
230a1867f85SMin Li default:
231a1867f85SMin Li dev_err(rsmu->dev, "Unsupported RSMU device type: %d\n", rsmu->type);
232a1867f85SMin Li return -ENODEV;
233a1867f85SMin Li }
23467d6c76fSMin Li
23567d6c76fSMin Li if (rsmu->type == RSMU_CM)
23667d6c76fSMin Li rsmu->regmap = devm_regmap_init(&client->dev, NULL, client, cfg);
23767d6c76fSMin Li else
238a1867f85SMin Li rsmu->regmap = devm_regmap_init_i2c(client, cfg);
239a1867f85SMin Li if (IS_ERR(rsmu->regmap)) {
240a1867f85SMin Li ret = PTR_ERR(rsmu->regmap);
241a1867f85SMin Li dev_err(rsmu->dev, "Failed to allocate register map: %d\n", ret);
242a1867f85SMin Li return ret;
243a1867f85SMin Li }
244a1867f85SMin Li
245a1867f85SMin Li return rsmu_core_init(rsmu);
246a1867f85SMin Li }
247a1867f85SMin Li
rsmu_i2c_remove(struct i2c_client * client)248ed5c2f5fSUwe Kleine-König static void rsmu_i2c_remove(struct i2c_client *client)
249a1867f85SMin Li {
250a1867f85SMin Li struct rsmu_ddata *rsmu = i2c_get_clientdata(client);
251a1867f85SMin Li
252a1867f85SMin Li rsmu_core_exit(rsmu);
253a1867f85SMin Li }
254a1867f85SMin Li
255a1867f85SMin Li static const struct i2c_device_id rsmu_i2c_id[] = {
256a1867f85SMin Li { "8a34000", RSMU_CM },
257a1867f85SMin Li { "8a34001", RSMU_CM },
258a1867f85SMin Li { "82p33810", RSMU_SABRE },
259a1867f85SMin Li { "82p33811", RSMU_SABRE },
260a1867f85SMin Li { "8v19n850", RSMU_SL },
261a1867f85SMin Li { "8v19n851", RSMU_SL },
262a1867f85SMin Li {}
263a1867f85SMin Li };
264a1867f85SMin Li MODULE_DEVICE_TABLE(i2c, rsmu_i2c_id);
265a1867f85SMin Li
266a1867f85SMin Li static const struct of_device_id rsmu_i2c_of_match[] = {
267a1867f85SMin Li { .compatible = "idt,8a34000", .data = (void *)RSMU_CM },
268a1867f85SMin Li { .compatible = "idt,8a34001", .data = (void *)RSMU_CM },
269a1867f85SMin Li { .compatible = "idt,82p33810", .data = (void *)RSMU_SABRE },
270a1867f85SMin Li { .compatible = "idt,82p33811", .data = (void *)RSMU_SABRE },
271a1867f85SMin Li { .compatible = "idt,8v19n850", .data = (void *)RSMU_SL },
272a1867f85SMin Li { .compatible = "idt,8v19n851", .data = (void *)RSMU_SL },
273a1867f85SMin Li {}
274a1867f85SMin Li };
275a1867f85SMin Li MODULE_DEVICE_TABLE(of, rsmu_i2c_of_match);
276a1867f85SMin Li
277a1867f85SMin Li static struct i2c_driver rsmu_i2c_driver = {
278a1867f85SMin Li .driver = {
279a1867f85SMin Li .name = "rsmu-i2c",
280*e158e08aSZhu Wang .of_match_table = rsmu_i2c_of_match,
281a1867f85SMin Li },
2829816d859SUwe Kleine-König .probe = rsmu_i2c_probe,
283a1867f85SMin Li .remove = rsmu_i2c_remove,
284a1867f85SMin Li .id_table = rsmu_i2c_id,
285a1867f85SMin Li };
286a1867f85SMin Li
rsmu_i2c_init(void)287a1867f85SMin Li static int __init rsmu_i2c_init(void)
288a1867f85SMin Li {
289a1867f85SMin Li return i2c_add_driver(&rsmu_i2c_driver);
290a1867f85SMin Li }
291a1867f85SMin Li subsys_initcall(rsmu_i2c_init);
292a1867f85SMin Li
rsmu_i2c_exit(void)293a1867f85SMin Li static void __exit rsmu_i2c_exit(void)
294a1867f85SMin Li {
295a1867f85SMin Li i2c_del_driver(&rsmu_i2c_driver);
296a1867f85SMin Li }
297a1867f85SMin Li module_exit(rsmu_i2c_exit);
298a1867f85SMin Li
299a1867f85SMin Li MODULE_DESCRIPTION("Renesas SMU I2C driver");
300a1867f85SMin Li MODULE_LICENSE("GPL");
301