2. 程式人生 > >SPI匯流排驅動、裝置驅動

SPI匯流排驅動、裝置驅動

阿新 • • 發佈：2018-11-09

SPI驅動分析

zynq SPI控制器理解記錄

如下：spi一般都由一下兩個不通的模式組合成四個模式：
自動/手到傳送資料：
自動：當TxFIFO有資料就進行傳送；無資料則停止傳送。
手動：通過使能傳送位進行資料的傳送。
自動/手動控制CS使能訊號：
自動：當TXFIFO有資料的時候就自動使能，Txfifo資料傳輸完成之後就不使能
手動：通過使能位來軟體控制片選訊號的使能

在這裡插入圖片描述

在這裡插入圖片描述

SPI匯流排

在這裡插入圖片描述

一個SOC有多個spi控制器，這些控制器都是連線在SPI總線上，linux採用SPI匯流排來管理這些裝置。

其中driver/spi/spi.c中實現了對spi匯流排的註冊，同時為上層裝置提供了統一的介面,以下是spi.c中初始化程式碼

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);
	if (status < 0)
		goto err1;

	status = class_register(&spi_master_class);
	if (status < 0)
		goto err2;
	return 0;

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

/* board_info is normally registered in arch_initcall(),
 * but even essential drivers wait till later
 *
 * REVISIT only boardinfo really needs static linking. the rest (device and
 * driver registration) _could_ be dynamically linked (modular) ... costs
 * include needing to have boardinfo data structures be much more public.
 */
postcore_initcall(spi_init);

其中postcore_initcall(*)是一個巨集，核心起來的時候會執行巨集裡面定義的函式。
status = bus_register(&spi_bus_type);實現對SPI匯流排的註冊

SPI Master控制器驅動

SPI Master控制器是SOC內部的控制器，一般一個SOC有多個控制器，使用同一個控制器驅動，對應的程式碼在drivers/spi/spi-xxx.c。每一個檔案對應著不通的spi控制器驅動，本文以spi-candance.c為例

/**
 * cdns_spi_probe - Probe method for the SPI driver
 * @pdev:	Pointer to the platform_device structure
 *
 * This function initializes the driver data structures and the hardware.
 *
 * Return:	0 on success and error value on error
 */
