PS2SDK
PS2 Homebrew Libraries
Loading...
Searching...
No Matches
dvrmisc.c
1/*
2# _____ ___ ____ ___ ____
3# ____| | ____| | | |____|
4# | ___| |____ ___| ____| | \ PS2DEV Open Source Project.
5#-----------------------------------------------------------------------
6# Copyright 2021-2021, ps2dev - http://www.ps2dev.org
7# Licenced under Academic Free License version 2.0
8# Review ps2sdk README & LICENSE files for further details.
9*/
10
11#include <stdbool.h>
12#include "iomanX.h"
13#include "loadcore.h"
14#include "pvrdrv.h"
15#include "stdio.h"
16#include "sysclib.h"
17#include "thbase.h"
18#include "thsemap.h"
19#include "speedregs.h"
20#include "errno.h"
21
22#define MODNAME "DVRMISC"
23#ifdef DEBUG
24#define DPRINTF(x...) printf(MODNAME ": " x)
25#else
26#define DPRINTF(x...)
27#endif
28
29extern int module_start(int argc, char *argv[], void *startaddr, ModuleInfo_t *mi);
30extern int module_stop(int argc, char *argv[], void *startaddr, ModuleInfo_t *mi);
31extern int dvrmisc_df_init(iomanX_iop_device_t *dev);
32extern int dvrmisc_df_exit(iomanX_iop_device_t *dev);
33extern int dvrmisc_df_ioctl(iomanX_iop_file_t *f, int cmd, void *param);
34extern int dvrmisc_df_devctl(iomanX_iop_file_t *a1, const char *name, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
35extern int dvrmisc_df_ioctl2(iomanX_iop_file_t *f, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
36extern int dvrioctl2_nop(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
37extern int dvrioctl2_version(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
38extern int dvrioctl2_led_hdd_rec(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
39extern int dvrioctl2_led_dvd_rec(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
40extern int dvrioctl2_get_sircs(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
41extern int dvrioctl2_get_time(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
42extern int dvrioctl2_set_timezone(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
43extern int dvrioctl2_save_preset_info(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
44extern int dvrioctl2_load_preset_info(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
45extern int dvrioctl2_test_dev_rst(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
46extern int dvrioctl2_test_sdram_chk(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
47extern int dvrioctl2_test_mpe_chk(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
48extern int dvrioctl2_test_mpd_chk(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
49extern int dvrioctl2_test_vdec_chk(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
50extern int dvrioctl2_partition_free(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
51extern int dvrioctl2_buzzer(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
52extern int dvrioctl2_clr_preset_info(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
53extern int dvrioctl2_get_vbi_err_rate(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
54extern int dvrioctl2_update_dvrp_firmware(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
55extern int dvrioctl2_flash_write_status(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
56extern int dvrioctl2_set_device_key(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
57extern int dvrioctl2_get_device_key(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
58extern int dvrioctl2_set_dv_nodeid(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
59extern int dvrioctl2_get_dv_nodeid(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
60extern int dvrioctl2_diag_test(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen);
61
62struct DevctlCmdTbl_t
63{
64 u16 cmd;
65 int (*fn)(iomanX_iop_file_t *, int, void *, unsigned int, void *, unsigned int);
66} DevctlCmdTbl[25] =
67 {
68 {0x5668, &dvrioctl2_get_sircs},
69 {0x5666, &dvrioctl2_led_hdd_rec},
70 {0x5667, &dvrioctl2_led_dvd_rec},
71 {0x5669, &dvrioctl2_get_time},
72 {0x566A, &dvrioctl2_set_timezone},
73 {0x566B, &dvrioctl2_save_preset_info},
74 {0x566C, &dvrioctl2_load_preset_info},
75 {0x5664, &dvrioctl2_nop},
76 {0x5665, &dvrioctl2_version},
77 {0x566D, &dvrioctl2_test_dev_rst},
78 {0x566E, &dvrioctl2_test_sdram_chk},
79 {0x566F, &dvrioctl2_test_mpe_chk},
80 {0x5670, &dvrioctl2_test_mpd_chk},
81 {0x5671, &dvrioctl2_test_vdec_chk},
82 {0x5672, &dvrioctl2_partition_free},
83 {0x5673, &dvrioctl2_buzzer},
84 {0x5674, &dvrioctl2_clr_preset_info},
85 {0x5675, &dvrioctl2_get_vbi_err_rate},
86 {0x5676, &dvrioctl2_update_dvrp_firmware},
87 {0x5677, &dvrioctl2_flash_write_status},
88 {0x5678, &dvrioctl2_set_device_key},
89 {0x5679, &dvrioctl2_get_device_key},
90 {0x567A, &dvrioctl2_set_dv_nodeid},
91 {0x567B, &dvrioctl2_get_dv_nodeid},
92 {0x5682, &dvrioctl2_diag_test},
93};
94
95IOMANX_RETURN_VALUE_IMPL(EUNSUP);
96
97static iomanX_iop_device_ops_t DvrFuncTbl =
98 {
99 &dvrmisc_df_init, // init
100 &dvrmisc_df_exit, // deinit
101 IOMANX_RETURN_VALUE(EUNSUP), // format
102 IOMANX_RETURN_VALUE(EUNSUP), // open
103 IOMANX_RETURN_VALUE(EUNSUP), // close
104 IOMANX_RETURN_VALUE(EUNSUP), // read
105 IOMANX_RETURN_VALUE(EUNSUP), // write
106 IOMANX_RETURN_VALUE(EUNSUP), // lseek
107 &dvrmisc_df_ioctl, // ioctl
108 IOMANX_RETURN_VALUE(EUNSUP), // remove
109 IOMANX_RETURN_VALUE(EUNSUP), // mkdir
110 IOMANX_RETURN_VALUE(EUNSUP), // rmdir
111 IOMANX_RETURN_VALUE(EUNSUP), // dopen
112 IOMANX_RETURN_VALUE(EUNSUP), // dclose
113 IOMANX_RETURN_VALUE(EUNSUP), // dread
114 IOMANX_RETURN_VALUE(EUNSUP), // getstat
115 IOMANX_RETURN_VALUE(EUNSUP), // chstat
116 IOMANX_RETURN_VALUE(EUNSUP), // rename
117 IOMANX_RETURN_VALUE(EUNSUP), // chdir
118 IOMANX_RETURN_VALUE(EUNSUP), // sync
119 IOMANX_RETURN_VALUE(EUNSUP), // mount
120 IOMANX_RETURN_VALUE(EUNSUP), // umount
121 IOMANX_RETURN_VALUE_S64(EUNSUP), // lseek64
122 &dvrmisc_df_devctl, // devctl
123 IOMANX_RETURN_VALUE(EUNSUP), // symlink
124 IOMANX_RETURN_VALUE(EUNSUP), // readlink
125 &dvrmisc_df_ioctl2, // ioctl2
126 };
127static iomanX_iop_device_t DVRMISC = {
128 .name = "dvr_misc",
129 .desc = "Digital Video Recorder MISC task",
130 .type = (IOP_DT_FS | IOP_DT_FSEXT),
131 .ops = &DvrFuncTbl,
132};
133s32 sema_id;
134char SBUF[16384];
135
136// Based off of DESR / PSX DVR system software version 1.31.
137// Added additional functions from DESR / PSX DVR system software version 2.11.
138IRX_ID(MODNAME, 1, 1);
139
140int _start(int argc, char *argv[], void *startaddr, ModuleInfo_t *mi)
141{
142 if (argc >= 0)
143 return module_start(argc, argv, startaddr, mi);
144 else
145 return module_stop(argc, argv, startaddr, mi);
146}
147
148int module_start(int argc, char *argv[], void *startaddr, ModuleInfo_t *mi)
149{
150 int i;
151
152 (void)argc;
153 (void)argv;
154 (void)startaddr;
155
156 for (i = 0; i < 30000; ++i) {
157 if (((*((vu32 *)0xB0004230)) & 4) != 0)
158 break;
159 DelayThread(1000);
160 }
161 if (i == 30000) {
162 DPRINTF("MISC task of DVRP is not running...\n");
163 return MODULE_NO_RESIDENT_END;
164 } else {
165 if (iomanX_AddDrv(&DVRMISC) != 0)
166 return MODULE_NO_RESIDENT_END;
167 }
168#if 0
169 return MODULE_REMOVABLE_END;
170#else
171 if (mi && ((mi->newflags & 2) != 0))
172 mi->newflags |= 0x10;
173 return MODULE_RESIDENT_END;
174#endif
175}
176
177int module_stop(int argc, char *argv[], void *startaddr, ModuleInfo_t *mi)
178{
179 (void)argc;
180 (void)argv;
181 (void)startaddr;
182 (void)mi;
183
184 if (iomanX_DelDrv(DVRMISC.name) != 0)
185 return MODULE_REMOVABLE_END;
186 return MODULE_NO_RESIDENT_END;
187}
188
189int dvrmisc_df_init(iomanX_iop_device_t *dev)
190{
191 int v1;
192 iop_sema_t v3;
193
194 (void)dev;
195
196 v3.attr = 0;
197 v3.initial = 1;
198 v3.max = 1;
199 v3.option = 0;
200 v1 = CreateSema(&v3);
201 if (v1 < 0)
202 return -1;
203 sema_id = v1;
204 return 0;
205}
206
207int dvrmisc_df_exit(iomanX_iop_device_t *dev)
208{
209 (void)dev;
210
211 if (DeleteSema(sema_id) != 0)
212 return -1;
213 return 0;
214}
215
216int dvrmisc_df_ioctl(iomanX_iop_file_t *f, int cmd, void *param)
217{
218 (void)f;
219 (void)cmd;
220 (void)param;
221
222 WaitSema(sema_id);
223 SignalSema(sema_id);
224 return -EINVAL;
225}
226
227int dvrmisc_df_devctl(
228 iomanX_iop_file_t *a1,
229 const char *name,
230 int cmd,
231 void *arg,
232 unsigned int arglen,
233 void *buf,
234 unsigned int buflen)
235{
236 int v10;
237 unsigned int v11;
238 unsigned int v12;
239
240 (void)name;
241
242 v10 = 0;
243 v11 = 0;
244 WaitSema(sema_id);
245 v12 = 0;
246 while (DevctlCmdTbl[v12].cmd != cmd) {
247 v12 = ++v11;
248 if (v11 >= sizeof(DevctlCmdTbl) / sizeof(DevctlCmdTbl[0]))
249 goto LABEL_5;
250 }
251 v10 = DevctlCmdTbl[v12].fn(a1, cmd, arg, arglen, buf, buflen);
252LABEL_5:
253 if (v11 == sizeof(DevctlCmdTbl) / sizeof(DevctlCmdTbl[0]))
254 v10 = -EINVAL;
255 SignalSema(sema_id);
256 return v10;
257}
258
259int dvrmisc_df_ioctl2(
260 iomanX_iop_file_t *f,
261 int cmd,
262 void *arg,
263 unsigned int arglen,
264 void *buf,
265 unsigned int buflen)
266{
267
268 (void)f;
269 (void)cmd;
270 (void)arg;
271 (void)arglen;
272 (void)buf;
273 (void)buflen;
274
275 WaitSema(sema_id);
276 SignalSema(sema_id);
277 return -EINVAL;
278}
279
280int dvrioctl2_nop(iomanX_iop_file_t *a1, int cmd, void *arg, unsigned int arglen, void *buf, unsigned int buflen)
281{
282 drvdrv_exec_cmd_ack cmdack;
283
284 (void)a1;
285 (void)cmd;
286 (void)arg;
287 (void)arglen;
288 (void)buf;
289 (void)buflen;
290
291 cmdack.command = 0x5101;
292 cmdack.input_word_count = 0;
293 if (DvrdrvExecCmdAck(&cmdack)) {
294 DPRINTF("dvrioctl2_nop -> Handshake error!\n");
295 return -EIO;
296 } else {
297 if (cmdack.ack_status_ack) {
298 DPRINTF("dvrioctl2_nop -> Status error!\n");
299 return -EADV;
300 }
301 }
302 return 0;
303}
304
305int dvrioctl2_version(
306 iomanX_iop_file_t *a1,
307 int cmd,
308 void *arg,
309 unsigned int arglen,
310 void *buf,
311 unsigned int buflen)
312{
313 drvdrv_exec_cmd_ack cmdack;
314
315 (void)a1;
316 (void)cmd;
317 (void)arg;
318 (void)arglen;
319 (void)buflen;
320
321 cmdack.command = 0x5102;
322 cmdack.input_word_count = 0;
323 if (DvrdrvExecCmdAck(&cmdack)) {
324 DPRINTF("dvrioctl2_version -> Handshake error!\n");
325 return -EIO;
326 } else if (cmdack.ack_status_ack) {
327 DPRINTF("dvrioctl2_version -> Status error!\n");
328 return -EADV;
329 } else {
330 *(u16 *)buf = cmdack.output_word[0];
331 *((u16 *)buf + 1) = cmdack.output_word[1];
332 }
333 return 0;
334}
335
336int dvrioctl2_led_hdd_rec(
337 iomanX_iop_file_t *a1,
338 int cmd,
339 void *arg,
340 unsigned int arglen,
341 void *buf,
342 unsigned int buflen)
343{
344 drvdrv_exec_cmd_ack cmdack;
345
346 (void)a1;
347 (void)cmd;
348 (void)arglen;
349 (void)buf;
350 (void)buflen;
351
352 cmdack.command = 0x5104;
353 cmdack.input_word_count = 1;
354 cmdack.input_word[0] = *(u16 *)arg;
355 if (DvrdrvExecCmdAck(&cmdack)) {
356 DPRINTF("dvrioctl2_led_hdd_rec -> Handshake error!\n");
357 return -EIO;
358 } else {
359 if (cmdack.ack_status_ack) {
360 DPRINTF("dvrioctl2_led_hdd_rec -> Status error!\n");
361 return -EADV;
362 }
363 }
364 return 0;
365}
366
367int dvrioctl2_led_dvd_rec(
368 iomanX_iop_file_t *a1,
369 int cmd,
370 void *arg,
371 unsigned int arglen,
372 void *buf,
373 unsigned int buflen)
374{
375 drvdrv_exec_cmd_ack cmdack;
376
377 (void)a1;
378 (void)cmd;
379 (void)arglen;
380 (void)buf;
381 (void)buflen;
382
383 cmdack.command = 0x5106;
384 cmdack.input_word_count = 1;
385 cmdack.input_word[0] = *(u16 *)arg;
386 if (DvrdrvExecCmdAck(&cmdack)) {
387 DPRINTF("dvrioctl2_led_dvd_rec -> Handshake error!\n");
388 return -EIO;
389 } else {
390 if (cmdack.ack_status_ack) {
391 DPRINTF("dvrioctl2_led_dvd_rec -> Status error!\n");
392 return -EADV;
393 }
394 }
395 return 0;
396}
397
398int dvrioctl2_get_sircs(
399 iomanX_iop_file_t *a1,
400 int cmd,
401 void *arg,
402 unsigned int arglen,
403 void *buf,
404 unsigned int buflen)
405{
406 drvdrv_exec_cmd_ack cmdack;
407
408 (void)a1;
409 (void)cmd;
410 (void)arg;
411 (void)arglen;
412 (void)buflen;
413
414 cmdack.command = 0x5107;
415 cmdack.input_word_count = 0;
416 if (DvrdrvExecCmdAck(&cmdack)) {
417 DPRINTF("dvrioctl2_get_sircs -> Handshake error!\n");
418 return -EIO;
419 } else if (cmdack.ack_status_ack) {
420 DPRINTF("dvrioctl2_get_sircs -> Status error!\n");
421 return -EADV;
422 } else {
423 *(u16 *)buf = cmdack.output_word[0];
424 *((u16 *)buf + 1) = cmdack.output_word[1];
425 *((u16 *)buf + 2) = cmdack.output_word[2];
426 *((u16 *)buf + 3) = cmdack.output_word[3];
427 *((u16 *)buf + 4) = cmdack.output_word[4];
428 }
429 return 0;
430}
431
432int dvrioctl2_get_time(
433 iomanX_iop_file_t *a1,
434 int cmd,
435 void *arg,
436 unsigned int arglen,
437 void *buf,
438 unsigned int buflen)
439{
440 drvdrv_exec_cmd_ack cmdack;
441
442 (void)a1;
443 (void)cmd;
444 (void)arg;
445 (void)arglen;
446 (void)buflen;
447
448 cmdack.command = 0x5108;
449 cmdack.input_word_count = 0;
450 if (DvrdrvExecCmdAck(&cmdack)) {
451 DPRINTF("dvrioctl2_get_time -> Handshake error!\n");
452 return -EIO;
453 } else if (cmdack.ack_status_ack) {
454 DPRINTF("dvrioctl2_get_time -> Status error!\n");
455 return -EADV;
456 } else {
457 *(u8 *)buf = cmdack.output_word[0];
458 *((u8 *)buf + 1) = cmdack.output_word[1];
459 *((u8 *)buf + 2) = cmdack.output_word[2];
460 *((u8 *)buf + 3) = cmdack.output_word[3];
461 *((u8 *)buf + 5) = cmdack.output_word[5];
462 *((u8 *)buf + 6) = cmdack.output_word[6];
463 *((u8 *)buf + 7) = cmdack.output_word[7];
464 }
465 return 0;
466}
467
468int dvrioctl2_set_timezone(
469 iomanX_iop_file_t *a1,
470 int cmd,
471 void *arg,
472 unsigned int arglen,
473 void *buf,
474 unsigned int buflen)
475{
476 drvdrv_exec_cmd_ack cmdack;
477
478 (void)a1;
479 (void)cmd;
480 (void)arglen;
481 (void)buf;
482 (void)buflen;
483
484 cmdack.command = 0x5109;
485 cmdack.input_word[0] = *(u16 *)arg;
486 cmdack.input_word_count = 2;
487 cmdack.input_word[1] = *((u16 *)arg + 1);
488 if (DvrdrvExecCmdAck(&cmdack)) {
489 DPRINTF("dvrioctl2_set_timezone -> Handshake error!\n");
490 return -EIO;
491 } else {
492 if (cmdack.ack_status_ack) {
493 DPRINTF("dvrioctl2_set_timezone -> Status error!\n");
494 return -EADV;
495 }
496 }
497 return 0;
498}
499
500int dvrioctl2_save_preset_info(
501 iomanX_iop_file_t *a1,
502 int cmd,
503 void *arg,
504 unsigned int arglen,
505 void *buf,
506 unsigned int buflen)
507{
508 drvdrv_exec_cmd_ack cmdack;
509
510 (void)a1;
511 (void)cmd;
512 (void)arg;
513 (void)arglen;
514 (void)buf;
515 (void)buflen;
516
517 cmdack.command = 0x510A;
518 cmdack.input_word_count = 0;
519 cmdack.timeout = 15000000;
520 if (DvrdrvExecCmdAckComp(&cmdack)) {
521 DPRINTF("dvrioctl2_save_preset_info -> Handshake error!\n");
522 return -EIO;
523 } else if (cmdack.ack_status_ack || cmdack.comp_status) {
524 DPRINTF("dvrioctl2_save_preset_info -> Status error!\n");
525 return -EADV;
526 }
527 return 0;
528}
529
530int dvrioctl2_load_preset_info(
531 iomanX_iop_file_t *a1,
532 int cmd,
533 void *arg,
534 unsigned int arglen,
535 void *buf,
536 unsigned int buflen)
537{
538 drvdrv_exec_cmd_ack cmdack;
539
540 (void)a1;
541 (void)cmd;
542 (void)arg;
543 (void)arglen;
544 (void)buf;
545 (void)buflen;
546
547 cmdack.command = 0x510B;
548 cmdack.input_word_count = 0;
549 cmdack.timeout = 15000000;
550 if (DvrdrvExecCmdAckComp(&cmdack)) {
551 DPRINTF("dvrioctl2_load_preset_info -> Handshake error!\n");
552 return -EIO;
553 } else if (cmdack.ack_status_ack || cmdack.comp_status) {
554 DPRINTF("dvrioctl2_load_preset_info -> Status error!\n");
555 return -EADV;
556 }
557 return 0;
558}
559
560int dvrioctl2_test_dev_rst(
561 iomanX_iop_file_t *a1,
562 int cmd,
563 void *arg,
564 unsigned int arglen,
565 void *buf,
566 unsigned int buflen)
567{
568 drvdrv_exec_cmd_ack cmdack;
569
570 (void)a1;
571 (void)cmd;
572 (void)arg;
573 (void)arglen;
574 (void)buf;
575 (void)buflen;
576
577 cmdack.command = 0x510C;
578 cmdack.input_word_count = 0;
579 cmdack.timeout = 15000000;
580 if (DvrdrvExecCmdAckComp(&cmdack)) {
581 DPRINTF("dvrioctl2_test_dev_rst -> Handshake error!\n");
582 return -EIO;
583 } else if (cmdack.ack_status_ack || cmdack.comp_status) {
584 DPRINTF("dvrioctl2_test_dev_rst -> Status error!\n");
585 return -EADV;
586 }
587 return 0;
588}
589
590int dvrioctl2_test_sdram_chk(
591 iomanX_iop_file_t *a1,
592 int cmd,
593 void *arg,
594 unsigned int arglen,
595 void *buf,
596 unsigned int buflen)
597{
598 drvdrv_exec_cmd_ack cmdack;
599
600 (void)a1;
601 (void)cmd;
602 (void)arg;
603 (void)arglen;
604 (void)buflen;
605
606 cmdack.command = 0x510D;
607 cmdack.input_word_count = 0;
608 cmdack.timeout = 20000000;
609 if (DvrdrvExecCmdAckComp(&cmdack)) {
610 DPRINTF("dvrioctl2_test_sdram_chk -> Handshake error!\n");
611 return -EIO;
612 } else if (cmdack.ack_status_ack || cmdack.comp_status) {
613 DPRINTF("dvrioctl2_test_sdram_chk -> Status error!\n");
614 return -EADV;
615 } else {
616 *(u32 *)buf = (cmdack.return_result_word[0] << 16) + cmdack.return_result_word[1];
617 *((u32 *)buf + 1) = (cmdack.return_result_word[2] << 16) + cmdack.return_result_word[3];
618 *((u32 *)buf + 2) = (cmdack.return_result_word[4] << 16) + cmdack.return_result_word[5];
619 }
620 return 0;
621}
622
623int dvrioctl2_test_mpe_chk(
624 iomanX_iop_file_t *a1,
625 int cmd,
626 void *arg,
627 unsigned int arglen,
628 void *buf,
629 unsigned int buflen)
630{
631 drvdrv_exec_cmd_ack cmdack;
632
633 (void)a1;
634 (void)cmd;
635 (void)arg;
636 (void)arglen;
637 (void)buflen;
638
639 cmdack.command = 0x510E;
640 cmdack.input_word_count = 0;
641 cmdack.timeout = 15000000;
642 if (DvrdrvExecCmdAckComp(&cmdack)) {
643 DPRINTF("dvrioctl2_test_mpe_chk -> Handshake error!\n");
644 return -EIO;
645 } else if (cmdack.ack_status_ack || cmdack.comp_status) {
646 DPRINTF("dvrioctl2_test_mpe_chk -> Status error!\n");
647 return -EADV;
648 } else {
649 *(u16 *)buf = cmdack.return_result_word[0];
650 }
651 return 0;
652}
653
654int dvrioctl2_test_mpd_chk(
655 iomanX_iop_file_t *a1,
656 int cmd,
657 void *arg,
658 unsigned int arglen,
659 void *buf,
660 unsigned int buflen)
661{
662 drvdrv_exec_cmd_ack cmdack;
663
664 (void)a1;
665 (void)cmd;
666 (void)arg;
667 (void)arglen;
668 (void)buflen;
669
670 cmdack.command = 0x510F;
671 cmdack.input_word_count = 0;
672 cmdack.timeout = 15000000;
673 if (DvrdrvExecCmdAckComp(&cmdack)) {
674 DPRINTF("dvrioctl2_test_mpd_chk -> Handshake error!\n");
675 return -EIO;
676 } else if (cmdack.ack_status_ack || cmdack.comp_status) {
677 DPRINTF("dvrioctl2_test_mpd_chk -> Status error!\n");
678 return -EADV;
679 } else {
680 *(u16 *)buf = cmdack.return_result_word[0];
681 }
682 return 0;
683}
684
685int dvrioctl2_test_vdec_chk(
686 iomanX_iop_file_t *a1,
687 int cmd,
688 void *arg,
689 unsigned int arglen,
690 void *buf,
691 unsigned int buflen)
692{
693 drvdrv_exec_cmd_ack cmdack;
694
695 (void)a1;
696 (void)cmd;
697 (void)arg;
698 (void)arglen;
699 (void)buf;
700 (void)buflen;
701
702 cmdack.command = 0x5110;
703 cmdack.input_word_count = 0;
704 cmdack.timeout = 15000000;
705 if (DvrdrvExecCmdAckComp(&cmdack)) {
706 DPRINTF("dvrioctl2_test_vdec_chk -> Handshake error!\n");
707 return -EIO;
708 } else if (cmdack.ack_status_ack || cmdack.comp_status) {
709 DPRINTF("dvrioctl2_test_vdec_chk -> Status error!\n");
710 return -EADV;
711 }
712 return 0;
713}
714
715int dvrioctl2_partition_free(
716 iomanX_iop_file_t *a1,
717 int cmd,
718 void *arg,
719 unsigned int arglen,
720 void *buf,
721 unsigned int buflen)
722{
723 int v7;
724 int v8;
725 int v9;
726 s64 v10;
727
728 (void)a1;
729 (void)cmd;
730 (void)arglen;
731 (void)buflen;
732
733 v7 = iomanX_devctl((const char *)arg, 0x5002, 0, 0, 0, 0);
734 v8 = v7;
735 if (v7 < 0) {
736 DPRINTF("dvrioctl2_partition_free : Cannot execute PDIOC_ZONEFREE.,%d\n", v7);
737 return -EIO;
738 }
739 v9 = iomanX_devctl((const char *)arg, 0x5001, 0, 0, 0, 0);
740 v10 = v8 * (s64)v9;
741 if (v9 < 0) {
742 DPRINTF("dvrioctl2_partition_free : Cannot execute PDIOC_ZONESZ.,%d\n", v9);
743 return -EIO;
744 }
745 *(u64 *)buf = v10;
746 if (*(s64 *)buf <= 0x7FFFFFF) {
747 *(u32 *)buf = 0;
748 *((u32 *)buf + 1) = 0;
749 } else {
750 *(u32 *)buf = v10 - 0x8000000;
751 *((u32 *)buf + 1) = (v10 >> 32) - 1 + ((unsigned int)(v10 - 0x8000000) < 0xF8000000);
752 }
753 return 0;
754}
755
756int dvrioctl2_buzzer(
757 iomanX_iop_file_t *a1,
758 int cmd,
759 void *arg,
760 unsigned int arglen,
761 void *buf,
762 unsigned int buflen)
763{
764 drvdrv_exec_cmd_ack cmdack;
765
766 (void)a1;
767 (void)cmd;
768 (void)arg;
769 (void)arglen;
770 (void)buf;
771 (void)buflen;
772
773 cmdack.command = 0x5111;
774 cmdack.input_word_count = 0;
775 if (DvrdrvExecCmdAck(&cmdack)) {
776 DPRINTF("dvrioctl2_buzzer -> Handshake error!\n");
777 return -EIO;
778 } else {
779 if (cmdack.ack_status_ack) {
780 DPRINTF("dvrioctl2_buzzer -> Status error!\n");
781 return -EADV;
782 }
783 }
784 return 0;
785}
786
787int dvrioctl2_clr_preset_info(
788 iomanX_iop_file_t *a1,
789 int cmd,
790 void *arg,
791 unsigned int arglen,
792 void *buf,
793 unsigned int buflen)
794{
795 drvdrv_exec_cmd_ack cmdack;
796
797 (void)a1;
798 (void)cmd;
799 (void)arg;
800 (void)arglen;
801 (void)buf;
802 (void)buflen;
803
804 cmdack.command = 0x5112;
805 cmdack.input_word_count = 0;
806 cmdack.timeout = 20000000;
807 if (DvrdrvExecCmdAckComp(&cmdack)) {
808 DPRINTF("dvrioctl2_clr_preset_info -> Handshake error!\n");
809 return -EIO;
810 } else {
811 if (cmdack.ack_status_ack) {
812 DPRINTF("dvrioctl2_clr_preset_info -> Status error!\n");
813 return -EADV;
814 }
815 }
816 return 0;
817}
818
819int dvrioctl2_get_vbi_err_rate(
820 iomanX_iop_file_t *a1,
821 int cmd,
822 void *arg,
823 unsigned int arglen,
824 void *buf,
825 unsigned int buflen)
826{
827 drvdrv_exec_cmd_ack cmdack;
828
829 (void)a1;
830 (void)cmd;
831 (void)arg;
832 (void)arglen;
833 (void)buflen;
834
835 cmdack.command = 0x5113;
836 cmdack.input_word_count = 0;
837 if (DvrdrvExecCmdAck(&cmdack)) {
838 DPRINTF("dvrioctl2_get_vbi_err_rate -> Handshake error!\n");
839 return -EIO;
840 } else {
841 if (cmdack.ack_status_ack) {
842 DPRINTF("dvrioctl2_get_vbi_err_rate -> Status error!\n");
843 return -EADV;
844 } else {
845 *(u32 *)buf = (cmdack.output_word[0] << 16) + cmdack.output_word[1];
846 *((u32 *)buf + 1) = (cmdack.output_word[2] << 16) + cmdack.output_word[3];
847 }
848 }
849 return 0;
850}
851
852int dvrioctl2_update_dvrp_firmware(
853 iomanX_iop_file_t *a1,
854 int cmd,
855 void *arg,
856 unsigned int arglen,
857 void *buf,
858 unsigned int buflen)
859{
860 int read_offset;
861 int checksum;
862 int retval;
863 int update_fd;
864 int update_size;
865 int i;
866 drvdrv_exec_cmd_ack cmdack;
867
868 (void)a1;
869 (void)cmd;
870 (void)buf;
871 (void)buflen;
872
873 read_offset = 0;
874 checksum = 0;
875 retval = -EPERM;
876 update_fd = iomanX_open((const char *)arg, 1, 0x49, arglen);
877 if (update_fd < 0) {
878 retval = -ENOENT;
879 goto LABEL_38;
880 }
881 update_size = iomanX_lseek(update_fd, 0, 2);
882 if (iomanX_lseek(update_fd, 0, 0) < 0)
883 goto LABEL_38;
884 cmdack.command = 0x5114;
885 cmdack.input_word[0] = update_size >> 16;
886 cmdack.input_word[1] = update_size;
887 cmdack.input_word_count = 2;
888 cmdack.timeout = 10000000;
889 if (DvrdrvExecCmdAckComp(&cmdack)) {
890 DPRINTF("FLASH_DATA_TOTALSIZE -> Handshake error!\n");
891 LABEL_37:
892 retval = -EIO;
893 goto LABEL_38;
894 }
895 if (cmdack.ack_status_ack) {
896 DPRINTF("FLASH_DATA_TOTALSIZE -> Status error!\n");
897 goto LABEL_37;
898 }
899 if (cmdack.comp_status) {
900 DPRINTF("FLASH_DATA_TOTALSIZE -> Status error!\n");
901 goto LABEL_37;
902 }
903 if (update_size != (cmdack.return_result_word[0] << 16) + cmdack.return_result_word[1])
904 DPRINTF("Size of firmware is not equal to Size of buffer on DVRP memory.\n");
905 for (i = 0x3FFF;; i = 0x3FFF) {
906 char *v13;
907 int read_size;
908 int j;
909 v13 = &SBUF[0x3FFF];
910 do {
911 *v13 = 0;
912 --i;
913 --v13;
914 } while (i >= 0);
915 read_size = iomanX_read(update_fd, SBUF, 0x4000);
916 if (read_size <= 0)
917 break;
918 cmdack.command = 0x5115;
919 cmdack.input_word[0] = read_offset >> 16;
920 cmdack.input_word[1] = read_offset;
921 cmdack.input_word_count = 2;
922 cmdack.input_buffer = SBUF;
923 cmdack.input_buffer_length = read_size;
924 cmdack.timeout = 10000000;
925 if (DvrdrvExecCmdAckDmaSendComp(&cmdack)) {
926 DPRINTF("MISCCMD_FLASH_DATA_DOWNLOAD -> Handshake error!\n");
927 goto LABEL_37;
928 }
929 if (cmdack.ack_status_ack || (read_offset += read_size, cmdack.comp_status)) {
930 DPRINTF("MISCCMD_FLASH_DATA_DOWNLOAD -> Status error!\n");
931 goto LABEL_37;
932 }
933 for (j = 0; j < read_size; ++j) {
934 checksum += (u8)SBUF[j];
935 }
936 }
937 cmdack.command = 0x5116;
938 cmdack.input_word[0] = update_size >> 16;
939 cmdack.input_word[2] = checksum >> 16;
940 cmdack.input_word[1] = update_size;
941 cmdack.input_word[3] = checksum;
942 cmdack.input_word[4] = 0;
943 cmdack.input_word[5] = 0;
944 cmdack.input_word_count = 6;
945 cmdack.timeout = 10000000;
946 if (DvrdrvExecCmdAckComp(&cmdack)) {
947 DPRINTF("MISCCMD_FLASH_DATA_CHECKSUM -> Handshake error!\n");
948 goto LABEL_37;
949 }
950 if (cmdack.ack_status_ack) {
951 DPRINTF("MISCCMD_FLASH_DATA_CHECKSUM -> ACK Status error!\n");
952 } else {
953 if (cmdack.comp_status) {
954 retval = -EADV;
955 DPRINTF("MISCCMD_FLASH_DATA_CHECKSUM -> COMP Status error!\n");
956 DPRINTF(
957 "Check sum error! IOP:%08X,DVRP:%08X\n",
958 checksum,
959 (cmdack.return_result_word[0] << 16) | cmdack.return_result_word[1]);
960 goto LABEL_38;
961 }
962 cmdack.command = 0x5117;
963 cmdack.input_word_count = 0;
964 cmdack.timeout = 10000000;
965 if (DvrdrvExecCmdAckComp(&cmdack)) {
966 DPRINTF("MISCCMD_FLASH_DATA_WRITE -> Handshake error!\n");
967 goto LABEL_37;
968 }
969 if (cmdack.ack_status_ack) {
970 DPRINTF("MISCCMD_FLASH_DATA_WRITE -> ACK Status error!\n");
971 } else {
972 retval = 0;
973 if (!cmdack.comp_status)
974 goto LABEL_38;
975 DPRINTF("MISCCMD_FLASH_DATA_WRITE -> COMP Status error!\n");
976 }
977 }
978 retval = -EADV;
979LABEL_38:
980 iomanX_close(update_fd);
981 return retval;
982}
983
984int dvrioctl2_flash_write_status(
985 iomanX_iop_file_t *a1,
986 int cmd,
987 void *arg,
988 unsigned int arglen,
989 void *buf,
990 unsigned int buflen)
991{
992 drvdrv_exec_cmd_ack cmdack;
993
994 (void)a1;
995 (void)cmd;
996 (void)arg;
997 (void)arglen;
998 (void)buflen;
999
1000 cmdack.command = 0x5118;
1001 cmdack.input_word_count = 0;
1002 if (DvrdrvExecCmdAck(&cmdack)) {
1003 DPRINTF("dvrioctl2_flash_write_status -> Handshake error!\n");
1004 return -EIO;
1005 } else if (cmdack.ack_status_ack) {
1006 DPRINTF("dvrioctl2_flash_write_status -> Status error!\n");
1007 return -EADV;
1008 } else {
1009 *(u16 *)buf = cmdack.output_word[0];
1010 *((u16 *)buf + 1) = cmdack.output_word[1];
1011 }
1012 return 0;
1013}
1014
1015int dvrioctl2_set_device_key(
1016 iomanX_iop_file_t *a1,
1017 int cmd,
1018 void *arg,
1019 unsigned int arglen,
1020 void *buf,
1021 unsigned int buflen)
1022{
1023 int cmdack_err;
1024 int bsize;
1025 int *byteswap_tmp2;
1026 int *byteswap_tmp;
1027 int *byteswap_tmp_end;
1028 int cmdack_err3;
1029 int cmdack_err2;
1030 drvdrv_exec_cmd_ack cmdack;
1031
1032 DPRINTF(
1033 "dvrioctl2_set_device_key (io=%p,cmd=%08X,argp=%p,arglen=%u,bufp=%p,buflen=%u)\n",
1034 a1,
1035 cmd,
1036 arg,
1037 arglen,
1038 buf,
1039 buflen);
1040 cmdack.command = 0x511B;
1041 cmdack.input_word[0] = 0;
1042 cmdack.input_word[1] = 456;
1043 cmdack.input_word_count = 2;
1044 cmdack.timeout = 10000000;
1045 DPRINTF("dvrcmd.cmd_p[0]:%x\n", 0);
1046 DPRINTF("dvrcmd.cmd_p[1]:%x\n", 456);
1047 cmdack_err = DvrdrvExecCmdAckComp(&cmdack);
1048 DPRINTF("dvrcmd.ack_p[0]:%x\n", cmdack.ack_status_ack);
1049 if (cmdack_err) {
1050 DPRINTF("DEVKEY_TOTALSIZE -> Handshake error!\n");
1051 return -EIO;
1052 }
1053 if (cmdack.ack_status_ack || cmdack.comp_status) {
1054 DPRINTF("DEVKEY_TOTALSIZE -> Status error!\n");
1055 return -EIO;
1056 }
1057 bsize = (cmdack.return_result_word[0] << 16) + cmdack.return_result_word[1];
1058 if (bsize != 456)
1059 DPRINTF("Size of firmware is not equal to Size of buffer on DVRP memory.\n");
1060 DPRINTF("FSIZE:%08X\n", 456);
1061 DPRINTF("BSIZE:%08X\n", bsize);
1062 cmdack.command = 0x511C;
1063 ((u32 *)SBUF)[0] = *(u32 *)"XESD";
1064 byteswap_tmp2 = (int *)&SBUF[4];
1065 byteswap_tmp = (int *)arg;
1066 byteswap_tmp_end = (int *)((char *)arg + 448);
1067 do {
1068 byteswap_tmp2[0] = byteswap_tmp[0];
1069 byteswap_tmp2[1] = byteswap_tmp[1];
1070 byteswap_tmp2[2] = byteswap_tmp[2];
1071 byteswap_tmp2[3] = byteswap_tmp[3];
1072 byteswap_tmp += 4;
1073 byteswap_tmp2 += 4;
1074 } while (byteswap_tmp != byteswap_tmp_end);
1075 *byteswap_tmp2 = *byteswap_tmp;
1076 cmdack.input_word_count = 2;
1077 cmdack.input_word[0] = 0;
1078 cmdack.input_word[1] = 0;
1079 cmdack.input_buffer = &SBUF;
1080 cmdack.input_buffer_length = 456;
1081 cmdack.timeout = 10000000;
1082 cmdack_err3 = DvrdrvExecCmdAckDmaSendComp(&cmdack);
1083 DPRINTF("dvrcmd.ack_p[0]:%x\n", cmdack.ack_status_ack);
1084 if (cmdack_err3) {
1085 DPRINTF("MISCCMD_DEVKEY_DOWNLOAD -> Handshake error!\n");
1086 return -EIO;
1087 }
1088 if (cmdack.ack_status_ack) {
1089 DPRINTF("MISCCMD_DEVKEY_DOWNLOAD -> Status error!\n");
1090 return -EIO;
1091 }
1092 if (cmdack.comp_status) {
1093 DPRINTF("MISCCMD_DEVKEY_DOWNLOAD -> Status error!\n");
1094 return -EIO;
1095 }
1096 cmdack.command = 0x5119;
1097 cmdack.input_word_count = 0;
1098 cmdack.timeout = 10000000;
1099 cmdack_err2 = DvrdrvExecCmdAckComp(&cmdack);
1100 DPRINTF("dvrcmd.ack_p[0]:%x\n", cmdack.ack_status_ack);
1101 if (cmdack_err2) {
1102 DPRINTF("MISCCMD_SAVE_DEVKEY_INFO -> Handshake error!\n");
1103 return -EIO;
1104 }
1105 if (cmdack.ack_status_ack) {
1106 DPRINTF("MISCCMD_SAVE_DEVKEY_INFO -> Status error!\n");
1107 return -EADV;
1108 }
1109 if (cmdack.comp_status) {
1110 DPRINTF("MISCCMD_SAVE_DEVKEY_INFO -> Status error!\n");
1111 return -EIO;
1112 }
1113 return 0;
1114}
1115
1116int dvrioctl2_get_device_key(
1117 iomanX_iop_file_t *a1,
1118 int cmd,
1119 void *arg,
1120 unsigned int arglen,
1121 void *buf,
1122 unsigned int buflen)
1123{
1124 int v6;
1125 u16 *return_result_word;
1126 int busywait;
1127 drvdrv_exec_cmd_ack cmdack;
1128 u8 v27[8];
1129
1130 (void)a1;
1131 (void)cmd;
1132 (void)arg;
1133 (void)arglen;
1134 (void)buflen;
1135
1136 cmdack.command = 0x511A;
1137 cmdack.input_word[0] = 0;
1138 cmdack.input_word[1] = 4;
1139 cmdack.input_word_count = 2;
1140 cmdack.timeout = 15000000;
1141 if (DvrdrvExecCmdAckComp(&cmdack)) {
1142 DPRINTF("MISCCMD_GET_DEVKEY_INFO -> Handshake error!\n");
1143 return -EIO;
1144 }
1145 if (cmdack.ack_status_ack) {
1146 DPRINTF("MISCCMD_GET_DEVKEY_INFO -> Status error!\n");
1147 return -EADV;
1148 }
1149 if (cmdack.comp_status) {
1150 DPRINTF("MISCCMD_GET_DEVKEY_INFO -> Status error!\n");
1151 return -EIO;
1152 }
1153 v6 = 0;
1154 return_result_word = cmdack.return_result_word;
1155 do {
1156 u8 *v8;
1157 v8 = &v27[v6];
1158 v6 += 2;
1159 v8[0] = (*return_result_word & 0xFF00) >> 8;
1160 v8[1] = (*return_result_word & 0x00FF);
1161 return_result_word += 1;
1162 } while (v6 < 4);
1163 busywait = 2;
1164 do {
1165 } while (busywait-- >= 0);
1166 if (memcmp(v27, "XESD", 4) == 0) {
1167 int v13;
1168 u16 *in_word_tmp;
1169 u16 v17;
1170 int v18;
1171 int v19;
1172 unsigned int v20;
1173 v13 = 0;
1174 in_word_tmp = &cmdack.return_result_word[2];
1175 do {
1176 u8 *v15;
1177 v15 = (u8 *)buf + v13;
1178 v13 += 2;
1179 v15[0] = (*in_word_tmp & 0xFF00) >> 8;
1180 v15[1] = (*in_word_tmp & 0x00FF);
1181 in_word_tmp += 1;
1182 } while (v13 < 4);
1183 v17 = 4;
1184 v18 = 224;
1185 v19 = 0;
1186 v20 = 224;
1187 while (1) {
1188 int v21;
1189 int v22;
1190 v21 = v18;
1191 if (v20 >= 0x11)
1192 v21 = 16;
1193 cmdack.command = 0x511A;
1194 cmdack.input_word[0] = v17;
1195 cmdack.input_word[1] = v21;
1196 cmdack.input_word_count = 2;
1197 cmdack.timeout = 30000000;
1198 if (DvrdrvExecCmdAckComp(&cmdack)) {
1199 DPRINTF("MISCCMD_GET_DEVKEY_INFO -> Handshake error!\n");
1200 return -EIO;
1201 }
1202 if (cmdack.ack_status_ack) {
1203 DPRINTF("MISCCMD_GET_DEVKEY_INFO -> Status error!\n");
1204 return -EADV;
1205 }
1206 v22 = 1;
1207 if (cmdack.comp_status) {
1208 DPRINTF("MISCCMD_GET_DEVKEY_INFO -> Status error!\n");
1209 return -EIO;
1210 }
1211 if ((u16)v21 + 1 > 1) {
1212 u16 *in_word_tmp2;
1213 in_word_tmp2 = cmdack.return_result_word;
1214 do {
1215 u8 *v24;
1216 v24 = (u8 *)buf + v19;
1217 v19 += 2;
1218 v22 += 1;
1219 v24[4] = (*in_word_tmp2 & 0xFF00) >> 8;
1220 v24[5] = (*in_word_tmp2 & 0x00FF);
1221 in_word_tmp2 += 1;
1222 } while (v22 < (u16)v21 + 1);
1223 }
1224 v18 -= v21;
1225 v20 = (u16)v18;
1226 v17 += v21;
1227 if (!(u16)v18)
1228 return 0;
1229 }
1230 }
1231 return -EADV;
1232}
1233
1234int dvrioctl2_set_dv_nodeid(
1235 iomanX_iop_file_t *a1,
1236 int cmd,
1237 void *arg,
1238 unsigned int arglen,
1239 void *buf,
1240 unsigned int buflen)
1241{
1242 unsigned int argwalked;
1243 drvdrv_exec_cmd_ack cmdack;
1244
1245 (void)a1;
1246 (void)cmd;
1247 (void)buf;
1248 (void)buflen;
1249
1250 argwalked = 0;
1251 cmdack.command = 0x511D;
1252 if (arglen) {
1253 u8 *inword_tmp;
1254 inword_tmp = ((u8 *)&cmdack.input_word[0]);
1255 do {
1256 u8 *inword_tmp2;
1257 inword_tmp2 = ((u8 *)arg + argwalked);
1258 inword_tmp[0] = inword_tmp2[1];
1259 inword_tmp[1] = inword_tmp2[0];
1260 inword_tmp += 2;
1261 argwalked += 2;
1262 } while (argwalked < arglen);
1263 }
1264 cmdack.input_word_count = 4;
1265 cmdack.timeout = 10000000;
1266 if (DvrdrvExecCmdAckComp(&cmdack)) {
1267 DPRINTF("MISCCMD_SAVE_DV_NODEID -> Handshake error!\n");
1268 return -EIO;
1269 }
1270 if (cmdack.ack_status_ack) {
1271 DPRINTF("MISCCMD_SAVE_DV_NODEID -> Status error!\n");
1272 return -EADV;
1273 }
1274 if (cmdack.comp_status) {
1275 DPRINTF("MISCCMD_SAVE_DV_NODEID -> Status error!\n");
1276 return -EIO;
1277 }
1278 return 0;
1279}
1280
1281int dvrioctl2_get_dv_nodeid(
1282 iomanX_iop_file_t *a1,
1283 int cmd,
1284 void *arg,
1285 unsigned int arglen,
1286 void *buf,
1287 unsigned int buflen)
1288{
1289 unsigned int bufwalked;
1290 drvdrv_exec_cmd_ack cmdack;
1291
1292 (void)a1;
1293 (void)cmd;
1294 (void)arg;
1295 (void)arglen;
1296
1297 cmdack.command = 0x511E;
1298 cmdack.input_word_count = 0;
1299 cmdack.timeout = 15000000;
1300 if (DvrdrvExecCmdAckComp(&cmdack)) {
1301 DPRINTF("MISCCMD_GET_DV_NODEID -> Handshake error!\n");
1302 return -EIO;
1303 }
1304 if (cmdack.ack_status_ack) {
1305 DPRINTF("MISCCMD_GET_DV_NODEID -> Status error!\n");
1306 return -EADV;
1307 }
1308 if (cmdack.comp_status) {
1309 DPRINTF("MISCCMD_GET_DV_NODEID -> Status error!\n");
1310 return -EIO;
1311 }
1312 bufwalked = 0;
1313 if (buflen) {
1314 u16 *return_result_word;
1315 int bufbusyloop;
1316
1317 return_result_word = cmdack.return_result_word;
1318 do {
1319 char *buftmp;
1320 buftmp = (char *)buf + bufwalked;
1321 bufwalked += 2;
1322 buftmp[0] = (*return_result_word & 0xFF00) >> 8;
1323 buftmp[1] = (*return_result_word & 0x00FF);
1324 return_result_word += 1;
1325 } while (bufwalked < buflen);
1326
1327 bufbusyloop = 0;
1328 while ((unsigned int)(bufbusyloop++) < buflen)
1329 ;
1330 }
1331 return 0;
1332}
1333#ifdef DEBUG
1334int test_count = 0;
1335#endif
1336int dvrioctl2_diag_test(
1337 iomanX_iop_file_t *a1,
1338 int cmd,
1339 void *arg,
1340 unsigned int arglen,
1341 void *buf,
1342 unsigned int buflen)
1343{
1344 int cmdack_err;
1345#ifdef DEBUG
1346 int testcnt_tmp;
1347#endif
1348 int outbuf_cnt;
1349 u16 *outbuf_tmp;
1350 drvdrv_exec_cmd_ack cmdack;
1351
1352 (void)a1;
1353 (void)cmd;
1354 (void)arglen;
1355 (void)buflen;
1356
1357 cmdack.command = 0x511F;
1358 cmdack.input_word[0] = *(u16 *)arg;
1359 cmdack.input_word[1] = *((u16 *)arg + 1);
1360 cmdack.input_word[2] = *((u16 *)arg + 2);
1361 cmdack.input_word[3] = *((u16 *)arg + 3);
1362 cmdack.input_word[4] = *((u16 *)arg + 4);
1363 cmdack.input_word_count = 5;
1364 cmdack.timeout = 120000000;
1365 if (cmdack.input_word[2]) {
1366 DPRINTF("------------------- > SetTO:%d msec\n", 120000);
1367 cmdack.timeout = 10000000 * cmdack.input_word[2];
1368 }
1369 DPRINTF("arg : %4x", cmdack.input_word[0]);
1370 DPRINTF(" %4x", cmdack.input_word[1]);
1371 DPRINTF(" %4x ", cmdack.input_word[2]);
1372 DPRINTF(" SetTimeOutTo : %d usec\n", cmdack.timeout);
1373 cmdack_err = DvrdrvExecCmdAckComp(&cmdack);
1374#ifdef DEBUG
1375 testcnt_tmp = test_count++;
1376#endif
1377 DPRINTF(
1378 "cmd ID : %d -------------------- TEST VERSION - diag test -------------------- r %d -- c %d\n",
1379 31,
1380 cmdack_err,
1381 testcnt_tmp);
1382 DPRINTF("diag_test dvrcmd.ack_p[0]:%x\n", cmdack.ack_status_ack);
1383 DPRINTF("diag_test dvrcmd.phase:%x\n", cmdack.phase);
1384 if (cmdack_err) {
1385 DPRINTF("dvrioctl2_diag_test -> Handshake error!\n");
1386 return -EIO;
1387 }
1388 if (cmdack.ack_status_ack) {
1389 DPRINTF("dvrioctl2_diag_test -> Status error in ACK! param:%04x\n", cmdack.ack_status_ack);
1390 return -EADV;
1391 }
1392 if (cmdack.comp_status) {
1393 DPRINTF("dvrioctl2_diag_test -> Status error in COMP! param:%04x\n", cmdack.comp_status);
1394 return -EADV;
1395 }
1396 outbuf_cnt = 0;
1397 DPRINTF("---------------------------- return buffer\n");
1398 outbuf_tmp = (u16 *)&cmdack.return_result_word[0];
1399 do {
1400 outbuf_cnt += 1;
1401 DPRINTF(" %4x", *outbuf_tmp);
1402 *(u16 *)buf = *outbuf_tmp;
1403 outbuf_tmp += 1;
1404 buf = (char *)buf + 2;
1405 } while (outbuf_cnt < 16);
1406 DPRINTF("\n");
1407 return 0;
1408}
ENOENT
#define ENOENT
Definition errno.h:23
EINVAL
#define EINVAL
Definition errno.h:63
EUNSUP
#define EUNSUP
Definition errno.h:117
EIO
#define EIO
Definition errno.h:29
EADV
#define EADV
Definition errno.h:151
EPERM
#define EPERM
Definition errno.h:21
IOP_DT_FSEXT
#define IOP_DT_FSEXT
Definition iomanX.h:66
_iomanX_iop_device
Definition iomanX.h:81
_iomanX_iop_device_ops
Definition iomanX.h:95
_iomanX_iop_file
Definition iomanX.h:70
_ModuleInfo::newflags
u16 newflags
Definition loadcore.h:36
_ModuleInfo
Definition loadcore.h:31
DevctlCmdTbl_t
Definition xesdrv.c:199
iop_sema_t
Definition thsemap.h:39