rtl88x2CE_WiFi_linux driver

hc

2024-05-10 cde9070d9970eef1f7ec2360586c802a16230ad8

 kernel/arch/s390/include/asm/pci_io.h
..
..
@@ -8,14 +8,19 @@
8
8
 #include <linux/slab.h>
9
9
 #include <asm/pci_insn.h>
10
10
 
11
+/* I/O size constraints */
12
+#define ZPCI_MAX_READ_SIZE	8
13
+#define ZPCI_MAX_WRITE_SIZE	128
14
+
11
15
 /* I/O Map */
12
16
 #define ZPCI_IOMAP_SHIFT		48
13
-#define ZPCI_IOMAP_ADDR_BASE		0x8000000000000000UL
17
+#define ZPCI_IOMAP_ADDR_SHIFT		62
18
+#define ZPCI_IOMAP_ADDR_BASE		(1UL << ZPCI_IOMAP_ADDR_SHIFT)
14
19
 #define ZPCI_IOMAP_ADDR_OFF_MASK	((1UL << ZPCI_IOMAP_SHIFT) - 1)
15
20
 #define ZPCI_IOMAP_MAX_ENTRIES							\
16
-	((ULONG_MAX - ZPCI_IOMAP_ADDR_BASE + 1) / (1UL << ZPCI_IOMAP_SHIFT))
21
+	(1UL << (ZPCI_IOMAP_ADDR_SHIFT - ZPCI_IOMAP_SHIFT))
17
22
 #define ZPCI_IOMAP_ADDR_IDX_MASK						\
18
-	(~ZPCI_IOMAP_ADDR_OFF_MASK - ZPCI_IOMAP_ADDR_BASE)
23
+	((ZPCI_IOMAP_ADDR_BASE - 1) & ~ZPCI_IOMAP_ADDR_OFF_MASK)
19
24
 
