2 * Copyright (C) 2016-2017 Linaro Ltd., Rob Herring <robh@kernel.org>
4 * Based on drivers/spmi/spmi.c:
5 * Copyright (c) 2012-2015, The Linux Foundation. All rights reserved.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 and
9 * only version 2 as published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
17 #include <linux/errno.h>
18 #include <linux/idr.h>
19 #include <linux/kernel.h>
20 #include <linux/module.h>
22 #include <linux/of_device.h>
23 #include <linux/serdev.h>
24 #include <linux/slab.h>
26 static bool is_registered
;
27 static DEFINE_IDA(ctrl_ida
);
29 static void serdev_device_release(struct device
*dev
)
31 struct serdev_device
*serdev
= to_serdev_device(dev
);
35 static const struct device_type serdev_device_type
= {
36 .release
= serdev_device_release
,
39 static void serdev_ctrl_release(struct device
*dev
)
41 struct serdev_controller
*ctrl
= to_serdev_controller(dev
);
42 ida_simple_remove(&ctrl_ida
, ctrl
->nr
);
46 static const struct device_type serdev_ctrl_type
= {
47 .release
= serdev_ctrl_release
,
50 static int serdev_device_match(struct device
*dev
, struct device_driver
*drv
)
52 /* TODO: ACPI and platform matching */
53 return of_driver_match_device(dev
, drv
);
56 static int serdev_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
58 /* TODO: ACPI and platform modalias */
59 return of_device_uevent_modalias(dev
, env
);
63 * serdev_device_add() - add a device previously constructed via serdev_device_alloc()
64 * @serdev: serdev_device to be added
66 int serdev_device_add(struct serdev_device
*serdev
)
68 struct device
*parent
= serdev
->dev
.parent
;
71 dev_set_name(&serdev
->dev
, "%s-%d", dev_name(parent
), serdev
->nr
);
73 err
= device_add(&serdev
->dev
);
75 dev_err(&serdev
->dev
, "Can't add %s, status %d\n",
76 dev_name(&serdev
->dev
), err
);
80 dev_dbg(&serdev
->dev
, "device %s registered\n", dev_name(&serdev
->dev
));
85 EXPORT_SYMBOL_GPL(serdev_device_add
);
88 * serdev_device_remove(): remove an serdev device
89 * @serdev: serdev_device to be removed
91 void serdev_device_remove(struct serdev_device
*serdev
)
93 device_unregister(&serdev
->dev
);
95 EXPORT_SYMBOL_GPL(serdev_device_remove
);
97 int serdev_device_open(struct serdev_device
*serdev
)
99 struct serdev_controller
*ctrl
= serdev
->ctrl
;
101 if (!ctrl
|| !ctrl
->ops
->open
)
104 return ctrl
->ops
->open(ctrl
);
106 EXPORT_SYMBOL_GPL(serdev_device_open
);
108 void serdev_device_close(struct serdev_device
*serdev
)
110 struct serdev_controller
*ctrl
= serdev
->ctrl
;
112 if (!ctrl
|| !ctrl
->ops
->close
)
115 ctrl
->ops
->close(ctrl
);
117 EXPORT_SYMBOL_GPL(serdev_device_close
);
119 int serdev_device_write_buf(struct serdev_device
*serdev
,
120 const unsigned char *buf
, size_t count
)
122 struct serdev_controller
*ctrl
= serdev
->ctrl
;
124 if (!ctrl
|| !ctrl
->ops
->write_buf
)
127 return ctrl
->ops
->write_buf(ctrl
, buf
, count
);
129 EXPORT_SYMBOL_GPL(serdev_device_write_buf
);
131 void serdev_device_write_flush(struct serdev_device
*serdev
)
133 struct serdev_controller
*ctrl
= serdev
->ctrl
;
135 if (!ctrl
|| !ctrl
->ops
->write_flush
)
138 ctrl
->ops
->write_flush(ctrl
);
140 EXPORT_SYMBOL_GPL(serdev_device_write_flush
);
142 int serdev_device_write_room(struct serdev_device
*serdev
)
144 struct serdev_controller
*ctrl
= serdev
->ctrl
;
146 if (!ctrl
|| !ctrl
->ops
->write_room
)
149 return serdev
->ctrl
->ops
->write_room(ctrl
);
151 EXPORT_SYMBOL_GPL(serdev_device_write_room
);
153 unsigned int serdev_device_set_baudrate(struct serdev_device
*serdev
, unsigned int speed
)
155 struct serdev_controller
*ctrl
= serdev
->ctrl
;
157 if (!ctrl
|| !ctrl
->ops
->set_baudrate
)
160 return ctrl
->ops
->set_baudrate(ctrl
, speed
);
163 EXPORT_SYMBOL_GPL(serdev_device_set_baudrate
);
165 void serdev_device_set_flow_control(struct serdev_device
*serdev
, bool enable
)
167 struct serdev_controller
*ctrl
= serdev
->ctrl
;
169 if (!ctrl
|| !ctrl
->ops
->set_flow_control
)
172 ctrl
->ops
->set_flow_control(ctrl
, enable
);
174 EXPORT_SYMBOL_GPL(serdev_device_set_flow_control
);
176 void serdev_device_wait_until_sent(struct serdev_device
*serdev
, long timeout
)
178 struct serdev_controller
*ctrl
= serdev
->ctrl
;
180 if (!ctrl
|| !ctrl
->ops
->wait_until_sent
)
183 ctrl
->ops
->wait_until_sent(ctrl
, timeout
);
185 EXPORT_SYMBOL_GPL(serdev_device_wait_until_sent
);
187 int serdev_device_get_tiocm(struct serdev_device
*serdev
)
189 struct serdev_controller
*ctrl
= serdev
->ctrl
;
191 if (!ctrl
|| !ctrl
->ops
->get_tiocm
)
194 return ctrl
->ops
->get_tiocm(ctrl
);
196 EXPORT_SYMBOL_GPL(serdev_device_get_tiocm
);
198 int serdev_device_set_tiocm(struct serdev_device
*serdev
, int set
, int clear
)
200 struct serdev_controller
*ctrl
= serdev
->ctrl
;
202 if (!ctrl
|| !ctrl
->ops
->set_tiocm
)
205 return ctrl
->ops
->set_tiocm(ctrl
, set
, clear
);
207 EXPORT_SYMBOL_GPL(serdev_device_set_tiocm
);
209 static int serdev_drv_probe(struct device
*dev
)
211 const struct serdev_device_driver
*sdrv
= to_serdev_device_driver(dev
->driver
);
213 return sdrv
->probe(to_serdev_device(dev
));
216 static int serdev_drv_remove(struct device
*dev
)
218 const struct serdev_device_driver
*sdrv
= to_serdev_device_driver(dev
->driver
);
220 sdrv
->remove(to_serdev_device(dev
));
224 static ssize_t
modalias_show(struct device
*dev
,
225 struct device_attribute
*attr
, char *buf
)
227 return of_device_modalias(dev
, buf
, PAGE_SIZE
);
230 static struct device_attribute serdev_device_attrs
[] = {
235 static struct bus_type serdev_bus_type
= {
237 .match
= serdev_device_match
,
238 .probe
= serdev_drv_probe
,
239 .remove
= serdev_drv_remove
,
240 .uevent
= serdev_uevent
,
241 .dev_attrs
= serdev_device_attrs
,
245 * serdev_controller_alloc() - Allocate a new serdev device
246 * @ctrl: associated controller
248 * Caller is responsible for either calling serdev_device_add() to add the
249 * newly allocated controller, or calling serdev_device_put() to discard it.
251 struct serdev_device
*serdev_device_alloc(struct serdev_controller
*ctrl
)
253 struct serdev_device
*serdev
;
255 serdev
= kzalloc(sizeof(*serdev
), GFP_KERNEL
);
260 ctrl
->serdev
= serdev
;
261 device_initialize(&serdev
->dev
);
262 serdev
->dev
.parent
= &ctrl
->dev
;
263 serdev
->dev
.bus
= &serdev_bus_type
;
264 serdev
->dev
.type
= &serdev_device_type
;
267 EXPORT_SYMBOL_GPL(serdev_device_alloc
);
270 * serdev_controller_alloc() - Allocate a new serdev controller
271 * @parent: parent device
272 * @size: size of private data
274 * Caller is responsible for either calling serdev_controller_add() to add the
275 * newly allocated controller, or calling serdev_controller_put() to discard it.
276 * The allocated private data region may be accessed via
277 * serdev_controller_get_drvdata()
279 struct serdev_controller
*serdev_controller_alloc(struct device
*parent
,
282 struct serdev_controller
*ctrl
;
285 if (WARN_ON(!parent
))
288 ctrl
= kzalloc(sizeof(*ctrl
) + size
, GFP_KERNEL
);
292 device_initialize(&ctrl
->dev
);
293 ctrl
->dev
.type
= &serdev_ctrl_type
;
294 ctrl
->dev
.bus
= &serdev_bus_type
;
295 ctrl
->dev
.parent
= parent
;
296 ctrl
->dev
.of_node
= parent
->of_node
;
297 serdev_controller_set_drvdata(ctrl
, &ctrl
[1]);
299 id
= ida_simple_get(&ctrl_ida
, 0, 0, GFP_KERNEL
);
302 "unable to allocate serdev controller identifier.\n");
303 serdev_controller_put(ctrl
);
308 dev_set_name(&ctrl
->dev
, "serial%d", id
);
310 dev_dbg(&ctrl
->dev
, "allocated controller 0x%p id %d\n", ctrl
, id
);
313 EXPORT_SYMBOL_GPL(serdev_controller_alloc
);
315 static int of_serdev_register_devices(struct serdev_controller
*ctrl
)
317 struct device_node
*node
;
318 struct serdev_device
*serdev
= NULL
;
322 for_each_available_child_of_node(ctrl
->dev
.of_node
, node
) {
323 if (!of_get_property(node
, "compatible", NULL
))
326 dev_dbg(&ctrl
->dev
, "adding child %s\n", node
->full_name
);
328 serdev
= serdev_device_alloc(ctrl
);
332 serdev
->dev
.of_node
= node
;
334 err
= serdev_device_add(serdev
);
336 dev_err(&serdev
->dev
,
337 "failure adding device. status %d\n", err
);
338 serdev_device_put(serdev
);
349 * serdev_controller_add() - Add an serdev controller
350 * @ctrl: controller to be registered.
352 * Register a controller previously allocated via serdev_controller_alloc() with
355 int serdev_controller_add(struct serdev_controller
*ctrl
)
359 /* Can't register until after driver model init */
360 if (WARN_ON(!is_registered
))
363 ret
= device_add(&ctrl
->dev
);
367 ret
= of_serdev_register_devices(ctrl
);
371 dev_dbg(&ctrl
->dev
, "serdev%d registered: dev:%p\n",
372 ctrl
->nr
, &ctrl
->dev
);
376 device_del(&ctrl
->dev
);
379 EXPORT_SYMBOL_GPL(serdev_controller_add
);
381 /* Remove a device associated with a controller */
382 static int serdev_remove_device(struct device
*dev
, void *data
)
384 struct serdev_device
*serdev
= to_serdev_device(dev
);
385 if (dev
->type
== &serdev_device_type
)
386 serdev_device_remove(serdev
);
391 * serdev_controller_remove(): remove an serdev controller
392 * @ctrl: controller to remove
394 * Remove a serdev controller. Caller is responsible for calling
395 * serdev_controller_put() to discard the allocated controller.
397 void serdev_controller_remove(struct serdev_controller
*ctrl
)
404 dummy
= device_for_each_child(&ctrl
->dev
, NULL
,
405 serdev_remove_device
);
406 device_del(&ctrl
->dev
);
408 EXPORT_SYMBOL_GPL(serdev_controller_remove
);
411 * serdev_driver_register() - Register client driver with serdev core
412 * @sdrv: client driver to be associated with client-device.
414 * This API will register the client driver with the serdev framework.
415 * It is typically called from the driver's module-init function.
417 int __serdev_device_driver_register(struct serdev_device_driver
*sdrv
, struct module
*owner
)
419 sdrv
->driver
.bus
= &serdev_bus_type
;
420 sdrv
->driver
.owner
= owner
;
422 /* force drivers to async probe so I/O is possible in probe */
423 sdrv
->driver
.probe_type
= PROBE_PREFER_ASYNCHRONOUS
;
425 return driver_register(&sdrv
->driver
);
427 EXPORT_SYMBOL_GPL(__serdev_device_driver_register
);
429 static void __exit
serdev_exit(void)
431 bus_unregister(&serdev_bus_type
);
433 module_exit(serdev_exit
);
435 static int __init
serdev_init(void)
439 ret
= bus_register(&serdev_bus_type
);
443 is_registered
= true;
446 /* Must be before serial drivers register */
447 postcore_initcall(serdev_init
);
449 MODULE_AUTHOR("Rob Herring <robh@kernel.org>");
450 MODULE_LICENSE("GPL v2");
451 MODULE_DESCRIPTION("Serial attached device bus");