design.rst 42 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985
  1. .. SPDX-License-Identifier: GPL-2.0+
  2. .. sectionauthor:: Simon Glass <sjg@chromium.org>
  3. Design Details
  4. ==============
  5. This README contains high-level information about driver model, a unified
  6. way of declaring and accessing drivers in U-Boot. The original work was done
  7. by:
  8. * Marek Vasut <marex@denx.de>
  9. * Pavel Herrmann <morpheus.ibis@gmail.com>
  10. * Viktor Křivák <viktor.krivak@gmail.com>
  11. * Tomas Hlavacek <tmshlvck@gmail.com>
  12. This has been both simplified and extended into the current implementation
  13. by:
  14. * Simon Glass <sjg@chromium.org>
  15. Terminology
  16. -----------
  17. Uclass
  18. a group of devices which operate in the same way. A uclass provides
  19. a way of accessing individual devices within the group, but always
  20. using the same interface. For example a GPIO uclass provides
  21. operations for get/set value. An I2C uclass may have 10 I2C ports,
  22. 4 with one driver, and 6 with another.
  23. Driver
  24. some code which talks to a peripheral and presents a higher-level
  25. interface to it.
  26. Device
  27. an instance of a driver, tied to a particular port or peripheral.
  28. How to try it
  29. -------------
  30. Build U-Boot sandbox and run it::
  31. make sandbox_defconfig
  32. make
  33. ./u-boot -d u-boot.dtb
  34. (type 'reset' to exit U-Boot)
  35. There is a uclass called 'demo'. This uclass handles
  36. saying hello, and reporting its status. There are two drivers in this
  37. uclass:
  38. - simple: Just prints a message for hello, doesn't implement status
  39. - shape: Prints shapes and reports number of characters printed as status
  40. The demo class is pretty simple, but not trivial. The intention is that it
  41. can be used for testing, so it will implement all driver model features and
  42. provide good code coverage of them. It does have multiple drivers, it
  43. handles parameter data and platdata (data which tells the driver how
  44. to operate on a particular platform) and it uses private driver data.
  45. To try it, see the example session below::
  46. =>demo hello 1
  47. Hello '@' from 07981110: red 4
  48. =>demo status 2
  49. Status: 0
  50. =>demo hello 2
  51. g
  52. r@
  53. e@@
  54. e@@@
  55. n@@@@
  56. g@@@@@
  57. =>demo status 2
  58. Status: 21
  59. =>demo hello 4 ^
  60. y^^^
  61. e^^^^^
  62. l^^^^^^^
  63. l^^^^^^^
  64. o^^^^^
  65. w^^^
  66. =>demo status 4
  67. Status: 36
  68. =>
  69. Running the tests
  70. -----------------
  71. The intent with driver model is that the core portion has 100% test coverage
  72. in sandbox, and every uclass has its own test. As a move towards this, tests
  73. are provided in test/dm. To run them, try::
  74. ./test/py/test.py --bd sandbox --build -k ut_dm -v
  75. You should see something like this::
  76. (venv)$ ./test/py/test.py --bd sandbox --build -k ut_dm -v
  77. +make O=/root/u-boot/build-sandbox -s sandbox_defconfig
  78. +make O=/root/u-boot/build-sandbox -s -j8
  79. ============================= test session starts ==============================
  80. platform linux2 -- Python 2.7.5, pytest-2.9.0, py-1.4.31, pluggy-0.3.1 -- /root/u-boot/venv/bin/python
  81. cachedir: .cache
  82. rootdir: /root/u-boot, inifile:
  83. collected 199 items
  84. test/py/tests/test_ut.py::test_ut_dm_init PASSED
  85. test/py/tests/test_ut.py::test_ut[ut_dm_adc_bind] PASSED
  86. test/py/tests/test_ut.py::test_ut[ut_dm_adc_multi_channel_conversion] PASSED
  87. test/py/tests/test_ut.py::test_ut[ut_dm_adc_multi_channel_shot] PASSED
  88. test/py/tests/test_ut.py::test_ut[ut_dm_adc_single_channel_conversion] PASSED
  89. test/py/tests/test_ut.py::test_ut[ut_dm_adc_single_channel_shot] PASSED
  90. test/py/tests/test_ut.py::test_ut[ut_dm_adc_supply] PASSED
  91. test/py/tests/test_ut.py::test_ut[ut_dm_adc_wrong_channel_selection] PASSED
  92. test/py/tests/test_ut.py::test_ut[ut_dm_autobind] PASSED
  93. test/py/tests/test_ut.py::test_ut[ut_dm_autobind_uclass_pdata_alloc] PASSED
  94. test/py/tests/test_ut.py::test_ut[ut_dm_autobind_uclass_pdata_valid] PASSED
  95. test/py/tests/test_ut.py::test_ut[ut_dm_autoprobe] PASSED
  96. test/py/tests/test_ut.py::test_ut[ut_dm_bus_child_post_bind] PASSED
  97. test/py/tests/test_ut.py::test_ut[ut_dm_bus_child_post_bind_uclass] PASSED
  98. test/py/tests/test_ut.py::test_ut[ut_dm_bus_child_pre_probe_uclass] PASSED
  99. test/py/tests/test_ut.py::test_ut[ut_dm_bus_children] PASSED
  100. test/py/tests/test_ut.py::test_ut[ut_dm_bus_children_funcs] PASSED
  101. test/py/tests/test_ut.py::test_ut[ut_dm_bus_children_iterators] PASSED
  102. test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_data] PASSED
  103. test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_data_uclass] PASSED
  104. test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_ops] PASSED
  105. test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_platdata] PASSED
  106. test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_platdata_uclass] PASSED
  107. test/py/tests/test_ut.py::test_ut[ut_dm_children] PASSED
  108. test/py/tests/test_ut.py::test_ut[ut_dm_clk_base] PASSED
  109. test/py/tests/test_ut.py::test_ut[ut_dm_clk_periph] PASSED
  110. test/py/tests/test_ut.py::test_ut[ut_dm_device_get_uclass_id] PASSED
  111. test/py/tests/test_ut.py::test_ut[ut_dm_eth] PASSED
  112. test/py/tests/test_ut.py::test_ut[ut_dm_eth_act] PASSED
  113. test/py/tests/test_ut.py::test_ut[ut_dm_eth_alias] PASSED
  114. test/py/tests/test_ut.py::test_ut[ut_dm_eth_prime] PASSED
  115. test/py/tests/test_ut.py::test_ut[ut_dm_eth_rotate] PASSED
  116. test/py/tests/test_ut.py::test_ut[ut_dm_fdt] PASSED
  117. test/py/tests/test_ut.py::test_ut[ut_dm_fdt_offset] PASSED
  118. test/py/tests/test_ut.py::test_ut[ut_dm_fdt_pre_reloc] PASSED
  119. test/py/tests/test_ut.py::test_ut[ut_dm_fdt_uclass_seq] PASSED
  120. test/py/tests/test_ut.py::test_ut[ut_dm_gpio] PASSED
  121. test/py/tests/test_ut.py::test_ut[ut_dm_gpio_anon] PASSED
  122. test/py/tests/test_ut.py::test_ut[ut_dm_gpio_copy] PASSED
  123. test/py/tests/test_ut.py::test_ut[ut_dm_gpio_leak] PASSED
  124. test/py/tests/test_ut.py::test_ut[ut_dm_gpio_phandles] PASSED
  125. test/py/tests/test_ut.py::test_ut[ut_dm_gpio_requestf] PASSED
  126. test/py/tests/test_ut.py::test_ut[ut_dm_i2c_bytewise] PASSED
  127. test/py/tests/test_ut.py::test_ut[ut_dm_i2c_find] PASSED
  128. test/py/tests/test_ut.py::test_ut[ut_dm_i2c_offset] PASSED
  129. test/py/tests/test_ut.py::test_ut[ut_dm_i2c_offset_len] PASSED
  130. test/py/tests/test_ut.py::test_ut[ut_dm_i2c_probe_empty] PASSED
  131. test/py/tests/test_ut.py::test_ut[ut_dm_i2c_read_write] PASSED
  132. test/py/tests/test_ut.py::test_ut[ut_dm_i2c_speed] PASSED
  133. test/py/tests/test_ut.py::test_ut[ut_dm_leak] PASSED
  134. test/py/tests/test_ut.py::test_ut[ut_dm_led_base] PASSED
  135. test/py/tests/test_ut.py::test_ut[ut_dm_led_gpio] PASSED
  136. test/py/tests/test_ut.py::test_ut[ut_dm_led_label] PASSED
  137. test/py/tests/test_ut.py::test_ut[ut_dm_lifecycle] PASSED
  138. test/py/tests/test_ut.py::test_ut[ut_dm_mmc_base] PASSED
  139. test/py/tests/test_ut.py::test_ut[ut_dm_net_retry] PASSED
  140. test/py/tests/test_ut.py::test_ut[ut_dm_operations] PASSED
  141. test/py/tests/test_ut.py::test_ut[ut_dm_ordering] PASSED
  142. test/py/tests/test_ut.py::test_ut[ut_dm_pci_base] PASSED
  143. test/py/tests/test_ut.py::test_ut[ut_dm_pci_busnum] PASSED
  144. test/py/tests/test_ut.py::test_ut[ut_dm_pci_swapcase] PASSED
  145. test/py/tests/test_ut.py::test_ut[ut_dm_platdata] PASSED
  146. test/py/tests/test_ut.py::test_ut[ut_dm_power_pmic_get] PASSED
  147. test/py/tests/test_ut.py::test_ut[ut_dm_power_pmic_io] PASSED
  148. test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_autoset] PASSED
  149. test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_autoset_list] PASSED
  150. test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_get] PASSED
  151. test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_set_get_current] PASSED
  152. test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_set_get_enable] PASSED
  153. test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_set_get_mode] PASSED
  154. test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_set_get_voltage] PASSED
  155. test/py/tests/test_ut.py::test_ut[ut_dm_pre_reloc] PASSED
  156. test/py/tests/test_ut.py::test_ut[ut_dm_ram_base] PASSED
  157. test/py/tests/test_ut.py::test_ut[ut_dm_regmap_base] PASSED
  158. test/py/tests/test_ut.py::test_ut[ut_dm_regmap_syscon] PASSED
  159. test/py/tests/test_ut.py::test_ut[ut_dm_remoteproc_base] PASSED
  160. test/py/tests/test_ut.py::test_ut[ut_dm_remove] PASSED
  161. test/py/tests/test_ut.py::test_ut[ut_dm_reset_base] PASSED
  162. test/py/tests/test_ut.py::test_ut[ut_dm_reset_walk] PASSED
  163. test/py/tests/test_ut.py::test_ut[ut_dm_rtc_base] PASSED
  164. test/py/tests/test_ut.py::test_ut[ut_dm_rtc_dual] PASSED
  165. test/py/tests/test_ut.py::test_ut[ut_dm_rtc_reset] PASSED
  166. test/py/tests/test_ut.py::test_ut[ut_dm_rtc_set_get] PASSED
  167. test/py/tests/test_ut.py::test_ut[ut_dm_spi_find] PASSED
  168. test/py/tests/test_ut.py::test_ut[ut_dm_spi_flash] PASSED
  169. test/py/tests/test_ut.py::test_ut[ut_dm_spi_xfer] PASSED
  170. test/py/tests/test_ut.py::test_ut[ut_dm_syscon_base] PASSED
  171. test/py/tests/test_ut.py::test_ut[ut_dm_syscon_by_driver_data] PASSED
  172. test/py/tests/test_ut.py::test_ut[ut_dm_timer_base] PASSED
  173. test/py/tests/test_ut.py::test_ut[ut_dm_uclass] PASSED
  174. test/py/tests/test_ut.py::test_ut[ut_dm_uclass_before_ready] PASSED
  175. test/py/tests/test_ut.py::test_ut[ut_dm_uclass_devices_find] PASSED
  176. test/py/tests/test_ut.py::test_ut[ut_dm_uclass_devices_find_by_name] PASSED
  177. test/py/tests/test_ut.py::test_ut[ut_dm_uclass_devices_get] PASSED
  178. test/py/tests/test_ut.py::test_ut[ut_dm_uclass_devices_get_by_name] PASSED
  179. test/py/tests/test_ut.py::test_ut[ut_dm_usb_base] PASSED
  180. test/py/tests/test_ut.py::test_ut[ut_dm_usb_flash] PASSED
  181. test/py/tests/test_ut.py::test_ut[ut_dm_usb_keyb] PASSED
  182. test/py/tests/test_ut.py::test_ut[ut_dm_usb_multi] PASSED
  183. test/py/tests/test_ut.py::test_ut[ut_dm_usb_remove] PASSED
  184. test/py/tests/test_ut.py::test_ut[ut_dm_usb_tree] PASSED
  185. test/py/tests/test_ut.py::test_ut[ut_dm_usb_tree_remove] PASSED
  186. test/py/tests/test_ut.py::test_ut[ut_dm_usb_tree_reorder] PASSED
  187. test/py/tests/test_ut.py::test_ut[ut_dm_video_base] PASSED
  188. test/py/tests/test_ut.py::test_ut[ut_dm_video_bmp] PASSED
  189. test/py/tests/test_ut.py::test_ut[ut_dm_video_bmp_comp] PASSED
  190. test/py/tests/test_ut.py::test_ut[ut_dm_video_chars] PASSED
  191. test/py/tests/test_ut.py::test_ut[ut_dm_video_context] PASSED
  192. test/py/tests/test_ut.py::test_ut[ut_dm_video_rotation1] PASSED
  193. test/py/tests/test_ut.py::test_ut[ut_dm_video_rotation2] PASSED
  194. test/py/tests/test_ut.py::test_ut[ut_dm_video_rotation3] PASSED
  195. test/py/tests/test_ut.py::test_ut[ut_dm_video_text] PASSED
  196. test/py/tests/test_ut.py::test_ut[ut_dm_video_truetype] PASSED
  197. test/py/tests/test_ut.py::test_ut[ut_dm_video_truetype_bs] PASSED
  198. test/py/tests/test_ut.py::test_ut[ut_dm_video_truetype_scroll] PASSED
  199. ======================= 84 tests deselected by '-kut_dm' =======================
  200. ================== 115 passed, 84 deselected in 3.77 seconds ===================
  201. What is going on?
  202. -----------------
  203. Let's start at the top. The demo command is in cmd/demo.c. It does
  204. the usual command processing and then:
  205. .. code-block:: c
  206. struct udevice *demo_dev;
  207. ret = uclass_get_device(UCLASS_DEMO, devnum, &demo_dev);
  208. UCLASS_DEMO means the class of devices which implement 'demo'. Other
  209. classes might be MMC, or GPIO, hashing or serial. The idea is that the
  210. devices in the class all share a particular way of working. The class
  211. presents a unified view of all these devices to U-Boot.
  212. This function looks up a device for the demo uclass. Given a device
  213. number we can find the device because all devices have registered with
  214. the UCLASS_DEMO uclass.
  215. The device is automatically activated ready for use by uclass_get_device().
  216. Now that we have the device we can do things like:
  217. .. code-block:: c
  218. return demo_hello(demo_dev, ch);
  219. This function is in the demo uclass. It takes care of calling the 'hello'
  220. method of the relevant driver. Bearing in mind that there are two drivers,
  221. this particular device may use one or other of them.
  222. The code for demo_hello() is in drivers/demo/demo-uclass.c:
  223. .. code-block:: c
  224. int demo_hello(struct udevice *dev, int ch)
  225. {
  226. const struct demo_ops *ops = device_get_ops(dev);
  227. if (!ops->hello)
  228. return -ENOSYS;
  229. return ops->hello(dev, ch);
  230. }
  231. As you can see it just calls the relevant driver method. One of these is
  232. in drivers/demo/demo-simple.c:
  233. .. code-block:: c
  234. static int simple_hello(struct udevice *dev, int ch)
  235. {
  236. const struct dm_demo_pdata *pdata = dev_get_platdata(dev);
  237. printf("Hello from %08x: %s %d\n", map_to_sysmem(dev),
  238. pdata->colour, pdata->sides);
  239. return 0;
  240. }
  241. So that is a trip from top (command execution) to bottom (driver action)
  242. but it leaves a lot of topics to address.
  243. Declaring Drivers
  244. -----------------
  245. A driver declaration looks something like this (see
  246. drivers/demo/demo-shape.c):
  247. .. code-block:: c
  248. static const struct demo_ops shape_ops = {
  249. .hello = shape_hello,
  250. .status = shape_status,
  251. };
  252. U_BOOT_DRIVER(demo_shape_drv) = {
  253. .name = "demo_shape_drv",
  254. .id = UCLASS_DEMO,
  255. .ops = &shape_ops,
  256. .priv_data_size = sizeof(struct shape_data),
  257. };
  258. This driver has two methods (hello and status) and requires a bit of
  259. private data (accessible through dev_get_priv(dev) once the driver has
  260. been probed). It is a member of UCLASS_DEMO so will register itself
  261. there.
  262. In U_BOOT_DRIVER it is also possible to specify special methods for bind
  263. and unbind, and these are called at appropriate times. For many drivers
  264. it is hoped that only 'probe' and 'remove' will be needed.
  265. The U_BOOT_DRIVER macro creates a data structure accessible from C,
  266. so driver model can find the drivers that are available.
  267. The methods a device can provide are documented in the device.h header.
  268. Briefly, they are:
  269. * bind - make the driver model aware of a device (bind it to its driver)
  270. * unbind - make the driver model forget the device
  271. * ofdata_to_platdata - convert device tree data to platdata - see later
  272. * probe - make a device ready for use
  273. * remove - remove a device so it cannot be used until probed again
  274. The sequence to get a device to work is bind, ofdata_to_platdata (if using
  275. device tree) and probe.
  276. Platform Data
  277. -------------
  278. Note: platform data is the old way of doing things. It is
  279. basically a C structure which is passed to drivers to tell them about
  280. platform-specific settings like the address of its registers, bus
  281. speed, etc. Device tree is now the preferred way of handling this.
  282. Unless you have a good reason not to use device tree (the main one
  283. being you need serial support in SPL and don't have enough SRAM for
  284. the cut-down device tree and libfdt libraries) you should stay away
  285. from platform data.
  286. Platform data is like Linux platform data, if you are familiar with that.
  287. It provides the board-specific information to start up a device.
  288. Why is this information not just stored in the device driver itself? The
  289. idea is that the device driver is generic, and can in principle operate on
  290. any board that has that type of device. For example, with modern
  291. highly-complex SoCs it is common for the IP to come from an IP vendor, and
  292. therefore (for example) the MMC controller may be the same on chips from
  293. different vendors. It makes no sense to write independent drivers for the
  294. MMC controller on each vendor's SoC, when they are all almost the same.
  295. Similarly, we may have 6 UARTs in an SoC, all of which are mostly the same,
  296. but lie at different addresses in the address space.
  297. Using the UART example, we have a single driver and it is instantiated 6
  298. times by supplying 6 lots of platform data. Each lot of platform data
  299. gives the driver name and a pointer to a structure containing information
  300. about this instance - e.g. the address of the register space. It may be that
  301. one of the UARTS supports RS-485 operation - this can be added as a flag in
  302. the platform data, which is set for this one port and clear for the rest.
  303. Think of your driver as a generic piece of code which knows how to talk to
  304. a device, but needs to know where it is, any variant/option information and
  305. so on. Platform data provides this link between the generic piece of code
  306. and the specific way it is bound on a particular board.
  307. Examples of platform data include:
  308. - The base address of the IP block's register space
  309. - Configuration options, like:
  310. - the SPI polarity and maximum speed for a SPI controller
  311. - the I2C speed to use for an I2C device
  312. - the number of GPIOs available in a GPIO device
  313. Where does the platform data come from? It is either held in a structure
  314. which is compiled into U-Boot, or it can be parsed from the Device Tree
  315. (see 'Device Tree' below).
  316. For an example of how it can be compiled in, see demo-pdata.c which
  317. sets up a table of driver names and their associated platform data.
  318. The data can be interpreted by the drivers however they like - it is
  319. basically a communication scheme between the board-specific code and
  320. the generic drivers, which are intended to work on any board.
  321. Drivers can access their data via dev->info->platdata. Here is
  322. the declaration for the platform data, which would normally appear
  323. in the board file.
  324. .. code-block:: c
  325. static const struct dm_demo_pdata red_square = {
  326. .colour = "red",
  327. .sides = 4.
  328. };
  329. static const struct driver_info info[] = {
  330. {
  331. .name = "demo_shape_drv",
  332. .platdata = &red_square,
  333. },
  334. };
  335. demo1 = driver_bind(root, &info[0]);
  336. Device Tree
  337. -----------
  338. While platdata is useful, a more flexible way of providing device data is
  339. by using device tree. In U-Boot you should use this where possible. Avoid
  340. sending patches which make use of the U_BOOT_DEVICE() macro unless strictly
  341. necessary.
  342. With device tree we replace the above code with the following device tree
  343. fragment:
  344. .. code-block:: c
  345. red-square {
  346. compatible = "demo-shape";
  347. colour = "red";
  348. sides = <4>;
  349. };
  350. This means that instead of having lots of U_BOOT_DEVICE() declarations in
  351. the board file, we put these in the device tree. This approach allows a lot
  352. more generality, since the same board file can support many types of boards
  353. (e,g. with the same SoC) just by using different device trees. An added
  354. benefit is that the Linux device tree can be used, thus further simplifying
  355. the task of board-bring up either for U-Boot or Linux devs (whoever gets to
  356. the board first!).
  357. The easiest way to make this work it to add a few members to the driver:
  358. .. code-block:: c
  359. .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
  360. .ofdata_to_platdata = testfdt_ofdata_to_platdata,
  361. The 'auto_alloc' feature allowed space for the platdata to be allocated
  362. and zeroed before the driver's ofdata_to_platdata() method is called. The
  363. ofdata_to_platdata() method, which the driver write supplies, should parse
  364. the device tree node for this device and place it in dev->platdata. Thus
  365. when the probe method is called later (to set up the device ready for use)
  366. the platform data will be present.
  367. Note that both methods are optional. If you provide an ofdata_to_platdata
  368. method then it will be called first (during activation). If you provide a
  369. probe method it will be called next. See Driver Lifecycle below for more
  370. details.
  371. If you don't want to have the platdata automatically allocated then you
  372. can leave out platdata_auto_alloc_size. In this case you can use malloc
  373. in your ofdata_to_platdata (or probe) method to allocate the required memory,
  374. and you should free it in the remove method.
  375. The driver model tree is intended to mirror that of the device tree. The
  376. root driver is at device tree offset 0 (the root node, '/'), and its
  377. children are the children of the root node.
  378. In order for a device tree to be valid, the content must be correct with
  379. respect to either device tree specification
  380. (https://www.devicetree.org/specifications/) or the device tree bindings that
  381. are found in the doc/device-tree-bindings directory. When not U-Boot specific
  382. the bindings in this directory tend to come from the Linux Kernel. As such
  383. certain design decisions may have been made already for us in terms of how
  384. specific devices are described and bound. In most circumstances we wish to
  385. retain compatibility without additional changes being made to the device tree
  386. source files.
  387. Declaring Uclasses
  388. ------------------
  389. The demo uclass is declared like this:
  390. .. code-block:: c
  391. UCLASS_DRIVER(demo) = {
  392. .id = UCLASS_DEMO,
  393. };
  394. It is also possible to specify special methods for probe, etc. The uclass
  395. numbering comes from include/dm/uclass-id.h. To add a new uclass, add to the
  396. end of the enum there, then declare your uclass as above.
  397. Device Sequence Numbers
  398. -----------------------
  399. U-Boot numbers devices from 0 in many situations, such as in the command
  400. line for I2C and SPI buses, and the device names for serial ports (serial0,
  401. serial1, ...). Driver model supports this numbering and permits devices
  402. to be locating by their 'sequence'. This numbering uniquely identifies a
  403. device in its uclass, so no two devices within a particular uclass can have
  404. the same sequence number.
  405. Sequence numbers start from 0 but gaps are permitted. For example, a board
  406. may have I2C buses 1, 4, 5 but no 0, 2 or 3. The choice of how devices are
  407. numbered is up to a particular board, and may be set by the SoC in some
  408. cases. While it might be tempting to automatically renumber the devices
  409. where there are gaps in the sequence, this can lead to confusion and is
  410. not the way that U-Boot works.
  411. Each device can request a sequence number. If none is required then the
  412. device will be automatically allocated the next available sequence number.
  413. To specify the sequence number in the device tree an alias is typically
  414. used. Make sure that the uclass has the DM_UC_FLAG_SEQ_ALIAS flag set.
  415. .. code-block:: none
  416. aliases {
  417. serial2 = "/serial@22230000";
  418. };
  419. This indicates that in the uclass called "serial", the named node
  420. ("/serial@22230000") will be given sequence number 2. Any command or driver
  421. which requests serial device 2 will obtain this device.
  422. More commonly you can use node references, which expand to the full path:
  423. .. code-block:: none
  424. aliases {
  425. serial2 = &serial_2;
  426. };
  427. ...
  428. serial_2: serial@22230000 {
  429. ...
  430. };
  431. The alias resolves to the same string in this case, but this version is
  432. easier to read.
  433. Device sequence numbers are resolved when a device is probed. Before then
  434. the sequence number is only a request which may or may not be honoured,
  435. depending on what other devices have been probed. However the numbering is
  436. entirely under the control of the board author so a conflict is generally
  437. an error.
  438. Bus Drivers
  439. -----------
  440. A common use of driver model is to implement a bus, a device which provides
  441. access to other devices. Example of buses include SPI and I2C. Typically
  442. the bus provides some sort of transport or translation that makes it
  443. possible to talk to the devices on the bus.
  444. Driver model provides some useful features to help with implementing buses.
  445. Firstly, a bus can request that its children store some 'parent data' which
  446. can be used to keep track of child state. Secondly, the bus can define
  447. methods which are called when a child is probed or removed. This is similar
  448. to the methods the uclass driver provides. Thirdly, per-child platform data
  449. can be provided to specify things like the child's address on the bus. This
  450. persists across child probe()/remove() cycles.
  451. For consistency and ease of implementation, the bus uclass can specify the
  452. per-child platform data, so that it can be the same for all children of buses
  453. in that uclass. There are also uclass methods which can be called when
  454. children are bound and probed.
  455. Here an explanation of how a bus fits with a uclass may be useful. Consider
  456. a USB bus with several devices attached to it, each from a different (made
  457. up) uclass::
  458. xhci_usb (UCLASS_USB)
  459. eth (UCLASS_ETH)
  460. camera (UCLASS_CAMERA)
  461. flash (UCLASS_FLASH_STORAGE)
  462. Each of the devices is connected to a different address on the USB bus.
  463. The bus device wants to store this address and some other information such
  464. as the bus speed for each device.
  465. To achieve this, the bus device can use dev->parent_platdata in each of its
  466. three children. This can be auto-allocated if the bus driver (or bus uclass)
  467. has a non-zero value for per_child_platdata_auto_alloc_size. If not, then
  468. the bus device or uclass can allocate the space itself before the child
  469. device is probed.
  470. Also the bus driver can define the child_pre_probe() and child_post_remove()
  471. methods to allow it to do some processing before the child is activated or
  472. after it is deactivated.
  473. Similarly the bus uclass can define the child_post_bind() method to obtain
  474. the per-child platform data from the device tree and set it up for the child.
  475. The bus uclass can also provide a child_pre_probe() method. Very often it is
  476. the bus uclass that controls these features, since it avoids each driver
  477. having to do the same processing. Of course the driver can still tweak and
  478. override these activities.
  479. Note that the information that controls this behaviour is in the bus's
  480. driver, not the child's. In fact it is possible that child has no knowledge
  481. that it is connected to a bus. The same child device may even be used on two
  482. different bus types. As an example. the 'flash' device shown above may also
  483. be connected on a SATA bus or standalone with no bus::
  484. xhci_usb (UCLASS_USB)
  485. flash (UCLASS_FLASH_STORAGE) - parent data/methods defined by USB bus
  486. sata (UCLASS_AHCI)
  487. flash (UCLASS_FLASH_STORAGE) - parent data/methods defined by SATA bus
  488. flash (UCLASS_FLASH_STORAGE) - no parent data/methods (not on a bus)
  489. Above you can see that the driver for xhci_usb/sata controls the child's
  490. bus methods. In the third example the device is not on a bus, and therefore
  491. will not have these methods at all. Consider the case where the flash
  492. device defines child methods. These would be used for *its* children, and
  493. would be quite separate from the methods defined by the driver for the bus
  494. that the flash device is connetced to. The act of attaching a device to a
  495. parent device which is a bus, causes the device to start behaving like a
  496. bus device, regardless of its own views on the matter.
  497. The uclass for the device can also contain data private to that uclass.
  498. But note that each device on the bus may be a member of a different
  499. uclass, and this data has nothing to do with the child data for each child
  500. on the bus. It is the bus' uclass that controls the child with respect to
  501. the bus.
  502. Driver Lifecycle
  503. ----------------
  504. Here are the stages that a device goes through in driver model. Note that all
  505. methods mentioned here are optional - e.g. if there is no probe() method for
  506. a device then it will not be called. A simple device may have very few
  507. methods actually defined.
  508. Bind stage
  509. ^^^^^^^^^^
  510. U-Boot discovers devices using one of these two methods:
  511. - Scan the U_BOOT_DEVICE() definitions. U-Boot looks up the name specified
  512. by each, to find the appropriate U_BOOT_DRIVER() definition. In this case,
  513. there is no path by which driver_data may be provided, but the U_BOOT_DEVICE()
  514. may provide platdata.
  515. - Scan through the device tree definitions. U-Boot looks at top-level
  516. nodes in the the device tree. It looks at the compatible string in each node
  517. and uses the of_match table of the U_BOOT_DRIVER() structure to find the
  518. right driver for each node. In this case, the of_match table may provide a
  519. driver_data value, but platdata cannot be provided until later.
  520. For each device that is discovered, U-Boot then calls device_bind() to create a
  521. new device, initializes various core fields of the device object such as name,
  522. uclass & driver, initializes any optional fields of the device object that are
  523. applicable such as of_offset, driver_data & platdata, and finally calls the
  524. driver's bind() method if one is defined.
  525. At this point all the devices are known, and bound to their drivers. There
  526. is a 'struct udevice' allocated for all devices. However, nothing has been
  527. activated (except for the root device). Each bound device that was created
  528. from a U_BOOT_DEVICE() declaration will hold the platdata pointer specified
  529. in that declaration. For a bound device created from the device tree,
  530. platdata will be NULL, but of_offset will be the offset of the device tree
  531. node that caused the device to be created. The uclass is set correctly for
  532. the device.
  533. The device's bind() method is permitted to perform simple actions, but
  534. should not scan the device tree node, not initialise hardware, nor set up
  535. structures or allocate memory. All of these tasks should be left for
  536. the probe() method.
  537. Note that compared to Linux, U-Boot's driver model has a separate step of
  538. probe/remove which is independent of bind/unbind. This is partly because in
  539. U-Boot it may be expensive to probe devices and we don't want to do it until
  540. they are needed, or perhaps until after relocation.
  541. Reading ofdata
  542. ^^^^^^^^^^^^^^
  543. Most devices have data in the device tree which they can read to find out the
  544. base address of hardware registers and parameters relating to driver
  545. operation. This is called 'ofdata' (Open-Firmware data).
  546. The device's_ofdata_to_platdata() implemnents allocation and reading of
  547. platdata. A parent's ofdata is always read before a child.
  548. The steps are:
  549. 1. If priv_auto_alloc_size is non-zero, then the device-private space
  550. is allocated for the device and zeroed. It will be accessible as
  551. dev->priv. The driver can put anything it likes in there, but should use
  552. it for run-time information, not platform data (which should be static
  553. and known before the device is probed).
  554. 2. If platdata_auto_alloc_size is non-zero, then the platform data space
  555. is allocated. This is only useful for device tree operation, since
  556. otherwise you would have to specific the platform data in the
  557. U_BOOT_DEVICE() declaration. The space is allocated for the device and
  558. zeroed. It will be accessible as dev->platdata.
  559. 3. If the device's uclass specifies a non-zero per_device_auto_alloc_size,
  560. then this space is allocated and zeroed also. It is allocated for and
  561. stored in the device, but it is uclass data. owned by the uclass driver.
  562. It is possible for the device to access it.
  563. 4. If the device's immediate parent specifies a per_child_auto_alloc_size
  564. then this space is allocated. This is intended for use by the parent
  565. device to keep track of things related to the child. For example a USB
  566. flash stick attached to a USB host controller would likely use this
  567. space. The controller can hold information about the USB state of each
  568. of its children.
  569. 5. If the driver provides an ofdata_to_platdata() method, then this is
  570. called to convert the device tree data into platform data. This should
  571. do various calls like dev_read_u32(dev, ...) to access the node and store
  572. the resulting information into dev->platdata. After this point, the device
  573. works the same way whether it was bound using a device tree node or
  574. U_BOOT_DEVICE() structure. In either case, the platform data is now stored
  575. in the platdata structure. Typically you will use the
  576. platdata_auto_alloc_size feature to specify the size of the platform data
  577. structure, and U-Boot will automatically allocate and zero it for you before
  578. entry to ofdata_to_platdata(). But if not, you can allocate it yourself in
  579. ofdata_to_platdata(). Note that it is preferable to do all the device tree
  580. decoding in ofdata_to_platdata() rather than in probe(). (Apart from the
  581. ugliness of mixing configuration and run-time data, one day it is possible
  582. that U-Boot will cache platform data for devices which are regularly
  583. de/activated).
  584. 5. The device is marked 'platdata valid'.
  585. Note that ofdata reading is always done (for a child and all its parents)
  586. before probing starts. Thus devices go through two distinct states when
  587. probing: reading platform data and actually touching the hardware to bring
  588. the device up.
  589. Having probing separate from ofdata-reading helps deal with of-platdata, where
  590. the probe() method is common to both DT/of-platdata operation, but the
  591. ofdata_to_platdata() method is implemented differently.
  592. Another case has come up where this separate is useful. Generation of ACPI
  593. tables uses the of-platdata but does not want to probe the device. Probing
  594. would cause U-Boot to violate one of its design principles, viz that it
  595. should only probe devices that are used. For ACPI we want to generate a
  596. table for each device, even if U-Boot does not use it. In fact it may not
  597. even be possible to probe the device - e.g. an SD card which is not
  598. present will cause an error on probe, yet we still must tell Linux about
  599. the SD card connector in case it is used while Linux is running.
  600. It is important that the ofdata_to_platdata() method does not actually probe
  601. the device itself. However there are cases where other devices must be probed
  602. in the ofdata_to_platdata() method. An example is where a device requires a
  603. GPIO for it to operate. To select a GPIO obviously requires that the GPIO
  604. device is probed. This is OK when used by common, core devices such as GPIO,
  605. clock, interrupts, reset and the like.
  606. If your device relies on its parent setting up a suitable address space, so
  607. that dev_read_addr() works correctly, then make sure that the parent device
  608. has its setup code in ofdata_to_platdata(). If it has it in the probe method,
  609. then you cannot call dev_read_addr() from the child device's
  610. ofdata_to_platdata() method. Move it to probe() instead. Buses like PCI can
  611. fall afoul of this rule.
  612. Activation/probe
  613. ^^^^^^^^^^^^^^^^
  614. When a device needs to be used, U-Boot activates it, by first reading ofdata
  615. as above and then following these steps (see device_probe()):
  616. 1. All parent devices are probed. It is not possible to activate a device
  617. unless its predecessors (all the way up to the root device) are activated.
  618. This means (for example) that an I2C driver will require that its bus
  619. be activated.
  620. 2. The device's sequence number is assigned, either the requested one
  621. (assuming no conflicts) or the next available one if there is a conflict
  622. or nothing particular is requested.
  623. 4. The device's probe() method is called. This should do anything that
  624. is required by the device to get it going. This could include checking
  625. that the hardware is actually present, setting up clocks for the
  626. hardware and setting up hardware registers to initial values. The code
  627. in probe() can access:
  628. - platform data in dev->platdata (for configuration)
  629. - private data in dev->priv (for run-time state)
  630. - uclass data in dev->uclass_priv (for things the uclass stores
  631. about this device)
  632. Note: If you don't use priv_auto_alloc_size then you will need to
  633. allocate the priv space here yourself. The same applies also to
  634. platdata_auto_alloc_size. Remember to free them in the remove() method.
  635. 5. The device is marked 'activated'
  636. 10. The uclass's post_probe() method is called, if one exists. This may
  637. cause the uclass to do some housekeeping to record the device as
  638. activated and 'known' by the uclass.
  639. Running stage
  640. ^^^^^^^^^^^^^
  641. The device is now activated and can be used. From now until it is removed
  642. all of the above structures are accessible. The device appears in the
  643. uclass's list of devices (so if the device is in UCLASS_GPIO it will appear
  644. as a device in the GPIO uclass). This is the 'running' state of the device.
  645. Removal stage
  646. ^^^^^^^^^^^^^
  647. When the device is no-longer required, you can call device_remove() to
  648. remove it. This performs the probe steps in reverse:
  649. 1. The uclass's pre_remove() method is called, if one exists. This may
  650. cause the uclass to do some housekeeping to record the device as
  651. deactivated and no-longer 'known' by the uclass.
  652. 2. All the device's children are removed. It is not permitted to have
  653. an active child device with a non-active parent. This means that
  654. device_remove() is called for all the children recursively at this point.
  655. 3. The device's remove() method is called. At this stage nothing has been
  656. deallocated so platform data, private data and the uclass data will all
  657. still be present. This is where the hardware can be shut down. It is
  658. intended that the device be completely inactive at this point, For U-Boot
  659. to be sure that no hardware is running, it should be enough to remove
  660. all devices.
  661. 4. The device memory is freed (platform data, private data, uclass data,
  662. parent data).
  663. Note: Because the platform data for a U_BOOT_DEVICE() is defined with a
  664. static pointer, it is not de-allocated during the remove() method. For
  665. a device instantiated using the device tree data, the platform data will
  666. be dynamically allocated, and thus needs to be deallocated during the
  667. remove() method, either:
  668. - if the platdata_auto_alloc_size is non-zero, the deallocation
  669. happens automatically within the driver model core; or
  670. - when platdata_auto_alloc_size is 0, both the allocation (in probe()
  671. or preferably ofdata_to_platdata()) and the deallocation in remove()
  672. are the responsibility of the driver author.
  673. 5. The device sequence number is set to -1, meaning that it no longer
  674. has an allocated sequence. If the device is later reactivated and that
  675. sequence number is still free, it may well receive the name sequence
  676. number again. But from this point, the sequence number previously used
  677. by this device will no longer exist (think of SPI bus 2 being removed
  678. and bus 2 is no longer available for use).
  679. 6. The device is marked inactive. Note that it is still bound, so the
  680. device structure itself is not freed at this point. Should the device be
  681. activated again, then the cycle starts again at step 2 above.
  682. Unbind stage
  683. ^^^^^^^^^^^^
  684. The device is unbound. This is the step that actually destroys the device.
  685. If a parent has children these will be destroyed first. After this point
  686. the device does not exist and its memory has be deallocated.
  687. Data Structures
  688. ---------------
  689. Driver model uses a doubly-linked list as the basic data structure. Some
  690. nodes have several lists running through them. Creating a more efficient
  691. data structure might be worthwhile in some rare cases, once we understand
  692. what the bottlenecks are.
  693. Changes since v1
  694. ----------------
  695. For the record, this implementation uses a very similar approach to the
  696. original patches, but makes at least the following changes:
  697. - Tried to aggressively remove boilerplate, so that for most drivers there
  698. is little or no 'driver model' code to write.
  699. - Moved some data from code into data structure - e.g. store a pointer to
  700. the driver operations structure in the driver, rather than passing it
  701. to the driver bind function.
  702. - Rename some structures to make them more similar to Linux (struct udevice
  703. instead of struct instance, struct platdata, etc.)
  704. - Change the name 'core' to 'uclass', meaning U-Boot class. It seems that
  705. this concept relates to a class of drivers (or a subsystem). We shouldn't
  706. use 'class' since it is a C++ reserved word, so U-Boot class (uclass) seems
  707. better than 'core'.
  708. - Remove 'struct driver_instance' and just use a single 'struct udevice'.
  709. This removes a level of indirection that doesn't seem necessary.
  710. - Built in device tree support, to avoid the need for platdata
  711. - Removed the concept of driver relocation, and just make it possible for
  712. the new driver (created after relocation) to access the old driver data.
  713. I feel that relocation is a very special case and will only apply to a few
  714. drivers, many of which can/will just re-init anyway. So the overhead of
  715. dealing with this might not be worth it.
  716. - Implemented a GPIO system, trying to keep it simple
  717. Pre-Relocation Support
  718. ----------------------
  719. For pre-relocation we simply call the driver model init function. Only
  720. drivers marked with DM_FLAG_PRE_RELOC or the device tree 'u-boot,dm-pre-reloc'
  721. property are initialised prior to relocation. This helps to reduce the driver
  722. model overhead. This flag applies to SPL and TPL as well, if device tree is
  723. enabled (CONFIG_OF_CONTROL) there.
  724. Note when device tree is enabled, the device tree 'u-boot,dm-pre-reloc'
  725. property can provide better control granularity on which device is bound
  726. before relocation. While with DM_FLAG_PRE_RELOC flag of the driver all
  727. devices with the same driver are bound, which requires allocation a large
  728. amount of memory. When device tree is not used, DM_FLAG_PRE_RELOC is the
  729. only way for statically declared devices via U_BOOT_DEVICE() to be bound
  730. prior to relocation.
  731. It is possible to limit this to specific relocation steps, by using
  732. the more specialized 'u-boot,dm-spl' and 'u-boot,dm-tpl' flags
  733. in the device tree node. For U-Boot proper you can use 'u-boot,dm-pre-proper'
  734. which means that it will be processed (and a driver bound) in U-Boot proper
  735. prior to relocation, but will not be available in SPL or TPL.
  736. To reduce the size of SPL and TPL, only the nodes with pre-relocation properties
  737. ('u-boot,dm-pre-reloc', 'u-boot,dm-spl' or 'u-boot,dm-tpl') are keept in their
  738. device trees (see README.SPL for details); the remaining nodes are always bound.
  739. Then post relocation we throw that away and re-init driver model again.
  740. For drivers which require some sort of continuity between pre- and
  741. post-relocation devices, we can provide access to the pre-relocation
  742. device pointers, but this is not currently implemented (the root device
  743. pointer is saved but not made available through the driver model API).
  744. SPL Support
  745. -----------
  746. Driver model can operate in SPL. Its efficient implementation and small code
  747. size provide for a small overhead which is acceptable for all but the most
  748. constrained systems.
  749. To enable driver model in SPL, define CONFIG_SPL_DM. You might want to
  750. consider the following option also. See the main README for more details.
  751. - CONFIG_SYS_MALLOC_SIMPLE
  752. - CONFIG_DM_WARN
  753. - CONFIG_DM_DEVICE_REMOVE
  754. - CONFIG_DM_STDIO
  755. Enabling Driver Model
  756. ---------------------
  757. Driver model is being brought into U-Boot gradually. As each subsystems gets
  758. support, a uclass is created and a CONFIG to enable use of driver model for
  759. that subsystem.
  760. For example CONFIG_DM_SERIAL enables driver model for serial. With that
  761. defined, the old serial support is not enabled, and your serial driver must
  762. conform to driver model. With that undefined, the old serial support is
  763. enabled and driver model is not available for serial. This means that when
  764. you convert a driver, you must either convert all its boards, or provide for
  765. the driver to be compiled both with and without driver model (generally this
  766. is not very hard).
  767. See the main README for full details of the available driver model CONFIG
  768. options.
  769. Things to punt for later
  770. ------------------------
  771. Uclasses are statically numbered at compile time. It would be possible to
  772. change this to dynamic numbering, but then we would require some sort of
  773. lookup service, perhaps searching by name. This is slightly less efficient
  774. so has been left out for now. One small advantage of dynamic numbering might
  775. be fewer merge conflicts in uclass-id.h.