Commit 4489b983 authored by Ben Skeggs's avatar Ben Skeggs
Browse files

drm/nouveau/bios: rework vbios shadowing 



Refactored to allow shadowing of VBIOS images longer than 64KiB, which
allows us to pass the VBIOS checksum test on certain boards.

There's also a workaround for reading the PROM VBIOS on some chipsets.

Signed-off-by: default avatarBen Skeggs <bskeggs@redhat.com>
parent 05a7c15d

drivers/gpu/drm/nouveau/nouveau_bios.c

+156 −119
Original line number Diff line number Diff line
@@ -65,195 +65,232 @@ static bool nv_cksum(const uint8_t *data, unsigned int length) 
}



static int

score_vbios(struct drm_device *dev, const uint8_t *data, const bool writeable)

score_vbios(struct nvbios *bios, const bool writeable)

{

	if (!(data[0] == 0x55 && data[1] == 0xAA)) {

		NV_TRACEWARN(dev, "... BIOS signature not found\n");

	if (!bios->data || bios->data[0] != 0x55 || bios->data[1] != 0xAA) {

		NV_TRACEWARN(bios->dev, "... BIOS signature not found\n");

		return 0;

	}



	if (nv_cksum(data, data[2] * 512)) {

		NV_TRACEWARN(dev, "... BIOS checksum invalid\n");

	if (nv_cksum(bios->data, bios->data[2] * 512)) {

		NV_TRACEWARN(bios->dev, "... BIOS checksum invalid\n");

		/* if a ro image is somewhat bad, it's probably all rubbish */

		return writeable ? 2 : 1;

	} else

		NV_TRACE(dev, "... appears to be valid\n");

	}



	NV_TRACE(bios->dev, "... appears to be valid\n");

	return 3;

}



static void load_vbios_prom(struct drm_device *dev, uint8_t *data)

static void

bios_shadow_prom(struct nvbios *bios)

{

	struct drm_device *dev = bios->dev;

	struct drm_nouveau_private *dev_priv = dev->dev_private;

	uint32_t pci_nv_20, save_pci_nv_20;

	int pcir_ptr;

	u32 pcireg, access;

	u16 pcir;

	int i;



	/* enable access to rom */

	if (dev_priv->card_type >= NV_50)

		pci_nv_20 = 0x88050;

		pcireg = 0x088050;

	else

		pci_nv_20 = NV_PBUS_PCI_NV_20;

		pcireg = NV_PBUS_PCI_NV_20;

	access = nv_mask(dev, pcireg, 0x00000001, 0x00000000);



	/* enable ROM access */

	save_pci_nv_20 = nvReadMC(dev, pci_nv_20);

	nvWriteMC(dev, pci_nv_20,

		  save_pci_nv_20 & ~NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED);

	/* bail if no rom signature, with a workaround for a PROM reading

	 * issue on some chipsets.  the first read after a period of

	 * inactivity returns the wrong result, so retry the first header

	 * byte a few times before giving up as a workaround

	 */

	i = 16;

	do {

		if (nv_rd08(dev, NV_PROM_OFFSET + 0) == 0x55)

			break;

	} while (i--);



	/* bail if no rom signature */

	if (nv_rd08(dev, NV_PROM_OFFSET) != 0x55 ||

	    nv_rd08(dev, NV_PROM_OFFSET + 1) != 0xaa)

	if (!i || nv_rd08(dev, NV_PROM_OFFSET + 1) != 0xaa)

		goto out;



	/* additional check (see note below) - read PCI record header */

	pcir_ptr = nv_rd08(dev, NV_PROM_OFFSET + 0x18) |

	pcir = nv_rd08(dev, NV_PROM_OFFSET + 0x18) |

	       nv_rd08(dev, NV_PROM_OFFSET + 0x19) << 8;

	if (nv_rd08(dev, NV_PROM_OFFSET + pcir_ptr) != 'P' ||

	    nv_rd08(dev, NV_PROM_OFFSET + pcir_ptr + 1) != 'C' ||

	    nv_rd08(dev, NV_PROM_OFFSET + pcir_ptr + 2) != 'I' ||

	    nv_rd08(dev, NV_PROM_OFFSET + pcir_ptr + 3) != 'R')

	if (nv_rd08(dev, NV_PROM_OFFSET + pcir + 0) != 'P' ||

	    nv_rd08(dev, NV_PROM_OFFSET + pcir + 1) != 'C' ||

	    nv_rd08(dev, NV_PROM_OFFSET + pcir + 2) != 'I' ||

	    nv_rd08(dev, NV_PROM_OFFSET + pcir + 3) != 'R')

		goto out;



	/* on some 6600GT/6800LE prom reads are messed up.  nvclock alleges a

	 * a good read may be obtained by waiting or re-reading (cargocult: 5x)

	 * each byte.  we'll hope pramin has something usable instead

	 */

	for (i = 0; i < NV_PROM_SIZE; i++)

		data[i] = nv_rd08(dev, NV_PROM_OFFSET + i);

	/* read entire bios image to system memory */

	bios->length = nv_rd08(dev, NV_PROM_OFFSET + 2) * 512;

	bios->data = kmalloc(bios->length, GFP_KERNEL);

	if (bios->data) {

		for (i = 0; i < bios->length; i++)

			bios->data[i] = nv_rd08(dev, NV_PROM_OFFSET + i);

	}



out:

	/* disable ROM access */

	nvWriteMC(dev, pci_nv_20,

		  save_pci_nv_20 | NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED);

	/* disable access to rom */

	nv_wr32(dev, pcireg, access);

}



static void load_vbios_pramin(struct drm_device *dev, uint8_t *data)

static void

bios_shadow_pramin(struct nvbios *bios)

{

	struct drm_device *dev = bios->dev;

	struct drm_nouveau_private *dev_priv = dev->dev_private;

	uint32_t old_bar0_pramin = 0;

	u32 bar0 = 0;

	int i;



	if (dev_priv->card_type >= NV_50) {

		u64 addr = (u64)(nv_rd32(dev, 0x619f04) & 0xffffff00) << 8;

		if (!addr) {

			addr  = (u64)nv_rd32(dev, 0x1700) << 16;

			addr  = (u64)nv_rd32(dev, 0x001700) << 16;

			addr += 0xf0000;

		}



		old_bar0_pramin = nv_rd32(dev, 0x1700);

		nv_wr32(dev, 0x1700, addr >> 16);

		bar0 = nv_mask(dev, 0x001700, 0xffffffff, addr >> 16);

	}



	/* bail if no rom signature */

	if (nv_rd08(dev, NV_PRAMIN_OFFSET) != 0x55 ||

	if (nv_rd08(dev, NV_PRAMIN_OFFSET + 0) != 0x55 ||

	    nv_rd08(dev, NV_PRAMIN_OFFSET + 1) != 0xaa)

		goto out;



	for (i = 0; i < NV_PROM_SIZE; i++)

		data[i] = nv_rd08(dev, NV_PRAMIN_OFFSET + i);

	bios->length = nv_rd08(dev, NV_PRAMIN_OFFSET + 2) * 512;

	bios->data = kmalloc(bios->length, GFP_KERNEL);

	if (bios->data) {

		for (i = 0; i < bios->length; i++)

			bios->data[i] = nv_rd08(dev, NV_PRAMIN_OFFSET + i);

	}



out:

	if (dev_priv->card_type >= NV_50)

		nv_wr32(dev, 0x1700, old_bar0_pramin);

		nv_wr32(dev, 0x001700, bar0);

}



static void load_vbios_pci(struct drm_device *dev, uint8_t *data)

static void

bios_shadow_pci(struct nvbios *bios)

{

	void __iomem *rom = NULL;

	size_t rom_len;

	int ret;

	struct pci_dev *pdev = bios->dev->pdev;

	size_t length;



	ret = pci_enable_rom(dev->pdev);

	if (ret)

		return;



	rom = pci_map_rom(dev->pdev, &rom_len);

	if (!rom)

		goto out;

	memcpy_fromio(data, rom, rom_len);

	pci_unmap_rom(dev->pdev, rom);

	if (!pci_enable_rom(pdev)) {

		void __iomem *rom = pci_map_rom(pdev, &length);

		if (rom) {

			bios->data = kmalloc(length, GFP_KERNEL);

			if (bios->data) {

				memcpy_fromio(bios->data, rom, length);

				bios->length = length;

			}

			pci_unmap_rom(pdev, rom);

		}



out:

	pci_disable_rom(dev->pdev);

		pci_disable_rom(pdev);

	}

}



static void load_vbios_acpi(struct drm_device *dev, uint8_t *data)

static void

bios_shadow_acpi(struct nvbios *bios)

{

	int i;

	int ret;

	int size = 64 * 1024;

	struct pci_dev *pdev = bios->dev->pdev;

	int ptr, len, ret;

	u8 data[3];



	if (!nouveau_acpi_rom_supported(dev->pdev))

	if (!nouveau_acpi_rom_supported(pdev))

		return;



	for (i = 0; i < (size / ROM_BIOS_PAGE); i++) {

		ret = nouveau_acpi_get_bios_chunk(data,

						  (i * ROM_BIOS_PAGE),

						  ROM_BIOS_PAGE);

		if (ret <= 0)

			break;

	}

	ret = nouveau_acpi_get_bios_chunk(data, 0, sizeof(data));

	if (ret != sizeof(data))

		return;



	bios->length = min(data[2] * 512, 65536);

	bios->data = kmalloc(bios->length, GFP_KERNEL);

	if (!bios->data)

		return;



	len = bios->length;

	ptr = 0;

	while (len) {

		int size = (len > ROM_BIOS_PAGE) ? ROM_BIOS_PAGE : len;



		ret = nouveau_acpi_get_bios_chunk(bios->data, ptr, size);

		if (ret != size) {

			kfree(bios->data);

			bios->data = NULL;

			return;

		}



		len -= size;

		ptr += size;

	}

}



struct methods {

	const char desc[8];

	void (*loadbios)(struct drm_device *, uint8_t *);

	void (*shadow)(struct nvbios *);

	const bool rw;

	int score;

	u32 size;

	u8 *data;

};



static struct methods shadow_methods[] = {

	{ "PRAMIN", load_vbios_pramin, true },

	{ "PROM", load_vbios_prom, false },

	{ "ACPI", load_vbios_acpi, true },

	{ "PCIROM", load_vbios_pci, true },

};

#define NUM_SHADOW_METHODS ARRAY_SIZE(shadow_methods)



static bool NVShadowVBIOS(struct drm_device *dev, uint8_t *data)

static bool

bios_shadow(struct drm_device *dev)

{

	struct methods *methods = shadow_methods;

	int testscore = 3;

	int scores[NUM_SHADOW_METHODS], i;

	struct methods shadow_methods[] = {

		{ "PRAMIN", bios_shadow_pramin, true, 0, 0, NULL },

		{ "PROM", bios_shadow_prom, false, 0, 0, NULL },

		{ "ACPI", bios_shadow_acpi, true, 0, 0, NULL },

		{ "PCIROM", bios_shadow_pci, true, 0, 0, NULL },

		{}

	};

	struct drm_nouveau_private *dev_priv = dev->dev_private;

	struct nvbios *bios = &dev_priv->vbios;

	struct methods *mthd, *best;



	if (nouveau_vbios) {

		for (i = 0; i < NUM_SHADOW_METHODS; i++)

			if (!strcasecmp(nouveau_vbios, methods[i].desc))

				break;



		if (i < NUM_SHADOW_METHODS) {

			NV_INFO(dev, "Attempting to use BIOS image from %s\n",

				methods[i].desc);

		mthd = shadow_methods;

		do {

			if (strcasecmp(nouveau_vbios, mthd->desc))

				continue;

			NV_INFO(dev, "VBIOS source: %s\n", mthd->desc);



			methods[i].loadbios(dev, data);

			if (score_vbios(dev, data, methods[i].rw))

			mthd->shadow(bios);

			mthd->score = score_vbios(bios, mthd->rw);

			if (mthd->score)

				return true;

		}

		} while ((++mthd)->shadow);



		NV_ERROR(dev, "VBIOS source \'%s\' invalid\n", nouveau_vbios);

	}



	for (i = 0; i < NUM_SHADOW_METHODS; i++) {

		NV_TRACE(dev, "Attempting to load BIOS image from %s\n",

			 methods[i].desc);

		data[0] = data[1] = 0;	/* avoid reuse of previous image */

		methods[i].loadbios(dev, data);

		scores[i] = score_vbios(dev, data, methods[i].rw);

		if (scores[i] == testscore)

			return true;

	mthd = shadow_methods;

	do {

		NV_TRACE(dev, "Checking %s for VBIOS\n", mthd->desc);

		mthd->shadow(bios);

		mthd->score = score_vbios(bios, mthd->rw);

		mthd->size = bios->length;

		mthd->data = bios->data;

	} while (mthd->score != 3 && (++mthd)->shadow);



	mthd = shadow_methods;

	best = mthd;

	do {

		if (mthd->score > best->score) {

			kfree(best->data);

			best = mthd;

		}

	} while ((++mthd)->shadow);



	while (--testscore > 0) {

		for (i = 0; i < NUM_SHADOW_METHODS; i++) {

			if (scores[i] == testscore) {

				NV_TRACE(dev, "Using BIOS image from %s\n",

					 methods[i].desc);

				methods[i].loadbios(dev, data);

	if (best->score) {

		NV_TRACE(dev, "Using VBIOS from %s\n", best->desc);

		bios->length = best->size;

		bios->data = best->data;

		return true;

	}

		}

	}



	NV_ERROR(dev, "No valid BIOS image found\n");

	NV_ERROR(dev, "No valid VBIOS image found\n");

	return false;

}
@@ -6334,11 +6371,7 @@ static bool NVInitVBIOS(struct drm_device *dev) 
	spin_lock_init(&bios->lock);

	bios->dev = dev;



	if (!NVShadowVBIOS(dev, bios->data))

		return false;



	bios->length = NV_PROM_SIZE;

	return true;

	return bios_shadow(dev);

}



static int nouveau_parse_vbios_struct(struct drm_device *dev)
@@ -6498,6 +6531,10 @@ nouveau_bios_init(struct drm_device *dev) 
void

nouveau_bios_takedown(struct drm_device *dev)

{

	struct drm_nouveau_private *dev_priv = dev->dev_private;



	nouveau_mxm_fini(dev);

	nouveau_i2c_fini(dev);



	kfree(dev_priv->vbios.data);

}

drivers/gpu/drm/nouveau/nouveau_bios.h

+2 −2
Original line number Diff line number Diff line
@@ -211,6 +211,8 @@ struct nvbios { 
		NVBIOS_BIT

	} type;

	uint16_t offset;

	uint32_t length;

	uint8_t *data;



	uint8_t chip_version;
@@ -221,8 +223,6 @@ struct nvbios { 


	spinlock_t lock;



	uint8_t data[NV_PROM_SIZE];

	unsigned int length;

	bool execute;



	uint8_t major_version;

CRA Git | Maintained and supported by SUSTech CRA and CCSE