drivers/mfd/rsmu_spi.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * SPI driver for Renesas Synchronization Management Unit (SMU) devices.
0004  *
0005  * Copyright (C) 2021 Integrated Device Technology, Inc., a Renesas Company.
0006  */
0007
0008 #include <linux/init.h>
0009 #include <linux/kernel.h>
0010 #include <linux/mfd/core.h>
0011 #include <linux/mfd/rsmu.h>
0012 #include <linux/module.h>
0013 #include <linux/of.h>
0014 #include <linux/regmap.h>
0015 #include <linux/slab.h>
0016 #include <linux/spi/spi.h>
0017
0018 #include "rsmu.h"
0019
0020 #define RSMU_CM_PAGE_ADDR       0x7C
0021 #define RSMU_SABRE_PAGE_ADDR        0x7F
0022 #define RSMU_HIGHER_ADDR_MASK       0xFF80
0023 #define RSMU_HIGHER_ADDR_SHIFT      7
0024 #define RSMU_LOWER_ADDR_MASK        0x7F
0025
0026 static int rsmu_read_device(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u16 bytes)
0027 {
0028     struct spi_device *client = to_spi_device(rsmu->dev);
0029     struct spi_transfer xfer = {0};
0030     struct spi_message msg;
0031     u8 cmd[256] = {0};
0032     u8 rsp[256] = {0};
0033     int ret;
0034
0035     cmd[0] = reg | 0x80;
0036     xfer.rx_buf = rsp;
0037     xfer.len = bytes + 1;
0038     xfer.tx_buf = cmd;
0039     xfer.bits_per_word = client->bits_per_word;
0040     xfer.speed_hz = client->max_speed_hz;
0041
0042     spi_message_init(&msg);
0043     spi_message_add_tail(&xfer, &msg);
0044
0045     /*
0046      * 4-wire SPI is a shift register, so for every byte you send,
0047      * you get one back at the same time. Example read from 0xC024,
0048      * which has value of 0x2D
0049      *
0050      * MOSI:
0051      *       7C 00 C0 #Set page register
0052      *       A4 00    #MSB is set, so this is read command
0053      * MISO:
0054      *       XX 2D    #XX is a dummy byte from sending A4 and we
0055      *                 need to throw it away
0056      */
0057     ret = spi_sync(client, &msg);
0058     if (ret >= 0)
0059         memcpy(buf, &rsp[1], xfer.len-1);
0060
0061     return ret;
0062 }
0063
0064 static int rsmu_write_device(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u16 bytes)
0065 {
0066     struct spi_device *client = to_spi_device(rsmu->dev);
0067     struct spi_transfer xfer = {0};
0068     struct spi_message msg;
0069     u8 cmd[256] = {0};
0070
0071     cmd[0] = reg;
0072     memcpy(&cmd[1], buf, bytes);
0073
0074     xfer.len = bytes + 1;
0075     xfer.tx_buf = cmd;
0076     xfer.bits_per_word = client->bits_per_word;
0077     xfer.speed_hz = client->max_speed_hz;
0078     spi_message_init(&msg);
0079     spi_message_add_tail(&xfer, &msg);
0080
0081     return  spi_sync(client, &msg);
0082 }
0083
0084 /*
0085  * 1-byte (1B) offset addressing:
0086  * 16-bit register address: the lower 7 bits of the register address come
0087  * from the offset addr byte and the upper 9 bits come from the page register.
0088  */
0089 static int rsmu_write_page_register(struct rsmu_ddata *rsmu, u16 reg)
0090 {
0091     u8 page_reg;
0092     u8 buf[2];
0093     u16 bytes;
0094     u16 page;
0095     int err;
0096
0097     switch (rsmu->type) {
0098     case RSMU_CM:
0099         page_reg = RSMU_CM_PAGE_ADDR;
0100         page = reg & RSMU_HIGHER_ADDR_MASK;
0101         buf[0] = (u8)(page & 0xff);
0102         buf[1] = (u8)((page >> 8) & 0xff);
0103         bytes = 2;
0104         break;
0105     case RSMU_SABRE:
0106         page_reg = RSMU_SABRE_PAGE_ADDR;
0107         page = reg >> RSMU_HIGHER_ADDR_SHIFT;
0108         buf[0] = (u8)(page & 0xff);
0109         bytes = 1;
0110         break;
0111     default:
0112         dev_err(rsmu->dev, "Unsupported RSMU device type: %d\n", rsmu->type);
0113         return -ENODEV;
0114     }
0115
0116     /* Simply return if we are on the same page */
0117     if (rsmu->page == page)
0118         return 0;
0119
0120     err = rsmu_write_device(rsmu, page_reg, buf, bytes);
0121     if (err)
0122         dev_err(rsmu->dev, "Failed to set page offset 0x%x\n", page);
0123     else
0124         /* Remember the last page */
0125         rsmu->page = page;
0126
0127     return err;
0128 }
0129
0130 static int rsmu_reg_read(void *context, unsigned int reg, unsigned int *val)
0131 {
0132     struct rsmu_ddata *rsmu = spi_get_drvdata((struct spi_device *)context);
0133     u8 addr = (u8)(reg & RSMU_LOWER_ADDR_MASK);
0134     int err;
0135
0136     err = rsmu_write_page_register(rsmu, reg);
0137     if (err)
0138         return err;
0139
0140     err = rsmu_read_device(rsmu, addr, (u8 *)val, 1);
0141     if (err)
0142         dev_err(rsmu->dev, "Failed to read offset address 0x%x\n", addr);
0143
0144     return err;
0145 }
0146
0147 static int rsmu_reg_write(void *context, unsigned int reg, unsigned int val)
0148 {
0149     struct rsmu_ddata *rsmu = spi_get_drvdata((struct spi_device *)context);
0150     u8 addr = (u8)(reg & RSMU_LOWER_ADDR_MASK);
0151     u8 data = (u8)val;
0152     int err;
0153
0154     err = rsmu_write_page_register(rsmu, reg);
0155     if (err)
0156         return err;
0157
0158     err = rsmu_write_device(rsmu, addr, &data, 1);
0159     if (err)
0160         dev_err(rsmu->dev,
0161             "Failed to write offset address 0x%x\n", addr);
0162
0163     return err;
0164 }
0165
0166 static const struct regmap_config rsmu_cm_regmap_config = {
0167     .reg_bits = 16,
0168     .val_bits = 8,
0169     .max_register = 0xD000,
0170     .reg_read = rsmu_reg_read,
0171     .reg_write = rsmu_reg_write,
0172     .cache_type = REGCACHE_NONE,
0173 };
0174
0175 static const struct regmap_config rsmu_sabre_regmap_config = {
0176     .reg_bits = 16,
0177     .val_bits = 8,
0178     .max_register = 0x400,
0179     .reg_read = rsmu_reg_read,
0180     .reg_write = rsmu_reg_write,
0181     .cache_type = REGCACHE_NONE,
0182 };
0183
0184 static int rsmu_spi_probe(struct spi_device *client)
0185 {
0186     const struct spi_device_id *id = spi_get_device_id(client);
0187     const struct regmap_config *cfg;
0188     struct rsmu_ddata *rsmu;
0189     int ret;
0190
0191     rsmu = devm_kzalloc(&client->dev, sizeof(*rsmu), GFP_KERNEL);
0192     if (!rsmu)
0193         return -ENOMEM;
0194
0195     spi_set_drvdata(client, rsmu);
0196
0197     rsmu->dev = &client->dev;
0198     rsmu->type = (enum rsmu_type)id->driver_data;
0199
0200     /* Initialize regmap */
0201     switch (rsmu->type) {
0202     case RSMU_CM:
0203         cfg = &rsmu_cm_regmap_config;
0204         break;
0205     case RSMU_SABRE:
0206         cfg = &rsmu_sabre_regmap_config;
0207         break;
0208     default:
0209         dev_err(rsmu->dev, "Unsupported RSMU device type: %d\n", rsmu->type);
0210         return -ENODEV;
0211     }
0212
0213     rsmu->regmap = devm_regmap_init(&client->dev, NULL, client, cfg);
0214     if (IS_ERR(rsmu->regmap)) {
0215         ret = PTR_ERR(rsmu->regmap);
0216         dev_err(rsmu->dev, "Failed to allocate register map: %d\n", ret);
0217         return ret;
0218     }
0219
0220     return rsmu_core_init(rsmu);
0221 }
0222
0223 static void rsmu_spi_remove(struct spi_device *client)
0224 {
0225     struct rsmu_ddata *rsmu = spi_get_drvdata(client);
0226
0227     rsmu_core_exit(rsmu);
0228 }
0229
0230 static const struct spi_device_id rsmu_spi_id[] = {
0231     { "8a34000",  RSMU_CM },
0232     { "8a34001",  RSMU_CM },
0233     { "82p33810", RSMU_SABRE },
0234     { "82p33811", RSMU_SABRE },
0235     {}
0236 };
0237 MODULE_DEVICE_TABLE(spi, rsmu_spi_id);
0238
0239 static const struct of_device_id rsmu_spi_of_match[] = {
0240     { .compatible = "idt,8a34000",  .data = (void *)RSMU_CM },
0241     { .compatible = "idt,8a34001",  .data = (void *)RSMU_CM },
0242     { .compatible = "idt,82p33810", .data = (void *)RSMU_SABRE },
0243     { .compatible = "idt,82p33811", .data = (void *)RSMU_SABRE },
0244     {}
0245 };
0246 MODULE_DEVICE_TABLE(of, rsmu_spi_of_match);
0247
0248 static struct spi_driver rsmu_spi_driver = {
0249     .driver = {
0250         .name = "rsmu-spi",
0251         .of_match_table = of_match_ptr(rsmu_spi_of_match),
0252     },
0253     .probe = rsmu_spi_probe,
0254     .remove = rsmu_spi_remove,
0255     .id_table = rsmu_spi_id,
0256 };
0257
0258 static int __init rsmu_spi_init(void)
0259 {
0260     return spi_register_driver(&rsmu_spi_driver);
0261 }
0262 subsys_initcall(rsmu_spi_init);
0263
0264 static void __exit rsmu_spi_exit(void)
0265 {
0266     spi_unregister_driver(&rsmu_spi_driver);
0267 }
0268 module_exit(rsmu_spi_exit);
0269
0270 MODULE_DESCRIPTION("Renesas SMU SPI driver");
0271 MODULE_LICENSE("GPL");