2 * Generic driver for the OLPC Embedded Controller.
4 * Copyright (C) 2011-2012 One Laptop per Child Foundation.
6 * Licensed under the GPL v2 or later.
8 #include <linux/completion.h>
9 #include <linux/debugfs.h>
10 #include <linux/spinlock.h>
11 #include <linux/mutex.h>
12 #include <linux/platform_device.h>
13 #include <linux/slab.h>
14 #include <linux/workqueue.h>
15 #include <linux/module.h>
16 #include <linux/list.h>
17 #include <linux/olpc-ec.h>
26 struct completion finished
;
27 struct list_head node
;
33 struct olpc_ec_driver
*drv
;
34 struct work_struct worker
;
35 struct mutex cmd_lock
;
37 /* Pending EC commands */
38 struct list_head cmd_q
;
39 spinlock_t cmd_q_lock
;
41 struct dentry
*dbgfs_dir
;
44 * Running an EC command while suspending means we don't always finish
45 * the command before the machine suspends. This means that the EC
46 * is expecting the command protocol to finish, but we after a period
47 * of time (while the OS is asleep) the EC times out and restarts its
48 * idle loop. Meanwhile, the OS wakes up, thinks it's still in the
49 * middle of the command protocol, starts throwing random things at
50 * the EC... and everyone's uphappy.
55 static struct olpc_ec_driver
*ec_driver
;
56 static struct olpc_ec_priv
*ec_priv
;
57 static void *ec_cb_arg
;
59 void olpc_ec_driver_register(struct olpc_ec_driver
*drv
, void *arg
)
64 EXPORT_SYMBOL_GPL(olpc_ec_driver_register
);
66 static void olpc_ec_worker(struct work_struct
*w
)
68 struct olpc_ec_priv
*ec
= container_of(w
, struct olpc_ec_priv
, worker
);
69 struct ec_cmd_desc
*desc
= NULL
;
72 /* Grab the first pending command from the queue */
73 spin_lock_irqsave(&ec
->cmd_q_lock
, flags
);
74 if (!list_empty(&ec
->cmd_q
)) {
75 desc
= list_first_entry(&ec
->cmd_q
, struct ec_cmd_desc
, node
);
76 list_del(&desc
->node
);
78 spin_unlock_irqrestore(&ec
->cmd_q_lock
, flags
);
80 /* Do we actually have anything to do? */
84 /* Protect the EC hw with a mutex; only run one cmd at a time */
85 mutex_lock(&ec
->cmd_lock
);
86 desc
->err
= ec_driver
->ec_cmd(desc
->cmd
, desc
->inbuf
, desc
->inlen
,
87 desc
->outbuf
, desc
->outlen
, ec_cb_arg
);
88 mutex_unlock(&ec
->cmd_lock
);
90 /* Finished, wake up olpc_ec_cmd() */
91 complete(&desc
->finished
);
93 /* Run the worker thread again in case there are more cmds pending */
94 schedule_work(&ec
->worker
);
98 * Throw a cmd descripter onto the list. We now have SMP OLPC machines, so
99 * locking is pretty critical.
101 static void queue_ec_descriptor(struct ec_cmd_desc
*desc
,
102 struct olpc_ec_priv
*ec
)
106 INIT_LIST_HEAD(&desc
->node
);
108 spin_lock_irqsave(&ec
->cmd_q_lock
, flags
);
109 list_add_tail(&desc
->node
, &ec
->cmd_q
);
110 spin_unlock_irqrestore(&ec
->cmd_q_lock
, flags
);
112 schedule_work(&ec
->worker
);
115 int olpc_ec_cmd(u8 cmd
, u8
*inbuf
, size_t inlen
, u8
*outbuf
, size_t outlen
)
117 struct olpc_ec_priv
*ec
= ec_priv
;
118 struct ec_cmd_desc desc
;
120 /* Ensure a driver and ec hook have been registered */
121 if (WARN_ON(!ec_driver
|| !ec_driver
->ec_cmd
))
127 /* Suspending in the middle of a command hoses things really badly */
128 if (WARN_ON(ec
->suspended
))
135 desc
.outbuf
= outbuf
;
137 desc
.outlen
= outlen
;
139 init_completion(&desc
.finished
);
141 queue_ec_descriptor(&desc
, ec
);
143 /* Timeouts must be handled in the platform-specific EC hook */
144 wait_for_completion(&desc
.finished
);
146 /* The worker thread dequeues the cmd; no need to do anything here */
149 EXPORT_SYMBOL_GPL(olpc_ec_cmd
);
151 #ifdef CONFIG_DEBUG_FS
154 * debugfs support for "generic commands", to allow sending
155 * arbitrary EC commands from userspace.
158 #define EC_MAX_CMD_ARGS (5 + 1) /* cmd byte + 5 args */
159 #define EC_MAX_CMD_REPLY (8)
161 static DEFINE_MUTEX(ec_dbgfs_lock
);
162 static unsigned char ec_dbgfs_resp
[EC_MAX_CMD_REPLY
];
163 static unsigned int ec_dbgfs_resp_bytes
;
165 static ssize_t
ec_dbgfs_cmd_write(struct file
*file
, const char __user
*buf
,
166 size_t size
, loff_t
*ppos
)
169 unsigned char ec_cmd
[EC_MAX_CMD_ARGS
];
170 unsigned int ec_cmd_int
[EC_MAX_CMD_ARGS
];
174 mutex_lock(&ec_dbgfs_lock
);
176 size
= simple_write_to_buffer(cmdbuf
, sizeof(cmdbuf
), ppos
, buf
, size
);
178 m
= sscanf(cmdbuf
, "%x:%u %x %x %x %x %x", &ec_cmd_int
[0],
179 &ec_dbgfs_resp_bytes
, &ec_cmd_int
[1], &ec_cmd_int
[2],
180 &ec_cmd_int
[3], &ec_cmd_int
[4], &ec_cmd_int
[5]);
181 if (m
< 2 || ec_dbgfs_resp_bytes
> EC_MAX_CMD_REPLY
) {
182 /* reset to prevent overflow on read */
183 ec_dbgfs_resp_bytes
= 0;
185 pr_debug("olpc-ec: bad ec cmd: cmd:response-count [arg1 [arg2 ...]]\n");
190 /* convert scanf'd ints to char */
191 ec_cmd_bytes
= m
- 2;
192 for (i
= 0; i
<= ec_cmd_bytes
; i
++)
193 ec_cmd
[i
] = ec_cmd_int
[i
];
195 pr_debug("olpc-ec: debugfs cmd 0x%02x with %d args %02x %02x %02x %02x %02x, want %d returns\n",
196 ec_cmd
[0], ec_cmd_bytes
, ec_cmd
[1], ec_cmd
[2],
197 ec_cmd
[3], ec_cmd
[4], ec_cmd
[5], ec_dbgfs_resp_bytes
);
199 olpc_ec_cmd(ec_cmd
[0], (ec_cmd_bytes
== 0) ? NULL
: &ec_cmd
[1],
200 ec_cmd_bytes
, ec_dbgfs_resp
, ec_dbgfs_resp_bytes
);
202 pr_debug("olpc-ec: response %02x %02x %02x %02x %02x %02x %02x %02x (%d bytes expected)\n",
203 ec_dbgfs_resp
[0], ec_dbgfs_resp
[1], ec_dbgfs_resp
[2],
204 ec_dbgfs_resp
[3], ec_dbgfs_resp
[4], ec_dbgfs_resp
[5],
205 ec_dbgfs_resp
[6], ec_dbgfs_resp
[7],
206 ec_dbgfs_resp_bytes
);
209 mutex_unlock(&ec_dbgfs_lock
);
213 static ssize_t
ec_dbgfs_cmd_read(struct file
*file
, char __user
*buf
,
214 size_t size
, loff_t
*ppos
)
220 mutex_lock(&ec_dbgfs_lock
);
222 rp
+= sprintf(rp
, "%02x", ec_dbgfs_resp
[0]);
223 for (i
= 1; i
< ec_dbgfs_resp_bytes
; i
++)
224 rp
+= sprintf(rp
, ", %02x", ec_dbgfs_resp
[i
]);
225 mutex_unlock(&ec_dbgfs_lock
);
226 rp
+= sprintf(rp
, "\n");
229 return simple_read_from_buffer(buf
, size
, ppos
, respbuf
, r
);
232 static const struct file_operations ec_dbgfs_ops
= {
233 .write
= ec_dbgfs_cmd_write
,
234 .read
= ec_dbgfs_cmd_read
,
237 static struct dentry
*olpc_ec_setup_debugfs(void)
239 struct dentry
*dbgfs_dir
;
241 dbgfs_dir
= debugfs_create_dir("olpc-ec", NULL
);
242 if (IS_ERR_OR_NULL(dbgfs_dir
))
245 debugfs_create_file("cmd", 0600, dbgfs_dir
, NULL
, &ec_dbgfs_ops
);
252 static struct dentry
*olpc_ec_setup_debugfs(void)
257 #endif /* CONFIG_DEBUG_FS */
259 static int olpc_ec_probe(struct platform_device
*pdev
)
261 struct olpc_ec_priv
*ec
;
267 ec
= kzalloc(sizeof(*ec
), GFP_KERNEL
);
272 INIT_WORK(&ec
->worker
, olpc_ec_worker
);
273 mutex_init(&ec
->cmd_lock
);
275 INIT_LIST_HEAD(&ec
->cmd_q
);
276 spin_lock_init(&ec
->cmd_q_lock
);
279 platform_set_drvdata(pdev
, ec
);
281 err
= ec_driver
->probe
? ec_driver
->probe(pdev
) : 0;
286 ec
->dbgfs_dir
= olpc_ec_setup_debugfs();
292 static int olpc_ec_suspend(struct device
*dev
)
294 struct platform_device
*pdev
= to_platform_device(dev
);
295 struct olpc_ec_priv
*ec
= platform_get_drvdata(pdev
);
298 if (ec_driver
->suspend
)
299 err
= ec_driver
->suspend(pdev
);
301 ec
->suspended
= true;
306 static int olpc_ec_resume(struct device
*dev
)
308 struct platform_device
*pdev
= to_platform_device(dev
);
309 struct olpc_ec_priv
*ec
= platform_get_drvdata(pdev
);
311 ec
->suspended
= false;
312 return ec_driver
->resume
? ec_driver
->resume(pdev
) : 0;
315 static const struct dev_pm_ops olpc_ec_pm_ops
= {
316 .suspend_late
= olpc_ec_suspend
,
317 .resume_early
= olpc_ec_resume
,
320 static struct platform_driver olpc_ec_plat_driver
= {
321 .probe
= olpc_ec_probe
,
324 .pm
= &olpc_ec_pm_ops
,
328 static int __init
olpc_ec_init_module(void)
330 return platform_driver_register(&olpc_ec_plat_driver
);
333 arch_initcall(olpc_ec_init_module
);
335 MODULE_AUTHOR("Andres Salomon <dilinger@queued.net>");
336 MODULE_LICENSE("GPL");