tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

max17042_battery: Support regmap to access device's registers

This patch makes max17042 fuelguage driver uses regmap API to access its
device's registers.

Signed-off-by: Jonghwa Lee <jonghwa3.lee@samsung.com>
Signed-off-by: Myungjoo Ham <myungjoo.ham@samsung.com>
Signed-off-by: Anton Vorontsov <anton@enomsg.org>

authored by

Jonghwa Lee and committed by
Anton Vorontsov 39e7213e 3d23c7f4

+170 -179
+170 -179
drivers/power/max17042_battery.c
··· 33 33 #include <linux/power_supply.h> 34 34 #include <linux/power/max17042_battery.h> 35 35 #include <linux/of.h> 36 + #include <linux/regmap.h> 36 37 37 38 /* Status register bits */ 38 39 #define STATUS_POR_BIT (1 << 1) ··· 68 67 69 68 struct max17042_chip { 70 69 struct i2c_client *client; 70 + struct regmap *regmap; 71 71 struct power_supply battery; 72 72 enum max170xx_chip_type chip_type; 73 73 struct max17042_platform_data *pdata; 74 74 struct work_struct work; 75 75 int init_complete; 76 76 }; 77 - 78 - static int max17042_write_reg(struct i2c_client *client, u8 reg, u16 value) 79 - { 80 - int ret = i2c_smbus_write_word_data(client, reg, value); 81 - 82 - if (ret < 0) 83 - dev_err(&client->dev, "%s: err %d\n", __func__, ret); 84 - 85 - return ret; 86 - } 87 - 88 - static int max17042_read_reg(struct i2c_client *client, u8 reg) 89 - { 90 - int ret = i2c_smbus_read_word_data(client, reg); 91 - 92 - if (ret < 0) 93 - dev_err(&client->dev, "%s: err %d\n", __func__, ret); 94 - 95 - return ret; 96 - } 97 - 98 - static void max17042_set_reg(struct i2c_client *client, 99 - struct max17042_reg_data *data, int size) 100 - { 101 - int i; 102 - 103 - for (i = 0; i < size; i++) 104 - max17042_write_reg(client, data[i].addr, data[i].data); 105 - } 106 77 107 78 static enum power_supply_property max17042_battery_props[] = { 108 79 POWER_SUPPLY_PROP_PRESENT, ··· 98 125 { 99 126 struct max17042_chip *chip = container_of(psy, 100 127 struct max17042_chip, battery); 128 + struct regmap *map = chip->regmap; 101 129 int ret; 130 + u32 data; 102 131 103 132 if (!chip->init_complete) 104 133 return -EAGAIN; 105 134 106 135 switch (psp) { 107 136 case POWER_SUPPLY_PROP_PRESENT: 108 - ret = max17042_read_reg(chip->client, MAX17042_STATUS); 137 + ret = regmap_read(map, MAX17042_STATUS, &data); 109 138 if (ret < 0) 110 139 return ret; 111 140 112 - if (ret & MAX17042_STATUS_BattAbsent) 141 + if (data & MAX17042_STATUS_BattAbsent) 113 142 val->intval = 0; 114 143 else 115 144 val->intval = 1; 116 145 break; 117 146 case POWER_SUPPLY_PROP_CYCLE_COUNT: 118 - ret = max17042_read_reg(chip->client, MAX17042_Cycles); 147 + ret = regmap_read(map, MAX17042_Cycles, &data); 119 148 if (ret < 0) 120 149 return ret; 121 150 122 - val->intval = ret; 151 + val->intval = data; 123 152 break; 124 153 case POWER_SUPPLY_PROP_VOLTAGE_MAX: 125 - ret = max17042_read_reg(chip->client, MAX17042_MinMaxVolt); 154 + ret = regmap_read(map, MAX17042_MinMaxVolt, &data); 126 155 if (ret < 0) 127 156 return ret; 128 157 129 - val->intval = ret >> 8; 158 + val->intval = data >> 8; 130 159 val->intval *= 20000; /* Units of LSB = 20mV */ 131 160 break; 132 161 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: 133 162 if (chip->chip_type == MAX17042) 134 - ret = max17042_read_reg(chip->client, MAX17042_V_empty); 163 + ret = regmap_read(map, MAX17042_V_empty, &data); 135 164 else 136 - ret = max17042_read_reg(chip->client, MAX17047_V_empty); 165 + ret = regmap_read(map, MAX17047_V_empty, &data); 137 166 if (ret < 0) 138 167 return ret; 139 168 140 - val->intval = ret >> 7; 169 + val->intval = data >> 7; 141 170 val->intval *= 10000; /* Units of LSB = 10mV */ 142 171 break; 143 172 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 144 - ret = max17042_read_reg(chip->client, MAX17042_VCELL); 173 + ret = regmap_read(map, MAX17042_VCELL, &data); 145 174 if (ret < 0) 146 175 return ret; 147 176 148 - val->intval = ret * 625 / 8; 177 + val->intval = data * 625 / 8; 149 178 break; 150 179 case POWER_SUPPLY_PROP_VOLTAGE_AVG: 151 - ret = max17042_read_reg(chip->client, MAX17042_AvgVCELL); 180 + ret = regmap_read(map, MAX17042_AvgVCELL, &data); 152 181 if (ret < 0) 153 182 return ret; 154 183 155 - val->intval = ret * 625 / 8; 184 + val->intval = data * 625 / 8; 156 185 break; 157 186 case POWER_SUPPLY_PROP_VOLTAGE_OCV: 158 - ret = max17042_read_reg(chip->client, MAX17042_OCVInternal); 187 + ret = regmap_read(map, MAX17042_OCVInternal, &data); 159 188 if (ret < 0) 160 189 return ret; 161 190 162 - val->intval = ret * 625 / 8; 191 + val->intval = data * 625 / 8; 163 192 break; 164 193 case POWER_SUPPLY_PROP_CAPACITY: 165 - ret = max17042_read_reg(chip->client, MAX17042_RepSOC); 194 + ret = regmap_read(map, MAX17042_RepSOC, &data); 166 195 if (ret < 0) 167 196 return ret; 168 197 169 - val->intval = ret >> 8; 198 + val->intval = data >> 8; 170 199 break; 171 200 case POWER_SUPPLY_PROP_CHARGE_FULL: 172 - ret = max17042_read_reg(chip->client, MAX17042_FullCAP); 201 + ret = regmap_read(map, MAX17042_FullCAP, &data); 173 202 if (ret < 0) 174 203 return ret; 175 204 176 - val->intval = ret * 1000 / 2; 205 + val->intval = data * 1000 / 2; 177 206 break; 178 207 case POWER_SUPPLY_PROP_CHARGE_COUNTER: 179 - ret = max17042_read_reg(chip->client, MAX17042_QH); 208 + ret = regmap_read(map, MAX17042_QH, &data); 180 209 if (ret < 0) 181 210 return ret; 182 211 183 - val->intval = ret * 1000 / 2; 212 + val->intval = data * 1000 / 2; 184 213 break; 185 214 case POWER_SUPPLY_PROP_TEMP: 186 - ret = max17042_read_reg(chip->client, MAX17042_TEMP); 215 + ret = regmap_read(map, MAX17042_TEMP, &data); 187 216 if (ret < 0) 188 217 return ret; 189 218 190 - val->intval = ret; 219 + val->intval = data; 191 220 /* The value is signed. */ 192 221 if (val->intval & 0x8000) { 193 222 val->intval = (0x7fff & ~val->intval) + 1; ··· 201 226 break; 202 227 case POWER_SUPPLY_PROP_CURRENT_NOW: 203 228 if (chip->pdata->enable_current_sense) { 204 - ret = max17042_read_reg(chip->client, MAX17042_Current); 229 + ret = regmap_read(map, MAX17042_Current, &data); 205 230 if (ret < 0) 206 231 return ret; 207 232 208 - val->intval = ret; 233 + val->intval = data; 209 234 if (val->intval & 0x8000) { 210 235 /* Negative */ 211 236 val->intval = ~val->intval & 0x7fff; ··· 219 244 break; 220 245 case POWER_SUPPLY_PROP_CURRENT_AVG: 221 246 if (chip->pdata->enable_current_sense) { 222 - ret = max17042_read_reg(chip->client, 223 - MAX17042_AvgCurrent); 247 + ret = regmap_read(map, MAX17042_AvgCurrent, &data); 224 248 if (ret < 0) 225 249 return ret; 226 250 227 - val->intval = ret; 251 + val->intval = data; 228 252 if (val->intval & 0x8000) { 229 253 /* Negative */ 230 254 val->intval = ~val->intval & 0x7fff; ··· 241 267 return 0; 242 268 } 243 269 244 - static int max17042_write_verify_reg(struct i2c_client *client, 245 - u8 reg, u16 value) 270 + static int max17042_write_verify_reg(struct regmap *map, u8 reg, u32 value) 246 271 { 247 272 int retries = 8; 248 273 int ret; 249 - u16 read_value; 274 + u32 read_value; 250 275 251 276 do { 252 - ret = i2c_smbus_write_word_data(client, reg, value); 253 - read_value = max17042_read_reg(client, reg); 277 + ret = regmap_write(map, reg, value); 278 + regmap_read(map, reg, &read_value); 254 279 if (read_value != value) { 255 280 ret = -EIO; 256 281 retries--; ··· 257 284 } while (retries && read_value != value); 258 285 259 286 if (ret < 0) 260 - dev_err(&client->dev, "%s: err %d\n", __func__, ret); 287 + pr_err("%s: err %d\n", __func__, ret); 261 288 262 289 return ret; 263 290 } 264 291 265 - static inline void max17042_override_por( 266 - struct i2c_client *client, u8 reg, u16 value) 292 + static inline void max17042_override_por(struct regmap *map, 293 + u8 reg, u16 value) 267 294 { 268 295 if (value) 269 - max17042_write_reg(client, reg, value); 296 + regmap_write(map, reg, value); 270 297 } 271 298 272 299 static inline void max10742_unlock_model(struct max17042_chip *chip) 273 300 { 274 - struct i2c_client *client = chip->client; 275 - max17042_write_reg(client, MAX17042_MLOCKReg1, MODEL_UNLOCK1); 276 - max17042_write_reg(client, MAX17042_MLOCKReg2, MODEL_UNLOCK2); 301 + struct regmap *map = chip->regmap; 302 + regmap_write(map, MAX17042_MLOCKReg1, MODEL_UNLOCK1); 303 + regmap_write(map, MAX17042_MLOCKReg2, MODEL_UNLOCK2); 277 304 } 278 305 279 306 static inline void max10742_lock_model(struct max17042_chip *chip) 280 307 { 281 - struct i2c_client *client = chip->client; 282 - max17042_write_reg(client, MAX17042_MLOCKReg1, MODEL_LOCK1); 283 - max17042_write_reg(client, MAX17042_MLOCKReg2, MODEL_LOCK2); 308 + struct regmap *map = chip->regmap; 309 + 310 + regmap_write(map, MAX17042_MLOCKReg1, MODEL_LOCK1); 311 + regmap_write(map, MAX17042_MLOCKReg2, MODEL_LOCK2); 284 312 } 285 313 286 314 static inline void max17042_write_model_data(struct max17042_chip *chip, 287 315 u8 addr, int size) 288 316 { 289 - struct i2c_client *client = chip->client; 317 + struct regmap *map = chip->regmap; 290 318 int i; 291 319 for (i = 0; i < size; i++) 292 - max17042_write_reg(client, addr + i, 293 - chip->pdata->config_data->cell_char_tbl[i]); 320 + regmap_write(map, addr + i, 321 + chip->pdata->config_data->cell_char_tbl[i]); 294 322 } 295 323 296 324 static inline void max17042_read_model_data(struct max17042_chip *chip, 297 - u8 addr, u16 *data, int size) 325 + u8 addr, u32 *data, int size) 298 326 { 299 - struct i2c_client *client = chip->client; 327 + struct regmap *map = chip->regmap; 300 328 int i; 301 329 302 330 for (i = 0; i < size; i++) 303 - data[i] = max17042_read_reg(client, addr + i); 331 + regmap_read(map, addr + i, &data[i]); 304 332 } 305 333 306 334 static inline int max17042_model_data_compare(struct max17042_chip *chip, ··· 324 350 { 325 351 int ret; 326 352 int table_size = ARRAY_SIZE(chip->pdata->config_data->cell_char_tbl); 327 - u16 *temp_data; 353 + u32 *temp_data; 328 354 329 355 temp_data = kcalloc(table_size, sizeof(*temp_data), GFP_KERNEL); 330 356 if (!temp_data) ··· 339 365 ret = max17042_model_data_compare( 340 366 chip, 341 367 chip->pdata->config_data->cell_char_tbl, 342 - temp_data, 368 + (u16 *)temp_data, 343 369 table_size); 344 370 345 371 max10742_lock_model(chip); ··· 352 378 { 353 379 int i; 354 380 int table_size = ARRAY_SIZE(chip->pdata->config_data->cell_char_tbl); 355 - u16 *temp_data; 381 + u32 *temp_data; 356 382 int ret = 0; 357 383 358 384 temp_data = kcalloc(table_size, sizeof(*temp_data), GFP_KERNEL); ··· 372 398 static void max17042_write_config_regs(struct max17042_chip *chip) 373 399 { 374 400 struct max17042_config_data *config = chip->pdata->config_data; 401 + struct regmap *map = chip->regmap; 375 402 376 - max17042_write_reg(chip->client, MAX17042_CONFIG, config->config); 377 - max17042_write_reg(chip->client, MAX17042_LearnCFG, config->learn_cfg); 378 - max17042_write_reg(chip->client, MAX17042_FilterCFG, 403 + regmap_write(map, MAX17042_CONFIG, config->config); 404 + regmap_write(map, MAX17042_LearnCFG, config->learn_cfg); 405 + regmap_write(map, MAX17042_FilterCFG, 379 406 config->filter_cfg); 380 - max17042_write_reg(chip->client, MAX17042_RelaxCFG, config->relax_cfg); 407 + regmap_write(map, MAX17042_RelaxCFG, config->relax_cfg); 381 408 if (chip->chip_type == MAX17047) 382 - max17042_write_reg(chip->client, MAX17047_FullSOCThr, 409 + regmap_write(map, MAX17047_FullSOCThr, 383 410 config->full_soc_thresh); 384 411 } 385 412 386 413 static void max17042_write_custom_regs(struct max17042_chip *chip) 387 414 { 388 415 struct max17042_config_data *config = chip->pdata->config_data; 416 + struct regmap *map = chip->regmap; 389 417 390 - max17042_write_verify_reg(chip->client, MAX17042_RCOMP0, 391 - config->rcomp0); 392 - max17042_write_verify_reg(chip->client, MAX17042_TempCo, 393 - config->tcompc0); 394 - max17042_write_verify_reg(chip->client, MAX17042_ICHGTerm, 395 - config->ichgt_term); 418 + max17042_write_verify_reg(map, MAX17042_RCOMP0, config->rcomp0); 419 + max17042_write_verify_reg(map, MAX17042_TempCo, config->tcompc0); 420 + max17042_write_verify_reg(map, MAX17042_ICHGTerm, config->ichgt_term); 396 421 if (chip->chip_type == MAX17042) { 397 - max17042_write_reg(chip->client, MAX17042_EmptyTempCo, 398 - config->empty_tempco); 399 - max17042_write_verify_reg(chip->client, MAX17042_K_empty0, 422 + regmap_write(map, MAX17042_EmptyTempCo, config->empty_tempco); 423 + max17042_write_verify_reg(map, MAX17042_K_empty0, 400 424 config->kempty0); 401 425 } else { 402 - max17042_write_verify_reg(chip->client, MAX17047_QRTbl00, 426 + max17042_write_verify_reg(map, MAX17047_QRTbl00, 403 427 config->qrtbl00); 404 - max17042_write_verify_reg(chip->client, MAX17047_QRTbl10, 428 + max17042_write_verify_reg(map, MAX17047_QRTbl10, 405 429 config->qrtbl10); 406 - max17042_write_verify_reg(chip->client, MAX17047_QRTbl20, 430 + max17042_write_verify_reg(map, MAX17047_QRTbl20, 407 431 config->qrtbl20); 408 - max17042_write_verify_reg(chip->client, MAX17047_QRTbl30, 432 + max17042_write_verify_reg(map, MAX17047_QRTbl30, 409 433 config->qrtbl30); 410 434 } 411 435 } ··· 411 439 static void max17042_update_capacity_regs(struct max17042_chip *chip) 412 440 { 413 441 struct max17042_config_data *config = chip->pdata->config_data; 442 + struct regmap *map = chip->regmap; 414 443 415 - max17042_write_verify_reg(chip->client, MAX17042_FullCAP, 444 + max17042_write_verify_reg(map, MAX17042_FullCAP, 416 445 config->fullcap); 417 - max17042_write_reg(chip->client, MAX17042_DesignCap, 418 - config->design_cap); 419 - max17042_write_verify_reg(chip->client, MAX17042_FullCAPNom, 446 + regmap_write(map, MAX17042_DesignCap, config->design_cap); 447 + max17042_write_verify_reg(map, MAX17042_FullCAPNom, 420 448 config->fullcapnom); 421 449 } 422 450 423 451 static void max17042_reset_vfsoc0_reg(struct max17042_chip *chip) 424 452 { 425 - u16 vfSoc; 453 + unsigned int vfSoc; 454 + struct regmap *map = chip->regmap; 426 455 427 - vfSoc = max17042_read_reg(chip->client, MAX17042_VFSOC); 428 - max17042_write_reg(chip->client, MAX17042_VFSOC0Enable, VFSOC0_UNLOCK); 429 - max17042_write_verify_reg(chip->client, MAX17042_VFSOC0, vfSoc); 430 - max17042_write_reg(chip->client, MAX17042_VFSOC0Enable, VFSOC0_LOCK); 456 + regmap_read(map, MAX17042_VFSOC, &vfSoc); 457 + regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_UNLOCK); 458 + max17042_write_verify_reg(map, MAX17042_VFSOC0, vfSoc); 459 + regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_LOCK); 431 460 } 432 461 433 462 static void max17042_load_new_capacity_params(struct max17042_chip *chip) 434 463 { 435 - u16 full_cap0, rep_cap, dq_acc, vfSoc; 464 + u32 full_cap0, rep_cap, dq_acc, vfSoc; 436 465 u32 rem_cap; 437 466 438 467 struct max17042_config_data *config = chip->pdata->config_data; 468 + struct regmap *map = chip->regmap; 439 469 440 - full_cap0 = max17042_read_reg(chip->client, MAX17042_FullCAP0); 441 - vfSoc = max17042_read_reg(chip->client, MAX17042_VFSOC); 470 + regmap_read(map, MAX17042_FullCAP0, &full_cap0); 471 + regmap_read(map, MAX17042_VFSOC, &vfSoc); 442 472 443 473 /* fg_vfSoc needs to shifted by 8 bits to get the 444 474 * perc in 1% accuracy, to get the right rem_cap multiply 445 475 * full_cap0, fg_vfSoc and devide by 100 446 476 */ 447 477 rem_cap = ((vfSoc >> 8) * full_cap0) / 100; 448 - max17042_write_verify_reg(chip->client, MAX17042_RemCap, (u16)rem_cap); 478 + max17042_write_verify_reg(map, MAX17042_RemCap, rem_cap); 449 479 450 - rep_cap = (u16)rem_cap; 451 - max17042_write_verify_reg(chip->client, MAX17042_RepCap, rep_cap); 480 + rep_cap = rem_cap; 481 + max17042_write_verify_reg(map, MAX17042_RepCap, rep_cap); 452 482 453 483 /* Write dQ_acc to 200% of Capacity and dP_acc to 200% */ 454 484 dq_acc = config->fullcap / dQ_ACC_DIV; 455 - max17042_write_verify_reg(chip->client, MAX17042_dQacc, dq_acc); 456 - max17042_write_verify_reg(chip->client, MAX17042_dPacc, dP_ACC_200); 485 + max17042_write_verify_reg(map, MAX17042_dQacc, dq_acc); 486 + max17042_write_verify_reg(map, MAX17042_dPacc, dP_ACC_200); 457 487 458 - max17042_write_verify_reg(chip->client, MAX17042_FullCAP, 488 + max17042_write_verify_reg(map, MAX17042_FullCAP, 459 489 config->fullcap); 460 - max17042_write_reg(chip->client, MAX17042_DesignCap, 490 + regmap_write(map, MAX17042_DesignCap, 461 491 config->design_cap); 462 - max17042_write_verify_reg(chip->client, MAX17042_FullCAPNom, 492 + max17042_write_verify_reg(map, MAX17042_FullCAPNom, 463 493 config->fullcapnom); 464 494 /* Update SOC register with new SOC */ 465 - max17042_write_reg(chip->client, MAX17042_RepSOC, vfSoc); 495 + regmap_write(map, MAX17042_RepSOC, vfSoc); 466 496 } 467 497 468 498 /* ··· 474 500 */ 475 501 static inline void max17042_override_por_values(struct max17042_chip *chip) 476 502 { 477 - struct i2c_client *client = chip->client; 503 + struct regmap *map = chip->regmap; 478 504 struct max17042_config_data *config = chip->pdata->config_data; 479 505 480 - max17042_override_por(client, MAX17042_TGAIN, config->tgain); 481 - max17042_override_por(client, MAx17042_TOFF, config->toff); 482 - max17042_override_por(client, MAX17042_CGAIN, config->cgain); 483 - max17042_override_por(client, MAX17042_COFF, config->coff); 506 + max17042_override_por(map, MAX17042_TGAIN, config->tgain); 507 + max17042_override_por(map, MAx17042_TOFF, config->toff); 508 + max17042_override_por(map, MAX17042_CGAIN, config->cgain); 509 + max17042_override_por(map, MAX17042_COFF, config->coff); 484 510 485 - max17042_override_por(client, MAX17042_VALRT_Th, config->valrt_thresh); 486 - max17042_override_por(client, MAX17042_TALRT_Th, config->talrt_thresh); 487 - max17042_override_por(client, MAX17042_SALRT_Th, 488 - config->soc_alrt_thresh); 489 - max17042_override_por(client, MAX17042_CONFIG, config->config); 490 - max17042_override_por(client, MAX17042_SHDNTIMER, config->shdntimer); 511 + max17042_override_por(map, MAX17042_VALRT_Th, config->valrt_thresh); 512 + max17042_override_por(map, MAX17042_TALRT_Th, config->talrt_thresh); 513 + max17042_override_por(map, MAX17042_SALRT_Th, 514 + config->soc_alrt_thresh); 515 + max17042_override_por(map, MAX17042_CONFIG, config->config); 516 + max17042_override_por(map, MAX17042_SHDNTIMER, config->shdntimer); 491 517 492 - max17042_override_por(client, MAX17042_DesignCap, config->design_cap); 493 - max17042_override_por(client, MAX17042_ICHGTerm, config->ichgt_term); 518 + max17042_override_por(map, MAX17042_DesignCap, config->design_cap); 519 + max17042_override_por(map, MAX17042_ICHGTerm, config->ichgt_term); 494 520 495 - max17042_override_por(client, MAX17042_AtRate, config->at_rate); 496 - max17042_override_por(client, MAX17042_LearnCFG, config->learn_cfg); 497 - max17042_override_por(client, MAX17042_FilterCFG, config->filter_cfg); 498 - max17042_override_por(client, MAX17042_RelaxCFG, config->relax_cfg); 499 - max17042_override_por(client, MAX17042_MiscCFG, config->misc_cfg); 500 - max17042_override_por(client, MAX17042_MaskSOC, config->masksoc); 521 + max17042_override_por(map, MAX17042_AtRate, config->at_rate); 522 + max17042_override_por(map, MAX17042_LearnCFG, config->learn_cfg); 523 + max17042_override_por(map, MAX17042_FilterCFG, config->filter_cfg); 524 + max17042_override_por(map, MAX17042_RelaxCFG, config->relax_cfg); 525 + max17042_override_por(map, MAX17042_MiscCFG, config->misc_cfg); 526 + max17042_override_por(map, MAX17042_MaskSOC, config->masksoc); 501 527 502 - max17042_override_por(client, MAX17042_FullCAP, config->fullcap); 503 - max17042_override_por(client, MAX17042_FullCAPNom, config->fullcapnom); 528 + max17042_override_por(map, MAX17042_FullCAP, config->fullcap); 529 + max17042_override_por(map, MAX17042_FullCAPNom, config->fullcapnom); 504 530 if (chip->chip_type == MAX17042) 505 - max17042_override_por(client, MAX17042_SOC_empty, 531 + max17042_override_por(map, MAX17042_SOC_empty, 506 532 config->socempty); 507 - max17042_override_por(client, MAX17042_LAvg_empty, config->lavg_empty); 508 - max17042_override_por(client, MAX17042_dQacc, config->dqacc); 509 - max17042_override_por(client, MAX17042_dPacc, config->dpacc); 533 + max17042_override_por(map, MAX17042_LAvg_empty, config->lavg_empty); 534 + max17042_override_por(map, MAX17042_dQacc, config->dqacc); 535 + max17042_override_por(map, MAX17042_dPacc, config->dpacc); 510 536 511 537 if (chip->chip_type == MAX17042) 512 - max17042_override_por(client, MAX17042_V_empty, config->vempty); 538 + max17042_override_por(map, MAX17042_V_empty, config->vempty); 513 539 else 514 - max17042_override_por(client, MAX17047_V_empty, config->vempty); 515 - max17042_override_por(client, MAX17042_TempNom, config->temp_nom); 516 - max17042_override_por(client, MAX17042_TempLim, config->temp_lim); 517 - max17042_override_por(client, MAX17042_FCTC, config->fctc); 518 - max17042_override_por(client, MAX17042_RCOMP0, config->rcomp0); 519 - max17042_override_por(client, MAX17042_TempCo, config->tcompc0); 540 + max17042_override_por(map, MAX17047_V_empty, config->vempty); 541 + max17042_override_por(map, MAX17042_TempNom, config->temp_nom); 542 + max17042_override_por(map, MAX17042_TempLim, config->temp_lim); 543 + max17042_override_por(map, MAX17042_FCTC, config->fctc); 544 + max17042_override_por(map, MAX17042_RCOMP0, config->rcomp0); 545 + max17042_override_por(map, MAX17042_TempCo, config->tcompc0); 520 546 if (chip->chip_type) { 521 - max17042_override_por(client, MAX17042_EmptyTempCo, 522 - config->empty_tempco); 523 - max17042_override_por(client, MAX17042_K_empty0, 524 - config->kempty0); 547 + max17042_override_por(map, MAX17042_EmptyTempCo, 548 + config->empty_tempco); 549 + max17042_override_por(map, MAX17042_K_empty0, 550 + config->kempty0); 525 551 } 526 552 } 527 553 528 554 static int max17042_init_chip(struct max17042_chip *chip) 529 555 { 556 + struct regmap *map = chip->regmap; 530 557 int ret; 531 558 int val; 532 559 ··· 572 597 max17042_load_new_capacity_params(chip); 573 598 574 599 /* Init complete, Clear the POR bit */ 575 - val = max17042_read_reg(chip->client, MAX17042_STATUS); 576 - max17042_write_reg(chip->client, MAX17042_STATUS, 577 - val & (~STATUS_POR_BIT)); 600 + regmap_read(map, MAX17042_STATUS, &val); 601 + regmap_write(map, MAX17042_STATUS, val & (~STATUS_POR_BIT)); 578 602 return 0; 579 603 } 580 604 581 605 static void max17042_set_soc_threshold(struct max17042_chip *chip, u16 off) 582 606 { 583 - u16 soc, soc_tr; 607 + struct regmap *map = chip->regmap; 608 + u32 soc, soc_tr; 584 609 585 610 /* program interrupt thesholds such that we should 586 611 * get interrupt for every 'off' perc change in the soc 587 612 */ 588 - soc = max17042_read_reg(chip->client, MAX17042_RepSOC) >> 8; 613 + regmap_read(map, MAX17042_RepSOC, &soc); 614 + soc >>= 8; 589 615 soc_tr = (soc + off) << 8; 590 616 soc_tr |= (soc - off); 591 - max17042_write_reg(chip->client, MAX17042_SALRT_Th, soc_tr); 617 + regmap_write(map, MAX17042_SALRT_Th, soc_tr); 592 618 } 593 619 594 620 static irqreturn_t max17042_thread_handler(int id, void *dev) 595 621 { 596 622 struct max17042_chip *chip = dev; 597 - u16 val; 623 + u32 val; 598 624 599 - val = max17042_read_reg(chip->client, MAX17042_STATUS); 625 + regmap_read(chip->regmap, MAX17042_STATUS, &val); 600 626 if ((val & STATUS_INTR_SOCMIN_BIT) || 601 627 (val & STATUS_INTR_SOCMAX_BIT)) { 602 628 dev_info(&chip->client->dev, "SOC threshold INTR\n"); ··· 658 682 } 659 683 #endif 660 684 685 + static struct regmap_config max17042_regmap_config = { 686 + .reg_bits = 8, 687 + .val_bits = 16, 688 + .val_format_endian = REGMAP_ENDIAN_NATIVE, 689 + }; 690 + 661 691 static int max17042_probe(struct i2c_client *client, 662 692 const struct i2c_device_id *id) 663 693 { 664 694 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); 665 695 struct max17042_chip *chip; 666 696 int ret; 667 - int reg; 697 + int i; 698 + u32 val; 668 699 669 700 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) 670 701 return -EIO; ··· 681 698 return -ENOMEM; 682 699 683 700 chip->client = client; 701 + chip->regmap = devm_regmap_init_i2c(client, &max17042_regmap_config); 702 + if (IS_ERR(chip->regmap)) { 703 + dev_err(&client->dev, "Failed to initialize regmap\n"); 704 + return -EINVAL; 705 + } 706 + 684 707 chip->pdata = max17042_get_pdata(&client->dev); 685 708 if (!chip->pdata) { 686 709 dev_err(&client->dev, "no platform data provided\n"); ··· 695 706 696 707 i2c_set_clientdata(client, chip); 697 708 698 - ret = max17042_read_reg(chip->client, MAX17042_DevName); 699 - if (ret == MAX17042_IC_VERSION) { 709 + regmap_read(chip->regmap, MAX17042_DevName, &val); 710 + if (val == MAX17042_IC_VERSION) { 700 711 dev_dbg(&client->dev, "chip type max17042 detected\n"); 701 712 chip->chip_type = MAX17042; 702 - } else if (ret == MAX17047_IC_VERSION) { 713 + } else if (val == MAX17047_IC_VERSION) { 703 714 dev_dbg(&client->dev, "chip type max17047/50 detected\n"); 704 715 chip->chip_type = MAX17047; 705 716 } else { 706 - dev_err(&client->dev, "device version mismatch: %x\n", ret); 717 + dev_err(&client->dev, "device version mismatch: %x\n", val); 707 718 return -EIO; 708 719 } 709 720 ··· 722 733 chip->pdata->r_sns = MAX17042_DEFAULT_SNS_RESISTOR; 723 734 724 735 if (chip->pdata->init_data) 725 - max17042_set_reg(client, chip->pdata->init_data, 726 - chip->pdata->num_init_data); 736 + for (i = 0; i < chip->pdata->num_init_data; i++) 737 + regmap_write(chip->regmap, 738 + chip->pdata->init_data[i].addr, 739 + chip->pdata->init_data[i].data); 727 740 728 741 if (!chip->pdata->enable_current_sense) { 729 - max17042_write_reg(client, MAX17042_CGAIN, 0x0000); 730 - max17042_write_reg(client, MAX17042_MiscCFG, 0x0003); 731 - max17042_write_reg(client, MAX17042_LearnCFG, 0x0007); 742 + regmap_write(chip->regmap, MAX17042_CGAIN, 0x0000); 743 + regmap_write(chip->regmap, MAX17042_MiscCFG, 0x0003); 744 + regmap_write(chip->regmap, MAX17042_LearnCFG, 0x0007); 732 745 } 733 746 734 747 ret = power_supply_register(&client->dev, &chip->battery); ··· 745 754 IRQF_TRIGGER_FALLING, 746 755 chip->battery.name, chip); 747 756 if (!ret) { 748 - reg = max17042_read_reg(client, MAX17042_CONFIG); 749 - reg |= CONFIG_ALRT_BIT_ENBL; 750 - max17042_write_reg(client, MAX17042_CONFIG, reg); 757 + regmap_read(chip->regmap, MAX17042_CONFIG, &val); 758 + val |= CONFIG_ALRT_BIT_ENBL; 759 + regmap_write(chip->regmap, MAX17042_CONFIG, val); 751 760 max17042_set_soc_threshold(chip, 1); 752 761 } else { 753 762 client->irq = 0; ··· 756 765 } 757 766 } 758 767 759 - reg = max17042_read_reg(chip->client, MAX17042_STATUS); 760 - if (reg & STATUS_POR_BIT) { 768 + regmap_read(chip->regmap, MAX17042_STATUS, &val); 769 + if (val & STATUS_POR_BIT) { 761 770 INIT_WORK(&chip->work, max17042_init_worker); 762 771 schedule_work(&chip->work); 763 772 } else {