Quelle  common.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
#include <linux/pci.h>
#include <linux/interrupt.h>
#include <linux/timer.h>
#include <linux/kernel.h>

/*
 * These functions are used early on before PCI scanning is done
 * and all of the pci_dev and pci_bus structures have been created.
 */
static struct pci_dev *fake_pci_dev(struct pci_channel *hose,
 int top_bus, int busnr, int devfn)
{
 static struct pci_dev dev;
 static struct pci_bus bus;

 dev.bus = &bus;
 dev.sysdata = hose;
 dev.devfn = devfn;
 bus.number = busnr;
 bus.sysdata = hose;
 bus.ops = hose->pci_ops;

 if(busnr != top_bus)
  /* Fake a parent bus structure. */
  bus.parent = &bus;
 else
  bus.parent = NULL;

 return &dev;
}

#define EARLY_PCI_OP(rw, size, type)     \
int __init early_##rw##_config_##size(struct pci_channel *hose,  \
 int top_bus, int bus, int devfn, int offset, type value) \
{         \
 return pci_##rw##_config_##size(    \
  fake_pci_dev(hose, top_bus, bus, devfn),  \
  offset, value);      \
}

EARLY_PCI_OP(read, byte, u8 *)
EARLY_PCI_OP(read, word, u16 *)
EARLY_PCI_OP(read, dword, u32 *)
EARLY_PCI_OP(write, byte, u8)
EARLY_PCI_OP(write, word, u16)
EARLY_PCI_OP(write, dword, u32)

int __init pci_is_66mhz_capable(struct pci_channel *hose,
    int top_bus, int current_bus)
{
 u32 pci_devfn;
 u16 vid;
 int cap66 = -1;
 u16 stat;
 int ret;

 pr_info("PCI: Checking 66MHz capabilities...\n");

 for (pci_devfn = 0; pci_devfn < 0xff; pci_devfn++) {
  if (PCI_FUNC(pci_devfn))
   continue;
  ret = early_read_config_word(hose, top_bus, current_bus,
          pci_devfn, PCI_VENDOR_ID, &vid);
  if (ret != PCIBIOS_SUCCESSFUL)
   continue;
  if (PCI_POSSIBLE_ERROR(vid))
   continue;

  /* check 66MHz capability */
  if (cap66 < 0)
   cap66 = 1;
  if (cap66) {
   early_read_config_word(hose, top_bus, current_bus,
            pci_devfn, PCI_STATUS, &stat);
   if (!(stat & PCI_STATUS_66MHZ)) {
    printk(KERN_DEBUG
           "PCI: %02x:%02x not 66MHz capable.\n",
           current_bus, pci_devfn);
    cap66 = 0;
    break;
   }
  }
 }

 return cap66 > 0;
}

static void pcibios_enable_err(struct timer_list *t)
{
 struct pci_channel *hose = timer_container_of(hose, t, err_timer);

 timer_delete(&hose->err_timer);
 printk(KERN_DEBUG "PCI: re-enabling error IRQ.\n");
 enable_irq(hose->err_irq);
}

static void pcibios_enable_serr(struct timer_list *t)
{
 struct pci_channel *hose = timer_container_of(hose, t, serr_timer);

 timer_delete(&hose->serr_timer);
 printk(KERN_DEBUG "PCI: re-enabling system error IRQ.\n");
 enable_irq(hose->serr_irq);
}

void pcibios_enable_timers(struct pci_channel *hose)
{
 if (hose->err_irq) {
  timer_setup(&hose->err_timer, pcibios_enable_err, 0);
 }

 if (hose->serr_irq) {
  timer_setup(&hose->serr_timer, pcibios_enable_serr, 0);
 }
}

/*
 * A simple handler for the regular PCI status errors, called from IRQ
 * context.
 */
unsigned int pcibios_handle_status_errors(unsigned long addr,
       unsigned int status,
       struct pci_channel *hose)
{
 unsigned int cmd = 0;

 if (status & PCI_STATUS_REC_MASTER_ABORT) {
  printk(KERN_DEBUG "PCI: master abort, pc=0x%08lx\n", addr);
  cmd |= PCI_STATUS_REC_MASTER_ABORT;
 }

 if (status & PCI_STATUS_REC_TARGET_ABORT) {
  printk(KERN_DEBUG "PCI: target abort: ");
  pcibios_report_status(PCI_STATUS_REC_TARGET_ABORT |
          PCI_STATUS_SIG_TARGET_ABORT |
          PCI_STATUS_REC_MASTER_ABORT, 1);
  pr_cont("\n");

  cmd |= PCI_STATUS_REC_TARGET_ABORT;
 }

 if (status & (PCI_STATUS_PARITY | PCI_STATUS_DETECTED_PARITY)) {
  printk(KERN_DEBUG "PCI: parity error detected: ");
  pcibios_report_status(PCI_STATUS_PARITY |
          PCI_STATUS_DETECTED_PARITY, 1);
  pr_cont("\n");

  cmd |= PCI_STATUS_PARITY | PCI_STATUS_DETECTED_PARITY;

  /* Now back off of the IRQ for awhile */
  if (hose->err_irq) {
   disable_irq_nosync(hose->err_irq);
   hose->err_timer.expires = jiffies + HZ;
   add_timer(&hose->err_timer);
  }
 }

 return cmd;
}