acq-fiber-hba.c

/* ------------------------------------------------------------------------- *
 * acq-fiber-hba.c  		                     	                    
 * ------------------------------------------------------------------------- *
 *   Copyright (C) 2014 Peter Milne, D-TACQ Solutions Ltd                
 *                      <peter dot milne at D hyphen TACQ dot com>          
 *                         www.d-tacq.com
 *   Created on: 10 Aug 2014  
 *    Author: pgm                                                         
 *                                                                           *
 *  This program is free software; you can redistribute it and/or modify     *
 *  it under the terms of Version 2 of the GNU General Public License        *
 *  as published by the Free Software Foundation;                            *
 *                                                                           *
 *  This program 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 this program; if not, write to the Free Software              *
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
/* ------------------------------------------------------------------------- */




#include "acq-fiber-hba.h"


char afhba_driver_name[] = "afhba";
char afhba__driver_string[] = "D-TACQ ACQ-FIBER-HBA Driver for ACQ400";
char afhba__driver_version[] = "B1108";
char afhba__copyright[] = "Copyright (c) 2010/2014 D-TACQ Solutions Ltd";


struct class* afhba_device_class;

LIST_HEAD(afhba_devices);


const char* afhba_devnames[MAXDEV];


#ifndef EXPORT_SYMTAB
#define EXPORT_SYMTAB
#include <linux/module.h>
#endif

int afhba_debug = 0;
module_param(afhba_debug, int, 0644);

/* deprecated: only retained for load script compatibility */
int ll_mode_only = 1;
module_param(ll_mode_only, int, 0444);


#include "d-tacq_pci_id.h"

int afhba4_stream = 0;
module_param(afhba4_stream, int, 0444);

int afhba_nports = 4;
module_param(afhba_nports, int, 0444);

int bad_bios_bar_limit = 0;
module_param(bad_bios_bar_limit, int, 0644);

extern int buffer_len;

static int MAP2BAR(struct AFHBA_DEV *adev, int imap)
{
	return imap;
}

static int minor2bar(struct AFHBA_DEV *adev, int iminor)
{
	switch(iminor){
	default:
		dev_err(pdev(adev), "bad call minor2bar %d", iminor); /* fallthru */
	case MINOR_REGREAD:
		return REGS_BAR;
	case MINOR_REMOTE:
		return REMOTE_BAR;
	}

}
#define VALID_BAR(bar)	((bar) != NO_BAR)


ssize_t bar_read(
	struct file *file, char *buf, size_t count, loff_t *f_pos, int BAR)
{
	struct AFHBA_DEV *adev = PD(file)->dev;
	int ii;
	int rc;
	void *va = adev->mappings[BAR].va;
	int len = adev->mappings[BAR].len;

	dev_dbg(pdev(adev), "01 adev %p va %p name %s", adev, va, adev->name);

	if (count > len){
		count = len;
	}
	if (*f_pos >= len){
		return 0;
	}else{
		va += *f_pos;
	}

	for (ii = 0; ii < count/sizeof(u32); ++ii){
		u32 reg = readl(va + ii*sizeof(u32));
		rc = copy_to_user(buf+ii*sizeof(u32), &reg, sizeof(u32));
		if (rc){
			return -1;
		}
	}
	*f_pos += count;
	return count;
}




ssize_t bar_write(
	struct file *file, const char *buf, size_t count, loff_t *f_pos,
	int BAR, int OFFSET)
{
	struct AFHBA_DEV *adev = PD(file)->dev;
	int LEN = adev->mappings[BAR].len;
	u32 data;
	void *va = adev->mappings[BAR].va + OFFSET;
	int rc = copy_from_user(&data, buf, min(count, sizeof(u32)));

	int ii;
	if (rc){
		return -1;
	}
	if (*f_pos > LEN){
		return -1;
	}else if (count + *f_pos > LEN){
		count = LEN - *f_pos;
	}

	for (ii = 0; ii < count; ii += sizeof(u32)){
		u32 readval = readl(va+ii);
		dev_dbg(pdev(adev), "writing %p = 0x%08x was 0x%08x",
					va+ii, data+ii, readval);

		writel(data+ii, va+ii);
	}

	*f_pos += count;
	return count;
}

