libdi/di.c

   1 /*-------------------------------------------------------------
   2
   3 di.c -- Drive Interface library
   4
   5 Team Twiizers
   6 Copyright (C) 2008
   7
   8 Erant
   9 marcan
  10
  11 rodries
  12 emukidid
  13
  14 This software is provided 'as-is', without any express or implied
  15 warranty.  In no event will the authors be held liable for any
  16 damages arising from the use of this software.
  17
  18 Permission is granted to anyone to use this software for any
  19 purpose, including commercial applications, and to alter it and
  20 redistribute it freely, subject to the following restrictions:
  21
  22 1.      The origin of this software must not be misrepresented; you
  23 must not claim that you wrote the original software. If you use
  24 this software in a product, an acknowledgment in the product
  25 documentation would be appreciated but is not required.
  26
  27 2.      Altered source versions must be plainly marked as such, and
  28 must not be misrepresented as being the original software.
  29
  30 3.      This notice may not be removed or altered from any source
  31 distribution.
  32
  33 -------------------------------------------------------------*/
  34
  35 #include <errno.h>
  36 #include <string.h>
  37 #include <malloc.h>
  38 #include <unistd.h>
  39
  40 #include <di/di.h>
  41 #include <ogc/cache.h>
  42 #include <ogc/es.h>
  43 #include <ogc/ipc.h>
  44 #include <ogc/ios.h>
  45 #include <ogc/mutex.h>
  46 #include <ogc/lwp_watchdog.h>
  47 #include <ogc/machine/processor.h>
  48
  49 #define MOUNT_TIMEOUT           15000 // 15 seconds
  50
  51 int di_fd = -1;
  52 static bool load_dvdx = false;
  53 static bool use_dvd_cache = true;
  54 static int have_ahbprot = 0;
  55 static int state = DVD_INIT | DVD_NO_DISC;
  56
  57 static int _cover_callback(int ret, void* usrdata);
  58
  59 static unsigned int bufferMutex = 0;
  60 static uint32_t outbuf[8] __attribute__((aligned(32)));
  61 static uint32_t dic[8] __attribute__((aligned(32)));
  62 static const char di_path[] ATTRIBUTE_ALIGN(32) = "/dev/di";
  63
  64 static read_func DI_ReadDVDptr = NULL;
  65 static read_func_async DI_ReadDVDAsyncptr = NULL;
  66 static di_callback di_cb = NULL;
  67
  68 static vu32* const _dvdReg = (u32*)0xCD806000;
  69
  70 static int _DI_ReadDVD_A8_Async(void* buf, uint32_t len, uint32_t lba, ipccallback ipc_cb){
  71         int ret;
  72
  73         if(!buf)
  74                 return -EINVAL;
  75
  76         if((uint32_t)buf & 0x1F) // This only works with 32 byte aligned addresses!
  77                 return -EFAULT;
  78
  79         dic[0] = DVD_READ_UNENCRYPTED << 24;
  80         dic[1] = len << 11; // 1 LB is 2048 bytes
  81         dic[2] = lba << 9; // Nintendo's read function uses byteOffset >> 2, so we only shift 9 left, not 11.
  82
  83         ret = IOS_IoctlAsync(di_fd, DVD_READ_UNENCRYPTED, dic, 0x20, buf, len << 11,ipc_cb, buf);
  84
  85         if(ret == 2)
  86                 ret = EIO;
  87
  88         return (ret == 1)? 0 : -ret;
  89 }
  90
  91 static int _DI_ReadDVD_D0_Async(void* buf, uint32_t len, uint32_t lba, ipccallback ipc_cb){
  92         int ret;
  93
  94         if(!buf)
  95                 return -EINVAL;
  96
  97         if((uint32_t)buf & 0x1F)
  98                 return -EFAULT;
  99
 100         dic[0] = DVD_READ << 24;
 101         dic[1] = 0;             // Unknown what this does as of now. (Sets some value to 0x10 in the drive if set).
 102         dic[2] = 0;             // USE_DEFAULT_CONFIG flag. Drive will use default config if this bit is set.
 103         dic[3] = len;
 104         dic[4] = lba;
 105
 106         ret = IOS_IoctlAsync(di_fd, DVD_READ, dic, 0x20, buf, len << 11,ipc_cb, buf);
 107
 108         if(ret == 2)
 109                 ret = EIO;
 110
 111         return (ret == 1)? 0 : -ret;
 112 }
 113
 114 static int _DI_ReadDVD(void* buf, uint32_t len, uint32_t lba, uint32_t read_cmd){
 115         if ((((int) buf) & 0xC0000000) == 0x80000000) // cached?
 116                 _dvdReg[0] = 0x2E;
 117         _dvdReg[1] = 0;
 118         _dvdReg[2] = read_cmd;
 119         _dvdReg[3] = read_cmd == 0xD0000000 ? lba : lba << 9;
 120         _dvdReg[4] = read_cmd == 0xD0000000 ? len : len << 11;
 121         _dvdReg[5] = (unsigned long) buf;
 122         _dvdReg[6] = len << 11;
 123         _dvdReg[7] = 3; // enable reading!
 124         DCInvalidateRange(buf, len << 11);
 125         while (_dvdReg[7] & 1);
 126
 127         if (_dvdReg[0] & 0x4)
 128                 return 1;
 129         return 0;
 130 }
 131
 132 static int _DI_ReadDVD_A8(void* buf, uint32_t len, uint32_t lba){
 133         int ret, retry_count = LIBDI_MAX_RETRIES;
 134
 135         if(!buf)
 136                 return -EINVAL;
 137
 138         if((uint32_t)buf & 0x1F) // This only works with 32 byte aligned addresses!
 139                 return -EFAULT;
 140
 141         if(have_ahbprot)
 142                 return _DI_ReadDVD(buf, len, lba, 0xA8000000);
 143
 144         dic[0] = DVD_READ_UNENCRYPTED << 24;
 145         dic[1] = len << 11; // 1 LB is 2048 bytes
 146         dic[2] = lba << 9; // Nintendo's read function uses byteOffset >> 2, so we only shift 9 left, not 11.
 147
 148         do{
 149                 ret = IOS_Ioctl(di_fd, DVD_READ_UNENCRYPTED, dic, 0x20, buf, len << 11);
 150                 retry_count--;
 151         }while(ret != 1 && retry_count > 0);
 152
 153         if(ret == 2)
 154                 ret = EIO;
 155
 156         return (ret == 1)? 0 : -ret;
 157 }
 158
 159 static int _DI_ReadDVD_D0(void* buf, uint32_t len, uint32_t lba){
 160         int ret, retry_count = LIBDI_MAX_RETRIES;
 161
 162         if(!buf)
 163                 return -EINVAL;
 164
 165         if((uint32_t)buf & 0x1F)
 166                 return -EFAULT;
 167
 168         if(have_ahbprot)
 169                 return _DI_ReadDVD(buf, len, lba, 0xD0000000);
 170
 171         dic[0] = DVD_READ << 24;
 172         dic[1] = 0; // Unknown what this does as of now. (Sets some value to 0x10 in the drive if set).
 173         dic[2] = 0; // USE_DEFAULT_CONFIG flag. Drive will use default config if this bit is set.
 174         dic[3] = len;
 175         dic[4] = lba;
 176
 177         do{
 178                 ret = IOS_Ioctl(di_fd, DVD_READ, dic, 0x20, buf, len << 11);
 179                 retry_count--;
 180         }while(ret != 1 && retry_count > 0);
 181
 182         if(ret == 2)
 183                 ret = EIO;
 184
 185         return (ret == 1)? 0 : -ret;
 186 }
 187
 188 ///// Cache
 189 #define CACHE_FREE 0xFFFFFFFF
 190 #define BLOCK_SIZE 0x800
 191 #define CACHEBLOCKS 26
 192 typedef struct
 193 {
 194         uint32_t block;
 195         void *ptr;
 196 } cache_page;
 197 static cache_page *cache_read = NULL;
 198
 199 static void CreateDVDCache()
 200 {
 201         if (cache_read != NULL)
 202                 return;
 203         cache_read = (cache_page *) malloc(sizeof(cache_page));
 204         if (cache_read == NULL)
 205                 return;
 206
 207         cache_read->block = CACHE_FREE;
 208         cache_read->ptr = memalign(32, BLOCK_SIZE * CACHEBLOCKS);
 209         if (cache_read->ptr == NULL)
 210         {
 211                 free(cache_read);
 212                 cache_read = NULL;
 213                 return;
 214         }
 215         memset(cache_read->ptr, 0, BLOCK_SIZE);
 216 }
 217
 218 static int ReadBlockFromCache(void *buf, uint32_t len, uint32_t block)
 219 {
 220         int retval;
 221
 222         if (cache_read == NULL)
 223                 return DI_ReadDVDptr(buf, len, block);
 224
 225         if ((block >= cache_read->block) && (block + len < (cache_read->block + CACHEBLOCKS)))
 226         {
 227                 memcpy(buf, cache_read->ptr     + ((block - cache_read->block) * BLOCK_SIZE), BLOCK_SIZE * len);
 228                 return 0;
 229         }
 230
 231         if (len > CACHEBLOCKS)
 232                 return DI_ReadDVDptr(buf, len, block);
 233
 234         retval = DI_ReadDVDptr(cache_read->ptr, CACHEBLOCKS, block);
 235         if (retval)
 236         {
 237                 cache_read->block = CACHE_FREE;
 238                 return retval;
 239         }
 240
 241         cache_read->block = block;
 242         memcpy(buf, cache_read->ptr, len * BLOCK_SIZE);
 243
 244         return 0;
 245 }
 246
 247 /*
 248 Initialize the DI interface, should always be called first!
 249 */
 250
 251 u32 __di_check_ahbprot(void) {
 252         return ((*(vu32*)0xcd800064 == 0xFFFFFFFF) ? 1 : 0);
 253 }
 254
 255 int DI_Init() {
 256         if(di_fd >= 0)
 257                 return 1;
 258
 259         state = DVD_INIT | DVD_NO_DISC;
 260         have_ahbprot = __di_check_ahbprot();
 261
 262         if(have_ahbprot == 0)
 263                 return 0;
 264
 265         if (di_fd < 0)
 266                 di_fd = IOS_Open(di_path, 2);
 267
 268         if (di_fd < 0)
 269                 return di_fd;
 270
 271         if (!bufferMutex)
 272                 LWP_MutexInit(&bufferMutex, false);
 273
 274         if(use_dvd_cache)
 275                 CreateDVDCache();
 276
 277         return 0;
 278 }
 279
 280 void DI_LoadDVDX(bool load) {
 281         load_dvdx = load;
 282 }
 283
 284 void DI_UseCache(bool use) {
 285         use_dvd_cache = use;
 286 }
 287
 288 void DI_Mount() {
 289         if(di_fd < 0)
 290                 return;
 291
 292         uint32_t status;
 293
 294         if (DI_GetCoverRegister(&status) != 0) {
 295                 state = DVD_NO_DISC;
 296                 return;
 297         }
 298
 299         if ((status & DVD_COVER_DISC_INSERTED) == 0) {
 300                 state = DVD_NO_DISC;
 301                 return;
 302         }
 303
 304         state = DVD_INIT | DVD_NO_DISC;
 305         _cover_callback(1, NULL);       // Initialize the callback chain.
 306
 307         if (cache_read != NULL)
 308                 cache_read->block = CACHE_FREE; // reset cache
 309 }
 310
 311 void DI_Close(){
 312         if(di_fd < 0)
 313                 return;
 314
 315         if (di_fd > 0)
 316                 IOS_Close(di_fd);
 317
 318         di_fd = -1;
 319
 320         DI_ReadDVDptr = NULL;
 321         DI_ReadDVDAsyncptr = NULL;
 322         state = DVD_INIT | DVD_NO_DISC;
 323
 324         if (bufferMutex) {
 325                 LWP_MutexDestroy(bufferMutex);
 326                 bufferMutex = 0;
 327         }
 328 }
 329
 330 static int _DI_ReadDVD_Check(void* buf, uint32_t len, uint32_t lba)
 331 {
 332         int ret;
 333
 334         ret = _DI_ReadDVD_D0(buf, len, lba);
 335         if (ret == 0)
 336         {
 337                 state = state | DVD_D0;
 338                 DI_ReadDVDptr = _DI_ReadDVD_D0;
 339                 DI_ReadDVDAsyncptr = _DI_ReadDVD_D0_Async;
 340                 return ret;
 341         }
 342         ret = _DI_ReadDVD_A8(buf, len, lba);
 343         if (ret == 0)
 344         {
 345                 state = state | DVD_A8;
 346                 DI_ReadDVDptr = _DI_ReadDVD_A8;
 347                 DI_ReadDVDAsyncptr = _DI_ReadDVD_A8_Async;
 348                 return ret;
 349         }
 350         return ret;
 351 }
 352
 353 static int _DI_ReadDVD_Check_Async(void* buf, uint32_t len, uint32_t lba,       ipccallback ipc_cb)
 354 {
 355         int ret;
 356
 357         ret = _DI_ReadDVD_D0_Async(buf, len, lba, ipc_cb);
 358         if (ret == 0)
 359         {
 360                 state = state | DVD_D0;
 361                 DI_ReadDVDptr = _DI_ReadDVD_D0;
 362                 DI_ReadDVDAsyncptr = _DI_ReadDVD_D0_Async;
 363                 return ret;
 364         }
 365         ret = _DI_ReadDVD_A8_Async(buf, len, lba, ipc_cb);
 366         if (ret == 0)
 367         {
 368                 state = state | DVD_A8;
 369                 DI_ReadDVDptr = _DI_ReadDVD_A8;
 370                 DI_ReadDVDAsyncptr = _DI_ReadDVD_A8_Async;
 371                 return ret;
 372         }
 373         return ret;
 374 }
 375
 376 static void _DI_SetCallback(int ioctl_nr, ipccallback ipc_cb){
 377         if ((di_fd < 0) || !ipc_cb)
 378                 return;
 379
 380         LWP_MutexLock(bufferMutex);
 381
 382         memset(dic, 0x00, sizeof(dic));
 383
 384         dic[0] = ioctl_nr << 24;
 385         dic[1] = (ioctl_nr == DVD_RESET)? 1 : 0;        // For reset callback. Dirty, I know...
 386
 387         IOS_IoctlAsync(di_fd,ioctl_nr, dic, 0x20, outbuf, 0x20, ipc_cb, outbuf);
 388         LWP_MutexUnlock(bufferMutex);
 389 }
 390
 391 #define COVER_CLOSED (*((uint32_t*)usrdata) & DVD_COVER_DISC_INSERTED)
 392
 393 static int _cover_callback(int ret, void* usrdata){
 394         static int cur_state = 0;
 395         static int retry_count = LIBDI_MAX_RETRIES;
 396         const int callback_table[] = {
 397                 DVD_GETCOVER,
 398                 DVD_WAITFORCOVERCLOSE,
 399                 DVD_RESET,
 400                 DVD_IDENTIFY,           // This one will complete when the drive is ready.
 401                 DVD_READ_DISCID,
 402                 0};
 403         const int return_table[] = {1,1,4,1,1};
 404
 405         if(cur_state > 1)
 406                 state &= ~DVD_NO_DISC;
 407
 408         if(callback_table[cur_state]){
 409                 if(ret == return_table[cur_state]){
 410                         if(cur_state == 1 && COVER_CLOSED)      // Disc inside, skipping wait for cover.
 411                                 cur_state += 2;
 412                         else
 413                                 cur_state++; // If the previous callback succeeded, moving on to the next
 414
 415                         retry_count = LIBDI_MAX_RETRIES;
 416                 }
 417                 else
 418                 {
 419                         retry_count--;
 420                         if(retry_count < 0){            // Drive init failed for unknown reasons.
 421                                 retry_count = LIBDI_MAX_RETRIES;
 422                                 cur_state = 0;
 423                                 state = DVD_UNKNOWN;
 424                                 return 0;
 425                         }
 426                 }
 427                 _DI_SetCallback(callback_table[cur_state - 1], _cover_callback);
 428
 429         }
 430         else            // Callback chain has completed OK. The drive is ready.
 431         {
 432                 state = DVD_READY;
 433                 DI_ReadDVDptr = _DI_ReadDVD_Check;
 434                 DI_ReadDVDAsyncptr = _DI_ReadDVD_Check_Async;
 435
 436
 437                 if(di_cb)
 438                         di_cb(state,0);
 439
 440                 retry_count = LIBDI_MAX_RETRIES;
 441                 cur_state = 0;
 442         }
 443         return 0;
 444 }
 445
 446 /* Get current status, will return the API status */
 447 int DI_GetStatus(){
 448         return state;
 449 }
 450
 451 void DI_SetInitCallback(di_callback cb){
 452         di_cb = cb;
 453 }
 454
 455 /*
 456 Request an identification from the drive, returned in a DI_DriveID struct
 457 */
 458 int DI_Identify(DI_DriveID* id){
 459         if(di_fd < 0)
 460                 return -ENXIO;
 461
 462         if(!id)
 463                 return -EINVAL;
 464
 465         LWP_MutexLock(bufferMutex);
 466
 467         dic[0] = DVD_IDENTIFY << 24;
 468
 469         int ret = IOS_Ioctl(di_fd, DVD_IDENTIFY, dic, 0x20, outbuf, 0x20);
 470
 471         if(ret == 2)
 472                 ret = EIO;
 473
 474         memcpy(id,outbuf,sizeof(DI_DriveID));
 475
 476         LWP_MutexUnlock(bufferMutex);
 477         return (ret == 1)? 0 : -ret;
 478 }
 479
 480 /*
 481 Returns the current error code on the drive.
 482 yagcd has a pretty comprehensive list of possible error codes
 483 */
 484 int DI_GetError(uint32_t* error){
 485         if(di_fd < 0)
 486                 return -ENXIO;
 487
 488         if(!error)
 489                 return -EINVAL;
 490
 491         LWP_MutexLock(bufferMutex);
 492
 493         dic[0] = DVD_GET_ERROR << 24;
 494
 495         int ret = IOS_Ioctl(di_fd, DVD_GET_ERROR, dic, 0x20, outbuf, 0x20);
 496
 497         if(ret == 2)
 498                 ret = EIO;
 499
 500         *error = outbuf[0];             // Error code is returned as an int in the first four bytes of outbuf.
 501
 502         LWP_MutexUnlock(bufferMutex);
 503         return (ret == 1)? 0 : -ret;
 504 }
 505
 506 /*
 507 Reset the drive.
 508 */
 509 int DI_Reset(){
 510         if(di_fd < 0)
 511                 return -ENXIO;
 512
 513         LWP_MutexLock(bufferMutex);
 514
 515         dic[0] = DVD_RESET << 24;
 516         dic[1] = 1;
 517
 518         int ret = IOS_Ioctl(di_fd, DVD_RESET, dic, 0x20, outbuf, 0x20);
 519
 520         if(ret == 2)
 521                 ret = EIO;
 522
 523         LWP_MutexUnlock(bufferMutex);
 524         return (ret == 1)? 0 : -ret;
 525 }
 526
 527 /*
 528 Main read function, basically just a wrapper to the function pointer.
 529 Nicer then just exposing the pointer itself
 530 */
 531 int DI_ReadDVD(void* buf, uint32_t len, uint32_t lba){
 532         if(di_fd < 0)
 533                 return -ENXIO;
 534
 535         int ret;
 536         if(DI_ReadDVDptr){
 537                 LWP_MutexLock(bufferMutex);
 538                 ret = ReadBlockFromCache(buf,len,lba);
 539                 LWP_MutexUnlock(bufferMutex);
 540                 return ret;
 541         }
 542         return -1;
 543 }
 544
 545 int DI_ReadDVDAsync(void* buf, uint32_t len, uint32_t lba,ipccallback ipc_cb){
 546         if(di_fd < 0)
 547                 return -ENXIO;
 548
 549         int ret;
 550         if(DI_ReadDVDAsyncptr){
 551                 LWP_MutexLock(bufferMutex);
 552                 ret = DI_ReadDVDAsyncptr(buf,len,lba,ipc_cb);
 553                 LWP_MutexUnlock(bufferMutex);
 554                 return ret;
 555         }
 556         return -1;
 557 }
 558
 559 /*
 560 Unknown what this does as of now...
 561 */
 562 int DI_ReadDVDConfig(uint32_t* val, uint32_t flag){
 563         if(di_fd < 0)
 564                 return -ENXIO;
 565
 566         if(!val)
 567                 return -EINVAL;
 568
 569         LWP_MutexLock(bufferMutex);
 570
 571         dic[0] = DVD_READ_CONFIG << 24;
 572         dic[1] = flag & 0x1;            // Update flag, val will be written if this is 1, val won't be written if it's 0.
 573         dic[2] = 0;                                     // Command will fail driveside if this is not zero.
 574         dic[3] = *val;
 575
 576         int ret = IOS_Ioctl(di_fd, DVD_READ_CONFIG, dic, 0x20, outbuf, 0x20);
 577
 578         if(ret == 2)
 579                 ret = EIO;
 580
 581         *val = outbuf[0];
 582         LWP_MutexUnlock(bufferMutex);
 583         return (ret == 1)? 0 : -ret;
 584 }
 585
 586 /*
 587 Read the copyright information on a DVDVideo
 588 */
 589 int DI_ReadDVDCopyright(uint32_t* copyright){
 590         if(di_fd < 0)
 591                 return -ENXIO;
 592
 593         if(!copyright)
 594                 return -EINVAL;
 595
 596         LWP_MutexLock(bufferMutex);
 597
 598         dic[0] = DVD_READ_COPYRIGHT << 24;
 599         dic[1] = 0;
 600
 601         int ret = IOS_Ioctl(di_fd, DVD_READ_COPYRIGHT, dic, 0x20, outbuf, 0x20);
 602         *copyright = *((uint32_t*)outbuf);              // Copyright information is returned as an int in the first four bytes of outbuf.
 603
 604         if(ret == 2)
 605                 ret = EIO;
 606
 607         LWP_MutexUnlock(bufferMutex);
 608         return (ret == 1)? 0 : -ret;
 609 }
 610
 611 int DI_Read_BCA(void *outbuf)
 612 {
 613         if(di_fd < 0)
 614                 return -ENXIO;
 615
 616         if(!outbuf)
 617                 return -EINVAL;
 618
 619         memset(dic, 0, sizeof(dic));
 620         dic[0] = DVD_READ_BCA << 24;
 621
 622         int ret = IOS_Ioctl(di_fd, DVD_READ_BCA, dic, 0x20, outbuf, 64);
 623
 624         if(ret == 2)
 625                 ret = EIO;
 626
 627         LWP_MutexUnlock(bufferMutex);
 628         return (ret == 1)? 0 : -ret;
 629 }
 630
 631 /*
 632 Returns 0x800 bytes worth of Disc key
 633 */
 634 int DI_ReadDVDDiscKey(void* buf){
 635         int ret;
 636         int retry_count = LIBDI_MAX_RETRIES;
 637
 638         if(di_fd < 0)
 639                 return -ENXIO;
 640
 641         if(!buf)
 642                 return -EINVAL;
 643
 644         if((uint32_t)buf & 0x1F)
 645                 return -EFAULT;
 646
 647         LWP_MutexLock(bufferMutex);
 648
 649         dic[0] = DVD_READ_DISCKEY << 24;
 650         dic[1] = 0;             // Unknown what this flag does.
 651         do{
 652                 ret = IOS_Ioctl(di_fd, DVD_READ_DISCKEY, dic, 0x20, buf, 0x800);
 653                 retry_count--;
 654         }while(ret != 1 && retry_count > 0);
 655
 656         if(ret == 2)
 657                 ret = EIO;
 658
 659         LWP_MutexUnlock(bufferMutex);
 660         return (ret == 1)? 0 : -ret;
 661 }
 662
 663 /*
 664 This function will read the initial sector on the DVD, which contains stuff like the booktype
 665 */
 666 int DI_ReadDVDPhysical(void* buf){
 667         int ret;
 668         int retry_count = LIBDI_MAX_RETRIES;
 669
 670         if(di_fd < 0)
 671                 return -ENXIO;
 672
 673         if(!buf)
 674                 return -EINVAL;
 675
 676         if((uint32_t)buf & 0x1F)
 677                 return -EFAULT;
 678
 679         LWP_MutexLock(bufferMutex);
 680
 681         dic[0] = DVD_READ_PHYSICAL << 24;
 682         dic[1] = 0;             // Unknown what this flag does.
 683
 684         do{
 685                 ret = IOS_Ioctl(di_fd, DVD_READ_PHYSICAL, dic, 0x20, buf, 0x800);
 686                 retry_count--;
 687         }while(ret != 1 && retry_count > 0);
 688
 689         if(ret == 2)
 690                 ret = EIO;
 691
 692         LWP_MutexUnlock(bufferMutex);
 693         return (ret == 1)? 0 : -ret;
 694 }
 695
 696 int DI_ReportKey(int keytype, uint32_t lba, void* buf){
 697         if(di_fd < 0)
 698                 return -ENXIO;
 699
 700         if(!buf)
 701                 return -EINVAL;
 702
 703         if((uint32_t)buf & 0x1F)
 704                 return -EFAULT;
 705
 706         LWP_MutexLock(bufferMutex);
 707
 708         dic[0] = DVD_REPORTKEY << 24;
 709         dic[1] = keytype & 0xFF;
 710         dic[2] = lba;
 711
 712         int ret = IOS_Ioctl(di_fd, DVD_REPORTKEY, dic, 0x20, buf, 0x20);
 713
 714         if(ret == 2)
 715                 ret = EIO;
 716
 717         LWP_MutexUnlock(bufferMutex);
 718         return (ret == 1)? 0 : -ret;
 719 }
 720
 721 int DI_GetCoverRegister(uint32_t* status){
 722         if(di_fd < 0)
 723                 return -ENXIO;
 724
 725         LWP_MutexLock(bufferMutex);
 726         memset(dic, 0x00, 0x20);
 727
 728         int ret = IOS_Ioctl(di_fd, DVD_GETCOVER, dic, 0x20, outbuf, 0x20);
 729         if(ret == 2)
 730                 ret = EIO;
 731
 732         *status = outbuf[0];
 733
 734         LWP_MutexUnlock(bufferMutex);
 735         return (ret == 1)? 0 : -ret;
 736 }
 737
 738 /* Internal function for controlling motor operations */
 739 static int _DI_SetMotor(int flag){
 740         if(di_fd < 0)
 741                 return -ENXIO;
 742
 743         LWP_MutexLock(bufferMutex);
 744
 745         dic[0] = DVD_SET_MOTOR << 24;
 746         dic[1] = flag & 0x1;                    // Eject flag.
 747         dic[2] = (flag >> 1) & 0x1;             // Don't use this flag, it kills the drive until next reset.
 748
 749         int ret = IOS_Ioctl(di_fd, DVD_SET_MOTOR, dic, 0x20, outbuf, 0x20);
 750
 751         if(ret == 2)
 752                 ret = EIO;
 753
 754         LWP_MutexUnlock(bufferMutex);
 755         return(ret == 1)? 0 : -ret;
 756 }
 757
 758 /* Stop the drives motor */
 759 int DI_StopMotor(){
 760         return _DI_SetMotor(0);
 761 }
 762
 763 /* Stop the motor, and eject the disc. Also needs a reset afterwards for normal operation */
 764 int DI_Eject(){
 765         return _DI_SetMotor(1);
 766 }
 767
 768 /* Warning, this will kill your drive untill the next reset. Will not respond to DI commands,
 769 will not take in or eject the disc. Your drive will be d - e - d, dead.
 770
 771 I deem this function to be harmless, as normal operation will resume after a reset.
 772 However, I am not liable for anyones drive exploding as a result from using this function.
 773 */
 774 int DI_KillDrive(){
 775         return _DI_SetMotor(2);
 776 }
 777
 778 int DI_ClosePartition() {
 779         if(di_fd < 0)
 780                 return -ENXIO;
 781
 782         LWP_MutexLock(bufferMutex);
 783
 784         dic[0] = DVD_CLOSE_PARTITION << 24;
 785
 786         int ret = IOS_Ioctl(di_fd, DVD_CLOSE_PARTITION, dic, 0x20, outbuf, 0x20);
 787
 788         if(ret == 2)
 789                 ret = EIO;
 790
 791         LWP_MutexUnlock(bufferMutex);
 792         return(ret == 1)? 0 : -ret;
 793 }
 794
 795 int DI_OpenPartition(uint32_t offset)
 796 {
 797         if(di_fd < 0)
 798                 return -ENXIO;
 799
 800         static ioctlv vectors[5] __attribute__((aligned(32)));
 801         static char certs[0x49e4] __attribute__((aligned(32)));
 802         LWP_MutexLock(bufferMutex);
 803
 804         dic[0] = DVD_OPEN_PARTITION << 24;
 805         dic[1] = offset;
 806
 807         vectors[0].data = dic;
 808         vectors[0].len = 0x20;
 809         vectors[1].data = NULL;
 810         vectors[1].len = 0x2a4;
 811         vectors[2].data = NULL;
 812         vectors[2].len = 0;
 813
 814         vectors[3].data = certs;
 815         vectors[3].len = 0x49e4;
 816         vectors[4].data = outbuf;
 817         vectors[4].len = 0x20;
 818
 819         int ret = IOS_Ioctlv(di_fd, DVD_OPEN_PARTITION, 3, 2, vectors);
 820
 821         if(ret == 2)
 822                 ret = EIO;
 823
 824         LWP_MutexUnlock(bufferMutex);
 825         return(ret == 1)? 0 : -ret;
 826
 827 }
 828
 829 int DI_Read(void *buf, uint32_t size, uint32_t offset)
 830 {
 831         if(di_fd < 0)
 832                 return -ENXIO;
 833
 834         if(!buf)
 835                 return -EINVAL;
 836
 837         if((uint32_t)buf & 0x1F)
 838                 return -EFAULT;
 839
 840         LWP_MutexLock(bufferMutex);
 841
 842         dic[0] = DVD_LOW_READ << 24;
 843         dic[1] = size;
 844         dic[2] = offset;
 845
 846         int ret = IOS_Ioctl(di_fd, DVD_LOW_READ, dic, 0x20, buf, size);
 847
 848         if(ret == 2)
 849                 ret = EIO;
 850
 851         LWP_MutexUnlock(bufferMutex);
 852         return(ret == 1)? 0 : -ret;
 853 }
 854
 855 int DI_UnencryptedRead(void *buf, uint32_t size, uint32_t offset)
 856 {
 857         int ret, retry_count = LIBDI_MAX_RETRIES;
 858
 859         if(di_fd < 0)
 860                 return -ENXIO;
 861
 862         if(!buf)
 863                 return -EINVAL;
 864
 865         if((uint32_t)buf & 0x1F) // This only works with 32 byte aligned addresses!
 866                 return -EFAULT;
 867
 868         LWP_MutexLock(bufferMutex);
 869
 870         dic[0] = DVD_READ_UNENCRYPTED << 24;
 871         dic[1] = size;
 872         dic[2] = offset;
 873
 874         do{
 875                 ret = IOS_Ioctl(di_fd, DVD_READ_UNENCRYPTED, dic, 0x20, buf, size);
 876                 retry_count--;
 877         }while(ret != 1 && retry_count > 0);
 878
 879         if(ret == 2)
 880                 ret = EIO;
 881
 882         LWP_MutexUnlock(bufferMutex);
 883
 884         return (ret == 1)? 0 : -ret;
 885 }
 886
 887 int DI_ReadDiscID(uint64_t *id)
 888 {
 889         if(di_fd < 0)
 890                 return -ENXIO;
 891
 892         LWP_MutexLock(bufferMutex);
 893
 894         dic[0] = DVD_READ_DISCID << 24;
 895
 896         int ret = IOS_Ioctl(di_fd, DVD_READ_DISCID, dic, 0x20, outbuf, 0x20);
 897
 898         if(ret == 2)
 899                 ret = EIO;
 900
 901         memcpy(id, outbuf, sizeof(*id));
 902
 903         LWP_MutexUnlock(bufferMutex);
 904         return(ret == 1)? 0 : -ret;
 905 }
 906
 907 static bool diio_Startup()
 908 {
 909         u64 t1,t2;
 910
 911         if(di_fd < 0)
 912                 return false;
 913
 914         DI_Mount();
 915
 916         t1=ticks_to_millisecs(gettime());
 917
 918         while(state & DVD_INIT)
 919         {
 920                 usleep(500);
 921                 t2=ticks_to_millisecs(gettime());
 922                 if( (t2 - t1) > MOUNT_TIMEOUT)
 923                         return false; // timeout
 924         }
 925
 926         if(state & DVD_READY)
 927                 return true;
 928         return false;
 929 }
 930
 931 static bool diio_IsInserted()
 932 {
 933         u32 val;
 934
 935         if(di_fd < 0)
 936                 return false;
 937
 938         DI_GetCoverRegister(&val);
 939         if(val & 0x2)
 940                 return true;
 941
 942         return false;
 943 }
 944
 945 static bool diio_ReadSectors(sec_t sector,sec_t numSectors,void *buffer)
 946 {
 947         if(DI_ReadDVD(buffer, numSectors, sector) == 0)
 948                 return true;
 949         return false;
 950 }
 951
 952 static bool diio_WriteSectors(sec_t sector,sec_t numSectors,const void *buffer)
 953 {
 954         return true;
 955 }
 956
 957 static bool diio_ClearStatus()
 958 {
 959         return true;
 960 }
 961
 962 static bool diio_Shutdown()
 963 {
 964         DI_StopMotor();
 965         return true;
 966 }
 967
 968 const DISC_INTERFACE __io_wiidvd = {
 969         DEVICE_TYPE_WII_DVD,
 970         FEATURE_MEDIUM_CANREAD | FEATURE_WII_DVD,
 971         (FN_MEDIUM_STARTUP)&diio_Startup,
 972         (FN_MEDIUM_ISINSERTED)&diio_IsInserted,
 973         (FN_MEDIUM_READSECTORS)&diio_ReadSectors,
 974         (FN_MEDIUM_WRITESECTORS)&diio_WriteSectors,
 975         (FN_MEDIUM_CLEARSTATUS)&diio_ClearStatus,
 976         (FN_MEDIUM_SHUTDOWN)&diio_Shutdown
 977 };