百度360必应搜狗淘宝本站头条
ug5 0软件免费下载右键菜单清理flac文件grub4doss spline
当前位置：网站首页 > 技术文章 > 正文

【驱动】SPI驱动分析(五)-模拟SPI驱动

cac55 2025-03-20 12:38 15 浏览 0 评论

简介

模拟SPI驱动是一种软件实现的SPI总线驱动。在没有硬件SPI控制器的系统中，通过软件模拟实现SPI总线的功能。它允许在不修改硬件的情况下，通过GPIO（通用输入/输出）引脚模拟SPI总线的通信，从而与SPI设备进行数据交换。

模拟SPI驱动相对于硬件SPI来说，可能会有一定的性能损失，因为软件模拟不如硬件实现的SPI控制器快速和高效。

模拟SPI驱动相比硬件SPI控制器存在一些缺点，包括：

  1. 性能较低：软件模拟SPI需要通过GPIO引脚进行数据的输入和输出，并进行相应的时序控制。相比硬件SPI控制器，软件模拟SPI的速度较慢，通信效率较低，特别是在高速数据传输和频繁通信的场景下。
  2. 占用CPU资源：模拟SPI驱动在内核空间运行，需要通过CPU执行软件代码来模拟SPI总线的功能。这会占用一定的CPU资源，可能导致系统性能下降，并且可能影响其他任务的响应时间。
  3. 时序控制的挑战：软件模拟SPI需要准确控制数据的时序，包括数据的传输速率、时钟边沿和信号延迟等。需要仔细处理时序相关的问题，确保正确的数据传输和可靠性。
  4. 受限于GPIO资源：模拟SPI驱动需要使用系统中的GPIO引脚来模拟SPI总线的通信，因此受限于可用的GPIO资源数量。如果系统中可用的GPIO引脚有限，可能会限制同时连接的SPI设备数量或引起硬件扩展的困难。

内核中模拟SPI驱动的实现

在Linux内核中，SPI子系统提供了用于管理SPI总线和设备的功能和接口。虽然SPI子系统本身不直接提供模拟SPI驱动的功能，但它提供了一些接口和框架，可以用于实现模拟SPI驱动。

  1. SPI GPIO框架：SPI子系统提供了一个名为spi-gpio的框架，可使用GPIO引脚模拟SPI总线，gpio模拟spi代码在drivers/spi/spi-gpio.c中。这个框架允许将GPIO引脚配置为SPI总线的时钟、片选、输入和输出信号，并提供了对应的接口函数供驱动程序使用。
  2. spi-bitbang：spi-bitbang是Linux内核中提供的一个通用框架，用于在没有硬件SPI控制器或需要灵活控制SPI时序和配置的系统中模拟SPI总线的通信。代码在spi-bitbang.c中

下面我们分别分析下这drivers/spi/spi-gpio.c 和 spi-bitbang.c两个文件。

spi-gpio

platform_driver

spi_gpio_driver 属于总线设备驱动模型中的一种。当设备树中的compatible字段与spi_gpio_dt_ids的compatible匹配时，spi_gpio_probe将被调用，在probe函数中初始化并注册设备。

static struct platform_driver spi_gpio_driver = {br
    .driver = {br
        .name   = DRIVER_NAME,br
        .of_match_table = of_match_ptr(spi_gpio_dt_ids),br
    },br
    .probe      = spi_gpio_probe,br
    .remove     = spi_gpio_remove,br
};br
module_platform_driver(spi_gpio_driver);

spi_gpio_dt_ids

设备树需要添加 spi-gpio节点，这样才能probe成功。

br
static const struct of_device_id spi_gpio_dt_ids[] = {br
    { .compatible = "spi-gpio" },br
    {}br
};

spi_gpio_probe_dt

spi_gpio_probe_dt主要作用是解析设备树中的SPI GPIO设备信息，并将其存储在platform_data结构体中。这样，在SPI GPIO驱动的探测函数中，可以通过pdev设备的platform_data字段获取这些信息，并根据需要进行相应的配置和操作。

static int spi_gpio_probe_dt(struct platform_device *pdev)br
{br
    int ret;br
    u32 tmp;br
    struct spi_gpio_platform_data   *pdata;br
    struct device_node *np = pdev->dev.of_node;br
    const struct of_device_id *of_id =br
            of_match_device(spi_gpio_dt_ids, &pdev->dev);br
br
    if (!of_id)br
        return 0;br
br
    pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);br
    if (!pdata)br
        return -ENOMEM;br
br
    ret = of_get_named_gpio(np, "gpio-sck", 0);br
    if (ret < 0) {br
        dev_err(&pdev->dev, "gpio-sck property not found\n");br
        goto error_free;br
    }br
    pdata->sck = ret;br
br
    ret = of_get_named_gpio(np, "gpio-miso", 0);br
    if (ret < 0) {br
        dev_info(&pdev->dev, "gpio-miso property not found, switching to no-rx mode\n");br
        pdata->miso = SPI_GPIO_NO_MISO;br
    } elsebr
        pdata->miso = ret;br
br
    ret = of_get_named_gpio(np, "gpio-mosi", 0);br
    if (ret < 0) {br
        dev_info(&pdev->dev, "gpio-mosi property not found, switching to no-tx mode\n");br
        pdata->mosi = SPI_GPIO_NO_MOSI;br
    } elsebr
        pdata->mosi = ret;br
br
    ret = of_property_read_u32(np, "num-chipselects", &tmp);br
    if (ret < 0) {br
        dev_err(&pdev->dev, "num-chipselects property not found\n");br
        goto error_free;br
    }br
br
    pdata->num_chipselect = tmp;br
    pdev->dev.platform_data = pdata;br
br
    return 1;br
br
error_free:br
    devm_kfree(&pdev->dev, pdata);br
    return ret;br
}

spi_gpio_probe

spi_gpio_probe使用了bitbang模式实现SPI协议的位操作传输，在Linux内核的SPI子系统中注册并初始化一个SPI GPIO设备。