int afhba_open(struct inode *inode, struct file *file)
{
	struct AFHBA_DEV *adev = afhba_lookupDevice(MAJOR(inode->i_rdev));

	dev_dbg(pdev(adev), "01");
	if (adev == 0){
		return -ENODEV;
	}else{
		file->private_data = kmalloc(PSZ, GFP_KERNEL);
		PD(file)->dev = adev;
		PD(file)->minor = MINOR(inode->i_rdev);
		INIT_LIST_HEAD(&PD(file)->my_buffers);

		dev_dbg(pdev(adev), "33: minor %d", PD(file)->minor);

		switch((PD(file)->minor)){
		case MINOR_REGREAD:
		case MINOR_REMOTE:
			return 0;
		default:
			if (adev->stream_fops != 0){
				file->f_op = adev->stream_fops;
				return file->f_op->open(inode, file);
			}else{
				dev_err(pdev(adev),"99 adev %p name %s", adev, adev->name);
				return -ENODEV;
			}
		}
	}
}
ssize_t afhba_read(struct file *file, char __user *buf, size_t count, loff_t *f_pos)
{
	struct AFHBA_DEV *adev = DEV(file);
	return bar_read(file, buf, count, f_pos, minor2bar(adev, PD(file)->minor));
}

ssize_t afhba_write(
	struct file *file, const char *buf, size_t count, loff_t *f_pos)
{
	return bar_write(file, buf, count, f_pos, REGS_BAR, 0);
}
int afhba_mmap_bar(struct file* file, struct vm_area_struct* vma)
{
	struct AFHBA_DEV *adev = PD(file)->dev;
	int bar = minor2bar(adev, PD(file)->minor);
	unsigned long vsize = vma->vm_end - vma->vm_start;
	unsigned long psize = adev->mappings[bar].len;
	unsigned pfn = adev->mappings[bar].pa >> PAGE_SHIFT;

	dev_dbg(pdev(adev), "%c vsize %lu psize %lu %s",
		'D', vsize, psize, vsize>psize? "EINVAL": "OK");

	if (vsize > psize){
		return -EINVAL;                   /* request too big */
	}
	if (io_remap_pfn_range(
		vma, vma->vm_start, pfn, vsize, vma->vm_page_prot)){
		return -EAGAIN;
	}else{
		return 0;
	}
}

int afhba_mmap_hb(struct file* file, struct vm_area_struct* vma)
{
	struct AFHBA_DEV *adev = PD(file)->dev;
	struct HostBuffer* hb = adev->hb1;
	unsigned long vsize = vma->vm_end - vma->vm_start;
	unsigned long psize = buffer_len;
	unsigned pfn = hb->pa >> PAGE_SHIFT;

	dev_dbg(pdev(adev), "%c vsize %lu psize %lu %s",
		'D', vsize, psize, vsize>psize? "EINVAL": "OK");

	if (vsize > psize){
		return -EINVAL;                   /* request too big */
	}
	if (io_remap_pfn_range(
		vma, vma->vm_start, pfn, vsize, vma->vm_page_prot)){
		return -EAGAIN;
	}else{
		return 0;
	}
}

int afhba_release(struct inode *inode, struct file *file)
{
	struct AFHBA_DEV *adev = PD(file)->dev;
	dev_dbg(pdev(adev), "01");
	kfree(file->private_data);
	return 0;
}

void afhba_map(struct AFHBA_DEV *adev)
{
	struct pci_dev *dev = adev->pci_dev;
	int imap;
	int nmappings = 0;

	for (imap = 0; nmappings < adev->map_count; ++imap){
		struct PciMapping* mp = adev->mappings+imap;
		int bar = MAP2BAR(adev, imap);

		dev_dbg(pdev(adev), "[%d] ", imap);
		if (VALID_BAR(bar)){
			if (adev->peer != 0 && adev->peer->mappings[imap].va != 0){
				adev->mappings[imap] = adev->peer->mappings[imap];
			}else{
				snprintf(mp->name, SZM1(mp->name), "afhba.%d.%d", adev->idx, bar);

				mp->pa = pci_resource_start(dev,bar)&
						PCI_BASE_ADDRESS_MEM_MASK;
				mp->len = pci_resource_len(dev, bar);
				mp->region = request_mem_region(
					mp->pa, mp->len, mp->name);
				mp->va = ioremap_nocache(mp->pa, mp->len);

				dev_dbg(pdev(adev), "BAR %d va:%p", bar, mp->va);
			}
			++nmappings;
		}
	}

	dev_dbg(pdev(adev), "99 nmappings %d", nmappings);
}



