Re: [Xenomai] Hilscher driver for cifX boards

[Jerome Poncin <JPoncin@hilscher.com>]

Le 06/03/2013 22:05, Gilles Chanteperdrix a écrit :
> On 03/06/2013 04:28 PM, Jan Kiszka wrote:
>
>> Also here: Do not misuse write(), define an IOCTL that contains
>> something like "MMAP" and another one with MUNMAP in its name - that's
>> the purpose of this service, no?
>
> A lot of drivers probably have to reinvent a way to pass all the
> parameters for an mmap, why not adding an "mmap" method to RTDM drivers?
>
>
Hello,

I  re factored my code with all your remarks (I think and I hope).

Could you say me if it's correct now ?

Jan, you're right, It's possible to use Xenomai with UIO driver, but I 
would like to use more real time possibilities of Xenomai in future 
(like IRQ).
My first goal is to have a code compliant.
I added IRQ, and my next step will be to understand why the kernel crash 
after IRQ registration.

Thank you for your help,

Jerome



-------------- next part --------------
/*
 * Copyright (C) 2013 Hilscher France (JP) <www.hilscher.fr>
 *
 * Xenomai is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Xenomai is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Xenomai; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include <linux/device.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/io.h>
#include <linux/mman.h>

#include <asm-generic/xenomai/pci_ids.h>

#include <rtdm/rtdm_driver.h>

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("RTDM board driver for CifX cards");
MODULE_AUTHOR("Hilscher France (JP) <www.hilscher.fr>");

#define RTCIFX_GET_MEM_INFO				0x00
#define RTCIFX_MMAP					0x01
#define RTCIFX_MUNMAP					0x02
#define RTCIFX_REQUEST_IRQ				0x03
#define RTCIFX_FREE_IRQ					0x04
#define RTCIFX_ENABLE_IRQ				0x05
#define RTCIFX_DISABLE_IRQ				0x06

#define DPM_HOST_INT_EN0                0xfff0
#define DPM_HOST_INT_STAT0              0xffe0
#define PLX_GPIO_OFFSET                 0x15
#define PLX_TIMING_OFFSET               0x0a

#define DPM_HOST_INT_MASK               0xe600ffff
#define DPM_HOST_INT_GLOBAL_EN          0x80000000
#define PLX_GPIO_DATA0_MASK             0x00000004
#define PLX_GPIO_DATA1_MASK             0x00000020

#define NX_PCA_PCI_8_BIT_DPM_MODE       0x5431F962
#define NX_PCA_PCI_16_BIT_DPM_MODE      0x4073F8E2
#define NX_PCA_PCI_32_BIT_DPM_MODE      0x40824122

/* Number of bar */
/* points to the DPM -> netX, netPLC, netJACK */
#define DPM_BAR                         0
/* points to the optional extended memory     */
#define EXT_MEM_BAR                     1
/* points to the DPM -> netXPLX               */
#define PLX_DPM_BAR                     2
/* timing config register                     */
#define PXA_PLX_BAR                     0

/* Index of io_info structure's memory array */
/* first mapping describes DPM              */
#define DPM_INDEX                       0
/* second mapping describes extended memory */
#define EXT_MEM_INDEX                   1

#define MAX_MAPS                        2

#define MEM_PHYS                        1

#define DRIVER_NAME                     "rtdm_cifx"
#define PERIPHERAL_NAME                 "cifx"
#define PROVIDER_NAME                   "Hilscher"

/* name of a NXSB-PCA or NXPCA-PCI card */
#define CIFX_RTDM_PLX_CARD_NAME         "netx_plx"
/* name of a cifX PCI card              */
#define CIFX_RTDM_CARD_NAME             "netx"
/* name of a netPLC PCI card            */
#define CIFX_RTDM_NETPLC_CARD_NAME      "netplc"
/* name of a netJACK PCI card           */
#define CIFX_RTDM_NETJACK_CARD_NAME     "netjack"

struct io_mem {
	uint32_t addr;
	uint32_t size;
	int32_t memtype;
	void __iomem *internal_addr;
};