br
static int spi_gpio_probe(struct platform_device *pdev)br
{br
    int             status;br
    struct spi_master       *master;br
    struct spi_gpio         *spi_gpio;br
    struct spi_gpio_platform_data   *pdata;br
    u16 master_flags = 0;br
    bool use_of = 0;br
    int num_devices;br
    // 解析设备树中的SPI GPIO设备信息并初始化platform_data结构体br
    status = spi_gpio_probe_dt(pdev);br
    if (status < 0)br
        return status;br
    if (status > 0)br
        use_of = 1;br
    // 获取设备的platform_data结构体br
    pdata = dev_get_platdata(&pdev->dev);br
#ifdef GENERIC_BITBANGbr
    // 如果没有platform_data或者设备树中没有定义num_chipselect属性，返回错误码br
    if (!pdata || (!use_of && !pdata->num_chipselect))br
        return -ENODEV;br
#endifbr
br
    if (use_of && !SPI_N_CHIPSEL)br
        num_devices = 1;br
    elsebr
        num_devices = SPI_N_CHIPSEL;br
    // 请求和配置SPI GPIO相关的GPIO资源br
    status = spi_gpio_request(pdata, dev_name(&pdev->dev), &master_flags);br
    if (status < 0)br
        return status;br
    // 分配spi_master结构体，并保存spi_gpio结构体指针br
    master = spi_alloc_master(&pdev->dev, sizeof(*spi_gpio) +br
                    (sizeof(unsigned long) * num_devices));br
    if (!master) {br
        status = -ENOMEM;br
        goto gpio_free;br
    }br
    spi_gpio = spi_master_get_devdata(master);br
    platform_set_drvdata(pdev, spi_gpio);br
br
    spi_gpio->pdev = pdev;br
    if (pdata)br
        spi_gpio->pdata = *pdata;br
    // 设置spi_master结构体的一些字段br
    master->bits_per_word_mask = SPI_BPW_RANGE_MASK(1, 32);br
    master->flags = master_flags;br
    master->bus_num = pdev->id;br
    master->num_chipselect = num_devices;br
    master->setup = spi_gpio_setup;br
    master->cleanup = spi_gpio_cleanup;br
#ifdef CONFIG_OFbr
    master->dev.of_node = pdev->dev.of_node;br
br
    if (use_of) {br
        int i;br
        struct device_node *np = pdev->dev.of_node;br
br
        /*br
         * In DT environments, take the CS GPIO from the "cs-gpios"br
         * property of the node.br
         */br
        br
        if (!SPI_N_CHIPSEL)br
            spi_gpio->cs_gpios[0] = SPI_GPIO_NO_CHIPSELECT;br
        elsebr
            for (i = 0; i < SPI_N_CHIPSEL; i++) {br
                status = of_get_named_gpio(np, "cs-gpios", i);br
                if (status < 0) {br
                    dev_err(&pdev->dev,br
                        "invalid cs-gpios property\n");br
                    goto gpio_free;br
                }br
                spi_gpio->cs_gpios[i] = status;br
            }br
    }br
#endifbr
br
    spi_gpio->bitbang.master = master;br
    spi_gpio->bitbang.chipselect = spi_gpio_chipselect;br
    // 设置SPI传输相关的回调函数br
    if ((master_flags & (SPI_MASTER_NO_TX | SPI_MASTER_NO_RX)) == 0) {br
        spi_gpio->bitbang.txrx_word[SPI_MODE_0] = spi_gpio_txrx_word_mode0;br
        spi_gpio->bitbang.txrx_word[SPI_MODE_1] = spi_gpio_txrx_word_mode1;br
        spi_gpio->bitbang.txrx_word[SPI_MODE_2] = spi_gpio_txrx_word_mode2;br
        spi_gpio->bitbang.txrx_word[SPI_MODE_3] = spi_gpio_txrx_word_mode3;br
    } else {br
        spi_gpio->bitbang.txrx_word[SPI_MODE_0] = spi_gpio_spec_txrx_word_mode0;br
        spi_gpio->bitbang.txrx_word[SPI_MODE_1] = spi_gpio_spec_txrx_word_mode1;br
        spi_gpio->bitbang.txrx_word[SPI_MODE_2] = spi_gpio_spec_txrx_word_mode2;br
        spi_gpio->bitbang.txrx_word[SPI_MODE_3] = spi_gpio_spec_txrx_word_mode3;br
    }br
    spi_gpio->bitbang.setup_transfer = spi_bitbang_setup_transfer;br
    spi_gpio->bitbang.flags = SPI_CS_HIGH;br
    // 启动SPI GPIO位操作传输br
    status = spi_bitbang_start(&spi_gpio->bitbang);br
    if (status < 0) {br
gpio_free:br
        if (SPI_MISO_GPIO != SPI_GPIO_NO_MISO)br
            gpio_free(SPI_MISO_GPIO);br
        if (SPI_MOSI_GPIO != SPI_GPIO_NO_MOSI)br
            gpio_free(SPI_MOSI_GPIO);br
        gpio_free(SPI_SCK_GPIO);br
        spi_master_put(master);br
    }br
br
    return status;br
}

函数所做工作如下：

  1. 首先，函数调用spi_gpio_probe_dt()函数来解析设备树（Device Tree）中的SPI GPIO设备信息，并初始化platform_data结构体。设备树中包含了SPI GPIO设备的属性，如时钟引脚、数据输入引脚、数据输出引脚等。
  2. 接下来，函数获取设备的platform_data结构体，并进行一些合法性检查。
  3. 函数通过调用spi_gpio_request()函数请求和配置SPI GPIO相关的GPIO资源。该函数会申请所需的GPIO引脚，并设置引脚的方向和电平。
  4. 然后，函数使用spi_alloc_master()函数分配一个spi_master结构体，并保存了指向spi_gpio结构体的指针。同时，通过调用platform_set_drvdata()函数将spi_gpio结构体指针保存在platform_device结构体的driver_data字段中。
  5. 接着，函数对spi_master结构体的各个字段进行设置。这些字段包括SPI传输的参数，如数据位宽、传输模式、片选信号数量等。此外，还会设置回调函数，用于数据传输的配置和清理。
  6. 如果设备树支持（即配置了CONFIG_OF），函数会获取设备树中的片选信号的GPIO引脚信息。通过遍历设备树中的cs-gpios属性，获取每个片选信号的GPIO引脚。
  7. 接下来，函数设置spi_gpio结构体中的bitbang字段，将之前设置的spi_master结构体以及自定义的片选信号处理函数指定给它。
  8. 根据SPI的传输模式，函数选择不同的回调函数进行数据的传输。如果SPI设备同时支持数据发送和接收，则使用通用的传输函数；否则，使用特定的传输函数。
  9. 最后，函数调用spi_bitbang_start()函数启动SPI GPIO的位操作传输。该函数会根据之前设置的参数，开始进行SPI数据的传输。
  10. 如果启动失败，函数会释放之前请求的GPIO资源，并释放分配的spi_master结构体的内存空间。

spi_gpio_remove

spi_gpio_remove函数，它的目的是从SPI GPIO平台设备中移除驱动程序并释放相关的资源，如GPIO引脚和SPI主设备。

