Quelle  gpio.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Coldfire generic GPIO support.
 *
 * (C) Copyright 2009, Steven King <sfking@fdwdc.com>
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/gpio/driver.h>

#include <linux/io.h>
#include <asm/coldfire.h>
#include <asm/mcfsim.h>
#include <asm/mcfgpio.h>

int __mcfgpio_get_value(unsigned gpio)
{
 return mcfgpio_read(__mcfgpio_ppdr(gpio)) & mcfgpio_bit(gpio);
}
EXPORT_SYMBOL(__mcfgpio_get_value);

void __mcfgpio_set_value(unsigned gpio, int value)
{
 if (gpio < MCFGPIO_SCR_START) {
  unsigned long flags;
  MCFGPIO_PORTTYPE data;

  local_irq_save(flags);
  data = mcfgpio_read(__mcfgpio_podr(gpio));
  if (value)
   data |= mcfgpio_bit(gpio);
  else
   data &= ~mcfgpio_bit(gpio);
  mcfgpio_write(data, __mcfgpio_podr(gpio));
  local_irq_restore(flags);
 } else {
  if (value)
   mcfgpio_write(mcfgpio_bit(gpio),
     MCFGPIO_SETR_PORT(gpio));
  else
   mcfgpio_write(~mcfgpio_bit(gpio),
     MCFGPIO_CLRR_PORT(gpio));
 }
}
EXPORT_SYMBOL(__mcfgpio_set_value);

int __mcfgpio_direction_input(unsigned gpio)
{
 unsigned long flags;
 MCFGPIO_PORTTYPE dir;

 local_irq_save(flags);
 dir = mcfgpio_read(__mcfgpio_pddr(gpio));
 dir &= ~mcfgpio_bit(gpio);
 mcfgpio_write(dir, __mcfgpio_pddr(gpio));
 local_irq_restore(flags);

 return 0;
}
EXPORT_SYMBOL(__mcfgpio_direction_input);

int __mcfgpio_direction_output(unsigned gpio, int value)
{
 unsigned long flags;
 MCFGPIO_PORTTYPE data;

 local_irq_save(flags);
 data = mcfgpio_read(__mcfgpio_pddr(gpio));
 data |= mcfgpio_bit(gpio);
 mcfgpio_write(data, __mcfgpio_pddr(gpio));

 /* now set the data to output */
 if (gpio < MCFGPIO_SCR_START) {
  data = mcfgpio_read(__mcfgpio_podr(gpio));
  if (value)
   data |= mcfgpio_bit(gpio);
  else
   data &= ~mcfgpio_bit(gpio);
  mcfgpio_write(data, __mcfgpio_podr(gpio));
 } else {
   if (value)
   mcfgpio_write(mcfgpio_bit(gpio),
     MCFGPIO_SETR_PORT(gpio));
   else
    mcfgpio_write(~mcfgpio_bit(gpio),
      MCFGPIO_CLRR_PORT(gpio));
 }
 local_irq_restore(flags);
 return 0;
}
EXPORT_SYMBOL(__mcfgpio_direction_output);

int __mcfgpio_request(unsigned gpio)
{
 return 0;
}
EXPORT_SYMBOL(__mcfgpio_request);

void __mcfgpio_free(unsigned gpio)
{
 __mcfgpio_direction_input(gpio);
}
EXPORT_SYMBOL(__mcfgpio_free);

#ifdef CONFIG_GPIOLIB

static int mcfgpio_direction_input(struct gpio_chip *chip, unsigned offset)
{
 return __mcfgpio_direction_input(offset);
}

static int mcfgpio_get_value(struct gpio_chip *chip, unsigned offset)
{
 return !!__mcfgpio_get_value(offset);
}

static int mcfgpio_direction_output(struct gpio_chip *chip, unsigned offset,
        int value)
{
 return __mcfgpio_direction_output(offset, value);
}

static int mcfgpio_set_value(struct gpio_chip *chip, unsigned int offset,
        int value)
{
 __mcfgpio_set_value(offset, value);

 return 0;
}

static int mcfgpio_request(struct gpio_chip *chip, unsigned offset)
{
 return __mcfgpio_request(offset);
}

static void mcfgpio_free(struct gpio_chip *chip, unsigned offset)
{
 __mcfgpio_free(offset);
}

static int mcfgpio_to_irq(struct gpio_chip *chip, unsigned offset)
{
#if defined(MCFGPIO_IRQ_MIN)
 if ((offset >= MCFGPIO_IRQ_MIN) && (offset < MCFGPIO_IRQ_MAX))
#else
 if (offset < MCFGPIO_IRQ_MAX)
#endif
  return MCFGPIO_IRQ_VECBASE + offset;
 else
  return -EINVAL;
}

static struct gpio_chip mcfgpio_chip = {
 .label   = "mcfgpio",
 .request  = mcfgpio_request,
 .free   = mcfgpio_free,
 .direction_input = mcfgpio_direction_input,
 .direction_output = mcfgpio_direction_output,
 .get   = mcfgpio_get_value,
 .set   = mcfgpio_set_value,
 .to_irq   = mcfgpio_to_irq,
 .base   = 0,
 .ngpio   = MCFGPIO_PIN_MAX,
};

static int __init mcfgpio_sysinit(void)
{
 return gpiochip_add_data(&mcfgpio_chip, NULL);
}

core_initcall(mcfgpio_sysinit);
#endif