static int getOrder(int len)
{
	int order;
	len /= PAGE_SIZE;

	for (order = 0; 1 << order < len; ++order){
		;
	}
	return order;
}


static void init_buffers(struct AFHBA_DEV* adev)
{
	int order = getOrder(buffer_len);
	int ii = 0;
	struct HostBuffer* hb = adev->hb1 = kmalloc(sizeof(struct HostBuffer)*1, GFP_KERNEL);
	void *buf = (void*)__get_free_pages(GFP_KERNEL|GFP_DMA32, order);

	if (!buf){
		dev_err(pdev(adev), "failed to allocate buffer %d", ii);
		return;
	}

	dev_dbg(pdev(adev), "buffer %2d allocated at %p, map it", ii, buf);

	hb->ibuf = 0;
	hb->pa = dma_map_single(&adev->pci_dev->dev, buf,
			buffer_len, PCI_DMA_FROMDEVICE);
	hb->va = buf;
	hb->len = buffer_len;

	dev_dbg(pdev(adev), "buffer %2d allocated, map done", ii);

	hb->bstate = BS_EMPTY;

	dev_info(pdev(adev), "hb1 [%d] %p %08x %d %08x", ii,
			adev->hb1->va, adev->hb1->pa,
			adev->hb1->len, adev->hb1->descr);
}


struct AFHBA_DEV *adevCreate(struct pci_dev *dev)
{
	static int idx;
	struct AFHBA_DEV *adev = kzalloc(sizeof(struct AFHBA_DEV), GFP_KERNEL);

	static u64 dma_mask = DMA_BIT_MASK(32);

	adev->pci_dev = dev;
	adev->idx = idx++;
	dev->dev.dma_mask = &dma_mask;
	adev->remote_com_bar = NO_BAR;

	return adev;
}

void adevDelete(struct AFHBA_DEV* adev)
{
	kfree(adev);
}

#include <linux/pci_regs.h>

#define AFHBA_PCI_CMD (PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY)

void force_busmaster_mode(struct AFHBA_DEV* adev)
{
	u16 cmd;

	/* Workaround for PCI problem when BIOS sets MMRBC incorrectly. */
	pci_read_config_word( adev->pci_dev, PCI_COMMAND, &cmd);
	if ((cmd & AFHBA_PCI_CMD) != AFHBA_PCI_CMD) {
		u16 new_cmd = cmd | AFHBA_PCI_CMD;
		pci_write_config_word( adev->pci_dev, PCI_COMMAND, new_cmd);
		dev_info(pdev(adev), "ENABLE BUS MASTER transactions %04x to %04x",
							cmd, new_cmd);
	}
}

int _afhba_probe(struct AFHBA_DEV* adev, int remote_bar,
		int (*stream_drv_init)(struct AFHBA_DEV* adev))
{
	static struct file_operations afhba_fops = {
		.open = afhba_open,
		.release = afhba_release,
		.read = afhba_read,
		.write = afhba_write,
		//.mmap = afhba_mmap_bar
		.mmap = afhba_mmap_hb
	};

	int rc;

	snprintf(adev->name, SZM1(adev->name), "afhba.%d", adev->idx);
	afhba_devnames[adev->idx] = adev->name;
	snprintf(adev->mon_name, SZM1(adev->name), "afhba-mon.%d", adev->idx);


	rc = register_chrdev(0, adev->name, &afhba_fops);
	if (rc < 0){
		dev_err(pdev(adev), "can't get major");
		kfree(adev);
		return rc;
	}else{
		adev->major = rc;
	}

	afhba_map(adev);
	adev->remote = adev->mappings[remote_bar].va;
	init_buffers(adev);
	afhba_registerDevice(adev);
	afhba_createDebugfs(adev);

	rc = pci_enable_device(adev->pci_dev);
	if (rc != 0){
		dev_warn(pdev(adev), "pci_enabled_device returned %d", rc);
	}
	force_busmaster_mode(adev);

	dev_dbg(pdev(adev), "pci_enable_device returns %d", rc);
	dev_info(pdev(adev), "FPGA revision: %08x",
			afhba_read_reg(adev, FPGA_REVISION_REG));

	adev->class_dev = device_create(
			afhba_device_class,			/* cls */
			NULL,					/* cls_parent */
			adev->idx,				/* "devt" */
			&adev->pci_dev->dev,			/* device */
			adev->name);
	afhba_create_sysfs_class(adev);

	dev_dbg(pdev(adev), "calling afhba_create_sysfs()");
	afhba_create_sysfs(adev);

	dev_dbg(pdev(adev), "calling stream_drv_init()");
	stream_drv_init(adev);

	dev_dbg(pdev(adev), "99 rc %d", rc);
	return rc;
}

