Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 1 | /* |
| 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 | |
| 21 | #include <stdint.h> |
| 22 | #include <string.h> |
| 23 | #include <stdlib.h> |
| 24 | #include <fcntl.h> |
| 25 | #include <sys/types.h> |
| 26 | #include <sys/stat.h> |
| 27 | #include <errno.h> |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 28 | #include "flash.h" |
| 29 | |
Carl-Daniel Hailfinger | 66ef4e5 | 2009-12-13 22:28:00 +0000 | [diff] [blame] | 30 | #if NEED_PCI == 1 |
Christian Ruppert | 0cdb031 | 2009-05-14 18:57:26 +0000 | [diff] [blame] | 31 | struct pci_dev *pci_dev_find_filter(struct pci_filter filter) |
| 32 | { |
| 33 | struct pci_dev *temp; |
| 34 | |
| 35 | for (temp = pacc->devices; temp; temp = temp->next) |
| 36 | if (pci_filter_match(&filter, temp)) |
| 37 | return temp; |
| 38 | |
| 39 | return NULL; |
| 40 | } |
| 41 | |
Carl-Daniel Hailfinger | 9f46cfc | 2009-11-15 17:13:29 +0000 | [diff] [blame] | 42 | struct pci_dev *pci_dev_find_vendorclass(uint16_t vendor, uint16_t class) |
| 43 | { |
| 44 | struct pci_dev *temp; |
| 45 | struct pci_filter filter; |
| 46 | uint16_t tmp2; |
| 47 | |
| 48 | pci_filter_init(NULL, &filter); |
| 49 | filter.vendor = vendor; |
| 50 | |
| 51 | for (temp = pacc->devices; temp; temp = temp->next) |
| 52 | if (pci_filter_match(&filter, temp)) { |
| 53 | /* Read PCI class */ |
| 54 | tmp2 = pci_read_word(temp, 0x0a); |
| 55 | if (tmp2 == class) |
| 56 | return temp; |
| 57 | } |
| 58 | |
| 59 | return NULL; |
| 60 | } |
| 61 | |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 62 | struct pci_dev *pci_dev_find(uint16_t vendor, uint16_t device) |
| 63 | { |
| 64 | struct pci_dev *temp; |
| 65 | struct pci_filter filter; |
| 66 | |
| 67 | pci_filter_init(NULL, &filter); |
| 68 | filter.vendor = vendor; |
| 69 | filter.device = device; |
| 70 | |
| 71 | for (temp = pacc->devices; temp; temp = temp->next) |
| 72 | if (pci_filter_match(&filter, temp)) |
| 73 | return temp; |
| 74 | |
| 75 | return NULL; |
| 76 | } |
| 77 | |
| 78 | struct pci_dev *pci_card_find(uint16_t vendor, uint16_t device, |
| 79 | uint16_t card_vendor, uint16_t card_device) |
| 80 | { |
| 81 | struct pci_dev *temp; |
| 82 | struct pci_filter filter; |
| 83 | |
| 84 | pci_filter_init(NULL, &filter); |
| 85 | filter.vendor = vendor; |
| 86 | filter.device = device; |
| 87 | |
| 88 | for (temp = pacc->devices; temp; temp = temp->next) |
| 89 | if (pci_filter_match(&filter, temp)) { |
| 90 | if ((card_vendor == |
| 91 | pci_read_word(temp, PCI_SUBSYSTEM_VENDOR_ID)) |
| 92 | && (card_device == |
| 93 | pci_read_word(temp, PCI_SUBSYSTEM_ID))) |
| 94 | return temp; |
| 95 | } |
| 96 | |
| 97 | return NULL; |
| 98 | } |
Carl-Daniel Hailfinger | 66ef4e5 | 2009-12-13 22:28:00 +0000 | [diff] [blame] | 99 | #endif |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 100 | |
Carl-Daniel Hailfinger | 66ef4e5 | 2009-12-13 22:28:00 +0000 | [diff] [blame] | 101 | #if INTERNAL_SUPPORT == 1 |
Carl-Daniel Hailfinger | 14e100c | 2009-12-22 23:42:04 +0000 | [diff] [blame] | 102 | struct superio superio = {}; |
Michael Karcher | 0bdc092 | 2010-02-28 01:33:48 +0000 | [diff] [blame] | 103 | int force_boardenable = 0; |
Carl-Daniel Hailfinger | 2702376 | 2010-04-28 15:22:14 +0000 | [diff] [blame] | 104 | int force_boardmismatch = 0; |
Carl-Daniel Hailfinger | 14e100c | 2009-12-22 23:42:04 +0000 | [diff] [blame] | 105 | |
| 106 | void probe_superio(void) |
| 107 | { |
| 108 | superio = probe_superio_ite(); |
Uwe Hermann | 4395970 | 2010-03-13 17:28:29 +0000 | [diff] [blame] | 109 | #if 0 |
| 110 | /* Winbond Super I/O code is not yet available. */ |
Carl-Daniel Hailfinger | 14e100c | 2009-12-22 23:42:04 +0000 | [diff] [blame] | 111 | if (superio.vendor == SUPERIO_VENDOR_NONE) |
| 112 | superio = probe_superio_winbond(); |
| 113 | #endif |
| 114 | } |
| 115 | |
Michael Karcher | 8c1df28 | 2010-02-26 09:51:20 +0000 | [diff] [blame] | 116 | int is_laptop; |
| 117 | |
Uwe Hermann | a086932 | 2009-05-14 20:41:57 +0000 | [diff] [blame] | 118 | int internal_init(void) |
| 119 | { |
| 120 | int ret = 0; |
Carl-Daniel Hailfinger | 2702376 | 2010-04-28 15:22:14 +0000 | [diff] [blame] | 121 | int force_laptop = 0; |
| 122 | char *arg; |
Uwe Hermann | a086932 | 2009-05-14 20:41:57 +0000 | [diff] [blame] | 123 | |
Carl-Daniel Hailfinger | 2702376 | 2010-04-28 15:22:14 +0000 | [diff] [blame] | 124 | arg = extract_param(&programmer_param, "boardenable=", ",:"); |
| 125 | if (arg && !strcmp(arg,"force")) { |
| 126 | force_boardenable = 1; |
| 127 | } else if (arg && !strlen(arg)) { |
| 128 | msg_perr("Missing argument for boardenable.\n"); |
| 129 | } else if (arg) { |
| 130 | msg_perr("Unknown argument for boardenable: %s\n", arg); |
| 131 | exit(1); |
Michael Karcher | 0bdc092 | 2010-02-28 01:33:48 +0000 | [diff] [blame] | 132 | } |
Carl-Daniel Hailfinger | 2702376 | 2010-04-28 15:22:14 +0000 | [diff] [blame] | 133 | free(arg); |
Michael Karcher | 0bdc092 | 2010-02-28 01:33:48 +0000 | [diff] [blame] | 134 | |
Carl-Daniel Hailfinger | 2702376 | 2010-04-28 15:22:14 +0000 | [diff] [blame] | 135 | arg = extract_param(&programmer_param, "boardmismatch=", ",:"); |
| 136 | if (arg && !strcmp(arg,"force")) { |
| 137 | force_boardmismatch = 1; |
| 138 | } else if (arg && !strlen(arg)) { |
| 139 | msg_perr("Missing argument for boardmismatch.\n"); |
| 140 | } else if (arg) { |
| 141 | msg_perr("Unknown argument for boardmismatch: %s\n", arg); |
| 142 | exit(1); |
Michael Karcher | 0bdc092 | 2010-02-28 01:33:48 +0000 | [diff] [blame] | 143 | } |
Carl-Daniel Hailfinger | 2702376 | 2010-04-28 15:22:14 +0000 | [diff] [blame] | 144 | free(arg); |
| 145 | |
| 146 | arg = extract_param(&programmer_param, "laptop=", ",:"); |
| 147 | if (arg && !strcmp(arg,"force_I_want_a_brick")) { |
| 148 | force_laptop = 1; |
| 149 | } else if (arg && !strlen(arg)) { |
| 150 | msg_perr("Missing argument for laptop.\n"); |
| 151 | } else if (arg) { |
| 152 | msg_perr("Unknown argument for laptop: %s\n", arg); |
| 153 | exit(1); |
| 154 | } |
| 155 | free(arg); |
| 156 | |
Carl-Daniel Hailfinger | 3b7e75a | 2009-05-14 21:41:10 +0000 | [diff] [blame] | 157 | get_io_perms(); |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 158 | |
| 159 | /* Initialize PCI access for flash enables */ |
| 160 | pacc = pci_alloc(); /* Get the pci_access structure */ |
| 161 | /* Set all options you want -- here we stick with the defaults */ |
| 162 | pci_init(pacc); /* Initialize the PCI library */ |
| 163 | pci_scan_bus(pacc); /* We want to get the list of devices */ |
| 164 | |
| 165 | /* We look at the lbtable first to see if we need a |
| 166 | * mainboard specific flash enable sequence. |
| 167 | */ |
| 168 | coreboot_init(); |
Michael Karcher | 6701ee8 | 2010-01-20 14:14:11 +0000 | [diff] [blame] | 169 | dmi_init(); |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 170 | |
Uwe Hermann | 4395970 | 2010-03-13 17:28:29 +0000 | [diff] [blame] | 171 | /* Probe for the Super I/O chip and fill global struct superio. */ |
Carl-Daniel Hailfinger | 14e100c | 2009-12-22 23:42:04 +0000 | [diff] [blame] | 172 | probe_superio(); |
| 173 | |
Uwe Hermann | 4395970 | 2010-03-13 17:28:29 +0000 | [diff] [blame] | 174 | /* Warn if a laptop is detected. */ |
Carl-Daniel Hailfinger | 2702376 | 2010-04-28 15:22:14 +0000 | [diff] [blame] | 175 | if (is_laptop) { |
| 176 | msg_perr("========================================================================\n" |
| 177 | "WARNING! You seem to be running flashrom on a laptop.\n" |
| 178 | "Laptops, notebooks and netbooks are difficult to support and we recommend\n" |
| 179 | "to use the vendor flashing utility. The embedded controller (EC) in these\n" |
| 180 | "machines often interacts badly with flashing.\n" |
| 181 | "See http://www.flashrom.org/Laptops for details.\n\n" |
| 182 | "If flash is shared with the EC, erase is guaranteed to brick your laptop\n" |
| 183 | "and write may brick your laptop.\n" |
| 184 | "Read and probe may irritate your EC and cause fan failure, backlight\n" |
| 185 | "failure and sudden poweroff.\n" |
| 186 | "You have been warned.\n" |
| 187 | "========================================================================\n"); |
| 188 | if (force_laptop) { |
| 189 | msg_perr("Proceeding anyway because user specified " |
| 190 | "laptop=force_I_want_a_brick\n"); |
| 191 | } else { |
| 192 | msg_perr("Aborting.\n"); |
| 193 | exit(1); |
| 194 | } |
| 195 | } |
Michael Karcher | 8c1df28 | 2010-02-26 09:51:20 +0000 | [diff] [blame] | 196 | |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 197 | /* try to enable it. Failure IS an option, since not all motherboards |
| 198 | * really need this to be done, etc., etc. |
| 199 | */ |
| 200 | ret = chipset_flash_enable(); |
| 201 | if (ret == -2) { |
Carl-Daniel Hailfinger | 2702376 | 2010-04-28 15:22:14 +0000 | [diff] [blame] | 202 | msg_perr("WARNING: No chipset found. Flash detection " |
| 203 | "will most likely fail.\n"); |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 204 | } |
| 205 | |
Carl-Daniel Hailfinger | 01f3ef4 | 2010-03-25 02:50:40 +0000 | [diff] [blame] | 206 | /* Probe for IT87* LPC->SPI translation unconditionally. */ |
| 207 | it87xx_probe_spi_flash(NULL); |
| 208 | |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 209 | board_flash_enable(lb_vendor, lb_part); |
| 210 | |
Carl-Daniel Hailfinger | 9246ff4 | 2009-09-02 13:43:56 +0000 | [diff] [blame] | 211 | /* Even if chipset init returns an error code, we don't want to abort. |
| 212 | * The error code might have been a warning only. |
| 213 | * Besides that, we don't check the board enable return code either. |
| 214 | */ |
Carl-Daniel Hailfinger | 2702376 | 2010-04-28 15:22:14 +0000 | [diff] [blame] | 215 | return 0; |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 216 | } |
| 217 | |
| 218 | int internal_shutdown(void) |
| 219 | { |
Carl-Daniel Hailfinger | db41c59 | 2009-08-09 21:50:24 +0000 | [diff] [blame] | 220 | release_io_perms(); |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 221 | |
| 222 | return 0; |
| 223 | } |
Carl-Daniel Hailfinger | 66ef4e5 | 2009-12-13 22:28:00 +0000 | [diff] [blame] | 224 | #endif |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 225 | |
Carl-Daniel Hailfinger | 5820f42 | 2009-05-16 21:22:56 +0000 | [diff] [blame] | 226 | void internal_chip_writeb(uint8_t val, chipaddr addr) |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 227 | { |
Carl-Daniel Hailfinger | 78185dc | 2009-05-17 15:49:24 +0000 | [diff] [blame] | 228 | mmio_writeb(val, (void *) addr); |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 229 | } |
| 230 | |
Carl-Daniel Hailfinger | 5820f42 | 2009-05-16 21:22:56 +0000 | [diff] [blame] | 231 | void internal_chip_writew(uint16_t val, chipaddr addr) |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 232 | { |
Carl-Daniel Hailfinger | 78185dc | 2009-05-17 15:49:24 +0000 | [diff] [blame] | 233 | mmio_writew(val, (void *) addr); |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 234 | } |
| 235 | |
Carl-Daniel Hailfinger | 5820f42 | 2009-05-16 21:22:56 +0000 | [diff] [blame] | 236 | void internal_chip_writel(uint32_t val, chipaddr addr) |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 237 | { |
Carl-Daniel Hailfinger | 78185dc | 2009-05-17 15:49:24 +0000 | [diff] [blame] | 238 | mmio_writel(val, (void *) addr); |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 239 | } |
| 240 | |
Carl-Daniel Hailfinger | 5820f42 | 2009-05-16 21:22:56 +0000 | [diff] [blame] | 241 | uint8_t internal_chip_readb(const chipaddr addr) |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 242 | { |
Carl-Daniel Hailfinger | 78185dc | 2009-05-17 15:49:24 +0000 | [diff] [blame] | 243 | return mmio_readb((void *) addr); |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 244 | } |
| 245 | |
Carl-Daniel Hailfinger | 5820f42 | 2009-05-16 21:22:56 +0000 | [diff] [blame] | 246 | uint16_t internal_chip_readw(const chipaddr addr) |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 247 | { |
Carl-Daniel Hailfinger | 78185dc | 2009-05-17 15:49:24 +0000 | [diff] [blame] | 248 | return mmio_readw((void *) addr); |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 249 | } |
| 250 | |
Carl-Daniel Hailfinger | 5820f42 | 2009-05-16 21:22:56 +0000 | [diff] [blame] | 251 | uint32_t internal_chip_readl(const chipaddr addr) |
Carl-Daniel Hailfinger | 702218d | 2009-05-08 17:43:22 +0000 | [diff] [blame] | 252 | { |
Carl-Daniel Hailfinger | 78185dc | 2009-05-17 15:49:24 +0000 | [diff] [blame] | 253 | return mmio_readl((void *) addr); |
| 254 | } |
| 255 | |
Carl-Daniel Hailfinger | 0bd2a2b | 2009-06-05 18:32:07 +0000 | [diff] [blame] | 256 | void internal_chip_readn(uint8_t *buf, const chipaddr addr, size_t len) |
| 257 | { |
| 258 | memcpy(buf, (void *)addr, len); |
| 259 | return; |
| 260 | } |