add xenomai

hc

2024-11-01 2f529f9b558ca1c1bd74be7437a84e4711743404

 kernel/drivers/dma/virt-dma.c
..
..
@@ -23,11 +23,11 @@
23
23
 	unsigned long flags;
24
24
 	dma_cookie_t cookie;
25
25
 
26
-	spin_lock_irqsave(&vc->lock, flags);
26
+	vchan_lock_irqsave(vc, flags);
27
27
 	cookie = dma_cookie_assign(tx);
28
28
 
29
29
 	list_move_tail(&vd->node, &vc->desc_submitted);
30
-	spin_unlock_irqrestore(&vc->lock, flags);
30
+	vchan_unlock_irqrestore(vc, flags);
31
31
 
32
32
 	dev_dbg(vc->chan.device->dev, "vchan %p: txd %p[%x]: submitted\n",
33
33
 		vc, vd, cookie);
..
..
@@ -52,9 +52,9 @@
52
52
 	struct virt_dma_desc *vd = to_virt_desc(tx);
53
53
 	unsigned long flags;
54
54
 
55
-	spin_lock_irqsave(&vc->lock, flags);
55
+	vchan_lock_irqsave(vc, flags);
56
56
 	list_del(&vd->node);
57
-	spin_unlock_irqrestore(&vc->lock, flags);
57
+	vchan_unlock_irqrestore(vc, flags);
58
58
 
59
59
 	dev_dbg(vc->chan.device->dev, "vchan %p: txd %p[%x]: freeing\n",
60
60
 		vc, vd, vd->tx.cookie);
..
..
@@ -87,7 +87,7 @@
87
87
 	struct dmaengine_desc_callback cb;
88
88
 	LIST_HEAD(head);
89
89
 
90
-	spin_lock_irq(&vc->lock);
90
+	vchan_lock_irq(vc);
91
91
 	list_splice_tail_init(&vc->desc_completed, &head);
92
92
 	vd = vc->cyclic;
93
93
 	if (vd) {
..
..
@@ -96,7 +96,7 @@
96
96
 	} else {
97
97
 		memset(&cb, 0, sizeof(cb));
98
98
 	}
99
-	spin_unlock_irq(&vc->lock);
99
+	vchan_unlock_irq(vc);
100
100
 
101
101
 	dmaengine_desc_callback_invoke(&cb, &vd->tx_result);
102
102
 
..
..
@@ -120,11 +120,119 @@
120
120
 }
121
121
 EXPORT_SYMBOL_GPL(vchan_dma_desc_free_list);
122
122
 
123
+#ifdef CONFIG_DMA_VIRTUAL_CHANNELS_OOB
124
+
125
+static void inband_init_chan_lock(struct virt_dma_chan *vc)
126
+{
127
+	spin_lock_init(&vc->lock);
128
+}
129
+
130
+static void inband_lock_chan(struct virt_dma_chan *vc)
131
+{
132
+	spin_lock(&vc->lock);
133
+}
134
+
135
+static void inband_unlock_chan(struct virt_dma_chan *vc)
136
+{
137
+	spin_unlock(&vc->lock);
138
+}
139
+
140
+static void inband_lock_irq_chan(struct virt_dma_chan *vc)
141
+{
142
+	spin_lock_irq(&vc->lock);
143
+}
144
+
145
+static void inband_unlock_irq_chan(struct virt_dma_chan *vc)
146
+{
147
+	spin_unlock_irq(&vc->lock);
148
+}
149
+
150
+static unsigned long inband_lock_irqsave_chan(struct virt_dma_chan *vc)
151
+{
152
+	unsigned long flags;
153
+
154
+	spin_lock_irqsave(&vc->lock, flags);
155
+
156
+	return flags;
157
+}
158
+
159
+static void inband_unlock_irqrestore_chan(struct virt_dma_chan *vc,
160
+			unsigned long flags)
161
+{
162
+	spin_unlock_irqrestore(&vc->lock, flags);
163
+}
164
+
165
+static struct virt_dma_lockops inband_lock_ops = {
166
+	.init			= inband_init_chan_lock,
167
+	.lock			= inband_lock_chan,
168
+	.unlock			= inband_unlock_chan,
169
+	.lock_irq		= inband_lock_irq_chan,
170
+	.unlock_irq		= inband_unlock_irq_chan,
171
+	.lock_irqsave		= inband_lock_irqsave_chan,
172
+	.unlock_irqrestore	= inband_unlock_irqrestore_chan,
173
+};
174
+
175
+static void oob_init_chan_lock(struct virt_dma_chan *vc)
176
+{
177
+	raw_spin_lock_init(&vc->oob_lock);
178
+}
179
+
180
+static void oob_lock_chan(struct virt_dma_chan *vc)
181
+{
182
+	raw_spin_lock(&vc->oob_lock);
183
+}
184
+
185
+static void oob_unlock_chan(struct virt_dma_chan *vc)
186
+{
187
+	raw_spin_unlock(&vc->oob_lock);
188
+}
189
+
190
+static void oob_lock_irq_chan(struct virt_dma_chan *vc)
191
+{
192
+	raw_spin_lock_irq(&vc->oob_lock);
193
+}
194
+
195
+static void oob_unlock_irq_chan(struct virt_dma_chan *vc)
196
+{
197
+	raw_spin_unlock_irq(&vc->oob_lock);
198
+}
199
+
200
+static unsigned long oob_lock_irqsave_chan(struct virt_dma_chan *vc)
201
+{
202
+	unsigned long flags;
203
+
204
+	raw_spin_lock_irqsave(&vc->oob_lock, flags);
205
+
206
+	return flags;
207
+}
208
+
209
+static void oob_unlock_irqrestore_chan(struct virt_dma_chan *vc,
210
+				unsigned long flags)
211
+{
212
+	raw_spin_unlock_irqrestore(&vc->oob_lock, flags);
213
+}
214
+
215
+static struct virt_dma_lockops oob_lock_ops = {
216
+	.init			= oob_init_chan_lock,
217
+	.lock			= oob_lock_chan,
218
+	.unlock			= oob_unlock_chan,
219
+	.lock_irq		= oob_lock_irq_chan,
220
+	.unlock_irq		= oob_unlock_irq_chan,
221
+	.lock_irqsave		= oob_lock_irqsave_chan,
222
+	.unlock_irqrestore	= oob_unlock_irqrestore_chan,
223
+};
224
+
225
+#endif
226
+
123
227
 void vchan_init(struct virt_dma_chan *vc, struct dma_device *dmadev)
124
228
 {
125
229
 	dma_cookie_init(&vc->chan);
126
230
 
127
-	spin_lock_init(&vc->lock);
231
+#ifdef CONFIG_DMA_VIRTUAL_CHANNELS_OOB
232
+	vc->lock_ops = test_bit(DMA_OOB, dmadev->cap_mask.bits) ?
233
+		&oob_lock_ops : &inband_lock_ops;
234
+#endif
235
+	vchan_lock_init(vc);
128
236
 	INIT_LIST_HEAD(&vc->desc_allocated);
129
237
 	INIT_LIST_HEAD(&vc->desc_submitted);
130
238
 	INIT_LIST_HEAD(&vc->desc_issued);