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 #define hybrid_tuner_report_instance_count(state)                       \
 174 ({                                                                      \
 175         int __ret = 0;                                                  \
 176         if (state)                                                      \
 177                 __ret = state->i2c_props.count;                         \
 178         __ret;                                                          \
 179 })
 180
 181 #endif /* __TUNER_I2C_H__ */