mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
283 lines
7.0 KiB
283 lines
7.0 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* |
|
* Janz CMOD-IO MODULbus Carrier Board PCI Driver |
|
* |
|
* Copyright (c) 2010 Ira W. Snyder <[email protected]> |
|
* |
|
* Lots of inspiration and code was copied from drivers/mfd/sm501.c |
|
*/ |
|
|
|
#include <linux/kernel.h> |
|
#include <linux/module.h> |
|
#include <linux/pci.h> |
|
#include <linux/interrupt.h> |
|
#include <linux/delay.h> |
|
#include <linux/platform_device.h> |
|
#include <linux/slab.h> |
|
#include <linux/mfd/core.h> |
|
|
|
#include <linux/mfd/janz.h> |
|
|
|
#define DRV_NAME "janz-cmodio" |
|
|
|
/* Size of each MODULbus module in PCI BAR4 */ |
|
#define CMODIO_MODULBUS_SIZE 0x200 |
|
|
|
/* Maximum number of MODULbus modules on a CMOD-IO carrier board */ |
|
#define CMODIO_MAX_MODULES 4 |
|
|
|
/* Module Parameters */ |
|
static unsigned int num_modules = CMODIO_MAX_MODULES; |
|
static char *modules[CMODIO_MAX_MODULES] = { |
|
"empty", "empty", "empty", "empty", |
|
}; |
|
|
|
module_param_array(modules, charp, &num_modules, S_IRUGO); |
|
MODULE_PARM_DESC(modules, "MODULbus modules attached to the carrier board"); |
|
|
|
/* Unique Device Id */ |
|
static unsigned int cmodio_id; |
|
|
|
struct cmodio_device { |
|
/* Parent PCI device */ |
|
struct pci_dev *pdev; |
|
|
|
/* PLX control registers */ |
|
struct janz_cmodio_onboard_regs __iomem *ctrl; |
|
|
|
/* hex switch position */ |
|
u8 hex; |
|
|
|
/* mfd-core API */ |
|
struct mfd_cell cells[CMODIO_MAX_MODULES]; |
|
struct resource resources[3 * CMODIO_MAX_MODULES]; |
|
struct janz_platform_data pdata[CMODIO_MAX_MODULES]; |
|
}; |
|
|
|
/* |
|
* Subdevices using the mfd-core API |
|
*/ |
|
|
|
static int cmodio_setup_subdevice(struct cmodio_device *priv, |
|
char *name, unsigned int devno, |
|
unsigned int modno) |
|
{ |
|
struct janz_platform_data *pdata; |
|
struct mfd_cell *cell; |
|
struct resource *res; |
|
struct pci_dev *pci; |
|
|
|
pci = priv->pdev; |
|
cell = &priv->cells[devno]; |
|
res = &priv->resources[devno * 3]; |
|
pdata = &priv->pdata[devno]; |
|
|
|
cell->name = name; |
|
cell->resources = res; |
|
cell->num_resources = 3; |
|
|
|
/* Setup the subdevice ID -- must be unique */ |
|
cell->id = cmodio_id++; |
|
|
|
/* Add platform data */ |
|
pdata->modno = modno; |
|
cell->platform_data = pdata; |
|
cell->pdata_size = sizeof(*pdata); |
|
|
|
/* MODULbus registers -- PCI BAR3 is big-endian MODULbus access */ |
|
res->flags = IORESOURCE_MEM; |
|
res->parent = &pci->resource[3]; |
|
res->start = pci->resource[3].start + (CMODIO_MODULBUS_SIZE * modno); |
|
res->end = res->start + CMODIO_MODULBUS_SIZE - 1; |
|
res++; |
|
|
|
/* PLX Control Registers -- PCI BAR4 is interrupt and other registers */ |
|
res->flags = IORESOURCE_MEM; |
|
res->parent = &pci->resource[4]; |
|
res->start = pci->resource[4].start; |
|
res->end = pci->resource[4].end; |
|
res++; |
|
|
|
/* |
|
* IRQ |
|
* |
|
* The start and end fields are used as an offset to the irq_base |
|
* parameter passed into the mfd_add_devices() function call. All |
|
* devices share the same IRQ. |
|
*/ |
|
res->flags = IORESOURCE_IRQ; |
|
res->parent = NULL; |
|
res->start = 0; |
|
res->end = 0; |
|
res++; |
|
|
|
return 0; |
|
} |
|
|
|
/* Probe each submodule using kernel parameters */ |
|
static int cmodio_probe_submodules(struct cmodio_device *priv) |
|
{ |
|
struct pci_dev *pdev = priv->pdev; |
|
unsigned int num_probed = 0; |
|
char *name; |
|
int i; |
|
|
|
for (i = 0; i < num_modules; i++) { |
|
name = modules[i]; |
|
if (!strcmp(name, "") || !strcmp(name, "empty")) |
|
continue; |
|
|
|
dev_dbg(&priv->pdev->dev, "MODULbus %d: name %s\n", i, name); |
|
cmodio_setup_subdevice(priv, name, num_probed, i); |
|
num_probed++; |
|
} |
|
|
|
/* print an error message if no modules were probed */ |
|
if (num_probed == 0) { |
|
dev_err(&priv->pdev->dev, "no MODULbus modules specified, " |
|
"please set the ``modules'' kernel " |
|
"parameter according to your " |
|
"hardware configuration\n"); |
|
return -ENODEV; |
|
} |
|
|
|
return mfd_add_devices(&pdev->dev, 0, priv->cells, |
|
num_probed, NULL, pdev->irq, NULL); |
|
} |
|
|
|
/* |
|
* SYSFS Attributes |
|
*/ |
|
|
|
static ssize_t modulbus_number_show(struct device *dev, |
|
struct device_attribute *attr, char *buf) |
|
{ |
|
struct cmodio_device *priv = dev_get_drvdata(dev); |
|
|
|
return snprintf(buf, PAGE_SIZE, "%x\n", priv->hex); |
|
} |
|
|
|
static DEVICE_ATTR_RO(modulbus_number); |
|
|
|
static struct attribute *cmodio_sysfs_attrs[] = { |
|
&dev_attr_modulbus_number.attr, |
|
NULL, |
|
}; |
|
|
|
static const struct attribute_group cmodio_sysfs_attr_group = { |
|
.attrs = cmodio_sysfs_attrs, |
|
}; |
|
|
|
/* |
|
* PCI Driver |
|
*/ |
|
|
|
static int cmodio_pci_probe(struct pci_dev *dev, |
|
const struct pci_device_id *id) |
|
{ |
|
struct cmodio_device *priv; |
|
int ret; |
|
|
|
priv = devm_kzalloc(&dev->dev, sizeof(*priv), GFP_KERNEL); |
|
if (!priv) |
|
return -ENOMEM; |
|
|
|
pci_set_drvdata(dev, priv); |
|
priv->pdev = dev; |
|
|
|
/* Hardware Initialization */ |
|
ret = pci_enable_device(dev); |
|
if (ret) { |
|
dev_err(&dev->dev, "unable to enable device\n"); |
|
return ret; |
|
} |
|
|
|
pci_set_master(dev); |
|
ret = pci_request_regions(dev, DRV_NAME); |
|
if (ret) { |
|
dev_err(&dev->dev, "unable to request regions\n"); |
|
goto out_pci_disable_device; |
|
} |
|
|
|
/* Onboard configuration registers */ |
|
priv->ctrl = pci_ioremap_bar(dev, 4); |
|
if (!priv->ctrl) { |
|
dev_err(&dev->dev, "unable to remap onboard regs\n"); |
|
ret = -ENOMEM; |
|
goto out_pci_release_regions; |
|
} |
|
|
|
/* Read the hex switch on the carrier board */ |
|
priv->hex = ioread8(&priv->ctrl->int_enable); |
|
|
|
/* Add the MODULbus number (hex switch value) to the device's sysfs */ |
|
ret = sysfs_create_group(&dev->dev.kobj, &cmodio_sysfs_attr_group); |
|
if (ret) { |
|
dev_err(&dev->dev, "unable to create sysfs attributes\n"); |
|
goto out_unmap_ctrl; |
|
} |
|
|
|
/* |
|
* Disable all interrupt lines, each submodule will enable its |
|
* own interrupt line if needed |
|
*/ |
|
iowrite8(0xf, &priv->ctrl->int_disable); |
|
|
|
/* Register drivers for all submodules */ |
|
ret = cmodio_probe_submodules(priv); |
|
if (ret) { |
|
dev_err(&dev->dev, "unable to probe submodules\n"); |
|
goto out_sysfs_remove_group; |
|
} |
|
|
|
return 0; |
|
|
|
out_sysfs_remove_group: |
|
sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group); |
|
out_unmap_ctrl: |
|
iounmap(priv->ctrl); |
|
out_pci_release_regions: |
|
pci_release_regions(dev); |
|
out_pci_disable_device: |
|
pci_disable_device(dev); |
|
|
|
return ret; |
|
} |
|
|
|
static void cmodio_pci_remove(struct pci_dev *dev) |
|
{ |
|
struct cmodio_device *priv = pci_get_drvdata(dev); |
|
|
|
mfd_remove_devices(&dev->dev); |
|
sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group); |
|
iounmap(priv->ctrl); |
|
pci_release_regions(dev); |
|
pci_disable_device(dev); |
|
} |
|
|
|
#define PCI_VENDOR_ID_JANZ 0x13c3 |
|
|
|
/* The list of devices that this module will support */ |
|
static const struct pci_device_id cmodio_pci_ids[] = { |
|
{ PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030, PCI_VENDOR_ID_JANZ, 0x0101 }, |
|
{ PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_JANZ, 0x0100 }, |
|
{ PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030, PCI_VENDOR_ID_JANZ, 0x0201 }, |
|
{ PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030, PCI_VENDOR_ID_JANZ, 0x0202 }, |
|
{ PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_JANZ, 0x0201 }, |
|
{ PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_JANZ, 0x0202 }, |
|
{ 0, } |
|
}; |
|
MODULE_DEVICE_TABLE(pci, cmodio_pci_ids); |
|
|
|
static struct pci_driver cmodio_pci_driver = { |
|
.name = DRV_NAME, |
|
.id_table = cmodio_pci_ids, |
|
.probe = cmodio_pci_probe, |
|
.remove = cmodio_pci_remove, |
|
}; |
|
|
|
module_pci_driver(cmodio_pci_driver); |
|
|
|
MODULE_AUTHOR("Ira W. Snyder <[email protected]>"); |
|
MODULE_DESCRIPTION("Janz CMOD-IO PCI MODULbus Carrier Board Driver"); |
|
MODULE_LICENSE("GPL");
|
|
|