GNUBoot
/
coreboot-kgpe-d16
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

src: Make implicit fall throughs explicit 

Implicit fall throughs are a perpetual source of bugs and Coverity Scan
issues, so let's squash them once and for all. GCC can flag implicit fall
throughs using the -Wimplicit-fallthrough warning, and this should
ensure no more enter the code base. However, many fall throughs are
intentional, and we can use the following comment style to have GCC
suppress the warning.

    switch (x) {
    case 1:
            y += 1;
	    /* fall through */
    case 2:
            y += 2;
	    /* fall through - but this time with an explanation */
    default:
            y += 3;
    }

This patch adds comments for all remaining intentional fall throughs,
and tweaks some existing fall through comments to fit the syntax that
GCC expects.

Change-Id: I1d75637a434a955a58d166ad203e49620d7395ed
Signed-off-by: Jacob Garber <jgarber1@ualberta.ca>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/34297
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: HAOUAS Elyes <ehaouas@noos.fr>
This commit is contained in:
Jacob Garber 2019-07-12 10:34:06 -06:00 committed by Patrick Georgi
parent 78107939de
commit 4c33a3aaa3
24 changed files with 107 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/console/vtxprintf.c
View File

@ -271,6 +271,7 @@ repeat:
case 'X': case 'X':
flags |= LARGE; flags |= LARGE;
/* fall through */
case 'x': case 'x':
base = 16; base = 16;
break; break;

6
src/lib/edid.c
View File

@ -1207,14 +1207,16 @@ int decode_edid(unsigned char *edid, int size, struct edid *out)
switch (edid[0x13]) { switch (edid[0x13]) {
case 4: case 4:
c.claims_one_point_four = 1; c.claims_one_point_four = 1;
/* fall through */
case 3: case 3:
c.claims_one_point_three = 1; c.claims_one_point_three = 1;
/* fall through */
case 2: case 2:
c.claims_one_point_two = 1; c.claims_one_point_two = 1;
/* fall through */
default: default:
break; c.claims_one_point_oh = 1;
} }
c.claims_one_point_oh = 1;
} }
/* display section */ /* display section */

1
src/soc/nvidia/tegra124/sor.c
View File

