add new system file

hc

2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c

 kernel/arch/parisc/lib/iomap.c
..
..
@@ -43,19 +43,23 @@
43
43
 #endif
44
44
 
45
45
 struct iomap_ops {
46
-	unsigned int (*read8)(void __iomem *);
47
-	unsigned int (*read16)(void __iomem *);
48
-	unsigned int (*read16be)(void __iomem *);
49
-	unsigned int (*read32)(void __iomem *);
50
-	unsigned int (*read32be)(void __iomem *);
46
+	unsigned int (*read8)(const void __iomem *);
47
+	unsigned int (*read16)(const void __iomem *);
48
+	unsigned int (*read16be)(const void __iomem *);
49
+	unsigned int (*read32)(const void __iomem *);
50
+	unsigned int (*read32be)(const void __iomem *);
51
+	u64 (*read64)(const void __iomem *);
52
+	u64 (*read64be)(const void __iomem *);
51
53
 	void (*write8)(u8, void __iomem *);
52
54
 	void (*write16)(u16, void __iomem *);
53
55
 	void (*write16be)(u16, void __iomem *);
54
56
 	void (*write32)(u32, void __iomem *);
55
57
 	void (*write32be)(u32, void __iomem *);
56
-	void (*read8r)(void __iomem *, void *, unsigned long);
57
-	void (*read16r)(void __iomem *, void *, unsigned long);
58
-	void (*read32r)(void __iomem *, void *, unsigned long);
58
+	void (*write64)(u64, void __iomem *);
59
+	void (*write64be)(u64, void __iomem *);
60
+	void (*read8r)(const void __iomem *, void *, unsigned long);
61
+	void (*read16r)(const void __iomem *, void *, unsigned long);
62
+	void (*read32r)(const void __iomem *, void *, unsigned long);
59
63
 	void (*write8r)(void __iomem *, const void *, unsigned long);
60
64
 	void (*write16r)(void __iomem *, const void *, unsigned long);
61
65
 	void (*write32r)(void __iomem *, const void *, unsigned long);
..
..
@@ -65,17 +69,17 @@
65
69
 
66
70
 #define ADDR2PORT(addr) ((unsigned long __force)(addr) & 0xffffff)
67
71
 
68
-static unsigned int ioport_read8(void __iomem *addr)
72
+static unsigned int ioport_read8(const void __iomem *addr)
69
73
 {
70
74
 	return inb(ADDR2PORT(addr));
71
75
 }
72
76
 
73
-static unsigned int ioport_read16(void __iomem *addr)
77
+static unsigned int ioport_read16(const void __iomem *addr)
74
78
 {
75
79
 	return inw(ADDR2PORT(addr));
76
80
 }
77
81
 
78
-static unsigned int ioport_read32(void __iomem *addr)
82
+static unsigned int ioport_read32(const void __iomem *addr)
79
83
 {
80
84
 	return inl(ADDR2PORT(addr));
81
85
 }
..
..
@@ -95,17 +99,17 @@
95
99
 	outl(datum, ADDR2PORT(addr));
96
100
 }
97
101
 
98
-static void ioport_read8r(void __iomem *addr, void *dst, unsigned long count)
102
+static void ioport_read8r(const void __iomem *addr, void *dst, unsigned long count)
99
103
 {
100
104
 	insb(ADDR2PORT(addr), dst, count);
101
105
 }
102
106
 
103
-static void ioport_read16r(void __iomem *addr, void *dst, unsigned long count)
107
+static void ioport_read16r(const void __iomem *addr, void *dst, unsigned long count)
104
108
 {
105
109
 	insw(ADDR2PORT(addr), dst, count);
106
110
 }
107
111
 
108
-static void ioport_read32r(void __iomem *addr, void *dst, unsigned long count)
112
+static void ioport_read32r(const void __iomem *addr, void *dst, unsigned long count)
109
113
 {
110
114
 	insl(ADDR2PORT(addr), dst, count);
111
115
 }
..
..
@@ -146,29 +150,39 @@
146
150
 
147
151
 /* Legacy I/O memory ops */
148
152
 
149
-static unsigned int iomem_read8(void __iomem *addr)
153
+static unsigned int iomem_read8(const void __iomem *addr)
150
154
 {
151
155
 	return readb(addr);
152
156
 }
153
157
 
154
-static unsigned int iomem_read16(void __iomem *addr)
158
+static unsigned int iomem_read16(const void __iomem *addr)
155
159
 {
156
160
 	return readw(addr);
157
161
 }
158
162
 
159
-static unsigned int iomem_read16be(void __iomem *addr)
163
+static unsigned int iomem_read16be(const void __iomem *addr)
160
164
 {
161
165
 	return __raw_readw(addr);
162
166
 }
163
167
 
164
-static unsigned int iomem_read32(void __iomem *addr)
168
+static unsigned int iomem_read32(const void __iomem *addr)
165
169
 {
166
170
 	return readl(addr);
167
171
 }
168
172
 
