1
2
3
4
5
6
7
8
9
10
11#include <linux/device.h>
12#include <linux/kernel.h>
13#include <linux/platform_data/wilco-ec.h>
14#include <linux/string.h>
15#include <linux/sysfs.h>
16#include <linux/types.h>
17
18#define CMD_KB_CMOS 0x7C
19#define SUB_CMD_KB_CMOS_AUTO_ON 0x03
20
21struct boot_on_ac_request {
22 u8 cmd;
23 u8 reserved1;
24 u8 sub_cmd;
25 u8 reserved3to5[3];
26 u8 val;
27 u8 reserved7;
28} __packed;
29
30#define CMD_USB_CHARGE 0x39
31
32enum usb_charge_op {
33 USB_CHARGE_GET = 0,
34 USB_CHARGE_SET = 1,
35};
36
37struct usb_charge_request {
38 u8 cmd;
39 u8 reserved;
40 u8 op;
41 u8 val;
42} __packed;
43
44struct usb_charge_response {
45 u8 reserved;
46 u8 status;
47 u8 val;
48} __packed;
49
50#define CMD_EC_INFO 0x38
51enum get_ec_info_op {
52 CMD_GET_EC_LABEL = 0,
53 CMD_GET_EC_REV = 1,
54 CMD_GET_EC_MODEL = 2,
55 CMD_GET_EC_BUILD_DATE = 3,
56};
57
58struct get_ec_info_req {
59 u8 cmd;
60 u8 reserved;
61 u8 op;
62} __packed;
63
64struct get_ec_info_resp {
65 u8 reserved[2];
66 char value[9];
67} __packed;
68
69static ssize_t boot_on_ac_store(struct device *dev,
70 struct device_attribute *attr,
71 const char *buf, size_t count)
72{
73 struct wilco_ec_device *ec = dev_get_drvdata(dev);
74 struct boot_on_ac_request rq;
75 struct wilco_ec_message msg;
76 int ret;
77 u8 val;
78
79 ret = kstrtou8(buf, 10, &val);
80 if (ret < 0)
81 return ret;
82 if (val > 1)
83 return -EINVAL;
84
85 memset(&rq, 0, sizeof(rq));
86 rq.cmd = CMD_KB_CMOS;
87 rq.sub_cmd = SUB_CMD_KB_CMOS_AUTO_ON;
88 rq.val = val;
89
90 memset(&msg, 0, sizeof(msg));
91 msg.type = WILCO_EC_MSG_LEGACY;
92 msg.request_data = &rq;
93 msg.request_size = sizeof(rq);
94 ret = wilco_ec_mailbox(ec, &msg);
95 if (ret < 0)
96 return ret;
97
98 return count;
99}
100
101static DEVICE_ATTR_WO(boot_on_ac);
102
103static ssize_t get_info(struct device *dev, char *buf, enum get_ec_info_op op)
104{
105 struct wilco_ec_device *ec = dev_get_drvdata(dev);
106 struct get_ec_info_req req = { .cmd = CMD_EC_INFO, .op = op };
107 struct get_ec_info_resp resp;
108 int ret;
109
110 struct wilco_ec_message msg = {
111 .type = WILCO_EC_MSG_LEGACY,
112 .request_data = &req,
113 .request_size = sizeof(req),
114 .response_data = &resp,
115 .response_size = sizeof(resp),
116 };
117
118 ret = wilco_ec_mailbox(ec, &msg);
119 if (ret < 0)
120 return ret;
121
122 return scnprintf(buf, PAGE_SIZE, "%.*s\n", (int)sizeof(resp.value),
123 (char *)&resp.value);
124}
125
126static ssize_t version_show(struct device *dev, struct device_attribute *attr,
127 char *buf)
128{
129 return get_info(dev, buf, CMD_GET_EC_LABEL);
130}
131
132static DEVICE_ATTR_RO(version);
133
134static ssize_t build_revision_show(struct device *dev,
135 struct device_attribute *attr, char *buf)
136{
137 return get_info(dev, buf, CMD_GET_EC_REV);
138}
139
140static DEVICE_ATTR_RO(build_revision);
141
142static ssize_t build_date_show(struct device *dev,
143 struct device_attribute *attr, char *buf)
144{
145 return get_info(dev, buf, CMD_GET_EC_BUILD_DATE);
146}
147
148static DEVICE_ATTR_RO(build_date);
149
150static ssize_t model_number_show(struct device *dev,
151 struct device_attribute *attr, char *buf)
152{
153 return get_info(dev, buf, CMD_GET_EC_MODEL);
154}
155
156static DEVICE_ATTR_RO(model_number);
157
158static int send_usb_charge(struct wilco_ec_device *ec,
159 struct usb_charge_request *rq,
160 struct usb_charge_response *rs)
161{
162 struct wilco_ec_message msg;
163 int ret;
164
165 memset(&msg, 0, sizeof(msg));
166 msg.type = WILCO_EC_MSG_LEGACY;
167 msg.request_data = rq;
168 msg.request_size = sizeof(*rq);
169 msg.response_data = rs;
170 msg.response_size = sizeof(*rs);
171 ret = wilco_ec_mailbox(ec, &msg);
172 if (ret < 0)
173 return ret;
174 if (rs->status)
175 return -EIO;
176
177 return 0;
178}
179
180static ssize_t usb_charge_show(struct device *dev,
181 struct device_attribute *attr, char *buf)
182{
183 struct wilco_ec_device *ec = dev_get_drvdata(dev);
184 struct usb_charge_request rq;
185 struct usb_charge_response rs;
186 int ret;
187
188 memset(&rq, 0, sizeof(rq));
189 rq.cmd = CMD_USB_CHARGE;
190 rq.op = USB_CHARGE_GET;
191
192 ret = send_usb_charge(ec, &rq, &rs);
193 if (ret < 0)
194 return ret;
195
196 return sprintf(buf, "%d\n", rs.val);
197}
198
199static ssize_t usb_charge_store(struct device *dev,
200 struct device_attribute *attr,
201 const char *buf, size_t count)
202{
203 struct wilco_ec_device *ec = dev_get_drvdata(dev);
204 struct usb_charge_request rq;
205 struct usb_charge_response rs;
206 int ret;
207 u8 val;
208
209 ret = kstrtou8(buf, 10, &val);
210 if (ret < 0)
211 return ret;
212 if (val > 1)
213 return -EINVAL;
214
215 memset(&rq, 0, sizeof(rq));
216 rq.cmd = CMD_USB_CHARGE;
217 rq.op = USB_CHARGE_SET;
218 rq.val = val;
219
220 ret = send_usb_charge(ec, &rq, &rs);
221 if (ret < 0)
222 return ret;
223
224 return count;
225}
226
227static DEVICE_ATTR_RW(usb_charge);
228
229static struct attribute *wilco_dev_attrs[] = {
230 &dev_attr_boot_on_ac.attr,
231 &dev_attr_build_date.attr,
232 &dev_attr_build_revision.attr,
233 &dev_attr_model_number.attr,
234 &dev_attr_usb_charge.attr,
235 &dev_attr_version.attr,
236 NULL,
237};
238
239static const struct attribute_group wilco_dev_attr_group = {
240 .attrs = wilco_dev_attrs,
241};
242
243int wilco_ec_add_sysfs(struct wilco_ec_device *ec)
244{
245 return sysfs_create_group(&ec->dev->kobj, &wilco_dev_attr_group);
246}
247
248void wilco_ec_remove_sysfs(struct wilco_ec_device *ec)
249{
250 sysfs_remove_group(&ec->dev->kobj, &wilco_dev_attr_group);
251}
252