br
static int spi_gpio_remove(struct platform_device *pdev)br
{br
    struct spi_gpio         *spi_gpio;br
    struct spi_gpio_platform_data   *pdata;br
br
    spi_gpio = platform_get_drvdata(pdev);br
    pdata = dev_get_platdata(&pdev->dev);br
br
    /* stop() unregisters child devices too */br
    spi_bitbang_stop(&spi_gpio->bitbang);br
br
    if (SPI_MISO_GPIO != SPI_GPIO_NO_MISO)br
        gpio_free(SPI_MISO_GPIO);br
    if (SPI_MOSI_GPIO != SPI_GPIO_NO_MOSI)br
        gpio_free(SPI_MOSI_GPIO);br
    gpio_free(SPI_SCK_GPIO);br
    spi_master_put(spi_gpio->bitbang.master);br
br
    return 0;br
}
  1. 首先，函数接受一个指向struct platform_device类型的指针pdev作为参数。
  2. 接下来定义了两个指针变量spi_gpio和pdata，分别指向struct spi_gpio和struct spi_gpio_platform_data类型的数据结构。
  3. platform_get_drvdata(pdev)用于获取存储在平台设备中的私有数据指针，将其赋值给spi_gpio指针。这个私有数据指针通常在设备的probe函数中设置。
  4. dev_get_platdata(&pdev->dev)用于获取与设备相关的平台数据，将其赋值给pdata指针。平台数据是在设备的设备树绑定或者通过platform_set_drvdata()函数设置的。
  5. spi_bitbang_stop(&spi_gpio->bitbang)调用函数spi_bitbang_stop()，停止SPI位操作的传输。这个函数将注销子设备。
  6. 接下来的一系列if语句用于检查是否为每个GPIO引脚分配了一个有效的引脚号，并释放这些引脚。
  • if (SPI_MISO_GPIO != SPI_GPIO_NO_MISO)检查是否为MISO引脚分配了一个非零的引脚号，如果是，则调用gpio_free(SPI_MISO_GPIO)释放该引脚。
  • if (SPI_MOSI_GPIO != SPI_GPIO_NO_MOSI)检查是否为MOSI引脚分配了一个非零的引脚号，如果是，则调用gpio_free(SPI_MOSI_GPIO)释放该引脚。
  • 最后，调用gpio_free(SPI_SCK_GPIO)释放SCK引脚。
  1. spi_master_put(spi_gpio->bitbang.master)调用函数spi_master_put()，释放对SPI主设备的引用。
  2. 最后，函数返回0，表示成功执行函数。

spi_gpio_request

spi_gpio_request的函数，它用于请求并分配SPI GPIO引脚的资源，并根据硬件配置设置SPI主设备的传输和接收功能标志。如果引脚分配成功，函数返回0，否则返回一个非零值表示分配失败。

br
static int spi_gpio_request(struct spi_gpio_platform_data *pdata,br
                const char *label, u16 *res_flags)br
{br
    int value;br
br
    /* NOTE:  SPI_*_GPIO symbols may reference "pdata" */br
br
    if (SPI_MOSI_GPIO != SPI_GPIO_NO_MOSI) {br
        value = spi_gpio_alloc(SPI_MOSI_GPIO, label, false);br
        if (value)br
            goto done;br
    } else {br
        /* HW configuration without MOSI pin */br
        *res_flags |= SPI_MASTER_NO_TX;br
    }br
br
    if (SPI_MISO_GPIO != SPI_GPIO_NO_MISO) {br
        value = spi_gpio_alloc(SPI_MISO_GPIO, label, true);br
        if (value)br
            goto free_mosi;br
    } else {br
        /* HW configuration without MISO pin */br
        *res_flags |= SPI_MASTER_NO_RX;br
    }br
br
    value = spi_gpio_alloc(SPI_SCK_GPIO, label, false);br
    if (value)br
        goto free_miso;br
br
    goto done;br
br
free_miso:br
    if (SPI_MISO_GPIO != SPI_GPIO_NO_MISO)br
        gpio_free(SPI_MISO_GPIO);br
free_mosi:br
    if (SPI_MOSI_GPIO != SPI_GPIO_NO_MOSI)br
        gpio_free(SPI_MOSI_GPIO);br
done:br
    return value;br
}
  1. 首先，函数接受一个指向struct spi_gpio_platform_data类型的指针pdata、一个指向字符常量的指针label和一个指向u16类型的指针res_flags作为参数。
  2. 首先，通过比较SPI_MOSI_GPIO和SPI_GPIO_NO_MOSI的值来判断是否为MOSI引脚分配了一个有效的引脚号。
  3. 如果SPI_MOSI_GPIO不等于SPI_GPIO_NO_MOSI，表示为MOSI引脚分配了一个有效的引脚号，接下来调用spi_gpio_alloc(SPI_MOSI_GPIO, label, false)函数分配该引脚，并将返回值赋给value变量。如果返回值不为0，则表示分配失败，直接跳转到done标签处。
  4. 如果SPI_MOSI_GPIO等于SPI_GPIO_NO_MOSI，表示硬件配置中没有使用MOSI引脚，这时将设置*res_flags中的SPI_MASTER_NO_TX标志，表示SPI主设备没有传输功能。
  5. 接下来，通过比较SPI_MISO_GPIO和SPI_GPIO_NO_MISO的值来判断是否为MISO引脚分配了一个有效的引脚号。
  6. 如果SPI_MISO_GPIO不等于SPI_GPIO_NO_MISO，表示为MISO引脚分配了一个有效的引脚号，接下来调用spi_gpio_alloc(SPI_MISO_GPIO, label, true)函数分配该引脚，并将返回值赋给value变量。如果返回值不为0，则表示分配失败，直接跳转到free_mosi标签处。
  7. 如果SPI_MISO_GPIO等于SPI_GPIO_NO_MISO，表示硬件配置中没有使用MISO引脚，这时将设置*res_flags中的SPI_MASTER_NO_RX标志，表示SPI主设备没有接收功能。
  8. 最后，调用spi_gpio_alloc(SPI_SCK_GPIO, label, false)函数分配SCK引脚，并将返回值赋给value变量。如果返回值不为0，则表示分配失败，直接跳转到free_miso标签处。
  9. 如果程序成功执行到这里，表示所有引脚分配都成功，直接跳转到done标签处。
  10. free_miso标签处，如果之前为MISO引脚分配了一个有效的引脚号，调用gpio_free(SPI_MISO_GPIO)函数释放该引脚。
  11. free_mosi标签处，如果之前为MOSI引脚分配了一个有效的引脚号，调用gpio_free(SPI_MOSI_GPIO)函数释放该引脚。
  12. done标签处，函数返回value变量的值，表示引脚分配的结果。如果返回值为0，表示成功执行函数，否则表示分配引脚失败。

spi_gpio_alloc

spi_gpio_alloc函数用于分配和配置一个GPIO引脚的资源。它首先通过gpio_request()函数请求分配GPIO资源，并根据is_in参数来配置引脚的输入或输出模式。如果分配和配置成功，函数返回0，否则返回一个非零值表示分配和配置失败。

