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 device_del(&fn->dev); 235 of_node_put(fn->dev.of_node); 236 put_device(&fn->dev); 237 } 238 239 /** 240 * rmi_register_function_handler - register a handler for an RMI function 241 * @handler: RMI handler that should be registered. 242 * @module: pointer to module that implements the handler 243 * @mod_name: name of the module implementing the handler 244 * 245 * This function performs additional setup of RMI function handler and 246 * registers it with the RMI core so that it can be bound to 247 * RMI function devices. 248 */ 249 int __rmi_register_function_handler(struct rmi_function_handler *handler, 250 struct module *owner, 251 const char *mod_name) 252 { 253 struct device_driver *driver = &handler->driver; 254 int error; 255 256 driver->bus = &rmi_bus_type; 257 driver->owner = owner; 258 driver->mod_name = mod_name; 259 driver->probe = rmi_function_probe; 260 driver->remove = rmi_function_remove; 261 262 error = driver_register(&handler->driver); 263 if (error) { 264 pr_err("driver_register() failed for %s, error: %d\n", 265 handler->driver.name, error); 266 return error; 267 } 268 269 return 0; 270 } 271 EXPORT_SYMBOL_GPL(__rmi_register_function_handler); 272 273 /** 274 * rmi_unregister_function_handler - unregister given RMI function handler 275 * @handler: RMI handler that should be unregistered. 276 * 277 * This function unregisters given function handler from RMI core which 278 * causes it to be unbound from the function devices. 279 */ 280 void rmi_unregister_function_handler(struct rmi_function_handler *handler) 281 { 282 driver_unregister(&handler->driver); 283 } 284 EXPORT_SYMBOL_GPL(rmi_unregister_function_handler); 285 286 /* Bus specific stuff */ 287 288 static int rmi_bus_match(struct device *dev, struct device_driver *drv) 289 { 290 bool physical = rmi_is_physical_device(dev); 291 292 /* First see if types are not compatible */ 293 if (physical != rmi_is_physical_driver(drv)) 294 return 0; 295 296 return physical || rmi_function_match(dev, drv); 297 } 298 299 struct bus_type rmi_bus_type = { 300 .match = rmi_bus_match, 301 .name = "rmi4", 302 }; 303 304 static struct rmi_function_handler *fn_handlers[] = { 305 &rmi_f01_handler, 306 #ifdef CONFIG_RMI4_F11 307 &rmi_f11_handler, 308 #endif 309 #ifdef CONFIG_RMI4_F12 310 &rmi_f12_handler, 311 #endif 312 #ifdef CONFIG_RMI4_F30 313 &rmi_f30_handler, 314 #endif 315 }; 316 317 static void __rmi_unregister_function_handlers(int start_idx) 318 { 319 int i; 320 321 for (i = start_idx; i >= 0; i--) 322 rmi_unregister_function_handler(fn_handlers[i]); 323 } 324 325 static void rmi_unregister_function_handlers(void) 326 { 327 __rmi_unregister_function_handlers(ARRAY_SIZE(fn_handlers) - 1); 328 } 329 330 static int rmi_register_function_handlers(void) 331 { 332 int ret; 333 int i; 334 335 for (i = 0; i < ARRAY_SIZE(fn_handlers); i++) { 336 ret = rmi_register_function_handler(fn_handlers[i]); 337 if (ret) { 338 pr_err("%s: error registering the RMI F%02x handler: %d\n", 339 __func__, fn_handlers[i]->func, ret); 340 goto err_unregister_function_handlers; 341 } 342 } 343 344 return 0; 345 346 err_unregister_function_handlers: 347 __rmi_unregister_function_handlers(i - 1); 348 return ret; 349 } 350 351 int rmi_of_property_read_u32(struct device *dev, u32 *result, 352 const char *prop, bool optional) 353 { 354 int retval; 355 u32 val = 0; 356 357 retval = of_property_read_u32(dev->of_node, prop, &val); 358 if (retval && (!optional && retval == -EINVAL)) { 359 dev_err(dev, "Failed to get %s value: %d\n", 360 prop, retval); 361 return retval; 362 } 363 *result = val; 364 365 return 0; 366 } 367 EXPORT_SYMBOL_GPL(rmi_of_property_read_u32); 368 369 static int __init rmi_bus_init(void) 370 { 371 int error; 372 373 error = bus_register(&rmi_bus_type); 374 if (error) { 375 pr_err("%s: error registering the RMI bus: %d\n", 376 __func__, error); 377 return error; 378 } 379 380 error = rmi_register_function_handlers(); 381 if (error) 382 goto err_unregister_bus; 383 384 error = rmi_register_physical_driver(); 385 if (error) { 386 pr_err("%s: error registering the RMI physical driver: %d\n", 387 __func__, error); 388 goto err_unregister_bus; 389 } 390 391 return 0; 392 393 err_unregister_bus: 394 bus_unregister(&rmi_bus_type); 395 return error; 396 } 397 module_init(rmi_bus_init); 398 399 static void __exit rmi_bus_exit(void) 400 { 401 /* 402 * We should only ever get here if all drivers are unloaded, so 403 * all we have to do at this point is unregister ourselves. 404 */ 405 406 rmi_unregister_physical_driver(); 407 rmi_unregister_function_handlers(); 408 bus_unregister(&rmi_bus_type); 409 } 410 module_exit(rmi_bus_exit); 411 412 MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com"); 413 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com"); 414 MODULE_DESCRIPTION("RMI bus"); 415 MODULE_LICENSE("GPL"); 416 MODULE_VERSION(RMI_DRIVER_VERSION); 417