static int cdns_spi_probe(struct platform_device *pdev)
{
	int ret = 0, irq;
	struct spi_master *master;
	struct cdns_spi *xspi;
	struct resource *res;
	u32 num_cs;

	//pr_info("cdns_spi_probe....\r\n");
	//pr_info("sizeof(*xspi)=%d\n", sizeof(*xspi));

	master = spi_alloc_master(&pdev->dev, sizeof(*xspi));
	if (master == NULL)
		return -ENOMEM;

	xspi = spi_master_get_devdata(master);
	master->dev.of_node = pdev->dev.of_node;
	platform_set_drvdata(pdev, master);

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	//pr_info("addr:0x%x\n", res->start);
	xspi->regs = devm_ioremap_resource(&pdev->dev, res);
	if (IS_ERR(xspi->regs)) {
		ret = PTR_ERR(xspi->regs);
		goto remove_master;
	}

	xspi->pclk = devm_clk_get(&pdev->dev, "pclk");
	if (IS_ERR(xspi->pclk)) {
		dev_err(&pdev->dev, "pclk clock not found.\n");
		ret = PTR_ERR(xspi->pclk);
		goto remove_master;
	}

	xspi->ref_clk = devm_clk_get(&pdev->dev, "ref_clk");
	if (IS_ERR(xspi->ref_clk)) {
		dev_err(&pdev->dev, "ref_clk clock not found.\n");
		ret = PTR_ERR(xspi->ref_clk);
		goto remove_master;
	}

	ret = clk_prepare_enable(xspi->pclk);
	if (ret) {
		dev_err(&pdev->dev, "Unable to enable APB clock.\n");
		goto remove_master;
	}

	ret = clk_prepare_enable(xspi->ref_clk);
	if (ret) {
		dev_err(&pdev->dev, "Unable to enable device clock.\n");
		goto clk_dis_apb;
	}

	/* SPI controller initializations */
	cdns_spi_init_hw(xspi);

	irq = platform_get_irq(pdev, 0);
	if (irq <= 0) {
		ret = -ENXIO;
		dev_err(&pdev->dev, "irq number is invalid\n");
		goto remove_master;
	}

	ret = devm_request_irq(&pdev->dev, irq, cdns_spi_irq,
			       0, pdev->name, master);
	if (ret != 0) {
		ret = -ENXIO;
		dev_err(&pdev->dev, "request_irq failed\n");
		goto remove_master;
	}

	ret = of_property_read_u32(pdev->dev.of_node, "num-cs", &num_cs);
//pr_info("num_cs = %d\n", num_cs);
	if (ret < 0)
		master->num_chipselect = CDNS_SPI_DEFAULT_NUM_CS;
	else
		master->num_chipselect = num_cs;

	ret = of_property_read_u32(pdev->dev.of_node, "is-decoded-cs",
				   &xspi->is_decoded_cs);
//pr_info("is-decoded-cs = %d\n", xspi->is_decoded_cs);
	if (ret < 0)
		xspi->is_decoded_cs = 0;

	master->prepare_transfer_hardware = cdns_prepare_transfer_hardware;
	master->prepare_message = cdns_prepare_message;
	master->transfer_one = cdns_transfer_one;
	master->unprepare_transfer_hardware = cdns_unprepare_transfer_hardware;
	master->set_cs = cdns_spi_chipselect;
	master->mode_bits = SPI_CPOL | SPI_CPHA;

	/* Set to default valid value */
	master->max_speed_hz = clk_get_rate(xspi->ref_clk) / 4;
	xspi->speed_hz = master->max_speed_hz;

	master->bits_per_word_mask = SPI_BPW_MASK(8);

	ret = spi_register_master(master);
	if (ret) {
		dev_err(&pdev->dev, "spi_register_master failed\n");
		goto clk_dis_all;
	}

	return ret;

clk_dis_all:
	clk_disable_unprepare(xspi->ref_clk);
clk_dis_apb:
	clk_disable_unprepare(xspi->pclk);
remove_master:
	spi_master_put(master);
	return ret;
}

驅動就是linux驅動框架的三部曲
①，建立一個spi_master結構體
②，硬體初始化
③，結構體設定（相關驅動函式的編寫，根據裝置數進行相應的測試）
④，註冊結構體

SPI Device驅動

把一個連線的外設當做一個通用的裝置，驅動中只搭建spi通訊的介面，不實現裝置其它的協議，這裡有通用的驅動。
spi針對應用功能程式的驅動介面實現在drivers/spi/spidev.c裡面實現，跟普通的字元裝置驅動一樣，實現裝置的生成註冊；裝置驅動函式open、write、read、open函式的實現；這些函式直接呼叫通用層spi.c裡的函式，所以本原始碼檔案也是通用的，不需要針對不同的控制器進行修改。

其他外設使用SPI通訊

其他外設在裝置樹編寫的時候作為spi控制器下的一個子裝置，在對應的驅動程式的時候呼叫spi.c提供的介面即可使用對應spi控制器進行控制。