br
static int spi_gpio_alloc(unsigned pin, const char *label, bool is_in)br
{br
    int value;br
br
    value = gpio_request(pin, label);br
    if (value == 0) {br
        if (is_in)br
            value = gpio_direction_input(pin);br
        elsebr
            value = gpio_direction_output(pin, 0);br
    }br
    return value;br
}
  1. 首先，函数接受一个无符号整数pin作为GPIO引脚号，一个指向字符常量的指针label作为引脚的标签，以及一个布尔值is_in来指示引脚是否用于输入。
  2. gpio_request(pin, label)调用函数gpio_request()来请求分配指定引脚号的GPIO资源，并将返回值赋给value变量。如果返回值为0，表示成功分配GPIO资源；如果返回值不为0，表示分配失败。
  3. 如果gpio_request()成功执行，进入条件判断语句块：
  4. 如果is_in为真，表示该引脚是一个输入引脚，调用gpio_direction_input(pin)函数将该引脚配置为输入模式，并将返回值赋给value变量。如果返回值为0，表示成功配置引脚为输入模式；如果返回值不为0，表示配置失败。
  5. 如果is_in为假，表示该引脚是一个输出引脚，调用gpio_direction_output(pin, 0)函数将该引脚配置为输出模式，并将输出电平设置为低电平（0），将返回值赋给value变量。如果返回值为0，表示成功配置引脚为输出模式并设置输出电平；如果返回值不为0，表示配置失败。
  6. 最后，函数返回value变量的值，表示引脚分配和配置的结果。如果返回值为0，表示成功执行函数；如果返回值不为0，表示分配和配置引脚失败。

spi_gpio_cleanup

spi_gpio_cleanup的函数，用于清理和释放SPI GPIO相关资源。它首先检查特定的SPI片选引脚是否分配了有效的GPIO资源，如果是，则释放该GPIO资源。然后，调用spi_bitbang_cleanup(spi)函数清理和释放与SPI位操作相关的资源。

br
static void spi_gpio_cleanup(struct spi_device *spi)br
{br
    struct spi_gpio *spi_gpio = spi_to_spi_gpio(spi);br
    unsigned long cs = spi_gpio->cs_gpios[spi->chip_select];br
br
    if (cs != SPI_GPIO_NO_CHIPSELECT)br
        gpio_free(cs);br
    spi_bitbang_cleanup(spi);br
}

spi_gpio_setup

pi_gpio_setup的函数，用于设置SPI GPIO相关的配置。它首先根据设备树环境或SPI控制器数据获取片选引脚的值，然后根据情况请求分配并配置片选引脚的GPIO资源。如果片选引脚成功分配和配置，将进行SPI位操作的设置。如果设置失败，将释放之前分配的GPIO资源。函数最终返回设置的状态，0表示成功，非零表示失败。

static int spi_gpio_setup(struct spi_device *spi)
{
	unsigned long		cs;
	int			status = 0;
	struct spi_gpio		*spi_gpio = spi_to_spi_gpio(spi);
	struct device_node	*np = spi->master->dev.of_node;

	if (np) {
		/*
		 * In DT environments, the CS GPIOs have already been
		 * initialized from the "cs-gpios" property of the node.
		 */
		cs = spi_gpio->cs_gpios[spi->chip_select];
	} else {
		/*
		 * ... otherwise, take it from spi->controller_data
		 */
		cs = (uintptr_t) spi->controller_data;
	}

	if (!spi->controller_state) {
		if (cs != SPI_GPIO_NO_CHIPSELECT) {
			status = gpio_request(cs, dev_name(&spi->dev));
			if (status)
				return status;
			status = gpio_direction_output(cs,
					!(spi->mode & SPI_CS_HIGH));
		}
	}
	if (!status) {
		/* in case it was initialized from static board data */
		spi_gpio->cs_gpios[spi->chip_select] = cs;
		status = spi_bitbang_setup(spi);
	}

	if (status) {
		if (!spi->controller_state && cs != SPI_GPIO_NO_CHIPSELECT)
			gpio_free(cs);
	}
	return status;
}
  1. 首先，函数接受一个指向struct spi_device类型的指针spi作为参数。
  2. 代码中定义了一个无符号长整型变量cs，用于存储片选引脚（Chip Select，CS）的值。
  3. 定义了一个整型变量status，用于存储函数执行的状态，默认为0。
  4. 定义了一个指向struct spi_gpio类型的指针spi_gpio，通过spi_to_spi_gpio(spi)宏将spi转换为spi_gpio结构体。
  5. 定义了一个指向struct device_node类型的指针np，用于存储SPI主设备的设备树节点。
  6. 如果np非空（非NULL），表示在设备树（Device Tree）环境中，片选引脚已经从节点的"cs-gpios"属性中进行了初始化。
  7. 将spi_gpio->cs_gpios[spi->chip_select]的值赋给cs，表示获取对应片选引脚的GPIO资源。
  8. 如果np为空，表示不在设备树环境中，从spi->controller_data中获取片选引脚的值。
  9. 将spi->controller_data的值转换为无符号整数并赋给cs，表示获取对应片选引脚的GPIO资源。
  10. 如果spi->controller_state为空，表示SPI控制器的状态未初始化。
  11. 如果 cs不等于 SPI_GPIO_NO_CHIPSELECT，表示为该片选引脚分配了有效的GPIO资源。
  12. 调用gpio_request(cs, dev_name(&spi->dev))函数请求分配片选引脚的GPIO资源，并将返回值赋给status。
  13. 如果gpio_request()执行失败（返回值非零），直接返回status表示设置失败。
  14. 调用gpio_direction_output(cs, !(spi->mode & SPI_CS_HIGH))函数将片选引脚配置为输出模式，并根据SPI模式中的SPI_CS_HIGH标志设置输出电平。
  15. 如果spi->controller_state为空且status仍然为0，表示片选引脚成功分配和配置。
  16. 如果status为0，表示片选引脚成功分配和配置。
  17. 将cs的值存储到spi_gpio->cs_gpios[spi->chip_select]中，以便后续使用。
  18. 调用spi_bitbang_setup(spi)函数进行SPI位操作相关的设置，将返回值赋给status。
  19. 如果status非零，表示片选引脚或SPI位操作设置发生错误。
  • 如果spi->controller_state为空且cs不等于SPI_GPIO_NO_CHIPSELECT，表示之前为片选引脚分配了GPIO资源，现在需要释放它。
    • 调用gpio_free(cs)函数释放片选引脚的GPIO资源。
  1. 最后，函数返回status，表示设置的结果。如果返回值为0，表示成功执行函数；如果返回值非零，表示设置失败。