struct io_info {
	struct io_mem mem[MAX_MAPS];
	int32_t irq;
	bool irq_enable;
	bool irq_registered;
	rtdm_irq_t irq_handle;
	struct ext_io_info *priv;
};

struct ext_io_info {
	uint32_t __iomem *plx;
	uint8_t dpm_mode;
	uint32_t plx_timing;
};

struct io_map_mem {
	uint32_t phys_addr;
	uint32_t virt_addr;
	uint32_t length;
};

static struct io_info *cifx_get_device_data(struct rtdm_device *info);
static struct ext_io_info *cifx_get_private(struct rtdm_device *info);

static int cifx_set_plx_timing(struct ext_io_info *ext_info);
static int cifx_get_plx_timing(struct ext_io_info *ext_info);
static int cifx_get_dpm_mode(struct ext_io_info *ext_info);

static int cifx_pci_open(struct rtdm_dev_context *context,
			 rtdm_user_info_t *user_info, int oflags);
static int cifx_pci_close(struct rtdm_dev_context *context,
			  rtdm_user_info_t *user_info);
static int cifx_pci_ioctl(struct rtdm_dev_context *context,
			  rtdm_user_info_t *user_info,
			  unsigned int request, void *arg);

static int cifx_pci_probe(struct pci_dev *dev, const struct pci_device_id *id);
static void cifx_pci_remove(struct pci_dev *dev);

static inline int cifx_handler(rtdm_irq_t *irq);

/* Number or cifx found and open */
static int32_t cifx_num;

/* RTDM Device information structure */
static const struct rtdm_device __initdata cifx_device_tmpl = {
	.struct_version = RTDM_DEVICE_STRUCT_VER,

	.device_flags = RTDM_NAMED_DEVICE,
	.context_size = 0,
	.device_name = "",

	.open_nrt = cifx_pci_open,

	.ops = {
		.close_nrt = cifx_pci_close,

		.read_nrt = NULL,
		.write_nrt = NULL,

		.ioctl_rt = NULL,
		.ioctl_nrt = cifx_pci_ioctl,

		.read_rt = NULL,
		.write_rt = NULL,
		},

	.device_class = RTDM_CLASS_EXPERIMENTAL,
	.device_sub_class = RTDM_SUBCLASS_GENERIC,
	.profile_version = 1,
	.driver_name = DRIVER_NAME,
	.driver_version = RTDM_DRIVER_VER(1, 0, 0),
	.provider_name = PROVIDER_NAME,
};

/* Device table */
static DEFINE_PCI_DEVICE_TABLE(cifx_pci_tbl) = {
	{
	PCI_VENDOR_ID_HILSCHER, PCI_DEVICE_ID_HILSCHER_NETX, 0, 0}, {
	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030,
		    PCI_VENDOR_ID_PLX, PCI_SUBDEVICE_ID_NXSB_PCA}, {
	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030,
		    PCI_VENDOR_ID_PLX, PCI_SUBDEVICE_ID_NXPCA}, {
	PCI_VENDOR_ID_HILSCHER, PCI_DEVICE_ID_HILSCHER_NETPLC,
		    PCI_VENDOR_ID_HILSCHER, PCI_SUBDEVICE_ID_NETPLC_RAM}, {
	PCI_VENDOR_ID_HILSCHER, PCI_DEVICE_ID_HILSCHER_NETPLC,
		    PCI_VENDOR_ID_HILSCHER, PCI_SUBDEVICE_ID_NETPLC_FLASH}, {
	PCI_VENDOR_ID_HILSCHER, PCI_DEVICE_ID_HILSCHER_NETJACK,
		    PCI_VENDOR_ID_HILSCHER, PCI_SUBDEVICE_ID_NETJACK_RAM}, {
	PCI_VENDOR_ID_HILSCHER, PCI_DEVICE_ID_HILSCHER_NETJACK,
		    PCI_VENDOR_ID_HILSCHER, PCI_SUBDEVICE_ID_NETJACK_FLASH}, {
	0,}
};

/* cifX Driver */
static struct pci_driver cifx_pci_driver = {
	.name = "cifx",
	.id_table = cifx_pci_tbl,
	.probe = cifx_pci_probe,
	.remove = cifx_pci_remove,
};

