err.no Git - linux-2.6/blob - drivers/media/video/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                         i2c_adapter_id(i2cprops.adap),                  \
  87                         i2cprops.addr, ##arg);                          \
  88          } while (0)
  89
  90 /* TO DO: convert all callers of these macros to pass in
  91  * struct tuner_i2c_props, then remove the macro wrappers */
  92
  93 #define __tuner_warn(i2cprops, fmt, arg...) do {                        \
  94         tuner_printk(KERN_WARNING, i2cprops, fmt, ##arg);               \
  95         } while (0)
  96
  97 #define __tuner_info(i2cprops, fmt, arg...) do {                        \
  98         tuner_printk(KERN_INFO, i2cprops, fmt, ##arg);                  \
  99         } while (0)
 100
 101 #define __tuner_err(i2cprops, fmt, arg...) do {                         \
 102         tuner_printk(KERN_ERR, i2cprops, fmt, ##arg);                   \
 103         } while (0)
 104
 105 #define __tuner_dbg(i2cprops, fmt, arg...) do {                         \
 106         if ((debug))                                                    \
 107                 tuner_printk(KERN_DEBUG, i2cprops, fmt, ##arg);         \
 108         } while (0)
 109
 110 #define tuner_warn(fmt, arg...) __tuner_warn(priv->i2c_props, fmt, ##arg)
 111 #define tuner_info(fmt, arg...) __tuner_info(priv->i2c_props, fmt, ##arg)
 112 #define tuner_err(fmt, arg...) __tuner_err(priv->i2c_props, fmt, ##arg)
 113 #define tuner_dbg(fmt, arg...) __tuner_dbg(priv->i2c_props, fmt, ##arg)
 114
 115 /****************************************************************************/
 116
 117 /* The return value of hybrid_tuner_request_state indicates the number of
 118  * instances using this tuner object.
 119  *
 120  * 0 - no instances, indicates an error - kzalloc must have failed
 121  *
 122  * 1 - one instance, indicates that the tuner object was created successfully
 123  *
 124  * 2 (or more) instances, indicates that an existing tuner object was found
 125  */
 126
 127 #define hybrid_tuner_request_state(type, state, list, i2cadap, i2caddr, devname)\
 128 ({                                                                      \
 129         int __ret = 0;                                                  \
 130         list_for_each_entry(state, &list, hybrid_tuner_instance_list) { \
 131                 if ((i2c_adapter_id(state->i2c_props.adap) ==           \
 132                      i2c_adapter_id(i2cadap)) &&                        \
 133                     (state->i2c_props.addr == i2caddr)) {               \
 134                         __tuner_info(state->i2c_props,                  \
 135                                      "attaching existing instance\n");  \
 136                         state->i2c_props.count++;                       \
 137                         __ret = state->i2c_props.count;                 \
 138                         break;                                          \
 139                 }                                                       \
 140         }                                                               \
 141         if (0 == __ret) {                                               \
 142                 state = kzalloc(sizeof(type), GFP_KERNEL);              \
 143                 if (NULL == state)                                      \
 144                         goto __fail;                                    \
 145                 state->i2c_props.addr = i2caddr;                        \
 146                 state->i2c_props.adap = i2cadap;                        \
 147                 state->i2c_props.name = devname;                        \
 148                 __tuner_info(state->i2c_props,                          \
 149                              "creating new instance\n");                \
 150                 list_add_tail(&state->hybrid_tuner_instance_list, &list);\
 151                 state->i2c_props.count++;                               \
 152                 __ret = state->i2c_props.count;                         \
 153         }                                                               \
 154 __fail:                                                                 \
 155         __ret;                                                          \
 156 })
 157
 158 #define hybrid_tuner_release_state(state)                               \
 159 ({                                                                      \
 160         int __ret;                                                      \
 161         state->i2c_props.count--;                                       \
 162         __ret = state->i2c_props.count;                                 \
 163         if (!state->i2c_props.count) {                                  \
 164                 __tuner_info(state->i2c_props, "destroying instance\n");\
 165                 list_del(&state->hybrid_tuner_instance_list);           \
 166                 kfree(state);                                           \
 167         }                                                               \
 168         __ret;                                                          \
 169 })
 170
 171 #endif /* __TUNER_I2C_H__ */