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