[media] remove the old RC_MAP_HAUPPAUGE_NEW RC map
[linux-2.6.git] / drivers / media / video / hdpvr / hdpvr-i2c.c
1
2 /*
3  * Hauppauge HD PVR USB driver
4  *
5  * Copyright (C) 2008      Janne Grunau (j@jannau.net)
6  *
7  * IR device registration code is
8  * Copyright (C) 2010   Andy Walls <awalls@md.metrocast.net>
9  *
10  *      This program is free software; you can redistribute it and/or
11  *      modify it under the terms of the GNU General Public License as
12  *      published by the Free Software Foundation, version 2.
13  *
14  */
15
16 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
17
18 #include <linux/i2c.h>
19 #include <linux/slab.h>
20
21 #include "hdpvr.h"
22
23 #define CTRL_READ_REQUEST       0xb8
24 #define CTRL_WRITE_REQUEST      0x38
25
26 #define REQTYPE_I2C_READ        0xb1
27 #define REQTYPE_I2C_WRITE       0xb0
28 #define REQTYPE_I2C_WRITE_STATT 0xd0
29
30 #define Z8F0811_IR_TX_I2C_ADDR  0x70
31 #define Z8F0811_IR_RX_I2C_ADDR  0x71
32
33
34 struct i2c_client *hdpvr_register_ir_tx_i2c(struct hdpvr_device *dev)
35 {
36         struct IR_i2c_init_data *init_data = &dev->ir_i2c_init_data;
37         struct i2c_board_info hdpvr_ir_tx_i2c_board_info = {
38                 I2C_BOARD_INFO("ir_tx_z8f0811_hdpvr", Z8F0811_IR_TX_I2C_ADDR),
39         };
40
41         init_data->name = "HD-PVR";
42         hdpvr_ir_tx_i2c_board_info.platform_data = init_data;
43
44         return i2c_new_device(&dev->i2c_adapter, &hdpvr_ir_tx_i2c_board_info);
45 }
46
47 struct i2c_client *hdpvr_register_ir_rx_i2c(struct hdpvr_device *dev)
48 {
49         struct IR_i2c_init_data *init_data = &dev->ir_i2c_init_data;
50         struct i2c_board_info hdpvr_ir_rx_i2c_board_info = {
51                 I2C_BOARD_INFO("ir_rx_z8f0811_hdpvr", Z8F0811_IR_RX_I2C_ADDR),
52         };
53
54         /* Our default information for ir-kbd-i2c.c to use */
55         init_data->ir_codes = RC_MAP_HAUPPAUGE;
56         init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP_XVR;
57         init_data->type = RC_TYPE_RC5;
58         init_data->name = "HD-PVR";
59         hdpvr_ir_rx_i2c_board_info.platform_data = init_data;
60
61         return i2c_new_device(&dev->i2c_adapter, &hdpvr_ir_rx_i2c_board_info);
62 }
63
64 static int hdpvr_i2c_read(struct hdpvr_device *dev, int bus,
65                           unsigned char addr, char *wdata, int wlen,
66                           char *data, int len)
67 {
68         int ret;
69
70         if ((len > sizeof(dev->i2c_buf)) || (wlen > sizeof(dev->i2c_buf)))
71                 return -EINVAL;
72
73         if (wlen) {
74                 memcpy(&dev->i2c_buf, wdata, wlen);
75                 ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
76                                       REQTYPE_I2C_WRITE, CTRL_WRITE_REQUEST,
77                                       (bus << 8) | addr, 0, &dev->i2c_buf,
78                                       wlen, 1000);
79                 if (ret < 0)
80                         return ret;
81         }
82
83         ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
84                               REQTYPE_I2C_READ, CTRL_READ_REQUEST,
85                               (bus << 8) | addr, 0, &dev->i2c_buf, len, 1000);
86
87         if (ret == len) {
88                 memcpy(data, &dev->i2c_buf, len);
89                 ret = 0;
90         } else if (ret >= 0)
91                 ret = -EIO;
92
93         return ret;
94 }
95
96 static int hdpvr_i2c_write(struct hdpvr_device *dev, int bus,
97                            unsigned char addr, char *data, int len)
98 {
99         int ret;
100
101         if (len > sizeof(dev->i2c_buf))
102                 return -EINVAL;
103
104         memcpy(&dev->i2c_buf, data, len);
105         ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
106                               REQTYPE_I2C_WRITE, CTRL_WRITE_REQUEST,
107                               (bus << 8) | addr, 0, &dev->i2c_buf, len, 1000);
108
109         if (ret < 0)
110                 return ret;
111
112         ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
113                               REQTYPE_I2C_WRITE_STATT, CTRL_READ_REQUEST,
114                               0, 0, &dev->i2c_buf, 2, 1000);
115
116         if ((ret == 2) && (dev->i2c_buf[1] == (len - 1)))
117                 ret = 0;
118         else if (ret >= 0)
119                 ret = -EIO;
120
121         return ret;
122 }
123
124 static int hdpvr_transfer(struct i2c_adapter *i2c_adapter, struct i2c_msg *msgs,
125                           int num)
126 {
127         struct hdpvr_device *dev = i2c_get_adapdata(i2c_adapter);
128         int retval = 0, addr;
129
130         if (num <= 0)
131                 return 0;
132
133         mutex_lock(&dev->i2c_mutex);
134
135         addr = msgs[0].addr << 1;
136
137         if (num == 1) {
138                 if (msgs[0].flags & I2C_M_RD)
139                         retval = hdpvr_i2c_read(dev, 1, addr, NULL, 0,
140                                                 msgs[0].buf, msgs[0].len);
141                 else
142                         retval = hdpvr_i2c_write(dev, 1, addr, msgs[0].buf,
143                                                  msgs[0].len);
144         } else if (num == 2) {
145                 if (msgs[0].addr != msgs[1].addr) {
146                         v4l2_warn(&dev->v4l2_dev, "refusing 2-phase i2c xfer "
147                                   "with conflicting target addresses\n");
148                         retval = -EINVAL;
149                         goto out;
150                 }
151
152                 if ((msgs[0].flags & I2C_M_RD) || !(msgs[1].flags & I2C_M_RD)) {
153                         v4l2_warn(&dev->v4l2_dev, "refusing complex xfer with "
154                                   "r0=%d, r1=%d\n", msgs[0].flags & I2C_M_RD,
155                                   msgs[1].flags & I2C_M_RD);
156                         retval = -EINVAL;
157                         goto out;
158                 }
159
160                 /*
161                  * Write followed by atomic read is the only complex xfer that
162                  * we actually support here.
163                  */
164                 retval = hdpvr_i2c_read(dev, 1, addr, msgs[0].buf, msgs[0].len,
165                                         msgs[1].buf, msgs[1].len);
166         } else {
167                 v4l2_warn(&dev->v4l2_dev, "refusing %d-phase i2c xfer\n", num);
168         }
169
170 out:
171         mutex_unlock(&dev->i2c_mutex);
172
173         return retval ? retval : num;
174 }
175
176 static u32 hdpvr_functionality(struct i2c_adapter *adapter)
177 {
178         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
179 }
180
181 static struct i2c_algorithm hdpvr_algo = {
182         .master_xfer   = hdpvr_transfer,
183         .functionality = hdpvr_functionality,
184 };
185
186 static struct i2c_adapter hdpvr_i2c_adapter_template = {
187         .name   = "Hauppage HD PVR I2C",
188         .owner  = THIS_MODULE,
189         .algo   = &hdpvr_algo,
190 };
191
192 static int hdpvr_activate_ir(struct hdpvr_device *dev)
193 {
194         char buffer[8];
195
196         mutex_lock(&dev->i2c_mutex);
197
198         hdpvr_i2c_read(dev, 0, 0x54, NULL, 0, buffer, 1);
199
200         buffer[0] = 0;
201         buffer[1] = 0x8;
202         hdpvr_i2c_write(dev, 1, 0x54, buffer, 2);
203
204         buffer[1] = 0x18;
205         hdpvr_i2c_write(dev, 1, 0x54, buffer, 2);
206
207         mutex_unlock(&dev->i2c_mutex);
208
209         return 0;
210 }
211
212 int hdpvr_register_i2c_adapter(struct hdpvr_device *dev)
213 {
214         int retval = -ENOMEM;
215
216         hdpvr_activate_ir(dev);
217
218         memcpy(&dev->i2c_adapter, &hdpvr_i2c_adapter_template,
219                sizeof(struct i2c_adapter));
220         dev->i2c_adapter.dev.parent = &dev->udev->dev;
221
222         i2c_set_adapdata(&dev->i2c_adapter, dev);
223
224         retval = i2c_add_adapter(&dev->i2c_adapter);
225
226         return retval;
227 }
228
229 #endif