1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Hardware monitoring driver for PMBus devices 4 * 5 * Copyright (c) 2010, 2011 Ericsson AB. 6 */ 7 8 #include <linux/kernel.h> 9 #include <linux/module.h> 10 #include <linux/init.h> 11 #include <linux/err.h> 12 #include <linux/slab.h> 13 #include <linux/mutex.h> 14 #include <linux/i2c.h> 15 #include <linux/pmbus.h> 16 #include "pmbus.h" 17 18 struct pmbus_device_info { 19 int pages; 20 u32 flags; 21 }; 22 23 /* 24 * Find sensor groups and status registers on each page. 25 */ 26 static void pmbus_find_sensor_groups(struct i2c_client *client, 27 struct pmbus_driver_info *info) 28 { 29 int page; 30 31 /* Sensors detected on page 0 only */ 32 if (pmbus_check_word_register(client, 0, PMBUS_READ_VIN)) 33 info->func[0] |= PMBUS_HAVE_VIN; 34 if (pmbus_check_word_register(client, 0, PMBUS_READ_VCAP)) 35 info->func[0] |= PMBUS_HAVE_VCAP; 36 if (pmbus_check_word_register(client, 0, PMBUS_READ_IIN)) 37 info->func[0] |= PMBUS_HAVE_IIN; 38 if (pmbus_check_word_register(client, 0, PMBUS_READ_PIN)) 39 info->func[0] |= PMBUS_HAVE_PIN; 40 if (info->func[0] 41 && pmbus_check_byte_register(client, 0, PMBUS_STATUS_INPUT)) 42 info->func[0] |= PMBUS_HAVE_STATUS_INPUT; 43 if (pmbus_check_byte_register(client, 0, PMBUS_FAN_CONFIG_12) && 44 pmbus_check_word_register(client, 0, PMBUS_READ_FAN_SPEED_1)) { 45 info->func[0] |= PMBUS_HAVE_FAN12; 46 if (pmbus_check_byte_register(client, 0, PMBUS_STATUS_FAN_12)) 47 info->func[0] |= PMBUS_HAVE_STATUS_FAN12; 48 } 49 if (pmbus_check_byte_register(client, 0, PMBUS_FAN_CONFIG_34) && 50 pmbus_check_word_register(client, 0, PMBUS_READ_FAN_SPEED_3)) { 51 info->func[0] |= PMBUS_HAVE_FAN34; 52 if (pmbus_check_byte_register(client, 0, PMBUS_STATUS_FAN_34)) 53 info->func[0] |= PMBUS_HAVE_STATUS_FAN34; 54 } 55 if (pmbus_check_word_register(client, 0, PMBUS_READ_TEMPERATURE_1)) 56 info->func[0] |= PMBUS_HAVE_TEMP; 57 if (pmbus_check_word_register(client, 0, PMBUS_READ_TEMPERATURE_2)) 58 info->func[0] |= PMBUS_HAVE_TEMP2; 59 if (pmbus_check_word_register(client, 0, PMBUS_READ_TEMPERATURE_3)) 60 info->func[0] |= PMBUS_HAVE_TEMP3; 61 if (info->func[0] & (PMBUS_HAVE_TEMP | PMBUS_HAVE_TEMP2 62 | PMBUS_HAVE_TEMP3) 63 && pmbus_check_byte_register(client, 0, 64 PMBUS_STATUS_TEMPERATURE)) 65 info->func[0] |= PMBUS_HAVE_STATUS_TEMP; 66 67 /* Sensors detected on all pages */ 68 for (page = 0; page < info->pages; page++) { 69 if (pmbus_check_word_register(client, page, PMBUS_READ_VOUT)) { 70 info->func[page] |= PMBUS_HAVE_VOUT; 71 if (pmbus_check_byte_register(client, page, 72 PMBUS_STATUS_VOUT)) 73 info->func[page] |= PMBUS_HAVE_STATUS_VOUT; 74 } 75 if (pmbus_check_word_register(client, page, PMBUS_READ_IOUT)) { 76 info->func[page] |= PMBUS_HAVE_IOUT; 77 if (pmbus_check_byte_register(client, 0, 78 PMBUS_STATUS_IOUT)) 79 info->func[page] |= PMBUS_HAVE_STATUS_IOUT; 80 } 81 if (pmbus_check_word_register(client, page, PMBUS_READ_POUT)) 82 info->func[page] |= PMBUS_HAVE_POUT; 83 } 84 } 85 86 /* 87 * Identify chip parameters. 88 */ 89 static int pmbus_identify(struct i2c_client *client, 90 struct pmbus_driver_info *info) 91 { 92 int ret = 0; 93 94 if (!info->pages) { 95 /* 96 * Check if the PAGE command is supported. If it is, 97 * keep setting the page number until it fails or until the 98 * maximum number of pages has been reached. Assume that 99 * this is the number of pages supported by the chip. 100 */ 101 if (pmbus_check_byte_register(client, 0, PMBUS_PAGE)) { 102 int page; 103 104 for (page = 1; page < PMBUS_PAGES; page++) { 105 if (pmbus_set_page(client, page, 0xff) < 0) 106 break; 107 } 108 pmbus_set_page(client, 0, 0xff); 109 info->pages = page; 110 } else { 111 info->pages = 1; 112 } 113 114 pmbus_clear_faults(client); 115 } 116 117 if (pmbus_check_byte_register(client, 0, PMBUS_VOUT_MODE)) { 118 int vout_mode, i; 119 120 vout_mode = pmbus_read_byte_data(client, 0, PMBUS_VOUT_MODE); 121 if (vout_mode >= 0 && vout_mode != 0xff) { 122 switch (vout_mode >> 5) { 123 case 0: 124 break; 125 case 1: 126 info->format[PSC_VOLTAGE_OUT] = vid; 127 for (i = 0; i < info->pages; i++) 128 info->vrm_version[i] = vr11; 129 break; 130 case 2: 131 info->format[PSC_VOLTAGE_OUT] = direct; 132 break; 133 default: 134 ret = -ENODEV; 135 goto abort; 136 } 137 } 138 } 139 140 /* 141 * We should check if the COEFFICIENTS register is supported. 142 * If it is, and the chip is configured for direct mode, we can read 143 * the coefficients from the chip, one set per group of sensor 144 * registers. 145 * 146 * To do this, we will need access to a chip which actually supports the 147 * COEFFICIENTS command, since the command is too complex to implement 148 * without testing it. Until then, abort if a chip configured for direct 149 * mode was detected. 150 */ 151 if (info->format[PSC_VOLTAGE_OUT] == direct) { 152 ret = -ENODEV; 153 goto abort; 154 } 155 156 /* Try to find sensor groups */ 157 pmbus_find_sensor_groups(client, info); 158 abort: 159 return ret; 160 } 161 162 static int pmbus_probe(struct i2c_client *client, 163 const struct i2c_device_id *id) 164 { 165 struct pmbus_driver_info *info; 166 struct pmbus_platform_data *pdata = NULL; 167 struct device *dev = &client->dev; 168 struct pmbus_device_info *device_info; 169 170 info = devm_kzalloc(dev, sizeof(struct pmbus_driver_info), GFP_KERNEL); 171 if (!info) 172 return -ENOMEM; 173 174 device_info = (struct pmbus_device_info *)id->driver_data; 175 if (device_info->flags & PMBUS_SKIP_STATUS_CHECK) { 176 pdata = devm_kzalloc(dev, sizeof(struct pmbus_platform_data), 177 GFP_KERNEL); 178 if (!pdata) 179 return -ENOMEM; 180 181 pdata->flags = PMBUS_SKIP_STATUS_CHECK; 182 } 183 184 info->pages = device_info->pages; 185 info->identify = pmbus_identify; 186 dev->platform_data = pdata; 187 188 return pmbus_do_probe(client, id, info); 189 } 190 191 static const struct pmbus_device_info pmbus_info_one = { 192 .pages = 1, 193 .flags = 0 194 }; 195 static const struct pmbus_device_info pmbus_info_zero = { 196 .pages = 0, 197 .flags = 0 198 }; 199 static const struct pmbus_device_info pmbus_info_one_skip = { 200 .pages = 1, 201 .flags = PMBUS_SKIP_STATUS_CHECK 202 }; 203 204 /* 205 * Use driver_data to set the number of pages supported by the chip. 206 */ 207 static const struct i2c_device_id pmbus_id[] = { 208 {"adp4000", (kernel_ulong_t)&pmbus_info_one}, 209 {"bmr453", (kernel_ulong_t)&pmbus_info_one}, 210 {"bmr454", (kernel_ulong_t)&pmbus_info_one}, 211 {"dps460", (kernel_ulong_t)&pmbus_info_one_skip}, 212 {"dps650ab", (kernel_ulong_t)&pmbus_info_one_skip}, 213 {"dps800", (kernel_ulong_t)&pmbus_info_one_skip}, 214 {"max20796", (kernel_ulong_t)&pmbus_info_one}, 215 {"mdt040", (kernel_ulong_t)&pmbus_info_one}, 216 {"ncp4200", (kernel_ulong_t)&pmbus_info_one}, 217 {"ncp4208", (kernel_ulong_t)&pmbus_info_one}, 218 {"pdt003", (kernel_ulong_t)&pmbus_info_one}, 219 {"pdt006", (kernel_ulong_t)&pmbus_info_one}, 220 {"pdt012", (kernel_ulong_t)&pmbus_info_one}, 221 {"pmbus", (kernel_ulong_t)&pmbus_info_zero}, 222 {"sgd009", (kernel_ulong_t)&pmbus_info_one_skip}, 223 {"tps40400", (kernel_ulong_t)&pmbus_info_one}, 224 {"tps544b20", (kernel_ulong_t)&pmbus_info_one}, 225 {"tps544b25", (kernel_ulong_t)&pmbus_info_one}, 226 {"tps544c20", (kernel_ulong_t)&pmbus_info_one}, 227 {"tps544c25", (kernel_ulong_t)&pmbus_info_one}, 228 {"udt020", (kernel_ulong_t)&pmbus_info_one}, 229 {} 230 }; 231 232 MODULE_DEVICE_TABLE(i2c, pmbus_id); 233 234 /* This is the driver that will be inserted */ 235 static struct i2c_driver pmbus_driver = { 236 .driver = { 237 .name = "pmbus", 238 }, 239 .probe = pmbus_probe, 240 .remove = pmbus_do_remove, 241 .id_table = pmbus_id, 242 }; 243 244 module_i2c_driver(pmbus_driver); 245 246 MODULE_AUTHOR("Guenter Roeck"); 247 MODULE_DESCRIPTION("Generic PMBus driver"); 248 MODULE_LICENSE("GPL"); 249