xref: /linux/drivers/spmi/spmi.c (revision a1ff5a7d78a036d6c2178ee5acd6ba4946243800)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2012-2015, The Linux Foundation. All rights reserved.
4  */
5 #include <linux/kernel.h>
6 #include <linux/errno.h>
7 #include <linux/idr.h>
8 #include <linux/slab.h>
9 #include <linux/module.h>
10 #include <linux/of.h>
11 #include <linux/of_device.h>
12 #include <linux/platform_device.h>
13 #include <linux/spmi.h>
14 #include <linux/pm_runtime.h>
15 
16 #include <dt-bindings/spmi/spmi.h>
17 #define CREATE_TRACE_POINTS
18 #include <trace/events/spmi.h>
19 
20 static bool is_registered;
21 static DEFINE_IDA(ctrl_ida);
22 
spmi_dev_release(struct device * dev)23 static void spmi_dev_release(struct device *dev)
24 {
25 	struct spmi_device *sdev = to_spmi_device(dev);
26 
27 	kfree(sdev);
28 }
29 
30 static const struct device_type spmi_dev_type = {
31 	.release	= spmi_dev_release,
32 };
33 
spmi_ctrl_release(struct device * dev)34 static void spmi_ctrl_release(struct device *dev)
35 {
36 	struct spmi_controller *ctrl = to_spmi_controller(dev);
37 
38 	ida_free(&ctrl_ida, ctrl->nr);
39 	kfree(ctrl);
40 }
41 
42 static const struct device_type spmi_ctrl_type = {
43 	.release	= spmi_ctrl_release,
44 };
45 
spmi_device_match(struct device * dev,const struct device_driver * drv)46 static int spmi_device_match(struct device *dev, const struct device_driver *drv)
47 {
48 	if (of_driver_match_device(dev, drv))
49 		return 1;
50 
51 	if (drv->name)
52 		return strncmp(dev_name(dev), drv->name,
53 			       SPMI_NAME_SIZE) == 0;
54 
55 	return 0;
56 }
57 
58 /**
59  * spmi_device_add() - add a device previously constructed via spmi_device_alloc()
60  * @sdev:	spmi_device to be added
61  */
spmi_device_add(struct spmi_device * sdev)62 int spmi_device_add(struct spmi_device *sdev)
63 {
64 	struct spmi_controller *ctrl = sdev->ctrl;
65 	int err;
66 
67 	dev_set_name(&sdev->dev, "%d-%02x", ctrl->nr, sdev->usid);
68 
69 	err = device_add(&sdev->dev);
70 	if (err < 0) {
71 		dev_err(&sdev->dev, "Can't add %s, status %d\n",
72 			dev_name(&sdev->dev), err);
73 		goto err_device_add;
74 	}
75 
76 	dev_dbg(&sdev->dev, "device %s registered\n", dev_name(&sdev->dev));
77 
78 err_device_add:
79 	return err;
80 }
81 EXPORT_SYMBOL_GPL(spmi_device_add);
82 
83 /**
84  * spmi_device_remove(): remove an SPMI device
85  * @sdev:	spmi_device to be removed
86  */
spmi_device_remove(struct spmi_device * sdev)87 void spmi_device_remove(struct spmi_device *sdev)
88 {
89 	device_unregister(&sdev->dev);
90 }
91 EXPORT_SYMBOL_GPL(spmi_device_remove);
92 
93 static inline int
spmi_cmd(struct spmi_controller * ctrl,u8 opcode,u8 sid)94 spmi_cmd(struct spmi_controller *ctrl, u8 opcode, u8 sid)
95 {
96 	int ret;
97 
98 	if (!ctrl || !ctrl->cmd || ctrl->dev.type != &spmi_ctrl_type)
99 		return -EINVAL;
100 
101 	ret = ctrl->cmd(ctrl, opcode, sid);
102 	trace_spmi_cmd(opcode, sid, ret);
103 	return ret;
104 }
105 
spmi_read_cmd(struct spmi_controller * ctrl,u8 opcode,u8 sid,u16 addr,u8 * buf,size_t len)106 static inline int spmi_read_cmd(struct spmi_controller *ctrl, u8 opcode,
107 				u8 sid, u16 addr, u8 *buf, size_t len)
108 {
109 	int ret;
110 
111 	if (!ctrl || !ctrl->read_cmd || ctrl->dev.type != &spmi_ctrl_type)
112 		return -EINVAL;
113 
114 	trace_spmi_read_begin(opcode, sid, addr);
115 	ret = ctrl->read_cmd(ctrl, opcode, sid, addr, buf, len);
116 	trace_spmi_read_end(opcode, sid, addr, ret, len, buf);
117 	return ret;
118 }
119 
spmi_write_cmd(struct spmi_controller * ctrl,u8 opcode,u8 sid,u16 addr,const u8 * buf,size_t len)120 static inline int spmi_write_cmd(struct spmi_controller *ctrl, u8 opcode,
121 				 u8 sid, u16 addr, const u8 *buf, size_t len)
122 {
123 	int ret;
124 
125 	if (!ctrl || !ctrl->write_cmd || ctrl->dev.type != &spmi_ctrl_type)
126 		return -EINVAL;
127 
128 	trace_spmi_write_begin(opcode, sid, addr, len, buf);
129 	ret = ctrl->write_cmd(ctrl, opcode, sid, addr, buf, len);
130 	trace_spmi_write_end(opcode, sid, addr, ret);
131 	return ret;
132 }
133 
134 /**
135  * spmi_register_read() - register read
136  * @sdev:	SPMI device.
137  * @addr:	slave register address (5-bit address).
138  * @buf:	buffer to be populated with data from the Slave.
139  *
140  * Reads 1 byte of data from a Slave device register.
141  */
spmi_register_read(struct spmi_device * sdev,u8 addr,u8 * buf)142 int spmi_register_read(struct spmi_device *sdev, u8 addr, u8 *buf)
143 {
144 	/* 5-bit register address */
145 	if (addr > 0x1F)
146 		return -EINVAL;
147 
148 	return spmi_read_cmd(sdev->ctrl, SPMI_CMD_READ, sdev->usid, addr,
149 			     buf, 1);
150 }
151 EXPORT_SYMBOL_GPL(spmi_register_read);
152 
153 /**
154  * spmi_ext_register_read() - extended register read
155  * @sdev:	SPMI device.
156  * @addr:	slave register address (8-bit address).
157  * @buf:	buffer to be populated with data from the Slave.
158  * @len:	the request number of bytes to read (up to 16 bytes).
159  *
160  * Reads up to 16 bytes of data from the extended register space on a
161  * Slave device.
162  */
spmi_ext_register_read(struct spmi_device * sdev,u8 addr,u8 * buf,size_t len)163 int spmi_ext_register_read(struct spmi_device *sdev, u8 addr, u8 *buf,
164 			   size_t len)
165 {
166 	/* 8-bit register address, up to 16 bytes */
167 	if (len == 0 || len > 16)
168 		return -EINVAL;
169 
170 	return spmi_read_cmd(sdev->ctrl, SPMI_CMD_EXT_READ, sdev->usid, addr,
171 			     buf, len);
172 }
173 EXPORT_SYMBOL_GPL(spmi_ext_register_read);
174 
175 /**
176  * spmi_ext_register_readl() - extended register read long
177  * @sdev:	SPMI device.
178  * @addr:	slave register address (16-bit address).
179  * @buf:	buffer to be populated with data from the Slave.
180  * @len:	the request number of bytes to read (up to 8 bytes).
181  *
182  * Reads up to 8 bytes of data from the extended register space on a
183  * Slave device using 16-bit address.
184  */
spmi_ext_register_readl(struct spmi_device * sdev,u16 addr,u8 * buf,size_t len)185 int spmi_ext_register_readl(struct spmi_device *sdev, u16 addr, u8 *buf,
186 			    size_t len)
187 {
188 	/* 16-bit register address, up to 8 bytes */
189 	if (len == 0 || len > 8)
190 		return -EINVAL;
191 
192 	return spmi_read_cmd(sdev->ctrl, SPMI_CMD_EXT_READL, sdev->usid, addr,
193 			     buf, len);
194 }
195 EXPORT_SYMBOL_GPL(spmi_ext_register_readl);
196 
197 /**
198  * spmi_register_write() - register write
199  * @sdev:	SPMI device
200  * @addr:	slave register address (5-bit address).
201  * @data:	buffer containing the data to be transferred to the Slave.
202  *
203  * Writes 1 byte of data to a Slave device register.
204  */
spmi_register_write(struct spmi_device * sdev,u8 addr,u8 data)205 int spmi_register_write(struct spmi_device *sdev, u8 addr, u8 data)
206 {
207 	/* 5-bit register address */
208 	if (addr > 0x1F)
209 		return -EINVAL;
210 
211 	return spmi_write_cmd(sdev->ctrl, SPMI_CMD_WRITE, sdev->usid, addr,
212 			      &data, 1);
213 }
214 EXPORT_SYMBOL_GPL(spmi_register_write);
215 
216 /**
217  * spmi_register_zero_write() - register zero write
218  * @sdev:	SPMI device.
219  * @data:	the data to be written to register 0 (7-bits).
220  *
221  * Writes data to register 0 of the Slave device.
222  */
spmi_register_zero_write(struct spmi_device * sdev,u8 data)223 int spmi_register_zero_write(struct spmi_device *sdev, u8 data)
224 {
225 	return spmi_write_cmd(sdev->ctrl, SPMI_CMD_ZERO_WRITE, sdev->usid, 0,
226 			      &data, 1);
227 }
228 EXPORT_SYMBOL_GPL(spmi_register_zero_write);
229 
230 /**
231  * spmi_ext_register_write() - extended register write
232  * @sdev:	SPMI device.
233  * @addr:	slave register address (8-bit address).
234  * @buf:	buffer containing the data to be transferred to the Slave.
235  * @len:	the request number of bytes to read (up to 16 bytes).
236  *
237  * Writes up to 16 bytes of data to the extended register space of a
238  * Slave device.
239  */
spmi_ext_register_write(struct spmi_device * sdev,u8 addr,const u8 * buf,size_t len)240 int spmi_ext_register_write(struct spmi_device *sdev, u8 addr, const u8 *buf,
241 			    size_t len)
242 {
243 	/* 8-bit register address, up to 16 bytes */
244 	if (len == 0 || len > 16)
245 		return -EINVAL;
246 
247 	return spmi_write_cmd(sdev->ctrl, SPMI_CMD_EXT_WRITE, sdev->usid, addr,
248 			      buf, len);
249 }
250 EXPORT_SYMBOL_GPL(spmi_ext_register_write);
251 
252 /**
253  * spmi_ext_register_writel() - extended register write long
254  * @sdev:	SPMI device.
255  * @addr:	slave register address (16-bit address).
256  * @buf:	buffer containing the data to be transferred to the Slave.
257  * @len:	the request number of bytes to read (up to 8 bytes).
258  *
259  * Writes up to 8 bytes of data to the extended register space of a
260  * Slave device using 16-bit address.
261  */
spmi_ext_register_writel(struct spmi_device * sdev,u16 addr,const u8 * buf,size_t len)262 int spmi_ext_register_writel(struct spmi_device *sdev, u16 addr, const u8 *buf,
263 			     size_t len)
264 {
265 	/* 4-bit Slave Identifier, 16-bit register address, up to 8 bytes */
266 	if (len == 0 || len > 8)
267 		return -EINVAL;
268 
269 	return spmi_write_cmd(sdev->ctrl, SPMI_CMD_EXT_WRITEL, sdev->usid,
270 			      addr, buf, len);
271 }
272 EXPORT_SYMBOL_GPL(spmi_ext_register_writel);
273 
274 /**
275  * spmi_command_reset() - sends RESET command to the specified slave
276  * @sdev:	SPMI device.
277  *
278  * The Reset command initializes the Slave and forces all registers to
279  * their reset values. The Slave shall enter the STARTUP state after
280  * receiving a Reset command.
281  */
spmi_command_reset(struct spmi_device * sdev)282 int spmi_command_reset(struct spmi_device *sdev)
283 {
284 	return spmi_cmd(sdev->ctrl, SPMI_CMD_RESET, sdev->usid);
285 }
286 EXPORT_SYMBOL_GPL(spmi_command_reset);
287 
288 /**
289  * spmi_command_sleep() - sends SLEEP command to the specified SPMI device
290  * @sdev:	SPMI device.
291  *
292  * The Sleep command causes the Slave to enter the user defined SLEEP state.
293  */
spmi_command_sleep(struct spmi_device * sdev)294 int spmi_command_sleep(struct spmi_device *sdev)
295 {
296 	return spmi_cmd(sdev->ctrl, SPMI_CMD_SLEEP, sdev->usid);
297 }
298 EXPORT_SYMBOL_GPL(spmi_command_sleep);
299 
300 /**
301  * spmi_command_wakeup() - sends WAKEUP command to the specified SPMI device
302  * @sdev:	SPMI device.
303  *
304  * The Wakeup command causes the Slave to move from the SLEEP state to
305  * the ACTIVE state.
306  */
spmi_command_wakeup(struct spmi_device * sdev)307 int spmi_command_wakeup(struct spmi_device *sdev)
308 {
309 	return spmi_cmd(sdev->ctrl, SPMI_CMD_WAKEUP, sdev->usid);
310 }
311 EXPORT_SYMBOL_GPL(spmi_command_wakeup);
312 
313 /**
314  * spmi_command_shutdown() - sends SHUTDOWN command to the specified SPMI device
315  * @sdev:	SPMI device.
316  *
317  * The Shutdown command causes the Slave to enter the SHUTDOWN state.
318  */
spmi_command_shutdown(struct spmi_device * sdev)319 int spmi_command_shutdown(struct spmi_device *sdev)
320 {
321 	return spmi_cmd(sdev->ctrl, SPMI_CMD_SHUTDOWN, sdev->usid);
322 }
323 EXPORT_SYMBOL_GPL(spmi_command_shutdown);
324 
spmi_drv_probe(struct device * dev)325 static int spmi_drv_probe(struct device *dev)
326 {
327 	const struct spmi_driver *sdrv = to_spmi_driver(dev->driver);
328 	struct spmi_device *sdev = to_spmi_device(dev);
329 	int err;
330 
331 	pm_runtime_get_noresume(dev);
332 	pm_runtime_set_active(dev);
333 	pm_runtime_enable(dev);
334 
335 	err = sdrv->probe(sdev);
336 	if (err)
337 		goto fail_probe;
338 
339 	return 0;
340 
341 fail_probe:
342 	pm_runtime_disable(dev);
343 	pm_runtime_set_suspended(dev);
344 	pm_runtime_put_noidle(dev);
345 	return err;
346 }
347 
spmi_drv_remove(struct device * dev)348 static void spmi_drv_remove(struct device *dev)
349 {
350 	const struct spmi_driver *sdrv = to_spmi_driver(dev->driver);
351 
352 	pm_runtime_get_sync(dev);
353 	if (sdrv->remove)
354 		sdrv->remove(to_spmi_device(dev));
355 	pm_runtime_put_noidle(dev);
356 
357 	pm_runtime_disable(dev);
358 	pm_runtime_set_suspended(dev);
359 	pm_runtime_put_noidle(dev);
360 }
361 
spmi_drv_shutdown(struct device * dev)362 static void spmi_drv_shutdown(struct device *dev)
363 {
364 	const struct spmi_driver *sdrv = to_spmi_driver(dev->driver);
365 
366 	if (sdrv && sdrv->shutdown)
367 		sdrv->shutdown(to_spmi_device(dev));
368 }
369 
spmi_drv_uevent(const struct device * dev,struct kobj_uevent_env * env)370 static int spmi_drv_uevent(const struct device *dev, struct kobj_uevent_env *env)
371 {
372 	int ret;
373 
374 	ret = of_device_uevent_modalias(dev, env);
375 	if (ret != -ENODEV)
376 		return ret;
377 
378 	return 0;
379 }
380 
381 static const struct bus_type spmi_bus_type = {
382 	.name		= "spmi",
383 	.match		= spmi_device_match,
384 	.probe		= spmi_drv_probe,
385 	.remove		= spmi_drv_remove,
386 	.shutdown	= spmi_drv_shutdown,
387 	.uevent		= spmi_drv_uevent,
388 };
389 
390 /**
391  * spmi_find_device_by_of_node() - look up an SPMI device from a device node
392  *
393  * @np:		device node
394  *
395  * Takes a reference to the embedded struct device which needs to be dropped
396  * after use.
397  *
398  * Returns the struct spmi_device associated with a device node or NULL.
399  */
spmi_find_device_by_of_node(struct device_node * np)400 struct spmi_device *spmi_find_device_by_of_node(struct device_node *np)
401 {
402 	struct device *dev = bus_find_device_by_of_node(&spmi_bus_type, np);
403 
404 	if (dev)
405 		return to_spmi_device(dev);
406 	return NULL;
407 }
408 EXPORT_SYMBOL_GPL(spmi_find_device_by_of_node);
409 
410 /**
411  * spmi_device_alloc() - Allocate a new SPMI device
412  * @ctrl:	associated controller
413  *
414  * Caller is responsible for either calling spmi_device_add() to add the
415  * newly allocated controller, or calling spmi_device_put() to discard it.
416  */
spmi_device_alloc(struct spmi_controller * ctrl)417 struct spmi_device *spmi_device_alloc(struct spmi_controller *ctrl)
418 {
419 	struct spmi_device *sdev;
420 
421 	sdev = kzalloc(sizeof(*sdev), GFP_KERNEL);
422 	if (!sdev)
423 		return NULL;
424 
425 	sdev->ctrl = ctrl;
426 	device_initialize(&sdev->dev);
427 	sdev->dev.parent = &ctrl->dev;
428 	sdev->dev.bus = &spmi_bus_type;
429 	sdev->dev.type = &spmi_dev_type;
430 	return sdev;
431 }
432 EXPORT_SYMBOL_GPL(spmi_device_alloc);
433 
434 /**
435  * spmi_controller_alloc() - Allocate a new SPMI controller
436  * @parent:	parent device
437  * @size:	size of private data
438  *
439  * Caller is responsible for either calling spmi_controller_add() to add the
440  * newly allocated controller, or calling spmi_controller_put() to discard it.
441  * The allocated private data region may be accessed via
442  * spmi_controller_get_drvdata()
443  */
spmi_controller_alloc(struct device * parent,size_t size)444 struct spmi_controller *spmi_controller_alloc(struct device *parent,
445 					      size_t size)
446 {
447 	struct spmi_controller *ctrl;
448 	int id;
449 
450 	if (WARN_ON(!parent))
451 		return ERR_PTR(-EINVAL);
452 
453 	ctrl = kzalloc(sizeof(*ctrl) + size, GFP_KERNEL);
454 	if (!ctrl)
455 		return ERR_PTR(-ENOMEM);
456 
457 	device_initialize(&ctrl->dev);
458 	ctrl->dev.type = &spmi_ctrl_type;
459 	ctrl->dev.bus = &spmi_bus_type;
460 	ctrl->dev.parent = parent;
461 	ctrl->dev.of_node = parent->of_node;
462 	spmi_controller_set_drvdata(ctrl, &ctrl[1]);
463 
464 	id = ida_alloc(&ctrl_ida, GFP_KERNEL);
465 	if (id < 0) {
466 		dev_err(parent,
467 			"unable to allocate SPMI controller identifier.\n");
468 		spmi_controller_put(ctrl);
469 		return ERR_PTR(id);
470 	}
471 
472 	ctrl->nr = id;
473 	dev_set_name(&ctrl->dev, "spmi-%d", id);
474 
475 	dev_dbg(&ctrl->dev, "allocated controller 0x%p id %d\n", ctrl, id);
476 	return ctrl;
477 }
478 EXPORT_SYMBOL_GPL(spmi_controller_alloc);
479 
of_spmi_register_devices(struct spmi_controller * ctrl)480 static void of_spmi_register_devices(struct spmi_controller *ctrl)
481 {
482 	struct device_node *node;
483 	int err;
484 
485 	if (!ctrl->dev.of_node)
486 		return;
487 
488 	for_each_available_child_of_node(ctrl->dev.of_node, node) {
489 		struct spmi_device *sdev;
490 		u32 reg[2];
491 
492 		dev_dbg(&ctrl->dev, "adding child %pOF\n", node);
493 
494 		err = of_property_read_u32_array(node, "reg", reg, 2);
495 		if (err) {
496 			dev_err(&ctrl->dev,
497 				"node %pOF err (%d) does not have 'reg' property\n",
498 				node, err);
499 			continue;
500 		}
501 
502 		if (reg[1] != SPMI_USID) {
503 			dev_err(&ctrl->dev,
504 				"node %pOF contains unsupported 'reg' entry\n",
505 				node);
506 			continue;
507 		}
508 
509 		if (reg[0] >= SPMI_MAX_SLAVE_ID) {
510 			dev_err(&ctrl->dev, "invalid usid on node %pOF\n", node);
511 			continue;
512 		}
513 
514 		dev_dbg(&ctrl->dev, "read usid %02x\n", reg[0]);
515 
516 		sdev = spmi_device_alloc(ctrl);
517 		if (!sdev)
518 			continue;
519 
520 		sdev->dev.of_node = node;
521 		sdev->usid = (u8)reg[0];
522 
523 		err = spmi_device_add(sdev);
524 		if (err) {
525 			dev_err(&sdev->dev,
526 				"failure adding device. status %d\n", err);
527 			spmi_device_put(sdev);
528 		}
529 	}
530 }
531 
532 /**
533  * spmi_controller_add() - Add an SPMI controller
534  * @ctrl:	controller to be registered.
535  *
536  * Register a controller previously allocated via spmi_controller_alloc() with
537  * the SPMI core.
538  */
spmi_controller_add(struct spmi_controller * ctrl)539 int spmi_controller_add(struct spmi_controller *ctrl)
540 {
541 	int ret;
542 
543 	/* Can't register until after driver model init */
544 	if (WARN_ON(!is_registered))
545 		return -EAGAIN;
546 
547 	ret = device_add(&ctrl->dev);
548 	if (ret)
549 		return ret;
550 
551 	if (IS_ENABLED(CONFIG_OF))
552 		of_spmi_register_devices(ctrl);
553 
554 	dev_dbg(&ctrl->dev, "spmi-%d registered: dev:%p\n",
555 		ctrl->nr, &ctrl->dev);
556 
557 	return 0;
558 };
559 EXPORT_SYMBOL_GPL(spmi_controller_add);
560 
561 /* Remove a device associated with a controller */
spmi_ctrl_remove_device(struct device * dev,void * data)562 static int spmi_ctrl_remove_device(struct device *dev, void *data)
563 {
564 	struct spmi_device *spmidev = to_spmi_device(dev);
565 
566 	if (dev->type == &spmi_dev_type)
567 		spmi_device_remove(spmidev);
568 	return 0;
569 }
570 
571 /**
572  * spmi_controller_remove(): remove an SPMI controller
573  * @ctrl:	controller to remove
574  *
575  * Remove a SPMI controller.  Caller is responsible for calling
576  * spmi_controller_put() to discard the allocated controller.
577  */
spmi_controller_remove(struct spmi_controller * ctrl)578 void spmi_controller_remove(struct spmi_controller *ctrl)
579 {
580 	if (!ctrl)
581 		return;
582 
583 	device_for_each_child(&ctrl->dev, NULL, spmi_ctrl_remove_device);
584 	device_del(&ctrl->dev);
585 }
586 EXPORT_SYMBOL_GPL(spmi_controller_remove);
587 
588 /**
589  * __spmi_driver_register() - Register client driver with SPMI core
590  * @sdrv:	client driver to be associated with client-device.
591  * @owner:	module owner
592  *
593  * This API will register the client driver with the SPMI framework.
594  * It is typically called from the driver's module-init function.
595  */
__spmi_driver_register(struct spmi_driver * sdrv,struct module * owner)596 int __spmi_driver_register(struct spmi_driver *sdrv, struct module *owner)
597 {
598 	sdrv->driver.bus = &spmi_bus_type;
599 	sdrv->driver.owner = owner;
600 	return driver_register(&sdrv->driver);
601 }
602 EXPORT_SYMBOL_GPL(__spmi_driver_register);
603 
spmi_exit(void)604 static void __exit spmi_exit(void)
605 {
606 	bus_unregister(&spmi_bus_type);
607 }
608 module_exit(spmi_exit);
609 
spmi_init(void)610 static int __init spmi_init(void)
611 {
612 	int ret;
613 
614 	ret = bus_register(&spmi_bus_type);
615 	if (ret)
616 		return ret;
617 
618 	is_registered = true;
619 	return 0;
620 }
621 postcore_initcall(spmi_init);
622 
623 MODULE_LICENSE("GPL v2");
624 MODULE_DESCRIPTION("SPMI module");
625 MODULE_ALIAS("platform:spmi");
626