add lvds1024*800

hc

2024-01-31 f70575805708cabdedea7498aaa3f710fde4d920

 kernel/drivers/soc/rockchip/rockchip_decompress.c
..
..
@@ -93,32 +93,67 @@
93
93
 
94
94
 static struct rk_decom *g_decom;
95
95
 
96
-static DECLARE_WAIT_QUEUE_HEAD(initrd_decom_done);
97
-static bool initrd_continue;
96
+static DECLARE_WAIT_QUEUE_HEAD(g_decom_wait);
97
+static bool g_decom_complete;
98
+static bool g_decom_noblocking;
99
+static u64 g_decom_data_len;
98
100
 
99
101
 void __init wait_initrd_hw_decom_done(void)
100
102
 {
101
-	wait_event(initrd_decom_done, initrd_continue);
103
+	wait_event(g_decom_wait, g_decom_complete);
102
104
 }
105
+
106
+int rk_decom_wait_done(u32 timeout, u64 *decom_len)
107
+{
108
+	int ret;
109
+
110
+	if (!decom_len)
111
+		return -EINVAL;
112
+
113
+	ret = wait_event_timeout(g_decom_wait, g_decom_complete, timeout * HZ);
114
+	if (!ret) {
115
+		if (g_decom)
116
+			clk_bulk_disable_unprepare(g_decom->num_clocks, g_decom->clocks);
117
+
118
+		return -ETIMEDOUT;
119
+	}
120
+
121
+	*decom_len = g_decom_data_len;
122
+
123
+	return 0;
124
+}
125
+EXPORT_SYMBOL(rk_decom_wait_done);
103
126
 
104
127
 static DECLARE_WAIT_QUEUE_HEAD(decom_init_done);
105
128
 
106
129
 int rk_decom_start(u32 mode, phys_addr_t src, phys_addr_t dst, u32 dst_max_size)
