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,struct device_driver * drv)46 static int spmi_device_match(struct device *dev, 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 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_device_from_of() - get the associated SPMI device from a device node
392  *
393  * @np:		device node
394  *
395  * Returns the struct spmi_device associated with a device node or NULL.
396  */
spmi_device_from_of(struct device_node * np)397 struct spmi_device *spmi_device_from_of(struct device_node *np)
398 {
399 	struct device *dev = bus_find_device_by_of_node(&spmi_bus_type, np);
400 
401 	if (dev)
402 		return to_spmi_device(dev);
403 	return NULL;
404 }
405 EXPORT_SYMBOL_GPL(spmi_device_from_of);
406 
407 /**
408  * spmi_device_alloc() - Allocate a new SPMI device
409  * @ctrl:	associated controller
410  *
411  * Caller is responsible for either calling spmi_device_add() to add the
412  * newly allocated controller, or calling spmi_device_put() to discard it.
413  */
spmi_device_alloc(struct spmi_controller * ctrl)414 struct spmi_device *spmi_device_alloc(struct spmi_controller *ctrl)
415 {
416 	struct spmi_device *sdev;
417 
418 	sdev = kzalloc(sizeof(*sdev), GFP_KERNEL);
419 	if (!sdev)
420 		return NULL;
421 
422 	sdev->ctrl = ctrl;
423 	device_initialize(&sdev->dev);
424 	sdev->dev.parent = &ctrl->dev;
425 	sdev->dev.bus = &spmi_bus_type;
426 	sdev->dev.type = &spmi_dev_type;
427 	return sdev;
428 }
429 EXPORT_SYMBOL_GPL(spmi_device_alloc);
430 
431 /**
432  * spmi_controller_alloc() - Allocate a new SPMI controller
433  * @parent:	parent device
434  * @size:	size of private data
435  *
436  * Caller is responsible for either calling spmi_controller_add() to add the
437  * newly allocated controller, or calling spmi_controller_put() to discard it.
438  * The allocated private data region may be accessed via
439  * spmi_controller_get_drvdata()
440  */
spmi_controller_alloc(struct device * parent,size_t size)441 struct spmi_controller *spmi_controller_alloc(struct device *parent,
442 					      size_t size)
443 {
444 	struct spmi_controller *ctrl;
445 	int id;
446 
447 	if (WARN_ON(!parent))
448 		return NULL;
449 
450 	ctrl = kzalloc(sizeof(*ctrl) + size, GFP_KERNEL);
451 	if (!ctrl)
452 		return NULL;
453 
454 	device_initialize(&ctrl->dev);
455 	ctrl->dev.type = &spmi_ctrl_type;
456 	ctrl->dev.bus = &spmi_bus_type;
457 	ctrl->dev.parent = parent;
458 	ctrl->dev.of_node = parent->of_node;
459 	spmi_controller_set_drvdata(ctrl, &ctrl[1]);
460 
461 	id = ida_alloc(&ctrl_ida, GFP_KERNEL);
462 	if (id < 0) {
463 		dev_err(parent,
464 			"unable to allocate SPMI controller identifier.\n");
465 		spmi_controller_put(ctrl);
466 		return NULL;
467 	}
468 
469 	ctrl->nr = id;
470 	dev_set_name(&ctrl->dev, "spmi-%d", id);
471 
472 	dev_dbg(&ctrl->dev, "allocated controller 0x%p id %d\n", ctrl, id);
473 	return ctrl;
474 }
475 EXPORT_SYMBOL_GPL(spmi_controller_alloc);
476 
of_spmi_register_devices(struct spmi_controller * ctrl)477 static void of_spmi_register_devices(struct spmi_controller *ctrl)
478 {
479 	struct device_node *node;
480 	int err;
481 
482 	if (!ctrl->dev.of_node)
483 		return;
484 
485 	for_each_available_child_of_node(ctrl->dev.of_node, node) {
486 		struct spmi_device *sdev;
487 		u32 reg[2];
488 
489 		dev_dbg(&ctrl->dev, "adding child %pOF\n", node);
490 
491 		err = of_property_read_u32_array(node, "reg", reg, 2);
492 		if (err) {
493 			dev_err(&ctrl->dev,
494 				"node %pOF err (%d) does not have 'reg' property\n",
495 				node, err);
496 			continue;
497 		}
498 
499 		if (reg[1] != SPMI_USID) {
500 			dev_err(&ctrl->dev,
501 				"node %pOF contains unsupported 'reg' entry\n",
502 				node);
503 			continue;
504 		}
505 
506 		if (reg[0] >= SPMI_MAX_SLAVE_ID) {
507 			dev_err(&ctrl->dev, "invalid usid on node %pOF\n", node);
508 			continue;
509 		}
510 
511 		dev_dbg(&ctrl->dev, "read usid %02x\n", reg[0]);
512 
513 		sdev = spmi_device_alloc(ctrl);
514 		if (!sdev)
515 			continue;
516 
517 		sdev->dev.of_node = node;
518 		sdev->usid = (u8)reg[0];
519 
520 		err = spmi_device_add(sdev);
521 		if (err) {
522 			dev_err(&sdev->dev,
523 				"failure adding device. status %d\n", err);
524 			spmi_device_put(sdev);
525 		}
526 	}
527 }
528 
529 /**
530  * spmi_controller_add() - Add an SPMI controller
531  * @ctrl:	controller to be registered.
532  *
533  * Register a controller previously allocated via spmi_controller_alloc() with
534  * the SPMI core.
535  */
spmi_controller_add(struct spmi_controller * ctrl)536 int spmi_controller_add(struct spmi_controller *ctrl)
537 {
538 	int ret;
539 
540 	/* Can't register until after driver model init */
541 	if (WARN_ON(!is_registered))
542 		return -EAGAIN;
543 
544 	ret = device_add(&ctrl->dev);
545 	if (ret)
546 		return ret;
547 
548 	if (IS_ENABLED(CONFIG_OF))
549 		of_spmi_register_devices(ctrl);
550 
551 	dev_dbg(&ctrl->dev, "spmi-%d registered: dev:%p\n",
552 		ctrl->nr, &ctrl->dev);
553 
554 	return 0;
555 };
556 EXPORT_SYMBOL_GPL(spmi_controller_add);
557 
558 /* Remove a device associated with a controller */
spmi_ctrl_remove_device(struct device * dev,void * data)559 static int spmi_ctrl_remove_device(struct device *dev, void *data)
560 {
561 	struct spmi_device *spmidev = to_spmi_device(dev);
562 
563 	if (dev->type == &spmi_dev_type)
564 		spmi_device_remove(spmidev);
565 	return 0;
566 }
567 
568 /**
569  * spmi_controller_remove(): remove an SPMI controller
570  * @ctrl:	controller to remove
571  *
572  * Remove a SPMI controller.  Caller is responsible for calling
573  * spmi_controller_put() to discard the allocated controller.
574  */
spmi_controller_remove(struct spmi_controller * ctrl)575 void spmi_controller_remove(struct spmi_controller *ctrl)
576 {
577 	if (!ctrl)
578 		return;
579 
580 	device_for_each_child(&ctrl->dev, NULL, spmi_ctrl_remove_device);
581 	device_del(&ctrl->dev);
582 }
583 EXPORT_SYMBOL_GPL(spmi_controller_remove);
584 
585 /**
586  * __spmi_driver_register() - Register client driver with SPMI core
587  * @sdrv:	client driver to be associated with client-device.
588  * @owner:	module owner
589  *
590  * This API will register the client driver with the SPMI framework.
591  * It is typically called from the driver's module-init function.
592  */
__spmi_driver_register(struct spmi_driver * sdrv,struct module * owner)593 int __spmi_driver_register(struct spmi_driver *sdrv, struct module *owner)
594 {
595 	sdrv->driver.bus = &spmi_bus_type;
596 	sdrv->driver.owner = owner;
597 	return driver_register(&sdrv->driver);
598 }
599 EXPORT_SYMBOL_GPL(__spmi_driver_register);
600 
spmi_exit(void)601 static void __exit spmi_exit(void)
602 {
603 	bus_unregister(&spmi_bus_type);
604 }
605 module_exit(spmi_exit);
606 
spmi_init(void)607 static int __init spmi_init(void)
608 {
609 	int ret;
610 
611 	ret = bus_register(&spmi_bus_type);
612 	if (ret)
613 		return ret;
614 
615 	is_registered = true;
616 	return 0;
617 }
618 postcore_initcall(spmi_init);
619 
620 MODULE_LICENSE("GPL v2");
621 MODULE_DESCRIPTION("SPMI module");
622 MODULE_ALIAS("platform:spmi");
623