@ -237,6 +237,7 @@ static int tegra_dc_sor_power_dplanes(struct tegra_dc_sor_data *sor,
/* fall through */ /* fall through */
case 2: case 2:
reg_val |= NV_SOR_DP_PADCTL_PD_TXD_1_NO; reg_val |= NV_SOR_DP_PADCTL_PD_TXD_1_NO;
/* fall through */
case 1: case 1:
reg_val |= NV_SOR_DP_PADCTL_PD_TXD_0_NO; reg_val |= NV_SOR_DP_PADCTL_PD_TXD_0_NO;
break; break;

6
src/soc/rockchip/rk3288/sdram.c
View File

@ -751,10 +751,8 @@ static void move_to_config_state(struct rk3288_ddr_publ_regs *ddr_publ_regs,
while ((read32(&ddr_publ_regs->pgsr) & PGSR_DLDONE) while ((read32(&ddr_publ_regs->pgsr) & PGSR_DLDONE)
!= PGSR_DLDONE) != PGSR_DLDONE)
; ;
/* if at low power state,need wakeup first, /* if at low power state, need wakeup first, then enter the config */
* and then enter the config /* fall through */
* so here no break.
*/
case ACCESS: case ACCESS:
case INIT_MEM: case INIT_MEM:
write32(&ddr_pctl_regs->sctl, CFG_STATE); write32(&ddr_pctl_regs->sctl, CFG_STATE);

9
src/southbridge/amd/agesa/hudson/hudson.c
View File

@ -117,21 +117,24 @@ void hudson_enable(struct device *dev)
case PCI_DEVFN(0x12, 0): case PCI_DEVFN(0x12, 0):
if (dev->enabled == 0) if (dev->enabled == 0)
hudson_disable_usb(USB_EN_DEVFN_12_0); hudson_disable_usb(USB_EN_DEVFN_12_0);
case PCI_DEVFN(0x12, 2): /* Fall through */ /* fall through */
case PCI_DEVFN(0x12, 2):
if (dev->enabled == 0) if (dev->enabled == 0)
hudson_disable_usb(USB_EN_DEVFN_12_2); hudson_disable_usb(USB_EN_DEVFN_12_2);
break; break;
case PCI_DEVFN(0x13, 0): case PCI_DEVFN(0x13, 0):
if (dev->enabled == 0) if (dev->enabled == 0)
hudson_disable_usb(USB_EN_DEVFN_13_0); hudson_disable_usb(USB_EN_DEVFN_13_0);
case PCI_DEVFN(0x13, 2): /* Fall through */ /* fall through */
case PCI_DEVFN(0x13, 2):
if (dev->enabled == 0) if (dev->enabled == 0)
hudson_disable_usb(USB_EN_DEVFN_13_2); hudson_disable_usb(USB_EN_DEVFN_13_2);
break; break;
case PCI_DEVFN(0x16, 0): case PCI_DEVFN(0x16, 0):
if (dev->enabled == 0) if (dev->enabled == 0)
hudson_disable_usb(USB_EN_DEVFN_16_0); hudson_disable_usb(USB_EN_DEVFN_16_0);
case PCI_DEVFN(0x16, 2): /* Fall through */ /* fall through */
case PCI_DEVFN(0x16, 2):
if (dev->enabled == 0) if (dev->enabled == 0)
hudson_disable_usb(USB_EN_DEVFN_16_2); hudson_disable_usb(USB_EN_DEVFN_16_2);
break; break;

2
src/southbridge/amd/cimx/sb800/lpc.c
View File

@ -172,8 +172,10 @@ void lpc_enable_childrens_resources(struct device *dev)
switch (var_num) { switch (var_num) {
case 3: case 3:
pci_write_config16(dev, 0x90, reg_var[2]); pci_write_config16(dev, 0x90, reg_var[2]);
/* fall through */
case 2: case 2:
pci_write_config16(dev, 0x66, reg_var[1]); pci_write_config16(dev, 0x66, reg_var[1]);
/* fall through */
case 1: case 1:
//pci_write_config16(dev, 0x64, reg_var[0]); //cause filo can not find sata //pci_write_config16(dev, 0x64, reg_var[0]); //cause filo can not find sata
break; break;

2
src/southbridge/amd/cimx/sb900/lpc.c
View File

@ -170,8 +170,10 @@ void lpc_enable_childrens_resources(struct device *dev)
switch (var_num) { switch (var_num) {
case 3: case 3:
pci_write_config16(dev, 0x90, reg_var[2]); pci_write_config16(dev, 0x90, reg_var[2]);
/* fall through */
case 2: case 2:
pci_write_config16(dev, 0x66, reg_var[1]); pci_write_config16(dev, 0x66, reg_var[1]);
/* fall through */
case 1: case 1:
//pci_write_config16(dev, 0x64, reg_var[0]); //cause filo can not find sata //pci_write_config16(dev, 0x64, reg_var[0]); //cause filo can not find sata
break; break;

2
src/southbridge/amd/sb700/lpc.c
View File

@ -230,8 +230,10 @@ static void sb700_lpc_enable_childrens_resources(struct device *dev)
switch (var_num) { switch (var_num) {
case 3: case 3:
pci_write_config16(dev, 0x90, reg_var[2]); pci_write_config16(dev, 0x90, reg_var[2]);
/* fall through */
case 2: case 2:
pci_write_config16(dev, 0x66, reg_var[1]); pci_write_config16(dev, 0x66, reg_var[1]);
/* fall through */
case 1: case 1:
pci_write_config16(dev, 0x64, reg_var[0]); pci_write_config16(dev, 0x64, reg_var[0]);
break; break;

2
src/southbridge/amd/sb800/lpc.c
View File

@ -222,8 +222,10 @@ static void sb800_lpc_enable_childrens_resources(struct device *dev)
switch (var_num) { switch (var_num) {
case 3: case 3:
pci_write_config16(dev, 0x90, reg_var[2]); pci_write_config16(dev, 0x90, reg_var[2]);
/* fall through */
case 2: case 2:
pci_write_config16(dev, 0x66, reg_var[1]); pci_write_config16(dev, 0x66, reg_var[1]);
/* fall through */
case 1: case 1:
pci_write_config16(dev, 0x64, reg_var[0]); pci_write_config16(dev, 0x64, reg_var[0]);
break; break;

32
src/vendorcode/amd/agesa/f12/Proc/CPU/S3.c
View File

@ -225,25 +225,25 @@ SaveDeviceContext (
switch (Device.CommonDeviceHeader->Type) { switch (Device.CommonDeviceHeader->Type) {
case DEV_TYPE_PCI_PRE_ESR: case DEV_TYPE_PCI_PRE_ESR:
SavePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMask); SavePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_PCI: case DEV_TYPE_PCI:
Device.PciDevice++; Device.PciDevice++;
break; break;
case DEV_TYPE_CPCI_PRE_ESR: case DEV_TYPE_CPCI_PRE_ESR:
SaveConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMask); SaveConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_CPCI: case DEV_TYPE_CPCI:
Device.CPciDevice++; Device.CPciDevice++;
break; break;
case DEV_TYPE_MSR_PRE_ESR: case DEV_TYPE_MSR_PRE_ESR:
SaveMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMask); SaveMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_MSR: case DEV_TYPE_MSR:
Device.MsrDevice++; Device.MsrDevice++;
break; break;
case DEV_TYPE_CMSR_PRE_ESR: case DEV_TYPE_CMSR_PRE_ESR:
SaveConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMask); SaveConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_CMSR: case DEV_TYPE_CMSR:
Device.CMsrDevice++; Device.CMsrDevice++;
break; break;
@ -256,25 +256,25 @@ SaveDeviceContext (
switch (Device.CommonDeviceHeader->Type) { switch (Device.CommonDeviceHeader->Type) {
case DEV_TYPE_PCI: case DEV_TYPE_PCI:
SavePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMask); SavePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_PCI_PRE_ESR: case DEV_TYPE_PCI_PRE_ESR:
Device.PciDevice++; Device.PciDevice++;
break; break;
case DEV_TYPE_CPCI: case DEV_TYPE_CPCI:
SaveConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMask); SaveConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_CPCI_PRE_ESR: case DEV_TYPE_CPCI_PRE_ESR:
Device.CPciDevice++; Device.CPciDevice++;
break; break;
case DEV_TYPE_MSR: case DEV_TYPE_MSR:
SaveMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMask); SaveMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_MSR_PRE_ESR: case DEV_TYPE_MSR_PRE_ESR:
Device.MsrDevice++; Device.MsrDevice++;
break; break;
case DEV_TYPE_CMSR: case DEV_TYPE_CMSR:
SaveConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMask); SaveConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_CMSR_PRE_ESR: case DEV_TYPE_CMSR_PRE_ESR:
Device.CMsrDevice++; Device.CMsrDevice++;
break; break;
@ -679,25 +679,25 @@ RestorePreESRContext (
switch (Device.CommonDeviceHeader->Type) { switch (Device.CommonDeviceHeader->Type) {
case DEV_TYPE_PCI_PRE_ESR: case DEV_TYPE_PCI_PRE_ESR:
RestorePciDevice (StdHeader, Device.PciDevice, CallPoint, OrMaskPtr); RestorePciDevice (StdHeader, Device.PciDevice, CallPoint, OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_PCI: case DEV_TYPE_PCI:
Device.PciDevice++; Device.PciDevice++;
break; break;
case DEV_TYPE_CPCI_PRE_ESR: case DEV_TYPE_CPCI_PRE_ESR:
RestoreConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, OrMaskPtr); RestoreConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_CPCI: case DEV_TYPE_CPCI:
Device.CPciDevice++; Device.CPciDevice++;
break; break;
case DEV_TYPE_MSR_PRE_ESR: case DEV_TYPE_MSR_PRE_ESR:
RestoreMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) OrMaskPtr); RestoreMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_MSR: case DEV_TYPE_MSR:
Device.MsrDevice++; Device.MsrDevice++;
break; break;
case DEV_TYPE_CMSR_PRE_ESR: case DEV_TYPE_CMSR_PRE_ESR:
RestoreConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) OrMaskPtr); RestoreConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_CMSR: case DEV_TYPE_CMSR:
Device.CMsrDevice++; Device.CMsrDevice++;
break; break;
@ -739,25 +739,25 @@ RestorePostESRContext (
switch (Device.CommonDeviceHeader->Type) { switch (Device.CommonDeviceHeader->Type) {
case DEV_TYPE_PCI: case DEV_TYPE_PCI:
RestorePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMaskPtr); RestorePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_PCI_PRE_ESR: case DEV_TYPE_PCI_PRE_ESR:
Device.PciDevice++; Device.PciDevice++;
break; break;
case DEV_TYPE_CPCI: case DEV_TYPE_CPCI:
RestoreConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMaskPtr); RestoreConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_CPCI_PRE_ESR: case DEV_TYPE_CPCI_PRE_ESR:
Device.CPciDevice++; Device.CPciDevice++;
break; break;
case DEV_TYPE_MSR: case DEV_TYPE_MSR:
RestoreMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMaskPtr); RestoreMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_MSR_PRE_ESR: case DEV_TYPE_MSR_PRE_ESR:
Device.MsrDevice++; Device.MsrDevice++;
break; break;
case DEV_TYPE_CMSR: case DEV_TYPE_CMSR:
RestoreConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMaskPtr); RestoreConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_CMSR_PRE_ESR: case DEV_TYPE_CMSR_PRE_ESR:
Device.CMsrDevice++; Device.CMsrDevice++;
break; break;

6
src/vendorcode/amd/agesa/f12/Proc/Mem/Main/muc.c
View File

@ -212,8 +212,7 @@ MemUFillTrainPattern (
break; break;
case TestPatternJD256B: case TestPatternJD256B:
k >>= 1; k >>= 1;
// break is not being used here because TestPatternJD256B also need // fall through - TestPatternJD256B also need to run TestPatternJD256A sequence
// to run TestPatternJD256A sequence.
case TestPatternJD256A: case TestPatternJD256A:
k >>= 3; k >>= 3;
ASSERT (k < sizeof (PatternJD_256)); ASSERT (k < sizeof (PatternJD_256));
@ -221,8 +220,7 @@ MemUFillTrainPattern (
break; break;
case TestPatternJD1B: case TestPatternJD1B:
k >>= 1; k >>= 1;
// break is not being used here because TestPatternJD1B also need // fall through - TestPatternJD1B also need to run TestPatternJD1A sequence
// to run TestPatternJD1A sequence.
case TestPatternJD1A: case TestPatternJD1A:
k >>= 3; k >>= 3;
i = (UINT8) (k >> 3); i = (UINT8) (k >> 3);

9
src/vendorcode/amd/agesa/f12/Proc/Mem/NB/mnphy.c
View File

@ -691,8 +691,7 @@ MemNcmnGetSetTrainDlyNb (
} else if (Rank) { } else if (Rank) {
Index += 0x60; Index += 0x60;
} }
// break is not being used here because AccessRdDqsDly and AccessWrDatDly also need // fall through - AccessRdDqsDly and AccessWrDatDly also need to run AccessPhRecDly sequence
// to run AccessPhRecDly sequence.
case AccessPhRecDly: case AccessPhRecDly:
Index += (Byte / 4); Index += (Byte / 4);
Offset = 8 * (Byte % 4); Offset = 8 * (Byte % 4);
@ -818,8 +817,7 @@ MemNcmnGetSetTrainDlyClientNb (
case AccessRdDqsDly: case AccessRdDqsDly:
case AccessWrDatDly: case AccessWrDatDly:
Index += (Dimm * 0x100); Index += (Dimm * 0x100);
// break is not being used here because AccessRdDqsDly and AccessWrDatDly also need // fall through - AccessRdDqsDly and AccessWrDatDly also need to run AccessPhRecDly sequence
// to run AccessPhRecDly sequence.
case AccessPhRecDly: case AccessPhRecDly:
Index += (Byte / 4); Index += (Byte / 4);
Offset = 8 * (Byte % 4); Offset = 8 * (Byte % 4);
@ -967,8 +965,7 @@ MemNcmnGetSetTrainDlyUnb (
} else if (Rank) { } else if (Rank) {
Index += 0x60; Index += 0x60;
} }
// break is not being used here because AccessRdDqsDly and AccessWrDatDly also need // fall through - AccessRdDqsDly and AccessWrDatDly also need to run AccessPhRecDly sequence
// to run AccessPhRecDly sequence.
case AccessPhRecDly: case AccessPhRecDly:
Index += (Byte / 4); Index += (Byte / 4);
Offset = 8 * (Byte % 4); Offset = 8 * (Byte % 4);

32
src/vendorcode/amd/agesa/f14/Proc/CPU/S3.c
View File

@ -227,25 +227,25 @@ SaveDeviceContext (
switch (Device.CommonDeviceHeader->Type) { switch (Device.CommonDeviceHeader->Type) {
case DEV_TYPE_PCI_PRE_ESR: case DEV_TYPE_PCI_PRE_ESR:
SavePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMask); SavePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_PCI: case DEV_TYPE_PCI:
Device.PciDevice++; Device.PciDevice++;
break; break;
case DEV_TYPE_CPCI_PRE_ESR: case DEV_TYPE_CPCI_PRE_ESR:
SaveConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMask); SaveConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_CPCI: case DEV_TYPE_CPCI:
Device.CPciDevice++; Device.CPciDevice++;
break; break;
case DEV_TYPE_MSR_PRE_ESR: case DEV_TYPE_MSR_PRE_ESR:
SaveMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMask); SaveMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_MSR: case DEV_TYPE_MSR:
Device.MsrDevice++; Device.MsrDevice++;
break; break;
case DEV_TYPE_CMSR_PRE_ESR: case DEV_TYPE_CMSR_PRE_ESR:
SaveConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMask); SaveConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_CMSR: case DEV_TYPE_CMSR:
Device.CMsrDevice++; Device.CMsrDevice++;
break; break;
@ -258,25 +258,25 @@ SaveDeviceContext (
switch (Device.CommonDeviceHeader->Type) { switch (Device.CommonDeviceHeader->Type) {
case DEV_TYPE_PCI: case DEV_TYPE_PCI:
SavePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMask); SavePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_PCI_PRE_ESR: case DEV_TYPE_PCI_PRE_ESR:
Device.PciDevice++; Device.PciDevice++;
break; break;
case DEV_TYPE_CPCI: case DEV_TYPE_CPCI:
SaveConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMask); SaveConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_CPCI_PRE_ESR: case DEV_TYPE_CPCI_PRE_ESR:
Device.CPciDevice++; Device.CPciDevice++;
break; break;
case DEV_TYPE_MSR: case DEV_TYPE_MSR:
SaveMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMask); SaveMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_MSR_PRE_ESR: case DEV_TYPE_MSR_PRE_ESR:
Device.MsrDevice++; Device.MsrDevice++;
break; break;
case DEV_TYPE_CMSR: case DEV_TYPE_CMSR:
SaveConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMask); SaveConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_CMSR_PRE_ESR: case DEV_TYPE_CMSR_PRE_ESR:
Device.CMsrDevice++; Device.CMsrDevice++;
break; break;
@ -673,25 +673,25 @@ RestorePreESRContext (
switch (Device.CommonDeviceHeader->Type) { switch (Device.CommonDeviceHeader->Type) {
case DEV_TYPE_PCI_PRE_ESR: case DEV_TYPE_PCI_PRE_ESR:
RestorePciDevice (StdHeader, Device.PciDevice, CallPoint, OrMaskPtr); RestorePciDevice (StdHeader, Device.PciDevice, CallPoint, OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_PCI: case DEV_TYPE_PCI:
Device.PciDevice++; Device.PciDevice++;
break; break;
case DEV_TYPE_CPCI_PRE_ESR: case DEV_TYPE_CPCI_PRE_ESR:
RestoreConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, OrMaskPtr); RestoreConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_CPCI: case DEV_TYPE_CPCI:
Device.CPciDevice++; Device.CPciDevice++;
break; break;
case DEV_TYPE_MSR_PRE_ESR: case DEV_TYPE_MSR_PRE_ESR:
RestoreMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) OrMaskPtr); RestoreMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_MSR: case DEV_TYPE_MSR:
Device.MsrDevice++; Device.MsrDevice++;
break; break;
case DEV_TYPE_CMSR_PRE_ESR: case DEV_TYPE_CMSR_PRE_ESR:
RestoreConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) OrMaskPtr); RestoreConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_CMSR: case DEV_TYPE_CMSR:
Device.CMsrDevice++; Device.CMsrDevice++;
break; break;
@ -733,25 +733,25 @@ RestorePostESRContext (
switch (Device.CommonDeviceHeader->Type) { switch (Device.CommonDeviceHeader->Type) {
case DEV_TYPE_PCI: case DEV_TYPE_PCI:
RestorePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMaskPtr); RestorePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_PCI_PRE_ESR: case DEV_TYPE_PCI_PRE_ESR:
Device.PciDevice++; Device.PciDevice++;
break; break;
case DEV_TYPE_CPCI: case DEV_TYPE_CPCI:
RestoreConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMaskPtr); RestoreConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_CPCI_PRE_ESR: case DEV_TYPE_CPCI_PRE_ESR:
Device.CPciDevice++; Device.CPciDevice++;
break; break;
case DEV_TYPE_MSR: case DEV_TYPE_MSR:
RestoreMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMaskPtr); RestoreMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_MSR_PRE_ESR: case DEV_TYPE_MSR_PRE_ESR:
Device.MsrDevice++; Device.MsrDevice++;
break; break;
case DEV_TYPE_CMSR: case DEV_TYPE_CMSR:
RestoreConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMaskPtr); RestoreConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_CMSR_PRE_ESR: case DEV_TYPE_CMSR_PRE_ESR:
Device.CMsrDevice++; Device.CMsrDevice++;
break; break;

6
src/vendorcode/amd/agesa/f14/Proc/Mem/Main/muc.c
View File

@ -213,8 +213,7 @@ MemUFillTrainPattern (
break; break;
case TestPatternJD256B: case TestPatternJD256B:
k >>= 1; k >>= 1;
// break is not being used here because TestPatternJD256B also need // fall through - TestPatternJD256B also need to run TestPatternJD256A sequence
// to run TestPatternJD256A sequence.
case TestPatternJD256A: case TestPatternJD256A:
k >>= 3; k >>= 3;
ASSERT (k < sizeof (PatternJD_256)); ASSERT (k < sizeof (PatternJD_256));
@ -222,8 +221,7 @@ MemUFillTrainPattern (
break; break;
case TestPatternJD1B: case TestPatternJD1B:
k >>= 1; k >>= 1;
// break is not being used here because TestPatternJD1B also need // fall through - TestPatternJD1B also need to run TestPatternJD1A sequence
// to run TestPatternJD1A sequence.
case TestPatternJD1A: case TestPatternJD1A:
k >>= 3; k >>= 3;
i = (UINT8) (k >> 3); i = (UINT8) (k >> 3);

6
src/vendorcode/amd/agesa/f14/Proc/Mem/NB/mnphy.c
View File

@ -695,8 +695,7 @@ MemNcmnGetSetTrainDlyNb (
} else if (Rank) { } else if (Rank) {
Index += 0x60; Index += 0x60;
} }
// break is not being used here because AccessRdDqsDly and AccessWrDatDly also need // fall through - AccessRdDqsDly and AccessWrDatDly also need to run AccessPhRecDly sequence
// to run AccessPhRecDly sequence.
case AccessPhRecDly: case AccessPhRecDly:
Index += (Byte / 4); Index += (Byte / 4);
Offset = 8 * (Byte % 4); Offset = 8 * (Byte % 4);
@ -822,8 +821,7 @@ MemNcmnGetSetTrainDlyClientNb (
case AccessRdDqsDly: case AccessRdDqsDly:
case AccessWrDatDly: case AccessWrDatDly:
Index += (Dimm * 0x100); Index += (Dimm * 0x100);
// break is not being used here because AccessRdDqsDly and AccessWrDatDly also need // fall through - AccessRdDqsDly and AccessWrDatDly also need to run AccessPhRecDly sequence
// to run AccessPhRecDly sequence.
case AccessPhRecDly: case AccessPhRecDly:
Index += (Byte / 4); Index += (Byte / 4);
Offset = 8 * (Byte % 4); Offset = 8 * (Byte % 4);

32
src/vendorcode/amd/agesa/f15tn/Proc/CPU/S3.c
View File

@ -224,25 +224,25 @@ SaveDeviceContext (
switch (Device.CommonDeviceHeader->Type) { switch (Device.CommonDeviceHeader->Type) {
case DEV_TYPE_PCI_PRE_ESR: case DEV_TYPE_PCI_PRE_ESR:
SavePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMask); SavePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_PCI: case DEV_TYPE_PCI:
Device.PciDevice++; Device.PciDevice++;
break; break;
case DEV_TYPE_CPCI_PRE_ESR: case DEV_TYPE_CPCI_PRE_ESR:
SaveConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMask); SaveConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_CPCI: case DEV_TYPE_CPCI:
Device.CPciDevice++; Device.CPciDevice++;
break; break;
case DEV_TYPE_MSR_PRE_ESR: case DEV_TYPE_MSR_PRE_ESR:
SaveMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMask); SaveMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_MSR: case DEV_TYPE_MSR:
Device.MsrDevice++; Device.MsrDevice++;
break; break;
case DEV_TYPE_CMSR_PRE_ESR: case DEV_TYPE_CMSR_PRE_ESR:
SaveConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMask); SaveConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_CMSR: case DEV_TYPE_CMSR:
Device.CMsrDevice++; Device.CMsrDevice++;
break; break;
@ -255,25 +255,25 @@ SaveDeviceContext (
switch (Device.CommonDeviceHeader->Type) { switch (Device.CommonDeviceHeader->Type) {
case DEV_TYPE_PCI: case DEV_TYPE_PCI:
SavePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMask); SavePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_PCI_PRE_ESR: case DEV_TYPE_PCI_PRE_ESR:
Device.PciDevice++; Device.PciDevice++;
break; break;
case DEV_TYPE_CPCI: case DEV_TYPE_CPCI:
SaveConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMask); SaveConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_CPCI_PRE_ESR: case DEV_TYPE_CPCI_PRE_ESR:
Device.CPciDevice++; Device.CPciDevice++;
break; break;
case DEV_TYPE_MSR: case DEV_TYPE_MSR:
SaveMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMask); SaveMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_MSR_PRE_ESR: case DEV_TYPE_MSR_PRE_ESR:
Device.MsrDevice++; Device.MsrDevice++;
break; break;
case DEV_TYPE_CMSR: case DEV_TYPE_CMSR:
SaveConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMask); SaveConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_CMSR_PRE_ESR: case DEV_TYPE_CMSR_PRE_ESR:
Device.CMsrDevice++; Device.CMsrDevice++;
break; break;
@ -678,25 +678,25 @@ RestorePreESRContext (
switch (Device.CommonDeviceHeader->Type) { switch (Device.CommonDeviceHeader->Type) {
case DEV_TYPE_PCI_PRE_ESR: case DEV_TYPE_PCI_PRE_ESR:
RestorePciDevice (StdHeader, Device.PciDevice, CallPoint, OrMaskPtr); RestorePciDevice (StdHeader, Device.PciDevice, CallPoint, OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_PCI: case DEV_TYPE_PCI:
Device.PciDevice++; Device.PciDevice++;
break; break;
case DEV_TYPE_CPCI_PRE_ESR: case DEV_TYPE_CPCI_PRE_ESR:
RestoreConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, OrMaskPtr); RestoreConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_CPCI: case DEV_TYPE_CPCI:
Device.CPciDevice++; Device.CPciDevice++;
break; break;
case DEV_TYPE_MSR_PRE_ESR: case DEV_TYPE_MSR_PRE_ESR:
RestoreMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) OrMaskPtr); RestoreMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_MSR: case DEV_TYPE_MSR:
Device.MsrDevice++; Device.MsrDevice++;
break; break;
case DEV_TYPE_CMSR_PRE_ESR: case DEV_TYPE_CMSR_PRE_ESR:
RestoreConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) OrMaskPtr); RestoreConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_CMSR: case DEV_TYPE_CMSR:
Device.CMsrDevice++; Device.CMsrDevice++;
break; break;
@ -738,25 +738,25 @@ RestorePostESRContext (
switch (Device.CommonDeviceHeader->Type) { switch (Device.CommonDeviceHeader->Type) {
case DEV_TYPE_PCI: case DEV_TYPE_PCI:
RestorePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMaskPtr); RestorePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_PCI_PRE_ESR: case DEV_TYPE_PCI_PRE_ESR:
Device.PciDevice++; Device.PciDevice++;
break; break;
case DEV_TYPE_CPCI: case DEV_TYPE_CPCI:
RestoreConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMaskPtr); RestoreConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_CPCI_PRE_ESR: case DEV_TYPE_CPCI_PRE_ESR:
Device.CPciDevice++; Device.CPciDevice++;
break; break;
case DEV_TYPE_MSR: case DEV_TYPE_MSR:
RestoreMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMaskPtr); RestoreMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_MSR_PRE_ESR: case DEV_TYPE_MSR_PRE_ESR:
Device.MsrDevice++; Device.MsrDevice++;
break; break;
case DEV_TYPE_CMSR: case DEV_TYPE_CMSR:
RestoreConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMaskPtr); RestoreConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_CMSR_PRE_ESR: case DEV_TYPE_CMSR_PRE_ESR:
Device.CMsrDevice++; Device.CMsrDevice++;
break; break;

4
src/vendorcode/amd/agesa/f15tn/Proc/IDS/Debug/IdsDebugPrint.c
View File

@ -372,9 +372,7 @@ AmdIdsDebugPrintWorker (
case 'X': case 'X':
Flags |= PREFIX_ZERO; Flags |= PREFIX_ZERO;
Width = sizeof (UINT64) * 2; Width = sizeof (UINT64) * 2;
// // fall through
// break skipped on purpose
//
case 'x': case 'x':
if ((Flags & LONG_TYPE) == LONG_TYPE) { if ((Flags & LONG_TYPE) == LONG_TYPE) {
Value = VA_ARG (Marker, UINT64); Value = VA_ARG (Marker, UINT64);

6
src/vendorcode/amd/agesa/f15tn/Proc/Mem/Main/muc.c
View File

@ -211,8 +211,7 @@ MemUFillTrainPattern (
break; break;
case TestPatternJD256B: case TestPatternJD256B:
k >>= 1; k >>= 1;
// break is not being used here because TestPatternJD256B also need // fall through - TestPatternJD256B also need to run TestPatternJD256A sequence
// to run TestPatternJD256A sequence.
case TestPatternJD256A: case TestPatternJD256A:
k >>= 3; k >>= 3;
ASSERT (k < sizeof (PatternJD_256)); ASSERT (k < sizeof (PatternJD_256));
@ -220,8 +219,7 @@ MemUFillTrainPattern (
break; break;
case TestPatternJD1B: case TestPatternJD1B:
k >>= 1; k >>= 1;
// break is not being used here because TestPatternJD1B also need // fall through - TestPatternJD1B also need to run TestPatternJD1A sequence
// to run TestPatternJD1A sequence.
case TestPatternJD1A: case TestPatternJD1A:
k >>= 3; k >>= 3;
i = (UINT8) (k >> 3); i = (UINT8) (k >> 3);

9
src/vendorcode/amd/agesa/f15tn/Proc/Mem/NB/mnphy.c
View File

@ -693,8 +693,7 @@ MemNcmnGetSetTrainDlyNb (
} else if (Rank) { } else if (Rank) {
Index += 0x60; Index += 0x60;
} }
// break is not being used here because AccessRdDqsDly and AccessWrDatDly also need // fall through - AccessRdDqsDly and AccessWrDatDly also need to run AccessPhRecDly sequence
// to run AccessPhRecDly sequence.
case AccessPhRecDly: case AccessPhRecDly:
Index += (Byte / 4); Index += (Byte / 4);
Offset = 8 * (Byte % 4); Offset = 8 * (Byte % 4);
@ -820,8 +819,7 @@ MemNcmnGetSetTrainDlyClientNb (
case AccessRdDqsDly: case AccessRdDqsDly:
case AccessWrDatDly: case AccessWrDatDly:
Index += (Dimm * 0x100); Index += (Dimm * 0x100);
// break is not being used here because AccessRdDqsDly and AccessWrDatDly also need // fall through - AccessRdDqsDly and AccessWrDatDly also need to run AccessPhRecDly sequence
// to run AccessPhRecDly sequence.
case AccessPhRecDly: case AccessPhRecDly:
Index += (Byte / 4); Index += (Byte / 4);
Offset = 8 * (Byte % 4); Offset = 8 * (Byte % 4);
@ -975,8 +973,7 @@ MemNcmnGetSetTrainDlyUnb (
} else if (Rank) { } else if (Rank) {
Index += 0x60; Index += 0x60;
} }
// break is not being used here because AccessRdDqsDly and AccessWrDatDly also need // fall through - AccessRdDqsDly and AccessWrDatDly also need to run AccessPhRecDly sequence
// to run AccessPhRecDly sequence.
case AccessPhRecDly: case AccessPhRecDly:
Index += (Byte / 4); Index += (Byte / 4);
Offset = 8 * (Byte % 4); Offset = 8 * (Byte % 4);

2
src/vendorcode/amd/agesa/f16kb/Proc/CPU/Family/0x16/KB/F16KbUtilities.c
View File

@ -242,9 +242,11 @@ F16KbSetDownCoreRegister (
case CORE_LEVEL_COMPUTE_UNIT_THREE: case CORE_LEVEL_COMPUTE_UNIT_THREE:
TempVar32_a = TempVar32_a << 1; TempVar32_a = TempVar32_a << 1;
CoresPerComputeUnit++; CoresPerComputeUnit++;
// fall through
case CORE_LEVEL_COMPUTE_UNIT_TWO: case CORE_LEVEL_COMPUTE_UNIT_TWO:
TempVar32_a = TempVar32_a << 1; TempVar32_a = TempVar32_a << 1;
CoresPerComputeUnit++; CoresPerComputeUnit++;
// fall through
case CORE_LEVEL_COMPUTE_UNIT: case CORE_LEVEL_COMPUTE_UNIT:
TempVar32_a = (TempVar32_a << 1) - 1; TempVar32_a = (TempVar32_a << 1) - 1;
TempVar32_a = FOUR_CORE_COMPUTE_UNIT_BITMAP & (~TempVar32_a); TempVar32_a = FOUR_CORE_COMPUTE_UNIT_BITMAP & (~TempVar32_a);

32
src/vendorcode/amd/agesa/f16kb/Proc/CPU/S3.c
View File

@ -224,25 +224,25 @@ SaveDeviceContext (
switch (Device.CommonDeviceHeader->Type) { switch (Device.CommonDeviceHeader->Type) {
case DEV_TYPE_PCI_PRE_ESR: case DEV_TYPE_PCI_PRE_ESR:
SavePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMask); SavePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_PCI: case DEV_TYPE_PCI:
Device.PciDevice++; Device.PciDevice++;
break; break;
case DEV_TYPE_CPCI_PRE_ESR: case DEV_TYPE_CPCI_PRE_ESR:
SaveConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMask); SaveConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_CPCI: case DEV_TYPE_CPCI:
Device.CPciDevice++; Device.CPciDevice++;
break; break;
case DEV_TYPE_MSR_PRE_ESR: case DEV_TYPE_MSR_PRE_ESR:
SaveMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMask); SaveMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_MSR: case DEV_TYPE_MSR:
Device.MsrDevice++; Device.MsrDevice++;
break; break;
case DEV_TYPE_CMSR_PRE_ESR: case DEV_TYPE_CMSR_PRE_ESR:
SaveConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMask); SaveConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_CMSR: case DEV_TYPE_CMSR:
Device.CMsrDevice++; Device.CMsrDevice++;
break; break;
@ -255,25 +255,25 @@ SaveDeviceContext (
switch (Device.CommonDeviceHeader->Type) { switch (Device.CommonDeviceHeader->Type) {
case DEV_TYPE_PCI: case DEV_TYPE_PCI:
SavePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMask); SavePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_PCI_PRE_ESR: case DEV_TYPE_PCI_PRE_ESR:
Device.PciDevice++; Device.PciDevice++;
break; break;
case DEV_TYPE_CPCI: case DEV_TYPE_CPCI:
SaveConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMask); SaveConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_CPCI_PRE_ESR: case DEV_TYPE_CPCI_PRE_ESR:
Device.CPciDevice++; Device.CPciDevice++;
break; break;
case DEV_TYPE_MSR: case DEV_TYPE_MSR:
SaveMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMask); SaveMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_MSR_PRE_ESR: case DEV_TYPE_MSR_PRE_ESR:
Device.MsrDevice++; Device.MsrDevice++;
break; break;
case DEV_TYPE_CMSR: case DEV_TYPE_CMSR:
SaveConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMask); SaveConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMask);
// Fall through to advance the pointer after saving context // fall through - advance the pointer after saving context
case DEV_TYPE_CMSR_PRE_ESR: case DEV_TYPE_CMSR_PRE_ESR:
Device.CMsrDevice++; Device.CMsrDevice++;
break; break;
@ -678,25 +678,25 @@ RestorePreESRContext (
switch (Device.CommonDeviceHeader->Type) { switch (Device.CommonDeviceHeader->Type) {
case DEV_TYPE_PCI_PRE_ESR: case DEV_TYPE_PCI_PRE_ESR:
RestorePciDevice (StdHeader, Device.PciDevice, CallPoint, OrMaskPtr); RestorePciDevice (StdHeader, Device.PciDevice, CallPoint, OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_PCI: case DEV_TYPE_PCI:
Device.PciDevice++; Device.PciDevice++;
break; break;
case DEV_TYPE_CPCI_PRE_ESR: case DEV_TYPE_CPCI_PRE_ESR:
RestoreConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, OrMaskPtr); RestoreConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_CPCI: case DEV_TYPE_CPCI:
Device.CPciDevice++; Device.CPciDevice++;
break; break;
case DEV_TYPE_MSR_PRE_ESR: case DEV_TYPE_MSR_PRE_ESR:
RestoreMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) OrMaskPtr); RestoreMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_MSR: case DEV_TYPE_MSR:
Device.MsrDevice++; Device.MsrDevice++;
break; break;
case DEV_TYPE_CMSR_PRE_ESR: case DEV_TYPE_CMSR_PRE_ESR:
RestoreConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) OrMaskPtr); RestoreConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_CMSR: case DEV_TYPE_CMSR:
Device.CMsrDevice++; Device.CMsrDevice++;
break; break;
@ -738,25 +738,25 @@ RestorePostESRContext (
switch (Device.CommonDeviceHeader->Type) { switch (Device.CommonDeviceHeader->Type) {
case DEV_TYPE_PCI: case DEV_TYPE_PCI:
RestorePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMaskPtr); RestorePciDevice (StdHeader, Device.PciDevice, CallPoint, &OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_PCI_PRE_ESR: case DEV_TYPE_PCI_PRE_ESR:
Device.PciDevice++; Device.PciDevice++;
break; break;
case DEV_TYPE_CPCI: case DEV_TYPE_CPCI:
RestoreConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMaskPtr); RestoreConditionalPciDevice (StdHeader, Device.CPciDevice, CallPoint, &OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_CPCI_PRE_ESR: case DEV_TYPE_CPCI_PRE_ESR:
Device.CPciDevice++; Device.CPciDevice++;
break; break;
case DEV_TYPE_MSR: case DEV_TYPE_MSR:
RestoreMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMaskPtr); RestoreMsrDevice (StdHeader, Device.MsrDevice, CallPoint, (UINT64 **) &OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_MSR_PRE_ESR: case DEV_TYPE_MSR_PRE_ESR:
Device.MsrDevice++; Device.MsrDevice++;
break; break;
case DEV_TYPE_CMSR: case DEV_TYPE_CMSR:
RestoreConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMaskPtr); RestoreConditionalMsrDevice (StdHeader, Device.CMsrDevice, CallPoint, (UINT64 **) &OrMaskPtr);
// Fall through to advance the pointer after restoring context // fall through - advance the pointer after restoring context
case DEV_TYPE_CMSR_PRE_ESR: case DEV_TYPE_CMSR_PRE_ESR:
Device.CMsrDevice++; Device.CMsrDevice++;
break; break;

4
src/vendorcode/amd/agesa/f16kb/Proc/IDS/Debug/IdsDebugPrint.c
View File

@ -375,9 +375,7 @@ AmdIdsDebugPrintWorker (
case 'X': case 'X':
Flags |= PREFIX_ZERO; Flags |= PREFIX_ZERO;
Width = sizeof (UINT64) * 2; Width = sizeof (UINT64) * 2;
// // fall through
// break skipped on purpose
//
case 'x': case 'x':
if ((Flags & LONG_TYPE) == LONG_TYPE) { if ((Flags & LONG_TYPE) == LONG_TYPE) {
Value = VA_ARG (Marker, UINT64); Value = VA_ARG (Marker, UINT64);

6
src/vendorcode/amd/agesa/f16kb/Proc/Mem/Main/muc.c
View File

@ -211,8 +211,7 @@ MemUFillTrainPattern (
break; break;
case TestPatternJD256B: case TestPatternJD256B:
k >>= 1; k >>= 1;
// break is not being used here because TestPatternJD256B also need // fall through - TestPatternJD256B also need to run TestPatternJD256A sequence
// to run TestPatternJD256A sequence.
case TestPatternJD256A: case TestPatternJD256A:
k >>= 3; k >>= 3;
ASSERT (k < sizeof (PatternJD_256)); ASSERT (k < sizeof (PatternJD_256));
@ -220,8 +219,7 @@ MemUFillTrainPattern (
break; break;
case TestPatternJD1B: case TestPatternJD1B:
k >>= 1; k >>= 1;
// break is not being used here because TestPatternJD1B also need // fall through - TestPatternJD1B also need to run TestPatternJD1A sequence
// to run TestPatternJD1A sequence.
case TestPatternJD1A: case TestPatternJD1A:
k >>= 3; k >>= 3;
i = (UINT8) (k >> 3); i = (UINT8) (k >> 3);

3
src/vendorcode/amd/agesa/f16kb/Proc/Mem/NB/mnphy.c
View File

@ -487,8 +487,7 @@ MemNcmnGetSetTrainDlyUnb (
} else if (Rank) { } else if (Rank) {
Index += 0x60; Index += 0x60;
} }
// break is not being used here because AccessRdDqsDly and AccessWrDatDly also need // fall through - AccessRdDqsDly and AccessWrDatDly also need to run AccessPhRecDly sequence
// to run AccessPhRecDly sequence.
case AccessPhRecDly: case AccessPhRecDly:
Index += (Byte / 4); Index += (Byte / 4);
Offset = 8 * (Byte % 4); Offset = 8 * (Byte % 4);