← Back to branch summary

~ubuntu-branches/ubuntu/utopic/vice/utopic

« back to all changes in this revision

Viewing changes to src/c64dtv/c64dtv.c

  • Committer: Package Import Robot
  • Author(s): Logan Rosen
  • Date: 2014-05-10 21:08:23 UTC
  • mfrom: (17.2.1 utopic-proposed)
  • Revision ID: package-import@ubuntu.com-20140510210823-r7x98jmpl1x7rgop
Tags: 2.4.dfsg+2.4.6-1ubuntu1
Use autotools-dev to update config.{sub,guess} for new arches.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/c64dtv/c64dtv.c
82
82
#include "tape.h"
83
83
#include "traps.h"
84
84
#include "types.h"
 
85
#include "userport_joystick.h"
85
86
#include "vicii.h"
86
87
#include "video.h"
87
88
#include "video-sound.h"
228
229
        || kbd_resources_init() < 0
229
230
#endif
230
231
        || drive_resources_init() < 0
231
 
        )
 
232
        || userport_joystick_resources_init() < 0
 
233
        ) {
232
234
        return -1;
 
235
    }
233
236
 
234
237
    return 0;
235
238
}
271
274
        || kbd_cmdline_options_init() < 0
272
275
#endif
273
276
        || drive_cmdline_options_init() < 0
274
 
        )
 
277
        || userport_joystick_cmdline_options_init() < 0
 
278
        ) {
275
279
        return -1;
 
280
    }
276
281
 
277
282
    return 0;
278
283
}
284
289
    monitor_interface_t *drive_interface_init[DRIVE_NUM];
285
290
    monitor_cpu_type_t *asmarray[4];
286
291
 
287
 
    asmarray[0]=&asm6502dtv;
288
 
    asmarray[1]=&asm6502;
289
 
    asmarray[2]=&asmR65C02;
290
 
    asmarray[3]=NULL;
 
292
    asmarray[0] = &asm6502dtv;
 
293
    asmarray[1] = &asm6502;
 
294
    asmarray[2] = &asmR65C02;
 
295
    asmarray[3] = NULL;
291
296
 
292
297
    asm6502dtv_init(&asm6502dtv);
293
298
    asm6502_init(&asm6502);
294
299
    asmR65C02_init(&asmR65C02);
295
300
 
296
 
    for (dnr = 0; dnr < DRIVE_NUM; dnr++)
 
301
    for (dnr = 0; dnr < DRIVE_NUM; dnr++) {
297
302
        drive_interface_init[dnr] = drivecpu_monitor_interface_get(dnr);
 
303
    }
298
304
 
299
305
    /* Initialize the monitor.  */
