1 /* 2 * Hardware monitoring driver for ucd9200 series Digital PWM System Controllers 3 * 4 * Copyright (C) 2011 Ericsson AB. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 */ 20 21 #include <linux/kernel.h> 22 #include <linux/module.h> 23 #include <linux/init.h> 24 #include <linux/err.h> 25 #include <linux/slab.h> 26 #include <linux/i2c.h> 27 #include <linux/i2c/pmbus.h> 28 #include "pmbus.h" 29 30 #define UCD9200_PHASE_INFO 0xd2 31 #define UCD9200_DEVICE_ID 0xfd 32 33 enum chips { ucd9200, ucd9220, ucd9222, ucd9224, ucd9240, ucd9244, ucd9246, 34 ucd9248 }; 35 36 static const struct i2c_device_id ucd9200_id[] = { 37 {"ucd9200", ucd9200}, 38 {"ucd9220", ucd9220}, 39 {"ucd9222", ucd9222}, 40 {"ucd9224", ucd9224}, 41 {"ucd9240", ucd9240}, 42 {"ucd9244", ucd9244}, 43 {"ucd9246", ucd9246}, 44 {"ucd9248", ucd9248}, 45 {} 46 }; 47 MODULE_DEVICE_TABLE(i2c, ucd9200_id); 48 49 static int ucd9200_probe(struct i2c_client *client, 50 const struct i2c_device_id *id) 51 { 52 u8 block_buffer[I2C_SMBUS_BLOCK_MAX + 1]; 53 struct pmbus_driver_info *info; 54 const struct i2c_device_id *mid; 55 int i, j, ret; 56 57 if (!i2c_check_functionality(client->adapter, 58 I2C_FUNC_SMBUS_BYTE_DATA | 59 I2C_FUNC_SMBUS_BLOCK_DATA)) 60 return -ENODEV; 61 62 ret = i2c_smbus_read_block_data(client, UCD9200_DEVICE_ID, 63 block_buffer); 64 if (ret < 0) { 65 dev_err(&client->dev, "Failed to read device ID\n"); 66 return ret; 67 } 68 block_buffer[ret] = '\0'; 69 dev_info(&client->dev, "Device ID %s\n", block_buffer); 70 71 mid = NULL; 72 for (i = 0; i < ARRAY_SIZE(ucd9200_id); i++) { 73 mid = &ucd9200_id[i]; 74 if (!strncasecmp(mid->name, block_buffer, strlen(mid->name))) 75 break; 76 } 77 if (!mid || !strlen(mid->name)) { 78 dev_err(&client->dev, "Unsupported device\n"); 79 return -ENODEV; 80 } 81 if (id->driver_data != ucd9200 && id->driver_data != mid->driver_data) 82 dev_notice(&client->dev, 83 "Device mismatch: Configured %s, detected %s\n", 84 id->name, mid->name); 85 86 info = kzalloc(sizeof(struct pmbus_driver_info), GFP_KERNEL); 87 if (!info) 88 return -ENOMEM; 89 90 ret = i2c_smbus_read_block_data(client, UCD9200_PHASE_INFO, 91 block_buffer); 92 if (ret < 0) { 93 dev_err(&client->dev, "Failed to read phase information\n"); 94 goto out; 95 } 96 97 /* 98 * Calculate number of configured pages (rails) from PHASE_INFO 99 * register. 100 * Rails have to be sequential, so we can abort after finding 101 * the first unconfigured rail. 102 */ 103 info->pages = 0; 104 for (i = 0; i < ret; i++) { 105 if (!block_buffer[i]) 106 break; 107 info->pages++; 108 } 109 if (!info->pages) { 110 dev_err(&client->dev, "No rails configured\n"); 111 ret = -ENODEV; 112 goto out; 113 } 114 dev_info(&client->dev, "%d rails configured\n", info->pages); 115 116 /* 117 * Set PHASE registers on all pages to 0xff to ensure that phase 118 * specific commands will apply to all phases of a given page (rail). 119 * This only affects the READ_IOUT and READ_TEMPERATURE2 registers. 120 * READ_IOUT will return the sum of currents of all phases of a rail, 121 * and READ_TEMPERATURE2 will return the maximum temperature detected 122 * for the the phases of the rail. 123 */ 124 for (i = 0; i < info->pages; i++) { 125 /* 126 * Setting PAGE & PHASE fails once in a while for no obvious 127 * reason, so we need to retry a couple of times. 128 */ 129 for (j = 0; j < 3; j++) { 130 ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i); 131 if (ret < 0) 132 continue; 133 ret = i2c_smbus_write_byte_data(client, PMBUS_PHASE, 134 0xff); 135 if (ret < 0) 136 continue; 137 break; 138 } 139 if (ret < 0) { 140 dev_err(&client->dev, 141 "Failed to initialize PHASE registers\n"); 142 goto out; 143 } 144 } 145 if (info->pages > 1) 146 i2c_smbus_write_byte_data(client, PMBUS_PAGE, 0); 147 148 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT | 149 PMBUS_HAVE_IIN | PMBUS_HAVE_PIN | 150 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | 151 PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT | 152 PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP | 153 PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP; 154 155 for (i = 1; i < info->pages; i++) 156 info->func[i] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | 157 PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT | 158 PMBUS_HAVE_POUT | 159 PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP; 160 161 /* ucd9240 supports a single fan */ 162 if (mid->driver_data == ucd9240) 163 info->func[0] |= PMBUS_HAVE_FAN12 | PMBUS_HAVE_STATUS_FAN12; 164 165 ret = pmbus_do_probe(client, mid, info); 166 if (ret < 0) 167 goto out; 168 return 0; 169 out: 170 kfree(info); 171 return ret; 172 } 173 174 static int ucd9200_remove(struct i2c_client *client) 175 { 176 int ret; 177 const struct pmbus_driver_info *info; 178 179 info = pmbus_get_driver_info(client); 180 ret = pmbus_do_remove(client); 181 kfree(info); 182 return ret; 183 } 184 185 186 /* This is the driver that will be inserted */ 187 static struct i2c_driver ucd9200_driver = { 188 .driver = { 189 .name = "ucd9200", 190 }, 191 .probe = ucd9200_probe, 192 .remove = ucd9200_remove, 193 .id_table = ucd9200_id, 194 }; 195 196 static int __init ucd9200_init(void) 197 { 198 return i2c_add_driver(&ucd9200_driver); 199 } 200 201 static void __exit ucd9200_exit(void) 202 { 203 i2c_del_driver(&ucd9200_driver); 204 } 205 206 MODULE_AUTHOR("Guenter Roeck"); 207 MODULE_DESCRIPTION("PMBus driver for TI UCD922x, UCD924x"); 208 MODULE_LICENSE("GPL"); 209 module_init(ucd9200_init); 210 module_exit(ucd9200_exit); 211