2 * This file is part of the flashrom project.
4 * Copyright (C) 2007, 2008, 2009 Carl-Daniel Hailfinger
5 * Copyright (C) 2008 Ronald Hoogenboom <ronald@zonnet.nl>
6 * Copyright (C) 2008 coresystems GmbH
7 * Copyright (C) 2010 Google Inc.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; version 2 of the License.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24 * Contains the ITE IT85* SPI specific routines
27 #if defined(__i386__) || defined(__x86_64__)
34 #include "programmer.h"
37 #define MAX_TIMEOUT 100000
40 /* Constants for I/O ports */
41 #define ITE_SUPERIO_PORT1 0x2e
42 #define ITE_SUPERIO_PORT2 0x4e
45 #define LEGACY_KBC_PORT_DATA 0x60
46 #define LEGACY_KBC_PORT_CMD 0x64
48 /* Constants for Logical Device registers */
51 /* These are standard Super I/O 16-bit base address registers */
52 #define SHM_IO_BAR0 0x60 /* big-endian, this is high bits */
53 #define SHM_IO_BAR1 0x61
55 /* The 8042 keyboard controller uses an input buffer and an output buffer to
56 * communicate with the host CPU. Both buffers are 1-byte depth. That means
57 * IBF is set to 1 when the host CPU sends a command to the input buffer
58 * of the EC. IBF is cleared to 0 once the command is read by the EC.
60 #define KB_IBF (1 << 1) /* Input Buffer Full */
61 #define KB_OBF (1 << 0) /* Output Buffer Full */
63 /* IT8502 supports two access modes:
64 * LPC_MEMORY: through the memory window in 0xFFFFFxxx (follow mode)
65 * LPC_IO: through I/O port (so called indirect memory)
71 /* macro to fill in indirect-access registers. */
72 #define INDIRECT_A0(base, value) OUTB(value, (base) + 0) /* little-endian */
73 #define INDIRECT_A1(base, value) OUTB(value, (base) + 1)
74 #define INDIRECT_A2(base, value) OUTB(value, (base) + 2)
75 #define INDIRECT_A3(base, value) OUTB(value, (base) + 3)
76 #define INDIRECT_READ(base) INB((base) + 4)
77 #define INDIRECT_WRITE(base, value) OUTB(value, (base) + 4)
81 unsigned int shm_io_base;
83 unsigned char *ce_high, *ce_low;
84 static int it85xx_scratch_rom_reenter = 0;
86 /* This function will poll the keyboard status register until either
87 * an expected value shows up, or the timeout is reached.
90 * Returns: 0 -- the expected value showed up.
93 static int wait_for(const unsigned int mask, const unsigned int expected_value,
94 const int timeout, const char * error_message,
95 const char * function_name, const int lineno)
99 for (time_passed = 0;; ++time_passed) {
100 if ((INB(LEGACY_KBC_PORT_CMD) & mask) == expected_value)
102 if (time_passed >= timeout)
107 msg_perr("%s():%d %s", function_name, lineno, error_message);
111 /* IT8502 employs a scratch RAM when flash is being updated. Call the following
112 * two functions before/after flash erase/program. */
113 void it85xx_enter_scratch_rom(void)
117 msg_pdbg("%s():%d was called ...\n", __func__, __LINE__);
118 if (it85xx_scratch_rom_reenter > 0)
122 /* FIXME: this a workaround for the bug that SMBus signal would
123 * interfere the EC firmware update. Should be removed if
124 * we find out the root cause. */
125 ret = system("stop powerd >&2");
127 msg_perr("Cannot stop powerd.\n");
130 for (tries = 0; tries < MAX_TRY; ++tries) {
131 /* Wait until IBF (input buffer) is not full. */
132 if (wait_for(KB_IBF, 0, MAX_TIMEOUT,
133 "* timeout at waiting for IBF==0.\n",
137 /* Copy EC firmware to SRAM. */
138 OUTB(0xb4, LEGACY_KBC_PORT_CMD);
140 /* Confirm EC has taken away the command. */
141 if (wait_for(KB_IBF, 0, MAX_TIMEOUT,
142 "* timeout at taking command.\n",
146 /* Waiting for OBF (output buffer) has data.
147 * Note sometimes the replied command might be stolen by kernel
148 * ISR so that it is okay as long as the command is 0xFA. */
149 if (wait_for(KB_OBF, KB_OBF, MAX_TIMEOUT, NULL, NULL, 0))
150 msg_pdbg("%s():%d * timeout at waiting for OBF.\n",
152 if ((ret = INB(LEGACY_KBC_PORT_DATA)) == 0xFA) {
155 msg_perr("%s():%d * not run on SRAM ret=%d\n",
156 __func__, __LINE__, ret);
161 if (tries < MAX_TRY) {
162 /* EC already runs on SRAM */
163 it85xx_scratch_rom_reenter++;
164 msg_pdbg("%s():%d * SUCCESS.\n", __func__, __LINE__);
166 msg_perr("%s():%d * Max try reached.\n", __func__, __LINE__);
170 void it85xx_exit_scratch_rom(void)
177 msg_pdbg("%s():%d was called ...\n", __func__, __LINE__);
178 if (it85xx_scratch_rom_reenter <= 0)
181 for (tries = 0; tries < MAX_TRY; ++tries) {
182 /* Wait until IBF (input buffer) is not full. */
183 if (wait_for(KB_IBF, 0, MAX_TIMEOUT,
184 "* timeout at waiting for IBF==0.\n",
188 /* Exit SRAM. Run on flash. */
189 OUTB(0xFE, LEGACY_KBC_PORT_CMD);
191 /* Confirm EC has taken away the command. */
192 if (wait_for(KB_IBF, 0, MAX_TIMEOUT,
193 "* timeout at taking command.\n",
194 __func__, __LINE__)) {
195 /* We cannot ensure if EC has exited update mode.
196 * If EC is in normal mode already, a further 0xFE
197 * command will reboot system. So, exit loop here. */
205 if (tries < MAX_TRY) {
206 it85xx_scratch_rom_reenter = 0;
207 msg_pdbg("%s():%d * SUCCESS.\n", __func__, __LINE__);
209 msg_perr("%s():%d * Max try reached.\n", __func__, __LINE__);
213 /* FIXME: this a workaround for the bug that SMBus signal would
214 * interfere the EC firmware update. Should be removed if
215 * we find out the root cause. */
216 ret = system("start powerd >&2");
218 msg_perr("Cannot start powerd again.\n");
222 static int it85xx_shutdown(void *data)
224 msg_pdbg("%s():%d\n", __func__, __LINE__);
225 it85xx_exit_scratch_rom();
227 return 0; /* FIXME: Should probably return something meaningful */
230 static int it85xx_spi_common_init(struct superio s)
234 msg_pdbg("%s():%d superio.vendor=0x%02x\n", __func__, __LINE__,
237 if (register_shutdown(it85xx_shutdown, NULL))
241 /* Get LPCPNP of SHM. That's big-endian. */
242 sio_write(s.port, LDNSEL, 0x0F); /* Set LDN to SHM (0x0F) */
243 shm_io_base = (sio_read(s.port, SHM_IO_BAR0) << 8) +
244 sio_read(s.port, SHM_IO_BAR1);
245 msg_pdbg("%s():%d shm_io_base=0x%04x\n", __func__, __LINE__,
248 /* These pointers are not used directly. They will be send to EC's
249 * register for indirect access. */
251 ce_high = ((unsigned char *)base) + 0xE00; /* 0xFFFFFE00 */
252 ce_low = ((unsigned char *)base) + 0xD00; /* 0xFFFFFD00 */
254 /* pre-set indirect-access registers since in most of cases they are
256 INDIRECT_A0(shm_io_base, base & 0xFF);
257 INDIRECT_A2(shm_io_base, (base >> 16) & 0xFF);
258 INDIRECT_A3(shm_io_base, (base >> 24));
261 /* FIXME: We should block accessing that region for anything else.
262 * Major TODO here, and it will be a lot of work.
264 base = (chipaddr)physmap("it85 communication", 0xFFFFF000, 0x1000);
265 msg_pdbg("%s():%d base=0x%08x\n", __func__, __LINE__,
267 ce_high = (unsigned char *)(base + 0xE00); /* 0xFFFFFE00 */
268 ce_low = (unsigned char *)(base + 0xD00); /* 0xFFFFFD00 */
274 static int it85xx_spi_send_command(struct flashctx *flash,
275 unsigned int writecnt, unsigned int readcnt,
276 const unsigned char *writearr,
277 unsigned char *readarr);
279 static const struct spi_programmer spi_programmer_it85xx = {
280 .type = SPI_CONTROLLER_IT85XX,
282 .max_data_write = 64,
283 .command = it85xx_spi_send_command,
284 .multicommand = default_spi_send_multicommand,
285 .read = default_spi_read,
286 .write_256 = default_spi_write_256,
287 .write_aai = default_spi_write_aai,
290 int it85xx_spi_init(struct superio s)
294 if (!(internal_buses_supported & BUS_FWH)) {
295 msg_pdbg("%s():%d buses not support FWH\n", __func__, __LINE__);
298 ret = it85xx_spi_common_init(s);
299 msg_pdbg("FWH: %s():%d ret=%d\n", __func__, __LINE__, ret);
301 msg_pdbg("%s: internal_buses_supported=0x%x\n", __func__,
302 internal_buses_supported);
303 /* Check for FWH because IT85 listens to FWH cycles.
304 * FIXME: The big question is whether FWH cycles are necessary
305 * for communication even if LPC_IO is defined.
307 if (internal_buses_supported & BUS_FWH)
308 msg_pdbg("Registering IT85 SPI.\n");
309 /* FIXME: Really leave FWH enabled? We can't use this region
310 * anymore since accessing it would mess up IT85 communication.
311 * If we decide to disable FWH for this region, we should print
312 * a debug message about it.
314 /* Set this as SPI controller. */
315 register_spi_programmer(&spi_programmer_it85xx);
320 /* According to ITE 8502 document, the procedure to follow mode is following:
321 * 1. write 0x00 to LPC/FWH address 0xffff_fexxh (drive CE# high)
322 * 2. write data to LPC/FWH address 0xffff_fdxxh (drive CE# low and MOSI
324 * 3. read date from LPC/FWH address 0xffff_fdxxh (drive CE# low and get
327 static int it85xx_spi_send_command(struct flashctx *flash,
328 unsigned int writecnt, unsigned int readcnt,
329 const unsigned char *writearr,
330 unsigned char *readarr)
334 it85xx_enter_scratch_rom();
335 /* Exit scratch ROM ONLY when programmer shuts down. Otherwise, the
336 * temporary flash state may halt the EC.
340 INDIRECT_A1(shm_io_base, (((unsigned long int)ce_high) >> 8) & 0xff);
341 INDIRECT_WRITE(shm_io_base, 0xFF); /* Write anything to this address.*/
342 INDIRECT_A1(shm_io_base, (((unsigned long int)ce_low) >> 8) & 0xff);
345 mmio_writeb(0, ce_high);
347 for (i = 0; i < writecnt; ++i) {
349 INDIRECT_WRITE(shm_io_base, writearr[i]);
352 mmio_writeb(writearr[i], ce_low);
355 for (i = 0; i < readcnt; ++i) {
357 readarr[i] = INDIRECT_READ(shm_io_base);
360 readarr[i] = mmio_readb(ce_low);
364 INDIRECT_A1(shm_io_base, (((unsigned long int)ce_high) >> 8) & 0xff);
365 INDIRECT_WRITE(shm_io_base, 0xFF); /* Write anything to this address.*/
368 mmio_writeb(0, ce_high);