SeaBIOS

seabios@seabios.org

3775 discussions

[PATCH 0/2] dsdt: add support for pnp ids as strings
by Gerd Hoffmann 13 Oct '20

13 Oct '20

Gerd Hoffmann (2): output: add support for uppercase hex numbers dsdt: add support for pnp ids as strings src/fw/dsdt_parser.c | 21 +++++++++++-------- src/output.c | 49 ++++++++++++++++++++++++-------------------- 2 files changed, 40 insertions(+), 30 deletions(-) -- 2.27.0

3 6

[PATCH] nvme: Split requests by maximum allowed size
by Alexander Graf 30 Sep '20

30 Sep '20

Some NVMe controllers only support small maximum request sizes, such as the AWS EBS NVMe implementation which only supports NVMe requests of up to 64 sectors at once. BIOS callers can easily exceed those request sizes by defining sector counts above this threshold. Currently we fall back to the bounce buffer implementation for those. This is slow. This patch introduces splitting logic to the NVMe I/O request code so that every NVMe I/O request gets handled in a chunk size that is consumable by the NVMe adapter, while maintaining the fast path PRPL logic we just introduced. Signed-off-by: Alexander Graf <graf(a)amazon.com> --- This patch is a follow-up to the NVMe PRP list patch set --- src/hw/nvme.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/hw/nvme.c b/src/hw/nvme.c index ec05836..4eb9a02 100644 --- a/src/hw/nvme.c +++ b/src/hw/nvme.c @@ -727,6 +727,22 @@ nvme_cmd_readwrite(struct nvme_namespace *ns, struct disk_op_s *op, int write) u16 const max_blocks = NVME_PAGE_SIZE / ns->block_size; u16 i; + /* Split up requests that are larger than the device can handle */ + if (op->count > ns->max_req_size) { + u16 count = op->count; + + /* Handle the first max_req_size elements */ + op->count = ns->max_req_size; + if (nvme_cmd_readwrite(ns, op, write)) + return res; + + /* Handle the remainder of the request */ + op->count = count - ns->max_req_size; + op->lba += ns->max_req_size; + op->buf_fl += (ns->max_req_size * ns->block_size); + return nvme_cmd_readwrite(ns, op, write); + } + if (!nvme_build_prpl(ns, op)) { /* Request goes via PRP List logic */ return nvme_io_readwrite(ns, op->lba, ns->prp1, op->count, write); -- 2.16.4 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879

1 0

[PATCH v2 0/3] nvme: Add PRP List support
by Alexander Graf 30 Sep '20

30 Sep '20

While looking at VM bootup times, we stumbled over the fact that the NVMe code only does I/O operations of up to 4kb at a given point in time. This is usually ok, but if you have an OS that loads a lot of data on boot in combination to network backed storage, it shows in bootup times. There is no need to restrict ourselves to 4kb though. The INT13 call we receive gives us much larger chunks which we can just map into a native bigger NVMe I/O call if the request buffer is page aligned. This patch implements all logic required to do the above and gives a substantial performance boost on boot. v1 -> v2: - fix dprintf - Fix bounds check on PRP list add logic - Reduce PRP list to 15 entries embedded in the ns struct. This reduces BIOS reserved memory footprint by 4kb. Alexander Graf (3): nvme: Record maximum allowed request size nvme: Allow to set PRP2 nvme: Pass large I/O requests as PRP lists src/hw/nvme-int.h | 16 ++++++++- src/hw/nvme.c | 106 +++++++++++++++++++++++++++++++++++++++++++++--------- 2 files changed, 105 insertions(+), 17 deletions(-) -- 2.16.4 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879

1 3

[PATCH 0/3] nvme: Add PRP List support
by Alexander Graf 30 Sep '20

30 Sep '20

While looking at VM bootup times, we stumbled over the fact that the NVMe code only does I/O operations of up to 4kb at a given point in time. This is usually ok, but if you have an OS that loads a lot of data on boot in combination to network backed storage, it shows in bootup times. There is no need to restrict ourselves to 4kb though. The INT13 call we receive gives us much larger chunks which we can just map into a native bigger NVMe I/O call if the request buffer is page aligned. This patch implements all logic required to do the above and gives a substantial performance boost on boot. Alexander Graf (3): nvme: Record maximum allowed request size nvme: Allow to set PRP2 nvme: Pass large I/O requests as PRP lists src/hw/nvme-int.h | 14 ++++++- src/hw/nvme.c | 107 ++++++++++++++++++++++++++++++++++++++++++++++-------- 2 files changed, 104 insertions(+), 17 deletions(-) -- 2.16.4 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879

3 6

[SeaBIOS][PATCH] USB:Fix xHCI initail fail by using longer reset and CNR clear timeout value
by weitaowang-oc＠zhaoxin.com 30 Sep '20

30 Sep '20

Some xHCI controller's reset time than 100ms,such as 120ms. On the on hand, xHCI spec has not specified a timeout value. Maybe setting xHCI HCRST and CNR bit clear timeout value larger is a nice thing.As a compromise between compatibility and latency,we can take 1000ms as a timeout value. Signed-off-by: WeitaoWangoc <WeitaoWang-oc(a)zhaoxin.com> --- src/hw/usb-xhci.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/hw/usb-xhci.c b/src/hw/usb-xhci.c index 08d1e32..21d091f 100644 --- a/src/hw/usb-xhci.c +++ b/src/hw/usb-xhci.c @@ -467,9 +467,9 @@ configure_xhci(void *data) dprintf(3, "%s: resetting\n", __func__); writel(&xhci->op->usbcmd, XHCI_CMD_HCRST); - if (wait_bit(&xhci->op->usbcmd, XHCI_CMD_HCRST, 0, 100) != 0) + if (wait_bit(&xhci->op->usbcmd, XHCI_CMD_HCRST, 0, 1000) != 0) goto fail; - if (wait_bit(&xhci->op->usbsts, XHCI_STS_CNR, 0, 100) != 0) + if (wait_bit(&xhci->op->usbsts, XHCI_STS_CNR, 0, 1000) != 0) goto fail; writel(&xhci->op->config, xhci->slots); -- 2.7.4

3 3

[PATCH] Add all HD and QXGA resolutions
by Elliot Killick 30 Sep '20

30 Sep '20

From: Elliot Killick <elliotkillick(a)zohomail.eu> Add support for all high-definition and quad extended graphics array resolutions as listed on Wikipedia. https://en.wikipedia.org/wiki/Graphics_display_resolution Signed-off-by: Elliot Killick <elliotkillick(a)zohomail.eu> --- Also fixed some indentation so the mode values would all align and changed a few of the hex identifiers at the start of the list to use lowercase instead of uppercase letters to comply with the style of the the rest of the modes in the struct. vgasrc/svgamodes.c | 222 +++++++++++++++++++++++++++++---------------- 1 file changed, 145 insertions(+), 77 deletions(-) diff --git a/vgasrc/svgamodes.c b/vgasrc/svgamodes.c index 6e494c7..a22cdf7 100644 --- a/vgasrc/svgamodes.c +++ b/vgasrc/svgamodes.c @@ -13,84 +13,152 @@ struct generic_svga_mode svga_modes[] VAR16 = { /* standard modes */ - { 0x100, { MM_PACKED, 640, 400, 8, 8, 16, SEG_GRAPH } }, - { 0x101, { MM_PACKED, 640, 480, 8, 8, 16, SEG_GRAPH } }, - { 0x102, { MM_PLANAR, 800, 600, 4, 8, 16, SEG_GRAPH } }, - { 0x103, { MM_PACKED, 800, 600, 8, 8, 16, SEG_GRAPH } }, - { 0x104, { MM_PLANAR, 1024, 768, 4, 8, 16, SEG_GRAPH } }, - { 0x105, { MM_PACKED, 1024, 768, 8, 8, 16, SEG_GRAPH } }, - { 0x106, { MM_PLANAR, 1280, 1024, 4, 8, 16, SEG_GRAPH } }, - { 0x107, { MM_PACKED, 1280, 1024, 8, 8, 16, SEG_GRAPH } }, - { 0x10D, { MM_DIRECT, 320, 200, 15, 8, 16, SEG_GRAPH } }, - { 0x10E, { MM_DIRECT, 320, 200, 16, 8, 16, SEG_GRAPH } }, - { 0x10F, { MM_DIRECT, 320, 200, 24, 8, 16, SEG_GRAPH } }, - { 0x110, { MM_DIRECT, 640, 480, 15, 8, 16, SEG_GRAPH } }, - { 0x111, { MM_DIRECT, 640, 480, 16, 8, 16, SEG_GRAPH } }, - { 0x112, { MM_DIRECT, 640, 480, 24, 8, 16, SEG_GRAPH } }, - { 0x113, { MM_DIRECT, 800, 600, 15, 8, 16, SEG_GRAPH } }, - { 0x114, { MM_DIRECT, 800, 600, 16, 8, 16, SEG_GRAPH } }, - { 0x115, { MM_DIRECT, 800, 600, 24, 8, 16, SEG_GRAPH } }, - { 0x116, { MM_DIRECT, 1024, 768, 15, 8, 16, SEG_GRAPH } }, - { 0x117, { MM_DIRECT, 1024, 768, 16, 8, 16, SEG_GRAPH } }, - { 0x118, { MM_DIRECT, 1024, 768, 24, 8, 16, SEG_GRAPH } }, - { 0x119, { MM_DIRECT, 1280, 1024, 15, 8, 16, SEG_GRAPH } }, - { 0x11A, { MM_DIRECT, 1280, 1024, 16, 8, 16, SEG_GRAPH } }, - { 0x11B, { MM_DIRECT, 1280, 1024, 24, 8, 16, SEG_GRAPH } }, - { 0x11C, { MM_PACKED, 1600, 1200, 8, 8, 16, SEG_GRAPH } }, - { 0x11D, { MM_DIRECT, 1600, 1200, 15, 8, 16, SEG_GRAPH } }, - { 0x11E, { MM_DIRECT, 1600, 1200, 16, 8, 16, SEG_GRAPH } }, - { 0x11F, { MM_DIRECT, 1600, 1200, 24, 8, 16, SEG_GRAPH } }, + { 0x100, { MM_PACKED, 640, 400, 8, 8, 16, SEG_GRAPH } }, + { 0x101, { MM_PACKED, 640, 480, 8, 8, 16, SEG_GRAPH } }, + { 0x102, { MM_PLANAR, 800, 600, 4, 8, 16, SEG_GRAPH } }, + { 0x103, { MM_PACKED, 800, 600, 8, 8, 16, SEG_GRAPH } }, + { 0x104, { MM_PLANAR, 1024, 768, 4, 8, 16, SEG_GRAPH } }, + { 0x105, { MM_PACKED, 1024, 768, 8, 8, 16, SEG_GRAPH } }, + { 0x106, { MM_PLANAR, 1280, 1024, 4, 8, 16, SEG_GRAPH } }, + { 0x107, { MM_PACKED, 1280, 1024, 8, 8, 16, SEG_GRAPH } }, + { 0x10d, { MM_DIRECT, 320, 200, 15, 8, 16, SEG_GRAPH } }, + { 0x10e, { MM_DIRECT, 320, 200, 16, 8, 16, SEG_GRAPH } }, + { 0x10f, { MM_DIRECT, 320, 200, 24, 8, 16, SEG_GRAPH } }, + { 0x110, { MM_DIRECT, 640, 480, 15, 8, 16, SEG_GRAPH } }, + { 0x111, { MM_DIRECT, 640, 480, 16, 8, 16, SEG_GRAPH } }, + { 0x112, { MM_DIRECT, 640, 480, 24, 8, 16, SEG_GRAPH } }, + { 0x113, { MM_DIRECT, 800, 600, 15, 8, 16, SEG_GRAPH } }, + { 0x114, { MM_DIRECT, 800, 600, 16, 8, 16, SEG_GRAPH } }, + { 0x115, { MM_DIRECT, 800, 600, 24, 8, 16, SEG_GRAPH } }, + { 0x116, { MM_DIRECT, 1024, 768, 15, 8, 16, SEG_GRAPH } }, + { 0x117, { MM_DIRECT, 1024, 768, 16, 8, 16, SEG_GRAPH } }, + { 0x118, { MM_DIRECT, 1024, 768, 24, 8, 16, SEG_GRAPH } }, + { 0x119, { MM_DIRECT, 1280, 1024, 15, 8, 16, SEG_GRAPH } }, + { 0x11a, { MM_DIRECT, 1280, 1024, 16, 8, 16, SEG_GRAPH } }, + { 0x11b, { MM_DIRECT, 1280, 1024, 24, 8, 16, SEG_GRAPH } }, + { 0x11c, { MM_PACKED, 1600, 1200, 8, 8, 16, SEG_GRAPH } }, + { 0x11d, { MM_DIRECT, 1600, 1200, 15, 8, 16, SEG_GRAPH } }, + { 0x11e, { MM_DIRECT, 1600, 1200, 16, 8, 16, SEG_GRAPH } }, + { 0x11f, { MM_DIRECT, 1600, 1200, 24, 8, 16, SEG_GRAPH } }, /* other modes */ - { 0x140, { MM_DIRECT, 320, 200, 32, 8, 16, SEG_GRAPH } }, - { 0x141, { MM_DIRECT, 640, 400, 32, 8, 16, SEG_GRAPH } }, - { 0x142, { MM_DIRECT, 640, 480, 32, 8, 16, SEG_GRAPH } }, - { 0x143, { MM_DIRECT, 800, 600, 32, 8, 16, SEG_GRAPH } }, - { 0x144, { MM_DIRECT, 1024, 768, 32, 8, 16, SEG_GRAPH } }, - { 0x145, { MM_DIRECT, 1280, 1024, 32, 8, 16, SEG_GRAPH } }, - { 0x146, { MM_PACKED, 320, 200, 8, 8, 16, SEG_GRAPH } }, - { 0x147, { MM_DIRECT, 1600, 1200, 32, 8, 16, SEG_GRAPH } }, - { 0x148, { MM_PACKED, 1152, 864, 8, 8, 16, SEG_GRAPH } }, - { 0x149, { MM_DIRECT, 1152, 864, 15, 8, 16, SEG_GRAPH } }, - { 0x14a, { MM_DIRECT, 1152, 864, 16, 8, 16, SEG_GRAPH } }, - { 0x14b, { MM_DIRECT, 1152, 864, 24, 8, 16, SEG_GRAPH } }, - { 0x14c, { MM_DIRECT, 1152, 864, 32, 8, 16, SEG_GRAPH } }, - { 0x175, { MM_DIRECT, 1280, 768, 16, 8, 16, SEG_GRAPH } }, - { 0x176, { MM_DIRECT, 1280, 768, 24, 8, 16, SEG_GRAPH } }, - { 0x177, { MM_DIRECT, 1280, 768, 32, 8, 16, SEG_GRAPH } }, - { 0x178, { MM_DIRECT, 1280, 800, 16, 8, 16, SEG_GRAPH } }, - { 0x179, { MM_DIRECT, 1280, 800, 24, 8, 16, SEG_GRAPH } }, - { 0x17a, { MM_DIRECT, 1280, 800, 32, 8, 16, SEG_GRAPH } }, - { 0x17b, { MM_DIRECT, 1280, 960, 16, 8, 16, SEG_GRAPH } }, - { 0x17c, { MM_DIRECT, 1280, 960, 24, 8, 16, SEG_GRAPH } }, - { 0x17d, { MM_DIRECT, 1280, 960, 32, 8, 16, SEG_GRAPH } }, - { 0x17e, { MM_DIRECT, 1440, 900, 16, 8, 16, SEG_GRAPH } }, - { 0x17f, { MM_DIRECT, 1440, 900, 24, 8, 16, SEG_GRAPH } }, - { 0x180, { MM_DIRECT, 1440, 900, 32, 8, 16, SEG_GRAPH } }, - { 0x181, { MM_DIRECT, 1400, 1050, 16, 8, 16, SEG_GRAPH } }, - { 0x182, { MM_DIRECT, 1400, 1050, 24, 8, 16, SEG_GRAPH } }, - { 0x183, { MM_DIRECT, 1400, 1050, 32, 8, 16, SEG_GRAPH } }, - { 0x184, { MM_DIRECT, 1680, 1050, 16, 8, 16, SEG_GRAPH } }, - { 0x185, { MM_DIRECT, 1680, 1050, 24, 8, 16, SEG_GRAPH } }, - { 0x186, { MM_DIRECT, 1680, 1050, 32, 8, 16, SEG_GRAPH } }, - { 0x187, { MM_DIRECT, 1920, 1200, 16, 8, 16, SEG_GRAPH } }, - { 0x188, { MM_DIRECT, 1920, 1200, 24, 8, 16, SEG_GRAPH } }, - { 0x189, { MM_DIRECT, 1920, 1200, 32, 8, 16, SEG_GRAPH } }, - { 0x18a, { MM_DIRECT, 2560, 1600, 16, 8, 16, SEG_GRAPH } }, - { 0x18b, { MM_DIRECT, 2560, 1600, 24, 8, 16, SEG_GRAPH } }, - { 0x18c, { MM_DIRECT, 2560, 1600, 32, 8, 16, SEG_GRAPH } }, - { 0x18d, { MM_DIRECT, 1280, 720, 16, 8, 16, SEG_GRAPH } }, - { 0x18e, { MM_DIRECT, 1280, 720, 24, 8, 16, SEG_GRAPH } }, - { 0x18f, { MM_DIRECT, 1280, 720, 32, 8, 16, SEG_GRAPH } }, - { 0x190, { MM_DIRECT, 1920, 1080, 16, 8, 16, SEG_GRAPH } }, - { 0x191, { MM_DIRECT, 1920, 1080, 24, 8, 16, SEG_GRAPH } }, - { 0x192, { MM_DIRECT, 1920, 1080, 32, 8, 16, SEG_GRAPH } }, + { 0x140, { MM_DIRECT, 320, 200, 32, 8, 16, SEG_GRAPH } }, + { 0x141, { MM_DIRECT, 640, 400, 32, 8, 16, SEG_GRAPH } }, + { 0x142, { MM_DIRECT, 640, 480, 32, 8, 16, SEG_GRAPH } }, + { 0x143, { MM_DIRECT, 800, 600, 32, 8, 16, SEG_GRAPH } }, + { 0x144, { MM_DIRECT, 1024, 768, 32, 8, 16, SEG_GRAPH } }, + { 0x145, { MM_DIRECT, 1280, 1024, 32, 8, 16, SEG_GRAPH } }, + { 0x146, { MM_PACKED, 320, 200, 8, 8, 16, SEG_GRAPH } }, + { 0x147, { MM_DIRECT, 1600, 1200, 32, 8, 16, SEG_GRAPH } }, + { 0x148, { MM_PACKED, 1152, 864, 8, 8, 16, SEG_GRAPH } }, + { 0x149, { MM_DIRECT, 1152, 864, 15, 8, 16, SEG_GRAPH } }, + { 0x14a, { MM_DIRECT, 1152, 864, 16, 8, 16, SEG_GRAPH } }, + { 0x14b, { MM_DIRECT, 1152, 864, 24, 8, 16, SEG_GRAPH } }, + { 0x14c, { MM_DIRECT, 1152, 864, 32, 8, 16, SEG_GRAPH } }, + { 0x175, { MM_DIRECT, 1280, 768, 16, 8, 16, SEG_GRAPH } }, + { 0x176, { MM_DIRECT, 1280, 768, 24, 8, 16, SEG_GRAPH } }, + { 0x177, { MM_DIRECT, 1280, 768, 32, 8, 16, SEG_GRAPH } }, + { 0x178, { MM_DIRECT, 1280, 800, 16, 8, 16, SEG_GRAPH } }, + { 0x179, { MM_DIRECT, 1280, 800, 24, 8, 16, SEG_GRAPH } }, + { 0x17a, { MM_DIRECT, 1280, 800, 32, 8, 16, SEG_GRAPH } }, + { 0x17b, { MM_DIRECT, 1280, 960, 16, 8, 16, SEG_GRAPH } }, + { 0x17c, { MM_DIRECT, 1280, 960, 24, 8, 16, SEG_GRAPH } }, + { 0x17d, { MM_DIRECT, 1280, 960, 32, 8, 16, SEG_GRAPH } }, + { 0x17e, { MM_DIRECT, 1440, 900, 16, 8, 16, SEG_GRAPH } }, + { 0x17f, { MM_DIRECT, 1440, 900, 24, 8, 16, SEG_GRAPH } }, + { 0x180, { MM_DIRECT, 1440, 900, 32, 8, 16, SEG_GRAPH } }, + { 0x181, { MM_DIRECT, 1400, 1050, 16, 8, 16, SEG_GRAPH } }, + { 0x182, { MM_DIRECT, 1400, 1050, 24, 8, 16, SEG_GRAPH } }, + { 0x183, { MM_DIRECT, 1400, 1050, 32, 8, 16, SEG_GRAPH } }, + { 0x184, { MM_DIRECT, 1680, 1050, 16, 8, 16, SEG_GRAPH } }, + { 0x185, { MM_DIRECT, 1680, 1050, 24, 8, 16, SEG_GRAPH } }, + { 0x186, { MM_DIRECT, 1680, 1050, 32, 8, 16, SEG_GRAPH } }, + { 0x187, { MM_DIRECT, 1920, 1200, 16, 8, 16, SEG_GRAPH } }, + { 0x188, { MM_DIRECT, 1920, 1200, 24, 8, 16, SEG_GRAPH } }, + { 0x189, { MM_DIRECT, 1920, 1200, 32, 8, 16, SEG_GRAPH } }, + { 0x18a, { MM_DIRECT, 2560, 1600, 16, 8, 16, SEG_GRAPH } }, + { 0x18b, { MM_DIRECT, 2560, 1600, 24, 8, 16, SEG_GRAPH } }, + { 0x18c, { MM_DIRECT, 2560, 1600, 32, 8, 16, SEG_GRAPH } }, + { 0x18d, { MM_DIRECT, 1280, 720, 16, 8, 16, SEG_GRAPH } }, + { 0x18e, { MM_DIRECT, 1280, 720, 24, 8, 16, SEG_GRAPH } }, + { 0x18f, { MM_DIRECT, 1280, 720, 32, 8, 16, SEG_GRAPH } }, + { 0x190, { MM_DIRECT, 1920, 1080, 16, 8, 16, SEG_GRAPH } }, + { 0x191, { MM_DIRECT, 1920, 1080, 24, 8, 16, SEG_GRAPH } }, + { 0x192, { MM_DIRECT, 1920, 1080, 32, 8, 16, SEG_GRAPH } }, + { 0x193, { MM_DIRECT, 1600, 900, 16, 8, 16, SEG_GRAPH } }, + { 0x194, { MM_DIRECT, 1600, 900, 24, 8, 16, SEG_GRAPH } }, + { 0x195, { MM_DIRECT, 1600, 900, 32, 8, 16, SEG_GRAPH } }, - /* custom resolutions for 16:9 displays */ - { 0x193, { MM_DIRECT, 1600, 900, 16, 8, 16, SEG_GRAPH } }, - { 0x194, { MM_DIRECT, 1600, 900, 24, 8, 16, SEG_GRAPH } }, - { 0x195, { MM_DIRECT, 1600, 900, 32, 8, 16, SEG_GRAPH } }, - { 0x196, { MM_DIRECT, 2560, 1440, 16, 8, 16, SEG_GRAPH } }, - { 0x197, { MM_DIRECT, 2560, 1440, 24, 8, 16, SEG_GRAPH } }, - { 0x198, { MM_DIRECT, 2560, 1440, 32, 8, 16, SEG_GRAPH } }, + /* other high-definition resolutions */ + { 0x196, { MM_DIRECT, 960, 540, 16, 8, 16, SEG_GRAPH } }, + { 0x197, { MM_DIRECT, 960, 540, 24, 8, 16, SEG_GRAPH } }, + { 0x198, { MM_DIRECT, 960, 540, 32, 8, 16, SEG_GRAPH } }, + { 0x199, { MM_DIRECT, 1280, 1080, 16, 8, 16, SEG_GRAPH } }, + { 0x19a, { MM_DIRECT, 1280, 1080, 24, 8, 16, SEG_GRAPH } }, + { 0x19b, { MM_DIRECT, 1280, 1080, 32, 8, 16, SEG_GRAPH } }, + { 0x19c, { MM_DIRECT, 2048, 1080, 16, 8, 16, SEG_GRAPH } }, + { 0x19d, { MM_DIRECT, 2048, 1080, 24, 8, 16, SEG_GRAPH } }, + { 0x19e, { MM_DIRECT, 2048, 1080, 32, 8, 16, SEG_GRAPH } }, + { 0x19f, { MM_DIRECT, 2160, 1080, 16, 8, 16, SEG_GRAPH } }, + { 0x1a0, { MM_DIRECT, 2160, 1080, 24, 8, 16, SEG_GRAPH } }, + { 0x1a1, { MM_DIRECT, 2160, 1080, 32, 8, 16, SEG_GRAPH } }, + { 0x1a2, { MM_DIRECT, 2560, 1080, 16, 8, 16, SEG_GRAPH } }, + { 0x1a3, { MM_DIRECT, 2560, 1080, 24, 8, 16, SEG_GRAPH } }, + { 0x1a4, { MM_DIRECT, 2560, 1080, 32, 8, 16, SEG_GRAPH } }, + { 0x1a5, { MM_DIRECT, 2560, 1440, 16, 8, 16, SEG_GRAPH } }, + { 0x1a6, { MM_DIRECT, 2560, 1440, 24, 8, 16, SEG_GRAPH } }, + { 0x1a7, { MM_DIRECT, 2560, 1440, 32, 8, 16, SEG_GRAPH } }, + { 0x1a8, { MM_DIRECT, 3200, 1800, 16, 8, 16, SEG_GRAPH } }, + { 0x1a9, { MM_DIRECT, 3200, 1800, 24, 8, 16, SEG_GRAPH } }, + { 0x1aa, { MM_DIRECT, 3200, 1800, 32, 8, 16, SEG_GRAPH } }, + { 0x1ab, { MM_DIRECT, 3440, 1440, 16, 8, 16, SEG_GRAPH } }, + { 0x1ac, { MM_DIRECT, 3440, 1440, 24, 8, 16, SEG_GRAPH } }, + { 0x1ad, { MM_DIRECT, 3440, 1440, 32, 8, 16, SEG_GRAPH } }, + { 0x1ae, { MM_DIRECT, 3840, 1080, 16, 8, 16, SEG_GRAPH } }, + { 0x1af, { MM_DIRECT, 3840, 1080, 24, 8, 16, SEG_GRAPH } }, + { 0x1b0, { MM_DIRECT, 3840, 1080, 32, 8, 16, SEG_GRAPH } }, + { 0x1b1, { MM_DIRECT, 3840, 1600, 16, 8, 16, SEG_GRAPH } }, + { 0x1b2, { MM_DIRECT, 3840, 1600, 24, 8, 16, SEG_GRAPH } }, + { 0x1b3, { MM_DIRECT, 3840, 1600, 32, 8, 16, SEG_GRAPH } }, + { 0x1b4, { MM_DIRECT, 3840, 2160, 16, 8, 16, SEG_GRAPH } }, + { 0x1b5, { MM_DIRECT, 3840, 2160, 24, 8, 16, SEG_GRAPH } }, + { 0x1b6, { MM_DIRECT, 3840, 2160, 32, 8, 16, SEG_GRAPH } }, + { 0x1b7, { MM_DIRECT, 4096, 2160, 16, 8, 16, SEG_GRAPH } }, + { 0x1b8, { MM_DIRECT, 4096, 2160, 24, 8, 16, SEG_GRAPH } }, + { 0x1b9, { MM_DIRECT, 4096, 2160, 32, 8, 16, SEG_GRAPH } }, + { 0x1ba, { MM_DIRECT, 5120, 2160, 16, 8, 16, SEG_GRAPH } }, + { 0x1bb, { MM_DIRECT, 5120, 2160, 24, 8, 16, SEG_GRAPH } }, + { 0x1bc, { MM_DIRECT, 5120, 2160, 32, 8, 16, SEG_GRAPH } }, + { 0x1bd, { MM_DIRECT, 5120, 2880, 16, 8, 16, SEG_GRAPH } }, + { 0x1be, { MM_DIRECT, 5120, 2880, 24, 8, 16, SEG_GRAPH } }, + { 0x1bf, { MM_DIRECT, 5120, 2880, 32, 8, 16, SEG_GRAPH } }, + { 0x1c0, { MM_DIRECT, 7680, 4320, 16, 8, 16, SEG_GRAPH } }, + { 0x1c1, { MM_DIRECT, 7680, 4320, 24, 8, 16, SEG_GRAPH } }, + { 0x1c2, { MM_DIRECT, 7680, 4320, 32, 8, 16, SEG_GRAPH } }, + { 0x1c3, { MM_DIRECT, 17280, 4320, 16, 8, 16, SEG_GRAPH } }, + { 0x1c4, { MM_DIRECT, 17280, 4320, 24, 8, 16, SEG_GRAPH } }, + { 0x1c5, { MM_DIRECT, 17280, 4320, 32, 8, 16, SEG_GRAPH } }, + + /* quad extended graphics array resolutions */ + { 0x1c6, { MM_DIRECT, 2048, 1152, 16, 8, 16, SEG_GRAPH } }, + { 0x1c7, { MM_DIRECT, 2048, 1152, 24, 8, 16, SEG_GRAPH } }, + { 0x1c8, { MM_DIRECT, 2048, 1152, 32, 8, 16, SEG_GRAPH } }, + { 0x1c9, { MM_DIRECT, 2048, 1536, 16, 8, 16, SEG_GRAPH } }, + { 0x1ca, { MM_DIRECT, 2048, 1536, 24, 8, 16, SEG_GRAPH } }, + { 0x1cb, { MM_DIRECT, 2048, 1536, 32, 8, 16, SEG_GRAPH } }, + { 0x1cc, { MM_DIRECT, 2560, 1600, 16, 8, 16, SEG_GRAPH } }, + { 0x1cd, { MM_DIRECT, 2560, 1600, 24, 8, 16, SEG_GRAPH } }, + { 0x1ce, { MM_DIRECT, 2560, 1600, 32, 8, 16, SEG_GRAPH } }, + { 0x1cf, { MM_DIRECT, 2560, 2048, 16, 8, 16, SEG_GRAPH } }, + { 0x1d0, { MM_DIRECT, 2560, 2048, 24, 8, 16, SEG_GRAPH } }, + { 0x1d1, { MM_DIRECT, 2560, 2048, 32, 8, 16, SEG_GRAPH } }, + { 0x1d2, { MM_DIRECT, 3200, 2048, 16, 8, 16, SEG_GRAPH } }, + { 0x1d3, { MM_DIRECT, 3200, 2048, 24, 8, 16, SEG_GRAPH } }, + { 0x1d4, { MM_DIRECT, 3200, 2048, 32, 8, 16, SEG_GRAPH } }, + { 0x1d5, { MM_DIRECT, 3200, 2400, 16, 8, 16, SEG_GRAPH } }, + { 0x1d6, { MM_DIRECT, 3200, 2400, 24, 8, 16, SEG_GRAPH } }, + { 0x1d7, { MM_DIRECT, 3200, 2400, 32, 8, 16, SEG_GRAPH } }, + { 0x1d8, { MM_DIRECT, 3840, 2400, 16, 8, 16, SEG_GRAPH } }, + { 0x1d9, { MM_DIRECT, 3840, 2400, 24, 8, 16, SEG_GRAPH } }, + { 0x1da, { MM_DIRECT, 3840, 2400, 32, 8, 16, SEG_GRAPH } }, }; unsigned int svga_mcount VAR16 = ARRAY_SIZE(svga_modes); -- 2.28.0

2 1

[SEABIOS] [PATCH] usb.c: Fix devices using non-primary interface descriptor
by Matt DeVillier 25 Sep '20

25 Sep '20

From 38f63fcd9b646d6a4eac30f0476bbaee611211ce Mon Sep 17 00:00:00 2001 From: Matt DeVillier <matt.devillier(a)puri.sm> Date: Fri, 11 Sep 2020 12:54:21 -0500 Subject: [PATCH] usb.c: Fix devices using non-primary interface descriptor A fair number of USB devices (keyboards in particular) use an interface descriptor other than the first available, making them non-functional currently. To correct this, iterate through all available interface descriptors until one with the correct class/subclass is found, then proceed to set the configuration and setup the driver. Tested on an ultimate hacking keyboard (UHK 60) Signed-off-by: Matt DeVillier <matt.devillier(a)puri.sm> --- src/hw/usb.c | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/src/hw/usb.c b/src/hw/usb.c index 4f9a852..38a866a 100644 --- a/src/hw/usb.c +++ b/src/hw/usb.c @@ -248,14 +248,14 @@ get_device_config(struct usb_pipe *pipe) if (ret) return NULL; - void *config = malloc_tmphigh(cfg.wTotalLength); + struct usb_config_descriptor *config = malloc_tmphigh(cfg.wTotalLength); if (!config) { warn_noalloc(); return NULL; } req.wLength = cfg.wTotalLength; ret = usb_send_default_control(pipe, &req, config); - if (ret) { + if (ret || config->wTotalLength != cfg.wTotalLength) { free(config); return NULL; } @@ -367,13 +367,24 @@ configure_usb_device(struct usbdevice_s *usbdev) return 0; // Determine if a driver exists for this device - only look at the - // first interface of the first configuration. + // interfaces of the first configuration. + int num_iface = config->bNumInterfaces; + void *config_end = (void*)config + config->wTotalLength; struct usb_interface_descriptor *iface = (void*)(&config[1]); - if (iface->bInterfaceClass != USB_CLASS_HID - && iface->bInterfaceClass != USB_CLASS_MASS_STORAGE - && iface->bInterfaceClass != USB_CLASS_HUB) - // Not a supported device. - goto fail; + for (;;) { + if (!num_iface-- || (void*)iface + iface->bLength > config_end) + // Not a supported device. + goto fail; + if (iface->bDescriptorType == USB_DT_INTERFACE + && (iface->bInterfaceClass == USB_CLASS_HUB + || (iface->bInterfaceClass == USB_CLASS_MASS_STORAGE + && (iface->bInterfaceProtocol == US_PR_BULK + || iface->bInterfaceProtocol == US_PR_UAS)) + || (iface->bInterfaceClass == USB_CLASS_HID + && iface->bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT))) + break; + iface = (void*)iface + iface->bLength; + } // Set the configuration. ret = set_configuration(usbdev->defpipe, config->bConfigurationValue); -- 2.20.1

2 1

[PATCH] smbios: avoid integer overflow adding SMBIOS type 0 table
by Daniel P. Berrangé 25 Sep '20

25 Sep '20

SeaBIOS implements the SMBIOS 2.1 entry point which is limited to a maximum length of 0xffff. If the SMBIOS data received from QEMU is large enough, then adding the type 0 table will cause integer overflow. This results in fun behaviour such as a KVM crash, or hangs in SeaBIOS. Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com> --- src/fw/biostables.c | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/src/fw/biostables.c b/src/fw/biostables.c index 0c07833..794b5be 100644 --- a/src/fw/biostables.c +++ b/src/fw/biostables.c @@ -462,10 +462,16 @@ smbios_romfile_setup(void) /* common case: add our own type 0, with 3 strings and 4 '\0's */ u16 t0_len = sizeof(struct smbios_type_0) + strlen(BIOS_NAME) + strlen(VERSION) + strlen(BIOS_DATE) + 4; - ep.structure_table_length += t0_len; - if (t0_len > ep.max_structure_size) - ep.max_structure_size = t0_len; - ep.number_of_structures++; + if (t0_len > (0xffff - ep.structure_table_length)) { + dprintf(1, "Insufficient space (%d bytes) to add SMBIOS type 0 table (%d bytes)\n", + 0xffff - ep.structure_table_length, t0_len); + need_t0 = 0; + } else { + ep.structure_table_length += t0_len; + if (t0_len > ep.max_structure_size) + ep.max_structure_size = t0_len; + ep.number_of_structures++; + } } /* allocate final blob and record its address in the entry point */ -- 2.26.2

3 4

Regression with latest SeaBIOS booting multi-disk root LVs?
by Stefan Reiter 22 Sep '20

22 Sep '20

Hi list, since SeaBIOS 1.14.0 (QEMU 5.1) VMs with LVM root disks spanning more than one PV fail to boot, if only the first is set as bootable. I believe this is due to the changes in SeaBIOS only initializing drives marked as 'bootable' by QEMU. One fix is to mark all disks containing root data as bootable, but existing setups will still break on upgrade (where only the disk containing the bootloader is marked). This is not ideal. Discovered by a user in our bugtracker: https://bugzilla.proxmox.com/show_bug.cgi?id=3011 and verified by installing Ubuntu 20.04 w/ LVM and GRUB on virtio-scsi, then expanding the LV to a second disk. I found that just reverting SeaBIOS to 1.13.0 makes it work again, same guest install, even with QEMU 5.1. Is this intended behaviour? A bug in GRUB? Any fix or workaround? ~ Stefan

3 3

[SEABIOS] [PATCH] usb-hid: Fix keyboards using non-primary interface descriptor
by Matt DeVillier 07 Sep '20

07 Sep '20

From 9e408a5441330b120a477324c017c0525cb5b365 Mon Sep 17 00:00:00 2001 From: Matt DeVillier <matt.devillier(a)puri.sm> Date: Tue, 1 Sep 2020 01:21:23 -0500 Subject: [PATCH] usb-hid: Fix keyboards using non-primary interface descriptor A fair number of USB keyboards use an interface descriptor other than the first available, making them non-functional currently. To correct this, iterate through all available interface descriptors until one with the correct class/subclass is found, then call usb_hid_setup(). Tested on an ultimate hacking keyboard (UHK 60) Signed-off-by: Matt DeVillier <matt.devillier(a)puri.sm> --- src/hw/usb-hid.c | 9 ++------- src/hw/usb.c | 17 +++++++++++++++-- 2 files changed, 17 insertions(+), 9 deletions(-) diff --git a/src/hw/usb-hid.c b/src/hw/usb-hid.c index a22765b..c1ceaba 100644 --- a/src/hw/usb-hid.c +++ b/src/hw/usb-hid.c @@ -138,11 +138,6 @@ usb_hid_setup(struct usbdevice_s *usbdev) return -1; dprintf(2, "usb_hid_setup %p\n", usbdev->defpipe); - struct usb_interface_descriptor *iface = usbdev->iface; - if (iface->bInterfaceSubClass != USB_INTERFACE_SUBCLASS_BOOT) - // Doesn't support boot protocol. - return -1; - // Find intr in endpoint. struct usb_endpoint_descriptor *epdesc = usb_find_desc( usbdev, USB_ENDPOINT_XFER_INT, USB_DIR_IN); @@ -151,9 +146,9 @@ usb_hid_setup(struct usbdevice_s *usbdev) return -1; } - if (iface->bInterfaceProtocol == USB_INTERFACE_PROTOCOL_KEYBOARD) + if (usbdev->iface->bInterfaceProtocol == USB_INTERFACE_PROTOCOL_KEYBOARD) return usb_kbd_setup(usbdev, epdesc); - if (iface->bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE) + if (usbdev->iface->bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE) return usb_mouse_setup(usbdev, epdesc); return -1; } diff --git a/src/hw/usb.c b/src/hw/usb.c index 4f9a852..aea70a5 100644 --- a/src/hw/usb.c +++ b/src/hw/usb.c @@ -391,8 +391,21 @@ configure_usb_device(struct usbdevice_s *usbdev) ret = usb_msc_setup(usbdev); if (iface->bInterfaceProtocol == US_PR_UAS) ret = usb_uas_setup(usbdev); - } else - ret = usb_hid_setup(usbdev); + } else { + // Some keyboards use an interface other than the first one + // so iterate through all available + for (int i=0; i<config->bNumInterfaces; i++) { + if (iface->bInterfaceClass == USB_CLASS_HID && + iface->bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT) { + usbdev->iface = iface; + ret = usb_hid_setup(usbdev); + break; + } else { + iface = (void*)iface + iface->bLength; + ret = -1; + } + } + } if (ret) goto fail; -- 2.20.1

2 8

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

SeaBIOS