static int ds1305_probe(struct spi_device *spi)
{
	struct ds1305			*ds1305;
	int				status;
	u8				addr, value;
	struct ds1305_platform_data	*pdata = dev_get_platdata(&spi->dev);
	bool				write_ctrl = false;

	/* Sanity check board setup data.  This may be hooked up
	 * in 3wire mode, but we don't care.  Note that unless
	 * there's an inverter in place, this needs SPI_CS_HIGH!
	 */
	if ((spi->bits_per_word && spi->bits_per_word != 8)
			|| (spi->max_speed_hz > 2000000)
			|| !(spi->mode & SPI_CPHA))
		return -EINVAL;

	/* set up driver data */
	ds1305 = devm_kzalloc(&spi->dev, sizeof(*ds1305), GFP_KERNEL);
	if (!ds1305)
		return -ENOMEM;
	ds1305->spi = spi;
	spi_set_drvdata(spi, ds1305);

	/* read and cache control registers */
	addr = DS1305_CONTROL;
	status = spi_write_then_read(spi, &addr, sizeof(addr),
			ds1305->ctrl, sizeof(ds1305->ctrl));
	if (status < 0) {
		dev_dbg(&spi->dev, "can't %s, %d\n",
				"read", status);
		return status;
	}

	dev_dbg(&spi->dev, "ctrl %s: %3ph\n", "read", ds1305->ctrl);

	/* Sanity check register values ... partially compensating for the
	 * fact that SPI has no device handshake.  A pullup on MISO would
	 * make these tests fail; but not all systems will have one.  If
	 * some register is neither 0x00 nor 0xff, a chip is likely there.
	 */
	if ((ds1305->ctrl[0] & 0x38) != 0 || (ds1305->ctrl[1] & 0xfc) != 0) {
		dev_dbg(&spi->dev, "RTC chip is not present\n");
		return -ENODEV;
	}
	if (ds1305->ctrl[2] == 0)
		dev_dbg(&spi->dev, "chip may not be present\n");

	/* enable writes if needed ... if we were paranoid it would
	 * make sense to enable them only when absolutely necessary.
	 */
	if (ds1305->ctrl[0] & DS1305_WP) {
		u8		buf[2];

		ds1305->ctrl[0] &= ~DS1305_WP;

		buf[0] = DS1305_WRITE | DS1305_CONTROL;
		buf[1] = ds1305->ctrl[0];
		status = spi_write_then_read(spi, buf, sizeof(buf), NULL, 0);

		dev_dbg(&spi->dev, "clear WP --> %d\n", status);
		if (status < 0)
			return status;
	}

	/* on DS1305, maybe start oscillator; like most low power
	 * oscillators, it may take a second to stabilize
	 */
	if (ds1305->ctrl[0] & DS1305_nEOSC) {
		ds1305->ctrl[0] &= ~DS1305_nEOSC;
		write_ctrl = true;
		dev_warn(&spi->dev, "SET TIME!\n");
	}

	/* ack any pending IRQs */
	if (ds1305->ctrl[1]) {
		ds1305->ctrl[1] = 0;
		write_ctrl = true;
	}

	/* this may need one-time (re)init */
	if (pdata) {
		/* maybe enable trickle charge */
		if (((ds1305->ctrl[2] & 0xf0) != DS1305_TRICKLE_MAGIC)) {
			ds1305->ctrl[2] = DS1305_TRICKLE_MAGIC
						| pdata->trickle;
			write_ctrl = true;
		}

		/* on DS1306, configure 1 Hz signal */
		if (pdata->is_ds1306) {
			if (pdata->en_1hz) {
				if (!(ds1305->ctrl[0] & DS1306_1HZ)) {
					ds1305->ctrl[0] |= DS1306_1HZ;
					write_ctrl = true;
				}
			} else {
				if (ds1305->ctrl[0] & DS1306_1HZ) {
					ds1305->ctrl[0] &= ~DS1306_1HZ;
					write_ctrl = true;
				}
			}
		}
	}

	if (write_ctrl) {
		u8		buf[4];

		buf[0] = DS1305_WRITE | DS1305_CONTROL;
		buf[1] = ds1305->ctrl[0];
		buf[2] = ds1305->ctrl[1];
		buf[3] = ds1305->ctrl[2];
		status = spi_write_then_read(spi, buf, sizeof(buf), NULL, 0);
		if (status < 0) {
			dev_dbg(&spi->dev, "can't %s, %d\n",
					"write", status);
			return status;
		}

		dev_dbg(&spi->dev, "ctrl %s: %3ph\n", "write", ds1305->ctrl);
	}

	/* see if non-Linux software set up AM/PM mode */
	addr = DS1305_HOUR;
	status = spi_write_then_read(spi, &addr, sizeof(addr),
				&value, sizeof(value));
	if (status < 0) {
		dev_dbg(&spi->dev, "read HOUR --> %d\n", status);
		return status;
	}

	ds1305->hr12 = (DS1305_HR_12 & value) != 0;
	if (ds1305->hr12)
		dev_dbg(&spi->dev, "AM/PM\n");

	/* register RTC ... from here on, ds1305->ctrl needs locking */
	ds1305->rtc = devm_rtc_device_register(&spi->dev, "ds1305",
			&ds1305_ops, THIS_MODULE);
	if (IS_ERR(ds1305->rtc)) {
		status = PTR_ERR(ds1305->rtc);
		dev_dbg(&spi->dev, "register rtc --> %d\n", status);
		return status;
	}

	/* Maybe set up alarm IRQ; be ready to handle it triggering right
	 * away.  NOTE that we don't share this.  The signal is active low,
	 * and we can't ack it before a SPI message delay.  We temporarily
	 * disable the IRQ until it's acked, which lets us work with more
	 * IRQ trigger modes (not all IRQ controllers can do falling edge).
	 */
	if (spi->irq) {
		INIT_WORK(&ds1305->work, ds1305_work);
		status = devm_request_irq(&spi->dev, spi->irq, ds1305_irq,
				0, dev_name(&ds1305->rtc->dev), ds1305);
		if (status < 0) {
			dev_err(&spi->dev, "request_irq %d --> %d\n",
					spi->irq, status);
		} else {
			device_set_wakeup_capable(&spi->dev, 1);
		}
	}

	/* export NVRAM */
	status = sysfs_create_bin_file(&spi->dev.kobj, &nvram);
	if (status < 0) {
		dev_err(&spi->dev, "register nvram --> %d\n", status);
	}

	return 0;
}

