| /Linux-v5.4/virt/lib/ |
| D | irqbypass.c | 87 struct irq_bypass_consumer *consumer; in irq_bypass_register_producer() local
107 list_for_each_entry(consumer, &consumers, node) { in irq_bypass_register_producer()
108 if (consumer->token == producer->token) { in irq_bypass_register_producer()
109 int ret = __connect(producer, consumer); in irq_bypass_register_producer()
132 * and disconnect it from any connected IRQ consumer.
137 struct irq_bypass_consumer *consumer; in irq_bypass_unregister_producer() local
153 list_for_each_entry(consumer, &consumers, node) { in irq_bypass_unregister_producer()
154 if (consumer->token == producer->token) { in irq_bypass_unregister_producer()
155 __disconnect(producer, consumer); in irq_bypass_unregister_producer()
172 * irq_bypass_register_consumer - register IRQ bypass consumer
[all …]
|
| /Linux-v5.4/drivers/pps/ |
| D | kc.c | 3 * PPS kernel consumer API
23 /* state variables to bind kernel consumer */
25 /* PPS API (RFC 2783): current source and mode for kernel consumer */
27 static int pps_kc_hardpps_mode; /* mode bits for kernel consumer */
29 /* pps_kc_bind - control PPS kernel consumer binding
31 * @bind_args: kernel consumer bind parameters
33 * This function is used to bind or unbind PPS kernel consumer according to
38 /* Check if another consumer is already bound */ in pps_kc_bind()
47 " consumer\n"); in pps_kc_bind()
50 dev_err(pps->dev, "selected kernel consumer" in pps_kc_bind()
[all …]
|
| /Linux-v5.4/Documentation/driver-api/iio/ |
| D | hw-consumer.rst | 2 HW consumer
5 case the buffers between IIO provider and IIO consumer are handled by hardware.
6 The Industrial I/O HW consumer offers a way to bond these IIO devices without
8 :file:`drivers/iio/buffer/hw-consumer.c`
11 * struct :c:type:`iio_hw_consumer` — Hardware consumer structure
12 * :c:func:`iio_hw_consumer_alloc` — Allocate IIO hardware consumer
13 * :c:func:`iio_hw_consumer_free` — Free IIO hardware consumer
14 * :c:func:`iio_hw_consumer_enable` — Enable IIO hardware consumer
15 * :c:func:`iio_hw_consumer_disable` — Disable IIO hardware consumer
18 HW consumer setup
[all …]
|
| /Linux-v5.4/Documentation/power/regulator/ |
| D | overview.rst | 39 - Consumer
43 Static: consumer does not change its supply voltage or
48 Dynamic: consumer needs to change its supply voltage or
59 Regulator -+-> Switch-1 -+-> Switch-2 --> [Consumer A]
61 | +-> [Consumer B], [Consumer C]
63 +-> [Consumer D], [Consumer E]
69 - Domain 3: Consumer A.
78 Regulator-1 -+-> Regulator-2 -+-> [Consumer A]
80 +-> [Consumer B]
84 - Domain 1: Regulator-2, Consumer B.
[all …]
|
| D | consumer.rst | 2 Regulator Consumer Driver Interface
5 This text describes the regulator interface for consumer device drivers.
9 1. Consumer Regulator Access (static & dynamic drivers)
12 A consumer driver can get access to its supply regulator by calling ::
16 The consumer passes in its struct device pointer and power supply ID. The core
19 regulator that supplies this consumer.
21 To release the regulator the consumer driver should call ::
25 Consumers can be supplied by more than one regulator e.g. codec consumer with
39 A consumer can enable its power supply by calling::
45 This may happen if the consumer shares the regulator or the regulator has been
[all …]
|
| D | machine.rst | 10 Regulator-1 -+-> Regulator-2 --> [Consumer A @ 1.8 - 2.0V]
12 +-> [Consumer B @ 3.3V]
20 const char *dev_name; /* consumer dev_name() */
21 const char *supply; /* consumer supply - e.g. "vcc" */
27 REGULATOR_SUPPLY("Vcc", "consumer B"),
31 REGULATOR_SUPPLY("Vcc", "consumer A"),
34 This maps Regulator-1 to the 'Vcc' supply for Consumer B and maps Regulator-2
35 to the 'Vcc' supply for Consumer A.
59 with the core so that Regulator-1 is also enabled when Consumer A enables its
|
| /Linux-v5.4/Documentation/driver-api/ |
| D | device_link.rst | 33 "supplier" device and its "consumer" devices, and it guarantees driver
34 presence on the supplier. The consumer devices are not probed before the
46 whenever and for as long as the consumer is runtime resumed.
53 :c:func:`device_initialize()` has been called for the consumer.
64 represents a driver presence dependency, yet is added from the consumer's
67 consumer in the first place. The onus is thus on the consumer to check
69 non-presence. [Note that it is valid to create a link from the consumer's
70 ``->probe`` callback while the supplier is still probing, but the consumer must
72 the case, for instance, if the consumer has just acquired some resources that
76 is added in the ``->probe`` callback of the supplier or consumer driver, it is
[all …]
|
| D | regulator.rst | 40 Consumer
49 regulator and all consumer devices. The configuration of the regulator
58 Consumer driver interface
61 This offers a similar API to the kernel clock framework. Consumer
79 regulators. Consumer devices use the :c:func:`regulator_enable()` and
86 cause the supply provided by the regulator to be disabled. Consumer
92 Some consumer devices may need to be able to dynamically configure their
160 .. kernel-doc:: include/linux/regulator/consumer.h
|
| /Linux-v5.4/Documentation/core-api/ |
| D | circular-buffers.rst | 15 (2) Memory barriers for when the producer and the consumer of objects in the
19 producer and just one consumer. It is possible to handle multiple producers by
31 - The consumer.
44 (2) A 'tail' index - the point at which the consumer finds the next item in
115 but the consumer may still be depleting the buffer on another CPU and
118 To the consumer it will show an upper bound as the producer may be busy
121 (2) CIRC_CNT*() are intended to be used in the consumer. To the consumer they
122 will return a lower bound as the consumer controls the tail index, but the
126 To the producer it will show an upper bound as the consumer may be busy
130 producer and consumer become visible cannot be guaranteed as they are
[all …]
|
| /Linux-v5.4/drivers/staging/iio/Documentation/ |
| D | inkernel.txt | 20 consumer_dev_name allows identification of the consumer device.
21 This are then used to find the channel mapping from the consumer device (see
24 Finally consumer_channel is a string identifying the channel to the consumer.
37 to associate a given channel with the consumer requesting it.
39 Acting as an IIO consumer (consumer.h)
41 The consumer first has to obtain an iio_channel structure from the core
55 with a given consumer. This is useful for generic drivers such as
57 consumer driver. To do this, use iio_channel_get_all.
|
| /Linux-v5.4/drivers/gpio/ |
| D | gpiolib-devres.c | 12 #include <linux/gpio/consumer.h>
48 * @dev: GPIO consumer
49 * @con_id: function within the GPIO consumer
66 * @dev: GPIO consumer
67 * @con_id: function within the GPIO consumer
84 * @dev: GPIO consumer
85 * @con_id: function within the GPIO consumer
86 * @idx: index of the GPIO to obtain in the consumer
137 * @index: index of the GPIO to obtain for the consumer
190 * @dev: GPIO consumer
[all …]
|
| /Linux-v5.4/arch/arm/mach-sti/ |
| D | Kconfig | 3 bool "STMicroelectronics Consumer Electronics SOCs"
30 bool "STiH415 STMicroelectronics Consumer Electronics family"
33 This enables support for STMicroelectronics Digital Consumer
39 bool "STiH416 STMicroelectronics Consumer Electronics family"
42 This enables support for STMicroelectronics Digital Consumer
48 bool "STiH407 STMicroelectronics Consumer Electronics family"
52 This enables support for STMicroelectronics Digital Consumer
|
| /Linux-v5.4/kernel/trace/ |
| D | ring_buffer_benchmark.c | 34 static struct task_struct *consumer; variable
55 MODULE_PARM_DESC(consumer_nice, "nice prio for consumer");
61 MODULE_PARM_DESC(consumer_fifo, "fifo prio for consumer");
267 if (consumer && !(cnt % wakeup_interval)) in ring_buffer_producer()
268 wake_up_process(consumer); in ring_buffer_producer()
286 if (consumer) { in ring_buffer_producer()
293 wake_up_process(consumer); in ring_buffer_producer()
307 trace_printk("Running Consumer at nice: %d\n", in ring_buffer_producer()
310 trace_printk("Running Consumer at SCHED_FIFO %d\n", in ring_buffer_producer()
406 if (consumer) { in ring_buffer_producer_thread()
[all …]
|
| /Linux-v5.4/net/xdp/ |
| D | xsk_queue.h | 18 u32 consumer ____cacheline_aligned_in_smp;
49 * ring, the kernel is the producer and user space is the consumer. For
50 * the Tx and fill rings, the kernel is the consumer and user space is
53 * producer consumer
55 * if (LOAD ->consumer) { LOAD ->producer
59 * STORE ->producer STORE ->consumer
65 * the producer pointer. If this barrier was missing, the consumer
67 * before the producer has written the new data. The consumer would in
70 * (C) protects the consumer from speculatively loading the data before
76 * (A) is a control dependency that separates the load of ->consumer
[all …]
|
| /Linux-v5.4/include/linux/ |
| D | irqbypass.h | 27 * callbacks. Match tokens must be unique per producer/consumer, 1:N pairings
34 * @token: opaque token to match between producer and consumer (non-NULL)
36 * @add_consumer: Connect the IRQ producer to an IRQ consumer (optional)
37 * @del_consumer: Disconnect the IRQ producer from an IRQ consumer (optional)
58 * struct irq_bypass_consumer - IRQ bypass consumer definition
60 * @token: opaque token to match between producer and consumer (non-NULL)
61 * @add_producer: Connect the IRQ consumer to an IRQ producer
62 * @del_producer: Disconnect the IRQ consumer from an IRQ producer
66 * The IRQ bypass consumer structure represents an interrupt sink for
|
| D | clk.h | 80 * @id: clock consumer ID
277 * @dev: device for clock "consumer"
278 * @id: clock consumer ID
282 * uses @dev and @id to determine the clock consumer, and thereby
294 * @dev: device for clock "consumer"
296 * @clks: the clk_bulk_data table of consumer
305 * clock consumer, and thereby the clock producer.
317 * @dev: device for clock "consumer"
318 * @clks: pointer to the clk_bulk_data table of consumer
337 * @dev: device for clock "consumer"
[all …]
|
| D | ptr_ring.h | 14 * single producer and a single consumer CPU.
35 /* Shared consumer/producer data */
36 /* Read-only by both the producer and the consumer */
119 * Note: resize (below) nests producer lock within consumer lock, so if you
248 /* Fundamentally, what we want to do is update consumer in __ptr_ring_discard_one()
251 * consumer = r->consumer; in __ptr_ring_discard_one()
252 * r->queue[consumer++] = NULL; in __ptr_ring_discard_one()
253 * if (unlikely(consumer >= r->size)) in __ptr_ring_discard_one()
254 * consumer = 0; in __ptr_ring_discard_one()
255 * r->consumer = consumer; in __ptr_ring_discard_one()
[all …]
|
| /Linux-v5.4/drivers/iio/buffer/ |
| D | industrialio-hw-consumer.c | 13 #include <linux/iio/consumer.h>
14 #include <linux/iio/hw-consumer.h>
18 * struct iio_hw_consumer - IIO hw consumer block
78 * iio_hw_consumer_alloc() - Allocate IIO hardware consumer
79 * @dev: Pointer to consumer device.
126 * iio_hw_consumer_free() - Free IIO hardware consumer
127 * @hwc: hw consumer to free.
158 * @dev: Pointer to consumer device.
191 * @dev: Pointer to consumer device.
207 * iio_hw_consumer_enable() - Enable IIO hardware consumer
[all …]
|
| /Linux-v5.4/Documentation/infiniband/ |
| D | core_locking.rst | 64 example, a consumer may safely call ib_poll_cq() on multiple CPUs
73 allowed for a low-level driver to call a consumer's completion event
87 consumer CQ event callback:
91 /* ... */ consumer CQ event callback:
110 semaphores that could cause deadlock if a consumer calls back into
113 An upper level protocol consumer may begin using an IB device as
115 device. A consumer must finish all cleanup and free all resources
118 A consumer is permitted to sleep in its add and remove methods.
|
| /Linux-v5.4/include/linux/iio/ |
| D | consumer.h | 3 * Industrial I/O in kernel consumer interface
18 * struct iio_channel - everything needed for a consumer to use a channel
21 * @data: Data about the channel used by consumer.
31 * @dev: Pointer to consumer device. Device name must match
33 * with which the desired provider to consumer mapping
35 * @consumer_channel: Unique name to identify the channel on the consumer
37 * the consumer. E.g. 'battery_voltage'
50 * @dev: Pointer to consumer device. Device name must match
52 * with which the desired provider to consumer mapping
54 * @consumer_channel: Unique name to identify the channel on the consumer
[all …]
|
| D | machine.h | 12 * struct iio_map - description of link between consumer and device channels
16 * @consumer_dev_name: Name to uniquely identify the consumer device.
18 * consumer side.
19 * @consumer_data: Data about the channel for use by the consumer driver.
|
| /Linux-v5.4/Documentation/devicetree/bindings/net/ |
| D | mdio-mux-multiplexer.txt | 1 Properties for an MDIO bus multiplexer consumer device
3 This is a special case of MDIO mux when MDIO mux is defined as a consumer
13 each child node of mdio bus multiplexer consumer device represent a mdio
21 In below example the Mux producer and consumer are separate nodes.
38 mdio-mux-1 { // Mux consumer
61 mdio-mux-2 { // Mux consumer
|
| /Linux-v5.4/drivers/mmc/host/ |
| D | mmci_qcom_dml.c | 60 /* Set producer CRCI-x and disable consumer CRCI */ in qcom_dma_start()
79 /* Write operation: configure DML for consumer operation */ in qcom_dma_start()
80 /* Set consumer CRCI-x and disable producer CRCI*/ in qcom_dma_start()
89 /* Trigger consumer */ in qcom_dma_start()
142 /* Disable the producer and consumer CRCI */ in qcom_dma_setup()
165 * and consumer. in qcom_dma_setup()
172 /* Initialize Producer/consumer pipe id */ in qcom_dma_setup()
|
| /Linux-v5.4/Documentation/crypto/ |
| D | intro.rst | 50 transformation objects is held by a crypto API consumer or another
52 consumer requests a transformation implementation. The consumer is then
68 returned to the consumer. Therefore, please refer to all initialization
69 API calls that refer to the data structure type a consumer is expected
|
| /Linux-v5.4/Documentation/networking/ |
| D | af_xdp.rst | 64 single-consumer / single-producer (for performance reasons), the new
116 The UMEM has two single-producer/single-consumer rings, that are used
124 TX. All rings are single-producer/single-consumer, so the user-space
133 The rings are head(producer)/tail(consumer) based rings. A producer
135 producer member, and increasing the producer index. A consumer reads
136 the data ring at the index pointed out by struct xdp_ring consumer
137 member, and increasing the consumer index.
245 // __u32 *consumer;
251 // __u32 *consumer;
263 __u32 entries = *ring->producer - *ring->consumer;
[all …]
|
