static int __init spi_init(void)
{
    int status;

    buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
    if (!buf) {
        status = -ENOMEM;
        goto err0;
    }

    status = bus_register(&spi_bus_type);     /* Регистрация шины SPI */
    if (status < 0)
        goto err1;

    status = class_register(&spi_master_class);     /* Зарегистрировать класс SPI */
    if (status < 0)
        goto err2;
    return 0;

err2:
    bus_unregister(&spi_bus_type);
err1:
    kfree(buf);
    buf = NULL;
err0:
    return status;
}

static const struct spi_device_id *spi_match_id(const struct spi_device_id *id,
                        const struct spi_device *sdev)
{
    while (id->name[0]) {
        if (!strcmp(sdev->modalias, id->name))
            return id;
        id++;
    }
    return NULL;
}

/* Метод сопоставления шины SPI */
static int spi_match_device(struct device *dev, struct device_driver *drv)
{
    const struct spi_device *spi = to_spi_device(dev);
    const struct spi_driver *sdrv = to_spi_driver(drv);

    if (sdrv->id_table)
        return !!spi_match_id(sdrv->id_table, spi);

    return strcmp(spi->modalias, drv->name) == 0;
}

static int __init s3c24xx_spi_init(void)
{   
    return platform_driver_probe(&s3c24xx_spi_driver, s3c24xx_spi_probe);
}

struct s3c2410_spi_info *pdata;
struct s3c24xx_spi *hw;
struct spi_master *master;
struct resource *res;
int err = 0;

/* Создать экземпляр spi-контроллера */
master = spi_alloc_master(&pdev->dev, squdongqudongizeof(struct s3c24xx_spi));
if (master == NULL) {
    dev_err(&pdev->dev, "No memory for spi_master\n");
    err = -ENOMEM;
    goto err_nomem;
}

/* Получите частную структуру данных spi и инициализируйте ее как пустую. */
hw = spi_master_get_devdata(master);
memset(hw, 0, sizeof(struct s3c24xx_spi));

/* Установить личные данные spi*/
hw->master = spi_master_get(master);
hw->pdata = pdata = pdev->dev.platform_data;
hw->dev = &pdev->dev;

if (pdata == NULL) {
    dev_err(&pdev->dev, "No platform data supplied\n");
    err = -ENOENT;
    goto err_no_pdata;
}

platform_set_drvdata(pdev, hw);
init_completion(&hw->done);     /* завершение инициализации,  Используется для синхронизации ввода-вывода*/

/* initialise fiq handler */

s3c24xx_spi_initfiq(hw);       /* Инициализируйте обработчик в структуре s3c24xx_spi и привяжите к нему функцию обработки прерываний. */

/* setup the master state. */

/* the spi->mode bits understood by this driver: */
master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;

master->num_chipselect = hw->pdata->num_cs;
master->bus_num = pdata->bus_num;

hw->bitbang.master         = hw->master;
hw->bitbang.setup_transfer = s3c24xx_spi_setupxfer;
hw->bitbang.chipselect     = s3c24xx_spi_chipsel;
hw->bitbang.txrx_bufs      = s3c24xx_spi_txrx;

hw->master->setup  = s3c24xx_spi_setup;
hw->master->cleanup = s3c24xx_spi_cleanup;

res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res == NULL) {
    dev_err(&pdev->dev, "Cannot get IORESOURCE_MEM\n");
    err = -ENOENT;
    goto err_no_iores;
}

hw->ioarea = request_mem_region(res->start, resource_size(res),
                pdev->name);

if (hw->ioarea == NULL) {
    dev_err(&pdev->dev, "Cannot reserve region\n");
    err = -ENXIO;
    goto err_no_iores;
}

hw->regs = ioremap(res->start, resource_size(res));
if (hw->regs == NULL) {
    dev_err(&pdev->dev, "Cannot map IO\n");
    err = -ENXIO;
    goto err_no_iomap;
}

hw->irq = platform_get_irq(pdev, 0);
if (hw->irq < 0) {
    dev_err(&pdev->dev, "No IRQ specified\n");
    err = -ENOENT;
    goto err_no_irq;
}

err = request_irq(hw->irq, s3c24xx_spi_irq, 0, pdev->name, hw);
if (err) {
    dev_err(&pdev->dev, "Cannot claim IRQ\n");
    goto err_no_irq;
}

hw->clk = clk_get(&pdev->dev, "spi");
if (IS_ERR(hw->clk)) {
    dev_err(&pdev->dev, "No clock for device\n");
    err = PTR_ERR(hw->clk);
    goto err_no_clk;
}

/* setup any gpio we can */

if (!pdata->set_cs) {
    if (pdata->pin_cs < 0) {
        dev_err(&pdev->dev, "No chipselect pin\n");
        goto err_register;
    }

    err = gpio_request(pdata->pin_cs, dev_name(&pdev->dev));
    if (err) {
        dev_err(&pdev->dev, "Failed to get gpio for cs\n");
        goto err_register;
    }

    hw->set_cs = s3c24xx_spi_gpiocs;
    gpio_direction_output(pdata->pin_cs, 1);
} else
    hw->set_cs = pdata->set_cs;

s3c24xx_spi_initialsetup(hw);  
    s3c24xx_spi_initialsetup(hw);  /* spi Инициализация контроллера */

/* register our spi controller */

/* Внутренне последний spi_register_master используется для регистрации контроллера SPI. */
err = spi_bitbang_start(&hw->bitbang);
if (err) {
    dev_err(&pdev->dev, "Failed to register SPI master\n");
    goto err_register;weiyu
}

static struct spi_driver spidev_spi_driver = {
    .driver = {
        .name =     "spidev",
        .owner =    THIS_MODULE,
    },
    .probe =    spidev_probe,
    .remove =   __devexit_p(spidev_remove),
};

static int __init spidev_init(void)
{
    int status;

    /* Claim our 256 reserved device numbers.  Then register a class
     * that will key udev/mdev to add/remove /dev nodes.  Last, register
     * the driver which manages those device numbers.
     */
    BUILD_BUG_ON(N_SPI_MINORS > 256);
    /* Зарегистрируйтесь в качестве драйвера символьного устройства и предоставьте интерфейс вызова для уровня приложения. */
    status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
    if (status < 0)
        return status;

    /* Создать класс spidev */
    spidev_class = class_create(THIS_MODULE, "spidev");
    if (IS_ERR(spidev_class)) {
        unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
        return PTR_ERR(spidev_class);
    }

    /* вызовосновной Интерфейс, предоставляемый слоем для регистрации драйверов устройств */
    status = spi_register_driver(&spidev_spi_driver);
    if (status < 0) {
        class_destroy(spidev_class);
        unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
    }
    return status;
}