haiku.git

/*
 * Copyright 2018-2025 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		B Krishnan Iyer, krishnaniyer97@gmail.com
 *		Adrien Destugues, pulkomandy@pulkomandy.tk
 *		Ron Ben Aroya, sed4906birdie@gmail.com
 */
#include <algorithm>
#include <new>
#include <stdio.h>
#include <string.h>

#include <bus/PCI.h>
#include <ACPI.h>
#include "acpi.h"

#include <KernelExport.h>

#include "IOSchedulerSimple.h"
#include "mmc.h"
#include "sdhci.h"


//#define TRACE_SDHCI
#ifdef TRACE_SDHCI
#	define TRACE(x...) dprintf("\33[33msdhci:\33[0m " x)
#else
#	define TRACE(x...) ;
#endif
#define TRACE_ALWAYS(x...)	dprintf("\33[33msdhci:\33[0m " x)
#define ERROR(x...)			dprintf("\33[33msdhci:\33[0m " x)
#define CALLED(x...)		TRACE("CALLED %s\n", __PRETTY_FUNCTION__)


#define SDHCI_DEVICE_MODULE_NAME "busses/mmc/sdhci/driver_v1"
#define SDHCI_ACPI_MMC_BUS_MODULE_NAME "busses/mmc/sdhci/acpi/device/v1"

static acpi_status
sdhci_acpi_scan_parse_callback(ACPI_RESOURCE *res, void *context)
{
	struct sdhci_crs* crs = (struct sdhci_crs*)context;

	if (res->Type == ACPI_RESOURCE_TYPE_FIXED_MEMORY32) {
		crs->addr_bas = res->Data.FixedMemory32.Address;
		crs->addr_len = res->Data.FixedMemory32.AddressLength;
	} else if (res->Type == ACPI_RESOURCE_TYPE_IRQ) {
		crs->irq = res->Data.Irq.Interrupt;
		//crs->irq_triggering = res->Data.Irq.Triggering;
		//crs->irq_polarity = res->Data.Irq.Polarity;
		//crs->irq_shareable = res->Data.Irq.Shareable;
	} else if (res->Type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ) {
		crs->irq = res->Data.ExtendedIrq.Interrupt;
		//crs->irq_triggering = res->Data.ExtendedIrq.Triggering;
		//crs->irq_polarity = res->Data.ExtendedIrq.Polarity;
		//crs->irq_shareable = res->Data.ExtendedIrq.Shareable;
	}

	return B_OK;
}

status_t
init_bus_acpi(device_node* node, void** bus_cookie)
{
	CALLED();

	// Get the ACPI driver and device
	acpi_device_module_info* acpi;
	acpi_device device;

	device_node* parent = gDeviceManager->get_parent_node(node);
	device_node* acpiParent = gDeviceManager->get_parent_node(parent);
	gDeviceManager->get_driver(acpiParent, (driver_module_info**)&acpi,
			(void**)&device);
	gDeviceManager->put_node(acpiParent);
	gDeviceManager->put_node(parent);

	// Ignore invalid bars
	TRACE("Register SD bus\n");

	struct sdhci_crs crs;
	if(acpi->walk_resources(device, (ACPI_STRING)"_CRS",
			sdhci_acpi_scan_parse_callback, &crs) != B_OK) {
		ERROR("Couldn't scan ACPI register set\n");
		return B_IO_ERROR;
	}

	TRACE("addr: %" B_PRIx32 " len: %" B_PRIx32 "\n", crs.addr_bas, crs.addr_len);

	if (crs.addr_bas == 0 || crs.addr_len == 0) {
		ERROR("No registers to map\n");
		return B_IO_ERROR;
	}

	// map the slot registers
	area_id	regs_area;
	struct registers* _regs;
	regs_area = map_physical_memory("sdhc_regs_map",
		crs.addr_bas, crs.addr_len, B_ANY_KERNEL_BLOCK_ADDRESS,
		B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA, (void**)&_regs);

	if (regs_area < B_OK) {
		ERROR("Could not map registers\n");
		return B_BAD_VALUE;
	}

	// the interrupt is shared between all busses in an SDHC controller, but
	// they each register an handler. Not a problem, we will just test the
	// interrupt registers for all busses one after the other and find no
	// interrupts on the idle busses.
	uint8_t irq = crs.irq;
	TRACE("irq interrupt line: %d\n", irq);

	SdhciBus* bus = new(std::nothrow) SdhciBus(_regs, irq, true);

	status_t status = B_NO_MEMORY;
	if (bus != NULL)
		status = bus->InitCheck();

	if (status != B_OK) {
		if (bus != NULL)
			delete bus;
		else
			delete_area(regs_area);
		return status;
	}

	// Store the created object as a cookie, allowing users of the bus to
	// locate it.
	*bus_cookie = bus;

	return status;
}

