This source file includes following definitions.
- wait_ci_ready
- read_attribute_mem
- write_attribute_mem
- read_cam_control
- write_cam_control
- slot_reset
- slot_shutdown
- slot_ts_enable
- poll_slot_status
- ci_attach
- write_creg
- read_attribute_mem_xo2
- write_attribute_mem_xo2
- read_cam_control_xo2
- write_cam_control_xo2
- slot_reset_xo2
- slot_shutdown_xo2
- slot_ts_enable_xo2
- poll_slot_status_xo2
- ci_xo2_attach
- ci_cxd2099_attach
- ddb_ci_attach
- ddb_ci_detach
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 #include "ddbridge.h"
20 #include "ddbridge-regs.h"
21 #include "ddbridge-ci.h"
22 #include "ddbridge-io.h"
23 #include "ddbridge-i2c.h"
24
25 #include "cxd2099.h"
26
27
28
29 static int wait_ci_ready(struct ddb_ci *ci)
30 {
31 u32 count = 10;
32
33 ndelay(500);
34 do {
35 if (ddbreadl(ci->port->dev,
36 CI_CONTROL(ci->nr)) & CI_READY)
37 break;
38 usleep_range(1, 2);
39 if ((--count) == 0)
40 return -1;
41 } while (1);
42 return 0;
43 }
44
45 static int read_attribute_mem(struct dvb_ca_en50221 *ca,
46 int slot, int address)
47 {
48 struct ddb_ci *ci = ca->data;
49 u32 val, off = (address >> 1) & (CI_BUFFER_SIZE - 1);
50
51 if (address > CI_BUFFER_SIZE)
52 return -1;
53 ddbwritel(ci->port->dev, CI_READ_CMD | (1 << 16) | address,
54 CI_DO_READ_ATTRIBUTES(ci->nr));
55 wait_ci_ready(ci);
56 val = 0xff & ddbreadl(ci->port->dev, CI_BUFFER(ci->nr) + off);
57 return val;
58 }
59
60 static int write_attribute_mem(struct dvb_ca_en50221 *ca, int slot,
61 int address, u8 value)
62 {
63 struct ddb_ci *ci = ca->data;
64
65 ddbwritel(ci->port->dev, CI_WRITE_CMD | (value << 16) | address,
66 CI_DO_ATTRIBUTE_RW(ci->nr));
67 wait_ci_ready(ci);
68 return 0;
69 }
70
71 static int read_cam_control(struct dvb_ca_en50221 *ca,
72 int slot, u8 address)
73 {
74 u32 count = 100;
75 struct ddb_ci *ci = ca->data;
76 u32 res;
77
78 ddbwritel(ci->port->dev, CI_READ_CMD | address,
79 CI_DO_IO_RW(ci->nr));
80 ndelay(500);
81 do {
82 res = ddbreadl(ci->port->dev, CI_READDATA(ci->nr));
83 if (res & CI_READY)
84 break;
85 usleep_range(1, 2);
86 if ((--count) == 0)
87 return -1;
88 } while (1);
89 return 0xff & res;
90 }
91
92 static int write_cam_control(struct dvb_ca_en50221 *ca, int slot,
93 u8 address, u8 value)
94 {
95 struct ddb_ci *ci = ca->data;
96
97 ddbwritel(ci->port->dev, CI_WRITE_CMD | (value << 16) | address,
98 CI_DO_IO_RW(ci->nr));
99 wait_ci_ready(ci);
100 return 0;
101 }
102
103 static int slot_reset(struct dvb_ca_en50221 *ca, int slot)
104 {
105 struct ddb_ci *ci = ca->data;
106
107 ddbwritel(ci->port->dev, CI_POWER_ON,
108 CI_CONTROL(ci->nr));
109 msleep(100);
110 ddbwritel(ci->port->dev, CI_POWER_ON | CI_RESET_CAM,
111 CI_CONTROL(ci->nr));
112 ddbwritel(ci->port->dev, CI_ENABLE | CI_POWER_ON | CI_RESET_CAM,
113 CI_CONTROL(ci->nr));
114 usleep_range(20, 25);
115 ddbwritel(ci->port->dev, CI_ENABLE | CI_POWER_ON,
116 CI_CONTROL(ci->nr));
117 return 0;
118 }
119
120 static int slot_shutdown(struct dvb_ca_en50221 *ca, int slot)
121 {
122 struct ddb_ci *ci = ca->data;
123
124 ddbwritel(ci->port->dev, 0, CI_CONTROL(ci->nr));
125 msleep(300);
126 return 0;
127 }
128
129 static int slot_ts_enable(struct dvb_ca_en50221 *ca, int slot)
130 {
131 struct ddb_ci *ci = ca->data;
132 u32 val = ddbreadl(ci->port->dev, CI_CONTROL(ci->nr));
133
134 ddbwritel(ci->port->dev, val | CI_BYPASS_DISABLE,
135 CI_CONTROL(ci->nr));
136 return 0;
137 }
138
139 static int poll_slot_status(struct dvb_ca_en50221 *ca, int slot, int open)
140 {
141 struct ddb_ci *ci = ca->data;
142 u32 val = ddbreadl(ci->port->dev, CI_CONTROL(ci->nr));
143 int stat = 0;
144
145 if (val & CI_CAM_DETECT)
146 stat |= DVB_CA_EN50221_POLL_CAM_PRESENT;
147 if (val & CI_CAM_READY)
148 stat |= DVB_CA_EN50221_POLL_CAM_READY;
149 return stat;
150 }
151
152 static struct dvb_ca_en50221 en_templ = {
153 .read_attribute_mem = read_attribute_mem,
154 .write_attribute_mem = write_attribute_mem,
155 .read_cam_control = read_cam_control,
156 .write_cam_control = write_cam_control,
157 .slot_reset = slot_reset,
158 .slot_shutdown = slot_shutdown,
159 .slot_ts_enable = slot_ts_enable,
160 .poll_slot_status = poll_slot_status,
161 };
162
163 static void ci_attach(struct ddb_port *port)
164 {
165 struct ddb_ci *ci;
166
167 ci = kzalloc(sizeof(*ci), GFP_KERNEL);
168 if (!ci)
169 return;
170 memcpy(&ci->en, &en_templ, sizeof(en_templ));
171 ci->en.data = ci;
172 port->en = &ci->en;
173 port->en_freedata = 1;
174 ci->port = port;
175 ci->nr = port->nr - 2;
176 }
177
178
179
180 static int write_creg(struct ddb_ci *ci, u8 data, u8 mask)
181 {
182 struct i2c_adapter *i2c = &ci->port->i2c->adap;
183 u8 adr = (ci->port->type == DDB_CI_EXTERNAL_XO2) ? 0x12 : 0x13;
184
185 ci->port->creg = (ci->port->creg & ~mask) | data;
186 return i2c_write_reg(i2c, adr, 0x02, ci->port->creg);
187 }
188
189 static int read_attribute_mem_xo2(struct dvb_ca_en50221 *ca,
190 int slot, int address)
191 {
192 struct ddb_ci *ci = ca->data;
193 struct i2c_adapter *i2c = &ci->port->i2c->adap;
194 u8 adr = (ci->port->type == DDB_CI_EXTERNAL_XO2) ? 0x12 : 0x13;
195 int res;
196 u8 val;
197
198 res = i2c_read_reg16(i2c, adr, 0x8000 | address, &val);
199 return res ? res : val;
200 }
201
202 static int write_attribute_mem_xo2(struct dvb_ca_en50221 *ca, int slot,
203 int address, u8 value)
204 {
205 struct ddb_ci *ci = ca->data;
206 struct i2c_adapter *i2c = &ci->port->i2c->adap;
207 u8 adr = (ci->port->type == DDB_CI_EXTERNAL_XO2) ? 0x12 : 0x13;
208
209 return i2c_write_reg16(i2c, adr, 0x8000 | address, value);
210 }
211
212 static int read_cam_control_xo2(struct dvb_ca_en50221 *ca,
213 int slot, u8 address)
214 {
215 struct ddb_ci *ci = ca->data;
216 struct i2c_adapter *i2c = &ci->port->i2c->adap;
217 u8 adr = (ci->port->type == DDB_CI_EXTERNAL_XO2) ? 0x12 : 0x13;
218 u8 val;
219 int res;
220
221 res = i2c_read_reg(i2c, adr, 0x20 | (address & 3), &val);
222 return res ? res : val;
223 }
224
225 static int write_cam_control_xo2(struct dvb_ca_en50221 *ca, int slot,
226 u8 address, u8 value)
227 {
228 struct ddb_ci *ci = ca->data;
229 struct i2c_adapter *i2c = &ci->port->i2c->adap;
230 u8 adr = (ci->port->type == DDB_CI_EXTERNAL_XO2) ? 0x12 : 0x13;
231
232 return i2c_write_reg(i2c, adr, 0x20 | (address & 3), value);
233 }
234
235 static int slot_reset_xo2(struct dvb_ca_en50221 *ca, int slot)
236 {
237 struct ddb_ci *ci = ca->data;
238
239 dev_dbg(ci->port->dev->dev, "%s\n", __func__);
240 write_creg(ci, 0x01, 0x01);
241 write_creg(ci, 0x04, 0x04);
242 msleep(20);
243 write_creg(ci, 0x02, 0x02);
244 write_creg(ci, 0x00, 0x04);
245 write_creg(ci, 0x18, 0x18);
246 return 0;
247 }
248
249 static int slot_shutdown_xo2(struct dvb_ca_en50221 *ca, int slot)
250 {
251 struct ddb_ci *ci = ca->data;
252
253 dev_dbg(ci->port->dev->dev, "%s\n", __func__);
254 write_creg(ci, 0x10, 0xff);
255 write_creg(ci, 0x08, 0x08);
256 return 0;
257 }
258
259 static int slot_ts_enable_xo2(struct dvb_ca_en50221 *ca, int slot)
260 {
261 struct ddb_ci *ci = ca->data;
262
263 dev_dbg(ci->port->dev->dev, "%s\n", __func__);
264 write_creg(ci, 0x00, 0x10);
265 return 0;
266 }
267
268 static int poll_slot_status_xo2(struct dvb_ca_en50221 *ca, int slot, int open)
269 {
270 struct ddb_ci *ci = ca->data;
271 struct i2c_adapter *i2c = &ci->port->i2c->adap;
272 u8 adr = (ci->port->type == DDB_CI_EXTERNAL_XO2) ? 0x12 : 0x13;
273 u8 val = 0;
274 int stat = 0;
275
276 i2c_read_reg(i2c, adr, 0x01, &val);
277
278 if (val & 2)
279 stat |= DVB_CA_EN50221_POLL_CAM_PRESENT;
280 if (val & 1)
281 stat |= DVB_CA_EN50221_POLL_CAM_READY;
282 return stat;
283 }
284
285 static struct dvb_ca_en50221 en_xo2_templ = {
286 .read_attribute_mem = read_attribute_mem_xo2,
287 .write_attribute_mem = write_attribute_mem_xo2,
288 .read_cam_control = read_cam_control_xo2,
289 .write_cam_control = write_cam_control_xo2,
290 .slot_reset = slot_reset_xo2,
291 .slot_shutdown = slot_shutdown_xo2,
292 .slot_ts_enable = slot_ts_enable_xo2,
293 .poll_slot_status = poll_slot_status_xo2,
294 };
295
296 static void ci_xo2_attach(struct ddb_port *port)
297 {
298 struct ddb_ci *ci;
299
300 ci = kzalloc(sizeof(*ci), GFP_KERNEL);
301 if (!ci)
302 return;
303 memcpy(&ci->en, &en_xo2_templ, sizeof(en_xo2_templ));
304 ci->en.data = ci;
305 port->en = &ci->en;
306 port->en_freedata = 1;
307 ci->port = port;
308 ci->nr = port->nr - 2;
309 ci->port->creg = 0;
310 write_creg(ci, 0x10, 0xff);
311 write_creg(ci, 0x08, 0x08);
312 }
313
314 static const struct cxd2099_cfg cxd_cfgtmpl = {
315 .bitrate = 72000,
316 .polarity = 1,
317 .clock_mode = 1,
318 .max_i2c = 512,
319 };
320
321 static int ci_cxd2099_attach(struct ddb_port *port, u32 bitrate)
322 {
323 struct cxd2099_cfg cxd_cfg = cxd_cfgtmpl;
324 struct i2c_client *client;
325
326 cxd_cfg.bitrate = bitrate;
327 cxd_cfg.en = &port->en;
328
329 client = dvb_module_probe("cxd2099", NULL, &port->i2c->adap,
330 0x40, &cxd_cfg);
331 if (!client)
332 goto err;
333
334 port->dvb[0].i2c_client[0] = client;
335 port->en_freedata = 0;
336 return 0;
337
338 err:
339 dev_err(port->dev->dev, "CXD2099AR attach failed\n");
340 return -ENODEV;
341 }
342
343 int ddb_ci_attach(struct ddb_port *port, u32 bitrate)
344 {
345 int ret;
346
347 switch (port->type) {
348 case DDB_CI_EXTERNAL_SONY:
349 ret = ci_cxd2099_attach(port, bitrate);
350 if (ret)
351 return -ENODEV;
352 break;
353 case DDB_CI_EXTERNAL_XO2:
354 case DDB_CI_EXTERNAL_XO2_B:
355 ci_xo2_attach(port);
356 break;
357 case DDB_CI_INTERNAL:
358 ci_attach(port);
359 break;
360 default:
361 return -ENODEV;
362 }
363
364 if (!port->en)
365 return -ENODEV;
366 dvb_ca_en50221_init(port->dvb[0].adap, port->en, 0, 1);
367 return 0;
368 }
369
370 void ddb_ci_detach(struct ddb_port *port)
371 {
372 if (port->dvb[0].dev)
373 dvb_unregister_device(port->dvb[0].dev);
374 if (port->en) {
375 dvb_ca_en50221_release(port->en);
376
377 dvb_module_release(port->dvb[0].i2c_client[0]);
378 port->dvb[0].i2c_client[0] = NULL;
379
380
381 if (port->en_freedata)
382 kfree(port->en->data);
383
384 port->en = NULL;
385 }
386 }