drivers/mfd/gateworks-gsc.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * The Gateworks System Controller (GSC) is a multi-function
0004  * device designed for use in Gateworks Single Board Computers.
0005  * The control interface is I2C, with an interrupt. The device supports
0006  * system functions such as push-button monitoring, multiple ADC's for
0007  * voltage and temperature monitoring, fan controller and watchdog monitor.
0008  *
0009  * Copyright (C) 2020 Gateworks Corporation
0010  */
0011
0012 #include <linux/device.h>
0013 #include <linux/i2c.h>
0014 #include <linux/interrupt.h>
0015 #include <linux/mfd/gsc.h>
0016 #include <linux/module.h>
0017 #include <linux/mutex.h>
0018 #include <linux/of.h>
0019 #include <linux/of_platform.h>
0020 #include <linux/platform_device.h>
0021 #include <linux/regmap.h>
0022
0023 #include <asm/unaligned.h>
0024
0025 /*
0026  * The GSC suffers from an errata where occasionally during
0027  * ADC cycles the chip can NAK I2C transactions. To ensure we have reliable
0028  * register access we place retries around register access.
0029  */
0030 #define I2C_RETRIES 3
0031
0032 int gsc_write(void *context, unsigned int reg, unsigned int val)
0033 {
0034     struct i2c_client *client = context;
0035     int retry, ret;
0036
0037     for (retry = 0; retry < I2C_RETRIES; retry++) {
0038         ret = i2c_smbus_write_byte_data(client, reg, val);
0039         /*
0040          * -EAGAIN returned when the i2c host controller is busy
0041          * -EIO returned when i2c device is busy
0042          */
0043         if (ret != -EAGAIN && ret != -EIO)
0044             break;
0045     }
0046
0047     return 0;
0048 }
0049 EXPORT_SYMBOL_GPL(gsc_write);
0050
0051 int gsc_read(void *context, unsigned int reg, unsigned int *val)
0052 {
0053     struct i2c_client *client = context;
0054     int retry, ret;
0055
0056     for (retry = 0; retry < I2C_RETRIES; retry++) {
0057         ret = i2c_smbus_read_byte_data(client, reg);
0058         /*
0059          * -EAGAIN returned when the i2c host controller is busy
0060          * -EIO returned when i2c device is busy
0061          */
0062         if (ret != -EAGAIN && ret != -EIO)
0063             break;
0064     }
0065     *val = ret & 0xff;
0066
0067     return 0;
0068 }
0069 EXPORT_SYMBOL_GPL(gsc_read);
0070
0071 /*
0072  * gsc_powerdown - API to use GSC to power down board for a specific time
0073  *
0074  * secs - number of seconds to remain powered off
0075  */
0076 static int gsc_powerdown(struct gsc_dev *gsc, unsigned long secs)
0077 {
0078     int ret;
0079     unsigned char regs[4];
0080
0081     dev_info(&gsc->i2c->dev, "GSC powerdown for %ld seconds\n",
0082          secs);
0083
0084     put_unaligned_le32(secs, regs);
0085     ret = regmap_bulk_write(gsc->regmap, GSC_TIME_ADD, regs, 4);
0086     if (ret)
0087         return ret;
0088
0089     ret = regmap_update_bits(gsc->regmap, GSC_CTRL_1,
0090                  BIT(GSC_CTRL_1_SLEEP_ADD),
0091                  BIT(GSC_CTRL_1_SLEEP_ADD));
0092     if (ret)
0093         return ret;
0094
0095     ret = regmap_update_bits(gsc->regmap, GSC_CTRL_1,
0096                  BIT(GSC_CTRL_1_SLEEP_ACTIVATE) |
0097                  BIT(GSC_CTRL_1_SLEEP_ENABLE),
0098                  BIT(GSC_CTRL_1_SLEEP_ACTIVATE) |
0099                  BIT(GSC_CTRL_1_SLEEP_ENABLE));
0100
0101
0102     return ret;
0103 }
0104
0105 static ssize_t gsc_show(struct device *dev, struct device_attribute *attr,
0106             char *buf)
0107 {
0108     struct gsc_dev *gsc = dev_get_drvdata(dev);
0109     const char *name = attr->attr.name;
0110     int rz = 0;
0111
0112     if (strcasecmp(name, "fw_version") == 0)
0113         rz = sprintf(buf, "%d\n", gsc->fwver);
0114     else if (strcasecmp(name, "fw_crc") == 0)
0115         rz = sprintf(buf, "0x%04x\n", gsc->fwcrc);
0116     else
0117         dev_err(dev, "invalid command: '%s'\n", name);
0118
0119     return rz;
0120 }
0121
0122 static ssize_t gsc_store(struct device *dev, struct device_attribute *attr,
0123              const char *buf, size_t count)
0124 {
0125     struct gsc_dev *gsc = dev_get_drvdata(dev);
0126     const char *name = attr->attr.name;
0127     long value;
0128
0129     if (strcasecmp(name, "powerdown") == 0) {
0130         if (kstrtol(buf, 0, &value) == 0)
0131             gsc_powerdown(gsc, value);
0132     } else {
0133         dev_err(dev, "invalid command: '%s\n", name);
0134     }
0135
0136     return count;
0137 }
0138
0139 static struct device_attribute attr_fwver =
0140     __ATTR(fw_version, 0440, gsc_show, NULL);
0141 static struct device_attribute attr_fwcrc =
0142     __ATTR(fw_crc, 0440, gsc_show, NULL);
0143 static struct device_attribute attr_pwrdown =
0144     __ATTR(powerdown, 0220, NULL, gsc_store);
0145
0146 static struct attribute *gsc_attrs[] = {
0147     &attr_fwver.attr,
0148     &attr_fwcrc.attr,
0149     &attr_pwrdown.attr,
0150     NULL,
0151 };
0152
0153 static struct attribute_group attr_group = {
0154     .attrs = gsc_attrs,
0155 };
0156
0157 static const struct of_device_id gsc_of_match[] = {
0158     { .compatible = "gw,gsc", },
0159     { }
0160 };
0161 MODULE_DEVICE_TABLE(of, gsc_of_match);
0162
0163 static struct regmap_bus gsc_regmap_bus = {
0164     .reg_read = gsc_read,
0165     .reg_write = gsc_write,
0166 };
0167
0168 static const struct regmap_config gsc_regmap_config = {
0169     .reg_bits = 8,
0170     .val_bits = 8,
0171     .cache_type = REGCACHE_NONE,
0172     .max_register = GSC_WP,
0173 };
0174
0175 static const struct regmap_irq gsc_irqs[] = {
0176     REGMAP_IRQ_REG(GSC_IRQ_PB, 0, BIT(GSC_IRQ_PB)),
0177     REGMAP_IRQ_REG(GSC_IRQ_KEY_ERASED, 0, BIT(GSC_IRQ_KEY_ERASED)),
0178     REGMAP_IRQ_REG(GSC_IRQ_EEPROM_WP, 0, BIT(GSC_IRQ_EEPROM_WP)),
0179     REGMAP_IRQ_REG(GSC_IRQ_RESV, 0, BIT(GSC_IRQ_RESV)),
0180     REGMAP_IRQ_REG(GSC_IRQ_GPIO, 0, BIT(GSC_IRQ_GPIO)),
0181     REGMAP_IRQ_REG(GSC_IRQ_TAMPER, 0, BIT(GSC_IRQ_TAMPER)),
0182     REGMAP_IRQ_REG(GSC_IRQ_WDT_TIMEOUT, 0, BIT(GSC_IRQ_WDT_TIMEOUT)),
0183     REGMAP_IRQ_REG(GSC_IRQ_SWITCH_HOLD, 0, BIT(GSC_IRQ_SWITCH_HOLD)),
0184 };
0185
0186 static const struct regmap_irq_chip gsc_irq_chip = {
0187     .name = "gateworks-gsc",
0188     .irqs = gsc_irqs,
0189     .num_irqs = ARRAY_SIZE(gsc_irqs),
0190     .num_regs = 1,
0191     .status_base = GSC_IRQ_STATUS,
0192     .mask_base = GSC_IRQ_ENABLE,
0193     .mask_invert = true,
0194     .ack_base = GSC_IRQ_STATUS,
0195     .ack_invert = true,
0196 };
0197
0198 static int gsc_probe(struct i2c_client *client)
0199 {
0200     struct device *dev = &client->dev;
0201     struct gsc_dev *gsc;
0202     struct regmap_irq_chip_data *irq_data;
0203     int ret;
0204     unsigned int reg;
0205
0206     gsc = devm_kzalloc(dev, sizeof(*gsc), GFP_KERNEL);
0207     if (!gsc)
0208         return -ENOMEM;
0209
0210     gsc->dev = &client->dev;
0211     gsc->i2c = client;
0212     i2c_set_clientdata(client, gsc);
0213
0214     gsc->regmap = devm_regmap_init(dev, &gsc_regmap_bus, client,
0215                        &gsc_regmap_config);
0216     if (IS_ERR(gsc->regmap))
0217         return PTR_ERR(gsc->regmap);
0218
0219     if (regmap_read(gsc->regmap, GSC_FW_VER, &reg))
0220         return -EIO;
0221     gsc->fwver = reg;
0222
0223     regmap_read(gsc->regmap, GSC_FW_CRC, &reg);
0224     gsc->fwcrc = reg;
0225     regmap_read(gsc->regmap, GSC_FW_CRC + 1, &reg);
0226     gsc->fwcrc |= reg << 8;
0227
0228     gsc->i2c_hwmon = devm_i2c_new_dummy_device(dev, client->adapter,
0229                            GSC_HWMON);
0230     if (IS_ERR(gsc->i2c_hwmon)) {
0231         dev_err(dev, "Failed to allocate I2C device for HWMON\n");
0232         return PTR_ERR(gsc->i2c_hwmon);
0233     }
0234
0235     ret = devm_regmap_add_irq_chip(dev, gsc->regmap, client->irq,
0236                        IRQF_ONESHOT | IRQF_SHARED |
0237                        IRQF_TRIGGER_LOW, 0,
0238                        &gsc_irq_chip, &irq_data);
0239     if (ret)
0240         return ret;
0241
0242     dev_info(dev, "Gateworks System Controller v%d: fw 0x%04x\n",
0243          gsc->fwver, gsc->fwcrc);
0244
0245     ret = sysfs_create_group(&dev->kobj, &attr_group);
0246     if (ret)
0247         dev_err(dev, "failed to create sysfs attrs\n");
0248
0249     ret = devm_of_platform_populate(dev);
0250     if (ret) {
0251         sysfs_remove_group(&dev->kobj, &attr_group);
0252         return ret;
0253     }
0254
0255     return 0;
0256 }
0257
0258 static int gsc_remove(struct i2c_client *client)
0259 {
0260     sysfs_remove_group(&client->dev.kobj, &attr_group);
0261
0262     return 0;
0263 }
0264
0265 static struct i2c_driver gsc_driver = {
0266     .driver = {
0267         .name   = "gateworks-gsc",
0268         .of_match_table = gsc_of_match,
0269     },
0270     .probe_new  = gsc_probe,
0271     .remove     = gsc_remove,
0272 };
0273 module_i2c_driver(gsc_driver);
0274
0275 MODULE_AUTHOR("Tim Harvey <tharvey@gateworks.com>");
0276 MODULE_DESCRIPTION("I2C Core interface for GSC");
0277 MODULE_LICENSE("GPL v2");