include/linux/mfd/core.h

   1 /*
   2  * drivers/mfd/mfd-core.h
   3  *
   4  * core MFD support
   5  * Copyright (c) 2006 Ian Molton
   6  * Copyright (c) 2007 Dmitry Baryshkov
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  */
  13
  14 #ifndef MFD_CORE_H
  15 #define MFD_CORE_H
  16
  17 #include <linux/platform_device.h>
  18
  19 struct irq_domain;
  20 struct property_entry;
  21
  22 /* Matches ACPI PNP id, either _HID or _CID, or ACPI _ADR */
  23 struct mfd_cell_acpi_match {
  24         const char                      *pnpid;
  25         const unsigned long long        adr;
  26 };
  27
  28 /*
  29  * This struct describes the MFD part ("cell").
  30  * After registration the copy of this structure will become the platform data
  31  * of the resulting platform_device
  32  */
  33 struct mfd_cell {
  34         const char              *name;
  35         int                     id;
  36
  37         /* refcounting for multiple drivers to use a single cell */
  38         atomic_t                *usage_count;
  39         int                     (*enable)(struct platform_device *dev);
  40         int                     (*disable)(struct platform_device *dev);
  41
  42         int                     (*suspend)(struct platform_device *dev);
  43         int                     (*resume)(struct platform_device *dev);
  44
  45         /* platform data passed to the sub devices drivers */
  46         void                    *platform_data;
  47         size_t                  pdata_size;
  48
  49         /* device properties passed to the sub devices drivers */
  50         struct property_entry *properties;
  51
  52         /*
  53          * Device Tree compatible string
  54          * See: Documentation/devicetree/usage-model.txt Chapter 2.2 for details
  55          */
  56         const char              *of_compatible;
  57
  58         /* Matches ACPI */
  59         const struct mfd_cell_acpi_match        *acpi_match;
  60
  61         /*
  62          * These resources can be specified relative to the parent device.
  63          * For accessing hardware you should use resources from the platform dev
  64          */
  65         int                     num_resources;
  66         const struct resource   *resources;
  67
  68         /* don't check for resource conflicts */
  69         bool                    ignore_resource_conflicts;
  70
  71         /*
  72          * Disable runtime PM callbacks for this subdevice - see
  73          * pm_runtime_no_callbacks().
  74          */
  75         bool                    pm_runtime_no_callbacks;
  76
  77         /* A list of regulator supplies that should be mapped to the MFD
  78          * device rather than the child device when requested
  79          */
  80         const char * const      *parent_supplies;
  81         int                     num_parent_supplies;
  82 };
  83
  84 /*
  85  * Convenience functions for clients using shared cells.  Refcounting
  86  * happens automatically, with the cell's enable/disable callbacks
  87  * being called only when a device is first being enabled or no other
  88  * clients are making use of it.
  89  */
  90 extern int mfd_cell_enable(struct platform_device *pdev);
  91 extern int mfd_cell_disable(struct platform_device *pdev);
  92
  93 /*
  94  * "Clone" multiple platform devices for a single cell. This is to be used
  95  * for devices that have multiple users of a cell.  For example, if an mfd
  96  * driver wants the cell "foo" to be used by a GPIO driver, an MTD driver,
  97  * and a platform driver, the following bit of code would be use after first
  98  * calling mfd_add_devices():
  99  *
 100  * const char *fclones[] = { "foo-gpio", "foo-mtd" };
 101  * err = mfd_clone_cells("foo", fclones, ARRAY_SIZE(fclones));
 102  *
 103  * Each driver (MTD, GPIO, and platform driver) would then register
 104  * platform_drivers for "foo-mtd", "foo-gpio", and "foo", respectively.
 105  * The cell's .enable/.disable hooks should be used to deal with hardware
 106  * resource contention.
 107  */
 108 extern int mfd_clone_cell(const char *cell, const char **clones,
 109                 size_t n_clones);
 110
 111 /*
 112  * Given a platform device that's been created by mfd_add_devices(), fetch
 113  * the mfd_cell that created it.
 114  */
 115 static inline const struct mfd_cell *mfd_get_cell(struct platform_device *pdev)
 116 {
 117         return pdev->mfd_cell;
 118 }
 119
 120 extern int mfd_add_devices(struct device *parent, int id,
 121                            const struct mfd_cell *cells, int n_devs,
 122                            struct resource *mem_base,
 123                            int irq_base, struct irq_domain *irq_domain);
 124
 125 static inline int mfd_add_hotplug_devices(struct device *parent,
 126                 const struct mfd_cell *cells, int n_devs)
 127 {
 128         return mfd_add_devices(parent, PLATFORM_DEVID_AUTO, cells, n_devs,
 129                         NULL, 0, NULL);
 130 }
 131
 132 extern void mfd_remove_devices(struct device *parent);
 133
 134 extern int devm_mfd_add_devices(struct device *dev, int id,
 135                                 const struct mfd_cell *cells, int n_devs,
 136                                 struct resource *mem_base,
 137                                 int irq_base, struct irq_domain *irq_domain);
 138 #endif