8d8799a33a
We've seen an increasing need to reduce stack sizes more and more for space reasons, and it's always guesswork because no one has a good idea how little is too litte. We now have boards with 3K and 2K stacks, and old pieces of common code often allocate large temporary buffers that would lead to very dangerous and hard to detect bugs when someone eventually tries to use them on one of those. This patch tries improve this situation at least a bit by declaring 2K as the minimum stack size all of coreboot code should work with. It checks all function frames with -Wstack-usage=1536 to make sure we don't allocate more than 1.5K in a single buffer. This is of course not a perfect test, but it should catch the most common situation of declaring a single, large buffer in some close-to-leaf function (with the assumption that 0.5K is hopefully enough for all the "normal" functions above that). Change one example where we were a bit overzealous and put a 1K buffer into BSS back to stack allocation, since it actually conforms to this new assumption and frees up another kilobyte of that highly sought-after verstage space. Not touching x86 with any of this since it's lack of __PRE_RAM__ BSS often requires it to allocate way more on the stack than would usually be considered sane. BRANCH=veyron BUG=None TEST=Compiled Cosmos, Daisy, Falco, Blaze, Pit, Storm, Urara and Pinky, made sure they still build as well as before and don't show any stack usage warnings. Change-Id: Idc53d33bd8487bbef49d3ecd751914b0308006ec Signed-off-by: Patrick Georgi <pgeorgi@chromium.org> Original-Commit-Id: 8e5931066575e256dfc2295c3dab7f0e1b65417f Original-Change-Id: I30bd9c2c77e0e0623df89b9e5bb43ed29506be98 Original-Signed-off-by: Julius Werner <jwerner@chromium.org> Original-Reviewed-on: https://chromium-review.googlesource.com/236978 Original-Reviewed-by: David Hendricks <dhendrix@chromium.org> Original-Reviewed-by: Aaron Durbin <adurbin@chromium.org> Reviewed-on: http://review.coreboot.org/9729 Tested-by: build bot (Jenkins) Reviewed-by: Stefan Reinauer <stefan.reinauer@coreboot.org>
100 lines
2.6 KiB
C
100 lines
2.6 KiB
C
/*
|
|
* This file is part of the coreboot project.
|
|
*
|
|
* Copyright 2014 Google Inc.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; version 2 of the License.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc.
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <base3.h>
|
|
#include <console/console.h>
|
|
#include <delay.h>
|
|
#include <gpio.h>
|
|
|
|
int gpio_base2_value(gpio_t gpio[], int num_gpio)
|
|
{
|
|
int i, result = 0;
|
|
|
|
for (i = 0; i < num_gpio; i++)
|
|
gpio_input(gpio[i]);
|
|
|
|
/* Wait until signals become stable */
|
|
udelay(10);
|
|
|
|
for (i = 0; i < num_gpio; i++)
|
|
result |= gpio_get(gpio[i]) << i;
|
|
|
|
return result;
|
|
}
|
|
|
|
int gpio_base3_value(gpio_t gpio[], int num_gpio)
|
|
{
|
|
/*
|
|
* GPIOs which are tied to stronger external pull up or pull down
|
|
* will stay there regardless of the internal pull up or pull
|
|
* down setting.
|
|
*
|
|
* GPIOs which are floating will go to whatever level they're
|
|
* internally pulled to.
|
|
*/
|
|
|
|
static const char tristate_char[] = {[0] = '0', [1] = '1', [Z] = 'Z'};
|
|
int temp;
|
|
int index;
|
|
int result = 0;
|
|
char value[32];
|
|
assert(num_gpio <= 32);
|
|
|
|
/* Enable internal pull up */
|
|
for (index = 0; index < num_gpio; ++index)
|
|
gpio_input_pullup(gpio[index]);
|
|
|
|
/* Wait until signals become stable */
|
|
udelay(10);
|
|
|
|
/* Get gpio values at internal pull up */
|
|
for (index = 0; index < num_gpio; ++index)
|
|
value[index] = gpio_get(gpio[index]);
|
|
|
|
/* Enable internal pull down */
|
|
for (index = 0; index < num_gpio; ++index)
|
|
gpio_input_pulldown(gpio[index]);
|
|
|
|
/* Wait until signals become stable */
|
|
udelay(10);
|
|
|
|
/*
|
|
* Get gpio values at internal pull down.
|
|
* Compare with gpio pull up value and then
|
|
* determine a gpio final value/state:
|
|
* 0: pull down
|
|
* 1: pull up
|
|
* 2: floating
|
|
*/
|
|
printk(BIOS_DEBUG, "Reading tristate GPIOs: ");
|
|
for (index = num_gpio - 1; index >= 0; --index) {
|
|
temp = gpio_get(gpio[index]);
|
|
temp |= ((value[index] ^ temp) << 1);
|
|
printk(BIOS_DEBUG, "%c ", tristate_char[temp]);
|
|
result = (result * 3) + temp;
|
|
}
|
|
printk(BIOS_DEBUG, "= %d\n", result);
|
|
|
|
/* Disable pull up / pull down to conserve power */
|
|
for (index = 0; index < num_gpio; ++index)
|
|
gpio_input(gpio[index]);
|
|
|
|
return result;
|
|
}
|