• Android充电驱动bq24375源码分析

    这个驱动的源码还是比较简单的，我把源码中的函数都写上了中文注释。驱动虽小，五脏俱全。是学习硬件驱动的好例子。

    看驱动源码， 一定要先看芯片的PDF文档，重点是寄存器部分。对照文档和代码才能明白其中的关键代码。

    文档下载地址：https://download.csdn.net/download/langeldep/87009997

    1. /*
    2.  * Battery charger driver for TI BQ24735
    3.  *
    4.  * Copyright (c) 2013, NVIDIA CORPORATION.  All rights reserved.
    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;
    9.  *
    10.  * This program is distributed in the hope that it will be useful, but WITHOUT
    11.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    12.  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
    13.  * more details.
    14.  *
    15.  * You should have received a copy of the GNU General Public License along
    16.  * with this program; if not, write to the Free Software Foundation, Inc.,
    17.  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
    18.  */
    19.  
    20. #include 
    21. #include 
    22. #include 
    23. #include 
    24. #include 
    25. #include 
    26. #include 
    27. #include 
    28. #include 
    29. #include 
    30. #include 
    31. #include 
    32. #include 
    33. #include 
    34.  
    35. #define BQ24735_CHG_OPT				0x12
    36. #define BQ24735_CHG_OPT_CHARGE_DISABLE	(1 << 0)
    37. #define BQ24735_CHG_OPT_AC_PRESENT	(1 << 4)
    38. #define BQ24735_CHARGE_CURRENT		0x14
    39. #define BQ24735_CHARGE_CURRENT_MASK	0x1fc0
    40. #define BQ24735_CHARGE_VOLTAGE		0x15
    41. #define BQ24735_CHARGE_VOLTAGE_MASK	0x7ff0
    42. #define BQ24735_INPUT_CURRENT		0x3f
    43. #define BQ24735_INPUT_CURRENT_MASK	0x1f80
    44. #define BQ24735_MANUFACTURER_ID		0xfe
    45. #define BQ24735_DEVICE_ID			0xff
    46.  
    47. /*
    48. 0x12H   ChargeOption()    Read or Write          Charger  Options Control        0xF902H
    49. 0x14H   ChargeCurrent()   Read or Write          7-Bit  Charge Current Setting   0x0000H
    50. 0x15H   ChargeVoltage()   Read or Write          11-Bit Charge Voltage Setting   0x0000H
    51. 0x3FH   InputCurrent()    Read or Write          6-Bit Input Current Setting     0x1000H
    52. 0XFEH   ManufacturerID()  Read Only              Manufacturer ID                 0x0040H
    53. 0xFFH   DeviceID()        Read Only              Device       ID                 0x000BH
    54. */
    55.  
    56. struct bq24735_platform {
    57. 	uint32_t charge_current;
    58. 	uint32_t charge_voltage;
    59. 	uint32_t input_current;
    60.  
    61. 	const char *name;
    62.  
    63. 	bool ext_control;
    64.  
    65. 	char **supplied_to;
    66. 	size_t num_supplicants;
    67. };
    68.  
    69. struct bq24735 {
    70. 	struct power_supply			*charger;
    71. 	struct power_supply_desc	charger_desc;
    72. 	struct i2c_client			*client;
    73. 	struct bq24735_platform		*pdata;
    74. 	struct mutex			lock;
    75. 	struct gpio_desc		*status_gpio;
    76. 	struct delayed_work		poll;
    77. 	u32						poll_interval;
    78. 	bool					charging;
    79. };
    80.  
    81. //通过psy的指针获取自定义的结构体指针
    82. static inline struct bq24735 *to_bq24735(struct power_supply *psy)
    83. {
    84. 	return power_supply_get_drvdata(psy);
    85. }
    86.  
    87. static enum power_supply_property bq24735_charger_properties[] = {
    88. 	POWER_SUPPLY_PROP_STATUS,
    89. 	POWER_SUPPLY_PROP_ONLINE,
    90. };
    91.  
    92. //判断属性是否可写
    93. static int bq24735_charger_property_is_writeable(struct power_supply *psy, enum power_supply_property psp)
    94. {
    95. 	switch (psp) {
    96. 	case POWER_SUPPLY_PROP_STATUS:
    97. 		return 1;
    98. 	default:
    99. 		break;
    100. 	}
    101.  
    102. 	return 0;
    103. }
    104.  
    105. //给寄存器写2个字节的值
    106. static inline int bq24735_write_word(struct i2c_client *client, u8 reg, u16 value)
    107. {
    108. 	return i2c_smbus_write_word_data(client, reg, value);
    109. }
    110.  
    111. //读取寄存器两个字节的值
    112. static inline int bq24735_read_word(struct i2c_client *client, u8 reg)
    113. {
    114. 	return i2c_smbus_read_word_data(client, reg);
    115. }
    116.  
    117. //先读取寄存器，再写入寄存器
    118. static int bq24735_update_word(struct i2c_client *client, u8 reg, u16 mask, u16 value)
    119. {
    120. 	unsigned int tmp;
    121. 	int ret;
    122.  
    123. 	ret = bq24735_read_word(client, reg);
    124. 	if (ret < 0)
    125. 		return ret;
    126.  
    127. 	tmp = ret & ~mask;
    128. 	tmp |= value & mask;
    129.  
    130. 	return bq24735_write_word(client, reg, tmp);
    131. }
    132.  
    133. /*
    134. 配置充电器，往寄存器写入电流值，电压值，输入电流值，而这三个值是从设备树中读取出来的
    135. pdata->charge_current =  "ti,charge-current"
    136. pdata->charge_voltage =  "ti,charge-voltage"
    137. pdata->input_current  =  "ti,input-current"
    138. */
    139. static int bq24735_config_charger(struct bq24735 *charger)
    140. {
    141. 	struct bq24735_platform *pdata = charger->pdata;
    142. 	int ret;
    143. 	u16 value;
    144.  
    145. 	if (pdata->ext_control)
    146. 		return 0;
    147.  
    148. 	if (pdata->charge_current) {
    149. 		value = pdata->charge_current & BQ24735_CHARGE_CURRENT_MASK;
    150.  
    151. 		ret = bq24735_write_word(charger->client, BQ24735_CHARGE_CURRENT, value);//电流
    152. 		if (ret < 0) {
    153. 			dev_err(&charger->client->dev, "Failed to write charger current : %d\n", ret);
    154. 			return ret;
    155. 		}
    156. 	}
    157.  
    158. 	if (pdata->charge_voltage) {
    159. 		value = pdata->charge_voltage & BQ24735_CHARGE_VOLTAGE_MASK;
    160.  
    161. 		ret = bq24735_write_word(charger->client, BQ24735_CHARGE_VOLTAGE, value);//电压
    162. 		if (ret < 0) {
    163. 			dev_err(&charger->client->dev, "Failed to write charger voltage : %d\n", ret);
    164. 			return ret;
    165. 		}
    166. 	}
    167.  
    168. 	if (pdata->input_current) {
    169. 		value = pdata->input_current & BQ24735_INPUT_CURRENT_MASK;
    170.  
    171. 		ret = bq24735_write_word(charger->client, BQ24735_INPUT_CURRENT, value);//输入电流
    172. 		if (ret < 0) {
    173. 			dev_err(&charger->client->dev, "Failed to write input current : %d\n", ret);
    174. 			return ret;
    175. 		}
    176. 	}
    177.  
    178. 	return 0;
    179. }
    180.  
    181. //使能充电器：先初始化寄存器的值，然后再获取对充电器的控制，就是往BQ24735_CHG_OPT=0x12寄存器写入数据
    182. static inline int bq24735_enable_charging(struct bq24735 *charger)
    183. {
    184. 	int ret;
    185.  
    186. 	if (charger->pdata->ext_control)
    187. 		return 0;
    188.  
    189. 	ret = bq24735_config_charger(charger);
    190. 	if (ret)
    191. 		return ret;
    192.  
    193. 	return bq24735_update_word(charger->client, BQ24735_CHG_OPT, BQ24735_CHG_OPT_CHARGE_DISABLE, 0);
    194. }
    195.  
    196. //消能充电器：
    197. static inline int bq24735_disable_charging(struct bq24735 *charger)
    198. {
    199. 	if (charger->pdata->ext_control)
    200. 		return 0;
    201.  
    202. 	return bq24735_update_word(charger->client, BQ24735_CHG_OPT, BQ24735_CHG_OPT_CHARGE_DISABLE, 1);
    203. }
    204.  
    205. //判断充电器是否存在，查看pdf文件中的 0x12H 寄存器的值
    206. static bool bq24735_charger_is_present(struct bq24735 *charger)
    207. {
    208. 	if (charger->status_gpio) {
    209. 		return !gpiod_get_value_cansleep(charger->status_gpio);
    210. 	} else {
    211. 		int ac = 0;
    212.  
    213. 		ac = bq24735_read_word(charger->client, BQ24735_CHG_OPT);
    214. 		if (ac < 0) {
    215. 			dev_dbg(&charger->client->dev, "Failed to read charger options : %d\n", ac);
    216. 			return false;
    217. 		}
    218. 		return (ac & BQ24735_CHG_OPT_AC_PRESENT) ? true : false;//判断第四位是否为1
    219. 	}
    220.  
    221. 	return false;
    222. }
    223.  
    224. //判断充电器是否正在充电中。。。。
    225. //
    226. static int bq24735_charger_is_charging(struct bq24735 *charger)
    227. {
    228. 	int ret;
    229.  
    230. 	//设备不存在，则返回0
    231. 	if (!bq24735_charger_is_present(charger))
    232. 		return 0;
    233.  
    234. 	//读取寄存器的值
    235. 	ret  = bq24735_read_word(charger->client, BQ24735_CHG_OPT);
    236. 	if (ret < 0)
    237. 		return ret;
    238.  
    239. 	//返回寄存器的第0位的值
    240. 	return !(ret & BQ24735_CHG_OPT_CHARGE_DISABLE);
    241. }
    242.  
    243. //更新充电设备状态
    244. static void bq24735_update(struct bq24735 *charger)
    245. {
    246. 	mutex_lock(&charger->lock);
    247.  
    248. 	if (charger->charging && bq24735_charger_is_present(charger))
    249. 		bq24735_enable_charging(charger);
    250. 	else
    251. 		bq24735_disable_charging(charger);
    252.  
    253. 	mutex_unlock(&charger->lock);
    254.  
    255. 	power_supply_changed(charger->charger);
    256. }
    257.  
    258.  
    259. //中断处理回调函数
    260. static irqreturn_t bq24735_charger_isr(int irq, void *devid)
    261. {
    262. 	struct power_supply *psy = devid;
    263. 	struct bq24735 *charger = to_bq24735(psy);
    264.  
    265. 	bq24735_update(charger);
    266.  
    267. 	return IRQ_HANDLED;
    268. }
    269.  
    270. //设备主循环
    271. static void bq24735_poll(struct work_struct *work)
    272. {
    273. 	struct bq24735 *charger = container_of(work, struct bq24735, poll.work);
    274.  
    275. 	bq24735_update(charger);
    276.  
    277. 	schedule_delayed_work(&charger->poll, msecs_to_jiffies(charger->poll_interval));
    278. }
    279.  
    280. //获取充电设备的属性值
    281. static int bq24735_charger_get_property(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val)
    282. {
    283. 	struct bq24735 *charger = to_bq24735(psy);
    284.  
    285. 	switch (psp) {
    286. 	case POWER_SUPPLY_PROP_ONLINE://设备是否存在
    287. 		val->intval = bq24735_charger_is_present(charger) ? 1 : 0;
    288. 		break;
    289. 	case POWER_SUPPLY_PROP_STATUS://设备状态
    290. 		switch (bq24735_charger_is_charging(charger)) {
    291. 		case 1:
    292. 			val->intval = POWER_SUPPLY_STATUS_CHARGING;
    293. 			break;
    294. 		case 0:
    295. 			val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
    296. 			break;
    297. 		default:
    298. 			val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
    299. 			break;
    300. 		}
    301. 		break;
    302. 	default:
    303. 		return -EINVAL;
    304. 	}
    305.  
    306. 	return 0;
    307. }
    308.  
    309. //设置充电器属性：设置充电状态，取消充电状态
    310. static int bq24735_charger_set_property(struct power_supply *psy, enum power_supply_property psp, const union power_supply_propval *val)
    311. {
    312. 	struct bq24735 *charger = to_bq24735(psy);
    313. 	int ret;
    314.  
    315. 	switch (psp) {
    316. 	case POWER_SUPPLY_PROP_STATUS:
    317. 		switch (val->intval) {
    318. 		case POWER_SUPPLY_STATUS_CHARGING:
    319. 			mutex_lock(&charger->lock);
    320. 			charger->charging = true;
    321. 			ret = bq24735_enable_charging(charger);
    322. 			mutex_unlock(&charger->lock);
    323. 			if (ret)
    324. 				return ret;
    325. 			break;
    326. 		case POWER_SUPPLY_STATUS_DISCHARGING:
    327. 		case POWER_SUPPLY_STATUS_NOT_CHARGING:
    328. 			mutex_lock(&charger->lock);
    329. 			charger->charging = false;
    330. 			ret = bq24735_disable_charging(charger);
    331. 			mutex_unlock(&charger->lock);
    332. 			if (ret)
    333. 				return ret;
    334. 			break;
    335. 		default:
    336. 			return -EINVAL;
    337. 		}
    338. 		power_supply_changed(psy);
    339. 		break;
    340. 	default:
    341. 		return -EPERM;
    342. 	}
    343.  
    344. 	return 0;
    345. }
    346.  
    347. //解析设备树，读取设备树的属性值
    348. static struct bq24735_platform *bq24735_parse_dt_data(struct i2c_client *client)
    349. {
    350. 	struct bq24735_platform *pdata;
    351. 	struct device_node *np = client->dev.of_node;
    352. 	u32 val;
    353. 	int ret;
    354.  
    355. 	pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
    356. 	if (!pdata) {
    357. 		dev_err(&client->dev, "Memory alloc for bq24735 pdata failed\n");
    358. 		return NULL;
    359. 	}
    360.  
    361. 	ret = of_property_read_u32(np, "ti,charge-current", &val);
    362. 	if (!ret)
    363. 		pdata->charge_current = val;
    364.  
    365. 	ret = of_property_read_u32(np, "ti,charge-voltage", &val);
    366. 	if (!ret)
    367. 		pdata->charge_voltage = val;
    368.  
    369. 	ret = of_property_read_u32(np, "ti,input-current", &val);
    370. 	if (!ret)
    371. 		pdata->input_current = val;
    372.  
    373. 	pdata->ext_control = of_property_read_bool(np, "ti,external-control");
    374.  
    375. 	return pdata;
    376. }
    377.  
    378. //驱动匹配后被系统内核调用的初始化函数
    379. static int bq24735_charger_probe(struct i2c_client *client, const struct i2c_device_id *id)
    380. {
    381. 	int ret;
    382. 	struct bq24735 *charger;
    383. 	struct power_supply_desc *supply_desc;
    384. 	struct power_supply_config psy_cfg = {};
    385. 	char *name;
    386.  
    387. 	//分配自定义结构体的内存
    388. 	charger = devm_kzalloc(&client->dev, sizeof(*charger), GFP_KERNEL);
    389. 	if (!charger)
    390. 		return -ENOMEM;
    391.  
    392. 	//初始化锁
    393. 	mutex_init(&charger->lock);
    394. 	charger->charging = true;
    395. 	charger->pdata = client->dev.platform_data;
    396.  
    397. 	if (IS_ENABLED(CONFIG_OF) && !charger->pdata && client->dev.of_node)
    398. 		charger->pdata = bq24735_parse_dt_data(client);
    399.  
    400. 	if (!charger->pdata) {
    401. 		dev_err(&client->dev, "no platform data provided\n");
    402. 		return -EINVAL;
    403. 	}
    404.  
    405. 	name = (char *)charger->pdata->name;
    406. 	if (!name) {
    407. 		name = devm_kasprintf(&client->dev, GFP_KERNEL, "bq24735@%s", dev_name(&client->dev));
    408. 		if (!name) {
    409. 			dev_err(&client->dev, "Failed to alloc device name\n");
    410. 			return -ENOMEM;
    411. 		}
    412. 	}
    413.  
    414. 	charger->client = client;
    415.  
    416. 	supply_desc = &charger->charger_desc;
    417.  
    418. 	supply_desc->name = name;
    419. 	supply_desc->type = POWER_SUPPLY_TYPE_MAINS;
    420. 	supply_desc->properties = bq24735_charger_properties;
    421. 	supply_desc->num_properties = ARRAY_SIZE(bq24735_charger_properties);
    422. 	supply_desc->get_property = bq24735_charger_get_property;
    423. 	supply_desc->set_property = bq24735_charger_set_property;
    424. 	supply_desc->property_is_writeable = bq24735_charger_property_is_writeable;
    425.  
    426. 	psy_cfg.supplied_to = charger->pdata->supplied_to;
    427. 	psy_cfg.num_supplicants = charger->pdata->num_supplicants;
    428. 	psy_cfg.of_node = client->dev.of_node;
    429. 	psy_cfg.drv_data = charger;
    430.  
    431. 	//注册结构体的数据指针到系统内核中
    432. 	i2c_set_clientdata(client, charger);
    433.  
    434. 	//获取GPIO的状态
    435. 	charger->status_gpio = devm_gpiod_get_optional(&client->dev, "ti,ac-detect", GPIOD_IN);
    436. 	if (IS_ERR(charger->status_gpio)) {
    437. 		ret = PTR_ERR(charger->status_gpio);
    438. 		dev_err(&client->dev, "Getting gpio failed: %d\n", ret);
    439. 		return ret;
    440. 	}
    441.  
    442. 	//充电器是否存在
    443. 	if (bq24735_charger_is_present(charger)) {
    444. 		//读取寄存器 0xfe 的值
    445. 		ret = bq24735_read_word(client, BQ24735_MANUFACTURER_ID);
    446. 		if (ret < 0) {
    447. 			dev_err(&client->dev, "Failed to read manufacturer id : %d\n", ret);
    448. 			return ret;
    449. 		} else if (ret != 0x0040) {
    450. 			dev_err(&client->dev, "manufacturer id mismatch. 0x0040 != 0x%04x\n", ret);
    451. 			return -ENODEV;
    452. 		}
    453.  
    454. 		//读取寄存器 0xff 的值
    455. 		ret = bq24735_read_word(client, BQ24735_DEVICE_ID);
    456. 		if (ret < 0) {
    457. 			dev_err(&client->dev, "Failed to read device id : %d\n", ret);
    458. 			return ret;
    459. 		} else if (ret != 0x000B) {
    460. 			dev_err(&client->dev, "device id mismatch. 0x000b != 0x%04x\n", ret);
    461. 			return -ENODEV;
    462. 		}
    463.  
    464. 		//使能充电器
    465. 		ret = bq24735_enable_charging(charger);
    466. 		if (ret < 0) {
    467. 			dev_err(&client->dev, "Failed to enable charging\n");
    468. 			return ret;
    469. 		}
    470. 	}
    471.  
    472. 	//注册驱动为一个power_supply设备
    473. 	charger->charger = devm_power_supply_register(&client->dev, supply_desc, &psy_cfg);
    474. 	if (IS_ERR(charger->charger)) {
    475. 		ret = PTR_ERR(charger->charger);
    476. 		dev_err(&client->dev, "Failed to register power supply: %d\n", ret);
    477. 		return ret;
    478. 	}
    479.  
    480. 	//支持中断
    481. 	//内核提供 request_threaded_irq 和 devm_request_threaded_irq 为中断分配内核线程
    482. 	//若flags中设置IRQF_ONESHOT标志，内核会自动在中断上下文中屏蔽该中断号
    483. 	//bq24735_charger_isr 为中断处理函数
    484. 	if (client->irq) {
    485. 		ret = devm_request_threaded_irq(&client->dev, client->irq, NULL, bq24735_charger_isr, 
    486. 				IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, supply_desc->name, charger->charger);
    487. 		if (ret) {
    488. 			dev_err(&client->dev, "Unable to register IRQ %d err %d\n", client->irq, ret);
    489. 			return ret;
    490. 		}
    491. 	} else {
    492. 		//不支持中断，通过定时轮询来进入主循环
    493. 		ret = device_property_read_u32(&client->dev, "poll-interval", &charger->poll_interval);
    494. 		if (ret)
    495. 			return 0;
    496. 		if (!charger->poll_interval)
    497. 			return 0;
    498.  
    499. 		INIT_DELAYED_WORK(&charger->poll, bq24735_poll);
    500. 		schedule_delayed_work(&charger->poll, msecs_to_jiffies(charger->poll_interval));
    501. 	}
    502.  
    503. 	return 0;
    504. }
    505.  
    506. //设备移除时被内核调用的函数
    507. static int bq24735_charger_remove(struct i2c_client *client)
    508. {
    509. 	struct bq24735 *charger = i2c_get_clientdata(client);
    510.  
    511. 	if (charger->poll_interval)
    512. 		cancel_delayed_work_sync(&charger->poll);//取消定时器
    513.  
    514. 	return 0;
    515. }
    516.  
    517. static const struct i2c_device_id bq24735_charger_id[] = {
    518. 	{ "bq24735-charger", 0 },
    519. 	{}
    520. };
    521. MODULE_DEVICE_TABLE(i2c, bq24735_charger_id);
    522.  
    523. static const struct of_device_id bq24735_match_ids[] = {
    524. 	{ .compatible = "ti,bq24735", },
    525. 	{ /* end */ }
    526. };
    527. MODULE_DEVICE_TABLE(of, bq24735_match_ids);
    528.  
    529. static struct i2c_driver bq24735_charger_driver = {
    530. 	.driver = {
    531. 		.name = "bq24735-charger",
    532. 		.of_match_table = bq24735_match_ids,
    533. 	},
    534. 	.probe = bq24735_charger_probe,
    535. 	.remove = bq24735_charger_remove,
    536. 	.id_table = bq24735_charger_id,
    537. };
    538.  
    539. //用一个函数完成了好几个函数做的事情
    540. module_i2c_driver(bq24735_charger_driver);
    541.  
    542. MODULE_DESCRIPTION("bq24735 battery charging driver");
    543. MODULE_AUTHOR("Darbha Sriharsha ");
    544. MODULE_LICENSE("GPL v2");

    #define module_i2c_driver(__i2c_driver)         module_driver(__i2c_driver, i2c_add_driver, i2c_del_driver)

    1. #define module_i2c_driver(__i2c_driver)         module_driver(__i2c_driver, i2c_add_driver, i2c_del_driver)
    2.  
    3.  
    4.  #define module_driver(__driver, __register, __unregister, ...) \
    5.  static int __init __driver##_init(void) \
    6.  { \
    7.          return __register(&(__driver) , ##__VA_ARGS__); \
    8.  } \
    9.  module_init(__driver##_init); \
    10.  static void __exit __driver##_exit(void) \
    11.  { \
    12.          __unregister(&(__driver) , ##__VA_ARGS__); \
    13.  } \
    14.  module_exit(__driver##_exit);

  • 相关阅读:
    Vue + Nodejs + socket.io 实现聊天
    Unity开发者——编辑器技巧
    使用Python实现强化学习算法
    实验1 熟悉R语言环境
    详解SpringBoot的常用注解
    联想y7000 y7000p 2018/2019 不插电源 不插充电器， 直接关机 ，电量一直89%/87%/86%，V0005如何解决？
    从Opencv之图像直方图源码，探讨高性能计算设计思想
    CockroachDB-哈希分片索引
    Pycharm远程debug代码，一直进入remote_sources
    Laya---淘宝小程序
  • 原文地址：https://blog.csdn.net/langeldep/article/details/127506764