1 /* 2 * Common SPI Interface: Controller-specific definitions 3 * 4 * (C) Copyright 2001 5 * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com. 6 * 7 * SPDX-License-Identifier: GPL-2.0+ 8 */ 9 10 #ifndef _SPI_H_ 11 #define _SPI_H_ 12 13 #include <common.h> 14 15 /* SPI mode flags */ 16 #define SPI_CPHA BIT(0) /* clock phase */ 17 #define SPI_CPOL BIT(1) /* clock polarity */ 18 #define SPI_MODE_0 (0|0) /* (original MicroWire) */ 19 #define SPI_MODE_1 (0|SPI_CPHA) 20 #define SPI_MODE_2 (SPI_CPOL|0) 21 #define SPI_MODE_3 (SPI_CPOL|SPI_CPHA) 22 #define SPI_CS_HIGH BIT(2) /* CS active high */ 23 #define SPI_LSB_FIRST BIT(3) /* per-word bits-on-wire */ 24 #define SPI_3WIRE BIT(4) /* SI/SO signals shared */ 25 #define SPI_LOOP BIT(5) /* loopback mode */ 26 #define SPI_SLAVE BIT(6) /* slave mode */ 27 #define SPI_PREAMBLE BIT(7) /* Skip preamble bytes */ 28 #define SPI_TX_BYTE BIT(8) /* transmit with 1 wire byte */ 29 #define SPI_TX_DUAL BIT(9) /* transmit with 2 wires */ 30 #define SPI_TX_QUAD BIT(10) /* transmit with 4 wires */ 31 #define SPI_RX_SLOW BIT(11) /* receive with 1 wire slow */ 32 #define SPI_RX_DUAL BIT(12) /* receive with 2 wires */ 33 #define SPI_RX_QUAD BIT(13) /* receive with 4 wires */ 34 #define SPI_TX_OCTAL BIT(14) /* transmit with 8 wires */ 35 #define SPI_RX_OCTAL BIT(15) /* receive with 8 wires */ 36 #define SPI_DMA_PREPARE BIT(24) /* dma transfer skip waiting idle */ 37 38 /* Header byte that marks the start of the message */ 39 #define SPI_PREAMBLE_END_BYTE 0xec 40 41 #define SPI_DEFAULT_WORDLEN 8 42 43 /** 44 * struct dm_spi_bus - SPI bus info 45 * 46 * This contains information about a SPI bus. To obtain this structure, use 47 * dev_get_uclass_priv(bus) where bus is the SPI bus udevice. 48 * 49 * @max_hz: Maximum speed that the bus can tolerate. 50 * @speed: Current bus speed. This is 0 until the bus is first claimed. 51 * @mode: Current bus mode. This is 0 until the bus is first claimed. 52 * 53 * TODO(sjg@chromium.org): Remove this and use max_hz from struct spi_slave. 54 */ 55 struct dm_spi_bus { 56 uint max_hz; 57 uint speed; 58 uint mode; 59 }; 60 61 /** 62 * struct dm_spi_platdata - platform data for all SPI slaves 63 * 64 * This describes a SPI slave, a child device of the SPI bus. To obtain this 65 * struct from a spi_slave, use dev_get_parent_platdata(dev) or 66 * dev_get_parent_platdata(slave->dev). 67 * 68 * This data is immuatable. Each time the device is probed, @max_hz and @mode 69 * will be copied to struct spi_slave. 70 * 71 * @cs: Chip select number (0..n-1) 72 * @max_hz: Maximum bus speed that this slave can tolerate 73 * @mode: SPI mode to use for this device (see SPI mode flags) 74 */ 75 struct dm_spi_slave_platdata { 76 unsigned int cs; 77 uint max_hz; 78 uint mode; 79 }; 80 81 /** 82 * struct spi_slave - Representation of a SPI slave 83 * 84 * For driver model this is the per-child data used by the SPI bus. It can 85 * be accessed using dev_get_parent_priv() on the slave device. The SPI uclass 86 * sets uip per_child_auto_alloc_size to sizeof(struct spi_slave), and the 87 * driver should not override it. Two platform data fields (max_hz and mode) 88 * are copied into this structure to provide an initial value. This allows 89 * them to be changed, since we should never change platform data in drivers. 90 * 91 * If not using driver model, drivers are expected to extend this with 92 * controller-specific data. 93 * 94 * @dev: SPI slave device 95 * @max_hz: Maximum speed for this slave 96 * @bus: ID of the bus that the slave is attached to. For 97 * driver model this is the sequence number of the SPI 98 * bus (bus->seq) so does not need to be stored 99 * @cs: ID of the chip select connected to the slave. 100 * @mode: SPI mode to use for this slave (see SPI mode flags) 101 * @wordlen: Size of SPI word in number of bits 102 * @max_read_size: If non-zero, the maximum number of bytes which can 103 * be read at once. 104 * @max_write_size: If non-zero, the maximum number of bytes which can 105 * be written at once. 106 * @memory_map: Address of read-only SPI flash access. 107 * @flags: Indication of SPI flags. 108 */ 109 struct spi_slave { 110 #ifdef CONFIG_DM_SPI 111 struct udevice *dev; /* struct spi_slave is dev->parentdata */ 112 uint max_hz; 113 #else 114 unsigned int bus; 115 unsigned int cs; 116 #endif 117 uint mode; 118 unsigned int wordlen; 119 unsigned int max_read_size; 120 unsigned int max_write_size; 121 void *memory_map; 122 u8 option; 123 124 u8 flags; 125 #define SPI_XFER_BEGIN BIT(0) /* Assert CS before transfer */ 126 #define SPI_XFER_END BIT(1) /* Deassert CS after transfer */ 127 #define SPI_XFER_ONCE (SPI_XFER_BEGIN | SPI_XFER_END) 128 #define SPI_XFER_MMAP BIT(2) /* Memory Mapped start */ 129 #define SPI_XFER_MMAP_END BIT(3) /* Memory Mapped End */ 130 #define SPI_XFER_PREPARE BIT(7) /* Transfer skip waiting idle */ 131 }; 132 133 /** 134 * Initialization, must be called once on start up. 135 * 136 * TODO: I don't think we really need this. 137 */ 138 void spi_init(void); 139 140 /** 141 * spi_do_alloc_slave - Allocate a new SPI slave (internal) 142 * 143 * Allocate and zero all fields in the spi slave, and set the bus/chip 144 * select. Use the helper macro spi_alloc_slave() to call this. 145 * 146 * @offset: Offset of struct spi_slave within slave structure. 147 * @size: Size of slave structure. 148 * @bus: Bus ID of the slave chip. 149 * @cs: Chip select ID of the slave chip on the specified bus. 150 */ 151 void *spi_do_alloc_slave(int offset, int size, unsigned int bus, 152 unsigned int cs); 153 154 /** 155 * spi_alloc_slave - Allocate a new SPI slave 156 * 157 * Allocate and zero all fields in the spi slave, and set the bus/chip 158 * select. 159 * 160 * @_struct: Name of structure to allocate (e.g. struct tegra_spi). 161 * This structure must contain a member 'struct spi_slave *slave'. 162 * @bus: Bus ID of the slave chip. 163 * @cs: Chip select ID of the slave chip on the specified bus. 164 */ 165 #define spi_alloc_slave(_struct, bus, cs) \ 166 spi_do_alloc_slave(offsetof(_struct, slave), \ 167 sizeof(_struct), bus, cs) 168 169 /** 170 * spi_alloc_slave_base - Allocate a new SPI slave with no private data 171 * 172 * Allocate and zero all fields in the spi slave, and set the bus/chip 173 * select. 174 * 175 * @bus: Bus ID of the slave chip. 176 * @cs: Chip select ID of the slave chip on the specified bus. 177 */ 178 #define spi_alloc_slave_base(bus, cs) \ 179 spi_do_alloc_slave(0, sizeof(struct spi_slave), bus, cs) 180 181 /** 182 * Set up communications parameters for a SPI slave. 183 * 184 * This must be called once for each slave. Note that this function 185 * usually doesn't touch any actual hardware, it only initializes the 186 * contents of spi_slave so that the hardware can be easily 187 * initialized later. 188 * 189 * @bus: Bus ID of the slave chip. 190 * @cs: Chip select ID of the slave chip on the specified bus. 191 * @max_hz: Maximum SCK rate in Hz. 192 * @mode: Clock polarity, clock phase and other parameters. 193 * 194 * Returns: A spi_slave reference that can be used in subsequent SPI 195 * calls, or NULL if one or more of the parameters are not supported. 196 */ 197 struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs, 198 unsigned int max_hz, unsigned int mode); 199 200 /** 201 * Free any memory associated with a SPI slave. 202 * 203 * @slave: The SPI slave 204 */ 205 void spi_free_slave(struct spi_slave *slave); 206 207 /** 208 * Claim the bus and prepare it for communication with a given slave. 209 * 210 * This must be called before doing any transfers with a SPI slave. It 211 * will enable and initialize any SPI hardware as necessary, and make 212 * sure that the SCK line is in the correct idle state. It is not 213 * allowed to claim the same bus for several slaves without releasing 214 * the bus in between. 215 * 216 * @slave: The SPI slave 217 * 218 * Returns: 0 if the bus was claimed successfully, or a negative value 219 * if it wasn't. 220 */ 221 int spi_claim_bus(struct spi_slave *slave); 222 223 /** 224 * Release the SPI bus 225 * 226 * This must be called once for every call to spi_claim_bus() after 227 * all transfers have finished. It may disable any SPI hardware as 228 * appropriate. 229 * 230 * @slave: The SPI slave 231 */ 232 void spi_release_bus(struct spi_slave *slave); 233 234 /** 235 * Set the word length for SPI transactions 236 * 237 * Set the word length (number of bits per word) for SPI transactions. 238 * 239 * @slave: The SPI slave 240 * @wordlen: The number of bits in a word 241 * 242 * Returns: 0 on success, -1 on failure. 243 */ 244 int spi_set_wordlen(struct spi_slave *slave, unsigned int wordlen); 245 246 /** 247 * SPI transfer (optional if mem_ops is used) 248 * 249 * This writes "bitlen" bits out the SPI MOSI port and simultaneously clocks 250 * "bitlen" bits in the SPI MISO port. That's just the way SPI works. 251 * 252 * The source of the outgoing bits is the "dout" parameter and the 253 * destination of the input bits is the "din" parameter. Note that "dout" 254 * and "din" can point to the same memory location, in which case the 255 * input data overwrites the output data (since both are buffered by 256 * temporary variables, this is OK). 257 * 258 * spi_xfer() interface: 259 * @slave: The SPI slave which will be sending/receiving the data. 260 * @bitlen: How many bits to write and read. 261 * @dout: Pointer to a string of bits to send out. The bits are 262 * held in a byte array and are sent MSB first. 263 * @din: Pointer to a string of bits that will be filled in. 264 * @flags: A bitwise combination of SPI_XFER_* flags. 265 * 266 * Returns: 0 on success, not 0 on failure 267 */ 268 int spi_xfer(struct spi_slave *slave, unsigned int bitlen, const void *dout, 269 void *din, unsigned long flags); 270 271 /** 272 * spi_write_then_read - SPI synchronous write followed by read 273 * 274 * This performs a half duplex transaction in which the first transaction 275 * is to send the opcode and if the length of buf is non-zero then it start 276 * the second transaction as tx or rx based on the need from respective slave. 277 * 278 * @slave: The SPI slave device with which opcode/data will be exchanged 279 * @opcode: opcode used for specific transfer 280 * @n_opcode: size of opcode, in bytes 281 * @txbuf: buffer into which data to be written 282 * @rxbuf: buffer into which data will be read 283 * @n_buf: size of buf (whether it's [tx|rx]buf), in bytes 284 * 285 * Returns: 0 on success, not 0 on failure 286 */ 287 int spi_write_then_read(struct spi_slave *slave, const u8 *opcode, 288 size_t n_opcode, const u8 *txbuf, u8 *rxbuf, 289 size_t n_buf); 290 291 /* Copy memory mapped data */ 292 void spi_flash_copy_mmap(void *data, void *offset, size_t len); 293 294 /** 295 * Determine if a SPI chipselect is valid. 296 * This function is provided by the board if the low-level SPI driver 297 * needs it to determine if a given chipselect is actually valid. 298 * 299 * Returns: 1 if bus:cs identifies a valid chip on this board, 0 300 * otherwise. 301 */ 302 int spi_cs_is_valid(unsigned int bus, unsigned int cs); 303 304 #ifndef CONFIG_DM_SPI 305 /** 306 * Activate a SPI chipselect. 307 * This function is provided by the board code when using a driver 308 * that can't control its chipselects automatically (e.g. 309 * common/soft_spi.c). When called, it should activate the chip select 310 * to the device identified by "slave". 311 */ 312 void spi_cs_activate(struct spi_slave *slave); 313 314 /** 315 * Deactivate a SPI chipselect. 316 * This function is provided by the board code when using a driver 317 * that can't control its chipselects automatically (e.g. 318 * common/soft_spi.c). When called, it should deactivate the chip 319 * select to the device identified by "slave". 320 */ 321 void spi_cs_deactivate(struct spi_slave *slave); 322 323 /** 324 * Set transfer speed. 325 * This sets a new speed to be applied for next spi_xfer(). 326 * @slave: The SPI slave 327 * @hz: The transfer speed 328 */ 329 void spi_set_speed(struct spi_slave *slave, uint hz); 330 #endif 331 332 /** 333 * Write 8 bits, then read 8 bits. 334 * @slave: The SPI slave we're communicating with 335 * @byte: Byte to be written 336 * 337 * Returns: The value that was read, or a negative value on error. 338 * 339 * TODO: This function probably shouldn't be inlined. 340 */ 341 static inline int spi_w8r8(struct spi_slave *slave, unsigned char byte) 342 { 343 unsigned char dout[2]; 344 unsigned char din[2]; 345 int ret; 346 347 dout[0] = byte; 348 dout[1] = 0; 349 350 ret = spi_xfer(slave, 16, dout, din, SPI_XFER_BEGIN | SPI_XFER_END); 351 return ret < 0 ? ret : din[1]; 352 } 353 354 #ifdef CONFIG_DM_SPI 355 356 /** 357 * struct spi_cs_info - Information about a bus chip select 358 * 359 * @dev: Connected device, or NULL if none 360 */ 361 struct spi_cs_info { 362 struct udevice *dev; 363 }; 364 365 /** 366 * struct struct dm_spi_ops - Driver model SPI operations 367 * 368 * The uclass interface is implemented by all SPI devices which use 369 * driver model. 370 */ 371 struct dm_spi_ops { 372 /** 373 * Claim the bus and prepare it for communication. 374 * 375 * The device provided is the slave device. It's parent controller 376 * will be used to provide the communication. 377 * 378 * This must be called before doing any transfers with a SPI slave. It 379 * will enable and initialize any SPI hardware as necessary, and make 380 * sure that the SCK line is in the correct idle state. It is not 381 * allowed to claim the same bus for several slaves without releasing 382 * the bus in between. 383 * 384 * @dev: The SPI slave 385 * 386 * Returns: 0 if the bus was claimed successfully, or a negative value 387 * if it wasn't. 388 */ 389 int (*claim_bus)(struct udevice *dev); 390 391 /** 392 * Release the SPI bus 393 * 394 * This must be called once for every call to spi_claim_bus() after 395 * all transfers have finished. It may disable any SPI hardware as 396 * appropriate. 397 * 398 * @dev: The SPI slave 399 */ 400 int (*release_bus)(struct udevice *dev); 401 402 /** 403 * Set the word length for SPI transactions 404 * 405 * Set the word length (number of bits per word) for SPI transactions. 406 * 407 * @bus: The SPI slave 408 * @wordlen: The number of bits in a word 409 * 410 * Returns: 0 on success, -ve on failure. 411 */ 412 int (*set_wordlen)(struct udevice *dev, unsigned int wordlen); 413 414 /** 415 * SPI transfer 416 * 417 * This writes "bitlen" bits out the SPI MOSI port and simultaneously 418 * clocks "bitlen" bits in the SPI MISO port. That's just the way SPI 419 * works. 420 * 421 * The source of the outgoing bits is the "dout" parameter and the 422 * destination of the input bits is the "din" parameter. Note that 423 * "dout" and "din" can point to the same memory location, in which 424 * case the input data overwrites the output data (since both are 425 * buffered by temporary variables, this is OK). 426 * 427 * spi_xfer() interface: 428 * @dev: The slave device to communicate with 429 * @bitlen: How many bits to write and read. 430 * @dout: Pointer to a string of bits to send out. The bits are 431 * held in a byte array and are sent MSB first. 432 * @din: Pointer to a string of bits that will be filled in. 433 * @flags: A bitwise combination of SPI_XFER_* flags. 434 * 435 * Returns: 0 on success, not -1 on failure 436 */ 437 int (*xfer)(struct udevice *dev, unsigned int bitlen, const void *dout, 438 void *din, unsigned long flags); 439 440 /** 441 * Optimized handlers for SPI memory-like operations. 442 * 443 * Optimized/dedicated operations for interactions with SPI memory. This 444 * field is optional and should only be implemented if the controller 445 * has native support for memory like operations. 446 */ 447 const struct spi_controller_mem_ops *mem_ops; 448 449 /** 450 * Set transfer speed. 451 * This sets a new speed to be applied for next spi_xfer(). 452 * @bus: The SPI bus 453 * @hz: The transfer speed 454 * @return 0 if OK, -ve on error 455 */ 456 int (*set_speed)(struct udevice *bus, uint hz); 457 458 /** 459 * Set the SPI mode/flags 460 * 461 * It is unclear if we want to set speed and mode together instead 462 * of separately. 463 * 464 * @bus: The SPI bus 465 * @mode: Requested SPI mode (SPI_... flags) 466 * @return 0 if OK, -ve on error 467 */ 468 int (*set_mode)(struct udevice *bus, uint mode); 469 470 /** 471 * Get information on a chip select 472 * 473 * This is only called when the SPI uclass does not know about a 474 * chip select, i.e. it has no attached device. It gives the driver 475 * a chance to allow activity on that chip select even so. 476 * 477 * @bus: The SPI bus 478 * @cs: The chip select (0..n-1) 479 * @info: Returns information about the chip select, if valid. 480 * On entry info->dev is NULL 481 * @return 0 if OK (and @info is set up), -ENODEV if the chip select 482 * is invalid, other -ve value on error 483 */ 484 int (*cs_info)(struct udevice *bus, uint cs, struct spi_cs_info *info); 485 486 /** 487 * get_mmap() - Get memory-mapped SPI 488 * 489 * @dev: The SPI flash slave device 490 * @map_basep: Returns base memory address for mapped SPI 491 * @map_sizep: Returns size of mapped SPI 492 * @offsetp: Returns start offset of SPI flash where the map works 493 * correctly (offsets before this are not visible) 494 * @return 0 if OK, -EFAULT if memory mapping is not available 495 */ 496 int (*get_mmap)(struct udevice *dev, ulong *map_basep, 497 uint *map_sizep, uint *offsetp); 498 }; 499 500 struct dm_spi_emul_ops { 501 /** 502 * SPI transfer 503 * 504 * This writes "bitlen" bits out the SPI MOSI port and simultaneously 505 * clocks "bitlen" bits in the SPI MISO port. That's just the way SPI 506 * works. Here the device is a slave. 507 * 508 * The source of the outgoing bits is the "dout" parameter and the 509 * destination of the input bits is the "din" parameter. Note that 510 * "dout" and "din" can point to the same memory location, in which 511 * case the input data overwrites the output data (since both are 512 * buffered by temporary variables, this is OK). 513 * 514 * spi_xfer() interface: 515 * @slave: The SPI slave which will be sending/receiving the data. 516 * @bitlen: How many bits to write and read. 517 * @dout: Pointer to a string of bits sent to the device. The 518 * bits are held in a byte array and are sent MSB first. 519 * @din: Pointer to a string of bits that will be sent back to 520 * the master. 521 * @flags: A bitwise combination of SPI_XFER_* flags. 522 * 523 * Returns: 0 on success, not -1 on failure 524 */ 525 int (*xfer)(struct udevice *slave, unsigned int bitlen, 526 const void *dout, void *din, unsigned long flags); 527 }; 528 529 /** 530 * spi_find_bus_and_cs() - Find bus and slave devices by number 531 * 532 * Given a bus number and chip select, this finds the corresponding bus 533 * device and slave device. Neither device is activated by this function, 534 * although they may have been activated previously. 535 * 536 * @busnum: SPI bus number 537 * @cs: Chip select to look for 538 * @busp: Returns bus device 539 * @devp: Return slave device 540 * @return 0 if found, -ENODEV on error 541 */ 542 int spi_find_bus_and_cs(int busnum, int cs, struct udevice **busp, 543 struct udevice **devp); 544 545 /** 546 * spi_get_bus_and_cs() - Find and activate bus and slave devices by number 547 * 548 * Given a bus number and chip select, this finds the corresponding bus 549 * device and slave device. 550 * 551 * If no such slave exists, and drv_name is not NULL, then a new slave device 552 * is automatically bound on this chip select with requested speed and mode. 553 * 554 * Ths new slave device is probed ready for use with the speed and mode 555 * from platdata when available or the requested values. 556 * 557 * @busnum: SPI bus number 558 * @cs: Chip select to look for 559 * @speed: SPI speed to use for this slave when not available in platdata 560 * @mode: SPI mode to use for this slave when not available in platdata 561 * @drv_name: Name of driver to attach to this chip select 562 * @dev_name: Name of the new device thus created 563 * @busp: Returns bus device 564 * @devp: Return slave device 565 * @return 0 if found, -ve on error 566 */ 567 int spi_get_bus_and_cs(int busnum, int cs, int speed, int mode, 568 const char *drv_name, const char *dev_name, 569 struct udevice **busp, struct spi_slave **devp); 570 571 /** 572 * spi_chip_select() - Get the chip select for a slave 573 * 574 * @return the chip select this slave is attached to 575 */ 576 int spi_chip_select(struct udevice *slave); 577 578 /** 579 * spi_find_chip_select() - Find the slave attached to chip select 580 * 581 * @bus: SPI bus to search 582 * @cs: Chip select to look for 583 * @devp: Returns the slave device if found 584 * @return 0 if found, -EINVAL if cs is invalid, -ENODEV if no device attached, 585 * other -ve value on error 586 */ 587 int spi_find_chip_select(struct udevice *bus, int cs, struct udevice **devp); 588 589 /** 590 * spi_slave_ofdata_to_platdata() - decode standard SPI platform data 591 * 592 * This decodes the speed and mode for a slave from a device tree node 593 * 594 * @blob: Device tree blob 595 * @node: Node offset to read from 596 * @plat: Place to put the decoded information 597 */ 598 int spi_slave_ofdata_to_platdata(struct udevice *dev, 599 struct dm_spi_slave_platdata *plat); 600 601 /** 602 * spi_cs_info() - Check information on a chip select 603 * 604 * This checks a particular chip select on a bus to see if it has a device 605 * attached, or is even valid. 606 * 607 * @bus: The SPI bus 608 * @cs: The chip select (0..n-1) 609 * @info: Returns information about the chip select, if valid 610 * @return 0 if OK (and @info is set up), -ENODEV if the chip select 611 * is invalid, other -ve value on error 612 */ 613 int spi_cs_info(struct udevice *bus, uint cs, struct spi_cs_info *info); 614 615 struct sandbox_state; 616 617 /** 618 * sandbox_spi_get_emul() - get an emulator for a SPI slave 619 * 620 * This provides a way to attach an emulated SPI device to a particular SPI 621 * slave, so that xfer() operations on the slave will be handled by the 622 * emulator. If a emulator already exists on that chip select it is returned. 623 * Otherwise one is created. 624 * 625 * @state: Sandbox state 626 * @bus: SPI bus requesting the emulator 627 * @slave: SPI slave device requesting the emulator 628 * @emuip: Returns pointer to emulator 629 * @return 0 if OK, -ve on error 630 */ 631 int sandbox_spi_get_emul(struct sandbox_state *state, 632 struct udevice *bus, struct udevice *slave, 633 struct udevice **emulp); 634 635 /** 636 * Claim the bus and prepare it for communication with a given slave. 637 * 638 * This must be called before doing any transfers with a SPI slave. It 639 * will enable and initialize any SPI hardware as necessary, and make 640 * sure that the SCK line is in the correct idle state. It is not 641 * allowed to claim the same bus for several slaves without releasing 642 * the bus in between. 643 * 644 * @dev: The SPI slave device 645 * 646 * Returns: 0 if the bus was claimed successfully, or a negative value 647 * if it wasn't. 648 */ 649 int dm_spi_claim_bus(struct udevice *dev); 650 651 /** 652 * Release the SPI bus 653 * 654 * This must be called once for every call to dm_spi_claim_bus() after 655 * all transfers have finished. It may disable any SPI hardware as 656 * appropriate. 657 * 658 * @slave: The SPI slave device 659 */ 660 void dm_spi_release_bus(struct udevice *dev); 661 662 /** 663 * SPI transfer 664 * 665 * This writes "bitlen" bits out the SPI MOSI port and simultaneously clocks 666 * "bitlen" bits in the SPI MISO port. That's just the way SPI works. 667 * 668 * The source of the outgoing bits is the "dout" parameter and the 669 * destination of the input bits is the "din" parameter. Note that "dout" 670 * and "din" can point to the same memory location, in which case the 671 * input data overwrites the output data (since both are buffered by 672 * temporary variables, this is OK). 673 * 674 * dm_spi_xfer() interface: 675 * @dev: The SPI slave device which will be sending/receiving the data. 676 * @bitlen: How many bits to write and read. 677 * @dout: Pointer to a string of bits to send out. The bits are 678 * held in a byte array and are sent MSB first. 679 * @din: Pointer to a string of bits that will be filled in. 680 * @flags: A bitwise combination of SPI_XFER_* flags. 681 * 682 * Returns: 0 on success, not 0 on failure 683 */ 684 int dm_spi_xfer(struct udevice *dev, unsigned int bitlen, 685 const void *dout, void *din, unsigned long flags); 686 687 /** 688 * spi_get_mmap() - Get memory-mapped SPI 689 * 690 * @dev: SPI slave device to check 691 * @map_basep: Returns base memory address for mapped SPI 692 * @map_sizep: Returns size of mapped SPI 693 * @offsetp: Returns start offset of SPI flash where the map works 694 * correctly (offsets before this are not visible) 695 * @return 0 if OK, -ENOSYS if no operation, -EFAULT if memory mapping is not 696 * available 697 */ 698 int dm_spi_get_mmap(struct udevice *dev, ulong *map_basep, uint *map_sizep, 699 uint *offsetp); 700 701 /* Access the operations for a SPI device */ 702 #define spi_get_ops(dev) ((struct dm_spi_ops *)(dev)->driver->ops) 703 #define spi_emul_get_ops(dev) ((struct dm_spi_emul_ops *)(dev)->driver->ops) 704 #endif /* CONFIG_DM_SPI */ 705 706 #endif /* _SPI_H_ */ 707