/*! * @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 #include #include #include #include #include #include #include #include #include #include #include #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);