1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Driver for the NXP SAA7164 PCIe bridge
4 *
5 * Copyright (c) 2010-2015 Steven Toth <stoth@kernellabs.com>
6 */
7
8 #include "saa7164.h"
9
10 /* The message bus to/from the firmware is a ring buffer in PCI address
11 * space. Establish the defaults.
12 */
saa7164_bus_setup(struct saa7164_dev * dev)13 int saa7164_bus_setup(struct saa7164_dev *dev)
14 {
15 struct tmComResBusInfo *b = &dev->bus;
16
17 mutex_init(&b->lock);
18
19 b->Type = TYPE_BUS_PCIe;
20 b->m_wMaxReqSize = SAA_DEVICE_MAXREQUESTSIZE;
21
22 b->m_pdwSetRing = (u8 __iomem *)(dev->bmmio +
23 ((u32)dev->busdesc.CommandRing));
24
25 b->m_dwSizeSetRing = SAA_DEVICE_BUFFERBLOCKSIZE;
26
27 b->m_pdwGetRing = (u8 __iomem *)(dev->bmmio +
28 ((u32)dev->busdesc.ResponseRing));
29
30 b->m_dwSizeGetRing = SAA_DEVICE_BUFFERBLOCKSIZE;
31
32 b->m_dwSetWritePos = ((u32)dev->intfdesc.BARLocation) +
33 (2 * sizeof(u64));
34 b->m_dwSetReadPos = b->m_dwSetWritePos + (1 * sizeof(u32));
35
36 b->m_dwGetWritePos = b->m_dwSetWritePos + (2 * sizeof(u32));
37 b->m_dwGetReadPos = b->m_dwSetWritePos + (3 * sizeof(u32));
38
39 return 0;
40 }
41
saa7164_bus_dump(struct saa7164_dev * dev)42 void saa7164_bus_dump(struct saa7164_dev *dev)
43 {
44 struct tmComResBusInfo *b = &dev->bus;
45
46 dprintk(DBGLVL_BUS, "Dumping the bus structure:\n");
47 dprintk(DBGLVL_BUS, " .type = %d\n", b->Type);
48 dprintk(DBGLVL_BUS, " .dev->bmmio = 0x%p\n", dev->bmmio);
49 dprintk(DBGLVL_BUS, " .m_wMaxReqSize = 0x%x\n", b->m_wMaxReqSize);
50 dprintk(DBGLVL_BUS, " .m_pdwSetRing = 0x%p\n", b->m_pdwSetRing);
51 dprintk(DBGLVL_BUS, " .m_dwSizeSetRing = 0x%x\n", b->m_dwSizeSetRing);
52 dprintk(DBGLVL_BUS, " .m_pdwGetRing = 0x%p\n", b->m_pdwGetRing);
53 dprintk(DBGLVL_BUS, " .m_dwSizeGetRing = 0x%x\n", b->m_dwSizeGetRing);
54
55 dprintk(DBGLVL_BUS, " .m_dwSetReadPos = 0x%x (0x%08x)\n",
56 b->m_dwSetReadPos, saa7164_readl(b->m_dwSetReadPos));
57
58 dprintk(DBGLVL_BUS, " .m_dwSetWritePos = 0x%x (0x%08x)\n",
59 b->m_dwSetWritePos, saa7164_readl(b->m_dwSetWritePos));
60
61 dprintk(DBGLVL_BUS, " .m_dwGetReadPos = 0x%x (0x%08x)\n",
62 b->m_dwGetReadPos, saa7164_readl(b->m_dwGetReadPos));
63
64 dprintk(DBGLVL_BUS, " .m_dwGetWritePos = 0x%x (0x%08x)\n",
65 b->m_dwGetWritePos, saa7164_readl(b->m_dwGetWritePos));
66
67 }
68
69 /* Intensionally throw a BUG() if the state of the message bus looks corrupt */
saa7164_bus_verify(struct saa7164_dev * dev)70 static void saa7164_bus_verify(struct saa7164_dev *dev)
71 {
72 struct tmComResBusInfo *b = &dev->bus;
73 int bug = 0;
74
75 if (saa7164_readl(b->m_dwSetReadPos) > b->m_dwSizeSetRing)
76 bug++;
77
78 if (saa7164_readl(b->m_dwSetWritePos) > b->m_dwSizeSetRing)
79 bug++;
80
81 if (saa7164_readl(b->m_dwGetReadPos) > b->m_dwSizeGetRing)
82 bug++;
83
84 if (saa7164_readl(b->m_dwGetWritePos) > b->m_dwSizeGetRing)
85 bug++;
86
87 if (bug) {
88 saa_debug = 0xffff; /* Ensure we get the bus dump */
89 saa7164_bus_dump(dev);
90 saa_debug = 1024; /* Ensure we get the bus dump */
91 BUG();
92 }
93 }
94
saa7164_bus_dumpmsg(struct saa7164_dev * dev,struct tmComResInfo * m,void * buf)95 static void saa7164_bus_dumpmsg(struct saa7164_dev *dev, struct tmComResInfo *m,
96 void *buf)
97 {
98 dprintk(DBGLVL_BUS, "Dumping msg structure:\n");
99 dprintk(DBGLVL_BUS, " .id = %d\n", m->id);
100 dprintk(DBGLVL_BUS, " .flags = 0x%x\n", m->flags);
101 dprintk(DBGLVL_BUS, " .size = 0x%x\n", m->size);
102 dprintk(DBGLVL_BUS, " .command = 0x%x\n", m->command);
103 dprintk(DBGLVL_BUS, " .controlselector = 0x%x\n", m->controlselector);
104 dprintk(DBGLVL_BUS, " .seqno = %d\n", m->seqno);
105 if (buf)
106 dprintk(DBGLVL_BUS, " .buffer (ignored)\n");
107 }
108
109 /*
110 * Places a command or a response on the bus. The implementation does not
111 * know if it is a command or a response it just places the data on the
112 * bus depending on the bus information given in the struct tmComResBusInfo
113 * structure. If the command or response does not fit into the bus ring
114 * buffer it will be refused.
115 *
116 * Return Value:
117 * SAA_OK The function executed successfully.
118 * < 0 One or more members are not initialized.
119 */
saa7164_bus_set(struct saa7164_dev * dev,struct tmComResInfo * msg,void * buf)120 int saa7164_bus_set(struct saa7164_dev *dev, struct tmComResInfo* msg,
121 void *buf)
122 {
123 struct tmComResBusInfo *bus = &dev->bus;
124 u32 bytes_to_write, free_write_space, timeout, curr_srp, curr_swp;
125 u32 new_swp, space_rem;
126 int ret = SAA_ERR_BAD_PARAMETER;
127 u16 size;
128
129 if (!msg) {
130 printk(KERN_ERR "%s() !msg\n", __func__);
131 return SAA_ERR_BAD_PARAMETER;
132 }
133
134 dprintk(DBGLVL_BUS, "%s()\n", __func__);
135
136 saa7164_bus_verify(dev);
137
138 if (msg->size > dev->bus.m_wMaxReqSize) {
139 printk(KERN_ERR "%s() Exceeded dev->bus.m_wMaxReqSize\n",
140 __func__);
141 return SAA_ERR_BAD_PARAMETER;
142 }
143
144 if ((msg->size > 0) && (buf == NULL)) {
145 printk(KERN_ERR "%s() Missing message buffer\n", __func__);
146 return SAA_ERR_BAD_PARAMETER;
147 }
148
149 /* Lock the bus from any other access */
150 mutex_lock(&bus->lock);
151
152 bytes_to_write = sizeof(*msg) + msg->size;
153 free_write_space = 0;
154 timeout = SAA_BUS_TIMEOUT;
155 curr_srp = saa7164_readl(bus->m_dwSetReadPos);
156 curr_swp = saa7164_readl(bus->m_dwSetWritePos);
157
158 /* Deal with ring wrapping issues */
159 if (curr_srp > curr_swp)
160 /* Deal with the wrapped ring */
161 free_write_space = curr_srp - curr_swp;
162 else
163 /* The ring has not wrapped yet */
164 free_write_space = (curr_srp + bus->m_dwSizeSetRing) - curr_swp;
165
166 dprintk(DBGLVL_BUS, "%s() bytes_to_write = %d\n", __func__,
167 bytes_to_write);
168
169 dprintk(DBGLVL_BUS, "%s() free_write_space = %d\n", __func__,
170 free_write_space);
171
172 dprintk(DBGLVL_BUS, "%s() curr_srp = %x\n", __func__, curr_srp);
173 dprintk(DBGLVL_BUS, "%s() curr_swp = %x\n", __func__, curr_swp);
174
175 /* Process the msg and write the content onto the bus */
176 while (bytes_to_write >= free_write_space) {
177
178 if (timeout-- == 0) {
179 printk(KERN_ERR "%s() bus timeout\n", __func__);
180 ret = SAA_ERR_NO_RESOURCES;
181 goto out;
182 }
183
184 /* TODO: Review this delay, efficient? */
185 /* Wait, allowing the hardware fetch time */
186 mdelay(1);
187
188 /* Check the space usage again */
189 curr_srp = saa7164_readl(bus->m_dwSetReadPos);
190
191 /* Deal with ring wrapping issues */
192 if (curr_srp > curr_swp)
193 /* Deal with the wrapped ring */
194 free_write_space = curr_srp - curr_swp;
195 else
196 /* Read didn't wrap around the buffer */
197 free_write_space = (curr_srp + bus->m_dwSizeSetRing) -
198 curr_swp;
199
200 }
201
202 /* Calculate the new write position */
203 new_swp = curr_swp + bytes_to_write;
204
205 dprintk(DBGLVL_BUS, "%s() new_swp = %x\n", __func__, new_swp);
206 dprintk(DBGLVL_BUS, "%s() bus->m_dwSizeSetRing = %x\n", __func__,
207 bus->m_dwSizeSetRing);
208
209 /*
210 * Make a copy of msg->size before it is converted to le16 since it is
211 * used in the code below.
212 */
213 size = msg->size;
214 /* Convert to le16/le32 */
215 msg->size = (__force u16)cpu_to_le16(msg->size);
216 msg->command = (__force u32)cpu_to_le32(msg->command);
217 msg->controlselector = (__force u16)cpu_to_le16(msg->controlselector);
218
219 /* Mental Note: line 462 tmmhComResBusPCIe.cpp */
220
221 /* Check if we're going to wrap again */
222 if (new_swp > bus->m_dwSizeSetRing) {
223
224 /* Ring wraps */
225 new_swp -= bus->m_dwSizeSetRing;
226
227 space_rem = bus->m_dwSizeSetRing - curr_swp;
228
229 dprintk(DBGLVL_BUS, "%s() space_rem = %x\n", __func__,
230 space_rem);
231
232 dprintk(DBGLVL_BUS, "%s() sizeof(*msg) = %d\n", __func__,
233 (u32)sizeof(*msg));
234
235 if (space_rem < sizeof(*msg)) {
236 dprintk(DBGLVL_BUS, "%s() tr4\n", __func__);
237
238 /* Split the msg into pieces as the ring wraps */
239 memcpy_toio(bus->m_pdwSetRing + curr_swp, msg, space_rem);
240 memcpy_toio(bus->m_pdwSetRing, (u8 *)msg + space_rem,
241 sizeof(*msg) - space_rem);
242
243 memcpy_toio(bus->m_pdwSetRing + sizeof(*msg) - space_rem,
244 buf, size);
245
246 } else if (space_rem == sizeof(*msg)) {
247 dprintk(DBGLVL_BUS, "%s() tr5\n", __func__);
248
249 /* Additional data at the beginning of the ring */
250 memcpy_toio(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
251 memcpy_toio(bus->m_pdwSetRing, buf, size);
252
253 } else {
254 /* Additional data wraps around the ring */
255 memcpy_toio(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
256 if (size > 0) {
257 memcpy_toio(bus->m_pdwSetRing + curr_swp +
258 sizeof(*msg), buf, space_rem -
259 sizeof(*msg));
260 memcpy_toio(bus->m_pdwSetRing, (u8 *)buf +
261 space_rem - sizeof(*msg),
262 bytes_to_write - space_rem);
263 }
264
265 }
266
267 } /* (new_swp > bus->m_dwSizeSetRing) */
268 else {
269 dprintk(DBGLVL_BUS, "%s() tr6\n", __func__);
270
271 /* The ring buffer doesn't wrap, two simple copies */
272 memcpy_toio(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
273 memcpy_toio(bus->m_pdwSetRing + curr_swp + sizeof(*msg), buf,
274 size);
275 }
276
277 dprintk(DBGLVL_BUS, "%s() new_swp = %x\n", __func__, new_swp);
278
279 /* Update the bus write position */
280 saa7164_writel(bus->m_dwSetWritePos, new_swp);
281
282 /* Convert back to cpu after writing the msg to the ringbuffer. */
283 msg->size = le16_to_cpu((__force __le16)msg->size);
284 msg->command = le32_to_cpu((__force __le32)msg->command);
285 msg->controlselector = le16_to_cpu((__force __le16)msg->controlselector);
286 ret = SAA_OK;
287
288 out:
289 saa7164_bus_dump(dev);
290 mutex_unlock(&bus->lock);
291 saa7164_bus_verify(dev);
292 return ret;
293 }
294
295 /*
296 * Receive a command or a response from the bus. The implementation does not
297 * know if it is a command or a response it simply dequeues the data,
298 * depending on the bus information given in the struct tmComResBusInfo
299 * structure.
300 *
301 * Return Value:
302 * 0 The function executed successfully.
303 * < 0 One or more members are not initialized.
304 */
saa7164_bus_get(struct saa7164_dev * dev,struct tmComResInfo * msg,void * buf,int peekonly)305 int saa7164_bus_get(struct saa7164_dev *dev, struct tmComResInfo* msg,
306 void *buf, int peekonly)
307 {
308 struct tmComResBusInfo *bus = &dev->bus;
309 u32 bytes_to_read, write_distance, curr_grp, curr_gwp,
310 new_grp, buf_size, space_rem;
311 struct tmComResInfo msg_tmp;
312 int ret = SAA_ERR_BAD_PARAMETER;
313
314 saa7164_bus_verify(dev);
315
316 if (msg == NULL)
317 return ret;
318
319 if (msg->size > dev->bus.m_wMaxReqSize) {
320 printk(KERN_ERR "%s() Exceeded dev->bus.m_wMaxReqSize\n",
321 __func__);
322 return ret;
323 }
324
325 if ((peekonly == 0) && (msg->size > 0) && (buf == NULL)) {
326 printk(KERN_ERR
327 "%s() Missing msg buf, size should be %d bytes\n",
328 __func__, msg->size);
329 return ret;
330 }
331
332 mutex_lock(&bus->lock);
333
334 /* Peek the bus to see if a msg exists, if it's not what we're expecting
335 * then return cleanly else read the message from the bus.
336 */
337 curr_gwp = saa7164_readl(bus->m_dwGetWritePos);
338 curr_grp = saa7164_readl(bus->m_dwGetReadPos);
339
340 if (curr_gwp == curr_grp) {
341 ret = SAA_ERR_EMPTY;
342 goto out;
343 }
344
345 bytes_to_read = sizeof(*msg);
346
347 /* Calculate write distance to current read position */
348 write_distance = 0;
349 if (curr_gwp >= curr_grp)
350 /* Write doesn't wrap around the ring */
351 write_distance = curr_gwp - curr_grp;
352 else
353 /* Write wraps around the ring */
354 write_distance = curr_gwp + bus->m_dwSizeGetRing - curr_grp;
355
356 if (bytes_to_read > write_distance) {
357 printk(KERN_ERR "%s() No message/response found\n", __func__);
358 ret = SAA_ERR_INVALID_COMMAND;
359 goto out;
360 }
361
362 /* Calculate the new read position */
363 new_grp = curr_grp + bytes_to_read;
364 if (new_grp > bus->m_dwSizeGetRing) {
365
366 /* Ring wraps */
367 new_grp -= bus->m_dwSizeGetRing;
368 space_rem = bus->m_dwSizeGetRing - curr_grp;
369
370 memcpy_fromio(&msg_tmp, bus->m_pdwGetRing + curr_grp, space_rem);
371 memcpy_fromio((u8 *)&msg_tmp + space_rem, bus->m_pdwGetRing,
372 bytes_to_read - space_rem);
373
374 } else {
375 /* No wrapping */
376 memcpy_fromio(&msg_tmp, bus->m_pdwGetRing + curr_grp, bytes_to_read);
377 }
378 /* Convert from little endian to CPU */
379 msg_tmp.size = le16_to_cpu((__force __le16)msg_tmp.size);
380 msg_tmp.command = le32_to_cpu((__force __le32)msg_tmp.command);
381 msg_tmp.controlselector = le16_to_cpu((__force __le16)msg_tmp.controlselector);
382 memcpy(msg, &msg_tmp, sizeof(*msg));
383
384 /* No need to update the read positions, because this was a peek */
385 /* If the caller specifically want to peek, return */
386 if (peekonly) {
387 goto peekout;
388 }
389
390 /* Check if the command/response matches what is expected */
391 if ((msg_tmp.id != msg->id) || (msg_tmp.command != msg->command) ||
392 (msg_tmp.controlselector != msg->controlselector) ||
393 (msg_tmp.seqno != msg->seqno) || (msg_tmp.size != msg->size)) {
394
395 printk(KERN_ERR "%s() Unexpected msg miss-match\n", __func__);
396 saa7164_bus_dumpmsg(dev, msg, buf);
397 saa7164_bus_dumpmsg(dev, &msg_tmp, NULL);
398 ret = SAA_ERR_INVALID_COMMAND;
399 goto out;
400 }
401
402 /* Get the actual command and response from the bus */
403 buf_size = msg->size;
404
405 bytes_to_read = sizeof(*msg) + msg->size;
406 /* Calculate write distance to current read position */
407 write_distance = 0;
408 if (curr_gwp >= curr_grp)
409 /* Write doesn't wrap around the ring */
410 write_distance = curr_gwp - curr_grp;
411 else
412 /* Write wraps around the ring */
413 write_distance = curr_gwp + bus->m_dwSizeGetRing - curr_grp;
414
415 if (bytes_to_read > write_distance) {
416 printk(KERN_ERR "%s() Invalid bus state, missing msg or mangled ring, faulty H/W / bad code?\n",
417 __func__);
418 ret = SAA_ERR_INVALID_COMMAND;
419 goto out;
420 }
421
422 /* Calculate the new read position */
423 new_grp = curr_grp + bytes_to_read;
424 if (new_grp > bus->m_dwSizeGetRing) {
425
426 /* Ring wraps */
427 new_grp -= bus->m_dwSizeGetRing;
428 space_rem = bus->m_dwSizeGetRing - curr_grp;
429
430 if (space_rem < sizeof(*msg)) {
431 if (buf)
432 memcpy_fromio(buf, bus->m_pdwGetRing + sizeof(*msg) -
433 space_rem, buf_size);
434
435 } else if (space_rem == sizeof(*msg)) {
436 if (buf)
437 memcpy_fromio(buf, bus->m_pdwGetRing, buf_size);
438 } else {
439 /* Additional data wraps around the ring */
440 if (buf) {
441 memcpy_fromio(buf, bus->m_pdwGetRing + curr_grp +
442 sizeof(*msg), space_rem - sizeof(*msg));
443 memcpy_fromio(buf + space_rem - sizeof(*msg),
444 bus->m_pdwGetRing, bytes_to_read -
445 space_rem);
446 }
447
448 }
449
450 } else {
451 /* No wrapping */
452 if (buf)
453 memcpy_fromio(buf, bus->m_pdwGetRing + curr_grp + sizeof(*msg),
454 buf_size);
455 }
456
457 /* Update the read positions, adjusting the ring */
458 saa7164_writel(bus->m_dwGetReadPos, new_grp);
459
460 peekout:
461 ret = SAA_OK;
462 out:
463 mutex_unlock(&bus->lock);
464 saa7164_bus_verify(dev);
465 return ret;
466 }
467
468