linux spi子系统驱动分析

最新推荐文章于 2023-03-08 16:42:33 发布
最新推荐文章于 2023-03-08 16:42:33 发布
阅读量512 收藏 1
点赞数
分类专栏： 嵌入式环境+BSP linux驱动 文章标签： linux struct null structure c div

原文网址 ： http://blog.chinaunix.net/u2/66039/showart_1686204.html

2.6.18内核下已经添加了完整的spi子系统了，参考mtd的分析，将从下到上层，再从上到下层的对其进行分析。

以下先从下到上的进行分析：

driver/spi下有两个底层相关的spi驱动程序：
spi_s3c24xx.c和spi_s3c24xx_gpio.c
其中spi_s3c24xx.c是基于s3c24xx下相应的spi接口的驱动程序，spi_s3c24xx_gpio.c允许用户指定3个gpio口，分别充当spi_clk、spi_mosi和spi_miso接口，模拟标准的spi总线。
s3c2410自带了两个spi接口(spi0和spi1)，在此我只研究基于s3c2410下spi接口的驱动程序spi_s3c24xx.c。
首先从spi驱动的检测函数进行分析：

[cpp] view plain copy print ?
  1. static int s3c24xx_spi_probe(struct platform_device *pdev)
  2. {
  3. struct s3c24xx_spi *hw;
  4. struct spi_master *master;
  5. struct spi_board_info *bi;
  6. struct resource *res;
  7. int err = 0;
  8. int i;
  10. /* pi_alloc_master函数申请了struct spi_master+struct s3c24xx_spi大小的数据，
  11. * spi_master_get_devdata和pi_master_get分别取出struct s3c24xx_spi和struct spi_master结构指针
  12. */
  13. master = spi_alloc_master(&pdev->dev, sizeof(struct s3c24xx_spi));
  14. if (master == NULL) {
  15. dev_err(&pdev->dev, "No memory for spi_master/n");
  16. err = -ENOMEM;
  17. goto err_nomem;
  18. }
  20. /* 填充struct spi_master结构 */
  21. hw = spi_master_get_devdata(master);
  22. memset(hw, 0, sizeof(struct s3c24xx_spi));
  24. hw->master = spi_master_get(master);
  25. hw->pdata = pdev->dev.platform_data;
  26. hw->dev = &pdev->dev;
  28. if (hw->pdata == NULL) {
  29. dev_err(&pdev->dev, "No platform data supplied/n");
  30. err = -ENOENT;
  31. goto err_no_pdata;
  32. }
  34. platform_set_drvdata(pdev, hw);//dev_set_drvdata(&pdev->dev, hw)
  35. init_completion(&hw->done);
  37. /* setup the state for the bitbang driver */
  39. /* 填充hw->bitbang结构(hw->bitbang结构充当一个中间层，相当与input system的input_handle struct) */
  40. hw->bitbang.master = hw->master;
  41. hw->bitbang.setup_transfer = s3c24xx_spi_setupxfer;
  42. hw->bitbang.chipselect = s3c24xx_spi_chipsel;
  43. hw->bitbang.txrx_bufs = s3c24xx_spi_txrx;
  44. hw->bitbang.master->setup = s3c24xx_spi_setup;
  46. dev_dbg(hw->dev, "bitbang at %p/n", &hw->bitbang);
  48. /* find and map our resources */
  49. /* 申请spi所用到的资源：io、irq、时钟等 */
  50. res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  51. if (res == NULL) {
  52. dev_err(&pdev->dev, "Cannot get IORESOURCE_MEM/n");
  53. err = -ENOENT;
  54. goto err_no_iores;
  55. }
  57. hw->ioarea = request_mem_region(res->start, (res->end - res->start)+1,
  58. pdev->name);
  60. if (hw->ioarea == NULL) {
  61. dev_err(&pdev->dev, "Cannot reserve region/n");
  62. err = -ENXIO;
  63. goto err_no_iores;
  64. }
  66. hw->regs = ioremap(res->start, (res->end - res->start)+1);
  67. if (hw->regs == NULL) {
  68. dev_err(&pdev->dev, "Cannot map IO/n");
  69. err = -ENXIO;
  70. goto err_no_iomap;
  71. }
  73. hw->irq = platform_get_irq(pdev, 0);
  74. if (hw->irq < 0) {
  75. dev_err(&pdev->dev, "No IRQ specified/n");
  76. err = -ENOENT;
  77. goto err_no_irq;
  78. }
  80. err = request_irq(hw->irq, s3c24xx_spi_irq, 0, pdev->name, hw);
  81. if (err) {
  82. dev_err(&pdev->dev, "Cannot claim IRQ/n");
  83. goto err_no_irq;
  84. }
  86. hw->clk = clk_get(&pdev->dev, "spi");
  87. if (IS_ERR(hw->clk)) {
  88. dev_err(&pdev->dev, "No clock for device/n");
  89. err = PTR_ERR(hw->clk);
  90. goto err_no_clk;
  91. }
  93. /* for the moment, permanently enable the clock */
  95. clk_enable(hw->clk);
  97. /* program defaults into the registers */
  98. /* 初始化spi相关的寄存器 */
  99. writeb(0xff, hw->regs + S3C2410_SPPRE);
  100. writeb(SPPIN_DEFAULT, hw->regs + S3C2410_SPPIN);
  101. writeb(SPCON_DEFAULT, hw->regs + S3C2410_SPCON);
  102. /* add by lfc */
  103. s3c2410_gpio_setpin(S3C2410_GPE13, 0);
  104. s3c2410_gpio_setpin(S3C2410_GPE12, 0);
  105. s3c2410_gpio_cfgpin(S3C2410_GPE13, S3C2410_GPE13_SPICLK0);
  106. s3c2410_gpio_cfgpin(S3C2410_GPE12, S3C2410_GPE12_SPIMOSI0);
  107. s3c2410_gpio_cfgpin(S3C2410_GPE11, S3C2410_GPE11_SPIMISO0);
  108. /* end add */
  110. /* setup any gpio we can */
  111. /* 片选 */
  112. if (!hw->pdata->set_cs) {
  113. s3c2410_gpio_setpin(hw->pdata->pin_cs, 1);
  114. s3c2410_gpio_cfgpin(hw->pdata->pin_cs, S3C2410_GPIO_OUTPUT);
  115. }
  117. /* register our spi controller */
  118. /* 最终通过调用spi_register_master来注册spi控制器(驱动) */
  119. err = spi_bitbang_start(&hw->bitbang);
  120. if (err) {
  121. dev_err(&pdev->dev, "Failed to register SPI master/n");
  122. goto err_register;
  123. }
  125. dev_dbg(hw->dev, "shutdown=%d/n", hw->bitbang.shutdown);
  127. /* register all the devices associated */
  128. /* 注册所用使用本spi驱动的设备 */
  130. bi = &hw->pdata->board_info[0];
  131. for (i = 0; i < hw->pdata->board_size; i++, bi++) {
  132. dev_info(hw->dev, "registering %s/n", bi->modalias);
  134. bi->controller_data = hw;
  135. spi_new_device(master, bi);
  136. }
  138. return 0;
  140. err_register:
  141. clk_disable(hw->clk);
  142. clk_put(hw->clk);
  144. err_no_clk:
  145. free_irq(hw->irq, hw);
  147. err_no_irq:
  148. iounmap(hw->regs);
  150. err_no_iomap:
  151. release_resource(hw->ioarea);
  152. kfree(hw->ioarea);
  154. err_no_iores:
  155. err_no_pdata:
  156. spi_master_put(hw->master);;
  158. err_nomem:
  159. return err;
  160. }
  162. /*
  163. * spi_alloc_master - allocate SPI master controller
  164. * @dev: the controller, possibly using the platform_bus
  165. * @size: how much driver-private data to preallocate; the pointer to this
  166. * memory is in the class_data field of the returned class_device,
  167. * accessible with spi_master_get_devdata().
  168. *
  169. * This call is used only by SPI master controller drivers, which are the
  170. * only ones directly touching chip registers. It's how they allocate
  171. * an spi_master structure, prior to calling spi_register_master().
  172. *
  173. * This must be called from context that can sleep. It returns the SPI
  174. * master structure on success, else NULL.
  175. *
  176. * The caller is responsible for assigning the bus number and initializing
  177. * the master's methods before calling spi_register_master(); and (after errors
  178. * adding the device) calling spi_master_put() to prevent a memory leak.
  179. */
  180. /*注释已经写得很清楚了，本函数旨在分配spi_master struct
  181. *其中，device为主控制设备，size为需要预分配的设备私有数据大小
  182. *该函数被spi主控制器驱动所调用，用于在调用spi_register_master注册主控制器前
  183. *分配spi_master struct，分配bus number和初始化主控制器的操作方法
  184. *注意在分配spi_master struct的时候多分配了大小为size的设备私有数据
  185. *并通过spi_master_set_devdata函数把其放到class_data field里，以后可以通过spi_master_get_devdata来访问
  186. */
  187. struct spi_master * __init_or_module
  188. spi_alloc_master(struct device *dev, unsigned size)
  189. {
  190. struct spi_master *master;
  192. if (!dev)
  193. return NULL;
  195. master = kzalloc(size + sizeof *master, SLAB_KERNEL);
  196. if (!master)
  197. return NULL;
  199. class_device_initialize(&master->cdev);
  200. master->cdev.class = &spi_master_class;
  201. master->cdev.dev = get_device(dev);
  202. spi_master_set_devdata(master, &master[1]);
  204. return master;
  205. }
  208. /*
  209. * spi_bitbang_start - start up a polled/bitbanging SPI master driver
  210. * @bitbang: driver handle
  211. *
  212. * Caller should have zero-initialized all parts of the structure, and then
  213. * provided callbacks for chip selection and I/O loops. If the master has
  214. * a transfer method, its final step should call spi_bitbang_transfer; or,
  215. * that's the default if the transfer routine is not initialized. It should
  216. * also set up the bus number and number of chipselects.
  217. *
  218. * For i/o loops, provide callbacks either per-word (for bitbanging, or for
  219. * hardware that basically exposes a shift register) or per-spi_transfer
  220. * (which takes better advantage of hardware like fifos or DMA engines).
  221. *
  222. * Drivers using per-word I/O loops should use (or call) spi_bitbang_setup and
  223. * spi_bitbang_cleanup to handle those spi master methods. Those methods are
  224. * the defaults if the bitbang->txrx_bufs routine isn't initialized.
  225. *
  226. * This routine registers the spi_master, which will process requests in a
  227. * dedicated task, keeping IRQs unblocked most of the time. To stop
  228. * processing those requests, call spi_bitbang_stop().
  229. */
  230. int spi_bitbang_start(struct spi_bitbang *bitbang)
  231. {
  232. int status;
  234. if (!bitbang->master || !bitbang->chipselect)
  235. return -EINVAL;
  236. /*bitbang_work
  237. * 初始化a work，后面再create_singlethread_workqueue，
  238. * 等到有数据要传输的时候，在spi_bitbang_transfer函数中通过调用queue_work(bitbang->workqueue, &bitbang->work)
  239. * 把work扔进workqueue中调度运行
  240. * 这是内核的一贯做法，在mmc/sd驱动中也是这样处理的^_^
  241. */
  242. INIT_WORK(&bitbang->work, bitbang_work, bitbang);
  244. /* 初始化自旋锁和链表头，以后用到 */
  245. spin_lock_init(&bitbang->lock);
  246. spi_new_device INIT_LIST_HEAD(&bitbang->queue);
  248. if (!bitbang->master->transfer)
  249. bitbang->master->transfer = spi_bitbang_transfer;//spi数据的传输就是通过调用这个方法来实现的
  250. /* spi_s3c24xx.c驱动中有相应的txrx_bufs处理方法，在bitbang_work中被调用 */
  251. if (!bitbang->txrx_bufs) {
  252. bitbang->use_dma = 0;
  253. bitbang->txrx_bufs = spi_bitbang_bufs;
  254. if (!bitbang->master->setup) {
  255. if (!bitbang->setup_transfer)
  256. bitbang->setup_transfer =
  257. spi_bitbang_setup_transfer;
  258. bitbang->master->setup = spi_bitbang_setup;
  259. bitbang->master->cleanup = spi_bitbang_cleanup;
  260. }
  261. /* spi_s3c24xx.c驱动中有相应的setup处理方法，在稍后的spi_new_device中被调用 */
  262. } else if (!bitbang->master->setup)
  263. return -EINVAL;
  265. /* this task is the only thing to touch the SPI bits */
  266. bitbang->busy = 0;
  267. /* 创建工作者进程 */
  268. bitbang->workqueue = create_singlethread_workqueue(
  269. bitbang->master->cdev.dev->bus_id);
  270. if (bitbang->workqueue == NULL) {
  271. status = -EBUSY;
  272. goto err1;
  273. }
  275. /* driver may get busy before register() returns, especially
  276. * if someone registered boardinfo for devices
  277. */
  278. status = spi_register_master(bitbang->master);
  279. if (status < 0)
  280. goto err2;
  282. return status;
  284. err2:
  285. destroy_workqueue(bitbang->workqueue);
  286. err1:
  287. return status;
  288. }
  291. /**
  292. * spi_register_master - register SPI master controller
  293. * @master: initialized master, originally from spi_alloc_master()
  294. *
  295. * SPI master controllers connect to their drivers using some non-SPI bus,
  296. * such as the platform bus. The final stage of probe() in that code
  297. * includes calling spi_register_master() to hook up to this SPI bus glue.
  298. *
  299. * SPI controllers use board specific (often SOC specific) bus numbers,
  300. * and board-specific addressing for SPI devices combines those numbers
  301. * with chip select numbers. Since SPI does not directly support dynamic
  302. * device identification, boards need configuration tables telling which
  303. * chip is at which address.
  304. *
  305. * This must be called from context that can sleep. It returns zero on
  306. * success, else a negative error code (dropping the master's refcount).
  307. * After a successful return, the caller is responsible for calling
  308. * spi_unregister_master().
  309. */
  310. int __init_or_module
  311. spi_register_master(struct spi_master *master)
  312. {
  313. static atomic_t dyn_bus_id = ATOMIC_INIT((1<<16) - 1);
  314. struct device *dev = master->cdev.dev;
  315. int status = -ENODEV;
  316. int dynamic = 0;
  318. if (!dev)
  319. return -ENODEV;
  321. /* convention: dynamically assigned bus IDs count down from the max */
  322. if (master->bus_num < 0) {
  323. master->bus_num = atomic_dec_return(&dyn_bus_id);
  324. dynamic = 1;
  325. }
  327. /* register the device, then userspace will see it.
  328. * registration fails if the bus ID is in use.
  329. */
  330. snprintf(master->cdev.class_id, sizeof master->cdev.class_id,
  331. "spi%u", master->bus_num);
  332. status = class_device_add(&master->cdev);//注册设备
  333. if (status < 0)
  334. goto done;
  335. dev_dbg(dev, "registered master %s%s/n", master->cdev.class_id,
  336. dynamic ? " (dynamic)" : "");
  338. /* populate children from any spi device tables */
  339. scan_boardinfo(master);
  340. status = 0;
  341. done:
  342. return status;
  343. }
  346. /* FIXME someone should add support for a __setup("spi", ...) that
  347. * creates board info from kernel command lines
  348. */
  350. /*
  351. * scan board_list for spi_board_info which is registered by spi_register_board_info
  352. * 很可惜，s3c24xx的spi驱动中不支持spi_register_board_info这种标准方式注册方式，而是直接调用spi_new_device内部函数
  353. */
  355. static void __init_or_module
  356. scan_boardinfo(struct spi_master *master)
  357. {
  358. struct boardinfo *bi;
  359. struct device *dev = master->cdev.dev;
  361. down(&board_lock);
  362. list_for_each_entry(bi, &board_list, list) {
  363. struct spi_board_info *chip = bi->board_info;
  364. unsigned n;
  366. for (n = bi->n_board_info; n > 0; n--, chip++) {
  367. if (chip->bus_num != master->bus_num)
  368. continue;
  369. /* some controllers only have one chip, so they
  370. * might not use chipselects. otherwise, the
  371. * chipselects are numbered 0..max.
  372. */
  373. if (chip->chip_select >= master->num_chipselect
  374. && master->num_chipselect) {
  375. dev_dbg(dev, "cs%d > max %d/n",
  376. chip->chip_select,
  377. master->num_chipselect);
  378. continue;
  379. }
  380. (void) spi_new_device(master, chip);
  381. }
  382. }
  383. up(&board_lock);
  384. }
  387. /*
  388. * Board-specific early init code calls this (probably during arch_initcall)
  389. * with segments of the SPI device table. Any device nodes are created later,
  390. * after the relevant parent SPI controller (bus_num) is defined. We keep
  391. * this table of devices forever, so that reloading a controller driver will
  392. * not make Linux forget about these hard-wired devices.
  393. *
  394. * Other code can also call this, e.g. a particular add-on board might provide
  395. * SPI devices through its expansion connector, so code initializing that board
  396. * would naturally declare its SPI devices.
  397. *
  398. * The board info passed can safely be __initdata ... but be careful of
  399. * any embedded pointers (platform_data, etc), they're copied as-is.
  400. */
  401. int __init
  402. spi_register_board_info(struct spi_board_info const *info, unsigned n)
  403. {
  404. struct boardinfo *bi;
  406. bi = kmalloc(sizeof(*bi) + n * sizeof *info, GFP_KERNEL);
  407. if (!bi)
  408. return -ENOMEM;
  409. bi->n_board_info = n;
  410. memcpy(bi->board_info, info, n * sizeof *info);
  412. down(&board_lock);
  413. list_add_tail(&bi->list, &board_list);
  414. up(&board_lock);
  415. return 0;
  416. }
  419. /* On typical mainboards, this is purely internal; and it's not needed
  420. * after board init creates the hard-wired devices. Some development
  421. * platforms may not be able to use spi_register_board_info though, and
  422. * this is exported so that for example a USB or parport based adapter
  423. * driver could add devices (which it would learn about out-of-band).
  424. */
  425. struct spi_device *__init_or_module
  426. spi_new_device(struct spi_master *master, struct spi_board_info *chip)
  427. {
  428. struct spi_device *proxy;//这个结构很重要，以后就是通过这个结构来操作实际的spi设备的
  429. struct device *dev = master->cdev.dev;
  430. int status;
  432. /* NOTE: caller did any chip->bus_num checks necessary */
  434. if (!spi_master_get(master))
  435. return NULL;
  437. proxy = kzalloc(sizeof *proxy, GFP_KERNEL);
  438. if (!proxy) {
  439. dev_err(dev, "can't alloc dev for cs%d/n",
  440. chip->chip_select);
  441. goto fail;
  442. }
  443. /* 初始化spi_device 结构各成员 */
  444. proxy->master = master;
  445. proxy->chip_select = chip->chip_select;
  446. proxy->max_speed_hz = chip->max_speed_hz;
  447. proxy->mode = chip->mode;
  448. proxy->irq = chip->irq;
  449. proxy->modalias = chip->modalias;
  451. snprintf(proxy->dev.bus_id, sizeof proxy->dev.bus_id,
  452. "%s.%u", master->cdev.class_id,
  453. chip->chip_select);
  454. proxy->dev.parent = dev;
  455. proxy->dev.bus = &spi_bus_type;
  456. proxy->dev.platform_data = (void *) chip->platform_data;
  457. proxy->controller_data = chip->controller_data;
  458. proxy->controller_state = NULL;
  459. proxy->dev.release = spidev_release;
  461. /* drivers may modify this default i/o setup */
  462. /* 调用master->setup(即s3c24xx_spi_setup)函数初始化spi设备 */
  463. status = master->setup(proxy);
  464. if (status < 0) {
  465. dev_dbg(dev, "can't %s %s, status %d/n",
  466. "setup", proxy->dev.bus_id, status);
  467. goto fail;
  468. }
  470. /* driver core catches callers that misbehave by defining
  471. * devices that already exist.
  472. */
  473. status = device_register(&proxy->dev);//真正注册原始设备
  474. if (status < 0) {
  475. dev_dbg(dev, "can't %s %s, status %d/n",
  476. "add", proxy->dev.bus_id, status);
  477. goto fail;
  478. }
  479. dev_dbg(dev, "registered child %s/n", proxy->dev.bus_id);
  480. return proxy;
  482. fail:
  483. spi_master_put(master);
  484. kfree(proxy);
  485. return NULL;
  486. }
  489. static int s3c24xx_spi_setup(struct spi_device *spi)
  490. {
  491. int ret;
  492. /* 进行一些检查性操作 */
  493. if (!spi->bits_per_word)
  494. spi->bits_per_word = 8;
  496. if ((spi->mode & SPI_LSB_FIRST) != 0)
  497. return -EINVAL;
  499. ret = s3c24xx_spi_setupxfer(spi, NULL);
  500. if (ret < 0) {
  501. dev_err(&spi->dev, "setupxfer returned %d/n", ret);
  502. return ret;
  503. }
  505. dev_dbg(&spi->dev, "%s: mode %d, %u bpw, %d hz/n",
  506. __FUNCTION__, spi->mode, spi->bits_per_word,
  507. spi->max_speed_hz);
  509. return 0;
  510. }
  513. static int s3c24xx_spi_setupxfer(struct spi_device *spi,
  514. struct spi_transfer *t)
  515. {
  516. struct s3c24xx_spi *hw = to_hw(spi);
  517. unsigned int bpw;
  518. unsigned int hz;
  519. unsigned int div;
  521. bpw = t ? t->bits_per_word : spi->bits_per_word;
  522. hz = t ? t->speed_hz : spi->max_speed_hz;
  524. if (bpw != 8) {
  525. dev_err(&spi->dev, "invalid bits-per-word (%d)/n", bpw);
  526. return -EINVAL;
  527. }
  529. div = clk_get_rate(hw->clk) / hz;
  531. /* is clk = pclk / (2 * (pre+1)), or is it
  532. * clk = (pclk * 2) / ( pre + 1) */
  534. div = (div / 2) - 1;//求出预分频值
  536. if (div < 0)
  537. div = 1;
  539. if (div > 255)
  540. div = 255;
  542. dev_dbg(&spi->dev, "setting pre-scaler to %d (hz %d)/n", div, hz);
  543. writeb(div, hw->regs + S3C2410_SPPRE);//设置预分频值
  545. spin_lock(&hw->bitbang.lock);
  546. if (!hw->bitbang.busy) {
  547. hw->bitbang.chipselect(spi, BITBANG_CS_INACTIVE);//修改时钟，先禁用spi
  548. /* need to ndelay for 0.5 clocktick ? */
  549. }
  550. spin_unlock(&hw->bitbang.lock);
  552. return 0;
  553. }
  556. static void s3c24xx_spi_chipsel(struct spi_device *spi, int value)
  557. {
  558. struct s3c24xx_spi *hw = to_hw(spi);
  559. unsigned int cspol = spi->mode & SPI_CS_HIGH ? 1 : 0;
  560. unsigned int spcon;
  562. switch (value) {
  563. case BITBANG_CS_INACTIVE:
  564. /* 禁用spi(禁用片选) */
  565. if (hw->pdata->set_cs)
  566. hw->pdata->set_cs(hw->pdata, value, cspol);
  567. else
  568. s3c2410_gpio_setpin(hw->pdata->pin_cs, cspol ^ 1);
  569. break;
  571. case BITBANG_CS_ACTIVE:
  572. /*
  573. * 启用spi：根据需要设置寄存器并启用使能片选
  574. * (如果spi_board_info中没有设置相应的mode选项的话，那就只能使用默认值SPPIN_DEFAULT和SPCON_DEFAULT了)
  575. */
  576. spcon = readb(hw->regs + S3C2410_SPCON);
  578. if (spi->mode & SPI_CPHA)
  579. spcon |= S3C2410_SPCON_CPHA_FMTB;
  580. else
  581. spcon &= ~S3C2410_SPCON_CPHA_FMTB;
  583. if (spi->mode & SPI_CPOL)
  584. spcon |= S3C2410_SPCON_CPOL_HIGH;
  585. else
  586. spcon &= ~S3C2410_SPCON_CPOL_HIGH;
  588. spcon |= S3C2410_SPCON_ENSCK;
  590. /* write new configration */
  592. writeb(spcon, hw->regs + S3C2410_SPCON);
  594. if (hw->pdata->set_cs)
  595. hw->pdata->set_cs(hw->pdata, value, cspol);
  596. else
  597. s3c2410_gpio_setpin(hw->pdata->pin_cs, cspol);
  599. break;
  601. }
  602. }

