src/southbridge/amd/sb600/usb.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * Copyright (C) 2008 Advanced Micro Devices, Inc.
   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; version 2 of the License.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  18  */
  19
  20 #include <console/console.h>
  21 #include <device/device.h>
  22 #include <device/pci.h>
  23 #include <device/pci_ids.h>
  24 #include <device/pci_ops.h>
  25 #include <usbdebug.h>
  26 #include <arch/io.h>
  27 #include "sb600.h"
  28
  29 static struct pci_operations lops_pci = {
  30         .set_subsystem = pci_dev_set_subsystem,
  31 };
  32
  33 static void usb_init(struct device *dev)
  34 {
  35         u8 byte;
  36         u16 word;
  37         u32 dword;
  38
  39         /* Enable OHCI0-4 and EHCI Controllers */
  40         device_t sm_dev;
  41         sm_dev = dev_find_slot(0, PCI_DEVFN(0x14, 0));
  42         byte = pci_read_config8(sm_dev, 0x68);
  43         byte |= 0x3F;
  44         pci_write_config8(sm_dev, 0x68, byte);
  45
  46         /* RPR 5.2 Enables the USB PME Event,Enable USB resume support */
  47         byte = pm_ioread(0x61);
  48         byte |= 1 << 6;
  49         pm_iowrite(0x61, byte);
  50         byte = pm_ioread(0x65);
  51         byte |= 1 << 2;
  52         pm_iowrite(0x65, byte);
  53
  54         /* RPR 5.3 Support USB device wakeup from the S4/S5 state */
  55         byte = pm_ioread(0x65);
  56         byte &= ~(1 << 0);
  57         pm_iowrite(0x65, byte);
  58
  59         /* RPR 5.6 Enable the USB controller to get reset by any software that generate a PCIRst# condition */
  60         byte = pm_ioread(0x65);
  61         byte |= (1 << 4);
  62         pm_iowrite(0x65, byte);
  63
  64         /* RPR 5.11 Disable OHCI MSI Capability */
  65         word = pci_read_config16(dev, 0x40);
  66         word |= (0x1F << 8);
  67         pci_write_config16(dev, 0x40, word);
  68
  69         /* RPR 5.8 Disable the OHCI Dynamic Power Saving feature  */
  70         dword = pci_read_config32(dev, 0x50);
  71         dword &= ~(1 << 16);
  72         pci_write_config32(dev, 0x50, dword);
  73
  74         /* RPR 5.12 Enable prevention of OHCI accessing the invalid system memory address range */
  75         word = pci_read_config16(dev, 0x50);
  76         word |= 1 << 15;
  77         pci_write_config16(dev, 0x50, word);
  78
  79         /* RPR 5.15 Disable SMI handshake in between USB and ACPI for USB legacy support. */
  80         /* The BIOS should always set this bit to prevent the malfunction on USB legacy keyboard/mouse support */
  81         word = pci_read_config16(dev, 0x50);
  82         word |= 1 << 12;
  83         pci_write_config16(dev, 0x50, word);
  84 }
  85
  86 static void usb_init2(struct device *dev)
  87 {
  88         u8 byte;
  89         u16 word;
  90         u32 dword;
  91         u32 usb2_bar0;
  92         /* dword = pci_read_config32(dev, 0xf8); */
  93         /* dword |= 40; */
  94         /* pci_write_config32(dev, 0xf8, dword); */
  95
  96         usb2_bar0 = pci_read_config32(dev, 0x10) & ~0xFF;
  97         printk(BIOS_INFO, "usb2_bar0=0x%x\n", usb2_bar0);
  98
  99         /* RPR5.4 Enables the USB PHY auto calibration resister to match 45ohm resistance */
 100         dword = 0x00020F00;
 101         write32(usb2_bar0 + 0xC0, dword);
 102
 103         /* RPR5.5 Sets In/OUT FIFO threshold for best performance */
 104         dword = 0x00200040;
 105         write32(usb2_bar0 + 0xA4, dword);
 106
 107         /* RPR5.9 Disable the EHCI Dynamic Power Saving feature */
 108         word = read16(usb2_bar0 + 0xBC);
 109         word &= ~(1 << 12);
 110         write16(usb2_bar0 + 0xBC, word);
 111
 112         /* RPR5.10 Disable EHCI MSI support */
 113         byte = pci_read_config8(dev, 0x50);
 114         byte |= (1 << 6);
 115         pci_write_config8(dev, 0x50, byte);
 116
 117         /* RPR5.13 Disable C3 time enhancement feature */
 118         dword = pci_read_config32(dev, 0x50);
 119         dword &= ~(1 << 28);
 120         pci_write_config32(dev, 0x50, dword);
 121
 122         /* RPR5.14 Disable USB PHY PLL Reset signal to come from ACPI */
 123         byte = pci_read_config8(dev, 0x54);
 124         byte &= ~(1 << 0);
 125         pci_write_config8(dev, 0x54, byte);
 126 }
 127
 128 static void usb_set_resources(struct device *dev)
 129 {
 130 #if CONFIG_USBDEBUG
 131         struct resource *res;
 132         u32 base;
 133         u32 old_debug;
 134
 135         old_debug = get_ehci_debug();
 136         set_ehci_debug(0);
 137 #endif
 138         pci_dev_set_resources(dev);
 139
 140 #if CONFIG_USBDEBUG
 141         res = find_resource(dev, 0x10);
 142         set_ehci_debug(old_debug);
 143         if (!res)
 144                 return;
 145         base = res->base;
 146         set_ehci_base(base);
 147         report_resource_stored(dev, res, "");
 148 #endif
 149
 150 }
 151
 152 static struct device_operations usb_ops = {
 153         .read_resources = pci_dev_read_resources,
 154         .set_resources = usb_set_resources, /* pci_dev_set_resources, */
 155         .enable_resources = pci_dev_enable_resources,
 156         .init = usb_init,
 157         /*.enable           = sb600_enable, */
 158         .scan_bus = 0,
 159         .ops_pci = &lops_pci,
 160 };
 161
 162 static const struct pci_driver usb_0_driver __pci_driver = {
 163         .ops = &usb_ops,
 164         .vendor = PCI_VENDOR_ID_ATI,
 165         .device = PCI_DEVICE_ID_ATI_SB600_USB_0,
 166 };
 167 static const struct pci_driver usb_1_driver __pci_driver = {
 168         .ops = &usb_ops,
 169         .vendor = PCI_VENDOR_ID_ATI,
 170         .device = PCI_DEVICE_ID_ATI_SB600_USB_1,
 171 };
 172 static const struct pci_driver usb_2_driver __pci_driver = {
 173         .ops = &usb_ops,
 174         .vendor = PCI_VENDOR_ID_ATI,
 175         .device = PCI_DEVICE_ID_ATI_SB600_USB_2,
 176 };
 177 static const struct pci_driver usb_3_driver __pci_driver = {
 178         .ops = &usb_ops,
 179         .vendor = PCI_VENDOR_ID_ATI,
 180         .device = PCI_DEVICE_ID_ATI_SB600_USB_3,
 181 };
 182 static const struct pci_driver usb_4_driver __pci_driver = {
 183         .ops = &usb_ops,
 184         .vendor = PCI_VENDOR_ID_ATI,
 185         .device = PCI_DEVICE_ID_ATI_SB600_USB_4,
 186 };
 187
 188 static struct device_operations usb_ops2 = {
 189         .read_resources = pci_dev_read_resources,
 190         .set_resources = usb_set_resources, /* pci_dev_set_resources, */
 191         .enable_resources = pci_dev_enable_resources,
 192         .init = usb_init2,
 193         /*.enable           = sb600_enable, */
 194         .scan_bus = 0,
 195         .ops_pci = &lops_pci,
 196 };
 197
 198 static const struct pci_driver usb_5_driver __pci_driver = {
 199         .ops = &usb_ops2,
 200         .vendor = PCI_VENDOR_ID_ATI,
 201         .device = PCI_DEVICE_ID_ATI_SB600_USB2,
 202 };
 203