Shamusworld >> Repos - virtualjaguar/blob - src/cdbios.cpp

   1 //////////////////////////////////////////////////////////////////////////////
   2 //
   3 //////////////////////////////////////////////////////////////////////////////
   4 //
   5 // 20.02.2002: fixed sector to msf conversion
   6 // 19.02.2002: fixed a bug in toc encoding function
   7 //
   8 //
   9 //
  10 //////////////////////////////////////////////////////////////////////////////
  11 #include "include/cdbios.h"
  12
  13 /* Added by SDLEMU (http://sdlemu.ngemu.com */
  14 /* Some GCC UNIX includes                   */
  15 #ifdef __GCCUNIX__
  16         #include <unistd.h>
  17 #endif
  18
  19 #define ERR_FLAG        0x3e00
  20 #define CD_TOC          0x2c00
  21 #define BIOS_VER    0x3004
  22
  23
  24 #define CDBIOS_INIT             0
  25 #define CDBIOS_INITM    1
  26 #define CDBIOS_INITF    2
  27
  28
  29
  30 #define CD_INIT         0x3000
  31 #define CD_MODE         0x3006
  32 #define CD_ACK          0x300C
  33 #define CD_JERI         0x3012
  34 #define CD_SPIN         0x3018
  35 #define CD_STOP         0x301E
  36 #define CD_MUTE         0x3024
  37 #define CD_UMUTE        0x302A
  38 #define CD_PAUSE        0x3030
  39 #define CD_UPAUSE       0x3036
  40 #define CD_READ         0x303C
  41 #define CD_UREAD        0x3042
  42 #define CD_SETUP        0x3048
  43 #define CD_PTR          0x304E
  44 #define CD_OSAMP        0x3054
  45 #define CD_GETTOC       0x306A
  46 #define CD_INITM        0x3060
  47 #define CD_INITF        0x3066
  48
  49
  50 char *cdbios_command[]={"init","mode","ack","jeri","spin","stop","mute","umute","pause","upause",
  51                                                 "read","uread","setup","ptr","osamp","getoc","initm","initf",
  52                                                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  53
  54 #define CDROM_AUDIO_MODE        0
  55 #define CDROM_DATA_MODE         1
  56
  57 #define CDROM_SINGLE_SPEED      0
  58 #define CDROM_DOUBLE_SPEED  1
  59
  60 #define CDROM_STATUS_OK         0
  61 #define CDROM_STATUS_ERROR      1
  62
  63
  64 uint32 cdrom_mode                               = CDROM_DATA_MODE;
  65 uint32 cdrom_speed                              = CDROM_SINGLE_SPEED;
  66 uint32 cdrom_oversample_factor  = 1;
  67 uint32 cdbios_session=0;
  68
  69 uint32 cdrom_destination_buffer_beginning;
  70 uint32 cdrom_destination_buffer_end;
  71 uint32 cdrom_time_code;
  72 uint32 cdrom_seek_only;
  73 uint32 cdrom_partition_marker;
  74 uint32 cdrom_circular_buffer_size;
  75
  76 uint32 cdbios_init_type;
  77 uint32 *cdbios_sector_lut;
  78 uint32 cdbios_init_done=0;
  79
  80 //////////////////////////////////////////////////////////////////////////////
  81 //
  82 //////////////////////////////////////////////////////////////////////////////
  83 //
  84 //
  85 //
  86 //
  87 //
  88 //
  89 //////////////////////////////////////////////////////////////////////////////
  90 void cdbios_build_sector_lut(void)
  91 {
  92         uint32 last_sector=0;
  93         int32 offset=0;
  94         uint32 sector=0;
  95
  96         s_cdi_track *last_track=&cdi_descriptor->sessions[cdi_descriptor->nb_of_sessions-1].tracks[cdi_descriptor->sessions[cdi_descriptor->nb_of_sessions-1].nb_of_tracks-1];
  97
  98         last_sector=last_track->start_lba+last_track->total_length-1;
  99
 100
 101         cdbios_sector_lut=(uint32*)malloc((last_sector+1)*sizeof(uint32));
 102         memset(cdbios_sector_lut,0xff,(last_sector+1)*sizeof(uint32));
 103
 104         for (int session=0;session<cdi_descriptor->nb_of_sessions;session++)
 105         {
 106                 for (int track=0;track<cdi_descriptor->sessions[session].nb_of_tracks;track++)
 107                 {
 108                         s_cdi_track *current_track=&cdi_descriptor->sessions[session].tracks[track];
 109
 110                         if (offset<((int32)(current_track->start_lba-1)))
 111                         {
 112                                 fprintf(log_get(),"cdbios: postgap between %i and %i\n",offset,current_track->start_lba-1);
 113
 114                                 // fill-in postgap
 115                                 for (;offset<current_track->start_lba;offset++)
 116                                 {
 117                                         cdbios_sector_lut[offset]=0xffffffff;
 118                                 }
 119
 120                         }
 121                         fprintf(log_get(),"cdbios: data between %i and %i\n",offset,current_track->start_lba+current_track->total_length-1);
 122                         for (;offset<current_track->start_lba+current_track->total_length;offset++)
 123                         {
 124                                 cdbios_sector_lut[offset]=sector;
 125                                 sector++;
 126                         }
 127
 128                 }
 129         }
 130
 131 }
 132 //////////////////////////////////////////////////////////////////////////////
 133 //
 134 //////////////////////////////////////////////////////////////////////////////
 135 //
 136 //
 137 //
 138 //
 139 //
 140 //
 141 //////////////////////////////////////////////////////////////////////////////
 142 void cdbios_get_time(uint32 sectors, uint32 *mm, uint32 *ss, uint32 *ff)
 143 {
 144         uint32 _sectors=sectors;
 145
 146         uint32 _mm=(sectors/(60*75));
 147         sectors-=(_mm*(60*75));
 148         uint32 _ss=(sectors/75);
 149         sectors-=(_ss*75);
 150         uint32 _ff=sectors;
 151
 152         *mm=_mm;
 153         *ss=_ss;
 154         *ff=_ff;
 155
 156
 157 //      fprintf(log_get(),"[%.2i:%.2i:%.2i]\n",_mm,_ss,_ff);
 158 }
 159 //////////////////////////////////////////////////////////////////////////////
 160 //
 161 //////////////////////////////////////////////////////////////////////////////
 162 //
 163 //
 164 //
 165 //
 166 //
 167 //
 168 //////////////////////////////////////////////////////////////////////////////
 169 void cdbios_encode_toc(void)
 170 {
 171         int i;
 172         uint32 base=CD_TOC;
 173
 174         jaguar_byte_write(base++,0x00);
 175         jaguar_byte_write(base++,0x00);
 176         jaguar_byte_write(base++,0x01);
 177
 178         int nbtracks=0;
 179         for (i=0;i<cdi_descriptor->nb_of_sessions;i++)
 180                 nbtracks+=cdi_descriptor->sessions[i].nb_of_tracks;
 181
 182         jaguar_byte_write(base++,nbtracks+1);
 183         jaguar_byte_write(base++,cdi_descriptor->nb_of_sessions);
 184
 185         uint32 mm=0;
 186         uint32 ss=0;
 187         uint32 ff=0;
 188
 189         cdbios_get_time(cdi_descriptor->sessions[cdi_descriptor->nb_of_sessions-1].tracks[cdi_descriptor->sessions[cdi_descriptor->nb_of_sessions-1].nb_of_tracks-1].start_lba+
 190                                         cdi_descriptor->sessions[cdi_descriptor->nb_of_sessions-1].tracks[cdi_descriptor->sessions[cdi_descriptor->nb_of_sessions-1].nb_of_tracks-1].length+
 191                                         cdi_descriptor->sessions[cdi_descriptor->nb_of_sessions-1].tracks[cdi_descriptor->sessions[cdi_descriptor->nb_of_sessions-1].nb_of_tracks-1].pregap_length,
 192                                         &mm,&ss,&ff);
 193
 194         jaguar_byte_write(base++,mm);
 195         jaguar_byte_write(base++,ss);
 196         jaguar_byte_write(base++,ff);
 197
 198         int track_count=1;
 199         for (i=0;i<cdi_descriptor->nb_of_sessions;i++)
 200                 for (int j=0;j<cdi_descriptor->sessions[i].nb_of_tracks;j++)
 201                 {
 202                         s_cdi_track *track=&cdi_descriptor->sessions[i].tracks[j];
 203
 204 //                      fprintf(log_get(),"track %i\n",track_count);
 205
 206                         jaguar_byte_write(base++,track_count);
 207                         cdbios_get_time(track->start_lba+track->pregap_length,&mm,&ss,&ff);
 208                         jaguar_byte_write(base++,mm);
 209                         jaguar_byte_write(base++,ss);
 210                         jaguar_byte_write(base++,ff);
 211                         jaguar_byte_write(base++,i);
 212                         cdbios_get_time(track->length,&mm,&ss,&ff);
 213                         jaguar_byte_write(base++,mm);
 214                         jaguar_byte_write(base++,ss);
 215                         jaguar_byte_write(base++,ff);
 216
 217                         track_count++;
 218                 }
 219
 220         cdi_tracks_count=track_count;
 221         cdi_tracks=(s_cdi_track**)malloc(track_count*sizeof(s_cdi_track*));
 222         track_count=0;
 223         for (i=0;i<cdi_descriptor->nb_of_sessions;i++)
 224         {
 225                 for (int j=0;j<cdi_descriptor->sessions[i].nb_of_tracks;j++)
 226                 {
 227                         cdi_tracks[track_count]=&cdi_descriptor->sessions[i].tracks[j];
 228                         track_count++;
 229                 }
 230         }
 231 }
 232 //////////////////////////////////////////////////////////////////////////////
 233 //
 234 //////////////////////////////////////////////////////////////////////////////
 235 //
 236 //
 237 //
 238 //
 239 //
 240 //
 241 //////////////////////////////////////////////////////////////////////////////
 242 void cdbios_decode_toc(void)
 243 {
 244         uint32 addr=0x2c00;
 245         uint32 nb_tracks;
 246
 247         fprintf(log_get(),"cdbios: toc:\n");
 248         fprintf(log_get(),"cdbios:\n");
 249         addr+=2;
 250         fprintf(log_get(),"cdbios: minimum track number: %i\n",jaguar_byte_read(addr++));
 251         fprintf(log_get(),"cdbios: maximum track number: %i\n",nb_tracks=jaguar_byte_read(addr++));
 252         fprintf(log_get(),"cdbios: number of sessions  : %i\n",jaguar_byte_read(addr++));
 253         fprintf(log_get(),"cdbios: start of last lead out time: %.2i:%.2i:%.2i\n",
 254                                           jaguar_byte_read(addr++),jaguar_byte_read(addr++),jaguar_byte_read(addr++));
 255
 256         uint32 mm,ss,ff;
 257
 258         nb_tracks--;
 259
 260         while (nb_tracks)
 261         {
 262                 fprintf(log_get(),"cdbios:\n");
 263                 fprintf(log_get(),"cdbios: track          : %i\n",jaguar_byte_read(addr++));
 264
 265                 mm=jaguar_byte_read(addr++);
 266                 ss=jaguar_byte_read(addr++);
 267                 ff=jaguar_byte_read(addr++);
 268
 269                 fprintf(log_get(),"cdbios: start at       : %.2i:%.2i:%.2i\n",mm,ss,ff);
 270                 fprintf(log_get(),"cdbios: session        : %i\n",jaguar_byte_read(addr++));
 271
 272                 mm=jaguar_byte_read(addr++);
 273                 ss=jaguar_byte_read(addr++);
 274                 ff=jaguar_byte_read(addr++);
 275
 276                 fprintf(log_get(),"cdbios: duration       : %.2i:%.2i:%.2i\n",mm,ss,ff);
 277                 nb_tracks--;
 278         }
 279 }
 280 //////////////////////////////////////////////////////////////////////////////
 281 //
 282 //////////////////////////////////////////////////////////////////////////////
 283 //
 284 //
 285 //
 286 //
 287 //
 288 //
 289 //////////////////////////////////////////////////////////////////////////////
 290 void cd_bios_boot(char *filename)
 291 {
 292         cd_bios_init();
 293
 294
 295         cdi_fp=cdi_open(filename);
 296         cdi_descriptor=cdi_get_descriptor(cdi_fp,log_get());
 297         if (cdi_descriptor==0)
 298         {
 299                 fprintf(log_get(),"cdi: bad image\n");
 300                 cdi_close(cdi_fp);
 301                 return;
 302         }
 303         cdi_dump_descriptor(log_get(),cdi_descriptor);
 304         cdbios_build_sector_lut();
 305
 306         uint8 *code=cdi_extract_boot_code(cdi_fp,cdi_descriptor);
 307
 308         // copy the code to ram
 309         for (uint32 i=0;i<cdi_code_length;i++)
 310                 jaguar_byte_write(cdi_load_address+i,code[i]);
 311
 312         // set the boot address
 313         jaguar_long_write(0x00000004,cdi_load_address);
 314
 315         // write the toc
 316         cdbios_encode_toc();
 317
 318         // dump the toc
 319         cdbios_decode_toc();
 320
 321 //      fprintf(log_get(),"cdbios: boot code:\n");
 322 //      jaguar_dasm(cdi_load_address, cdi_code_length);
 323 }
 324 //////////////////////////////////////////////////////////////////////////////
 325 //
 326 //////////////////////////////////////////////////////////////////////////////
 327 //
 328 //
 329 //
 330 //
 331 //
 332 //
 333 //////////////////////////////////////////////////////////////////////////////
 334 void cd_bios_init(void)
 335 {
 336         fprintf(log_get(),"cd_bios: initializing\n");
 337         for (int i=0;i<19;i++)
 338         {
 339                 // RESET opcode
 340                 jaguar_word_write(0x3000+(i*6),0x4E70);
 341         }
 342         cd_bios_reset();
 343         cdbios_init_done=1;
 344 }
 345 //////////////////////////////////////////////////////////////////////////////
 346 //
 347 //////////////////////////////////////////////////////////////////////////////
 348 //
 349 //
 350 //
 351 //
 352 //
 353 //
 354 //////////////////////////////////////////////////////////////////////////////
 355 void cd_bios_reset(void)
 356 {
 357         fprintf(log_get(), "cd_bios: reset\n");
 358         jaguar_word_write(BIOS_VER, 0x0405);
 359         cdrom_mode                              = CDROM_DATA_MODE;
 360         cdrom_speed                             = CDROM_SINGLE_SPEED;
 361         cdrom_oversample_factor = 1;
 362         cdbios_session                  = 0;
 363 }
 364 //////////////////////////////////////////////////////////////////////////////
 365 //
 366 //////////////////////////////////////////////////////////////////////////////
 367 //
 368 //
 369 //
 370 //
 371 //
 372 //
 373 //////////////////////////////////////////////////////////////////////////////
 374 void cd_bios_done(void)
 375 {
 376         fprintf(log_get(),"cd_bios: done\n");
 377         close(cdi_fp);
 378 }
 379 //////////////////////////////////////////////////////////////////////////////
 380 //
 381 //////////////////////////////////////////////////////////////////////////////
 382 //
 383 //
 384 //
 385 //
 386 //
 387 //
 388 //////////////////////////////////////////////////////////////////////////////
 389 void cdbios_cmd_init(void)
 390 {
 391         cdbios_init_type = CDBIOS_INIT;
 392     jaguar_word_write(ERR_FLAG, CDROM_STATUS_OK);
 393         fprintf(log_get(), "cdbios: init(0x%.8x)\n", m68k_get_reg(NULL, M68K_REG_A0));
 394 }
 395 //////////////////////////////////////////////////////////////////////////////
 396 //
 397 //////////////////////////////////////////////////////////////////////////////
 398 //
 399 //
 400 //
 401 //
 402 //
 403 //
 404 //////////////////////////////////////////////////////////////////////////////
 405 void cdbios_cmd_mode(void)
 406 {
 407 //      uint32 data = s68000context.dreg[0];
 408         uint32 data = m68k_get_reg(NULL, M68K_REG_D0);
 409
 410         uint32 cdrom_mode = (data>>1) & 0x01;
 411         uint32 cdrom_speed = data & 0x01;
 412         jaguar_word_write(ERR_FLAG, CDROM_STATUS_OK);
 413
 414 //      fprintf(log_get(),"cdbios: %s\n",(cdrom_mode==CDROM_AUDIO_MODE)?"audio mode":"data mode");
 415 //      fprintf(log_get(),"cdbios: %s\n",(cdrom_speed==CDROM_DOUBLE_SPEED)?"double speed":"single speed");
 416 }
 417 //////////////////////////////////////////////////////////////////////////////
 418 //
 419 //////////////////////////////////////////////////////////////////////////////
 420 //
 421 //
 422 //
 423 //
 424 //
 425 //
 426 //////////////////////////////////////////////////////////////////////////////
 427 void cdbios_cmd_ack(void)
 428 {
 429     jaguar_word_write(ERR_FLAG,CDROM_STATUS_OK);
 430 }
 431 //////////////////////////////////////////////////////////////////////////////
 432 //
 433 //////////////////////////////////////////////////////////////////////////////
 434 //
 435 //
 436 //
 437 //
 438 //
 439 //
 440 //////////////////////////////////////////////////////////////////////////////
 441 void cdbios_cmd_jeri(void)
 442 {
 443     jaguar_word_write(ERR_FLAG,CDROM_STATUS_OK);
 444 }
 445 //////////////////////////////////////////////////////////////////////////////
 446 //
 447 //////////////////////////////////////////////////////////////////////////////
 448 //
 449 //
 450 //
 451 //
 452 //
 453 //
 454 //////////////////////////////////////////////////////////////////////////////
 455 void cdbios_cmd_spin(void)
 456 {
 457 //      uint16 spin=(1<<(s68000context.dreg[0]&0xffff));
 458         uint16 spin = (1 << (m68k_get_reg(NULL, M68K_REG_D0) & 0xFFFF));
 459         cdbios_session = spin;
 460     jaguar_word_write(ERR_FLAG, CDROM_STATUS_OK);
 461 //      fprintf(log_get(),"cdbios: switching to session %i\n",spin);
 462 }
 463 //////////////////////////////////////////////////////////////////////////////
 464 //
 465 //////////////////////////////////////////////////////////////////////////////
 466 //
 467 //
 468 //
 469 //
 470 //
 471 //
 472 //////////////////////////////////////////////////////////////////////////////
 473 void cdbios_cmd_stop(void)
 474 {
 475     jaguar_word_write(ERR_FLAG,CDROM_STATUS_OK);
 476 }
 477 //////////////////////////////////////////////////////////////////////////////
 478 //
 479 //////////////////////////////////////////////////////////////////////////////
 480 //
 481 //
 482 //
 483 //
 484 //
 485 //
 486 //////////////////////////////////////////////////////////////////////////////
 487 void cdbios_cmd_mute(void)
 488 {
 489     jaguar_word_write(ERR_FLAG,CDROM_STATUS_OK);
 490 }
 491 //////////////////////////////////////////////////////////////////////////////
 492 //
 493 //////////////////////////////////////////////////////////////////////////////
 494 //
 495 //
 496 //
 497 //
 498 //
 499 //
 500 //////////////////////////////////////////////////////////////////////////////
 501 void cdbios_cmd_umute(void)
 502 {
 503     jaguar_word_write(ERR_FLAG,CDROM_STATUS_OK);
 504 }
 505 //////////////////////////////////////////////////////////////////////////////
 506 //
 507 //////////////////////////////////////////////////////////////////////////////
 508 //
 509 //
 510 //
 511 //
 512 //
 513 //
 514 //////////////////////////////////////////////////////////////////////////////
 515 void cdbios_cmd_pause(void)
 516 {
 517     jaguar_word_write(ERR_FLAG,CDROM_STATUS_OK);
 518 }
 519 //////////////////////////////////////////////////////////////////////////////
 520 //
 521 //////////////////////////////////////////////////////////////////////////////
 522 //
 523 //
 524 //
 525 //
 526 //
 527 //
 528 //////////////////////////////////////////////////////////////////////////////
 529 void cdbios_cmd_upause(void)
 530 {
 531     jaguar_word_write(ERR_FLAG,CDROM_STATUS_OK);
 532 }
 533 void cdi_read_block(uint32 sector, uint8 *buffer, uint32 count)
 534 {
 535         while (count)
 536         {
 537                 cdi_load_sector(cdbios_sector_lut[sector],buffer);
 538                 buffer+=2352;
 539                 sector++;
 540                 count--;
 541         }
 542 }
 543 //////////////////////////////////////////////////////////////////////////////
 544 //
 545 //////////////////////////////////////////////////////////////////////////////
 546 //
 547 //
 548 //
 549 //
 550 //
 551 //
 552 //////////////////////////////////////////////////////////////////////////////
 553 void cdbios_cmd_read(void)
 554 {
 555         static uint8 cdbios_sector[2352];
 556
 557 /*      cdrom_destination_buffer_beginning=s68000context.areg[0];
 558         cdrom_destination_buffer_end=s68000context.areg[1];
 559         cdrom_time_code=(s68000context.dreg[0])&0x7fffffff;
 560         cdrom_seek_only=s68000context.dreg[0]&0x80000000;*/
 561         cdrom_destination_buffer_beginning = m68k_get_reg(NULL, M68K_REG_A0);
 562         cdrom_destination_buffer_end = m68k_get_reg(NULL, M68K_REG_A1);
 563         cdrom_time_code = m68k_get_reg(NULL, M68K_REG_D0) & 0x7FFFFFFF;
 564         cdrom_seek_only = m68k_get_reg(NULL, M68K_REG_D0) & 0x80000000;
 565
 566 /*      cdrom_partition_marker=s68000context.dreg[1];
 567         if (s68000context.dreg[2]!=0)
 568                 cdrom_circular_buffer_size=(1<<s68000context.dreg[2]);*/
 569         cdrom_partition_marker = m68k_get_reg(NULL, M68K_REG_D1);
 570         if (m68k_get_reg(NULL, M68K_REG_D2) != 0)
 571                 cdrom_circular_buffer_size = 1 << m68k_get_reg(NULL, M68K_REG_D2);
 572         else
 573                 cdrom_circular_buffer_size = 0xFFFFFFFF; // no circular buffer;
 574
 575         uint32 mm = (10 * ((cdrom_time_code >> 20) & 0x0F)) + ((cdrom_time_code >> 16) & 0x0F);
 576         uint32 ss = (10 * ((cdrom_time_code >> 12) & 0x0F)) + ((cdrom_time_code >> 8) & 0x0F);
 577         uint32 ff = (10 * ((cdrom_time_code >> 4) & 0x0F)) + ((cdrom_time_code >> 0) & 0x0F);
 578
 579         fprintf(log_get(),"cdbios: read(0x%.8x, 0x%.8x, %.2i:%.2i:%.2i, %i) %s\n",
 580                                                 cdrom_destination_buffer_beginning,
 581                                                 cdrom_destination_buffer_end,
 582                                                 mm,ss,ff,
 583                                                 cdrom_circular_buffer_size,cdrom_seek_only?"(seek only)":"");
 584
 585         if (!cdrom_seek_only)
 586         {
 587                 if (cdbios_init_type==CDBIOS_INITM)
 588                 {
 589                         fprintf(log_get(),"cdbios: partition marker: %c%c%c%c (0x%.8x)\n",
 590                                 ((cdrom_partition_marker>>24)&0xff),
 591                                 ((cdrom_partition_marker>>16)&0xff),
 592                                 ((cdrom_partition_marker>>8)&0xff),
 593                                 (cdrom_partition_marker&0xff),
 594                                 cdrom_partition_marker
 595                                 );
 596                 }
 597                 if (((int32)cdrom_circular_buffer_size)==-1)
 598                         cdrom_circular_buffer_size=0xffffffff;
 599
 600                 uint32 track_offset=((ss+(60*mm))*75)+ff;
 601
 602                 fprintf(log_get(),"cdbios: track offset: %i\n",track_offset);
 603                 uint32 nb_sectors=(cdrom_destination_buffer_end-cdrom_destination_buffer_beginning)/2352;
 604                 uint32 reste=(cdrom_destination_buffer_end-cdrom_destination_buffer_beginning)%2352;
 605                 uint32 buffer_offset=0;
 606                 uint32 nb_bytes_to_read=cdrom_destination_buffer_end-cdrom_destination_buffer_beginning+1;
 607
 608                 if (cdbios_init_type==CDBIOS_INITF)
 609                 {
 610 //                      if (cdrom_destination_buffer_beginning==0x00046000)
 611 //                              return;
 612
 613                         uint8 *buffer=(uint8*)malloc((nb_sectors+1)*2352);
 614                         cdi_read_block(track_offset,buffer,nb_sectors+1);
 615                         for (uint32 k=0;k<nb_bytes_to_read;k++)
 616                                 jaguar_byte_write(cdrom_destination_buffer_beginning+k,buffer[k]);
 617                         free(buffer);
 618                 }
 619                 else
 620                 if (cdbios_init_type==CDBIOS_INITM)
 621                 {
 622                         uint8 *buffer=(uint8*)malloc((31+nb_sectors+1)*2352);
 623                         cdi_read_block(track_offset,buffer,nb_sectors+1);
 624
 625                         uint32  count=(31+nb_sectors+1)*2352;
 626                         uint8   *alias=buffer;
 627                         uint32  marker_count=2;
 628
 629                         while (count-4)
 630                         {
 631                                 if (
 632                                         (alias[0]==((cdrom_partition_marker>>24)&0xff))&&
 633                                         (alias[1]==((cdrom_partition_marker>>16)&0xff))&&
 634                                         (alias[2]==((cdrom_partition_marker>>8)&0xff))&&
 635                                         (alias[3]==((cdrom_partition_marker>>0)&0xff))
 636                                         )
 637                                 {
 638                                         marker_count--;
 639                                         if (marker_count)
 640                                         {
 641                                                 alias+=3;
 642                                         }
 643                                         else
 644                                         {
 645                                                 exit(0);
 646                                                 alias+=4;
 647                                                 for (uint32 k=0;k<nb_bytes_to_read;k++)
 648                                                         jaguar_byte_write(cdrom_destination_buffer_beginning+k,alias[k]);
 649                                                 free(buffer);
 650                                                 return;
 651                                         }
 652                                 }
 653                                 alias++;
 654                                 count--;
 655                         }
 656                         free(buffer);
 657                 }
 658                 else
 659                 {
 660                         fprintf(log_get(),"cdbios: unsupported read mode\n");
 661                 }
 662         }
 663     jaguar_word_write(ERR_FLAG,CDROM_STATUS_OK);
 664 }
 665 //////////////////////////////////////////////////////////////////////////////
 666 //
 667 //////////////////////////////////////////////////////////////////////////////
 668 //
 669 //
 670 //
 671 //
 672 //
 673 //
 674 //////////////////////////////////////////////////////////////////////////////
 675 void cdbios_cmd_uread(void)
 676 {
 677         // stop the recording started with a cd_read command
 678         // for now, there is nothing to do
 679     jaguar_word_write(ERR_FLAG,CDROM_STATUS_OK);
 680 }
 681 //////////////////////////////////////////////////////////////////////////////
 682 //
 683 //////////////////////////////////////////////////////////////////////////////
 684 //
 685 //
 686 //
 687 //
 688 //
 689 //
 690 //////////////////////////////////////////////////////////////////////////////
 691 void cdbios_cmd_setup(void)
 692 {
 693         // initialize the cd system
 694     jaguar_word_write(ERR_FLAG, CDROM_STATUS_OK);
 695 }
 696 //////////////////////////////////////////////////////////////////////////////
 697 //
 698 //////////////////////////////////////////////////////////////////////////////
 699 //
 700 //
 701 //
 702 //
 703 //
 704 //
 705 //////////////////////////////////////////////////////////////////////////////
 706 void cdbios_cmd_ptr(void)
 707 {
 708 //      s68000context.areg[0]=cdrom_destination_buffer_end+4;
 709         m68k_set_reg(M68K_REG_A0, cdrom_destination_buffer_end + 4);
 710     jaguar_word_write(ERR_FLAG, CDROM_STATUS_OK);
 711 }
 712 //////////////////////////////////////////////////////////////////////////////
 713 //
 714 //////////////////////////////////////////////////////////////////////////////
 715 //
 716 //
 717 //
 718 //
 719 //
 720 //
 721 //////////////////////////////////////////////////////////////////////////////
 722 void cdbios_cmd_osamp(void)
 723 {
 724 //      cdrom_oversample_factor=(1<<(s68000context.dreg[0]&0xffff));
 725         cdrom_oversample_factor = 1 << (m68k_get_reg(NULL, M68K_REG_D0) & 0xFFFF);
 726     jaguar_word_write(ERR_FLAG, CDROM_STATUS_OK);
 727 }
 728 //////////////////////////////////////////////////////////////////////////////
 729 //
 730 //////////////////////////////////////////////////////////////////////////////
 731 //
 732 //
 733 //
 734 //
 735 //
 736 //
 737 //////////////////////////////////////////////////////////////////////////////
 738 void cdbios_cmd_gettoc(void)
 739 {
 740     jaguar_word_write(ERR_FLAG,CDROM_STATUS_OK);
 741 }
 742 //////////////////////////////////////////////////////////////////////////////
 743 //
 744 //////////////////////////////////////////////////////////////////////////////
 745 //
 746 //
 747 //
 748 //
 749 //
 750 //
 751 //////////////////////////////////////////////////////////////////////////////
 752 void cdbios_cmd_initm(void)
 753 {
 754         cdbios_init_type = CDBIOS_INITM;
 755     jaguar_word_write(ERR_FLAG, CDROM_STATUS_OK);
 756 //      fprintf(log_get(),"cdbios: initm(0x%.8x)\n",s68000context.areg[0]);
 757         fprintf(log_get(), "cdbios: initm(0x%.8x)\n", m68k_get_reg(NULL, M68K_REG_A0));
 758 }
 759 //////////////////////////////////////////////////////////////////////////////
 760 //
 761 //////////////////////////////////////////////////////////////////////////////
 762 //
 763 //
 764 //
 765 //
 766 //
 767 //
 768 //////////////////////////////////////////////////////////////////////////////
 769 void cdbios_cmd_initf(void)
 770 {
 771         cdbios_init_type = CDBIOS_INITF;
 772     jaguar_word_write(ERR_FLAG, CDROM_STATUS_OK);
 773 //      fprintf(log_get(),"cdbios: initf(0x%.8x)\n",s68000context.areg[0]);
 774         fprintf(log_get(), "cdbios: initf(0x%.8x)\n", m68k_get_reg(NULL, M68K_REG_A0));
 775 }
 776 //////////////////////////////////////////////////////////////////////////////
 777 //
 778 //////////////////////////////////////////////////////////////////////////////
 779 //
 780 //
 781 //
 782 //
 783 //
 784 //
 785 //////////////////////////////////////////////////////////////////////////////
 786 void cd_bios_process(uint32 offset)
 787 {
 788         if (!cdbios_init_done)
 789                 return;
 790
 791         fprintf(log_get(), "cdbios: processing command '%s'\n", cdbios_command[(offset-0x3000) / 6]);
 792         fprintf(log_get(), "cdbios: 68K PC=%08X SP=%08X\n", jaguar_long_read(m68k_get_reg(NULL, M68K_REG_A7)), m68k_get_reg(NULL, M68K_REG_A7));
 793
 794         switch (offset)
 795         {
 796         case CD_INIT:   cdbios_cmd_init();              break;
 797         case CD_MODE:   cdbios_cmd_mode();              break;
 798         case CD_ACK:    cdbios_cmd_ack();               break;
 799         case CD_JERI:   cdbios_cmd_jeri();              break;
 800         case CD_SPIN:   cdbios_cmd_spin();              break;
 801         case CD_STOP:   cdbios_cmd_stop();              break;
 802         case CD_MUTE:   cdbios_cmd_mute();              break;
 803         case CD_UMUTE:  cdbios_cmd_umute();             break;
 804         case CD_PAUSE:  cdbios_cmd_pause();             break;
 805         case CD_UPAUSE: cdbios_cmd_upause();    break;
 806         case CD_READ:   cdbios_cmd_read();              break;
 807         case CD_UREAD:  cdbios_cmd_uread();             break;
 808         case CD_SETUP:  cdbios_cmd_setup();             break;
 809         case CD_PTR:    cdbios_cmd_ptr();               break;
 810         case CD_OSAMP:  cdbios_cmd_osamp();             break;
 811         case CD_GETTOC: cdbios_cmd_gettoc();    break;
 812         case CD_INITM:  cdbios_cmd_initm();             break;
 813         case CD_INITF:  cdbios_cmd_initf();             break;
 814
 815         default: fprintf(log_get(), "cdbios: unemulated entry point at %08X 68K PC=%08X SP=%08X\n", offset, jaguar_long_read(m68k_get_reg(NULL, M68K_REG_A7)), m68k_get_reg(NULL, M68K_REG_A7));
 816                 jaguar_word_write(ERR_FLAG, CDROM_STATUS_OK);
 817         }
 818
 819         // rts
 820 //      s68000context.pc=jaguar_long_read(s68000context.areg[7]);
 821 //      s68000context.areg[7]=(s68000context.areg[7]+4)&0xffffffff;
 822         m68k_set_reg(M68K_REG_PC, jaguar_long_read(m68k_get_reg(NULL, M68K_REG_A7)));
 823         m68k_set_reg(M68K_REG_A7, (m68k_get_reg(NULL, M68K_REG_A7) + 4) & 0xFFFFFFFF);
 824 }
 825 //////////////////////////////////////////////////////////////////////////////
 826 //
 827 //////////////////////////////////////////////////////////////////////////////
 828 //
 829 //
 830 //
 831 //
 832 //
 833 //
 834 //////////////////////////////////////////////////////////////////////////////
 835 void cd_bios_exec(uint32 scanline)
 836 {
 837         // single speed mode: 150 Kb/s (153600 bytes/s)
 838         // single speed mode: 300 Kb/s (307200 bytes/s)
 839         uint32 bytes_per_scanline=(153600*((cdrom_speed==CDROM_DOUBLE_SPEED)?2:1))/525;
 840 }