mirror of
https://github.com/Telecominfraproject/OpenCellular.git
synced 2026-01-01 21:02:27 +00:00
bd5dee115c
This CL includes:
1. Add gpio_chip-npcx5/7.h files and move all macro functions
related to chip family to them. (Move wui macro func from
gpio_wui.h to them.)
2. Replace alternative and low-voltage mapping table with macro
function NPCX_ALT_TABLE and NPCX_LVOL_TABLE.
3. Add UART wakeup mechanism in __gpio_wk1h_interrupt() ISR.
4. Add gpio register definitions of npcx7 family in registers.h.
5. Add GPIO_LOCKED flag for lock functionality.
BRANCH=none
BUG=none
TEST=No build errors for all boards using npcx5 series (besides gru).
Build poppy board and upload FW to platform. No issues found.
Passed validation for all GPIO functionalities on npcx5m6g
and npcx796f evb.
Change-Id: I60c30ce223629a0d8cb767a54a0a9b02a69de9c5
Signed-off-by: Mulin Chao <mlchao@nuvoton.com>
Reviewed-on: https://chromium-review.googlesource.com/481561
Reviewed-by: Aseda Aboagye <aaboagye@chromium.org>
Reviewed-by: Randall Spangler <rspangler@chromium.org>
260 lines
8.3 KiB
C
260 lines
8.3 KiB
C
/* Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
/* GPIO module for Chrome EC */
|
|
|
|
#ifndef __CROS_EC_GPIO_H
|
|
#define __CROS_EC_GPIO_H
|
|
|
|
#include "common.h"
|
|
|
|
/* Flag definitions for gpio_info and gpio_alt_func */
|
|
/* The following are valid for both gpio_info and gpio_alt_func: */
|
|
#define GPIO_OPEN_DRAIN (1 << 0) /* Output type is open-drain */
|
|
#define GPIO_PULL_UP (1 << 1) /* Enable on-chip pullup */
|
|
#define GPIO_PULL_DOWN (1 << 2) /* Enable on-chip pulldown */
|
|
/* The following are valid for gpio_alt_func only */
|
|
#define GPIO_ANALOG (1 << 3) /* Set pin to analog-mode */
|
|
/* The following are valid for gpio_info only */
|
|
#define GPIO_INPUT (1 << 4) /* Input */
|
|
#define GPIO_OUTPUT (1 << 5) /* Output */
|
|
#define GPIO_LOW (1 << 6) /* If GPIO_OUTPUT, set level low */
|
|
#define GPIO_HIGH (1 << 7) /* If GPIO_OUTPUT, set level high */
|
|
#define GPIO_INT_F_RISING (1 << 8) /* Interrupt on rising edge */
|
|
#define GPIO_INT_F_FALLING (1 << 9) /* Interrupt on falling edge */
|
|
#define GPIO_INT_F_LOW (1 << 11) /* Interrupt on low level */
|
|
#define GPIO_INT_F_HIGH (1 << 12) /* Interrupt on high level */
|
|
#define GPIO_DEFAULT (1 << 13) /* Don't set up on boot */
|
|
#define GPIO_INT_DSLEEP (1 << 14) /* Interrupt in deep sleep */
|
|
#define GPIO_INT_SHARED (1 << 15) /* Shared among multiple pins */
|
|
#define GPIO_SEL_1P8V (1 << 16) /* Support 1.8v */
|
|
#define GPIO_ALTERNATE (1 << 17) /* GPIO used for alternate function. */
|
|
#define GPIO_LOCKED (1 << 18) /* Lock GPIO output and configuration */
|
|
|
|
/* Common flag combinations */
|
|
#define GPIO_OUT_LOW (GPIO_OUTPUT | GPIO_LOW)
|
|
#define GPIO_OUT_HIGH (GPIO_OUTPUT | GPIO_HIGH)
|
|
#define GPIO_ODR_HIGH (GPIO_OUTPUT | GPIO_OPEN_DRAIN | GPIO_HIGH)
|
|
#define GPIO_ODR_LOW (GPIO_OUTPUT | GPIO_OPEN_DRAIN | GPIO_LOW)
|
|
#define GPIO_INT_RISING (GPIO_INPUT | GPIO_INT_F_RISING)
|
|
#define GPIO_INT_FALLING (GPIO_INPUT | GPIO_INT_F_FALLING)
|
|
/* TODO(crosbug.com/p/24204): "EDGE" would have been clearer than "BOTH". */
|
|
#define GPIO_INT_BOTH (GPIO_INT_RISING | GPIO_INT_FALLING)
|
|
#define GPIO_INT_LOW (GPIO_INPUT | GPIO_INT_F_LOW)
|
|
#define GPIO_INT_HIGH (GPIO_INPUT | GPIO_INT_F_HIGH)
|
|
#define GPIO_INT_LEVEL (GPIO_INT_LOW | GPIO_INT_HIGH)
|
|
#define GPIO_INT_ANY (GPIO_INT_BOTH | GPIO_INT_LEVEL)
|
|
#define GPIO_INT_BOTH_DSLEEP (GPIO_INT_BOTH | GPIO_INT_DSLEEP)
|
|
|
|
/* Convert GPIO mask to GPIO number / index. */
|
|
#define GPIO_MASK_TO_NUM(mask) (__fls(mask))
|
|
|
|
/* NOTE: This is normally included from board.h, thru config.h and common.h But,
|
|
* some boards and unit tests don't have a gpio_signal enum defined, so we
|
|
* define an emtpy one here.*/
|
|
#ifndef __CROS_EC_GPIO_SIGNAL_H
|
|
enum gpio_signal {
|
|
GPIO_COUNT
|
|
};
|
|
#endif /* __CROS_EC_GPIO_SIGNAL_H */
|
|
|
|
/* GPIO signal definition structure, for use by board.c */
|
|
struct gpio_info {
|
|
/* Signal name */
|
|
const char *name;
|
|
|
|
/* Port base address */
|
|
uint32_t port;
|
|
|
|
/* Bitmask on that port (1 << N; 0 = signal not implemented) */
|
|
uint32_t mask;
|
|
|
|
/* Flags (GPIO_*; see above) */
|
|
uint32_t flags;
|
|
};
|
|
|
|
/* Signal information from board.c. Must match order from enum gpio_signal. */
|
|
extern const struct gpio_info gpio_list[];
|
|
|
|
/* Interrupt handler table for those GPIOs which have IRQ handlers.
|
|
*
|
|
* If the signal's interrupt is enabled, this will be called in the
|
|
* context of the GPIO interrupt handler.
|
|
*/
|
|
extern void (* const gpio_irq_handlers[])(enum gpio_signal signal);
|
|
extern const int gpio_ih_count;
|
|
#define GPIO_IH_COUNT gpio_ih_count
|
|
|
|
/**
|
|
* Pre-initialize GPIOs.
|
|
*
|
|
* This occurs before clocks or tasks are set up.
|
|
*/
|
|
void gpio_pre_init(void);
|
|
|
|
/**
|
|
* Configure GPIO pin functions for a module.
|
|
*
|
|
* @param id Module ID to initialize
|
|
* @param enable Enable alternate functions if 1; high-Z pins if 0.
|
|
* @return EC_SUCCESS, or non-zero if module_id is not found.
|
|
*/
|
|
int gpio_config_module(enum module_id id, int enable);
|
|
|
|
/**
|
|
* Enable/disable alternate function for single pin
|
|
*
|
|
* @param id module ID of pins
|
|
* @param signal Signal to configure
|
|
* @param enable Enable alternate function if 1; GPIO if 0
|
|
* @return EC_SUCCESS, or non-zero if pin is not found.
|
|
* */
|
|
int gpio_config_pin(enum module_id id, enum gpio_signal signal, int enable);
|
|
|
|
/**
|
|
* Get the current value of a signal.
|
|
*
|
|
* @param signal Signal to get
|
|
* @return 0 if low, 1 if high.
|
|
*/
|
|
int gpio_get_level(enum gpio_signal signal);
|
|
|
|
/**
|
|
* Return the name of a given GPIO signal.
|
|
*
|
|
* @param signal Signal to name
|
|
* @returns name of the given signal
|
|
*/
|
|
const char *gpio_get_name(enum gpio_signal signal);
|
|
|
|
/**
|
|
* Determine if a GPIO is implemented.
|
|
*
|
|
* Some well known GPIO signal names may not be implemented on a particular
|
|
* board. This function can be used to determine if a GPIO is implemented.
|
|
*
|
|
* @param signal Signal to query
|
|
* @returns 0 if the GPIO is not implemented, 1 if it is.
|
|
*/
|
|
int gpio_is_implemented(enum gpio_signal signal);
|
|
|
|
/**
|
|
* Set the flags for a signal.
|
|
*
|
|
* @param signal Signal to set flags for
|
|
* @param flags New flags for the signal
|
|
*/
|
|
void gpio_set_flags(enum gpio_signal signal, int flags);
|
|
|
|
#ifdef CONFIG_CMD_GPIO_EXTENDED
|
|
/**
|
|
* Get the current flags for a signal.
|
|
*
|
|
* @param signal Signal to get flags for
|
|
* @returns The flags that are currently defined for this signal
|
|
*/
|
|
int gpio_get_flags(enum gpio_signal signal);
|
|
|
|
/**
|
|
* Get flags for GPIO by port and mask.
|
|
*
|
|
* @param port GPIO port to set (GPIO_*)
|
|
* @param mask Bitmask of pins on that port to check: one only.
|
|
*/
|
|
int gpio_get_flags_by_mask(uint32_t port, uint32_t mask);
|
|
#endif
|
|
|
|
/**
|
|
* Get the default flags for a signal.
|
|
*
|
|
* @param signal Signal to set flags for
|
|
* @returns The flags that were originally defined for this signal
|
|
*/
|
|
int gpio_get_default_flags(enum gpio_signal signal);
|
|
|
|
/**
|
|
* Set the value of a signal.
|
|
*
|
|
* @param signal Signal to set
|
|
* @param value New value for signal (0 = low, != high */
|
|
void gpio_set_level(enum gpio_signal signal, int value);
|
|
|
|
/**
|
|
* Reset the GPIO flags and alternate function state
|
|
*
|
|
* This returns the GPIO to it's default state of being a GPIO (not
|
|
* configured as an alternate function) with its default flags (those
|
|
* specified in gpio.inc when it was defined).
|
|
*
|
|
* @param signal Signal to reset
|
|
*/
|
|
void gpio_reset(enum gpio_signal signal);
|
|
|
|
/**
|
|
* Enable interrupts for the signal.
|
|
*
|
|
* The signal must have been defined with
|
|
* an interrupt handler. Normally called by the module which handles the
|
|
* interrupt, once it's ready to start processing interrupts.
|
|
*
|
|
* @param signal Signal to enable interrrupts for
|
|
* @return EC_SUCCESS, or non-zero if error.
|
|
*/
|
|
int gpio_enable_interrupt(enum gpio_signal signal);
|
|
|
|
/**
|
|
* Disable interrupts for the signal.
|
|
*
|
|
* The signal must have been defined with
|
|
* an interrupt handler. Normally called by the module which handles the
|
|
* interrupt, if it doesn't want to process interrupts.
|
|
*
|
|
* @param signal Signal to disable interrupts for
|
|
* @return EC_SUCCESS, or non-zero if error.
|
|
*/
|
|
int gpio_disable_interrupt(enum gpio_signal signal);
|
|
|
|
/**
|
|
* Clear pending interrupts for the signal.
|
|
*
|
|
* The signal must have been defined with an interrupt handler.
|
|
*
|
|
* @param signal Signal to clear interrupts for
|
|
* @return EC_SUCCESS, or non-zero on error.
|
|
*/
|
|
int gpio_clear_pending_interrupt(enum gpio_signal signal);
|
|
|
|
/**
|
|
* Set flags for GPIO(s) by port and mask.
|
|
*
|
|
* Use gpio_set_flags() to set flags for an individual GPIO by id.
|
|
*
|
|
* Note that modules should usually declare their GPIO alternate functions in
|
|
* gpio_alt_funcs[] and call gpio_init_module() instead of calling this
|
|
* directly.
|
|
*
|
|
* @param port GPIO port to set (GPIO_*)
|
|
* @param mask Bitmask of pins on that port to affect
|
|
* @param flags Flags (GPIO_*; see above)
|
|
*/
|
|
void gpio_set_flags_by_mask(uint32_t port, uint32_t mask, uint32_t flags);
|
|
|
|
|
|
/**
|
|
* Set alternate function for GPIO(s).
|
|
*
|
|
* Note that modules should usually declare their GPIO alternate functions in
|
|
* gpio_alt_funcs[] and call gpio_init_module() instead of calling this
|
|
* directly.
|
|
*
|
|
* @param port GPIO port to set (GPIO_*)
|
|
* @param mask Bitmask of pins on that port to affect
|
|
* @param func Alternate function; if <0, configures the specified
|
|
* GPIOs for normal GPIO operation.
|
|
*/
|
|
void gpio_set_alternate_function(uint32_t port, uint32_t mask, int func);
|
|
|
|
#endif /* __CROS_EC_GPIO_H */
|