linux/include/linux/platform_device.h
<<
>>
Prefs
   1/*
   2 * platform_device.h - generic, centralized driver model
   3 *
   4 * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
   5 *
   6 * This file is released under the GPLv2
   7 *
   8 * See Documentation/driver-model/ for more information.
   9 */
  10
  11#ifndef _PLATFORM_DEVICE_H_
  12#define _PLATFORM_DEVICE_H_
  13
  14#include <linux/device.h>
  15#include <linux/mod_devicetable.h>
  16
  17#define PLATFORM_DEVID_NONE     (-1)
  18#define PLATFORM_DEVID_AUTO     (-2)
  19
  20struct mfd_cell;
  21
  22struct platform_device {
  23        const char      * name;
  24        int             id;
  25        bool            id_auto;
  26        struct device   dev;
  27        u32             num_resources;
  28        struct resource * resource;
  29
  30        const struct platform_device_id *id_entry;
  31
  32        /* MFD cell pointer */
  33        struct mfd_cell *mfd_cell;
  34
  35        /* arch specific additions */
  36        struct pdev_archdata    archdata;
  37};
  38
  39#define platform_get_device_id(pdev)    ((pdev)->id_entry)
  40
  41#define to_platform_device(x) container_of((x), struct platform_device, dev)
  42
  43extern int platform_device_register(struct platform_device *);
  44extern void platform_device_unregister(struct platform_device *);
  45
  46extern struct bus_type platform_bus_type;
  47extern struct device platform_bus;
  48
  49extern void arch_setup_pdev_archdata(struct platform_device *);
  50extern struct resource *platform_get_resource(struct platform_device *, unsigned int, unsigned int);
  51extern int platform_get_irq(struct platform_device *, unsigned int);
  52extern struct resource *platform_get_resource_byname(struct platform_device *, unsigned int, const char *);
  53extern int platform_get_irq_byname(struct platform_device *, const char *);
  54extern int platform_add_devices(struct platform_device **, int);
  55
  56struct platform_device_info {
  57                struct device *parent;
  58
  59                const char *name;
  60                int id;
  61
  62                const struct resource *res;
  63                unsigned int num_res;
  64
  65                const void *data;
  66                size_t size_data;
  67                u64 dma_mask;
  68};
  69extern struct platform_device *platform_device_register_full(
  70                const struct platform_device_info *pdevinfo);
  71
  72/**
  73 * platform_device_register_resndata - add a platform-level device with
  74 * resources and platform-specific data
  75 *
  76 * @parent: parent device for the device we're adding
  77 * @name: base name of the device we're adding
  78 * @id: instance id
  79 * @res: set of resources that needs to be allocated for the device
  80 * @num: number of resources
  81 * @data: platform specific data for this platform device
  82 * @size: size of platform specific data
  83 *
  84 * Returns &struct platform_device pointer on success, or ERR_PTR() on error.
  85 */
  86static inline struct platform_device *platform_device_register_resndata(
  87                struct device *parent, const char *name, int id,
  88                const struct resource *res, unsigned int num,
  89                const void *data, size_t size) {
  90
  91        struct platform_device_info pdevinfo = {
  92                .parent = parent,
  93                .name = name,
  94                .id = id,
  95                .res = res,
  96                .num_res = num,
  97                .data = data,
  98                .size_data = size,
  99                .dma_mask = 0,
 100        };
 101
 102        return platform_device_register_full(&pdevinfo);
 103}
 104
 105/**
 106 * platform_device_register_simple - add a platform-level device and its resources
 107 * @name: base name of the device we're adding
 108 * @id: instance id
 109 * @res: set of resources that needs to be allocated for the device
 110 * @num: number of resources
 111 *
 112 * This function creates a simple platform device that requires minimal
 113 * resource and memory management. Canned release function freeing memory
 114 * allocated for the device allows drivers using such devices to be
 115 * unloaded without waiting for the last reference to the device to be
 116 * dropped.
 117 *
 118 * This interface is primarily intended for use with legacy drivers which
 119 * probe hardware directly.  Because such drivers create sysfs device nodes
 120 * themselves, rather than letting system infrastructure handle such device
 121 * enumeration tasks, they don't fully conform to the Linux driver model.
 122 * In particular, when such drivers are built as modules, they can't be
 123 * "hotplugged".
 124 *
 125 * Returns &struct platform_device pointer on success, or ERR_PTR() on error.
 126 */
 127static inline struct platform_device *platform_device_register_simple(
 128                const char *name, int id,
 129                const struct resource *res, unsigned int num)
 130{
 131        return platform_device_register_resndata(NULL, name, id,
 132                        res, num, NULL, 0);
 133}
 134
 135/**
 136 * platform_device_register_data - add a platform-level device with platform-specific data
 137 * @parent: parent device for the device we're adding
 138 * @name: base name of the device we're adding
 139 * @id: instance id
 140 * @data: platform specific data for this platform device
 141 * @size: size of platform specific data
 142 *
 143 * This function creates a simple platform device that requires minimal
 144 * resource and memory management. Canned release function freeing memory
 145 * allocated for the device allows drivers using such devices to be
 146 * unloaded without waiting for the last reference to the device to be
 147 * dropped.
 148 *
 149 * Returns &struct platform_device pointer on success, or ERR_PTR() on error.
 150 */
 151static inline struct platform_device *platform_device_register_data(
 152                struct device *parent, const char *name, int id,
 153                const void *data, size_t size)
 154{
 155        return platform_device_register_resndata(parent, name, id,
 156                        NULL, 0, data, size);
 157}
 158
 159extern struct platform_device *platform_device_alloc(const char *name, int id);
 160extern int platform_device_add_resources(struct platform_device *pdev,
 161                                         const struct resource *res,
 162                                         unsigned int num);
 163extern int platform_device_add_data(struct platform_device *pdev, const void *data, size_t size);
 164extern int platform_device_add(struct platform_device *pdev);
 165extern void platform_device_del(struct platform_device *pdev);
 166extern void platform_device_put(struct platform_device *pdev);
 167
 168struct platform_driver {
 169        int (*probe)(struct platform_device *);
 170        int (*remove)(struct platform_device *);
 171        void (*shutdown)(struct platform_device *);
 172        int (*suspend)(struct platform_device *, pm_message_t state);
 173        int (*resume)(struct platform_device *);
 174        struct device_driver driver;
 175        const struct platform_device_id *id_table;
 176};
 177
 178extern int platform_driver_register(struct platform_driver *);
 179extern void platform_driver_unregister(struct platform_driver *);
 180
 181/* non-hotpluggable platform devices may use this so that probe() and
 182 * its support may live in __init sections, conserving runtime memory.
 183 */
 184extern int platform_driver_probe(struct platform_driver *driver,
 185                int (*probe)(struct platform_device *));
 186
 187static inline void *platform_get_drvdata(const struct platform_device *pdev)
 188{
 189        return dev_get_drvdata(&pdev->dev);
 190}
 191
 192static inline void platform_set_drvdata(struct platform_device *pdev, void *data)
 193{
 194        dev_set_drvdata(&pdev->dev, data);
 195}
 196
 197/* module_platform_driver() - Helper macro for drivers that don't do
 198 * anything special in module init/exit.  This eliminates a lot of
 199 * boilerplate.  Each module may only use this macro once, and
 200 * calling it replaces module_init() and module_exit()
 201 */
 202#define module_platform_driver(__platform_driver) \
 203        module_driver(__platform_driver, platform_driver_register, \
 204                        platform_driver_unregister)
 205
 206extern struct platform_device *platform_create_bundle(struct platform_driver *driver,
 207                                        int (*probe)(struct platform_device *),
 208                                        struct resource *res, unsigned int n_res,
 209                                        const void *data, size_t size);
 210
 211/* early platform driver interface */
 212struct early_platform_driver {
 213        const char *class_str;
 214        struct platform_driver *pdrv;
 215        struct list_head list;
 216        int requested_id;
 217        char *buffer;
 218        int bufsize;
 219};
 220
 221#define EARLY_PLATFORM_ID_UNSET -2
 222#define EARLY_PLATFORM_ID_ERROR -3
 223
 224extern int early_platform_driver_register(struct early_platform_driver *epdrv,
 225                                          char *buf);
 226extern void early_platform_add_devices(struct platform_device **devs, int num);
 227
 228static inline int is_early_platform_device(struct platform_device *pdev)
 229{
 230        return !pdev->dev.driver;
 231}
 232
 233extern void early_platform_driver_register_all(char *class_str);
 234extern int early_platform_driver_probe(char *class_str,
 235                                       int nr_probe, int user_only);
 236extern void early_platform_cleanup(void);
 237
 238#define early_platform_init(class_string, platdrv)              \
 239        early_platform_init_buffer(class_string, platdrv, NULL, 0)
 240
 241#ifndef MODULE
 242#define early_platform_init_buffer(class_string, platdrv, buf, bufsiz)  \
 243static __initdata struct early_platform_driver early_driver = {         \
 244        .class_str = class_string,                                      \
 245        .buffer = buf,                                                  \
 246        .bufsize = bufsiz,                                              \
 247        .pdrv = platdrv,                                                \
 248        .requested_id = EARLY_PLATFORM_ID_UNSET,                        \
 249};                                                                      \
 250static int __init early_platform_driver_setup_func(char *buffer)        \
 251{                                                                       \
 252        return early_platform_driver_register(&early_driver, buffer);   \
 253}                                                                       \
 254early_param(class_string, early_platform_driver_setup_func)
 255#else /* MODULE */
 256#define early_platform_init_buffer(class_string, platdrv, buf, bufsiz)  \
 257static inline char *early_platform_driver_setup_func(void)              \
 258{                                                                       \
 259        return bufsiz ? buf : NULL;                                     \
 260}
 261#endif /* MODULE */
 262
 263#ifdef CONFIG_SUSPEND
 264extern int platform_pm_suspend(struct device *dev);
 265extern int platform_pm_resume(struct device *dev);
 266#else
 267#define platform_pm_suspend             NULL
 268#define platform_pm_resume              NULL
 269#endif
 270
 271#ifdef CONFIG_HIBERNATE_CALLBACKS
 272extern int platform_pm_freeze(struct device *dev);
 273extern int platform_pm_thaw(struct device *dev);
 274extern int platform_pm_poweroff(struct device *dev);
 275extern int platform_pm_restore(struct device *dev);
 276#else
 277#define platform_pm_freeze              NULL
 278#define platform_pm_thaw                NULL
 279#define platform_pm_poweroff            NULL
 280#define platform_pm_restore             NULL
 281#endif
 282
 283#ifdef CONFIG_PM_SLEEP
 284#define USE_PLATFORM_PM_SLEEP_OPS \
 285        .suspend = platform_pm_suspend, \
 286        .resume = platform_pm_resume, \
 287        .freeze = platform_pm_freeze, \
 288        .thaw = platform_pm_thaw, \
 289        .poweroff = platform_pm_poweroff, \
 290        .restore = platform_pm_restore,
 291#else
 292#define USE_PLATFORM_PM_SLEEP_OPS
 293#endif
 294
 295#endif /* _PLATFORM_DEVICE_H_ */
 296
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.