1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright 2019 Google LLC
4 *
5 * Sysfs properties to view and modify EC-controlled features on Wilco devices.
6 * The entries will appear under /sys/bus/platform/devices/GOOG000C:00/
7 *
8 * See Documentation/ABI/testing/sysfs-platform-wilco-ec for more information.
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
21 struct boot_on_ac_request {
22 u8 cmd; /* Always CMD_KB_CMOS */
23 u8 reserved1;
24 u8 sub_cmd; /* Always SUB_CMD_KB_CMOS_AUTO_ON */
25 u8 reserved3to5[3];
26 u8 val; /* Either 0 or 1 */
27 u8 reserved7;
28 } __packed;
29
30 #define CMD_USB_CHARGE 0x39
31
32 enum usb_charge_op {
33 USB_CHARGE_GET = 0,
34 USB_CHARGE_SET = 1,
35 };
36
37 struct usb_charge_request {
38 u8 cmd; /* Always CMD_USB_CHARGE */
39 u8 reserved;
40 u8 op; /* One of enum usb_charge_op */
41 u8 val; /* When setting, either 0 or 1 */
42 } __packed;
43
44 struct usb_charge_response {
45 u8 reserved;
46 u8 status; /* Set by EC to 0 on success, other value on failure */
47 u8 val; /* When getting, set by EC to either 0 or 1 */
48 } __packed;
49
50 #define CMD_EC_INFO 0x38
51 enum 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
58 struct get_ec_info_req {
59 u8 cmd; /* Always CMD_EC_INFO */
60 u8 reserved;
61 u8 op; /* One of enum get_ec_info_op */
62 } __packed;
63
64 struct get_ec_info_resp {
65 u8 reserved[2];
66 char value[9]; /* __nonstring: might not be null terminated */
67 } __packed;
68
boot_on_ac_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)69 static 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
101 static DEVICE_ATTR_WO(boot_on_ac);
102
get_info(struct device * dev,char * buf,enum get_ec_info_op op)103 static 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 sysfs_emit(buf, "%.*s\n", (int)sizeof(resp.value), (char *)&resp.value);
123 }
124
version_show(struct device * dev,struct device_attribute * attr,char * buf)125 static ssize_t version_show(struct device *dev, struct device_attribute *attr,
126 char *buf)
127 {
128 return get_info(dev, buf, CMD_GET_EC_LABEL);
129 }
130
131 static DEVICE_ATTR_RO(version);
132
build_revision_show(struct device * dev,struct device_attribute * attr,char * buf)133 static ssize_t build_revision_show(struct device *dev,
134 struct device_attribute *attr, char *buf)
135 {
136 return get_info(dev, buf, CMD_GET_EC_REV);
137 }
138
139 static DEVICE_ATTR_RO(build_revision);
140
build_date_show(struct device * dev,struct device_attribute * attr,char * buf)141 static ssize_t build_date_show(struct device *dev,
142 struct device_attribute *attr, char *buf)
143 {
144 return get_info(dev, buf, CMD_GET_EC_BUILD_DATE);
145 }
146
147 static DEVICE_ATTR_RO(build_date);
148
model_number_show(struct device * dev,struct device_attribute * attr,char * buf)149 static ssize_t model_number_show(struct device *dev,
150 struct device_attribute *attr, char *buf)
151 {
152 return get_info(dev, buf, CMD_GET_EC_MODEL);
153 }
154
155 static DEVICE_ATTR_RO(model_number);
156
send_usb_charge(struct wilco_ec_device * ec,struct usb_charge_request * rq,struct usb_charge_response * rs)157 static int send_usb_charge(struct wilco_ec_device *ec,
158 struct usb_charge_request *rq,
159 struct usb_charge_response *rs)
160 {
161 struct wilco_ec_message msg;
162 int ret;
163
164 memset(&msg, 0, sizeof(msg));
165 msg.type = WILCO_EC_MSG_LEGACY;
166 msg.request_data = rq;
167 msg.request_size = sizeof(*rq);
168 msg.response_data = rs;
169 msg.response_size = sizeof(*rs);
170 ret = wilco_ec_mailbox(ec, &msg);
171 if (ret < 0)
172 return ret;
173 if (rs->status)
174 return -EIO;
175
176 return 0;
177 }
178
usb_charge_show(struct device * dev,struct device_attribute * attr,char * buf)179 static ssize_t usb_charge_show(struct device *dev,
180 struct device_attribute *attr, char *buf)
181 {
182 struct wilco_ec_device *ec = dev_get_drvdata(dev);
183 struct usb_charge_request rq;
184 struct usb_charge_response rs;
185 int ret;
186
187 memset(&rq, 0, sizeof(rq));
188 rq.cmd = CMD_USB_CHARGE;
189 rq.op = USB_CHARGE_GET;
190
191 ret = send_usb_charge(ec, &rq, &rs);
192 if (ret < 0)
193 return ret;
194
195 return sysfs_emit(buf, "%d\n", rs.val);
196 }
197
usb_charge_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)198 static ssize_t usb_charge_store(struct device *dev,
199 struct device_attribute *attr,
200 const char *buf, size_t count)
201 {
202 struct wilco_ec_device *ec = dev_get_drvdata(dev);
203 struct usb_charge_request rq;
204 struct usb_charge_response rs;
205 int ret;
206 u8 val;
207
208 ret = kstrtou8(buf, 10, &val);
209 if (ret < 0)
210 return ret;
211 if (val > 1)
212 return -EINVAL;
213
214 memset(&rq, 0, sizeof(rq));
215 rq.cmd = CMD_USB_CHARGE;
216 rq.op = USB_CHARGE_SET;
217 rq.val = val;
218
219 ret = send_usb_charge(ec, &rq, &rs);
220 if (ret < 0)
221 return ret;
222
223 return count;
224 }
225
226 static DEVICE_ATTR_RW(usb_charge);
227
228 static struct attribute *wilco_dev_attrs[] = {
229 &dev_attr_boot_on_ac.attr,
230 &dev_attr_build_date.attr,
231 &dev_attr_build_revision.attr,
232 &dev_attr_model_number.attr,
233 &dev_attr_usb_charge.attr,
234 &dev_attr_version.attr,
235 NULL,
236 };
237
238 static const struct attribute_group wilco_dev_attr_group = {
239 .attrs = wilco_dev_attrs,
240 };
241
wilco_ec_add_sysfs(struct wilco_ec_device * ec)242 int wilco_ec_add_sysfs(struct wilco_ec_device *ec)
243 {
244 return sysfs_create_group(&ec->dev->kobj, &wilco_dev_attr_group);
245 }
246
wilco_ec_remove_sysfs(struct wilco_ec_device * ec)247 void wilco_ec_remove_sysfs(struct wilco_ec_device *ec)
248 {
249 sysfs_remove_group(&ec->dev->kobj, &wilco_dev_attr_group);
250 }
251