1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
// SPDX-License-Identifier: GPL-2.0-only
/*
* Toradex Embedded Controller driver
*
* Copyright (C) 2025 Toradex
*
* Author: Emanuele Ghidoli <emanuele.ghidoli@toradex.com>
*/
#include <linux/array_size.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/mod_devicetable.h>
#include <linux/module.h>
#include <linux/reboot.h>
#include <linux/regmap.h>
#include <linux/types.h>
#define EC_CHIP_ID_REG 0x00
#define EC_CHIP_ID_SMARC_IMX95 0x11
#define EC_CHIP_ID_SMARC_IMX8MP 0x12
#define EC_VERSION_REG_MAJOR 0x01
#define EC_VERSION_REG_MINOR 0x02
#define EC_ID_VERSION_LEN 3
#define EC_CMD_REG 0xD0
#define EC_CMD_POWEROFF 0x01
#define EC_CMD_RESET 0x02
#define EC_REG_MAX 0xD0
static const struct regmap_range volatile_ranges[] = {
regmap_reg_range(EC_CMD_REG, EC_CMD_REG),
};
static const struct regmap_access_table volatile_table = {
.yes_ranges = volatile_ranges,
.n_yes_ranges = ARRAY_SIZE(volatile_ranges),
};
static const struct regmap_range read_ranges[] = {
regmap_reg_range(EC_CHIP_ID_REG, EC_VERSION_REG_MINOR),
};
static const struct regmap_access_table read_table = {
.yes_ranges = read_ranges,
.n_yes_ranges = ARRAY_SIZE(read_ranges),
};
static const struct regmap_config regmap_config = {
.reg_bits = 8,
.val_bits = 8,
.max_register = EC_REG_MAX,
.cache_type = REGCACHE_RBTREE,
.rd_table = &read_table,
.volatile_table = &volatile_table,
};
static int tdx_ec_cmd(struct regmap *regmap, u8 cmd)
{
int err = regmap_write(regmap, EC_CMD_REG, cmd);
if (err)
dev_err(regmap_get_device(regmap), "Failed to send command 0x%02X: %d\n", cmd, err);
return err;
}
static int tdx_ec_power_off(struct sys_off_data *data)
{
struct regmap *regmap = data->cb_data;
int err;
err = tdx_ec_cmd(regmap, EC_CMD_POWEROFF);
return err ? NOTIFY_BAD : NOTIFY_DONE;
}
static int tdx_ec_restart(struct sys_off_data *data)
{
struct regmap *regmap = data->cb_data;
int err;
err = tdx_ec_cmd(regmap, EC_CMD_RESET);
return err ? NOTIFY_BAD : NOTIFY_DONE;
}
static int tdx_ec_register_power_off_restart(struct device *dev, struct regmap *regmap)
{
int err;
err = devm_register_sys_off_handler(dev, SYS_OFF_MODE_RESTART,
SYS_OFF_PRIO_FIRMWARE,
tdx_ec_restart, regmap);
if (err)
return err;
return devm_register_sys_off_handler(dev, SYS_OFF_MODE_POWER_OFF,
SYS_OFF_PRIO_FIRMWARE,
tdx_ec_power_off, regmap);
}
static int tdx_ec_probe(struct i2c_client *client)
{
struct device *dev = &client->dev;
u8 reg_val[EC_ID_VERSION_LEN];
struct regmap *regmap;
int err;
regmap = devm_regmap_init_i2c(client, ®map_config);
if (IS_ERR(regmap))
return PTR_ERR(regmap);
err = regmap_bulk_read(regmap, EC_CHIP_ID_REG, ®_val, EC_ID_VERSION_LEN);
if (err)
return dev_err_probe(dev, err,
"Cannot read id and version registers\n");
dev_info(dev, "Toradex Embedded Controller id %x - Firmware %u.%u\n",
reg_val[0], reg_val[1], reg_val[2]);
err = tdx_ec_register_power_off_restart(dev, regmap);
if (err)
return dev_err_probe(dev, err,
"Cannot register system restart handler\n");
return 0;
}
static const struct of_device_id __maybe_unused of_tdx_ec_match[] = {
{ .compatible = "toradex,smarc-ec" },
{}
};
MODULE_DEVICE_TABLE(of, of_tdx_ec_match);
static struct i2c_driver tdx_ec_driver = {
.probe = tdx_ec_probe,
.driver = {
.name = "toradex-smarc-ec",
.of_match_table = of_tdx_ec_match,
},
};
module_i2c_driver(tdx_ec_driver);
MODULE_AUTHOR("Emanuele Ghidoli <emanuele.ghidoli@toradex.com>");
MODULE_DESCRIPTION("Toradex SMARC Embedded Controller driver");
MODULE_LICENSE("GPL");
|