169
-static unsigned int iomem_read32be(void __iomem *addr)
173
+static unsigned int iomem_read32be(const void __iomem *addr)
170
174
 {
171
175
 	return __raw_readl(addr);
176
+}
177
+
178
+static u64 iomem_read64(const void __iomem *addr)
179
+{
180
+	return readq(addr);
181
+}
182
+
183
+static u64 iomem_read64be(const void __iomem *addr)
184
+{
185
+	return __raw_readq(addr);
172
186
 }
173
187
 
174
188
 static void iomem_write8(u8 datum, void __iomem *addr)
..
..
@@ -196,7 +210,17 @@
196
210
 	__raw_writel(datum, addr);
197
211
 }
198
212
 
199
-static void iomem_read8r(void __iomem *addr, void *dst, unsigned long count)
213
+static void iomem_write64(u64 datum, void __iomem *addr)
214
+{
215
+	writel(datum, addr);
216
+}
217
+
218
+static void iomem_write64be(u64 datum, void __iomem *addr)
219
+{
220
+	__raw_writel(datum, addr);
221
+}
222
+
223
+static void iomem_read8r(const void __iomem *addr, void *dst, unsigned long count)
200
224
 {
201
225
 	while (count--) {
202
226
 		*(u8 *)dst = __raw_readb(addr);
..
..
@@ -204,7 +228,7 @@
204
228
 	}
205
229
 }
206
230
 
207
-static void iomem_read16r(void __iomem *addr, void *dst, unsigned long count)
231
+static void iomem_read16r(const void __iomem *addr, void *dst, unsigned long count)
208
232
 {
209
233
 	while (count--) {
210
234
 		*(u16 *)dst = __raw_readw(addr);
..
..
@@ -212,7 +236,7 @@
212
236
 	}
213
237
 }
214
238
 
215
-static void iomem_read32r(void __iomem *addr, void *dst, unsigned long count)
239
+static void iomem_read32r(const void __iomem *addr, void *dst, unsigned long count)
216
240
 {
217
241
 	while (count--) {
218
242
 		*(u32 *)dst = __raw_readl(addr);
..
..
@@ -250,11 +274,15 @@
250
274
 	.read16be = iomem_read16be,
251
275
 	.read32 = iomem_read32,
252
276
 	.read32be = iomem_read32be,
277
+	.read64 = iomem_read64,
278
+	.read64be = iomem_read64be,
253
279
 	.write8 = iomem_write8,
254
280
 	.write16 = iomem_write16,
255
281
 	.write16be = iomem_write16be,
256
282
 	.write32 = iomem_write32,
257
283
 	.write32be = iomem_write32be,
284
+	.write64 = iomem_write64,
285
+	.write64be = iomem_write64be,
258
286
 	.read8r = iomem_read8r,
259
287
 	.read16r = iomem_read16r,
260
288
 	.read32r = iomem_read32r,
..
..
@@ -269,39 +297,73 @@
269
297
 };
270
298
 
271
299
 
272
-unsigned int ioread8(void __iomem *addr)
300
+unsigned int ioread8(const void __iomem *addr)
273
301
 {
274
302
 	if (unlikely(INDIRECT_ADDR(addr)))
275
303
 		return iomap_ops[ADDR_TO_REGION(addr)]->read8(addr);
276
304
 	return *((u8 *)addr);
277
305
 }
278
306
 
279
-unsigned int ioread16(void __iomem *addr)
307
+unsigned int ioread16(const void __iomem *addr)
280
308
 {
281
309
 	if (unlikely(INDIRECT_ADDR(addr)))
282
310
 		return iomap_ops[ADDR_TO_REGION(addr)]->read16(addr);
283
311
 	return le16_to_cpup((u16 *)addr);
284
312
 }
285
313
 
286
-unsigned int ioread16be(void __iomem *addr)
314
+unsigned int ioread16be(const void __iomem *addr)
287
315
 {
288
316
 	if (unlikely(INDIRECT_ADDR(addr)))
289
317
 		return iomap_ops[ADDR_TO_REGION(addr)]->read16be(addr);
290
318
 	return *((u16 *)addr);
291
319
 }
292
320
 
293
-unsigned int ioread32(void __iomem *addr)
321
+unsigned int ioread32(const void __iomem *addr)
294
322
 {
295
323
 	if (unlikely(INDIRECT_ADDR(addr)))
296
324
 		return iomap_ops[ADDR_TO_REGION(addr)]->read32(addr);
297
325
 	return le32_to_cpup((u32 *)addr);
298
326
 }
299
327
 
300
-unsigned int ioread32be(void __iomem *addr)
328
+unsigned int ioread32be(const void __iomem *addr)
301
329
 {
302
330
 	if (unlikely(INDIRECT_ADDR(addr)))
303
331
 		return iomap_ops[ADDR_TO_REGION(addr)]->read32be(addr);
304
332
 	return *((u32 *)addr);
333
+}
334
+
335
+u64 ioread64(const void __iomem *addr)
336
+{
337
+	if (unlikely(INDIRECT_ADDR(addr)))
338
+		return iomap_ops[ADDR_TO_REGION(addr)]->read64(addr);
339
+	return le64_to_cpup((u64 *)addr);
340
+}
341
+
342
+u64 ioread64be(const void __iomem *addr)
343
+{
344
+	if (unlikely(INDIRECT_ADDR(addr)))
345
+		return iomap_ops[ADDR_TO_REGION(addr)]->read64be(addr);
346
+	return *((u64 *)addr);
347
+}
348
+
349
+u64 ioread64_lo_hi(const void __iomem *addr)
350
+{
351
+	u32 low, high;
352
+
353
+	low = ioread32(addr);
354
+	high = ioread32(addr + sizeof(u32));
355
+
356
+	return low + ((u64)high << 32);
357
+}
358
+
359
+u64 ioread64_hi_lo(const void __iomem *addr)
360
+{
361
+	u32 low, high;
362
+
363
+	high = ioread32(addr + sizeof(u32));
364
+	low = ioread32(addr);
365
+
366
+	return low + ((u64)high << 32);
305
367
 }
306
368
 
307
369
 void iowrite8(u8 datum, void __iomem *addr)
..
..
@@ -349,9 +411,39 @@
349
411
 	}
