drivers/input/rmi4/rmi_bus.c

   1 /*
   2  * Copyright (c) 2011-2016 Synaptics Incorporated
   3  * Copyright (c) 2011 Unixphere
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 as published by
   7  * the Free Software Foundation.
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/device.h>
  12 #include <linux/irq.h>
  13 #include <linux/irqdomain.h>
  14 #include <linux/list.h>
  15 #include <linux/pm.h>
  16 #include <linux/rmi.h>
  17 #include <linux/slab.h>
  18 #include <linux/types.h>
  19 #include <linux/of.h>
  20 #include "rmi_bus.h"
  21 #include "rmi_driver.h"
  22
  23 static int debug_flags;
  24 module_param(debug_flags, int, 0644);
  25 MODULE_PARM_DESC(debug_flags, "control debugging information");
  26
  27 void rmi_dbg(int flags, struct device *dev, const char *fmt, ...)
  28 {
  29         struct va_format vaf;
  30         va_list args;
  31
  32         if (flags & debug_flags) {
  33                 va_start(args, fmt);
  34
  35                 vaf.fmt = fmt;
  36                 vaf.va = &args;
  37
  38                 dev_printk(KERN_DEBUG, dev, "%pV", &vaf);
  39
  40                 va_end(args);
  41         }
  42 }
  43 EXPORT_SYMBOL_GPL(rmi_dbg);
  44
  45 /*
  46  * RMI Physical devices
  47  *
  48  * Physical RMI device consists of several functions serving particular
  49  * purpose. For example F11 is a 2D touch sensor while F01 is a generic
  50  * function present in every RMI device.
  51  */
  52
  53 static void rmi_release_device(struct device *dev)
  54 {
  55         struct rmi_device *rmi_dev = to_rmi_device(dev);
  56
  57         kfree(rmi_dev);
  58 }
  59
  60 static const struct device_type rmi_device_type = {
  61         .name           = "rmi4_sensor",
  62         .release        = rmi_release_device,
  63 };
  64
  65 bool rmi_is_physical_device(struct device *dev)
  66 {
  67         return dev->type == &rmi_device_type;
  68 }
  69
  70 /**
  71  * rmi_register_transport_device - register a transport device connection
  72  * on the RMI bus.  Transport drivers provide communication from the devices
  73  * on a bus (such as SPI, I2C, and so on) to the RMI4 sensor.
  74  *
  75  * @xport: the transport device to register
  76  */
  77 int rmi_register_transport_device(struct rmi_transport_dev *xport)
  78 {
  79         static atomic_t transport_device_count = ATOMIC_INIT(0);
  80         struct rmi_device *rmi_dev;
  81         int error;
  82
  83         rmi_dev = kzalloc(sizeof(struct rmi_device), GFP_KERNEL);
  84         if (!rmi_dev)
  85                 return -ENOMEM;
  86
  87         device_initialize(&rmi_dev->dev);
  88
  89         rmi_dev->xport = xport;
  90         rmi_dev->number = atomic_inc_return(&transport_device_count) - 1;
  91
  92         dev_set_name(&rmi_dev->dev, "rmi4-%02d", rmi_dev->number);
  93
  94         rmi_dev->dev.bus = &rmi_bus_type;
  95         rmi_dev->dev.type = &rmi_device_type;
  96
  97         xport->rmi_dev = rmi_dev;
  98
  99         error = device_add(&rmi_dev->dev);
 100         if (error)
 101                 goto err_put_device;
 102
 103         rmi_dbg(RMI_DEBUG_CORE, xport->dev,
 104                 "%s: Registered %s as %s.\n", __func__,
 105                 dev_name(rmi_dev->xport->dev), dev_name(&rmi_dev->dev));
 106
 107         return 0;
 108
 109 err_put_device:
 110         put_device(&rmi_dev->dev);
 111         return error;
 112 }
 113 EXPORT_SYMBOL_GPL(rmi_register_transport_device);
 114
 115 /**
 116  * rmi_unregister_transport_device - unregister a transport device connection
 117  * @xport: the transport driver to unregister
 118  *
 119  */
 120 void rmi_unregister_transport_device(struct rmi_transport_dev *xport)
 121 {
 122         struct rmi_device *rmi_dev = xport->rmi_dev;
 123
 124         device_del(&rmi_dev->dev);
 125         put_device(&rmi_dev->dev);
 126 }
 127 EXPORT_SYMBOL(rmi_unregister_transport_device);
 128
 129
 130 /* Function specific stuff */
 131
 132 static void rmi_release_function(struct device *dev)
 133 {
 134         struct rmi_function *fn = to_rmi_function(dev);
 135
 136         kfree(fn);
 137 }
 138
 139 static const struct device_type rmi_function_type = {
 140         .name           = "rmi4_function",
 141         .release        = rmi_release_function,
 142 };
 143
 144 bool rmi_is_function_device(struct device *dev)
 145 {
 146         return dev->type == &rmi_function_type;
 147 }
 148
 149 static int rmi_function_match(struct device *dev, struct device_driver *drv)
 150 {
 151         struct rmi_function_handler *handler = to_rmi_function_handler(drv);
 152         struct rmi_function *fn = to_rmi_function(dev);
 153
 154         return fn->fd.function_number == handler->func;
 155 }
 156
 157 #ifdef CONFIG_OF
 158 static void rmi_function_of_probe(struct rmi_function *fn)
 159 {
 160         char of_name[9];
 161         struct device_node *node = fn->rmi_dev->xport->dev->of_node;
 162
 163         snprintf(of_name, sizeof(of_name), "rmi4-f%02x",
 164                 fn->fd.function_number);
 165         fn->dev.of_node = of_get_child_by_name(node, of_name);
 166 }
 167 #else
 168 static inline void rmi_function_of_probe(struct rmi_function *fn)
 169 {}
 170 #endif
 171
 172 static struct irq_chip rmi_irq_chip = {
 173         .name = "rmi4",
 174 };
 175
 176 static int rmi_create_function_irq(struct rmi_function *fn,
 177                                    struct rmi_function_handler *handler)
 178 {
 179         struct rmi_driver_data *drvdata = dev_get_drvdata(&fn->rmi_dev->dev);
 180         int i, error;
 181
 182         for (i = 0; i < fn->num_of_irqs; i++) {
 183                 set_bit(fn->irq_pos + i, fn->irq_mask);
 184
 185                 fn->irq[i] = irq_create_mapping(drvdata->irqdomain,
 186                                                 fn->irq_pos + i);
 187
 188                 irq_set_chip_data(fn->irq[i], fn);
 189                 irq_set_chip_and_handler(fn->irq[i], &rmi_irq_chip,
 190                                          handle_simple_irq);
 191                 irq_set_nested_thread(fn->irq[i], 1);
 192
 193                 error = devm_request_threaded_irq(&fn->dev, fn->irq[i], NULL,
 194                                         handler->attention, IRQF_ONESHOT,
 195                                         dev_name(&fn->dev), fn);
 196                 if (error) {
 197                         dev_err(&fn->dev, "Error %d registering IRQ\n", error);
 198                         return error;
 199                 }
 200         }
 201
 202         return 0;
 203 }
 204
 205 static int rmi_function_probe(struct device *dev)
 206 {
 207         struct rmi_function *fn = to_rmi_function(dev);
 208         struct rmi_function_handler *handler =
 209                                         to_rmi_function_handler(dev->driver);
 210         int error;
 211
 212         rmi_function_of_probe(fn);
 213
 214         if (handler->probe) {
 215                 error = handler->probe(fn);
 216                 if (error)
 217                         return error;
 218         }
 219
 220         if (fn->num_of_irqs && handler->attention) {
 221                 error = rmi_create_function_irq(fn, handler);
 222                 if (error)
 223                         return error;
 224         }
 225
 226         return 0;
 227 }
 228
 229 static int rmi_function_remove(struct device *dev)
 230 {
 231         struct rmi_function *fn = to_rmi_function(dev);
 232         struct rmi_function_handler *handler =
 233                                         to_rmi_function_handler(dev->driver);
 234
 235         if (handler->remove)
 236                 handler->remove(fn);
 237
 238         return 0;
 239 }
 240
 241 int rmi_register_function(struct rmi_function *fn)
 242 {
 243         struct rmi_device *rmi_dev = fn->rmi_dev;
 244         int error;
 245
 246         device_initialize(&fn->dev);
 247
 248         dev_set_name(&fn->dev, "%s.fn%02x",
 249                      dev_name(&rmi_dev->dev), fn->fd.function_number);
 250
 251         fn->dev.parent = &rmi_dev->dev;
 252         fn->dev.type = &rmi_function_type;
 253         fn->dev.bus = &rmi_bus_type;
 254
 255         error = device_add(&fn->dev);
 256         if (error) {
 257                 dev_err(&rmi_dev->dev,
 258                         "Failed device_register function device %s\n",
 259                         dev_name(&fn->dev));
 260                 goto err_put_device;
 261         }
 262
 263         rmi_dbg(RMI_DEBUG_CORE, &rmi_dev->dev, "Registered F%02X.\n",
 264                         fn->fd.function_number);
 265
 266         return 0;
 267
 268 err_put_device:
 269         put_device(&fn->dev);
 270         return error;
 271 }
 272
 273 void rmi_unregister_function(struct rmi_function *fn)
 274 {
 275         int i;
 276
 277         rmi_dbg(RMI_DEBUG_CORE, &fn->dev, "Unregistering F%02X.\n",
 278                         fn->fd.function_number);
 279
 280         device_del(&fn->dev);
 281         of_node_put(fn->dev.of_node);
 282         put_device(&fn->dev);
 283
 284         for (i = 0; i < fn->num_of_irqs; i++)
 285                 irq_dispose_mapping(fn->irq[i]);
 286
 287 }
 288
 289 /**
 290  * rmi_register_function_handler - register a handler for an RMI function
 291  * @handler: RMI handler that should be registered.
 292  * @module: pointer to module that implements the handler
 293  * @mod_name: name of the module implementing the handler
 294  *
 295  * This function performs additional setup of RMI function handler and
 296  * registers it with the RMI core so that it can be bound to
 297  * RMI function devices.
 298  */
 299 int __rmi_register_function_handler(struct rmi_function_handler *handler,
 300                                      struct module *owner,
 301                                      const char *mod_name)
 302 {
 303         struct device_driver *driver = &handler->driver;
 304         int error;
 305
 306         driver->bus = &rmi_bus_type;
 307         driver->owner = owner;
 308         driver->mod_name = mod_name;
 309         driver->probe = rmi_function_probe;
 310         driver->remove = rmi_function_remove;
 311
 312         error = driver_register(driver);
 313         if (error) {
 314                 pr_err("driver_register() failed for %s, error: %d\n",
 315                         driver->name, error);
 316                 return error;
 317         }
 318
 319         return 0;
 320 }
 321 EXPORT_SYMBOL_GPL(__rmi_register_function_handler);
 322
 323 /**
 324  * rmi_unregister_function_handler - unregister given RMI function handler
 325  * @handler: RMI handler that should be unregistered.
 326  *
 327  * This function unregisters given function handler from RMI core which
 328  * causes it to be unbound from the function devices.
 329  */
 330 void rmi_unregister_function_handler(struct rmi_function_handler *handler)
 331 {
 332         driver_unregister(&handler->driver);
 333 }
 334 EXPORT_SYMBOL_GPL(rmi_unregister_function_handler);
 335
 336 /* Bus specific stuff */
 337
 338 static int rmi_bus_match(struct device *dev, struct device_driver *drv)
 339 {
 340         bool physical = rmi_is_physical_device(dev);
 341
 342         /* First see if types are not compatible */
 343         if (physical != rmi_is_physical_driver(drv))
 344                 return 0;
 345
 346         return physical || rmi_function_match(dev, drv);
 347 }
 348
 349 struct bus_type rmi_bus_type = {
 350         .match          = rmi_bus_match,
 351         .name           = "rmi4",
 352 };
 353
 354 static struct rmi_function_handler *fn_handlers[] = {
 355         &rmi_f01_handler,
 356 #ifdef CONFIG_RMI4_F03
 357         &rmi_f03_handler,
 358 #endif
 359 #ifdef CONFIG_RMI4_F11
 360         &rmi_f11_handler,
 361 #endif
 362 #ifdef CONFIG_RMI4_F12
 363         &rmi_f12_handler,
 364 #endif
 365 #ifdef CONFIG_RMI4_F30
 366         &rmi_f30_handler,
 367 #endif
 368 #ifdef CONFIG_RMI4_F34
 369         &rmi_f34_handler,
 370 #endif
 371 #ifdef CONFIG_RMI4_F54
 372         &rmi_f54_handler,
 373 #endif
 374 #ifdef CONFIG_RMI4_F55
 375         &rmi_f55_handler,
 376 #endif
 377 };
 378
 379 static void __rmi_unregister_function_handlers(int start_idx)
 380 {
 381         int i;
 382
 383         for (i = start_idx; i >= 0; i--)
 384                 rmi_unregister_function_handler(fn_handlers[i]);
 385 }
 386
 387 static void rmi_unregister_function_handlers(void)
 388 {
 389         __rmi_unregister_function_handlers(ARRAY_SIZE(fn_handlers) - 1);
 390 }
 391
 392 static int rmi_register_function_handlers(void)
 393 {
 394         int ret;
 395         int i;
 396
 397         for (i = 0; i < ARRAY_SIZE(fn_handlers); i++)   {
 398                 ret = rmi_register_function_handler(fn_handlers[i]);
 399                 if (ret) {
 400                         pr_err("%s: error registering the RMI F%02x handler: %d\n",
 401                                 __func__, fn_handlers[i]->func, ret);
 402                         goto err_unregister_function_handlers;
 403                 }
 404         }
 405
 406         return 0;
 407
 408 err_unregister_function_handlers:
 409         __rmi_unregister_function_handlers(i - 1);
 410         return ret;
 411 }
 412
 413 int rmi_of_property_read_u32(struct device *dev, u32 *result,
 414                                 const char *prop, bool optional)
 415 {
 416         int retval;
 417         u32 val = 0;
 418
 419         retval = of_property_read_u32(dev->of_node, prop, &val);
 420         if (retval && (!optional && retval == -EINVAL)) {
 421                 dev_err(dev, "Failed to get %s value: %d\n",
 422                         prop, retval);
 423                 return retval;
 424         }
 425         *result = val;
 426
 427         return 0;
 428 }
 429 EXPORT_SYMBOL_GPL(rmi_of_property_read_u32);
 430
 431 static int __init rmi_bus_init(void)
 432 {
 433         int error;
 434
 435         error = bus_register(&rmi_bus_type);
 436         if (error) {
 437                 pr_err("%s: error registering the RMI bus: %d\n",
 438                         __func__, error);
 439                 return error;
 440         }
 441
 442         error = rmi_register_function_handlers();
 443         if (error)
 444                 goto err_unregister_bus;
 445
 446         error = rmi_register_physical_driver();
 447         if (error) {
 448                 pr_err("%s: error registering the RMI physical driver: %d\n",
 449                         __func__, error);
 450                 goto err_unregister_bus;
 451         }
 452
 453         return 0;
 454
 455 err_unregister_bus:
 456         bus_unregister(&rmi_bus_type);
 457         return error;
 458 }
 459 module_init(rmi_bus_init);
 460
 461 static void __exit rmi_bus_exit(void)
 462 {
 463         /*
 464          * We should only ever get here if all drivers are unloaded, so
 465          * all we have to do at this point is unregister ourselves.
 466          */
 467
 468         rmi_unregister_physical_driver();
 469         rmi_unregister_function_handlers();
 470         bus_unregister(&rmi_bus_type);
 471 }
 472 module_exit(rmi_bus_exit);
 473
 474 MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com");
 475 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com");
 476 MODULE_DESCRIPTION("RMI bus");
 477 MODULE_LICENSE("GPL");