drivers/media/dvb-frontends/drx39xyj/drx39xxj_dummy.c

   1 #include <linux/kernel.h>
   2 #include <linux/init.h>
   3 #include <linux/module.h>
   4 #include <linux/string.h>
   5 #include <linux/slab.h>
   6 #include <linux/delay.h>
   7 #include <linux/jiffies.h>
   8 #include <linux/types.h>
   9
  10 #include "drx_driver.h"
  11 #include "drx39xxj.h"
  12
  13 /* Dummy function to satisfy drxj.c */
  14 int drxbsp_tuner_open(struct tuner_instance *tuner)
  15 {
  16         return DRX_STS_OK;
  17 }
  18
  19 int drxbsp_tuner_close(struct tuner_instance *tuner)
  20 {
  21         return DRX_STS_OK;
  22 }
  23
  24 int drxbsp_tuner_set_frequency(struct tuner_instance *tuner,
  25                                       u32 mode,
  26                                       s32 center_frequency)
  27 {
  28         return DRX_STS_OK;
  29 }
  30
  31 int
  32 drxbsp_tuner_get_frequency(struct tuner_instance *tuner,
  33                            u32 mode,
  34                           s32 *r_ffrequency,
  35                           s32 *i_ffrequency)
  36 {
  37         return DRX_STS_OK;
  38 }
  39
  40 int drxbsp_hst_sleep(u32 n)
  41 {
  42         msleep(n);
  43         return DRX_STS_OK;
  44 }
  45
  46 u32 drxbsp_hst_clock(void)
  47 {
  48         return jiffies_to_msecs(jiffies);
  49 }
  50
  51 int drxbsp_hst_memcmp(void *s1, void *s2, u32 n)
  52 {
  53         return (memcmp(s1, s2, (size_t) n));
  54 }
  55
  56 void *drxbsp_hst_memcpy(void *to, void *from, u32 n)
  57 {
  58         return (memcpy(to, from, (size_t) n));
  59 }
  60
  61 int drxbsp_i2c_write_read(struct i2c_device_addr *w_dev_addr,
  62                                  u16 w_count,
  63                                  u8 *wData,
  64                                  struct i2c_device_addr *r_dev_addr,
  65                                  u16 r_count, u8 *r_data)
  66 {
  67         struct drx39xxj_state *state;
  68         struct i2c_msg msg[2];
  69         unsigned int num_msgs;
  70
  71         if (w_dev_addr == NULL) {
  72                 /* Read only */
  73                 state = r_dev_addr->user_data;
  74                 msg[0].addr = r_dev_addr->i2c_addr >> 1;
  75                 msg[0].flags = I2C_M_RD;
  76                 msg[0].buf = r_data;
  77                 msg[0].len = r_count;
  78                 num_msgs = 1;
  79         } else if (r_dev_addr == NULL) {
  80                 /* Write only */
  81                 state = w_dev_addr->user_data;
  82                 msg[0].addr = w_dev_addr->i2c_addr >> 1;
  83                 msg[0].flags = 0;
  84                 msg[0].buf = wData;
  85                 msg[0].len = w_count;
  86                 num_msgs = 1;
  87         } else {
  88                 /* Both write and read */
  89                 state = w_dev_addr->user_data;
  90                 msg[0].addr = w_dev_addr->i2c_addr >> 1;
  91                 msg[0].flags = 0;
  92                 msg[0].buf = wData;
  93                 msg[0].len = w_count;
  94                 msg[1].addr = r_dev_addr->i2c_addr >> 1;
  95                 msg[1].flags = I2C_M_RD;
  96                 msg[1].buf = r_data;
  97                 msg[1].len = r_count;
  98                 num_msgs = 2;
  99         }
 100
 101         if (state->i2c == NULL) {
 102                 printk("i2c was zero, aborting\n");
 103                 return 0;
 104         }
 105         if (i2c_transfer(state->i2c, msg, num_msgs) != num_msgs) {
 106                 printk(KERN_WARNING "drx3933: I2C write/read failed\n");
 107                 return -EREMOTEIO;
 108         }
 109
 110         return DRX_STS_OK;
 111
 112 #ifdef DJH_DEBUG
 113         struct drx39xxj_state *state = w_dev_addr->user_data;
 114
 115         struct i2c_msg msg[2] = {
 116                 {.addr = w_dev_addr->i2c_addr,
 117                  .flags = 0, .buf = wData, .len = w_count},
 118                 {.addr = r_dev_addr->i2c_addr,
 119                  .flags = I2C_M_RD, .buf = r_data, .len = r_count},
 120         };
 121
 122         printk("drx3933 i2c operation addr=%x i2c=%p, wc=%x rc=%x\n",
 123                w_dev_addr->i2c_addr, state->i2c, w_count, r_count);
 124
 125         if (i2c_transfer(state->i2c, msg, 2) != 2) {
 126                 printk(KERN_WARNING "drx3933: I2C write/read failed\n");
 127                 return -EREMOTEIO;
 128         }
 129 #endif
 130         return 0;
 131 }