spi_set_drvdata(spi, ds1305); 把spi相關的驅動儲存到此裝置當中，之後的此裝置驅動程式就可以利用spi來進行資料通訊
直接採用spi_write_then_read（）函式來實現spi的讀寫。

原始碼記錄

問： spi fifo只有一定的大小，應用程式一次傳遞了超過fifo的資料，怎麼處理
答： 每次只把fifo寫滿，然後開啟發送fifo閾值中斷，當fifo中的資料數量少於一定的值時中斷產生，當發起的傳輸還有資料沒有傳送時則繼續傳送，直到所有的資料傳送完成。

問： spi通用傳輸的片選訊號在那裡控制
答： spi.c裡面在一次傳輸開始之前會先進行片選，而片選的具體操作函式則在spi-xxx.c裡面實現

問題記錄

一次傳遞一定數量的時候出現了超時的現象

spi.c裡在開始一次傳輸之後設定一個等待值等待資料傳輸完成，這裡的
ms = xfer->len * 8 * 1000 / xfer->speed_hz;計算在一定值得時候是零，就會出現在這個為零的值得數量的時候出現超時的情況，可以吧 tolerance的值加大，從而使其不出現超時的情況

if (ret > 0) {
ret = 0;
ms = xfer->len * 8 * 1000 / xfer->speed_hz;
ms += 100; /* some tolerance */
ms = wait_for_completion_timeout(&master->xfer_completion,
msecs_to_jiffies(ms));
}

完整函式如下：

static int spi_transfer_one_message(struct spi_master *master,
				    struct spi_message *msg)
{
	struct spi_transfer *xfer;
	bool keep_cs = false;
	int ret = 0;
	int ms = 1;

	//printk("%s,%d\r\n",__func__,__LINE__);
	spi_set_cs(msg->spi, true);