spi_gpio_chipselect

spi_gpio_chipselect作用是根据传入的参数控制 SPI 设备的片选信号的 GPIO 引脚状态，以实现 SPI 通信中的片选功能。同时，根据 SPI 协议的要求，可以设置初始时钟极性。

static void spi_gpio_chipselect(struct spi_device *spi, int is_active)
{
	struct spi_gpio *spi_gpio = spi_to_spi_gpio(spi);
	unsigned long cs = spi_gpio->cs_gpios[spi->chip_select];

	/* set initial clock polarity */
	if (is_active)
		setsck(spi, spi->mode & SPI_CPOL);

	if (cs != SPI_GPIO_NO_CHIPSELECT) {
		/* SPI is normally active-low */
		gpio_set_value_cansleep(cs, (spi->mode & SPI_CS_HIGH) ? is_active : !is_active);
	}
}
  1. 首先，代码定义了一个静态函数 spi_gpio_chipselect，该函数接受两个参数：spi 是指向 spi_device 结构体的指针，表示要控制的 SPI 设备；is_active 是一个整数，表示片选信号的状态（激活或非激活）。
  2. 接下来，代码通过使用 spi_to_spi_gpio 函数将 spi_device 结构体转换为 spi_gpio 结构体，并将结果保存在 spi_gpio 变量中。这个转换是为了获取与 GPIO 控制相关的信息。
  3. 然后，代码使用 spi_device 结构体中的 chip_select 字段来确定当前片选信号对应的 GPIO 引脚编号，并将其保存在 cs 变量中。
  4. 代码接着根据 is_active 参数来设置初始时钟极性。如果 is_active 为非零值（表示片选信号激活），则通过 spi_device 结构体中的 mode 字段的 SPI_CPOL 位来确定初始时钟极性，然后调用 setsck 函数进行设置。
  5. 接下来，代码检查 cs 变量是否等于 SPI_GPIO_NO_CHIPSELECT。如果 cs 不等于该值，说明有有效的片选信号 GPIO 引脚配置。
  6. 在 SPI 协议中，通常片选信号是低电平有效的。因此，代码使用 gpio_set_value_cansleep 函数来设置片选信号 GPIO 引脚的电平。根据 spi_device 结构体中的 mode 字段的 SPI_CS_HIGH 位，如果该位为真，则表示片选信号是高电平有效，那么根据 is_active 参数的值直接传递给 gpio_set_value_cansleep 函数；如果该位为假，则表示片选信号是低电平有效，那么取 is_active 参数的反值作为电平状态传递给 gpio_set_value_cansleep 函数。

spi-bitbang

bitbang_txrx_32

bitbang_txrx_32用于进行 SPI 位移传输。通过调用传入的函数指针 txrx_word 实现实际的发送和接收操作。

static unsigned bitbang_txrx_32(
	struct spi_device	*spi,
	u32			(*txrx_word)(struct spi_device *spi,
					unsigned nsecs,
					u32 word, u8 bits),
	unsigned		ns,
	struct spi_transfer	*t
) {
	unsigned		bits = t->bits_per_word;
	unsigned		count = t->len;
	const u32		*tx = t->tx_buf;
	u32			*rx = t->rx_buf;

	while (likely(count > 3)) {
		u32		word = 0;

		if (tx)
			word = *tx++;
		word = txrx_word(spi, ns, word, bits);
		if (rx)
			*rx++ = word;
		count -= 4;
	}
	return t->len - count;
}
  1. 函数开始时，从传输结构体 t 中获取位数 bits，数据长度 count，发送缓冲区指针 tx 和接收缓冲区指针 rx。
  2. 进入 while 循环，当数据长度 count 大于 3（32 位数据的字长）时，循环继续。
  3. 在每次循环中，首先定义一个变量 word，用于保存当前要发送或接收的数据字。
  4. 如果发送缓冲区存在 (tx 不为空)，则将发送缓冲区中的数据字赋值给 word，并将指针 tx 向后移动。
  5. 调用函数指针 txrx_word，将 SPI 设备指针 spi、传输时间 ns、数据字 word 和位数 bits 作为参数传递给该函数。函数 txrx_word 将执行实际的发送和接收操作，并返回接收到的数据字，该数据字将被赋值给 word。
  6. 如果接收缓冲区存在 (rx 不为空)，则将 word 的值存储到接收缓冲区中，并将指针 rx 向后移动。
  7. 减少数据长度 count 的值，表示已经处理了一个数据字。
  8. 循环回到第 2 步，继续处理下一个数据字，直到剩余数据长度不足以组成完整的 32 位数据。
  9. 返回传输结构体的长度 t->len 减去剩余的未处理数据长度 count，表示成功发送和接收的数据长度。

spi_bitbang_setup_transfer


spi_bitbang_setup_transfer用于设置 SPI 位移传输的参数的函数。根据传入的传输结构体 t 中的参数设置位移传输的位数和速率，并选择相应的位移传输函数进行数据的发送和接收。

