linux/drivers/input/rmi4/rmi_bus.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2011-2016 Synaptics Incorporated
 * Copyright (c) 2011 Unixphere
 */

#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/irq.h>
#include <linux/irqdomain.h>
#include <linux/list.h>
#include <linux/pm.h>
#include <linux/rmi.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/of.h>
#include "rmi_bus.h"
#include "rmi_driver.h"

static int debug_flags;
module_param(debug_flags, int, 0644);
MODULE_PARM_DESC(…) …;

void rmi_dbg(int flags, struct device *dev, const char *fmt, ...)
{ … }
EXPORT_SYMBOL_GPL(…);

/*
 * RMI Physical devices
 *
 * Physical RMI device consists of several functions serving particular
 * purpose. For example F11 is a 2D touch sensor while F01 is a generic
 * function present in every RMI device.
 */

static void rmi_release_device(struct device *dev)
{ … }

static const struct device_type rmi_device_type = …;

bool rmi_is_physical_device(struct device *dev)
{ … }

/**
 * rmi_register_transport_device - register a transport device connection
 * on the RMI bus.  Transport drivers provide communication from the devices
 * on a bus (such as SPI, I2C, and so on) to the RMI4 sensor.
 *
 * @xport: the transport device to register
 */
int rmi_register_transport_device(struct rmi_transport_dev *xport)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * rmi_unregister_transport_device - unregister a transport device connection
 * @xport: the transport driver to unregister
 *
 */
void rmi_unregister_transport_device(struct rmi_transport_dev *xport)
{ … }
EXPORT_SYMBOL(…);


/* Function specific stuff */

static void rmi_release_function(struct device *dev)
{ … }

static const struct device_type rmi_function_type = …;

bool rmi_is_function_device(struct device *dev)
{ … }

static int rmi_function_match(struct device *dev, const struct device_driver *drv)
{ … }

#ifdef CONFIG_OF
static void rmi_function_of_probe(struct rmi_function *fn)
{ … }
#else
static inline void rmi_function_of_probe(struct rmi_function *fn)
{}
#endif

static struct irq_chip rmi_irq_chip = …;

static int rmi_create_function_irq(struct rmi_function *fn,
				   struct rmi_function_handler *handler)
{ … }

static int rmi_function_probe(struct device *dev)
{ … }

static int rmi_function_remove(struct device *dev)
{ … }

int rmi_register_function(struct rmi_function *fn)
{ … }

void rmi_unregister_function(struct rmi_function *fn)
{ … }

/**
 * __rmi_register_function_handler - register a handler for an RMI function
 * @handler: RMI handler that should be registered.
 * @owner: pointer to module that implements the handler
 * @mod_name: name of the module implementing the handler
 *
 * This function performs additional setup of RMI function handler and
 * registers it with the RMI core so that it can be bound to
 * RMI function devices.
 */
int __rmi_register_function_handler(struct rmi_function_handler *handler,
				     struct module *owner,
				     const char *mod_name)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * rmi_unregister_function_handler - unregister given RMI function handler
 * @handler: RMI handler that should be unregistered.
 *
 * This function unregisters given function handler from RMI core which
 * causes it to be unbound from the function devices.
 */
void rmi_unregister_function_handler(struct rmi_function_handler *handler)
{ … }
EXPORT_SYMBOL_GPL(…);

/* Bus specific stuff */

static int rmi_bus_match(struct device *dev, const struct device_driver *drv)
{ … }

const struct bus_type rmi_bus_type = …;

static struct rmi_function_handler *fn_handlers[] = …;

static void __rmi_unregister_function_handlers(int start_idx)
{ … }

static void rmi_unregister_function_handlers(void)
{ … }

static int rmi_register_function_handlers(void)
{ … }

int rmi_of_property_read_u32(struct device *dev, u32 *result,
				const char *prop, bool optional)
{ … }
EXPORT_SYMBOL_GPL(…);

static int __init rmi_bus_init(void)
{ … }
module_init(…) …;

static void __exit rmi_bus_exit(void)
{ … }
module_exit(rmi_bus_exit);

MODULE_AUTHOR(…) …;
MODULE_AUTHOR(…) …;
MODULE_DESCRIPTION(…) …;
MODULE_LICENSE(…) …;