/*
 *	cifx_rtdm_device_to_device_data
 *	Get device_data structure
 */
static struct io_info *cifx_get_device_data(struct rtdm_device *info)
{
	return info->device_data;
}

/*
 *	cifx_rtdm_device_to_private
 *	Get ext_io_info structure
 */
static struct ext_io_info *cifx_get_private(struct rtdm_device *info)
{
	return ((struct io_info *)info->device_data)->priv;
}

/*
 * cifx_handler
 * cifx interrupt handler
 */
static inline int cifx_handler(rtdm_irq_t *irq)
{
	struct rtdm_device *info = rtdm_irq_get_arg(irq, void);
	struct io_info *device_data = info->device_data;

	/* Test if request is for this driver */
	if ((device_data->priv != NULL)
	    || (device_data->irq_registered == 0)
	    || (device_data->irq_enable == 0)) {
		/* This is a PLX device and cannot produce an IRQ,
		   IRQ not registred or not enable (cannot produce an IRQ) */
		return RTDM_IRQ_NONE;
	} else {
		void __iomem *int_enable_reg =
		    device_data->mem[DPM_INDEX].internal_addr +
		    DPM_HOST_INT_EN0;
		void __iomem *int_status_reg =
		    device_data->mem[DPM_INDEX].internal_addr +
		    DPM_HOST_INT_STAT0;

		/* Is one of our interrupts enabled and active ? */
		if (!(ioread32(int_enable_reg) & ioread32(int_status_reg)
		      & DPM_HOST_INT_MASK))
			return RTDM_IRQ_NONE;

		/* Disable interrupt */
		iowrite32(ioread32(int_enable_reg)
			  & ~DPM_HOST_INT_GLOBAL_EN, int_enable_reg);

		return RTDM_IRQ_HANDLED;
	}
}

/*
 *	cifx_set_plx_timing
 *	Set plx timing
 */
static int cifx_set_plx_timing(struct ext_io_info *ext_info)
{
	uint32_t __iomem *plx_timing;

	if (ext_info == NULL)
		return -ENODEV;

	plx_timing = ext_info->plx + PLX_TIMING_OFFSET;
	*plx_timing = ext_info->plx_timing;

	return 0;
}

/*
 * cifx_get_plx_timing
 * Get plx timing
 */