	list_for_each_entry(xfer, &msg->transfers, transfer_list) {
		trace_spi_transfer_start(msg, xfer);

		reinit_completion(&master->xfer_completion);

		ret = master->transfer_one(master, msg->spi, xfer);
		if (ret < 0) {
			dev_err(&msg->spi->dev,
				"SPI transfer failed: %d\n", ret);
			goto out;
		}

		if (ret > 0) {
			ret = 0;
			ms = xfer->len * 8 * 1000 / xfer->speed_hz;
			ms += 100; /* some tolerance */

			ms = wait_for_completion_timeout(&master->xfer_completion,
							 msecs_to_jiffies(ms));
		}

		if (ms == 0) {
			dev_err(&msg->spi->dev, "SPI transfer timed out\n");
			msg->status = -ETIMEDOUT;
		}

		trace_spi_transfer_stop(msg, xfer);

		if (msg->status != -EINPROGRESS)
			goto out;

		if (xfer->delay_usecs)
			udelay(xfer->delay_usecs);

		if (xfer->cs_change) {
			if (list_is_last(&xfer->transfer_list,
					 &msg->transfers)) {
				keep_cs = true;
			} else {
				spi_set_cs(msg->spi, false);
				udelay(10);
				spi_set_cs(msg->spi, true);
			}
		}

		msg->actual_length += xfer->len;
	}

out:
	if (ret != 0 || !keep_cs)
		spi_set_cs(msg->spi, false);

	if (msg->status == -EINPROGRESS)
		msg->status = ret;

	spi_finalize_current_message(master);

	return ret;
}

相關推薦

SPI匯流排驅動、裝置驅動

SPI驅動分析 zynq SPI控制器理解記錄 SPI匯流排 SPI Master控制器驅動 SPI Device驅動 其他外設使用SPI通訊 原始碼記錄 問題記錄 一次傳遞一定數量的時候出現了超時的現象

《連載 | 物聯網框架ServerSuperIO教程》- 14．配製工具介紹，以及裝置驅動、檢視驅動、服務例項的掛載

目       錄 14．配製工具介紹，以及裝置驅動、檢視驅動、服務例項的掛載... 2 14.1        概述... 2 14.2        掛載裝置驅動... 2 14.3        掛載顯示檢視... 4 14.4 

裝置檔案、裝置檔案節點 、裝置 、裝置驅動 區別

1.裝置Linux下的裝置通常分為三類，字元裝置，塊裝置和網路裝置。見的字元裝置有滑鼠、鍵盤、串列埠、控制檯等。常見的塊裝置有各種硬碟、flash磁碟、RAM磁碟等。在Linux裡一個網路裝置也可以叫做一個網路介面，如eth0，應用程式是通過Socket而不是裝置節點來訪問網

linux裝置驅動--字元裝置驅動

一、linux系統將裝置分為3類：字元裝置、塊裝置、網路裝置。使用驅動程式： 1、字元裝置：是指只能一個位元組一個位元組讀寫的裝置，不能隨機讀取裝置記憶體中的某一資料，讀取資料需要按照先後資料。字元裝置是面向流的裝置，常見的字元裝置有滑鼠、鍵盤、串列埠、控制檯和LE

uboot 裝置驅動之裝置驅動描述

