Quelle  embedded.c   Sprache: C

/*
 * Sonics Silicon Backplane
 * Embedded systems support code
 *
 * Copyright 2005-2008, Broadcom Corporation
 * Copyright 2006-2008, Michael Buesch <m@bues.ch>
 * Copyright 2012, Hauke Mehrtens <hauke@hauke-m.de>
 *
 * Licensed under the GNU/GPL. See COPYING for details.
 */

#include "ssb_private.h"

#include <linux/export.h>
#include <linux/platform_device.h>
#include <linux/ssb/ssb.h>
#include <linux/ssb/ssb_embedded.h>
#include <linux/ssb/ssb_driver_pci.h>
#include <linux/ssb/ssb_driver_gige.h>
#include <linux/pci.h>


int ssb_watchdog_timer_set(struct ssb_bus *bus, u32 ticks)
{
 if (ssb_chipco_available(&bus->chipco)) {
  ssb_chipco_watchdog_timer_set(&bus->chipco, ticks);
  return 0;
 }
 if (ssb_extif_available(&bus->extif)) {
  ssb_extif_watchdog_timer_set(&bus->extif, ticks);
  return 0;
 }
 return -ENODEV;
}
EXPORT_SYMBOL(ssb_watchdog_timer_set);

int ssb_watchdog_register(struct ssb_bus *bus)
{
 struct bcm47xx_wdt wdt = {};
 struct platform_device *pdev;

 if (ssb_chipco_available(&bus->chipco)) {
  wdt.driver_data = &bus->chipco;
  wdt.timer_set = ssb_chipco_watchdog_timer_set_wdt;
  wdt.timer_set_ms = ssb_chipco_watchdog_timer_set_ms;
  wdt.max_timer_ms = bus->chipco.max_timer_ms;
 } else if (ssb_extif_available(&bus->extif)) {
  wdt.driver_data = &bus->extif;
  wdt.timer_set = ssb_extif_watchdog_timer_set_wdt;
  wdt.timer_set_ms = ssb_extif_watchdog_timer_set_ms;
  wdt.max_timer_ms = SSB_EXTIF_WATCHDOG_MAX_TIMER_MS;
 } else {
  return -ENODEV;
 }

 pdev = platform_device_register_data(NULL, "bcm47xx-wdt",
          bus->busnumber, &wdt,
          sizeof(wdt));
 if (IS_ERR(pdev)) {
  pr_debug("can not register watchdog device, err: %li\n",
    PTR_ERR(pdev));
  return PTR_ERR(pdev);
 }

 bus->watchdog = pdev;
 return 0;
}

u32 ssb_gpio_in(struct ssb_bus *bus, u32 mask)
{
 unsigned long flags;
 u32 res = 0;

 spin_lock_irqsave(&bus->gpio_lock, flags);
 if (ssb_chipco_available(&bus->chipco))
  res = ssb_chipco_gpio_in(&bus->chipco, mask);
 else if (ssb_extif_available(&bus->extif))
  res = ssb_extif_gpio_in(&bus->extif, mask);
 else
  WARN_ON(1);
 spin_unlock_irqrestore(&bus->gpio_lock, flags);

 return res;
}
EXPORT_SYMBOL(ssb_gpio_in);

u32 ssb_gpio_out(struct ssb_bus *bus, u32 mask, u32 value)
{
 unsigned long flags;
 u32 res = 0;

 spin_lock_irqsave(&bus->gpio_lock, flags);
 if (ssb_chipco_available(&bus->chipco))
  res = ssb_chipco_gpio_out(&bus->chipco, mask, value);
 else if (ssb_extif_available(&bus->extif))
  res = ssb_extif_gpio_out(&bus->extif, mask, value);
 else
  WARN_ON(1);
 spin_unlock_irqrestore(&bus->gpio_lock, flags);

 return res;
}
EXPORT_SYMBOL(ssb_gpio_out);

u32 ssb_gpio_outen(struct ssb_bus *bus, u32 mask, u32 value)
{
 unsigned long flags;
 u32 res = 0;

 spin_lock_irqsave(&bus->gpio_lock, flags);
 if (ssb_chipco_available(&bus->chipco))
  res = ssb_chipco_gpio_outen(&bus->chipco, mask, value);
 else if (ssb_extif_available(&bus->extif))
  res = ssb_extif_gpio_outen(&bus->extif, mask, value);
 else
  WARN_ON(1);
 spin_unlock_irqrestore(&bus->gpio_lock, flags);

 return res;
}
EXPORT_SYMBOL(ssb_gpio_outen);

