October 2013 - SeaBIOS - mail.coreboot.org

[PATCH] acpi: strip compiler info in built-in DSDT if any
by Michael S. Tsirkin Nov. 20, 2013

Nov. 20, 2013

IASL stores it's revision in each table header it generates. That's a problem since guests see a change each time they move between hypervisors. We generally fill our own info for tables, but we forgot to do this for the built-in DSDT. Signed-off-by: Michael S. Tsirkin <mst(a)redhat.com> --- src/fw/acpi.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/fw/acpi.c b/src/fw/acpi.c index c29425c..0e3e3ad 100644 --- a/src/fw/acpi.c +++ b/src/fw/acpi.c @@ -689,13 +689,16 @@ acpi_setup(void) if (CONFIG_ACPI_DSDT && fadt && !fadt->dsdt) { /* default DSDT */ - void *dsdt = malloc_high(sizeof(AmlCode)); + struct acpi_table_header *dsdt = malloc_high(sizeof(AmlCode)); if (!dsdt) { warn_noalloc(); return; } memcpy(dsdt, AmlCode, sizeof(AmlCode)); fill_dsdt(fadt, dsdt); + /* Strip out compiler-generated header if any */ + memset(dsdt, 0, sizeof *dsdt); + build_header(dsdt, DSDT_SIGNATURE, sizeof(AmlCode), 1); } // Build final rsdt table -- MST

2 4

PXE boot ROM question
by Jonathan Sturges Nov. 16, 2013

Nov. 16, 2013

Hi, I'm in the process of dusting off an old Geode GX1 thin client I have and upgrading it to coreboot v4. I had no problem building a new coreboot image (v4 is SO much easier than v2), but I'm having an issue with SeaBIOS and option ROMs. Since this is my first time working with SeaBIOS, I need a bit of help to bring this together. I built a PXE ROM for the onboard NIC, which is a NatSemi DP83815 (DEV/DID 100b/0020). I've tried both an iPXE image built from scratch, as well as a GPXE ROM from rom-o-matic. I added the ROM with cbfstool as documented at coreboot.org, and also added a bootorder file that lists the NIC first. However, when SeaBIOS calls the ROM, nothing seems to happen. See below, where it tries to boot from the ROM but fails almost immediately. It boots successfully from the local disk after the ROM returns. Any pointers as to what the issue is are appreciated. Start bios (version rel-1.7.2.1-0-g88cb66e-20130924_201442-test-f14) Found mainboard DTRI WBTG Ram Size=0x07de0000 (0x0000000000000000 high) Relocating low data from 0x000e7330 to 0x000ef790 (size 2156) Relocating init from 0x000e7b9c to 0x07dc61f0 (size 40164) Found CBFS header at 0xfffffd30 CPU Mhz=295 Found 8 PCI devices (max PCI bus is 00) No apic - only the main cpu is present. Copying SMBIOS entry point from 0x07de1400 to 0x000fd6c0 Scan for VGA option rom OHCI init on dev 00:13.0 (regs=0xfebf1000) Found 1 lpt ports Found 2 serial ports ATA controller 1 at 1f0/3f4/0 (irq 14 dev 92) ATA controller 2 at 170/374/0 (irq 15 dev 92) ata0-0: FUJITSU MHT2060AT ATA-6 Hard-Disk (57231 MiBytes) Searching bootorder for: /pci@i0cf8/*@12,2/drive@0/disk@0 Got ps2 nak (status=51) All threads complete. Scan for option roms Running option rom at c000:0003 pnp call arg1=60 pmm call arg1=0 pmm call arg1=2 pmm call arg1=0 Searching bootorder for: /pci@i0cf8/*@15 Press F12 for boot menu. Searching bootorder for: HALT drive 0x000fd670: PCHS=16383/16/63 translation=lba LCHS=1024/255/63 s=117210240 Space available for UMB: 000c0800-000ef000 Returned 65536 bytes of ZoneHigh e820 map has 5 items: 0: 0000000000000000 - 000000000009fc00 = 1 RAM 1: 000000000009fc00 - 00000000000a0000 = 2 RESERVED 2: 00000000000f0000 - 0000000000100000 = 2 RESERVED 3: 0000000000100000 - 0000000007de0000 = 1 RAM 4: 0000000007de0000 - 0000000007e00000 = 2 RESERVED enter handle_19: NULL Booting from ROM... Booting from c000:0336 enter handle_18: NULL Booting from Hard Disk... Booting from 0000:7c00 Press any key to continue.

3 3

[PATCH v7 0/3] seabios: load acpi tables from qemu
by Michael S. Tsirkin Nov. 6, 2013

Nov. 6, 2013

This is the seabios code that adds support for loading acpi tables from QEMU. Changes from v6: - submission was botched, it didn't compile fix up patch biostables: support looking up RSDP no changes to other patches Changes from v5: - address Kevin's comments: move code to find rsdp to biostables.c scan for RSDP at 0x10 intervals Changes from v4: - address Kevin's comments: move loader to src/fw/ simplify some code drop some unused code chunks load from ROM even if !ACPI rename option to make it non ACPI specific Changes from v3: - updated to latest bits - add option to disable loading from QEMU Changes from v2: - addressed comments from Kevin: fixed coding style, minimized changes to existing code Changes from v1: - simplified linker interfaces along the lines suggested by Kevin - fixed lots of bugs Michael S. Tsirkin (3): biostables: support looking up RSDP romfile_loader: utility to patch in-memory ROM files acpi: load and link tables through romfile loader Makefile | 2 +- src/fw/romfile_loader.h | 72 ++++++++++++++++++++ src/util.h | 1 + src/fw/acpi.c | 21 ++++++ src/fw/biostables.c | 41 +++++++++-- src/fw/romfile_loader.c | 177 ++++++++++++++++++++++++++++++++++++++++++++++++ src/Kconfig | 11 +++ 7 files changed, 317 insertions(+), 8 deletions(-) create mode 100644 src/fw/romfile_loader.h create mode 100644 src/fw/romfile_loader.c -- MST

2 7

[PATCH for 1.7] pc: disable pci-info
by Igor Mammedov Nov. 5, 2013

Nov. 5, 2013

