1 // SPDX-License-Identifier: GPL-2.0 2 /* Author: Dan Scally <djrscally@gmail.com> */ 3 4 #include <linux/acpi.h> 5 #include <linux/i2c.h> 6 #include <linux/kernel.h> 7 #include <linux/mfd/core.h> 8 #include <linux/mfd/tps68470.h> 9 #include <linux/platform_device.h> 10 #include <linux/platform_data/tps68470.h> 11 #include <linux/regmap.h> 12 #include <linux/string.h> 13 14 #include "common.h" 15 #include "tps68470.h" 16 17 #define DESIGNED_FOR_CHROMEOS 1 18 #define DESIGNED_FOR_WINDOWS 2 19 20 #define TPS68470_WIN_MFD_CELL_COUNT 3 21 22 static const struct mfd_cell tps68470_cros[] = { 23 { .name = "tps68470-gpio" }, 24 { .name = "tps68470_pmic_opregion" }, 25 }; 26 27 static const struct regmap_config tps68470_regmap_config = { 28 .reg_bits = 8, 29 .val_bits = 8, 30 .max_register = TPS68470_REG_MAX, 31 }; 32 33 static int tps68470_chip_init(struct device *dev, struct regmap *regmap) 34 { 35 unsigned int version; 36 int ret; 37 38 /* Force software reset */ 39 ret = regmap_write(regmap, TPS68470_REG_RESET, TPS68470_REG_RESET_MASK); 40 if (ret) 41 return ret; 42 43 ret = regmap_read(regmap, TPS68470_REG_REVID, &version); 44 if (ret) { 45 dev_err(dev, "Failed to read revision register: %d\n", ret); 46 return ret; 47 } 48 49 dev_info(dev, "TPS68470 REVID: 0x%02x\n", version); 50 51 return 0; 52 } 53 54 /** skl_int3472_tps68470_calc_type: Check what platform a device is designed for 55 * @adev: A pointer to a &struct acpi_device 56 * 57 * Check CLDB buffer against the PMIC's adev. If present, then we check 58 * the value of control_logic_type field and follow one of the 59 * following scenarios: 60 * 61 * 1. No CLDB - likely ACPI tables designed for ChromeOS. We 62 * create platform devices for the GPIOs and OpRegion drivers. 63 * 64 * 2. CLDB, with control_logic_type = 2 - probably ACPI tables 65 * made for Windows 2-in-1 platforms. Register pdevs for GPIO, 66 * Clock and Regulator drivers to bind to. 67 * 68 * 3. Any other value in control_logic_type, we should never have 69 * gotten to this point; fail probe and return. 70 * 71 * Return: 72 * * 1 Device intended for ChromeOS 73 * * 2 Device intended for Windows 74 * * -EINVAL Where @adev has an object named CLDB but it does not conform to 75 * our expectations 76 */ 77 static int skl_int3472_tps68470_calc_type(struct acpi_device *adev) 78 { 79 struct int3472_cldb cldb = { 0 }; 80 int ret; 81 82 /* 83 * A CLDB buffer that exists, but which does not match our expectations 84 * should trigger an error so we don't blindly continue. 85 */ 86 ret = skl_int3472_fill_cldb(adev, &cldb); 87 if (ret && ret != -ENODEV) 88 return ret; 89 90 if (ret) 91 return DESIGNED_FOR_CHROMEOS; 92 93 if (cldb.control_logic_type != 2) 94 return -EINVAL; 95 96 return DESIGNED_FOR_WINDOWS; 97 } 98 99 /* 100 * Return the size of the flexible array member, because we'll need that later 101 * on to pass .pdata_size to cells. 102 */ 103 static int 104 skl_int3472_fill_clk_pdata(struct device *dev, struct tps68470_clk_platform_data **clk_pdata) 105 { 106 struct acpi_device *adev = ACPI_COMPANION(dev); 107 struct acpi_device *consumer; 108 unsigned int n_consumers = 0; 109 const char *sensor_name; 110 unsigned int i = 0; 111 112 for_each_acpi_consumer_dev(adev, consumer) 113 n_consumers++; 114 115 if (!n_consumers) { 116 dev_err(dev, "INT3472 seems to have no dependents\n"); 117 return -ENODEV; 118 } 119 120 *clk_pdata = devm_kzalloc(dev, struct_size(*clk_pdata, consumers, n_consumers), 121 GFP_KERNEL); 122 if (!*clk_pdata) 123 return -ENOMEM; 124 125 (*clk_pdata)->n_consumers = n_consumers; 126 i = 0; 127 128 for_each_acpi_consumer_dev(adev, consumer) { 129 sensor_name = devm_kasprintf(dev, GFP_KERNEL, I2C_DEV_NAME_FORMAT, 130 acpi_dev_name(consumer)); 131 if (!sensor_name) { 132 acpi_dev_put(consumer); 133 return -ENOMEM; 134 } 135 136 (*clk_pdata)->consumers[i].consumer_dev_name = sensor_name; 137 i++; 138 } 139 140 return n_consumers; 141 } 142 143 static int skl_int3472_tps68470_probe(struct i2c_client *client) 144 { 145 struct acpi_device *adev = ACPI_COMPANION(&client->dev); 146 const struct int3472_tps68470_board_data *board_data; 147 struct tps68470_clk_platform_data *clk_pdata; 148 struct mfd_cell *cells; 149 struct regmap *regmap; 150 int n_consumers; 151 int device_type; 152 int ret; 153 int i; 154 155 n_consumers = skl_int3472_fill_clk_pdata(&client->dev, &clk_pdata); 156 if (n_consumers < 0) 157 return n_consumers; 158 159 regmap = devm_regmap_init_i2c(client, &tps68470_regmap_config); 160 if (IS_ERR(regmap)) { 161 dev_err(&client->dev, "Failed to create regmap: %ld\n", PTR_ERR(regmap)); 162 return PTR_ERR(regmap); 163 } 164 165 i2c_set_clientdata(client, regmap); 166 167 ret = tps68470_chip_init(&client->dev, regmap); 168 if (ret < 0) { 169 dev_err(&client->dev, "TPS68470 init error %d\n", ret); 170 return ret; 171 } 172 173 device_type = skl_int3472_tps68470_calc_type(adev); 174 switch (device_type) { 175 case DESIGNED_FOR_WINDOWS: 176 board_data = int3472_tps68470_get_board_data(dev_name(&client->dev)); 177 if (!board_data) 178 return dev_err_probe(&client->dev, -ENODEV, "No board-data found for this model\n"); 179 180 cells = kcalloc(TPS68470_WIN_MFD_CELL_COUNT, sizeof(*cells), GFP_KERNEL); 181 if (!cells) 182 return -ENOMEM; 183 184 /* 185 * The order of the cells matters here! The clk must be first 186 * because the regulator depends on it. The gpios must be last, 187 * acpi_gpiochip_add() calls acpi_dev_clear_dependencies() and 188 * the clk + regulators must be ready when this happens. 189 */ 190 cells[0].name = "tps68470-clk"; 191 cells[0].platform_data = clk_pdata; 192 cells[0].pdata_size = struct_size(clk_pdata, consumers, n_consumers); 193 cells[1].name = "tps68470-regulator"; 194 cells[1].platform_data = (void *)board_data->tps68470_regulator_pdata; 195 cells[1].pdata_size = sizeof(struct tps68470_regulator_platform_data); 196 cells[2].name = "tps68470-gpio"; 197 198 for (i = 0; i < board_data->n_gpiod_lookups; i++) 199 gpiod_add_lookup_table(board_data->tps68470_gpio_lookup_tables[i]); 200 201 ret = devm_mfd_add_devices(&client->dev, PLATFORM_DEVID_NONE, 202 cells, TPS68470_WIN_MFD_CELL_COUNT, 203 NULL, 0, NULL); 204 kfree(cells); 205 206 if (ret) { 207 for (i = 0; i < board_data->n_gpiod_lookups; i++) 208 gpiod_remove_lookup_table(board_data->tps68470_gpio_lookup_tables[i]); 209 } 210 211 break; 212 case DESIGNED_FOR_CHROMEOS: 213 ret = devm_mfd_add_devices(&client->dev, PLATFORM_DEVID_NONE, 214 tps68470_cros, ARRAY_SIZE(tps68470_cros), 215 NULL, 0, NULL); 216 break; 217 default: 218 dev_err(&client->dev, "Failed to add MFD devices\n"); 219 return device_type; 220 } 221 222 /* 223 * No acpi_dev_clear_dependencies() here, since the acpi_gpiochip_add() 224 * for the GPIO cell already does this. 225 */ 226 227 return ret; 228 } 229 230 static void skl_int3472_tps68470_remove(struct i2c_client *client) 231 { 232 const struct int3472_tps68470_board_data *board_data; 233 int i; 234 235 board_data = int3472_tps68470_get_board_data(dev_name(&client->dev)); 236 if (board_data) { 237 for (i = 0; i < board_data->n_gpiod_lookups; i++) 238 gpiod_remove_lookup_table(board_data->tps68470_gpio_lookup_tables[i]); 239 } 240 } 241 242 static const struct acpi_device_id int3472_device_id[] = { 243 { "INT3472", 0 }, 244 { } 245 }; 246 MODULE_DEVICE_TABLE(acpi, int3472_device_id); 247 248 static struct i2c_driver int3472_tps68470 = { 249 .driver = { 250 .name = "int3472-tps68470", 251 .acpi_match_table = int3472_device_id, 252 }, 253 .probe = skl_int3472_tps68470_probe, 254 .remove = skl_int3472_tps68470_remove, 255 }; 256 module_i2c_driver(int3472_tps68470); 257 258 MODULE_DESCRIPTION("Intel SkyLake INT3472 ACPI TPS68470 Device Driver"); 259 MODULE_AUTHOR("Daniel Scally <djrscally@gmail.com>"); 260 MODULE_LICENSE("GPL v2"); 261 MODULE_SOFTDEP("pre: clk-tps68470 tps68470-regulator"); 262