include/dm/device.h /**  * struct driver - A driver for a feature or peripheral  *  * This holds methods for setting up a new device, and

Struts2的模型驅動、屬性驅動的理解

因為在struts1的版本中，屬性的攔截以及控制的處理是被封裝為兩個對立的ActionForm、Action來獲取HttpServerRequest的引數、控制訪問的MAPPING的。而在Struts2中我們可以直接通過Action來獲取請求引數，並把處理的資源對映返回給

架構視角 - DDD、TDD、MDD領域驅動、測試驅動還是模型驅動？

提出問題     「領域驅動設計」之於微服務，好比麥當勞之於漢堡(個人更喜歡肯德基，漢堡要大些，麥當勞的漢堡，想吃頓飽飯，請先給我上6個

十一、Linux驅動之platform匯流排裝置驅動

1. 基本概念     從Linux2.6開始Linux加入了一套驅動管理和註冊機制—platform平臺匯流排驅動模型。platform平臺匯流排是一條虛擬匯流排，platform_device為相應的裝置，platform_driver為相應的驅動。與傳統的bu

【迅為iTop4412學習筆記】4. 匯流排、裝置、驅動，註冊流程

宣告 以下都是我剛開始看驅動視訊的個人強行解讀，如果有誤請指出，共同進步。 本節目標 瞭解Linux匯流排、裝置 驅動註冊的流程 基本知識 一般的裝置：接入裝置 -> 註冊裝置 -> 註冊

Linux I2C核心、匯流排與裝置驅動

I2C匯流排僅僅使用SCL、 SDA這兩根訊號線就實現了裝置之間的資料互動，極大地簡化了對硬體資源和PCB板佈線空間的佔用。因此， I2C匯流排非常廣泛地應用在EEPROM、實時鐘、小型LCD等裝置與C

裝置、驅動、匯流排模型簡介

前言         在Linux系統中，有很多的框架提供驅動編寫者使用，比如前面我寫過的一篇文章：input子系統的架構分析及應用。都是將純軟體相關的程式碼和操作硬體相關的程式碼分離開，這樣就使得驅動的編寫者省去編寫大量的、重複的程式碼，只要專注於底層硬體相關的程式碼就可

Linux SPI匯流排和裝置驅動架構之一：系統概述

SPI是"Serial Peripheral Interface" 的縮寫，是一種四線制的同步序列通訊介面，用來連線微控制器、感測器、儲存裝置，SPI裝置分為主裝置和從裝置兩種，用於通訊和控制的四根線分別是： CS    片選訊號SCK  時鐘訊號MISO  主裝置的資料

linux裝置驅動模型之匯流排、裝置、驅動三者的關係

匯流排、裝置、驅動，也就是bus、device、driver，在核心裡都有對應的結構體，在include/linux/device.h 裡定義。Device.h (linux-3.4.2\inclu

Linux SPI匯流排和裝置驅動架構之二：SPI通用介面層

通過上一篇文章的介紹，我們知道，SPI通用介面層用於把具體SPI裝置的協議驅動和SPI控制器驅動聯接在一起，通用介面層除了為協議驅動和控制器驅動提供一系列的標準介面API，同時還為這些介面API定義了相應的資料結構，這些資料結構一部分是SPI裝置、SPI協議驅動和SPI控制

Linux SPI匯流排和裝置驅動架構之四：SPI資料傳輸的佇列化

我們知道，SPI資料傳輸可以有兩種方式：同步方式和非同步方式。所謂同步方式是指資料傳輸的發起者必須等待本次傳輸的結束，期間不能做其它事情，用程式碼來解釋就是，呼叫傳輸的函式後，直到資料傳輸完成，函式才會返回。而非同步方式則正好相反，資料傳輸的發起者無需等待傳輸的結束，資料傳

Linux匯流排、裝置、驅動模型

1. 分配一個platform_device結構並呼叫platform_device_register函式進行註冊 int platform_device_register(struct platform_device *pdev) { device_initialize(&pdev->de

裝置驅動歸納總結（八）：1.匯流排、裝置和驅動 —— 匯流排的註冊

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 這幾天一直在看裝置模型，核心的程式碼看得我越來越沮喪，特別是kboject、kset和ktype之間的關係。但是，裝置

裝置、驅動、匯流排的關係

我們編寫的裝置驅動程式，一定是先屬於一個匯流排的驅動，比如屬於USB匯流排，或者屬於PCI匯流排，或者屬於I2C匯流排，等等，因為我們編寫的裝置驅動，在註冊，安裝到系統時，系統會先檢查驅動是屬於哪個匯流排的（裝置驅動編寫時已經定義好），會把驅動加入到對應的匯流排的kset中，即把當前裝置驅動的kobject加

《Linux匯流排、裝置與驅動》自己寫的demo

本demo基於Android2.3模擬器開發，核心程式碼(Linux2.6.29)和Android程式碼可以在網上下載、這裡不在說明。 一、驅動 1.匯流排驅動 功能：匯流排驅動；提供設備註冊和裝置驅動註冊以及裝置與裝置驅動匹配等函式功能。 testbus.c #inc

Linux裝置模型（匯流排、裝置、驅動程式和類）之一：bus_type

      匯流排是處理器和一個或多個裝置之間的通道，在裝置模型中，所有的裝置都通過匯流排相連，甚至是內部的虛擬"platform"匯流排。可以通過ls -l /sys/bus看到系統載入的所有匯流排。drwxr-xr-x root     root