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