4 * Copyright (C) 2010 Nokia Corporation. All rights reserved.
6 * Contact: Carlos Chinea <carlos.chinea@nokia.com>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
22 #include <linux/hsi/hsi.h>
23 #include <linux/compiler.h>
24 #include <linux/list.h>
25 #include <linux/kobject.h>
26 #include <linux/slab.h>
27 #include <linux/string.h>
28 #include <linux/notifier.h>
31 static ssize_t modalias_show(struct device *dev,
32 struct device_attribute *a __maybe_unused, char *buf)
34 return sprintf(buf, "hsi:%s\n", dev_name(dev));
36 static DEVICE_ATTR_RO(modalias);
38 static struct attribute *hsi_bus_dev_attrs[] = {
39 &dev_attr_modalias.attr,
42 ATTRIBUTE_GROUPS(hsi_bus_dev);
44 static int hsi_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
46 add_uevent_var(env, "MODALIAS=hsi:%s", dev_name(dev));
51 static int hsi_bus_match(struct device *dev, struct device_driver *driver)
53 return strcmp(dev_name(dev), driver->name) == 0;
56 static struct bus_type hsi_bus_type = {
58 .dev_groups = hsi_bus_dev_groups,
59 .match = hsi_bus_match,
60 .uevent = hsi_bus_uevent,
63 static void hsi_client_release(struct device *dev)
65 struct hsi_client *cl = to_hsi_client(dev);
67 kfree(cl->tx_cfg.channels);
68 kfree(cl->rx_cfg.channels);
72 static void hsi_new_client(struct hsi_port *port, struct hsi_board_info *info)
74 struct hsi_client *cl;
77 cl = kzalloc(sizeof(*cl), GFP_KERNEL);
81 cl->tx_cfg = info->tx_cfg;
82 if (cl->tx_cfg.channels) {
83 size = cl->tx_cfg.num_channels * sizeof(*cl->tx_cfg.channels);
84 cl->tx_cfg.channels = kzalloc(size , GFP_KERNEL);
85 memcpy(cl->tx_cfg.channels, info->tx_cfg.channels, size);
88 cl->rx_cfg = info->rx_cfg;
89 if (cl->rx_cfg.channels) {
90 size = cl->rx_cfg.num_channels * sizeof(*cl->rx_cfg.channels);
91 cl->rx_cfg.channels = kzalloc(size , GFP_KERNEL);
92 memcpy(cl->rx_cfg.channels, info->rx_cfg.channels, size);
95 cl->device.bus = &hsi_bus_type;
96 cl->device.parent = &port->device;
97 cl->device.release = hsi_client_release;
98 dev_set_name(&cl->device, "%s", info->name);
99 cl->device.platform_data = info->platform_data;
101 cl->device.archdata = *info->archdata;
102 if (device_register(&cl->device) < 0) {
103 pr_err("hsi: failed to register client: %s\n", info->name);
104 put_device(&cl->device);
108 static void hsi_scan_board_info(struct hsi_controller *hsi)
110 struct hsi_cl_info *cl_info;
113 list_for_each_entry(cl_info, &hsi_board_list, list)
114 if (cl_info->info.hsi_id == hsi->id) {
115 p = hsi_find_port_num(hsi, cl_info->info.port);
118 hsi_new_client(p, &cl_info->info);
122 static int hsi_remove_client(struct device *dev, void *data __maybe_unused)
124 device_unregister(dev);
129 static int hsi_remove_port(struct device *dev, void *data __maybe_unused)
131 device_for_each_child(dev, NULL, hsi_remove_client);
132 device_unregister(dev);
137 static void hsi_controller_release(struct device *dev)
139 struct hsi_controller *hsi = to_hsi_controller(dev);
145 static void hsi_port_release(struct device *dev)
147 kfree(to_hsi_port(dev));
151 * hsi_unregister_port - Unregister an HSI port
152 * @port: The HSI port to unregister
154 void hsi_port_unregister_clients(struct hsi_port *port)
156 device_for_each_child(&port->device, NULL, hsi_remove_client);
158 EXPORT_SYMBOL_GPL(hsi_port_unregister_clients);
161 * hsi_unregister_controller - Unregister an HSI controller
162 * @hsi: The HSI controller to register
164 void hsi_unregister_controller(struct hsi_controller *hsi)
166 device_for_each_child(&hsi->device, NULL, hsi_remove_port);
167 device_unregister(&hsi->device);
169 EXPORT_SYMBOL_GPL(hsi_unregister_controller);
172 * hsi_register_controller - Register an HSI controller and its ports
173 * @hsi: The HSI controller to register
175 * Returns -errno on failure, 0 on success.
177 int hsi_register_controller(struct hsi_controller *hsi)
182 err = device_add(&hsi->device);
185 for (i = 0; i < hsi->num_ports; i++) {
186 hsi->port[i]->device.parent = &hsi->device;
187 err = device_add(&hsi->port[i]->device);
191 /* Populate HSI bus with HSI clients */
192 hsi_scan_board_info(hsi);
197 device_del(&hsi->port[i]->device);
198 device_del(&hsi->device);
202 EXPORT_SYMBOL_GPL(hsi_register_controller);
205 * hsi_register_client_driver - Register an HSI client to the HSI bus
206 * @drv: HSI client driver to register
208 * Returns -errno on failure, 0 on success.
210 int hsi_register_client_driver(struct hsi_client_driver *drv)
212 drv->driver.bus = &hsi_bus_type;
214 return driver_register(&drv->driver);
216 EXPORT_SYMBOL_GPL(hsi_register_client_driver);
218 static inline int hsi_dummy_msg(struct hsi_msg *msg __maybe_unused)
223 static inline int hsi_dummy_cl(struct hsi_client *cl __maybe_unused)
229 * hsi_put_controller - Free an HSI controller
231 * @hsi: Pointer to the HSI controller to freed
233 * HSI controller drivers should only use this function if they need
234 * to free their allocated hsi_controller structures before a successful
235 * call to hsi_register_controller. Other use is not allowed.
237 void hsi_put_controller(struct hsi_controller *hsi)
244 for (i = 0; i < hsi->num_ports; i++)
245 if (hsi->port && hsi->port[i])
246 put_device(&hsi->port[i]->device);
247 put_device(&hsi->device);
249 EXPORT_SYMBOL_GPL(hsi_put_controller);
252 * hsi_alloc_controller - Allocate an HSI controller and its ports
253 * @n_ports: Number of ports on the HSI controller
254 * @flags: Kernel allocation flags
256 * Return NULL on failure or a pointer to an hsi_controller on success.
258 struct hsi_controller *hsi_alloc_controller(unsigned int n_ports, gfp_t flags)
260 struct hsi_controller *hsi;
261 struct hsi_port **port;
267 hsi = kzalloc(sizeof(*hsi), flags);
270 port = kzalloc(sizeof(*port)*n_ports, flags);
275 hsi->num_ports = n_ports;
277 hsi->device.release = hsi_controller_release;
278 device_initialize(&hsi->device);
280 for (i = 0; i < n_ports; i++) {
281 port[i] = kzalloc(sizeof(**port), flags);
285 port[i]->async = hsi_dummy_msg;
286 port[i]->setup = hsi_dummy_cl;
287 port[i]->flush = hsi_dummy_cl;
288 port[i]->start_tx = hsi_dummy_cl;
289 port[i]->stop_tx = hsi_dummy_cl;
290 port[i]->release = hsi_dummy_cl;
291 mutex_init(&port[i]->lock);
292 ATOMIC_INIT_NOTIFIER_HEAD(&port[i]->n_head);
293 dev_set_name(&port[i]->device, "port%d", i);
294 hsi->port[i]->device.release = hsi_port_release;
295 device_initialize(&hsi->port[i]->device);
300 hsi_put_controller(hsi);
304 EXPORT_SYMBOL_GPL(hsi_alloc_controller);
307 * hsi_free_msg - Free an HSI message
308 * @msg: Pointer to the HSI message
310 * Client is responsible to free the buffers pointed by the scatterlists.
312 void hsi_free_msg(struct hsi_msg *msg)
316 sg_free_table(&msg->sgt);
319 EXPORT_SYMBOL_GPL(hsi_free_msg);
322 * hsi_alloc_msg - Allocate an HSI message
323 * @nents: Number of memory entries
324 * @flags: Kernel allocation flags
326 * nents can be 0. This mainly makes sense for read transfer.
327 * In that case, HSI drivers will call the complete callback when
328 * there is data to be read without consuming it.
330 * Return NULL on failure or a pointer to an hsi_msg on success.
332 struct hsi_msg *hsi_alloc_msg(unsigned int nents, gfp_t flags)
337 msg = kzalloc(sizeof(*msg), flags);
344 err = sg_alloc_table(&msg->sgt, nents, flags);
352 EXPORT_SYMBOL_GPL(hsi_alloc_msg);
355 * hsi_async - Submit an HSI transfer to the controller
356 * @cl: HSI client sending the transfer
357 * @msg: The HSI transfer passed to controller
359 * The HSI message must have the channel, ttype, complete and destructor
360 * fields set beforehand. If nents > 0 then the client has to initialize
361 * also the scatterlists to point to the buffers to write to or read from.
363 * HSI controllers relay on pre-allocated buffers from their clients and they
364 * do not allocate buffers on their own.
366 * Once the HSI message transfer finishes, the HSI controller calls the
367 * complete callback with the status and actual_len fields of the HSI message
368 * updated. The complete callback can be called before returning from
371 * Returns -errno on failure or 0 on success
373 int hsi_async(struct hsi_client *cl, struct hsi_msg *msg)
375 struct hsi_port *port = hsi_get_port(cl);
377 if (!hsi_port_claimed(cl))
380 WARN_ON_ONCE(!msg->destructor || !msg->complete);
383 return port->async(msg);
385 EXPORT_SYMBOL_GPL(hsi_async);
388 * hsi_claim_port - Claim the HSI client's port
389 * @cl: HSI client that wants to claim its port
390 * @share: Flag to indicate if the client wants to share the port or not.
392 * Returns -errno on failure, 0 on success.
394 int hsi_claim_port(struct hsi_client *cl, unsigned int share)
396 struct hsi_port *port = hsi_get_port(cl);
399 mutex_lock(&port->lock);
400 if ((port->claimed) && (!port->shared || !share)) {
404 if (!try_module_get(to_hsi_controller(port->device.parent)->owner)) {
409 port->shared = !!share;
412 mutex_unlock(&port->lock);
416 EXPORT_SYMBOL_GPL(hsi_claim_port);
419 * hsi_release_port - Release the HSI client's port
420 * @cl: HSI client which previously claimed its port
422 void hsi_release_port(struct hsi_client *cl)
424 struct hsi_port *port = hsi_get_port(cl);
426 mutex_lock(&port->lock);
427 /* Allow HW driver to do some cleanup */
431 BUG_ON(port->claimed < 0);
435 module_put(to_hsi_controller(port->device.parent)->owner);
436 mutex_unlock(&port->lock);
438 EXPORT_SYMBOL_GPL(hsi_release_port);
440 static int hsi_event_notifier_call(struct notifier_block *nb,
441 unsigned long event, void *data __maybe_unused)
443 struct hsi_client *cl = container_of(nb, struct hsi_client, nb);
445 (*cl->ehandler)(cl, event);
451 * hsi_register_port_event - Register a client to receive port events
452 * @cl: HSI client that wants to receive port events
453 * @handler: Event handler callback
455 * Clients should register a callback to be able to receive
456 * events from the ports. Registration should happen after
458 * The handler can be called in interrupt context.
460 * Returns -errno on error, or 0 on success.
462 int hsi_register_port_event(struct hsi_client *cl,
463 void (*handler)(struct hsi_client *, unsigned long))
465 struct hsi_port *port = hsi_get_port(cl);
467 if (!handler || cl->ehandler)
469 if (!hsi_port_claimed(cl))
471 cl->ehandler = handler;
472 cl->nb.notifier_call = hsi_event_notifier_call;
474 return atomic_notifier_chain_register(&port->n_head, &cl->nb);
476 EXPORT_SYMBOL_GPL(hsi_register_port_event);
479 * hsi_unregister_port_event - Stop receiving port events for a client
480 * @cl: HSI client that wants to stop receiving port events
482 * Clients should call this function before releasing their associated
485 * Returns -errno on error, or 0 on success.
487 int hsi_unregister_port_event(struct hsi_client *cl)
489 struct hsi_port *port = hsi_get_port(cl);
492 WARN_ON(!hsi_port_claimed(cl));
494 err = atomic_notifier_chain_unregister(&port->n_head, &cl->nb);
500 EXPORT_SYMBOL_GPL(hsi_unregister_port_event);
503 * hsi_event -Notifies clients about port events
504 * @port: Port where the event occurred
505 * @event: The event type
507 * Clients should not be concerned about wake line behavior. However, due
508 * to a race condition in HSI HW protocol, clients need to be notified
509 * about wake line changes, so they can implement a workaround for it.
512 * HSI_EVENT_START_RX - Incoming wake line high
513 * HSI_EVENT_STOP_RX - Incoming wake line down
515 * Returns -errno on error, or 0 on success.
517 int hsi_event(struct hsi_port *port, unsigned long event)
519 return atomic_notifier_call_chain(&port->n_head, event, NULL);
521 EXPORT_SYMBOL_GPL(hsi_event);
524 * hsi_get_channel_id_by_name - acquire channel id by channel name
525 * @cl: HSI client, which uses the channel
526 * @name: name the channel is known under
528 * Clients can call this function to get the hsi channel ids similar to
529 * requesting IRQs or GPIOs by name. This function assumes the same
530 * channel configuration is used for RX and TX.
532 * Returns -errno on error or channel id on success.
534 int hsi_get_channel_id_by_name(struct hsi_client *cl, char *name)
538 if (!cl->rx_cfg.channels)
541 for (i = 0; i < cl->rx_cfg.num_channels; i++)
542 if (!strcmp(cl->rx_cfg.channels[i].name, name))
543 return cl->rx_cfg.channels[i].id;
547 EXPORT_SYMBOL_GPL(hsi_get_channel_id_by_name);
549 static int __init hsi_init(void)
551 return bus_register(&hsi_bus_type);
553 postcore_initcall(hsi_init);
555 static void __exit hsi_exit(void)
557 bus_unregister(&hsi_bus_type);
559 module_exit(hsi_exit);
561 MODULE_AUTHOR("Carlos Chinea <carlos.chinea@nokia.com>");
562 MODULE_DESCRIPTION("High-speed Synchronous Serial Interface (HSI) framework");
563 MODULE_LICENSE("GPL v2");