]> git.openfabrics.org - ~shefty/rdma-dev.git/commitdiff
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/trivial
authorLinus Torvalds <torvalds@linux-foundation.org>
Mon, 25 Jul 2011 20:56:39 +0000 (13:56 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Mon, 25 Jul 2011 20:56:39 +0000 (13:56 -0700)
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/trivial: (43 commits)
  fs: Merge split strings
  treewide: fix potentially dangerous trailing ';' in #defined values/expressions
  uwb: Fix misspelling of neighbourhood in comment
  net, netfilter: Remove redundant goto in ebt_ulog_packet
  trivial: don't touch files that are removed in the staging tree
  lib/vsprintf: replace link to Draft by final RFC number
  doc: Kconfig: `to be' -> `be'
  doc: Kconfig: Typo: square -> squared
  doc: Konfig: Documentation/power/{pm => apm-acpi}.txt
  drivers/net: static should be at beginning of declaration
  drivers/media: static should be at beginning of declaration
  drivers/i2c: static should be at beginning of declaration
  XTENSA: static should be at beginning of declaration
  SH: static should be at beginning of declaration
  MIPS: static should be at beginning of declaration
  ARM: static should be at beginning of declaration
  rcu: treewide: Do not use rcu_read_lock_held when calling rcu_dereference_check
  Update my e-mail address
  PCIe ASPM: forcedly -> forcibly
  gma500: push through device driver tree
  ...

Fix up trivial conflicts:
 - arch/arm/mach-ep93xx/dma-m2p.c (deleted)
 - drivers/gpio/gpio-ep93xx.c (renamed and context nearby)
 - drivers/net/r8169.c (just context changes)

86 files changed:
1  2 
Documentation/feature-removal-schedule.txt
MAINTAINERS
arch/arm/mach-shmobile/board-ap4evb.c
arch/microblaze/pci/pci-common.c
arch/powerpc/kernel/pci-common.c
arch/powerpc/platforms/powermac/pci.c
arch/powerpc/sysdev/xics/icp-native.c
arch/sparc/kernel/pci.c
arch/x86/Kconfig
arch/x86/kvm/mmu.c
crypto/Kconfig
drivers/bcma/driver_chipcommon.c
drivers/bcma/driver_chipcommon_pmu.c
drivers/bcma/driver_pci.c
drivers/gpio/gpio-ab8500.c
drivers/gpio/gpio-bt8xx.c
drivers/gpio/gpio-ep93xx.c
drivers/gpio/gpio-u300.c
drivers/mmc/host/dw_mmc.c
drivers/mtd/nand/atmel_nand.c
drivers/net/b44.c
drivers/net/bcm63xx_enet.c
drivers/net/can/softing/softing_main.c
drivers/net/davinci_emac.c
drivers/net/ethoc.c
drivers/net/fec_mpc52xx.c
drivers/net/macb.c
drivers/net/mv643xx_eth.c
drivers/net/natsemi.c
drivers/net/pxa168_eth.c
drivers/net/r8169.c
drivers/net/s2io.h
drivers/net/sungem.c
drivers/net/wireless/ath/ath5k/ahb.c
drivers/net/wireless/b43/dma.c
drivers/net/wireless/b43/leds.c
drivers/net/wireless/b43/lo.c
drivers/net/wireless/b43/main.c
drivers/net/wireless/b43/main.h
drivers/net/wireless/b43/phy_a.c
drivers/net/wireless/b43/phy_common.c
drivers/net/wireless/b43/phy_g.c
drivers/net/wireless/b43/phy_lp.c
drivers/net/wireless/b43/phy_n.c
drivers/net/wireless/b43/pio.c
drivers/net/wireless/b43/rfkill.c
drivers/net/wireless/b43/sdio.c
drivers/net/wireless/b43/sysfs.c
drivers/net/wireless/b43/tables_lpphy.c
drivers/net/wireless/b43/wa.c
drivers/net/wireless/b43/xmit.c
drivers/net/wireless/b43legacy/dma.c
drivers/net/wireless/b43legacy/main.c
drivers/net/wireless/b43legacy/xmit.c
drivers/net/wireless/iwlegacy/iwl-commands.h
drivers/net/wireless/iwlwifi/iwl-commands.h
drivers/net/wireless/rtlwifi/rtl8192ce/reg.h
drivers/ssb/driver_chipcommon_pmu.c
drivers/ssb/driver_gige.c
drivers/ssb/driver_pcicore.c
drivers/ssb/main.c
drivers/ssb/pci.c
drivers/ssb/pcihost_wrapper.c
drivers/ssb/scan.c
drivers/staging/brcm80211/brcmfmac/wl_iw.c
drivers/target/tcm_fc/tfc_cmd.c
drivers/target/tcm_fc/tfc_conf.c
drivers/target/tcm_fc/tfc_io.c
drivers/target/tcm_fc/tfc_sess.c
fs/xfs/xfs_dir2_node.c
include/linux/fs.h
include/linux/nl80211.h
include/linux/rtnetlink.h
include/linux/stop_machine.h
include/net/sock.h
kernel/cgroup.c
kernel/exit.c
kernel/power/Kconfig
kernel/sched.c
mm/slub.c
net/netlabel/netlabel_unlabeled.c
sound/pci/ice1712/ice1712.c
sound/soc/ep93xx/ep93xx-i2s.c
sound/soc/ep93xx/ep93xx-pcm.c
sound/soc/fsl/mpc5200_dma.c
sound/soc/omap/ams-delta.c

diff --cc MAINTAINERS
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
diff --cc crypto/Kconfig
Simple merge
Simple merge
Simple merge
Simple merge
index 970053c89ff7a70d80c7536477c8e06e52530951,0000000000000000000000000000000000000000..ed795e64eea7d68eaca749832225e3c3ef01108b
mode 100644,000000..100644
--- /dev/null
@@@ -1,521 -1,0 +1,520 @@@
- #include <linux/slab.h>
 +/*
 + * Copyright (C) ST-Ericsson SA 2011
 + *
 + * Author: BIBEK BASU <bibek.basu@stericsson.com>
 + * License terms: GNU General Public License (GPL) version 2
 + *
 + * This program is free software; you can redistribute it and/or modify
 + * it under the terms of the GNU General Public License version 2 as
 + * published by the Free Software Foundation.
 + */
 +#include <linux/kernel.h>
 +#include <linux/types.h>
 +#include <linux/slab.h>
 +#include <linux/init.h>
 +#include <linux/module.h>
 +#include <linux/err.h>
 +#include <linux/platform_device.h>
 +#include <linux/gpio.h>
 +#include <linux/irq.h>
 +#include <linux/interrupt.h>
 +#include <linux/mfd/ab8500.h>
 +#include <linux/mfd/abx500.h>
 +#include <linux/mfd/ab8500/gpio.h>
 +
 +/*
 + * GPIO registers offset
 + * Bank: 0x10
 + */
 +#define AB8500_GPIO_SEL1_REG  0x00
 +#define AB8500_GPIO_SEL2_REG  0x01
 +#define AB8500_GPIO_SEL3_REG  0x02
 +#define AB8500_GPIO_SEL4_REG  0x03
 +#define AB8500_GPIO_SEL5_REG  0x04
 +#define AB8500_GPIO_SEL6_REG  0x05
 +
 +#define AB8500_GPIO_DIR1_REG  0x10
 +#define AB8500_GPIO_DIR2_REG  0x11
 +#define AB8500_GPIO_DIR3_REG  0x12
 +#define AB8500_GPIO_DIR4_REG  0x13
 +#define AB8500_GPIO_DIR5_REG  0x14
 +#define AB8500_GPIO_DIR6_REG  0x15
 +
 +#define AB8500_GPIO_OUT1_REG  0x20
 +#define AB8500_GPIO_OUT2_REG  0x21
 +#define AB8500_GPIO_OUT3_REG  0x22
 +#define AB8500_GPIO_OUT4_REG  0x23
 +#define AB8500_GPIO_OUT5_REG  0x24
 +#define AB8500_GPIO_OUT6_REG  0x25
 +
 +#define AB8500_GPIO_PUD1_REG  0x30
 +#define AB8500_GPIO_PUD2_REG  0x31
 +#define AB8500_GPIO_PUD3_REG  0x32
 +#define AB8500_GPIO_PUD4_REG  0x33
 +#define AB8500_GPIO_PUD5_REG  0x34
 +#define AB8500_GPIO_PUD6_REG  0x35
 +
 +#define AB8500_GPIO_IN1_REG   0x40
 +#define AB8500_GPIO_IN2_REG   0x41
 +#define AB8500_GPIO_IN3_REG   0x42
 +#define AB8500_GPIO_IN4_REG   0x43
 +#define AB8500_GPIO_IN5_REG   0x44
 +#define AB8500_GPIO_IN6_REG   0x45
 +#define AB8500_GPIO_ALTFUN_REG        0x45
 +#define ALTFUN_REG_INDEX      6
 +#define AB8500_NUM_GPIO               42
 +#define AB8500_NUM_VIR_GPIO_IRQ       16
 +
 +enum ab8500_gpio_action {
 +      NONE,
 +      STARTUP,
 +      SHUTDOWN,
 +      MASK,
 +      UNMASK
 +};
 +
 +struct ab8500_gpio {
 +      struct gpio_chip chip;
 +      struct ab8500 *parent;
 +      struct device *dev;
 +      struct mutex lock;
 +      u32 irq_base;
 +      enum ab8500_gpio_action irq_action;
 +      u16 rising;
 +      u16 falling;
 +};
 +/**
 + * to_ab8500_gpio() - get the pointer to ab8500_gpio
 + * @chip:     Member of the structure ab8500_gpio
 + */
 +static inline struct ab8500_gpio *to_ab8500_gpio(struct gpio_chip *chip)
 +{
 +      return container_of(chip, struct ab8500_gpio, chip);
 +}
 +
 +static int ab8500_gpio_set_bits(struct gpio_chip *chip, u8 reg,
 +                                      unsigned offset, int val)
 +{
 +      struct ab8500_gpio *ab8500_gpio = to_ab8500_gpio(chip);
 +      u8 pos = offset % 8;
 +      int ret;
 +
 +      reg = reg + (offset / 8);
 +      ret = abx500_mask_and_set_register_interruptible(ab8500_gpio->dev,
 +                              AB8500_MISC, reg, 1 << pos, val << pos);
 +      if (ret < 0)
 +              dev_err(ab8500_gpio->dev, "%s write failed\n", __func__);
 +      return ret;
 +}
 +/**
 + * ab8500_gpio_get() - Get the particular GPIO value
 + * @chip: Gpio device
 + * @offset: GPIO number to read
 + */
 +static int ab8500_gpio_get(struct gpio_chip *chip, unsigned offset)
 +{
 +      struct ab8500_gpio *ab8500_gpio = to_ab8500_gpio(chip);
 +      u8 mask = 1 << (offset % 8);
 +      u8 reg = AB8500_GPIO_OUT1_REG + (offset / 8);
 +      int ret;
 +      u8 data;
 +      ret = abx500_get_register_interruptible(ab8500_gpio->dev, AB8500_MISC,
 +                                              reg, &data);
 +      if (ret < 0) {
 +              dev_err(ab8500_gpio->dev, "%s read failed\n", __func__);
 +              return ret;
 +      }
 +      return (data & mask) >> (offset % 8);
 +}
 +
 +static void ab8500_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
 +{
 +      struct ab8500_gpio *ab8500_gpio = to_ab8500_gpio(chip);
 +      int ret;
 +      /* Write the data */
 +      ret = ab8500_gpio_set_bits(chip, AB8500_GPIO_OUT1_REG, offset, 1);
 +      if (ret < 0)
 +              dev_err(ab8500_gpio->dev, "%s write failed\n", __func__);
 +}
 +
 +static int ab8500_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
 +                                      int val)
 +{
 +      int ret;
 +      /* set direction as output */
 +      ret = ab8500_gpio_set_bits(chip, AB8500_GPIO_DIR1_REG, offset, 1);
 +      if (ret < 0)
 +              return ret;
 +      /* disable pull down */
 +      ret = ab8500_gpio_set_bits(chip, AB8500_GPIO_PUD1_REG, offset, 1);
 +      if (ret < 0)
 +              return ret;
 +      /* set the output as 1 or 0 */
 +      return ab8500_gpio_set_bits(chip, AB8500_GPIO_OUT1_REG, offset, val);
 +
 +}
 +
 +static int ab8500_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 +{
 +      /* set the register as input */
 +      return ab8500_gpio_set_bits(chip, AB8500_GPIO_DIR1_REG, offset, 0);
 +}
 +
 +static int ab8500_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 +{
 +      /*
 +       * Only some GPIOs are interrupt capable, and they are
 +       * organized in discontiguous clusters:
 +       *
 +       *      GPIO6 to GPIO13
 +       *      GPIO24 and GPIO25
 +       *      GPIO36 to GPIO41
 +       */
 +      static struct ab8500_gpio_irq_cluster {
 +              int start;
 +              int end;
 +      } clusters[] = {
 +              {.start = 6,  .end = 13},
 +              {.start = 24, .end = 25},
 +              {.start = 36, .end = 41},
 +      };
 +      struct ab8500_gpio *ab8500_gpio = to_ab8500_gpio(chip);
 +      int base = ab8500_gpio->irq_base;
 +      int i;
 +
 +      for (i = 0; i < ARRAY_SIZE(clusters); i++) {
 +              struct ab8500_gpio_irq_cluster *cluster = &clusters[i];
 +
 +              if (offset >= cluster->start && offset <= cluster->end)
 +                      return base + offset - cluster->start;
 +
 +              /* Advance by the number of gpios in this cluster */
 +              base += cluster->end - cluster->start + 1;
 +      }
 +
 +      return -EINVAL;
 +}
 +
 +static struct gpio_chip ab8500gpio_chip = {
 +      .label                  = "ab8500_gpio",
 +      .owner                  = THIS_MODULE,
 +      .direction_input        = ab8500_gpio_direction_input,
 +      .get                    = ab8500_gpio_get,
 +      .direction_output       = ab8500_gpio_direction_output,
 +      .set                    = ab8500_gpio_set,
 +      .to_irq                 = ab8500_gpio_to_irq,
 +};
 +
 +static unsigned int irq_to_rising(unsigned int irq)
 +{
 +      struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
 +      int offset = irq - ab8500_gpio->irq_base;
 +      int new_irq = offset +  AB8500_INT_GPIO6R
 +                      + ab8500_gpio->parent->irq_base;
 +      return new_irq;
 +}
 +
 +static unsigned int irq_to_falling(unsigned int irq)
 +{
 +      struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
 +      int offset = irq - ab8500_gpio->irq_base;
 +      int new_irq = offset +  AB8500_INT_GPIO6F
 +                      +  ab8500_gpio->parent->irq_base;
 +      return new_irq;
 +
 +}
 +
 +static unsigned int rising_to_irq(unsigned int irq, void *dev)
 +{
 +      struct ab8500_gpio *ab8500_gpio = dev;
 +      int offset = irq - AB8500_INT_GPIO6R
 +                      - ab8500_gpio->parent->irq_base ;
 +      int new_irq = offset + ab8500_gpio->irq_base;
 +      return new_irq;
 +}
 +
 +static unsigned int falling_to_irq(unsigned int irq, void *dev)
 +{
 +      struct ab8500_gpio *ab8500_gpio = dev;
 +      int offset = irq - AB8500_INT_GPIO6F
 +                      - ab8500_gpio->parent->irq_base ;
 +      int new_irq = offset + ab8500_gpio->irq_base;
 +      return new_irq;
 +
 +}
 +
 +/*
 + * IRQ handler
 + */
 +
 +static irqreturn_t handle_rising(int irq, void *dev)
 +{
 +
 +      handle_nested_irq(rising_to_irq(irq , dev));
 +      return IRQ_HANDLED;
 +}
 +
 +static irqreturn_t handle_falling(int irq, void *dev)
 +{
 +
 +      handle_nested_irq(falling_to_irq(irq, dev));
 +      return IRQ_HANDLED;
 +}
 +
 +static void ab8500_gpio_irq_lock(unsigned int irq)
 +{
 +      struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
 +      mutex_lock(&ab8500_gpio->lock);
 +}
 +
 +static void ab8500_gpio_irq_sync_unlock(unsigned int irq)
 +{
 +      struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
 +      int offset = irq - ab8500_gpio->irq_base;
 +      bool rising = ab8500_gpio->rising & BIT(offset);
 +      bool falling = ab8500_gpio->falling & BIT(offset);
 +      int ret;
 +
 +      switch (ab8500_gpio->irq_action)        {
 +      case STARTUP:
 +              if (rising)
 +                      ret = request_threaded_irq(irq_to_rising(irq),
 +                                      NULL, handle_rising,
 +                                      IRQF_TRIGGER_RISING,
 +                                      "ab8500-gpio-r", ab8500_gpio);
 +              if (falling)
 +                      ret = request_threaded_irq(irq_to_falling(irq),
 +                                     NULL, handle_falling,
 +                                     IRQF_TRIGGER_FALLING,
 +                                     "ab8500-gpio-f", ab8500_gpio);
 +              break;
 +      case SHUTDOWN:
 +              if (rising)
 +                      free_irq(irq_to_rising(irq), ab8500_gpio);
 +              if (falling)
 +                      free_irq(irq_to_falling(irq), ab8500_gpio);
 +              break;
 +      case MASK:
 +              if (rising)
 +                      disable_irq(irq_to_rising(irq));
 +              if (falling)
 +                      disable_irq(irq_to_falling(irq));
 +              break;
 +      case UNMASK:
 +              if (rising)
 +                      enable_irq(irq_to_rising(irq));
 +              if (falling)
 +                      enable_irq(irq_to_falling(irq));
 +              break;
 +      case NONE:
 +              break;
 +      }
 +      ab8500_gpio->irq_action = NONE;
 +      ab8500_gpio->rising &= ~(BIT(offset));
 +      ab8500_gpio->falling &= ~(BIT(offset));
 +      mutex_unlock(&ab8500_gpio->lock);
 +}
 +
 +
 +static void ab8500_gpio_irq_mask(unsigned int irq)
 +{
 +      struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
 +      ab8500_gpio->irq_action = MASK;
 +}
 +
 +static void ab8500_gpio_irq_unmask(unsigned int irq)
 +{
 +      struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
 +      ab8500_gpio->irq_action = UNMASK;
 +}
 +
 +static int ab8500_gpio_irq_set_type(unsigned int irq, unsigned int type)
 +{
 +      struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
 +      int offset = irq - ab8500_gpio->irq_base;
 +
 +      if (type == IRQ_TYPE_EDGE_BOTH) {
 +              ab8500_gpio->rising =  BIT(offset);
 +              ab8500_gpio->falling = BIT(offset);
 +      } else if (type == IRQ_TYPE_EDGE_RISING) {
 +              ab8500_gpio->rising =  BIT(offset);
 +      } else  {
 +              ab8500_gpio->falling = BIT(offset);
 +      }
 +      return 0;
 +}
 +
 +unsigned int ab8500_gpio_irq_startup(unsigned int irq)
 +{
 +      struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
 +      ab8500_gpio->irq_action = STARTUP;
 +      return 0;
 +}
 +
 +void ab8500_gpio_irq_shutdown(unsigned int irq)
 +{
 +      struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
 +      ab8500_gpio->irq_action = SHUTDOWN;
 +}
 +
 +static struct irq_chip ab8500_gpio_irq_chip = {
 +      .name                   = "ab8500-gpio",
 +      .startup                = ab8500_gpio_irq_startup,
 +      .shutdown               = ab8500_gpio_irq_shutdown,
 +      .bus_lock               = ab8500_gpio_irq_lock,
 +      .bus_sync_unlock        = ab8500_gpio_irq_sync_unlock,
 +      .mask                   = ab8500_gpio_irq_mask,
 +      .unmask                 = ab8500_gpio_irq_unmask,
 +      .set_type               = ab8500_gpio_irq_set_type,
 +};
 +
 +static int ab8500_gpio_irq_init(struct ab8500_gpio *ab8500_gpio)
 +{
 +      u32 base = ab8500_gpio->irq_base;
 +      int irq;
 +
 +      for (irq = base; irq < base + AB8500_NUM_VIR_GPIO_IRQ ; irq++) {
 +              set_irq_chip_data(irq, ab8500_gpio);
 +              set_irq_chip_and_handler(irq, &ab8500_gpio_irq_chip,
 +                              handle_simple_irq);
 +              set_irq_nested_thread(irq, 1);
 +#ifdef CONFIG_ARM
 +              set_irq_flags(irq, IRQF_VALID);
 +#else
 +              set_irq_noprobe(irq);
 +#endif
 +      }
 +
 +      return 0;
 +}
 +
 +static void ab8500_gpio_irq_remove(struct ab8500_gpio *ab8500_gpio)
 +{
 +      int base = ab8500_gpio->irq_base;
 +      int irq;
 +
 +      for (irq = base; irq < base + AB8500_NUM_VIR_GPIO_IRQ; irq++) {
 +#ifdef CONFIG_ARM
 +              set_irq_flags(irq, 0);
 +#endif
 +              set_irq_chip_and_handler(irq, NULL, NULL);
 +              set_irq_chip_data(irq, NULL);
 +      }
 +}
 +
 +static int __devinit ab8500_gpio_probe(struct platform_device *pdev)
 +{
 +      struct ab8500_platform_data *ab8500_pdata =
 +                              dev_get_platdata(pdev->dev.parent);
 +      struct ab8500_gpio_platform_data *pdata;
 +      struct ab8500_gpio *ab8500_gpio;
 +      int ret;
 +      int i;
 +
 +      pdata = ab8500_pdata->gpio;
 +      if (!pdata)     {
 +              dev_err(&pdev->dev, "gpio platform data missing\n");
 +              return -ENODEV;
 +      }
 +
 +      ab8500_gpio = kzalloc(sizeof(struct ab8500_gpio), GFP_KERNEL);
 +      if (ab8500_gpio == NULL) {
 +              dev_err(&pdev->dev, "failed to allocate memory\n");
 +              return -ENOMEM;
 +      }
 +      ab8500_gpio->dev = &pdev->dev;
 +      ab8500_gpio->parent = dev_get_drvdata(pdev->dev.parent);
 +      ab8500_gpio->chip = ab8500gpio_chip;
 +      ab8500_gpio->chip.ngpio = AB8500_NUM_GPIO;
 +      ab8500_gpio->chip.dev = &pdev->dev;
 +      ab8500_gpio->chip.base = pdata->gpio_base;
 +      ab8500_gpio->irq_base = pdata->irq_base;
 +      /* initialize the lock */
 +      mutex_init(&ab8500_gpio->lock);
 +      /*
 +       * AB8500 core will handle and clear the IRQ
 +       * configre GPIO based on config-reg value.
 +       * These values are for selecting the PINs as
 +       * GPIO or alternate function
 +       */
 +      for (i = AB8500_GPIO_SEL1_REG; i <= AB8500_GPIO_SEL6_REG; i++)  {
 +              ret = abx500_set_register_interruptible(ab8500_gpio->dev,
 +                              AB8500_MISC, i,
 +                              pdata->config_reg[i]);
 +              if (ret < 0)
 +                      goto out_free;
 +      }
 +      ret = abx500_set_register_interruptible(ab8500_gpio->dev, AB8500_MISC,
 +                              AB8500_GPIO_ALTFUN_REG,
 +                              pdata->config_reg[ALTFUN_REG_INDEX]);
 +      if (ret < 0)
 +              goto out_free;
 +
 +      ret = ab8500_gpio_irq_init(ab8500_gpio);
 +      if (ret)
 +              goto out_free;
 +      ret = gpiochip_add(&ab8500_gpio->chip);
 +      if (ret) {
 +              dev_err(&pdev->dev, "unable to add gpiochip: %d\n",
 +                              ret);
 +              goto out_rem_irq;
 +      }
 +      platform_set_drvdata(pdev, ab8500_gpio);
 +      return 0;
 +
 +out_rem_irq:
 +      ab8500_gpio_irq_remove(ab8500_gpio);
 +out_free:
 +      mutex_destroy(&ab8500_gpio->lock);
 +      kfree(ab8500_gpio);
 +      return ret;
 +}
 +
 +/*
 + * ab8500_gpio_remove() - remove Ab8500-gpio driver
 + * @pdev :    Platform device registered
 + */
 +static int __devexit ab8500_gpio_remove(struct platform_device *pdev)
 +{
 +      struct ab8500_gpio *ab8500_gpio = platform_get_drvdata(pdev);
 +      int ret;
 +
 +      ret = gpiochip_remove(&ab8500_gpio->chip);
 +      if (ret < 0) {
 +              dev_err(ab8500_gpio->dev, "unable to remove gpiochip: %d\n",
 +                      ret);
 +              return ret;
 +      }
 +
 +      platform_set_drvdata(pdev, NULL);
 +      mutex_destroy(&ab8500_gpio->lock);
 +      kfree(ab8500_gpio);
 +
 +      return 0;
 +}
 +
 +static struct platform_driver ab8500_gpio_driver = {
 +      .driver = {
 +              .name = "ab8500-gpio",
 +              .owner = THIS_MODULE,
 +      },
 +      .probe = ab8500_gpio_probe,
 +      .remove = __devexit_p(ab8500_gpio_remove),
 +};
 +
 +static int __init ab8500_gpio_init(void)
 +{
 +      return platform_driver_register(&ab8500_gpio_driver);
 +}
 +arch_initcall(ab8500_gpio_init);
 +
 +static void __exit ab8500_gpio_exit(void)
 +{
 +      platform_driver_unregister(&ab8500_gpio_driver);
 +}
 +module_exit(ab8500_gpio_exit);
 +
 +MODULE_AUTHOR("BIBEK BASU <bibek.basu@stericsson.com>");
 +MODULE_DESCRIPTION("Driver allows to use AB8500 unused pins to be used as GPIO");
 +MODULE_ALIAS("AB8500 GPIO driver");
 +MODULE_LICENSE("GPL v2");
