]>
Commit | Line | Data |
---|---|---|
15490795 SR |
1 | /* |
2 | * FireDTV driver (formerly known as FireSAT) | |
3 | * | |
4 | * Copyright (C) 2004 Andreas Monitzer <andy@monitzer.com> | |
5 | * Copyright (C) 2008 Ben Backx <ben@bbackx.com> | |
6 | * Copyright (C) 2008 Henrik Kurelid <henrik@kurelid.se> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU General Public License as | |
10 | * published by the Free Software Foundation; either version 2 of | |
11 | * the License, or (at your option) any later version. | |
12 | */ | |
13 | ||
14 | #include <linux/bug.h> | |
15 | #include <linux/crc32.h> | |
16 | #include <linux/delay.h> | |
17 | #include <linux/device.h> | |
18 | #include <linux/jiffies.h> | |
19 | #include <linux/kernel.h> | |
20 | #include <linux/moduleparam.h> | |
21 | #include <linux/mutex.h> | |
22 | #include <linux/string.h> | |
23 | #include <linux/stringify.h> | |
24 | #include <linux/wait.h> | |
25 | #include <linux/workqueue.h> | |
26 | ||
d2fd44a3 TJ |
27 | #include <dvb_frontend.h> |
28 | ||
15490795 SR |
29 | #include "firedtv.h" |
30 | ||
31 | #define FCP_COMMAND_REGISTER 0xfffff0000b00ULL | |
32 | ||
33 | #define AVC_CTYPE_CONTROL 0x0 | |
34 | #define AVC_CTYPE_STATUS 0x1 | |
35 | #define AVC_CTYPE_NOTIFY 0x3 | |
36 | ||
37 | #define AVC_RESPONSE_ACCEPTED 0x9 | |
38 | #define AVC_RESPONSE_STABLE 0xc | |
39 | #define AVC_RESPONSE_CHANGED 0xd | |
40 | #define AVC_RESPONSE_INTERIM 0xf | |
41 | ||
42 | #define AVC_SUBUNIT_TYPE_TUNER (0x05 << 3) | |
43 | #define AVC_SUBUNIT_TYPE_UNIT (0x1f << 3) | |
44 | ||
45 | #define AVC_OPCODE_VENDOR 0x00 | |
46 | #define AVC_OPCODE_READ_DESCRIPTOR 0x09 | |
47 | #define AVC_OPCODE_DSIT 0xc8 | |
48 | #define AVC_OPCODE_DSD 0xcb | |
49 | ||
50 | #define DESCRIPTOR_TUNER_STATUS 0x80 | |
51 | #define DESCRIPTOR_SUBUNIT_IDENTIFIER 0x00 | |
52 | ||
53 | #define SFE_VENDOR_DE_COMPANYID_0 0x00 /* OUI of Digital Everywhere */ | |
54 | #define SFE_VENDOR_DE_COMPANYID_1 0x12 | |
55 | #define SFE_VENDOR_DE_COMPANYID_2 0x87 | |
56 | ||
57 | #define SFE_VENDOR_OPCODE_REGISTER_REMOTE_CONTROL 0x0a | |
58 | #define SFE_VENDOR_OPCODE_LNB_CONTROL 0x52 | |
59 | #define SFE_VENDOR_OPCODE_TUNE_QPSK 0x58 /* for DVB-S */ | |
60 | ||
61 | #define SFE_VENDOR_OPCODE_GET_FIRMWARE_VERSION 0x00 | |
62 | #define SFE_VENDOR_OPCODE_HOST2CA 0x56 | |
63 | #define SFE_VENDOR_OPCODE_CA2HOST 0x57 | |
64 | #define SFE_VENDOR_OPCODE_CISTATUS 0x59 | |
65 | #define SFE_VENDOR_OPCODE_TUNE_QPSK2 0x60 /* for DVB-S2 */ | |
66 | ||
67 | #define SFE_VENDOR_TAG_CA_RESET 0x00 | |
68 | #define SFE_VENDOR_TAG_CA_APPLICATION_INFO 0x01 | |
69 | #define SFE_VENDOR_TAG_CA_PMT 0x02 | |
70 | #define SFE_VENDOR_TAG_CA_DATE_TIME 0x04 | |
71 | #define SFE_VENDOR_TAG_CA_MMI 0x05 | |
72 | #define SFE_VENDOR_TAG_CA_ENTER_MENU 0x07 | |
73 | ||
74 | #define EN50221_LIST_MANAGEMENT_ONLY 0x03 | |
75 | #define EN50221_TAG_APP_INFO 0x9f8021 | |
76 | #define EN50221_TAG_CA_INFO 0x9f8031 | |
77 | ||
78 | struct avc_command_frame { | |
15490795 SR |
79 | u8 ctype; |
80 | u8 subunit; | |
81 | u8 opcode; | |
82 | u8 operand[509]; | |
83 | }; | |
84 | ||
85 | struct avc_response_frame { | |
15490795 SR |
86 | u8 response; |
87 | u8 subunit; | |
88 | u8 opcode; | |
89 | u8 operand[509]; | |
90 | }; | |
91 | ||
1e4348c8 SR |
92 | #define LAST_OPERAND (509 - 1) |
93 | ||
94 | static inline void clear_operands(struct avc_command_frame *c, int from, int to) | |
95 | { | |
96 | memset(&c->operand[from], 0, to - from + 1); | |
97 | } | |
98 | ||
99 | static void pad_operands(struct avc_command_frame *c, int from) | |
100 | { | |
101 | int to = ALIGN(from, 4); | |
102 | ||
103 | if (from <= to && to <= LAST_OPERAND) | |
104 | clear_operands(c, from, to); | |
105 | } | |
106 | ||
15344779 HK |
107 | #define AVC_DEBUG_READ_DESCRIPTOR 0x0001 |
108 | #define AVC_DEBUG_DSIT 0x0002 | |
109 | #define AVC_DEBUG_DSD 0x0004 | |
110 | #define AVC_DEBUG_REGISTER_REMOTE_CONTROL 0x0008 | |
111 | #define AVC_DEBUG_LNB_CONTROL 0x0010 | |
112 | #define AVC_DEBUG_TUNE_QPSK 0x0020 | |
113 | #define AVC_DEBUG_TUNE_QPSK2 0x0040 | |
114 | #define AVC_DEBUG_HOST2CA 0x0080 | |
115 | #define AVC_DEBUG_CA2HOST 0x0100 | |
116 | #define AVC_DEBUG_APPLICATION_PMT 0x4000 | |
117 | #define AVC_DEBUG_FCP_PAYLOADS 0x8000 | |
15490795 SR |
118 | |
119 | static int avc_debug; | |
120 | module_param_named(debug, avc_debug, int, 0644); | |
96e242a5 SR |
121 | MODULE_PARM_DESC(debug, "Verbose logging (none = 0" |
122 | ", FCP subactions" | |
123 | ": READ DESCRIPTOR = " __stringify(AVC_DEBUG_READ_DESCRIPTOR) | |
124 | ", DSIT = " __stringify(AVC_DEBUG_DSIT) | |
125 | ", REGISTER_REMOTE_CONTROL = " __stringify(AVC_DEBUG_REGISTER_REMOTE_CONTROL) | |
126 | ", LNB CONTROL = " __stringify(AVC_DEBUG_LNB_CONTROL) | |
127 | ", TUNE QPSK = " __stringify(AVC_DEBUG_TUNE_QPSK) | |
128 | ", TUNE QPSK2 = " __stringify(AVC_DEBUG_TUNE_QPSK2) | |
129 | ", HOST2CA = " __stringify(AVC_DEBUG_HOST2CA) | |
130 | ", CA2HOST = " __stringify(AVC_DEBUG_CA2HOST) | |
131 | "; Application sent PMT = " __stringify(AVC_DEBUG_APPLICATION_PMT) | |
132 | ", FCP payloads = " __stringify(AVC_DEBUG_FCP_PAYLOADS) | |
133 | ", or a combination, or all = -1)"); | |
15490795 | 134 | |
52065c51 HK |
135 | /* |
136 | * This is a workaround since there is no vendor specific command to retrieve | |
137 | * ca_info using AVC. If this parameter is not used, ca_system_id will be | |
138 | * filled with application_manufacturer from ca_app_info. | |
139 | * Digital Everywhere have said that adding ca_info is on their TODO list. | |
140 | */ | |
141 | static unsigned int num_fake_ca_system_ids; | |
142 | static int fake_ca_system_ids[4] = { -1, -1, -1, -1 }; | |
143 | module_param_array(fake_ca_system_ids, int, &num_fake_ca_system_ids, 0644); | |
144 | MODULE_PARM_DESC(fake_ca_system_ids, "If your CAM application manufacturer " | |
145 | "does not have the same ca_system_id as your CAS, you can " | |
146 | "override what ca_system_ids are presented to the " | |
147 | "application by setting this field to an array of ids."); | |
148 | ||
15490795 SR |
149 | static const char *debug_fcp_ctype(unsigned int ctype) |
150 | { | |
151 | static const char *ctypes[] = { | |
152 | [0x0] = "CONTROL", [0x1] = "STATUS", | |
153 | [0x2] = "SPECIFIC INQUIRY", [0x3] = "NOTIFY", | |
154 | [0x4] = "GENERAL INQUIRY", [0x8] = "NOT IMPLEMENTED", | |
155 | [0x9] = "ACCEPTED", [0xa] = "REJECTED", | |
156 | [0xb] = "IN TRANSITION", [0xc] = "IMPLEMENTED/STABLE", | |
157 | [0xd] = "CHANGED", [0xf] = "INTERIM", | |
158 | }; | |
159 | const char *ret = ctype < ARRAY_SIZE(ctypes) ? ctypes[ctype] : NULL; | |
160 | ||
161 | return ret ? ret : "?"; | |
162 | } | |
163 | ||
164 | static const char *debug_fcp_opcode(unsigned int opcode, | |
40cf65d1 | 165 | const u8 *data, int length) |
15490795 SR |
166 | { |
167 | switch (opcode) { | |
96e242a5 SR |
168 | case AVC_OPCODE_VENDOR: |
169 | break; | |
170 | case AVC_OPCODE_READ_DESCRIPTOR: | |
171 | return avc_debug & AVC_DEBUG_READ_DESCRIPTOR ? | |
172 | "ReadDescriptor" : NULL; | |
173 | case AVC_OPCODE_DSIT: | |
174 | return avc_debug & AVC_DEBUG_DSIT ? | |
175 | "DirectSelectInfo.Type" : NULL; | |
176 | case AVC_OPCODE_DSD: | |
177 | return avc_debug & AVC_DEBUG_DSD ? "DirectSelectData" : NULL; | |
178 | default: | |
179 | return "Unknown"; | |
15490795 SR |
180 | } |
181 | ||
182 | if (length < 7 || | |
183 | data[3] != SFE_VENDOR_DE_COMPANYID_0 || | |
184 | data[4] != SFE_VENDOR_DE_COMPANYID_1 || | |
185 | data[5] != SFE_VENDOR_DE_COMPANYID_2) | |
96e242a5 | 186 | return "Vendor/Unknown"; |
15490795 SR |
187 | |
188 | switch (data[6]) { | |
96e242a5 SR |
189 | case SFE_VENDOR_OPCODE_REGISTER_REMOTE_CONTROL: |
190 | return avc_debug & AVC_DEBUG_REGISTER_REMOTE_CONTROL ? | |
191 | "RegisterRC" : NULL; | |
192 | case SFE_VENDOR_OPCODE_LNB_CONTROL: | |
193 | return avc_debug & AVC_DEBUG_LNB_CONTROL ? "LNBControl" : NULL; | |
194 | case SFE_VENDOR_OPCODE_TUNE_QPSK: | |
195 | return avc_debug & AVC_DEBUG_TUNE_QPSK ? "TuneQPSK" : NULL; | |
196 | case SFE_VENDOR_OPCODE_TUNE_QPSK2: | |
197 | return avc_debug & AVC_DEBUG_TUNE_QPSK2 ? "TuneQPSK2" : NULL; | |
198 | case SFE_VENDOR_OPCODE_HOST2CA: | |
199 | return avc_debug & AVC_DEBUG_HOST2CA ? "Host2CA" : NULL; | |
200 | case SFE_VENDOR_OPCODE_CA2HOST: | |
201 | return avc_debug & AVC_DEBUG_CA2HOST ? "CA2Host" : NULL; | |
15490795 | 202 | } |
96e242a5 | 203 | return "Vendor/Unknown"; |
15344779 HK |
204 | } |
205 | ||
40cf65d1 | 206 | static void debug_fcp(const u8 *data, int length) |
15490795 | 207 | { |
96e242a5 SR |
208 | unsigned int subunit_type, subunit_id, opcode; |
209 | const char *op, *prefix; | |
15490795 | 210 | |
96e242a5 | 211 | prefix = data[0] > 7 ? "FCP <- " : "FCP -> "; |
15344779 | 212 | subunit_type = data[1] >> 3; |
96e242a5 SR |
213 | subunit_id = data[1] & 7; |
214 | opcode = subunit_type == 0x1e || subunit_id == 5 ? ~0 : data[2]; | |
215 | op = debug_fcp_opcode(opcode, data, length); | |
216 | ||
217 | if (op) { | |
14edcd5d | 218 | printk(KERN_INFO "%ssu=%x.%x l=%d: %-8s - %s\n", |
15490795 | 219 | prefix, subunit_type, subunit_id, length, |
96e242a5 | 220 | debug_fcp_ctype(data[0]), op); |
15344779 HK |
221 | if (avc_debug & AVC_DEBUG_FCP_PAYLOADS) |
222 | print_hex_dump(KERN_INFO, prefix, DUMP_PREFIX_NONE, | |
223 | 16, 1, data, length, false); | |
15490795 | 224 | } |
15344779 | 225 | } |
15490795 | 226 | |
15344779 HK |
227 | static void debug_pmt(char *msg, int length) |
228 | { | |
229 | printk(KERN_INFO "APP PMT -> l=%d\n", length); | |
230 | print_hex_dump(KERN_INFO, "APP PMT -> ", DUMP_PREFIX_NONE, | |
231 | 16, 1, msg, length, false); | |
15490795 SR |
232 | } |
233 | ||
3fb80ef3 | 234 | static int avc_write(struct firedtv *fdtv) |
15490795 SR |
235 | { |
236 | int err, retry; | |
237 | ||
3fb80ef3 | 238 | fdtv->avc_reply_received = false; |
15490795 SR |
239 | |
240 | for (retry = 0; retry < 6; retry++) { | |
241 | if (unlikely(avc_debug)) | |
3fb80ef3 | 242 | debug_fcp(fdtv->avc_data, fdtv->avc_data_length); |
15490795 SR |
243 | |
244 | err = fdtv->backend->write(fdtv, FCP_COMMAND_REGISTER, | |
3fb80ef3 | 245 | fdtv->avc_data, fdtv->avc_data_length); |
15490795 | 246 | if (err) { |
15490795 | 247 | dev_err(fdtv->device, "FCP command write failed\n"); |
3fb80ef3 | 248 | |
15490795 SR |
249 | return err; |
250 | } | |
251 | ||
15490795 SR |
252 | /* |
253 | * AV/C specs say that answers should be sent within 150 ms. | |
254 | * Time out after 200 ms. | |
255 | */ | |
256 | if (wait_event_timeout(fdtv->avc_wait, | |
257 | fdtv->avc_reply_received, | |
3fb80ef3 | 258 | msecs_to_jiffies(200)) != 0) |
15490795 | 259 | return 0; |
15490795 SR |
260 | } |
261 | dev_err(fdtv->device, "FCP response timed out\n"); | |
3fb80ef3 | 262 | |
15490795 SR |
263 | return -ETIMEDOUT; |
264 | } | |
265 | ||
3fb80ef3 | 266 | static bool is_register_rc(struct avc_response_frame *r) |
15490795 | 267 | { |
3fb80ef3 SR |
268 | return r->opcode == AVC_OPCODE_VENDOR && |
269 | r->operand[0] == SFE_VENDOR_DE_COMPANYID_0 && | |
270 | r->operand[1] == SFE_VENDOR_DE_COMPANYID_1 && | |
271 | r->operand[2] == SFE_VENDOR_DE_COMPANYID_2 && | |
272 | r->operand[3] == SFE_VENDOR_OPCODE_REGISTER_REMOTE_CONTROL; | |
15490795 SR |
273 | } |
274 | ||
275 | int avc_recv(struct firedtv *fdtv, void *data, size_t length) | |
276 | { | |
3fb80ef3 | 277 | struct avc_response_frame *r = data; |
15490795 SR |
278 | |
279 | if (unlikely(avc_debug)) | |
280 | debug_fcp(data, length); | |
281 | ||
3fb80ef3 SR |
282 | if (length >= 8 && is_register_rc(r)) { |
283 | switch (r->response) { | |
284 | case AVC_RESPONSE_CHANGED: | |
285 | fdtv_handle_rc(fdtv, r->operand[4] << 8 | r->operand[5]); | |
15490795 | 286 | schedule_work(&fdtv->remote_ctrl_work); |
3fb80ef3 SR |
287 | break; |
288 | case AVC_RESPONSE_INTERIM: | |
289 | if (is_register_rc((void *)fdtv->avc_data)) | |
290 | goto wake; | |
291 | break; | |
292 | default: | |
15490795 SR |
293 | dev_info(fdtv->device, |
294 | "remote control result = %d\n", r->response); | |
295 | } | |
296 | return 0; | |
297 | } | |
298 | ||
299 | if (fdtv->avc_reply_received) { | |
300 | dev_err(fdtv->device, "out-of-order AVC response, ignored\n"); | |
301 | return -EIO; | |
302 | } | |
303 | ||
3fb80ef3 SR |
304 | memcpy(fdtv->avc_data, data, length); |
305 | fdtv->avc_data_length = length; | |
306 | wake: | |
15490795 SR |
307 | fdtv->avc_reply_received = true; |
308 | wake_up(&fdtv->avc_wait); | |
309 | ||
310 | return 0; | |
311 | } | |
312 | ||
166987c6 HK |
313 | static int add_pid_filter(struct firedtv *fdtv, u8 *operand) |
314 | { | |
315 | int i, n, pos = 1; | |
316 | ||
317 | for (i = 0, n = 0; i < 16; i++) { | |
318 | if (test_bit(i, &fdtv->channel_active)) { | |
319 | operand[pos++] = 0x13; /* flowfunction relay */ | |
320 | operand[pos++] = 0x80; /* dsd_sel_spec_valid_flags -> PID */ | |
321 | operand[pos++] = (fdtv->channel_pid[i] >> 8) & 0x1f; | |
322 | operand[pos++] = fdtv->channel_pid[i] & 0xff; | |
323 | operand[pos++] = 0x00; /* tableID */ | |
324 | operand[pos++] = 0x00; /* filter_length */ | |
325 | n++; | |
326 | } | |
327 | } | |
328 | operand[0] = n; | |
329 | ||
330 | return pos; | |
331 | } | |
332 | ||
15490795 SR |
333 | /* |
334 | * tuning command for setting the relative LNB frequency | |
335 | * (not supported by the AVC standard) | |
336 | */ | |
1e4348c8 SR |
337 | static int avc_tuner_tuneqpsk(struct firedtv *fdtv, |
338 | struct dvb_frontend_parameters *params) | |
15490795 | 339 | { |
3fb80ef3 SR |
340 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
341 | ||
15490795 SR |
342 | c->opcode = AVC_OPCODE_VENDOR; |
343 | ||
344 | c->operand[0] = SFE_VENDOR_DE_COMPANYID_0; | |
345 | c->operand[1] = SFE_VENDOR_DE_COMPANYID_1; | |
346 | c->operand[2] = SFE_VENDOR_DE_COMPANYID_2; | |
32a0f488 BML |
347 | if (fdtv->type == FIREDTV_DVB_S2) |
348 | c->operand[3] = SFE_VENDOR_OPCODE_TUNE_QPSK2; | |
349 | else | |
350 | c->operand[3] = SFE_VENDOR_OPCODE_TUNE_QPSK; | |
15490795 SR |
351 | |
352 | c->operand[4] = (params->frequency >> 24) & 0xff; | |
353 | c->operand[5] = (params->frequency >> 16) & 0xff; | |
354 | c->operand[6] = (params->frequency >> 8) & 0xff; | |
355 | c->operand[7] = params->frequency & 0xff; | |
356 | ||
357 | c->operand[8] = ((params->u.qpsk.symbol_rate / 1000) >> 8) & 0xff; | |
358 | c->operand[9] = (params->u.qpsk.symbol_rate / 1000) & 0xff; | |
359 | ||
360 | switch (params->u.qpsk.fec_inner) { | |
361 | case FEC_1_2: c->operand[10] = 0x1; break; | |
362 | case FEC_2_3: c->operand[10] = 0x2; break; | |
363 | case FEC_3_4: c->operand[10] = 0x3; break; | |
364 | case FEC_5_6: c->operand[10] = 0x4; break; | |
365 | case FEC_7_8: c->operand[10] = 0x5; break; | |
366 | case FEC_4_5: | |
367 | case FEC_8_9: | |
368 | case FEC_AUTO: | |
369 | default: c->operand[10] = 0x0; | |
370 | } | |
371 | ||
372 | if (fdtv->voltage == 0xff) | |
373 | c->operand[11] = 0xff; | |
374 | else if (fdtv->voltage == SEC_VOLTAGE_18) /* polarisation */ | |
375 | c->operand[11] = 0; | |
376 | else | |
377 | c->operand[11] = 1; | |
378 | ||
379 | if (fdtv->tone == 0xff) | |
380 | c->operand[12] = 0xff; | |
381 | else if (fdtv->tone == SEC_TONE_ON) /* band */ | |
382 | c->operand[12] = 1; | |
383 | else | |
384 | c->operand[12] = 0; | |
385 | ||
386 | if (fdtv->type == FIREDTV_DVB_S2) { | |
d2fd44a3 TJ |
387 | if (fdtv->fe.dtv_property_cache.delivery_system == SYS_DVBS2) { |
388 | switch (fdtv->fe.dtv_property_cache.modulation) { | |
389 | case QAM_16: c->operand[13] = 0x1; break; | |
390 | case QPSK: c->operand[13] = 0x2; break; | |
391 | case PSK_8: c->operand[13] = 0x3; break; | |
392 | default: c->operand[13] = 0x2; break; | |
393 | } | |
394 | switch (fdtv->fe.dtv_property_cache.rolloff) { | |
395 | case ROLLOFF_AUTO: c->operand[14] = 0x2; break; | |
396 | case ROLLOFF_35: c->operand[14] = 0x2; break; | |
397 | case ROLLOFF_20: c->operand[14] = 0x0; break; | |
398 | case ROLLOFF_25: c->operand[14] = 0x1; break; | |
399 | /* case ROLLOFF_NONE: c->operand[14] = 0xff; break; */ | |
400 | } | |
401 | switch (fdtv->fe.dtv_property_cache.pilot) { | |
402 | case PILOT_AUTO: c->operand[15] = 0x0; break; | |
403 | case PILOT_OFF: c->operand[15] = 0x0; break; | |
404 | case PILOT_ON: c->operand[15] = 0x1; break; | |
405 | } | |
406 | } else { | |
407 | c->operand[13] = 0x1; /* auto modulation */ | |
408 | c->operand[14] = 0xff; /* disable rolloff */ | |
409 | c->operand[15] = 0xff; /* disable pilot */ | |
410 | } | |
1e4348c8 | 411 | return 16; |
15490795 | 412 | } else { |
1e4348c8 | 413 | return 13; |
15490795 SR |
414 | } |
415 | } | |
416 | ||
1e4348c8 SR |
417 | static int avc_tuner_dsd_dvb_c(struct firedtv *fdtv, |
418 | struct dvb_frontend_parameters *params) | |
15490795 | 419 | { |
3fb80ef3 SR |
420 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
421 | ||
15490795 SR |
422 | c->opcode = AVC_OPCODE_DSD; |
423 | ||
424 | c->operand[0] = 0; /* source plug */ | |
425 | c->operand[1] = 0xd2; /* subfunction replace */ | |
426 | c->operand[2] = 0x20; /* system id = DVB */ | |
427 | c->operand[3] = 0x00; /* antenna number */ | |
428 | c->operand[4] = 0x11; /* system_specific_multiplex selection_length */ | |
429 | ||
430 | /* multiplex_valid_flags, high byte */ | |
431 | c->operand[5] = 0 << 7 /* reserved */ | |
432 | | 0 << 6 /* Polarisation */ | |
433 | | 0 << 5 /* Orbital_Pos */ | |
434 | | 1 << 4 /* Frequency */ | |
435 | | 1 << 3 /* Symbol_Rate */ | |
436 | | 0 << 2 /* FEC_outer */ | |
437 | | (params->u.qam.fec_inner != FEC_AUTO ? 1 << 1 : 0) | |
438 | | (params->u.qam.modulation != QAM_AUTO ? 1 << 0 : 0); | |
439 | ||
440 | /* multiplex_valid_flags, low byte */ | |
441 | c->operand[6] = 0 << 7 /* NetworkID */ | |
442 | | 0 << 0 /* reserved */ ; | |
443 | ||
444 | c->operand[7] = 0x00; | |
445 | c->operand[8] = 0x00; | |
446 | c->operand[9] = 0x00; | |
447 | c->operand[10] = 0x00; | |
448 | ||
449 | c->operand[11] = (((params->frequency / 4000) >> 16) & 0xff) | (2 << 6); | |
450 | c->operand[12] = ((params->frequency / 4000) >> 8) & 0xff; | |
451 | c->operand[13] = (params->frequency / 4000) & 0xff; | |
452 | c->operand[14] = ((params->u.qpsk.symbol_rate / 1000) >> 12) & 0xff; | |
453 | c->operand[15] = ((params->u.qpsk.symbol_rate / 1000) >> 4) & 0xff; | |
454 | c->operand[16] = ((params->u.qpsk.symbol_rate / 1000) << 4) & 0xf0; | |
455 | c->operand[17] = 0x00; | |
456 | ||
457 | switch (params->u.qpsk.fec_inner) { | |
458 | case FEC_1_2: c->operand[18] = 0x1; break; | |
459 | case FEC_2_3: c->operand[18] = 0x2; break; | |
460 | case FEC_3_4: c->operand[18] = 0x3; break; | |
461 | case FEC_5_6: c->operand[18] = 0x4; break; | |
462 | case FEC_7_8: c->operand[18] = 0x5; break; | |
463 | case FEC_8_9: c->operand[18] = 0x6; break; | |
464 | case FEC_4_5: c->operand[18] = 0x8; break; | |
465 | case FEC_AUTO: | |
466 | default: c->operand[18] = 0x0; | |
467 | } | |
468 | ||
469 | switch (params->u.qam.modulation) { | |
470 | case QAM_16: c->operand[19] = 0x08; break; | |
471 | case QAM_32: c->operand[19] = 0x10; break; | |
472 | case QAM_64: c->operand[19] = 0x18; break; | |
473 | case QAM_128: c->operand[19] = 0x20; break; | |
474 | case QAM_256: c->operand[19] = 0x28; break; | |
475 | case QAM_AUTO: | |
476 | default: c->operand[19] = 0x00; | |
477 | } | |
478 | ||
479 | c->operand[20] = 0x00; | |
480 | c->operand[21] = 0x00; | |
15490795 | 481 | |
1e4348c8 | 482 | return 22 + add_pid_filter(fdtv, &c->operand[22]); |
15490795 SR |
483 | } |
484 | ||
1e4348c8 SR |
485 | static int avc_tuner_dsd_dvb_t(struct firedtv *fdtv, |
486 | struct dvb_frontend_parameters *params) | |
15490795 SR |
487 | { |
488 | struct dvb_ofdm_parameters *ofdm = ¶ms->u.ofdm; | |
3fb80ef3 | 489 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
15490795 SR |
490 | |
491 | c->opcode = AVC_OPCODE_DSD; | |
492 | ||
493 | c->operand[0] = 0; /* source plug */ | |
494 | c->operand[1] = 0xd2; /* subfunction replace */ | |
495 | c->operand[2] = 0x20; /* system id = DVB */ | |
496 | c->operand[3] = 0x00; /* antenna number */ | |
497 | c->operand[4] = 0x0c; /* system_specific_multiplex selection_length */ | |
498 | ||
499 | /* multiplex_valid_flags, high byte */ | |
500 | c->operand[5] = | |
501 | 0 << 7 /* reserved */ | |
502 | | 1 << 6 /* CenterFrequency */ | |
503 | | (ofdm->bandwidth != BANDWIDTH_AUTO ? 1 << 5 : 0) | |
504 | | (ofdm->constellation != QAM_AUTO ? 1 << 4 : 0) | |
505 | | (ofdm->hierarchy_information != HIERARCHY_AUTO ? 1 << 3 : 0) | |
506 | | (ofdm->code_rate_HP != FEC_AUTO ? 1 << 2 : 0) | |
507 | | (ofdm->code_rate_LP != FEC_AUTO ? 1 << 1 : 0) | |
508 | | (ofdm->guard_interval != GUARD_INTERVAL_AUTO ? 1 << 0 : 0); | |
509 | ||
510 | /* multiplex_valid_flags, low byte */ | |
511 | c->operand[6] = | |
512 | 0 << 7 /* NetworkID */ | |
513 | | (ofdm->transmission_mode != TRANSMISSION_MODE_AUTO ? 1 << 6 : 0) | |
514 | | 0 << 5 /* OtherFrequencyFlag */ | |
515 | | 0 << 0 /* reserved */ ; | |
516 | ||
517 | c->operand[7] = 0x0; | |
518 | c->operand[8] = (params->frequency / 10) >> 24; | |
519 | c->operand[9] = ((params->frequency / 10) >> 16) & 0xff; | |
520 | c->operand[10] = ((params->frequency / 10) >> 8) & 0xff; | |
521 | c->operand[11] = (params->frequency / 10) & 0xff; | |
522 | ||
523 | switch (ofdm->bandwidth) { | |
524 | case BANDWIDTH_7_MHZ: c->operand[12] = 0x20; break; | |
525 | case BANDWIDTH_8_MHZ: | |
526 | case BANDWIDTH_6_MHZ: /* not defined by AVC spec */ | |
527 | case BANDWIDTH_AUTO: | |
528 | default: c->operand[12] = 0x00; | |
529 | } | |
530 | ||
531 | switch (ofdm->constellation) { | |
532 | case QAM_16: c->operand[13] = 1 << 6; break; | |
533 | case QAM_64: c->operand[13] = 2 << 6; break; | |
534 | case QPSK: | |
535 | default: c->operand[13] = 0x00; | |
536 | } | |
537 | ||
538 | switch (ofdm->hierarchy_information) { | |
539 | case HIERARCHY_1: c->operand[13] |= 1 << 3; break; | |
540 | case HIERARCHY_2: c->operand[13] |= 2 << 3; break; | |
541 | case HIERARCHY_4: c->operand[13] |= 3 << 3; break; | |
542 | case HIERARCHY_AUTO: | |
543 | case HIERARCHY_NONE: | |
544 | default: break; | |
545 | } | |
546 | ||
547 | switch (ofdm->code_rate_HP) { | |
548 | case FEC_2_3: c->operand[13] |= 1; break; | |
549 | case FEC_3_4: c->operand[13] |= 2; break; | |
550 | case FEC_5_6: c->operand[13] |= 3; break; | |
551 | case FEC_7_8: c->operand[13] |= 4; break; | |
552 | case FEC_1_2: | |
553 | default: break; | |
554 | } | |
555 | ||
556 | switch (ofdm->code_rate_LP) { | |
557 | case FEC_2_3: c->operand[14] = 1 << 5; break; | |
558 | case FEC_3_4: c->operand[14] = 2 << 5; break; | |
559 | case FEC_5_6: c->operand[14] = 3 << 5; break; | |
560 | case FEC_7_8: c->operand[14] = 4 << 5; break; | |
561 | case FEC_1_2: | |
562 | default: c->operand[14] = 0x00; break; | |
563 | } | |
564 | ||
565 | switch (ofdm->guard_interval) { | |
566 | case GUARD_INTERVAL_1_16: c->operand[14] |= 1 << 3; break; | |
567 | case GUARD_INTERVAL_1_8: c->operand[14] |= 2 << 3; break; | |
568 | case GUARD_INTERVAL_1_4: c->operand[14] |= 3 << 3; break; | |
569 | case GUARD_INTERVAL_1_32: | |
570 | case GUARD_INTERVAL_AUTO: | |
571 | default: break; | |
572 | } | |
573 | ||
574 | switch (ofdm->transmission_mode) { | |
575 | case TRANSMISSION_MODE_8K: c->operand[14] |= 1 << 1; break; | |
576 | case TRANSMISSION_MODE_2K: | |
577 | case TRANSMISSION_MODE_AUTO: | |
578 | default: break; | |
579 | } | |
580 | ||
581 | c->operand[15] = 0x00; /* network_ID[0] */ | |
582 | c->operand[16] = 0x00; /* network_ID[1] */ | |
15490795 | 583 | |
1e4348c8 | 584 | return 17 + add_pid_filter(fdtv, &c->operand[17]); |
15490795 SR |
585 | } |
586 | ||
587 | int avc_tuner_dsd(struct firedtv *fdtv, | |
588 | struct dvb_frontend_parameters *params) | |
589 | { | |
3fb80ef3 | 590 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
1e4348c8 | 591 | int pos, ret; |
3fb80ef3 | 592 | |
6385c5bf | 593 | mutex_lock(&fdtv->avc_mutex); |
15490795 | 594 | |
15490795 SR |
595 | c->ctype = AVC_CTYPE_CONTROL; |
596 | c->subunit = AVC_SUBUNIT_TYPE_TUNER | fdtv->subunit; | |
597 | ||
598 | switch (fdtv->type) { | |
599 | case FIREDTV_DVB_S: | |
1e4348c8 SR |
600 | case FIREDTV_DVB_S2: pos = avc_tuner_tuneqpsk(fdtv, params); break; |
601 | case FIREDTV_DVB_C: pos = avc_tuner_dsd_dvb_c(fdtv, params); break; | |
602 | case FIREDTV_DVB_T: pos = avc_tuner_dsd_dvb_t(fdtv, params); break; | |
15490795 SR |
603 | default: |
604 | BUG(); | |
605 | } | |
1e4348c8 SR |
606 | pad_operands(c, pos); |
607 | ||
608 | fdtv->avc_data_length = ALIGN(3 + pos, 4); | |
3fb80ef3 | 609 | ret = avc_write(fdtv); |
15490795 | 610 | #if 0 |
3fb80ef3 SR |
611 | /* |
612 | * FIXME: | |
613 | * u8 *status was an out-parameter of avc_tuner_dsd, unused by caller. | |
614 | * Check for AVC_RESPONSE_ACCEPTED here instead? | |
615 | */ | |
15490795 SR |
616 | if (status) |
617 | *status = r->operand[2]; | |
618 | #endif | |
3fb80ef3 SR |
619 | mutex_unlock(&fdtv->avc_mutex); |
620 | ||
621 | if (ret == 0) | |
622 | msleep(500); | |
623 | ||
624 | return ret; | |
15490795 SR |
625 | } |
626 | ||
627 | int avc_tuner_set_pids(struct firedtv *fdtv, unsigned char pidc, u16 pid[]) | |
628 | { | |
3fb80ef3 SR |
629 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
630 | int ret, pos, k; | |
15490795 SR |
631 | |
632 | if (pidc > 16 && pidc != 0xff) | |
633 | return -EINVAL; | |
634 | ||
6385c5bf | 635 | mutex_lock(&fdtv->avc_mutex); |
3fb80ef3 | 636 | |
15490795 SR |
637 | c->ctype = AVC_CTYPE_CONTROL; |
638 | c->subunit = AVC_SUBUNIT_TYPE_TUNER | fdtv->subunit; | |
639 | c->opcode = AVC_OPCODE_DSD; | |
640 | ||
641 | c->operand[0] = 0; /* source plug */ | |
642 | c->operand[1] = 0xd2; /* subfunction replace */ | |
643 | c->operand[2] = 0x20; /* system id = DVB */ | |
644 | c->operand[3] = 0x00; /* antenna number */ | |
645 | c->operand[4] = 0x00; /* system_specific_multiplex selection_length */ | |
646 | c->operand[5] = pidc; /* Nr_of_dsd_sel_specs */ | |
647 | ||
648 | pos = 6; | |
649 | if (pidc != 0xff) | |
650 | for (k = 0; k < pidc; k++) { | |
651 | c->operand[pos++] = 0x13; /* flowfunction relay */ | |
652 | c->operand[pos++] = 0x80; /* dsd_sel_spec_valid_flags -> PID */ | |
653 | c->operand[pos++] = (pid[k] >> 8) & 0x1f; | |
654 | c->operand[pos++] = pid[k] & 0xff; | |
655 | c->operand[pos++] = 0x00; /* tableID */ | |
656 | c->operand[pos++] = 0x00; /* filter_length */ | |
657 | } | |
1e4348c8 | 658 | pad_operands(c, pos); |
15490795 | 659 | |
3fb80ef3 SR |
660 | fdtv->avc_data_length = ALIGN(3 + pos, 4); |
661 | ret = avc_write(fdtv); | |
15490795 | 662 | |
3fb80ef3 | 663 | /* FIXME: check response code? */ |
15490795 | 664 | |
3fb80ef3 SR |
665 | mutex_unlock(&fdtv->avc_mutex); |
666 | ||
667 | if (ret == 0) | |
668 | msleep(50); | |
669 | ||
670 | return ret; | |
15490795 SR |
671 | } |
672 | ||
673 | int avc_tuner_get_ts(struct firedtv *fdtv) | |
674 | { | |
3fb80ef3 SR |
675 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
676 | int ret, sl; | |
677 | ||
6385c5bf | 678 | mutex_lock(&fdtv->avc_mutex); |
15490795 | 679 | |
15490795 SR |
680 | c->ctype = AVC_CTYPE_CONTROL; |
681 | c->subunit = AVC_SUBUNIT_TYPE_TUNER | fdtv->subunit; | |
682 | c->opcode = AVC_OPCODE_DSIT; | |
683 | ||
684 | sl = fdtv->type == FIREDTV_DVB_T ? 0x0c : 0x11; | |
685 | ||
686 | c->operand[0] = 0; /* source plug */ | |
687 | c->operand[1] = 0xd2; /* subfunction replace */ | |
688 | c->operand[2] = 0xff; /* status */ | |
689 | c->operand[3] = 0x20; /* system id = DVB */ | |
690 | c->operand[4] = 0x00; /* antenna number */ | |
691 | c->operand[5] = 0x0; /* system_specific_search_flags */ | |
692 | c->operand[6] = sl; /* system_specific_multiplex selection_length */ | |
1e4348c8 SR |
693 | /* |
694 | * operand[7]: valid_flags[0] | |
695 | * operand[8]: valid_flags[1] | |
696 | * operand[7 + sl]: nr_of_dsit_sel_specs (always 0) | |
697 | */ | |
698 | clear_operands(c, 7, 24); | |
15490795 | 699 | |
3fb80ef3 SR |
700 | fdtv->avc_data_length = fdtv->type == FIREDTV_DVB_T ? 24 : 28; |
701 | ret = avc_write(fdtv); | |
15490795 | 702 | |
3fb80ef3 | 703 | /* FIXME: check response code? */ |
15490795 | 704 | |
3fb80ef3 SR |
705 | mutex_unlock(&fdtv->avc_mutex); |
706 | ||
707 | if (ret == 0) | |
708 | msleep(250); | |
709 | ||
710 | return ret; | |
15490795 SR |
711 | } |
712 | ||
713 | int avc_identify_subunit(struct firedtv *fdtv) | |
714 | { | |
3fb80ef3 SR |
715 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
716 | struct avc_response_frame *r = (void *)fdtv->avc_data; | |
717 | int ret; | |
718 | ||
6385c5bf | 719 | mutex_lock(&fdtv->avc_mutex); |
15490795 | 720 | |
15490795 SR |
721 | c->ctype = AVC_CTYPE_CONTROL; |
722 | c->subunit = AVC_SUBUNIT_TYPE_TUNER | fdtv->subunit; | |
723 | c->opcode = AVC_OPCODE_READ_DESCRIPTOR; | |
724 | ||
725 | c->operand[0] = DESCRIPTOR_SUBUNIT_IDENTIFIER; | |
726 | c->operand[1] = 0xff; | |
727 | c->operand[2] = 0x00; | |
728 | c->operand[3] = 0x00; /* length highbyte */ | |
729 | c->operand[4] = 0x08; /* length lowbyte */ | |
730 | c->operand[5] = 0x00; /* offset highbyte */ | |
731 | c->operand[6] = 0x0d; /* offset lowbyte */ | |
1e4348c8 | 732 | clear_operands(c, 7, 8); /* padding */ |
15490795 | 733 | |
3fb80ef3 SR |
734 | fdtv->avc_data_length = 12; |
735 | ret = avc_write(fdtv); | |
736 | if (ret < 0) | |
737 | goto out; | |
15490795 SR |
738 | |
739 | if ((r->response != AVC_RESPONSE_STABLE && | |
740 | r->response != AVC_RESPONSE_ACCEPTED) || | |
741 | (r->operand[3] << 8) + r->operand[4] != 8) { | |
742 | dev_err(fdtv->device, "cannot read subunit identifier\n"); | |
3fb80ef3 | 743 | ret = -EINVAL; |
15490795 | 744 | } |
3fb80ef3 SR |
745 | out: |
746 | mutex_unlock(&fdtv->avc_mutex); | |
747 | ||
748 | return ret; | |
15490795 SR |
749 | } |
750 | ||
751 | #define SIZEOF_ANTENNA_INPUT_INFO 22 | |
752 | ||
753 | int avc_tuner_status(struct firedtv *fdtv, struct firedtv_tuner_status *stat) | |
754 | { | |
3fb80ef3 SR |
755 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
756 | struct avc_response_frame *r = (void *)fdtv->avc_data; | |
757 | int length, ret; | |
758 | ||
6385c5bf | 759 | mutex_lock(&fdtv->avc_mutex); |
15490795 | 760 | |
15490795 SR |
761 | c->ctype = AVC_CTYPE_CONTROL; |
762 | c->subunit = AVC_SUBUNIT_TYPE_TUNER | fdtv->subunit; | |
763 | c->opcode = AVC_OPCODE_READ_DESCRIPTOR; | |
764 | ||
765 | c->operand[0] = DESCRIPTOR_TUNER_STATUS; | |
766 | c->operand[1] = 0xff; /* read_result_status */ | |
1e4348c8 SR |
767 | /* |
768 | * operand[2]: reserved | |
769 | * operand[3]: SIZEOF_ANTENNA_INPUT_INFO >> 8 | |
770 | * operand[4]: SIZEOF_ANTENNA_INPUT_INFO & 0xff | |
771 | */ | |
772 | clear_operands(c, 2, 31); | |
15490795 | 773 | |
3fb80ef3 SR |
774 | fdtv->avc_data_length = 12; |
775 | ret = avc_write(fdtv); | |
776 | if (ret < 0) | |
777 | goto out; | |
15490795 SR |
778 | |
779 | if (r->response != AVC_RESPONSE_STABLE && | |
780 | r->response != AVC_RESPONSE_ACCEPTED) { | |
781 | dev_err(fdtv->device, "cannot read tuner status\n"); | |
3fb80ef3 SR |
782 | ret = -EINVAL; |
783 | goto out; | |
15490795 SR |
784 | } |
785 | ||
786 | length = r->operand[9]; | |
787 | if (r->operand[1] != 0x10 || length != SIZEOF_ANTENNA_INPUT_INFO) { | |
788 | dev_err(fdtv->device, "got invalid tuner status\n"); | |
3fb80ef3 SR |
789 | ret = -EINVAL; |
790 | goto out; | |
15490795 SR |
791 | } |
792 | ||
793 | stat->active_system = r->operand[10]; | |
794 | stat->searching = r->operand[11] >> 7 & 1; | |
795 | stat->moving = r->operand[11] >> 6 & 1; | |
796 | stat->no_rf = r->operand[11] >> 5 & 1; | |
797 | stat->input = r->operand[12] >> 7 & 1; | |
798 | stat->selected_antenna = r->operand[12] & 0x7f; | |
799 | stat->ber = r->operand[13] << 24 | | |
800 | r->operand[14] << 16 | | |
801 | r->operand[15] << 8 | | |
802 | r->operand[16]; | |
803 | stat->signal_strength = r->operand[17]; | |
804 | stat->raster_frequency = r->operand[18] >> 6 & 2; | |
805 | stat->rf_frequency = (r->operand[18] & 0x3f) << 16 | | |
806 | r->operand[19] << 8 | | |
807 | r->operand[20]; | |
808 | stat->man_dep_info_length = r->operand[21]; | |
809 | stat->front_end_error = r->operand[22] >> 4 & 1; | |
810 | stat->antenna_error = r->operand[22] >> 3 & 1; | |
811 | stat->front_end_power_status = r->operand[22] >> 1 & 1; | |
812 | stat->power_supply = r->operand[22] & 1; | |
813 | stat->carrier_noise_ratio = r->operand[23] << 8 | | |
814 | r->operand[24]; | |
815 | stat->power_supply_voltage = r->operand[27]; | |
816 | stat->antenna_voltage = r->operand[28]; | |
817 | stat->firewire_bus_voltage = r->operand[29]; | |
818 | stat->ca_mmi = r->operand[30] & 1; | |
819 | stat->ca_pmt_reply = r->operand[31] >> 7 & 1; | |
820 | stat->ca_date_time_request = r->operand[31] >> 6 & 1; | |
821 | stat->ca_application_info = r->operand[31] >> 5 & 1; | |
822 | stat->ca_module_present_status = r->operand[31] >> 4 & 1; | |
823 | stat->ca_dvb_flag = r->operand[31] >> 3 & 1; | |
824 | stat->ca_error_flag = r->operand[31] >> 2 & 1; | |
825 | stat->ca_initialization_status = r->operand[31] >> 1 & 1; | |
3fb80ef3 SR |
826 | out: |
827 | mutex_unlock(&fdtv->avc_mutex); | |
15490795 | 828 | |
3fb80ef3 | 829 | return ret; |
15490795 SR |
830 | } |
831 | ||
832 | int avc_lnb_control(struct firedtv *fdtv, char voltage, char burst, | |
833 | char conttone, char nrdiseq, | |
834 | struct dvb_diseqc_master_cmd *diseqcmd) | |
835 | { | |
3fb80ef3 SR |
836 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
837 | struct avc_response_frame *r = (void *)fdtv->avc_data; | |
1e4348c8 | 838 | int pos, j, k, ret; |
3fb80ef3 | 839 | |
6385c5bf | 840 | mutex_lock(&fdtv->avc_mutex); |
15490795 | 841 | |
15490795 SR |
842 | c->ctype = AVC_CTYPE_CONTROL; |
843 | c->subunit = AVC_SUBUNIT_TYPE_TUNER | fdtv->subunit; | |
844 | c->opcode = AVC_OPCODE_VENDOR; | |
845 | ||
846 | c->operand[0] = SFE_VENDOR_DE_COMPANYID_0; | |
847 | c->operand[1] = SFE_VENDOR_DE_COMPANYID_1; | |
848 | c->operand[2] = SFE_VENDOR_DE_COMPANYID_2; | |
849 | c->operand[3] = SFE_VENDOR_OPCODE_LNB_CONTROL; | |
15490795 SR |
850 | c->operand[4] = voltage; |
851 | c->operand[5] = nrdiseq; | |
852 | ||
1e4348c8 | 853 | pos = 6; |
15490795 | 854 | for (j = 0; j < nrdiseq; j++) { |
1e4348c8 | 855 | c->operand[pos++] = diseqcmd[j].msg_len; |
15490795 SR |
856 | |
857 | for (k = 0; k < diseqcmd[j].msg_len; k++) | |
1e4348c8 | 858 | c->operand[pos++] = diseqcmd[j].msg[k]; |
15490795 | 859 | } |
1e4348c8 SR |
860 | c->operand[pos++] = burst; |
861 | c->operand[pos++] = conttone; | |
862 | pad_operands(c, pos); | |
15490795 | 863 | |
1e4348c8 | 864 | fdtv->avc_data_length = ALIGN(3 + pos, 4); |
3fb80ef3 SR |
865 | ret = avc_write(fdtv); |
866 | if (ret < 0) | |
867 | goto out; | |
15490795 SR |
868 | |
869 | if (r->response != AVC_RESPONSE_ACCEPTED) { | |
870 | dev_err(fdtv->device, "LNB control failed\n"); | |
3fb80ef3 | 871 | ret = -EINVAL; |
15490795 | 872 | } |
3fb80ef3 SR |
873 | out: |
874 | mutex_unlock(&fdtv->avc_mutex); | |
15490795 | 875 | |
3fb80ef3 | 876 | return ret; |
15490795 SR |
877 | } |
878 | ||
879 | int avc_register_remote_control(struct firedtv *fdtv) | |
880 | { | |
3fb80ef3 SR |
881 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
882 | int ret; | |
883 | ||
6385c5bf | 884 | mutex_lock(&fdtv->avc_mutex); |
15490795 | 885 | |
15490795 SR |
886 | c->ctype = AVC_CTYPE_NOTIFY; |
887 | c->subunit = AVC_SUBUNIT_TYPE_UNIT | 7; | |
888 | c->opcode = AVC_OPCODE_VENDOR; | |
889 | ||
890 | c->operand[0] = SFE_VENDOR_DE_COMPANYID_0; | |
891 | c->operand[1] = SFE_VENDOR_DE_COMPANYID_1; | |
892 | c->operand[2] = SFE_VENDOR_DE_COMPANYID_2; | |
893 | c->operand[3] = SFE_VENDOR_OPCODE_REGISTER_REMOTE_CONTROL; | |
1e4348c8 | 894 | c->operand[4] = 0; /* padding */ |
15490795 | 895 | |
3fb80ef3 SR |
896 | fdtv->avc_data_length = 8; |
897 | ret = avc_write(fdtv); | |
15490795 | 898 | |
3fb80ef3 SR |
899 | /* FIXME: check response code? */ |
900 | ||
901 | mutex_unlock(&fdtv->avc_mutex); | |
902 | ||
903 | return ret; | |
15490795 SR |
904 | } |
905 | ||
906 | void avc_remote_ctrl_work(struct work_struct *work) | |
907 | { | |
908 | struct firedtv *fdtv = | |
909 | container_of(work, struct firedtv, remote_ctrl_work); | |
910 | ||
911 | /* Should it be rescheduled in failure cases? */ | |
912 | avc_register_remote_control(fdtv); | |
913 | } | |
914 | ||
915 | #if 0 /* FIXME: unused */ | |
916 | int avc_tuner_host2ca(struct firedtv *fdtv) | |
917 | { | |
3fb80ef3 SR |
918 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
919 | int ret; | |
920 | ||
6385c5bf | 921 | mutex_lock(&fdtv->avc_mutex); |
15490795 | 922 | |
15490795 SR |
923 | c->ctype = AVC_CTYPE_CONTROL; |
924 | c->subunit = AVC_SUBUNIT_TYPE_TUNER | fdtv->subunit; | |
925 | c->opcode = AVC_OPCODE_VENDOR; | |
926 | ||
927 | c->operand[0] = SFE_VENDOR_DE_COMPANYID_0; | |
928 | c->operand[1] = SFE_VENDOR_DE_COMPANYID_1; | |
929 | c->operand[2] = SFE_VENDOR_DE_COMPANYID_2; | |
930 | c->operand[3] = SFE_VENDOR_OPCODE_HOST2CA; | |
931 | c->operand[4] = 0; /* slot */ | |
932 | c->operand[5] = SFE_VENDOR_TAG_CA_APPLICATION_INFO; /* ca tag */ | |
1e4348c8 | 933 | clear_operands(c, 6, 8); |
15490795 | 934 | |
3fb80ef3 SR |
935 | fdtv->avc_data_length = 12; |
936 | ret = avc_write(fdtv); | |
15490795 | 937 | |
3fb80ef3 | 938 | /* FIXME: check response code? */ |
15490795 | 939 | |
3fb80ef3 SR |
940 | mutex_unlock(&fdtv->avc_mutex); |
941 | ||
942 | return ret; | |
15490795 SR |
943 | } |
944 | #endif | |
945 | ||
946 | static int get_ca_object_pos(struct avc_response_frame *r) | |
947 | { | |
948 | int length = 1; | |
949 | ||
950 | /* Check length of length field */ | |
951 | if (r->operand[7] & 0x80) | |
952 | length = (r->operand[7] & 0x7f) + 1; | |
953 | return length + 7; | |
954 | } | |
955 | ||
956 | static int get_ca_object_length(struct avc_response_frame *r) | |
957 | { | |
958 | #if 0 /* FIXME: unused */ | |
959 | int size = 0; | |
960 | int i; | |
961 | ||
962 | if (r->operand[7] & 0x80) | |
963 | for (i = 0; i < (r->operand[7] & 0x7f); i++) { | |
964 | size <<= 8; | |
965 | size += r->operand[8 + i]; | |
966 | } | |
967 | #endif | |
968 | return r->operand[7]; | |
969 | } | |
970 | ||
971 | int avc_ca_app_info(struct firedtv *fdtv, char *app_info, unsigned int *len) | |
972 | { | |
3fb80ef3 SR |
973 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
974 | struct avc_response_frame *r = (void *)fdtv->avc_data; | |
975 | int pos, ret; | |
976 | ||
6385c5bf | 977 | mutex_lock(&fdtv->avc_mutex); |
15490795 | 978 | |
15490795 SR |
979 | c->ctype = AVC_CTYPE_STATUS; |
980 | c->subunit = AVC_SUBUNIT_TYPE_TUNER | fdtv->subunit; | |
981 | c->opcode = AVC_OPCODE_VENDOR; | |
982 | ||
983 | c->operand[0] = SFE_VENDOR_DE_COMPANYID_0; | |
984 | c->operand[1] = SFE_VENDOR_DE_COMPANYID_1; | |
985 | c->operand[2] = SFE_VENDOR_DE_COMPANYID_2; | |
986 | c->operand[3] = SFE_VENDOR_OPCODE_CA2HOST; | |
987 | c->operand[4] = 0; /* slot */ | |
988 | c->operand[5] = SFE_VENDOR_TAG_CA_APPLICATION_INFO; /* ca tag */ | |
1e4348c8 | 989 | clear_operands(c, 6, LAST_OPERAND); |
15490795 | 990 | |
3fb80ef3 SR |
991 | fdtv->avc_data_length = 12; |
992 | ret = avc_write(fdtv); | |
993 | if (ret < 0) | |
994 | goto out; | |
15490795 SR |
995 | |
996 | /* FIXME: check response code and validate response data */ | |
997 | ||
998 | pos = get_ca_object_pos(r); | |
999 | app_info[0] = (EN50221_TAG_APP_INFO >> 16) & 0xff; | |
1000 | app_info[1] = (EN50221_TAG_APP_INFO >> 8) & 0xff; | |
1001 | app_info[2] = (EN50221_TAG_APP_INFO >> 0) & 0xff; | |
1002 | app_info[3] = 6 + r->operand[pos + 4]; | |
1003 | app_info[4] = 0x01; | |
1004 | memcpy(&app_info[5], &r->operand[pos], 5 + r->operand[pos + 4]); | |
1005 | *len = app_info[3] + 4; | |
3fb80ef3 SR |
1006 | out: |
1007 | mutex_unlock(&fdtv->avc_mutex); | |
15490795 | 1008 | |
3fb80ef3 | 1009 | return ret; |
15490795 SR |
1010 | } |
1011 | ||
1012 | int avc_ca_info(struct firedtv *fdtv, char *app_info, unsigned int *len) | |
1013 | { | |
3fb80ef3 SR |
1014 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
1015 | struct avc_response_frame *r = (void *)fdtv->avc_data; | |
52065c51 | 1016 | int i, pos, ret; |
3fb80ef3 | 1017 | |
6385c5bf | 1018 | mutex_lock(&fdtv->avc_mutex); |
15490795 | 1019 | |
15490795 SR |
1020 | c->ctype = AVC_CTYPE_STATUS; |
1021 | c->subunit = AVC_SUBUNIT_TYPE_TUNER | fdtv->subunit; | |
1022 | c->opcode = AVC_OPCODE_VENDOR; | |
1023 | ||
1024 | c->operand[0] = SFE_VENDOR_DE_COMPANYID_0; | |
1025 | c->operand[1] = SFE_VENDOR_DE_COMPANYID_1; | |
1026 | c->operand[2] = SFE_VENDOR_DE_COMPANYID_2; | |
1027 | c->operand[3] = SFE_VENDOR_OPCODE_CA2HOST; | |
1028 | c->operand[4] = 0; /* slot */ | |
1029 | c->operand[5] = SFE_VENDOR_TAG_CA_APPLICATION_INFO; /* ca tag */ | |
1e4348c8 | 1030 | clear_operands(c, 6, LAST_OPERAND); |
15490795 | 1031 | |
3fb80ef3 SR |
1032 | fdtv->avc_data_length = 12; |
1033 | ret = avc_write(fdtv); | |
1034 | if (ret < 0) | |
1035 | goto out; | |
15490795 | 1036 | |
3fb80ef3 | 1037 | /* FIXME: check response code and validate response data */ |
15490795 SR |
1038 | |
1039 | pos = get_ca_object_pos(r); | |
1040 | app_info[0] = (EN50221_TAG_CA_INFO >> 16) & 0xff; | |
1041 | app_info[1] = (EN50221_TAG_CA_INFO >> 8) & 0xff; | |
1042 | app_info[2] = (EN50221_TAG_CA_INFO >> 0) & 0xff; | |
52065c51 HK |
1043 | if (num_fake_ca_system_ids == 0) { |
1044 | app_info[3] = 2; | |
1045 | app_info[4] = r->operand[pos + 0]; | |
1046 | app_info[5] = r->operand[pos + 1]; | |
1047 | } else { | |
1048 | app_info[3] = num_fake_ca_system_ids * 2; | |
1049 | for (i = 0; i < num_fake_ca_system_ids; i++) { | |
1050 | app_info[4 + i * 2] = | |
1051 | (fake_ca_system_ids[i] >> 8) & 0xff; | |
1052 | app_info[5 + i * 2] = fake_ca_system_ids[i] & 0xff; | |
1053 | } | |
1054 | } | |
15490795 | 1055 | *len = app_info[3] + 4; |
3fb80ef3 SR |
1056 | out: |
1057 | mutex_unlock(&fdtv->avc_mutex); | |
15490795 | 1058 | |
3fb80ef3 | 1059 | return ret; |
15490795 SR |
1060 | } |
1061 | ||
1062 | int avc_ca_reset(struct firedtv *fdtv) | |
1063 | { | |
3fb80ef3 SR |
1064 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
1065 | int ret; | |
1066 | ||
6385c5bf | 1067 | mutex_lock(&fdtv->avc_mutex); |
15490795 | 1068 | |
15490795 SR |
1069 | c->ctype = AVC_CTYPE_CONTROL; |
1070 | c->subunit = AVC_SUBUNIT_TYPE_TUNER | fdtv->subunit; | |
1071 | c->opcode = AVC_OPCODE_VENDOR; | |
1072 | ||
1073 | c->operand[0] = SFE_VENDOR_DE_COMPANYID_0; | |
1074 | c->operand[1] = SFE_VENDOR_DE_COMPANYID_1; | |
1075 | c->operand[2] = SFE_VENDOR_DE_COMPANYID_2; | |
1076 | c->operand[3] = SFE_VENDOR_OPCODE_HOST2CA; | |
1077 | c->operand[4] = 0; /* slot */ | |
1078 | c->operand[5] = SFE_VENDOR_TAG_CA_RESET; /* ca tag */ | |
1079 | c->operand[6] = 0; /* more/last */ | |
1080 | c->operand[7] = 1; /* length */ | |
1081 | c->operand[8] = 0; /* force hardware reset */ | |
1082 | ||
3fb80ef3 SR |
1083 | fdtv->avc_data_length = 12; |
1084 | ret = avc_write(fdtv); | |
15490795 | 1085 | |
3fb80ef3 | 1086 | /* FIXME: check response code? */ |
15490795 | 1087 | |
3fb80ef3 SR |
1088 | mutex_unlock(&fdtv->avc_mutex); |
1089 | ||
1090 | return ret; | |
15490795 SR |
1091 | } |
1092 | ||
1093 | int avc_ca_pmt(struct firedtv *fdtv, char *msg, int length) | |
1094 | { | |
3fb80ef3 SR |
1095 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
1096 | struct avc_response_frame *r = (void *)fdtv->avc_data; | |
15490795 SR |
1097 | int list_management; |
1098 | int program_info_length; | |
1099 | int pmt_cmd_id; | |
1100 | int read_pos; | |
1101 | int write_pos; | |
1102 | int es_info_length; | |
1103 | int crc32_csum; | |
3fb80ef3 | 1104 | int ret; |
15490795 | 1105 | |
15344779 HK |
1106 | if (unlikely(avc_debug & AVC_DEBUG_APPLICATION_PMT)) |
1107 | debug_pmt(msg, length); | |
1108 | ||
6385c5bf | 1109 | mutex_lock(&fdtv->avc_mutex); |
3fb80ef3 | 1110 | |
15490795 SR |
1111 | c->ctype = AVC_CTYPE_CONTROL; |
1112 | c->subunit = AVC_SUBUNIT_TYPE_TUNER | fdtv->subunit; | |
1113 | c->opcode = AVC_OPCODE_VENDOR; | |
1114 | ||
1115 | if (msg[0] != EN50221_LIST_MANAGEMENT_ONLY) { | |
1116 | dev_info(fdtv->device, "forcing list_management to ONLY\n"); | |
1117 | msg[0] = EN50221_LIST_MANAGEMENT_ONLY; | |
1118 | } | |
1119 | /* We take the cmd_id from the programme level only! */ | |
1120 | list_management = msg[0]; | |
1121 | program_info_length = ((msg[4] & 0x0f) << 8) + msg[5]; | |
1122 | if (program_info_length > 0) | |
1123 | program_info_length--; /* Remove pmt_cmd_id */ | |
1124 | pmt_cmd_id = msg[6]; | |
1125 | ||
1126 | c->operand[0] = SFE_VENDOR_DE_COMPANYID_0; | |
1127 | c->operand[1] = SFE_VENDOR_DE_COMPANYID_1; | |
1128 | c->operand[2] = SFE_VENDOR_DE_COMPANYID_2; | |
1129 | c->operand[3] = SFE_VENDOR_OPCODE_HOST2CA; | |
1130 | c->operand[4] = 0; /* slot */ | |
1131 | c->operand[5] = SFE_VENDOR_TAG_CA_PMT; /* ca tag */ | |
1132 | c->operand[6] = 0; /* more/last */ | |
c94115ff HK |
1133 | /* Use three bytes for length field in case length > 127 */ |
1134 | c->operand[10] = list_management; | |
1135 | c->operand[11] = 0x01; /* pmt_cmd=OK_descramble */ | |
15490795 SR |
1136 | |
1137 | /* TS program map table */ | |
1138 | ||
c94115ff HK |
1139 | c->operand[12] = 0x02; /* Table id=2 */ |
1140 | c->operand[13] = 0x80; /* Section syntax + length */ | |
1e4348c8 | 1141 | |
c94115ff HK |
1142 | c->operand[15] = msg[1]; /* Program number */ |
1143 | c->operand[16] = msg[2]; | |
ad5e9b9b | 1144 | c->operand[17] = msg[3]; /* Version number and current/next */ |
c94115ff HK |
1145 | c->operand[18] = 0x00; /* Section number=0 */ |
1146 | c->operand[19] = 0x00; /* Last section number=0 */ | |
1147 | c->operand[20] = 0x1f; /* PCR_PID=1FFF */ | |
1148 | c->operand[21] = 0xff; | |
1149 | c->operand[22] = (program_info_length >> 8); /* Program info length */ | |
1150 | c->operand[23] = (program_info_length & 0xff); | |
15490795 SR |
1151 | |
1152 | /* CA descriptors at programme level */ | |
1153 | read_pos = 6; | |
c94115ff | 1154 | write_pos = 24; |
15490795 SR |
1155 | if (program_info_length > 0) { |
1156 | pmt_cmd_id = msg[read_pos++]; | |
1157 | if (pmt_cmd_id != 1 && pmt_cmd_id != 4) | |
1158 | dev_err(fdtv->device, | |
1159 | "invalid pmt_cmd_id %d\n", pmt_cmd_id); | |
1160 | ||
1161 | memcpy(&c->operand[write_pos], &msg[read_pos], | |
1162 | program_info_length); | |
1163 | read_pos += program_info_length; | |
1164 | write_pos += program_info_length; | |
1165 | } | |
1166 | while (read_pos < length) { | |
1167 | c->operand[write_pos++] = msg[read_pos++]; | |
1168 | c->operand[write_pos++] = msg[read_pos++]; | |
1169 | c->operand[write_pos++] = msg[read_pos++]; | |
1170 | es_info_length = | |
1171 | ((msg[read_pos] & 0x0f) << 8) + msg[read_pos + 1]; | |
1172 | read_pos += 2; | |
1173 | if (es_info_length > 0) | |
1174 | es_info_length--; /* Remove pmt_cmd_id */ | |
1175 | c->operand[write_pos++] = es_info_length >> 8; | |
1176 | c->operand[write_pos++] = es_info_length & 0xff; | |
1177 | if (es_info_length > 0) { | |
1178 | pmt_cmd_id = msg[read_pos++]; | |
1179 | if (pmt_cmd_id != 1 && pmt_cmd_id != 4) | |
1180 | dev_err(fdtv->device, "invalid pmt_cmd_id %d " | |
1181 | "at stream level\n", pmt_cmd_id); | |
1182 | ||
1183 | memcpy(&c->operand[write_pos], &msg[read_pos], | |
1184 | es_info_length); | |
1185 | read_pos += es_info_length; | |
1186 | write_pos += es_info_length; | |
1187 | } | |
1188 | } | |
1e4348c8 | 1189 | write_pos += 4; /* CRC */ |
15490795 | 1190 | |
c94115ff HK |
1191 | c->operand[7] = 0x82; |
1192 | c->operand[8] = (write_pos - 10) >> 8; | |
1193 | c->operand[9] = (write_pos - 10) & 0xff; | |
1194 | c->operand[14] = write_pos - 15; | |
15490795 SR |
1195 | |
1196 | crc32_csum = crc32_be(0, &c->operand[10], c->operand[12] - 1); | |
1197 | c->operand[write_pos - 4] = (crc32_csum >> 24) & 0xff; | |
1198 | c->operand[write_pos - 3] = (crc32_csum >> 16) & 0xff; | |
1199 | c->operand[write_pos - 2] = (crc32_csum >> 8) & 0xff; | |
1200 | c->operand[write_pos - 1] = (crc32_csum >> 0) & 0xff; | |
1e4348c8 | 1201 | pad_operands(c, write_pos); |
15490795 | 1202 | |
3fb80ef3 SR |
1203 | fdtv->avc_data_length = ALIGN(3 + write_pos, 4); |
1204 | ret = avc_write(fdtv); | |
1205 | if (ret < 0) | |
1206 | goto out; | |
15490795 SR |
1207 | |
1208 | if (r->response != AVC_RESPONSE_ACCEPTED) { | |
1209 | dev_err(fdtv->device, | |
1210 | "CA PMT failed with response 0x%x\n", r->response); | |
3fb80ef3 | 1211 | ret = -EFAULT; |
15490795 | 1212 | } |
3fb80ef3 SR |
1213 | out: |
1214 | mutex_unlock(&fdtv->avc_mutex); | |
15490795 | 1215 | |
3fb80ef3 | 1216 | return ret; |
15490795 SR |
1217 | } |
1218 | ||
1219 | int avc_ca_get_time_date(struct firedtv *fdtv, int *interval) | |
1220 | { | |
3fb80ef3 SR |
1221 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
1222 | struct avc_response_frame *r = (void *)fdtv->avc_data; | |
1223 | int ret; | |
1224 | ||
6385c5bf | 1225 | mutex_lock(&fdtv->avc_mutex); |
15490795 | 1226 | |
15490795 SR |
1227 | c->ctype = AVC_CTYPE_STATUS; |
1228 | c->subunit = AVC_SUBUNIT_TYPE_TUNER | fdtv->subunit; | |
1229 | c->opcode = AVC_OPCODE_VENDOR; | |
1230 | ||
1231 | c->operand[0] = SFE_VENDOR_DE_COMPANYID_0; | |
1232 | c->operand[1] = SFE_VENDOR_DE_COMPANYID_1; | |
1233 | c->operand[2] = SFE_VENDOR_DE_COMPANYID_2; | |
1234 | c->operand[3] = SFE_VENDOR_OPCODE_CA2HOST; | |
1235 | c->operand[4] = 0; /* slot */ | |
1236 | c->operand[5] = SFE_VENDOR_TAG_CA_DATE_TIME; /* ca tag */ | |
1e4348c8 | 1237 | clear_operands(c, 6, LAST_OPERAND); |
15490795 | 1238 | |
3fb80ef3 SR |
1239 | fdtv->avc_data_length = 12; |
1240 | ret = avc_write(fdtv); | |
1241 | if (ret < 0) | |
1242 | goto out; | |
15490795 SR |
1243 | |
1244 | /* FIXME: check response code and validate response data */ | |
1245 | ||
1246 | *interval = r->operand[get_ca_object_pos(r)]; | |
3fb80ef3 SR |
1247 | out: |
1248 | mutex_unlock(&fdtv->avc_mutex); | |
15490795 | 1249 | |
3fb80ef3 | 1250 | return ret; |
15490795 SR |
1251 | } |
1252 | ||
1253 | int avc_ca_enter_menu(struct firedtv *fdtv) | |
1254 | { | |
3fb80ef3 SR |
1255 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
1256 | int ret; | |
1257 | ||
6385c5bf | 1258 | mutex_lock(&fdtv->avc_mutex); |
15490795 | 1259 | |
15490795 SR |
1260 | c->ctype = AVC_CTYPE_STATUS; |
1261 | c->subunit = AVC_SUBUNIT_TYPE_TUNER | fdtv->subunit; | |
1262 | c->opcode = AVC_OPCODE_VENDOR; | |
1263 | ||
1264 | c->operand[0] = SFE_VENDOR_DE_COMPANYID_0; | |
1265 | c->operand[1] = SFE_VENDOR_DE_COMPANYID_1; | |
1266 | c->operand[2] = SFE_VENDOR_DE_COMPANYID_2; | |
1267 | c->operand[3] = SFE_VENDOR_OPCODE_HOST2CA; | |
1268 | c->operand[4] = 0; /* slot */ | |
1269 | c->operand[5] = SFE_VENDOR_TAG_CA_ENTER_MENU; | |
1e4348c8 | 1270 | clear_operands(c, 6, 8); |
15490795 | 1271 | |
3fb80ef3 SR |
1272 | fdtv->avc_data_length = 12; |
1273 | ret = avc_write(fdtv); | |
15490795 | 1274 | |
3fb80ef3 | 1275 | /* FIXME: check response code? */ |
15490795 | 1276 | |
3fb80ef3 SR |
1277 | mutex_unlock(&fdtv->avc_mutex); |
1278 | ||
1279 | return ret; | |
15490795 SR |
1280 | } |
1281 | ||
1282 | int avc_ca_get_mmi(struct firedtv *fdtv, char *mmi_object, unsigned int *len) | |
1283 | { | |
3fb80ef3 SR |
1284 | struct avc_command_frame *c = (void *)fdtv->avc_data; |
1285 | struct avc_response_frame *r = (void *)fdtv->avc_data; | |
1286 | int ret; | |
1287 | ||
6385c5bf | 1288 | mutex_lock(&fdtv->avc_mutex); |
15490795 | 1289 | |
15490795 SR |
1290 | c->ctype = AVC_CTYPE_STATUS; |
1291 | c->subunit = AVC_SUBUNIT_TYPE_TUNER | fdtv->subunit; | |
1292 | c->opcode = AVC_OPCODE_VENDOR; | |
1293 | ||
1294 | c->operand[0] = SFE_VENDOR_DE_COMPANYID_0; | |
1295 | c->operand[1] = SFE_VENDOR_DE_COMPANYID_1; | |
1296 | c->operand[2] = SFE_VENDOR_DE_COMPANYID_2; | |
1297 | c->operand[3] = SFE_VENDOR_OPCODE_CA2HOST; | |
1298 | c->operand[4] = 0; /* slot */ | |
1299 | c->operand[5] = SFE_VENDOR_TAG_CA_MMI; | |
1e4348c8 | 1300 | clear_operands(c, 6, LAST_OPERAND); |
15490795 | 1301 | |
3fb80ef3 SR |
1302 | fdtv->avc_data_length = 12; |
1303 | ret = avc_write(fdtv); | |
1304 | if (ret < 0) | |
1305 | goto out; | |
15490795 SR |
1306 | |
1307 | /* FIXME: check response code and validate response data */ | |
1308 | ||
1309 | *len = get_ca_object_length(r); | |
1310 | memcpy(mmi_object, &r->operand[get_ca_object_pos(r)], *len); | |
3fb80ef3 SR |
1311 | out: |
1312 | mutex_unlock(&fdtv->avc_mutex); | |
15490795 | 1313 | |
3fb80ef3 | 1314 | return ret; |
15490795 SR |
1315 | } |
1316 | ||
1317 | #define CMP_OUTPUT_PLUG_CONTROL_REG_0 0xfffff0000904ULL | |
1318 | ||
5375659a | 1319 | static int cmp_read(struct firedtv *fdtv, u64 addr, __be32 *data) |
15490795 SR |
1320 | { |
1321 | int ret; | |
1322 | ||
6385c5bf | 1323 | mutex_lock(&fdtv->avc_mutex); |
15490795 | 1324 | |
5375659a | 1325 | ret = fdtv->backend->read(fdtv, addr, data); |
15490795 SR |
1326 | if (ret < 0) |
1327 | dev_err(fdtv->device, "CMP: read I/O error\n"); | |
1328 | ||
1329 | mutex_unlock(&fdtv->avc_mutex); | |
3fb80ef3 | 1330 | |
15490795 SR |
1331 | return ret; |
1332 | } | |
1333 | ||
054286b1 | 1334 | static int cmp_lock(struct firedtv *fdtv, u64 addr, __be32 data[]) |
15490795 SR |
1335 | { |
1336 | int ret; | |
1337 | ||
6385c5bf | 1338 | mutex_lock(&fdtv->avc_mutex); |
15490795 | 1339 | |
3fb80ef3 SR |
1340 | /* data[] is stack-allocated and should not be DMA-mapped. */ |
1341 | memcpy(fdtv->avc_data, data, 8); | |
1342 | ||
1343 | ret = fdtv->backend->lock(fdtv, addr, fdtv->avc_data); | |
15490795 SR |
1344 | if (ret < 0) |
1345 | dev_err(fdtv->device, "CMP: lock I/O error\n"); | |
3fb80ef3 SR |
1346 | else |
1347 | memcpy(data, fdtv->avc_data, 8); | |
15490795 SR |
1348 | |
1349 | mutex_unlock(&fdtv->avc_mutex); | |
3fb80ef3 | 1350 | |
15490795 SR |
1351 | return ret; |
1352 | } | |
1353 | ||
1354 | static inline u32 get_opcr(__be32 opcr, u32 mask, u32 shift) | |
1355 | { | |
1356 | return (be32_to_cpu(opcr) >> shift) & mask; | |
1357 | } | |
1358 | ||
1359 | static inline void set_opcr(__be32 *opcr, u32 value, u32 mask, u32 shift) | |
1360 | { | |
1361 | *opcr &= ~cpu_to_be32(mask << shift); | |
1362 | *opcr |= cpu_to_be32((value & mask) << shift); | |
1363 | } | |
1364 | ||
1365 | #define get_opcr_online(v) get_opcr((v), 0x1, 31) | |
1366 | #define get_opcr_p2p_connections(v) get_opcr((v), 0x3f, 24) | |
1367 | #define get_opcr_channel(v) get_opcr((v), 0x3f, 16) | |
1368 | ||
1369 | #define set_opcr_p2p_connections(p, v) set_opcr((p), (v), 0x3f, 24) | |
1370 | #define set_opcr_channel(p, v) set_opcr((p), (v), 0x3f, 16) | |
1371 | #define set_opcr_data_rate(p, v) set_opcr((p), (v), 0x3, 14) | |
1372 | #define set_opcr_overhead_id(p, v) set_opcr((p), (v), 0xf, 10) | |
1373 | ||
1374 | int cmp_establish_pp_connection(struct firedtv *fdtv, int plug, int channel) | |
1375 | { | |
054286b1 | 1376 | __be32 old_opcr, opcr[2]; |
15490795 SR |
1377 | u64 opcr_address = CMP_OUTPUT_PLUG_CONTROL_REG_0 + (plug << 2); |
1378 | int attempts = 0; | |
1379 | int ret; | |
1380 | ||
5375659a | 1381 | ret = cmp_read(fdtv, opcr_address, opcr); |
15490795 SR |
1382 | if (ret < 0) |
1383 | return ret; | |
1384 | ||
1385 | repeat: | |
054286b1 | 1386 | if (!get_opcr_online(*opcr)) { |
15490795 SR |
1387 | dev_err(fdtv->device, "CMP: output offline\n"); |
1388 | return -EBUSY; | |
1389 | } | |
1390 | ||
054286b1 | 1391 | old_opcr = *opcr; |
15490795 | 1392 | |
054286b1 SR |
1393 | if (get_opcr_p2p_connections(*opcr)) { |
1394 | if (get_opcr_channel(*opcr) != channel) { | |
15490795 SR |
1395 | dev_err(fdtv->device, "CMP: cannot change channel\n"); |
1396 | return -EBUSY; | |
1397 | } | |
1398 | dev_info(fdtv->device, "CMP: overlaying connection\n"); | |
1399 | ||
1400 | /* We don't allocate isochronous resources. */ | |
1401 | } else { | |
054286b1 SR |
1402 | set_opcr_channel(opcr, channel); |
1403 | set_opcr_data_rate(opcr, 2); /* S400 */ | |
15490795 SR |
1404 | |
1405 | /* FIXME: this is for the worst case - optimize */ | |
054286b1 | 1406 | set_opcr_overhead_id(opcr, 0); |
15490795 SR |
1407 | |
1408 | /* | |
1409 | * FIXME: allocate isochronous channel and bandwidth at IRM | |
1410 | * fdtv->backend->alloc_resources(fdtv, channels_mask, bw); | |
1411 | */ | |
1412 | } | |
1413 | ||
054286b1 | 1414 | set_opcr_p2p_connections(opcr, get_opcr_p2p_connections(*opcr) + 1); |
15490795 | 1415 | |
054286b1 SR |
1416 | opcr[1] = *opcr; |
1417 | opcr[0] = old_opcr; | |
1418 | ||
1419 | ret = cmp_lock(fdtv, opcr_address, opcr); | |
15490795 SR |
1420 | if (ret < 0) |
1421 | return ret; | |
1422 | ||
054286b1 | 1423 | if (old_opcr != *opcr) { |
15490795 SR |
1424 | /* |
1425 | * FIXME: if old_opcr.P2P_Connections > 0, | |
1426 | * deallocate isochronous channel and bandwidth at IRM | |
1427 | * if (...) | |
1428 | * fdtv->backend->dealloc_resources(fdtv, channel, bw); | |
1429 | */ | |
1430 | ||
1431 | if (++attempts < 6) /* arbitrary limit */ | |
1432 | goto repeat; | |
1433 | return -EBUSY; | |
1434 | } | |
1435 | ||
1436 | return 0; | |
1437 | } | |
1438 | ||
1439 | void cmp_break_pp_connection(struct firedtv *fdtv, int plug, int channel) | |
1440 | { | |
054286b1 | 1441 | __be32 old_opcr, opcr[2]; |
15490795 SR |
1442 | u64 opcr_address = CMP_OUTPUT_PLUG_CONTROL_REG_0 + (plug << 2); |
1443 | int attempts = 0; | |
1444 | ||
5375659a | 1445 | if (cmp_read(fdtv, opcr_address, opcr) < 0) |
15490795 SR |
1446 | return; |
1447 | ||
1448 | repeat: | |
054286b1 SR |
1449 | if (!get_opcr_online(*opcr) || !get_opcr_p2p_connections(*opcr) || |
1450 | get_opcr_channel(*opcr) != channel) { | |
15490795 SR |
1451 | dev_err(fdtv->device, "CMP: no connection to break\n"); |
1452 | return; | |
1453 | } | |
1454 | ||
054286b1 SR |
1455 | old_opcr = *opcr; |
1456 | set_opcr_p2p_connections(opcr, get_opcr_p2p_connections(*opcr) - 1); | |
1457 | ||
1458 | opcr[1] = *opcr; | |
1459 | opcr[0] = old_opcr; | |
15490795 | 1460 | |
054286b1 | 1461 | if (cmp_lock(fdtv, opcr_address, opcr) < 0) |
15490795 SR |
1462 | return; |
1463 | ||
054286b1 | 1464 | if (old_opcr != *opcr) { |
15490795 SR |
1465 | /* |
1466 | * FIXME: if old_opcr.P2P_Connections == 1, i.e. we were last | |
1467 | * owner, deallocate isochronous channel and bandwidth at IRM | |
1468 | * if (...) | |
1469 | * fdtv->backend->dealloc_resources(fdtv, channel, bw); | |
1470 | */ | |
1471 | ||
1472 | if (++attempts < 6) /* arbitrary limit */ | |
1473 | goto repeat; | |
1474 | } | |
1475 | } |