int null_stream_drv_init(struct AFHBA_DEV* adev)
{
	dev_warn(pdev(adev), "null_stream_drv_init STUB");
	return 0;
}
#define STREAM		afhba_stream_drv_init
#define NOSTREAM	null_stream_drv_init

int afhba2_probe(struct AFHBA_DEV *adev)
{
	int rc;
	dev_info(pdev(adev), "AFHBA 4G 2-port firmware detected");
	adev->map_count = MAP_COUNT_4G2;
	adev->remote_com_bar = MAP_COUNT_4G2 -1;
	adev->sfp = SFP_A;

	if ((rc = _afhba_probe(adev, REMOTE_BAR, STREAM)) != 0){
		dev_err(pdev(adev), "ERROR failed to create first device");
		return rc;
	}else{
		struct AFHBA_DEV *adev2 = adevCreate(adev->pci_dev);
		adev2->map_count = MAP_COUNT_4G2;
		adev2->peer = adev;
		adev2->sfp = SFP_B;

		if ((rc = _afhba_probe(adev2, REMOTE_BAR2, STREAM)) != 0){
			dev_err(pdev(adev2), "ERROR failed to create second device");
			return rc;
		}
		return rc;
	}
}
int afhba4_probe(struct AFHBA_DEV *adev)
{
	int (*_init)(struct AFHBA_DEV* adev) = afhba4_stream? STREAM: NOSTREAM;
	int rc;
	int ib;

	dev_info(pdev(adev), "AFHBA404 detected");
	adev->map_count = MAP_COUNT_4G4;
	adev->remote_com_bar = MAP_COUNT_4G4-1;
	if (bad_bios_bar_limit){
		dev_warn(pdev(adev), "limiting BAR count to bad_bios_bar_limit=%d",
				bad_bios_bar_limit);
		adev->map_count = bad_bios_bar_limit;
	}
	adev->sfp = SFP_A;
	adev->ACR = AURORA_CONTROL_REGA;
	rc = _afhba_probe(adev, REMOTE_BAR, _init);
	if (rc!=0) return rc;


	for (ib = 1; ib < afhba_nports; ++ib){
		struct AFHBA_DEV *adev2 = adevCreate(adev->pci_dev);
		adev2->map_count = MAP_COUNT_4G4;
		adev2->peer = adev;
		adev2->sfp = SFP_A+ib;
		adev2->ACR = AURORA_CONTROL_REGA + ib*0x10;
		if ((rc = _afhba_probe(adev2, REMOTE_BAR+ib, _init)) != 0){
			dev_err(pdev(adev2), "ERROR failed to create device %d", ib);
				return rc;
		}
	}
	return 0;
}
int afhba_mtca_probe(struct AFHBA_DEV *adev)
{
	int (*_init)(struct AFHBA_DEV* adev) = afhba4_stream? STREAM: NOSTREAM;

	dev_info(pdev(adev), "AFHBA404 detected %s", afhba4_stream? "STREAM": "NOSTREAM");
	adev->map_count = MAP_COUNT_4G1;
	adev->remote_com_bar = MAP_COUNT_4G1-1;
	if (bad_bios_bar_limit){
		dev_warn(pdev(adev), "limiting BAR count to bad_bios_bar_limit=%d",
				bad_bios_bar_limit);
		adev->map_count = bad_bios_bar_limit;
	}
	adev->sfp = SFP_A;
	adev->ACR = AURORA_CONTROL_REGA;
	return _afhba_probe(adev, REMOTE_BAR, _init);
}

