17b32d529f514b1c3d9bae3db4b369700e6348c8
[coreboot.git] / src / southbridge / via / vt8237r / vt8237r_early_smbus.c
1 /*
2  * This file is part of the coreboot project.
3  *
4  * Copyright (C) 2007 Corey Osgood <corey_osgood@verizon.net>
5  * Copyright (C) 2007 Rudolf Marek <r.marek@assembler.cz>
6  *
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.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
20  */
21
22 #include <device/pci_ids.h>
23 #include <spd.h>
24 #include <stdlib.h>
25 #include "vt8237r.h"
26
27 /**
28  * Print an error, should it occur. If no error, just exit.
29  *
30  * @param host_status The data returned on the host status register after
31  *                    a transaction is processed.
32  * @param loops The number of times a transaction was attempted.
33  */
34 static void smbus_print_error(u8 host_status, int loops)
35 {
36         /* Check if there actually was an error. */
37         if ((host_status == 0x00 || host_status == 0x40 ||
38              host_status == 0x42) && (loops < SMBUS_TIMEOUT))
39                 return;
40
41         if (loops >= SMBUS_TIMEOUT)
42                 print_err("SMBus timeout\r\n");
43         if (host_status & (1 << 4))
44                 print_err("Interrupt/SMI# was Failed Bus Transaction\r\n");
45         if (host_status & (1 << 3))
46                 print_err("Bus error\r\n");
47         if (host_status & (1 << 2))
48                 print_err("Device error\r\n");
49         if (host_status & (1 << 1))
50                 print_debug("Interrupt/SMI# completed successfully\r\n");
51         if (host_status & (1 << 0))
52                 print_err("Host busy\r\n");
53 }
54
55 /**
56  * Wait for the SMBus to become ready to process the next transaction.
57  */
58 static void smbus_wait_until_ready(void)
59 {
60         int loops;
61
62         PRINT_DEBUG("Waiting until SMBus ready\r\n");
63
64         loops = 0;
65         /* Yes, this is a mess, but it's the easiest way to do it. */
66         while ((inb(SMBHSTSTAT) & 1) == 1 && loops < SMBUS_TIMEOUT)
67                 ++loops;
68
69         smbus_print_error(inb(SMBHSTSTAT), loops);
70 }
71
72 /**
73  * Reset and take ownership of the SMBus.
74  */
75 static void smbus_reset(void)
76 {
77         outb(HOST_RESET, SMBHSTSTAT);
78
79         /* Datasheet says we have to read it to take ownership of SMBus. */
80         inb(SMBHSTSTAT);
81
82         PRINT_DEBUG("After reset status: ");
83         PRINT_DEBUG_HEX16(inb(SMBHSTSTAT));
84         PRINT_DEBUG("\r\n");
85 }
86
87 /**
88  * Read a byte from the SMBus.
89  *
90  * @param dimm The address location of the DIMM on the SMBus.
91  * @param offset The offset the data is located at.
92  */
93 u8 smbus_read_byte(u8 dimm, u8 offset)
94 {
95         u8 val;
96
97         PRINT_DEBUG("DIMM ");
98         PRINT_DEBUG_HEX16(dimm);
99         PRINT_DEBUG(" OFFSET ");
100         PRINT_DEBUG_HEX16(offset);
101         PRINT_DEBUG("\r\n");
102
103         smbus_reset();
104
105         /* Clear host data port. */
106         outb(0x00, SMBHSTDAT0);
107         SMBUS_DELAY();
108         smbus_wait_until_ready();
109
110         /* Actual addr to reg format. */
111         dimm = (dimm << 1);
112         dimm |= 1;
113         outb(dimm, SMBXMITADD);
114         outb(offset, SMBHSTCMD);
115
116         /* Start transaction, byte data read. */
117         outb(0x48, SMBHSTCTL);
118         SMBUS_DELAY();
119         smbus_wait_until_ready();
120
121         val = inb(SMBHSTDAT0);
122         PRINT_DEBUG("Read: ");
123         PRINT_DEBUG_HEX16(val);
124         PRINT_DEBUG("\r\n");
125
126         /* Probably don't have to do this, but it can't hurt. */
127         smbus_reset();
128
129         return val;
130 }
131
132 /**
133  * Enable the SMBus on VT8237R-based systems.
134  */
135 void enable_smbus(void)
136 {
137         device_t dev;
138
139         /* Power management controller */
140         dev = pci_locate_device(PCI_ID(PCI_VENDOR_ID_VIA,
141                                        PCI_DEVICE_ID_VIA_VT8237R_LPC), 0);
142         if (dev == PCI_DEV_INVALID) {
143                 /* Power management controller */
144                 dev = pci_locate_device(PCI_ID(PCI_VENDOR_ID_VIA,
145                                         PCI_DEVICE_ID_VIA_VT8237S_LPC), 0);
146                 if (dev == PCI_DEV_INVALID)
147                         die("Power management controller not found\r\n");
148         }
149
150         /*
151          * 7 = SMBus Clock from RTC 32.768KHz
152          * 5 = Internal PLL reset from susp
153          */
154         pci_write_config8(dev, VT8237R_POWER_WELL, 0xa0);
155
156         /* Enable SMBus. */
157         pci_write_config16(dev, VT8237R_SMBUS_IO_BASE_REG,
158                            VT8237R_SMBUS_IO_BASE | 0x1);
159
160         /* SMBus Host Configuration, enable. */
161         pci_write_config8(dev, VT8237R_SMBUS_HOST_CONF, 0x01);
162
163         /* Make it work for I/O. */
164         pci_write_config16(dev, PCI_COMMAND, PCI_COMMAND_IO);
165
166         smbus_reset();
167
168         /* Reset the internal pointer. */
169         inb(SMBHSTCTL);
170 }
171
172 /**
173  * A fixup for some systems that need time for the SMBus to "warm up". This is 
174  * needed on some VT823x based systems, where the SMBus spurts out bad data for 
175  * a short time after power on. This has been seen on the VIA Epia series and 
176  * Jetway J7F2-series. It reads the ID byte from SMBus, looking for 
177  * known-good data from a slot/address. Exits on either good data or a timeout.
178  *
179  * TODO: This should probably go into some global file, but one would need to
180  *       be created just for it. If some other chip needs/wants it, we can
181  *       worry about it then.
182  *
183  * @param ctrl The memory controller and SMBus addresses.
184  */
185 void smbus_fixup(const struct mem_controller *ctrl)
186 {
187         int i, ram_slots, current_slot = 0;
188         u8 result = 0;
189
190         ram_slots = ARRAY_SIZE(ctrl->channel0);
191         if (!ram_slots) {
192                 print_err("smbus_fixup() thinks there are no RAM slots!\r\n");
193                 return;
194         }
195
196         PRINT_DEBUG("Waiting for SMBus to warm up");
197
198         /*
199          * Bad SPD data should be either 0 or 0xff, but YMMV. So we look for
200          * the ID bytes of SDRAM, DDR, DDR2, and DDR3 (and anything in between).
201          * VT8237R has only been seen on DDR and DDR2 based systems, so far.
202          */
203         for (i = 0; (i < SMBUS_TIMEOUT && ((result < SPD_MEMORY_TYPE_SDRAM) ||
204            (result > SPD_MEMORY_TYPE_SDRAM_DDR3))); i++) {
205
206                 if (current_slot > ram_slots)
207                         current_slot = 0;
208
209                 result = smbus_read_byte(ctrl->channel0[current_slot],
210                                          SPD_MEMORY_TYPE);
211                 current_slot++;
212                 PRINT_DEBUG(".");
213         }
214
215         if (i >= SMBUS_TIMEOUT)
216                 print_err("SMBus timed out while warming up\r\n");
217         else
218                 PRINT_DEBUG("Done\r\n");
219 }
220
221 /* FIXME: Better separate the NB and SB, will be done once it works. */
222
223 void vt8237_sb_enable_fid_vid(void)
224 {
225         device_t dev, devctl;
226
227         /* Power management controller */
228         dev = pci_locate_device(PCI_ID(PCI_VENDOR_ID_VIA,
229                                        PCI_DEVICE_ID_VIA_VT8237R_LPC), 0);
230         if (dev == PCI_DEV_INVALID) {
231                 /* Power management controller */
232                 dev = pci_locate_device(PCI_ID(PCI_VENDOR_ID_VIA,
233                                         PCI_DEVICE_ID_VIA_VT8237S_LPC), 0);
234                 if (dev == PCI_DEV_INVALID)
235                         return;
236
237                 devctl = pci_locate_device(PCI_ID(PCI_VENDOR_ID_VIA,
238                                            PCI_DEVICE_ID_VIA_VT8237_VLINK), 0);
239
240                 if (devctl == PCI_DEV_INVALID)
241                         return;
242
243                 /* Set ACPI base address to I/O VT8237R_ACPI_IO_BASE. */
244                 pci_write_config16(dev, 0x88, VT8237R_ACPI_IO_BASE | 0x1);
245
246                 /* Enable ACPI accessm RTC signal gated with PSON. */
247                 pci_write_config8(dev, 0x81, 0x84);
248
249                 /*
250                  * Allow SLP# signal to assert LDTSTOP_L.
251                  * Will work for C3 and for FID/VID change.
252                  */
253
254                 outb(0xff, VT8237R_ACPI_IO_BASE + 0x50);
255
256                 /* Reduce further the STPCLK/LDTSTP signal to 5us. */
257                 pci_write_config8(dev, 0xec, 0x4);
258
259                 /* So the chip knows we are on AMD. */
260                 pci_write_config8(devctl, 0x7c, 0x7f);
261
262                 return;
263         }
264
265         /* Set ACPI base address to I/O VT8237R_ACPI_IO_BASE. */
266         pci_write_config16(dev, 0x88, VT8237R_ACPI_IO_BASE | 0x1);
267
268         /* Enable ACPI accessm RTC signal gated with PSON. */
269         pci_write_config8(dev, 0x81, 0x84);
270
271         /*
272          * Allow SLP# signal to assert LDTSTOP_L.
273          * Will work for C3 and for FID/VID change.
274          */
275         outb(0x1, VT8237R_ACPI_IO_BASE + 0x11);
276 }
277
278 void enable_rom_decode(void)
279 {
280         device_t dev;
281
282         /* Power management controller */
283         dev = pci_locate_device(PCI_ID(PCI_VENDOR_ID_VIA,
284                                        PCI_DEVICE_ID_VIA_VT8237R_LPC), 0);
285         if (dev == PCI_DEV_INVALID) {
286                 /* Power management controller */
287                 dev = pci_locate_device(PCI_ID(PCI_VENDOR_ID_VIA,
288                                         PCI_DEVICE_ID_VIA_VT8237S_LPC), 0);
289                 if (dev == PCI_DEV_INVALID)
290                         return;
291         }
292
293         /* ROM decode last 1MB FFC00000 - FFFFFFFF. */
294         pci_write_config8(dev, 0x41, 0x7f);
295 }
296
297 #define ACPI_IS_WAKEUP_EARLY 1
298
299 int acpi_is_wakeup_early(void) {
300         device_t dev;
301         u16 tmp;
302
303         print_debug("IN TEST WAKEUP\n");
304
305         /* Power management controller */
306         dev = pci_locate_device(PCI_ID(PCI_VENDOR_ID_VIA,
307                                        PCI_DEVICE_ID_VIA_VT8237R_LPC), 0);
308         if (dev == PCI_DEV_INVALID) {
309                 /* Power management controller */
310                 dev = pci_locate_device(PCI_ID(PCI_VENDOR_ID_VIA,
311                                         PCI_DEVICE_ID_VIA_VT8237S_LPC), 0);
312                 if (dev == PCI_DEV_INVALID)
313                         die("Power management controller not found\r\n");
314         }
315
316         /* Set ACPI base address to I/O VT8237R_ACPI_IO_BASE. */
317         pci_write_config16(dev, 0x88, VT8237R_ACPI_IO_BASE | 0x1);
318
319         /* Enable ACPI accessm RTC signal gated with PSON. */
320         pci_write_config8(dev, 0x81, 0x84);
321
322         tmp = inw(VT8237R_ACPI_IO_BASE + 0x04);
323
324         print_debug_hex8(tmp);
325         return ((tmp & (7 << 10)) >> 10) == 1 ? 3 : 0 ;
326 }
327
328 #if defined(__GNUC__)
329 void vt8237_early_spi_init(void)
330 {
331         device_t dev;
332         volatile u16 *spireg;
333         u32 tmp;
334
335         /* Bus Control and Power Management */
336         dev = pci_locate_device(PCI_ID(PCI_VENDOR_ID_VIA,
337                                        PCI_DEVICE_ID_VIA_VT8237S_LPC), 0);
338
339         if (dev == PCI_DEV_INVALID)
340                 die("SB not found\r\n");
341
342         /* Put SPI base 20 d0 fe. */
343         tmp = pci_read_config32(dev, 0xbc);
344         pci_write_config32(dev, 0xbc,
345                            (VT8237S_SPI_MEM_BASE >> 8) | (tmp & 0xFF000000));
346
347         /* Set SPI clock to 33MHz. */
348         spireg = (u16 *) (VT8237S_SPI_MEM_BASE + 0x6c);
349         (*spireg) &= 0xff00;
350 }
351 #endif
352
353 /* This #if is special. ROMCC chokes on the (rom == NULL) comparison.
354  * Since the whole function is only called for one target and that target
355  * is compiled with GCC, hide the function from ROMCC and be happy.
356  */
357 #if defined(__GNUC__)
358 /*
359  * Offset 0x58:
360  * 31:20        reserved
361  * 19:16        4 bit position in shadow EEPROM
362  * 15:0         data to write
363  *
364  * Offset 0x5c:
365  * 31:28        reserved
366  * 27           ERDBG - enable read from 0x5c
367  * 26           reserved
368  * 25           SEELD
369  * 24           SEEPR - write 1 when done updating, wait until SEELD is
370  *                      set to 1, sticky
371  *              cleared by reset, if it is 1 writing is disabled
372  * 19:16        4 bit position in shadow EEPROM
373  * 15:0         data from shadow EEPROM
374  *
375  * After PCIRESET SEELD and SEEPR must be 1 and 1.
376  */
377
378 /* 1 = needs PCI reset, 0 don't reset, network initialized. */
379
380 /* FIXME: Maybe close the debug register after use? */
381
382 #define LAN_TIMEOUT 0x7FFFFFFF
383
384 int vt8237_early_network_init(struct vt8237_network_rom *rom)
385 {
386         struct vt8237_network_rom n;
387         int i, loops;
388         device_t dev;
389         u32 tmp;
390         u8 status;
391         u16 *rom_write;
392         unsigned int checksum;
393
394         /* Network adapter */
395         dev = pci_locate_device(PCI_ID(PCI_VENDOR_ID_VIA,
396                                        PCI_DEVICE_ID_VIA_8233_7), 0);
397         if (dev == PCI_DEV_INVALID) {
398                 print_err("Network is disabled, please enable\n");
399                 return 0;
400         }
401
402         tmp = pci_read_config32(dev, 0x5c);
403         tmp |= 0x08000000;      /* Enable ERDBG. */
404         pci_write_config32(dev, 0x5c, tmp);
405
406         status = ((pci_read_config32(dev, 0x5c) >> 24) & 0x3);
407
408         /* Network controller OK, EEPROM loaded. */
409         if (status == 3)
410                 return 0;
411
412         if (rom == NULL) {
413                 print_err("No config data specified, using default MAC!\n");
414                 n.mac_address[0] = 0x0;
415                 n.mac_address[1] = 0x0;
416                 n.mac_address[2] = 0xde;
417                 n.mac_address[3] = 0xad;
418                 n.mac_address[4] = 0xbe;
419                 n.mac_address[5] = 0xef;
420                 n.phy_addr = 0x1;
421                 n.res1 = 0x0;
422                 n.sub_sid = 0x102;
423                 n.sub_vid = 0x1106;
424                 n.pid = 0x3065;
425                 n.vid = 0x1106;
426                 n.pmcc = 0x1f;
427                 n.data_sel = 0x10;
428                 n.pmu_data_reg = 0x0;
429                 n.aux_curr = 0x0;
430                 n.reserved = 0x0;
431                 n.min_gnt = 0x3;
432                 n.max_lat = 0x8;
433                 n.bcr0 = 0x9;
434                 n.bcr1 = 0xe;
435                 n.cfg_a = 0x3;
436                 n.cfg_b = 0x0;
437                 n.cfg_c = 0x40;
438                 n.cfg_d = 0x82;
439                 n.checksum = 0x0;
440                 rom = &n;
441         }
442
443         rom_write = (u16 *) rom;
444         checksum = 0;
445         /* Write all data except checksum and second to last byte. */
446         tmp &= 0xff000000;      /* Leave reserved bits in. */
447         for (i = 0; i < 15; i++) {
448                 pci_write_config32(dev, 0x58, tmp | (i << 16) | rom_write[i]);
449                 /* Lame code FIXME */
450                 checksum += rom_write[i] & 0xff;
451                 /* checksum %= 256; */
452                 checksum += (rom_write[i] >> 8) & 0xff;
453                 /* checksum %= 256; */
454         }
455
456         checksum += (rom_write[15] & 0xff);
457         checksum = ~(checksum & 0xff);
458         tmp |= (((checksum & 0xff) << 8) | rom_write[15]);
459
460         /* Write last byte and checksum. */
461         pci_write_config32(dev, 0x58, (15 << 16) | tmp);
462
463         tmp = pci_read_config32(dev, 0x5c);
464         pci_write_config32(dev, 0x5c, tmp | 0x01000000); /* Toggle SEEPR. */
465
466         /* Yes, this is a mess, but it's the easiest way to do it. */
467         while ((((pci_read_config32(dev, 0x5c) >> 25) & 1) == 0)
468                && (loops < LAN_TIMEOUT)) {
469                 ++loops;
470         }
471
472         if (loops >= LAN_TIMEOUT) {
473                 print_err("Timeout - LAN controller didn't accept config\n");
474                 return 0;
475         }
476
477         /* We are done, config will be used after PCIRST#. */
478         return 1;
479 }
480 #endif