mfd: Fetch cell pointer from platform_device->mfd_cell

[pandora-kernel.git] / include / linux / mfd / core.h

diff --git a/include/linux/mfd/core.h b/include/linux/mfd/core.h
index f317fe4..aef2330 100644 (file)
--- a/include/linux/mfd/core.h
+++ b/include/linux/mfd/core.h
@@ -25,14 +25,14 @@ struct mfd_cell {
        const char              *name;
        int                     id;
 
+       /* refcounting for multiple drivers to use a single cell */
+       atomic_t                *usage_count;
        int                     (*enable)(struct platform_device *dev);
        int                     (*disable)(struct platform_device *dev);
+
        int                     (*suspend)(struct platform_device *dev);
        int                     (*resume)(struct platform_device *dev);
 
-       /* driver-specific data for MFD-aware "cell" drivers */
-       void                    *driver_data;
-
        /* mfd_data can be used to pass data to client drivers */
        void                    *mfd_data;
 
@@ -53,26 +53,62 @@ struct mfd_cell {
        bool                    pm_runtime_no_callbacks;
 };
 
+/*
+ * Convenience functions for clients using shared cells.  Refcounting
+ * happens automatically, with the cell's enable/disable callbacks
+ * being called only when a device is first being enabled or no other
+ * clients are making use of it.
+ */
+extern int mfd_cell_enable(struct platform_device *pdev);
+extern int mfd_cell_disable(struct platform_device *pdev);
+
+/*
+ * "Clone" multiple platform devices for a single cell. This is to be used
+ * for devices that have multiple users of a cell.  For example, if an mfd
+ * driver wants the cell "foo" to be used by a GPIO driver, an MTD driver,
+ * and a platform driver, the following bit of code would be use after first
+ * calling mfd_add_devices():
+ *
+ * const char *fclones[] = { "foo-gpio", "foo-mtd" };
+ * err = mfd_clone_cells("foo", fclones, ARRAY_SIZE(fclones));
+ *
+ * Each driver (MTD, GPIO, and platform driver) would then register
+ * platform_drivers for "foo-mtd", "foo-gpio", and "foo", respectively.
+ * The cell's .enable/.disable hooks should be used to deal with hardware
+ * resource contention.
+ */
+extern int mfd_clone_cell(const char *cell, const char **clones,
+               size_t n_clones);
+
 /*
  * Given a platform device that's been created by mfd_add_devices(), fetch
  * the mfd_cell that created it.
  */
 static inline const struct mfd_cell *mfd_get_cell(struct platform_device *pdev)
 {
-       return pdev->dev.platform_data;
+       return pdev->mfd_cell;
 }
 
 /*
  * Given a platform device that's been created by mfd_add_devices(), fetch
  * the .mfd_data entry from the mfd_cell that created it.
+ * Otherwise just return the platform_data pointer.
+ * This maintains compatibility with platform drivers whose devices aren't
+ * created by the mfd layer, and expect platform_data to contain what would've
+ * otherwise been in mfd_data.
  */
 static inline void *mfd_get_data(struct platform_device *pdev)
 {
-       return mfd_get_cell(pdev)->mfd_data;
+       const struct mfd_cell *cell = mfd_get_cell(pdev);
+
+       if (cell)
+               return cell->mfd_data;
+       else
+               return pdev->dev.platform_data;
 }
 
 extern int mfd_add_devices(struct device *parent, int id,
-                          const struct mfd_cell *cells, int n_devs,
+                          struct mfd_cell *cells, int n_devs,
                           struct resource *mem_base,
                           int irq_base);