index aa4f09ad3cede46381641831d0b00a305f9c9099,0000000000000000000000000000000000000000..ec57936aef62ff936bc6cb0244dc029be467a879
mode 100644,000000..100644
--- /dev/null
@@@ -1,348 -1,0 +1,348 @@@
-     Copyright (C) 2008 Michael Buesch <mb@bu3sch.de>
 +/*
 +
 +    bt8xx GPIO abuser
 +
++    Copyright (C) 2008 Michael Buesch <m@bues.ch>
 +
 +    Please do _only_ contact the people listed _above_ with issues related to this driver.
 +    All the other people listed below are not related to this driver. Their names
 +    are only here, because this driver is derived from the bt848 driver.
 +
 +
 +    Derived from the bt848 driver:
 +
 +    Copyright (C) 1996,97,98 Ralph  Metzler
 +                         & Marcus Metzler
 +    (c) 1999-2002 Gerd Knorr
 +
 +    some v4l2 code lines are taken from Justin's bttv2 driver which is
 +    (c) 2000 Justin Schoeman
 +
 +    V4L1 removal from:
 +    (c) 2005-2006 Nickolay V. Shmyrev
 +
 +    Fixes to be fully V4L2 compliant by
 +    (c) 2006 Mauro Carvalho Chehab
 +
 +    Cropping and overscan support
 +    Copyright (C) 2005, 2006 Michael H. Schimek
 +    Sponsored by OPQ Systems AB
 +
 +    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; either version 2 of the License, or
 +    (at your option) any later version.
 +
 +    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., 675 Mass Ave, Cambridge, MA 02139, USA.
 +*/
 +
 +#include <linux/module.h>
 +#include <linux/pci.h>
 +#include <linux/spinlock.h>
 +#include <linux/gpio.h>
 +#include <linux/slab.h>
 +
 +/* Steal the hardware definitions from the bttv driver. */
 +#include "../media/video/bt8xx/bt848.h"
 +
 +
 +#define BT8XXGPIO_NR_GPIOS            24 /* We have 24 GPIO pins */
 +
 +
 +struct bt8xxgpio {
 +      spinlock_t lock;
 +
 +      void __iomem *mmio;
 +      struct pci_dev *pdev;
 +      struct gpio_chip gpio;
 +
 +#ifdef CONFIG_PM
 +      u32 saved_outen;
 +      u32 saved_data;
 +#endif
 +};
 +
 +#define bgwrite(dat, adr)     writel((dat), bg->mmio+(adr))
 +#define bgread(adr)           readl(bg->mmio+(adr))
 +
 +
 +static int modparam_gpiobase = -1/* dynamic */;
 +module_param_named(gpiobase, modparam_gpiobase, int, 0444);
 +MODULE_PARM_DESC(gpiobase, "The GPIO number base. -1 means dynamic, which is the default.");
 +
 +
 +static int bt8xxgpio_gpio_direction_input(struct gpio_chip *gpio, unsigned nr)
 +{
 +      struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
 +      unsigned long flags;
 +      u32 outen, data;
 +
 +      spin_lock_irqsave(&bg->lock, flags);
 +
 +      data = bgread(BT848_GPIO_DATA);
 +      data &= ~(1 << nr);
 +      bgwrite(data, BT848_GPIO_DATA);
 +
 +      outen = bgread(BT848_GPIO_OUT_EN);
 +      outen &= ~(1 << nr);
 +      bgwrite(outen, BT848_GPIO_OUT_EN);
 +
 +      spin_unlock_irqrestore(&bg->lock, flags);
 +
 +      return 0;
 +}
 +
 +static int bt8xxgpio_gpio_get(struct gpio_chip *gpio, unsigned nr)
 +{
 +      struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
 +      unsigned long flags;
 +      u32 val;
 +
 +      spin_lock_irqsave(&bg->lock, flags);
 +      val = bgread(BT848_GPIO_DATA);
 +      spin_unlock_irqrestore(&bg->lock, flags);
 +
 +      return !!(val & (1 << nr));
 +}
 +
 +static int bt8xxgpio_gpio_direction_output(struct gpio_chip *gpio,
 +                                      unsigned nr, int val)
 +{
 +      struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
 +      unsigned long flags;
 +      u32 outen, data;
 +
 +      spin_lock_irqsave(&bg->lock, flags);
 +
 +      outen = bgread(BT848_GPIO_OUT_EN);
 +      outen |= (1 << nr);
 +      bgwrite(outen, BT848_GPIO_OUT_EN);
 +
 +      data = bgread(BT848_GPIO_DATA);
 +      if (val)
 +              data |= (1 << nr);
 +      else
 +              data &= ~(1 << nr);
 +      bgwrite(data, BT848_GPIO_DATA);
 +
 +      spin_unlock_irqrestore(&bg->lock, flags);
 +
 +      return 0;
 +}
 +
 +static void bt8xxgpio_gpio_set(struct gpio_chip *gpio,
 +                          unsigned nr, int val)
 +{
 +      struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
 +      unsigned long flags;
 +      u32 data;
 +
 +      spin_lock_irqsave(&bg->lock, flags);
 +
 +      data = bgread(BT848_GPIO_DATA);
 +      if (val)
 +              data |= (1 << nr);
 +      else
 +              data &= ~(1 << nr);
 +      bgwrite(data, BT848_GPIO_DATA);
 +
 +      spin_unlock_irqrestore(&bg->lock, flags);
 +}
 +
 +static void bt8xxgpio_gpio_setup(struct bt8xxgpio *bg)
 +{
 +      struct gpio_chip *c = &bg->gpio;
 +
 +      c->label = dev_name(&bg->pdev->dev);
 +      c->owner = THIS_MODULE;
 +      c->direction_input = bt8xxgpio_gpio_direction_input;
 +      c->get = bt8xxgpio_gpio_get;
 +      c->direction_output = bt8xxgpio_gpio_direction_output;
 +      c->set = bt8xxgpio_gpio_set;
 +      c->dbg_show = NULL;
 +      c->base = modparam_gpiobase;
 +      c->ngpio = BT8XXGPIO_NR_GPIOS;
 +      c->can_sleep = 0;
 +}
 +
 +static int bt8xxgpio_probe(struct pci_dev *dev,
 +                      const struct pci_device_id *pci_id)
 +{
 +      struct bt8xxgpio *bg;
 +      int err;
 +
 +      bg = kzalloc(sizeof(*bg), GFP_KERNEL);
 +      if (!bg)
 +              return -ENOMEM;
 +
 +      bg->pdev = dev;
 +      spin_lock_init(&bg->lock);
 +
 +      err = pci_enable_device(dev);
 +      if (err) {
 +              printk(KERN_ERR "bt8xxgpio: Can't enable device.\n");
 +              goto err_freebg;
 +      }
 +      if (!request_mem_region(pci_resource_start(dev, 0),
 +                              pci_resource_len(dev, 0),
 +                              "bt8xxgpio")) {
 +              printk(KERN_WARNING "bt8xxgpio: Can't request iomem (0x%llx).\n",
 +                     (unsigned long long)pci_resource_start(dev, 0));
 +              err = -EBUSY;
 +              goto err_disable;
 +      }
 +      pci_set_master(dev);
 +      pci_set_drvdata(dev, bg);
 +
 +      bg->mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
 +      if (!bg->mmio) {
 +              printk(KERN_ERR "bt8xxgpio: ioremap() failed\n");
 +              err = -EIO;
 +              goto err_release_mem;
 +      }
 +
 +      /* Disable interrupts */
 +      bgwrite(0, BT848_INT_MASK);
 +
 +      /* gpio init */
 +      bgwrite(0, BT848_GPIO_DMA_CTL);
 +      bgwrite(0, BT848_GPIO_REG_INP);
 +      bgwrite(0, BT848_GPIO_OUT_EN);
 +
 +      bt8xxgpio_gpio_setup(bg);
 +      err = gpiochip_add(&bg->gpio);
 +      if (err) {
 +              printk(KERN_ERR "bt8xxgpio: Failed to register GPIOs\n");
 +              goto err_release_mem;
 +      }
 +
 +      printk(KERN_INFO "bt8xxgpio: Abusing BT8xx card for GPIOs %d to %d\n",
 +             bg->gpio.base, bg->gpio.base + BT8XXGPIO_NR_GPIOS - 1);
 +
 +      return 0;
 +
 +err_release_mem:
 +      release_mem_region(pci_resource_start(dev, 0),
 +                         pci_resource_len(dev, 0));
 +      pci_set_drvdata(dev, NULL);
 +err_disable:
 +      pci_disable_device(dev);
 +err_freebg:
 +      kfree(bg);
 +
 +      return err;
 +}
 +
 +static void bt8xxgpio_remove(struct pci_dev *pdev)
 +{
 +      struct bt8xxgpio *bg = pci_get_drvdata(pdev);
 +
 +      gpiochip_remove(&bg->gpio);
 +
 +      bgwrite(0, BT848_INT_MASK);
 +      bgwrite(~0x0, BT848_INT_STAT);
 +      bgwrite(0x0, BT848_GPIO_OUT_EN);
 +
 +      iounmap(bg->mmio);
 +      release_mem_region(pci_resource_start(pdev, 0),
 +                         pci_resource_len(pdev, 0));
 +      pci_disable_device(pdev);
 +
 +      pci_set_drvdata(pdev, NULL);
 +      kfree(bg);
 +}
 +
 +#ifdef CONFIG_PM
 +static int bt8xxgpio_suspend(struct pci_dev *pdev, pm_message_t state)
 +{
 +      struct bt8xxgpio *bg = pci_get_drvdata(pdev);
 +      unsigned long flags;
 +
 +      spin_lock_irqsave(&bg->lock, flags);
 +
 +      bg->saved_outen = bgread(BT848_GPIO_OUT_EN);
 +      bg->saved_data = bgread(BT848_GPIO_DATA);
 +
 +      bgwrite(0, BT848_INT_MASK);
 +      bgwrite(~0x0, BT848_INT_STAT);
 +      bgwrite(0x0, BT848_GPIO_OUT_EN);
 +
 +      spin_unlock_irqrestore(&bg->lock, flags);
 +
 +      pci_save_state(pdev);
 +      pci_disable_device(pdev);
 +      pci_set_power_state(pdev, pci_choose_state(pdev, state));
 +
 +      return 0;
 +}
 +
 +static int bt8xxgpio_resume(struct pci_dev *pdev)
 +{
 +      struct bt8xxgpio *bg = pci_get_drvdata(pdev);
 +      unsigned long flags;
 +      int err;
 +
 +      pci_set_power_state(pdev, 0);
 +      err = pci_enable_device(pdev);
 +      if (err)
 +              return err;
 +      pci_restore_state(pdev);
 +
 +      spin_lock_irqsave(&bg->lock, flags);
 +
 +      bgwrite(0, BT848_INT_MASK);
 +      bgwrite(0, BT848_GPIO_DMA_CTL);
 +      bgwrite(0, BT848_GPIO_REG_INP);
 +      bgwrite(bg->saved_outen, BT848_GPIO_OUT_EN);
 +      bgwrite(bg->saved_data & bg->saved_outen,
 +              BT848_GPIO_DATA);
 +
 +      spin_unlock_irqrestore(&bg->lock, flags);
 +
 +      return 0;
 +}
 +#else
 +#define bt8xxgpio_suspend NULL
 +#define bt8xxgpio_resume NULL
 +#endif /* CONFIG_PM */
 +
 +static struct pci_device_id bt8xxgpio_pci_tbl[] = {
 +      { PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848) },
 +      { PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849) },
 +      { PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878) },
 +      { PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879) },
 +      { 0, },
 +};
 +MODULE_DEVICE_TABLE(pci, bt8xxgpio_pci_tbl);
 +
 +static struct pci_driver bt8xxgpio_pci_driver = {
 +      .name           = "bt8xxgpio",
 +      .id_table       = bt8xxgpio_pci_tbl,
 +      .probe          = bt8xxgpio_probe,
 +      .remove         = bt8xxgpio_remove,
 +      .suspend        = bt8xxgpio_suspend,
 +      .resume         = bt8xxgpio_resume,
 +};
 +
 +static int __init bt8xxgpio_init(void)
 +{
 +      return pci_register_driver(&bt8xxgpio_pci_driver);
 +}
 +module_init(bt8xxgpio_init)
 +
 +static void __exit bt8xxgpio_exit(void)
 +{
 +      pci_unregister_driver(&bt8xxgpio_pci_driver);
 +}
 +module_exit(bt8xxgpio_exit)
 +
 +MODULE_LICENSE("GPL");
 +MODULE_AUTHOR("Michael Buesch");
 +MODULE_DESCRIPTION("Abuse a BT8xx framegrabber card as generic GPIO card");
