Skip to content

L
linux
Commit d8ac3593 authored by Jeremy Sowden's avatar Jeremy Sowden Committed by Greg Kroah-Hartman
Browse files
Options

staging: kpc2000: improved formatting of core.c. 

  * Indented with tabs.
  * Broke lines over 80 columns where possible.
  * Removed braces from one-statement blocks.
  * Tidied up some comments.
  * Removed multiple blank lines.
Signed-off-by: default avatarJeremy Sowden <jeremy@azazel.net>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 99803f17
Hide whitespace changes
Inline Side-by-side
Showing with 422 additions and 347 deletions
drivers/staging/kpc2000/kpc2000/core.c
View file @ d8ac3593
...@@ -26,28 +26,51 @@ ...@@ -26,28 +26,51 @@
#include "uapi.h" #include "uapi.h"
/******************************************************* /*******************************************************
* SysFS Attributes * SysFS Attributes
******************************************************/ ******************************************************/
static ssize_t show_attr(struct device *dev, struct device_attribute *attr, char *buf)
static ssize_t show_attr(struct device *dev, struct device_attribute *attr,
char *buf)
{ {
struct pci_dev *pdev = to_pci_dev(dev); struct pci_dev *pdev = to_pci_dev(dev);
struct kp2000_device *pcard; struct kp2000_device *pcard;
if (!pdev) return -ENXIO; if (!pdev)
pcard = pci_get_drvdata(pdev); return -ENXIO;
if (!pcard) return -ENXIO; pcard = pci_get_drvdata(pdev);
if (!pcard)
if (strcmp("ssid", attr->attr.name) == 0){ return scnprintf(buf, PAGE_SIZE, "%016llx\n", pcard->ssid); } else return -ENXIO;
if (strcmp("ddna", attr->attr.name) == 0){ return scnprintf(buf, PAGE_SIZE, "%016llx\n", pcard->ddna); } else
if (strcmp("card_id", attr->attr.name) == 0){ return scnprintf(buf, PAGE_SIZE, "%08x\n", pcard->card_id); } else if (strcmp("ssid", attr->attr.name) == 0)
if (strcmp("hw_rev", attr->attr.name) == 0){ return scnprintf(buf, PAGE_SIZE, "%08x\n", pcard->hardware_revision); } else return scnprintf(buf, PAGE_SIZE, "%016llx\n", pcard->ssid);
if (strcmp("build", attr->attr.name) == 0){ return scnprintf(buf, PAGE_SIZE, "%08x\n", pcard->build_version); } else
if (strcmp("build_date", attr->attr.name) == 0){ return scnprintf(buf, PAGE_SIZE, "%08x\n", pcard->build_datestamp); } else if (strcmp("ddna", attr->attr.name) == 0)
if (strcmp("build_time", attr->attr.name) == 0){ return scnprintf(buf, PAGE_SIZE, "%08x\n", pcard->build_timestamp); } else return scnprintf(buf, PAGE_SIZE, "%016llx\n", pcard->ddna);
{ return -ENXIO; }
if (strcmp("card_id", attr->attr.name) == 0)
return scnprintf(buf, PAGE_SIZE, "%08x\n", pcard->card_id);
if (strcmp("hw_rev", attr->attr.name) == 0)
return scnprintf(buf, PAGE_SIZE, "%08x\n",
pcard->hardware_revision);
if (strcmp("build", attr->attr.name) == 0)
return scnprintf(buf, PAGE_SIZE, "%08x\n",
pcard->build_version);
if (strcmp("build_date", attr->attr.name) == 0)
return scnprintf(buf, PAGE_SIZE, "%08x\n",
pcard->build_datestamp);
if (strcmp("build_time", attr->attr.name) == 0)
return scnprintf(buf, PAGE_SIZE, "%08x\n",
pcard->build_timestamp);
return -ENXIO;
} }
static ssize_t show_cpld_config_reg(struct device *dev, struct device_attribute *attr, char *buf) static ssize_t show_cpld_config_reg(struct device *dev,
struct device_attribute *attr, char *buf)
{ {
struct pci_dev *pdev = to_pci_dev(dev); struct pci_dev *pdev = to_pci_dev(dev);
struct kp2000_device *pcard; struct kp2000_device *pcard;
...@@ -63,27 +86,33 @@ static ssize_t show_cpld_config_reg(struct device *dev, struct device_attribute ...@@ -63,27 +86,33 @@ static ssize_t show_cpld_config_reg(struct device *dev, struct device_attribute
val = readq(pcard->sysinfo_regs_base + REG_CPLD_CONFIG); val = readq(pcard->sysinfo_regs_base + REG_CPLD_CONFIG);
return scnprintf(buf, PAGE_SIZE, "%016llx\n", val); return scnprintf(buf, PAGE_SIZE, "%016llx\n", val);
} }
static ssize_t cpld_reconfigure(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
static ssize_t cpld_reconfigure(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{ {
struct pci_dev *pdev = to_pci_dev(dev); struct pci_dev *pdev = to_pci_dev(dev);
long wr_val; long wr_val;
struct kp2000_device *pcard; struct kp2000_device *pcard;
int rv; int rv;
if (!pdev) return -ENXIO; if (!pdev)
pcard = pci_get_drvdata(pdev); return -ENXIO;
if (!pcard) return -ENXIO; pcard = pci_get_drvdata(pdev);
if (!pcard)
rv = kstrtol(buf, 0, &wr_val); return -ENXIO;
if (rv < 0) return rv;
if (wr_val > 7) return -EINVAL; rv = kstrtol(buf, 0, &wr_val);
if (rv < 0)
wr_val = wr_val << 8; return rv;
wr_val |= 0x1; // Set the "Configure Go" bit if (wr_val > 7)
writeq(wr_val, pcard->sysinfo_regs_base + REG_CPLD_CONFIG); return -EINVAL;
return count;
}
wr_val = wr_val << 8;
wr_val |= 0x1; // Set the "Configure Go" bit
writeq(wr_val, pcard->sysinfo_regs_base + REG_CPLD_CONFIG);
return count;
}
DEVICE_ATTR(ssid, 0444, show_attr, NULL); DEVICE_ATTR(ssid, 0444, show_attr, NULL);
DEVICE_ATTR(ddna, 0444, show_attr, NULL); DEVICE_ATTR(ddna, 0444, show_attr, NULL);
...@@ -95,106 +124,109 @@ DEVICE_ATTR(build_time, 0444, show_attr, NULL); ...@@ -95,106 +124,109 @@ DEVICE_ATTR(build_time, 0444, show_attr, NULL);
DEVICE_ATTR(cpld_reg, 0444, show_cpld_config_reg, NULL); DEVICE_ATTR(cpld_reg, 0444, show_cpld_config_reg, NULL);
DEVICE_ATTR(cpld_reconfigure, 0220, NULL, cpld_reconfigure); DEVICE_ATTR(cpld_reconfigure, 0220, NULL, cpld_reconfigure);
static const struct attribute * kp_attr_list[] = { static const struct attribute *kp_attr_list[] = {
&dev_attr_ssid.attr, &dev_attr_ssid.attr,
&dev_attr_ddna.attr, &dev_attr_ddna.attr,
&dev_attr_card_id.attr, &dev_attr_card_id.attr,
&dev_attr_hw_rev.attr, &dev_attr_hw_rev.attr,
&dev_attr_build.attr, &dev_attr_build.attr,
&dev_attr_build_date.attr, &dev_attr_build_date.attr,
&dev_attr_build_time.attr, &dev_attr_build_time.attr,
&dev_attr_cpld_reg.attr, &dev_attr_cpld_reg.attr,
&dev_attr_cpld_reconfigure.attr, &dev_attr_cpld_reconfigure.attr,
NULL, NULL,
}; };
/******************************************************* /*******************************************************
* Functions * Functions
******************************************************/ ******************************************************/
static void wait_and_read_ssid(struct kp2000_device *pcard) static void wait_and_read_ssid(struct kp2000_device *pcard)
{ {
u64 read_val = readq(pcard->sysinfo_regs_base + REG_FPGA_SSID); u64 read_val = readq(pcard->sysinfo_regs_base + REG_FPGA_SSID);
unsigned long timeout; unsigned long timeout;
if (read_val & 0x8000000000000000){ if (read_val & 0x8000000000000000) {
pcard->ssid = read_val; pcard->ssid = read_val;
return; return;
} }
timeout = jiffies + (HZ * 2); timeout = jiffies + (HZ * 2);
do { do {
read_val = readq(pcard->sysinfo_regs_base + REG_FPGA_SSID); read_val = readq(pcard->sysinfo_regs_base + REG_FPGA_SSID);
if (read_val & 0x8000000000000000){ if (read_val & 0x8000000000000000) {
pcard->ssid = read_val; pcard->ssid = read_val;
return; return;
} }
cpu_relax(); cpu_relax();
//schedule(); //schedule();
} while (time_before(jiffies, timeout)); } while (time_before(jiffies, timeout));
dev_notice(&pcard->pdev->dev, "SSID didn't show up!\n"); dev_notice(&pcard->pdev->dev, "SSID didn't show up!\n");
#if 0 #if 0
// Timed out waiting for the SSID to show up, just use the DDNA instead? // Timed out waiting for the SSID to show up, just use the DDNA instead?
read_val = readq(pcard->sysinfo_regs_base + REG_FPGA_DDNA); read_val = readq(pcard->sysinfo_regs_base + REG_FPGA_DDNA);
pcard->ssid = read_val; pcard->ssid = read_val;
#else #else
// Timed out waiting for the SSID to show up, stick all zeros in the value // Timed out waiting for the SSID to show up, stick all zeros in the
pcard->ssid = 0; // value
#endif pcard->ssid = 0;
#endif
} }
static int read_system_regs(struct kp2000_device *pcard) static int read_system_regs(struct kp2000_device *pcard)
{ {
u64 read_val; u64 read_val;
read_val = readq(pcard->sysinfo_regs_base + REG_MAGIC_NUMBER); read_val = readq(pcard->sysinfo_regs_base + REG_MAGIC_NUMBER);
if (read_val != KP2000_MAGIC_VALUE){ if (read_val != KP2000_MAGIC_VALUE) {
dev_err(&pcard->pdev->dev, "Invalid magic! Got: 0x%016llx Want: 0x%016lx\n", read_val, KP2000_MAGIC_VALUE); dev_err(&pcard->pdev->dev,
return -EILSEQ; "Invalid magic! Got: 0x%016llx Want: 0x%016lx\n",
} read_val, KP2000_MAGIC_VALUE);
return -EILSEQ;
read_val = readq(pcard->sysinfo_regs_base + REG_CARD_ID_AND_BUILD); }
pcard->card_id = (read_val & 0xFFFFFFFF00000000) >> 32;
pcard->build_version = (read_val & 0x00000000FFFFFFFF) >> 0; read_val = readq(pcard->sysinfo_regs_base + REG_CARD_ID_AND_BUILD);
pcard->card_id = (read_val & 0xFFFFFFFF00000000) >> 32;
read_val = readq(pcard->sysinfo_regs_base + REG_DATE_AND_TIME_STAMPS); pcard->build_version = (read_val & 0x00000000FFFFFFFF) >> 0;
pcard->build_datestamp = (read_val & 0xFFFFFFFF00000000) >> 32;
pcard->build_timestamp = (read_val & 0x00000000FFFFFFFF) >> 0; read_val = readq(pcard->sysinfo_regs_base + REG_DATE_AND_TIME_STAMPS);
pcard->build_datestamp = (read_val & 0xFFFFFFFF00000000) >> 32;
read_val = readq(pcard->sysinfo_regs_base + REG_CORE_TABLE_OFFSET); pcard->build_timestamp = (read_val & 0x00000000FFFFFFFF) >> 0;
pcard->core_table_length = (read_val & 0xFFFFFFFF00000000) >> 32;
pcard->core_table_offset = (read_val & 0x00000000FFFFFFFF) >> 0; read_val = readq(pcard->sysinfo_regs_base + REG_CORE_TABLE_OFFSET);
pcard->core_table_length = (read_val & 0xFFFFFFFF00000000) >> 32;
wait_and_read_ssid(pcard); pcard->core_table_offset = (read_val & 0x00000000FFFFFFFF) >> 0;
read_val = readq(pcard->sysinfo_regs_base + REG_FPGA_HW_ID); wait_and_read_ssid(pcard);
pcard->core_table_rev = (read_val & 0x0000000000000F00) >> 8;
pcard->hardware_revision = (read_val & 0x000000000000001F); read_val = readq(pcard->sysinfo_regs_base + REG_FPGA_HW_ID);
pcard->core_table_rev = (read_val & 0x0000000000000F00) >> 8;
read_val = readq(pcard->sysinfo_regs_base + REG_FPGA_DDNA); pcard->hardware_revision = (read_val & 0x000000000000001F);
pcard->ddna = read_val;
read_val = readq(pcard->sysinfo_regs_base + REG_FPGA_DDNA);
dev_info(&pcard->pdev->dev, "system_regs: %08x %08x %08x %08x %02x %d %d %016llx %016llx\n", pcard->ddna = read_val;
pcard->card_id,
pcard->build_version, dev_info(&pcard->pdev->dev,
pcard->build_datestamp, "system_regs: %08x %08x %08x %08x %02x %d %d %016llx %016llx\n",
pcard->build_timestamp, pcard->card_id,
pcard->hardware_revision, pcard->build_version,
pcard->core_table_rev, pcard->build_datestamp,
pcard->core_table_length, pcard->build_timestamp,
pcard->ssid, pcard->hardware_revision,
pcard->ddna pcard->core_table_rev,
); pcard->core_table_length,
pcard->ssid,
if (pcard->core_table_rev > 1){ pcard->ddna);
dev_err(&pcard->pdev->dev, "core table entry revision is higher than we can deal with, cannot continue with this card!\n");
return 1; if (pcard->core_table_rev > 1) {
} dev_err(&pcard->pdev->dev,
"core table entry revision is higher than we can deal with, cannot continue with this card!\n");
return 0; return 1;
}
return 0;
} }
static irqreturn_t kp2000_irq_handler(int irq, void *dev_id) static irqreturn_t kp2000_irq_handler(int irq, void *dev_id)
...@@ -317,241 +349,284 @@ static struct file_operations kp2000_fops = { ...@@ -317,241 +349,284 @@ static struct file_operations kp2000_fops = {
static int kp2000_pcie_probe(struct pci_dev *pdev, static int kp2000_pcie_probe(struct pci_dev *pdev,
const struct pci_device_id *id) const struct pci_device_id *id)
{ {
int err = 0; int err = 0;
struct kp2000_device *pcard; struct kp2000_device *pcard;
static int card_count = 1; static int card_count = 1;
int rv; int rv;
unsigned long reg_bar_phys_addr; unsigned long reg_bar_phys_addr;
unsigned long reg_bar_phys_len; unsigned long reg_bar_phys_len;
unsigned long dma_bar_phys_addr; unsigned long dma_bar_phys_addr;
unsigned long dma_bar_phys_len; unsigned long dma_bar_phys_len;
u16 regval; u16 regval;
dev_dbg(&pdev->dev, "kp2000_pcie_probe(pdev = [%p], id = [%p])\n", pdev, id); dev_dbg(&pdev->dev, "kp2000_pcie_probe(pdev = [%p], id = [%p])\n",
pdev, id);
//{ Step 1: Allocate a struct for the pcard
pcard = kzalloc(sizeof(struct kp2000_device), GFP_KERNEL); /*
if (NULL == pcard){ * Step 1: Allocate a struct for the pcard
dev_err(&pdev->dev, "probe: failed to allocate private card data\n"); */
return -ENOMEM; pcard = kzalloc(sizeof(struct kp2000_device), GFP_KERNEL);
} if (NULL == pcard) {
dev_dbg(&pdev->dev, "probe: allocated struct kp2000_device @ %p\n", pcard); dev_err(&pdev->dev,
//} "probe: failed to allocate private card data\n");
return -ENOMEM;
//{ Step 2: Initialize trivial pcard elements }
pcard->card_num = card_count; dev_dbg(&pdev->dev, "probe: allocated struct kp2000_device @ %p\n",
card_count++; pcard);
scnprintf(pcard->name, 16, "kpcard%d", pcard->card_num);
/*
mutex_init(&pcard->sem); * Step 2: Initialize trivial pcard elements
*/
pcard->card_num = card_count;
card_count++;
scnprintf(pcard->name, 16, "kpcard%d", pcard->card_num);
mutex_init(&pcard->sem);
mutex_lock(&pcard->sem); mutex_lock(&pcard->sem);
pcard->pdev = pdev; pcard->pdev = pdev;
pci_set_drvdata(pdev, pcard); pci_set_drvdata(pdev, pcard);
//}
/*
//{ Step 3: Enable PCI device * Step 3: Enable PCI device
err = pci_enable_device(pcard->pdev); */
if (err){ err = pci_enable_device(pcard->pdev);
dev_err(&pcard->pdev->dev, "probe: failed to enable PCIE2000 PCIe device (%d)\n", err); if (err) {
goto out3; dev_err(&pcard->pdev->dev,
} "probe: failed to enable PCIE2000 PCIe device (%d)\n",
//} err);
goto out3;
//{ Step 4: Setup the Register BAR }
reg_bar_phys_addr = pci_resource_start(pcard->pdev, REG_BAR);
reg_bar_phys_len = pci_resource_len(pcard->pdev, REG_BAR); /*
* Step 4: Setup the Register BAR
pcard->regs_bar_base = ioremap_nocache(reg_bar_phys_addr, PAGE_SIZE); */
if (NULL == pcard->regs_bar_base){ reg_bar_phys_addr = pci_resource_start(pcard->pdev, REG_BAR);
dev_err(&pcard->pdev->dev, "probe: REG_BAR could not remap memory to virtual space\n"); reg_bar_phys_len = pci_resource_len(pcard->pdev, REG_BAR);
err = -ENODEV;
goto out4; pcard->regs_bar_base = ioremap_nocache(reg_bar_phys_addr, PAGE_SIZE);
} if (NULL == pcard->regs_bar_base) {
dev_dbg(&pcard->pdev->dev, "probe: REG_BAR virt hardware address start [%p]\n", pcard->regs_bar_base); dev_err(&pcard->pdev->dev,
"probe: REG_BAR could not remap memory to virtual space\n");
err = pci_request_region(pcard->pdev, REG_BAR, KP_DRIVER_NAME_KP2000); err = -ENODEV;
if (err){ goto out4;
iounmap(pcard->regs_bar_base); }
dev_err(&pcard->pdev->dev, "probe: failed to acquire PCI region (%d)\n", err); dev_dbg(&pcard->pdev->dev,
err = -ENODEV; "probe: REG_BAR virt hardware address start [%p]\n",
goto out4; pcard->regs_bar_base);
}
err = pci_request_region(pcard->pdev, REG_BAR, KP_DRIVER_NAME_KP2000);
pcard->regs_base_resource.start = reg_bar_phys_addr; if (err) {
pcard->regs_base_resource.end = reg_bar_phys_addr + reg_bar_phys_len - 1; iounmap(pcard->regs_bar_base);
pcard->regs_base_resource.flags = IORESOURCE_MEM; dev_err(&pcard->pdev->dev,
//} "probe: failed to acquire PCI region (%d)\n",
err);
//{ Step 5: Setup the DMA BAR err = -ENODEV;
dma_bar_phys_addr = pci_resource_start(pcard->pdev, DMA_BAR); goto out4;
dma_bar_phys_len = pci_resource_len(pcard->pdev, DMA_BAR); }
pcard->dma_bar_base = ioremap_nocache(dma_bar_phys_addr, dma_bar_phys_len); pcard->regs_base_resource.start = reg_bar_phys_addr;
if (NULL == pcard->dma_bar_base){ pcard->regs_base_resource.end = reg_bar_phys_addr +
dev_err(&pcard->pdev->dev, "probe: DMA_BAR could not remap memory to virtual space\n"); reg_bar_phys_len - 1;
err = -ENODEV; pcard->regs_base_resource.flags = IORESOURCE_MEM;
goto out5;
} /*
dev_dbg(&pcard->pdev->dev, "probe: DMA_BAR virt hardware address start [%p]\n", pcard->dma_bar_base); * Step 5: Setup the DMA BAR
*/
pcard->dma_common_regs = pcard->dma_bar_base + KPC_DMA_COMMON_OFFSET; dma_bar_phys_addr = pci_resource_start(pcard->pdev, DMA_BAR);
dma_bar_phys_len = pci_resource_len(pcard->pdev, DMA_BAR);
err = pci_request_region(pcard->pdev, DMA_BAR, "kp2000_pcie");
if (err){ pcard->dma_bar_base = ioremap_nocache(dma_bar_phys_addr,
iounmap(pcard->dma_bar_base); dma_bar_phys_len);
dev_err(&pcard->pdev->dev, "probe: failed to acquire PCI region (%d)\n", err); if (NULL == pcard->dma_bar_base) {
err = -ENODEV; dev_err(&pcard->pdev->dev,
goto out5; "probe: DMA_BAR could not remap memory to virtual space\n");
} err = -ENODEV;
goto out5;
pcard->dma_base_resource.start = dma_bar_phys_addr; }
pcard->dma_base_resource.end = dma_bar_phys_addr + dma_bar_phys_len - 1; dev_dbg(&pcard->pdev->dev,
pcard->dma_base_resource.flags = IORESOURCE_MEM; "probe: DMA_BAR virt hardware address start [%p]\n",
//} pcard->dma_bar_base);
//{ Step 6: System Regs pcard->dma_common_regs = pcard->dma_bar_base + KPC_DMA_COMMON_OFFSET;
pcard->sysinfo_regs_base = pcard->regs_bar_base;
err = read_system_regs(pcard); err = pci_request_region(pcard->pdev, DMA_BAR, "kp2000_pcie");
if (err) if (err) {
goto out6; iounmap(pcard->dma_bar_base);
dev_err(&pcard->pdev->dev,
// Disable all "user" interrupts because they're not used yet. "probe: failed to acquire PCI region (%d)\n", err);
writeq(0xFFFFFFFFFFFFFFFF, pcard->sysinfo_regs_base + REG_INTERRUPT_MASK); err = -ENODEV;
//} goto out5;
}
//{ Step 7: Configure PCI thingies
// let the card master PCIe pcard->dma_base_resource.start = dma_bar_phys_addr;
pci_set_master(pcard->pdev); pcard->dma_base_resource.end = dma_bar_phys_addr +
// enable IO and mem if not already done dma_bar_phys_len - 1;
pci_read_config_word(pcard->pdev, PCI_COMMAND, &regval); pcard->dma_base_resource.flags = IORESOURCE_MEM;
regval |= (PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
pci_write_config_word(pcard->pdev, PCI_COMMAND, regval); /*
* Step 6: System Regs
// Clear relaxed ordering bit */
pcie_capability_clear_and_set_word(pcard->pdev, PCI_EXP_DEVCTL, PCI_EXP_DEVCTL_RELAX_EN, 0); pcard->sysinfo_regs_base = pcard->regs_bar_base;
err = read_system_regs(pcard);
// Set Max_Payload_Size and Max_Read_Request_Size if (err)
regval = (0x0) << 5; // Max_Payload_Size = 128 B goto out6;
pcie_capability_clear_and_set_word(pcard->pdev, PCI_EXP_DEVCTL, PCI_EXP_DEVCTL_PAYLOAD, regval);
regval = (0x0) << 12; // Max_Read_Request_Size = 128 B // Disable all "user" interrupts because they're not used yet.
pcie_capability_clear_and_set_word(pcard->pdev, PCI_EXP_DEVCTL, PCI_EXP_DEVCTL_READRQ, regval); writeq(0xFFFFFFFFFFFFFFFF,
pcard->sysinfo_regs_base + REG_INTERRUPT_MASK);
// Enable error reporting for: Correctable Errors, Non-Fatal Errors, Fatal Errors, Unsupported Requests
pcie_capability_clear_and_set_word(pcard->pdev, PCI_EXP_DEVCTL, 0, PCI_EXP_DEVCTL_CERE | PCI_EXP_DEVCTL_NFERE | PCI_EXP_DEVCTL_FERE | PCI_EXP_DEVCTL_URRE); /*
* Step 7: Configure PCI thingies
err = dma_set_mask(PCARD_TO_DEV(pcard), DMA_BIT_MASK(64)); */
if (err){ // let the card master PCIe
dev_err(&pcard->pdev->dev, "CANNOT use DMA mask %0llx\n", DMA_BIT_MASK(64)); pci_set_master(pcard->pdev);
goto out7; // enable IO and mem if not already done
} pci_read_config_word(pcard->pdev, PCI_COMMAND, &regval);
dev_dbg(&pcard->pdev->dev, "Using DMA mask %0llx\n", dma_get_mask(PCARD_TO_DEV(pcard))); regval |= (PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
//} pci_write_config_word(pcard->pdev, PCI_COMMAND, regval);
//{ Step 8: Configure IRQs // Clear relaxed ordering bit
err = pci_enable_msi(pcard->pdev); pcie_capability_clear_and_set_word(pcard->pdev, PCI_EXP_DEVCTL,
if (err < 0) PCI_EXP_DEVCTL_RELAX_EN, 0);
goto out8a;
// Set Max_Payload_Size and Max_Read_Request_Size
rv = request_irq(pcard->pdev->irq, kp2000_irq_handler, IRQF_SHARED, pcard->name, pcard); regval = (0x0) << 5; // Max_Payload_Size = 128 B
if (rv){ pcie_capability_clear_and_set_word(pcard->pdev, PCI_EXP_DEVCTL,
dev_err(&pcard->pdev->dev, "kp2000_pcie_probe: failed to request_irq: %d\n", rv); PCI_EXP_DEVCTL_PAYLOAD, regval);
goto out8b; regval = (0x0) << 12; // Max_Read_Request_Size = 128 B
} pcie_capability_clear_and_set_word(pcard->pdev, PCI_EXP_DEVCTL,
//} PCI_EXP_DEVCTL_READRQ, regval);
//{ Step 9: Setup sysfs attributes // Enable error reporting for: Correctable Errors, Non-Fatal Errors,
err = sysfs_create_files(&(pdev->dev.kobj), kp_attr_list); // Fatal Errors, Unsupported Requests
if (err){ pcie_capability_clear_and_set_word(pcard->pdev, PCI_EXP_DEVCTL, 0,
dev_err(&pdev->dev, "Failed to add sysfs files: %d\n", err); PCI_EXP_DEVCTL_CERE |
goto out9; PCI_EXP_DEVCTL_NFERE |
} PCI_EXP_DEVCTL_FERE |
//} PCI_EXP_DEVCTL_URRE);
//{ Step 10: Setup misc device err = dma_set_mask(PCARD_TO_DEV(pcard), DMA_BIT_MASK(64));
pcard->miscdev.minor = MISC_DYNAMIC_MINOR; if (err) {
pcard->miscdev.fops = &kp2000_fops; dev_err(&pcard->pdev->dev,
pcard->miscdev.parent = &pcard->pdev->dev; "CANNOT use DMA mask %0llx\n", DMA_BIT_MASK(64));
pcard->miscdev.name = pcard->name; goto out7;
}
err = misc_register(&pcard->miscdev); dev_dbg(&pcard->pdev->dev,
if (err){ "Using DMA mask %0llx\n", dma_get_mask(PCARD_TO_DEV(pcard)));
dev_err(&pcard->pdev->dev, "kp2000_pcie_probe: misc_register failed: %d\n", err);
goto out10; /*
} * Step 8: Configure IRQs
//} */
err = pci_enable_msi(pcard->pdev);
//{ Step 11: Probe cores if (err < 0)
err = kp2000_probe_cores(pcard); goto out8a;
if (err)
goto out11; rv = request_irq(pcard->pdev->irq, kp2000_irq_handler, IRQF_SHARED,
//} pcard->name, pcard);
if (rv) {
//{ Step 12: Enable IRQs in HW dev_err(&pcard->pdev->dev,
"kp2000_pcie_probe: failed to request_irq: %d\n", rv);
goto out8b;
}
/*
* Step 9: Setup sysfs attributes
*/
err = sysfs_create_files(&(pdev->dev.kobj), kp_attr_list);
if (err) {
dev_err(&pdev->dev, "Failed to add sysfs files: %d\n", err);
goto out9;
}
/*
* Step 10: Setup misc device
*/
pcard->miscdev.minor = MISC_DYNAMIC_MINOR;
pcard->miscdev.fops = &kp2000_fops;
pcard->miscdev.parent = &pcard->pdev->dev;
pcard->miscdev.name = pcard->name;
err = misc_register(&pcard->miscdev);
if (err) {
dev_err(&pcard->pdev->dev,
"kp2000_pcie_probe: misc_register failed: %d\n", err);
goto out10;
}
/*
* Step 11: Probe cores
*/
err = kp2000_probe_cores(pcard);
if (err)
goto out11;
/*
* Step 12: Enable IRQs in HW
*/
writel(KPC_DMA_CARD_IRQ_ENABLE | KPC_DMA_CARD_USER_INTERRUPT_MODE, writel(KPC_DMA_CARD_IRQ_ENABLE | KPC_DMA_CARD_USER_INTERRUPT_MODE,
pcard->dma_common_regs); pcard->dma_common_regs);
//}
dev_dbg(&pcard->pdev->dev, "kp2000_pcie_probe() complete!\n"); dev_dbg(&pcard->pdev->dev, "kp2000_pcie_probe() complete!\n");
mutex_unlock(&pcard->sem); mutex_unlock(&pcard->sem);
return 0; return 0;
out11: out11:
misc_deregister(&pcard->miscdev); misc_deregister(&pcard->miscdev);
out10: out10:
sysfs_remove_files(&(pdev->dev.kobj), kp_attr_list); sysfs_remove_files(&(pdev->dev.kobj), kp_attr_list);
out9: out9:
free_irq(pcard->pdev->irq, pcard); free_irq(pcard->pdev->irq, pcard);
out8b: out8b:
pci_disable_msi(pcard->pdev); pci_disable_msi(pcard->pdev);
out8a: out8a:
out7: out7:
out6: out6:
iounmap(pcard->dma_bar_base); iounmap(pcard->dma_bar_base);
pci_release_region(pdev, DMA_BAR); pci_release_region(pdev, DMA_BAR);
pcard->dma_bar_base = NULL; pcard->dma_bar_base = NULL;
out5: out5:
iounmap(pcard->regs_bar_base); iounmap(pcard->regs_bar_base);
pci_release_region(pdev, REG_BAR); pci_release_region(pdev, REG_BAR);
pcard->regs_bar_base = NULL; pcard->regs_bar_base = NULL;
out4: out4:
pci_disable_device(pcard->pdev); pci_disable_device(pcard->pdev);
out3: out3:
mutex_unlock(&pcard->sem); mutex_unlock(&pcard->sem);
kfree(pcard); kfree(pcard);
return err; return err;
} }
static void kp2000_pcie_remove(struct pci_dev *pdev) static void kp2000_pcie_remove(struct pci_dev *pdev)
{ {
struct kp2000_device *pcard = pci_get_drvdata(pdev); struct kp2000_device *pcard = pci_get_drvdata(pdev);
dev_dbg(&pdev->dev, "kp2000_pcie_remove(pdev=%p)\n", pdev); dev_dbg(&pdev->dev, "kp2000_pcie_remove(pdev=%p)\n", pdev);
if (pcard == NULL) return; if (pcard == NULL)
return;
mutex_lock(&pcard->sem); mutex_lock(&pcard->sem);
kp2000_remove_cores(pcard); kp2000_remove_cores(pcard);
mfd_remove_devices(PCARD_TO_DEV(pcard)); mfd_remove_devices(PCARD_TO_DEV(pcard));
misc_deregister(&pcard->miscdev); misc_deregister(&pcard->miscdev);
sysfs_remove_files(&(pdev->dev.kobj), kp_attr_list); sysfs_remove_files(&(pdev->dev.kobj), kp_attr_list);
free_irq(pcard->pdev->irq, pcard); free_irq(pcard->pdev->irq, pcard);
pci_disable_msi(pcard->pdev); pci_disable_msi(pcard->pdev);
if (pcard->dma_bar_base != NULL){ if (pcard->dma_bar_base != NULL) {
iounmap(pcard->dma_bar_base); iounmap(pcard->dma_bar_base);
pci_release_region(pdev, DMA_BAR); pci_release_region(pdev, DMA_BAR);
pcard->dma_bar_base = NULL; pcard->dma_bar_base = NULL;
} }
if (pcard->regs_bar_base != NULL){ if (pcard->regs_bar_base != NULL) {
iounmap(pcard->regs_bar_base); iounmap(pcard->regs_bar_base);
pci_release_region(pdev, REG_BAR); pci_release_region(pdev, REG_BAR);
pcard->regs_bar_base = NULL; pcard->regs_bar_base = NULL;
} }
pci_disable_device(pcard->pdev); pci_disable_device(pcard->pdev);
pci_set_drvdata(pdev, NULL); pci_set_drvdata(pdev, NULL);
mutex_unlock(&pcard->sem); mutex_unlock(&pcard->sem);
kfree(pcard); kfree(pcard);
} }
struct class *kpc_uio_class; struct class *kpc_uio_class;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7