path: root/drivers/input/sensors/smi130/boschclass.c

/*!
 * @section LICENSE
 * (C) Copyright 2011~2016 Bosch Sensortec GmbH All Rights Reserved
 *
 * (C) Modification Copyright 2018 Robert Bosch Kft  All Rights Reserved
 *
 * This software program is licensed subject to the GNU General
 * Public License (GPL).Version 2,June 1991,
 * available at http://www.fsf.org/copyleft/gpl.html
 *
 * Special: Description of the Software:
 *
 * This software module (hereinafter called "Software") and any
 * information on application-sheets (hereinafter called "Information") is
 * provided free of charge for the sole purpose to support your application
 * work. 
 *
 * As such, the Software is merely an experimental software, not tested for
 * safety in the field and only intended for inspiration for further development 
 * and testing. Any usage in a safety-relevant field of use (like automotive,
 * seafaring, spacefaring, industrial plants etc.) was not intended, so there are
 * no precautions for such usage incorporated in the Software.
 * 
 * The Software is specifically designed for the exclusive use for Bosch
 * Sensortec products by personnel who have special experience and training. Do
 * not use this Software if you do not have the proper experience or training.
 * 
 * This Software package is provided as is and without any expressed or
 * implied warranties, including without limitation, the implied warranties of
 * merchantability and fitness for a particular purpose.
 * 
 * Bosch Sensortec and their representatives and agents deny any liability for
 * the functional impairment of this Software in terms of fitness, performance
 * and safety. Bosch Sensortec and their representatives and agents shall not be
 * liable for any direct or indirect damages or injury, except as otherwise
 * stipulated in mandatory applicable law.
 * The Information provided is believed to be accurate and reliable. Bosch
 * Sensortec assumes no responsibility for the consequences of use of such
 * Information nor for any infringement of patents or other rights of third
 * parties which may result from its use.
 * 
 *------------------------------------------------------------------------------
 * The following Product Disclaimer does not apply to the BSX4-HAL-4.1NoFusion Software 
 * which is licensed under the Apache License, Version 2.0 as stated above.  
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Product Disclaimer
 *
 * Common:
 *
 * Assessment of Products Returned from Field
 *
 * Returned products are considered good if they fulfill the specifications / 
 * test data for 0-mileage and field listed in this document.
 *
 * Engineering Samples
 * 
 * Engineering samples are marked with (e) or (E). Samples may vary from the
 * valid technical specifications of the series product contained in this
 * data sheet. Therefore, they are not intended or fit for resale to
 * third parties or for use in end products. Their sole purpose is internal
 * client testing. The testing of an engineering sample may in no way replace
 * the testing of a series product. Bosch assumes no liability for the use
 * of engineering samples. The purchaser shall indemnify Bosch from all claims
 * arising from the use of engineering samples.
 *
 * Intended use
 *
 * Provided that SMI130 is used within the conditions (environment, application,
 * installation, loads) as described in this TCD and the corresponding
 * agreed upon documents, Bosch ensures that the product complies with
 * the agreed properties. Agreements beyond this require
 * the written approval by Bosch. The product is considered fit for the intended
 * use when the product successfully has passed the tests
 * in accordance with the TCD and agreed upon documents.
 *
 * It is the responsibility of the customer to ensure the proper application
 * of the product in the overall system/vehicle.
 *
 * Bosch does not assume any responsibility for changes to the environment
 * of the product that deviate from the TCD and the agreed upon documents 
 * as well as all applications not released by Bosch
  *
 * The resale and/or use of products are at the purchaser’s own risk and 
 * responsibility. The examination and testing of the SMI130 
 * is the sole responsibility of the purchaser.
 *
 * The purchaser shall indemnify Bosch from all third party claims 
 * arising from any product use not covered by the parameters of 
 * this product data sheet or not approved by Bosch and reimburse Bosch 
 * for all costs and damages in connection with such claims.
 *
 * The purchaser must monitor the market for the purchased products,
 * particularly with regard to product safety, and inform Bosch without delay
 * of all security relevant incidents.
 *
 * Application Examples and Hints
 *
 * With respect to any application examples, advice, normal values
 * and/or any information regarding the application of the device,
 * Bosch hereby disclaims any and all warranties and liabilities of any kind,
 * including without limitation warranties of
 * non-infringement of intellectual property rights or copyrights
 * of any third party.
 * The information given in this document shall in no event be regarded 
 * as a guarantee of conditions or characteristics. They are provided
 * for illustrative purposes only and no evaluation regarding infringement
 * of intellectual property rights or copyrights or regarding functionality,
 * performance or error has been made.
 *
 * @filename boschclass.c
 * @date     2015/11/17 13:44
 * @Modification Date 2018/08/28 18:20
 * @id       "836294d"
 * @version  1.5.9
 *
 * @brief    
 */
#include <linux/init.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/random.h>
#include <linux/sched.h>
#include <linux/seq_file.h>
#include <linux/poll.h>
#include <linux/mutex.h>
#include <linux/rcupdate.h>
#include <linux/compiler.h>
#include <linux/compat.h>
#include "boschclass.h"
#include "bs_log.h"

static LIST_HEAD(bosch_dev_list);

/*
 * bosch_mutex protects access to both bosch_dev_list and input_handler_list.
 * This also causes bosch_[un]register_device and bosch_[un]register_handler
 * be mutually exclusive which simplifies locking in drivers implementing
 * input handlers.
 */