20
25
 struct zpci_iomap_entry {
21
26
 	u32 fh;
..
..
@@ -37,12 +42,10 @@
37
42
 #define zpci_read(LENGTH, RETTYPE)						\
38
43
 static inline RETTYPE zpci_read_##RETTYPE(const volatile void __iomem *addr)	\
39
44
 {										\
40
-	struct zpci_iomap_entry *entry = &zpci_iomap_start[ZPCI_IDX(addr)];	\
41
-	u64 req = ZPCI_CREATE_REQ(entry->fh, entry->bar, LENGTH);		\
42
45
 	u64 data;								\
43
46
 	int rc;									\
44
47
 										\
45
-	rc = zpci_load(&data, req, ZPCI_OFFSET(addr));				\
48
+	rc = zpci_load(&data, addr, LENGTH);					\
46
49
 	if (rc)									\
47
50
 		data = -1ULL;							\
48
51
 	return (RETTYPE) data;							\
..
..
@@ -52,11 +55,9 @@
52
55
 static inline void zpci_write_##VALTYPE(VALTYPE val,				\
53
56
 					const volatile void __iomem *addr)	\
54
57
 {										\
55
-	struct zpci_iomap_entry *entry = &zpci_iomap_start[ZPCI_IDX(addr)];	\
56
-	u64 req = ZPCI_CREATE_REQ(entry->fh, entry->bar, LENGTH);		\
57
58
 	u64 data = (VALTYPE) val;						\
58
59
 										\
59
-	zpci_store(data, req, ZPCI_OFFSET(addr));				\
60
+	zpci_store(addr, data, LENGTH);						\
60
61
 }
61
62
 
62
63
 zpci_read(8, u64)
..
..
@@ -68,36 +69,38 @@
68
69
 zpci_write(2, u16)
69
70
 zpci_write(1, u8)
70
71
 
71
-static inline int zpci_write_single(u64 req, const u64 *data, u64 offset, u8 len)
72
+static inline int zpci_write_single(volatile void __iomem *dst, const void *src,
73
+				    unsigned long len)
72
74
 {
73
75
 	u64 val;
74
76
 
75
77
 	switch (len) {
76
78
 	case 1:
77
-		val = (u64) *((u8 *) data);
79
+		val = (u64) *((u8 *) src);
78
80
 		break;
79
81
 	case 2:
80
-		val = (u64) *((u16 *) data);
82
+		val = (u64) *((u16 *) src);
81
83
 		break;
82
84
 	case 4:
83
-		val = (u64) *((u32 *) data);
85
+		val = (u64) *((u32 *) src);
84
86
 		break;
85
87
 	case 8:
86
-		val = (u64) *((u64 *) data);
88
+		val = (u64) *((u64 *) src);
87
89
 		break;
88
90
 	default:
89
91
 		val = 0;		/* let FW report error */
90
92
 		break;
91
93
 	}
92
-	return zpci_store(val, req, offset);
94
+	return zpci_store(dst, val, len);
93
95
 }
94
96
 
95
-static inline int zpci_read_single(u64 req, u64 *dst, u64 offset, u8 len)
97
+static inline int zpci_read_single(void *dst, const volatile void __iomem *src,
98
+				   unsigned long len)
96
99
 {
97
100
 	u64 data;
98
101
 	int cc;
99
102
 
100
-	cc = zpci_load(&data, req, offset);
103
+	cc = zpci_load(&data, src, len);
101
104
 	if (cc)
102
105
 		goto out;
103
106
 
..
..
@@ -119,10 +122,8 @@
119
122
 	return cc;
120
123
 }
121
124
 
122
-static inline int zpci_write_block(u64 req, const u64 *data, u64 offset)
123
-{
124
-	return zpci_store_block(data, req, offset);
125
-}
125
+int zpci_write_block(volatile void __iomem *dst, const void *src,
126
+		     unsigned long len);
126
127
 
127
128
 static inline u8 zpci_get_max_write_size(u64 src, u64 dst, int len, int max)
128
129
 {
..
..
@@ -140,18 +141,16 @@
140
141
 				     const volatile void __iomem *src,
141
142
 				     unsigned long n)
142
143
 {
143
-	struct zpci_iomap_entry *entry = &zpci_iomap_start[ZPCI_IDX(src)];
144
-	u64 req, offset = ZPCI_OFFSET(src);
145
144
 	int size, rc = 0;
146
145
 
147
146
 	while (n > 0) {
148
147
 		size = zpci_get_max_write_size((u64 __force) src,
149
-					       (u64) dst, n, 8);
150
-		req = ZPCI_CREATE_REQ(entry->fh, entry->bar, size);
151
-		rc = zpci_read_single(req, dst, offset, size);
148
+					       (u64) dst, n,
149
+					       ZPCI_MAX_READ_SIZE);
150
+		rc = zpci_read_single(dst, src, size);
152
151
 		if (rc)
153
152
 			break;
154
-		offset += size;
153
+		src += size;
155
154
 		dst += size;
156
155
 		n -= size;
157
156
 	}
..
..
@@ -161,8 +160,6 @@
161
160
 static inline int zpci_memcpy_toio(volatile void __iomem *dst,
162
161
 				   const void *src, unsigned long n)
163
162
 {
164
-	struct zpci_iomap_entry *entry = &zpci_iomap_start[ZPCI_IDX(dst)];
165
-	u64 req, offset = ZPCI_OFFSET(dst);
166
163
 	int size, rc = 0;
167
164
 
168
165
 	if (!src)
..
..
@@ -170,17 +167,16 @@
170
167
 
171
168
 	while (n > 0) {
172
169
 		size = zpci_get_max_write_size((u64 __force) dst,
173
-					       (u64) src, n, 128);
174
-		req = ZPCI_CREATE_REQ(entry->fh, entry->bar, size);
175
-
170
+					       (u64) src, n,
171
+					       ZPCI_MAX_WRITE_SIZE);
176
172
 		if (size > 8) /* main path */
177
-			rc = zpci_write_block(req, src, offset);
173
+			rc = zpci_write_block(dst, src, size);
178
174
 		else
179
-			rc = zpci_write_single(req, src, offset, size);
175
+			rc = zpci_write_single(dst, src, size);
180
176
 		if (rc)
181
177
 			break;
182
-		offset += size;
183
178
 		src += size;
179
+		dst += size;
184
180
 		n -= size;
185
181
 	}
186
182
 	return rc;