|
KallistiOS
##version##
|
|
KallistiOS
##version##
|
Block-level access to an SD card attached to the SCIF port. More...
Go to the source code of this file.
Functions | |
| uint8 | sd_crc7 (const uint8 *data, int size, uint8 crc) |
| Calculate a SD/MMC-style CRC over a block of data. More... | |
| int | sd_init (void) |
| Initialize the SD card for use. More... | |
| int | sd_shutdown (void) |
| Shut down SD card support. More... | |
| int | sd_read_blocks (uint32 block, size_t count, uint8 *buf) |
| Read one or more blocks from the SD card. More... | |
| int | sd_write_blocks (uint32 block, size_t count, const uint8 *buf) |
| Write one or more blocks to the SD card. More... | |
| uint64 | sd_get_size (void) |
| Retrieve the size of the SD card. More... | |
| int | sd_blockdev_for_partition (int partition, kos_blockdev_t *rv, uint8 *partition_type) |
| Get a block device for a given partition on the SD card. More... | |
Block-level access to an SD card attached to the SCIF port.
This file contains the interface to working with the SD card reader that was designed by jj1odm. The SD card reader itself connects to the SCIF port and uses it basically as a simple SPI bus.
For reference, all I/O through this code should be done in the order of SD card blocks (which are 512 bytes a piece). Also, this should adequately support SD and SDHC cards (and possibly SDXC, but I don't have any of them to try out).
This code doesn't directly implement any filesystems on top of the SD card, but rather provides you with direct block-level access. This probably will not be useful to most people in its current form (without a filesystem), but this will provide you with all of the building blocks you should need to actually make it work for you.
Due to the patent-encumbered nature of certain parts of the FAT32 filesystem, that filesystem will likely never be supported in KOS proper (unless, of course, people are still using KOS after those patents expire). I'm not going to encourage anyone to violate Microsoft's patents on FAT32 and I'm not going to be the enabler for anyone to do so either. So, if you want FAT32, you're on your own.
| int sd_blockdev_for_partition | ( | int | partition, |
| kos_blockdev_t * | rv, | ||
| uint8 * | partition_type | ||
| ) |
Get a block device for a given partition on the SD card.
This function creates a block device descriptor for the given partition on the attached SD card. This block device is used to interface with various filesystems on the device.
| partition | The partition number (0-3) to use. |
| rv | Used to return the block device. Must be non-NULL. |
| partition_type | Used to return the partition type. Must be non-NULL. |
| 0 | On success. |
| -1 | On error, errno will be set as appropriate. |
Calculate a SD/MMC-style CRC over a block of data.
This function calculates a 7-bit CRC over a given block of data. The polynomial of this CRC is x^7 + x^3 + 1. The CRC is shifted into the upper 7 bits of the return value, so bit 0 should always be 0.
| data | The block of data to calculate the CRC over. |
| size | The number of bytes in the block of data. |
| crc | The starting value of the calculation. If you're passing in a full block, this will probably be 0. |
| uint64 sd_get_size | ( | void | ) |
Retrieve the size of the SD card.
This function reads the size of the SD card from the card's CSD register. This is the raw size of the card, not its formatted capacity. To get the number of blocks from this, divide by 512.
| int sd_init | ( | void | ) |
Initialize the SD card for use.
This function initializes the SD card for first use. This includes all steps of the basic initialization sequence for SPI mode, as documented in the SD card spec and at http://elm-chan.org/docs/mmc/mmc_e.html . This also will call scif_sd_init() for you, so you don't have to worry about that ahead of time.
| 0 | On success. |
| -1 | On failure. This could indicate any number of problems, but probably means that no SD card was detected. |
Read one or more blocks from the SD card.
This function reads the specified number of blocks from the SD card from the beginning block specified into the buffer passed in. It is your responsibility to allocate the buffer properly for the number of bytes that is to be read (512 * the number of blocks requested).
| block | The starting block number to read from. |
| count | The number of 512 byte blocks of data to read. |
| buf | The buffer to read into. |
| 0 | On success. |
| -1 | On error, errno will be set as appropriate. |
| int sd_shutdown | ( | void | ) |
Shut down SD card support.
This function shuts down SD card support, and cleans up anything that the sd_init() function set up.
| 0 | On success. |
| -1 | On failure. The only currently defined error is if the card was never initialized to start with. |
Write one or more blocks to the SD card.
This function writes the specified number of blocks to the SD card at the beginning block specified from the buffer passed in. Each block is 512 bytes in length, and you must write at least one block at a time. You cannot write partial blocks.
If this function returns an error, you have quite possibly corrupted something on the card or have a damaged card in general (unless errno is ENXIO).
| block | The starting block number to write to. |
| count | The number of 512 byte blocks of data to write. |
| buf | The buffer to write from. |
| 0 | On success. |
| -1 | On error, errno will be set as appropriate. |
1.8.7
