--- /dev/null
+/*
+ * GRUB -- GRand Unified Bootloader
+ * Copyright (C) 2010 Free Software Foundation, Inc.
+ *
+ * GRUB is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GRUB is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GRUB. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/types.h>
+#include <grub/cs5536.h>
+#include <grub/pci.h>
+#include <grub/time.h>
+#include <grub/ata.h>
+
+int
+grub_cs5536_find (grub_pci_device_t *devp)
+{
+ int found = 0;
+ auto int NESTED_FUNC_ATTR hook (grub_pci_device_t dev,
+ grub_pci_id_t pciid);
+
+ int NESTED_FUNC_ATTR hook (grub_pci_device_t dev,
+ grub_pci_id_t pciid)
+ {
+ if (pciid == GRUB_CS5536_PCIID)
+ {
+ *devp = dev;
+ found = 1;
+ return 1;
+ }
+ return 0;
+ }
+
+ grub_pci_iterate (hook);
+
+ return found;
+}
+
+grub_uint64_t
+grub_cs5536_read_msr (grub_pci_device_t dev, grub_uint32_t addr)
+{
+ grub_uint64_t ret = 0;
+ grub_pci_write (grub_pci_make_address (dev, GRUB_CS5536_MSR_MAILBOX_ADDR),
+ addr);
+ ret = (grub_uint64_t)
+ grub_pci_read (grub_pci_make_address (dev, GRUB_CS5536_MSR_MAILBOX_DATA0));
+ ret |= (((grub_uint64_t)
+ grub_pci_read (grub_pci_make_address (dev,
+ GRUB_CS5536_MSR_MAILBOX_DATA1)))
+ << 32);
+ return ret;
+}
+
+void
+grub_cs5536_write_msr (grub_pci_device_t dev, grub_uint32_t addr,
+ grub_uint64_t val)
+{
+ grub_pci_write (grub_pci_make_address (dev, GRUB_CS5536_MSR_MAILBOX_ADDR),
+ addr);
+ grub_pci_write (grub_pci_make_address (dev, GRUB_CS5536_MSR_MAILBOX_DATA0),
+ val & 0xffffffff);
+ grub_pci_write (grub_pci_make_address (dev, GRUB_CS5536_MSR_MAILBOX_DATA1),
+ val >> 32);
+}
+
+grub_err_t
+grub_cs5536_smbus_wait (grub_port_t smbbase)
+{
+ grub_uint64_t start = grub_get_time_ms ();
+ while (1)
+ {
+ grub_uint8_t status;
+ status = grub_inb (smbbase + GRUB_CS5536_SMB_REG_STATUS);
+ if (status & GRUB_CS5536_SMB_REG_STATUS_SDAST)
+ return GRUB_ERR_NONE;
+ if (status & GRUB_CS5536_SMB_REG_STATUS_BER)
+ return grub_error (GRUB_ERR_IO, "SM bus error");
+ if (status & GRUB_CS5536_SMB_REG_STATUS_NACK)
+ return grub_error (GRUB_ERR_IO, "NACK received");
+ if (grub_get_time_ms () > start + 40)
+ return grub_error (GRUB_ERR_IO, "SM stalled");
+ }
+
+ return GRUB_ERR_NONE;
+}
+
+grub_err_t
+grub_cs5536_read_spd_byte (grub_port_t smbbase, grub_uint8_t dev,
+ grub_uint8_t addr, grub_uint8_t *res)
+{
+ grub_err_t err;
+
+ /* Send START. */
+ grub_outb (grub_inb (smbbase + GRUB_CS5536_SMB_REG_CTRL1)
+ | GRUB_CS5536_SMB_REG_CTRL1_START,
+ smbbase + GRUB_CS5536_SMB_REG_CTRL1);
+
+ /* Send device address. */
+ err = grub_cs5536_smbus_wait (smbbase);
+ if (err)
+ return err;
+ grub_outb (dev << 1, smbbase + GRUB_CS5536_SMB_REG_DATA);
+
+ /* Send ACK. */
+ err = grub_cs5536_smbus_wait (smbbase);
+ if (err)
+ return err;
+ grub_outb (grub_inb (smbbase + GRUB_CS5536_SMB_REG_CTRL1)
+ | GRUB_CS5536_SMB_REG_CTRL1_ACK,
+ smbbase + GRUB_CS5536_SMB_REG_CTRL1);
+
+ /* Send byte address. */
+ grub_outb (addr, smbbase + GRUB_CS5536_SMB_REG_DATA);
+
+ /* Send START. */
+ err = grub_cs5536_smbus_wait (smbbase);
+ if (err)
+ return err;
+ grub_outb (grub_inb (smbbase + GRUB_CS5536_SMB_REG_CTRL1)
+ | GRUB_CS5536_SMB_REG_CTRL1_START,
+ smbbase + GRUB_CS5536_SMB_REG_CTRL1);
+
+ /* Send device address. */
+ err = grub_cs5536_smbus_wait (smbbase);
+ if (err)
+ return err;
+ grub_outb ((dev << 1) | 1, smbbase + GRUB_CS5536_SMB_REG_DATA);
+
+ /* Send STOP. */
+ err = grub_cs5536_smbus_wait (smbbase);
+ if (err)
+ return err;
+ grub_outb (grub_inb (smbbase + GRUB_CS5536_SMB_REG_CTRL1)
+ | GRUB_CS5536_SMB_REG_CTRL1_STOP,
+ smbbase + GRUB_CS5536_SMB_REG_CTRL1);
+
+ err = grub_cs5536_smbus_wait (smbbase);
+ if (err)
+ return err;
+ *res = grub_inb (smbbase + GRUB_CS5536_SMB_REG_DATA);
+
+ return GRUB_ERR_NONE;
+}
+
+grub_err_t
+grub_cs5536_init_smbus (grub_pci_device_t dev, grub_uint16_t divisor,
+ grub_port_t *smbbase)
+{
+ grub_uint64_t smbbar;
+
+ smbbar = grub_cs5536_read_msr (dev, GRUB_CS5536_MSR_SMB_BAR);
+
+ /* FIXME */
+ if (!(smbbar & GRUB_CS5536_LBAR_ENABLE))
+ return grub_error(GRUB_ERR_IO, "SMB controller not enabled\n");
+ *smbbase = (smbbar & GRUB_CS5536_LBAR_ADDR_MASK) + GRUB_MACHINE_PCI_IO_BASE;
+
+ if (divisor < 8)
+ return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid divisor");
+
+ /* Disable SMB. */
+ grub_outb (0, *smbbase + GRUB_CS5536_SMB_REG_CTRL2);
+
+ /* Disable interrupts. */
+ grub_outb (0, *smbbase + GRUB_CS5536_SMB_REG_CTRL1);
+
+ /* Set as master. */
+ grub_outb (GRUB_CS5536_SMB_REG_ADDR_MASTER,
+ *smbbase + GRUB_CS5536_SMB_REG_ADDR);
+
+ /* Launch. */
+ grub_outb (((divisor >> 7) & 0xff), *smbbase + GRUB_CS5536_SMB_REG_CTRL3);
+ grub_outb (((divisor << 1) & 0xfe) | GRUB_CS5536_SMB_REG_CTRL2_ENABLE,
+ *smbbase + GRUB_CS5536_SMB_REG_CTRL2);
+
+ return GRUB_ERR_NONE;
+}
+
+grub_err_t
+grub_cs5536_read_spd (grub_port_t smbbase, grub_uint8_t dev,
+ struct grub_smbus_spd *res)
+{
+ grub_err_t err;
+ grub_size_t size;
+ grub_uint8_t b;
+ grub_size_t ptr;
+
+ err = grub_cs5536_read_spd_byte (smbbase, dev, 0, &b);
+ if (err)
+ return err;
+ if (b == 0)
+ return grub_error (GRUB_ERR_IO, "no SPD found");
+ size = b;
+
+ ((grub_uint8_t *) res)[0] = b;
+ for (ptr = 1; ptr < size; ptr++)
+ {
+ err = grub_cs5536_read_spd_byte (smbbase, dev, ptr,
+ &((grub_uint8_t *) res)[ptr]);
+ if (err)
+ return err;
+ }
+ return GRUB_ERR_NONE;
+}
+
#include <grub/dl.h>
#include <grub/pci.h>
+#include <grub/mm.h>
+
+#if GRUB_TARGET_SIZEOF_VOID_P == 4
+struct grub_pci_dma_chunk *
+grub_memalign_dma32 (grub_size_t align, grub_size_t size)
+{
+ return grub_memalign (align, size);
+}
+
+void
+grub_dma_free (struct grub_pci_dma_chunk *ch)
+{
+ grub_free (ch);
+}
+#endif
+
+#ifdef GRUB_MACHINE_MIPS_YEELOONG
+volatile void *
+grub_dma_get_virt (struct grub_pci_dma_chunk *ch)
+{
+ return (void *) ((((grub_uint32_t) ch) & 0x1fffffff) | 0xa0000000);
+}
+
+grub_uint32_t
+grub_dma_get_phys (struct grub_pci_dma_chunk *ch)
+{
+ return (((grub_uint32_t) ch) & 0x1fffffff) | 0x80000000;
+}
+#else
+
+volatile void *
+grub_dma_get_virt (struct grub_pci_dma_chunk *ch)
+{
+ return (void *) ch;
+}
+
+grub_uint32_t
+grub_dma_get_phys (struct grub_pci_dma_chunk *ch)
+{
+ return (grub_uint32_t) ch;
+}
+
+#endif
grub_pci_address_t
grub_pci_make_address (grub_pci_device_t dev, int reg)
if (id >> 16 == 0xFFFF)
continue;
+#ifdef GRUB_MACHINE_MIPS_YEELOONG
+ /* Skip ghosts. */
+ if (id == GRUB_YEELOONG_OHCI_PCIID
+ && dev.function == GRUB_YEELOONG_OHCI_GHOST_FUNCTION)
+ continue;
+ if (id == GRUB_YEELOONG_EHCI_PCIID
+ && dev.function == GRUB_YEELOONG_EHCI_GHOST_FUNCTION)
+ continue;
+#endif
+
if (hook (dev, id))
return;
#include <grub/misc.h>
#include <grub/pci.h>
#include <grub/cpu/pci.h>
-#include <grub/i386/io.h>
+#include <grub/cpu/io.h>
#include <grub/time.h>
+#include <grub/cs5536.h>
struct grub_ohci_hcca
{
grub_uint32_t buffer_end;
} __attribute__((packed));
-typedef struct grub_ohci_td *grub_ohci_td_t;
-typedef struct grub_ohci_ed *grub_ohci_ed_t;
+typedef volatile struct grub_ohci_td *grub_ohci_td_t;
+typedef volatile struct grub_ohci_ed *grub_ohci_ed_t;
struct grub_ohci
{
volatile grub_uint32_t *iobase;
volatile struct grub_ohci_hcca *hcca;
+ grub_uint32_t hcca_addr;
+ struct grub_pci_dma_chunk *hcca_chunk;
struct grub_ohci *next;
};
GRUB_OHCI_REG_BULKCURR,
GRUB_OHCI_REG_DONEHEAD,
GRUB_OHCI_REG_FRAME_INTERVAL,
+ GRUB_OHCI_REG_PERIODIC_START = 16,
GRUB_OHCI_REG_RHUBA = 18,
GRUB_OHCI_REG_RHUBPORT = 21
} grub_ohci_reg_t;
+#define GRUB_OHCI_RHUB_PORT_POWER_MASK 0x300
+#define GRUB_OHCI_RHUB_PORT_ALL_POWERED 0x200
+
+#define GRUB_OHCI_REG_FRAME_INTERVAL_FSMPS_MASK 0x8fff0000
+#define GRUB_OHCI_REG_FRAME_INTERVAL_FSMPS_SHIFT 16
+#define GRUB_OHCI_REG_FRAME_INTERVAL_FI_SHIFT 0
+
+/* XXX: Is this choice of timings sane? */
+#define GRUB_OHCI_FSMPS 0x2778
+#define GRUB_OHCI_PERIODIC_START 0x257f
+#define GRUB_OHCI_FRAME_INTERVAL 0x2edf
+
static grub_uint32_t
grub_ohci_readreg32 (struct grub_ohci *o, grub_ohci_reg_t reg)
{
controller. If this is the case, initialize it. */
static int NESTED_FUNC_ATTR
grub_ohci_pci_iter (grub_pci_device_t dev,
- grub_pci_id_t pciid __attribute__((unused)))
+ grub_pci_id_t pciid)
{
- grub_uint32_t class_code;
- grub_uint32_t class;
- grub_uint32_t subclass;
grub_uint32_t interf;
grub_uint32_t base;
grub_pci_address_t addr;
struct grub_ohci *o;
grub_uint32_t revision;
- grub_uint32_t frame_interval;
+ int cs5536;
- addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
- class_code = grub_pci_read (addr) >> 8;
+ /* Determine IO base address. */
+ grub_dprintf ("ohci", "pciid = %x\n", pciid);
- interf = class_code & 0xFF;
- subclass = (class_code >> 8) & 0xFF;
- class = class_code >> 16;
+ if (pciid == GRUB_CS5536_PCIID)
+ {
+ grub_uint64_t basereg;
- /* If this is not an OHCI controller, just return. */
- if (class != 0x0c || subclass != 0x03 || interf != 0x10)
- return 0;
+ cs5536 = 1;
+ basereg = grub_cs5536_read_msr (dev, GRUB_CS5536_MSR_USB_OHCI_BASE);
+ if (!(basereg & GRUB_CS5536_MSR_USB_BASE_MEMORY_ENABLE))
+ {
+ /* Shouldn't happen. */
+ grub_dprintf ("ohci", "No OHCI address is assigned\n");
+ return 0;
+ }
+ base = (basereg & GRUB_CS5536_MSR_USB_BASE_ADDR_MASK);
+ basereg |= GRUB_CS5536_MSR_USB_BASE_BUS_MASTER;
+ basereg &= ~GRUB_CS5536_MSR_USB_BASE_PME_ENABLED;
+ basereg &= ~GRUB_CS5536_MSR_USB_BASE_PME_STATUS;
+ grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_USB_OHCI_BASE, basereg);
+ }
+ else
+ {
+ grub_uint32_t class_code;
+ grub_uint32_t class;
+ grub_uint32_t subclass;
- /* Determine IO base address. */
- addr = grub_pci_make_address (dev, GRUB_PCI_REG_ADDRESS_REG0);
- base = grub_pci_read (addr);
+ addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
+ class_code = grub_pci_read (addr) >> 8;
+
+ interf = class_code & 0xFF;
+ subclass = (class_code >> 8) & 0xFF;
+ class = class_code >> 16;
+
+ /* If this is not an OHCI controller, just return. */
+ if (class != 0x0c || subclass != 0x03 || interf != 0x10)
+ return 0;
+
+ addr = grub_pci_make_address (dev, GRUB_PCI_REG_ADDRESS_REG0);
+ base = grub_pci_read (addr);
#if 0
- /* Stop if there is no IO space base address defined. */
- if (! (base & 1))
- return 0;
+ /* Stop if there is no IO space base address defined. */
+ if (! (base & 1))
+ return 0;
#endif
+ grub_dprintf ("ohci", "class=0x%02x 0x%02x interface 0x%02x\n",
+ class, subclass, interf);
+ }
+
/* Allocate memory for the controller and register it. */
o = grub_malloc (sizeof (*o));
if (! o)
return 1;
- o->iobase = (grub_uint32_t *) base;
+ o->iobase = grub_pci_device_map_range (dev, base, 0x100);
- /* Reserve memory for the HCCA. */
- o->hcca = (struct grub_ohci_hcca *) grub_memalign (256, 256);
+ grub_dprintf ("ohci", "base=%p\n", o->iobase);
- grub_dprintf ("ohci", "class=0x%02x 0x%02x interface 0x%02x base=%p\n",
- class, subclass, interf, o->iobase);
+ /* Reserve memory for the HCCA. */
+ o->hcca_chunk = grub_memalign_dma32 (256, 256);
+ if (! o->hcca_chunk)
+ return 1;
+ o->hcca = grub_dma_get_virt (o->hcca_chunk);
+ o->hcca_addr = grub_dma_get_phys (o->hcca_chunk);
/* Check if the OHCI revision is actually 1.0 as supported. */
revision = grub_ohci_readreg32 (o, GRUB_OHCI_REG_REVISION);
if ((revision & 0xFF) != 0x10)
goto fail;
- /* Backup the frame interval register. */
- frame_interval = grub_ohci_readreg32 (o, GRUB_OHCI_REG_FRAME_INTERVAL);
+ grub_ohci_writereg32 (o, GRUB_OHCI_REG_RHUBA,
+ (grub_ohci_readreg32 (o, GRUB_OHCI_REG_RHUBA)
+ & ~GRUB_OHCI_RHUB_PORT_POWER_MASK)
+ | GRUB_OHCI_RHUB_PORT_ALL_POWERED);
/* Suspend the OHCI by issuing a reset. */
grub_ohci_writereg32 (o, GRUB_OHCI_REG_CMDSTATUS, 1); /* XXX: Magic. */
grub_millisleep (1);
grub_dprintf ("ohci", "OHCI reset\n");
- /* Restore the frame interval register. */
- grub_ohci_writereg32 (o, GRUB_OHCI_REG_FRAME_INTERVAL, frame_interval);
+ grub_ohci_writereg32 (o, GRUB_OHCI_REG_FRAME_INTERVAL,
+ (GRUB_OHCI_FSMPS
+ << GRUB_OHCI_REG_FRAME_INTERVAL_FSMPS_SHIFT)
+ | (GRUB_OHCI_FRAME_INTERVAL
+ << GRUB_OHCI_REG_FRAME_INTERVAL_FI_SHIFT));
+
+ grub_ohci_writereg32 (o, GRUB_OHCI_REG_PERIODIC_START,
+ GRUB_OHCI_PERIODIC_START);
/* Setup the HCCA. */
- grub_ohci_writereg32 (o, GRUB_OHCI_REG_HCCA, (grub_uint32_t) o->hcca);
+ grub_ohci_writereg32 (o, GRUB_OHCI_REG_HCCA, o->hcca_addr);
grub_dprintf ("ohci", "OHCI HCCA\n");
/* Enable the OHCI. */
return 0;
fail:
+#ifndef GRUB_MACHINE_MIPS_YEELOONG
if (o)
grub_free ((void *) o->hcca);
+#endif
grub_free (o);
- return 1;
+ return 0;
}
static void
grub_ohci_transaction (grub_ohci_td_t td,
grub_transfer_type_t type, unsigned int toggle,
- grub_size_t size, char *data)
+ grub_size_t size, grub_uint32_t data)
{
grub_uint32_t token;
grub_uint32_t buffer;
token |= toggle << 24;
token |= 1 << 25;
- buffer = (grub_uint32_t) data;
+ buffer = data;
buffer_end = buffer + size - 1;
td->token = grub_cpu_to_le32 (token);
{
struct grub_ohci *o = (struct grub_ohci *) dev->data;
grub_ohci_ed_t ed;
+ grub_uint32_t ed_addr;
+ struct grub_pci_dma_chunk *ed_chunk, *td_list_chunk;
grub_ohci_td_t td_list;
+ grub_uint32_t td_list_addr;
grub_uint32_t target;
grub_uint32_t td_tail;
grub_uint32_t td_head;
int i;
/* Allocate an Endpoint Descriptor. */
- ed = grub_memalign (16, sizeof (*ed));
- if (! ed)
+ ed_chunk = grub_memalign_dma32 (256, sizeof (*ed));
+ if (! ed_chunk)
return GRUB_USB_ERR_INTERNAL;
+ ed = grub_dma_get_virt (ed_chunk);
+ ed_addr = grub_dma_get_phys (ed_chunk);
- td_list = grub_memalign (16, sizeof (*td_list) * (transfer->transcnt + 1));
- if (! td_list)
+ td_list_chunk = grub_memalign_dma32 (256, sizeof (*td_list)
+ * (transfer->transcnt + 1));
+ if (! td_list_chunk)
{
- grub_free ((void *) ed);
+ grub_dma_free (ed_chunk);
return GRUB_USB_ERR_INTERNAL;
}
+ td_list = grub_dma_get_virt (td_list_chunk);
+ td_list_addr = grub_dma_get_phys (td_list_chunk);
- grub_dprintf ("ohci", "alloc=%p\n", td_list);
+ grub_dprintf ("ohci", "alloc=%p/0x%x\n", td_list, td_list_addr);
/* Setup all Transfer Descriptors. */
for (i = 0; i < transfer->transcnt; i++)
grub_ohci_transaction (&td_list[i], tr->pid, tr->toggle,
tr->size, tr->data);
- td_list[i].next_td = grub_cpu_to_le32 (&td_list[i + 1]);
+ td_list[i].next_td = grub_cpu_to_le32 (td_list_addr
+ + (i + 1) * sizeof (td_list[0]));
}
/* Setup the Endpoint Descriptor. */
/* Set the maximum packet size. */
target |= transfer->max << 16;
- td_head = (grub_uint32_t) td_list;
+ td_head = td_list_addr;
- td_tail = (grub_uint32_t) &td_list[transfer->transcnt];
+ td_tail = td_list_addr + transfer->transcnt * sizeof (*td_list);
ed->target = grub_cpu_to_le32 (target);
ed->td_head = grub_cpu_to_le32 (td_head);
status &= ~(1 << 2);
grub_ohci_writereg32 (o, GRUB_OHCI_REG_CMDSTATUS, status);
- grub_ohci_writereg32 (o, GRUB_OHCI_REG_BULKHEAD, (grub_uint32_t) ed);
+ grub_ohci_writereg32 (o, GRUB_OHCI_REG_BULKHEAD, ed_addr);
/* Enable the Bulk list. */
control |= 1 << 5;
status &= ~(1 << 1);
grub_ohci_writereg32 (o, GRUB_OHCI_REG_CMDSTATUS, status);
- grub_ohci_writereg32 (o, GRUB_OHCI_REG_CONTROLHEAD,
- (grub_uint32_t) ed);
+ grub_ohci_writereg32 (o, GRUB_OHCI_REG_CONTROLHEAD, ed_addr);
grub_ohci_writereg32 (o, GRUB_OHCI_REG_CONTROLHEAD+1,
- (grub_uint32_t) ed);
+ ed_addr);
/* Enable the Control list. */
control |= 1 << 4;
{
grub_uint8_t errcode;
grub_ohci_td_t tderr;
+ grub_uint32_t td_err_addr;
+
+ td_err_addr = grub_ohci_readreg32 (o, GRUB_OHCI_REG_DONEHEAD);
- tderr = (grub_ohci_td_t) grub_ohci_readreg32 (o,
- GRUB_OHCI_REG_DONEHEAD);
+ tderr = (grub_ohci_td_t) ((char *) td_list
+ + (td_err_addr - td_list_addr));
errcode = tderr->token >> 28;
switch (errcode)
grub_ohci_writereg32 (o, GRUB_OHCI_REG_CMDSTATUS, status);
/* XXX */
- grub_free (td_list);
- grub_free (ed);
+ grub_dma_free (td_list_chunk);
+ grub_dma_free (ed_chunk);
return err;
}
grub_uhci_transaction (struct grub_uhci *u, unsigned int endp,
grub_transfer_type_t type, unsigned int addr,
unsigned int toggle, grub_size_t size,
- char *data)
+ grub_uint32_t data)
{
grub_uhci_td_t td;
static const unsigned int tf[] = { 0x69, 0xE1, 0x2D };
}
grub_dprintf ("uhci",
- "transaction: endp=%d, type=%d, addr=%d, toggle=%d, size=%d data=%p td=%p\n",
+ "transaction: endp=%d, type=%d, addr=%d, toggle=%d, size=%d data=0x%x td=%p\n",
endp, type, addr, toggle, size, data, td);
/* Don't point to any TD, just terminate. */
td->token = ((size << 21) | (toggle << 19) | (endp << 15)
| (addr << 8) | tf[type]);
- td->buffer = (grub_uint32_t) data;
+ td->buffer = data;
return td;
}
*/
#include <grub/dl.h>
+#include <grub/pci.h>
#include <grub/mm.h>
#include <grub/misc.h>
#include <grub/usb.h>
grub_uint8_t request,
grub_uint16_t value,
grub_uint16_t index,
- grub_size_t size, char *data)
+ grub_size_t size0, char *data_in)
{
int i;
grub_usb_transfer_t transfer;
int datablocks;
- struct grub_usb_packet_setup setupdata;
+ volatile struct grub_usb_packet_setup *setupdata;
+ grub_uint32_t setupdata_addr;
grub_usb_err_t err;
unsigned int max;
+ struct grub_pci_dma_chunk *data_chunk, *setupdata_chunk;
+ volatile char *data;
+ grub_uint32_t data_addr;
+ grub_size_t size = size0;
+
+ /* FIXME: avoid allocation any kind of buffer in a first place. */
+ data_chunk = grub_memalign_dma32 (128, size ? : 16);
+ if (!data_chunk)
+ return GRUB_USB_ERR_INTERNAL;
+ data = grub_dma_get_virt (data_chunk);
+ data_addr = grub_dma_get_phys (data_chunk);
+ grub_memcpy ((char *) data, data_in, size);
grub_dprintf ("usb",
"control: reqtype=0x%02x req=0x%02x val=0x%02x idx=0x%02x size=%d\n",
reqtype, request, value, index, size);
/* Create a transfer. */
- transfer = grub_malloc (sizeof (struct grub_usb_transfer));
+ transfer = grub_malloc (sizeof (*transfer));
if (! transfer)
- return grub_errno;
+ {
+ grub_dma_free (data_chunk);
+ return grub_errno;
+ }
+
+ setupdata_chunk = grub_memalign_dma32 (32, sizeof (*setupdata));
+ if (! setupdata_chunk)
+ {
+ grub_free (transfer);
+ grub_dma_free (data_chunk);
+ return grub_errno;
+ }
+
+ setupdata = grub_dma_get_virt (setupdata_chunk);
+ setupdata_addr = grub_dma_get_phys (setupdata_chunk);
/* Determine the maximum packet size. */
- if (dev->initialized)
+ if (dev->initialized && dev->descdev.maxsize0)
max = dev->descdev.maxsize0;
else
max = 64;
+ grub_dprintf ("usb", "transfer = %p, dev = %p\n", transfer, dev);
+
datablocks = (size + max - 1) / max;
/* XXX: Discriminate between different types of control
if (! transfer->transactions)
{
grub_free (transfer);
+ grub_dma_free (setupdata_chunk);
+ grub_dma_free (data_chunk);
return grub_errno;
}
/* Build a Setup packet. XXX: Endianness. */
- setupdata.reqtype = reqtype;
- setupdata.request = request;
- setupdata.value = value;
- setupdata.index = index;
- setupdata.length = size;
- transfer->transactions[0].size = sizeof (setupdata);
+ setupdata->reqtype = reqtype;
+ setupdata->request = request;
+ setupdata->value = value;
+ setupdata->index = index;
+ setupdata->length = size;
+ transfer->transactions[0].size = sizeof (*setupdata);
transfer->transactions[0].pid = GRUB_USB_TRANSFER_TYPE_SETUP;
- transfer->transactions[0].data = (char *) &setupdata;
+ transfer->transactions[0].data = setupdata_addr;
transfer->transactions[0].toggle = 0;
/* Now the data... XXX: Is this the right way to transfer control
tr->pid = GRUB_USB_TRANSFER_TYPE_IN;
else
tr->pid = GRUB_USB_TRANSFER_TYPE_OUT;
- tr->data = &data[i * max];
+ tr->data = data_addr + i * max;
size -= max;
}
/* End with an empty OUT transaction. */
transfer->transactions[datablocks + 1].size = 0;
- transfer->transactions[datablocks + 1].data = NULL;
+ transfer->transactions[datablocks + 1].data = 0;
if (reqtype & 128)
transfer->transactions[datablocks + 1].pid = GRUB_USB_TRANSFER_TYPE_OUT;
else
grub_free (transfer->transactions);
grub_free (transfer);
+ grub_dma_free (data_chunk);
+ grub_dma_free (setupdata_chunk);
+
+ grub_memcpy (data_in, (char *) data, size0);
return err;
}
static grub_usb_err_t
grub_usb_bulk_readwrite (grub_usb_device_t dev,
- int endpoint, grub_size_t size, char *data,
+ int endpoint, grub_size_t size0, char *data_in,
grub_transfer_type_t type)
{
int i;
unsigned int max;
grub_usb_err_t err;
int toggle = dev->toggle[endpoint];
+ volatile char *data;
+ grub_uint32_t data_addr;
+ struct grub_pci_dma_chunk *data_chunk;
+ grub_size_t size = size0;
+
+ /* FIXME: avoid allocation any kind of buffer in a first place. */
+ data_chunk = grub_memalign_dma32 (128, size);
+ if (!data_chunk)
+ return GRUB_USB_ERR_INTERNAL;
+ data = grub_dma_get_virt (data_chunk);
+ data_addr = grub_dma_get_phys (data_chunk);
+ if (type == GRUB_USB_TRANSFER_TYPE_OUT)
+ grub_memcpy ((char *) data, data_in, size);
/* Use the maximum packet size given in the endpoint descriptor. */
if (dev->initialized)
/* Create a transfer. */
transfer = grub_malloc (sizeof (struct grub_usb_transfer));
if (! transfer)
- return grub_errno;
+ {
+ grub_dma_free (data_chunk);
+ return grub_errno;
+ }
datablocks = ((size + max - 1) / max);
transfer->transcnt = datablocks;
if (! transfer->transactions)
{
grub_free (transfer);
+ grub_dma_free (data_chunk);
return grub_errno;
}
tr->toggle = toggle;
toggle = toggle ? 0 : 1;
tr->pid = type;
- tr->data = &data[i * max];
+ tr->data = data_addr + i * max;
size -= tr->size;
}
grub_free (transfer->transactions);
grub_free (transfer);
+ grub_dma_free (data_chunk);
+
+ if (type == GRUB_USB_TRANSFER_TYPE_IN)
+ grub_memcpy (data_in, (char *) data, size0);
return err;
}
pci_mod_CFLAGS = $(COMMON_CFLAGS)
pci_mod_LDFLAGS = $(COMMON_LDFLAGS)
+# For cs5536.mod
+pkglib_MODULES += cs5536.mod
+cs5536_mod_SOURCES = bus/cs5536.c
+cs5536_mod_CFLAGS = $(COMMON_CFLAGS)
+cs5536_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
# For lspci.mod
pkglib_MODULES += lspci.mod
lspci_mod_SOURCES = commands/lspci.c
COMMON_CFLAGS += -march=mips3
COMMON_ASFLAGS += -march=mips3
-kernel_img_HEADERS += pci.h bitmap.h video.h gfxterm.h font.h bitmap_scale.h bufio.h
+kernel_img_HEADERS += pci.h bitmap.h video.h gfxterm.h font.h \
+ bitmap_scale.h bufio.h cs5536.h machine/pci.h
include $(srcdir)/conf/mips.mk
video/fb/fbfill.c video/fb/fbutil.c video/bitmap.c \
video/bitmap_scale.c video/sm712.c bus/pci.c bus/bonito.c \
term/gfxterm.c commands/extcmd.c lib/arg.c \
+ bus/cs5536.c \
symlist.c
kernel_img_CFLAGS = $(COMMON_CFLAGS) -DUSE_ASCII_FAILBACK
kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
linux_mod_ASFLAGS = $(COMMON_ASFLAGS)
linux_mod_LDFLAGS = $(COMMON_LDFLAGS)
+# For usb.mod
+pkglib_MODULES += usb.mod
+usb_mod_SOURCES = bus/usb/usb.c bus/usb/usbtrans.c bus/usb/usbhub.c
+usb_mod_CFLAGS = $(COMMON_CFLAGS)
+usb_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For usbtest.mod
+pkglib_MODULES += usbtest.mod
+usbtest_mod_SOURCES = commands/usbtest.c
+usbtest_mod_CFLAGS = $(COMMON_CFLAGS)
+usbtest_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For ohci.mod
+pkglib_MODULES += ohci.mod
+ohci_mod_SOURCES = bus/usb/ohci.c
+ohci_mod_CFLAGS = $(COMMON_CFLAGS)
+ohci_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For usbms.mod
+pkglib_MODULES += usbms.mod
+usbms_mod_SOURCES = disk/usbms.c
+usbms_mod_CFLAGS = $(COMMON_CFLAGS)
+usbms_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For usb_keyboard.mod
+pkglib_MODULES += usb_keyboard.mod
+usb_keyboard_mod_SOURCES = term/usb_keyboard.c
+usb_keyboard_mod_CFLAGS = $(COMMON_CFLAGS)
+usb_keyboard_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
sbin_SCRIPTS += grub-install
grub_install_SOURCES = util/grub-install.in
--- /dev/null
+/*
+ * GRUB -- GRand Unified Bootloader
+ * Copyright (C) 2010 Free Software Foundation, Inc.
+ *
+ * GRUB is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GRUB is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GRUB. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GRUB_CS5536_HEADER
+#define GRUB_CS5536_HEADER 1
+
+#ifndef ASM_FILE
+#include <grub/pci.h>
+#include <grub/err.h>
+#include <grub/smbus.h>
+#endif
+
+#define GRUB_CS5536_PCIID 0x208f1022
+#define GRUB_CS5536_MSR_MAILBOX_ADDR 0xf4
+#define GRUB_CS5536_MSR_MAILBOX_DATA0 0xf8
+#define GRUB_CS5536_MSR_MAILBOX_DATA1 0xfc
+#define GRUB_CS5536_MSR_IRQ_MAP_BAR 0x80000008
+#define GRUB_CS5536_MSR_SMB_BAR 0x8000000b
+
+#define GRUB_CS5536_SMBUS_REGS_SIZE 8
+#define GRUB_CS5536_GPIO_REGS_SIZE 256
+#define GRUB_CS5536_MFGPT_REGS_SIZE 64
+#define GRUB_CS5536_IRQ_MAP_REGS_SIZE 32
+#define GRUB_CS5536_PM_REGS_SIZE 128
+#define GRUB_CS5536_ACPI_REGS_SIZE 32
+
+#define GRUB_CS5536_USB_OPTION_REGS_SIZE 0x1c
+#define GRUB_CS5536_USB_OPTION_REG_UOCMUX 1
+#define GRUB_CS5536_USB_OPTION_REG_UOCMUX_PMUX_MASK 0x03
+#define GRUB_CS5536_USB_OPTION_REG_UOCMUX_PMUX_HC 0x02
+
+#define GRUB_CS5536_DESTINATION_GLIU 0
+#define GRUB_CS5536_DESTINATION_GLPCI_SB 1
+#define GRUB_CS5536_DESTINATION_USB 2
+#define GRUB_CS5536_DESTINATION_IDE 3
+#define GRUB_CS5536_DESTINATION_DD 4
+#define GRUB_CS5536_DESTINATION_ACC 5
+#define GRUB_CS5536_DESTINATION_GLCP 7
+
+#define GRUB_CS5536_P2D_DEST_SHIFT 61
+#define GRUB_CS5536_P2D_LOG_ALIGN 12
+#define GRUB_CS5536_P2D_ALIGN (1 << GRUB_CS5536_P2D_LOG_ALIGN)
+#define GRUB_CS5536_P2D_BASE_SHIFT 20
+#define GRUB_CS5536_P2D_MASK_SHIFT 0
+
+#define GRUB_CS5536_MSR_GL_IOD_START 0x000100e0
+#define GRUB_CS5536_IOD_DEST_SHIFT 61
+#define GRUB_CS5536_IOD_BASE_SHIFT 20
+#define GRUB_CS5536_IOD_MASK_SHIFT 0
+#define GRUB_CS5536_IOD_ADDR_MASK 0xfffff
+
+#define GRUB_CS5536_MSR_GPIO_BAR 0x8000000c
+#define GRUB_CS5536_MSR_MFGPT_BAR 0x8000000d
+#define GRUB_CS5536_MSR_ACPI_BAR 0x8000000e
+#define GRUB_CS5536_MSR_PM_BAR 0x8000000f
+#define GRUB_CS5536_MSR_DIVIL_LEG_IO 0x80000014
+#define GRUB_CS5536_MSR_DIVIL_LEG_IO_RTC_ENABLE0 0x00000001
+#define GRUB_CS5536_MSR_DIVIL_LEG_IO_RTC_ENABLE1 0x00000002
+#define GRUB_CS5536_MSR_DIVIL_LEG_IO_MODE_X86 0x10000000
+#define GRUB_CS5536_MSR_DIVIL_LEG_IO_F_REMAP 0x04000000
+#define GRUB_CS5536_MSR_DIVIL_IRQ_MAPPER_PRIMARY_MASK 0x80000024
+#define GRUB_CS5536_MSR_DIVIL_IRQ_MAPPER_LPC_MASK 0x80000025
+#define GRUB_CS5536_DIVIL_LPC_INTERRUPTS 0x1002
+#define GRUB_CS5536_MSR_DIVIL_LPC_SERIAL_IRQ_CONTROL 0x8000004e
+#define GRUB_CS5536_MSR_DIVIL_LPC_SERIAL_IRQ_CONTROL_ENABLE 0x80
+
+#define GRUB_CS5536_MSR_USB_OHCI_BASE 0x40000008
+#define GRUB_CS5536_MSR_USB_EHCI_BASE 0x40000009
+#define GRUB_CS5536_MSR_USB_CONTROLLER_BASE 0x4000000a
+#define GRUB_CS5536_MSR_USB_OPTION_CONTROLLER_BASE 0x4000000b
+#define GRUB_CS5536_MSR_USB_BASE_ADDR_MASK 0x00ffffff00ULL
+#define GRUB_CS5536_MSR_USB_BASE_BUS_MASTER 0x0400000000ULL
+#define GRUB_CS5536_MSR_USB_BASE_MEMORY_ENABLE 0x0200000000ULL
+#define GRUB_CS5536_MSR_USB_BASE_PME_ENABLED 0x0800000000ULL
+#define GRUB_CS5536_MSR_USB_BASE_PME_STATUS 0x1000000000ULL
+#define GRUB_CS5536_MSR_USB_EHCI_BASE_FLDJ_SHIFT 40
+
+#define GRUB_CS5536_MSR_IDE_IO_BAR 0x60000008
+#define GRUB_CS5536_MSR_IDE_IO_BAR_UNITS 1
+#define GRUB_CS5536_MSR_IDE_IO_BAR_ADDR_MASK 0xfffffff0
+#define GRUB_CS5536_MSR_IDE_CFG 0x60000010
+#define GRUB_CS5536_MSR_IDE_CFG_CHANNEL_ENABLE 2
+#define GRUB_CS5536_MSR_IDE_TIMING 0x60000012
+#define GRUB_CS5536_MSR_IDE_TIMING_PIO0 0x98
+#define GRUB_CS5536_MSR_IDE_TIMING_DRIVE0_SHIFT 24
+#define GRUB_CS5536_MSR_IDE_TIMING_DRIVE1_SHIFT 16
+#define GRUB_CS5536_MSR_IDE_CAS_TIMING 0x60000013
+#define GRUB_CS5536_MSR_IDE_CAS_TIMING_CMD_PIO0 0x99
+#define GRUB_CS5536_MSR_IDE_CAS_TIMING_CMD_SHIFT 24
+#define GRUB_CS5536_MSR_IDE_CAS_TIMING_DRIVE0_SHIFT 6
+#define GRUB_CS5536_MSR_IDE_CAS_TIMING_DRIVE1_SHIFT 4
+#define GRUB_CS5536_MSR_IDE_CAS_TIMING_PIO0 2
+
+#define GRUB_CS5536_MSR_GL_PCI_CTRL 0x00000010
+#define GRUB_CS5536_MSR_GL_PCI_CTRL_MEMORY_ENABLE 1
+#define GRUB_CS5536_MSR_GL_PCI_CTRL_IO_ENABLE 2
+#define GRUB_CS5536_MSR_GL_PCI_CTRL_LATENCY_SHIFT 35
+#define GRUB_CS5536_MSR_GL_PCI_CTRL_OUT_THR_SHIFT 60
+#define GRUB_CS5536_MSR_GL_PCI_CTRL_IN_THR_SHIFT 56
+
+#define GRUB_CS5536_MSR_GL_REGIONS_START 0x00000020
+#define GRUB_CS5536_MSR_GL_REGIONS_NUM 16
+#define GRUB_CS5536_MSR_GL_REGION_ENABLE 1
+#define GRUB_CS5536_MSR_GL_REGION_IO 0x100000000ULL
+#define GRUB_CS5536_MSR_GL_REGION_BASE_MASK 0xfffff000ULL
+#define GRUB_CS5536_MSR_GL_REGION_IO_BASE_SHIFT 12
+#define GRUB_CS5536_MSR_GL_REGION_TOP_MASK 0xfffff00000000000ULL
+#define GRUB_CS5536_MSR_GL_REGION_IO_TOP_SHIFT 44
+
+#define GRUB_CS5536_MSR_GL_P2D_START 0x00010020
+
+#define GRUB_CS5536_SMB_REG_DATA 0x0
+#define GRUB_CS5536_SMB_REG_STATUS 0x1
+#define GRUB_CS5536_SMB_REG_STATUS_SDAST (1 << 6)
+#define GRUB_CS5536_SMB_REG_STATUS_BER (1 << 5)
+#define GRUB_CS5536_SMB_REG_STATUS_NACK (1 << 4)
+#define GRUB_CS5536_SMB_REG_CTRL1 0x3
+#define GRUB_CS5536_SMB_REG_CTRL1_START 0x01
+#define GRUB_CS5536_SMB_REG_CTRL1_STOP 0x02
+#define GRUB_CS5536_SMB_REG_CTRL1_ACK 0x10
+#define GRUB_CS5536_SMB_REG_ADDR 0x4
+#define GRUB_CS5536_SMB_REG_ADDR_MASTER 0x0
+#define GRUB_CS5536_SMB_REG_CTRL2 0x5
+#define GRUB_CS5536_SMB_REG_CTRL2_ENABLE 0x1
+#define GRUB_CS5536_SMB_REG_CTRL3 0x6
+
+#ifdef ASM_FILE
+#define GRUB_ULL(x) x
+#else
+#define GRUB_ULL(x) x ## ULL
+#endif
+
+#define GRUB_CS5536_LBAR_ADDR_MASK GRUB_ULL (0x000000000000fff8)
+#define GRUB_CS5536_LBAR_ENABLE GRUB_ULL (0x0000000100000000)
+#define GRUB_CS5536_LBAR_MASK_MASK GRUB_ULL (0x0000f00000000000)
+#define GRUB_CS5536_LBAR_TURN_ON (GRUB_CS5536_LBAR_ENABLE | GRUB_CS5536_LBAR_MASK_MASK)
+
+/* PMON-compatible LBARs. */
+#define GRUB_CS5536_LBAR_GPIO 0xb000
+#define GRUB_CS5536_LBAR_ACC 0xb200
+#define GRUB_CS5536_LBAR_PM 0xb280
+#define GRUB_CS5536_LBAR_MFGPT 0xb300
+#define GRUB_CS5536_LBAR_ACPI 0xb340
+#define GRUB_CS5536_LBAR_IRQ_MAP 0xb360
+#define GRUB_CS5536_LBAR_IDE 0xb380
+#define GRUB_CS5536_LBAR_SMBUS 0xb390
+
+#define GRUB_GPIO_SMBUS_PINS ((1 << 14) | (1 << 15))
+#define GRUB_GPIO_REG_OUT_EN 0x4
+#define GRUB_GPIO_REG_OUT_AUX1 0x10
+#define GRUB_GPIO_REG_IN_EN 0x20
+#define GRUB_GPIO_REG_IN_AUX1 0x34
+
+#ifndef ASM_FILE
+int EXPORT_FUNC (grub_cs5536_find) (grub_pci_device_t *devp);
+
+grub_uint64_t EXPORT_FUNC (grub_cs5536_read_msr) (grub_pci_device_t dev,
+ grub_uint32_t addr);
+void EXPORT_FUNC (grub_cs5536_write_msr) (grub_pci_device_t dev,
+ grub_uint32_t addr,
+ grub_uint64_t val);
+grub_err_t grub_cs5536_read_spd_byte (grub_port_t smbbase, grub_uint8_t dev,
+ grub_uint8_t addr, grub_uint8_t *res);
+grub_err_t EXPORT_FUNC (grub_cs5536_read_spd) (grub_port_t smbbase,
+ grub_uint8_t dev,
+ struct grub_smbus_spd *res);
+grub_err_t grub_cs5536_smbus_wait (grub_port_t smbbase);
+grub_err_t EXPORT_FUNC (grub_cs5536_init_smbus) (grub_pci_device_t dev,
+ grub_uint16_t divisor,
+ grub_port_t *smbbase);
+
+void grub_cs5536_init_geode (grub_pci_device_t dev);
+#endif
+
+#endif
static inline void
grub_pci_device_unmap_range (grub_pci_device_t dev __attribute__ ((unused)),
- void *mem __attribute__ ((unused)),
+ volatile void *mem __attribute__ ((unused)),
grub_size_t size __attribute__ ((unused)))
{
}
#ifndef GRUB_MACHINE_PCI_H
#define GRUB_MACHINE_PCI_H 1
+#ifndef ASM_FILE
#include <grub/types.h>
#include <grub/cpu/io.h>
+#endif
+
+#define GRUB_YEELOONG_OHCI_PCIID 0x00351033
+#define GRUB_YEELOONG_EHCI_PCIID 0x00e01033
+#define GRUB_YEELOONG_OHCI_GHOST_FUNCTION 4
+#define GRUB_YEELOONG_EHCI_GHOST_FUNCTION 5
#define GRUB_PCI_NUM_BUS 1
#define GRUB_PCI_NUM_DEVICES 16
-#define GRUB_MACHINE_PCI_IO_BASE 0xbfd00000
-#define GRUB_MACHINE_PCI_CONFSPACE 0xbfe80000
-#define GRUB_MACHINE_PCI_CONF_CTRL_REG (*(volatile grub_uint32_t *) 0xbfe00118)
+#define GRUB_MACHINE_PCI_IO_BASE 0xbfd00000
+#define GRUB_MACHINE_PCI_CONFSPACE 0xbfe80000
+#define GRUB_MACHINE_PCI_CONTROLLER_HEADER 0xbfe00000
+
+#define GRUB_MACHINE_PCI_CONF_CTRL_REG_ADDR 0xbfe00118
+
+#ifndef ASM_FILE
+#define GRUB_MACHINE_PCI_CONF_CTRL_REG (*(volatile grub_uint32_t *) \
+ GRUB_MACHINE_PCI_CONF_CTRL_REG_ADDR)
#define GRUB_MACHINE_PCI_IO_CTRL_REG (*(volatile grub_uint32_t *) 0xbfe00110)
+#endif
#define GRUB_MACHINE_PCI_WIN_MASK_SIZE 6
#define GRUB_MACHINE_PCI_WIN_MASK ((1 << GRUB_MACHINE_PCI_WIN_MASK_SIZE) - 1)
#define GRUB_MACHINE_PCI_WIN2_ADDR 0xb4000000
#define GRUB_MACHINE_PCI_WIN3_ADDR 0xb8000000
+#ifndef ASM_FILE
static inline grub_uint32_t
grub_pci_read (grub_pci_address_t addr)
{
}
volatile void *
-grub_pci_device_map_range (grub_pci_device_t dev __attribute__ ((unused)),
- grub_addr_t base, grub_size_t size);
+EXPORT_FUNC (grub_pci_device_map_range) (grub_pci_device_t dev,
+ grub_addr_t base, grub_size_t size);
void
-grub_pci_device_unmap_range (grub_pci_device_t dev __attribute__ ((unused)),
- volatile void *mem,
- grub_size_t size __attribute__ ((unused)));
+EXPORT_FUNC (grub_pci_device_unmap_range) (grub_pci_device_t dev,
+ volatile void *mem,
+ grub_size_t size);
+#endif
#endif /* GRUB_MACHINE_PCI_H */
#ifndef GRUB_PCI_H
#define GRUB_PCI_H 1
+#ifndef ASM_FILE
#include <grub/types.h>
#include <grub/symbol.h>
+#endif
#define GRUB_PCI_ADDR_SPACE_MASK 0x01
#define GRUB_PCI_ADDR_SPACE_MEMORY 0x00
#define GRUB_PCI_REG_MIN_GNT 0x3e
#define GRUB_PCI_REG_MAX_LAT 0x3f
+#define GRUB_PCI_COMMAND_IO_ENABLED 0x0001
+#define GRUB_PCI_COMMAND_MEM_ENABLED 0x0002
+#define GRUB_PCI_COMMAND_BUS_MASTER 0x0004
+#define GRUB_PCI_COMMAND_PARITY_ERROR 0x0040
+#define GRUB_PCI_COMMAND_SERR_ENABLE 0x0100
+
+#define GRUB_PCI_STATUS_CAPABILITIES 0x0010
+#define GRUB_PCI_STATUS_66MHZ_CAPABLE 0x0020
+#define GRUB_PCI_STATUS_FAST_B2B_CAPABLE 0x0080
+
+#define GRUB_PCI_STATUS_DEVSEL_TIMING_SHIFT 9
+#define GRUB_PCI_STATUS_DEVSEL_TIMING_MASK 0x0600
+
+#ifndef ASM_FILE
typedef grub_uint32_t grub_pci_id_t;
#ifdef GRUB_MACHINE_EMU
void EXPORT_FUNC(grub_pci_iterate) (grub_pci_iteratefunc_t hook);
+struct grub_pci_dma_chunk;
+
+struct grub_pci_dma_chunk *EXPORT_FUNC(grub_memalign_dma32) (grub_size_t align,
+ grub_size_t size);
+void EXPORT_FUNC(grub_dma_free) (struct grub_pci_dma_chunk *ch);
+volatile void *EXPORT_FUNC(grub_dma_get_virt) (struct grub_pci_dma_chunk *ch);
+grub_uint32_t EXPORT_FUNC(grub_dma_get_phys) (struct grub_pci_dma_chunk *ch);
+
+#endif
+
#endif /* GRUB_PCI_H */
--- /dev/null
+/*
+ * GRUB -- GRand Unified Bootloader
+ * Copyright (C) 2010 Free Software Foundation, Inc.
+ *
+ * GRUB is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GRUB is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GRUB. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GRUB_SMBUS_HEADER
+#define GRUB_SMBUS_HEADER 1
+
+#define GRUB_SMB_RAM_START_ADDR 0x50
+#define GRUB_SMB_RAM_NUM_MAX 0x08
+
+#define GRUB_SMBUS_SPD_MEMORY_TYPE_ADDR 2
+#define GRUB_SMBUS_SPD_MEMORY_TYPE_DDR2 8
+#define GRUB_SMBUS_SPD_MEMORY_NUM_BANKS_ADDR 17
+#define GRUB_SMBUS_SPD_MEMORY_NUM_ROWS_ADDR 3
+#define GRUB_SMBUS_SPD_MEMORY_NUM_COLUMNS_ADDR 4
+#define GRUB_SMBUS_SPD_MEMORY_NUM_OF_RANKS_ADDR 5
+#define GRUB_SMBUS_SPD_MEMORY_NUM_OF_RANKS_MASK 0x7
+#define GRUB_SMBUS_SPD_MEMORY_CAS_LATENCY_ADDR 18
+#define GRUB_SMBUS_SPD_MEMORY_CAS_LATENCY_MIN_VALUE 5
+#define GRUB_SMBUS_SPD_MEMORY_TRAS_ADDR 30
+#define GRUB_SMBUS_SPD_MEMORY_TRTP_ADDR 38
+
+#ifndef ASM_FILE
+
+struct grub_smbus_spd
+{
+ grub_uint8_t written_size;
+ grub_uint8_t log_total_flash_size;
+ grub_uint8_t memory_type;
+ union
+ {
+ grub_uint8_t unknown[253];
+ struct {
+ grub_uint8_t num_rows;
+ grub_uint8_t num_columns;
+ grub_uint8_t num_of_ranks;
+ grub_uint8_t unused1[12];
+ grub_uint8_t num_of_banks;
+ grub_uint8_t unused2[2];
+ grub_uint8_t cas_latency;
+ grub_uint8_t unused3[9];
+ grub_uint8_t rank_capacity;
+ grub_uint8_t unused4[1];
+ grub_uint8_t tras;
+ grub_uint8_t unused5[7];
+ grub_uint8_t trtp;
+ grub_uint8_t unused6[31];
+ grub_uint8_t part_number[18];
+ grub_uint8_t unused7[165];
+ } ddr2;
+ };
+};
+
+#endif
+
+#endif
int size;
int toggle;
grub_transfer_type_t pid;
- char *data;
+ grub_uint32_t data;
};
typedef struct grub_usb_transaction *grub_usb_transaction_t;
projects / thirdparty / grub.git / commitdiff
