robocars/robocar-led
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
8b5888ee1b
robocar-led/vendor/periph.io/x/periph/host/allwinner/gpio.go

1066 lines
36 KiB
Go
Raw Normal View History

First implementation
2019-12-14 10:56:22 +00:00
// Copyright 2016 The Periph Authors. All rights reserved.
// Use of this source code is governed under the Apache License, Version 2.0
// that can be found in the LICENSE file.
// This file contains the definitions of all possible generic Allwinner pins and their
// implementation using a combination of sysfs and memory-mapped I/O.
package allwinner
import (
"errors"
"fmt"
"os"
"path"
"strconv"
"strings"
"time"
"periph.io/x/periph"
"periph.io/x/periph/conn/gpio"
"periph.io/x/periph/conn/gpio/gpioreg"
"periph.io/x/periph/conn/physic"
"periph.io/x/periph/conn/pin"
"periph.io/x/periph/host/pmem"
"periph.io/x/periph/host/sysfs"
)
// List of all known pins. These global variables can be used directly.
//
// The supported functionality of each gpio differs between CPUs. For example
// the R8 has the LCD-DE signal on gpio PD25 but the A64 has it on PD19.
//
// The availability of each gpio differs between CPUs. For example the R8 has
// 19 pins in the group PB but the A64 only has 10.
//
// So make sure to read the datasheet for the exact right CPU.
var (
PA0, PA1, PA2, PA3, PA4, PA5, PA6, PA7, PA8, PA9, PA10, PA11, PA12, PA13, PA14, PA15, PA16, PA17 *Pin
PB0, PB1, PB2, PB3, PB4, PB5, PB6, PB7, PB8, PB9, PB10, PB11, PB12, PB13, PB14, PB15, PB16, PB17, PB18, PB19, PB20, PB21, PB22, PB23 *Pin
PC0, PC1, PC2, PC3, PC4, PC5, PC6, PC7, PC8, PC9, PC10, PC11, PC12, PC13, PC14, PC15, PC16, PC17, PC18, PC19, PC20, PC21, PC22, PC23, PC24 *Pin
PD0, PD1, PD2, PD3, PD4, PD5, PD6, PD7, PD8, PD9, PD10, PD11, PD12, PD13, PD14, PD15, PD16, PD17, PD18, PD19, PD20, PD21, PD22, PD23, PD24, PD25, PD26, PD27 *Pin
PE0, PE1, PE2, PE3, PE4, PE5, PE6, PE7, PE8, PE9, PE10, PE11, PE12, PE13, PE14, PE15, PE16, PE17 *Pin
PF0, PF1, PF2, PF3, PF4, PF5, PF6 *Pin
PG0, PG1, PG2, PG3, PG4, PG5, PG6, PG7, PG8, PG9, PG10, PG11, PG12, PG13 *Pin
PH0, PH1, PH2, PH3, PH4, PH5, PH6, PH7, PH8, PH9, PH10, PH11, PH12, PH13, PH14, PH15, PH16, PH17, PH18, PH19, PH20, PH21, PH22, PH23, PH24, PH25, PH26, PH27 *Pin
PI0, PI1, PI2, PI3, PI4, PI5, PI6, PI7, PI8, PI9, PI10, PI11, PI12, PI13, PI14, PI15, PI16, PI17, PI18, PI19, PI20, PI21 *Pin
)
// Pin implements the gpio.PinIO interface for generic Allwinner CPU pins using
// memory mapping for gpio in/out functionality.
type Pin struct {
// Immutable.
group uint8 // as per register offset calculation
offset uint8 // as per register offset calculation
name string // name as per datasheet
defaultPull gpio.Pull // default pull at startup
// Immutable after driver initialization.
altFunc [5]pin.Func // alternate functions
sysfsPin *sysfs.Pin // Set to the corresponding sysfs.Pin, if any.
available bool // Set when the pin is available on this CPU architecture.
supportEdge bool // Set when the pin supports interrupt based edge detection.
// Mutable.
usingEdge bool // Set when edge detection is enabled.
}
// String implements conn.Resource.
//
// It returns the pin name and number, ex: "PB5(37)".
func (p *Pin) String() string {
return fmt.Sprintf("%s(%d)", p.name, p.Number())
}
// Halt implements conn.Resource.
//
// It stops edge detection if enabled.
func (p *Pin) Halt() error {
if p.usingEdge {
if err := p.sysfsPin.Halt(); err != nil {
return p.wrap(err)
}
p.usingEdge = false
}
return nil
}
// Name implements pin.Pin.
//
// It returns the pin name, ex: "PB5".
func (p *Pin) Name() string {
return p.name
}
// Number implements pin.Pin.
//
// It returns the GPIO pin number as represented by gpio sysfs.
func (p *Pin) Number() int {
return int(p.group)*32 + int(p.offset)
}
// Function implements pin.Pin.
func (p *Pin) Function() string {
return string(p.Func())
}
// Func implements pin.PinFunc.
func (p *Pin) Func() pin.Func {
if !p.available {
return pin.FuncNone
}
if drvGPIO.gpioMemory == nil {
if p.sysfsPin == nil {
return pin.FuncNone
}
return p.sysfsPin.Func()
}
switch f := p.function(); f {
case in:
if p.FastRead() {
return gpio.IN_HIGH
}
return gpio.IN_LOW
case out:
if p.FastRead() {
return gpio.OUT_HIGH
}
return gpio.OUT_LOW
case alt1:
if p.altFunc[0] != "" {
return pin.Func(p.altFunc[0])
}
return pin.Func("ALT1")
case alt2:
if p.altFunc[1] != "" {
return pin.Func(p.altFunc[1])
}
return pin.Func("ALT2")
case alt3:
if p.altFunc[2] != "" {
return pin.Func(p.altFunc[2])
}
return pin.Func("ALT3")
case alt4:
if p.altFunc[3] != "" {
if strings.Contains(string(p.altFunc[3]), "EINT") {
// It's an input supporting interrupts.
if p.FastRead() {
return gpio.IN_HIGH
}
return gpio.IN_LOW
}
return pin.Func(p.altFunc[3])
}
return pin.Func("ALT4")
case alt5:
if p.altFunc[4] != "" {
if strings.Contains(string(p.altFunc[4]), "EINT") {
// It's an input supporting interrupts.
if p.FastRead() {
return gpio.IN_HIGH
}
return gpio.IN_LOW
}
return pin.Func(p.altFunc[4])
}
return pin.Func("ALT5")
case disabled:
return pin.FuncNone
default:
return pin.FuncNone
}
}
// SupportedFuncs implements pin.PinFunc.
func (p *Pin) SupportedFuncs() []pin.Func {
f := make([]pin.Func, 0, 2+4)
f = append(f, gpio.IN, gpio.OUT)
for _, m := range p.altFunc {
if m != pin.FuncNone && !strings.Contains(string(m), "EINT") {
f = append(f, m)
}
}
return f
}
// SetFunc implements pin.PinFunc.
func (p *Pin) SetFunc(f pin.Func) error {
switch f {
case gpio.FLOAT:
return p.In(gpio.Float, gpio.NoEdge)
case gpio.IN:
return p.In(gpio.PullNoChange, gpio.NoEdge)
case gpio.IN_LOW:
return p.In(gpio.PullDown, gpio.NoEdge)
case gpio.IN_HIGH:
return p.In(gpio.PullUp, gpio.NoEdge)
case gpio.OUT_HIGH:
return p.Out(gpio.High)
case gpio.OUT_LOW:
return p.Out(gpio.Low)
default:
isGeneral := f == f.Generalize()
for i, m := range p.altFunc {
if m == f || (isGeneral && m.Generalize() == f) {
if err := p.Halt(); err != nil {
return err
}
switch i {
case 0:
p.setFunction(alt1)
case 1:
p.setFunction(alt2)
case 2:
p.setFunction(alt3)
case 3:
p.setFunction(alt4)
case 4:
p.setFunction(alt5)
}
return nil
}
}
return p.wrap(errors.New("unsupported function"))
}
}
// In implements gpio.PinIn.
//
// It sets the pin direction to input and optionally enables a pull-up/down
// resistor as well as edge detection.
//
// Not all pins support edge detection on Allwinner processors!
//
// Edge detection requires opening a gpio sysfs file handle. The pin will be
// exported at /sys/class/gpio/gpio*/. Note that the pin will not be unexported
// at shutdown.
func (p *Pin) In(pull gpio.Pull, edge gpio.Edge) error {
if !p.available {
// We do not want the error message about uninitialized system.
return p.wrap(errors.New("not available on this CPU architecture"))
}
if edge != gpio.NoEdge && !p.supportEdge {
return p.wrap(errors.New("edge detection is not supported on this pin"))
}
if p.usingEdge && edge == gpio.NoEdge {
if err := p.sysfsPin.Halt(); err != nil {
return p.wrap(err)
}
p.usingEdge = false
}
if drvGPIO.gpioMemory == nil {
if p.sysfsPin == nil {
return p.wrap(errors.New("subsystem gpiomem not initialized and sysfs not accessible; try running as root?"))
}
if pull != gpio.PullNoChange {
return p.wrap(errors.New("pull cannot be used when subsystem gpiomem not initialized; try running as root?"))
}
if err := p.sysfsPin.In(pull, edge); err != nil {
return p.wrap(err)
}
p.usingEdge = edge != gpio.NoEdge
return nil
}
p.setFunction(in)
if pull != gpio.PullNoChange {
off := p.offset / 16
shift := 2 * (p.offset % 16)
// Do it in a way that is concurrency safe.
drvGPIO.gpioMemory.groups[p.group].pull[off] &^= 3 << shift
switch pull {
case gpio.PullDown:
drvGPIO.gpioMemory.groups[p.group].pull[off] = 2 << shift
case gpio.PullUp:
drvGPIO.gpioMemory.groups[p.group].pull[off] = 1 << shift
default:
}
}
if edge != gpio.NoEdge {
if p.sysfsPin == nil {
return p.wrap(fmt.Errorf("pin %d is not exported by sysfs", p.Number()))
}
// This resets pending edges.
if err := p.sysfsPin.In(gpio.PullNoChange, edge); err != nil {
return p.wrap(err)
}
p.usingEdge = true
}
return nil
}
// Read implements gpio.PinIn.
//
// It returns the current pin level. This function is fast.
func (p *Pin) Read() gpio.Level {
if !p.available {
return gpio.Low
}
if drvGPIO.gpioMemory == nil {
if p.sysfsPin == nil {
return gpio.Low
}
return p.sysfsPin.Read()
}
return gpio.Level(drvGPIO.gpioMemory.groups[p.group].data&(1<<p.offset) != 0)
}
// FastRead return the current pin level without any error checking.
//
// This function is very fast.
func (p *Pin) FastRead() gpio.Level {
return gpio.Level(drvGPIO.gpioMemory.groups[p.group].data&(1<<p.offset) != 0)
}
// WaitForEdge implements gpio.PinIn.
//
// It waits for an edge as previously set using In() or the expiration of a
// timeout.
func (p *Pin) WaitForEdge(timeout time.Duration) bool {
if p.sysfsPin != nil {
return p.sysfsPin.WaitForEdge(timeout)
}
return false
}
// Pull implements gpio.PinIn.
func (p *Pin) Pull() gpio.Pull {
if drvGPIO.gpioMemory == nil || !p.available {
return gpio.PullNoChange
}
v := drvGPIO.gpioMemory.groups[p.group].pull[p.offset/16]
switch (v >> (2 * (p.offset % 16))) & 3 {
case 0:
return gpio.Float
case 1:
return gpio.PullUp
case 2:
return gpio.PullDown
default:
// Confused.
return gpio.PullNoChange
}
}
// DefaultPull implements gpio.PinIn.
func (p *Pin) DefaultPull() gpio.Pull {
return p.defaultPull
}
// Out implements gpio.PinOut.
func (p *Pin) Out(l gpio.Level) error {
if !p.available {
// We do not want the error message about uninitialized system.
return p.wrap(errors.New("not available on this CPU architecture"))
}
if drvGPIO.gpioMemory == nil {
if p.sysfsPin != nil {
return p.wrap(errors.New("subsystem gpiomem not initialized and sysfs not accessible; try running as root?"))
}
return p.sysfsPin.Out(l)
}
// First disable edges.
if err := p.Halt(); err != nil {
return err
}
p.FastOut(l)
p.setFunction(out)
return nil
}
// FastOut sets a pin output level with Absolutely No error checking.
//
// Out() Must be called once first before calling FastOut(), otherwise the
// behavior is undefined. Then FastOut() can be used for minimal CPU overhead
// to reach Mhz scale bit banging.
func (p *Pin) FastOut(l gpio.Level) {
bit := uint32(1 << p.offset)
// Pn_DAT n*0x24+0x10 Port n Data Register (n from 0(A) to 8(I))
// This is a switch on p.group rather than an index to the groups array for
// performance reasons: to avoid Go's array bound checking code.
// See https://periph.io/news/2017/gpio_perf/ for details.
switch p.group {
case 0:
if l {
drvGPIO.gpioMemory.groups[0].data |= bit
} else {
drvGPIO.gpioMemory.groups[0].data &^= bit
}
case 1:
if l {
drvGPIO.gpioMemory.groups[1].data |= bit
} else {
drvGPIO.gpioMemory.groups[1].data &^= bit
}
case 2:
if l {
drvGPIO.gpioMemory.groups[2].data |= bit
} else {
drvGPIO.gpioMemory.groups[2].data &^= bit
}
case 3:
if l {
drvGPIO.gpioMemory.groups[3].data |= bit
} else {
drvGPIO.gpioMemory.groups[3].data &^= bit
}
case 4:
if l {
drvGPIO.gpioMemory.groups[4].data |= bit
} else {
drvGPIO.gpioMemory.groups[4].data &^= bit
}
case 5:
if l {
drvGPIO.gpioMemory.groups[5].data |= bit
} else {
drvGPIO.gpioMemory.groups[5].data &^= bit
}
case 6:
if l {
drvGPIO.gpioMemory.groups[6].data |= bit
} else {
drvGPIO.gpioMemory.groups[6].data &^= bit
}
case 7:
if l {
drvGPIO.gpioMemory.groups[7].data |= bit
} else {
drvGPIO.gpioMemory.groups[7].data &^= bit
}
case 8:
if l {
drvGPIO.gpioMemory.groups[8].data |= bit
} else {
drvGPIO.gpioMemory.groups[8].data &^= bit
}
}
}
// PWM implements gpio.PinOut.
func (p *Pin) PWM(gpio.Duty, physic.Frequency) error {
return p.wrap(errors.New("not available on this CPU architecture"))
}
//
// drive returns the configured output current drive strength for this GPIO.
//
// The value returned by this function is not yet verified to be correct. Use
// with suspicion.
func (p *Pin) drive() physic.ElectricCurrent {
if drvGPIO.gpioMemory == nil {
return 0
}
// Explanation of the buffer configuration, but doesn't state what's the
// expected drive strength!
// http://files.pine64.org/doc/datasheet/pine-h64/Allwinner_H6%20V200_User_Manual_V1.1.pdf
// Section 3.21.3.4 page 381~382
//
// The A64 and H3 datasheets call for 20mA, so it could be reasonable to
// think that the values are 5mA, 10mA, 15mA, 20mA but we don't know for
// sure.
v := (drvGPIO.gpioMemory.groups[p.group].drv[p.offset/16] >> (2 * (p.offset & 15))) & 3
return physic.ElectricCurrent(v+1) * 5 * physic.MilliAmpere
}
// function returns the current GPIO pin function.
func (p *Pin) function() function {
if drvGPIO.gpioMemory == nil {
return disabled
}
shift := 4 * (p.offset % 8)
return function((drvGPIO.gpioMemory.groups[p.group].cfg[p.offset/8] >> shift) & 7)
}
// setFunction changes the GPIO pin function.
func (p *Pin) setFunction(f function) {
off := p.offset / 8
shift := 4 * (p.offset % 8)
mask := uint32(disabled) << shift
v := (uint32(f) << shift) ^ mask
// First disable, then setup. This is concurrent safe.
drvGPIO.gpioMemory.groups[p.group].cfg[off] |= mask
drvGPIO.gpioMemory.groups[p.group].cfg[off] &^= v
if p.function() != f {
panic(f)
}
}
func (p *Pin) wrap(err error) error {
return fmt.Errorf("allwinner-gpio (%s): %v", p, err)
}
//
// A64: Page 23~24
// R8: Page 322-334.
// Each pin can have one of 7 functions.
const (
in function = 0
out function = 1
alt1 function = 2
alt2 function = 3
alt3 function = 4
alt4 function = 5
alt5 function = 6 // often interrupt based edge detection as input
disabled function = 7
)
// cpupins that may be implemented by a generic Allwinner CPU. Not all pins
// will be present on all models and even if the CPU model supports them they
// may not be connected to anything on the board. The net effect is that it may
// look like more pins are available than really are, but trying to get the pin
// list 100% correct on all platforms seems futile, hence periph errs on the
// side of caution.
var cpupins = map[string]*Pin{
"PA0": {group: 0, offset: 0, name: "PA0", defaultPull: gpio.Float},
"PA1": {group: 0, offset: 1, name: "PA1", defaultPull: gpio.Float},
"PA2": {group: 0, offset: 2, name: "PA2", defaultPull: gpio.Float},
"PA3": {group: 0, offset: 3, name: "PA3", defaultPull: gpio.Float},
"PA4": {group: 0, offset: 4, name: "PA4", defaultPull: gpio.Float},
"PA5": {group: 0, offset: 5, name: "PA5", defaultPull: gpio.Float},
"PA6": {group: 0, offset: 6, name: "PA6", defaultPull: gpio.Float},
"PA7": {group: 0, offset: 7, name: "PA7", defaultPull: gpio.Float},
"PA8": {group: 0, offset: 8, name: "PA8", defaultPull: gpio.Float},
"PA9": {group: 0, offset: 9, name: "PA9", defaultPull: gpio.Float},
"PA10": {group: 0, offset: 10, name: "PA10", defaultPull: gpio.Float},
"PA11": {group: 0, offset: 11, name: "PA11", defaultPull: gpio.Float},
"PA12": {group: 0, offset: 12, name: "PA12", defaultPull: gpio.Float},
"PA13": {group: 0, offset: 13, name: "PA13", defaultPull: gpio.Float},
"PA14": {group: 0, offset: 14, name: "PA14", defaultPull: gpio.Float},
"PA15": {group: 0, offset: 15, name: "PA15", defaultPull: gpio.Float},
"PA16": {group: 0, offset: 16, name: "PA16", defaultPull: gpio.Float},
"PA17": {group: 0, offset: 17, name: "PA17", defaultPull: gpio.Float},
"PB0": {group: 1, offset: 0, name: "PB0", defaultPull: gpio.Float},
"PB1": {group: 1, offset: 1, name: "PB1", defaultPull: gpio.Float},
"PB2": {group: 1, offset: 2, name: "PB2", defaultPull: gpio.Float},
"PB3": {group: 1, offset: 3, name: "PB3", defaultPull: gpio.Float},
"PB4": {group: 1, offset: 4, name: "PB4", defaultPull: gpio.Float},
"PB5": {group: 1, offset: 5, name: "PB5", defaultPull: gpio.Float},
"PB6": {group: 1, offset: 6, name: "PB6", defaultPull: gpio.Float},
"PB7": {group: 1, offset: 7, name: "PB7", defaultPull: gpio.Float},
"PB8": {group: 1, offset: 8, name: "PB8", defaultPull: gpio.Float},
"PB9": {group: 1, offset: 9, name: "PB9", defaultPull: gpio.Float},
"PB10": {group: 1, offset: 10, name: "PB10", defaultPull: gpio.Float},
"PB11": {group: 1, offset: 11, name: "PB11", defaultPull: gpio.Float},
"PB12": {group: 1, offset: 12, name: "PB12", defaultPull: gpio.Float},
"PB13": {group: 1, offset: 13, name: "PB13", defaultPull: gpio.Float},
"PB14": {group: 1, offset: 14, name: "PB14", defaultPull: gpio.Float},
"PB15": {group: 1, offset: 15, name: "PB15", defaultPull: gpio.Float},
"PB16": {group: 1, offset: 16, name: "PB16", defaultPull: gpio.Float},
"PB17": {group: 1, offset: 17, name: "PB17", defaultPull: gpio.Float},
"PB18": {group: 1, offset: 18, name: "PB18", defaultPull: gpio.Float},
"PB19": {group: 1, offset: 19, name: "PB19", defaultPull: gpio.Float},
"PB20": {group: 1, offset: 20, name: "PB20", defaultPull: gpio.Float},
"PB21": {group: 1, offset: 21, name: "PB21", defaultPull: gpio.Float},
"PB22": {group: 1, offset: 22, name: "PB22", defaultPull: gpio.Float},
"PB23": {group: 1, offset: 23, name: "PB23", defaultPull: gpio.Float},
"PC0": {group: 2, offset: 0, name: "PC0", defaultPull: gpio.Float},
"PC1": {group: 2, offset: 1, name: "PC1", defaultPull: gpio.Float},
"PC2": {group: 2, offset: 2, name: "PC2", defaultPull: gpio.Float},
"PC3": {group: 2, offset: 3, name: "PC3", defaultPull: gpio.PullUp},
"PC4": {group: 2, offset: 4, name: "PC4", defaultPull: gpio.PullUp},
"PC5": {group: 2, offset: 5, name: "PC5", defaultPull: gpio.Float},
"PC6": {group: 2, offset: 6, name: "PC6", defaultPull: gpio.PullUp},
"PC7": {group: 2, offset: 7, name: "PC7", defaultPull: gpio.PullUp},
"PC8": {group: 2, offset: 8, name: "PC8", defaultPull: gpio.Float},
"PC9": {group: 2, offset: 9, name: "PC9", defaultPull: gpio.Float},
"PC10": {group: 2, offset: 10, name: "PC10", defaultPull: gpio.Float},
"PC11": {group: 2, offset: 11, name: "PC11", defaultPull: gpio.Float},
"PC12": {group: 2, offset: 12, name: "PC12", defaultPull: gpio.Float},
"PC13": {group: 2, offset: 13, name: "PC13", defaultPull: gpio.Float},
"PC14": {group: 2, offset: 14, name: "PC14", defaultPull: gpio.Float},
"PC15": {group: 2, offset: 15, name: "PC15", defaultPull: gpio.Float},
"PC16": {group: 2, offset: 16, name: "PC16", defaultPull: gpio.Float},
"PC17": {group: 2, offset: 17, name: "PC17", defaultPull: gpio.Float},
"PC18": {group: 2, offset: 18, name: "PC18", defaultPull: gpio.Float},
"PC19": {group: 2, offset: 19, name: "PC19", defaultPull: gpio.Float},
"PC20": {group: 2, offset: 20, name: "PC20", defaultPull: gpio.Float},
"PC21": {group: 2, offset: 21, name: "PC21", defaultPull: gpio.Float},
"PC22": {group: 2, offset: 22, name: "PC22", defaultPull: gpio.Float},
"PC23": {group: 2, offset: 23, name: "PC23", defaultPull: gpio.Float},
"PC24": {group: 2, offset: 24, name: "PC24", defaultPull: gpio.Float},
"PD0": {group: 3, offset: 0, name: "PD0", defaultPull: gpio.Float},
"PD1": {group: 3, offset: 1, name: "PD1", defaultPull: gpio.Float},
"PD2": {group: 3, offset: 2, name: "PD2", defaultPull: gpio.Float},
"PD3": {group: 3, offset: 3, name: "PD3", defaultPull: gpio.Float},
"PD4": {group: 3, offset: 4, name: "PD4", defaultPull: gpio.Float},
"PD5": {group: 3, offset: 5, name: "PD5", defaultPull: gpio.Float},
"PD6": {group: 3, offset: 6, name: "PD6", defaultPull: gpio.Float},
"PD7": {group: 3, offset: 7, name: "PD7", defaultPull: gpio.Float},
"PD8": {group: 3, offset: 8, name: "PD8", defaultPull: gpio.Float},
"PD9": {group: 3, offset: 9, name: "PD9", defaultPull: gpio.Float},
"PD10": {group: 3, offset: 10, name: "PD10", defaultPull: gpio.Float},
"PD11": {group: 3, offset: 11, name: "PD11", defaultPull: gpio.Float},
"PD12": {group: 3, offset: 12, name: "PD12", defaultPull: gpio.Float},
"PD13": {group: 3, offset: 13, name: "PD13", defaultPull: gpio.Float},
"PD14": {group: 3, offset: 14, name: "PD14", defaultPull: gpio.Float},
"PD15": {group: 3, offset: 15, name: "PD15", defaultPull: gpio.Float},
"PD16": {group: 3, offset: 16, name: "PD16", defaultPull: gpio.Float},
"PD17": {group: 3, offset: 17, name: "PD17", defaultPull: gpio.Float},
"PD18": {group: 3, offset: 18, name: "PD18", defaultPull: gpio.Float},
"PD19": {group: 3, offset: 19, name: "PD19", defaultPull: gpio.Float},
"PD20": {group: 3, offset: 20, name: "PD20", defaultPull: gpio.Float},
"PD21": {group: 3, offset: 21, name: "PD21", defaultPull: gpio.Float},
"PD22": {group: 3, offset: 22, name: "PD22", defaultPull: gpio.Float},
"PD23": {group: 3, offset: 23, name: "PD23", defaultPull: gpio.Float},
"PD24": {group: 3, offset: 24, name: "PD24", defaultPull: gpio.Float},
"PD25": {group: 3, offset: 25, name: "PD25", defaultPull: gpio.Float},
"PD26": {group: 3, offset: 26, name: "PD26", defaultPull: gpio.Float},
"PD27": {group: 3, offset: 27, name: "PD27", defaultPull: gpio.Float},
"PE0": {group: 4, offset: 0, name: "PE0", defaultPull: gpio.Float},
"PE1": {group: 4, offset: 1, name: "PE1", defaultPull: gpio.Float},
"PE2": {group: 4, offset: 2, name: "PE2", defaultPull: gpio.Float},
"PE3": {group: 4, offset: 3, name: "PE3", defaultPull: gpio.Float},
"PE4": {group: 4, offset: 4, name: "PE4", defaultPull: gpio.Float},
"PE5": {group: 4, offset: 5, name: "PE5", defaultPull: gpio.Float},
"PE6": {group: 4, offset: 6, name: "PE6", defaultPull: gpio.Float},
"PE7": {group: 4, offset: 7, name: "PE7", defaultPull: gpio.Float},
"PE8": {group: 4, offset: 8, name: "PE8", defaultPull: gpio.Float},
"PE9": {group: 4, offset: 9, name: "PE9", defaultPull: gpio.Float},
"PE10": {group: 4, offset: 10, name: "PE10", defaultPull: gpio.Float},
"PE11": {group: 4, offset: 11, name: "PE11", defaultPull: gpio.Float},
"PE12": {group: 4, offset: 12, name: "PE12", defaultPull: gpio.Float},
"PE13": {group: 4, offset: 13, name: "PE13", defaultPull: gpio.Float},
"PE14": {group: 4, offset: 14, name: "PE14", defaultPull: gpio.Float},
"PE15": {group: 4, offset: 15, name: "PE15", defaultPull: gpio.Float},
"PE16": {group: 4, offset: 16, name: "PE16", defaultPull: gpio.Float},
"PE17": {group: 4, offset: 17, name: "PE17", defaultPull: gpio.Float},
"PF0": {group: 5, offset: 0, name: "PF0", defaultPull: gpio.Float},
"PF1": {group: 5, offset: 1, name: "PF1", defaultPull: gpio.Float},
"PF2": {group: 5, offset: 2, name: "PF2", defaultPull: gpio.Float},
"PF3": {group: 5, offset: 3, name: "PF3", defaultPull: gpio.Float},
"PF4": {group: 5, offset: 4, name: "PF4", defaultPull: gpio.Float},
"PF5": {group: 5, offset: 5, name: "PF5", defaultPull: gpio.Float},
"PF6": {group: 5, offset: 6, name: "PF6", defaultPull: gpio.Float},
"PG0": {group: 6, offset: 0, name: "PG0", defaultPull: gpio.Float},
"PG1": {group: 6, offset: 1, name: "PG1", defaultPull: gpio.Float},
"PG2": {group: 6, offset: 2, name: "PG2", defaultPull: gpio.Float},
"PG3": {group: 6, offset: 3, name: "PG3", defaultPull: gpio.Float},
"PG4": {group: 6, offset: 4, name: "PG4", defaultPull: gpio.Float},
"PG5": {group: 6, offset: 5, name: "PG5", defaultPull: gpio.Float},
"PG6": {group: 6, offset: 6, name: "PG6", defaultPull: gpio.Float},
"PG7": {group: 6, offset: 7, name: "PG7", defaultPull: gpio.Float},
"PG8": {group: 6, offset: 8, name: "PG8", defaultPull: gpio.Float},
"PG9": {group: 6, offset: 9, name: "PG9", defaultPull: gpio.Float},
"PG10": {group: 6, offset: 10, name: "PG10", defaultPull: gpio.Float},
"PG11": {group: 6, offset: 11, name: "PG11", defaultPull: gpio.Float},
"PG12": {group: 6, offset: 12, name: "PG12", defaultPull: gpio.Float},
"PG13": {group: 6, offset: 13, name: "PG13", defaultPull: gpio.Float},
"PH0": {group: 7, offset: 0, name: "PH0", defaultPull: gpio.Float},
"PH1": {group: 7, offset: 1, name: "PH1", defaultPull: gpio.Float},
"PH2": {group: 7, offset: 2, name: "PH2", defaultPull: gpio.Float},
"PH3": {group: 7, offset: 3, name: "PH3", defaultPull: gpio.Float},
"PH4": {group: 7, offset: 4, name: "PH4", defaultPull: gpio.Float},
"PH5": {group: 7, offset: 5, name: "PH5", defaultPull: gpio.Float},
"PH6": {group: 7, offset: 6, name: "PH6", defaultPull: gpio.Float},
"PH7": {group: 7, offset: 7, name: "PH7", defaultPull: gpio.Float},
"PH8": {group: 7, offset: 8, name: "PH8", defaultPull: gpio.Float},
"PH9": {group: 7, offset: 9, name: "PH9", defaultPull: gpio.Float},
"PH10": {group: 7, offset: 10, name: "PH10", defaultPull: gpio.Float},
"PH11": {group: 7, offset: 11, name: "PH11", defaultPull: gpio.Float},
"PH12": {group: 7, offset: 12, name: "PH12", defaultPull: gpio.Float},
"PH13": {group: 7, offset: 13, name: "PH13", defaultPull: gpio.Float},
"PH14": {group: 7, offset: 14, name: "PH14", defaultPull: gpio.Float},
"PH15": {group: 7, offset: 15, name: "PH15", defaultPull: gpio.Float},
"PH16": {group: 7, offset: 16, name: "PH16", defaultPull: gpio.Float},
"PH17": {group: 7, offset: 17, name: "PH17", defaultPull: gpio.Float},
"PH18": {group: 7, offset: 18, name: "PH18", defaultPull: gpio.Float},
"PH19": {group: 7, offset: 19, name: "PH19", defaultPull: gpio.Float},
"PH20": {group: 7, offset: 20, name: "PH20", defaultPull: gpio.Float},
"PH21": {group: 7, offset: 21, name: "PH21", defaultPull: gpio.Float},
"PH22": {group: 7, offset: 22, name: "PH22", defaultPull: gpio.Float},
"PH23": {group: 7, offset: 23, name: "PH23", defaultPull: gpio.Float},
"PH24": {group: 7, offset: 24, name: "PH24", defaultPull: gpio.Float},
"PH25": {group: 7, offset: 25, name: "PH25", defaultPull: gpio.Float},
"PH26": {group: 7, offset: 26, name: "PH26", defaultPull: gpio.Float},
"PH27": {group: 7, offset: 27, name: "PH27", defaultPull: gpio.Float},
"PI0": {group: 8, offset: 0, name: "PI0", defaultPull: gpio.Float},
"PI1": {group: 8, offset: 1, name: "PI1", defaultPull: gpio.Float},
"PI2": {group: 8, offset: 2, name: "PI2", defaultPull: gpio.Float},
"PI3": {group: 8, offset: 3, name: "PI3", defaultPull: gpio.Float},
"PI4": {group: 8, offset: 4, name: "PI4", defaultPull: gpio.Float},
"PI5": {group: 8, offset: 5, name: "PI5", defaultPull: gpio.Float},
"PI6": {group: 8, offset: 6, name: "PI6", defaultPull: gpio.Float},
"PI7": {group: 8, offset: 7, name: "PI7", defaultPull: gpio.Float},
"PI8": {group: 8, offset: 8, name: "PI8", defaultPull: gpio.Float},
"PI9": {group: 8, offset: 9, name: "PI9", defaultPull: gpio.Float},
"PI10": {group: 8, offset: 10, name: "PI10", defaultPull: gpio.Float},
"PI11": {group: 8, offset: 11, name: "PI11", defaultPull: gpio.Float},
"PI12": {group: 8, offset: 12, name: "PI12", defaultPull: gpio.Float},
"PI13": {group: 8, offset: 13, name: "PI13", defaultPull: gpio.Float},
"PI14": {group: 8, offset: 14, name: "PI14", defaultPull: gpio.Float},
"PI15": {group: 8, offset: 15, name: "PI15", defaultPull: gpio.Float},
"PI16": {group: 8, offset: 16, name: "PI16", defaultPull: gpio.Float},
"PI17": {group: 8, offset: 17, name: "PI17", defaultPull: gpio.Float},
"PI18": {group: 8, offset: 18, name: "PI18", defaultPull: gpio.Float},
"PI19": {group: 8, offset: 19, name: "PI19", defaultPull: gpio.Float},
"PI20": {group: 8, offset: 20, name: "PI20", defaultPull: gpio.Float},
"PI21": {group: 8, offset: 21, name: "PI21", defaultPull: gpio.Float},
}
func init() {
PA0 = cpupins["PA0"]
PA1 = cpupins["PA1"]
PA2 = cpupins["PA2"]
PA3 = cpupins["PA3"]
PA4 = cpupins["PA4"]
PA5 = cpupins["PA5"]
PA6 = cpupins["PA6"]
PA7 = cpupins["PA7"]
PA8 = cpupins["PA8"]
PA9 = cpupins["PA9"]
PA10 = cpupins["PA10"]
PA11 = cpupins["PA11"]
PA12 = cpupins["PA12"]
PA13 = cpupins["PA13"]
PA14 = cpupins["PA14"]
PA15 = cpupins["PA15"]
PA16 = cpupins["PA16"]
PA17 = cpupins["PA17"]
PB0 = cpupins["PB0"]
PB1 = cpupins["PB1"]
PB2 = cpupins["PB2"]
PB3 = cpupins["PB3"]
PB4 = cpupins["PB4"]
PB5 = cpupins["PB5"]
PB6 = cpupins["PB6"]
PB7 = cpupins["PB7"]
PB8 = cpupins["PB8"]
PB9 = cpupins["PB9"]
PB10 = cpupins["PB10"]
PB11 = cpupins["PB11"]
PB12 = cpupins["PB12"]
PB13 = cpupins["PB13"]
PB14 = cpupins["PB14"]
PB15 = cpupins["PB15"]
PB16 = cpupins["PB16"]
PB17 = cpupins["PB17"]
PB18 = cpupins["PB18"]
PB19 = cpupins["PB19"]
PB20 = cpupins["PB20"]
PB21 = cpupins["PB21"]
PB22 = cpupins["PB22"]
PB23 = cpupins["PB23"]
PC0 = cpupins["PC0"]
PC1 = cpupins["PC1"]
PC2 = cpupins["PC2"]
PC3 = cpupins["PC3"]
PC4 = cpupins["PC4"]
PC5 = cpupins["PC5"]
PC6 = cpupins["PC6"]
PC7 = cpupins["PC7"]
PC8 = cpupins["PC8"]
PC9 = cpupins["PC9"]
PC10 = cpupins["PC10"]
PC11 = cpupins["PC11"]
PC12 = cpupins["PC12"]
PC13 = cpupins["PC13"]
PC14 = cpupins["PC14"]
PC15 = cpupins["PC15"]
PC16 = cpupins["PC16"]
PC17 = cpupins["PC17"]
PC18 = cpupins["PC18"]
PC19 = cpupins["PC19"]
PC20 = cpupins["PC20"]
PC21 = cpupins["PC21"]
PC22 = cpupins["PC22"]
PC23 = cpupins["PC23"]
PC24 = cpupins["PC24"]
PD0 = cpupins["PD0"]
PD1 = cpupins["PD1"]
PD2 = cpupins["PD2"]
PD3 = cpupins["PD3"]
PD4 = cpupins["PD4"]
PD5 = cpupins["PD5"]
PD6 = cpupins["PD6"]
PD7 = cpupins["PD7"]
PD8 = cpupins["PD8"]
PD9 = cpupins["PD9"]
PD10 = cpupins["PD10"]
PD11 = cpupins["PD11"]
PD12 = cpupins["PD12"]
PD13 = cpupins["PD13"]
PD14 = cpupins["PD14"]
PD15 = cpupins["PD15"]
PD16 = cpupins["PD16"]
PD17 = cpupins["PD17"]
PD18 = cpupins["PD18"]
PD19 = cpupins["PD19"]
PD20 = cpupins["PD20"]
PD21 = cpupins["PD21"]
PD22 = cpupins["PD22"]
PD23 = cpupins["PD23"]
PD24 = cpupins["PD24"]
PD25 = cpupins["PD25"]
PD26 = cpupins["PD26"]
PD27 = cpupins["PD27"]
PE0 = cpupins["PE0"]
PE1 = cpupins["PE1"]
PE2 = cpupins["PE2"]
PE3 = cpupins["PE3"]
PE4 = cpupins["PE4"]
PE5 = cpupins["PE5"]
PE6 = cpupins["PE6"]
PE7 = cpupins["PE7"]
PE8 = cpupins["PE8"]
PE9 = cpupins["PE9"]
PE10 = cpupins["PE10"]
PE11 = cpupins["PE11"]
PE12 = cpupins["PE12"]
PE13 = cpupins["PE13"]
PE14 = cpupins["PE14"]
PE15 = cpupins["PE15"]
PE16 = cpupins["PE16"]
PE17 = cpupins["PE17"]
PF0 = cpupins["PF0"]
PF1 = cpupins["PF1"]
PF2 = cpupins["PF2"]
PF3 = cpupins["PF3"]
PF4 = cpupins["PF4"]
PF5 = cpupins["PF5"]
PF6 = cpupins["PF6"]
PG0 = cpupins["PG0"]
PG1 = cpupins["PG1"]
PG2 = cpupins["PG2"]
PG3 = cpupins["PG3"]
PG4 = cpupins["PG4"]
PG5 = cpupins["PG5"]
PG6 = cpupins["PG6"]
PG7 = cpupins["PG7"]
PG8 = cpupins["PG8"]
PG9 = cpupins["PG9"]
PG10 = cpupins["PG10"]
PG11 = cpupins["PG11"]
PG12 = cpupins["PG12"]
PG13 = cpupins["PG13"]
PH0 = cpupins["PH0"]
PH1 = cpupins["PH1"]
PH2 = cpupins["PH2"]
PH3 = cpupins["PH3"]
PH4 = cpupins["PH4"]
PH5 = cpupins["PH5"]
PH6 = cpupins["PH6"]
PH7 = cpupins["PH7"]
PH8 = cpupins["PH8"]
PH9 = cpupins["PH9"]
PH10 = cpupins["PH10"]
PH11 = cpupins["PH11"]
PH12 = cpupins["PH12"]
PH13 = cpupins["PH13"]
PH14 = cpupins["PH14"]
PH15 = cpupins["PH15"]
PH16 = cpupins["PH16"]
PH17 = cpupins["PH17"]
PH18 = cpupins["PH18"]
PH19 = cpupins["PH19"]
PH20 = cpupins["PH20"]
PH21 = cpupins["PH21"]
PH22 = cpupins["PH22"]
PH23 = cpupins["PH23"]
PH24 = cpupins["PH24"]
PH25 = cpupins["PH25"]
PH26 = cpupins["PH26"]
PH27 = cpupins["PH27"]
PI0 = cpupins["PI0"]
PI1 = cpupins["PI1"]
PI2 = cpupins["PI2"]
PI3 = cpupins["PI3"]
PI4 = cpupins["PI4"]
PI5 = cpupins["PI5"]
PI6 = cpupins["PI6"]
PI7 = cpupins["PI7"]
PI8 = cpupins["PI8"]
PI9 = cpupins["PI9"]
PI10 = cpupins["PI10"]
PI11 = cpupins["PI11"]
PI12 = cpupins["PI12"]
PI13 = cpupins["PI13"]
PI14 = cpupins["PI14"]
PI15 = cpupins["PI15"]
PI16 = cpupins["PI16"]
PI17 = cpupins["PI17"]
PI18 = cpupins["PI18"]
PI19 = cpupins["PI19"]
PI20 = cpupins["PI20"]
PI21 = cpupins["PI21"]
}
// initPins initializes the mapping of pins by function, sets the alternate
// functions of each pin, and registers all the pins with gpio.
func initPins() error {
functions := map[pin.Func]struct{}{}
for name, p := range cpupins {
num := strconv.Itoa(p.Number())
gpion := "GPIO" + num
// Unregister the pin if already registered. This happens with sysfs-gpio.
// Do not error on it, since sysfs-gpio may have failed to load.
_ = gpioreg.Unregister(gpion)
_ = gpioreg.Unregister(num)
// Register the pin with gpio.
if err := gpioreg.Register(p); err != nil {
return err
}
if err := gpioreg.RegisterAlias(gpion, name); err != nil {
return err
}
if err := gpioreg.RegisterAlias(num, name); err != nil {
return err
}
switch f := p.Func(); f {
case gpio.IN, gpio.OUT, pin.FuncNone:
default:
// Registering the same alias twice fails. This can happen if two pins
// are configured with the same function.
if _, ok := functions[f]; !ok {
functions[f] = struct{}{}
if err := gpioreg.RegisterAlias(string(f), name); err != nil {
return err
}
}
}
}
// Now do a second loop but do the alternate functions.
for name, p := range cpupins {
for _, f := range p.SupportedFuncs() {
switch f {
case gpio.IN, gpio.OUT:
default:
if _, ok := functions[f]; !ok {
functions[f] = struct{}{}
if err := gpioreg.RegisterAlias(string(f), name); err != nil {
return err
}
}
}
}
}
return nil
}
// function encodes the active functionality of a pin. The alternate functions
// are GPIO pin dependent.
type function uint8
// gpioGroup is a memory-mapped structure for the hardware registers that
// control a group of at most 32 pins. In practice the number of valid pins per
// group varies between 10 and 27.
//
// http://files.pine64.org/doc/datasheet/pine64/Allwinner_A64_User_Manual_V1.0.pdf
// Page 376 GPIO PB to PH.
// Page 410 GPIO PL.
// Size is 36 bytes.
type gpioGroup struct {
// Pn_CFGx n*0x24+x*4 Port n Configure Register x (n from 1(B) to 7(H))
cfg [4]uint32
// Pn_DAT n*0x24+0x10 Port n Data Register (n from 1(B) to 7(H))
data uint32
// Pn_DRVx n*0x24+0x14+x*4 Port n Multi-Driving Register x (n from 1 to 7)
drv [2]uint32
// Pn_PULL n*0x24+0x1C+x*4 Port n Pull Register (n from 1(B) to 7(H))
pull [2]uint32
}
// gpioMap memory-maps all the gpio pin groups.
type gpioMap struct {
// PA to PI.
groups [9]gpioGroup
}
// driverGPIO implements periph.Driver.
type driverGPIO struct {
// gpioMemory is the memory map of the CPU GPIO registers.
gpioMemory *gpioMap
}
func (d *driverGPIO) String() string {
return "allwinner-gpio"
}
func (d *driverGPIO) Prerequisites() []string {
return nil
}
func (d *driverGPIO) After() []string {
return []string{"sysfs-gpio"}
}
// Init does nothing if an allwinner processor is not detected. If one is
// detected, it memory maps gpio CPU registers and then sets up the pin mapping
// for the exact processor model detected.
func (d *driverGPIO) Init() (bool, error) {
if !Present() {
Upgrade dependencies
2020-09-07 16:41:44 +00:00
return false, errors.New("no Allwinner CPU detected")
First implementation
2019-12-14 10:56:22 +00:00
}
// Mark the right pins as available even if the memory map fails so they can
// callback to sysfs.Pins.
switch {
case IsA64():
if err := mapA64Pins(); err != nil {
return true, err
}
case IsR8():
if err := mapR8Pins(); err != nil {
return true, err
}
case IsA20():
if err := mapA20Pins(); err != nil {
return true, err
}
default:
return false, errors.New("unknown Allwinner CPU model")
}
// gpioBaseAddr is the physical base address of the GPIO registers.
gpioBaseAddr := uint32(getBaseAddress())
if err := pmem.MapAsPOD(uint64(gpioBaseAddr), &d.gpioMemory); err != nil {
if os.IsPermission(err) {
return true, fmt.Errorf("need more access, try as root: %v", err)
}
return true, err
}
return true, initPins()
}
func init() {
if isArm {
periph.MustRegister(&drvGPIO)
}
}
// getBaseAddress queries the virtual file system to retrieve the base address
// of the GPIO registers for GPIO pins in groups PA to PI.
//
// Defaults to 0x01C20800 as per datasheet if it could not query the file
// system.
func getBaseAddress() uint64 {
base := uint64(0x01C20800)
link, err := os.Readlink("/sys/bus/platform/drivers/sun50i-pinctrl/driver")
if err != nil {
return base
}
parts := strings.SplitN(path.Base(link), ".", 2)
if len(parts) != 2 {
return base
}
base2, err := strconv.ParseUint(parts[0], 16, 64)
if err != nil {
return base
}
return base2
}
var drvGPIO driverGPIO
// Ensure that the various structs implement the interfaces they're supposed to.
var _ gpio.PinIO = &Pin{}
var _ gpio.PinIn = &Pin{}
var _ gpio.PinOut = &Pin{}
var _ pin.PinFunc = &Pin{}
Reference in New Issue Copy Permalink