1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * I2C driver for Renesas Synchronization Management Unit (SMU) devices. 4 * 5 * Copyright (C) 2021 Integrated Device Technology, Inc., a Renesas Company. 6 */ 7 8 #include <linux/i2c.h> 9 #include <linux/init.h> 10 #include <linux/kernel.h> 11 #include <linux/mfd/core.h> 12 #include <linux/mfd/rsmu.h> 13 #include <linux/module.h> 14 #include <linux/of.h> 15 #include <linux/regmap.h> 16 #include <linux/slab.h> 17 18 #include "rsmu.h" 19 20 /* 21 * 32-bit register address: the lower 8 bits of the register address come 22 * from the offset addr byte and the upper 24 bits come from the page register. 23 */ 24 #define RSMU_CM_PAGE_ADDR 0xFC 25 #define RSMU_CM_PAGE_MASK 0xFFFFFF00 26 #define RSMU_CM_ADDRESS_MASK 0x000000FF 27 28 /* 29 * 15-bit register address: the lower 7 bits of the register address come 30 * from the offset addr byte and the upper 8 bits come from the page register. 31 */ 32 #define RSMU_SABRE_PAGE_ADDR 0x7F 33 #define RSMU_SABRE_PAGE_WINDOW 128 34 35 typedef int (*rsmu_rw_device)(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u8 bytes); 36 37 static const struct regmap_range_cfg rsmu_sabre_range_cfg[] = { 38 { 39 .range_min = 0, 40 .range_max = 0x400, 41 .selector_reg = RSMU_SABRE_PAGE_ADDR, 42 .selector_mask = 0xFF, 43 .selector_shift = 0, 44 .window_start = 0, 45 .window_len = RSMU_SABRE_PAGE_WINDOW, 46 } 47 }; 48 49 static bool rsmu_sabre_volatile_reg(struct device *dev, unsigned int reg) 50 { 51 switch (reg) { 52 case RSMU_SABRE_PAGE_ADDR: 53 return false; 54 default: 55 return true; 56 } 57 } 58 59 static int rsmu_smbus_i2c_write_device(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u8 bytes) 60 { 61 struct i2c_client *client = to_i2c_client(rsmu->dev); 62 63 return i2c_smbus_write_i2c_block_data(client, reg, bytes, buf); 64 } 65 66 static int rsmu_smbus_i2c_read_device(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u8 bytes) 67 { 68 struct i2c_client *client = to_i2c_client(rsmu->dev); 69 int ret; 70 71 ret = i2c_smbus_read_i2c_block_data(client, reg, bytes, buf); 72 if (ret == bytes) 73 return 0; 74 else if (ret < 0) 75 return ret; 76 else 77 return -EIO; 78 } 79 80 static int rsmu_i2c_read_device(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u8 bytes) 81 { 82 struct i2c_client *client = to_i2c_client(rsmu->dev); 83 struct i2c_msg msg[2]; 84 int cnt; 85 86 msg[0].addr = client->addr; 87 msg[0].flags = 0; 88 msg[0].len = 1; 89 msg[0].buf = ® 90 91 msg[1].addr = client->addr; 92 msg[1].flags = I2C_M_RD; 93 msg[1].len = bytes; 94 msg[1].buf = buf; 95 96 cnt = i2c_transfer(client->adapter, msg, 2); 97 98 if (cnt < 0) { 99 dev_err(rsmu->dev, "i2c_transfer failed at addr: %04x!", reg); 100 return cnt; 101 } else if (cnt != 2) { 102 dev_err(rsmu->dev, 103 "i2c_transfer sent only %d of 2 messages", cnt); 104 return -EIO; 105 } 106 107 return 0; 108 } 109 110 static int rsmu_i2c_write_device(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u8 bytes) 111 { 112 struct i2c_client *client = to_i2c_client(rsmu->dev); 113 /* we add 1 byte for device register */ 114 u8 msg[RSMU_MAX_WRITE_COUNT + 1]; 115 int cnt; 116 117 if (bytes > RSMU_MAX_WRITE_COUNT) 118 return -EINVAL; 119 120 msg[0] = reg; 121 memcpy(&msg[1], buf, bytes); 122 123 cnt = i2c_master_send(client, msg, bytes + 1); 124 125 if (cnt < 0) { 126 dev_err(&client->dev, 127 "i2c_master_send failed at addr: %04x!", reg); 128 return cnt; 129 } 130 131 return 0; 132 } 133 134 static int rsmu_write_page_register(struct rsmu_ddata *rsmu, u32 reg, 135 rsmu_rw_device rsmu_write_device) 136 { 137 u32 page = (reg | RSMU_CM_SCSR_BASE) & RSMU_CM_PAGE_MASK; 138 u8 buf[4]; 139 int err; 140 141 /* Simply return if we are on the same page */ 142 if (rsmu->page == page) 143 return 0; 144 145 buf[0] = 0x0; 146 buf[1] = (u8)((page >> 8) & 0xFF); 147 buf[2] = (u8)((page >> 16) & 0xFF); 148 buf[3] = (u8)((page >> 24) & 0xFF); 149 150 err = rsmu_write_device(rsmu, RSMU_CM_PAGE_ADDR, buf, sizeof(buf)); 151 if (err) 152 dev_err(rsmu->dev, "Failed to set page offset 0x%x\n", page); 153 else 154 /* Remember the last page */ 155 rsmu->page = page; 156 157 return err; 158 } 159 160 static int rsmu_i2c_reg_read(void *context, unsigned int reg, unsigned int *val) 161 { 162 struct rsmu_ddata *rsmu = i2c_get_clientdata((struct i2c_client *)context); 163 u8 addr = (u8)(reg & RSMU_CM_ADDRESS_MASK); 164 int err; 165 166 err = rsmu_write_page_register(rsmu, reg, rsmu_i2c_write_device); 167 if (err) 168 return err; 169 170 err = rsmu_i2c_read_device(rsmu, addr, (u8 *)val, 1); 171 if (err) 172 dev_err(rsmu->dev, "Failed to read offset address 0x%x\n", addr); 173 174 return err; 175 } 176 177 static int rsmu_i2c_reg_write(void *context, unsigned int reg, unsigned int val) 178 { 179 struct rsmu_ddata *rsmu = i2c_get_clientdata((struct i2c_client *)context); 180 u8 addr = (u8)(reg & RSMU_CM_ADDRESS_MASK); 181 u8 data = (u8)val; 182 int err; 183 184 err = rsmu_write_page_register(rsmu, reg, rsmu_i2c_write_device); 185 if (err) 186 return err; 187 188 err = rsmu_i2c_write_device(rsmu, addr, &data, 1); 189 if (err) 190 dev_err(rsmu->dev, 191 "Failed to write offset address 0x%x\n", addr); 192 193 return err; 194 } 195 196 static int rsmu_smbus_i2c_reg_read(void *context, unsigned int reg, unsigned int *val) 197 { 198 struct rsmu_ddata *rsmu = i2c_get_clientdata((struct i2c_client *)context); 199 u8 addr = (u8)(reg & RSMU_CM_ADDRESS_MASK); 200 int err; 201 202 err = rsmu_write_page_register(rsmu, reg, rsmu_smbus_i2c_write_device); 203 if (err) 204 return err; 205 206 err = rsmu_smbus_i2c_read_device(rsmu, addr, (u8 *)val, 1); 207 if (err) 208 dev_err(rsmu->dev, "Failed to read offset address 0x%x\n", addr); 209 210 return err; 211 } 212 213 static int rsmu_smbus_i2c_reg_write(void *context, unsigned int reg, unsigned int val) 214 { 215 struct rsmu_ddata *rsmu = i2c_get_clientdata((struct i2c_client *)context); 216 u8 addr = (u8)(reg & RSMU_CM_ADDRESS_MASK); 217 u8 data = (u8)val; 218 int err; 219 220 err = rsmu_write_page_register(rsmu, reg, rsmu_smbus_i2c_write_device); 221 if (err) 222 return err; 223 224 err = rsmu_smbus_i2c_write_device(rsmu, addr, &data, 1); 225 if (err) 226 dev_err(rsmu->dev, 227 "Failed to write offset address 0x%x\n", addr); 228 229 return err; 230 } 231 232 static const struct regmap_config rsmu_i2c_cm_regmap_config = { 233 .reg_bits = 32, 234 .val_bits = 8, 235 .max_register = 0x20120000, 236 .reg_read = rsmu_i2c_reg_read, 237 .reg_write = rsmu_i2c_reg_write, 238 .cache_type = REGCACHE_NONE, 239 }; 240 241 static const struct regmap_config rsmu_smbus_i2c_cm_regmap_config = { 242 .reg_bits = 32, 243 .val_bits = 8, 244 .max_register = 0x20120000, 245 .reg_read = rsmu_smbus_i2c_reg_read, 246 .reg_write = rsmu_smbus_i2c_reg_write, 247 .cache_type = REGCACHE_NONE, 248 }; 249 250 static const struct regmap_config rsmu_sabre_regmap_config = { 251 .reg_bits = 8, 252 .val_bits = 8, 253 .max_register = 0x400, 254 .ranges = rsmu_sabre_range_cfg, 255 .num_ranges = ARRAY_SIZE(rsmu_sabre_range_cfg), 256 .volatile_reg = rsmu_sabre_volatile_reg, 257 .cache_type = REGCACHE_MAPLE, 258 .can_multi_write = true, 259 }; 260 261 static const struct regmap_config rsmu_sl_regmap_config = { 262 .reg_bits = 16, 263 .val_bits = 8, 264 .reg_format_endian = REGMAP_ENDIAN_BIG, 265 .max_register = 0x340, 266 .cache_type = REGCACHE_NONE, 267 .can_multi_write = true, 268 }; 269 270 static int rsmu_i2c_probe(struct i2c_client *client) 271 { 272 const struct i2c_device_id *id = i2c_client_get_device_id(client); 273 const struct regmap_config *cfg; 274 struct rsmu_ddata *rsmu; 275 int ret; 276 277 rsmu = devm_kzalloc(&client->dev, sizeof(*rsmu), GFP_KERNEL); 278 if (!rsmu) 279 return -ENOMEM; 280 281 i2c_set_clientdata(client, rsmu); 282 283 rsmu->dev = &client->dev; 284 rsmu->type = (enum rsmu_type)id->driver_data; 285 286 switch (rsmu->type) { 287 case RSMU_CM: 288 if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 289 cfg = &rsmu_i2c_cm_regmap_config; 290 } else if (i2c_check_functionality(client->adapter, 291 I2C_FUNC_SMBUS_I2C_BLOCK)) { 292 cfg = &rsmu_smbus_i2c_cm_regmap_config; 293 } else { 294 dev_err(rsmu->dev, "Unsupported i2c adapter\n"); 295 return -ENOTSUPP; 296 } 297 break; 298 case RSMU_SABRE: 299 cfg = &rsmu_sabre_regmap_config; 300 break; 301 case RSMU_SL: 302 cfg = &rsmu_sl_regmap_config; 303 break; 304 default: 305 dev_err(rsmu->dev, "Unsupported RSMU device type: %d\n", rsmu->type); 306 return -ENODEV; 307 } 308 309 if (rsmu->type == RSMU_CM) 310 rsmu->regmap = devm_regmap_init(&client->dev, NULL, client, cfg); 311 else 312 rsmu->regmap = devm_regmap_init_i2c(client, cfg); 313 314 if (IS_ERR(rsmu->regmap)) { 315 ret = PTR_ERR(rsmu->regmap); 316 dev_err(rsmu->dev, "Failed to allocate register map: %d\n", ret); 317 return ret; 318 } 319 320 return rsmu_core_init(rsmu); 321 } 322 323 static void rsmu_i2c_remove(struct i2c_client *client) 324 { 325 struct rsmu_ddata *rsmu = i2c_get_clientdata(client); 326 327 rsmu_core_exit(rsmu); 328 } 329 330 static const struct i2c_device_id rsmu_i2c_id[] = { 331 { "8a34000", RSMU_CM }, 332 { "8a34001", RSMU_CM }, 333 { "8a34002", RSMU_CM }, 334 { "82p33810", RSMU_SABRE }, 335 { "82p33811", RSMU_SABRE }, 336 { "8v19n850", RSMU_SL }, 337 { "8v19n851", RSMU_SL }, 338 {} 339 }; 340 MODULE_DEVICE_TABLE(i2c, rsmu_i2c_id); 341 342 static const struct of_device_id rsmu_i2c_of_match[] = { 343 { .compatible = "idt,8a34000", .data = (void *)RSMU_CM }, 344 { .compatible = "idt,8a34001", .data = (void *)RSMU_CM }, 345 { .compatible = "idt,8a34002", .data = (void *)RSMU_CM }, 346 { .compatible = "idt,82p33810", .data = (void *)RSMU_SABRE }, 347 { .compatible = "idt,82p33811", .data = (void *)RSMU_SABRE }, 348 { .compatible = "idt,8v19n850", .data = (void *)RSMU_SL }, 349 { .compatible = "idt,8v19n851", .data = (void *)RSMU_SL }, 350 {} 351 }; 352 MODULE_DEVICE_TABLE(of, rsmu_i2c_of_match); 353 354 static struct i2c_driver rsmu_i2c_driver = { 355 .driver = { 356 .name = "rsmu-i2c", 357 .of_match_table = rsmu_i2c_of_match, 358 }, 359 .probe = rsmu_i2c_probe, 360 .remove = rsmu_i2c_remove, 361 .id_table = rsmu_i2c_id, 362 }; 363 364 static int __init rsmu_i2c_init(void) 365 { 366 return i2c_add_driver(&rsmu_i2c_driver); 367 } 368 subsys_initcall(rsmu_i2c_init); 369 370 static void __exit rsmu_i2c_exit(void) 371 { 372 i2c_del_driver(&rsmu_i2c_driver); 373 } 374 module_exit(rsmu_i2c_exit); 375 376 MODULE_DESCRIPTION("Renesas SMU I2C driver"); 377 MODULE_LICENSE("GPL"); 378