drivers/mfd/abx500-core.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) 2007-2010 ST-Ericsson
0004  * Register access functions for the ABX500 Mixed Signal IC family.
0005  * Author: Mattias Wallin <mattias.wallin@stericsson.com>
0006  */
0007
0008 #include <linux/list.h>
0009 #include <linux/slab.h>
0010 #include <linux/err.h>
0011 #include <linux/init.h>
0012 #include <linux/export.h>
0013 #include <linux/mfd/abx500.h>
0014
0015 static LIST_HEAD(abx500_list);
0016
0017 struct abx500_device_entry {
0018     struct list_head list;
0019     struct abx500_ops ops;
0020     struct device *dev;
0021 };
0022
0023 static void lookup_ops(struct device *dev, struct abx500_ops **ops)
0024 {
0025     struct abx500_device_entry *dev_entry;
0026
0027     *ops = NULL;
0028     list_for_each_entry(dev_entry, &abx500_list, list) {
0029         if (dev_entry->dev == dev) {
0030             *ops = &dev_entry->ops;
0031             return;
0032         }
0033     }
0034 }
0035
0036 int abx500_register_ops(struct device *dev, struct abx500_ops *ops)
0037 {
0038     struct abx500_device_entry *dev_entry;
0039
0040     dev_entry = devm_kzalloc(dev, sizeof(*dev_entry), GFP_KERNEL);
0041     if (!dev_entry)
0042         return -ENOMEM;
0043
0044     dev_entry->dev = dev;
0045     memcpy(&dev_entry->ops, ops, sizeof(*ops));
0046
0047     list_add_tail(&dev_entry->list, &abx500_list);
0048     return 0;
0049 }
0050 EXPORT_SYMBOL(abx500_register_ops);
0051
0052 void abx500_remove_ops(struct device *dev)
0053 {
0054     struct abx500_device_entry *dev_entry, *tmp;
0055
0056     list_for_each_entry_safe(dev_entry, tmp, &abx500_list, list)
0057         if (dev_entry->dev == dev)
0058             list_del(&dev_entry->list);
0059 }
0060 EXPORT_SYMBOL(abx500_remove_ops);
0061
0062 int abx500_set_register_interruptible(struct device *dev, u8 bank, u8 reg,
0063     u8 value)
0064 {
0065     struct abx500_ops *ops;
0066
0067     lookup_ops(dev->parent, &ops);
0068     if (ops && ops->set_register)
0069         return ops->set_register(dev, bank, reg, value);
0070     else
0071         return -ENOTSUPP;
0072 }
0073 EXPORT_SYMBOL(abx500_set_register_interruptible);
0074
0075 int abx500_get_register_interruptible(struct device *dev, u8 bank, u8 reg,
0076     u8 *value)
0077 {
0078     struct abx500_ops *ops;
0079
0080     lookup_ops(dev->parent, &ops);
0081     if (ops && ops->get_register)
0082         return ops->get_register(dev, bank, reg, value);
0083     else
0084         return -ENOTSUPP;
0085 }
0086 EXPORT_SYMBOL(abx500_get_register_interruptible);
0087
0088 int abx500_get_register_page_interruptible(struct device *dev, u8 bank,
0089     u8 first_reg, u8 *regvals, u8 numregs)
0090 {
0091     struct abx500_ops *ops;
0092
0093     lookup_ops(dev->parent, &ops);
0094     if (ops && ops->get_register_page)
0095         return ops->get_register_page(dev, bank,
0096             first_reg, regvals, numregs);
0097     else
0098         return -ENOTSUPP;
0099 }
0100 EXPORT_SYMBOL(abx500_get_register_page_interruptible);
0101
0102 int abx500_mask_and_set_register_interruptible(struct device *dev, u8 bank,
0103     u8 reg, u8 bitmask, u8 bitvalues)
0104 {
0105     struct abx500_ops *ops;
0106
0107     lookup_ops(dev->parent, &ops);
0108     if (ops && ops->mask_and_set_register)
0109         return ops->mask_and_set_register(dev, bank,
0110             reg, bitmask, bitvalues);
0111     else
0112         return -ENOTSUPP;
0113 }
0114 EXPORT_SYMBOL(abx500_mask_and_set_register_interruptible);
0115
0116 int abx500_get_chip_id(struct device *dev)
0117 {
0118     struct abx500_ops *ops;
0119
0120     lookup_ops(dev->parent, &ops);
0121     if (ops && ops->get_chip_id)
0122         return ops->get_chip_id(dev);
0123     else
0124         return -ENOTSUPP;
0125 }
0126 EXPORT_SYMBOL(abx500_get_chip_id);
0127
0128 int abx500_event_registers_startup_state_get(struct device *dev, u8 *event)
0129 {
0130     struct abx500_ops *ops;
0131
0132     lookup_ops(dev->parent, &ops);
0133     if (ops && ops->event_registers_startup_state_get)
0134         return ops->event_registers_startup_state_get(dev, event);
0135     else
0136         return -ENOTSUPP;
0137 }
0138 EXPORT_SYMBOL(abx500_event_registers_startup_state_get);
0139
0140 int abx500_startup_irq_enabled(struct device *dev, unsigned int irq)
0141 {
0142     struct abx500_ops *ops;
0143
0144     lookup_ops(dev->parent, &ops);
0145     if (ops && ops->startup_irq_enabled)
0146         return ops->startup_irq_enabled(dev, irq);
0147     else
0148         return -ENOTSUPP;
0149 }
0150 EXPORT_SYMBOL(abx500_startup_irq_enabled);