change system file

hc

2024-10-09 244b2c5ca8b14627e4a17755e5922221e121c771

 kernel/drivers/spi/spi-pxa2xx-dma.c
..
..
@@ -1,12 +1,9 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
1
2
 /*
2
3
  * PXA2xx SPI DMA engine support.
3
4
  *
4
5
  * Copyright (C) 2013, Intel Corporation
5
6
  * Author: Mika Westerberg <mika.westerberg@linux.intel.com>
6
- *
7
- * This program is free software; you can redistribute it and/or modify
8
- * it under the terms of the GNU General Public License version 2 as
9
- * published by the Free Software Foundation.
10
7
  */
11
8
 
12
9
 #include <linux/device.h>
..
..
@@ -23,7 +20,7 @@
23
20
 static void pxa2xx_spi_dma_transfer_complete(struct driver_data *drv_data,
24
21
 					     bool error)
25
22
 {
26
-	struct spi_message *msg = drv_data->master->cur_msg;
23
+	struct spi_message *msg = drv_data->controller->cur_msg;
27
24
 
28
25
 	/*
29
26
 	 * It is possible that one CPU is handling ROR interrupt and other
..
..
@@ -59,7 +56,7 @@
59
56
 			msg->status = -EIO;
60
57
 		}
61
58
 
62
-		spi_finalize_current_transfer(drv_data->master);
59
+		spi_finalize_current_transfer(drv_data->controller);
63
60
 	}
64
61
 }
65
62
 
..
..
@@ -74,7 +71,7 @@
74
71
 			   struct spi_transfer *xfer)
75
72
 {
76
73
 	struct chip_data *chip =
77
-		spi_get_ctldata(drv_data->master->cur_msg->spi);
74
+		spi_get_ctldata(drv_data->controller->cur_msg->spi);
78
75
 	enum dma_slave_buswidth width;
79
76
 	struct dma_slave_config cfg;
80
77
 	struct dma_chan *chan;
..
..
@@ -102,14 +99,14 @@
102
99
 		cfg.dst_maxburst = chip->dma_burst_size;
103
100
 
104
101
 		sgt = &xfer->tx_sg;
105
-		chan = drv_data->master->dma_tx;
102
+		chan = drv_data->controller->dma_tx;
106
103
 	} else {
107
104
 		cfg.src_addr = drv_data->ssdr_physical;
108
105
 		cfg.src_addr_width = width;
109
106
 		cfg.src_maxburst = chip->dma_burst_size;
110
107
 
111
108
 		sgt = &xfer->rx_sg;
112
-		chan = drv_data->master->dma_rx;
109
+		chan = drv_data->controller->dma_rx;
113
110
 	}
114
111
 
115
112
 	ret = dmaengine_slave_config(chan, &cfg);
..
..
@@ -130,8 +127,8 @@
130
127
 	if (status & SSSR_ROR) {
131
128
 		dev_err(&drv_data->pdev->dev, "FIFO overrun\n");
132
129
 
133
-		dmaengine_terminate_async(drv_data->master->dma_rx);
134
-		dmaengine_terminate_async(drv_data->master->dma_tx);
130
+		dmaengine_terminate_async(drv_data->controller->dma_rx);
131
+		dmaengine_terminate_async(drv_data->controller->dma_tx);
135
132
 
136
133
 		pxa2xx_spi_dma_transfer_complete(drv_data, true);
137
134
 		return IRQ_HANDLED;
..
..
@@ -171,15 +168,15 @@
171
168
 	return 0;
172
169
 
173
170
 err_rx:
174
-	dmaengine_terminate_async(drv_data->master->dma_tx);
171
+	dmaengine_terminate_async(drv_data->controller->dma_tx);
175
172
 err_tx:
176
173
 	return err;
177
174
 }
178
175
 
179
176
 void pxa2xx_spi_dma_start(struct driver_data *drv_data)
180
177
 {
181
-	dma_async_issue_pending(drv_data->master->dma_rx);
182
-	dma_async_issue_pending(drv_data->master->dma_tx);
178
+	dma_async_issue_pending(drv_data->controller->dma_rx);
179
+	dma_async_issue_pending(drv_data->controller->dma_tx);
183
180
 
184
181
 	atomic_set(&drv_data->dma_running, 1);
185
182
 }
..
..
@@ -187,30 +184,30 @@
187
184
 void pxa2xx_spi_dma_stop(struct driver_data *drv_data)
188
185
 {
189
186
 	atomic_set(&drv_data->dma_running, 0);
190
-	dmaengine_terminate_sync(drv_data->master->dma_rx);
191
-	dmaengine_terminate_sync(drv_data->master->dma_tx);
187
+	dmaengine_terminate_sync(drv_data->controller->dma_rx);
188
+	dmaengine_terminate_sync(drv_data->controller->dma_tx);
192
189
 }
193
190
 
194
191
 int pxa2xx_spi_dma_setup(struct driver_data *drv_data)
195
192
 {
196
-	struct pxa2xx_spi_master *pdata = drv_data->master_info;
193
+	struct pxa2xx_spi_controller *pdata = drv_data->controller_info;
197
194
 	struct device *dev = &drv_data->pdev->dev;
198
-	struct spi_controller *master = drv_data->master;
195
+	struct spi_controller *controller = drv_data->controller;
199
196
 	dma_cap_mask_t mask;
200
197
 
201
198
 	dma_cap_zero(mask);
202
199
 	dma_cap_set(DMA_SLAVE, mask);
203
200
 
204
-	master->dma_tx = dma_request_slave_channel_compat(mask,
201
+	controller->dma_tx = dma_request_slave_channel_compat(mask,
205
202
 				pdata->dma_filter, pdata->tx_param, dev, "tx");
206
-	if (!master->dma_tx)
203
+	if (!controller->dma_tx)
207
204
 		return -ENODEV;
208
205
 
209
-	master->dma_rx = dma_request_slave_channel_compat(mask,
206
+	controller->dma_rx = dma_request_slave_channel_compat(mask,
210
207
 				pdata->dma_filter, pdata->rx_param, dev, "rx");
211
-	if (!master->dma_rx) {
212
-		dma_release_channel(master->dma_tx);
213
-		master->dma_tx = NULL;
208
+	if (!controller->dma_rx) {
209
+		dma_release_channel(controller->dma_tx);
210
+		controller->dma_tx = NULL;
214
211
 		return -ENODEV;
215
212
 	}
216
213
 
..
..
@@ -219,17 +216,17 @@
219
216
 
220
217
 void pxa2xx_spi_dma_release(struct driver_data *drv_data)
221
218
 {
222
-	struct spi_controller *master = drv_data->master;
219
+	struct spi_controller *controller = drv_data->controller;
223
220
 
224
-	if (master->dma_rx) {
225
-		dmaengine_terminate_sync(master->dma_rx);
226
-		dma_release_channel(master->dma_rx);
227
-		master->dma_rx = NULL;
221
+	if (controller->dma_rx) {
222
+		dmaengine_terminate_sync(controller->dma_rx);
223
+		dma_release_channel(controller->dma_rx);
224
+		controller->dma_rx = NULL;
228
225
 	}
229
-	if (master->dma_tx) {
230
-		dmaengine_terminate_sync(master->dma_tx);
231
-		dma_release_channel(master->dma_tx);
232
-		master->dma_tx = NULL;
226
+	if (controller->dma_tx) {
227
+		dmaengine_terminate_sync(controller->dma_tx);
228
+		dma_release_channel(controller->dma_tx);
229
+		controller->dma_tx = NULL;
233
230
 	}
234
231
 }
235
232
 
..
..
@@ -239,13 +236,15 @@
239
236
 					   u32 *threshold)
240
237
 {
241
238
 	struct pxa2xx_spi_chip *chip_info = spi->controller_data;
239
+	struct driver_data *drv_data = spi_controller_get_devdata(spi->controller);
240
+	u32 dma_burst_size = drv_data->controller_info->dma_burst_size;
242
241
 
243
242
 	/*
244
243
 	 * If the DMA burst size is given in chip_info we use that,
245
244
 	 * otherwise we use the default. Also we use the default FIFO
246
245
 	 * thresholds for now.
247
246
 	 */
248
-	*burst_code = chip_info ? chip_info->dma_burst_size : 1;
247
+	*burst_code = chip_info ? chip_info->dma_burst_size : dma_burst_size;
249
248
 	*threshold = SSCR1_RxTresh(RX_THRESH_DFLT)
250
249
 		   | SSCR1_TxTresh(TX_THRESH_DFLT);
251
250