drivers/input/rmi4/rmi_bus.c

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