虎皮猫大人王
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【嵌入式Linux学习七步曲之第五篇 Linux内核及驱动编程】PowerPC + Linux2.6.25平台下的SPI驱动架构分析
Sailor_forever
10-31 1万+
【摘要】本文以PowerPC+Linux 2.6.25 平台为例，详细分析了SPI总线的驱动架构。首先介绍了SPI的总体架构，从用户的角度将其分为三个层面，不同的开发者只需要关注相应的层面即可。然后分析了主要数据结构及其之间的相互关系，接着分析了不同层的具体实现，最后以一款SPI接口的时钟芯片为例讲述了如何在用户空间访问SPI驱动。对于ARM + Linux平台，只有平台依赖层即总线控制器驱动有差异。
linux spi 设备驱动简析 一(基于s5pv210)
yiheng528的专栏
11-27 2695
一:相关结体 /**  * struct s3c64xx_spi_csinfo - ChipSelect description  * @fb_delay: Slave specific feedback delay.  *            Refer to FB_CLK_SEL register definition in SPI chapter.  * @line: Custo
Linux下SPI驱动分析
steven.bai的专栏
06-20 777
Linux下SPI总线驱动有通用接口，一般的SPI设备驱动使用这个驱动接口实现设备驱动。分析驱动最好是先了解核心代码，然后从具体设备分析入手，然后从下至上，了解整个框架，再从上到下分析，理解透彻。以下分析内核根目录均以"src"代替。内核代码http://lxr.linux.no/，版本2.6.37.2。SPI的核心代码即"src/drivers/spi/spi.c"——SPI 初始化
linux spi
chenliang0224的专栏
01-01 4414
前言：       linux spi驱动分层架构包括，应用层、系统调用层、spi接口层、spi核心层、spi驱动层、spi从设备，本博客首先分析spi-platfrom设备驱动的注册，从设备m25p80是如何绑定到spi总线上，在platform探测函数是如何注册spi-master主设备的，其次通过从设备spi nandflash分析其是如何工作的.... 1.spi驱动框架 1.1.硬
Nanopi2 Fire 编写SPI驱动
08-28 2967
惯例先胡扯一同～怎么说呢，Nanopi2这个板子用来开发真的是很磨练人啊。首先自己很菜，然后这个板子资料还不算太多，热度也少，玩的人深度也不够，造成了自己开发的难度激增，SPI这个最基本的框架弄了一下午才弄出了个大概，照例放出给我启示很大的两篇博文： http://blog.csdn.net/yuanlulu/article/details/6318165 http://blog.csdn
linux SPI子系统驱动分析
10-24
linux SPI子系统驱动分析
Linux SPI 子系统驱动程序结构分析
07-09
Linux是一套免费使用和自由传播的类Unix操作系统，是一个基于POSIX和UNIX的多用户、多任务、支持多线程和多CPU的操作系统。它能运行主要的UNIX工具软件、应用程序和网络协议。它支持32位和64位硬件。Linux继承了Unix...
Linux内核驱动之spi子系统(一)spi协议
07-31
一、 SPI接口是摩托罗拉首先提出的全双工三线同步串行外围接口SCK,MOSI,MISO，采用主从模式（Master Slave）架构；支持多slave模式应用(此时使用四线模式进行通信，在原有三线模式下多出一根片选信号CS)，一般一个...
Linux下spi驱动开发
05-25
SPI子系统的开发和I2C有很多的相似性，大家可以对比学习。本主题分为两个部分叙述，第一部分介绍基于SPI子系统开发的理论框架；第二部分以华清远见教学平台FS_S5PC100上的M25P10芯片为例（内核版本2.6.29），编写一...
linux 2.6.36+ok6410 SPI子系统接口讨论
05-31
linux下的设备模型包括几个主要的概念sysfs （dev是用户空间接口，根据...driver是设备驱动class是类别，从功能角度对设备进行分类注意，在sys/bus目录下有platform目录和spi目录这两个目录下面的设备分别代表什么呢？
mtk_spi 总线架构
每一个不曾起舞的日子，都是对生命的辜负
07-15 2184
mt6739-kernel4.4 0. file_list 2. alps/kernel-4.4/include/linux/spi/spi.h struct spi_device, struct spi_driver, struct spi_board_info, struct spi_transfer, struct spi_master, struct s...
spi 子系统
weixin_48006170的博客
03-08 2402
Linux spi 子系统
基于S3C2440的嵌入式Linux驱动——SPI子系统解读（一）
嵌入式Linux
07-14 7291
本文将介绍SPI子系统。内核版本为2.6.30。如有错误欢迎指正。 预备知识要求：1.SPI总线                        2. platfrom平台                        3. sysfs子系统                        4. 阅读过LDD3第3，5，6，7，9，10，11章的内容。 NOTE：如果没有看过LDD3的相
spi 主机控制器驱动(spi_master)
weixin_30505043的博客
12-03 276
spi_master /* linux/drivers/spi/spi_s3c24xx.c * * Copyright (c) 2006 Ben Dooks * Copyright (c) 2006 Simtec Electronics * Ben Dooks <[email protected]> * * This program is free softwar...
SPI驱动之主控制器驱动程序
JK198310的专栏
05-02 1360
嵌入式微处理器访问SPI设备有两种方式：使用GPIO模拟SPI接口的工作时序或者使用SPI控制器。使用GPIO模拟SPI接口的工作时序是非常容易实现的，但是会导致大量的时间耗费在模拟SPI接口的时序上，访问效率比较低，容易成为系统瓶颈。这里主要分析使用SPI控制器的情况。在内核的drivers/spi/目录下有两个spi主控制器驱动程序：spi_s3c24xx.c和spi_s3c24xx_gpio...
linux 将devices 下spi 驱动注册为设备?,Linux spi驱动分析(二)
weixin_39981041的博客
05-11 196
一、spi总线注册这里所说的SPI核心，就是指/drivers/spi/目录下spi.c文件中提供给其他文件的函数，首先看下spi核心的初始化函数spi_init(void)。程序如下：点击(此处)折叠或打开static int __init spi_init(void){intstatus;buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);if (!buf) {...
linux spi 平台驱动6,linux 2.6.28之spi平台驱动spi_sam.c的初始化代码
weixin_39616693的博客
05-15 143
module_init(sam_spi_init);static int __init sam_spi_init(void){dbg_printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);//在match函数匹配成功的情况下, 系统将调用相应的probe函数，此处是直接在模块初始化时直接调用probe?returnplatform_driver_pr...
spi（5）参考资料
jzzjsy的专栏
03-06 1651
OMAP3630下的Linux SPI总线驱动分析(2) 4 OMAP3630 SPI 控制器驱动       在Linux内核中，SPI 控制器驱动位于drivers/spi目录下，OMAP3630 的spi控制器驱动程序为omap2_mcspi.c。       SPI 控制器驱动的注册采用Platform设备和驱动机制。 4.1 SPI 控制器的Platform devi
0.96寸oled linuxspi 驱动
最新发布
12-28
编写0.96寸OLED Linux SPI驱动需要了解Linux内核中的SPI子系统，以及OLED显示屏的通信协议和控制方式。开发者需要通过Linux设备驱动程序的框架，编写SPI通信的相关代码，同时也需要实现显示屏的初始化、写入数据、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值