Lines Matching refs:that
5 These calls use the gpio_* naming prefix. No other calls should use that
16 which GPIOs. Drivers can be written generically, so that board setup code
24 also "GPIO Expander" chips that connect using the I2C or SPI serial busses.
31 options about how that value is driven, so that for example only one
58 Note that this is called a "convention" because you don't need to do it this
61 glue logic that may even change between board revisions, and can't ever be
62 used on a board that's wired differently. Only least-common-denominator
64 and that can be critical for glue logic.
76 ARCH_WANT_OPTIONAL_GPIOLIB in their Kconfig. Drivers that can't work without
86 Note that these operations include I/O barriers on platforms which need to
94 "not available on this board", or indicating faults. Code that doesn't
98 for the GPIO lines so that board-specific setup code directly corresponds
100 numbers passed to them from that setup code, using platform_data to hold
111 some negative number (perhaps "-EINVAL"); that will never be valid. To
117 A number that's not valid will be rejected by calls which may request
122 implementation issue, as are whether that support can leave "holes" in the space
148 of a GPIO implicitly requests that GPIO (see below) if it has not been
153 that particular GPIO can't be used in that mode. It's generally a bad
156 that board setup code probably needs to multiplex that pin as a GPIO,
177 pin ... that won't always match the specified output value, because of
181 been reported earlier from gpio_direction_*(). However, note that not all
182 platforms can read the value of output pins; those that can't should always
183 return zero. Also, using these calls for GPIOs that can't safely be accessed
195 GPIO access that may sleep
202 Platforms that support this type of GPIO distinguish them from other GPIOs
221 Other than the fact that these accessors might sleep, and will work
222 on GPIOs that can't be accessed from hardIRQ handlers, these calls act
256 GPIOs that have already been claimed with that call. The return value of
265 (a) two or more drivers wrongly think they have exclusive use of that
267 needed to manage a signal that's in active use. That is, requesting a
274 For GPIOs that use pins known to the pinctrl subsystem, that subsystem should
281 Any programming of pin multiplexing hardware that is needed to route the
290 pullup/pulldown. Platform software should arrange that any such details are
292 the pinctrl subsystem's mapping table, so that GPIO users need not be aware
295 Also note that it's your responsibility to have stopped using a GPIO
335 When setting the flag as GPIOF_OPEN_DRAIN then it will assume that pins is
341 When setting the flag as GPIOF_OPEN_SOURCE then it will assume that pins is
394 number that wasn't set up as an input using gpio_direction_input(), or
395 to use an IRQ number that didn't originally come from gpio_to_irq().
402 devices, by the board-specific initialization code. Note that IRQ trigger
408 when the IRQ is edge-triggered. Note that some platforms don't support
425 there's a common idiom you can use to emulate it with any GPIO pin that can
437 common example, that's how I2C clocks are stretched: a slave that needs a
446 subsystem, in the sense that the pins can be used by other functions
466 that different pin ranges in a SoC is managed by different gpio drivers.
491 come from systems that run Linux today.)
496 pullups (or pulldowns) so that the on-chip ones should not be used.
502 There are other system-specific mechanisms that are not specified here,
504 Hardware may support reading or writing GPIOs in gangs, but that's usually
529 with information common to each controller of that type:
551 either NULL or the label associated with that GPIO when it was requested.
558 and arrange that its <asm/gpio.h> includes <asm-generic/gpio.h> and defines
561 It may also provide a custom value for ARCH_NR_GPIOS, so that it better
562 reflects the number of GPIOs in actual use on that platform, without
566 ARCH_REQUIRE_GPIOLIB means that the gpiolib code will always get compiled
567 into the kernel on that architecture.
602 registering controller devices and ensures that their drivers know what GPIO
607 of GPIOs that chip will expose, and passes them to each GPIO expander chip
608 using platform_data. Then the chip driver's probe() routine could pass that
612 an I2C-based GPIO, its probe() routine should only be called after that GPIO
614 calls for that GPIO can work. One way to address such dependencies is for
630 know for example that GPIO #23 controls the write protect line used to
632 may need to temporarily remove that protection, first importing a GPIO,
638 userspace GPIO can be used to determine system configuration data that
640 GPIO drivers could be all that the system really needs.
642 Note that standard kernel drivers exist for common "LEDs and Buttons"
668 for GPIO #19, if that's not requested by kernel code.
684 configure the GPIO as an output with that initial value.
686 Note that this attribute *will not exist* if the kernel
688 it was exported by kernel code that didn't explicitly
697 description of "edge"), you can poll(2) on that file and
707 that will make poll(2) on the "value" file return.
763 of experiments easier), or can provide an always-there interface that's