home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / asm-powerpc / pmac_pfunc.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  8.0 KB  |  253 lines
  1. #ifndef __PMAC_PFUNC_H__
  2. #define __PMAC_PFUNC_H__
  3.  
  4. #include <linux/types.h>
  5. #include <linux/list.h>
  6.  
  7. /* Flags in command lists */
  8. #define PMF_FLAGS_ON_INIT        0x80000000u
  9. #define PMF_FLGAS_ON_TERM        0x40000000u
  10. #define PMF_FLAGS_ON_SLEEP        0x20000000u
  11. #define PMF_FLAGS_ON_WAKE        0x10000000u
  12. #define PMF_FLAGS_ON_DEMAND        0x08000000u
  13. #define PMF_FLAGS_INT_GEN        0x04000000u
  14. #define PMF_FLAGS_HIGH_SPEED        0x02000000u
  15. #define PMF_FLAGS_LOW_SPEED        0x01000000u
  16. #define PMF_FLAGS_SIDE_EFFECTS        0x00800000u
  17.  
  18. /*
  19.  * Arguments to a platform function call.
  20.  *
  21.  * NOTE: By convention, pointer arguments point to an u32
  22.  */
  23. struct pmf_args {
  24.     union {
  25.         u32 v;
  26.         u32 *p;
  27.     } u[4];
  28.     unsigned int count;
  29. };
  30.  
  31. /*
  32.  * A driver capable of interpreting commands provides a handlers
  33.  * structure filled with whatever handlers are implemented by this
  34.  * driver. Non implemented handlers are left NULL.
  35.  *
  36.  * PMF_STD_ARGS are the same arguments that are passed to the parser
  37.  * and that gets passed back to the various handlers.
  38.  *
  39.  * Interpreting a given function always start with a begin() call which
  40.  * returns an instance data to be passed around subsequent calls, and
  41.  * ends with an end() call. This allows the low level driver to implement
  42.  * locking policy or per-function instance data.
  43.  *
  44.  * For interrupt capable functions, irq_enable() is called when a client
  45.  * registers, and irq_disable() is called when the last client unregisters
  46.  * Note that irq_enable & irq_disable are called within a semaphore held
  47.  * by the core, thus you should not try to register yourself to some other
  48.  * pmf interrupt during those calls.
  49.  */
  50.  
  51. #define PMF_STD_ARGS    struct pmf_function *func, void *instdata, \
  52.                 struct pmf_args *args
  53.  
  54. struct pmf_function;
  55.  
  56. struct pmf_handlers {
  57.     void * (*begin)(struct pmf_function *func, struct pmf_args *args);
  58.     void (*end)(struct pmf_function *func, void *instdata);
  59.  
  60.     int (*irq_enable)(struct pmf_function *func);
  61.     int (*irq_disable)(struct pmf_function *func);
  62.  
  63.     int (*write_gpio)(PMF_STD_ARGS, u8 value, u8 mask);
  64.     int (*read_gpio)(PMF_STD_ARGS, u8 mask, int rshift, u8 xor);
  65.  
  66.     int (*write_reg32)(PMF_STD_ARGS, u32 offset, u32 value, u32 mask);
  67.     int (*read_reg32)(PMF_STD_ARGS, u32 offset);
  68.     int (*write_reg16)(PMF_STD_ARGS, u32 offset, u16 value, u16 mask);
  69.     int (*read_reg16)(PMF_STD_ARGS, u32 offset);
  70.     int (*write_reg8)(PMF_STD_ARGS, u32 offset, u8 value, u8 mask);
  71.     int (*read_reg8)(PMF_STD_ARGS, u32 offset);
  72.  
  73.     int (*delay)(PMF_STD_ARGS, u32 duration);
  74.  
  75.     int (*wait_reg32)(PMF_STD_ARGS, u32 offset, u32 value, u32 mask);
  76.     int (*wait_reg16)(PMF_STD_ARGS, u32 offset, u16 value, u16 mask);
  77.     int (*wait_reg8)(PMF_STD_ARGS, u32 offset, u8 value, u8 mask);
  78.  
  79.     int (*read_i2c)(PMF_STD_ARGS, u32 len);
  80.     int (*write_i2c)(PMF_STD_ARGS, u32 len, const u8 *data);
  81.     int (*rmw_i2c)(PMF_STD_ARGS, u32 masklen, u32 valuelen, u32 totallen,
  82.                const u8 *maskdata, const u8 *valuedata);
  83.  
  84.     int (*read_cfg)(PMF_STD_ARGS, u32 offset, u32 len);
  85.     int (*write_cfg)(PMF_STD_ARGS, u32 offset, u32 len, const u8 *data);
  86.     int (*rmw_cfg)(PMF_STD_ARGS, u32 offset, u32 masklen, u32 valuelen,
  87.                u32 totallen, const u8 *maskdata, const u8 *valuedata);
  88.  
  89.     int (*read_i2c_sub)(PMF_STD_ARGS, u8 subaddr, u32 len);
  90.     int (*write_i2c_sub)(PMF_STD_ARGS, u8 subaddr, u32 len, const u8 *data);
  91.     int (*set_i2c_mode)(PMF_STD_ARGS, int mode);
  92.     int (*rmw_i2c_sub)(PMF_STD_ARGS, u8 subaddr, u32 masklen, u32 valuelen,
  93.                u32 totallen, const u8 *maskdata,
  94.                const u8 *valuedata);
  95.  
  96.     int (*read_reg32_msrx)(PMF_STD_ARGS, u32 offset, u32 mask, u32 shift,
  97.                    u32 xor);
  98.     int (*read_reg16_msrx)(PMF_STD_ARGS, u32 offset, u32 mask, u32 shift,
  99.                    u32 xor);
  100.     int (*read_reg8_msrx)(PMF_STD_ARGS, u32 offset, u32 mask, u32 shift,
  101.                   u32 xor);
  102.  
  103.     int (*write_reg32_slm)(PMF_STD_ARGS, u32 offset, u32 shift, u32 mask);
  104.     int (*write_reg16_slm)(PMF_STD_ARGS, u32 offset, u32 shift, u32 mask);
  105.     int (*write_reg8_slm)(PMF_STD_ARGS, u32 offset, u32 shift, u32 mask);
  106.  
  107.     int (*mask_and_compare)(PMF_STD_ARGS, u32 len, const u8 *maskdata,
  108.                 const u8 *valuedata);
  109.  
  110.     struct module *owner;
  111. };
  112.  
  113.  
  114. /*
  115.  * Drivers who expose platform functions register at init time, this
  116.  * causes the platform functions for that device node to be parsed in
  117.  * advance and associated with the device. The data structures are
  118.  * partially public so a driver can walk the list of platform functions
  119.  * and eventually inspect the flags
  120.  */
  121. struct pmf_device;
  122.  
  123. struct pmf_function {
  124.     /* All functions for a given driver are linked */
  125.     struct list_head    link;
  126.  
  127.     /* Function node & driver data */
  128.     struct device_node    *node;
  129.     void            *driver_data;
  130.  
  131.     /* For internal use by core */
  132.     struct pmf_device    *dev;
  133.  
  134.     /* The name is the "xxx" in "platform-do-xxx", this is how
  135.      * platform functions are identified by this code. Some functions
  136.      * only operate for a given target, in which case the phandle is
  137.      * here (or 0 if the filter doesn't apply)
  138.      */
  139.     const char        *name;
  140.     u32            phandle;
  141.  
  142.     /* The flags for that function. You can have several functions
  143.      * with the same name and different flag
  144.      */
  145.     u32            flags;
  146.  
  147.     /* The actual tokenized function blob */
  148.     const void        *data;
  149.     unsigned int        length;
  150.  
  151.     /* Interrupt clients */
  152.     struct list_head    irq_clients;
  153.  
  154.     /* Refcounting */
  155.     struct kref        ref;
  156. };
  157.  
  158. /*
  159.  * For platform functions that are interrupts, one can register
  160.  * irq_client structures. You canNOT use the same structure twice
  161.  * as it contains a link member. Also, the callback is called with
  162.  * a spinlock held, you must not call back into any of the pmf_* functions
  163.  * from within that callback
  164.  */
  165. struct pmf_irq_client {
  166.     void            (*handler)(void *data);
  167.     void            *data;
  168.     struct module        *owner;
  169.     struct list_head    link;
  170.     struct pmf_function    *func;
  171. };
  172.  
  173.  
  174. /*
  175.  * Register/Unregister a function-capable driver and its handlers
  176.  */
  177. extern int pmf_register_driver(struct device_node *np,
  178.                   struct pmf_handlers *handlers,
  179.                   void *driverdata);
  180.  
  181. extern void pmf_unregister_driver(struct device_node *np);
  182.  
  183.  
  184. /*
  185.  * Register/Unregister interrupt clients
  186.  */
  187. extern int pmf_register_irq_client(struct device_node *np,
  188.                    const char *name,
  189.                    struct pmf_irq_client *client);
  190.  
  191. extern void pmf_unregister_irq_client(struct pmf_irq_client *client);
  192.  
  193. /*
  194.  * Called by the handlers when an irq happens
  195.  */
  196. extern void pmf_do_irq(struct pmf_function *func);
  197.  
  198.  
  199. /*
  200.  * Low level call to platform functions.
  201.  *
  202.  * The phandle can filter on the target object for functions that have
  203.  * multiple targets, the flags allow you to restrict the call to a given
  204.  * combination of flags.
  205.  *
  206.  * The args array contains as many arguments as is required by the function,
  207.  * this is dependent on the function you are calling, unfortunately Apple
  208.  * mecanism provides no way to encode that so you have to get it right at
  209.  * the call site. Some functions require no args, in which case, you can
  210.  * pass NULL.
  211.  *
  212.  * You can also pass NULL to the name. This will match any function that has
  213.  * the appropriate combination of flags & phandle or you can pass 0 to the
  214.  * phandle to match any
  215.  */
  216. extern int pmf_do_functions(struct device_node *np, const char *name,
  217.                 u32 phandle, u32 flags, struct pmf_args *args);
  218.  
  219.  
  220.  
  221. /*
  222.  * High level call to a platform function.
  223.  *
  224.  * This one looks for the platform-xxx first so you should call it to the
  225.  * actual target if any. It will fallback to platform-do-xxx if it can't
  226.  * find one. It will also exclusively target functions that have
  227.  * the "OnDemand" flag.
  228.  */
  229.  
  230. extern int pmf_call_function(struct device_node *target, const char *name,
  231.                  struct pmf_args *args);
  232.  
  233.  
  234. /*
  235.  * For low latency interrupt usage, you can lookup for on-demand functions
  236.  * using the functions below
  237.  */
  238.  
  239. extern struct pmf_function *pmf_find_function(struct device_node *target,
  240.                           const char *name);
  241.  
  242. extern struct pmf_function * pmf_get_function(struct pmf_function *func);
  243. extern void pmf_put_function(struct pmf_function *func);
  244.  
  245. extern int pmf_call_one(struct pmf_function *func, struct pmf_args *args);
  246.  
  247.  
  248. /* Suspend/resume code called by via-pmu directly for now */
  249. extern void pmac_pfunc_base_suspend(void);
  250. extern void pmac_pfunc_base_resume(void);
  251.  
  252. #endif /* __PMAC_PFUNC_H__ */
  253.