1 /*---------------------------------------------------------------------------* 2 Project: TwlSDK - FATFS - include 3 File: types.h 4 5 Copyright 2007-2009 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-06-04#$ 14 $Rev: 10698 $ 15 $Author: okubata_ryoma $ 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_SEARCH_WILDCARD 32 107 #define FATFS_COMMAND_MAX 33 108 109 // Media types that can be controlled by FATFS 110 typedef u32 FATFSMediaType; 111 #define FATFS_MEDIA_TYPE_NAND 0 112 #define FATFS_MEDIA_TYPE_SD 1 113 #define FATFS_MEDIA_TYPE_SUBNAND 2 114 115 // Starting point for file pointer movement 116 typedef u32 FATFSSeekMode; 117 #define FATFS_SEEK_SET 0 118 #define FATFS_SEEK_CUR 1 119 #define FATFS_SEEK_END 2 120 121 // Maximum size of each argument type used by commands 122 #define FATFS_PATH_MAX 260 123 #define FATFS_DRIVE_NAME_MAX 15 // Consider future extensions. 124 #define FATFS_PERMIT_STRING_MAX 15 125 #define FATFS_ACCESSMODE_STRING_MAX 15 126 #define FATFS_ARCHIVE_FULLPATH_MAX (FATFS_DRIVE_NAME_MAX + 1 + 1 + FATFS_PATH_MAX) 127 #define FATFS_SHORTNAME_FILENAME_MAX 8 128 #define FATFS_SHORTNAME_PREFIX_MAX 5 129 #define FATFS_SHORTNAME_SUFFIX_MAX 3 130 131 // Entry attributes 132 #define FATFS_ATTRIBUTE_IS_PROTECTED 0x00000200UL 133 #define FATFS_ATTRIBUTE_DOS_MASK 0x000000FFUL 134 #define FATFS_ATTRIBUTE_DOS_READONLY 0x00000001UL 135 #define FATFS_ATTRIBUTE_DOS_HIDDEN 0x00000002UL 136 #define FATFS_ATTRIBUTE_DOS_SYSTEM 0x00000004UL 137 #define FATFS_ATTRIBUTE_DOS_VOLUME 0x00000008UL 138 #define FATFS_ATTRIBUTE_DOS_DIRECTORY 0x00000010UL 139 #define FATFS_ATTRIBUTE_DOS_ARCHIVE 0x00000020UL 140 141 #define FATFS_PROPERTY_CTRL_SET_MTIME 0x01000000UL 142 #define FATFS_PROPERTY_CTRL_MASK 0x01000000UL 143 144 // DOS-FAT time format 145 #define FATFS_DOSTIME_TO_SEC(dostime) (u32)((((dostime) >> 0) & 0x1F) * 2) 146 #define FATFS_DOSTIME_TO_MIN(dostime) (u32)((((dostime) >> 5) & 0x3F) + 0) 147 #define FATFS_DOSTIME_TO_HOUR(dostime) (u32)((((dostime) >> 11) & 0x1F) + 0) 148 #define FATFS_DOSTIME_TO_MDAY(dostime) (u32)((((dostime) >> 16) & 0x1F) + 0) 149 #define FATFS_DOSTIME_TO_MON(dostime) (u32)((((dostime) >> 21) & 0x0F) + 0) 150 #define FATFS_DOSTIME_TO_YEAR(dostime) (u32)((((dostime) >> 25) & 0x7F) + 1980) 151 152 #define FATFS_DATETIME_TO_DOSTIME(year, mon, mday, hour, min, sec) \ 153 (u32)((((sec / 2) & 0x1F) << 0) | \ 154 (((min - 0) & 0x3F) << 5) | \ 155 (((hour - 0) & 0x1F) << 11) | \ 156 (((mday - 0) & 0x1F) << 16) | \ 157 (((mon - 0) & 0x0F) << 21) | \ 158 (((year - 1980) & 0x7F) << 25)) 159 160 #define FATFS_EVENT_SD_INSERTED 0x00010001 161 #define FATFS_EVENT_SD_REMOVED 0x00010002 162 163 /*---------------------------------------------------------------------------*/ 164 /* Declarations */ 165 166 typedef u32 FATFSFileHandle; 167 typedef u32 FATFSDirectoryHandle; 168 169 typedef struct FATFSFileInfo 170 { 171 char shortname[16]; 172 char longname[FATFS_PATH_MAX + 1]; 173 char padding[3]; 174 u32 length; 175 u32 dos_atime; 176 u32 dos_mtime; 177 u32 dos_ctime; 178 u32 attributes; 179 } 180 FATFSFileInfo; 181 182 typedef struct FATFSDiskInfo 183 { 184 u32 n_user_files; 185 u32 n_hidden_files; 186 u32 n_user_directories; 187 u32 n_free_clusters; 188 u32 n_bad_clusters; 189 u32 n_file_clusters; 190 u32 n_hidden_clusters; 191 u32 n_dir_clusters; 192 u32 n_crossed_points; 193 u32 n_lost_chains; 194 u32 n_lost_clusters; 195 u32 n_bad_lfns; 196 } 197 FATFSDiskInfo; 198 199 typedef struct FATFSDriveResource 200 { 201 u64 totalSize; 202 u64 availableSize; 203 u32 maxFileHandles; 204 u32 currentFileHandles; 205 u32 maxDirectoryHandles; 206 u32 currentDirectoryHandles; 207 // for FAT archives 208 u32 bytesPerSector; 209 u32 sectorsPerCluster; 210 u32 totalClusters; 211 u32 availableClusters; 212 u32 fatBits; 213 } 214 FATFSDriveResource; 215 216 typedef struct FATFSCommandHeader 217 { 218 FATFSCommandID command; 219 FATFSResult result; 220 u32 flags; 221 struct FATFSCommandHeader *next; 222 } 223 FATFSCommandHeader; 224 225 typedef struct FATFSCommandMountDrive 226 { 227 FATFSCommandHeader header; 228 FATFSMediaType media; 229 int partition; 230 char name[FATFS_DRIVE_NAME_MAX + 1]; 231 } 232 FATFSCommandMountDrive; 233 234 typedef struct FATFSCommandUnmountDrive 235 { 236 FATFSCommandHeader header; 237 char name[FATFS_DRIVE_NAME_MAX + 1]; 238 } 239 FATFSCommandUnmountDrive; 240 241 typedef struct FATFSCommandFormatDrive 242 { 243 FATFSCommandHeader header; 244 char name[FATFS_DRIVE_NAME_MAX + 1]; 245 u32 formatMedia; 246 } 247 FATFSCommandFormatDrive; 248 249 typedef struct FATFSCommandCheckDisk 250 { 251 FATFSCommandHeader header; 252 char name[FATFS_DRIVE_NAME_MAX + 1]; 253 u32 verbose; 254 u32 fix_problems; 255 u32 write_chains; 256 FATFSDiskInfo info; 257 } 258 FATFSCommandCheckDisk; 259 260 typedef struct FATFSCommandGetDriveResource 261 { 262 FATFSCommandHeader header; 263 char name[FATFS_DRIVE_NAME_MAX + 1]; 264 FATFSDriveResource resource[1]; 265 } 266 FATFSCommandGetDriveResource; 267 268 typedef struct FATFSCommandSetDefaultDrive 269 { 270 FATFSCommandHeader header; 271 char name[FATFS_DRIVE_NAME_MAX + 1]; 272 } 273 FATFSCommandSetDefaultDrive; 274 275 typedef struct FATFSCommandGetFileInfo 276 { 277 FATFSCommandHeader header; 278 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 279 u8 padding[2]; 280 FATFSFileInfo info; 281 } 282 FATFSCommandGetFileInfo; 283 284 typedef struct FATFSCommandSetFileInfo 285 { 286 FATFSCommandHeader header; 287 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 288 u8 padding[2]; 289 FATFSFileInfo info; 290 } 291 FATFSCommandSetFileInfo; 292 293 typedef struct FATFSCommandCreateFile 294 { 295 FATFSCommandHeader header; 296 BOOL trunc; 297 char permit[FATFS_PERMIT_STRING_MAX + 1]; 298 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 299 u8 padding[2]; 300 } 301 FATFSCommandCreateFile; 302 303 typedef struct FATFSCommandDeleteFile 304 { 305 FATFSCommandHeader header; 306 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 307 u8 padding[2]; 308 } 309 FATFSCommandDeleteFile; 310 311 typedef struct FATFSCommandRenameFile 312 { 313 FATFSCommandHeader header; 314 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 315 char newpath[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 316 u8 padding[4]; 317 } 318 FATFSCommandRenameFile; 319 320 typedef struct FATFSCommandCreateDirectory 321 { 322 FATFSCommandHeader header; 323 char permit[FATFS_PERMIT_STRING_MAX + 1]; 324 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 325 u8 padding[2]; 326 } 327 FATFSCommandCreateDirectory; 328 329 typedef struct FATFSCommandDeleteDirectory 330 { 331 FATFSCommandHeader header; 332 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 333 u8 padding[2]; 334 } 335 FATFSCommandDeleteDirectory; 336 337 typedef struct FATFSCommandRenameDirectory 338 { 339 FATFSCommandHeader header; 340 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 341 char newpath[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 342 u8 padding[4]; 343 } 344 FATFSCommandRenameDirectory; 345 346 typedef struct FATFSCommandOpenFile 347 { 348 FATFSCommandHeader header; 349 FATFSFileHandle handle; 350 char mode[FATFS_ACCESSMODE_STRING_MAX + 1]; 351 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 352 u8 padding[2]; 353 } 354 FATFSCommandOpenFile; 355 356 typedef struct FATFSCommandCloseFile 357 { 358 FATFSCommandHeader header; 359 FATFSFileHandle handle; 360 } 361 FATFSCommandCloseFile; 362 363 typedef struct FATFSCommandReadFile 364 { 365 FATFSCommandHeader header; 366 FATFSFileHandle handle; 367 void *buffer; 368 int length; 369 } 370 FATFSCommandReadFile; 371 372 typedef struct FATFSCommandWriteFile 373 { 374 FATFSCommandHeader header; 375 FATFSFileHandle handle; 376 const void *buffer; 377 int length; 378 } 379 FATFSCommandWriteFile; 380 381 typedef struct FATFSCommandSetSeekCache 382 { 383 FATFSCommandHeader header; 384 FATFSFileHandle handle; 385 void *buf; 386 u32 buf_size; 387 } 388 FATFSCommandSetSeekCache; 389 390 typedef struct FATFSCommandSeekFile 391 { 392 FATFSCommandHeader header; 393 FATFSFileHandle handle; 394 int offset; 395 FATFSSeekMode origin; 396 } 397 FATFSCommandSeekFile; 398 399 typedef struct FATFSCommandFlushFile 400 { 401 FATFSCommandHeader header; 402 FATFSFileHandle handle; 403 } 404 FATFSCommandFlushFile; 405 406 typedef struct FATFSCommandGetFileLength 407 { 408 FATFSCommandHeader header; 409 FATFSFileHandle handle; 410 u32 length; 411 } 412 FATFSCommandGetFileLength; 413 414 typedef struct FATFSCommandSetFileLength 415 { 416 FATFSCommandHeader header; 417 FATFSFileHandle handle; 418 u32 length; 419 } 420 FATFSCommandSetFileLength; 421 422 typedef struct FATFSCommandOpenDirectory 423 { 424 FATFSCommandHeader header; 425 FATFSDirectoryHandle handle; 426 char mode[FATFS_ACCESSMODE_STRING_MAX + 1]; 427 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 428 u8 padding[2]; 429 } 430 FATFSCommandOpenDirectory; 431 432 typedef struct FATFSCommandCloseDirectory 433 { 434 FATFSCommandHeader header; 435 FATFSDirectoryHandle handle; 436 } 437 FATFSCommandCloseDirectory; 438 439 typedef struct FATFSCommandReadDirectory 440 { 441 FATFSCommandHeader header; 442 FATFSDirectoryHandle handle; 443 FATFSFileInfo info; 444 } 445 FATFSCommandReadDirectory; 446 447 typedef struct FATFSCommandFlushAll 448 { 449 FATFSCommandHeader header; 450 } 451 FATFSCommandFlushAll; 452 453 typedef struct FATFSCommandUnmountAll 454 { 455 FATFSCommandHeader header; 456 } 457 FATFSCommandUnmountAll; 458 459 typedef struct FATFSCommandMountSpecial 460 { 461 FATFSCommandHeader header; 462 u64 param; 463 int slot; 464 char arcname[OS_MOUNT_ARCHIVE_NAME_LEN]; 465 } 466 FATFSCommandMountSpecial; 467 468 typedef struct FATFSCommandSetNdmaParameters 469 { 470 FATFSCommandHeader header; 471 u32 ndmaNo; 472 u32 blockWord; 473 u32 intervalTimer; 474 u32 prescaler; 475 } 476 FATFSCommandSetNdmaParameters; 477 478 typedef struct FATFSCommandFormatSpecial 479 { 480 FATFSCommandHeader header; 481 char path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 482 u8 padding[6]; 483 u64 data; 484 } 485 FATFSCommandFormatSpecial; 486 487 typedef struct FATFSCommandSetLatencyEmulation 488 { 489 FATFSCommandHeader header; 490 u32 enable; 491 } 492 FATFSCommandSetLatencyEmulation; 493 494 typedef struct FATFSCommandSearchWildcard 495 { 496 FATFSCommandHeader header; 497 char directory[FATFS_SHORTNAME_FILENAME_MAX + 1]; 498 char prefix[FATFS_SHORTNAME_PREFIX_MAX + 1]; 499 char suffix[FATFS_SHORTNAME_SUFFIX_MAX + 1]; 500 u8 buffer[10000 / 8 + 1]; 501 u8 padding[2]; 502 } 503 FATFSCommandSearchWildcard; 504 505 506 SDK_COMPILER_ASSERT(sizeof(FATFSCommandHeader) <= FATFS_COMMAND_BUFFER_SIZE); 507 SDK_COMPILER_ASSERT(sizeof(FATFSCommandMountDrive) <= FATFS_COMMAND_BUFFER_SIZE); 508 SDK_COMPILER_ASSERT(sizeof(FATFSCommandUnmountDrive) <= FATFS_COMMAND_BUFFER_SIZE); 509 SDK_COMPILER_ASSERT(sizeof(FATFSCommandSetDefaultDrive) <= FATFS_COMMAND_BUFFER_SIZE); 510 SDK_COMPILER_ASSERT(sizeof(FATFSCommandFormatDrive) <= FATFS_COMMAND_BUFFER_SIZE); 511 SDK_COMPILER_ASSERT(sizeof(FATFSCommandCheckDisk) <= FATFS_COMMAND_BUFFER_SIZE); 512 SDK_COMPILER_ASSERT(sizeof(FATFSCommandGetDriveResource) <= FATFS_COMMAND_BUFFER_SIZE); 513 SDK_COMPILER_ASSERT(sizeof(FATFSCommandGetFileInfo) <= FATFS_COMMAND_BUFFER_SIZE); 514 SDK_COMPILER_ASSERT(sizeof(FATFSCommandCreateFile) <= FATFS_COMMAND_BUFFER_SIZE); 515 SDK_COMPILER_ASSERT(sizeof(FATFSCommandDeleteFile) <= FATFS_COMMAND_BUFFER_SIZE); 516 SDK_COMPILER_ASSERT(sizeof(FATFSCommandRenameFile) <= FATFS_COMMAND_BUFFER_SIZE); 517 518 SDK_COMPILER_ASSERT(sizeof(FATFSCommandOpenFile) <= FATFS_COMMAND_BUFFER_SIZE); 519 SDK_COMPILER_ASSERT(sizeof(FATFSCommandCloseFile) <= FATFS_COMMAND_BUFFER_SIZE); 520 SDK_COMPILER_ASSERT(sizeof(FATFSCommandReadFile) <= FATFS_COMMAND_BUFFER_SIZE); 521 SDK_COMPILER_ASSERT(sizeof(FATFSCommandWriteFile) <= FATFS_COMMAND_BUFFER_SIZE); 522 SDK_COMPILER_ASSERT(sizeof(FATFSCommandSeekFile) <= FATFS_COMMAND_BUFFER_SIZE); 523 SDK_COMPILER_ASSERT(sizeof(FATFSCommandFlushFile) <= FATFS_COMMAND_BUFFER_SIZE); 524 SDK_COMPILER_ASSERT(sizeof(FATFSCommandGetFileLength) <= FATFS_COMMAND_BUFFER_SIZE); 525 SDK_COMPILER_ASSERT(sizeof(FATFSCommandSetFileLength) <= FATFS_COMMAND_BUFFER_SIZE); 526 527 SDK_COMPILER_ASSERT(sizeof(FATFSCommandOpenDirectory) <= FATFS_COMMAND_BUFFER_SIZE); 528 SDK_COMPILER_ASSERT(sizeof(FATFSCommandCloseDirectory) <= FATFS_COMMAND_BUFFER_SIZE); 529 SDK_COMPILER_ASSERT(sizeof(FATFSCommandReadDirectory) <= FATFS_COMMAND_BUFFER_SIZE); 530 531 SDK_COMPILER_ASSERT(sizeof(FATFSCommandFlushAll) <= FATFS_COMMAND_BUFFER_SIZE); 532 SDK_COMPILER_ASSERT(sizeof(FATFSCommandUnmountAll) <= FATFS_COMMAND_BUFFER_SIZE); 533 SDK_COMPILER_ASSERT(sizeof(FATFSCommandMountSpecial) <= FATFS_COMMAND_BUFFER_SIZE); 534 SDK_COMPILER_ASSERT(sizeof(FATFSCommandSetNdmaParameters) <= FATFS_COMMAND_BUFFER_SIZE); 535 SDK_COMPILER_ASSERT(sizeof(FATFSCommandFormatSpecial) <= FATFS_COMMAND_BUFFER_SIZE); 536 SDK_COMPILER_ASSERT(sizeof(FATFSCommandSetLatencyEmulation) <= FATFS_COMMAND_BUFFER_SIZE); 537 SDK_COMPILER_ASSERT(sizeof(FATFSCommandSearchWildcard) <= FATFS_COMMAND_BUFFER_SIZE); 538 539 540 typedef struct FATFSRequestBuffer 541 { 542 union 543 { 544 FATFSCommandHeader header; 545 u8 buffer[FATFS_COMMAND_BUFFER_SIZE]; 546 }; 547 OSThread *thread; 548 void (*callback)(struct FATFSRequestBuffer *); 549 void *userdata; 550 struct FATFSRequestBuffer *next; 551 u8 padding[16]; 552 } 553 FATFSRequestBuffer ATTRIBUTE_ALIGN(32); 554 555 typedef struct FATFSResultBuffer 556 { 557 struct FATFSResultBuffer *next; 558 OSThread *thread; 559 FATFSCommandHeader *command; 560 u32 result; 561 u8 reserved[16]; 562 } 563 FATFSResultBuffer; 564 565 566 /*---------------------------------------------------------------------------* 567 * Versions with Unicode support 568 *---------------------------------------------------------------------------*/ 569 570 typedef struct FATFSFileInfoW 571 { 572 char shortname[16]; 573 u16 longname[FATFS_PATH_MAX + 1]; 574 u16 padding; 575 u32 length; 576 u32 dos_atime; 577 u32 dos_mtime; 578 u32 dos_ctime; 579 u32 attributes; 580 } 581 FATFSFileInfoW; 582 583 SDK_COMPILER_ASSERT(sizeof(FATFSFileInfoW) <= FATFS_COMMAND_BUFFER_SIZE); 584 585 typedef struct FATFSCommandGetFileInfoW 586 { 587 FATFSCommandHeader header; 588 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 589 u16 padding[2]; 590 FATFSFileInfoW info; 591 } 592 FATFSCommandGetFileInfoW; 593 594 typedef struct FATFSCommandSetFileInfoW 595 { 596 FATFSCommandHeader header; 597 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 598 u16 padding[2]; 599 FATFSFileInfoW info; 600 } 601 FATFSCommandSetFileInfoW; 602 603 typedef struct FATFSCommandCreateFileW 604 { 605 FATFSCommandHeader header; 606 BOOL trunc; 607 char permit[FATFS_PERMIT_STRING_MAX + 1]; 608 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 609 u16 padding[2]; 610 } 611 FATFSCommandCreateFileW; 612 613 typedef struct FATFSCommandDeleteFileW 614 { 615 FATFSCommandHeader header; 616 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 617 u16 padding[2]; 618 } 619 FATFSCommandDeleteFileW; 620 621 typedef struct FATFSCommandRenameFileW 622 { 623 FATFSCommandHeader header; 624 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 625 u16 newpath[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 626 } 627 FATFSCommandRenameFileW; 628 629 typedef struct FATFSCommandCreateDirectoryW 630 { 631 FATFSCommandHeader header; 632 char permit[FATFS_PERMIT_STRING_MAX + 1]; 633 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 634 u16 padding[2]; 635 } 636 FATFSCommandCreateDirectoryW; 637 638 typedef struct FATFSCommandDeleteDirectoryW 639 { 640 FATFSCommandHeader header; 641 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 642 u16 padding[2]; 643 } 644 FATFSCommandDeleteDirectoryW; 645 646 typedef struct FATFSCommandRenameDirectoryW 647 { 648 FATFSCommandHeader header; 649 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 650 u16 newpath[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 651 } 652 FATFSCommandRenameDirectoryW; 653 654 typedef struct FATFSCommandOpenFileW 655 { 656 FATFSCommandHeader header; 657 FATFSFileHandle handle; 658 char mode[FATFS_ACCESSMODE_STRING_MAX + 1]; 659 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 660 u16 padding[2]; 661 } 662 FATFSCommandOpenFileW; 663 664 typedef struct FATFSCommandOpenDirectoryW 665 { 666 FATFSCommandHeader header; 667 FATFSDirectoryHandle handle; 668 char mode[FATFS_ACCESSMODE_STRING_MAX + 1]; 669 u16 path[FATFS_ARCHIVE_FULLPATH_MAX + 1]; 670 u16 padding[2]; 671 } 672 FATFSCommandOpenDirectoryW; 673 674 typedef struct FATFSCommandReadDirectoryW 675 { 676 FATFSCommandHeader header; 677 FATFSDirectoryHandle handle; 678 FATFSFileInfoW info; 679 } 680 FATFSCommandReadDirectoryW; 681 682 683 SDK_COMPILER_ASSERT(sizeof(FATFSCommandGetFileInfoW) <= FATFS_COMMAND_BUFFER_SIZE); 684 SDK_COMPILER_ASSERT(sizeof(FATFSCommandSetFileInfoW) <= FATFS_COMMAND_BUFFER_SIZE); 685 SDK_COMPILER_ASSERT(sizeof(FATFSCommandCreateFileW) <= FATFS_COMMAND_BUFFER_SIZE); 686 SDK_COMPILER_ASSERT(sizeof(FATFSCommandDeleteFileW) <= FATFS_COMMAND_BUFFER_SIZE); 687 SDK_COMPILER_ASSERT(sizeof(FATFSCommandRenameFileW) <= FATFS_COMMAND_BUFFER_SIZE); 688 SDK_COMPILER_ASSERT(sizeof(FATFSCommandCreateDirectoryW) <= FATFS_COMMAND_BUFFER_SIZE); 689 SDK_COMPILER_ASSERT(sizeof(FATFSCommandDeleteDirectoryW) <= FATFS_COMMAND_BUFFER_SIZE); 690 SDK_COMPILER_ASSERT(sizeof(FATFSCommandRenameDirectoryW) <= FATFS_COMMAND_BUFFER_SIZE); 691 SDK_COMPILER_ASSERT(sizeof(FATFSCommandOpenFileW) <= FATFS_COMMAND_BUFFER_SIZE); 692 SDK_COMPILER_ASSERT(sizeof(FATFSCommandOpenDirectoryW) <= FATFS_COMMAND_BUFFER_SIZE); 693 SDK_COMPILER_ASSERT(sizeof(FATFSCommandReadDirectoryW) <= FATFS_COMMAND_BUFFER_SIZE); 694 695 696 #ifdef __cplusplus 697 } /* extern "C" */ 698 #endif 699 700 /* NITRO_FATFS_TYPES_H_ */ 701 #endif 702