]> err.no Git - linux-2.6/blob - drivers/media/common/tuners/tuner-i2c.h
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ieee1394...
[linux-2.6] / drivers / media / common / tuners / tuner-i2c.h
1 /*
2     tuner-i2c.h - i2c interface for different tuners
3
4     Copyright (C) 2007 Michael Krufky (mkrufky@linuxtv.org)
5
6     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with this program; if not, write to the Free Software
18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #ifndef __TUNER_I2C_H__
22 #define __TUNER_I2C_H__
23
24 #include <linux/i2c.h>
25
26 struct tuner_i2c_props {
27         u8 addr;
28         struct i2c_adapter *adap;
29
30         /* used for tuner instance management */
31         int count;
32         char *name;
33 };
34
35 static inline int tuner_i2c_xfer_send(struct tuner_i2c_props *props, char *buf, int len)
36 {
37         struct i2c_msg msg = { .addr = props->addr, .flags = 0,
38                                .buf = buf, .len = len };
39         int ret = i2c_transfer(props->adap, &msg, 1);
40
41         return (ret == 1) ? len : ret;
42 }
43
44 static inline int tuner_i2c_xfer_recv(struct tuner_i2c_props *props, char *buf, int len)
45 {
46         struct i2c_msg msg = { .addr = props->addr, .flags = I2C_M_RD,
47                                .buf = buf, .len = len };
48         int ret = i2c_transfer(props->adap, &msg, 1);
49
50         return (ret == 1) ? len : ret;
51 }
52
53 static inline int tuner_i2c_xfer_send_recv(struct tuner_i2c_props *props,
54                                            char *obuf, int olen,
55                                            char *ibuf, int ilen)
56 {
57         struct i2c_msg msg[2] = { { .addr = props->addr, .flags = 0,
58                                     .buf = obuf, .len = olen },
59                                   { .addr = props->addr, .flags = I2C_M_RD,
60                                     .buf = ibuf, .len = ilen } };
61         int ret = i2c_transfer(props->adap, msg, 2);
62
63         return (ret == 2) ? ilen : ret;
64 }
65
66 /* Callers must declare as a global for the module:
67  *
68  * static LIST_HEAD(hybrid_tuner_instance_list);
69  *
70  * hybrid_tuner_instance_list should be the third argument
71  * passed into hybrid_tuner_request_state().
72  *
73  * state structure must contain the following:
74  *
75  *      struct list_head        hybrid_tuner_instance_list;
76  *      struct tuner_i2c_props  i2c_props;
77  *
78  * hybrid_tuner_instance_list (both within state structure and globally)
79  * is only required if the driver is using hybrid_tuner_request_state
80  * and hybrid_tuner_release_state to manage state sharing between
81  * multiple instances of hybrid tuners.
82  */
83
84 #define tuner_printk(kernlvl, i2cprops, fmt, arg...) do {               \
85         printk(kernlvl "%s %d-%04x: " fmt, i2cprops.name,               \
86                         i2cprops.adap ?                                 \
87                                 i2c_adapter_id(i2cprops.adap) : -1,     \
88                         i2cprops.addr, ##arg);                          \
89          } while (0)
90
91 /* TO DO: convert all callers of these macros to pass in
92  * struct tuner_i2c_props, then remove the macro wrappers */
93
94 #define __tuner_warn(i2cprops, fmt, arg...) do {                        \
95         tuner_printk(KERN_WARNING, i2cprops, fmt, ##arg);               \
96         } while (0)
97
98 #define __tuner_info(i2cprops, fmt, arg...) do {                        \
99         tuner_printk(KERN_INFO, i2cprops, fmt, ##arg);                  \
100         } while (0)
101
102 #define __tuner_err(i2cprops, fmt, arg...) do {                         \
103         tuner_printk(KERN_ERR, i2cprops, fmt, ##arg);                   \
104         } while (0)
105
106 #define __tuner_dbg(i2cprops, fmt, arg...) do {                         \
107         if ((debug))                                                    \
108                 tuner_printk(KERN_DEBUG, i2cprops, fmt, ##arg);         \
109         } while (0)
110
111 #define tuner_warn(fmt, arg...) __tuner_warn(priv->i2c_props, fmt, ##arg)
112 #define tuner_info(fmt, arg...) __tuner_info(priv->i2c_props, fmt, ##arg)
113 #define tuner_err(fmt, arg...) __tuner_err(priv->i2c_props, fmt, ##arg)
114 #define tuner_dbg(fmt, arg...) __tuner_dbg(priv->i2c_props, fmt, ##arg)
115
116 /****************************************************************************/
117
118 /* The return value of hybrid_tuner_request_state indicates the number of
119  * instances using this tuner object.
120  *
121  * 0 - no instances, indicates an error - kzalloc must have failed
122  *
123  * 1 - one instance, indicates that the tuner object was created successfully
124  *
125  * 2 (or more) instances, indicates that an existing tuner object was found
126  */
127
128 #define hybrid_tuner_request_state(type, state, list, i2cadap, i2caddr, devname)\
129 ({                                                                      \
130         int __ret = 0;                                                  \
131         list_for_each_entry(state, &list, hybrid_tuner_instance_list) { \
132                 if (((i2cadap) && (state->i2c_props.adap)) &&           \
133                     ((i2c_adapter_id(state->i2c_props.adap) ==          \
134                       i2c_adapter_id(i2cadap)) &&                       \
135                      (i2caddr == state->i2c_props.addr))) {             \
136                         __tuner_info(state->i2c_props,                  \
137                                      "attaching existing instance\n");  \
138                         state->i2c_props.count++;                       \
139                         __ret = state->i2c_props.count;                 \
140                         break;                                          \
141                 }                                                       \
142         }                                                               \
143         if (0 == __ret) {                                               \
144                 state = kzalloc(sizeof(type), GFP_KERNEL);              \
145                 if (NULL == state)                                      \
146                         goto __fail;                                    \
147                 state->i2c_props.addr = i2caddr;                        \
148                 state->i2c_props.adap = i2cadap;                        \
149                 state->i2c_props.name = devname;                        \
150                 __tuner_info(state->i2c_props,                          \
151                              "creating new instance\n");                \
152                 list_add_tail(&state->hybrid_tuner_instance_list, &list);\
153                 state->i2c_props.count++;                               \
154                 __ret = state->i2c_props.count;                         \
155         }                                                               \
156 __fail:                                                                 \
157         __ret;                                                          \
158 })
159
160 #define hybrid_tuner_release_state(state)                               \
161 ({                                                                      \
162         int __ret;                                                      \
163         state->i2c_props.count--;                                       \
164         __ret = state->i2c_props.count;                                 \
165         if (!state->i2c_props.count) {                                  \
166                 __tuner_info(state->i2c_props, "destroying instance\n");\
167                 list_del(&state->hybrid_tuner_instance_list);           \
168                 kfree(state);                                           \
169         }                                                               \
170         __ret;                                                          \
171 })
172
173 #endif /* __TUNER_I2C_H__ */