350
412
 }
351
413
 
414
+void iowrite64(u64 datum, void __iomem *addr)
415
+{
416
+	if (unlikely(INDIRECT_ADDR(addr))) {
417
+		iomap_ops[ADDR_TO_REGION(addr)]->write64(datum, addr);
418
+	} else {
419
+		*((u64 *)addr) = cpu_to_le64(datum);
420
+	}
421
+}
422
+
423
+void iowrite64be(u64 datum, void __iomem *addr)
424
+{
425
+	if (unlikely(INDIRECT_ADDR(addr))) {
426
+		iomap_ops[ADDR_TO_REGION(addr)]->write64be(datum, addr);
427
+	} else {
428
+		*((u64 *)addr) = datum;
429
+	}
430
+}
431
+
432
+void iowrite64_lo_hi(u64 val, void __iomem *addr)
433
+{
434
+	iowrite32(val, addr);
435
+	iowrite32(val >> 32, addr + sizeof(u32));
436
+}
437
+
438
+void iowrite64_hi_lo(u64 val, void __iomem *addr)
439
+{
440
+	iowrite32(val >> 32, addr + sizeof(u32));
441
+	iowrite32(val, addr);
442
+}
443
+
352
444
 /* Repeating interfaces */
353
445
 
354
-void ioread8_rep(void __iomem *addr, void *dst, unsigned long count)
446
+void ioread8_rep(const void __iomem *addr, void *dst, unsigned long count)
355
447
 {
356
448
 	if (unlikely(INDIRECT_ADDR(addr))) {
357
449
 		iomap_ops[ADDR_TO_REGION(addr)]->read8r(addr, dst, count);
..
..
@@ -363,7 +455,7 @@
363
455
 	}
364
456
 }
365
457
 
366
-void ioread16_rep(void __iomem *addr, void *dst, unsigned long count)
458
+void ioread16_rep(const void __iomem *addr, void *dst, unsigned long count)
367
459
 {
368
460
 	if (unlikely(INDIRECT_ADDR(addr))) {
369
461
 		iomap_ops[ADDR_TO_REGION(addr)]->read16r(addr, dst, count);
..
..
@@ -375,7 +467,7 @@
375
467
 	}
376
468
 }
377
469
 
378
-void ioread32_rep(void __iomem *addr, void *dst, unsigned long count)
470
+void ioread32_rep(const void __iomem *addr, void *dst, unsigned long count)
379
471
 {
380
472
 	if (unlikely(INDIRECT_ADDR(addr))) {
381
473
 		iomap_ops[ADDR_TO_REGION(addr)]->read32r(addr, dst, count);
..
..
@@ -449,11 +541,19 @@
449
541
 EXPORT_SYMBOL(ioread16be);
450
542
 EXPORT_SYMBOL(ioread32);
451
543
 EXPORT_SYMBOL(ioread32be);
544
+EXPORT_SYMBOL(ioread64);
545
+EXPORT_SYMBOL(ioread64be);
546
+EXPORT_SYMBOL(ioread64_lo_hi);
547
+EXPORT_SYMBOL(ioread64_hi_lo);
452
548
 EXPORT_SYMBOL(iowrite8);
453
549
 EXPORT_SYMBOL(iowrite16);
454
550
 EXPORT_SYMBOL(iowrite16be);
455
551
 EXPORT_SYMBOL(iowrite32);
456
552
 EXPORT_SYMBOL(iowrite32be);
553
+EXPORT_SYMBOL(iowrite64);
554
+EXPORT_SYMBOL(iowrite64be);
555
+EXPORT_SYMBOL(iowrite64_lo_hi);
556
+EXPORT_SYMBOL(iowrite64_hi_lo);
457
557
 EXPORT_SYMBOL(ioread8_rep);
458
558
 EXPORT_SYMBOL(ioread16_rep);
459
559
 EXPORT_SYMBOL(ioread32_rep);