int afhba_probe(struct pci_dev *dev, const struct pci_device_id *ent)
{
	struct AFHBA_DEV *adev = adevCreate(dev);

	dev_info(pdev(adev), "AFHBA: subdevice : %04x\n", ent->subdevice);
	switch(ent->subdevice){
	case PCI_SUBDID_FHBA_2G:
		dev_err(pdev(adev), "AFHBA 2G FIRMWARE detected %04x", ent->subdevice);
		adevDelete(adev);
		return -1;
	case PCI_SUBDID_FHBA_4G_OLD:
		dev_err(pdev(adev), "AFHBA 4G OBSOLETE FIRMWARE detected %04x", ent->subdevice);
		adevDelete(adev);
		return -1;
	case PCI_SUBDID_FHBA_4G:
		dev_info(pdev(adev), "AFHBA 4G single port firmware detected");
		adev->map_count = MAP_COUNT_4G1;
		adev->sfp = SFP_A;
		return _afhba_probe(adev, REMOTE_BAR, STREAM);
	case PCI_SUBDID_FHBA_4G2:
		return afhba2_probe(adev);
	case PCI_SUBDID_FHBA_4G4:
		return afhba4_probe(adev);
	case PCI_SUBDID_HBA_KMCU:
		dev_info(pdev(adev), "KMCU detected");
		return afhba_mtca_probe(adev);
	case PCI_SUBDID_HBA_KMCU2:
		dev_info(pdev(adev), "KMCU2 detected");
		return afhba_mtca_probe(adev);
	default:
		return -ENODEV;
	}
}
void afhba_remove (struct pci_dev *dev)
{
	struct AFHBA_DEV *adev = afhba_lookupDevicePci(dev);

	if (adev){
		afhba_stream_drv_del(adev);
		afhba_removeDebugfs(adev);
		afhba_remove_sysfs(adev);
		afhba_remove_sysfs_class(adev);
	}
	pci_disable_device(dev);

}
/*
 *
 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
 *   Class, Class Mask, String Index }
 */
static struct pci_device_id afhba_pci_tbl[] = {
	{ PCI_VENDOR_ID_XILINX, PCI_DEVICE_ID_XILINX_PCIE,
		PCI_SUBVID_DTACQ, PCI_SUBDID_FHBA_2G, 0 },
	{ PCI_VENDOR_ID_XILINX, PCI_DEVICE_ID_XILINX_PCIE,
		PCI_SUBVID_DTACQ, PCI_SUBDID_FHBA_4G_OLD, 0 },
	{ PCI_VENDOR_ID_XILINX, PCI_DEVICE_ID_DTACQ_PCIE,
		PCI_SUBVID_DTACQ, PCI_SUBDID_FHBA_4G, 0 },
	{ PCI_VENDOR_ID_XILINX, PCI_DEVICE_ID_DTACQ_PCIE,
		PCI_SUBVID_DTACQ, PCI_SUBDID_FHBA_4G2, 0 },
	{ PCI_VENDOR_ID_XILINX, PCI_DEVICE_ID_DTACQ_PCIE,
		PCI_SUBVID_DTACQ, PCI_SUBDID_FHBA_4G4, 0 },
	{ PCI_VENDOR_ID_XILINX, PCI_DEVICE_ID_DTACQ_PCIE,
		PCI_SUBVID_DTACQ, PCI_SUBDID_HBA_KMCU, 0 },
	{ PCI_VENDOR_ID_XILINX, PCI_DEVICE_ID_DTACQ_PCIE,
		PCI_SUBVID_DTACQ, PCI_SUBDID_HBA_KMCU2, 0 },
        { }
};
static struct pci_driver afhba_driver = {
        .name     = afhba_driver_name,
        .id_table = afhba_pci_tbl,
        .probe    = afhba_probe,
//        .remove   = __devexit_p(afhba_remove),
	.remove = afhba_remove
};

int __init afhba_init_module(void)
{
	int rc;

	printk(KERN_INFO "%s %s %s\n%s\n",
	     afhba_driver_name, afhba__driver_string,
	     afhba__driver_version,
	     afhba__copyright);

	afhba_device_class = class_create(THIS_MODULE, "afhba");
	rc = pci_register_driver(&afhba_driver);
	return rc;
}

void afhba_exit_module(void)
{
	class_destroy(afhba_device_class);
	pci_unregister_driver(&afhba_driver);
}

module_init(afhba_init_module);
module_exit(afhba_exit_module);

EXPORT_SYMBOL_GPL(afhba_devices);

MODULE_DEVICE_TABLE(pci, afhba_pci_tbl);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Peter.Milne@d-tacq.com");
MODULE_DESCRIPTION("D-TACQ ACQ-FIBER-HBA Driver for ACQ400");