| /drivers/video/drm/include/drmP.h |
|---|
| 67,6 → 67,9 |
| __func__, ##args); \ |
| } while (0) |
| #define DRM_DEBUG(fmt, arg...) \ |
| printk("[" DRM_NAME ":%s] " fmt , __func__ , ##arg) |
| #if 0 |
| /***********************************************************************/ |
| /drivers/video/drm/include/drm_crtc.h |
|---|
| 25,10 → 25,10 |
| #ifndef __DRM_CRTC_H__ |
| #define __DRM_CRTC_H__ |
| //#include <linux/i2c.h> |
| #include <linux/i2c.h> |
| //#include <linux/spinlock.h> |
| //#include <linux/types.h> |
| //#include <linux/idr.h> |
| #include <linux/idr.h> |
| //#include <linux/fb.h> |
| /drivers/video/drm/include/drm_edid.h |
|---|
| 193,97 → 193,6 |
| #define EDID_PRODUCT_ID(e) ((e)->prod_code[0] | ((e)->prod_code[1] << 8)) |
| #define KOBJ_NAME_LEN 20 |
| #define I2C_NAME_SIZE 20 |
| /* --- Defines for bit-adapters --------------------------------------- */ |
| /* |
| * This struct contains the hw-dependent functions of bit-style adapters to |
| * manipulate the line states, and to init any hw-specific features. This is |
| * only used if you have more than one hw-type of adapter running. |
| */ |
| struct i2c_algo_bit_data { |
| void *data; /* private data for lowlevel routines */ |
| void (*setsda) (void *data, int state); |
| void (*setscl) (void *data, int state); |
| int (*getsda) (void *data); |
| int (*getscl) (void *data); |
| /* local settings */ |
| int udelay; /* half clock cycle time in us, |
| minimum 2 us for fast-mode I2C, |
| minimum 5 us for standard-mode I2C and SMBus, |
| maximum 50 us for SMBus */ |
| int timeout; /* in jiffies */ |
| }; |
| struct i2c_client; |
| /* |
| * i2c_adapter is the structure used to identify a physical i2c bus along |
| * with the access algorithms necessary to access it. |
| */ |
| struct i2c_adapter { |
| // struct module *owner; |
| unsigned int id; |
| unsigned int class; |
| // const struct i2c_algorithm *algo; /* the algorithm to access the bus */ |
| void *algo_data; |
| /* --- administration stuff. */ |
| int (*client_register)(struct i2c_client *); |
| int (*client_unregister)(struct i2c_client *); |
| /* data fields that are valid for all devices */ |
| u8 level; /* nesting level for lockdep */ |
| // struct mutex bus_lock; |
| // struct mutex clist_lock; |
| int timeout; |
| int retries; |
| // struct device dev; /* the adapter device */ |
| int nr; |
| struct list_head clients; /* DEPRECATED */ |
| char name[48]; |
| // struct completion dev_released; |
| }; |
| #define to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev) |
| struct i2c_client { |
| unsigned short flags; /* div., see below */ |
| unsigned short addr; /* chip address - NOTE: 7bit */ |
| /* addresses are stored in the */ |
| /* _LOWER_ 7 bits */ |
| char name[I2C_NAME_SIZE]; |
| struct i2c_adapter *adapter; /* the adapter we sit on */ |
| // struct i2c_driver *driver; /* and our access routines */ |
| // struct device dev; /* the device structure */ |
| int irq; /* irq issued by device (or -1) */ |
| char driver_name[KOBJ_NAME_LEN]; |
| struct list_head list; /* DEPRECATED */ |
| // struct completion released; |
| }; |
| #define to_i2c_client(d) container_of(d, struct i2c_client, dev) |
| int i2c_bit_add_bus(struct i2c_adapter *); |
| int i2c_bit_add_numbered_bus(struct i2c_adapter *); |
| struct i2c_msg { |
| u16 addr; /* slave address */ |
| u16 flags; |
| #define I2C_M_TEN 0x0010 /* this is a ten bit chip address */ |
| #define I2C_M_RD 0x0001 /* read data, from slave to master */ |
| #define I2C_M_NOSTART 0x4000 /* if I2C_FUNC_PROTOCOL_MANGLING */ |
| #define I2C_M_REV_DIR_ADDR 0x2000 /* if I2C_FUNC_PROTOCOL_MANGLING */ |
| #define I2C_M_IGNORE_NAK 0x1000 /* if I2C_FUNC_PROTOCOL_MANGLING */ |
| #define I2C_M_NO_RD_ACK 0x0800 /* if I2C_FUNC_PROTOCOL_MANGLING */ |
| #define I2C_M_RECV_LEN 0x0400 /* length will be first received byte */ |
| u16 len; /* msg length */ |
| u8 *buf; /* pointer to msg data */ |
| }; |
| #endif /* __DRM_EDID_H__ */ |
| /drivers/video/drm/include/errno.h |
|---|
| 0,0 → 1,111 |
| #ifndef _ASM_GENERIC_ERRNO_H |
| #define _ASM_GENERIC_ERRNO_H |
| #include <errno-base.h> |
| #define EDEADLK 35 /* Resource deadlock would occur */ |
| #define ENAMETOOLONG 36 /* File name too long */ |
| #define ENOLCK 37 /* No record locks available */ |
| #define ENOSYS 38 /* Function not implemented */ |
| #define ENOTEMPTY 39 /* Directory not empty */ |
| #define ELOOP 40 /* Too many symbolic links encountered */ |
| #define EWOULDBLOCK EAGAIN /* Operation would block */ |
| #define ENOMSG 42 /* No message of desired type */ |
| #define EIDRM 43 /* Identifier removed */ |
| #define ECHRNG 44 /* Channel number out of range */ |
| #define EL2NSYNC 45 /* Level 2 not synchronized */ |
| #define EL3HLT 46 /* Level 3 halted */ |
| #define EL3RST 47 /* Level 3 reset */ |
| #define ELNRNG 48 /* Link number out of range */ |
| #define EUNATCH 49 /* Protocol driver not attached */ |
| #define ENOCSI 50 /* No CSI structure available */ |
| #define EL2HLT 51 /* Level 2 halted */ |
| #define EBADE 52 /* Invalid exchange */ |
| #define EBADR 53 /* Invalid request descriptor */ |
| #define EXFULL 54 /* Exchange full */ |
| #define ENOANO 55 /* No anode */ |
| #define EBADRQC 56 /* Invalid request code */ |
| #define EBADSLT 57 /* Invalid slot */ |
| #define EDEADLOCK EDEADLK |
| #define EBFONT 59 /* Bad font file format */ |
| #define ENOSTR 60 /* Device not a stream */ |
| #define ENODATA 61 /* No data available */ |
| #define ETIME 62 /* Timer expired */ |
| #define ENOSR 63 /* Out of streams resources */ |
| #define ENONET 64 /* Machine is not on the network */ |
| #define ENOPKG 65 /* Package not installed */ |
| #define EREMOTE 66 /* Object is remote */ |
| #define ENOLINK 67 /* Link has been severed */ |
| #define EADV 68 /* Advertise error */ |
| #define ESRMNT 69 /* Srmount error */ |
| #define ECOMM 70 /* Communication error on send */ |
| #define EPROTO 71 /* Protocol error */ |
| #define EMULTIHOP 72 /* Multihop attempted */ |
| #define EDOTDOT 73 /* RFS specific error */ |
| #define EBADMSG 74 /* Not a data message */ |
| #define EOVERFLOW 75 /* Value too large for defined data type */ |
| #define ENOTUNIQ 76 /* Name not unique on network */ |
| #define EBADFD 77 /* File descriptor in bad state */ |
| #define EREMCHG 78 /* Remote address changed */ |
| #define ELIBACC 79 /* Can not access a needed shared library */ |
| #define ELIBBAD 80 /* Accessing a corrupted shared library */ |
| #define ELIBSCN 81 /* .lib section in a.out corrupted */ |
| #define ELIBMAX 82 /* Attempting to link in too many shared libraries */ |
| #define ELIBEXEC 83 /* Cannot exec a shared library directly */ |
| #define EILSEQ 84 /* Illegal byte sequence */ |
| #define ERESTART 85 /* Interrupted system call should be restarted */ |
| #define ESTRPIPE 86 /* Streams pipe error */ |
| #define EUSERS 87 /* Too many users */ |
| #define ENOTSOCK 88 /* Socket operation on non-socket */ |
| #define EDESTADDRREQ 89 /* Destination address required */ |
| #define EMSGSIZE 90 /* Message too long */ |
| #define EPROTOTYPE 91 /* Protocol wrong type for socket */ |
| #define ENOPROTOOPT 92 /* Protocol not available */ |
| #define EPROTONOSUPPORT 93 /* Protocol not supported */ |
| #define ESOCKTNOSUPPORT 94 /* Socket type not supported */ |
| #define EOPNOTSUPP 95 /* Operation not supported on transport endpoint */ |
| #define EPFNOSUPPORT 96 /* Protocol family not supported */ |
| #define EAFNOSUPPORT 97 /* Address family not supported by protocol */ |
| #define EADDRINUSE 98 /* Address already in use */ |
| #define EADDRNOTAVAIL 99 /* Cannot assign requested address */ |
| #define ENETDOWN 100 /* Network is down */ |
| #define ENETUNREACH 101 /* Network is unreachable */ |
| #define ENETRESET 102 /* Network dropped connection because of reset */ |
| #define ECONNABORTED 103 /* Software caused connection abort */ |
| #define ECONNRESET 104 /* Connection reset by peer */ |
| #define ENOBUFS 105 /* No buffer space available */ |
| #define EISCONN 106 /* Transport endpoint is already connected */ |
| #define ENOTCONN 107 /* Transport endpoint is not connected */ |
| #define ESHUTDOWN 108 /* Cannot send after transport endpoint shutdown */ |
| #define ETOOMANYREFS 109 /* Too many references: cannot splice */ |
| #define ETIMEDOUT 110 /* Connection timed out */ |
| #define ECONNREFUSED 111 /* Connection refused */ |
| #define EHOSTDOWN 112 /* Host is down */ |
| #define EHOSTUNREACH 113 /* No route to host */ |
| #define EALREADY 114 /* Operation already in progress */ |
| #define EINPROGRESS 115 /* Operation now in progress */ |
| #define ESTALE 116 /* Stale NFS file handle */ |
| #define EUCLEAN 117 /* Structure needs cleaning */ |
| #define ENOTNAM 118 /* Not a XENIX named type file */ |
| #define ENAVAIL 119 /* No XENIX semaphores available */ |
| #define EISNAM 120 /* Is a named type file */ |
| #define EREMOTEIO 121 /* Remote I/O error */ |
| #define EDQUOT 122 /* Quota exceeded */ |
| #define ENOMEDIUM 123 /* No medium found */ |
| #define EMEDIUMTYPE 124 /* Wrong medium type */ |
| #define ECANCELED 125 /* Operation Canceled */ |
| #define ENOKEY 126 /* Required key not available */ |
| #define EKEYEXPIRED 127 /* Key has expired */ |
| #define EKEYREVOKED 128 /* Key has been revoked */ |
| #define EKEYREJECTED 129 /* Key was rejected by service */ |
| /* for robust mutexes */ |
| #define EOWNERDEAD 130 /* Owner died */ |
| #define ENOTRECOVERABLE 131 /* State not recoverable */ |
| #define ERFKILL 132 /* Operation not possible due to RF-kill */ |
| #endif |
| /drivers/video/drm/include/linux/bitops.h |
|---|
| 0,0 → 1,191 |
| #ifndef _LINUX_BITOPS_H |
| #define _LINUX_BITOPS_H |
| #define BIT(nr) (1UL << (nr)) |
| #define BIT_MASK(nr) (1UL << ((nr) % BITS_PER_LONG)) |
| #define BIT_WORD(nr) ((nr) / BITS_PER_LONG) |
| #define BITS_PER_BYTE 8 |
| #define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long)) |
| /* |
| * Include this here because some architectures need generic_ffs/fls in |
| * scope |
| */ |
| #include <asm/bitops.h> |
| #define for_each_bit(bit, addr, size) \ |
| for ((bit) = find_first_bit((addr), (size)); \ |
| (bit) < (size); \ |
| (bit) = find_next_bit((addr), (size), (bit) + 1)) |
| static __inline__ int get_bitmask_order(unsigned int count) |
| { |
| int order; |
| order = fls(count); |
| return order; /* We could be slightly more clever with -1 here... */ |
| } |
| static __inline__ int get_count_order(unsigned int count) |
| { |
| int order; |
| order = fls(count) - 1; |
| if (count & (count - 1)) |
| order++; |
| return order; |
| } |
| static inline unsigned long hweight_long(unsigned long w) |
| { |
| return sizeof(w) == 4 ? hweight32(w) : hweight64(w); |
| } |
| /** |
| * rol32 - rotate a 32-bit value left |
| * @word: value to rotate |
| * @shift: bits to roll |
| */ |
| static inline __u32 rol32(__u32 word, unsigned int shift) |
| { |
| return (word << shift) | (word >> (32 - shift)); |
| } |
| /** |
| * ror32 - rotate a 32-bit value right |
| * @word: value to rotate |
| * @shift: bits to roll |
| */ |
| static inline __u32 ror32(__u32 word, unsigned int shift) |
| { |
| return (word >> shift) | (word << (32 - shift)); |
| } |
| /** |
| * rol16 - rotate a 16-bit value left |
| * @word: value to rotate |
| * @shift: bits to roll |
| */ |
| static inline __u16 rol16(__u16 word, unsigned int shift) |
| { |
| return (word << shift) | (word >> (16 - shift)); |
| } |
| /** |
| * ror16 - rotate a 16-bit value right |
| * @word: value to rotate |
| * @shift: bits to roll |
| */ |
| static inline __u16 ror16(__u16 word, unsigned int shift) |
| { |
| return (word >> shift) | (word << (16 - shift)); |
| } |
| /** |
| * rol8 - rotate an 8-bit value left |
| * @word: value to rotate |
| * @shift: bits to roll |
| */ |
| static inline __u8 rol8(__u8 word, unsigned int shift) |
| { |
| return (word << shift) | (word >> (8 - shift)); |
| } |
| /** |
| * ror8 - rotate an 8-bit value right |
| * @word: value to rotate |
| * @shift: bits to roll |
| */ |
| static inline __u8 ror8(__u8 word, unsigned int shift) |
| { |
| return (word >> shift) | (word << (8 - shift)); |
| } |
| static inline unsigned fls_long(unsigned long l) |
| { |
| if (sizeof(l) == 4) |
| return fls(l); |
| return fls64(l); |
| } |
| /** |
| * __ffs64 - find first set bit in a 64 bit word |
| * @word: The 64 bit word |
| * |
| * On 64 bit arches this is a synomyn for __ffs |
| * The result is not defined if no bits are set, so check that @word |
| * is non-zero before calling this. |
| */ |
| static inline unsigned long __ffs64(u64 word) |
| { |
| #if BITS_PER_LONG == 32 |
| if (((u32)word) == 0UL) |
| return __ffs((u32)(word >> 32)) + 32; |
| #elif BITS_PER_LONG != 64 |
| #error BITS_PER_LONG not 32 or 64 |
| #endif |
| return __ffs((unsigned long)word); |
| } |
| #ifdef __KERNEL__ |
| #ifdef CONFIG_GENERIC_FIND_FIRST_BIT |
| /** |
| * find_first_bit - find the first set bit in a memory region |
| * @addr: The address to start the search at |
| * @size: The maximum size to search |
| * |
| * Returns the bit number of the first set bit. |
| */ |
| extern unsigned long find_first_bit(const unsigned long *addr, |
| unsigned long size); |
| /** |
| * find_first_zero_bit - find the first cleared bit in a memory region |
| * @addr: The address to start the search at |
| * @size: The maximum size to search |
| * |
| * Returns the bit number of the first cleared bit. |
| */ |
| extern unsigned long find_first_zero_bit(const unsigned long *addr, |
| unsigned long size); |
| #endif /* CONFIG_GENERIC_FIND_FIRST_BIT */ |
| #ifdef CONFIG_GENERIC_FIND_LAST_BIT |
| /** |
| * find_last_bit - find the last set bit in a memory region |
| * @addr: The address to start the search at |
| * @size: The maximum size to search |
| * |
| * Returns the bit number of the first set bit, or size. |
| */ |
| extern unsigned long find_last_bit(const unsigned long *addr, |
| unsigned long size); |
| #endif /* CONFIG_GENERIC_FIND_LAST_BIT */ |
| #ifdef CONFIG_GENERIC_FIND_NEXT_BIT |
| /** |
| * find_next_bit - find the next set bit in a memory region |
| * @addr: The address to base the search on |
| * @offset: The bitnumber to start searching at |
| * @size: The bitmap size in bits |
| */ |
| extern unsigned long find_next_bit(const unsigned long *addr, |
| unsigned long size, unsigned long offset); |
| /** |
| * find_next_zero_bit - find the next cleared bit in a memory region |
| * @addr: The address to base the search on |
| * @offset: The bitnumber to start searching at |
| * @size: The bitmap size in bits |
| */ |
| extern unsigned long find_next_zero_bit(const unsigned long *addr, |
| unsigned long size, |
| unsigned long offset); |
| #endif /* CONFIG_GENERIC_FIND_NEXT_BIT */ |
| #endif /* __KERNEL__ */ |
| #endif |
| /drivers/video/drm/include/linux/i2c-algo-bit.h |
|---|
| 0,0 → 1,51 |
| /* ------------------------------------------------------------------------- */ |
| /* i2c-algo-bit.h i2c driver algorithms for bit-shift adapters */ |
| /* ------------------------------------------------------------------------- */ |
| /* Copyright (C) 1995-99 Simon G. Vogl |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2 of the License, or |
| (at your option) any later version. |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ |
| /* ------------------------------------------------------------------------- */ |
| /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even |
| Frodo Looijaard <frodol@dds.nl> */ |
| #ifndef _LINUX_I2C_ALGO_BIT_H |
| #define _LINUX_I2C_ALGO_BIT_H |
| /* --- Defines for bit-adapters --------------------------------------- */ |
| /* |
| * This struct contains the hw-dependent functions of bit-style adapters to |
| * manipulate the line states, and to init any hw-specific features. This is |
| * only used if you have more than one hw-type of adapter running. |
| */ |
| struct i2c_algo_bit_data { |
| void *data; /* private data for lowlevel routines */ |
| void (*setsda) (void *data, int state); |
| void (*setscl) (void *data, int state); |
| int (*getsda) (void *data); |
| int (*getscl) (void *data); |
| /* local settings */ |
| int udelay; /* half clock cycle time in us, |
| minimum 2 us for fast-mode I2C, |
| minimum 5 us for standard-mode I2C and SMBus, |
| maximum 50 us for SMBus */ |
| int timeout; /* in jiffies */ |
| }; |
| int i2c_bit_add_bus(struct i2c_adapter *); |
| int i2c_bit_add_numbered_bus(struct i2c_adapter *); |
| #endif /* _LINUX_I2C_ALGO_BIT_H */ |
| /drivers/video/drm/include/linux/i2c.h |
|---|
| 0,0 → 1,299 |
| /* ------------------------------------------------------------------------- */ |
| /* */ |
| /* i2c.h - definitions for the i2c-bus interface */ |
| /* */ |
| /* ------------------------------------------------------------------------- */ |
| /* Copyright (C) 1995-2000 Simon G. Vogl |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2 of the License, or |
| (at your option) any later version. |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ |
| /* ------------------------------------------------------------------------- */ |
| /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and |
| Frodo Looijaard <frodol@dds.nl> */ |
| #ifndef _LINUX_I2C_H |
| #define _LINUX_I2C_H |
| #include <types.h> |
| #define I2C_NAME_SIZE 20 |
| struct i2c_msg; |
| struct i2c_algorithm; |
| struct i2c_adapter; |
| struct i2c_client; |
| union i2c_smbus_data; |
| /* Transfer num messages. |
| */ |
| extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, |
| int num); |
| /** |
| * struct i2c_client - represent an I2C slave device |
| * @flags: I2C_CLIENT_TEN indicates the device uses a ten bit chip address; |
| * I2C_CLIENT_PEC indicates it uses SMBus Packet Error Checking |
| * @addr: Address used on the I2C bus connected to the parent adapter. |
| * @name: Indicates the type of the device, usually a chip name that's |
| * generic enough to hide second-sourcing and compatible revisions. |
| * @adapter: manages the bus segment hosting this I2C device |
| * @driver: device's driver, hence pointer to access routines |
| * @dev: Driver model device node for the slave. |
| * @irq: indicates the IRQ generated by this device (if any) |
| * @detected: member of an i2c_driver.clients list or i2c-core's |
| * userspace_devices list |
| * |
| * An i2c_client identifies a single device (i.e. chip) connected to an |
| * i2c bus. The behaviour exposed to Linux is defined by the driver |
| * managing the device. |
| */ |
| struct i2c_client { |
| unsigned short flags; /* div., see below */ |
| unsigned short addr; /* chip address - NOTE: 7bit */ |
| /* addresses are stored in the */ |
| /* _LOWER_ 7 bits */ |
| char name[I2C_NAME_SIZE]; |
| struct i2c_adapter *adapter; /* the adapter we sit on */ |
| // struct i2c_driver *driver; /* and our access routines */ |
| // struct device dev; /* the device structure */ |
| int irq; /* irq issued by device (or -1) */ |
| struct list_head detected; |
| }; |
| #define to_i2c_client(d) container_of(d, struct i2c_client, dev) |
| /* |
| * The following structs are for those who like to implement new bus drivers: |
| * i2c_algorithm is the interface to a class of hardware solutions which can |
| * be addressed using the same bus algorithms - i.e. bit-banging or the PCF8584 |
| * to name two of the most common. |
| */ |
| struct i2c_algorithm { |
| /* If an adapter algorithm can't do I2C-level access, set master_xfer |
| to NULL. If an adapter algorithm can do SMBus access, set |
| smbus_xfer. If set to NULL, the SMBus protocol is simulated |
| using common I2C messages */ |
| /* master_xfer should return the number of messages successfully |
| processed, or a negative value on error */ |
| int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs, |
| int num); |
| int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr, |
| unsigned short flags, char read_write, |
| u8 command, int size, union i2c_smbus_data *data); |
| /* To determine what the adapter supports */ |
| u32 (*functionality) (struct i2c_adapter *); |
| }; |
| /* |
| * i2c_adapter is the structure used to identify a physical i2c bus along |
| * with the access algorithms necessary to access it. |
| */ |
| struct i2c_adapter { |
| unsigned int id; |
| unsigned int class; /* classes to allow probing for */ |
| const struct i2c_algorithm *algo; /* the algorithm to access the bus */ |
| void *algo_data; |
| /* data fields that are valid for all devices */ |
| u8 level; /* nesting level for lockdep */ |
| int timeout; /* in jiffies */ |
| int retries; |
| // struct device dev; /* the adapter device */ |
| int nr; |
| char name[48]; |
| }; |
| #define to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev) |
| /*flags for the client struct: */ |
| #define I2C_CLIENT_PEC 0x04 /* Use Packet Error Checking */ |
| #define I2C_CLIENT_TEN 0x10 /* we have a ten bit chip address */ |
| /* Must equal I2C_M_TEN below */ |
| #define I2C_CLIENT_WAKE 0x80 /* for board_info; true iff can wake */ |
| /* i2c adapter classes (bitmask) */ |
| #define I2C_CLASS_HWMON (1<<0) /* lm_sensors, ... */ |
| #define I2C_CLASS_TV_ANALOG (1<<1) /* bttv + friends */ |
| #define I2C_CLASS_TV_DIGITAL (1<<2) /* dvb cards */ |
| #define I2C_CLASS_DDC (1<<3) /* DDC bus on graphics adapters */ |
| #define I2C_CLASS_SPD (1<<7) /* SPD EEPROMs and similar */ |
| /* i2c_client_address_data is the struct for holding default client |
| * addresses for a driver and for the parameters supplied on the |
| * command line |
| */ |
| struct i2c_client_address_data { |
| const unsigned short *normal_i2c; |
| const unsigned short *probe; |
| const unsigned short *ignore; |
| const unsigned short * const *forces; |
| }; |
| /* Internal numbers to terminate lists */ |
| #define I2C_CLIENT_END 0xfffeU |
| /* The numbers to use to set I2C bus address */ |
| #define ANY_I2C_BUS 0xffff |
| /* Construct an I2C_CLIENT_END-terminated array of i2c addresses */ |
| #define I2C_ADDRS(addr, addrs...) \ |
| ((const unsigned short []){ addr, ## addrs, I2C_CLIENT_END }) |
| /** |
| * struct i2c_msg - an I2C transaction segment beginning with START |
| * @addr: Slave address, either seven or ten bits. When this is a ten |
| * bit address, I2C_M_TEN must be set in @flags and the adapter |
| * must support I2C_FUNC_10BIT_ADDR. |
| * @flags: I2C_M_RD is handled by all adapters. No other flags may be |
| * provided unless the adapter exported the relevant I2C_FUNC_* |
| * flags through i2c_check_functionality(). |
| * @len: Number of data bytes in @buf being read from or written to the |
| * I2C slave address. For read transactions where I2C_M_RECV_LEN |
| * is set, the caller guarantees that this buffer can hold up to |
| * 32 bytes in addition to the initial length byte sent by the |
| * slave (plus, if used, the SMBus PEC); and this value will be |
| * incremented by the number of block data bytes received. |
| * @buf: The buffer into which data is read, or from which it's written. |
| * |
| * An i2c_msg is the low level representation of one segment of an I2C |
| * transaction. It is visible to drivers in the @i2c_transfer() procedure, |
| * to userspace from i2c-dev, and to I2C adapter drivers through the |
| * @i2c_adapter.@master_xfer() method. |
| * |
| * Except when I2C "protocol mangling" is used, all I2C adapters implement |
| * the standard rules for I2C transactions. Each transaction begins with a |
| * START. That is followed by the slave address, and a bit encoding read |
| * versus write. Then follow all the data bytes, possibly including a byte |
| * with SMBus PEC. The transfer terminates with a NAK, or when all those |
| * bytes have been transferred and ACKed. If this is the last message in a |
| * group, it is followed by a STOP. Otherwise it is followed by the next |
| * @i2c_msg transaction segment, beginning with a (repeated) START. |
| * |
| * Alternatively, when the adapter supports I2C_FUNC_PROTOCOL_MANGLING then |
| * passing certain @flags may have changed those standard protocol behaviors. |
| * Those flags are only for use with broken/nonconforming slaves, and with |
| * adapters which are known to support the specific mangling options they |
| * need (one or more of IGNORE_NAK, NO_RD_ACK, NOSTART, and REV_DIR_ADDR). |
| */ |
| struct i2c_msg { |
| u16 addr; /* slave address */ |
| u16 flags; |
| #define I2C_M_TEN 0x0010 /* this is a ten bit chip address */ |
| #define I2C_M_RD 0x0001 /* read data, from slave to master */ |
| #define I2C_M_NOSTART 0x4000 /* if I2C_FUNC_PROTOCOL_MANGLING */ |
| #define I2C_M_REV_DIR_ADDR 0x2000 /* if I2C_FUNC_PROTOCOL_MANGLING */ |
| #define I2C_M_IGNORE_NAK 0x1000 /* if I2C_FUNC_PROTOCOL_MANGLING */ |
| #define I2C_M_NO_RD_ACK 0x0800 /* if I2C_FUNC_PROTOCOL_MANGLING */ |
| #define I2C_M_RECV_LEN 0x0400 /* length will be first received byte */ |
| u16 len; /* msg length */ |
| u8 *buf; /* pointer to msg data */ |
| }; |
| /* To determine what functionality is present */ |
| #define I2C_FUNC_I2C 0x00000001 |
| #define I2C_FUNC_10BIT_ADDR 0x00000002 |
| #define I2C_FUNC_PROTOCOL_MANGLING 0x00000004 /* I2C_M_NOSTART etc. */ |
| #define I2C_FUNC_SMBUS_PEC 0x00000008 |
| #define I2C_FUNC_SMBUS_BLOCK_PROC_CALL 0x00008000 /* SMBus 2.0 */ |
| #define I2C_FUNC_SMBUS_QUICK 0x00010000 |
| #define I2C_FUNC_SMBUS_READ_BYTE 0x00020000 |
| #define I2C_FUNC_SMBUS_WRITE_BYTE 0x00040000 |
| #define I2C_FUNC_SMBUS_READ_BYTE_DATA 0x00080000 |
| #define I2C_FUNC_SMBUS_WRITE_BYTE_DATA 0x00100000 |
| #define I2C_FUNC_SMBUS_READ_WORD_DATA 0x00200000 |
| #define I2C_FUNC_SMBUS_WRITE_WORD_DATA 0x00400000 |
| #define I2C_FUNC_SMBUS_PROC_CALL 0x00800000 |
| #define I2C_FUNC_SMBUS_READ_BLOCK_DATA 0x01000000 |
| #define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA 0x02000000 |
| #define I2C_FUNC_SMBUS_READ_I2C_BLOCK 0x04000000 /* I2C-like block xfer */ |
| #define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK 0x08000000 /* w/ 1-byte reg. addr. */ |
| #define I2C_FUNC_SMBUS_BYTE (I2C_FUNC_SMBUS_READ_BYTE | \ |
| I2C_FUNC_SMBUS_WRITE_BYTE) |
| #define I2C_FUNC_SMBUS_BYTE_DATA (I2C_FUNC_SMBUS_READ_BYTE_DATA | \ |
| I2C_FUNC_SMBUS_WRITE_BYTE_DATA) |
| #define I2C_FUNC_SMBUS_WORD_DATA (I2C_FUNC_SMBUS_READ_WORD_DATA | \ |
| I2C_FUNC_SMBUS_WRITE_WORD_DATA) |
| #define I2C_FUNC_SMBUS_BLOCK_DATA (I2C_FUNC_SMBUS_READ_BLOCK_DATA | \ |
| I2C_FUNC_SMBUS_WRITE_BLOCK_DATA) |
| #define I2C_FUNC_SMBUS_I2C_BLOCK (I2C_FUNC_SMBUS_READ_I2C_BLOCK | \ |
| I2C_FUNC_SMBUS_WRITE_I2C_BLOCK) |
| #define I2C_FUNC_SMBUS_EMUL (I2C_FUNC_SMBUS_QUICK | \ |
| I2C_FUNC_SMBUS_BYTE | \ |
| I2C_FUNC_SMBUS_BYTE_DATA | \ |
| I2C_FUNC_SMBUS_WORD_DATA | \ |
| I2C_FUNC_SMBUS_PROC_CALL | \ |
| I2C_FUNC_SMBUS_WRITE_BLOCK_DATA | \ |
| I2C_FUNC_SMBUS_I2C_BLOCK | \ |
| I2C_FUNC_SMBUS_PEC) |
| /* |
| * Data for SMBus Messages |
| */ |
| #define I2C_SMBUS_BLOCK_MAX 32 /* As specified in SMBus standard */ |
| union i2c_smbus_data { |
| __u8 byte; |
| __u16 word; |
| __u8 block[I2C_SMBUS_BLOCK_MAX + 2]; /* block[0] is used for length */ |
| /* and one more for user-space compatibility */ |
| }; |
| /* i2c_smbus_xfer read or write markers */ |
| #define I2C_SMBUS_READ 1 |
| #define I2C_SMBUS_WRITE 0 |
| /* SMBus transaction types (size parameter in the above functions) |
| Note: these no longer correspond to the (arbitrary) PIIX4 internal codes! */ |
| #define I2C_SMBUS_QUICK 0 |
| #define I2C_SMBUS_BYTE 1 |
| #define I2C_SMBUS_BYTE_DATA 2 |
| #define I2C_SMBUS_WORD_DATA 3 |
| #define I2C_SMBUS_PROC_CALL 4 |
| #define I2C_SMBUS_BLOCK_DATA 5 |
| #define I2C_SMBUS_I2C_BLOCK_BROKEN 6 |
| #define I2C_SMBUS_BLOCK_PROC_CALL 7 /* SMBus 2.0 */ |
| #define I2C_SMBUS_I2C_BLOCK_DATA 8 |
| #endif /* _LINUX_I2C_H */ |
| /drivers/video/drm/include/linux/idr.h |
|---|
| 0,0 → 1,144 |
| /* |
| * include/linux/idr.h |
| * |
| * 2002-10-18 written by Jim Houston jim.houston@ccur.com |
| * Copyright (C) 2002 by Concurrent Computer Corporation |
| * Distributed under the GNU GPL license version 2. |
| * |
| * Small id to pointer translation service avoiding fixed sized |
| * tables. |
| */ |
| #ifndef __IDR_H__ |
| #define __IDR_H__ |
| #include <types.h> |
| #include <errno-base.h> |
| //#include <linux/bitops.h> |
| //#include <linux/init.h> |
| //#include <linux/rcupdate.h> |
| struct rcu_head { |
| struct rcu_head *next; |
| void (*func)(struct rcu_head *head); |
| }; |
| # define IDR_BITS 5 |
| # define IDR_FULL 0xfffffffful |
| /* We can only use two of the bits in the top level because there is |
| only one possible bit in the top level (5 bits * 7 levels = 35 |
| bits, but you only use 31 bits in the id). */ |
| # define TOP_LEVEL_FULL (IDR_FULL >> 30) |
| #define IDR_SIZE (1 << IDR_BITS) |
| #define IDR_MASK ((1 << IDR_BITS)-1) |
| #define MAX_ID_SHIFT (sizeof(int)*8 - 1) |
| #define MAX_ID_BIT (1U << MAX_ID_SHIFT) |
| #define MAX_ID_MASK (MAX_ID_BIT - 1) |
| /* Leave the possibility of an incomplete final layer */ |
| #define MAX_LEVEL (MAX_ID_SHIFT + IDR_BITS - 1) / IDR_BITS |
| /* Number of id_layer structs to leave in free list */ |
| #define IDR_FREE_MAX MAX_LEVEL + MAX_LEVEL |
| struct idr_layer { |
| unsigned long bitmap; /* A zero bit means "space here" */ |
| struct idr_layer *ary[1<<IDR_BITS]; |
| int count; /* When zero, we can release it */ |
| int layer; /* distance from leaf */ |
| struct rcu_head rcu_head; |
| }; |
| struct idr { |
| struct idr_layer *top; |
| struct idr_layer *id_free; |
| int layers; /* only valid without concurrent changes */ |
| int id_free_cnt; |
| // spinlock_t lock; |
| }; |
| #define IDR_INIT(name) \ |
| { \ |
| .top = NULL, \ |
| .id_free = NULL, \ |
| .layers = 0, \ |
| .id_free_cnt = 0, \ |
| // .lock = __SPIN_LOCK_UNLOCKED(name.lock), \ |
| } |
| #define DEFINE_IDR(name) struct idr name = IDR_INIT(name) |
| /* Actions to be taken after a call to _idr_sub_alloc */ |
| #define IDR_NEED_TO_GROW -2 |
| #define IDR_NOMORE_SPACE -3 |
| #define _idr_rc_to_errno(rc) ((rc) == -1 ? -EAGAIN : -ENOSPC) |
| /** |
| * idr synchronization (stolen from radix-tree.h) |
| * |
| * idr_find() is able to be called locklessly, using RCU. The caller must |
| * ensure calls to this function are made within rcu_read_lock() regions. |
| * Other readers (lock-free or otherwise) and modifications may be running |
| * concurrently. |
| * |
| * It is still required that the caller manage the synchronization and |
| * lifetimes of the items. So if RCU lock-free lookups are used, typically |
| * this would mean that the items have their own locks, or are amenable to |
| * lock-free access; and that the items are freed by RCU (or only freed after |
| * having been deleted from the idr tree *and* a synchronize_rcu() grace |
| * period). |
| */ |
| /* |
| * This is what we export. |
| */ |
| void *idr_find(struct idr *idp, int id); |
| int idr_pre_get(struct idr *idp, u32_t gfp_mask); |
| int idr_get_new(struct idr *idp, void *ptr, int *id); |
| int idr_get_new_above(struct idr *idp, void *ptr, int starting_id, int *id); |
| int idr_for_each(struct idr *idp, |
| int (*fn)(int id, void *p, void *data), void *data); |
| void *idr_get_next(struct idr *idp, int *nextid); |
| void *idr_replace(struct idr *idp, void *ptr, int id); |
| void idr_remove(struct idr *idp, int id); |
| void idr_remove_all(struct idr *idp); |
| void idr_destroy(struct idr *idp); |
| void idr_init(struct idr *idp); |
| /* |
| * IDA - IDR based id allocator, use when translation from id to |
| * pointer isn't necessary. |
| */ |
| #define IDA_CHUNK_SIZE 128 /* 128 bytes per chunk */ |
| #define IDA_BITMAP_LONGS (128 / sizeof(long) - 1) |
| #define IDA_BITMAP_BITS (IDA_BITMAP_LONGS * sizeof(long) * 8) |
| struct ida_bitmap { |
| long nr_busy; |
| unsigned long bitmap[IDA_BITMAP_LONGS]; |
| }; |
| struct ida { |
| struct idr idr; |
| struct ida_bitmap *free_bitmap; |
| }; |
| #define IDA_INIT(name) { .idr = IDR_INIT(name), .free_bitmap = NULL, } |
| #define DEFINE_IDA(name) struct ida name = IDA_INIT(name) |
| int ida_pre_get(struct ida *ida, u32_t gfp_mask); |
| int ida_get_new_above(struct ida *ida, int starting_id, int *p_id); |
| int ida_get_new(struct ida *ida, int *p_id); |
| void ida_remove(struct ida *ida, int id); |
| void ida_destroy(struct ida *ida); |
| void ida_init(struct ida *ida); |
| void idr_init_cache(void); |
| #endif /* __IDR_H__ */ |
| /drivers/video/drm/include/types.h |
|---|
| 86,9 → 86,6 |
| #define DRM_INFO(fmt, arg...) dbgprintf("DRM: "fmt , ##arg) |
| #define DRM_DEBUG(fmt, arg...) \ |
| printk(KERN_ERR "[" DRM_NAME ":%s] *ERROR* " fmt , __func__ , ##arg) |
| #define DRM_ERROR(fmt, arg...) \ |
| printk(KERN_ERR "[" DRM_NAME ":%s] *ERROR* " fmt , __func__ , ##arg) |
| 230,24 → 227,6 |
| #define EXPORT_SYMBOL(x) |
| #define IDR_BITS 5 |
| #define IDR_FULL 0xfffffffful |
| struct idr_layer { |
| unsigned long bitmap; /* A zero bit means "space here" */ |
| struct idr_layer *ary[1<<IDR_BITS]; |
| int count; /* When zero, we can release it */ |
| }; |
| struct idr { |
| struct idr_layer *top; |
| struct idr_layer *id_free; |
| int layers; |
| int id_free_cnt; |
| // spinlock_t lock; |
| }; |
| #define min(x,y) ({ \ |
| typeof(x) _x = (x); \ |
| typeof(y) _y = (y); \ |
| 292,7 → 271,10 |
| { |
| if (n != 0 && size > ULONG_MAX / n) |
| return NULL; |
| return kmalloc(n * size, 0); |
| return kzalloc(n * size, 0); |
| } |
| #define ENTRY() dbgprintf("entry %s\n",__FUNCTION__) |
| #define LEAVE() dbgprintf("leave %s\n",__FUNCTION__) |
| #endif //__TYPES_H__ |