status_t
register_child_devices_acpi(void* cookie)
{
	CALLED();
	SdhciDevice* context = (SdhciDevice*)cookie;
	device_node* parent = gDeviceManager->get_parent_node(context->fNode);
	acpi_device_module_info* acpi;
	acpi_device* device;

	gDeviceManager->get_driver(parent, (driver_module_info**)&acpi,
		(void**)&device);

	TRACE("register_child_devices\n");

	char prettyName[25];

	sprintf(prettyName, "SDHC bus");
	device_attr attrs[] = {
		// properties of this controller for mmc bus manager
		{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = prettyName } },
		{ B_DEVICE_FIXED_CHILD, B_STRING_TYPE,
			{.string = MMC_BUS_MODULE_NAME} },
		{ B_DEVICE_BUS, B_STRING_TYPE, {.string = "mmc"} },

		// DMA properties
		// The high alignment is to force access only to complete sectors
		// These constraints could be removed by using ADMA which allows
		// use of the full 64bit address space and can do scatter-gather.
		{ B_DMA_ALIGNMENT, B_UINT32_TYPE, { .ui32 = 511 }},
		{ B_DMA_HIGH_ADDRESS, B_UINT64_TYPE, { .ui64 = 0x100000000LL }},
		{ B_DMA_BOUNDARY, B_UINT32_TYPE, { .ui32 = (1 << 19) - 1 }},
		{ B_DMA_MAX_SEGMENT_COUNT, B_UINT32_TYPE, { .ui32 = 1 }},
		{ B_DMA_MAX_SEGMENT_BLOCKS, B_UINT32_TYPE, { .ui32 = (1 << 10) - 1 }},

		// private data to identify device
		{ NULL }
	};
	device_node* node;
	if (gDeviceManager->register_node(context->fNode,
			SDHCI_ACPI_MMC_BUS_MODULE_NAME, attrs, NULL,
			&node) != B_OK)
		return B_BAD_VALUE;
	return B_OK;
}

float
supports_device_acpi(device_node* parent)
{
	const char* hid;
	const char* uid;
	const char* cid;
	uint32 type;

	if (gDeviceManager->get_attr_uint32(parent, ACPI_DEVICE_TYPE_ITEM, &type, false)
		|| type != ACPI_TYPE_DEVICE) {
		return 0.0f;
	}

	if (gDeviceManager->get_attr_string(parent, ACPI_DEVICE_HID_ITEM, &hid, false)) {
		TRACE("No hid attribute\n");
		return 0.0f;
	}

	if (gDeviceManager->get_attr_string(parent, ACPI_DEVICE_UID_ITEM, &uid, false)) {
		TRACE("No uid attribute\n");
		return 0.0f;
	}

	if (gDeviceManager->get_attr_string(parent, ACPI_DEVICE_CID_ITEM, &cid, false)) {
		TRACE("No cid attribute\n");
		return 0.0f;
	}

	// The HID and UID determine whether a given host controller is SD, SDIO, or eMMC.
	// The CID determines whether an ACPI device is a host controller at all.
	if (strcmp(cid, "PNP0D40") != 0) {
		return 0.0f;
	}

	acpi_device_module_info* acpi;
	acpi_device* device;
	gDeviceManager->get_driver(parent, (driver_module_info**)&acpi,
		(void**)&device);
	TRACE("SDHCI Device found! hid: %s, uid: %s\n", hid, uid);

	return 0.8f;
}

// Device node registered for each SD slot. It implements the MMC operations so
// the bus manager can use it to communicate with SD cards.
mmc_bus_interface gSDHCIACPIDeviceModule = {
	.info = {
		.info = {
			.name = SDHCI_ACPI_MMC_BUS_MODULE_NAME,
		},

		.init_driver = init_bus_acpi,
		.uninit_driver = uninit_bus,
		.device_removed = bus_removed,
	},

	.set_clock = set_clock,
	.execute_command = execute_command,
	.do_io = do_io,
	.set_scan_semaphore = set_scan_semaphore,
	.set_bus_width = set_bus_width,
};