u32 ssb_gpio_control(struct ssb_bus *bus, u32 mask, u32 value)
{
 unsigned long flags;
 u32 res = 0;

 spin_lock_irqsave(&bus->gpio_lock, flags);
 if (ssb_chipco_available(&bus->chipco))
  res = ssb_chipco_gpio_control(&bus->chipco, mask, value);
 spin_unlock_irqrestore(&bus->gpio_lock, flags);

 return res;
}
EXPORT_SYMBOL(ssb_gpio_control);

u32 ssb_gpio_intmask(struct ssb_bus *bus, u32 mask, u32 value)
{
 unsigned long flags;
 u32 res = 0;

 spin_lock_irqsave(&bus->gpio_lock, flags);
 if (ssb_chipco_available(&bus->chipco))
  res = ssb_chipco_gpio_intmask(&bus->chipco, mask, value);
 else if (ssb_extif_available(&bus->extif))
  res = ssb_extif_gpio_intmask(&bus->extif, mask, value);
 else
  WARN_ON(1);
 spin_unlock_irqrestore(&bus->gpio_lock, flags);

 return res;
}
EXPORT_SYMBOL(ssb_gpio_intmask);

u32 ssb_gpio_polarity(struct ssb_bus *bus, u32 mask, u32 value)
{
 unsigned long flags;
 u32 res = 0;

 spin_lock_irqsave(&bus->gpio_lock, flags);
 if (ssb_chipco_available(&bus->chipco))
  res = ssb_chipco_gpio_polarity(&bus->chipco, mask, value);
 else if (ssb_extif_available(&bus->extif))
  res = ssb_extif_gpio_polarity(&bus->extif, mask, value);
 else
  WARN_ON(1);
 spin_unlock_irqrestore(&bus->gpio_lock, flags);

 return res;
}
EXPORT_SYMBOL(ssb_gpio_polarity);

#ifdef CONFIG_SSB_DRIVER_GIGE
static int gige_pci_init_callback(struct ssb_bus *bus, unsigned long data)
{
 struct pci_dev *pdev = (struct pci_dev *)data;
 struct ssb_device *dev;
 unsigned int i;
 int res;

 for (i = 0; i < bus->nr_devices; i++) {
  dev = &(bus->devices[i]);
  if (dev->id.coreid != SSB_DEV_ETHERNET_GBIT)
   continue;
  if (!dev->dev ||
      !dev->dev->driver ||
      !device_is_registered(dev->dev))
   continue;
  res = ssb_gige_pcibios_plat_dev_init(dev, pdev);
  if (res >= 0)
   return res;
 }

 return -ENODEV;
}
#endif /* CONFIG_SSB_DRIVER_GIGE */

int ssb_pcibios_plat_dev_init(struct pci_dev *dev)
{
 int err;

 err = ssb_pcicore_plat_dev_init(dev);
 if (!err)
  return 0;
#ifdef CONFIG_SSB_DRIVER_GIGE
 err = ssb_for_each_bus_call((unsigned long)dev, gige_pci_init_callback);
 if (err >= 0)
  return err;
#endif
 /* This is not a PCI device on any SSB device. */

 return -ENODEV;
}

#ifdef CONFIG_SSB_DRIVER_GIGE
static int gige_map_irq_callback(struct ssb_bus *bus, unsigned long data)
{
 const struct pci_dev *pdev = (const struct pci_dev *)data;
 struct ssb_device *dev;
 unsigned int i;
 int res;

 for (i = 0; i < bus->nr_devices; i++) {
  dev = &(bus->devices[i]);
  if (dev->id.coreid != SSB_DEV_ETHERNET_GBIT)
   continue;
  if (!dev->dev ||
      !dev->dev->driver ||
      !device_is_registered(dev->dev))
   continue;
  res = ssb_gige_map_irq(dev, pdev);
  if (res >= 0)
   return res;
 }

 return -ENODEV;
}
#endif /* CONFIG_SSB_DRIVER_GIGE */

int ssb_pcibios_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
{
 int res;

 /* Check if this PCI device is a device on a SSB bus or device
 * and return the IRQ number for it. */

 res = ssb_pcicore_pcibios_map_irq(dev, slot, pin);
 if (res >= 0)
  return res;
#ifdef CONFIG_SSB_DRIVER_GIGE
 res = ssb_for_each_bus_call((unsigned long)dev, gige_map_irq_callback);
 if (res >= 0)
  return res;
#endif
 /* This is not a PCI device on any SSB device. */

 return -ENODEV;
}