int spi_bitbang_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
{
	struct spi_bitbang_cs	*cs = spi->controller_state;
	u8			bits_per_word;
	u32			hz;

	if (t) {
		bits_per_word = t->bits_per_word;
		hz = t->speed_hz;
	} else {
		bits_per_word = 0;
		hz = 0;
	}

	/* spi_transfer level calls that work per-word */
	if (!bits_per_word)
		bits_per_word = spi->bits_per_word;
	if (bits_per_word <= 8 cs->txrx_bufs = bitbang_txrx_8;
	else if (bits_per_word <= 16 cs->txrx_bufs = bitbang_txrx_16;
	else if (bits_per_word <= 32 cs->txrx_bufs = bitbang_txrx_32;
	else
		return -EINVAL;

	/* nsecs = (clock period)/2 */
	if (!hz)
		hz = spi->max_speed_hz;
	if (hz) {
		cs->nsecs = (1000000000/2) / hz;
		if (cs->nsecs > (MAX_UDELAY_MS * 1000 * 1000))
			return -EINVAL;
	}

	return 0;
}
  1. 首先，从 SPI 设备结构体中获取位移传输相关的控制器状态结构体 cs。
  2. 接着，定义变量 bits_per_word 和 hz，用于保存位数和传输速率。
  3. 如果传输结构体 t 不为空，将从传输结构体中获取位数和速率，并分别赋值给 bits_per_word 和 hz。如果 t 为空，则将 bits_per_word 和 hz 设置为 0。
  4. 如果位数 bits_per_word 为零，将从 SPI 设备结构体中获取默认的位数 spi->bits_per_word。
  5. 根据位数 bits_per_word 的大小，决定使用不同的位移传输函数。
  6. 如果传输速率 hz 为零，将从 SPI 设备结构体中获取最大速率 spi->max_speed_hz。
  7. 如果速率 hz 不为零，计算每个位移传输的时间间隔 nsecs。这里假设时钟周期为传输速率的倒数的一半（即半周期）。计算公式为 nsecs = (clock period)/2 = (1000000000/2) / hz。
  8. 如果计算得到的时间间隔 nsecs 超过最大延迟时间，则返回错误码 -EINVAL，表示时间间隔过大。
  9. 如果都设置成功，返回 0，表示设置传输参数的函数执行成功。

spi_bitbang_setup

spi_bitbang_setup在进行实际的数据传输之前，设置 SPI 设备的位移传输相关参数。它通过获取位移传输函数、调用传输参数设置函数、设置片选信号状态等步骤来完成设置。

int spi_bitbang_setup(struct spi_device *spi)
{
	struct spi_bitbang_cs	*cs = spi->controller_state;
	struct spi_bitbang	*bitbang;

	bitbang = spi_master_get_devdata(spi->master);

	if (!cs) {
		cs = kzalloc(sizeof(*cs), GFP_KERNEL);
		if (!cs)
			return -ENOMEM;
		spi->controller_state = cs;
	}

	/* per-word shift register access, in hardware or bitbanging */
	cs->txrx_word = bitbang->txrx_word[spi->mode & (SPI_CPOL|SPI_CPHA)];
	if (!cs->txrx_word)
		return -EINVAL;

	if (bitbang->setup_transfer) {
		int retval = bitbang->setup_transfer(spi, NULL);
		if (retval < 0 return retval dev_dbgspi->dev, "%s, %u nsec/bit\n", __func__, 2 * cs->nsecs);

	/* NOTE we _need_ to call chipselect() early, ideally with adapter
	 * setup, unless the hardware defaults cooperate to avoid confusion
	 * between normal (active low) and inverted chipselects.
	 */

	/* deselect chip (low or high) */
	mutex_lock(&bitbang->lock);
	if (!bitbang->busy) {
		bitbang->chipselect(spi, BITBANG_CS_INACTIVE);
		ndelay(cs->nsecs);
	}
	mutex_unlock(&bitbang->lock);

	return 0;
}
  1. 首先，从 SPI 设备结构体中获取控制器状态结构体 cs 和位移传输相关的控制结构体 bitbang。
  2. 使用函数 spi_master_get_devdata 从 SPI 主设备结构体中获取位移传输控制结构体 bitbang。
  3. 如果控制器状态结构体 cs 为空，说明还没有为该 SPI 设备分配控制器状态结构体，此时需要为其分配内存并初始化。使用函数 kzalloc 分配内存，并将分配的内存赋值给 cs。如果内存分配失败，则返回错误码 -ENOMEM。
  4. 将控制器状态结构体 cs 赋值给 SPI 设备结构体中的 controller_state 字段。
  5. 从位移传输控制结构体 bitbang 中根据 SPI 设备的模式（spi->mode）获取相应的位移传输函数 txrx_word。根据 SPI 设备的模式中的 SPI_CPOL（时钟极性）和 SPI_CPHA（时钟相位）位进行位运算，获取相应的位移传输函数。如果获取的函数为空，则返回错误码 -EINVAL。
  6. 如果位移传输控制结构体 bitbang 中的 setup_transfer 函数存在，则调用该函数设置传输参数。传输参数通过传递 SPI 设备指针 spi 和空指针 NULL 来实现。如果 setup_transfer 函数返回的值小于 0，则表示设置传输参数失败，此时返回该错误码。
  7. 在进行实际的数据传输之前，需要先选择片选信号，并确保片选信号处于非活动状态。
  8. 通过互斥锁 bitbang->lock 来保护对位移传输控制结构体的访问。首先获取互斥锁。
  9. 检查位移传输控制结构体 bitbang 中的 busy 标志。如果该标志为假，则表示当前没有其他数据传输操作正在进行，此时调用 chipselect 函数将片选信号设置为非活动状态，并通过 ndelay 函数延迟一段时间，以确保片选信号稳定。
  10. 最后，释放互斥锁 bitbang->lock。

spi_bitbang_transfer_one

spi_bitbang_transfer_one作用是执行单个传输操作，包括设置传输参数和进行数据的发送和接收。它通过调用位移传输控制结构体中的函数来完成传输操作，并根据传输的结果来设置传输操作的状态。最后，执行收尾工作并返回传输操作的状态。

static int spi_bitbang_transfer_one(struct spi_master *master,
				    struct spi_device *spi,
				    struct spi_transfer *transfer)
{
	struct spi_bitbang *bitbang = spi_master_get_devdata(master);
	int status = 0;

	if (bitbang->setup_transfer) {
		status = bitbang->setup_transfer(spi, transfer);
		if (status < 0 goto out if transfer->len)
		status = bitbang->txrx_bufs(spi, transfer);

	if (status == transfer->len)
		status = 0;
	else if (status >= 0)
		status = -EREMOTEIO;

out:
	spi_finalize_current_transfer(master);

	return status;
}
  1. 首先，从 SPI 主设备结构体中获取位移传输相关的控制结构体 bitbang。
  2. 定义变量 status 来保存传输操作的状态，默认为 0。
  3. 如果位移传输控制结构体 bitbang 中的 setup_transfer 函数存在，则调用该函数设置传输参数。传输参数通过传递 SPI 设备指针 spi 和传输结构体指针 transfer 来实现。如果设置传输参数的函数返回的值小于 0，则表示设置传输参数失败，此时跳转到标签 out 处进行处理。
  4. 检查传输结构体 transfer 的数据长度 len 是否非零。如果非零，则调用位移传输控制结构体 bitbang 中的 txrx_bufs 函数进行数据的发送和接收。
  5. 判断传输操作的状态 status 是否等于传输结构体 transfer 的长度 len。如果相等，则表示传输操作成功完成，将状态 status 设置为 0。如果状态 status 大于等于 0 但不等于传输结构体 transfer 的长度 len，则表示传输操作未完成，将状态 status 设置为 -EREMOTEIO。
  6. 跳转到标签 out 处，执行 spi_finalize_current_transfer 函数，以完成当前传输的收尾工作。
  7. 返回传输操作的状态 status。

spi_bitbang_bufs

spi_bitbang_bufs封装了对控制器状态结构体中的位移传输函数的调用，以执行数据缓冲区的传输。它通过获取位移传输所需的时间间隔和调用位移传输函数来完成传输操作，并返回传输操作的状态。

static int spi_bitbang_bufs(struct spi_device *spi, struct spi_transfer *t)
{
	struct spi_bitbang_cs	*cs = spi->controller_state;
	unsigned		nsecs = cs->nsecs;

	return cs->txrx_bufs(spi, cs->txrx_word, nsecs, t);
}
  1. 首先，从 SPI 设备结构体中获取控制器状态结构体 cs。
  2. 从控制器状态结构体 cs 中获取位移传输所需的时间间隔 nsecs。
  3. 调用控制器状态结构体 cs 中的 txrx_bufs 函数来执行数据缓冲区的传输。该函数接受 SPI 设备指针 spi、位移传输函数 txrx_word、时间间隔 nsecs 和传输结构体指针 t 作为参数，并返回传输操作的状态。
  4. 将传输操作的状态作为函数的返回值。

spi_bitbang_prepare_hardware


spi_bitbang_prepare_hardware作用是在进行数据传输之前，准备 SPI 硬件。它通过设置位移传输控制结构体中的 busy 标志来指示硬件正在忙于数据传输操作。这样做可以确保在进行数据传输之前，其他线程不会干扰硬件的正常操作。

static int spi_bitbang_prepare_hardware(struct spi_master *spi)
{
	struct spi_bitbang	*bitbang;

	bitbang = spi_master_get_devdata(spi);

	mutex_lock(&bitbang->lock);
	bitbang->busy = 1;
	mutex_unlock(&bitbang->lock);

	return 0;
}
  1. 首先，从 SPI 主设备结构体中获取位移传输相关的控制结构体 bitbang。
  2. 使用互斥锁 bitbang->lock 来保护对位移传输控制结构体的访问。首先获取互斥锁。
  3. 将位移传输控制结构体中的 busy 标志设置为 1，表示硬件正在忙于数据传输操作。
  4. 释放互斥锁 bitbang->lock，以允许其他线程访问位移传输控制结构体。
  5. 返回 0，表示硬件准备操作执行成功。

spi_bitbang_unprepare_hardware


spi_bitbang_unprepare_hardware在完成数据传输后释放 SPI 硬件资源。通过将位移传输控制结构体中的 busy 标志设置为 0，表示硬件不再忙于数据传输操作。这样做可以确保在释放硬件资源之前，其他线程可以正常访问硬件。

static int spi_bitbang_unprepare_hardware(struct spi_master *spi)
{
	struct spi_bitbang	*bitbang;

	bitbang = spi_master_get_devdata(spi);

	mutex_lock(&bitbang->lock);
	bitbang->busy = 0;
	mutex_unlock(&bitbang->lock);

	return 0;
}
  1. 首先，从 SPI 主设备结构体中获取位移传输相关的控制结构体 bitbang。
  2. 使用互斥锁 bitbang->lock 来保护对位移传输控制结构体的访问。首先获取互斥锁。
  3. 将位移传输控制结构体中的 busy 标志设置为 0，表示硬件不再忙于数据传输操作。
  4. 释放互斥锁 bitbang->lock，以允许其他线程访问位移传输控制结构体。
  5. 返回 0，表示硬件释放操作执行成功。

spi_bitbang_set_cs

spi_bitbang_set_cs作用是根据输入参数的值来控制 SPI 设备的片选信号。它通过检查 SPI 设备的传输模式和输入参数的值，判断是否需要使能片选信号，并调用位移传输控制结构体中的函数来设置片选信号的状态。同时，使用延迟函数确保在改变片选信号状态前后有适当的延迟时间。

static void spi_bitbang_set_cs(struct spi_device *spi, bool enable)
{
	struct spi_bitbang *bitbang = spi_master_get_devdata(spi->master);

	/* SPI core provides CS high / low, but bitbang driver
	 * expects CS active
	 * spi device driver takes care of handling SPI_CS_HIGH
	 */
	enable = (!!(spi->mode & SPI_CS_HIGH) == enable);

	ndelay(SPI_BITBANG_CS_DELAY);
	bitbang->chipselect(spi, enable ? BITBANG_CS_ACTIVE :
			    BITBANG_CS_INACTIVE);
	ndelay(SPI_BITBANG_CS_DELAY);
}
  1. 首先，从 SPI 设备结构体的主设备结构体中获取位移传输相关的控制结构体 bitbang。
  2. 通过检查 SPI 设备的传输模式中的 SPI_CS_HIGH 标志位，以及函数输入参数 enable 的值，来确定是否需要使能片选信号。这是为了确保兼容片选信号的极性。
  3. 使用 ndelay 函数引入延迟，以确保在改变片选信号状态之前有足够的时间。
  4. 调用位移传输控制结构体 bitbang 中的 chipselect 函数，以控制片选信号的状态。根据 enable 的值，将片选信号设置为活动状态或非活动状态。
  5. 再次使用 ndelay 函数引入延迟，以确保在改变片选信号状态后有足够的时间。

spi_bitbang_start

spi_bitbang_start进行了一系列的设置和配置，包括初始化互斥锁、设置主设备结构体中的函数指针、注册 SPI 主设备等。通过这些操作，可以使得 SPI 位移传输准备就绪，并可以进行数据传输操作。

int spi_bitbang_start(struct spi_bitbang *bitbang)
{
	struct spi_master *master = bitbang->master;
	int ret;

	if (!master || !bitbang->chipselect)
		return -EINVAL;

	mutex_init(&bitbang->lock);

	if (!master->mode_bits)
		master->mode_bits = SPI_CPOL | SPI_CPHA | bitbang->flags;

	if (master->transfer || master->transfer_one_message)
		return -EINVAL;

	master->prepare_transfer_hardware = spi_bitbang_prepare_hardware;
	master->unprepare_transfer_hardware = spi_bitbang_unprepare_hardware;
	master->transfer_one = spi_bitbang_transfer_one;
	master->set_cs = spi_bitbang_set_cs;

	if (!bitbang->txrx_bufs) {
		bitbang->use_dma = 0;
		bitbang->txrx_bufs = spi_bitbang_bufs;
		if (!master->setup) {
			if (!bitbang->setup_transfer)
				bitbang->setup_transfer =
					 spi_bitbang_setup_transfer;
			master->setup = spi_bitbang_setup;
			master->cleanup = spi_bitbang_cleanup;
		}
	}

	/* driver may get busy before register() returns, especially
	 * if someone registered boardinfo for devices
	 */
	ret = spi_register_master(spi_master_get(master));
	if (ret)
		spi_master_put(master);

	return ret;
}
  1. 首先，从位移传输控制结构体中获取 SPI 主设备结构体 master。
  2. 检查主设备结构体和位移传输控制结构体中的片选信号控制函数是否存在，如果不存在则返回错误码 -EINVAL。
  3. 初始化互斥锁 bitbang->lock，用于保护对位移传输控制结构体的访问。
  4. 如果主设备结构体中的传输模式位字段 mode_bits 未设置，则设置为默认的模式位，包括 SPI_CPOL、SPI_CPHA 和位移传输控制结构体中的标志位。
  5. 检查主设备结构体中的传输函数是否已经定义，如果已定义则返回错误码 -EINVAL。
  6. 设置主设备结构体中的准备硬件传输函数、释放硬件传输函数、单次传输函数和片选信号控制函数，分别对应位移传输控制结构体中的对应函数。
  7. 如果位移传输控制结构体中的数据缓冲区传输函数未定义，则设置使用 DMA 标志为 0，并将数据缓冲区传输函数设置为默认的位移传输函数 spi_bitbang_bufs。如果主设备结构体中的设置函数未定义，则设置使用默认的设置函数 spi_bitbang_setup 和清理函数 spi_bitbang_cleanup。
  8. 注册 SPI 主设备，将其添加到系统中。如果注册失败，则释放主设备结构体并返回错误码。
  9. 返回注册结果，成功时返回 0。

spi_bitbang_stop

spi_bitbang_stop作用是停止 SPI 位移传输。它通过取消注册 SPI 主设备来停止相关的传输操作。这可以用于在不需要进行 SPI 位移传输时，将相关资源释放并从系统中移除相应的设备。

void spi_bitbang_stop(struct spi_bitbang *bitbang)
{
	spi_unregister_master(bitbang->master);
}
  1. 从位移传输控制结构体中获取 SPI 主设备结构体 master。
  2. 调用 spi_unregister_master 函数来取消注册 SPI 主设备。这将从系统中移除该 SPI 主设备。

模拟SPI驱动框架

https://blog.csdn.net/qq_16054639/article/details/106733956

https://www.cnblogs.com/TWL123/p/9516269.html

https://whycan.com/t_5012.html

https://www.imooc.com/article/33911

https://blog.csdn.net/Creator_Ly/article/details/109640572

相关推荐

unetbootin中文版:能够将Linux系统装进U盘的U盘启动盘制作工具

unetbootin中文版是一款能够将Linux操作系统装进U盘或移动硬盘的U盘启动盘制作工具，制作好的U盘启动盘能够用于电脑的维护和系统还原等操作，使用起来非常地不错。该软件不会基于操作系统使用特定...

实用之选，实用之改:DELL 戴尔 灵越14CR-4528B 小改作业

昨天发布了一篇三脚架，今天有时间也写写早就准备写的DELL戴尔灵越14CR-4528B作业吧。话说上个笔记本还是2006年底买的华硕A6JE，电脑挺不错的，在家上上网也够用了，就是转轴设计缺陷，容...

教你如何制作一个启动U盘，从此电脑不用找专人做系统

在电脑使用中，老是遇到卡顿，蓝屏，重启等很多故障，大多都是因为自己日常使用习惯而造成的，很多用户在下载软件的时候不知不觉中都被安装许多乱七八糟的软件，当电脑乱七八糟的东西过多的时候我们就重新来装一个系...

8、Deepin操作系统启动盘(系统盘)制作

1、在Deepin官网https://www.deepin.org/zh/download/下载原版Deepin操作系统2、同时在Deepin官网https://www.deepin.org/zh/d...

电脑死机怎么办，电脑如何使用U盘重装系统

电脑死机是我们最常遇到的系统故障,遇到死机时通常重启就可以解决,不过系统损坏引起的死机就只能重装系统,那么电脑死机如何重装系统呢?下面来看看电脑死机怎么办如何使用U盘重装系统_小白一键重装系统官网。　...

bootmgr is compressed无法启动系统

bootmgriscompressedPressCtrlAltDeltorestart，电脑启动后无法正常开机出现了这样的字样，就是说明你的C盘驱动被压缩解决方法：1、使用系统光盘或者...

新手教程!如何分辨BIOS启动列表(菜单)中的各种启动项

在BIOS启动菜单中识别各类启动项，是新手安装系统或调整启动顺序的必备技能。下面用最直观的方式，为你梳理常见启动项及其含义，帮助你快速上手：一、传统存储设备启动项1.Floppy（软盘驱动器）对应...

带回家的MINI客厅电脑，自学成才，分享U盘装系统教程

刚好老家新装修了房子，客厅买了个大电视，本来是想在客厅弄台主机，接电视玩，大屏幕玩的才爽，但是台式机箱太占地方了。网上逛了一圈，发现有专门的客厅电脑，就搞了一个，外形不错，放客厅很有档次，主要是主机太...

电脑基础知识:BIOS简介及其与Windows操作系统的关系

什么是BIOS？BIOS，全称BasicInputOutputSystem，即“基本输入输出系统”，是一段固化在电脑主板芯片上的底层固件程序。它类似于一款极简化的操作系统，负责电脑开机时的硬件初...

win 7 系统注册表文件丢失或损坏，求不重做系统的解决办法!

粉丝问题解答：win7系统注册表文件丢失或损坏，求不重做系统的解决办法！解决方法：你只需要有启动盘即可，不需要其他的。之所以要求启动盘，是因为下面要对系统文件进行还原覆盖，所以不能用原系统启动。用...

UEFI怎么装Win7 小编呕血解难点!

自从广开言路之后，小编就被你们害苦了，这不，一条评论又让小编彻夜难眠。另外某些小伙伴坐不上沙发后提出要上墙的需求，其实呢只要大家提出的问题具有普遍性、有难度、而且适合小编做微信内容的话，都有机会将你们...

固态攻坚战——ASUS 华硕k45v换固态、拆机清灰教程

作者：蘑菇爱上我现在固态白菜价固态对于电脑体验的提升还是很大的对于固态存储芯片的问题没什么好说的有钱mlc，没钱tlc，不需要考虑什么寿命的问题，我用了一年多的m600，写入才3TB品牌很重要，主控...

MBR启动报错?Win10不重装一样能好!

Win10一遇到启动故障，很多小伙伴可能就会抓瞎，这可怎么弄，我不会修复啊！其实大可不必惊慌，就像这种最常见的Winload启动错误，多半都是MBR分区表丢失造成的（UEFI分区模式的几乎没有这种故障...

从零开始:硬盘手动装系统全攻略

手动安装操作系统是计算机技术必备的基本技能。对于初学者来说，可能会感到有些挑战。但通过掌握硬盘手动装系统方法，你可以亲身体验整个安装过程，进而更好地理解操作系统的工作原理。本文将详细介绍硬盘手动装系统...

电脑开机后显示File:BCD错误0xc000000f

WIN7\WIN8\WIN101、一个win864位PE。这个64位PE的相关文件，路径在boot\BOOT.WIM实机测试，开机后显示File:\EFI\Microsoft\Boot\BCD，...

取消回复欢迎 你 发表评论:

一周热门
最近发表
标签列表
赣ICP备2023011147号-26