Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
cc2642c124
haiku/headers/private/drivers/mmc.h

88 lines
2.1 KiB
C
Raw Normal View History

sdhci and mmc implementation sdhci: - Add semaphore for interrupt management - Add basic operations (setting clock, executing a command) - Add early initialization (clocks and power up) - Wrap the bus in a C++ class to ease usage - Expose API to MMC bus manager - TODO: manage card insertion and removal interrupts - TODO: use MSI when available mmc_bus: - Implements SD card management independant of the way we access the bus (later on different drivers can provide the same API as SDHCI) - Worker thread to do the initialization - Implement card initialization process up until getting an RCA from the card. This is the generic part to assign an ID to the card, after this point commands can be targetted at the specific card so it can be handed over to the mmc_disk driver. - TODO: initialization for non-SDHC cards which do not reply to CMD8. Change-Id: I71950ca3ce206378a68fa7f97c19f638183d6cdd Reviewed-on: https://review.haiku-os.org/c/1032 Reviewed-by: waddlesplash <waddlesplash@gmail.com>
2019-02-11 00:39:02 +03:00
/*
Initial work for the mmc_disk driver No read and write support for now. But we implement getting SD card capacity. SDHC is not supported yet (it uses a different layout for the CSD register which will be rejected by this version of the code) Change-Id: Ife844a62f3846c0a780259e9a3a08195e2fd965e Reviewed-on: https://review.haiku-os.org/c/haiku/+/1068 Reviewed-by: Jérôme Duval <jerome.duval@gmail.com>
2019-02-19 22:12:08 +03:00
* Copyright 2019-2020, Haiku, Inc. All Rights Reserved.
sdhci and mmc implementation sdhci: - Add semaphore for interrupt management - Add basic operations (setting clock, executing a command) - Add early initialization (clocks and power up) - Wrap the bus in a C++ class to ease usage - Expose API to MMC bus manager - TODO: manage card insertion and removal interrupts - TODO: use MSI when available mmc_bus: - Implements SD card management independant of the way we access the bus (later on different drivers can provide the same API as SDHCI) - Worker thread to do the initialization - Implement card initialization process up until getting an RCA from the card. This is the generic part to assign an ID to the card, after this point commands can be targetted at the specific card so it can be handed over to the mmc_disk driver. - TODO: initialization for non-SDHC cards which do not reply to CMD8. Change-Id: I71950ca3ce206378a68fa7f97c19f638183d6cdd Reviewed-on: https://review.haiku-os.org/c/1032 Reviewed-by: waddlesplash <waddlesplash@gmail.com>
2019-02-11 00:39:02 +03:00
* Distributed under the terms of the MIT License.
*
* Authors:
* Adrien Destugues, pulkomandy@pulkomandy.tk
*/
#ifndef _MMC_H
#define _MMC_H
#include <device_manager.h>
sdhci/mmc: add to the image. Change-Id: Ic43965efea2c62b6e731c7552e4f27d6d20fc26b Reviewed-on: https://review.haiku-os.org/c/haiku/+/448 Reviewed-by: Stephan Aßmus <superstippi@gmx.de>
2018-12-23 13:31:48 +03:00
#define MMC_BUS_MODULE_NAME "bus_managers/mmc/driver_v1"
sdhci and mmc implementation sdhci: - Add semaphore for interrupt management - Add basic operations (setting clock, executing a command) - Add early initialization (clocks and power up) - Wrap the bus in a C++ class to ease usage - Expose API to MMC bus manager - TODO: manage card insertion and removal interrupts - TODO: use MSI when available mmc_bus: - Implements SD card management independant of the way we access the bus (later on different drivers can provide the same API as SDHCI) - Worker thread to do the initialization - Implement card initialization process up until getting an RCA from the card. This is the generic part to assign an ID to the card, after this point commands can be targetted at the specific card so it can be handed over to the mmc_disk driver. - TODO: initialization for non-SDHC cards which do not reply to CMD8. Change-Id: I71950ca3ce206378a68fa7f97c19f638183d6cdd Reviewed-on: https://review.haiku-os.org/c/1032 Reviewed-by: waddlesplash <waddlesplash@gmail.com>
2019-02-11 00:39:02 +03:00
mmc: register devices for detected cards Change-Id: I90891ead9a425e0e8bd25c2190fe3d430d49411b Reviewed-on: https://review.haiku-os.org/c/haiku/+/1067 Reviewed-by: waddlesplash <waddlesplash@gmail.com>
2019-02-17 13:54:12 +03:00
enum {
CARD_TYPE_MMC,
CARD_TYPE_SD,
CARD_TYPE_SDHC,
CARD_TYPE_UHS1,
CARD_TYPE_UHS2,
CARD_TYPE_SDIO
};
sd/mmc: read, naive method First implementation of reading sectors from an SD card. This is not the best performance for many reasons: - No DMA - Reads only one sector at a time - Cannot read more than 512 bytes per syscall Also there are major limitations: - Cannot read less than 512 bytes. The hardware of course works in full sectors. The mmc_disk driver should go through the io scheduler to make sure requests have a reasonable size and offset, and nothing tries to read just a few bytes in the middle of a sector. - SD cards only (no SDHC, no MMC) Architecture problems: I think too much of the implementation is done in sdhci_pci and should be moved to the upper layers. However it is difficult to say without having implemented DMA (which indeed will be at the low level of the sdhci controller). It doesn't help that the order of operations is a bit different depending on wether there is DMA or not. In DMA mode you first prepare the buffer, then run the command. In non-DMA mode you first send the command, then read the data into the buffer. We need an API at the mmc_bus level that doesn't care about that low-level detail. There are other things that the MMC bus should be doing however, such as switching to different clock speeds depending on which card is activated and how fast it can go. At least the following should be done: - The read method for mmc_bus and sdhci_pci should use a scatter-gather structure as a parameter instead of a single buffer - See if can be integrated into ExecuteCommand at sdhci level (it's essentially a command with an additional data phase) Change-Id: I688b6c694561074535c9c0c2545f06dc04b06e7d Reviewed-on: https://review.haiku-os.org/c/haiku/+/3466 Reviewed-by: Jérôme Duval <jerome.duval@gmail.com>
2020-10-14 16:10:01 +03:00
// Commands for SD cards defined in SD Specifications Part 1:
// Physical Layer Simplified Specification Version 8.00
// They are in the common .h file for the mmc stack because the SDHCI driver
// currently needs to map them to the corresponding expected response types.
enum SD_COMMANDS {
// Basic commands, class 0
SD_GO_IDLE_STATE = 0,
SD_ALL_SEND_CID = 2,
SD_SEND_RELATIVE_ADDR = 3,
SD_SELECT_DESELECT_CARD = 7,
SD_SEND_IF_COND = 8,
SD_SEND_CSD = 9,
SD_STOP_TRANSMISSION = 12,
// Block oriented read commands, class 2
SD_READ_SINGLE_BLOCK = 17,
SD_READ_MULTIPLE_BLOCKS = 18,
// Application specific commands, class 8
SD_APP_CMD = 55,
// I/O mode commands, class 9
SD_IO_ABORT = 52,
};
enum SDHCI_APPLICATION_COMMANDS {
SD_SEND_OP_COND = 41,
};
Initial work for the mmc_disk driver No read and write support for now. But we implement getting SD card capacity. SDHC is not supported yet (it uses a different layout for the CSD register which will be rejected by this version of the code) Change-Id: Ife844a62f3846c0a780259e9a3a08195e2fd965e Reviewed-on: https://review.haiku-os.org/c/haiku/+/1068 Reviewed-by: Jérôme Duval <jerome.duval@gmail.com>
2019-02-19 22:12:08 +03:00
// Interface between mmc_bus and underlying implementation (sdhci_pci or any
// other thing that can execute mmc commands)
sdhci and mmc implementation sdhci: - Add semaphore for interrupt management - Add basic operations (setting clock, executing a command) - Add early initialization (clocks and power up) - Wrap the bus in a C++ class to ease usage - Expose API to MMC bus manager - TODO: manage card insertion and removal interrupts - TODO: use MSI when available mmc_bus: - Implements SD card management independant of the way we access the bus (later on different drivers can provide the same API as SDHCI) - Worker thread to do the initialization - Implement card initialization process up until getting an RCA from the card. This is the generic part to assign an ID to the card, after this point commands can be targetted at the specific card so it can be handed over to the mmc_disk driver. - TODO: initialization for non-SDHC cards which do not reply to CMD8. Change-Id: I71950ca3ce206378a68fa7f97c19f638183d6cdd Reviewed-on: https://review.haiku-os.org/c/1032 Reviewed-by: waddlesplash <waddlesplash@gmail.com>
2019-02-11 00:39:02 +03:00
typedef struct mmc_bus_interface {
driver_module_info info;
status_t (*set_clock)(void* controller, uint32_t kilohertz);
status_t (*execute_command)(void* controller, uint8_t command,
uint32_t argument, uint32_t* result);
sd/mmc: read, naive method First implementation of reading sectors from an SD card. This is not the best performance for many reasons: - No DMA - Reads only one sector at a time - Cannot read more than 512 bytes per syscall Also there are major limitations: - Cannot read less than 512 bytes. The hardware of course works in full sectors. The mmc_disk driver should go through the io scheduler to make sure requests have a reasonable size and offset, and nothing tries to read just a few bytes in the middle of a sector. - SD cards only (no SDHC, no MMC) Architecture problems: I think too much of the implementation is done in sdhci_pci and should be moved to the upper layers. However it is difficult to say without having implemented DMA (which indeed will be at the low level of the sdhci controller). It doesn't help that the order of operations is a bit different depending on wether there is DMA or not. In DMA mode you first prepare the buffer, then run the command. In non-DMA mode you first send the command, then read the data into the buffer. We need an API at the mmc_bus level that doesn't care about that low-level detail. There are other things that the MMC bus should be doing however, such as switching to different clock speeds depending on which card is activated and how fast it can go. At least the following should be done: - The read method for mmc_bus and sdhci_pci should use a scatter-gather structure as a parameter instead of a single buffer - See if can be integrated into ExecuteCommand at sdhci level (it's essentially a command with an additional data phase) Change-Id: I688b6c694561074535c9c0c2545f06dc04b06e7d Reviewed-on: https://review.haiku-os.org/c/haiku/+/3466 Reviewed-by: Jérôme Duval <jerome.duval@gmail.com>
2020-10-14 16:10:01 +03:00
status_t (*read_naive)(void* controller, off_t pos,
void* buffer, size_t* _length);
sdhci and mmc implementation sdhci: - Add semaphore for interrupt management - Add basic operations (setting clock, executing a command) - Add early initialization (clocks and power up) - Wrap the bus in a C++ class to ease usage - Expose API to MMC bus manager - TODO: manage card insertion and removal interrupts - TODO: use MSI when available mmc_bus: - Implements SD card management independant of the way we access the bus (later on different drivers can provide the same API as SDHCI) - Worker thread to do the initialization - Implement card initialization process up until getting an RCA from the card. This is the generic part to assign an ID to the card, after this point commands can be targetted at the specific card so it can be handed over to the mmc_disk driver. - TODO: initialization for non-SDHC cards which do not reply to CMD8. Change-Id: I71950ca3ce206378a68fa7f97c19f638183d6cdd Reviewed-on: https://review.haiku-os.org/c/1032 Reviewed-by: waddlesplash <waddlesplash@gmail.com>
2019-02-11 00:39:02 +03:00
} mmc_bus_interface;
mmc_bus: add execute_command function For now it just forwards the command to the SDHCI controller. The bus will gain more features and functions as work advances (tracking which card is active, arbitration of DMA transfers, etc). Change-Id: I094eb84f27e7789387a3f8fb65fba1e5fcfa3e8a Reviewed-on: https://review.haiku-os.org/c/haiku/+/3094 Reviewed-by: waddlesplash <waddlesplash@gmail.com>
2020-07-26 14:49:20 +03:00
// Interface between mmc device driver (mmc_disk, sdio drivers, ...) and mmc_bus
typedef struct mmc_device_interface {
driver_module_info info;
status_t (*execute_command)(device_node* node, uint8_t command,
uint32_t argument, uint32_t* result);
sd/mmc: read, naive method First implementation of reading sectors from an SD card. This is not the best performance for many reasons: - No DMA - Reads only one sector at a time - Cannot read more than 512 bytes per syscall Also there are major limitations: - Cannot read less than 512 bytes. The hardware of course works in full sectors. The mmc_disk driver should go through the io scheduler to make sure requests have a reasonable size and offset, and nothing tries to read just a few bytes in the middle of a sector. - SD cards only (no SDHC, no MMC) Architecture problems: I think too much of the implementation is done in sdhci_pci and should be moved to the upper layers. However it is difficult to say without having implemented DMA (which indeed will be at the low level of the sdhci controller). It doesn't help that the order of operations is a bit different depending on wether there is DMA or not. In DMA mode you first prepare the buffer, then run the command. In non-DMA mode you first send the command, then read the data into the buffer. We need an API at the mmc_bus level that doesn't care about that low-level detail. There are other things that the MMC bus should be doing however, such as switching to different clock speeds depending on which card is activated and how fast it can go. At least the following should be done: - The read method for mmc_bus and sdhci_pci should use a scatter-gather structure as a parameter instead of a single buffer - See if can be integrated into ExecuteCommand at sdhci level (it's essentially a command with an additional data phase) Change-Id: I688b6c694561074535c9c0c2545f06dc04b06e7d Reviewed-on: https://review.haiku-os.org/c/haiku/+/3466 Reviewed-by: Jérôme Duval <jerome.duval@gmail.com>
2020-10-14 16:10:01 +03:00
status_t (*read_naive)(device_node* controller, uint16_t rca, off_t pos,
void* buffer, size_t* _length);
mmc_bus: add execute_command function For now it just forwards the command to the SDHCI controller. The bus will gain more features and functions as work advances (tracking which card is active, arbitration of DMA transfers, etc). Change-Id: I094eb84f27e7789387a3f8fb65fba1e5fcfa3e8a Reviewed-on: https://review.haiku-os.org/c/haiku/+/3094 Reviewed-by: waddlesplash <waddlesplash@gmail.com>
2020-07-26 14:49:20 +03:00
} mmc_device_interface;
Initial work for the mmc_disk driver No read and write support for now. But we implement getting SD card capacity. SDHC is not supported yet (it uses a different layout for the CSD register which will be rejected by this version of the code) Change-Id: Ife844a62f3846c0a780259e9a3a08195e2fd965e Reviewed-on: https://review.haiku-os.org/c/haiku/+/1068 Reviewed-by: Jérôme Duval <jerome.duval@gmail.com>
2019-02-19 22:12:08 +03:00
// Device attribute paths for the MMC device
static const char* kMmcRcaAttribute = "mmc/rca";
static const char* kMmcTypeAttribute = "mmc/type";
sdhci and mmc implementation sdhci: - Add semaphore for interrupt management - Add basic operations (setting clock, executing a command) - Add early initialization (clocks and power up) - Wrap the bus in a C++ class to ease usage - Expose API to MMC bus manager - TODO: manage card insertion and removal interrupts - TODO: use MSI when available mmc_bus: - Implements SD card management independant of the way we access the bus (later on different drivers can provide the same API as SDHCI) - Worker thread to do the initialization - Implement card initialization process up until getting an RCA from the card. This is the generic part to assign an ID to the card, after this point commands can be targetted at the specific card so it can be handed over to the mmc_disk driver. - TODO: initialization for non-SDHC cards which do not reply to CMD8. Change-Id: I71950ca3ce206378a68fa7f97c19f638183d6cdd Reviewed-on: https://review.haiku-os.org/c/1032 Reviewed-by: waddlesplash <waddlesplash@gmail.com>
2019-02-11 00:39:02 +03:00
#endif /* _MMC_H */
Reference in New Issue Copy Permalink