/include/linux/platform_device.h

https://bitbucket.org/thekraven/iscream_thunderc-2.6.35 · C++ Header · 139 lines · 100 code · 25 blank · 14 comment · 0 complexity · b40629627981f989a59f89d40fb671b3 MD5 · raw file 

    

  1. /*
    2. 

  2.  * platform_device.h - generic, centralized driver model
    3. 

  3.  *
    4. 

  4.  * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
    5. 

  5.  *
    6. 

  6.  * This file is released under the GPLv2
    7. 

  7.  *
    8. 

  8.  * See Documentation/driver-model/ for more information.
    9. 

  9.  */
    10. 

  10. 

  11. #ifndef _PLATFORM_DEVICE_H_
    12. 

  12. #define _PLATFORM_DEVICE_H_
    13. 

  13. 

  14. #include <linux/device.h>
    15. 

  15. #include <linux/mod_devicetable.h>
    16. 

  16. 

  17. struct platform_device {
    18. 

  18. 	const char	* name;
    19. 

  19. 	int		id;
    20. 

  20. 	struct device	dev;
    21. 

  21. 	u32		num_resources;
    22. 

  22. 	struct resource	* resource;
    23. 

  23. 

  24. 	const struct platform_device_id	*id_entry;
    25. 

  25. 

  26. 	/* arch specific additions */
    27. 

  27. 	struct pdev_archdata	archdata;
    28. 

  28. };
    29. 

  29. 

  30. #define platform_get_device_id(pdev)	((pdev)->id_entry)
    31. 

  31. 

  32. #define to_platform_device(x) container_of((x), struct platform_device, dev)
    33. 

  33. 

  34. extern int platform_device_register(struct platform_device *);
    35. 

  35. extern void platform_device_unregister(struct platform_device *);
    36. 

  36. 

  37. extern struct bus_type platform_bus_type;
    38. 

  38. extern struct device platform_bus;
    39. 

  39. 

  40. extern struct resource *platform_get_resource(struct platform_device *, unsigned int, unsigned int);
    41. 

  41. extern int platform_get_irq(struct platform_device *, unsigned int);
    42. 

  42. extern struct resource *platform_get_resource_byname(struct platform_device *, unsigned int, const char *);
    43. 

  43. extern int platform_get_irq_byname(struct platform_device *, const char *);
    44. 

  44. extern int platform_add_devices(struct platform_device **, int);
    45. 

  45. 

  46. extern struct platform_device *platform_device_register_simple(const char *, int id,
    47. 

  47. 					const struct resource *, unsigned int);
    48. 

  48. extern struct platform_device *platform_device_register_data(struct device *,
    49. 

  49. 		const char *, int, const void *, size_t);
    50. 

  50. 

  51. extern struct platform_device *platform_device_alloc(const char *name, int id);
    52. 

  52. extern int platform_device_add_resources(struct platform_device *pdev,
    53. 

  53. 					 const struct resource *res,
    54. 

  54. 					 unsigned int num);
    55. 

  55. extern int platform_device_add_data(struct platform_device *pdev, const void *data, size_t size);
    56. 

  56. extern int platform_device_add(struct platform_device *pdev);
    57. 

  57. extern void platform_device_del(struct platform_device *pdev);
    58. 

  58. extern void platform_device_put(struct platform_device *pdev);
    59. 

  59. 

  60. struct platform_driver {
    61. 

  61. 	int (*probe)(struct platform_device *);
    62. 

  62. 	int (*remove)(struct platform_device *);
    63. 

  63. 	void (*shutdown)(struct platform_device *);
    64. 

  64. 	int (*suspend)(struct platform_device *, pm_message_t state);
    65. 

  65. 	int (*resume)(struct platform_device *);
    66. 

  66. 	struct device_driver driver;
    67. 

  67. 	const struct platform_device_id *id_table;
    68. 

  68. };
    69. 

  69. 

  70. extern int platform_driver_register(struct platform_driver *);
    71. 

  71. extern void platform_driver_unregister(struct platform_driver *);
    72. 

  72. 

  73. /* non-hotpluggable platform devices may use this so that probe() and
    74. 

  74.  * its support may live in __init sections, conserving runtime memory.
    75. 

  75.  */
    76. 

  76. extern int platform_driver_probe(struct platform_driver *driver,
    77. 

  77. 		int (*probe)(struct platform_device *));
    78. 

  78. 

  79. #define platform_get_drvdata(_dev)	dev_get_drvdata(&(_dev)->dev)
    80. 

  80. #define platform_set_drvdata(_dev,data)	dev_set_drvdata(&(_dev)->dev, (data))
    81. 

  81. 

  82. extern struct platform_device *platform_create_bundle(struct platform_driver *driver,
    83. 

  83. 					int (*probe)(struct platform_device *),
    84. 

  84. 					struct resource *res, unsigned int n_res,
    85. 

  85. 					const void *data, size_t size);
    86. 

  86. 

  87. /* early platform driver interface */
    88. 

  88. struct early_platform_driver {
    89. 

  89. 	const char *class_str;
    90. 

  90. 	struct platform_driver *pdrv;
    91. 

  91. 	struct list_head list;
    92. 

  92. 	int requested_id;
    93. 

  93. 	char *buffer;
    94. 

  94. 	int bufsize;
    95. 

  95. };
    96. 

  96. 

  97. #define EARLY_PLATFORM_ID_UNSET -2
    98. 

  98. #define EARLY_PLATFORM_ID_ERROR -3
    99. 

  99. 

  100. extern int early_platform_driver_register(struct early_platform_driver *epdrv,
    101. 

  101. 					  char *buf);
    102. 

  102. extern void early_platform_add_devices(struct platform_device **devs, int num);
    103. 

  103. 

  104. static inline int is_early_platform_device(struct platform_device *pdev)
    105. 

  105. {
    106. 

  106. 	return !pdev->dev.driver;
    107. 

  107. }
    108. 

  108. 

  109. extern void early_platform_driver_register_all(char *class_str);
    110. 

  110. extern int early_platform_driver_probe(char *class_str,
    111. 

  111. 				       int nr_probe, int user_only);
    112. 

  112. extern void early_platform_cleanup(void);
    113. 

  113. 

  114. #define early_platform_init(class_string, platdrv)		\
    115. 

  115. 	early_platform_init_buffer(class_string, platdrv, NULL, 0)
    116. 

  116. 

  117. #ifndef MODULE
    118. 

  118. #define early_platform_init_buffer(class_string, platdrv, buf, bufsiz)	\
    119. 

  119. static __initdata struct early_platform_driver early_driver = {		\
    120. 

  120. 	.class_str = class_string,					\
    121. 

  121. 	.buffer = buf,							\
    122. 

  122. 	.bufsize = bufsiz,						\
    123. 

  123. 	.pdrv = platdrv,						\
    124. 

  124. 	.requested_id = EARLY_PLATFORM_ID_UNSET,			\
    125. 

  125. };									\
    126. 

  126. static int __init early_platform_driver_setup_func(char *buffer)	\
    127. 

  127. {									\
    128. 

  128. 	return early_platform_driver_register(&early_driver, buffer);	\
    129. 

  129. }									\
    130. 

  130. early_param(class_string, early_platform_driver_setup_func)
    131. 

  131. #else /* MODULE */
    132. 

  132. #define early_platform_init_buffer(class_string, platdrv, buf, bufsiz)	\
    133. 

  133. static inline char *early_platform_driver_setup_func(void)		\
    134. 

  134. {									\
    135. 

  135. 	return bufsiz ? buf : NULL;					\
    136. 

  136. }
    137. 

  137. #endif /* MODULE */
    138. 

  138. 

  139. #endif /* _PLATFORM_DEVICE_H_ */
    140.