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