2 * Driver for the NXP SAA7164 PCIe bridge
4 * Copyright (c) 2010 Steven Toth <stoth@kernellabs.com>
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.
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
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 /* The message bus to/from the firmware is a ring buffer in PCI address
25 * space. Establish the defaults.
27 int saa7164_bus_setup(struct saa7164_dev *dev)
29 struct tmComResBusInfo *b = &dev->bus;
33 b->Type = TYPE_BUS_PCIe;
34 b->m_wMaxReqSize = SAA_DEVICE_MAXREQUESTSIZE;
36 b->m_pdwSetRing = (u8 *)(dev->bmmio +
37 ((u32)dev->busdesc.CommandRing));
39 b->m_dwSizeSetRing = SAA_DEVICE_BUFFERBLOCKSIZE;
41 b->m_pdwGetRing = (u8 *)(dev->bmmio +
42 ((u32)dev->busdesc.ResponseRing));
44 b->m_dwSizeGetRing = SAA_DEVICE_BUFFERBLOCKSIZE;
46 b->m_dwSetWritePos = ((u32)dev->intfdesc.BARLocation) + (2 * sizeof(u64));
47 b->m_dwSetReadPos = b->m_dwSetWritePos + (1 * sizeof(u32));
49 b->m_dwGetWritePos = b->m_dwSetWritePos + (2 * sizeof(u32));
50 b->m_dwGetReadPos = b->m_dwSetWritePos + (3 * sizeof(u32));
55 void saa7164_bus_dump(struct saa7164_dev *dev)
57 struct tmComResBusInfo *b = &dev->bus;
59 dprintk(DBGLVL_BUS, "Dumping the bus structure:\n");
60 dprintk(DBGLVL_BUS, " .type = %d\n", b->Type);
61 dprintk(DBGLVL_BUS, " .dev->bmmio = 0x%p\n", dev->bmmio);
62 dprintk(DBGLVL_BUS, " .m_wMaxReqSize = 0x%x\n", b->m_wMaxReqSize);
63 dprintk(DBGLVL_BUS, " .m_pdwSetRing = 0x%p\n", b->m_pdwSetRing);
64 dprintk(DBGLVL_BUS, " .m_dwSizeSetRing = 0x%x\n", b->m_dwSizeSetRing);
65 dprintk(DBGLVL_BUS, " .m_pdwGetRing = 0x%p\n", b->m_pdwGetRing);
66 dprintk(DBGLVL_BUS, " .m_dwSizeGetRing = 0x%x\n", b->m_dwSizeGetRing);
68 dprintk(DBGLVL_BUS, " .m_dwSetReadPos = 0x%x (0x%08x)\n",
69 b->m_dwSetReadPos, saa7164_readl(b->m_dwSetReadPos));
71 dprintk(DBGLVL_BUS, " .m_dwSetWritePos = 0x%x (0x%08x)\n",
72 b->m_dwSetWritePos, saa7164_readl(b->m_dwSetWritePos));
74 dprintk(DBGLVL_BUS, " .m_dwGetReadPos = 0x%x (0x%08x)\n",
75 b->m_dwGetReadPos, saa7164_readl(b->m_dwGetReadPos));
77 dprintk(DBGLVL_BUS, " .m_dwGetWritePos = 0x%x (0x%08x)\n",
78 b->m_dwGetWritePos, saa7164_readl(b->m_dwGetWritePos));
82 /* Intensionally throw a BUG() if the state of the message bus looks corrupt */
83 void saa7164_bus_verify(struct saa7164_dev *dev)
85 struct tmComResBusInfo *b = &dev->bus;
88 if (saa7164_readl(b->m_dwSetReadPos) > b->m_dwSizeSetRing)
91 if (saa7164_readl(b->m_dwSetWritePos) > b->m_dwSizeSetRing)
94 if (saa7164_readl(b->m_dwGetReadPos) > b->m_dwSizeGetRing)
97 if (saa7164_readl(b->m_dwGetWritePos) > b->m_dwSizeGetRing)
101 saa_debug = 0xffff; /* Ensure we get the bus dump */
102 saa7164_bus_dump(dev);
103 saa_debug = 1024; /* Ensure we get the bus dump */
108 void saa7164_bus_dumpmsg(struct saa7164_dev *dev, struct tmComResInfo* m, void *buf)
110 dprintk(DBGLVL_BUS, "Dumping msg structure:\n");
111 dprintk(DBGLVL_BUS, " .id = %d\n", m->id);
112 dprintk(DBGLVL_BUS, " .flags = 0x%x\n", m->flags);
113 dprintk(DBGLVL_BUS, " .size = 0x%x\n", m->size);
114 dprintk(DBGLVL_BUS, " .command = 0x%x\n", m->command);
115 dprintk(DBGLVL_BUS, " .controlselector = 0x%x\n", m->controlselector);
116 dprintk(DBGLVL_BUS, " .seqno = %d\n", m->seqno);
118 dprintk(DBGLVL_BUS, " .buffer (ignored)\n");
122 * Places a command or a response on the bus. The implementation does not
123 * know if it is a command or a response it just places the data on the
124 * bus depending on the bus information given in the struct tmComResBusInfo
125 * structure. If the command or response does not fit into the bus ring
126 * buffer it will be refused.
129 * SAA_OK The function executed successfully.
130 * < 0 One or more members are not initialized.
132 int saa7164_bus_set(struct saa7164_dev *dev, struct tmComResInfo* msg, void *buf)
134 struct tmComResBusInfo *bus = &dev->bus;
135 u32 bytes_to_write, free_write_space, timeout, curr_srp, curr_swp;
136 u32 new_swp, space_rem;
137 int ret = SAA_ERR_BAD_PARAMETER;
140 printk(KERN_ERR "%s() !msg\n", __func__);
141 return SAA_ERR_BAD_PARAMETER;
144 dprintk(DBGLVL_BUS, "%s()\n", __func__);
146 saa7164_bus_verify(dev);
148 msg->size = cpu_to_le16(msg->size);
149 msg->command = cpu_to_le16(msg->command);
150 msg->controlselector = cpu_to_le16(msg->controlselector);
152 if (msg->size > dev->bus.m_wMaxReqSize) {
153 printk(KERN_ERR "%s() Exceeded dev->bus.m_wMaxReqSize\n",
155 return SAA_ERR_BAD_PARAMETER;
158 if ((msg->size > 0) && (buf == 0)) {
159 printk(KERN_ERR "%s() Missing message buffer\n", __func__);
160 return SAA_ERR_BAD_PARAMETER;
163 /* Lock the bus from any other access */
164 mutex_lock(&bus->lock);
166 bytes_to_write = sizeof(*msg) + msg->size;
167 free_write_space = 0;
168 timeout = SAA_BUS_TIMEOUT;
169 curr_srp = le32_to_cpu(saa7164_readl(bus->m_dwSetReadPos));
170 curr_swp = le32_to_cpu(saa7164_readl(bus->m_dwSetWritePos));
172 /* Deal with ring wrapping issues */
173 if (curr_srp > curr_swp)
174 /* Deal with the wrapped ring */
175 free_write_space = curr_srp - curr_swp;
177 /* The ring has not wrapped yet */
178 free_write_space = (curr_srp + bus->m_dwSizeSetRing) - curr_swp;
180 dprintk(DBGLVL_BUS, "%s() bytes_to_write = %d\n", __func__,
183 dprintk(DBGLVL_BUS, "%s() free_write_space = %d\n", __func__,
186 dprintk(DBGLVL_BUS, "%s() curr_srp = %x\n", __func__, curr_srp);
187 dprintk(DBGLVL_BUS, "%s() curr_swp = %x\n", __func__, curr_swp);
189 /* Process the msg and write the content onto the bus */
190 while (bytes_to_write >= free_write_space) {
192 if (timeout-- == 0) {
193 printk(KERN_ERR "%s() bus timeout\n", __func__);
194 ret = SAA_ERR_NO_RESOURCES;
198 /* TODO: Review this delay, efficient? */
199 /* Wait, allowing the hardware fetch time */
202 /* Check the space usage again */
203 curr_srp = le32_to_cpu(saa7164_readl(bus->m_dwSetReadPos));
205 /* Deal with ring wrapping issues */
206 if (curr_srp > curr_swp)
207 /* Deal with the wrapped ring */
208 free_write_space = curr_srp - curr_swp;
210 /* Read didn't wrap around the buffer */
211 free_write_space = (curr_srp + bus->m_dwSizeSetRing) -
216 /* Calculate the new write position */
217 new_swp = curr_swp + bytes_to_write;
219 dprintk(DBGLVL_BUS, "%s() new_swp = %x\n", __func__, new_swp);
220 dprintk(DBGLVL_BUS, "%s() bus->m_dwSizeSetRing = %x\n", __func__,
221 bus->m_dwSizeSetRing);
223 /* Mental Note: line 462 tmmhComResBusPCIe.cpp */
225 /* Check if we're going to wrap again */
226 if (new_swp > bus->m_dwSizeSetRing) {
229 new_swp -= bus->m_dwSizeSetRing;
231 space_rem = bus->m_dwSizeSetRing - curr_swp;
233 dprintk(DBGLVL_BUS, "%s() space_rem = %x\n", __func__,
236 dprintk(DBGLVL_BUS, "%s() sizeof(*msg) = %d\n", __func__,
239 if (space_rem < sizeof(*msg)) {
240 dprintk(DBGLVL_BUS, "%s() tr4\n", __func__);
242 /* Split the msg into pieces as the ring wraps */
243 memcpy(bus->m_pdwSetRing + curr_swp, msg, space_rem);
244 memcpy(bus->m_pdwSetRing, (u8 *)msg + space_rem,
245 sizeof(*msg) - space_rem);
247 memcpy(bus->m_pdwSetRing + sizeof(*msg) - space_rem,
250 } else if (space_rem == sizeof(*msg)) {
251 dprintk(DBGLVL_BUS, "%s() tr5\n", __func__);
253 /* Additional data at the beginning of the ring */
254 memcpy(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
255 memcpy(bus->m_pdwSetRing, buf, msg->size);
258 /* Additional data wraps around the ring */
259 memcpy(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
261 memcpy(bus->m_pdwSetRing + curr_swp +
262 sizeof(*msg), buf, space_rem -
264 memcpy(bus->m_pdwSetRing, (u8 *)buf +
265 space_rem - sizeof(*msg),
266 bytes_to_write - space_rem);
271 } /* (new_swp > bus->m_dwSizeSetRing) */
273 dprintk(DBGLVL_BUS, "%s() tr6\n", __func__);
275 /* The ring buffer doesn't wrap, two simple copies */
276 memcpy(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
277 memcpy(bus->m_pdwSetRing + curr_swp + sizeof(*msg), buf,
281 dprintk(DBGLVL_BUS, "%s() new_swp = %x\n", __func__, new_swp);
283 /* Update the bus write position */
284 saa7164_writel(bus->m_dwSetWritePos, cpu_to_le32(new_swp));
288 saa7164_bus_dump(dev);
289 mutex_unlock(&bus->lock);
290 saa7164_bus_verify(dev);
295 * Receive a command or a response from the bus. The implementation does not
296 * know if it is a command or a response it simply dequeues the data,
297 * depending on the bus information given in the struct tmComResBusInfo structure.
300 * 0 The function executed successfully.
301 * < 0 One or more members are not initialized.
303 int saa7164_bus_get(struct saa7164_dev *dev, struct tmComResInfo* msg, void *buf,
306 struct tmComResBusInfo *bus = &dev->bus;
307 u32 bytes_to_read, write_distance, curr_grp, curr_gwp,
308 new_grp, buf_size, space_rem;
309 struct tmComResInfo msg_tmp;
310 int ret = SAA_ERR_BAD_PARAMETER;
312 saa7164_bus_verify(dev);
317 if (msg->size > dev->bus.m_wMaxReqSize) {
318 printk(KERN_ERR "%s() Exceeded dev->bus.m_wMaxReqSize\n",
323 if ((peekonly == 0) && (msg->size > 0) && (buf == 0)) {
325 "%s() Missing msg buf, size should be %d bytes\n",
326 __func__, msg->size);
330 mutex_lock(&bus->lock);
332 /* Peek the bus to see if a msg exists, if it's not what we're expecting
333 * then return cleanly else read the message from the bus.
335 curr_gwp = le32_to_cpu(saa7164_readl(bus->m_dwGetWritePos));
336 curr_grp = le32_to_cpu(saa7164_readl(bus->m_dwGetReadPos));
338 if (curr_gwp == curr_grp) {
343 bytes_to_read = sizeof(*msg);
345 /* Calculate write distance to current read position */
347 if (curr_gwp >= curr_grp)
348 /* Write doesn't wrap around the ring */
349 write_distance = curr_gwp - curr_grp;
351 /* Write wraps around the ring */
352 write_distance = curr_gwp + bus->m_dwSizeGetRing - curr_grp;
354 if (bytes_to_read > write_distance) {
355 printk(KERN_ERR "%s() No message/response found\n", __func__);
356 ret = SAA_ERR_INVALID_COMMAND;
360 /* Calculate the new read position */
361 new_grp = curr_grp + bytes_to_read;
362 if (new_grp > bus->m_dwSizeGetRing) {
365 new_grp -= bus->m_dwSizeGetRing;
366 space_rem = bus->m_dwSizeGetRing - curr_grp;
368 memcpy(&msg_tmp, bus->m_pdwGetRing + curr_grp, space_rem);
369 memcpy((u8 *)&msg_tmp + space_rem, bus->m_pdwGetRing,
370 bytes_to_read - space_rem);
374 memcpy(&msg_tmp, bus->m_pdwGetRing + curr_grp, bytes_to_read);
377 /* No need to update the read positions, because this was a peek */
378 /* If the caller specifically want to peek, return */
380 memcpy(msg, &msg_tmp, sizeof(*msg));
384 /* Check if the command/response matches what is expected */
385 if ((msg_tmp.id != msg->id) || (msg_tmp.command != msg->command) ||
386 (msg_tmp.controlselector != msg->controlselector) ||
387 (msg_tmp.seqno != msg->seqno) || (msg_tmp.size != msg->size)) {
389 printk(KERN_ERR "%s() Unexpected msg miss-match\n", __func__);
390 saa7164_bus_dumpmsg(dev, msg, buf);
391 saa7164_bus_dumpmsg(dev, &msg_tmp, 0);
392 ret = SAA_ERR_INVALID_COMMAND;
396 /* Get the actual command and response from the bus */
397 buf_size = msg->size;
399 bytes_to_read = sizeof(*msg) + msg->size;
400 /* Calculate write distance to current read position */
402 if (curr_gwp >= curr_grp)
403 /* Write doesn't wrap around the ring */
404 write_distance = curr_gwp - curr_grp;
406 /* Write wraps around the ring */
407 write_distance = curr_gwp + bus->m_dwSizeGetRing - curr_grp;
409 if (bytes_to_read > write_distance) {
410 printk(KERN_ERR "%s() Invalid bus state, missing msg "
411 "or mangled ring, faulty H/W / bad code?\n", __func__);
412 ret = SAA_ERR_INVALID_COMMAND;
416 /* Calculate the new read position */
417 new_grp = curr_grp + bytes_to_read;
418 if (new_grp > bus->m_dwSizeGetRing) {
421 new_grp -= bus->m_dwSizeGetRing;
422 space_rem = bus->m_dwSizeGetRing - curr_grp;
424 if (space_rem < sizeof(*msg)) {
425 /* msg wraps around the ring */
426 memcpy(msg, bus->m_pdwGetRing + curr_grp, space_rem);
427 memcpy((u8 *)msg + space_rem, bus->m_pdwGetRing,
428 sizeof(*msg) - space_rem);
430 memcpy(buf, bus->m_pdwGetRing + sizeof(*msg) -
431 space_rem, buf_size);
433 } else if (space_rem == sizeof(*msg)) {
434 memcpy(msg, bus->m_pdwGetRing + curr_grp, sizeof(*msg));
436 memcpy(buf, bus->m_pdwGetRing, buf_size);
438 /* Additional data wraps around the ring */
439 memcpy(msg, bus->m_pdwGetRing + curr_grp, sizeof(*msg));
441 memcpy(buf, bus->m_pdwGetRing + curr_grp +
442 sizeof(*msg), space_rem - sizeof(*msg));
443 memcpy(buf + space_rem - sizeof(*msg),
444 bus->m_pdwGetRing, bytes_to_read -
452 memcpy(msg, bus->m_pdwGetRing + curr_grp, sizeof(*msg));
454 memcpy(buf, bus->m_pdwGetRing + curr_grp + sizeof(*msg),
458 /* Update the read positions, adjusting the ring */
459 saa7164_writel(bus->m_dwGetReadPos, cpu_to_le32(new_grp));
462 msg->size = le16_to_cpu(msg->size);
463 msg->command = le16_to_cpu(msg->command);
464 msg->controlselector = le16_to_cpu(msg->controlselector);
467 mutex_unlock(&bus->lock);
468 saa7164_bus_verify(dev);