107
130
 {
131
+	int ret;
108
132
 	u32 irq_status;
109
133
 	u32 decom_enr;
110
-
111
-	pr_info("%s: mode %u src %pa dst %pa max_size %u\n",
112
-		__func__, mode, &src, &dst, dst_max_size);
134
+	u32 decom_mode = rk_get_decom_mode(mode);
113
135
 
114
136
 	wait_event_timeout(decom_init_done, g_decom, HZ);
115
137
 	if (!g_decom)
116
138
 		return -EINVAL;
117
139
 
140
+	if (g_decom->mem_start)
141
+		pr_info("%s: mode %u src %pa dst %pa max_size %u\n",
142
+			__func__, mode, &src, &dst, dst_max_size);
143
+
144
+	ret = clk_bulk_prepare_enable(g_decom->num_clocks, g_decom->clocks);
145
+	if (ret)
146
+		return ret;
147
+
148
+	g_decom_complete   = false;
149
+	g_decom_data_len   = 0;
150
+	g_decom_noblocking = rk_get_noblocking_flag(mode);
151
+
118
152
 	decom_enr = readl(g_decom->regs + DECOM_ENR);
119
153
 	if (decom_enr & 0x1) {
120
154
 		pr_err("decompress busy\n");
121
-		return -EBUSY;
155
+		ret = -EBUSY;
156
+		goto error;
122
157
 	}
123
158
 
124
159
 	if (g_decom->reset) {
..
..
@@ -132,7 +167,7 @@
132
167
 	if (irq_status)
133
168
 		writel(irq_status, g_decom->regs + DECOM_ISR);
134
169
 
135
-	switch (mode) {
170
+	switch (decom_mode) {
136
171
 	case LZ4_MOD:
137
172
 		writel(LZ4_CONT_CSUM_CHECK_EN |
138
173
 		       LZ4_HEAD_CSUM_CHECK_EN |
..
..
@@ -148,8 +183,9 @@
148
183
 		       g_decom->regs + DECOM_CTRL);
149
184
 		break;
150
185
 	default:
151
-		pr_err("undefined mode : %d\n", mode);
152
-		return -EINVAL;
186
+		pr_err("undefined mode : %d\n", decom_mode);
187
+		ret = -EINVAL;
188
+		goto error;
153
189
 	}
154
190
 
155
191
 	writel(src, g_decom->regs + DECOM_RADDR);
..
..
@@ -161,9 +197,11 @@
161
197
 	writel(DECOM_INT_MASK, g_decom->regs + DECOM_IEN);
162
198
 	writel(DECOM_ENABLE, g_decom->regs + DECOM_ENR);
163
199
 
164
-	pr_info("%s: started\n", __func__);
165
-
166
200
 	return 0;
201
+error:
202
+	clk_bulk_disable_unprepare(g_decom->num_clocks, g_decom->clocks);
203
+
204
+	return ret;
167
205
 }
168
206
 EXPORT_SYMBOL(rk_decom_start);
169
207
 
..
..
@@ -179,9 +217,15 @@
179
217
 	if (irq_status & DECOM_STOP) {
180
218
 		decom_status = readl(rk_dec->regs + DECOM_STAT);
181
219
 		if (decom_status & DECOM_COMPLETE) {
182
-			initrd_continue = true;
183
-			wake_up(&initrd_decom_done);
184
-			dev_info(rk_dec->dev, "decom completed\n");
220
+			g_decom_complete = true;
221
+			g_decom_data_len = readl(rk_dec->regs + DECOM_TSIZEH);
222
+			g_decom_data_len = (g_decom_data_len << 32) |
223
+					   readl(rk_dec->regs + DECOM_TSIZEL);
224
+			wake_up(&g_decom_wait);
225
+			if (rk_dec->mem_start)
226
+				dev_info(rk_dec->dev,
227
+					 "decom completed, decom_data_len = %llu\n",
228
+					 g_decom_data_len);
185
229
 		} else {
186
230
 			dev_info(rk_dec->dev,
187
231
 				 "decom failed, irq_status = 0x%x, decom_status = 0x%x, try again !\n",
..
..
@@ -190,7 +234,18 @@
190
234
 			print_hex_dump(KERN_WARNING, "", DUMP_PREFIX_OFFSET,
191
235
 				       32, 4, rk_dec->regs, 0x128, false);
192
236
 
193
-			writel(DECOM_ENABLE, rk_dec->regs + DECOM_ENR);
237
+			if (g_decom_noblocking) {
238
+				dev_info(rk_dec->dev, "decom failed and exit in noblocking mode.");
239
+				writel(DECOM_DISABLE, rk_dec->regs + DECOM_ENR);
240
+				writel(0, g_decom->regs + DECOM_IEN);
241
+
242
+				g_decom_complete  = true;
243
+				g_decom_data_len = 0;
244
+				g_decom_noblocking = false;
245
+				wake_up(&g_decom_wait);
246
+			} else {
247
+				writel(DECOM_ENABLE, rk_dec->regs + DECOM_ENR);
248
+			}
194
249
 		}
195
250
 	}
196
251
 
..
..
@@ -201,16 +256,20 @@
201
256
 {
202
257
 	struct rk_decom *rk_dec = priv;
203
258
 
204
-	if (initrd_continue) {
259
+	if (g_decom_complete) {
205
260
 		void *start, *end;
206
261
 
207
-		/*
208
-		 * Now it is safe to free reserve memory that
209
-		 * store the origin ramdisk file
210
-		 */
211
-		start = phys_to_virt(rk_dec->mem_start);
212
-		end = start + rk_dec->mem_size;
213
-		free_reserved_area(start, end, -1, "ramdisk gzip archive");
262
+		if (rk_dec->mem_start) {
263
+			/*
264
+			 * Now it is safe to free reserve memory that
265
+			 * store the origin ramdisk file
266
+			 */
267
+			start = phys_to_virt(rk_dec->mem_start);
268
+			end = start + rk_dec->mem_size;
269
+			free_reserved_area(start, end, -1, "ramdisk gzip archive");
270
+			rk_dec->mem_start = 0;
271
+		}
272
+
214
273
 		clk_bulk_disable_unprepare(rk_dec->num_clocks, rk_dec->clocks);
215
274
 	}
216
275
 
..
..
@@ -259,10 +318,6 @@
259
318
 		dev_err(dev, "failed to get decompress clock\n");
260
319
 		return -ENODEV;
261
320
 	}
262
-
263
-	ret = clk_bulk_prepare_enable(rk_dec->num_clocks, rk_dec->clocks);
264
-	if (ret)
265
-		return ret;
266
321
 
267
322
 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
268
323
 	rk_dec->regs = devm_ioremap_resource(dev, res);