[mirror_ubuntu-jammy-kernel.git] / drivers / vme / boards / vme_vmivme7805.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Support for the VMIVME-7805 board access to the Universe II bridge.
 *
 * Author: Arthur Benilov <arthur.benilov@iba-group.com>
 * Copyright 2010 Ion Beam Application, Inc.
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/pci.h>
#include <linux/poll.h>
#include <linux/io.h>

#include "vme_vmivme7805.h"

static int vmic_probe(struct pci_dev *, const struct pci_device_id *);
static void vmic_remove(struct pci_dev *);

/** Base address to access FPGA register */
static void __iomem *vmic_base;

static const char driver_name[] = "vmivme_7805";

static const struct pci_device_id vmic_ids[] = {
	{ PCI_DEVICE(PCI_VENDOR_ID_VMIC, PCI_DEVICE_ID_VTIMR) },
	{ },
};

static struct pci_driver vmic_driver = {
	.name = driver_name,
	.id_table = vmic_ids,
	.probe = vmic_probe,
	.remove = vmic_remove,
};

static int vmic_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
	int retval;
	u32 data;

	/* Enable the device */
	retval = pci_enable_device(pdev);
	if (retval) {
		dev_err(&pdev->dev, "Unable to enable device\n");
		goto err;
	}

	/* Map Registers */
	retval = pci_request_regions(pdev, driver_name);
	if (retval) {
		dev_err(&pdev->dev, "Unable to reserve resources\n");
		goto err_resource;
	}

	/* Map registers in BAR 0 */
	vmic_base = ioremap_nocache(pci_resource_start(pdev, 0), 16);
	if (!vmic_base) {
		dev_err(&pdev->dev, "Unable to remap CRG region\n");
		retval = -EIO;
		goto err_remap;
	}

	/* Clear the FPGA VME IF contents */
	iowrite32(0, vmic_base + VME_CONTROL);

	/* Clear any initial BERR  */
	data = ioread32(vmic_base + VME_CONTROL) & 0x00000FFF;
	data |= BM_VME_CONTROL_BERRST;
	iowrite32(data, vmic_base + VME_CONTROL);

	/* Enable the vme interface and byte swapping */
	data = ioread32(vmic_base + VME_CONTROL) & 0x00000FFF;
	data = data | BM_VME_CONTROL_MASTER_ENDIAN |
			BM_VME_CONTROL_SLAVE_ENDIAN |
			BM_VME_CONTROL_ABLE |
			BM_VME_CONTROL_BERRI |
			BM_VME_CONTROL_BPENA |
			BM_VME_CONTROL_VBENA;
	iowrite32(data, vmic_base + VME_CONTROL);

	return 0;

err_remap:
	pci_release_regions(pdev);
err_resource:
	pci_disable_device(pdev);
err:
	return retval;
}

static void vmic_remove(struct pci_dev *pdev)
{
	iounmap(vmic_base);
	pci_release_regions(pdev);
	pci_disable_device(pdev);

}

module_pci_driver(vmic_driver);

MODULE_DESCRIPTION("VMIVME-7805 board support driver");
MODULE_AUTHOR("Arthur Benilov <arthur.benilov@iba-group.com>");
MODULE_LICENSE("GPL");
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
3c2aabc4 AB	2	/*
	3	* Support for the VMIVME-7805 board access to the Universe II bridge.
	4	*
	5	* Author: Arthur Benilov <arthur.benilov@iba-group.com>
	6	* Copyright 2010 Ion Beam Application, Inc.
3c2aabc4 AB	7	*/
3c2aabc4 AB	8
3c2aabc4 AB	9	#include <linux/module.h>
	10	#include <linux/types.h>
	11	#include <linux/errno.h>
	12	#include <linux/pci.h>
	13	#include <linux/poll.h>
	14	#include <linux/io.h>
	15
	16	#include "vme_vmivme7805.h"
	17
3c2aabc4 AB	18	static int vmic_probe(struct pci_dev , const struct pci_device_id );
3c2aabc4 AB	19	static void vmic_remove(struct pci_dev *);
3c2aabc4 AB	20
3c2aabc4 AB	21	/** Base address to access FPGA register */
a84a3222	22	static void __iomem *vmic_base;
3c2aabc4	23
584721ca	24	static const char driver_name[] = "vmivme_7805";
3c2aabc4	25
c3a09c18	26	static const struct pci_device_id vmic_ids[] = {
3c2aabc4 AB	27	{ PCI_DEVICE(PCI_VENDOR_ID_VMIC, PCI_DEVICE_ID_VTIMR) },
	28	{ },
	29	};
	30
	31	static struct pci_driver vmic_driver = {
	32	.name = driver_name,
	33	.id_table = vmic_ids,
	34	.probe = vmic_probe,
	35	.remove = vmic_remove,
	36	};
	37
3c2aabc4 AB	38	static int vmic_probe(struct pci_dev pdev, const struct pci_device_id id)
	39	{
	40	int retval;
	41	u32 data;
	42
	43	/* Enable the device */
	44	retval = pci_enable_device(pdev);
	45	if (retval) {
	46	dev_err(&pdev->dev, "Unable to enable device\n");
	47	goto err;
	48	}
	49
	50	/* Map Registers */
	51	retval = pci_request_regions(pdev, driver_name);
	52	if (retval) {
	53	dev_err(&pdev->dev, "Unable to reserve resources\n");
	54	goto err_resource;
	55	}
	56
	57	/* Map registers in BAR 0 */
	58	vmic_base = ioremap_nocache(pci_resource_start(pdev, 0), 16);
	59	if (!vmic_base) {
	60	dev_err(&pdev->dev, "Unable to remap CRG region\n");
	61	retval = -EIO;
	62	goto err_remap;
	63	}
	64
	65	/* Clear the FPGA VME IF contents */
	66	iowrite32(0, vmic_base + VME_CONTROL);
	67
	68	/* Clear any initial BERR */
	69	data = ioread32(vmic_base + VME_CONTROL) & 0x00000FFF;
	70	data \|= BM_VME_CONTROL_BERRST;
	71	iowrite32(data, vmic_base + VME_CONTROL);
	72
	73	/* Enable the vme interface and byte swapping */
	74	data = ioread32(vmic_base + VME_CONTROL) & 0x00000FFF;
	75	data = data \| BM_VME_CONTROL_MASTER_ENDIAN \|
	76	BM_VME_CONTROL_SLAVE_ENDIAN \|
	77	BM_VME_CONTROL_ABLE \|
	78	BM_VME_CONTROL_BERRI \|
	79	BM_VME_CONTROL_BPENA \|
	80	BM_VME_CONTROL_VBENA;
	81	iowrite32(data, vmic_base + VME_CONTROL);
	82
	83	return 0;
	84
	85	err_remap:
	86	pci_release_regions(pdev);
	87	err_resource:
	88	pci_disable_device(pdev);
	89	err:
	90	return retval;
	91	}
	92
	93	static void vmic_remove(struct pci_dev *pdev)
	94	{
	95	iounmap(vmic_base);
	96	pci_release_regions(pdev);
	97	pci_disable_device(pdev);
	98
	99	}
	100
5f1e7790	101	module_pci_driver(vmic_driver);
3c2aabc4 AB	102
	103	MODULE_DESCRIPTION("VMIVME-7805 board support driver");
	104	MODULE_AUTHOR("Arthur Benilov <arthur.benilov@iba-group.com>");
	105	MODULE_LICENSE("GPL");
	106