static DEFINE_MUTEX(bosch_mutex);


static void bosch_dev_release(struct device *device)
{
	struct bosch_dev *dev = to_bosch_dev(device);
	if (NULL != dev)
		kfree(dev);
	module_put(THIS_MODULE);
}


#ifdef CONFIG_PM
static int bosch_dev_suspend(struct device *dev)
{
	return 0;
}

static int bosch_dev_resume(struct device *dev)
{
	return 0;
}

static const struct dev_pm_ops bosch_dev_pm_ops = {
	.suspend    = bosch_dev_suspend,
	.resume     = bosch_dev_resume,
	.poweroff   = bosch_dev_suspend,
	.restore    = bosch_dev_resume,
};
#endif /* CONFIG_PM */

static const struct attribute_group *bosch_dev_attr_groups[] = {
	NULL
};

static struct device_type bosch_dev_type = {
	.groups      = bosch_dev_attr_groups,
	.release = bosch_dev_release,
#ifdef CONFIG_PM
	.pm      = &bosch_dev_pm_ops,
#endif
};



static char *bosch_devnode(struct device *dev, mode_t *mode)
{
	return kasprintf(GFP_KERNEL, "%s", dev_name(dev));
}

struct class bosch_class = {
	.name        = "bosch",
	.owner       = THIS_MODULE,
	.devnode     = (void*)bosch_devnode,
	.dev_release = bosch_dev_release,
};
EXPORT_SYMBOL_GPL(bosch_class);

/**
 * bosch_allocate_device - allocate memory for new input device
 *
 * Returns prepared struct bosch_dev or NULL.
 *
 * NOTE: Use bosch_free_device() to free devices that have not been
 * registered; bosch_unregister_device() should be used for already
 * registered devices.
 */
struct bosch_dev *bosch_allocate_device(void)
{
	struct bosch_dev *dev;

	dev = kzalloc(sizeof(struct bosch_dev), GFP_KERNEL);
	if (dev) {
		dev->dev.type = &bosch_dev_type;
		dev->dev.class = &bosch_class;
		device_initialize(&dev->dev);
		mutex_init(&dev->mutex);
		INIT_LIST_HEAD(&dev->node);
		__module_get(THIS_MODULE);
	}
	return dev;
}
EXPORT_SYMBOL(bosch_allocate_device);



/**
 * bosch_free_device - free memory occupied by bosch_dev structure
 * @dev: input device to free
 *
 * This function should only be used if bosch_register_device()
 * was not called yet or if it failed. Once device was registered
 * use bosch_unregister_device() and memory will be freed once last
 * reference to the device is dropped.
 *
 * Device should be allocated by bosch_allocate_device().
 *
 * NOTE: If there are references to the input device then memory
 * will not be freed until last reference is dropped.
 */
void bosch_free_device(struct bosch_dev *dev)
{
	if (dev)
		bosch_put_device(dev);
}
EXPORT_SYMBOL(bosch_free_device);

/**
 * bosch_register_device - register device with input core
 * @dev: device to be registered
 *
 * This function registers device with input core. The device must be
 * allocated with bosch_allocate_device() and all it's capabilities
 * set up before registering.
 * If function fails the device must be freed with bosch_free_device().
 * Once device has been successfully registered it can be unregistered
 * with bosch_unregister_device(); bosch_free_device() should not be
 * called in this case.
 */
int bosch_register_device(struct bosch_dev *dev)
{
	const char *path;
	int error;


	/*
	 * If delay and period are pre-set by the driver, then autorepeating
	 * is handled by the driver itself and we don't do it in input.c.
	 */
	dev_set_name(&dev->dev, dev->name);

	error = device_add(&dev->dev);
	if (error)
		return error;

	path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
	PINFO("%s as %s\n",
			dev->name ? dev->name : "Unspecified device",
			path ? path : "N/A");
	kfree(path);
	error = mutex_lock_interruptible(&bosch_mutex);
	if (error) {
		device_del(&dev->dev);
		return error;
	}

	list_add_tail(&dev->node, &bosch_dev_list);

	mutex_unlock(&bosch_mutex);
	return 0;
}
EXPORT_SYMBOL(bosch_register_device);

/**
 * bosch_unregister_device - unregister previously registered device
 * @dev: device to be unregistered
 *
 * This function unregisters an input device. Once device is unregistered
 * the caller should not try to access it as it may get freed at any moment.
 */
void bosch_unregister_device(struct bosch_dev *dev)
{
	int ret = 0;
	ret = mutex_lock_interruptible(&bosch_mutex);
	if(ret){
		return;
	}

	list_del_init(&dev->node);
	mutex_unlock(&bosch_mutex);
	device_unregister(&dev->dev);
}
EXPORT_SYMBOL(bosch_unregister_device);

static int __init bosch_init(void)
{
	int err;
	/*bosch class register*/
	err = class_register(&bosch_class);
	if (err) {
		pr_err("unable to register bosch_dev class\n");
		return err;
	}
	return err;
}

static void __exit bosch_exit(void)
{
	/*bosch class*/
	class_unregister(&bosch_class);
}

/*subsys_initcall(bosch_init);*/

MODULE_AUTHOR("contact@bosch-sensortec.com");
MODULE_DESCRIPTION("BST CLASS CORE");
MODULE_LICENSE("GPL V2");

module_init(bosch_init);
module_exit(bosch_exit);