275 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * The Gateworks System Controller (GSC) is a multi-function4 * device designed for use in Gateworks Single Board Computers.5 * The control interface is I2C, with an interrupt. The device supports6 * system functions such as push-button monitoring, multiple ADC's for7 * voltage and temperature monitoring, fan controller and watchdog monitor.8 *9 * Copyright (C) 2020 Gateworks Corporation10 */11 12#include <linux/device.h>13#include <linux/i2c.h>14#include <linux/interrupt.h>15#include <linux/mfd/gsc.h>16#include <linux/module.h>17#include <linux/mutex.h>18#include <linux/of.h>19#include <linux/of_platform.h>20#include <linux/platform_device.h>21#include <linux/regmap.h>22 23#include <linux/unaligned.h>24 25/*26 * The GSC suffers from an errata where occasionally during27 * ADC cycles the chip can NAK I2C transactions. To ensure we have reliable28 * register access we place retries around register access.29 */30#define I2C_RETRIES 331 32int gsc_write(void *context, unsigned int reg, unsigned int val)33{34 struct i2c_client *client = context;35 int retry, ret;36 37 for (retry = 0; retry < I2C_RETRIES; retry++) {38 ret = i2c_smbus_write_byte_data(client, reg, val);39 /*40 * -EAGAIN returned when the i2c host controller is busy41 * -EIO returned when i2c device is busy42 */43 if (ret != -EAGAIN && ret != -EIO)44 break;45 }46 47 return 0;48}49EXPORT_SYMBOL_GPL(gsc_write);50 51int gsc_read(void *context, unsigned int reg, unsigned int *val)52{53 struct i2c_client *client = context;54 int retry, ret;55 56 for (retry = 0; retry < I2C_RETRIES; retry++) {57 ret = i2c_smbus_read_byte_data(client, reg);58 /*59 * -EAGAIN returned when the i2c host controller is busy60 * -EIO returned when i2c device is busy61 */62 if (ret != -EAGAIN && ret != -EIO)63 break;64 }65 *val = ret & 0xff;66 67 return 0;68}69EXPORT_SYMBOL_GPL(gsc_read);70 71/*72 * gsc_powerdown - API to use GSC to power down board for a specific time73 *74 * secs - number of seconds to remain powered off75 */76static int gsc_powerdown(struct gsc_dev *gsc, unsigned long secs)77{78 int ret;79 unsigned char regs[4];80 81 dev_info(&gsc->i2c->dev, "GSC powerdown for %ld seconds\n",82 secs);83 84 put_unaligned_le32(secs, regs);85 ret = regmap_bulk_write(gsc->regmap, GSC_TIME_ADD, regs, 4);86 if (ret)87 return ret;88 89 ret = regmap_update_bits(gsc->regmap, GSC_CTRL_1,90 BIT(GSC_CTRL_1_SLEEP_ADD),91 BIT(GSC_CTRL_1_SLEEP_ADD));92 if (ret)93 return ret;94 95 ret = regmap_update_bits(gsc->regmap, GSC_CTRL_1,96 BIT(GSC_CTRL_1_SLEEP_ACTIVATE) |97 BIT(GSC_CTRL_1_SLEEP_ENABLE),98 BIT(GSC_CTRL_1_SLEEP_ACTIVATE) |99 BIT(GSC_CTRL_1_SLEEP_ENABLE));100 101 102 return ret;103}104 105static ssize_t gsc_show(struct device *dev, struct device_attribute *attr,106 char *buf)107{108 struct gsc_dev *gsc = dev_get_drvdata(dev);109 const char *name = attr->attr.name;110 int rz = 0;111 112 if (strcasecmp(name, "fw_version") == 0)113 rz = sprintf(buf, "%d\n", gsc->fwver);114 else if (strcasecmp(name, "fw_crc") == 0)115 rz = sprintf(buf, "0x%04x\n", gsc->fwcrc);116 else117 dev_err(dev, "invalid command: '%s'\n", name);118 119 return rz;120}121 122static ssize_t gsc_store(struct device *dev, struct device_attribute *attr,123 const char *buf, size_t count)124{125 struct gsc_dev *gsc = dev_get_drvdata(dev);126 const char *name = attr->attr.name;127 long value;128 129 if (strcasecmp(name, "powerdown") == 0) {130 if (kstrtol(buf, 0, &value) == 0)131 gsc_powerdown(gsc, value);132 } else {133 dev_err(dev, "invalid command: '%s\n", name);134 }135 136 return count;137}138 139static struct device_attribute attr_fwver =140 __ATTR(fw_version, 0440, gsc_show, NULL);141static struct device_attribute attr_fwcrc =142 __ATTR(fw_crc, 0440, gsc_show, NULL);143static struct device_attribute attr_pwrdown =144 __ATTR(powerdown, 0220, NULL, gsc_store);145 146static struct attribute *gsc_attrs[] = {147 &attr_fwver.attr,148 &attr_fwcrc.attr,149 &attr_pwrdown.attr,150 NULL,151};152 153static struct attribute_group attr_group = {154 .attrs = gsc_attrs,155};156 157static const struct of_device_id gsc_of_match[] = {158 { .compatible = "gw,gsc", },159 { }160};161MODULE_DEVICE_TABLE(of, gsc_of_match);162 163static const struct regmap_bus gsc_regmap_bus = {164 .reg_read = gsc_read,165 .reg_write = gsc_write,166};167 168static const struct regmap_config gsc_regmap_config = {169 .reg_bits = 8,170 .val_bits = 8,171 .cache_type = REGCACHE_NONE,172 .max_register = GSC_WP,173};174 175static const struct regmap_irq gsc_irqs[] = {176 REGMAP_IRQ_REG(GSC_IRQ_PB, 0, BIT(GSC_IRQ_PB)),177 REGMAP_IRQ_REG(GSC_IRQ_KEY_ERASED, 0, BIT(GSC_IRQ_KEY_ERASED)),178 REGMAP_IRQ_REG(GSC_IRQ_EEPROM_WP, 0, BIT(GSC_IRQ_EEPROM_WP)),179 REGMAP_IRQ_REG(GSC_IRQ_RESV, 0, BIT(GSC_IRQ_RESV)),180 REGMAP_IRQ_REG(GSC_IRQ_GPIO, 0, BIT(GSC_IRQ_GPIO)),181 REGMAP_IRQ_REG(GSC_IRQ_TAMPER, 0, BIT(GSC_IRQ_TAMPER)),182 REGMAP_IRQ_REG(GSC_IRQ_WDT_TIMEOUT, 0, BIT(GSC_IRQ_WDT_TIMEOUT)),183 REGMAP_IRQ_REG(GSC_IRQ_SWITCH_HOLD, 0, BIT(GSC_IRQ_SWITCH_HOLD)),184};185 186static const struct regmap_irq_chip gsc_irq_chip = {187 .name = "gateworks-gsc",188 .irqs = gsc_irqs,189 .num_irqs = ARRAY_SIZE(gsc_irqs),190 .num_regs = 1,191 .status_base = GSC_IRQ_STATUS,192 .unmask_base = GSC_IRQ_ENABLE,193 .ack_base = GSC_IRQ_STATUS,194 .ack_invert = true,195};196 197static int gsc_probe(struct i2c_client *client)198{199 struct device *dev = &client->dev;200 struct gsc_dev *gsc;201 struct regmap_irq_chip_data *irq_data;202 int ret;203 unsigned int reg;204 205 gsc = devm_kzalloc(dev, sizeof(*gsc), GFP_KERNEL);206 if (!gsc)207 return -ENOMEM;208 209 gsc->dev = &client->dev;210 gsc->i2c = client;211 i2c_set_clientdata(client, gsc);212 213 gsc->regmap = devm_regmap_init(dev, &gsc_regmap_bus, client,214 &gsc_regmap_config);215 if (IS_ERR(gsc->regmap))216 return PTR_ERR(gsc->regmap);217 218 if (regmap_read(gsc->regmap, GSC_FW_VER, ®))219 return -EIO;220 gsc->fwver = reg;221 222 regmap_read(gsc->regmap, GSC_FW_CRC, ®);223 gsc->fwcrc = reg;224 regmap_read(gsc->regmap, GSC_FW_CRC + 1, ®);225 gsc->fwcrc |= reg << 8;226 227 gsc->i2c_hwmon = devm_i2c_new_dummy_device(dev, client->adapter,228 GSC_HWMON);229 if (IS_ERR(gsc->i2c_hwmon)) {230 dev_err(dev, "Failed to allocate I2C device for HWMON\n");231 return PTR_ERR(gsc->i2c_hwmon);232 }233 234 ret = devm_regmap_add_irq_chip(dev, gsc->regmap, client->irq,235 IRQF_ONESHOT | IRQF_SHARED |236 IRQF_TRIGGER_LOW, 0,237 &gsc_irq_chip, &irq_data);238 if (ret)239 return ret;240 241 dev_info(dev, "Gateworks System Controller v%d: fw 0x%04x\n",242 gsc->fwver, gsc->fwcrc);243 244 ret = sysfs_create_group(&dev->kobj, &attr_group);245 if (ret)246 dev_err(dev, "failed to create sysfs attrs\n");247 248 ret = devm_of_platform_populate(dev);249 if (ret) {250 sysfs_remove_group(&dev->kobj, &attr_group);251 return ret;252 }253 254 return 0;255}256 257static void gsc_remove(struct i2c_client *client)258{259 sysfs_remove_group(&client->dev.kobj, &attr_group);260}261 262static struct i2c_driver gsc_driver = {263 .driver = {264 .name = "gateworks-gsc",265 .of_match_table = gsc_of_match,266 },267 .probe = gsc_probe,268 .remove = gsc_remove,269};270module_i2c_driver(gsc_driver);271 272MODULE_AUTHOR("Tim Harvey <tharvey@gateworks.com>");273MODULE_DESCRIPTION("I2C Core interface for GSC");274MODULE_LICENSE("GPL v2");275