The BIOS that we ship in 1.7 does not use pci info from host and so far isn't going to use it. Taking in account problems it caused see 9604f70fdf and to avoid future incompatibility issues, it's safest to disable that interface by default for all machine types including 1.7 as it was never exposed/used by guest. And properly remove/cleanup it during 1.8 development cycle. Signed-off-by: Igor Mammedov <imammedo(a)redhat.com> --- hw/i386/pc_piix.c | 3 ++- hw/i386/pc_q35.c | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c index c6042c7..4a4d969 100644 --- a/hw/i386/pc_piix.c +++ b/hw/i386/pc_piix.c @@ -58,7 +58,8 @@ static const int ide_iobase2[MAX_IDE_BUS] = { 0x3f6, 0x376 }; static const int ide_irq[MAX_IDE_BUS] = { 14, 15 }; static bool has_pvpanic; -static bool has_pci_info = true; +/* TODO: remove unused "etc/pci-info" */ +static bool has_pci_info; /* PC hardware initialisation */ static void pc_init1(QEMUMachineInitArgs *args, diff --git a/hw/i386/pc_q35.c b/hw/i386/pc_q35.c index ca84e1c..8e5c1ae 100644 --- a/hw/i386/pc_q35.c +++ b/hw/i386/pc_q35.c @@ -48,7 +48,8 @@ #define MAX_SATA_PORTS 6 static bool has_pvpanic; -static bool has_pci_info = true; +/* TODO: remove unused "etc/pci-info" */ +static bool has_pci_info; /* PC hardware initialisation */ static void pc_q35_init(QEMUMachineInitArgs *args) -- 1.7.1

4 5

[PATCH v3 0/3] usb: add xhci support
by Gerd Hoffmann Nov. 4, 2013

Nov. 4, 2013

Hi, Next version of the xhci support patch series. Changed xhci device list to use standard hlist macros. Delete devices from list in disconnect() callback, so we should not have inactive/freed devices in the list. cheers, Gerd Gerd Hoffmann (3): uas: add (temporary) superspeed stopgap usb: add usb_update_pipe() usb: add xhci support Makefile | 2 +- src/Kconfig | 6 + src/pci_ids.h | 1 + src/usb-uas.c | 4 + src/usb-xhci.c | 1124 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/usb-xhci.h | 144 ++++++++ src/usb.c | 35 +- src/usb.h | 17 +- 8 files changed, 1320 insertions(+), 13 deletions(-) create mode 100644 src/usb-xhci.c create mode 100644 src/usb-xhci.h -- 1.8.3.1

4 17

[PATCH] Convert op->drive_g from a 16bit pointer to a 32 bit "GLOBALFLAT" pointer.
by Kevin O'Connor Nov. 1, 2013

Nov. 1, 2013

The "drive" structure is always malloc'ed and therefore always starts off described as a 32-bit "flat" pointer. Instead of switching to/from 16bit pointers, make all the code use the 32bit pointer. This eliminates the confusing 16/32 bit pointer switches. This patch also removes the "_g" suffixes on local variables in functions that are always called in 32bit mode. Signed-off-by: Kevin O'Connor <kevin(a)koconnor.net> --- src/block.c | 100 ++++++++++---------- src/block.h | 10 +- src/cdrom.c | 31 +++---- src/disk.c | 257 +++++++++++++++++++++++++-------------------------- src/hw/ahci.c | 28 +++--- src/hw/ata.c | 164 ++++++++++++++++---------------- src/hw/blockcmd.c | 12 +-- src/hw/esp-scsi.c | 15 +-- src/hw/floppy.c | 58 ++++++------ src/hw/lsi-scsi.c | 15 +-- src/hw/megasas.c | 16 ++-- src/hw/pvscsi.c | 19 ++-- src/hw/ramdisk.c | 12 +-- src/hw/usb-msc.c | 42 ++++----- src/hw/usb-uas.c | 18 ++-- src/hw/virtio-blk.c | 50 +++++----- src/hw/virtio-scsi.c | 13 +-- 17 files changed, 429 insertions(+), 431 deletions(-) diff --git a/src/block.c b/src/block.c index af254ce..7493a5d 100644 --- a/src/block.c +++ b/src/block.c @@ -31,17 +31,15 @@ getDrive(u8 exttype, u8 extdriveoffset) { if (extdriveoffset >= ARRAY_SIZE(IDMap[0])) return NULL; - struct drive_s *drive_gf = GET_GLOBAL(IDMap[exttype][extdriveoffset]); - if (!drive_gf) - return NULL; - return GLOBALFLAT2GLOBAL(drive_gf); + return GET_GLOBAL(IDMap[exttype][extdriveoffset]); } -int getDriveId(u8 exttype, struct drive_s *drive_g) +int getDriveId(u8 exttype, struct drive_s *drive) { + ASSERT32FLAT(); int i; for (i = 0; i < ARRAY_SIZE(IDMap[0]); i++) - if (getDrive(exttype, i) == drive_g) + if (getDrive(exttype, i) == drive) return i; return -1; } @@ -65,12 +63,12 @@ int create_bounce_buf(void) ****************************************************************/ static u8 -get_translation(struct drive_s *drive_g) +get_translation(struct drive_s *drive) { - u8 type = GET_GLOBAL(drive_g->type); + u8 type = drive->type; if (CONFIG_QEMU && type == DTYPE_ATA) { // Emulators pass in the translation info via nvram. - u8 ataid = GET_GLOBAL(drive_g->cntl_id); + u8 ataid = drive->cntl_id; u8 channel = ataid / 2; u8 translation = rtc_read(CMOS_BIOS_DISKTRANSFLAG + channel/2); translation >>= 2 * (ataid % 4); @@ -79,10 +77,10 @@ get_translation(struct drive_s *drive_g) } // Otherwise use a heuristic to determine translation type. - u16 heads = GET_GLOBAL(drive_g->pchs.head); - u16 cylinders = GET_GLOBAL(drive_g->pchs.cylinder); - u16 spt = GET_GLOBAL(drive_g->pchs.sector); - u64 sectors = GET_GLOBAL(drive_g->sectors); + u16 heads = drive->pchs.head; + u16 cylinders = drive->pchs.cylinder; + u16 spt = drive->pchs.sector; + u64 sectors = drive->sectors; u64 psectors = (u64)heads * cylinders * spt; if (!heads || !cylinders || !spt || psectors > sectors) // pchs doesn't look valid - use LBA. @@ -96,15 +94,15 @@ get_translation(struct drive_s *drive_g) } static void -setup_translation(struct drive_s *drive_g) +setup_translation(struct drive_s *drive) { - u8 translation = get_translation(drive_g); - SET_GLOBAL(drive_g->translation, translation); + u8 translation = get_translation(drive); + drive->translation = translation; - u16 heads = GET_GLOBAL(drive_g->pchs.head); - u16 cylinders = GET_GLOBAL(drive_g->pchs.cylinder); - u16 spt = GET_GLOBAL(drive_g->pchs.sector); - u64 sectors = GET_GLOBAL(drive_g->sectors); + u16 heads = drive->pchs.head ; + u16 cylinders = drive->pchs.cylinder; + u16 spt = drive->pchs.sector; + u64 sectors = drive->sectors; const char *desc = NULL; switch (translation) { @@ -161,15 +159,15 @@ setup_translation(struct drive_s *drive_g) if (cylinders > 1024) cylinders = 1024; dprintf(1, "drive %p: PCHS=%u/%d/%d translation=%s LCHS=%d/%d/%d s=%d\n" - , drive_g - , drive_g->pchs.cylinder, drive_g->pchs.head, drive_g->pchs.sector + , drive + , drive->pchs.cylinder, drive->pchs.head, drive->pchs.sector , desc , cylinders, heads, spt , (u32)sectors); - SET_GLOBAL(drive_g->lchs.head, heads); - SET_GLOBAL(drive_g->lchs.cylinder, cylinders); - SET_GLOBAL(drive_g->lchs.sector, spt); + drive->lchs.head = heads; + drive->lchs.cylinder = cylinders; + drive->lchs.sector = spt; } @@ -179,18 +177,18 @@ setup_translation(struct drive_s *drive_g) // Fill in Fixed Disk Parameter Table (located in ebda). static void -fill_fdpt(struct drive_s *drive_g, int hdid) +fill_fdpt(struct drive_s *drive, int hdid) { if (hdid > 1) return; - u16 nlc = GET_GLOBAL(drive_g->lchs.cylinder); - u16 nlh = GET_GLOBAL(drive_g->lchs.head); - u16 nls = GET_GLOBAL(drive_g->lchs.sector); + u16 nlc = drive->lchs.cylinder; + u16 nlh = drive->lchs.head; + u16 nls = drive->lchs.sector; - u16 npc = GET_GLOBAL(drive_g->pchs.cylinder); - u16 nph = GET_GLOBAL(drive_g->pchs.head); - u16 nps = GET_GLOBAL(drive_g->pchs.sector); + u16 npc = drive->pchs.cylinder; + u16 nph = drive->pchs.head; + u16 nps = drive->pchs.sector; struct fdpt_s *fdpt = &get_ebda_ptr()->fdpt[hdid]; fdpt->precompensation = 0xffff; @@ -224,47 +222,49 @@ fill_fdpt(struct drive_s *drive_g, int hdid) // Find spot to add a drive static void -add_drive(struct drive_s **idmap, u8 *count, struct drive_s *drive_g) +add_drive(struct drive_s **idmap, u8 *count, struct drive_s *drive) { if (*count >= ARRAY_SIZE(IDMap[0])) { warn_noalloc(); return; } - idmap[*count] = drive_g; + idmap[*count] = drive; *count = *count + 1; } // Map a hard drive void -map_hd_drive(struct drive_s *drive_g) +map_hd_drive(struct drive_s *drive) { ASSERT32FLAT(); struct bios_data_area_s *bda = MAKE_FLATPTR(SEG_BDA, 0); int hdid = bda->hdcount; - dprintf(3, "Mapping hd drive %p to %d\n", drive_g, hdid); - add_drive(IDMap[EXTTYPE_HD], &bda->hdcount, drive_g); + dprintf(3, "Mapping hd drive %p to %d\n", drive, hdid); + add_drive(IDMap[EXTTYPE_HD], &bda->hdcount, drive); // Setup disk geometry translation. - setup_translation(drive_g); + setup_translation(drive); // Fill "fdpt" structure. - fill_fdpt(drive_g, hdid); + fill_fdpt(drive, hdid); } // Map a cd void -map_cd_drive(struct drive_s *drive_g) +map_cd_drive(struct drive_s *drive) { - dprintf(3, "Mapping cd drive %p\n", drive_g); - add_drive(IDMap[EXTTYPE_CD], &CDCount, drive_g); + ASSERT32FLAT(); + dprintf(3, "Mapping cd drive %p\n", drive); + add_drive(IDMap[EXTTYPE_CD], &CDCount, drive); } // Map a floppy void -map_floppy_drive(struct drive_s *drive_g) +map_floppy_drive(struct drive_s *drive) { - dprintf(3, "Mapping floppy drive %p\n", drive_g); - add_drive(IDMap[EXTTYPE_FLOPPY], &FloppyCount, drive_g); + ASSERT32FLAT(); + dprintf(3, "Mapping floppy drive %p\n", drive); + add_drive(IDMap[EXTTYPE_FLOPPY], &FloppyCount, drive); // Update equipment word bits for floppy if (FloppyCount == 1) { @@ -350,7 +350,7 @@ int process_op(struct disk_op_s *op) { ASSERT16(); - u8 type = GET_GLOBAL(op->drive_g->type); + u8 type = GET_GLOBALFLAT(op->drive_gf->type); switch (type) { case DTYPE_FLOPPY: return process_floppy_op(op); @@ -362,15 +362,13 @@ process_op(struct disk_op_s *op) return process_cdemu_op(op); case DTYPE_VIRTIO_BLK: return process_virtio_blk_op(op); - case DTYPE_AHCI: - op->drive_g = (void*)op->drive_g + BUILD_BIOS_ADDR; + case DTYPE_AHCI: ; extern void _cfunc32flat_process_ahci_op(void); return call32(_cfunc32flat_process_ahci_op , (u32)MAKE_FLATPTR(GET_SEG(SS), op), DISK_RET_EPARAM); case DTYPE_ATA_ATAPI: return process_atapi_op(op); - case DTYPE_AHCI_ATAPI: - op->drive_g = (void*)op->drive_g + BUILD_BIOS_ADDR; + case DTYPE_AHCI_ATAPI: ; extern void _cfunc32flat_process_atapi_op(void); return call32(_cfunc32flat_process_atapi_op , (u32)MAKE_FLATPTR(GET_SEG(SS), op), DISK_RET_EPARAM); @@ -398,7 +396,7 @@ __send_disk_op(struct disk_op_s *op_far, u16 op_seg) , sizeof(dop)); dprintf(DEBUG_HDL_13, "disk_op d=%p lba=%d buf=%p count=%d cmd=%d\n" - , dop.drive_g, (u32)dop.lba, dop.buf_fl + , dop.drive_gf, (u32)dop.lba, dop.buf_fl , dop.count, dop.command); int status = process_op(&dop); diff --git a/src/block.h b/src/block.h index 9bffa09..9cb25d0 100644 --- a/src/block.h +++ b/src/block.h @@ -11,7 +11,7 @@ struct disk_op_s { u64 lba; void *buf_fl; - struct drive_s *drive_g; + struct drive_s *drive_gf; u16 count; u8 command; }; @@ -109,10 +109,10 @@ extern struct dpte_s DefaultDPTE; extern u8 FloppyCount, CDCount; extern u8 *bounce_buf_fl; struct drive_s *getDrive(u8 exttype, u8 extdriveoffset); -int getDriveId(u8 exttype, struct drive_s *drive_g); -void map_floppy_drive(struct drive_s *drive_g); -void map_hd_drive(struct drive_s *drive_g); -void map_cd_drive(struct drive_s *drive_g); +int getDriveId(u8 exttype, struct drive_s *drive); +void map_floppy_drive(struct drive_s *drive); +void map_hd_drive(struct drive_s *drive); +void map_cd_drive(struct drive_s *drive); struct bregs; void __disk_ret(struct bregs *regs, u32 linecode, const char *fname); void __disk_ret_unimplemented(struct bregs *regs, u32 linecode diff --git a/src/cdrom.c b/src/cdrom.c index 836808b..811bef5 100644 --- a/src/cdrom.c +++ b/src/cdrom.c @@ -30,10 +30,9 @@ struct drive_s *cdemu_drive_gf VARFSEG; static int cdemu_read(struct disk_op_s *op) { - struct drive_s *drive_g; - drive_g = GLOBALFLAT2GLOBAL(GET_LOW(CDEmu.emulated_drive_gf)); + struct drive_s *drive_gf = GET_LOW(CDEmu.emulated_drive_gf); struct disk_op_s dop; - dop.drive_g = drive_g; + dop.drive_gf = drive_gf; dop.command = op->command; dop.lba = GET_LOW(CDEmu.ilba) + op->lba / 4; @@ -120,17 +119,17 @@ cdrom_prepboot(void) if (create_bounce_buf() < 0) return; - struct drive_s *drive_g = malloc_fseg(sizeof(*drive_g)); - if (!drive_g) { + struct drive_s *drive = malloc_fseg(sizeof(*drive)); + if (!drive) { warn_noalloc(); - free(drive_g); + free(drive); return; } - cdemu_drive_gf = drive_g; - memset(drive_g, 0, sizeof(*drive_g)); - drive_g->type = DTYPE_CDEMU; - drive_g->blksize = DISK_SECTOR_SIZE; - drive_g->sectors = (u64)-1; + cdemu_drive_gf = drive; + memset(drive, 0, sizeof(*drive)); + drive->type = DTYPE_CDEMU; + drive->blksize = DISK_SECTOR_SIZE; + drive->sectors = (u64)-1; } #define SET_INT13ET(regs,var,val) \ @@ -175,14 +174,14 @@ cdemu_134b(struct bregs *regs) ****************************************************************/ int -cdrom_boot(struct drive_s *drive_g) +cdrom_boot(struct drive_s *drive) { ASSERT32FLAT(); struct disk_op_s dop; - int cdid = getDriveId(EXTTYPE_CD, drive_g); + int cdid = getDriveId(EXTTYPE_CD, drive); memset(&dop, 0, sizeof(dop)); - dop.drive_g = drive_g; - if (!dop.drive_g || cdid < 0) + dop.drive_gf = drive; + if (!dop.drive_gf || cdid < 0) return 1; int ret = scsi_is_ready(&dop); @@ -231,7 +230,7 @@ cdrom_boot(struct drive_s *drive_g) u8 media = buffer[0x21]; CDEmu.media = media; - CDEmu.emulated_drive_gf = dop.drive_g; + CDEmu.emulated_drive_gf = dop.drive_gf; u16 boot_segment = *(u16*)&buffer[0x22]; if (!boot_segment) diff --git a/src/disk.c b/src/disk.c index 80290ce..1011b39 100644 --- a/src/disk.c +++ b/src/disk.c @@ -34,11 +34,10 @@ __disk_stub(struct bregs *regs, int lineno, const char *fname) // Get the cylinders/heads/sectors for the given drive. static struct chs_s -getLCHS(struct drive_s *drive_g) +getLCHS(struct drive_s *drive_gf) { struct chs_s res = { }; - if (CONFIG_CDROM_EMU - && drive_g == GLOBALFLAT2GLOBAL(GET_GLOBAL(cdemu_drive_gf))) { + if (CONFIG_CDROM_EMU && drive_gf == GET_GLOBAL(cdemu_drive_gf)) { // Emulated drive - get info from CDEmu. (It's not possible to // populate the geometry directly in the driveid because the // geometry is only known after the bios segment is made @@ -48,18 +47,18 @@ getLCHS(struct drive_s *drive_g) res.sector = GET_LOW(CDEmu.lchs.sector); return res; } - res.cylinder = GET_GLOBAL(drive_g->lchs.cylinder); - res.head = GET_GLOBAL(drive_g->lchs.head); - res.sector = GET_GLOBAL(drive_g->lchs.sector); + res.cylinder = GET_GLOBALFLAT(drive_gf->lchs.cylinder); + res.head = GET_GLOBALFLAT(drive_gf->lchs.head); + res.sector = GET_GLOBALFLAT(drive_gf->lchs.sector); return res; } // Perform read/write/verify using old-style chs accesses static void noinline -basic_access(struct bregs *regs, struct drive_s *drive_g, u16 command) +basic_access(struct bregs *regs, struct drive_s *drive_gf, u16 command) { struct disk_op_s dop; - dop.drive_g = drive_g; + dop.drive_gf = drive_gf; dop.command = command; u8 count = regs->al; @@ -74,7 +73,7 @@ basic_access(struct bregs *regs, struct drive_s *drive_g, u16 command) } dop.count = count; - struct chs_s chs = getLCHS(drive_g); + struct chs_s chs = getLCHS(drive_gf); u16 nlc=chs.cylinder, nlh=chs.head, nls=chs.sector; // sanity check on cyl heads, sec @@ -99,15 +98,15 @@ basic_access(struct bregs *regs, struct drive_s *drive_g, u16 command) // Perform read/write/verify using new-style "int13ext" accesses. static void noinline -extended_access(struct bregs *regs, struct drive_s *drive_g, u16 command) +extended_access(struct bregs *regs, struct drive_s *drive_gf, u16 command) { struct disk_op_s dop; struct int13ext_s *param_far = (struct int13ext_s*)(regs->si+0); // Get lba and check. dop.lba = GET_FARVAR(regs->ds, param_far->lba); dop.command = command; - dop.drive_g = drive_g; - if (dop.lba >= GET_GLOBAL(drive_g->sectors)) { + dop.drive_gf = drive_gf; + if (dop.lba >= GET_GLOBALFLAT(drive_gf->sectors)) { warn_invalid(regs); disk_ret(regs, DISK_RET_EPARAM); return; @@ -135,10 +134,10 @@ extended_access(struct bregs *regs, struct drive_s *drive_g, u16 command) // disk controller reset static void -disk_1300(struct bregs *regs, struct drive_s *drive_g) +disk_1300(struct bregs *regs, struct drive_s *drive_gf) { struct disk_op_s dop; - dop.drive_g = drive_g; + dop.drive_gf = drive_gf; dop.command = CMD_RESET; int status = send_disk_op(&dop); disk_ret(regs, status); @@ -146,7 +145,7 @@ disk_1300(struct bregs *regs, struct drive_s *drive_g) // read disk status static void -disk_1301(struct bregs *regs, struct drive_s *drive_g) +disk_1301(struct bregs *regs, struct drive_s *drive_gf) { u8 v; if (regs->dl < EXTSTART_HD) @@ -161,32 +160,32 @@ disk_1301(struct bregs *regs, struct drive_s *drive_g) // read disk sectors static void -disk_1302(struct bregs *regs, struct drive_s *drive_g) +disk_1302(struct bregs *regs, struct drive_s *drive_gf) { - basic_access(regs, drive_g, CMD_READ); + basic_access(regs, drive_gf, CMD_READ); } // write disk sectors static void -disk_1303(struct bregs *regs, struct drive_s *drive_g) +disk_1303(struct bregs *regs, struct drive_s *drive_gf) { - basic_access(regs, drive_g, CMD_WRITE); + basic_access(regs, drive_gf, CMD_WRITE); } // verify disk sectors static void -disk_1304(struct bregs *regs, struct drive_s *drive_g) +disk_1304(struct bregs *regs, struct drive_s *drive_gf) { - basic_access(regs, drive_g, CMD_VERIFY); + basic_access(regs, drive_gf, CMD_VERIFY); } // format disk track static void noinline -disk_1305(struct bregs *regs, struct drive_s *drive_g) +disk_1305(struct bregs *regs, struct drive_s *drive_gf) { debug_stub(regs); - struct chs_s chs = getLCHS(drive_g); + struct chs_s chs = getLCHS(drive_gf); u16 nlh=chs.head, nls=chs.sector; u8 num_sectors = regs->al; @@ -198,7 +197,7 @@ disk_1305(struct bregs *regs, struct drive_s *drive_g) } struct disk_op_s dop; - dop.drive_g = drive_g; + dop.drive_gf = drive_gf; dop.command = CMD_FORMAT; dop.lba = head; dop.count = num_sectors; @@ -209,10 +208,10 @@ disk_1305(struct bregs *regs, struct drive_s *drive_g) // read disk drive parameters static void noinline -disk_1308(struct bregs *regs, struct drive_s *drive_g) +disk_1308(struct bregs *regs, struct drive_s *drive_gf) { // Get logical geometry from table - struct chs_s chs = getLCHS(drive_g); + struct chs_s chs = getLCHS(drive_gf); u16 nlc=chs.cylinder, nlh=chs.head, nls=chs.sector; nlc--; nlh--; @@ -221,11 +220,10 @@ disk_1308(struct bregs *regs, struct drive_s *drive_g) // Floppy count = GET_GLOBAL(FloppyCount); - if (CONFIG_CDROM_EMU - && drive_g == GLOBALFLAT2GLOBAL(GET_GLOBAL(cdemu_drive_gf))) + if (CONFIG_CDROM_EMU && drive_gf == GET_GLOBAL(cdemu_drive_gf)) regs->bx = GET_LOW(CDEmu.media) * 2; else - regs->bx = GET_GLOBAL(drive_g->floppy_type); + regs->bx = GET_GLOBALFLAT(drive_gf->floppy_type); // set es & di to point to 11 byte diskette param table in ROM regs->es = SEG_BIOS; @@ -261,33 +259,33 @@ disk_1308(struct bregs *regs, struct drive_s *drive_g) // initialize drive parameters static void -disk_1309(struct bregs *regs, struct drive_s *drive_g) +disk_1309(struct bregs *regs, struct drive_s *drive_gf) { DISK_STUB(regs); } // seek to specified cylinder static void -disk_130c(struct bregs *regs, struct drive_s *drive_g) +disk_130c(struct bregs *regs, struct drive_s *drive_gf) { DISK_STUB(regs); } // alternate disk reset static void -disk_130d(struct bregs *regs, struct drive_s *drive_g) +disk_130d(struct bregs *regs, struct drive_s *drive_gf) { DISK_STUB(regs); } // check drive ready static void -disk_1310(struct bregs *regs, struct drive_s *drive_g) +disk_1310(struct bregs *regs, struct drive_s *drive_gf) { // should look at 40:8E also??? struct disk_op_s dop; - dop.drive_g = drive_g; + dop.drive_gf = drive_gf; dop.command = CMD_ISREADY; int status = send_disk_op(&dop); disk_ret(regs, status); @@ -295,21 +293,21 @@ disk_1310(struct bregs *regs, struct drive_s *drive_g) // recalibrate static void -disk_1311(struct bregs *regs, struct drive_s *drive_g) +disk_1311(struct bregs *regs, struct drive_s *drive_gf) { DISK_STUB(regs); } // controller internal diagnostic static void -disk_1314(struct bregs *regs, struct drive_s *drive_g) +disk_1314(struct bregs *regs, struct drive_s *drive_gf) { DISK_STUB(regs); } // read disk drive size static void noinline -disk_1315(struct bregs *regs, struct drive_s *drive_g) +disk_1315(struct bregs *regs, struct drive_s *drive_gf) { disk_ret(regs, DISK_RET_SUCCESS); if (regs->dl < EXTSTART_HD || regs->dl >= EXTSTART_CD) { @@ -320,7 +318,7 @@ disk_1315(struct bregs *regs, struct drive_s *drive_g) // Hard drive // Get logical geometry from table - struct chs_s chs = getLCHS(drive_g); + struct chs_s chs = getLCHS(drive_gf); u16 nlc=chs.cylinder, nlh=chs.head, nls=chs.sector; // Compute sector count seen by int13 @@ -331,7 +329,7 @@ disk_1315(struct bregs *regs, struct drive_s *drive_g) } static void -disk_1316(struct bregs *regs, struct drive_s *drive_g) +disk_1316(struct bregs *regs, struct drive_s *drive_gf) { if (regs->dl >= EXTSTART_HD) { // Hard drive @@ -343,7 +341,7 @@ disk_1316(struct bregs *regs, struct drive_s *drive_g) // IBM/MS installation check static void -disk_1341(struct bregs *regs, struct drive_s *drive_g) +disk_1341(struct bregs *regs, struct drive_s *drive_gf) { regs->bx = 0xaa55; // install check regs->cx = 0x0007; // ext disk access and edd, removable supported @@ -353,28 +351,28 @@ disk_1341(struct bregs *regs, struct drive_s *drive_g) // IBM/MS extended read static void -disk_1342(struct bregs *regs, struct drive_s *drive_g) +disk_1342(struct bregs *regs, struct drive_s *drive_gf) { - extended_access(regs, drive_g, CMD_READ); + extended_access(regs, drive_gf, CMD_READ); } // IBM/MS extended write static void -disk_1343(struct bregs *regs, struct drive_s *drive_g) +disk_1343(struct bregs *regs, struct drive_s *drive_gf) { - extended_access(regs, drive_g, CMD_WRITE); + extended_access(regs, drive_gf, CMD_WRITE); } // IBM/MS verify static void -disk_1344(struct bregs *regs, struct drive_s *drive_g) +disk_1344(struct bregs *regs, struct drive_s *drive_gf) { - extended_access(regs, drive_g, CMD_VERIFY); + extended_access(regs, drive_gf, CMD_VERIFY); } // lock static void -disk_134500(struct bregs *regs, struct drive_s *drive_g) +disk_134500(struct bregs *regs, struct drive_s *drive_gf) { int cdid = regs->dl - EXTSTART_CD; u8 locks = GET_LOW(CDRom_locks[cdid]); @@ -390,7 +388,7 @@ disk_134500(struct bregs *regs, struct drive_s *drive_g) // unlock static void -disk_134501(struct bregs *regs, struct drive_s *drive_g) +disk_134501(struct bregs *regs, struct drive_s *drive_gf) { int cdid = regs->dl - EXTSTART_CD; u8 locks = GET_LOW(CDRom_locks[cdid]); @@ -407,7 +405,7 @@ disk_134501(struct bregs *regs, struct drive_s *drive_g) // status static void -disk_134502(struct bregs *regs, struct drive_s *drive_g) +disk_134502(struct bregs *regs, struct drive_s *drive_gf) { int cdid = regs->dl - EXTSTART_CD; u8 locks = GET_LOW(CDRom_locks[cdid]); @@ -416,14 +414,14 @@ disk_134502(struct bregs *regs, struct drive_s *drive_g) } static void -disk_1345XX(struct bregs *regs, struct drive_s *drive_g) +disk_1345XX(struct bregs *regs, struct drive_s *drive_gf) { disk_ret_unimplemented(regs, DISK_RET_EPARAM); } // IBM/MS lock/unlock drive static void -disk_1345(struct bregs *regs, struct drive_s *drive_g) +disk_1345(struct bregs *regs, struct drive_s *drive_gf) { if (regs->dl < EXTSTART_CD) { // Always success for HD @@ -432,16 +430,16 @@ disk_1345(struct bregs *regs, struct drive_s *drive_g) } switch (regs->al) { - case 0x00: disk_134500(regs, drive_g); break; - case 0x01: disk_134501(regs, drive_g); break; - case 0x02: disk_134502(regs, drive_g); break; - default: disk_1345XX(regs, drive_g); break; + case 0x00: disk_134500(regs, drive_gf); break; + case 0x01: disk_134501(regs, drive_gf); break; + case 0x02: disk_134502(regs, drive_gf); break; + default: disk_1345XX(regs, drive_gf); break; } } // IBM/MS eject media static void noinline -disk_1346(struct bregs *regs, struct drive_s *drive_g) +disk_1346(struct bregs *regs, struct drive_s *drive_gf) { if (regs->dl < EXTSTART_CD) { // Volume Not Removable @@ -475,14 +473,14 @@ disk_1346(struct bregs *regs, struct drive_s *drive_g) // IBM/MS extended seek static void -disk_1347(struct bregs *regs, struct drive_s *drive_g) +disk_1347(struct bregs *regs, struct drive_s *drive_gf) { - extended_access(regs, drive_g, CMD_SEEK); + extended_access(regs, drive_gf, CMD_SEEK); } // IBM/MS get drive parameters static void noinline -disk_1348(struct bregs *regs, struct drive_s *drive_g) +disk_1348(struct bregs *regs, struct drive_s *drive_gf) { u16 seg = regs->ds; struct int13dpt_s *param_far = (struct int13dpt_s*)(regs->si+0); @@ -497,12 +495,12 @@ disk_1348(struct bregs *regs, struct drive_s *drive_g) // EDD 1.x - u8 type = GET_GLOBAL(drive_g->type); - u16 npc = GET_GLOBAL(drive_g->pchs.cylinder); - u16 nph = GET_GLOBAL(drive_g->pchs.head); - u16 nps = GET_GLOBAL(drive_g->pchs.sector); - u64 lba = GET_GLOBAL(drive_g->sectors); - u16 blksize = GET_GLOBAL(drive_g->blksize); + u8 type = GET_GLOBALFLAT(drive_gf->type); + u16 npc = GET_GLOBALFLAT(drive_gf->pchs.cylinder); + u16 nph = GET_GLOBALFLAT(drive_gf->pchs.head); + u16 nps = GET_GLOBALFLAT(drive_gf->pchs.sector); + u64 lba = GET_GLOBALFLAT(drive_gf->sectors); + u16 blksize = GET_GLOBALFLAT(drive_gf->blksize); dprintf(DEBUG_HDL_13, "disk_1348 size=%d t=%d chs=%d,%d,%d lba=%d bs=%d\n" , size, type, npc, nph, nps, (u32)lba, blksize); @@ -547,10 +545,10 @@ disk_1348(struct bregs *regs, struct drive_s *drive_g) SET_FARVAR(seg, param_far->dpte, SEGOFF(SEG_LOW, (u32)&DefaultDPTE)); // Fill in dpte - struct atadrive_s *adrive_g = container_of( - drive_g, struct atadrive_s, drive); - struct ata_channel_s *chan_gf = GET_GLOBAL(adrive_g->chan_gf); - u8 slave = GET_GLOBAL(adrive_g->slave); + struct atadrive_s *adrive_gf = container_of( + drive_gf, struct atadrive_s, drive); + struct ata_channel_s *chan_gf = GET_GLOBALFLAT(adrive_gf->chan_gf); + u8 slave = GET_GLOBALFLAT(adrive_gf->slave); u16 iobase2 = GET_GLOBALFLAT(chan_gf->iobase2); u8 irq = GET_GLOBALFLAT(chan_gf->irq); iobase1 = GET_GLOBALFLAT(chan_gf->iobase1); @@ -560,7 +558,7 @@ disk_1348(struct bregs *regs, struct drive_s *drive_g) u16 options = 0; if (type == DTYPE_ATA) { - u8 translation = GET_GLOBAL(drive_g->translation); + u8 translation = GET_GLOBALFLAT(drive_gf->translation); if (translation != TRANSLATION_NONE) { options |= 1<<3; // CHS translation if (translation == TRANSLATION_LBA) @@ -594,7 +592,7 @@ disk_1348(struct bregs *regs, struct drive_s *drive_g) SET_LOW(DefaultDPTE.checksum, -sum); } else { SET_FARVAR(seg, param_far->dpte.segoff, 0xffffffff); - bdf = GET_GLOBAL(drive_g->cntl_id); + bdf = GET_GLOBALFLAT(drive_gf->cntl_id); } if (size < 66) { @@ -664,7 +662,7 @@ disk_1348(struct bregs *regs, struct drive_s *drive_g) // IBM/MS extended media change static void -disk_1349(struct bregs *regs, struct drive_s *drive_g) +disk_1349(struct bregs *regs, struct drive_s *drive_gf) { if (regs->dl < EXTSTART_CD) { // Always success for HD @@ -677,56 +675,56 @@ disk_1349(struct bregs *regs, struct drive_s *drive_g) } static void -disk_134e01(struct bregs *regs, struct drive_s *drive_g) +disk_134e01(struct bregs *regs, struct drive_s *drive_gf) { disk_ret(regs, DISK_RET_SUCCESS); } static void -disk_134e03(struct bregs *regs, struct drive_s *drive_g) +disk_134e03(struct bregs *regs, struct drive_s *drive_gf) { disk_ret(regs, DISK_RET_SUCCESS); } static void -disk_134e04(struct bregs *regs, struct drive_s *drive_g) +disk_134e04(struct bregs *regs, struct drive_s *drive_gf) { disk_ret(regs, DISK_RET_SUCCESS); } static void -disk_134e06(struct bregs *regs, struct drive_s *drive_g) +disk_134e06(struct bregs *regs, struct drive_s *drive_gf) { disk_ret(regs, DISK_RET_SUCCESS); } static void -disk_134eXX(struct bregs *regs, struct drive_s *drive_g) +disk_134eXX(struct bregs *regs, struct drive_s *drive_gf) { disk_ret(regs, DISK_RET_EPARAM); } // IBM/MS set hardware configuration static void -disk_134e(struct bregs *regs, struct drive_s *drive_g) +disk_134e(struct bregs *regs, struct drive_s *drive_gf) { switch (regs->al) { - case 0x01: disk_134e01(regs, drive_g); break; - case 0x03: disk_134e03(regs, drive_g); break; - case 0x04: disk_134e04(regs, drive_g); break; - case 0x06: disk_134e06(regs, drive_g); break; - default: disk_134eXX(regs, drive_g); break; + case 0x01: disk_134e01(regs, drive_gf); break; + case 0x03: disk_134e03(regs, drive_gf); break; + case 0x04: disk_134e04(regs, drive_gf); break; + case 0x06: disk_134e06(regs, drive_gf); break; + default: disk_134eXX(regs, drive_gf); break; } } static void -disk_13XX(struct bregs *regs, struct drive_s *drive_g) +disk_13XX(struct bregs *regs, struct drive_s *drive_gf) { disk_ret_unimplemented(regs, DISK_RET_EPARAM); } static void -disk_13(struct bregs *regs, struct drive_s *drive_g) +disk_13(struct bregs *regs, struct drive_s *drive_gf) { //debug_stub(regs); @@ -734,37 +732,37 @@ disk_13(struct bregs *regs, struct drive_s *drive_g) SET_BDA(disk_interrupt_flag, 0); switch (regs->ah) { - case 0x00: disk_1300(regs, drive_g); break; - case 0x01: disk_1301(regs, drive_g); break; - case 0x02: disk_1302(regs, drive_g); break; - case 0x03: disk_1303(regs, drive_g); break; - case 0x04: disk_1304(regs, drive_g); break; - case 0x05: disk_1305(regs, drive_g); break; - case 0x08: disk_1308(regs, drive_g); break; - case 0x09: disk_1309(regs, drive_g); break; - case 0x0c: disk_130c(regs, drive_g); break; - case 0x0d: disk_130d(regs, drive_g); break; - case 0x10: disk_1310(regs, drive_g); break; - case 0x11: disk_1311(regs, drive_g); break; - case 0x14: disk_1314(regs, drive_g); break; - case 0x15: disk_1315(regs, drive_g); break; - case 0x16: disk_1316(regs, drive_g); break; - case 0x41: disk_1341(regs, drive_g); break; - case 0x42: disk_1342(regs, drive_g); break; - case 0x43: disk_1343(regs, drive_g); break; - case 0x44: disk_1344(regs, drive_g); break; - case 0x45: disk_1345(regs, drive_g); break; - case 0x46: disk_1346(regs, drive_g); break; - case 0x47: disk_1347(regs, drive_g); break; - case 0x48: disk_1348(regs, drive_g); break; - case 0x49: disk_1349(regs, drive_g); break; - case 0x4e: disk_134e(regs, drive_g); break; - default: disk_13XX(regs, drive_g); break; - } -} - -static void -floppy_13(struct bregs *regs, struct drive_s *drive_g) + case 0x00: disk_1300(regs, drive_gf); break; + case 0x01: disk_1301(regs, drive_gf); break; + case 0x02: disk_1302(regs, drive_gf); break; + case 0x03: disk_1303(regs, drive_gf); break; + case 0x04: disk_1304(regs, drive_gf); break; + case 0x05: disk_1305(regs, drive_gf); break; + case 0x08: disk_1308(regs, drive_gf); break; + case 0x09: disk_1309(regs, drive_gf); break; + case 0x0c: disk_130c(regs, drive_gf); break; + case 0x0d: disk_130d(regs, drive_gf); break; + case 0x10: disk_1310(regs, drive_gf); break; + case 0x11: disk_1311(regs, drive_gf); break; + case 0x14: disk_1314(regs, drive_gf); break; + case 0x15: disk_1315(regs, drive_gf); break; + case 0x16: disk_1316(regs, drive_gf); break; + case 0x41: disk_1341(regs, drive_gf); break; + case 0x42: disk_1342(regs, drive_gf); break; + case 0x43: disk_1343(regs, drive_gf); break; + case 0x44: disk_1344(regs, drive_gf); break; + case 0x45: disk_1345(regs, drive_gf); break; + case 0x46: disk_1346(regs, drive_gf); break; + case 0x47: disk_1347(regs, drive_gf); break; + case 0x48: disk_1348(regs, drive_gf); break; + case 0x49: disk_1349(regs, drive_gf); break; + case 0x4e: disk_134e(regs, drive_gf); break; + default: disk_13XX(regs, drive_gf); break; + } +} + +static void +floppy_13(struct bregs *regs, struct drive_s *drive_gf) { // Only limited commands are supported on floppies. switch (regs->ah) { @@ -777,9 +775,9 @@ floppy_13(struct bregs *regs, struct drive_s *drive_g) case 0x08: case 0x15: case 0x16: - disk_13(regs, drive_g); + disk_13(regs, drive_gf); break; - default: disk_13XX(regs, drive_g); break; + default: disk_13XX(regs, drive_gf); break; } } @@ -798,21 +796,21 @@ handle_legacy_disk(struct bregs *regs, u8 extdrive) } if (extdrive < EXTSTART_HD) { - struct drive_s *drive_g = getDrive(EXTTYPE_FLOPPY, extdrive); - if (!drive_g) + struct drive_s *drive_gf = getDrive(EXTTYPE_FLOPPY, extdrive); + if (!drive_gf) goto fail; - floppy_13(regs, drive_g); + floppy_13(regs, drive_gf); return; } - struct drive_s *drive_g; + struct drive_s *drive_gf; if (extdrive >= EXTSTART_CD) - drive_g = getDrive(EXTTYPE_CD, extdrive - EXTSTART_CD); + drive_gf = getDrive(EXTTYPE_CD, extdrive - EXTSTART_CD); else - drive_g = getDrive(EXTTYPE_HD, extdrive - EXTSTART_HD); - if (!drive_g) + drive_gf = getDrive(EXTTYPE_HD, extdrive - EXTSTART_HD); + if (!drive_gf) goto fail; - disk_13(regs, drive_g); + disk_13(regs, drive_gf); return; fail: @@ -843,14 +841,13 @@ handle_13(struct bregs *regs) u8 emudrive = GET_LOW(CDEmu.emulated_extdrive); if (extdrive == emudrive) { // Access to an emulated drive. - struct drive_s *cdemu_g; - cdemu_g = GLOBALFLAT2GLOBAL(GET_GLOBAL(cdemu_drive_gf)); + struct drive_s *cdemu_gf = GET_GLOBAL(cdemu_drive_gf); if (regs->ah > 0x16) { // Only old-style commands supported. - disk_13XX(regs, cdemu_g); + disk_13XX(regs, cdemu_gf); return; } - disk_13(regs, cdemu_g); + disk_13(regs, cdemu_gf); return; } if (extdrive < EXTSTART_CD && ((emudrive ^ extdrive) & 0x80) == 0) diff --git a/src/hw/ahci.c b/src/hw/ahci.c index 82a6194..a4ef5c5 100644 --- a/src/hw/ahci.c +++ b/src/hw/ahci.c @@ -102,15 +102,15 @@ static void ahci_port_writel(struct ahci_ctrl_s *ctrl, u32 pnr, u32 reg, u32 val } // submit ahci command + wait for result -static int ahci_command(struct ahci_port_s *port, int iswrite, int isatapi, +static int ahci_command(struct ahci_port_s *port_gf, int iswrite, int isatapi, void *buffer, u32 bsize) { u32 val, status, success, flags, intbits, error; - struct ahci_ctrl_s *ctrl = GET_GLOBAL(port->ctrl); - struct ahci_cmd_s *cmd = GET_GLOBAL(port->cmd); - struct ahci_fis_s *fis = GET_GLOBAL(port->fis); - struct ahci_list_s *list = GET_GLOBAL(port->list); - u32 pnr = GET_GLOBAL(port->pnr); + struct ahci_ctrl_s *ctrl = GET_GLOBALFLAT(port_gf->ctrl); + struct ahci_cmd_s *cmd = GET_GLOBALFLAT(port_gf->cmd); + struct ahci_fis_s *fis = GET_GLOBALFLAT(port_gf->fis); + struct ahci_list_s *list = GET_GLOBALFLAT(port_gf->list); + u32 pnr = GET_GLOBALFLAT(port_gf->pnr); SET_LOWFLAT(cmd->fis.reg, 0x27); SET_LOWFLAT(cmd->fis.pmp_type, (1 << 7)); /* cmd fis */ @@ -218,9 +218,9 @@ int ahci_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) if (! CONFIG_AHCI) return 0; - struct ahci_port_s *port = container_of( - op->drive_g, struct ahci_port_s, drive); - struct ahci_cmd_s *cmd = GET_GLOBAL(port->cmd); + struct ahci_port_s *port_gf = container_of( + op->drive_gf, struct ahci_port_s, drive); + struct ahci_cmd_s *cmd = GET_GLOBALFLAT(port_gf->cmd); u8 *atapi = cdbcmd; int i, rc; @@ -228,7 +228,7 @@ int ahci_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) for (i = 0; i < CDROM_CDB_SIZE; i++) { SET_LOWFLAT(cmd->atapi[i], atapi[i]); } - rc = ahci_command(port, 0, 1, op->buf_fl, + rc = ahci_command(port_gf, 0, 1, op->buf_fl, op->count * blocksize); if (rc < 0) return DISK_RET_EBADTRACK; @@ -239,13 +239,13 @@ int ahci_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) static int ahci_disk_readwrite_aligned(struct disk_op_s *op, int iswrite) { - struct ahci_port_s *port = container_of( - op->drive_g, struct ahci_port_s, drive); - struct ahci_cmd_s *cmd = GET_GLOBAL(port->cmd); + struct ahci_port_s *port_gf = container_of( + op->drive_gf, struct ahci_port_s, drive); + struct ahci_cmd_s *cmd = GET_GLOBALFLAT(port_gf->cmd); int rc; sata_prep_readwrite(&cmd->fis, op, iswrite); - rc = ahci_command(port, iswrite, 0, op->buf_fl, + rc = ahci_command(port_gf, iswrite, 0, op->buf_fl, op->count * DISK_SECTOR_SIZE); dprintf(8, "ahci disk %s, lba %6x, count %3x, buf %p, rc %d\n", iswrite ? "write" : "read", (u32)op->lba, op->count, op->buf_fl, rc); diff --git a/src/hw/ata.c b/src/hw/ata.c index e5ef685..de2a919 100644 --- a/src/hw/ata.c +++ b/src/hw/ata.c @@ -6,7 +6,7 @@ // This file may be distributed under the terms of the GNU LGPLv3 license. #include "ata.h" // ATA_CB_STAT -#include "biosvar.h" // GET_GLOBAL +#include "biosvar.h" // GET_GLOBALFLAT #include "block.h" // struct drive_s #include "blockcmd.h" // CDB_CMD_READ_10 #include "byteorder.h" // be16_to_cpu @@ -80,14 +80,14 @@ ndelay_await_not_bsy(u16 iobase1) // Reset a drive static void -ata_reset(struct atadrive_s *adrive_g) +ata_reset(struct atadrive_s *adrive_gf) { - struct ata_channel_s *chan_gf = GET_GLOBAL(adrive_g->chan_gf); - u8 slave = GET_GLOBAL(adrive_g->slave); + struct ata_channel_s *chan_gf = GET_GLOBALFLAT(adrive_gf->chan_gf); + u8 slave = GET_GLOBALFLAT(adrive_gf->slave); u16 iobase1 = GET_GLOBALFLAT(chan_gf->iobase1); u16 iobase2 = GET_GLOBALFLAT(chan_gf->iobase2); - dprintf(6, "ata_reset drive=%p\n", &adrive_g->drive); + dprintf(6, "ata_reset drive=%p\n", &adrive_gf->drive); // Pulse SRST outb(ATA_CB_DC_HD15 | ATA_CB_DC_NIEN | ATA_CB_DC_SRST, iobase2+ATA_CB_DC); udelay(5); @@ -120,7 +120,7 @@ ata_reset(struct atadrive_s *adrive_g) } // On a user-reset request, wait for RDY if it is an ATA device. - u8 type=GET_GLOBAL(adrive_g->drive.type); + u8 type=GET_GLOBALFLAT(adrive_gf->drive.type); if (type == DTYPE_ATA) status = await_rdy(iobase1); @@ -133,10 +133,10 @@ done: // Check for drive RDY for 16bit interface command. static int -isready(struct atadrive_s *adrive_g) +isready(struct atadrive_s *adrive_gf) { // Read the status from controller - struct ata_channel_s *chan_gf = GET_GLOBAL(adrive_g->chan_gf); + struct ata_channel_s *chan_gf = GET_GLOBALFLAT(adrive_gf->chan_gf); u16 iobase1 = GET_GLOBALFLAT(chan_gf->iobase1); u8 status = inb(iobase1 + ATA_CB_STAT); if ((status & (ATA_CB_STAT_BSY|ATA_CB_STAT_RDY)) == ATA_CB_STAT_RDY) @@ -167,10 +167,10 @@ struct ata_pio_command { // Send an ata command to the drive. static int -send_cmd(struct atadrive_s *adrive_g, struct ata_pio_command *cmd) +send_cmd(struct atadrive_s *adrive_gf, struct ata_pio_command *cmd) { - struct ata_channel_s *chan_gf = GET_GLOBAL(adrive_g->chan_gf); - u8 slave = GET_GLOBAL(adrive_g->slave); + struct ata_channel_s *chan_gf = GET_GLOBALFLAT(adrive_gf->chan_gf); + u8 slave = GET_GLOBALFLAT(adrive_gf->slave); u16 iobase1 = GET_GLOBALFLAT(chan_gf->iobase1); // Select device @@ -229,16 +229,16 @@ ata_wait_data(u16 iobase1) // Send an ata command that does not transfer any further data. int -ata_cmd_nondata(struct atadrive_s *adrive_g, struct ata_pio_command *cmd) +ata_cmd_nondata(struct atadrive_s *adrive_gf, struct ata_pio_command *cmd) { - struct ata_channel_s *chan_gf = GET_GLOBAL(adrive_g->chan_gf); + struct ata_channel_s *chan_gf = GET_GLOBALFLAT(adrive_gf->chan_gf); u16 iobase1 = GET_GLOBALFLAT(chan_gf->iobase1); u16 iobase2 = GET_GLOBALFLAT(chan_gf->iobase2); // Disable interrupts outb(ATA_CB_DC_HD15 | ATA_CB_DC_NIEN, iobase2 + ATA_CB_DC); - int ret = send_cmd(adrive_g, cmd); + int ret = send_cmd(adrive_gf, cmd); if (ret) goto fail; ret = ndelay_await_not_bsy(iobase1); @@ -270,16 +270,16 @@ fail: ****************************************************************/ // Transfer 'op->count' blocks (of 'blocksize' bytes) to/from drive -// 'op->drive_g'. +// 'op->drive_gf'. static int ata_pio_transfer(struct disk_op_s *op, int iswrite, int blocksize) { dprintf(16, "ata_pio_transfer id=%p write=%d count=%d bs=%d buf=%p\n" - , op->drive_g, iswrite, op->count, blocksize, op->buf_fl); + , op->drive_gf, iswrite, op->count, blocksize, op->buf_fl); - struct atadrive_s *adrive_g = container_of( - op->drive_g, struct atadrive_s, drive); - struct ata_channel_s *chan_gf = GET_GLOBAL(adrive_g->chan_gf); + struct atadrive_s *adrive_gf = container_of( + op->drive_gf, struct atadrive_s, drive); + struct ata_channel_s *chan_gf = GET_GLOBALFLAT(adrive_gf->chan_gf); u16 iobase1 = GET_GLOBALFLAT(chan_gf->iobase1); u16 iobase2 = GET_GLOBALFLAT(chan_gf->iobase2); int count = op->count; @@ -288,14 +288,14 @@ ata_pio_transfer(struct disk_op_s *op, int iswrite, int blocksize) for (;;) { if (iswrite) { // Write data to controller - dprintf(16, "Write sector id=%p dest=%p\n", op->drive_g, buf_fl); + dprintf(16, "Write sector id=%p dest=%p\n", op->drive_gf, buf_fl); if (CONFIG_ATA_PIO32) outsl_fl(iobase1, buf_fl, blocksize / 4); else outsw_fl(iobase1, buf_fl, blocksize / 2); } else { // Read data from controller - dprintf(16, "Read sector id=%p dest=%p\n", op->drive_g, buf_fl); + dprintf(16, "Read sector id=%p dest=%p\n", op->drive_gf, buf_fl); if (CONFIG_ATA_PIO32) insl_fl(iobase1, buf_fl, blocksize / 4); else @@ -364,9 +364,9 @@ ata_try_dma(struct disk_op_s *op, int iswrite, int blocksize) if (dest & 1) // Need minimum alignment of 1. return -1; - struct atadrive_s *adrive_g = container_of( - op->drive_g, struct atadrive_s, drive); - struct ata_channel_s *chan_gf = GET_GLOBAL(adrive_g->chan_gf); + struct atadrive_s *adrive_gf = container_of( + op->drive_gf, struct atadrive_s, drive); + struct ata_channel_s *chan_gf = GET_GLOBALFLAT(adrive_gf->chan_gf); u16 iomaster = GET_GLOBALFLAT(chan_gf->iomaster); if (! iomaster) return -1; @@ -412,11 +412,11 @@ ata_dma_transfer(struct disk_op_s *op) { if (! CONFIG_ATA_DMA) return -1; - dprintf(16, "ata_dma_transfer id=%p buf=%p\n", op->drive_g, op->buf_fl); + dprintf(16, "ata_dma_transfer id=%p buf=%p\n", op->drive_gf, op->buf_fl); - struct atadrive_s *adrive_g = container_of( - op->drive_g, struct atadrive_s, drive); - struct ata_channel_s *chan_gf = GET_GLOBAL(adrive_g->chan_gf); + struct atadrive_s *adrive_gf = container_of( + op->drive_gf, struct atadrive_s, drive); + struct ata_channel_s *chan_gf = GET_GLOBALFLAT(adrive_gf->chan_gf); u16 iomaster = GET_GLOBALFLAT(chan_gf->iomaster); // Start bus-master controller. @@ -465,16 +465,16 @@ ata_dma_transfer(struct disk_op_s *op) static int ata_pio_cmd_data(struct disk_op_s *op, int iswrite, struct ata_pio_command *cmd) { - struct atadrive_s *adrive_g = container_of( - op->drive_g, struct atadrive_s, drive); - struct ata_channel_s *chan_gf = GET_GLOBAL(adrive_g->chan_gf); + struct atadrive_s *adrive_gf = container_of( + op->drive_gf, struct atadrive_s, drive); + struct ata_channel_s *chan_gf = GET_GLOBALFLAT(adrive_gf->chan_gf); u16 iobase1 = GET_GLOBALFLAT(chan_gf->iobase1); u16 iobase2 = GET_GLOBALFLAT(chan_gf->iobase2); // Disable interrupts outb(ATA_CB_DC_HD15 | ATA_CB_DC_NIEN, iobase2 + ATA_CB_DC); - int ret = send_cmd(adrive_g, cmd); + int ret = send_cmd(adrive_gf, cmd); if (ret) goto fail; ret = ata_wait_data(iobase1); @@ -494,9 +494,9 @@ ata_dma_cmd_data(struct disk_op_s *op, struct ata_pio_command *cmd) { if (! CONFIG_ATA_DMA) return -1; - struct atadrive_s *adrive_g = container_of( - op->drive_g, struct atadrive_s, drive); - int ret = send_cmd(adrive_g, cmd); + struct atadrive_s *adrive_gf = container_of( + op->drive_gf, struct atadrive_s, drive); + int ret = send_cmd(adrive_gf, cmd); if (ret) return ret; return ata_dma_transfer(op); @@ -558,18 +558,18 @@ process_ata_op(struct disk_op_s *op) if (!CONFIG_ATA) return 0; - struct atadrive_s *adrive_g = container_of( - op->drive_g, struct atadrive_s, drive); + struct atadrive_s *adrive_gf = container_of( + op->drive_gf, struct atadrive_s, drive); switch (op->command) { case CMD_READ: return ata_readwrite(op, 0); case CMD_WRITE: return ata_readwrite(op, 1); case CMD_RESET: - ata_reset(adrive_g); + ata_reset(adrive_gf); return DISK_RET_SUCCESS; case CMD_ISREADY: - return isready(adrive_g); + return isready(adrive_gf); case CMD_FORMAT: case CMD_VERIFY: case CMD_SEEK: @@ -594,9 +594,9 @@ atapi_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) if (! CONFIG_ATA) return 0; - struct atadrive_s *adrive_g = container_of( - op->drive_g, struct atadrive_s, drive); - struct ata_channel_s *chan_gf = GET_GLOBAL(adrive_g->chan_gf); + struct atadrive_s *adrive_gf = container_of( + op->drive_gf, struct atadrive_s, drive); + struct ata_channel_s *chan_gf = GET_GLOBALFLAT(adrive_gf->chan_gf); u16 iobase1 = GET_GLOBALFLAT(chan_gf->iobase1); u16 iobase2 = GET_GLOBALFLAT(chan_gf->iobase2); @@ -609,7 +609,7 @@ atapi_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) // Disable interrupts outb(ATA_CB_DC_HD15 | ATA_CB_DC_NIEN, iobase2 + ATA_CB_DC); - int ret = send_cmd(adrive_g, &cmd); + int ret = send_cmd(adrive_gf, &cmd); if (ret) goto fail; ret = ata_wait_data(iobase1); @@ -659,13 +659,13 @@ fail: // Send an identify device or identify device packet command. static int -send_ata_identity(struct atadrive_s *adrive_g, u16 *buffer, int command) +send_ata_identity(struct atadrive_s *adrive, u16 *buffer, int command) { memset(buffer, 0, DISK_SECTOR_SIZE); struct disk_op_s dop; memset(&dop, 0, sizeof(dop)); - dop.drive_g = &adrive_g->drive; + dop.drive_gf = &adrive->drive; dop.count = 1; dop.lba = 1; dop.buf_fl = MAKE_FLATPTR(GET_SEG(SS), buffer); @@ -709,17 +709,17 @@ ata_extract_model(char *model, u32 size, u16 *buffer) static struct atadrive_s * init_atadrive(struct atadrive_s *dummy, u16 *buffer) { - struct atadrive_s *adrive_g = malloc_fseg(sizeof(*adrive_g)); - if (!adrive_g) { + struct atadrive_s *adrive = malloc_fseg(sizeof(*adrive)); + if (!adrive) { warn_noalloc(); return NULL; } - memset(adrive_g, 0, sizeof(*adrive_g)); - adrive_g->chan_gf = dummy->chan_gf; - adrive_g->slave = dummy->slave; - adrive_g->drive.cntl_id = adrive_g->chan_gf->chanid * 2 + dummy->slave; - adrive_g->drive.removable = (buffer[0] & 0x80) ? 1 : 0; - return adrive_g; + memset(adrive, 0, sizeof(*adrive)); + adrive->chan_gf = dummy->chan_gf; + adrive->slave = dummy->slave; + adrive->drive.cntl_id = adrive->chan_gf->chanid * 2 + dummy->slave; + adrive->drive.removable = (buffer[0] & 0x80) ? 1 : 0; + return adrive; } // Detect if the given drive is an atapi - initialize it if so. @@ -732,17 +732,17 @@ init_drive_atapi(struct atadrive_s *dummy, u16 *buffer) return NULL; // Success - setup as ATAPI. - struct atadrive_s *adrive_g = init_atadrive(dummy, buffer); - if (!adrive_g) + struct atadrive_s *adrive = init_atadrive(dummy, buffer); + if (!adrive) return NULL; - adrive_g->drive.type = DTYPE_ATA_ATAPI; - adrive_g->drive.blksize = CDROM_SECTOR_SIZE; - adrive_g->drive.sectors = (u64)-1; + adrive->drive.type = DTYPE_ATA_ATAPI; + adrive->drive.blksize = CDROM_SECTOR_SIZE; + adrive->drive.sectors = (u64)-1; u8 iscd = ((buffer[0] >> 8) & 0x1f) == 0x05; char model[MAXMODEL+1]; char *desc = znprintf(MAXDESCSIZE , "DVD/CD [ata%d-%d: %s ATAPI-%d %s]" - , adrive_g->chan_gf->chanid, adrive_g->slave + , adrive->chan_gf->chanid, adrive->slave , ata_extract_model(model, MAXMODEL, buffer) , ata_extract_version(buffer) , (iscd ? "DVD/CD" : "Device")); @@ -750,13 +750,13 @@ init_drive_atapi(struct atadrive_s *dummy, u16 *buffer) // fill cdidmap if (iscd) { - int prio = bootprio_find_ata_device(adrive_g->chan_gf->pci_tmp, - adrive_g->chan_gf->chanid, - adrive_g->slave); - boot_add_cd(&adrive_g->drive, desc, prio); + int prio = bootprio_find_ata_device(adrive->chan_gf->pci_tmp, + adrive->chan_gf->chanid, + adrive->slave); + boot_add_cd(&adrive->drive, desc, prio); } - return adrive_g; + return adrive; } // Detect if the given drive is a regular ata drive - initialize it if so. @@ -769,22 +769,22 @@ init_drive_ata(struct atadrive_s *dummy, u16 *buffer) return NULL; // Success - setup as ATA. - struct atadrive_s *adrive_g = init_atadrive(dummy, buffer); - if (!adrive_g) + struct atadrive_s *adrive = init_atadrive(dummy, buffer); + if (!adrive) return NULL; - adrive_g->drive.type = DTYPE_ATA; - adrive_g->drive.blksize = DISK_SECTOR_SIZE; + adrive->drive.type = DTYPE_ATA; + adrive->drive.blksize = DISK_SECTOR_SIZE; - adrive_g->drive.pchs.cylinder = buffer[1]; - adrive_g->drive.pchs.head = buffer[3]; - adrive_g->drive.pchs.sector = buffer[6]; + adrive->drive.pchs.cylinder = buffer[1]; + adrive->drive.pchs.head = buffer[3]; + adrive->drive.pchs.sector = buffer[6]; u64 sectors; if (buffer[83] & (1 << 10)) // word 83 - lba48 support sectors = *(u64*)&buffer[100]; // word 100-103 else sectors = *(u32*)&buffer[60]; // word 60 and word 61 - adrive_g->drive.sectors = sectors; + adrive->drive.sectors = sectors; u64 adjsize = sectors >> 11; char adjprefix = 'M'; if (adjsize >= (1 << 16)) { @@ -794,19 +794,19 @@ init_drive_ata(struct atadrive_s *dummy, u16 *buffer) char model[MAXMODEL+1]; char *desc = znprintf(MAXDESCSIZE , "ata%d-%d: %s ATA-%d Hard-Disk (%u %ciBytes)" - , adrive_g->chan_gf->chanid, adrive_g->slave + , adrive->chan_gf->chanid, adrive->slave , ata_extract_model(model, MAXMODEL, buffer) , ata_extract_version(buffer) , (u32)adjsize, adjprefix); dprintf(1, "%s\n", desc); - int prio = bootprio_find_ata_device(adrive_g->chan_gf->pci_tmp, - adrive_g->chan_gf->chanid, - adrive_g->slave); + int prio = bootprio_find_ata_device(adrive->chan_gf->pci_tmp, + adrive->chan_gf->chanid, + adrive->slave); // Register with bcv system. - boot_add_hd(&adrive_g->drive, desc, prio); + boot_add_hd(&adrive->drive, desc, prio); - return adrive_g; + return adrive; } static u32 SpinupEnd; @@ -883,8 +883,8 @@ ata_detect(void *data) // check for ATAPI u16 buffer[256]; - struct atadrive_s *adrive_g = init_drive_atapi(&dummy, buffer); - if (!adrive_g) { + struct atadrive_s *adrive = init_drive_atapi(&dummy, buffer); + if (!adrive) { // Didn't find an ATAPI drive - look for ATA drive. u8 st = inb(iobase1+ATA_CB_STAT); if (!st) @@ -897,8 +897,8 @@ ata_detect(void *data) continue; // check for ATA. - adrive_g = init_drive_ata(&dummy, buffer); - if (!adrive_g) + adrive = init_drive_ata(&dummy, buffer); + if (!adrive) // No ATA drive found continue; } diff --git a/src/hw/blockcmd.c b/src/hw/blockcmd.c index 7b07ab6..96950f2 100644 --- a/src/hw/blockcmd.c +++ b/src/hw/blockcmd.c @@ -7,7 +7,7 @@ #include "ahci.h" // atapi_cmd_data #include "ata.h" // atapi_cmd_data -#include "biosvar.h" // GET_GLOBAL +#include "biosvar.h" // GET_GLOBALFLAT #include "block.h" // struct disk_op_s #include "blockcmd.h" // struct cdb_request_sense #include "byteorder.h" // be32_to_cpu @@ -27,7 +27,7 @@ static int cdb_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) { - u8 type = GET_GLOBAL(op->drive_g->type); + u8 type = GET_GLOBALFLAT(op->drive_gf->type); switch (type) { case DTYPE_ATA_ATAPI: return atapi_cmd_data(op, cdbcmd, blocksize); @@ -64,7 +64,7 @@ cdb_is_read(u8 *cdbcmd, u16 blocksize) int scsi_is_ready(struct disk_op_s *op) { - dprintf(6, "scsi_is_ready (drive=%p)\n", op->drive_g); + dprintf(6, "scsi_is_ready (drive=%p)\n", op->drive_gf); /* Retry TEST UNIT READY for 5 seconds unless MEDIUM NOT PRESENT is * reported by the device. If the device reports "IN PROGRESS", @@ -111,7 +111,7 @@ scsi_drive_setup(struct drive_s *drive, const char *s, int prio) { struct disk_op_s dop; memset(&dop, 0, sizeof(dop)); - dop.drive_g = drive; + dop.drive_gf = drive; struct cdbres_inquiry data; int ret = cdb_get_inquiry(&dop, &data); if (ret) @@ -268,7 +268,7 @@ cdb_read(struct disk_op_s *op) cmd.command = CDB_CMD_READ_10; cmd.lba = cpu_to_be32(op->lba); cmd.count = cpu_to_be16(op->count); - return cdb_cmd_data(op, &cmd, GET_GLOBAL(op->drive_g->blksize)); + return cdb_cmd_data(op, &cmd, GET_GLOBALFLAT(op->drive_gf->blksize)); } // Write sectors. @@ -280,5 +280,5 @@ cdb_write(struct disk_op_s *op) cmd.command = CDB_CMD_WRITE_10; cmd.lba = cpu_to_be32(op->lba); cmd.count = cpu_to_be16(op->count); - return cdb_cmd_data(op, &cmd, GET_GLOBAL(op->drive_g->blksize)); + return cdb_cmd_data(op, &cmd, GET_GLOBALFLAT(op->drive_gf->blksize)); } diff --git a/src/hw/esp-scsi.c b/src/hw/esp-scsi.c index 118a1f5..982c1d5 100644 --- a/src/hw/esp-scsi.c +++ b/src/hw/esp-scsi.c @@ -10,7 +10,7 @@ // // This file may be distributed under the terms of the GNU LGPLv3 license. -#include "biosvar.h" // GET_GLOBAL +#include "biosvar.h" // GET_GLOBALFLAT #include "block.h" // struct drive_s #include "blockcmd.h" // scsi_drive_setup #include "config.h" // CONFIG_* @@ -77,10 +77,10 @@ esp_scsi_dma(u32 iobase, u32 buf, u32 len, int read) } static int -esp_scsi_cmd(struct esp_lun_s *llun, struct disk_op_s *op, +esp_scsi_cmd(struct esp_lun_s *llun_gf, struct disk_op_s *op, u8 *cdbcmd, u16 target, u16 lun, u16 blocksize) { - u32 iobase = GET_GLOBAL(llun->iobase); + u32 iobase = GET_GLOBALFLAT(llun_gf->iobase); int i, state; u8 status; @@ -150,11 +150,12 @@ esp_scsi_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) if (!CONFIG_ESP_SCSI) return DISK_RET_EBADTRACK; - struct esp_lun_s *llun = - container_of(op->drive_g, struct esp_lun_s, drive); + struct esp_lun_s *llun_gf = + container_of(op->drive_gf, struct esp_lun_s, drive); - return esp_scsi_cmd(llun, op, cdbcmd, - GET_GLOBAL(llun->target), GET_GLOBAL(llun->lun), + return esp_scsi_cmd(llun_gf, op, cdbcmd, + GET_GLOBALFLAT(llun_gf->target), + GET_GLOBALFLAT(llun_gf->lun), blocksize); } diff --git a/src/hw/floppy.c b/src/hw/floppy.c index 7f63bcc..e73b303 100644 --- a/src/hw/floppy.c +++ b/src/hw/floppy.c @@ -103,33 +103,33 @@ init_floppy(int floppyid, int ftype) return NULL; } - struct drive_s *drive_g = malloc_fseg(sizeof(*drive_g)); - if (!drive_g) { + struct drive_s *drive = malloc_fseg(sizeof(*drive)); + if (!drive) { warn_noalloc(); return NULL; } - memset(drive_g, 0, sizeof(*drive_g)); - drive_g->cntl_id = floppyid; - drive_g->type = DTYPE_FLOPPY; - drive_g->blksize = DISK_SECTOR_SIZE; - drive_g->floppy_type = ftype; - drive_g->sectors = (u64)-1; - - memcpy(&drive_g->lchs, &FloppyInfo[ftype].chs + memset(drive, 0, sizeof(*drive)); + drive->cntl_id = floppyid; + drive->type = DTYPE_FLOPPY; + drive->blksize = DISK_SECTOR_SIZE; + drive->floppy_type = ftype; + drive->sectors = (u64)-1; + + memcpy(&drive->lchs, &FloppyInfo[ftype].chs , sizeof(FloppyInfo[ftype].chs)); - return drive_g; + return drive; } static void addFloppy(int floppyid, int ftype) { - struct drive_s *drive_g = init_floppy(floppyid, ftype); - if (!drive_g) + struct drive_s *drive = init_floppy(floppyid, ftype); + if (!drive) return; char *desc = znprintf(MAXDESCSIZE, "Floppy [drive %c]", 'A' + floppyid); struct pci_device *pci = pci_find_class(PCI_CLASS_BRIDGE_ISA); /* isa-to-pci bridge */ int prio = bootprio_find_fdc_device(pci, PORT_FD_BASE, floppyid); - boot_add_floppy(drive_g, desc, prio); + boot_add_floppy(drive, desc, prio); } void @@ -376,10 +376,10 @@ floppy_drive_readid(u8 floppyid, u8 data_rate, u8 head) } static int -floppy_media_sense(struct drive_s *drive_g) +floppy_media_sense(struct drive_s *drive_gf) { - u8 ftype = GET_GLOBAL(drive_g->floppy_type), stype = ftype; - u8 floppyid = GET_GLOBAL(drive_g->cntl_id); + u8 ftype = GET_GLOBALFLAT(drive_gf->floppy_type), stype = ftype; + u8 floppyid = GET_GLOBALFLAT(drive_gf->cntl_id); u8 data_rate = GET_GLOBAL(FloppyInfo[stype].data_rate); int ret = floppy_drive_readid(floppyid, data_rate, 0); @@ -418,9 +418,9 @@ floppy_media_sense(struct drive_s *drive_g) } static int -check_recal_drive(struct drive_s *drive_g) +check_recal_drive(struct drive_s *drive_gf) { - u8 floppyid = GET_GLOBAL(drive_g->cntl_id); + u8 floppyid = GET_GLOBALFLAT(drive_gf->cntl_id); if ((GET_BDA(floppy_recalibration_status) & (1<<floppyid)) && (GET_BDA(floppy_media_state[floppyid]) & FMS_MEDIA_DRIVE_ESTABLISHED)) // Media is known. @@ -432,7 +432,7 @@ check_recal_drive(struct drive_s *drive_g) return ret; // Sense media. - return floppy_media_sense(drive_g); + return floppy_media_sense(drive_gf); } @@ -444,7 +444,7 @@ check_recal_drive(struct drive_s *drive_g) static int floppy_cmd(struct disk_op_s *op, int blocksize, struct floppy_pio_s *pio) { - int ret = check_recal_drive(op->drive_g); + int ret = check_recal_drive(op->drive_gf); if (ret) return ret; @@ -496,11 +496,11 @@ lba2chs(struct disk_op_s *op) u32 lba = op->lba; u32 tmp = lba + 1; - u16 nls = GET_GLOBAL(op->drive_g->lchs.sector); + u16 nls = GET_GLOBALFLAT(op->drive_gf->lchs.sector); res.sector = tmp % nls; tmp /= nls; - u16 nlh = GET_GLOBAL(op->drive_g->lchs.head); + u16 nlh = GET_GLOBALFLAT(op->drive_gf->lchs.head); res.head = tmp % nlh; tmp /= nlh; @@ -513,7 +513,7 @@ lba2chs(struct disk_op_s *op) static int floppy_reset(struct disk_op_s *op) { - u8 floppyid = GET_GLOBAL(op->drive_g->cntl_id); + u8 floppyid = GET_GLOBALFLAT(op->drive_gf->cntl_id); SET_BDA(floppy_recalibration_status, 0); SET_BDA(floppy_media_state[0], 0); SET_BDA(floppy_media_state[1], 0); @@ -531,7 +531,7 @@ floppy_read(struct disk_op_s *op) struct chs_s chs = lba2chs(op); // send read-normal-data command (9 bytes) to controller - u8 floppyid = GET_GLOBAL(op->drive_g->cntl_id); + u8 floppyid = GET_GLOBALFLAT(op->drive_gf->cntl_id); struct floppy_pio_s pio; pio.cmdlen = 9; pio.data[0] = 0xe6; // e6: read normal data @@ -560,7 +560,7 @@ floppy_write(struct disk_op_s *op) struct chs_s chs = lba2chs(op); // send write-normal-data command (9 bytes) to controller - u8 floppyid = GET_GLOBAL(op->drive_g->cntl_id); + u8 floppyid = GET_GLOBALFLAT(op->drive_gf->cntl_id); struct floppy_pio_s pio; pio.cmdlen = 9; pio.data[0] = 0xc5; // c5: write normal data @@ -586,14 +586,14 @@ fail: static int floppy_verify(struct disk_op_s *op) { - int res = check_recal_drive(op->drive_g); + int res = check_recal_drive(op->drive_gf); if (res) goto fail; struct chs_s chs = lba2chs(op); // ??? should track be new val from return_status[3] ? - u8 floppyid = GET_GLOBAL(op->drive_g->cntl_id); + u8 floppyid = GET_GLOBALFLAT(op->drive_gf->cntl_id); set_diskette_current_cyl(floppyid, chs.cylinder); return DISK_RET_SUCCESS; fail: @@ -608,7 +608,7 @@ floppy_format(struct disk_op_s *op) u8 head = op->lba; // send format-track command (6 bytes) to controller - u8 floppyid = GET_GLOBAL(op->drive_g->cntl_id); + u8 floppyid = GET_GLOBALFLAT(op->drive_gf->cntl_id); struct floppy_pio_s pio; pio.cmdlen = 6; pio.data[0] = 0x4d; // 4d: format track diff --git a/src/hw/lsi-scsi.c b/src/hw/lsi-scsi.c index 021aa61..b1d6bbf 100644 --- a/src/hw/lsi-scsi.c +++ b/src/hw/lsi-scsi.c @@ -10,7 +10,7 @@ // // This file may be distributed under the terms of the GNU LGPLv3 license. -#include "biosvar.h" // GET_GLOBAL +#include "biosvar.h" // GET_GLOBALFLAT #include "block.h" // struct drive_s #include "blockcmd.h" // scsi_drive_setup #include "config.h" // CONFIG_* @@ -51,10 +51,10 @@ struct lsi_lun_s { }; static int -lsi_scsi_cmd(struct lsi_lun_s *llun, struct disk_op_s *op, +lsi_scsi_cmd(struct lsi_lun_s *llun_gf, struct disk_op_s *op, void *cdbcmd, u16 target, u16 lun, u16 blocksize) { - u32 iobase = GET_GLOBAL(llun->iobase); + u32 iobase = GET_GLOBALFLAT(llun_gf->iobase); u32 dma = ((cdb_is_read(cdbcmd, blocksize) ? 0x01000000 : 0x00000000) | (op->count * blocksize)); u8 msgout[] = { @@ -128,11 +128,12 @@ lsi_scsi_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) if (!CONFIG_LSI_SCSI) return DISK_RET_EBADTRACK; - struct lsi_lun_s *llun = - container_of(op->drive_g, struct lsi_lun_s, drive); + struct lsi_lun_s *llun_gf = + container_of(op->drive_gf, struct lsi_lun_s, drive); - return lsi_scsi_cmd(llun, op, cdbcmd, - GET_GLOBAL(llun->target), GET_GLOBAL(llun->lun), + return lsi_scsi_cmd(llun_gf, op, cdbcmd, + GET_GLOBALFLAT(llun_gf->target), + GET_GLOBALFLAT(llun_gf->lun), blocksize); } diff --git a/src/hw/megasas.c b/src/hw/megasas.c index ebc49f9..3ded877 100644 --- a/src/hw/megasas.c +++ b/src/hw/megasas.c @@ -10,7 +10,7 @@ // // This file may be distributed under the terms of the GNU LGPLv3 license. -#include "biosvar.h" // GET_GLOBAL +#include "biosvar.h" // GET_GLOBALFLAT #include "block.h" // struct drive_s #include "blockcmd.h" // scsi_drive_setup #include "config.h" // CONFIG_* @@ -159,11 +159,11 @@ static int megasas_fire_cmd(u16 pci_id, u32 ioaddr, int megasas_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) { - struct megasas_lun_s *mlun = - container_of(op->drive_g, struct megasas_lun_s, drive); + struct megasas_lun_s *mlun_gf = + container_of(op->drive_gf, struct megasas_lun_s, drive); u8 *cdb = cdbcmd; - struct megasas_cmd_frame *frame = GET_GLOBAL(mlun->frame); - u16 pci_id = GET_GLOBAL(mlun->pci->device); + struct megasas_cmd_frame *frame = GET_GLOBALFLAT(mlun_gf->frame); + u16 pci_id = GET_GLOBALFLAT(mlun_gf->pci->device); int i; if (!CONFIG_MEGASAS) @@ -172,8 +172,8 @@ megasas_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) memset_fl(frame, 0, sizeof(*frame)); SET_LOWFLAT(frame->cmd, MFI_CMD_LD_SCSI_IO); SET_LOWFLAT(frame->cmd_status, 0xFF); - SET_LOWFLAT(frame->target_id, GET_GLOBAL(mlun->target)); - SET_LOWFLAT(frame->lun, GET_GLOBAL(mlun->lun)); + SET_LOWFLAT(frame->target_id, GET_GLOBALFLAT(mlun_gf->target)); + SET_LOWFLAT(frame->lun, GET_GLOBALFLAT(mlun_gf->lun)); SET_LOWFLAT(frame->flags, 0x0001); SET_LOWFLAT(frame->data_xfer_len, op->count * blocksize); SET_LOWFLAT(frame->cdb_len, 16); @@ -191,7 +191,7 @@ megasas_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) } SET_LOWFLAT(frame->context, (u32)frame); - if (megasas_fire_cmd(pci_id, GET_GLOBAL(mlun->iobase), frame) == 0) + if (megasas_fire_cmd(pci_id, GET_GLOBALFLAT(mlun_gf->iobase), frame) == 0) return DISK_RET_SUCCESS; dprintf(2, "pthru cmd 0x%x failed\n", cdb[0]); diff --git a/src/hw/pvscsi.c b/src/hw/pvscsi.c index 740a74b..6911230 100644 --- a/src/hw/pvscsi.c +++ b/src/hw/pvscsi.c @@ -7,7 +7,7 @@ // // This file may be distributed under the terms of the GNU LGPLv3 license. -#include "biosvar.h" // GET_GLOBAL +#include "biosvar.h" // GET_GLOBALFLAT #include "block.h" // struct drive_s #include "blockcmd.h" // scsi_drive_setup #include "config.h" // CONFIG_* @@ -234,10 +234,10 @@ pvscsi_get_rsp(struct PVSCSIRingsState *s, } static int -pvscsi_cmd(struct pvscsi_lun_s *plun, struct disk_op_s *op, +pvscsi_cmd(struct pvscsi_lun_s *plun_gf, struct disk_op_s *op, void *cdbcmd, u16 target, u16 lun, u16 blocksize) { - struct pvscsi_ring_dsc_s *ring_dsc = GET_GLOBAL(plun->ring_dsc); + struct pvscsi_ring_dsc_s *ring_dsc = GET_GLOBALFLAT(plun_gf->ring_dsc); struct PVSCSIRingsState *s = GET_LOWFLAT(ring_dsc->ring_state); u32 req_entries = GET_LOWFLAT(s->reqNumEntriesLog2); u32 cmp_entries = GET_LOWFLAT(s->cmpNumEntriesLog2); @@ -254,8 +254,8 @@ pvscsi_cmd(struct pvscsi_lun_s *plun, struct disk_op_s *op, req = GET_LOWFLAT(ring_dsc->ring_reqs) + (GET_LOWFLAT(s->reqProdIdx) & MASK(req_entries)); pvscsi_fill_req(s, req, target, lun, cdbcmd, blocksize, op); - pvscsi_kick_rw_io(GET_GLOBAL(plun->iobase)); - pvscsi_wait_intr_cmpl(GET_GLOBAL(plun->iobase)); + pvscsi_kick_rw_io(GET_GLOBALFLAT(plun_gf->iobase)); + pvscsi_wait_intr_cmpl(GET_GLOBALFLAT(plun_gf->iobase)); rsp = GET_LOWFLAT(ring_dsc->ring_cmps) + (GET_LOWFLAT(s->cmpConsIdx) & MASK(cmp_entries)); status = pvscsi_get_rsp(s, rsp); @@ -269,11 +269,12 @@ pvscsi_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) if (!CONFIG_PVSCSI) return DISK_RET_EBADTRACK; - struct pvscsi_lun_s *plun = - container_of(op->drive_g, struct pvscsi_lun_s, drive); + struct pvscsi_lun_s *plun_gf = + container_of(op->drive_gf, struct pvscsi_lun_s, drive); - return pvscsi_cmd(plun, op, cdbcmd, - GET_GLOBAL(plun->target), GET_GLOBAL(plun->lun), + return pvscsi_cmd(plun_gf, op, cdbcmd, + GET_GLOBALFLAT(plun_gf->target), + GET_GLOBALFLAT(plun_gf->lun), blocksize); } diff --git a/src/hw/ramdisk.c b/src/hw/ramdisk.c index eeddf25..81aed50 100644 --- a/src/hw/ramdisk.c +++ b/src/hw/ramdisk.c @@ -4,7 +4,7 @@ // // This file may be distributed under the terms of the GNU LGPLv3 license. -#include "biosvar.h" // GET_GLOBAL +#include "biosvar.h" // GET_GLOBALFLAT #include "block.h" // struct drive_s #include "bregs.h" // struct bregs #include "malloc.h" // malloc_fseg @@ -49,19 +49,19 @@ ramdisk_setup(void) return; // Setup driver. - struct drive_s *drive_g = init_floppy((u32)pos, ftype); - if (!drive_g) + struct drive_s *drive = init_floppy((u32)pos, ftype); + if (!drive) return; - drive_g->type = DTYPE_RAMDISK; + drive->type = DTYPE_RAMDISK; dprintf(1, "Mapping CBFS floppy %s to addr %p\n", filename, pos); char *desc = znprintf(MAXDESCSIZE, "Ramdisk [%s]", &filename[10]); - boot_add_floppy(drive_g, desc, bootprio_find_named_rom(filename, 0)); + boot_add_floppy(drive, desc, bootprio_find_named_rom(filename, 0)); } static int ramdisk_copy(struct disk_op_s *op, int iswrite) { - u32 offset = GET_GLOBAL(op->drive_g->cntl_id); + u32 offset = GET_GLOBALFLAT(op->drive_gf->cntl_id); offset += (u32)op->lba * DISK_SECTOR_SIZE; u64 opd = GDT_DATA | GDT_LIMIT(0xfffff) | GDT_BASE((u32)op->buf_fl); u64 ramd = GDT_DATA | GDT_LIMIT(0xfffff) | GDT_BASE(offset); diff --git a/src/hw/usb-msc.c b/src/hw/usb-msc.c index 8ee448f..7e2e440 100644 --- a/src/hw/usb-msc.c +++ b/src/hw/usb-msc.c @@ -4,7 +4,7 @@ // // This file may be distributed under the terms of the GNU LGPLv3 license. -#include "biosvar.h" // GET_GLOBAL +#include "biosvar.h" // GET_GLOBALFLAT #include "block.h" // DTYPE_USB #include "blockcmd.h" // cdb_read #include "config.h" // CONFIG_USB_MSC @@ -51,13 +51,13 @@ struct csw_s { } PACKED; static int -usb_msc_send(struct usbdrive_s *udrive_g, int dir, void *buf, u32 bytes) +usb_msc_send(struct usbdrive_s *udrive_gf, int dir, void *buf, u32 bytes) { struct usb_pipe *pipe; if (dir == USB_DIR_OUT) - pipe = GET_GLOBAL(udrive_g->bulkout); + pipe = GET_GLOBALFLAT(udrive_gf->bulkout); else - pipe = GET_GLOBAL(udrive_g->bulkin); + pipe = GET_GLOBALFLAT(udrive_gf->bulkin); return usb_send_bulk(pipe, dir, buf, bytes); } @@ -69,9 +69,9 @@ usb_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) return 0; dprintf(16, "usb_cmd_data id=%p write=%d count=%d bs=%d buf=%p\n" - , op->drive_g, 0, op->count, blocksize, op->buf_fl); - struct usbdrive_s *udrive_g = container_of( - op->drive_g, struct usbdrive_s, drive); + , op->drive_gf, 0, op->count, blocksize, op->buf_fl); + struct usbdrive_s *udrive_gf = container_of( + op->drive_gf, struct usbdrive_s, drive); // Setup command block wrapper. u32 bytes = blocksize * op->count; @@ -82,26 +82,26 @@ usb_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) cbw.dCBWTag = 999; // XXX cbw.dCBWDataTransferLength = bytes; cbw.bmCBWFlags = cdb_is_read(cdbcmd, blocksize) ? USB_DIR_IN : USB_DIR_OUT; - cbw.bCBWLUN = GET_GLOBAL(udrive_g->lun); + cbw.bCBWLUN = GET_GLOBALFLAT(udrive_gf->lun); cbw.bCBWCBLength = USB_CDB_SIZE; // Transfer cbw to device. - int ret = usb_msc_send(udrive_g, USB_DIR_OUT + int ret = usb_msc_send(udrive_gf, USB_DIR_OUT , MAKE_FLATPTR(GET_SEG(SS), &cbw), sizeof(cbw)); if (ret) goto fail; // Transfer data to/from device. if (bytes) { - ret = usb_msc_send(udrive_g, cbw.bmCBWFlags, op->buf_fl, bytes); + ret = usb_msc_send(udrive_gf, cbw.bmCBWFlags, op->buf_fl, bytes); if (ret) goto fail; } // Transfer csw info. struct csw_s csw; - ret = usb_msc_send(udrive_g, USB_DIR_IN - , MAKE_FLATPTR(GET_SEG(SS), &csw), sizeof(csw)); + ret = usb_msc_send(udrive_gf, USB_DIR_IN + , MAKE_FLATPTR(GET_SEG(SS), &csw), sizeof(csw)); if (ret) goto fail; @@ -142,22 +142,22 @@ usb_msc_lun_setup(struct usb_pipe *inpipe, struct usb_pipe *outpipe, struct usbdevice_s *usbdev, int lun) { // Allocate drive structure. - struct usbdrive_s *udrive_g = malloc_fseg(sizeof(*udrive_g)); - if (!udrive_g) { + struct usbdrive_s *drive = malloc_fseg(sizeof(*drive)); + if (!drive) { warn_noalloc(); return -1; } - memset(udrive_g, 0, sizeof(*udrive_g)); - udrive_g->drive.type = DTYPE_USB; - udrive_g->bulkin = inpipe; - udrive_g->bulkout = outpipe; - udrive_g->lun = lun; + memset(drive, 0, sizeof(*drive)); + drive->drive.type = DTYPE_USB; + drive->bulkin = inpipe; + drive->bulkout = outpipe; + drive->lun = lun; int prio = bootprio_find_usb(usbdev, lun); - int ret = scsi_drive_setup(&udrive_g->drive, "USB MSC", prio); + int ret = scsi_drive_setup(&drive->drive, "USB MSC", prio); if (ret) { dprintf(1, "Unable to configure USB MSC drive.\n"); - free(udrive_g); + free(drive); return -1; } return 0; diff --git a/src/hw/usb-uas.c b/src/hw/usb-uas.c index 62b9675..33657ac 100644 --- a/src/hw/usb-uas.c +++ b/src/hw/usb-uas.c @@ -14,7 +14,7 @@ // // This file may be distributed under the terms of the GNU LGPLv3 license. -#include "biosvar.h" // GET_GLOBAL +#include "biosvar.h" // GET_GLOBALFLAT #include "block.h" // DTYPE_USB #include "blockcmd.h" // cdb_read #include "config.h" // CONFIG_USB_UAS @@ -96,16 +96,16 @@ uas_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) if (!CONFIG_USB_UAS) return DISK_RET_EBADTRACK; - struct uasdrive_s *drive = container_of( - op->drive_g, struct uasdrive_s, drive); + struct uasdrive_s *drive_gf = container_of( + op->drive_gf, struct uasdrive_s, drive); uas_ui ui; memset(&ui, 0, sizeof(ui)); ui.hdr.id = UAS_UI_COMMAND; ui.hdr.tag = 0xdead; - ui.command.lun[1] = drive->lun; + ui.command.lun[1] = GET_GLOBALFLAT(drive_gf->lun); memcpy(ui.command.cdb, cdbcmd, sizeof(ui.command.cdb)); - int ret = usb_send_bulk(GET_GLOBAL(drive->command), + int ret = usb_send_bulk(GET_GLOBALFLAT(drive_gf->command), USB_DIR_OUT, MAKE_FLATPTR(GET_SEG(SS), &ui), sizeof(ui.hdr) + sizeof(ui.command)); if (ret) { @@ -114,7 +114,7 @@ uas_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) } memset(&ui, 0xff, sizeof(ui)); - ret = usb_send_bulk(GET_GLOBAL(drive->status), + ret = usb_send_bulk(GET_GLOBALFLAT(drive_gf->status), USB_DIR_IN, MAKE_FLATPTR(GET_SEG(SS), &ui), sizeof(ui)); if (ret) { dprintf(1, "uas: status recv fail"); @@ -125,7 +125,7 @@ uas_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) case UAS_UI_SENSE: goto have_sense; case UAS_UI_READ_READY: - ret = usb_send_bulk(GET_GLOBAL(drive->data_in), + ret = usb_send_bulk(GET_GLOBALFLAT(drive_gf->data_in), USB_DIR_IN, op->buf_fl, op->count * blocksize); if (ret) { dprintf(1, "uas: data read fail"); @@ -133,7 +133,7 @@ uas_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) } break; case UAS_UI_WRITE_READY: - ret = usb_send_bulk(GET_GLOBAL(drive->data_out), + ret = usb_send_bulk(GET_GLOBALFLAT(drive_gf->data_out), USB_DIR_OUT, op->buf_fl, op->count * blocksize); if (ret) { dprintf(1, "uas: data write fail"); @@ -146,7 +146,7 @@ uas_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) } memset(&ui, 0xff, sizeof(ui)); - ret = usb_send_bulk(GET_GLOBAL(drive->status), + ret = usb_send_bulk(GET_GLOBALFLAT(drive_gf->status), USB_DIR_IN, MAKE_FLATPTR(GET_SEG(SS), &ui), sizeof(ui)); if (ret) { dprintf(1, "uas: status recv fail"); diff --git a/src/hw/virtio-blk.c b/src/hw/virtio-blk.c index 2b8e17c..0290d67 100644 --- a/src/hw/virtio-blk.c +++ b/src/hw/virtio-blk.c @@ -7,7 +7,7 @@ // // This file may be distributed under the terms of the GNU LGPLv3 license. -#include "biosvar.h" // GET_GLOBAL +#include "biosvar.h" // GET_GLOBALFLAT #include "config.h" // CONFIG_* #include "block.h" // struct drive_s #include "malloc.h" // free @@ -31,9 +31,9 @@ struct virtiodrive_s { static int virtio_blk_op(struct disk_op_s *op, int write) { - struct virtiodrive_s *vdrive_g = - container_of(op->drive_g, struct virtiodrive_s, drive); - struct vring_virtqueue *vq = GET_GLOBAL(vdrive_g->vq); + struct virtiodrive_s *vdrive_gf = + container_of(op->drive_gf, struct virtiodrive_s, drive); + struct vring_virtqueue *vq = GET_GLOBALFLAT(vdrive_gf->vq); struct virtio_blk_outhdr hdr = { .type = write ? VIRTIO_BLK_T_OUT : VIRTIO_BLK_T_IN, .ioprio = 0, @@ -47,7 +47,7 @@ virtio_blk_op(struct disk_op_s *op, int write) }, { .addr = op->buf_fl, - .length = GET_GLOBAL(vdrive_g->drive.blksize) * op->count, + .length = GET_GLOBALFLAT(vdrive_gf->drive.blksize) * op->count, }, { .addr = MAKE_FLATPTR(GET_SEG(SS), &status), @@ -60,7 +60,7 @@ virtio_blk_op(struct disk_op_s *op, int write) vring_add_buf(vq, sg, 2, 1, 0, 0); else vring_add_buf(vq, sg, 1, 2, 0, 0); - vring_kick(GET_GLOBAL(vdrive_g->ioaddr), vq, 1); + vring_kick(GET_GLOBALFLAT(vdrive_gf->ioaddr), vq, 1); /* Wait for reply */ while (!vring_more_used(vq)) @@ -72,7 +72,7 @@ virtio_blk_op(struct disk_op_s *op, int write) /* Clear interrupt status register. Avoid leaving interrupts stuck if * VRING_AVAIL_F_NO_INTERRUPT was ignored and interrupts were raised. */ - vp_get_isr(GET_GLOBAL(vdrive_g->ioaddr)); + vp_get_isr(GET_GLOBALFLAT(vdrive_gf->ioaddr)); return status == VIRTIO_BLK_S_OK ? DISK_RET_SUCCESS : DISK_RET_EBADTRACK; } @@ -105,18 +105,18 @@ init_virtio_blk(struct pci_device *pci) u16 bdf = pci->bdf; dprintf(1, "found virtio-blk at %x:%x\n", pci_bdf_to_bus(bdf), pci_bdf_to_dev(bdf)); - struct virtiodrive_s *vdrive_g = malloc_fseg(sizeof(*vdrive_g)); - if (!vdrive_g) { + struct virtiodrive_s *vdrive = malloc_fseg(sizeof(*vdrive)); + if (!vdrive) { warn_noalloc(); return; } - memset(vdrive_g, 0, sizeof(*vdrive_g)); - vdrive_g->drive.type = DTYPE_VIRTIO_BLK; - vdrive_g->drive.cntl_id = bdf; + memset(vdrive, 0, sizeof(*vdrive)); + vdrive->drive.type = DTYPE_VIRTIO_BLK; + vdrive->drive.cntl_id = bdf; u16 ioaddr = vp_init_simple(bdf); - vdrive_g->ioaddr = ioaddr; - if (vp_find_vq(ioaddr, 0, &vdrive_g->vq) < 0 ) { + vdrive->ioaddr = ioaddr; + if (vp_find_vq(ioaddr, 0, &vdrive->vq) < 0 ) { dprintf(1, "fail to find vq for virtio-blk %x:%x\n", pci_bdf_to_bus(bdf), pci_bdf_to_dev(bdf)); goto fail; @@ -126,36 +126,36 @@ init_virtio_blk(struct pci_device *pci) vp_get(ioaddr, 0, &cfg, sizeof(cfg)); u32 f = vp_get_features(ioaddr); - vdrive_g->drive.blksize = (f & (1 << VIRTIO_BLK_F_BLK_SIZE)) ? + vdrive->drive.blksize = (f & (1 << VIRTIO_BLK_F_BLK_SIZE)) ? cfg.blk_size : DISK_SECTOR_SIZE; - vdrive_g->drive.sectors = cfg.capacity; + vdrive->drive.sectors = cfg.capacity; dprintf(3, "virtio-blk %x:%x blksize=%d sectors=%u\n", pci_bdf_to_bus(bdf), pci_bdf_to_dev(bdf), - vdrive_g->drive.blksize, (u32)vdrive_g->drive.sectors); + vdrive->drive.blksize, (u32)vdrive->drive.sectors); - if (vdrive_g->drive.blksize != DISK_SECTOR_SIZE) { + if (vdrive->drive.blksize != DISK_SECTOR_SIZE) { dprintf(1, "virtio-blk %x:%x block size %d is unsupported\n", pci_bdf_to_bus(bdf), pci_bdf_to_dev(bdf), - vdrive_g->drive.blksize); + vdrive->drive.blksize); goto fail; } - vdrive_g->drive.pchs.cylinder = cfg.cylinders; - vdrive_g->drive.pchs.head = cfg.heads; - vdrive_g->drive.pchs.sector = cfg.sectors; + vdrive->drive.pchs.cylinder = cfg.cylinders; + vdrive->drive.pchs.head = cfg.heads; + vdrive->drive.pchs.sector = cfg.sectors; char *desc = znprintf(MAXDESCSIZE, "Virtio disk PCI:%x:%x", pci_bdf_to_bus(bdf), pci_bdf_to_dev(bdf)); - boot_add_hd(&vdrive_g->drive, desc, bootprio_find_pci_device(pci)); + boot_add_hd(&vdrive->drive, desc, bootprio_find_pci_device(pci)); vp_set_status(ioaddr, VIRTIO_CONFIG_S_ACKNOWLEDGE | VIRTIO_CONFIG_S_DRIVER | VIRTIO_CONFIG_S_DRIVER_OK); return; fail: - free(vdrive_g->vq); - free(vdrive_g); + free(vdrive->vq); + free(vdrive); } void diff --git a/src/hw/virtio-scsi.c b/src/hw/virtio-scsi.c index 7cde3bc..4b4ec7b 100644 --- a/src/hw/virtio-scsi.c +++ b/src/hw/virtio-scsi.c @@ -7,7 +7,7 @@ // // This file may be distributed under the terms of the GNU LGPLv3 license. -#include "biosvar.h" // GET_GLOBAL +#include "biosvar.h" // GET_GLOBALFLAT #include "block.h" // struct drive_s #include "blockcmd.h" // scsi_drive_setup #include "config.h" // CONFIG_* @@ -89,12 +89,13 @@ virtio_scsi_cmd(u16 ioaddr, struct vring_virtqueue *vq, struct disk_op_s *op, int virtio_scsi_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) { - struct virtio_lun_s *vlun = - container_of(op->drive_g, struct virtio_lun_s, drive); + struct virtio_lun_s *vlun_gf = + container_of(op->drive_gf, struct virtio_lun_s, drive); - return virtio_scsi_cmd(GET_GLOBAL(vlun->ioaddr), - GET_GLOBAL(vlun->vq), op, cdbcmd, - GET_GLOBAL(vlun->target), GET_GLOBAL(vlun->lun), + return virtio_scsi_cmd(GET_GLOBALFLAT(vlun_gf->ioaddr), + GET_GLOBALFLAT(vlun_gf->vq), op, cdbcmd, + GET_GLOBALFLAT(vlun_gf->target), + GET_GLOBALFLAT(vlun_gf->lun), blocksize); } -- 1.8.3.1

1 1

qemu 1.7 & seabios -- release planning
by Gerd Hoffmann Oct. 29, 2013

Oct. 29, 2013

Hi, It's probably going to be a bit tough this time. We are pretty late in the qemu 1.7 devel cycle, soft freeze today, and a big chunk of code (ahci-tables-from qemu) which needs seabios support[1] is just about to be pulled. That leaves only two weeks (with kvm forum in the middle!) until qemu 1.7 hard freeze with -rc0 (2013-10-29), which should ideally have a seabios update so it can be tested in the rc phase. There are two more interface updates (pass pcimem64-start address + e820 entries for ram regions) which would be good to get in while being at it. seabios patches are ready for the most part and just waiting for the qemu counterparts to be merged first. The timing constrains suggest we should tightly align the releases, with seabios releases being a bit earlier, i.e. something like this: (1) merge pending qemu patches (2) merge pending seabios patches (3) tag -rc0 seabios release [asap, no later than 2013-10-28] (4) merge seabios update into qemu (5) qemu hard freeze, -rc0 release with seabios update [2013-10-29] (6) seabios freeze in parallel with qemu hard freeze (7) apply seabios fixes if needed. (8) tag final seabios release [targeting qemu -rc2 or -rc3 date here] (9) merge seabios bugfix update into qemu Qemu 1.7 schedule is here: http://wiki.qemu.org/Planning/1.7 Comments? cheers, Gerd [1] Strictly speaking it isn't absolutely required, but would be very good to have.

2 2

[PATCH] Minor - eliminate the SET_GLOBAL macro.
by Kevin O'Connor Oct. 26, 2013

Oct. 26, 2013

Remove the SET_GLOBAL macro - it is no longer used and since it was only available in "32bit flat" mode it does not have much use. Signed-off-by: Kevin O'Connor <kevin(a)koconnor.net> --- README | 21 ++++++++++----------- src/biosvar.h | 4 ---- 2 files changed, 10 insertions(+), 15 deletions(-) diff --git a/README b/README index 6844e52..1e61e2f 100644 --- a/README +++ b/README @@ -104,23 +104,22 @@ mode instead of a segment/offset pair. Most BIOS variables are stored in global variables, the "BDA", or "EBDA" memory areas. Because this is common, three sets of helper -macros (GET/SET_GLOBAL, GET/SET_BDA, and GET/SET_EBDA) are available -to simplify these accesses. Also, an area in the 0xc0000-0xf0000 -memory range is made available for internal BIOS run-time variables -that are marked with the VARLOW attribute. These variables can then -be accessed with the GET/SET_LOW macros. +macros (GET_GLOBAL, GET/SET_BDA, and GET/SET_EBDA) are available to +simplify these accesses. Also, an area in the 0xc0000-0xf0000 memory +range is made available for internal BIOS run-time variables that are +marked with the VARLOW attribute. These variables can then be +accessed with the GET/SET_LOW macros. Global variables defined in the C code can be read in 16bit mode if the variable declaration is marked with VAR16, VARFSEG, or VAR16FIXED. The GET_GLOBAL macro will then allow read access to the variable. Global variables are stored in the 0xf000 segment. Because the f-segment is marked read-only during run-time, the 16bit code is not -permitted to change the value of 16bit variables (use of the -SET_GLOBAL macro from 16bit mode will cause a link error). Code -running in 32bit mode can not access variables with VAR16, but can -access variables marked with VARFSEG, VARLOW, VAR16FIXED, or with no -marking at all. The 32bit code can use the GET/SET_GLOBAL macros, but -they are not required. +permitted to change the value of 16bit variables. Code running in +32bit mode can not access variables with VAR16, but can access +variables marked with VARFSEG, VARLOW, VAR16FIXED, or with no marking +at all. The 32bit code can use the GET_GLOBAL macros, but they are +not required. GCC 16 bit stack limitations: diff --git a/src/biosvar.h b/src/biosvar.h index 051cd1e..58bcbce 100644 --- a/src/biosvar.h +++ b/src/biosvar.h @@ -99,10 +99,6 @@ static inline u16 get_global_seg(void) { #define GET_GLOBAL(var) \ GET_VAR(GLOBAL_SEGREG, *(typeof(&(var)))((void*)&(var) \ + get_global_offset())) -#define SET_GLOBAL(var, val) do { \ - ASSERT32FLAT(); \ - (var) = (val); \ - } while (0) #if MODESEGMENT #define GLOBALFLAT2GLOBAL(var) ((typeof(var))((void*)(var) - BUILD_BIOS_ADDR)) #else -- 1.8.3.1

1 0

[PATCH] megasas: Don't attempt to access 'struct pci_device' at runtime.
by Kevin O'Connor Oct. 26, 2013

Oct. 26, 2013

The PCI device structures are only available during the POST phase. Don't attempt to access them from the runtime disk driver code. This patch has not been tested, but the old code is definitely incorrect. Signed-off-by: Kevin O'Connor <kevin(a)koconnor.net> --- src/hw/megasas.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/hw/megasas.c b/src/hw/megasas.c index 3ded877..a5dc14f 100644 --- a/src/hw/megasas.c +++ b/src/hw/megasas.c @@ -109,9 +109,9 @@ struct mfi_ld_list_s { struct megasas_lun_s { struct drive_s drive; - struct pci_device *pci; struct megasas_cmd_frame *frame; u32 iobase; + u16 pci_id; u8 target; u8 lun; }; @@ -163,7 +163,7 @@ megasas_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize) container_of(op->drive_gf, struct megasas_lun_s, drive); u8 *cdb = cdbcmd; struct megasas_cmd_frame *frame = GET_GLOBALFLAT(mlun_gf->frame); - u16 pci_id = GET_GLOBALFLAT(mlun_gf->pci->device); + u16 pci_id = GET_GLOBALFLAT(mlun_gf->pci_id); int i; if (!CONFIG_MEGASAS) @@ -212,7 +212,7 @@ megasas_add_lun(struct pci_device *pci, u32 iobase, u8 target, u8 lun) memset(mlun, 0, sizeof(*mlun)); mlun->drive.type = DTYPE_MEGASAS; mlun->drive.cntl_id = pci->bdf; - mlun->pci = pci; + mlun->pci_id = pci->device; mlun->target = target; mlun->lun = lun; mlun->iobase = iobase; -- 1.8.3.1

1 0

[PATCH] vgahooks: add SM720 VGA BIOS hooks for WIN Enterprises MB-60470
by Jonathan A. Kollasch Oct. 26, 2013

Oct. 26, 2013

Add vgahooks to support the SMI SM720 VGA BIOS used on the WIN Enterprises MB-60470. The response from smi_157f14() is necessary for the CRT output to turn on. The response from smi_157f02() is used to configure which connector(s) output is routed to. As I lack hardware to test LCD panel output, I've selected CRT-only output on the MB-60470 as this prevents the CRT output from being scaled to the resolution of the LCD panel. Signed-off-by: Jonathan A. Kollasch <jakllsch(a)kollasch.net> --- src/system.c | 1 + src/util.h | 1 + src/vgahooks.c | 66 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 3 files changed, 67 insertions(+), 1 deletion(-) diff --git a/src/system.c b/src/system.c index 3daf49b..5d10cc8 100644 --- a/src/system.c +++ b/src/system.c @@ -349,6 +349,7 @@ handle_15(struct bregs *regs) case 0x52: handle_1552(regs); break; case 0x53: handle_1553(regs); break; case 0x5f: handle_155f(regs); break; + case 0x7f: handle_157f(regs); break; case 0x83: handle_1583(regs); break; case 0x86: handle_1586(regs); break; case 0x87: handle_1587(regs); break; diff --git a/src/util.h b/src/util.h index d51e30f..c9d463d 100644 --- a/src/util.h +++ b/src/util.h @@ -218,6 +218,7 @@ void lpt_setup(void); // vgahooks.c void handle_155f(struct bregs *regs); +void handle_157f(struct bregs *regs); void vgahook_setup(struct pci_device *pci); diff --git a/src/vgahooks.c b/src/vgahooks.c index dc3085e..6a4acfe 100644 --- a/src/vgahooks.c +++ b/src/vgahooks.c @@ -12,10 +12,11 @@ #include "hw/pci_regs.h" // PCI_VENDOR_ID #include "output.h" // dprintf #include "string.h" // strcmp -#include "util.h" // handle_155f +#include "util.h" // handle_155f, handle_157f #define VH_VIA 1 #define VH_INTEL 2 +#define VH_SMI 3 int VGAHookHandlerType VARFSEG; @@ -25,6 +26,11 @@ handle_155fXX(struct bregs *regs) set_code_unimplemented(regs, RET_EUNSUPPORTED); } +static void +handle_157fXX(struct bregs *regs) +{ + set_code_unimplemented(regs, RET_EUNSUPPORTED); +} /**************************************************************** * Via hooks @@ -248,6 +254,46 @@ getac_setup(struct pci_device *pci) { } +/**************************************************************** + * Silicon Motion hooks + ****************************************************************/ + +u8 SmiBootDisplay VARFSEG; // 1: LCD, 2: CRT, 3: Both */ + +static void +smi_157f02(struct bregs *regs) +{ + /* Boot Display Device Override */ + regs->ax = 0x007f; + regs->bl = GET_GLOBAL(SmiBootDisplay); + set_success(regs); +} + +static void +smi_157f14(struct bregs *regs) +{ + /* ReduceOn support default status */ + regs->ax = 0x007f; + regs->bl = 0x00; + set_success(regs); +} + +static void +smi_157f(struct bregs *regs) +{ + switch (regs->al) { + case 0x02: smi_157f02(regs); break; + case 0x14: smi_157f14(regs); break; + default: handle_157fXX(regs); break; + } +} + +static void +winent_mb6047_setup(struct pci_device *pci) +{ + VGAHookHandlerType = VH_SMI; + SmiBootDisplay = 0x02; +} /**************************************************************** * Entry and setup @@ -270,6 +316,22 @@ handle_155f(struct bregs *regs) } } +// Main 16bit entry point +void +handle_157f(struct bregs *regs) +{ + if (!CONFIG_VGAHOOKS) { + handle_157fXX(regs); + return; + } + + int htype = GET_GLOBAL(VGAHookHandlerType); + switch (htype) { + case VH_SMI: smi_157f(regs); break; + default: handle_157fXX(regs); break; + } +} + // Setup void vgahook_setup(struct pci_device *pci) @@ -283,6 +345,8 @@ vgahook_setup(struct pci_device *pci) getac_setup(pci); else if (strcmp(CBvendor, "RODA") == 0 && strcmp(CBpart, "RK886EX") == 0) roda_setup(pci); + else if (strcmp(CBvendor, "Win Enterprise") == 0 && strcmp(CBpart, "MB6047") == 0) + winent_mb6047_setup(pci); else if (pci->vendor == PCI_VENDOR_ID_VIA) via_setup(pci); else if (pci->vendor == PCI_VENDOR_ID_INTEL) -- 1.8.0.1

2 1