blob: 9ffe05caed3bba69172f2ec99fe5bd427fb4bc16 [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"
Patrick Georgi32508eb2012-07-20 20:35:14 +000022#include "hwaccess.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:
145 msg_perr("BAR type unknown, please report a bug at flashrom@flashrom.org\n");
146 }
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"
155 "Please report a bug at flashrom@flashrom.org\n", __func__);
156 return 1;
157 }
158 pci_cleanup(pacc);
Youness Alaouia54ceb12017-07-26 18:03:36 -0400159 pacc = NULL;
Stefan Tauner55619552013-01-04 22:24:58 +0000160 return 0;
161}
162
163int pci_init_common(void)
164{
165 if (pacc != NULL) {
166 msg_perr("%s: Tried to allocate a new PCI context, but there is still an old one!\n"
167 "Please report a bug at flashrom@flashrom.org\n", __func__);
168 return 1;
169 }
170 pacc = pci_alloc(); /* Get the pci_access structure */
171 pci_init(pacc); /* Initialize the PCI library */
172 if (register_shutdown(pcidev_shutdown, NULL))
173 return 1;
174 pci_scan_bus(pacc); /* We want to get the list of devices */
175 return 0;
176}
177
Carl-Daniel Hailfingera2faddf2013-01-05 23:52:45 +0000178/* pcidev_init gets an array of allowed PCI device IDs and returns a pointer to struct pci_dev iff exactly one
179 * match was found. If the "pci=bb:dd.f" programmer parameter was specified, a match is only considered if it
180 * also matches the specified bus:device.function.
181 * For convenience, this function also registers its own undo handlers.
182 */
183struct pci_dev *pcidev_init(const struct dev_entry *devs, int bar)
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000184{
185 struct pci_dev *dev;
Nico Huber67710af2020-01-18 18:23:22 +0000186 struct pci_dev *found_dev = NULL;
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000187 struct pci_filter filter;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000188 char *pcidev_bdf;
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000189 char *msg = NULL;
190 int found = 0;
Nico Huber67710af2020-01-18 18:23:22 +0000191 int i;
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000192
Carl-Daniel Hailfingera2faddf2013-01-05 23:52:45 +0000193 if (pci_init_common() != 0)
194 return NULL;
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000195 pci_filter_init(pacc, &filter);
196
Carl-Daniel Hailfinger40446ee2011-03-07 01:08:09 +0000197 /* Filter by bb:dd.f (if supplied by the user). */
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000198 pcidev_bdf = extract_programmer_param("pci");
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000199 if (pcidev_bdf != NULL) {
200 if ((msg = pci_filter_parse_slot(&filter, pcidev_bdf))) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000201 msg_perr("Error: %s\n", msg);
Carl-Daniel Hailfingera2faddf2013-01-05 23:52:45 +0000202 return NULL;
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000203 }
204 }
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000205 free(pcidev_bdf);
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000206
207 for (dev = pacc->devices; dev; dev = dev->next) {
208 if (pci_filter_match(&filter, dev)) {
Daniel Verkampca2e3bc2020-10-12 12:55:56 -0700209 pci_fill_info(dev, PCI_FILL_IDENT);
Nico Huber67710af2020-01-18 18:23:22 +0000210 /* Check against list of supported devices. */
211 for (i = 0; devs[i].device_name != NULL; i++)
212 if ((dev->vendor_id == devs[i].vendor_id) &&
213 (dev->device_id == devs[i].device_id))
214 break;
215 /* Not supported, try the next one. */
216 if (devs[i].device_name == NULL)
217 continue;
218
219 msg_pdbg("Found \"%s %s\" (%04x:%04x, BDF %02x:%02x.%x).\n", devs[i].vendor_name,
220 devs[i].device_name, dev->vendor_id, dev->device_id, dev->bus, dev->dev,
221 dev->func);
222 if (devs[i].status == NT)
223 msg_pinfo("===\nThis PCI device is UNTESTED. Please report the 'flashrom -p "
224 "xxxx' output\n"
225 "to flashrom@flashrom.org if it works for you. Please add the name "
226 "of your\n"
227 "PCI device to the subject. Thank you for your help!\n===\n");
228
Carl-Daniel Hailfinger40446ee2011-03-07 01:08:09 +0000229 /* FIXME: We should count all matching devices, not
230 * just those with a valid BAR.
231 */
Elyes HAOUAS577c6b72020-04-21 21:20:44 +0200232 if (pcidev_readbar(dev, bar) != 0) {
Nico Huber67710af2020-01-18 18:23:22 +0000233 found_dev = dev;
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000234 found++;
Uwe Hermann8403ccb2009-05-16 21:39:19 +0000235 }
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000236 }
237 }
238
239 /* Only continue if exactly one supported PCI dev has been found. */
240 if (found == 0) {
Sean Nelson316a29f2010-05-07 20:09:04 +0000241 msg_perr("Error: No supported PCI device found.\n");
Carl-Daniel Hailfingera2faddf2013-01-05 23:52:45 +0000242 return NULL;
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000243 } else if (found > 1) {
Elyes HAOUASac01baa2018-05-28 16:52:21 +0200244 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 +0000245 "to explicitly select the card with the given BDF (PCI bus, device, function).\n");
Carl-Daniel Hailfingera2faddf2013-01-05 23:52:45 +0000246 return NULL;
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000247 }
248
Nico Huber67710af2020-01-18 18:23:22 +0000249 return found_dev;
Uwe Hermann515ab3d2009-05-15 17:02:34 +0000250}
251
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000252enum pci_write_type {
253 pci_write_type_byte,
254 pci_write_type_word,
255 pci_write_type_long,
256};
257
258struct undo_pci_write_data {
Youness Alaouia54ceb12017-07-26 18:03:36 -0400259 struct pci_dev *dev;
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000260 int reg;
261 enum pci_write_type type;
262 union {
263 uint8_t bytedata;
264 uint16_t worddata;
265 uint32_t longdata;
266 };
267};
268
Jacob Garberbeeb8bc2019-06-21 15:24:17 -0600269static int undo_pci_write(void *p)
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000270{
271 struct undo_pci_write_data *data = p;
Youness Alaouia54ceb12017-07-26 18:03:36 -0400272 if (pacc == NULL || data->dev == NULL) {
273 msg_perr("%s: Tried to undo PCI writes without a valid PCI %s!\n"
274 "Please report a bug at flashrom@flashrom.org\n",
275 __func__, data->dev == NULL ? "device" : "context");
Stefan Tauner55619552013-01-04 22:24:58 +0000276 return 1;
277 }
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000278 msg_pdbg("Restoring PCI config space for %02x:%02x:%01x reg 0x%02x\n",
Youness Alaouia54ceb12017-07-26 18:03:36 -0400279 data->dev->bus, data->dev->dev, data->dev->func, data->reg);
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000280 switch (data->type) {
281 case pci_write_type_byte:
Youness Alaouia54ceb12017-07-26 18:03:36 -0400282 pci_write_byte(data->dev, data->reg, data->bytedata);
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000283 break;
284 case pci_write_type_word:
Youness Alaouia54ceb12017-07-26 18:03:36 -0400285 pci_write_word(data->dev, data->reg, data->worddata);
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000286 break;
287 case pci_write_type_long:
Youness Alaouia54ceb12017-07-26 18:03:36 -0400288 pci_write_long(data->dev, data->reg, data->longdata);
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000289 break;
290 }
291 /* p was allocated in register_undo_pci_write. */
292 free(p);
David Hendricks8bb20212011-06-14 01:35:36 +0000293 return 0;
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000294}
295
Elyes HAOUASac01baa2018-05-28 16:52:21 +0200296#define register_undo_pci_write(a, b, c) \
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000297{ \
298 struct undo_pci_write_data *undo_pci_write_data; \
Angel Pons3bd47522021-06-07 12:33:53 +0200299 undo_pci_write_data = malloc(sizeof(*undo_pci_write_data)); \
Stefan Tauner269de352011-07-12 22:35:21 +0000300 if (!undo_pci_write_data) { \
301 msg_gerr("Out of memory!\n"); \
302 exit(1); \
303 } \
Youness Alaouia54ceb12017-07-26 18:03:36 -0400304 if (pacc) \
305 undo_pci_write_data->dev = pci_get_dev(pacc, \
306 a->domain, a->bus, a->dev, a->func); \
307 else \
308 undo_pci_write_data->dev = NULL; \
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000309 undo_pci_write_data->reg = b; \
310 undo_pci_write_data->type = pci_write_type_##c; \
311 undo_pci_write_data->c##data = pci_read_##c(dev, reg); \
312 register_shutdown(undo_pci_write, undo_pci_write_data); \
313}
314
315#define register_undo_pci_write_byte(a, b) register_undo_pci_write(a, b, byte)
316#define register_undo_pci_write_word(a, b) register_undo_pci_write(a, b, word)
317#define register_undo_pci_write_long(a, b) register_undo_pci_write(a, b, long)
318
319int rpci_write_byte(struct pci_dev *dev, int reg, uint8_t data)
320{
321 register_undo_pci_write_byte(dev, reg);
322 return pci_write_byte(dev, reg, data);
323}
Elyes HAOUAS124ef382018-03-27 12:15:09 +0200324
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000325int rpci_write_word(struct pci_dev *dev, int reg, uint16_t data)
326{
327 register_undo_pci_write_word(dev, reg);
328 return pci_write_word(dev, reg, data);
329}
Elyes HAOUAS124ef382018-03-27 12:15:09 +0200330
Carl-Daniel Hailfinger2bee8cf2010-11-10 15:25:18 +0000331int rpci_write_long(struct pci_dev *dev, int reg, uint32_t data)
332{
333 register_undo_pci_write_long(dev, reg);
334 return pci_write_long(dev, reg, data);
335}