index 3bfd3417ab113f9fa596e13563158a0cf2c7c20d,0000000000000000000000000000000000000000..72fb9c665320804b43c7e9bff8bcd663fdc2ba74
mode 100644,000000..100644
--- /dev/null
@@@ -1,405 -1,0 +1,405 @@@
-  * Copyright (c) 2008 Ryan Mallon <ryan@bluewatersys.com>
 +/*
 + * Generic EP93xx GPIO handling
 + *
++ * Copyright (c) 2008 Ryan Mallon
 + * Copyright (c) 2011 H Hartley Sweeten <hsweeten@visionengravers.com>
 + *
 + * Based on code originally from:
 + *  linux/arch/arm/mach-ep93xx/core.c
 + *
 + *  This program is free software; you can redistribute it and/or modify
 + *  it under the terms of the GNU General Public License version 2 as
 + *  published by the Free Software Foundation.
 + */
 +
 +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 +
 +#include <linux/init.h>
 +#include <linux/platform_device.h>
 +#include <linux/io.h>
 +#include <linux/gpio.h>
 +#include <linux/irq.h>
 +#include <linux/slab.h>
 +#include <linux/basic_mmio_gpio.h>
 +
 +#include <mach/hardware.h>
 +
 +struct ep93xx_gpio {
 +      void __iomem            *mmio_base;
 +      struct bgpio_chip       bgc[8];
 +};
 +
 +/*************************************************************************
 + * Interrupt handling for EP93xx on-chip GPIOs
 + *************************************************************************/
 +static unsigned char gpio_int_unmasked[3];
 +static unsigned char gpio_int_enabled[3];
 +static unsigned char gpio_int_type1[3];
 +static unsigned char gpio_int_type2[3];
 +static unsigned char gpio_int_debounce[3];
 +
 +/* Port ordering is: A B F */
 +static const u8 int_type1_register_offset[3]  = { 0x90, 0xac, 0x4c };
 +static const u8 int_type2_register_offset[3]  = { 0x94, 0xb0, 0x50 };
 +static const u8 eoi_register_offset[3]                = { 0x98, 0xb4, 0x54 };
 +static const u8 int_en_register_offset[3]     = { 0x9c, 0xb8, 0x58 };
 +static const u8 int_debounce_register_offset[3]       = { 0xa8, 0xc4, 0x64 };
 +
 +static void ep93xx_gpio_update_int_params(unsigned port)
 +{
 +      BUG_ON(port > 2);
 +
 +      __raw_writeb(0, EP93XX_GPIO_REG(int_en_register_offset[port]));
 +
 +      __raw_writeb(gpio_int_type2[port],
 +              EP93XX_GPIO_REG(int_type2_register_offset[port]));
 +
 +      __raw_writeb(gpio_int_type1[port],
 +              EP93XX_GPIO_REG(int_type1_register_offset[port]));
 +
 +      __raw_writeb(gpio_int_unmasked[port] & gpio_int_enabled[port],
 +              EP93XX_GPIO_REG(int_en_register_offset[port]));
 +}
 +
 +static inline void ep93xx_gpio_int_mask(unsigned line)
 +{
 +      gpio_int_unmasked[line >> 3] &= ~(1 << (line & 7));
 +}
 +
 +static void ep93xx_gpio_int_debounce(unsigned int irq, bool enable)
 +{
 +      int line = irq_to_gpio(irq);
 +      int port = line >> 3;
 +      int port_mask = 1 << (line & 7);
 +
 +      if (enable)
 +              gpio_int_debounce[port] |= port_mask;
 +      else
 +              gpio_int_debounce[port] &= ~port_mask;
 +
 +      __raw_writeb(gpio_int_debounce[port],
 +              EP93XX_GPIO_REG(int_debounce_register_offset[port]));
 +}
 +
 +static void ep93xx_gpio_ab_irq_handler(unsigned int irq, struct irq_desc *desc)
 +{
 +      unsigned char status;
 +      int i;
 +
 +      status = __raw_readb(EP93XX_GPIO_A_INT_STATUS);
 +      for (i = 0; i < 8; i++) {
 +              if (status & (1 << i)) {
 +                      int gpio_irq = gpio_to_irq(EP93XX_GPIO_LINE_A(0)) + i;
 +                      generic_handle_irq(gpio_irq);
 +              }
 +      }
 +
 +      status = __raw_readb(EP93XX_GPIO_B_INT_STATUS);
 +      for (i = 0; i < 8; i++) {
 +              if (status & (1 << i)) {
 +                      int gpio_irq = gpio_to_irq(EP93XX_GPIO_LINE_B(0)) + i;
 +                      generic_handle_irq(gpio_irq);
 +              }
 +      }
 +}
 +
 +static void ep93xx_gpio_f_irq_handler(unsigned int irq, struct irq_desc *desc)
 +{
 +      /*
 +       * map discontiguous hw irq range to continuous sw irq range:
 +       *
 +       *  IRQ_EP93XX_GPIO{0..7}MUX -> gpio_to_irq(EP93XX_GPIO_LINE_F({0..7})
 +       */
 +      int port_f_idx = ((irq + 1) & 7) ^ 4; /* {19..22,47..50} -> {0..7} */
 +      int gpio_irq = gpio_to_irq(EP93XX_GPIO_LINE_F(0)) + port_f_idx;
 +
 +      generic_handle_irq(gpio_irq);
 +}
 +
 +static void ep93xx_gpio_irq_ack(struct irq_data *d)
 +{
 +      int line = irq_to_gpio(d->irq);
 +      int port = line >> 3;
 +      int port_mask = 1 << (line & 7);
 +
 +      if (irqd_get_trigger_type(d) == IRQ_TYPE_EDGE_BOTH) {
 +              gpio_int_type2[port] ^= port_mask; /* switch edge direction */
 +              ep93xx_gpio_update_int_params(port);
 +      }
 +
 +      __raw_writeb(port_mask, EP93XX_GPIO_REG(eoi_register_offset[port]));
 +}
 +
 +static void ep93xx_gpio_irq_mask_ack(struct irq_data *d)
 +{
 +      int line = irq_to_gpio(d->irq);
 +      int port = line >> 3;
 +      int port_mask = 1 << (line & 7);
 +
 +      if (irqd_get_trigger_type(d) == IRQ_TYPE_EDGE_BOTH)
 +              gpio_int_type2[port] ^= port_mask; /* switch edge direction */
 +
 +      gpio_int_unmasked[port] &= ~port_mask;
 +      ep93xx_gpio_update_int_params(port);
 +
 +      __raw_writeb(port_mask, EP93XX_GPIO_REG(eoi_register_offset[port]));
 +}
 +
 +static void ep93xx_gpio_irq_mask(struct irq_data *d)
 +{
 +      int line = irq_to_gpio(d->irq);
 +      int port = line >> 3;
 +
 +      gpio_int_unmasked[port] &= ~(1 << (line & 7));
 +      ep93xx_gpio_update_int_params(port);
 +}
 +
 +static void ep93xx_gpio_irq_unmask(struct irq_data *d)
 +{
 +      int line = irq_to_gpio(d->irq);
 +      int port = line >> 3;
 +
 +      gpio_int_unmasked[port] |= 1 << (line & 7);
 +      ep93xx_gpio_update_int_params(port);
 +}
 +
 +/*
 + * gpio_int_type1 controls whether the interrupt is level (0) or
 + * edge (1) triggered, while gpio_int_type2 controls whether it
 + * triggers on low/falling (0) or high/rising (1).
 + */
 +static int ep93xx_gpio_irq_type(struct irq_data *d, unsigned int type)
 +{
 +      const int gpio = irq_to_gpio(d->irq);
 +      const int port = gpio >> 3;
 +      const int port_mask = 1 << (gpio & 7);
 +      irq_flow_handler_t handler;
 +
 +      gpio_direction_input(gpio);
 +
 +      switch (type) {
 +      case IRQ_TYPE_EDGE_RISING:
 +              gpio_int_type1[port] |= port_mask;
 +              gpio_int_type2[port] |= port_mask;
 +              handler = handle_edge_irq;
 +              break;
 +      case IRQ_TYPE_EDGE_FALLING:
 +              gpio_int_type1[port] |= port_mask;
 +              gpio_int_type2[port] &= ~port_mask;
 +              handler = handle_edge_irq;
 +              break;
 +      case IRQ_TYPE_LEVEL_HIGH:
 +              gpio_int_type1[port] &= ~port_mask;
 +              gpio_int_type2[port] |= port_mask;
 +              handler = handle_level_irq;
 +              break;
 +      case IRQ_TYPE_LEVEL_LOW:
 +              gpio_int_type1[port] &= ~port_mask;
 +              gpio_int_type2[port] &= ~port_mask;
 +              handler = handle_level_irq;
 +              break;
 +      case IRQ_TYPE_EDGE_BOTH:
 +              gpio_int_type1[port] |= port_mask;
 +              /* set initial polarity based on current input level */
 +              if (gpio_get_value(gpio))
 +                      gpio_int_type2[port] &= ~port_mask; /* falling */
 +              else
 +                      gpio_int_type2[port] |= port_mask; /* rising */
 +              handler = handle_edge_irq;
 +              break;
 +      default:
 +              pr_err("failed to set irq type %d for gpio %d\n", type, gpio);
 +              return -EINVAL;
 +      }
 +
 +      __irq_set_handler_locked(d->irq, handler);
 +
 +      gpio_int_enabled[port] |= port_mask;
 +
 +      ep93xx_gpio_update_int_params(port);
 +
 +      return 0;
 +}
 +
 +static struct irq_chip ep93xx_gpio_irq_chip = {
 +      .name           = "GPIO",
 +      .irq_ack        = ep93xx_gpio_irq_ack,
 +      .irq_mask_ack   = ep93xx_gpio_irq_mask_ack,
 +      .irq_mask       = ep93xx_gpio_irq_mask,
 +      .irq_unmask     = ep93xx_gpio_irq_unmask,
 +      .irq_set_type   = ep93xx_gpio_irq_type,
 +};
 +
 +static void ep93xx_gpio_init_irq(void)
 +{
 +      int gpio_irq;
 +
 +      for (gpio_irq = gpio_to_irq(0);
 +           gpio_irq <= gpio_to_irq(EP93XX_GPIO_LINE_MAX_IRQ); ++gpio_irq) {
 +              irq_set_chip_and_handler(gpio_irq, &ep93xx_gpio_irq_chip,
 +                                       handle_level_irq);
 +              set_irq_flags(gpio_irq, IRQF_VALID);
 +      }
 +
 +      irq_set_chained_handler(IRQ_EP93XX_GPIO_AB,
 +                              ep93xx_gpio_ab_irq_handler);
 +      irq_set_chained_handler(IRQ_EP93XX_GPIO0MUX,
 +                              ep93xx_gpio_f_irq_handler);
 +      irq_set_chained_handler(IRQ_EP93XX_GPIO1MUX,
 +                              ep93xx_gpio_f_irq_handler);
 +      irq_set_chained_handler(IRQ_EP93XX_GPIO2MUX,
 +                              ep93xx_gpio_f_irq_handler);
 +      irq_set_chained_handler(IRQ_EP93XX_GPIO3MUX,
 +                              ep93xx_gpio_f_irq_handler);
 +      irq_set_chained_handler(IRQ_EP93XX_GPIO4MUX,
 +                              ep93xx_gpio_f_irq_handler);
 +      irq_set_chained_handler(IRQ_EP93XX_GPIO5MUX,
 +                              ep93xx_gpio_f_irq_handler);
 +      irq_set_chained_handler(IRQ_EP93XX_GPIO6MUX,
 +                              ep93xx_gpio_f_irq_handler);
 +      irq_set_chained_handler(IRQ_EP93XX_GPIO7MUX,
 +                              ep93xx_gpio_f_irq_handler);
 +}
 +
 +
 +/*************************************************************************
 + * gpiolib interface for EP93xx on-chip GPIOs
 + *************************************************************************/
 +struct ep93xx_gpio_bank {
 +      const char      *label;
 +      int             data;
 +      int             dir;
 +      int             base;
 +      bool            has_debounce;
 +};
 +
 +#define EP93XX_GPIO_BANK(_label, _data, _dir, _base, _debounce)       \
 +      {                                                       \
 +              .label          = _label,                       \
 +              .data           = _data,                        \
 +              .dir            = _dir,                         \
 +              .base           = _base,                        \
 +              .has_debounce   = _debounce,                    \
 +      }
 +
 +static struct ep93xx_gpio_bank ep93xx_gpio_banks[] = {
 +      EP93XX_GPIO_BANK("A", 0x00, 0x10, 0, true),
 +      EP93XX_GPIO_BANK("B", 0x04, 0x14, 8, true),
 +      EP93XX_GPIO_BANK("C", 0x08, 0x18, 40, false),
 +      EP93XX_GPIO_BANK("D", 0x0c, 0x1c, 24, false),
 +      EP93XX_GPIO_BANK("E", 0x20, 0x24, 32, false),
 +      EP93XX_GPIO_BANK("F", 0x30, 0x34, 16, true),
 +      EP93XX_GPIO_BANK("G", 0x38, 0x3c, 48, false),
 +      EP93XX_GPIO_BANK("H", 0x40, 0x44, 56, false),
 +};
 +
 +static int ep93xx_gpio_set_debounce(struct gpio_chip *chip,
 +                                  unsigned offset, unsigned debounce)
 +{
 +      int gpio = chip->base + offset;
 +      int irq = gpio_to_irq(gpio);
 +
 +      if (irq < 0)
 +              return -EINVAL;
 +
 +      ep93xx_gpio_int_debounce(irq, debounce ? true : false);
 +
 +      return 0;
 +}
 +
 +static int ep93xx_gpio_add_bank(struct bgpio_chip *bgc, struct device *dev,
 +      void __iomem *mmio_base, struct ep93xx_gpio_bank *bank)
 +{
 +      void __iomem *data = mmio_base + bank->data;
 +      void __iomem *dir =  mmio_base + bank->dir;
 +      int err;
 +
 +      err = bgpio_init(bgc, dev, 1, data, NULL, NULL, dir, NULL, false);
 +      if (err)
 +              return err;
 +
 +      bgc->gc.label = bank->label;
 +      bgc->gc.base = bank->base;
 +
 +      if (bank->has_debounce)
 +              bgc->gc.set_debounce = ep93xx_gpio_set_debounce;
 +
 +      return gpiochip_add(&bgc->gc);
 +}
 +
 +static int __devinit ep93xx_gpio_probe(struct platform_device *pdev)
 +{
 +      struct ep93xx_gpio *ep93xx_gpio;
 +      struct resource *res;
 +      void __iomem *mmio;
 +      int i;
 +      int ret;
 +
 +      ep93xx_gpio = kzalloc(sizeof(*ep93xx_gpio), GFP_KERNEL);
 +      if (!ep93xx_gpio)
 +              return -ENOMEM;
 +
 +      res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 +      if (!res) {
 +              ret = -ENXIO;
 +              goto exit_free;
 +      }
 +
 +      if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
 +              ret = -EBUSY;
 +              goto exit_free;
 +      }
 +
 +      mmio = ioremap(res->start, resource_size(res));
 +      if (!mmio) {
 +              ret = -ENXIO;
 +              goto exit_release;
 +      }
 +      ep93xx_gpio->mmio_base = mmio;
 +
 +      /* Default all ports to GPIO */
 +      ep93xx_devcfg_set_bits(EP93XX_SYSCON_DEVCFG_KEYS |
 +                             EP93XX_SYSCON_DEVCFG_GONK |
 +                             EP93XX_SYSCON_DEVCFG_EONIDE |
 +                             EP93XX_SYSCON_DEVCFG_GONIDE |
 +                             EP93XX_SYSCON_DEVCFG_HONIDE);
 +
 +      for (i = 0; i < ARRAY_SIZE(ep93xx_gpio_banks); i++) {
 +              struct bgpio_chip *bgc = &ep93xx_gpio->bgc[i];
 +              struct ep93xx_gpio_bank *bank = &ep93xx_gpio_banks[i];
 +
 +              if (ep93xx_gpio_add_bank(bgc, &pdev->dev, mmio, bank))
 +                      dev_warn(&pdev->dev, "Unable to add gpio bank %s\n",
 +                              bank->label);
 +      }
 +
 +      ep93xx_gpio_init_irq();
 +
 +      return 0;
 +
 +exit_release:
 +      release_mem_region(res->start, resource_size(res));
 +exit_free:
 +      kfree(ep93xx_gpio);
 +      dev_info(&pdev->dev, "%s failed with errno %d\n", __func__, ret);
 +      return ret;
 +}
 +
 +static struct platform_driver ep93xx_gpio_driver = {
 +      .driver         = {
 +              .name   = "gpio-ep93xx",
 +              .owner  = THIS_MODULE,
 +      },
 +      .probe          = ep93xx_gpio_probe,
 +};
 +
 +static int __init ep93xx_gpio_init(void)
 +{
 +      return platform_driver_register(&ep93xx_gpio_driver);
 +}
 +postcore_initcall(ep93xx_gpio_init);
 +
 +MODULE_AUTHOR("Ryan Mallon <ryan@bluewatersys.com> "
 +              "H Hartley Sweeten <hsweeten@visionengravers.com>");
 +MODULE_DESCRIPTION("EP93XX GPIO driver");
 +MODULE_LICENSE("GPL");
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 4e2d1448093cda6f10bb42041d574c803bea3382,6f3630618fa8de007e18689dcd2ff2bb66505175..7d9c650f395e1399a7185c9338f26b5fd8713db7
@@@ -682,19 -666,8 +682,19 @@@ struct rtl8169_private 
        struct rtl8169_counters counters;
        u32 saved_wolopts;
  
 -      const struct firmware *fw;
 +      struct rtl_fw {
 +              const struct firmware *fw;
 +
 +#define RTL_VER_SIZE          32
 +
 +              char version[RTL_VER_SIZE];
 +
 +              struct rtl_fw_phy_action {
 +                      __le32 *code;
 +                      size_t size;
 +              } phy_action;
 +      } *rtl_fw;
- #define RTL_FIRMWARE_UNKNOWN  ERR_PTR(-EAGAIN);
+ #define RTL_FIRMWARE_UNKNOWN  ERR_PTR(-EAGAIN)
  };
  
  MODULE_AUTHOR("Realtek and the Linux r8169 crew <netdev@vger.kernel.org>");
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 35eec917f2321b23599f8773416a6c3c48110292,ab843bc1d5d7d8a197d2d6c3cad8ccc5a7fb058b..53e6a10655e1ed346cc8e5ca48e6f70049227da1
  #include <linux/semaphore.h>
  #include <bcmdefs.h>
  #include <linux/netdevice.h>
 +#include <linux/hardirq.h>
  #include <wlioctl.h>
  #include <bcmutils.h>
  #include <linux/if_arp.h>
  #include <asm/uaccess.h>
+ #include <linux/ieee80211.h>
  
  #include <dngl_stats.h>
  #include <dhd.h>
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
diff --cc kernel/cgroup.c
Simple merge
diff --cc kernel/exit.c
Simple merge
Simple merge
diff --cc kernel/sched.c
Simple merge
diff --cc mm/slub.c
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge