blob: 1ec6455949c2b144ab27c2f9ca4d6424c82b024d [file] [log] [blame]
Uwe Hermann515ab3d2009-05-15 17:02:34 +00001/*
2 * This file is part of the flashrom project.
3 *
4 * Copyright (C) 2009 Uwe Hermann <uwe@hermann-uwe.de>
Carl-Daniel Hailfinger8a19ef12011-02-15 22:44:27 +00005 * Copyright (C) 2010, 2011 Carl-Daniel Hailfinger
Uwe Hermann515ab3d2009-05-15 17:02:34 +00006 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
Uwe Hermann515ab3d2009-05-15 17:02:34 +000016 */
17
18#include <stdlib.h>
19#include <string.h>
Uwe Hermann515ab3d2009-05-15 17:02:34 +000020#include "flash.h"
Carl-Daniel Hailfinger5b997c32010-07-27 22:41:39 +000021#include "programmer.h"
Thomas Heijligend96c97c2021-11-02 21:03:00 +010022#include "platform/pci.h"
Uwe Hermann515ab3d2009-05-15 17:02:34 +000023
Uwe Hermann515ab3d2009-05-15 17:02:34 +000024struct pci_access *pacc;
Uwe Hermann515ab3d2009-05-15 17:02:34 +000025
Carl-Daniel Hailfinger8a19ef12011-02-15 22:44:27 +000026enum pci_bartype {
27 TYPE_MEMBAR,
28 TYPE_IOBAR,
29 TYPE_ROMBAR,
30 TYPE_UNKNOWN
31};
32
Carl-Daniel Hailfinger3834c2d2012-07-16 21:32:19 +000033uintptr_t pcidev_readbar(struct pci_dev *dev, int bar)
Uwe Hermann515ab3d2009-05-15 17:02:34 +000034{
Carl-Daniel Hailfinger8a19ef12011-02-15 22:44:27 +000035 uint64_t addr;
36 uint32_t upperaddr;
37 uint8_t headertype;
38 uint16_t supported_cycles;
39 enum pci_bartype bartype = TYPE_UNKNOWN;
Uwe Hermann515ab3d2009-05-15 17:02:34 +000040
Uwe Hermann515ab3d2009-05-15 17:02:34 +000041
Carl-Daniel Hailfinger3834c2d2012-07-16 21:32:19 +000042 headertype = pci_read_byte(dev, PCI_HEADER_TYPE) & 0x7f;
43 msg_pspew("PCI header type 0x%02x\n", headertype);
Carl-Daniel Hailfinger8a19ef12011-02-15 22:44:27 +000044
Carl-Daniel Hailfinger3834c2d2012-07-16 21:32:19 +000045 /* Don't use dev->base_addr[x] (as value for 'bar'), won't work on older libpci. */
46 addr = pci_read_long(dev, bar);
Carl-Daniel Hailfinger8a19ef12011-02-15 22:44:27 +000047
Carl-Daniel Hailfinger3834c2d2012-07-16 21:32:19 +000048 /* Sanity checks. */
49 switch (headertype) {
50 case PCI_HEADER_TYPE_NORMAL:
51 switch (bar) {
52 case PCI_BASE_ADDRESS_0:
53 case PCI_BASE_ADDRESS_1:
54 case PCI_BASE_ADDRESS_2:
55 case PCI_BASE_ADDRESS_3:
56 case PCI_BASE_ADDRESS_4:
57 case PCI_BASE_ADDRESS_5:
58 if ((addr & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO)
59 bartype = TYPE_IOBAR;
60 else
61 bartype = TYPE_MEMBAR;
Carl-Daniel Hailfinger8a19ef12011-02-15 22:44:27 +000062 break;
Carl-Daniel Hailfinger3834c2d2012-07-16 21:32:19 +000063 case PCI_ROM_ADDRESS:
64 bartype = TYPE_ROMBAR;
Carl-Daniel Hailfinger8a19ef12011-02-15 22:44:27 +000065 break;
66 }
Carl-Daniel Hailfinger3834c2d2012-07-16 21:32:19 +000067 break;
68 case PCI_HEADER_TYPE_BRIDGE:
69 switch (bar) {
70 case PCI_BASE_ADDRESS_0:
71 case PCI_BASE_ADDRESS_1:
72 if ((addr & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO)
73 bartype = TYPE_IOBAR;
74 else
75 bartype = TYPE_MEMBAR;
Carl-Daniel Hailfinger8a19ef12011-02-15 22:44:27 +000076 break;
Carl-Daniel Hailfinger3834c2d2012-07-16 21:32:19 +000077 case PCI_ROM_ADDRESS1:
78 bartype = TYPE_ROMBAR;
Carl-Daniel Hailfinger8a19ef12011-02-15 22:44:27 +000079 break;
Carl-Daniel Hailfinger295b3af2010-03-17 00:47:56 +000080 }
Carl-Daniel Hailfinger3834c2d2012-07-16 21:32:19 +000081 break;
82 case PCI_HEADER_TYPE_CARDBUS:
83 break;
84 default:
85 msg_perr("Unknown PCI header type 0x%02x, BAR type cannot be determined reliably.\n",
86 headertype);
87 break;
Uwe Hermann515ab3d2009-05-15 17:02:34 +000088 }
89
Carl-Daniel Hailfinger3834c2d2012-07-16 21:32:19 +000090 supported_cycles = pci_read_word(dev, PCI_COMMAND);
91
Niklas Söderlund89edf362013-08-23 23:29:23 +000092 msg_pdbg("Requested BAR is of type ");
Carl-Daniel Hailfinger3834c2d2012-07-16 21:32:19 +000093 switch (bartype) {
94 case TYPE_MEMBAR:
95 msg_pdbg("MEM");
96 if (!(supported_cycles & PCI_COMMAND_MEMORY)) {
97 msg_perr("MEM BAR access requested, but device has MEM space accesses disabled.\n");
98 /* TODO: Abort here? */
99 }
100 msg_pdbg(", %sbit, %sprefetchable\n",
101 ((addr & 0x6) == 0x0) ? "32" : (((addr & 0x6) == 0x4) ? "64" : "reserved"),
102 (addr & 0x8) ? "" : "not ");
103 if ((addr & 0x6) == 0x4) {
104 /* The spec says that a 64-bit register consumes
105 * two subsequent dword locations.
106 */
107 upperaddr = pci_read_long(dev, bar + 4);
108 if (upperaddr != 0x00000000) {
109 /* Fun! A real 64-bit resource. */
110 if (sizeof(uintptr_t) != sizeof(uint64_t)) {
111 msg_perr("BAR unreachable!");
112 /* TODO: Really abort here? If multiple PCI devices match,
113 * we might never tell the user about the other devices.
114 */
115 return 0;
116 }
117 addr |= (uint64_t)upperaddr << 32;
118 }
119 }
120 addr &= PCI_BASE_ADDRESS_MEM_MASK;
121 break;
122 case TYPE_IOBAR:
123 msg_pdbg("I/O\n");
124#if __FLASHROM_HAVE_OUTB__
125 if (!(supported_cycles & PCI_COMMAND_IO)) {
126 msg_perr("I/O BAR access requested, but device has I/O space accesses disabled.\n");
127 /* TODO: Abort here? */
128 }
129#else
130 msg_perr("I/O BAR access requested, but flashrom does not support I/O BAR access on this "
131 "platform (yet).\n");
132#endif
133 addr &= PCI_BASE_ADDRESS_IO_MASK;
134 break;
135 case TYPE_ROMBAR:
136 msg_pdbg("ROM\n");
137 /* Not sure if this check is needed. */
138 if (!(supported_cycles & PCI_COMMAND_MEMORY)) {
139 msg_perr("MEM BAR access requested, but device has MEM space accesses disabled.\n");
140 /* TODO: Abort here? */
141 }
142 addr &= PCI_ROM_ADDRESS_MASK;
143 break;
144 case TYPE_UNKNOWN:
Nico Huberac90af62022-12-18 00:22:47 +0000145 msg_perr("BAR type unknown, please report a bug at flashrom-stable@flashrom.org\n");
Carl-Daniel Hailfinger3834c2d2012-07-16 21:32:19 +0000146 }
147
148 return (uintptr_t)addr;
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000149}
150
Stefan Tauner55619552013-01-04 22:24:58 +0000151static int pcidev_shutdown(void *data)
152{
Stefan Tauner55619552013-01-04 22:24:58 +0000153 if (pacc == NULL) {
154 msg_perr("%s: Tried to cleanup an invalid PCI context!\n"
Nico Huberac90af62022-12-18 00:22:47 +0000155 "Please report a bug at flashrom-stable@flashrom.org\n",
156 __func__);
Stefan Tauner55619552013-01-04 22:24:58 +0000157 return 1;
158 }
159 pci_cleanup(pacc);
Youness Alaouia54ceb12017-07-26 18:03:36 -0400160 pacc = NULL;
Stefan Tauner55619552013-01-04 22:24:58 +0000161 return 0;
162}
163
164int pci_init_common(void)
165{
166 if (pacc != NULL) {
167 msg_perr("%s: Tried to allocate a new PCI context, but there is still an old one!\n"
Nico Huberac90af62022-12-18 00:22:47 +0000168 "Please report a bug at flashrom-stable@flashrom.org\n", __func__);
Stefan Tauner55619552013-01-04 22:24:58 +0000169 return 1;
170 }
171 pacc = pci_alloc(); /* Get the pci_access structure */
172 pci_init(pacc); /* Initialize the PCI library */
173 if (register_shutdown(pcidev_shutdown, NULL))
174 return 1;
175 pci_scan_bus(pacc); /* We want to get the list of devices */
176 return 0;
177}
178
Carl-Daniel Hailfingera2faddf2013-01-05 23:52:45 +0000179/* pcidev_init gets an array of allowed PCI device IDs and returns a pointer to struct pci_dev iff exactly one
180 * match was found. If the "pci=bb:dd.f" programmer parameter was specified, a match is only considered if it
181 * also matches the specified bus:device.function.
182 * For convenience, this function also registers its own undo handlers.
183 */
184struct pci_dev *pcidev_init(const struct dev_entry *devs, int bar)
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000185{
186 struct pci_dev *dev;
Nico Huber67710af2020-01-18 18:23:22 +0000187 struct pci_dev *found_dev = NULL;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000188 struct pci_filter filter;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000189 char *pcidev_bdf;
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000190 char *msg = NULL;
191 int found = 0;
Nico Huber67710af2020-01-18 18:23:22 +0000192 int i;
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000193
Carl-Daniel Hailfingera2faddf2013-01-05 23:52:45 +0000194 if (pci_init_common() != 0)
195 return NULL;
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000196 pci_filter_init(pacc, &filter);
197
Carl-Daniel Hailfinger40446ee2011-03-07 01:08:09 +0000198 /* Filter by bb:dd.f (if supplied by the user). */
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000199 pcidev_bdf = extract_programmer_param("pci");
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000200 if (pcidev_bdf != NULL) {
201 if ((msg = pci_filter_parse_slot(&filter, pcidev_bdf))) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000202 msg_perr("Error: %s\n", msg);
Carl-Daniel Hailfingera2faddf2013-01-05 23:52:45 +0000203 return NULL;
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000204 }
205 }
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000206 free(pcidev_bdf);
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000207
208 for (dev = pacc->devices; dev; dev = dev->next) {
209 if (pci_filter_match(&filter, dev)) {
Daniel Verkamp298ac332020-10-12 12:55:56 -0700210 pci_fill_info(dev, PCI_FILL_IDENT);
Nico Huber67710af2020-01-18 18:23:22 +0000211 /* Check against list of supported devices. */
212 for (i = 0; devs[i].device_name != NULL; i++)
213 if ((dev->vendor_id == devs[i].vendor_id) &&
214 (dev->device_id == devs[i].device_id))
215 break;
216 /* Not supported, try the next one. */
217 if (devs[i].device_name == NULL)
218 continue;
219
220 msg_pdbg("Found \"%s %s\" (%04x:%04x, BDF %02x:%02x.%x).\n", devs[i].vendor_name,
221 devs[i].device_name, dev->vendor_id, dev->device_id, dev->bus, dev->dev,
222 dev->func);
223 if (devs[i].status == NT)
224 msg_pinfo("===\nThis PCI device is UNTESTED. Please report the 'flashrom -p "
225 "xxxx' output\n"
Nico Huberac90af62022-12-18 00:22:47 +0000226 "to flashrom-stable@flashrom.org if it works for you. Please add "
227 "the name of your\n"
Nico Huber67710af2020-01-18 18:23:22 +0000228 "PCI device to the subject. Thank you for your help!\n===\n");
229
Carl-Daniel Hailfinger40446ee2011-03-07 01:08:09 +0000230 /* FIXME: We should count all matching devices, not
231 * just those with a valid BAR.
232 */
Elyes HAOUAS34e74562020-04-21 21:20:44 +0200233 if (pcidev_readbar(dev, bar) != 0) {
Nico Huber67710af2020-01-18 18:23:22 +0000234 found_dev = dev;
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000235 found++;
Uwe Hermann8403ccb2009-05-16 21:39:19 +0000236 }
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000237 }
238 }
239
240 /* Only continue if exactly one supported PCI dev has been found. */
241 if (found == 0) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000242 msg_perr("Error: No supported PCI device found.\n");
Carl-Daniel Hailfingera2faddf2013-01-05 23:52:45 +0000243 return NULL;
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000244 } else if (found > 1) {
Elyes HAOUASac01baa2018-05-28 16:52:21 +0200245 msg_perr("Error: Multiple supported PCI devices found. Use 'flashrom -p xxxx:pci=bb:dd.f'\n"
Carl-Daniel Hailfinger3834c2d2012-07-16 21:32:19 +0000246 "to explicitly select the card with the given BDF (PCI bus, device, function).\n");
Carl-Daniel Hailfingera2faddf2013-01-05 23:52:45 +0000247 return NULL;
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000248 }
249
Nico Huber67710af2020-01-18 18:23:22 +0000250 return found_dev;
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000251}
252
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000253enum pci_write_type {
254 pci_write_type_byte,
255 pci_write_type_word,
256 pci_write_type_long,
257};
258
259struct undo_pci_write_data {
Youness Alaouia54ceb12017-07-26 18:03:36 -0400260 struct pci_dev *dev;
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000261 int reg;
262 enum pci_write_type type;
263 union {
264 uint8_t bytedata;
265 uint16_t worddata;
266 uint32_t longdata;
267 };
268};
269
Jacob Garberbeeb8bc2019-06-21 15:24:17 -0600270static int undo_pci_write(void *p)
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000271{
272 struct undo_pci_write_data *data = p;
Youness Alaouia54ceb12017-07-26 18:03:36 -0400273 if (pacc == NULL || data->dev == NULL) {
274 msg_perr("%s: Tried to undo PCI writes without a valid PCI %s!\n"
Nico Huberac90af62022-12-18 00:22:47 +0000275 "Please report a bug at flashrom-stable@flashrom.org\n",
Youness Alaouia54ceb12017-07-26 18:03:36 -0400276 __func__, data->dev == NULL ? "device" : "context");
Stefan Tauner55619552013-01-04 22:24:58 +0000277 return 1;
278 }
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000279 msg_pdbg("Restoring PCI config space for %02x:%02x:%01x reg 0x%02x\n",
Youness Alaouia54ceb12017-07-26 18:03:36 -0400280 data->dev->bus, data->dev->dev, data->dev->func, data->reg);
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000281 switch (data->type) {
282 case pci_write_type_byte:
Youness Alaouia54ceb12017-07-26 18:03:36 -0400283 pci_write_byte(data->dev, data->reg, data->bytedata);
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000284 break;
285 case pci_write_type_word:
Youness Alaouia54ceb12017-07-26 18:03:36 -0400286 pci_write_word(data->dev, data->reg, data->worddata);
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000287 break;
288 case pci_write_type_long:
Youness Alaouia54ceb12017-07-26 18:03:36 -0400289 pci_write_long(data->dev, data->reg, data->longdata);
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000290 break;
291 }
292 /* p was allocated in register_undo_pci_write. */
293 free(p);
David Hendricks8bb20212011-06-14 01:35:36 +0000294 return 0;
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000295}
296
Elyes HAOUASac01baa2018-05-28 16:52:21 +0200297#define register_undo_pci_write(a, b, c) \
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000298{ \
299 struct undo_pci_write_data *undo_pci_write_data; \
Angel Pons690a9442021-06-07 12:33:53 +0200300 undo_pci_write_data = malloc(sizeof(*undo_pci_write_data)); \
Stefan Tauner269de352011-07-12 22:35:21 +0000301 if (!undo_pci_write_data) { \
302 msg_gerr("Out of memory!\n"); \
303 exit(1); \
304 } \
Youness Alaouia54ceb12017-07-26 18:03:36 -0400305 if (pacc) \
306 undo_pci_write_data->dev = pci_get_dev(pacc, \
307 a->domain, a->bus, a->dev, a->func); \
308 else \
309 undo_pci_write_data->dev = NULL; \
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000310 undo_pci_write_data->reg = b; \
311 undo_pci_write_data->type = pci_write_type_##c; \
312 undo_pci_write_data->c##data = pci_read_##c(dev, reg); \
313 register_shutdown(undo_pci_write, undo_pci_write_data); \
314}
315
316#define register_undo_pci_write_byte(a, b) register_undo_pci_write(a, b, byte)
317#define register_undo_pci_write_word(a, b) register_undo_pci_write(a, b, word)
318#define register_undo_pci_write_long(a, b) register_undo_pci_write(a, b, long)
319
320int rpci_write_byte(struct pci_dev *dev, int reg, uint8_t data)
321{
322 register_undo_pci_write_byte(dev, reg);
323 return pci_write_byte(dev, reg, data);
324}
Elyes HAOUAS124ef382018-03-27 12:15:09 +0200325
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000326int rpci_write_word(struct pci_dev *dev, int reg, uint16_t data)
327{
328 register_undo_pci_write_word(dev, reg);
329 return pci_write_word(dev, reg, data);
330}
Elyes HAOUAS124ef382018-03-27 12:15:09 +0200331
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000332int rpci_write_long(struct pci_dev *dev, int reg, uint32_t data)
333{
334 register_undo_pci_write_long(dev, reg);
335 return pci_write_long(dev, reg, data);
336}