300
306
    monitor_init(maincpu_monitor_interface_get(), drive_interface_init,
315
321
 
316
322
    c64_log = log_open("C64");
317
323
 
318
 
    if (mem_load() < 0)
 
324
    if (mem_load() < 0) {
319
325
        return -1;
 
326
    }
320
327
 
321
328
    /* Setup trap handling.  */
322
329
    traps_init();
323
330
 
324
331
    /* Initialize serial traps.  */
325
 
    if (serial_init(c64_serial_traps) < 0)
 
332
    if (serial_init(c64_serial_traps) < 0) {
326
333
        return -1;
 
334
    }
327
335
 
328
336
    serial_trap_init(0xa4);
329
337
    serial_iec_bus_init();
330
338
 
331
339
    /* Initialize flash traps.  */
332
 
    if (flash_trap_init(c64dtv_flash_traps) < 0)
 
340
    if (flash_trap_init(c64dtv_flash_traps) < 0) {
333
341
        return -1;
 
342
    }
334
343
 
335
344
    /* Initialize RS232 handler.  */
336
345
    rs232drv_init();
347
356
    if (delay == 0) {
348
357
        delay = 3; /* default */
349
358
    }
350
 
    autostart_init((CLOCK)(delay * C64_PAL_RFSH_PER_SEC
351
 
                     * C64_PAL_CYCLES_PER_RFSH),
352
 
                     1, 0xcc, 0xd1, 0xd3, 0xd5);
 
359
    autostart_init((CLOCK)(delay * C64_PAL_RFSH_PER_SEC * C64_PAL_CYCLES_PER_RFSH),
 
360
                   1, 0xcc, 0xd1, 0xd3, 0xd5);
353
361
 
354
 
    if (vicii_init(VICII_DTV) == NULL && !console_mode)
 
362
    if (vicii_init(VICII_DTV) == NULL && !console_mode) {
355
363
        return -1;
 
364
    }
356
365
 
357
366
    cia1_init(machine_context.cia1);
358
367
    cia2_init(machine_context.cia2);
359
368
 
360
369
#ifndef COMMON_KBD
361
370
    /* Initialize the keyboard.  */
362
 
    if (c64_kbd_init() < 0)
 
371
    if (c64_kbd_init() < 0) {
363
372
        return -1;
 
373
    }
364
374
#endif
365
375
 
366
376
    c64keyboard_init();
383
393
    sound_init(machine_timing.cycles_per_sec, machine_timing.cycles_per_rfsh);
384
394
 
385
395
    /* Initialize keyboard buffer.  */
386
 
    kbdbuf_init(631, 198, 10, (CLOCK)(machine_timing.rfsh_per_sec
387
 
                * machine_timing.cycles_per_rfsh));
 
396
    kbdbuf_init(631, 198, 10, (CLOCK)(machine_timing.rfsh_per_sec * machine_timing.cycles_per_rfsh));
388
397
 
389
398
    /* Initialize the C64-specific part of the UI.  */
390
399
    if (!console_mode) {
516
525
 
517
526
void machine_get_line_cycle(unsigned int *line, unsigned int *cycle, int *half_cycle)
518
527
{
519
 
    *line = (unsigned int)((maincpu_clk) / machine_timing.cycles_per_line
520
 
            % machine_timing.screen_lines);
 
528
    *line = (unsigned int)((maincpu_clk) / machine_timing.cycles_per_line % machine_timing.screen_lines);
521
529
 
522
530
    *cycle = (unsigned int)((maincpu_clk) % machine_timing.cycles_per_line);
523
531
 
526
534
 
527
535
void machine_change_timing(int timeval)
528
536
{
529
 
   int border_mode;
530
 
 
531
 
    switch (timeval) {
532
 
      default:
533
 
      case MACHINE_SYNC_PAL ^ VICII_BORDER_MODE(VICII_NORMAL_BORDERS):
534
 
      case MACHINE_SYNC_NTSC ^ VICII_BORDER_MODE(VICII_NORMAL_BORDERS):
535
 
        timeval ^= VICII_BORDER_MODE(VICII_NORMAL_BORDERS);
536
 
        border_mode = VICII_NORMAL_BORDERS;
537
 
        break;
538
 
      case MACHINE_SYNC_PAL ^ VICII_BORDER_MODE(VICII_FULL_BORDERS):
539
 
      case MACHINE_SYNC_NTSC ^ VICII_BORDER_MODE(VICII_FULL_BORDERS):
540
 
        timeval ^= VICII_BORDER_MODE(VICII_FULL_BORDERS);
541
 
        border_mode = VICII_FULL_BORDERS;
542
 
        break;
543
 
      case MACHINE_SYNC_PAL ^ VICII_BORDER_MODE(VICII_DEBUG_BORDERS):
544
 
      case MACHINE_SYNC_NTSC ^ VICII_BORDER_MODE(VICII_DEBUG_BORDERS):
545
 
        timeval ^= VICII_BORDER_MODE(VICII_DEBUG_BORDERS);
546
 
        border_mode = VICII_DEBUG_BORDERS;
547
 
        break;
548
 
      case MACHINE_SYNC_PAL ^ VICII_BORDER_MODE(VICII_NO_BORDERS):
549
 
      case MACHINE_SYNC_NTSC ^ VICII_BORDER_MODE(VICII_NO_BORDERS):
550
 
        timeval ^= VICII_BORDER_MODE(VICII_NO_BORDERS);
551
 
        border_mode = VICII_NO_BORDERS;
552
 
        break;
553
 
   }
554
 
 
555
 
    switch (timeval) {
556
 
      case MACHINE_SYNC_PAL:
557
 
        machine_timing.cycles_per_sec = C64_PAL_CYCLES_PER_SEC;
558
 
        machine_timing.cycles_per_rfsh = C64_PAL_CYCLES_PER_RFSH;
559
 
        machine_timing.rfsh_per_sec = C64_PAL_RFSH_PER_SEC;
560
 
        machine_timing.cycles_per_line = C64_PAL_CYCLES_PER_LINE;
561
 
        machine_timing.screen_lines = C64_PAL_SCREEN_LINES;
562
 
        break;
563
 
      case MACHINE_SYNC_NTSC:
564
 
        machine_timing.cycles_per_sec = C64_NTSC_CYCLES_PER_SEC;
565
 
        machine_timing.cycles_per_rfsh = C64_NTSC_CYCLES_PER_RFSH;
566
 
        machine_timing.rfsh_per_sec = C64_NTSC_RFSH_PER_SEC;
567
 
        machine_timing.cycles_per_line = C64_NTSC_CYCLES_PER_LINE;
568
 
        machine_timing.screen_lines = C64_NTSC_SCREEN_LINES;
569
 
        break;
570
 
      default:
571
 
        log_error(c64_log, "Unknown machine timing.");
 
537
    int border_mode;
 
538
 
 
539
    switch (timeval) {
 
540
        default:
 
541
        case MACHINE_SYNC_PAL ^ VICII_BORDER_MODE(VICII_NORMAL_BORDERS):
 
542
        case MACHINE_SYNC_NTSC ^ VICII_BORDER_MODE(VICII_NORMAL_BORDERS):
 
543
            timeval ^= VICII_BORDER_MODE(VICII_NORMAL_BORDERS);
 
544
            border_mode = VICII_NORMAL_BORDERS;
 
545
            break;
 
546
        case MACHINE_SYNC_PAL ^ VICII_BORDER_MODE(VICII_FULL_BORDERS):
 
547
        case MACHINE_SYNC_NTSC ^ VICII_BORDER_MODE(VICII_FULL_BORDERS):
 
548
            timeval ^= VICII_BORDER_MODE(VICII_FULL_BORDERS);
 
549
            border_mode = VICII_FULL_BORDERS;
 
550
            break;
 
551
        case MACHINE_SYNC_PAL ^ VICII_BORDER_MODE(VICII_DEBUG_BORDERS):
 
552
        case MACHINE_SYNC_NTSC ^ VICII_BORDER_MODE(VICII_DEBUG_BORDERS):
 
553
            timeval ^= VICII_BORDER_MODE(VICII_DEBUG_BORDERS);
 
554
            border_mode = VICII_DEBUG_BORDERS;
 
555
            break;
 
556
        case MACHINE_SYNC_PAL ^ VICII_BORDER_MODE(VICII_NO_BORDERS):
 
557
        case MACHINE_SYNC_NTSC ^ VICII_BORDER_MODE(VICII_NO_BORDERS):
 
558
            timeval ^= VICII_BORDER_MODE(VICII_NO_BORDERS);
 
559
            border_mode = VICII_NO_BORDERS;
 
560
            break;
 
561
    }
 
562
 
 
563
    switch (timeval) {
 
564
        case MACHINE_SYNC_PAL:
 
565
            machine_timing.cycles_per_sec = C64_PAL_CYCLES_PER_SEC;
 
566
            machine_timing.cycles_per_rfsh = C64_PAL_CYCLES_PER_RFSH;
 
567
            machine_timing.rfsh_per_sec = C64_PAL_RFSH_PER_SEC;
 
568
            machine_timing.cycles_per_line = C64_PAL_CYCLES_PER_LINE;
 
569
            machine_timing.screen_lines = C64_PAL_SCREEN_LINES;
 
570
            break;
 
571
        case MACHINE_SYNC_NTSC:
 
572
            machine_timing.cycles_per_sec = C64_NTSC_CYCLES_PER_SEC;
 
573
            machine_timing.cycles_per_rfsh = C64_NTSC_CYCLES_PER_RFSH;
 
574
            machine_timing.rfsh_per_sec = C64_NTSC_RFSH_PER_SEC;
 
575
            machine_timing.cycles_per_line = C64_NTSC_CYCLES_PER_LINE;
 
576
            machine_timing.screen_lines = C64_NTSC_SCREEN_LINES;
 
577
            break;
 
578
        default:
 
579
            log_error(c64_log, "Unknown machine timing.");
572
580
    }
573
581
 
574
582
    vsync_set_machine_parameter(machine_timing.rfsh_per_sec,
604
612
 
605
613
int machine_screenshot(screenshot_t *screenshot, struct video_canvas_s *canvas)
606
614
{
607
 
    if (canvas != vicii_get_canvas())
 
615
    if (canvas != vicii_get_canvas()) {
608
616
        return -1;
 
617
    }
609
618
 
610
619
    vicii_screenshot(screenshot);
611
620
    return 0;
614
623
int machine_canvas_async_refresh(struct canvas_refresh_s *refresh,
615
624
                                 struct video_canvas_s *canvas)
616
625
{
617
 
    if (canvas != vicii_get_canvas())
 
626
    if (canvas != vicii_get_canvas()) {
618
627
        return -1;
 
628
    }
619
629
 
620
630
    vicii_async_refresh(refresh);
621
631
    return 0;
666
676
{
667
677
    return machine_name;
668
678
}
669
 
 
670
 
#ifdef USE_SDLUI
671
 
/* Kludges for vsid & linking issues */
672
 
const char **csidmodel = NULL;
673
 
void psid_init_driver(void) {}
674
 
void machine_play_psid(int tune) {}
675
 
#endif