1 /*---------------------------------------------------------------------------* 2 Project: TwlSDK - FATFS - include 3 File: types.h 4 5 Copyright 2007-2008 Nintendo. All rights reserved. 6 7 These coded instructions, statements, and computer programs contain 8 proprietary information of Nintendo of America Inc. and/or Nintendo 9 Company Ltd., and are protected by Federal copyright law. They may 10 not be disclosed to third parties or copied or duplicated in any form, 11 in whole or in part, without the prior written consent of Nintendo. 12 13 $Date:: 2009-02-06#$ 14 $Rev: 9992 $ 15 $Author: yosizaki $ 16 *---------------------------------------------------------------------------*/ 17 18 #ifndef NITRO_FATFS_TYPES_H_ 19 #define NITRO_FATFS_TYPES_H_ 20 21 22 #include <twl/types.h> 23 #include <twl/misc.h> 24 #include <twl/os/common/systemWork.h> 25 #include <nitro/os/common/thread.h> 26 27 28 #ifdef __cplusplus 29 extern "C" { 30 #endif 31 32 33 /*---------------------------------------------------------------------------*/ 34 /* Constants */ 35 36 // File handles that can be opened simultaneously (increase this if necessary) 37 #define FATFS_FILE_HANDLE_MAX 8 38 #define FATFS_DIRECTORY_HANDLE_MAX 8 39 40 #define FATFS_DMA_NOT_USE 0xFF 41 #define FATFS_DMA_4 0 42 #define FATFS_DMA_5 1 43 #define FATFS_DMA_6 2 44 #define FATFS_DMA_7 3 45 46 #define FATFS_COMMAND_BUFFER_SIZE 2048 47 48 // A command buffer is required for both normal and urgent use 49 #define FATFS_COMMAND_BUFFER_MAX (FATFS_COMMAND_BUFFER_SIZE * 2) 50 51 #define FATFS_INVALID_HANDLE 0 52 53 // Result codes for the FATFS library API 54 typedef u32 FATFSResult; 55 #define FATFS_RESULT_SUCCESS 0 56 #define FATFS_RESULT_ERROR 1 57 #define FATFS_RESULT_BUSY 2 58 #define FATFS_RESULT_FAILURE 3 59 #define FATFS_RESULT_UNSUPPORTED 4 60 #define FATFS_RESULT_INVALIDPARAM 5 61 #define FATFS_RESULT_NOMORERESOURCE 6 62 #define FATFS_RESULT_ALREADYDONE 7 63 #define FATFS_RESULT_PERMISSIONDENIDED 8 64 #define FATFS_RESULT_MEDIAFATAL 9 65 #define FATFS_RESULT_NOENTRY 10 66 #define FATFS_RESULT_MEDIANOTHING 11 67 #define FATFS_RESULT_MEDIAUNKNOWN 12 68 #define FATFS_RESULT_BADFORMAT 13 69 #define FATFS_RESULT_CANCELED 14 70 #define FATFS_RESULT_CANCELLED FATFS_RESULT_CANCELED 71 72 // FATFS command types 73 typedef u32 FATFSCommandID; 74 #define FATFS_COMMAND_MOUNT_DRIVE 0 75 #define FATFS_COMMAND_UNMOUNT_DRIVE 1 76 #define FATFS_COMMAND_FORMAT_DRIVE 2 77 #define FATFS_COMMAND_CHECK_DISK 3 78 #define FATFS_COMMAND_GET_DRIVE_RESOURCE 4 79 #define FATFS_COMMAND_SET_DEFAULT_DRIVE 5 80 #define FATFS_COMMAND_GET_FILEINFO 6 81 #define FATFS_COMMAND_SET_FILEINFO 7 82 #define FATFS_COMMAND_CREATE_FILE 8 83 #define FATFS_COMMAND_DELETE_FILE 9 84 #define FATFS_COMMAND_RENAME_FILE 10 85 #define FATFS_COMMAND_CREATE_DIRECTORY 11 86 #define FATFS_COMMAND_DELETE_DIRECTORY 12 87 #define FATFS_COMMAND_RENAME_DIRECTORY 13 88 #define FATFS_COMMAND_OPEN_FILE 14 89 #define FATFS_COMMAND_CLOSE_FILE 15 90 #define FATFS_COMMAND_READ_FILE 16 91 #define FATFS_COMMAND_WRITE_FILE 17 92 #define FATFS_COMMAND_SEEK_FILE 18 93 #define FATFS_COMMAND_FLUSH_FILE 19 94 #define FATFS_COMMAND_GET_FILE_LENGTH 20 95 #define FATFS_COMMAND_SET_FILE_LENGTH 21 96 #define FATFS_COMMAND_OPEN_DIRECTORY 22 97 #define FATFS_COMMAND_CLOSE_DIRECTORY 23 98 #define FATFS_COMMAND_READ_DIRECTORY 24 99 #define FATFS_COMMAND_FLUSH_ALL 25 100 #define FATFS_COMMAND_UNMOUNT_ALL 26 101 #define FATFS_COMMAND_MOUNT_SPECIAL 27 102 #define FATFS_COMMAND_SET_NDMA_PARAMETERS 28 103 #define FATFS_COMMAND_SET_SEEK_CACHE 29 104 #define FATFS_COMMAND_FORMAT_SPECIAL 30 105 #define FATFS_COMMAND_SET_LATENCY_EMULATION 31 106 #define FATFS_COMMAND_MAX 32 107 108 // Media types that can be controlled by FATFS 109 typedef u32 FATFSMediaType; 110 #define FATFS_MEDIA_TYPE_NAND 0 111 #define FATFS_MEDIA_TYPE_SD 1 112 #define FATFS_MEDIA_TYPE_SUBNAND 2 113 114 // Starting point for file pointer movement 115 typedef u32 FATFSSeekMode; 116 #define FATFS_SEEK_SET 0 117 #define FATFS_SEEK_CUR 1 118 #define FATFS_SEEK_END 2 119 120 // Maximum size of each argument type used by commands 121 #define FATFS_PATH_MAX 260 122 #define FATFS_DRIVE_NAME_MAX 15 // Consider future extensions. 123 #define FATFS_PERMIT_STRING_MAX 15 124 #define FATFS_ACCESSMODE_STRING_MAX 15 125 #define FATFS_ARCHIVE_FULLPATH_MAX (FATFS_DRIVE_NAME_MAX + 1 + 1 + FATFS_PATH_MAX) 126 127 // Entry attributes 128 #define FATFS_ATTRIBUTE_IS_PROTECTED 0x00000200UL 129 #define FATFS_ATTRIBUTE_DOS_MASK 0x000000FFUL 130 #define FATFS_ATTRIBUTE_DOS_READONLY 0x00000001UL 131 #define FATFS_ATTRIBUTE_DOS_HIDDEN 0x00000002UL 132 #define FATFS_ATTRIBUTE_DOS_SYSTEM 0x00000004UL 133 #define FATFS_ATTRIBUTE_DOS_VOLUME 0x00000008UL 134 #define FATFS_ATTRIBUTE_DOS_DIRECTORY 0x00000010UL 135 #define FATFS_ATTRIBUTE_DOS_ARCHIVE 0x00000020UL 136 137 #define FATFS_PROPERTY_CTRL_SET_MTIME 0x01000000UL 138 #define FATFS_PROPERTY_CTRL_MASK 0x01000000UL 139 140 // DOS-FAT time format 141 #define FATFS_DOSTIME_TO_SEC(dostime) (u32)((((dostime) >> 0) & 0x1F) * 2) 142 #define FATFS_DOSTIME_TO_MIN(dostime) (u32)((((dostime) >> 5) & 0x3F) + 0) 143 #define FATFS_DOSTIME_TO_HOUR(dostime) (u32)((((dostime) >> 11) & 0x1F) + 0) 144 #define FATFS_DOSTIME_TO_MDAY(dostime) (u32)((((dostime) >> 16) & 0x1F) + 0) 145 #define FATFS_DOSTIME_TO_MON(dostime) (u32)((((dostime) >> 21) & 0x0F) + 0) 146 #define FATFS_DOSTIME_TO_YEAR(dostime) (u32)((((dostime) >> 25) & 0x7F) + 1980) 147 148 #define FATFS_DATETIME_TO_DOSTIME(year, mon, mday, hour, min, sec) \ 149 (u32)((((sec / 2) & 0x1F) << 0) | \ 150 (((min - 0) & 0x3F) << 5) | \ 151 (((hour - 0) & 0x1F) << 11) | \ 152 (((mday - 0) & 0x1F) << 16) | \ 153 (((mon - 0) & 0x0F) << 21) | \ 154 (((year - 1980) & 0x7F) << 25)) 155 156 #define FATFS_EVENT_SD_INSERTED 0x00010001 157 #define FATFS_EVENT_SD_REMOVED 0x00010002 158 159 /*---------------------------------------------------------------------------*/ 160 /* Declarations */ 161 162 typedef u32 FATFSFileHandle; 163 typedef u32 FATFSDirectoryHandle; 164 165 typedef struct FATFSFileInfo 166 { 167 char shortname[16]; 168 char longname[FATFS_PATH_MAX + 1]; 169 char padding[3]; 170 u32 length; 171 u32 dos_atime; 172 u32 dos_mtime; 173 u32 dos_ctime; 174 u32 attributes; 175 } 176 FATFSFileInfo; 177 178 typedef struct FATFSDiskInfo 179 { 180 u32 n_user_files; 181 u32 n_hidden_files; 182 u32 n_user_directories; 183 u32 n_free_clusters; 184 u32 n_bad_clusters; 185 u32 n_file_clusters; 186 u32 n_hidden_clusters; 187 u32 n_dir_clusters; 188 u32 n_crossed_points; 189 u32 n_lost_chains; 190 u32 n_lost_clusters; 191 u32 n_bad_lfns; 192 } 193 FATFSDiskInfo; 194 195 typedef struct FATFSDriveResource 196 { 197 u64 totalSize; 198 u64 availableSize; 199 u32 maxFileHandles; 200 u32 currentFileHandles; 201 u32 maxDirectoryHandles; 202 u32 currentDirectoryHandles; 203 // for FAT archives 204 u32 bytesPerSector; 205 u32 sectorsPerCluster; 206 u32 totalClusters; 207 u32 availableClusters; 208 u32 fatBits; 209 } 210 FATFSDriveResource; 211 212 typedef struct FATFSCommandHeader 213 { 214 FATFSCommandID command; 215 FATFSResult result; 216 u32 flags; 217 struct FATFSCommandHeader *next; 218 } 219 FATFSCommandHeader; 220 221 typedef struct FATFSCommandMountDrive 222 { 223 FATFSCommandHeader header; 224 FATFSMediaType media; 225 int partition; 226 char name[FATFS_DRIVE_NAME_MAX + 1]; 227 } 228 FATFSCommandMountDrive; 229 230 typedef struct FATFSCommandUnmountDrive 231 { 232 FATFSCommandHeader header; 233 char name[FATFS_DRIVE_NAME_MAX + 1]; 234 } 235 FATFSCommandUnmountDrive; 236 237 typedef struct FATFSCommandFormatDrive 238 { 239 FATFSCommandHeader header; 240 char name[FATFS_DRIVE_NAME_MAX + 1]; 241 u32 formatMedia; 242 } 243 FATFSCommandFormatDrive; 244 245 typedef struct FATFSCommandCheckDisk 246 { 247 FATFSCommandHeader header; 248 char name[FATFS_DRIVE_NAME_MAX + 1]; 249 u32 verbose; 250 u32 fix_problems; 251 u32 write_chains; 252 FATFSDiskInfo info; 253 } 254 FATFSCommandCheckDisk; 255 256 typedef struct FATFSCommandGetDriveResource 257 { 258 FATFSCommandHeader header; 259 char name[FATFS_DRIVE_NAME_MAX + 1]; 260 FATFSDriveResource resource[1]; 261 } 262 FATFSCommandGetDriveResource; 263 264 typedef struct FATFSCommandSetDefaultDrive 265 { 266 FATFSCommandHeader header; 267 char name[FATFS_DRIVE_NAME_MAX + 1]; 268 } 269 FATFSCommandSetDefaultDrive; 270 271 typedef struct FATFSCommandGetFileInfo 272 { 273 FATFSCommandHeader header; 274 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 275 u8 padding[2]; 276 FATFSFileInfo info; 277 } 278 FATFSCommandGetFileInfo; 279 280 typedef struct FATFSCommandSetFileInfo 281 { 282 FATFSCommandHeader header; 283 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 284 u8 padding[2]; 285 FATFSFileInfo info; 286 } 287 FATFSCommandSetFileInfo; 288 289 typedef struct FATFSCommandCreateFile 290 { 291 FATFSCommandHeader header; 292 BOOL trunc; 293 char permit[FATFS_PERMIT_STRING_MAX + 1]; 294 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 295 u8 padding[2]; 296 } 297 FATFSCommandCreateFile; 298 299 typedef struct FATFSCommandDeleteFile 300 { 301 FATFSCommandHeader header; 302 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 303 u8 padding[2]; 304 } 305 FATFSCommandDeleteFile; 306 307 typedef struct FATFSCommandRenameFile 308 { 309 FATFSCommandHeader header; 310 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 311 char newpath[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 312 u8 padding[4]; 313 } 314 FATFSCommandRenameFile; 315 316 typedef struct FATFSCommandCreateDirectory 317 { 318 FATFSCommandHeader header; 319 char permit[FATFS_PERMIT_STRING_MAX + 1]; 320 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 321 u8 padding[2]; 322 } 323 FATFSCommandCreateDirectory; 324 325 typedef struct FATFSCommandDeleteDirectory 326 { 327 FATFSCommandHeader header; 328 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 329 u8 padding[2]; 330 } 331 FATFSCommandDeleteDirectory; 332 333 typedef struct FATFSCommandRenameDirectory 334 { 335 FATFSCommandHeader header; 336 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 337 char newpath[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 338 u8 padding[4]; 339 } 340 FATFSCommandRenameDirectory; 341 342 typedef struct FATFSCommandOpenFile 343 { 344 FATFSCommandHeader header; 345 FATFSFileHandle handle; 346 char mode[FATFS_ACCESSMODE_STRING_MAX + 1]; 347 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 348 u8 padding[2]; 349 } 350 FATFSCommandOpenFile; 351 352 typedef struct FATFSCommandCloseFile 353 { 354 FATFSCommandHeader header; 355 FATFSFileHandle handle; 356 } 357 FATFSCommandCloseFile; 358 359 typedef struct FATFSCommandReadFile 360 { 361 FATFSCommandHeader header; 362 FATFSFileHandle handle; 363 void *buffer; 364 int length; 365 } 366 FATFSCommandReadFile; 367 368 typedef struct FATFSCommandWriteFile 369 { 370 FATFSCommandHeader header; 371 FATFSFileHandle handle; 372 const void *buffer; 373 int length; 374 } 375 FATFSCommandWriteFile; 376 377 typedef struct FATFSCommandSetSeekCache 378 { 379 FATFSCommandHeader header; 380 FATFSFileHandle handle; 381 void *buf; 382 u32 buf_size; 383 } 384 FATFSCommandSetSeekCache; 385 386 typedef struct FATFSCommandSeekFile 387 { 388 FATFSCommandHeader header; 389 FATFSFileHandle handle; 390 int offset; 391 FATFSSeekMode origin; 392 } 393 FATFSCommandSeekFile; 394 395 typedef struct FATFSCommandFlushFile 396 { 397 FATFSCommandHeader header; 398 FATFSFileHandle handle; 399 } 400 FATFSCommandFlushFile; 401 402 typedef struct FATFSCommandGetFileLength 403 { 404 FATFSCommandHeader header; 405 FATFSFileHandle handle; 406 u32 length; 407 } 408 FATFSCommandGetFileLength; 409 410 typedef struct FATFSCommandSetFileLength 411 { 412 FATFSCommandHeader header; 413 FATFSFileHandle handle; 414 u32 length; 415 } 416 FATFSCommandSetFileLength; 417 418 typedef struct FATFSCommandOpenDirectory 419 { 420 FATFSCommandHeader header; 421 FATFSDirectoryHandle handle; 422 char mode[FATFS_ACCESSMODE_STRING_MAX + 1]; 423 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 424 u8 padding[2]; 425 } 426 FATFSCommandOpenDirectory; 427 428 typedef struct FATFSCommandCloseDirectory 429 { 430 FATFSCommandHeader header; 431 FATFSDirectoryHandle handle; 432 } 433 FATFSCommandCloseDirectory; 434 435 typedef struct FATFSCommandReadDirectory 436 { 437 FATFSCommandHeader header; 438 FATFSDirectoryHandle handle; 439 FATFSFileInfo info; 440 } 441 FATFSCommandReadDirectory; 442 443 typedef struct FATFSCommandFlushAll 444 { 445 FATFSCommandHeader header; 446 } 447 FATFSCommandFlushAll; 448 449 typedef struct FATFSCommandUnmountAll 450 { 451 FATFSCommandHeader header; 452 } 453 FATFSCommandUnmountAll; 454 455 typedef struct FATFSCommandMountSpecial 456 { 457 FATFSCommandHeader header; 458 u64 param; 459 int slot; 460 char arcname[OS_MOUNT_ARCHIVE_NAME_LEN]; 461 } 462 FATFSCommandMountSpecial; 463 464 typedef struct FATFSCommandSetNdmaParameters 465 { 466 FATFSCommandHeader header; 467 u32 ndmaNo; 468 u32 blockWord; 469 u32 intervalTimer; 470 u32 prescaler; 471 } 472 FATFSCommandSetNdmaParameters; 473 474 typedef struct FATFSCommandFormatSpecial 475 { 476 FATFSCommandHeader header; 477 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 478 u8 padding[6]; 479 u64 data; 480 } 481 FATFSCommandFormatSpecial; 482 483 typedef struct FATFSCommandSetLatencyEmulation 484 { 485 FATFSCommandHeader header; 486 u32 enable; 487 } 488 FATFSCommandSetLatencyEmulation; 489 490 491 SDK_COMPILER_ASSERT(sizeof(FATFSCommandHeader) <= FATFS_COMMAND_BUFFER_SIZE); 492 SDK_COMPILER_ASSERT(sizeof(FATFSCommandMountDrive) <= FATFS_COMMAND_BUFFER_SIZE); 493 SDK_COMPILER_ASSERT(sizeof(FATFSCommandUnmountDrive) <= FATFS_COMMAND_BUFFER_SIZE); 494 SDK_COMPILER_ASSERT(sizeof(FATFSCommandSetDefaultDrive) <= FATFS_COMMAND_BUFFER_SIZE); 495 SDK_COMPILER_ASSERT(sizeof(FATFSCommandFormatDrive) <= FATFS_COMMAND_BUFFER_SIZE); 496 SDK_COMPILER_ASSERT(sizeof(FATFSCommandCheckDisk) <= FATFS_COMMAND_BUFFER_SIZE); 497 SDK_COMPILER_ASSERT(sizeof(FATFSCommandGetDriveResource) <= FATFS_COMMAND_BUFFER_SIZE); 498 SDK_COMPILER_ASSERT(sizeof(FATFSCommandGetFileInfo) <= FATFS_COMMAND_BUFFER_SIZE); 499 SDK_COMPILER_ASSERT(sizeof(FATFSCommandCreateFile) <= FATFS_COMMAND_BUFFER_SIZE); 500 SDK_COMPILER_ASSERT(sizeof(FATFSCommandDeleteFile) <= FATFS_COMMAND_BUFFER_SIZE); 501 SDK_COMPILER_ASSERT(sizeof(FATFSCommandRenameFile) <= FATFS_COMMAND_BUFFER_SIZE); 502 503 SDK_COMPILER_ASSERT(sizeof(FATFSCommandOpenFile) <= FATFS_COMMAND_BUFFER_SIZE); 504 SDK_COMPILER_ASSERT(sizeof(FATFSCommandCloseFile) <= FATFS_COMMAND_BUFFER_SIZE); 505 SDK_COMPILER_ASSERT(sizeof(FATFSCommandReadFile) <= FATFS_COMMAND_BUFFER_SIZE); 506 SDK_COMPILER_ASSERT(sizeof(FATFSCommandWriteFile) <= FATFS_COMMAND_BUFFER_SIZE); 507 SDK_COMPILER_ASSERT(sizeof(FATFSCommandSeekFile) <= FATFS_COMMAND_BUFFER_SIZE); 508 SDK_COMPILER_ASSERT(sizeof(FATFSCommandFlushFile) <= FATFS_COMMAND_BUFFER_SIZE); 509 SDK_COMPILER_ASSERT(sizeof(FATFSCommandGetFileLength) <= FATFS_COMMAND_BUFFER_SIZE); 510 SDK_COMPILER_ASSERT(sizeof(FATFSCommandSetFileLength) <= FATFS_COMMAND_BUFFER_SIZE); 511 512 SDK_COMPILER_ASSERT(sizeof(FATFSCommandOpenDirectory) <= FATFS_COMMAND_BUFFER_SIZE); 513 SDK_COMPILER_ASSERT(sizeof(FATFSCommandCloseDirectory) <= FATFS_COMMAND_BUFFER_SIZE); 514 SDK_COMPILER_ASSERT(sizeof(FATFSCommandReadDirectory) <= FATFS_COMMAND_BUFFER_SIZE); 515 516 SDK_COMPILER_ASSERT(sizeof(FATFSCommandFlushAll) <= FATFS_COMMAND_BUFFER_SIZE); 517 SDK_COMPILER_ASSERT(sizeof(FATFSCommandUnmountAll) <= FATFS_COMMAND_BUFFER_SIZE); 518 SDK_COMPILER_ASSERT(sizeof(FATFSCommandMountSpecial) <= FATFS_COMMAND_BUFFER_SIZE); 519 SDK_COMPILER_ASSERT(sizeof(FATFSCommandSetNdmaParameters) <= FATFS_COMMAND_BUFFER_SIZE); 520 SDK_COMPILER_ASSERT(sizeof(FATFSCommandFormatSpecial) <= FATFS_COMMAND_BUFFER_SIZE); 521 SDK_COMPILER_ASSERT(sizeof(FATFSCommandSetLatencyEmulation) <= FATFS_COMMAND_BUFFER_SIZE); 522 523 524 typedef struct FATFSRequestBuffer 525 { 526 union 527 { 528 FATFSCommandHeader header; 529 u8 buffer[FATFS_COMMAND_BUFFER_SIZE]; 530 }; 531 OSThread *thread; 532 void (*callback)(struct FATFSRequestBuffer *); 533 void *userdata; 534 struct FATFSRequestBuffer *next; 535 u8 padding[16]; 536 } 537 FATFSRequestBuffer ATTRIBUTE_ALIGN(32); 538 539 typedef struct FATFSResultBuffer 540 { 541 struct FATFSResultBuffer *next; 542 OSThread *thread; 543 FATFSCommandHeader *command; 544 u32 result; 545 u8 reserved[16]; 546 } 547 FATFSResultBuffer; 548 549 550 /*---------------------------------------------------------------------------* 551 * Versions with Unicode support 552 *---------------------------------------------------------------------------*/ 553 554 typedef struct FATFSFileInfoW 555 { 556 char shortname[16]; 557 u16 longname[FATFS_PATH_MAX + 1]; 558 u16 padding; 559 u32 length; 560 u32 dos_atime; 561 u32 dos_mtime; 562 u32 dos_ctime; 563 u32 attributes; 564 } 565 FATFSFileInfoW; 566 567 SDK_COMPILER_ASSERT(sizeof(FATFSFileInfoW) <= FATFS_COMMAND_BUFFER_SIZE); 568 569 typedef struct FATFSCommandGetFileInfoW 570 { 571 FATFSCommandHeader header; 572 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 573 u16 padding[2]; 574 FATFSFileInfoW info; 575 } 576 FATFSCommandGetFileInfoW; 577 578 typedef struct FATFSCommandSetFileInfoW 579 { 580 FATFSCommandHeader header; 581 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 582 u16 padding[2]; 583 FATFSFileInfoW info; 584 } 585 FATFSCommandSetFileInfoW; 586 587 typedef struct FATFSCommandCreateFileW 588 { 589 FATFSCommandHeader header; 590 BOOL trunc; 591 char permit[FATFS_PERMIT_STRING_MAX + 1]; 592 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 593 u16 padding[2]; 594 } 595 FATFSCommandCreateFileW; 596 597 typedef struct FATFSCommandDeleteFileW 598 { 599 FATFSCommandHeader header; 600 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 601 u16 padding[2]; 602 } 603 FATFSCommandDeleteFileW; 604 605 typedef struct FATFSCommandRenameFileW 606 { 607 FATFSCommandHeader header; 608 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 609 u16 newpath[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 610 } 611 FATFSCommandRenameFileW; 612 613 typedef struct FATFSCommandCreateDirectoryW 614 { 615 FATFSCommandHeader header; 616 char permit[FATFS_PERMIT_STRING_MAX + 1]; 617 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 618 u16 padding[2]; 619 } 620 FATFSCommandCreateDirectoryW; 621 622 typedef struct FATFSCommandDeleteDirectoryW 623 { 624 FATFSCommandHeader header; 625 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 626 u16 padding[2]; 627 } 628 FATFSCommandDeleteDirectoryW; 629 630 typedef struct FATFSCommandRenameDirectoryW 631 { 632 FATFSCommandHeader header; 633 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 634 u16 newpath[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 635 } 636 FATFSCommandRenameDirectoryW; 637 638 typedef struct FATFSCommandOpenFileW 639 { 640 FATFSCommandHeader header; 641 FATFSFileHandle handle; 642 char mode[FATFS_ACCESSMODE_STRING_MAX + 1]; 643 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 644 u16 padding[2]; 645 } 646 FATFSCommandOpenFileW; 647 648 typedef struct FATFSCommandOpenDirectoryW 649 { 650 FATFSCommandHeader header; 651 FATFSDirectoryHandle handle; 652 char mode[FATFS_ACCESSMODE_STRING_MAX + 1]; 653 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 654 u16 padding[2]; 655 } 656 FATFSCommandOpenDirectoryW; 657 658 typedef struct FATFSCommandReadDirectoryW 659 { 660 FATFSCommandHeader header; 661 FATFSDirectoryHandle handle; 662 FATFSFileInfoW info; 663 } 664 FATFSCommandReadDirectoryW; 665 666 667 SDK_COMPILER_ASSERT(sizeof(FATFSCommandGetFileInfoW) <= FATFS_COMMAND_BUFFER_SIZE); 668 SDK_COMPILER_ASSERT(sizeof(FATFSCommandSetFileInfoW) <= FATFS_COMMAND_BUFFER_SIZE); 669 SDK_COMPILER_ASSERT(sizeof(FATFSCommandCreateFileW) <= FATFS_COMMAND_BUFFER_SIZE); 670 SDK_COMPILER_ASSERT(sizeof(FATFSCommandDeleteFileW) <= FATFS_COMMAND_BUFFER_SIZE); 671 SDK_COMPILER_ASSERT(sizeof(FATFSCommandRenameFileW) <= FATFS_COMMAND_BUFFER_SIZE); 672 SDK_COMPILER_ASSERT(sizeof(FATFSCommandCreateDirectoryW) <= FATFS_COMMAND_BUFFER_SIZE); 673 SDK_COMPILER_ASSERT(sizeof(FATFSCommandDeleteDirectoryW) <= FATFS_COMMAND_BUFFER_SIZE); 674 SDK_COMPILER_ASSERT(sizeof(FATFSCommandRenameDirectoryW) <= FATFS_COMMAND_BUFFER_SIZE); 675 SDK_COMPILER_ASSERT(sizeof(FATFSCommandOpenFileW) <= FATFS_COMMAND_BUFFER_SIZE); 676 SDK_COMPILER_ASSERT(sizeof(FATFSCommandOpenDirectoryW) <= FATFS_COMMAND_BUFFER_SIZE); 677 SDK_COMPILER_ASSERT(sizeof(FATFSCommandReadDirectoryW) <= FATFS_COMMAND_BUFFER_SIZE); 678 679 680 #ifdef __cplusplus 681 } /* extern "C" */ 682 #endif 683 684 /* NITRO_FATFS_TYPES_H_ */ 685 #endif 686