static int cifx_get_plx_timing(struct ext_io_info *ext_info)
{
	if (ext_info == NULL)
		return -ENODEV;

	switch (ext_info->dpm_mode) {
	case 8:
		ext_info->plx_timing = NX_PCA_PCI_8_BIT_DPM_MODE;
		break;
	case 16:
		ext_info->plx_timing = NX_PCA_PCI_16_BIT_DPM_MODE;
		break;
	case 32:
		ext_info->plx_timing = NX_PCA_PCI_32_BIT_DPM_MODE;
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

/*
 * cifx_get_dpm_mode
 * Get dpm mode
 */
static int cifx_get_dpm_mode(struct ext_io_info *ext_info)
{
	uint32_t __iomem *plx_gpio;

	if (ext_info == NULL)
		return -ENODEV;

	plx_gpio = ext_info->plx + PLX_GPIO_OFFSET;

	if ((*plx_gpio & PLX_GPIO_DATA0_MASK)
	    && ~(*plx_gpio & PLX_GPIO_DATA1_MASK))
		ext_info->dpm_mode = 8;
	else if (~(*plx_gpio & PLX_GPIO_DATA0_MASK)
		 && (*plx_gpio & PLX_GPIO_DATA1_MASK))
		ext_info->dpm_mode = 32;
	else if (~(*plx_gpio & PLX_GPIO_DATA0_MASK)
		 && ~(*plx_gpio & PLX_GPIO_DATA1_MASK))
		ext_info->dpm_mode = 16;
	else
		return -EINVAL;

	return 0;
}

/*
 * cifx_pci_open
 * Open cifx pci driver
 */
static int cifx_pci_open(struct rtdm_dev_context *context,
			 rtdm_user_info_t *user_info, int oflags)
{
	return 0;
}

/*
 * cifx_pci_close
 * Close cifx pci driver
 */
static int cifx_pci_close(struct rtdm_dev_context *context,
			  rtdm_user_info_t *user_info)
{
	return 0;
}

/*
 * cifx_pci_ioctl
 * ioctl
 */
static int cifx_pci_ioctl(struct rtdm_dev_context *context,
			  rtdm_user_info_t *user_info,
			  unsigned int request, void *arg)
{
	int ret = 0;
	struct rtdm_device *info = (struct rtdm_device *)context->device;
	struct io_info *device_data = cifx_get_device_data(info);
	struct io_map_mem map_mem;

	switch (request) {
	case RTCIFX_GET_MEM_INFO:
		if (arg == NULL)
			return -EINVAL;

		ret = rtdm_safe_copy_to_user(user_info,
					     arg,
					     device_data->mem,
					     (2 * sizeof(uint32_t)));
		break;

	case RTCIFX_MMAP:
		if (arg == NULL)
			return -EINVAL;

		ret = rtdm_safe_copy_from_user(user_info,
					       &map_mem, arg, sizeof(map_mem));
		if (ret != 0)
			break;

		/* Map physical on virtual memory */
		ret = rtdm_iomap_to_user(user_info,
					 map_mem.phys_addr,
					 map_mem.length,
					 (PROT_READ | PROT_WRITE),
					 (void **)&map_mem.virt_addr,
					NULL,
					NULL);
		if (ret != 0)
			break;

		ret = rtdm_safe_copy_to_user(user_info,
						arg,
						&map_mem,
						sizeof(map_mem));
		break;

	case RTCIFX_MUNMAP:
		if (arg == NULL)
			return -EINVAL;

		ret = rtdm_safe_copy_from_user(user_info,
					       &map_mem, arg, sizeof(map_mem));
		if (ret != 0)
			break;

		/* Unap virtual memory */
		ret = rtdm_munmap(user_info,
				  (void *)map_mem.virt_addr, map_mem.length);
		break;

	case RTCIFX_REQUEST_IRQ:
		if (device_data->irq_registered == 0) {
			ret = rtdm_irq_request(&device_data->irq_handle,
					       device_data->irq,
					       cifx_handler,
					       RTDM_IRQTYPE_SHARED,
					       info->device_name, (void *)info);

			if (ret == 0)
				device_data->irq_registered = 1;
		}
		break;

	case RTCIFX_FREE_IRQ:
		if (device_data->irq_registered == 1) {
			ret = rtdm_irq_free(&device_data->irq_handle);

			if (ret == 0)
				device_data->irq_registered = 0;
		}
		break;

	case RTCIFX_ENABLE_IRQ:
		if (device_data->irq_registered == 1) {
			ret = rtdm_irq_enable(&device_data->irq_handle);

			if (ret == 0)
				device_data->irq_enable = 1;
		}
		break;

	case RTCIFX_DISABLE_IRQ:
		if (device_data->irq_registered == 1) {
			ret = rtdm_irq_disable(&device_data->irq_handle);

			if (ret == 0)
				device_data->irq_enable = 0;
		}
		break;

	default:
		ret = -EINVAL;
		break;
	}

	return ret;
}

static int cifx_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
{
	struct rtdm_device *info = NULL;
	struct io_info *device_data = NULL;
	int32_t bar;
	int32_t ret = -ENODEV;

	/* Allocate device driver structure */
	info = kmalloc(sizeof(*info), GFP_KERNEL);

	if (info == NULL)
		return -ENOMEM;

	ret = pci_enable_device(dev);
	if (ret != 0)
		goto out_free;

	ret = pci_request_regions(dev, DRIVER_NAME);
	if (ret != 0)
		goto out_disable;

	/* Initialize structure with default values */
	memcpy(info, &cifx_device_tmpl, sizeof(*info));

	info->device_id = id->device;
	snprintf(info->device_name, RTDM_MAX_DEVNAME_LEN, "cifx%i", cifx_num);
	info->proc_name = info->device_name;

	switch (id->device) {
	case PCI_DEVICE_ID_HILSCHER_NETX:
		bar = DPM_BAR;
		info->peripheral_name = CIFX_RTDM_CARD_NAME;
		break;
	case PCI_DEVICE_ID_HILSCHER_NETPLC:
		bar = DPM_BAR;
		info->peripheral_name = CIFX_RTDM_NETPLC_CARD_NAME;
		break;
	case PCI_DEVICE_ID_HILSCHER_NETJACK:
		bar = DPM_BAR;
		info->peripheral_name = CIFX_RTDM_NETJACK_CARD_NAME;
		break;
	default:
		bar = PLX_DPM_BAR;
		info->peripheral_name = CIFX_RTDM_PLX_CARD_NAME;
		break;
	}

	info->device_data = NULL;

	/* Allocate specific data strcuture for device */
	device_data = kmalloc(sizeof(*device_data), GFP_KERNEL);

	if (device_data == NULL) {
		ret = -ENOMEM;
		goto out_release;
	}

	memset(device_data, 0, sizeof(*device_data));

	/* BAR 0 or 2 points to the card's dual port memory */
	device_data->mem[DPM_INDEX].addr = pci_resource_start(dev, bar);

	if (device_data->mem[DPM_INDEX].addr == 0)
		goto out_release;

	device_data->mem[DPM_INDEX].internal_addr =
	    ioremap_nocache(pci_resource_start(dev, bar),
			    pci_resource_len(dev, bar));

	if (device_data->mem[DPM_INDEX].internal_addr == 0)
		goto out_release;

	dev_info(&dev->dev, "DPM at %08X\n", device_data->mem[DPM_INDEX].addr);
	device_data->mem[DPM_INDEX].size = pci_resource_len(dev, bar);
	device_data->mem[DPM_INDEX].memtype = MEM_PHYS;

	/* map extended mem (BAR 1 points to the extended memory) */
	device_data->mem[EXT_MEM_INDEX].addr =
	    pci_resource_start(dev, EXT_MEM_BAR);

	/* extended memory is optional, so don't care if it is not present */
	if (device_data->mem[EXT_MEM_INDEX].addr != 0) {
		device_data->mem[EXT_MEM_INDEX].internal_addr =
		    ioremap_nocache(pci_resource_start(dev, EXT_MEM_BAR),
				    pci_resource_len(dev, EXT_MEM_BAR));

		if (device_data->mem[EXT_MEM_INDEX].internal_addr == 0)
			goto out_unmap;

		dev_info(&dev->dev,
			 "extended memory at %08X\n",
			 device_data->mem[EXT_MEM_INDEX].addr);
		device_data->mem[EXT_MEM_INDEX].size =
		    pci_resource_len(dev, EXT_MEM_BAR);
		device_data->mem[EXT_MEM_INDEX].memtype = MEM_PHYS;
	}

	if ((id->device == PCI_DEVICE_ID_HILSCHER_NETX)
	    || (id->device == PCI_DEVICE_ID_HILSCHER_NETPLC)
	    || (id->device == PCI_DEVICE_ID_HILSCHER_NETJACK)) {
		/* make sure all interrupts are disabled */
		iowrite32(0, device_data->mem[DPM_INDEX].internal_addr
			  + DPM_HOST_INT_EN0);
		device_data->priv = NULL;
	} else if (id->subdevice == PCI_SUBDEVICE_ID_NXPCA) {
		/* map PLX registers */
		struct ext_io_info *ext_info;

		ext_info = kmalloc(sizeof(*ext_info), GFP_KERNEL);

		if (ext_info == NULL) {
			ret = -ENOMEM;
			goto out_unmap;
		}

		device_data->priv = ext_info;

		/* set PXA PLX Timings */
		ext_info->plx =
		    ioremap_nocache(pci_resource_start(dev, PXA_PLX_BAR),
				    pci_resource_len(dev, PXA_PLX_BAR));

		if (ext_info->plx == NULL)
			goto out_unmap;
		if (cifx_get_dpm_mode(ext_info))
			goto out_unmap_plx;
		if (cifx_get_plx_timing(ext_info))
			goto out_unmap_plx;
		if (cifx_set_plx_timing(ext_info))
			goto out_unmap_plx;
	} else {
		struct ext_io_info *ext_info;

		ext_info = kmalloc(sizeof(*ext_info), GFP_KERNEL);

		if (ext_info == NULL) {
			ret = -ENOMEM;
			goto out_free_pxa;
		}

		ext_info->plx = NULL;
		ext_info->plx_timing = 0;
		ext_info->dpm_mode = 0;
		device_data->priv = ext_info;
	}

	/* Initialize irq data */
	device_data->irq = dev->irq;
	device_data->irq_enable = 0;
	device_data->irq_registered = 0;

	info->device_data = device_data;

	/* Register RTDM device driver */
	ret = rtdm_dev_register(info);
	if (ret != 0) {
		if (id->subdevice != PCI_SUBDEVICE_ID_NXPCA)
			goto out_unmap;
		else
			goto out_unmap_plx;
	}

	pci_set_drvdata(dev, info);

	if (id->device == PCI_DEVICE_ID_HILSCHER_NETX)
		dev_info(&dev->dev, "registered CifX card\n");
	else if (id->device == PCI_DEVICE_ID_HILSCHER_NETPLC)
		dev_info(&dev->dev, "registered netPLC card\n");
	else if (id->device == PCI_DEVICE_ID_HILSCHER_NETJACK)
		dev_info(&dev->dev, "registered netJACK card\n");
	else if (id->subdevice == PCI_SUBDEVICE_ID_NXSB_PCA)
		dev_info(&dev->dev, "registered NXSB-PCA adapter card\n");
	else {
		struct ext_io_info *ext_info = device_data->priv;
		dev_info(&dev->dev,
			 "registered NXPCA-PCI adapter card in %d bit mode\n",
			 ((struct ext_io_info *)ext_info)->dpm_mode);
	}

	cifx_num++;

	return 0;

out_unmap_plx:
	iounmap((device_data->priv)->plx);

out_free_pxa:
	kfree(device_data->priv);

out_unmap:
	iounmap(device_data->mem[DPM_INDEX].internal_addr);
	if (device_data->mem[EXT_MEM_INDEX].internal_addr != 0)
		iounmap(device_data->mem[EXT_MEM_INDEX].internal_addr);

out_release:
	pci_release_regions(dev);

out_disable:
	pci_disable_device(dev);

out_free:
	if (info->device_data != NULL)
		kfree(info->device_data);

	kfree(info);

	return ret;
}

static void cifx_pci_remove(struct pci_dev *dev)
{
	struct rtdm_device *info = pci_get_drvdata(dev);
	struct io_info *device_data = cifx_get_device_data(info);
	struct ext_io_info *ext_info = cifx_get_private(info);

	if (cifx_num > 0) {
		if (info->device_data == NULL)
			return;

		if (ext_info != NULL) {
			/* Disable all interrupts */
			iowrite32(0, device_data->mem[DPM_INDEX].internal_addr
				  + DPM_HOST_INT_EN0);

			if (ext_info->plx != NULL)
				iounmap((void *)ext_info->plx);

			kfree((void *)ext_info);
		}

		/* Unregister device driver */
		rtdm_dev_unregister(info, 1000);

		pci_release_regions(dev);
		pci_disable_device(dev);
		pci_set_drvdata(dev, NULL);

		/* Unmap memory */
		iounmap(device_data->mem[DPM_INDEX].internal_addr);
		if (device_data->mem[EXT_MEM_INDEX].internal_addr != 0)
			iounmap(device_data->mem[EXT_MEM_INDEX].internal_addr);

		/* Release structure memory allocation */
		kfree(info->device_data);
		kfree(info);

		cifx_num--;
	}
}

static int __init cifx_pci_init(void)
{
	return pci_register_driver(&cifx_pci_driver);
}

static void __exit cifx_pci_exit(void)
{
	pci_unregister_driver(&cifx_pci_driver);
}

module_init(cifx_pci_init);
module_exit(cifx_pci_exit);