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 236 if (fn->dev.of_node) 237 of_node_put(fn->dev.of_node); 238 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(&handler->driver); 266 if (error) { 267 pr_err("driver_register() failed for %s, error: %d\n", 268 handler->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_F11 310 &rmi_f11_handler, 311 #endif 312 #ifdef CONFIG_RMI4_F12 313 &rmi_f12_handler, 314 #endif 315 #ifdef CONFIG_RMI4_F30 316 &rmi_f30_handler, 317 #endif 318 }; 319 320 static void __rmi_unregister_function_handlers(int start_idx) 321 { 322 int i; 323 324 for (i = start_idx; i >= 0; i--) 325 rmi_unregister_function_handler(fn_handlers[i]); 326 } 327 328 static void rmi_unregister_function_handlers(void) 329 { 330 __rmi_unregister_function_handlers(ARRAY_SIZE(fn_handlers) - 1); 331 } 332 333 static int rmi_register_function_handlers(void) 334 { 335 int ret; 336 int i; 337 338 for (i = 0; i < ARRAY_SIZE(fn_handlers); i++) { 339 ret = rmi_register_function_handler(fn_handlers[i]); 340 if (ret) { 341 pr_err("%s: error registering the RMI F%02x handler: %d\n", 342 __func__, fn_handlers[i]->func, ret); 343 goto err_unregister_function_handlers; 344 } 345 } 346 347 return 0; 348 349 err_unregister_function_handlers: 350 __rmi_unregister_function_handlers(i - 1); 351 return ret; 352 } 353 354 int rmi_of_property_read_u32(struct device *dev, u32 *result, 355 const char *prop, bool optional) 356 { 357 int retval; 358 u32 val = 0; 359 360 retval = of_property_read_u32(dev->of_node, prop, &val); 361 if (retval && (!optional && retval == -EINVAL)) { 362 dev_err(dev, "Failed to get %s value: %d\n", 363 prop, retval); 364 return retval; 365 } 366 *result = val; 367 368 return 0; 369 } 370 EXPORT_SYMBOL_GPL(rmi_of_property_read_u32); 371 372 static int __init rmi_bus_init(void) 373 { 374 int error; 375 376 error = bus_register(&rmi_bus_type); 377 if (error) { 378 pr_err("%s: error registering the RMI bus: %d\n", 379 __func__, error); 380 return error; 381 } 382 383 error = rmi_register_function_handlers(); 384 if (error) 385 goto err_unregister_bus; 386 387 error = rmi_register_physical_driver(); 388 if (error) { 389 pr_err("%s: error registering the RMI physical driver: %d\n", 390 __func__, error); 391 goto err_unregister_bus; 392 } 393 394 return 0; 395 396 err_unregister_bus: 397 bus_unregister(&rmi_bus_type); 398 return error; 399 } 400 module_init(rmi_bus_init); 401 402 static void __exit rmi_bus_exit(void) 403 { 404 /* 405 * We should only ever get here if all drivers are unloaded, so 406 * all we have to do at this point is unregister ourselves. 407 */ 408 409 rmi_unregister_physical_driver(); 410 rmi_unregister_function_handlers(); 411 bus_unregister(&rmi_bus_type); 412 } 413 module_exit(rmi_bus_exit); 414 415 MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com"); 416 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com"); 417 MODULE_DESCRIPTION("RMI bus"); 418 MODULE_LICENSE("GPL"); 419 MODULE_VERSION(RMI_DRIVER_VERSION); 420