1 /* 2 * Hardware monitoring driver for Analog Devices ADM1275 Hot-Swap Controller 3 * and Digital Power Monitor 4 * 5 * Copyright (c) 2011 Ericsson AB. 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 */ 17 18 #include <linux/kernel.h> 19 #include <linux/module.h> 20 #include <linux/init.h> 21 #include <linux/err.h> 22 #include <linux/slab.h> 23 #include <linux/i2c.h> 24 #include "pmbus.h" 25 26 enum chips { adm1275, adm1276 }; 27 28 #define ADM1275_PEAK_IOUT 0xd0 29 #define ADM1275_PEAK_VIN 0xd1 30 #define ADM1275_PEAK_VOUT 0xd2 31 #define ADM1275_PMON_CONFIG 0xd4 32 33 #define ADM1275_VIN_VOUT_SELECT (1 << 6) 34 #define ADM1275_VRANGE (1 << 5) 35 36 #define ADM1275_IOUT_WARN2_LIMIT 0xd7 37 #define ADM1275_DEVICE_CONFIG 0xd8 38 39 #define ADM1275_IOUT_WARN2_SELECT (1 << 4) 40 41 #define ADM1276_PEAK_PIN 0xda 42 43 #define ADM1275_MFR_STATUS_IOUT_WARN2 (1 << 0) 44 45 struct adm1275_data { 46 int id; 47 bool have_oc_fault; 48 struct pmbus_driver_info info; 49 }; 50 51 #define to_adm1275_data(x) container_of(x, struct adm1275_data, info) 52 53 static int adm1275_read_word_data(struct i2c_client *client, int page, int reg) 54 { 55 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 56 const struct adm1275_data *data = to_adm1275_data(info); 57 int ret = 0; 58 59 if (page) 60 return -ENXIO; 61 62 switch (reg) { 63 case PMBUS_IOUT_UC_FAULT_LIMIT: 64 if (data->have_oc_fault) { 65 ret = -ENXIO; 66 break; 67 } 68 ret = pmbus_read_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT); 69 break; 70 case PMBUS_IOUT_OC_FAULT_LIMIT: 71 if (!data->have_oc_fault) { 72 ret = -ENXIO; 73 break; 74 } 75 ret = pmbus_read_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT); 76 break; 77 case PMBUS_VIRT_READ_IOUT_MAX: 78 ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_IOUT); 79 break; 80 case PMBUS_VIRT_READ_VOUT_MAX: 81 ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_VOUT); 82 break; 83 case PMBUS_VIRT_READ_VIN_MAX: 84 ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_VIN); 85 break; 86 case PMBUS_VIRT_READ_PIN_MAX: 87 if (data->id != adm1276) { 88 ret = -ENXIO; 89 break; 90 } 91 ret = pmbus_read_word_data(client, 0, ADM1276_PEAK_PIN); 92 break; 93 case PMBUS_VIRT_RESET_IOUT_HISTORY: 94 case PMBUS_VIRT_RESET_VOUT_HISTORY: 95 case PMBUS_VIRT_RESET_VIN_HISTORY: 96 break; 97 case PMBUS_VIRT_RESET_PIN_HISTORY: 98 if (data->id != adm1276) 99 ret = -ENXIO; 100 break; 101 default: 102 ret = -ENODATA; 103 break; 104 } 105 return ret; 106 } 107 108 static int adm1275_write_word_data(struct i2c_client *client, int page, int reg, 109 u16 word) 110 { 111 int ret; 112 113 if (page) 114 return -ENXIO; 115 116 switch (reg) { 117 case PMBUS_IOUT_UC_FAULT_LIMIT: 118 case PMBUS_IOUT_OC_FAULT_LIMIT: 119 ret = pmbus_write_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT, 120 word); 121 break; 122 case PMBUS_VIRT_RESET_IOUT_HISTORY: 123 ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_IOUT, 0); 124 break; 125 case PMBUS_VIRT_RESET_VOUT_HISTORY: 126 ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_VOUT, 0); 127 break; 128 case PMBUS_VIRT_RESET_VIN_HISTORY: 129 ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_VIN, 0); 130 break; 131 case PMBUS_VIRT_RESET_PIN_HISTORY: 132 ret = pmbus_write_word_data(client, 0, ADM1276_PEAK_PIN, 0); 133 break; 134 default: 135 ret = -ENODATA; 136 break; 137 } 138 return ret; 139 } 140 141 static int adm1275_read_byte_data(struct i2c_client *client, int page, int reg) 142 { 143 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 144 const struct adm1275_data *data = to_adm1275_data(info); 145 int mfr_status, ret; 146 147 if (page > 0) 148 return -ENXIO; 149 150 switch (reg) { 151 case PMBUS_STATUS_IOUT: 152 ret = pmbus_read_byte_data(client, page, PMBUS_STATUS_IOUT); 153 if (ret < 0) 154 break; 155 mfr_status = pmbus_read_byte_data(client, page, 156 PMBUS_STATUS_MFR_SPECIFIC); 157 if (mfr_status < 0) { 158 ret = mfr_status; 159 break; 160 } 161 if (mfr_status & ADM1275_MFR_STATUS_IOUT_WARN2) { 162 ret |= data->have_oc_fault ? 163 PB_IOUT_OC_FAULT : PB_IOUT_UC_FAULT; 164 } 165 break; 166 default: 167 ret = -ENODATA; 168 break; 169 } 170 return ret; 171 } 172 173 static const struct i2c_device_id adm1275_id[] = { 174 { "adm1275", adm1275 }, 175 { "adm1276", adm1276 }, 176 { } 177 }; 178 MODULE_DEVICE_TABLE(i2c, adm1275_id); 179 180 static int adm1275_probe(struct i2c_client *client, 181 const struct i2c_device_id *id) 182 { 183 u8 block_buffer[I2C_SMBUS_BLOCK_MAX + 1]; 184 int config, device_config; 185 int ret; 186 struct pmbus_driver_info *info; 187 struct adm1275_data *data; 188 const struct i2c_device_id *mid; 189 190 if (!i2c_check_functionality(client->adapter, 191 I2C_FUNC_SMBUS_READ_BYTE_DATA 192 | I2C_FUNC_SMBUS_BLOCK_DATA)) 193 return -ENODEV; 194 195 ret = i2c_smbus_read_block_data(client, PMBUS_MFR_ID, block_buffer); 196 if (ret < 0) { 197 dev_err(&client->dev, "Failed to read Manufacturer ID\n"); 198 return ret; 199 } 200 if (ret != 3 || strncmp(block_buffer, "ADI", 3)) { 201 dev_err(&client->dev, "Unsupported Manufacturer ID\n"); 202 return -ENODEV; 203 } 204 205 ret = i2c_smbus_read_block_data(client, PMBUS_MFR_MODEL, block_buffer); 206 if (ret < 0) { 207 dev_err(&client->dev, "Failed to read Manufacturer Model\n"); 208 return ret; 209 } 210 for (mid = adm1275_id; mid->name[0]; mid++) { 211 if (!strncasecmp(mid->name, block_buffer, strlen(mid->name))) 212 break; 213 } 214 if (!mid->name[0]) { 215 dev_err(&client->dev, "Unsupported device\n"); 216 return -ENODEV; 217 } 218 219 if (id->driver_data != mid->driver_data) 220 dev_notice(&client->dev, 221 "Device mismatch: Configured %s, detected %s\n", 222 id->name, mid->name); 223 224 config = i2c_smbus_read_byte_data(client, ADM1275_PMON_CONFIG); 225 if (config < 0) 226 return config; 227 228 device_config = i2c_smbus_read_byte_data(client, ADM1275_DEVICE_CONFIG); 229 if (device_config < 0) 230 return device_config; 231 232 data = kzalloc(sizeof(struct adm1275_data), GFP_KERNEL); 233 if (!data) 234 return -ENOMEM; 235 236 data->id = mid->driver_data; 237 238 info = &data->info; 239 240 info->pages = 1; 241 info->format[PSC_VOLTAGE_IN] = direct; 242 info->format[PSC_VOLTAGE_OUT] = direct; 243 info->format[PSC_CURRENT_OUT] = direct; 244 info->m[PSC_CURRENT_OUT] = 807; 245 info->b[PSC_CURRENT_OUT] = 20475; 246 info->R[PSC_CURRENT_OUT] = -1; 247 info->func[0] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT; 248 249 info->read_word_data = adm1275_read_word_data; 250 info->read_byte_data = adm1275_read_byte_data; 251 info->write_word_data = adm1275_write_word_data; 252 253 if (config & ADM1275_VRANGE) { 254 info->m[PSC_VOLTAGE_IN] = 19199; 255 info->b[PSC_VOLTAGE_IN] = 0; 256 info->R[PSC_VOLTAGE_IN] = -2; 257 info->m[PSC_VOLTAGE_OUT] = 19199; 258 info->b[PSC_VOLTAGE_OUT] = 0; 259 info->R[PSC_VOLTAGE_OUT] = -2; 260 } else { 261 info->m[PSC_VOLTAGE_IN] = 6720; 262 info->b[PSC_VOLTAGE_IN] = 0; 263 info->R[PSC_VOLTAGE_IN] = -1; 264 info->m[PSC_VOLTAGE_OUT] = 6720; 265 info->b[PSC_VOLTAGE_OUT] = 0; 266 info->R[PSC_VOLTAGE_OUT] = -1; 267 } 268 269 if (device_config & ADM1275_IOUT_WARN2_SELECT) 270 data->have_oc_fault = true; 271 272 switch (data->id) { 273 case adm1275: 274 if (config & ADM1275_VIN_VOUT_SELECT) 275 info->func[0] |= 276 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT; 277 else 278 info->func[0] |= 279 PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT; 280 break; 281 case adm1276: 282 info->format[PSC_POWER] = direct; 283 info->func[0] |= PMBUS_HAVE_VIN | PMBUS_HAVE_PIN 284 | PMBUS_HAVE_STATUS_INPUT; 285 if (config & ADM1275_VIN_VOUT_SELECT) 286 info->func[0] |= 287 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT; 288 if (config & ADM1275_VRANGE) { 289 info->m[PSC_POWER] = 6043; 290 info->b[PSC_POWER] = 0; 291 info->R[PSC_POWER] = -2; 292 } else { 293 info->m[PSC_POWER] = 2115; 294 info->b[PSC_POWER] = 0; 295 info->R[PSC_POWER] = -1; 296 } 297 break; 298 } 299 300 ret = pmbus_do_probe(client, id, info); 301 if (ret) 302 goto err_mem; 303 return 0; 304 305 err_mem: 306 kfree(data); 307 return ret; 308 } 309 310 static int adm1275_remove(struct i2c_client *client) 311 { 312 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 313 const struct adm1275_data *data = to_adm1275_data(info); 314 315 pmbus_do_remove(client); 316 kfree(data); 317 return 0; 318 } 319 320 static struct i2c_driver adm1275_driver = { 321 .driver = { 322 .name = "adm1275", 323 }, 324 .probe = adm1275_probe, 325 .remove = adm1275_remove, 326 .id_table = adm1275_id, 327 }; 328 329 static int __init adm1275_init(void) 330 { 331 return i2c_add_driver(&adm1275_driver); 332 } 333 334 static void __exit adm1275_exit(void) 335 { 336 i2c_del_driver(&adm1275_driver); 337 } 338 339 MODULE_AUTHOR("Guenter Roeck"); 340 MODULE_DESCRIPTION("PMBus driver for Analog Devices ADM1275 and compatibles"); 341 MODULE_LICENSE("GPL"); 342 module_init(adm1275_init); 343 module_exit(adm1275_exit); 344