1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * The Gateworks System Controller (GSC) is a multi-function |
4 | * device designed for use in Gateworks Single Board Computers. |
5 | * The control interface is I2C, with an interrupt. The device supports |
6 | * system functions such as push-button monitoring, multiple ADC's for |
7 | * voltage and temperature monitoring, fan controller and watchdog monitor. |
8 | * |
9 | * Copyright (C) 2020 Gateworks Corporation |
10 | */ |
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 <asm/unaligned.h> |
24 | |
25 | /* |
26 | * The GSC suffers from an errata where occasionally during |
27 | * ADC cycles the chip can NAK I2C transactions. To ensure we have reliable |
28 | * register access we place retries around register access. |
29 | */ |
30 | #define I2C_RETRIES 3 |
31 | |
32 | int 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, command: reg, value: val); |
39 | /* |
40 | * -EAGAIN returned when the i2c host controller is busy |
41 | * -EIO returned when i2c device is busy |
42 | */ |
43 | if (ret != -EAGAIN && ret != -EIO) |
44 | break; |
45 | } |
46 | |
47 | return 0; |
48 | } |
49 | EXPORT_SYMBOL_GPL(gsc_write); |
50 | |
51 | int 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, command: reg); |
58 | /* |
59 | * -EAGAIN returned when the i2c host controller is busy |
60 | * -EIO returned when i2c device is busy |
61 | */ |
62 | if (ret != -EAGAIN && ret != -EIO) |
63 | break; |
64 | } |
65 | *val = ret & 0xff; |
66 | |
67 | return 0; |
68 | } |
69 | EXPORT_SYMBOL_GPL(gsc_read); |
70 | |
71 | /* |
72 | * gsc_powerdown - API to use GSC to power down board for a specific time |
73 | * |
74 | * secs - number of seconds to remain powered off |
75 | */ |
76 | static 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(val: secs, p: regs); |
85 | ret = regmap_bulk_write(map: gsc->regmap, reg: GSC_TIME_ADD, val: regs, val_count: 4); |
86 | if (ret) |
87 | return ret; |
88 | |
89 | ret = regmap_update_bits(map: gsc->regmap, reg: 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(map: gsc->regmap, reg: 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 | |
105 | static 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(s1: name, s2: "fw_version" ) == 0) |
113 | rz = sprintf(buf, fmt: "%d\n" , gsc->fwver); |
114 | else if (strcasecmp(s1: name, s2: "fw_crc" ) == 0) |
115 | rz = sprintf(buf, fmt: "0x%04x\n" , gsc->fwcrc); |
116 | else |
117 | dev_err(dev, "invalid command: '%s'\n" , name); |
118 | |
119 | return rz; |
120 | } |
121 | |
122 | static 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(s1: name, s2: "powerdown" ) == 0) { |
130 | if (kstrtol(s: buf, base: 0, res: &value) == 0) |
131 | gsc_powerdown(gsc, secs: value); |
132 | } else { |
133 | dev_err(dev, "invalid command: '%s\n" , name); |
134 | } |
135 | |
136 | return count; |
137 | } |
138 | |
139 | static struct device_attribute attr_fwver = |
140 | __ATTR(fw_version, 0440, gsc_show, NULL); |
141 | static struct device_attribute attr_fwcrc = |
142 | __ATTR(fw_crc, 0440, gsc_show, NULL); |
143 | static struct device_attribute attr_pwrdown = |
144 | __ATTR(powerdown, 0220, NULL, gsc_store); |
145 | |
146 | static struct attribute *gsc_attrs[] = { |
147 | &attr_fwver.attr, |
148 | &attr_fwcrc.attr, |
149 | &attr_pwrdown.attr, |
150 | NULL, |
151 | }; |
152 | |
153 | static struct attribute_group attr_group = { |
154 | .attrs = gsc_attrs, |
155 | }; |
156 | |
157 | static const struct of_device_id gsc_of_match[] = { |
158 | { .compatible = "gw,gsc" , }, |
159 | { } |
160 | }; |
161 | MODULE_DEVICE_TABLE(of, gsc_of_match); |
162 | |
163 | static struct regmap_bus gsc_regmap_bus = { |
164 | .reg_read = gsc_read, |
165 | .reg_write = gsc_write, |
166 | }; |
167 | |
168 | static 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 | |
175 | static 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 | |
186 | static 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 | |
197 | static 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, size: 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, data: gsc); |
212 | |
213 | gsc->regmap = devm_regmap_init(dev, &gsc_regmap_bus, client, |
214 | &gsc_regmap_config); |
215 | if (IS_ERR(ptr: gsc->regmap)) |
216 | return PTR_ERR(ptr: gsc->regmap); |
217 | |
218 | if (regmap_read(map: gsc->regmap, reg: GSC_FW_VER, val: ®)) |
219 | return -EIO; |
220 | gsc->fwver = reg; |
221 | |
222 | regmap_read(map: gsc->regmap, reg: GSC_FW_CRC, val: ®); |
223 | gsc->fwcrc = reg; |
224 | regmap_read(map: gsc->regmap, reg: GSC_FW_CRC + 1, val: ®); |
225 | gsc->fwcrc |= reg << 8; |
226 | |
227 | gsc->i2c_hwmon = devm_i2c_new_dummy_device(dev, adap: client->adapter, |
228 | GSC_HWMON); |
229 | if (IS_ERR(ptr: gsc->i2c_hwmon)) { |
230 | dev_err(dev, "Failed to allocate I2C device for HWMON\n" ); |
231 | return PTR_ERR(ptr: gsc->i2c_hwmon); |
232 | } |
233 | |
234 | ret = devm_regmap_add_irq_chip(dev, map: gsc->regmap, irq: client->irq, |
235 | IRQF_ONESHOT | IRQF_SHARED | |
236 | IRQF_TRIGGER_LOW, irq_base: 0, |
237 | chip: &gsc_irq_chip, data: &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(kobj: &dev->kobj, grp: &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(kobj: &dev->kobj, grp: &attr_group); |
251 | return ret; |
252 | } |
253 | |
254 | return 0; |
255 | } |
256 | |
257 | static void gsc_remove(struct i2c_client *client) |
258 | { |
259 | sysfs_remove_group(kobj: &client->dev.kobj, grp: &attr_group); |
260 | } |
261 | |
262 | static 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 | }; |
270 | module_i2c_driver(gsc_driver); |
271 | |
272 | MODULE_AUTHOR("Tim Harvey <tharvey@gateworks.com>" ); |
273 | MODULE_DESCRIPTION("I2C Core interface for GSC" ); |
274 | MODULE_LICENSE("GPL v2" ); |
275 | |