1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * nct6775-i2c - I2C driver for the hardware monitoring functionality of
4 * Nuvoton NCT677x Super-I/O chips
5 *
6 * Copyright (C) 2022 Zev Weiss <zev@bewilderbeest.net>
7 *
8 * This driver interacts with the chip via it's "back door" i2c interface, as
9 * is often exposed to a BMC. Because the host may still be operating the
10 * chip via the ("front door") LPC interface, this driver cannot assume that
11 * it actually has full control of the chip, and in particular must avoid
12 * making any changes that could confuse the host's LPC usage of it. It thus
13 * operates in a strictly read-only fashion, with the only exception being the
14 * bank-select register (which seems, thankfully, to be replicated for the i2c
15 * interface so it doesn't affect the LPC interface).
16 */
17
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/i2c.h>
21 #include <linux/hwmon.h>
22 #include <linux/hwmon-sysfs.h>
23 #include <linux/err.h>
24 #include <linux/of_device.h>
25 #include <linux/regmap.h>
26 #include "nct6775.h"
27
nct6775_i2c_read(void * ctx,unsigned int reg,unsigned int * val)28 static int nct6775_i2c_read(void *ctx, unsigned int reg, unsigned int *val)
29 {
30 int ret;
31 u32 tmp;
32 u8 bank = reg >> 8;
33 struct nct6775_data *data = ctx;
34 struct i2c_client *client = data->driver_data;
35
36 if (bank != data->bank) {
37 ret = i2c_smbus_write_byte_data(client, NCT6775_REG_BANK, bank);
38 if (ret)
39 return ret;
40 data->bank = bank;
41 }
42
43 ret = i2c_smbus_read_byte_data(client, reg & 0xff);
44 if (ret < 0)
45 return ret;
46 tmp = ret;
47
48 if (nct6775_reg_is_word_sized(data, reg)) {
49 ret = i2c_smbus_read_byte_data(client, (reg & 0xff) + 1);
50 if (ret < 0)
51 return ret;
52 tmp = (tmp << 8) | ret;
53 }
54
55 *val = tmp;
56 return 0;
57 }
58
59 /*
60 * The write operation is a dummy so as not to disturb anything being done
61 * with the chip via LPC.
62 */
nct6775_i2c_write(void * ctx,unsigned int reg,unsigned int value)63 static int nct6775_i2c_write(void *ctx, unsigned int reg, unsigned int value)
64 {
65 struct nct6775_data *data = ctx;
66 struct i2c_client *client = data->driver_data;
67
68 dev_dbg(&client->dev, "skipping attempted write: %02x -> %03x\n", value, reg);
69
70 /*
71 * This is a lie, but writing anything but the bank-select register is
72 * something this driver shouldn't be doing.
73 */
74 return 0;
75 }
76
77 static const struct of_device_id __maybe_unused nct6775_i2c_of_match[] = {
78 { .compatible = "nuvoton,nct6106", .data = (void *)nct6106, },
79 { .compatible = "nuvoton,nct6116", .data = (void *)nct6116, },
80 { .compatible = "nuvoton,nct6775", .data = (void *)nct6775, },
81 { .compatible = "nuvoton,nct6776", .data = (void *)nct6776, },
82 { .compatible = "nuvoton,nct6779", .data = (void *)nct6779, },
83 { .compatible = "nuvoton,nct6791", .data = (void *)nct6791, },
84 { .compatible = "nuvoton,nct6792", .data = (void *)nct6792, },
85 { .compatible = "nuvoton,nct6793", .data = (void *)nct6793, },
86 { .compatible = "nuvoton,nct6795", .data = (void *)nct6795, },
87 { .compatible = "nuvoton,nct6796", .data = (void *)nct6796, },
88 { .compatible = "nuvoton,nct6797", .data = (void *)nct6797, },
89 { .compatible = "nuvoton,nct6798", .data = (void *)nct6798, },
90 { .compatible = "nuvoton,nct6799", .data = (void *)nct6799, },
91 { },
92 };
93 MODULE_DEVICE_TABLE(of, nct6775_i2c_of_match);
94
95 static const struct i2c_device_id nct6775_i2c_id[] = {
96 { "nct6106", nct6106 },
97 { "nct6116", nct6116 },
98 { "nct6775", nct6775 },
99 { "nct6776", nct6776 },
100 { "nct6779", nct6779 },
101 { "nct6791", nct6791 },
102 { "nct6792", nct6792 },
103 { "nct6793", nct6793 },
104 { "nct6795", nct6795 },
105 { "nct6796", nct6796 },
106 { "nct6797", nct6797 },
107 { "nct6798", nct6798 },
108 { "nct6799", nct6799 },
109 { }
110 };
111 MODULE_DEVICE_TABLE(i2c, nct6775_i2c_id);
112
nct6775_i2c_probe_init(struct nct6775_data * data)113 static int nct6775_i2c_probe_init(struct nct6775_data *data)
114 {
115 u32 tsi_channel_mask;
116 struct i2c_client *client = data->driver_data;
117
118 /*
119 * The i2c interface doesn't provide access to the control registers
120 * needed to determine the presence of other fans, but fans 1 and 2
121 * are (in principle) always there.
122 *
123 * In practice this is perhaps a little silly, because the system
124 * using this driver is mostly likely a BMC, and hence probably has
125 * totally separate fan tachs & pwms of its own that are actually
126 * controlling/monitoring the fans -- these are thus unlikely to be
127 * doing anything actually useful.
128 */
129 data->has_fan = 0x03;
130 data->has_fan_min = 0x03;
131 data->has_pwm = 0x03;
132
133 /*
134 * Because on a BMC this driver may be bound very shortly after power
135 * is first applied to the device, the automatic TSI channel detection
136 * in nct6775_probe() (which has already been run at this point) may
137 * not find anything if a channel hasn't yet produced a temperature
138 * reading. Augment whatever was found via autodetection (if
139 * anything) with the channels DT says should be active.
140 */
141 if (!of_property_read_u32(client->dev.of_node, "nuvoton,tsi-channel-mask",
142 &tsi_channel_mask))
143 data->have_tsi_temp |= tsi_channel_mask & GENMASK(NUM_TSI_TEMP - 1, 0);
144
145 return 0;
146 }
147
148 static const struct regmap_config nct6775_i2c_regmap_config = {
149 .reg_bits = 16,
150 .val_bits = 16,
151 .reg_read = nct6775_i2c_read,
152 .reg_write = nct6775_i2c_write,
153 };
154
nct6775_i2c_probe(struct i2c_client * client)155 static int nct6775_i2c_probe(struct i2c_client *client)
156 {
157 struct nct6775_data *data;
158 const struct of_device_id *of_id;
159 const struct i2c_device_id *i2c_id;
160 struct device *dev = &client->dev;
161
162 of_id = of_match_device(nct6775_i2c_of_match, dev);
163 i2c_id = i2c_match_id(nct6775_i2c_id, client);
164
165 if (of_id && (unsigned long)of_id->data != i2c_id->driver_data)
166 dev_notice(dev, "Device mismatch: %s in device tree, %s detected\n",
167 of_id->name, i2c_id->name);
168
169 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
170 if (!data)
171 return -ENOMEM;
172
173 data->kind = i2c_id->driver_data;
174
175 data->read_only = true;
176 data->driver_data = client;
177 data->driver_init = nct6775_i2c_probe_init;
178
179 return nct6775_probe(dev, data, &nct6775_i2c_regmap_config);
180 }
181
182 static struct i2c_driver nct6775_i2c_driver = {
183 .class = I2C_CLASS_HWMON,
184 .driver = {
185 .name = "nct6775-i2c",
186 .of_match_table = of_match_ptr(nct6775_i2c_of_match),
187 },
188 .probe = nct6775_i2c_probe,
189 .id_table = nct6775_i2c_id,
190 };
191
192 module_i2c_driver(nct6775_i2c_driver);
193
194 MODULE_AUTHOR("Zev Weiss <zev@bewilderbeest.net>");
195 MODULE_DESCRIPTION("I2C driver for NCT6775F and compatible chips");
196 MODULE_LICENSE("GPL");
197 MODULE_IMPORT_NS(HWMON_NCT6775);
198