blob: d31808d5ef17f0b6bff224b304fad5e425a9a1b7 [file] [log] [blame]
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +00001/*
2 * This file is part of the flashrom project.
3 *
4 * Copyright (C) 2009 Carl-Daniel Hailfinger
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 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
Carl-Daniel Hailfinger1c6d2ff2012-08-27 00:44:42 +000021#include <strings.h>
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +000022#include <string.h>
23#include <stdlib.h>
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +000024#include "flash.h"
Carl-Daniel Hailfinger5b997c32010-07-27 22:41:39 +000025#include "programmer.h"
Patrick Georgi32508eb2012-07-20 20:35:14 +000026#include "hwaccess.h"
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +000027
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000028#if NEED_PCI == 1
Christian Ruppert0cdb0312009-05-14 18:57:26 +000029struct pci_dev *pci_dev_find_filter(struct pci_filter filter)
30{
31 struct pci_dev *temp;
32
33 for (temp = pacc->devices; temp; temp = temp->next)
34 if (pci_filter_match(&filter, temp))
35 return temp;
36
37 return NULL;
38}
39
Uwe Hermann24c35e42011-07-13 11:22:03 +000040struct pci_dev *pci_dev_find_vendorclass(uint16_t vendor, uint16_t devclass)
Carl-Daniel Hailfinger9f46cfc2009-11-15 17:13:29 +000041{
42 struct pci_dev *temp;
43 struct pci_filter filter;
44 uint16_t tmp2;
45
46 pci_filter_init(NULL, &filter);
47 filter.vendor = vendor;
48
49 for (temp = pacc->devices; temp; temp = temp->next)
50 if (pci_filter_match(&filter, temp)) {
51 /* Read PCI class */
52 tmp2 = pci_read_word(temp, 0x0a);
Uwe Hermann24c35e42011-07-13 11:22:03 +000053 if (tmp2 == devclass)
Carl-Daniel Hailfinger9f46cfc2009-11-15 17:13:29 +000054 return temp;
55 }
56
57 return NULL;
58}
59
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +000060struct pci_dev *pci_dev_find(uint16_t vendor, uint16_t device)
61{
62 struct pci_dev *temp;
63 struct pci_filter filter;
64
65 pci_filter_init(NULL, &filter);
66 filter.vendor = vendor;
67 filter.device = device;
68
69 for (temp = pacc->devices; temp; temp = temp->next)
70 if (pci_filter_match(&filter, temp))
71 return temp;
72
73 return NULL;
74}
75
76struct pci_dev *pci_card_find(uint16_t vendor, uint16_t device,
77 uint16_t card_vendor, uint16_t card_device)
78{
79 struct pci_dev *temp;
80 struct pci_filter filter;
81
82 pci_filter_init(NULL, &filter);
83 filter.vendor = vendor;
84 filter.device = device;
85
86 for (temp = pacc->devices; temp; temp = temp->next)
87 if (pci_filter_match(&filter, temp)) {
88 if ((card_vendor ==
89 pci_read_word(temp, PCI_SUBSYSTEM_VENDOR_ID))
90 && (card_device ==
91 pci_read_word(temp, PCI_SUBSYSTEM_ID)))
92 return temp;
93 }
94
95 return NULL;
96}
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +000097#endif
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +000098
Carl-Daniel Hailfinger71127722010-05-31 15:27:27 +000099#if CONFIG_INTERNAL == 1
Michael Karcher0bdc0922010-02-28 01:33:48 +0000100int force_boardenable = 0;
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000101int force_boardmismatch = 0;
Carl-Daniel Hailfinger14e100c2009-12-22 23:42:04 +0000102
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +0000103#if defined(__i386__) || defined(__x86_64__)
Carl-Daniel Hailfinger14e100c2009-12-22 23:42:04 +0000104void probe_superio(void)
105{
Carl-Daniel Hailfingerf5e62cb2012-05-06 22:48:01 +0000106 probe_superio_winbond();
107 /* ITE probe causes SMSC LPC47N217 to power off the serial UART.
108 * Always probe for SMSC first, and if a SMSC Super I/O is detected
109 * at a given I/O port, do _not_ probe that port with the ITE probe.
110 * This means SMSC probing must be done before ITE probing.
111 */
112 //probe_superio_smsc();
Carl-Daniel Hailfingerbfecef62011-04-27 14:34:08 +0000113 probe_superio_ite();
Carl-Daniel Hailfinger14e100c2009-12-22 23:42:04 +0000114}
Carl-Daniel Hailfingerbfecef62011-04-27 14:34:08 +0000115
116int superio_count = 0;
117#define SUPERIO_MAX_COUNT 3
118
119struct superio superios[SUPERIO_MAX_COUNT];
120
121int register_superio(struct superio s)
122{
123 if (superio_count == SUPERIO_MAX_COUNT)
124 return 1;
125 superios[superio_count++] = s;
126 return 0;
127}
128
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +0000129#endif
Carl-Daniel Hailfinger14e100c2009-12-22 23:42:04 +0000130
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +0000131int is_laptop = 0;
Carl-Daniel Hailfinger580d29a2011-05-05 07:12:40 +0000132int laptop_ok = 0;
Michael Karcher8c1df282010-02-26 09:51:20 +0000133
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000134static void internal_chip_writeb(const struct flashctx *flash, uint8_t val,
135 chipaddr addr);
136static void internal_chip_writew(const struct flashctx *flash, uint16_t val,
137 chipaddr addr);
138static void internal_chip_writel(const struct flashctx *flash, uint32_t val,
139 chipaddr addr);
140static uint8_t internal_chip_readb(const struct flashctx *flash,
141 const chipaddr addr);
142static uint16_t internal_chip_readw(const struct flashctx *flash,
143 const chipaddr addr);
144static uint32_t internal_chip_readl(const struct flashctx *flash,
145 const chipaddr addr);
146static void internal_chip_readn(const struct flashctx *flash, uint8_t *buf,
147 const chipaddr addr, size_t len);
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000148static const struct par_programmer par_programmer_internal = {
149 .chip_readb = internal_chip_readb,
150 .chip_readw = internal_chip_readw,
151 .chip_readl = internal_chip_readl,
152 .chip_readn = internal_chip_readn,
153 .chip_writeb = internal_chip_writeb,
154 .chip_writew = internal_chip_writew,
155 .chip_writel = internal_chip_writel,
156 .chip_writen = fallback_chip_writen,
157};
158
159enum chipbustype internal_buses_supported = BUS_NONE;
160
David Hendricks8bb20212011-06-14 01:35:36 +0000161static int internal_shutdown(void *data)
162{
David Hendricks8bb20212011-06-14 01:35:36 +0000163 return 0;
164}
165
Uwe Hermanna0869322009-05-14 20:41:57 +0000166int internal_init(void)
167{
Peter Lemenkov0a6f9ca2010-09-20 17:23:38 +0000168#if __FLASHROM_LITTLE_ENDIAN__
Uwe Hermanna0869322009-05-14 20:41:57 +0000169 int ret = 0;
Peter Lemenkov0a6f9ca2010-09-20 17:23:38 +0000170#endif
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000171 int force_laptop = 0;
Stefan Taunera28087f2011-09-13 23:14:25 +0000172 int not_a_laptop = 0;
Stefan Taunerb4e06bd2012-08-20 00:24:22 +0000173 const char *board_vendor = NULL;
174 const char *board_model = NULL;
175 const char *cb_vendor = NULL;
176 const char *cb_model = NULL;
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000177 char *arg;
Uwe Hermanna0869322009-05-14 20:41:57 +0000178
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000179 arg = extract_programmer_param("boardenable");
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000180 if (arg && !strcmp(arg,"force")) {
181 force_boardenable = 1;
182 } else if (arg && !strlen(arg)) {
183 msg_perr("Missing argument for boardenable.\n");
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000184 free(arg);
185 return 1;
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000186 } else if (arg) {
187 msg_perr("Unknown argument for boardenable: %s\n", arg);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000188 free(arg);
189 return 1;
Michael Karcher0bdc0922010-02-28 01:33:48 +0000190 }
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000191 free(arg);
Michael Karcher0bdc0922010-02-28 01:33:48 +0000192
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000193 arg = extract_programmer_param("boardmismatch");
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000194 if (arg && !strcmp(arg,"force")) {
195 force_boardmismatch = 1;
196 } else if (arg && !strlen(arg)) {
197 msg_perr("Missing argument for boardmismatch.\n");
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000198 free(arg);
199 return 1;
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000200 } else if (arg) {
201 msg_perr("Unknown argument for boardmismatch: %s\n", arg);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000202 free(arg);
203 return 1;
Michael Karcher0bdc0922010-02-28 01:33:48 +0000204 }
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000205 free(arg);
206
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000207 arg = extract_programmer_param("laptop");
Stefan Taunera28087f2011-09-13 23:14:25 +0000208 if (arg && !strcmp(arg, "force_I_want_a_brick"))
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000209 force_laptop = 1;
Stefan Taunera28087f2011-09-13 23:14:25 +0000210 else if (arg && !strcmp(arg, "this_is_not_a_laptop"))
211 not_a_laptop = 1;
212 else if (arg && !strlen(arg)) {
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000213 msg_perr("Missing argument for laptop.\n");
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000214 free(arg);
215 return 1;
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000216 } else if (arg) {
217 msg_perr("Unknown argument for laptop: %s\n", arg);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000218 free(arg);
219 return 1;
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000220 }
221 free(arg);
222
Carl-Daniel Hailfinger2d927fb2012-01-04 00:48:27 +0000223 arg = extract_programmer_param("mainboard");
224 if (arg && strlen(arg)) {
Stefan Taunerb4e06bd2012-08-20 00:24:22 +0000225 if (board_parse_parameter(arg, &board_vendor, &board_model)) {
226 free(arg);
227 return 1;
228 }
Carl-Daniel Hailfinger2d927fb2012-01-04 00:48:27 +0000229 } else if (arg && !strlen(arg)) {
230 msg_perr("Missing argument for mainboard.\n");
231 free(arg);
232 return 1;
233 }
234 free(arg);
235
Carl-Daniel Hailfingerd6bb8282012-07-21 17:27:08 +0000236 if (rget_io_perms())
237 return 1;
David Hendricks8bb20212011-06-14 01:35:36 +0000238 if (register_shutdown(internal_shutdown, NULL))
239 return 1;
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000240
Michael Karcherb9dbe482011-05-11 17:07:07 +0000241 /* Default to Parallel/LPC/FWH flash devices. If a known host controller
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000242 * is found, the host controller init routine sets the
243 * internal_buses_supported bitfield.
Michael Karcherb9dbe482011-05-11 17:07:07 +0000244 */
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000245 internal_buses_supported = BUS_NONSPI;
Michael Karcherb9dbe482011-05-11 17:07:07 +0000246
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000247 /* Initialize PCI access for flash enables */
248 pacc = pci_alloc(); /* Get the pci_access structure */
249 /* Set all options you want -- here we stick with the defaults */
250 pci_init(pacc); /* Initialize the PCI library */
251 pci_scan_bus(pacc); /* We want to get the list of devices */
252
Carl-Daniel Hailfingerb5b161b2010-06-04 19:05:39 +0000253 if (processor_flash_enable()) {
254 msg_perr("Processor detection/init failed.\n"
255 "Aborting.\n");
256 return 1;
257 }
258
259#if defined(__i386__) || defined(__x86_64__)
Stefan Taunerb4e06bd2012-08-20 00:24:22 +0000260 if (cb_parse_table(&cb_vendor, &cb_model) == 0) { /* coreboot IDs valid */
261 /* If no -p internal:mainboard was given but there are valid coreboot IDs then use those. */
262 if (board_vendor == NULL || board_model == NULL) {
263 board_vendor = cb_vendor;
264 board_model = cb_model;
265 } else if (strcasecmp(board_vendor, cb_vendor) || strcasecmp(board_model, cb_model)) {
266 msg_pinfo("WARNING: The mainboard IDs set by -p internal:mainboard (%s:%s) do not\n"
267 " match the current coreboot IDs of the mainboard (%s:%s).\n",
268 board_vendor, board_model, cb_vendor, cb_model);
269 if (!force_boardmismatch)
270 return 1;
271 msg_pinfo("Continuing anyway.\n");
272 }
273 }
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +0000274
Michael Karcher6701ee82010-01-20 14:14:11 +0000275 dmi_init();
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000276
Carl-Daniel Hailfinger580d29a2011-05-05 07:12:40 +0000277 /* In case Super I/O probing would cause pretty explosions. */
278 board_handle_before_superio();
279
Uwe Hermann43959702010-03-13 17:28:29 +0000280 /* Probe for the Super I/O chip and fill global struct superio. */
Carl-Daniel Hailfinger14e100c2009-12-22 23:42:04 +0000281 probe_superio();
Carl-Daniel Hailfingerb5b161b2010-06-04 19:05:39 +0000282#else
283 /* FIXME: Enable cbtable searching on all non-x86 platforms supported
284 * by coreboot.
285 * FIXME: Find a replacement for DMI on non-x86.
286 * FIXME: Enable Super I/O probing once port I/O is possible.
287 */
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +0000288#endif
Carl-Daniel Hailfinger14e100c2009-12-22 23:42:04 +0000289
Carl-Daniel Hailfinger580d29a2011-05-05 07:12:40 +0000290 /* Check laptop whitelist. */
291 board_handle_before_laptop();
292
293 /* Warn if a non-whitelisted laptop is detected. */
294 if (is_laptop && !laptop_ok) {
Stefan Taunera34d7192011-07-26 00:54:42 +0000295 msg_perr("========================================================================\n");
296 if (is_laptop == 1) {
297 msg_perr("WARNING! You seem to be running flashrom on an unsupported laptop.\n");
298 } else {
299 msg_perr("WARNING! You may be running flashrom on an unsupported laptop. We could\n"
300 "not detect this for sure because your vendor has not setup the SMBIOS\n"
301 "tables correctly. You can enforce execution by adding\n"
Stefan Taunera28087f2011-09-13 23:14:25 +0000302 "'-p internal:laptop=this_is_not_a_laptop' to the command line, but\n"
Stefan Taunera34d7192011-07-26 00:54:42 +0000303 "please read the following warning if you are not sure.\n\n");
304 }
305 msg_perr("Laptops, notebooks and netbooks are difficult to support and we\n"
306 "recommend to use the vendor flashing utility. The embedded controller\n"
307 "(EC) in these machines often interacts badly with flashing.\n"
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000308 "See http://www.flashrom.org/Laptops for details.\n\n"
309 "If flash is shared with the EC, erase is guaranteed to brick your laptop\n"
310 "and write may brick your laptop.\n"
311 "Read and probe may irritate your EC and cause fan failure, backlight\n"
312 "failure and sudden poweroff.\n"
313 "You have been warned.\n"
314 "========================================================================\n");
Stefan Taunera34d7192011-07-26 00:54:42 +0000315
Stefan Taunera28087f2011-09-13 23:14:25 +0000316 if (force_laptop || (not_a_laptop && (is_laptop == 2))) {
317 msg_perr("Proceeding anyway because user forced us to.\n");
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000318 } else {
319 msg_perr("Aborting.\n");
Niklas Söderlund2a95e872012-07-30 19:42:33 +0000320 return 1;
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000321 }
322 }
Michael Karcher8c1df282010-02-26 09:51:20 +0000323
Carl-Daniel Hailfingerb5b161b2010-06-04 19:05:39 +0000324#if __FLASHROM_LITTLE_ENDIAN__
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000325 /* try to enable it. Failure IS an option, since not all motherboards
326 * really need this to be done, etc., etc.
327 */
328 ret = chipset_flash_enable();
329 if (ret == -2) {
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000330 msg_perr("WARNING: No chipset found. Flash detection "
331 "will most likely fail.\n");
Tadas Slotkusad470342011-09-03 17:15:00 +0000332 } else if (ret == ERROR_FATAL)
333 return ret;
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000334
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +0000335#if defined(__i386__) || defined(__x86_64__)
Carl-Daniel Hailfinger76d4b372010-07-10 16:56:32 +0000336 /* Probe unconditionally for IT87* LPC->SPI translation and for
337 * IT87* Parallel write enable.
338 */
339 init_superio_ite();
Carl-Daniel Hailfingercceafa22010-05-26 01:45:41 +0000340#endif
Carl-Daniel Hailfinger01f3ef42010-03-25 02:50:40 +0000341
Stefan Taunerb4e06bd2012-08-20 00:24:22 +0000342 if (board_flash_enable(board_vendor, board_model)) {
343 msg_perr("Aborting to be safe.\n");
344 return 1;
345 }
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000346
Vladimir 'phcoder' Serbinenko5cfc94a2010-09-29 23:37:24 +0000347#if defined(__i386__) || defined(__x86_64__) || defined (__mips)
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000348 register_par_programmer(&par_programmer_internal, internal_buses_supported);
Carl-Daniel Hailfinger27023762010-04-28 15:22:14 +0000349 return 0;
Carl-Daniel Hailfingerb5b161b2010-06-04 19:05:39 +0000350#else
351 msg_perr("Your platform is not supported yet for the internal "
352 "programmer due to missing\n"
353 "flash_base and top/bottom alignment information.\n"
354 "Aborting.\n");
355 return 1;
356#endif
357#else
358 /* FIXME: Remove this unconditional abort once all PCI drivers are
359 * converted to use little-endian accesses for memory BARs.
360 */
361 msg_perr("Your platform is not supported yet for the internal "
362 "programmer because it has\n"
363 "not been converted from native endian to little endian "
364 "access yet.\n"
365 "Aborting.\n");
366 return 1;
367#endif
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000368}
Carl-Daniel Hailfinger66ef4e52009-12-13 22:28:00 +0000369#endif
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000370
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000371static void internal_chip_writeb(const struct flashctx *flash, uint8_t val,
372 chipaddr addr)
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000373{
Carl-Daniel Hailfinger78185dc2009-05-17 15:49:24 +0000374 mmio_writeb(val, (void *) addr);
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000375}
376
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000377static void internal_chip_writew(const struct flashctx *flash, uint16_t val,
378 chipaddr addr)
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000379{
Carl-Daniel Hailfinger78185dc2009-05-17 15:49:24 +0000380 mmio_writew(val, (void *) addr);
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000381}
382
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000383static void internal_chip_writel(const struct flashctx *flash, uint32_t val,
384 chipaddr addr)
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000385{
Carl-Daniel Hailfinger78185dc2009-05-17 15:49:24 +0000386 mmio_writel(val, (void *) addr);
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000387}
388
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000389static uint8_t internal_chip_readb(const struct flashctx *flash,
390 const chipaddr addr)
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000391{
Carl-Daniel Hailfinger78185dc2009-05-17 15:49:24 +0000392 return mmio_readb((void *) addr);
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000393}
394
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000395static uint16_t internal_chip_readw(const struct flashctx *flash,
396 const chipaddr addr)
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000397{
Carl-Daniel Hailfinger78185dc2009-05-17 15:49:24 +0000398 return mmio_readw((void *) addr);
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000399}
400
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000401static uint32_t internal_chip_readl(const struct flashctx *flash,
402 const chipaddr addr)
Carl-Daniel Hailfinger702218d2009-05-08 17:43:22 +0000403{
Carl-Daniel Hailfinger78185dc2009-05-17 15:49:24 +0000404 return mmio_readl((void *) addr);
405}
406
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000407static void internal_chip_readn(const struct flashctx *flash, uint8_t *buf,
408 const chipaddr addr, size_t len)
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000409{
Carl-Daniel Hailfingerccd71c22012-03-01 22:38:27 +0000410 mmio_readn((void *)addr, buf, len);
Carl-Daniel Hailfinger0bd2a2b2009-06-05 18:32:07 +0000411 return;
412}