Generic WorkQueue Engine (GenWQE) device driver (v7)
Subsystems (2)
cover Generic WorkQueue Engine (GenWQE) device driver (v7)
The GenWQE device is a PCIe card used to acclerate different tasks. Since it is configurable, it can be adjusted to different purposes. Our initial task for the card is to do zlib style compression/decompression RFC1950, RFC1951, and RFC1952.
I kindly ask for your feedback on the code, such that I can do any change which helps me to get it integrated smoothly.
The genwqe driver has a user-space interface described in linux/include/genwqe/genwqe_card.h. There are several ioctls which can be used to talk to the driver.
In addition there are some sysfs entries where information can be exchanged with user-space. The sysfs interface is described in Documentation/ABI/testing/sysfs-driver-genwqe.
Now the driver has also a debugfs interface. This is described in Documentation/ABI/testing/debugfs-driver-genwqe.
Frank Haverkamp (6):
GenWQE PCI support, health monitoring and recovery GenWQE Character device and DDCB queue GenWQE Utility functions
GenWQE Debugfs interfaces
GenWQE Sysfs interfaces
GenWQE Enable driver
Documentation/ABI/testing/debugfs-driver-genwqe | 70 ++ Documentation/ABI/testing/sysfs-driver-genwqe | 50 + drivers/misc/Kconfig | 1 + drivers/misc/Makefile | 1 + drivers/misc/genwqe/Kconfig | 13 + drivers/misc/genwqe/Makefile | 8 + drivers/misc/genwqe/card_base.c | 1203 ++++++++++++++++++ drivers/misc/genwqe/card_base.h | 570 +++++++++ drivers/misc/genwqe/card_ddcb.c | 1380 +++++++++++++++++++++ drivers/misc/genwqe/card_ddcb.h | 188 +++ drivers/misc/genwqe/card_debugfs.c | 480 ++++++++ drivers/misc/genwqe/card_dev.c | 1499 +++++++++++++++++++++++ drivers/misc/genwqe/card_sysfs.c | 277 +++++ drivers/misc/genwqe/card_utils.c | 983 +++++++++++++++ drivers/misc/genwqe/genwqe_driver.h | 75 ++ include/linux/genwqe/genwqe_card.h | 547 +++++++++ 16 files changed, 7345 insertions(+), 0 deletions(-) create mode 100644 Documentation/ABI/testing/debugfs-driver-genwqe create mode 100644 Documentation/ABI/testing/sysfs-driver-genwqe create mode 100644 drivers/misc/genwqe/Kconfig create mode 100644 drivers/misc/genwqe/Makefile create mode 100644 drivers/misc/genwqe/card_base.c create mode 100644 drivers/misc/genwqe/card_base.h create mode 100644 drivers/misc/genwqe/card_ddcb.c create mode 100644 drivers/misc/genwqe/card_ddcb.h create mode 100644 drivers/misc/genwqe/card_debugfs.c create mode 100644 drivers/misc/genwqe/card_dev.c create mode 100644 drivers/misc/genwqe/card_sysfs.c create mode 100644 drivers/misc/genwqe/card_utils.c create mode 100644 drivers/misc/genwqe/genwqe_driver.h create mode 100644 include/linux/genwqe/genwqe_card.h
PATCH 1/6 GenWQE PCI support, health monitoring and recovery
Module initialization and PCIe setup. Card health monitoring and recovery functionality. Character device creation and deletion are controlled from here.
Co-authors: Joerg-Stephan Vogt <[email protected]>,
Michael Jung <[email protected]>, Michael Ruettger <[email protected]>
--- drivers/misc/genwqe/card_base.c | 1203 +++++++++++++++++++++++++++++++++++ drivers/misc/genwqe/card_base.h | 570 +++++++++++++++++ drivers/misc/genwqe/genwqe_driver.h | 75 +++ include/linux/genwqe/genwqe_card.h | 547 ++++++++++++++++ 4 files changed, 2395 insertions(+), 0 deletions(-) create mode 100644 drivers/misc/genwqe/card_base.c create mode 100644 drivers/misc/genwqe/card_base.h create mode 100644 drivers/misc/genwqe/genwqe_driver.h create mode 100644 include/linux/genwqe/genwqe_card.h
drivers/misc/genwqe/card_base.c new file +1203 -0
@@ -0,0 +1,1203 @@ +/** +* IBM Accelerator Family 'GenWQE' +* +* (C) Copyright IBM Corp. 2013 +* +* Author: Frank Haverkamp <[email protected]> +* Author: Joerg-Stephan Vogt <[email protected]> +* Author: Michael Jung <[email protected]> +* Author: Michael Ruettger <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License (version 2 only) +* 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. +*/ + +/* +* Module initialization and PCIe setup. Card health monitoring and +* recovery functionality. Character device creation and deletion are +* controlled from here. +*/ + +#include <linux/module.h> +#include <linux/types.h> +#include <linux/pci.h> +#include <linux/err.h> +#include <linux/aer.h> +#include <linux/string.h> +#include <linux/sched.h> +#include <linux/wait.h> +#include <linux/delay.h> +#include <linux/dma-mapping.h> +#include <linux/module.h> +#include <linux/notifier.h> +#include <linux/device.h> +#include <linux/log2.h> +#include <linux/genwqe/genwqe_card.h> + +#include "card_base.h" +#include "card_ddcb.h" + +MODULE_AUTHOR ("Frank Haverkamp <[email protected]>" ); +MODULE_AUTHOR ("Michael Ruettger <[email protected]>" ); +MODULE_AUTHOR ("Joerg-Stephan Vogt <[email protected]>" ); +MODULE_AUTHOR ("Michal Jung <[email protected]>" ); + +MODULE_DESCRIPTION ("GenWQE Card" ); +MODULE_VERSION (DRV_VERS_STRING ); +MODULE_LICENSE ("GPL" ); + +static char genwqe_driver_name[] =GENWQE_DEVNAME ; +static struct class *class_genwqe; +static struct dentry *debugfs_genwqe; +static struct genwqe_dev *genwqe_devices[GENWQE_CARD_NO_MAX ]; + +/* PCI structure for identifying device by PCI vendor and device ID */ +static DEFINE_PCI_DEVICE_TABLE (genwqe_device_table) = { + { .vendor =PCI_VENDOR_ID_IBM , + .device =PCI_DEVICE_GENWQE , + .subvendor =PCI_SUBVENDOR_ID_IBM , + .subdevice =PCI_SUBSYSTEM_ID_GENWQE5 , + .class = (PCI_CLASSCODE_GENWQE5 <<8 ), + .class_mask = ~0 , + .driver_data =0 }, + +/* Initial SR-IOV bring-up image */ + { .vendor =PCI_VENDOR_ID_IBM , + .device =PCI_DEVICE_GENWQE , + .subvendor =PCI_SUBVENDOR_ID_IBM_SRIOV , + .subdevice =PCI_SUBSYSTEM_ID_GENWQE5_SRIOV , + .class = (PCI_CLASSCODE_GENWQE5_SRIOV <<8 ), + .class_mask = ~0 , + .driver_data =0 }, + + { .vendor =PCI_VENDOR_ID_IBM ,/* VF Vendor ID */ + .device =0x0000 ,/* VF Device ID */ + .subvendor =PCI_SUBVENDOR_ID_IBM_SRIOV , + .subdevice =PCI_SUBSYSTEM_ID_GENWQE5_SRIOV , + .class = (PCI_CLASSCODE_GENWQE5_SRIOV <<8 ), + .class_mask = ~0 , + .driver_data =0 }, + +/* Fixed up image */ + { .vendor =PCI_VENDOR_ID_IBM , + .device =PCI_DEVICE_GENWQE , + .subvendor =PCI_SUBVENDOR_ID_IBM_SRIOV , + .subdevice =PCI_SUBSYSTEM_ID_GENWQE5 , + .class = (PCI_CLASSCODE_GENWQE5_SRIOV <<8 ), + .class_mask = ~0 , + .driver_data =0 }, + + { .vendor =PCI_VENDOR_ID_IBM ,/* VF Vendor ID */ + .device =0x0000 ,/* VF Device ID */ + .subvendor =PCI_SUBVENDOR_ID_IBM_SRIOV , + .subdevice =PCI_SUBSYSTEM_ID_GENWQE5 , + .class = (PCI_CLASSCODE_GENWQE5_SRIOV <<8 ), + .class_mask = ~0 , + .driver_data =0 }, + +/* Even one more ... */ + { .vendor =PCI_VENDOR_ID_IBM , + .device =PCI_DEVICE_GENWQE , + .subvendor =PCI_SUBVENDOR_ID_IBM , + .subdevice =PCI_SUBSYSTEM_ID_GENWQE5_NEW , + .class = (PCI_CLASSCODE_GENWQE5 <<8 ), + .class_mask = ~0 , + .driver_data =0 }, + + {0 , }/* 0 terminated list. */ +}; + +MODULE_DEVICE_TABLE (pci, genwqe_device_table); + +/** +* genwqe_dev_alloc() - Create and prepare a new card descriptor +* +* Return: Pointer to card descriptor, or ERR_PTR(err) on error +*/ +static struct genwqe_dev *genwqe_dev_alloc (void ) +{ +unsigned int i =0 , j; +struct genwqe_dev *cd; + +for (i =0 ; i <GENWQE_CARD_NO_MAX ; i++) { +if (genwqe_devices[i] ==NULL ) +break ; + } +if (i >=GENWQE_CARD_NO_MAX ) +return ERR_PTR (-ENODEV ); + + cd =kzalloc (sizeof (struct genwqe_dev ),GFP_KERNEL ); +if (!cd) +return ERR_PTR (-ENOMEM ); + + cd->card_idx = i; + cd->class_genwqe = class_genwqe; + cd->debugfs_genwqe = debugfs_genwqe; + +init_waitqueue_head (&cd->queue_waitq); + +spin_lock_init (&cd->file_lock); +INIT_LIST_HEAD (&cd->file_list); + + cd->card_state =GENWQE_CARD_UNUSED ; +spin_lock_init (&cd->print_lock); + + cd->ddcb_software_timeout = genwqe_ddcb_software_timeout; + cd->kill_timeout = genwqe_kill_timeout; + +for (j =0 ; j <GENWQE_MAX_VFS ; j++) + cd->vf_jobtimeout_msec[j] = genwqe_vf_jobtimeout_msec; + + genwqe_devices[i] = cd; +return cd; +} + +static void genwqe_dev_free (struct genwqe_dev *cd) +{ +if (!cd) +return ; + + genwqe_devices[cd->card_idx] =NULL ; +kfree (cd); +} + +/** +* genwqe_bus_reset() - Card recovery +* +* pci_reset_function() will recover the device and ensure that the +* registers are accessible again when it completes with success. If +* not, the card will stay dead and registers will be unaccessible +* still. +*/ +static int genwqe_bus_reset (struct genwqe_dev *cd) +{ +int bars, rc =0 ; +struct pci_dev *pci_dev = cd->pci_dev; +void __iomem *mmio; + +if (cd->err_inject &GENWQE_INJECT_BUS_RESET_FAILURE ) +return -EIO ; + + mmio = cd->mmio; + cd->mmio =NULL ; +pci_iounmap (pci_dev, mmio); + + bars =pci_select_bars (pci_dev,IORESOURCE_MEM ); +pci_release_selected_regions (pci_dev, bars); + +/* +* Firmware/BIOS might change memory mapping during bus reset. +* Settings like enable bus-mastering, ... are backuped and +* restored by the pci_reset_function(). +*/ +dev_dbg (&pci_dev->dev,"[%s] pci_reset function ...\n" , __func__); + rc =pci_reset_function (pci_dev); +if (rc) { +dev_err (&pci_dev->dev, +"[%s] err: failed reset func (rc %d)\n" , __func__, rc); +return rc; + } +dev_dbg (&pci_dev->dev,"[%s] done with rc=%d\n" , __func__, rc); + +/* +* Here is the right spot to clear the register read +* failure. pci_bus_reset() does this job in real systems. +*/ + cd->err_inject &= ~(GENWQE_INJECT_HARDWARE_FAILURE | +GENWQE_INJECT_GFIR_FATAL | +GENWQE_INJECT_GFIR_INFO ); + + rc =pci_request_selected_regions (pci_dev, bars, genwqe_driver_name); +if (rc) { +dev_err (&pci_dev->dev, +"[%s] err: request bars failed (%d)\n" , __func__, rc); +return -EIO ; + } + + cd->mmio =pci_iomap (pci_dev,0 ,0 ); +if (cd->mmio ==NULL ) { +dev_err (&pci_dev->dev, +"[%s] err: mapping BAR0 failed\n" , __func__); +return -ENOMEM ; + } +return 0 ; +} + +/* +* Hardware circumvention section. Certain bitstreams in our test-lab +* had different kinds of problems. Here is where we adjust those +* bitstreams to function will with this version of our device driver. +* +* Thise circumventions are applied to the physical function only. +* The magical numbers below are identifying development/manufacturing +* versions of the bitstream used on the card. +* +* Turn off error reporting for old/manufacturing images. +*/ + +bool genwqe_need_err_masking (struct genwqe_dev *cd) +{ +return (cd->slu_unitcfg &0xFFFF0ull ) <0x32170ull ; +} + +static void genwqe_tweak_hardware (struct genwqe_dev *cd) +{ +struct pci_dev *pci_dev = cd->pci_dev; + +/* Mask FIRs for development images */ +if (((cd->slu_unitcfg &0xFFFF0ull ) >=0x32000ull ) && + ((cd->slu_unitcfg &0xFFFF0ull ) <=0x33250ull )) { +dev_warn (&pci_dev->dev, +"FIRs masked due to bitstream %016llx.%016llx\n" , + cd->slu_unitcfg, cd->app_unitcfg); + +__genwqe_writeq (cd,IO_APP_SEC_LEM_DEBUG_OVR , +0xFFFFFFFFFFFFFFFFull ); + +__genwqe_writeq (cd,IO_APP_ERR_ACT_MASK , +0x0000000000000000ull ); + } +} + +/** +* genwqe_recovery_on_fatal_gfir_required() - Version depended actions +* +* Bitstreams older than 2013-02-17 have a bug where fatal GFIRs must +* be ignored. This is e.g. true for the bitstream we gave to the card +* manufacturer, but also for some old bitstreams we released to our +* test-lab. +*/ +int genwqe_recovery_on_fatal_gfir_required (struct genwqe_dev *cd) +{ +return ((cd->slu_unitcfg &0xFFFF0ull ) >=0x32170ull ); +} + +int genwqe_flash_readback_fails (struct genwqe_dev *cd) +{ +return ((cd->slu_unitcfg &0xFFFF0ull ) <0x32170ull ); +} + +/** +* genwqe_T_psec() - Calculate PF/VF timeout register content +* +* Note: From a design perspective it turned out to be a bad idea to +* use codes here to specifiy the frequency/speed values. An old +* driver cannot understand new codes and is therefore always a +* problem. Better is to measure out the value or put the +* speed/frequency directly into a register which is always a valid +* value for old as well as for new software. +*/ +/* T = 1/f */ +static int genwqe_T_psec (struct genwqe_dev *cd) +{ +u16 speed;/* 1/f -> 250, 200, 166, 175 */ +static const int T [] = {4000 ,5000 ,6000 ,5714 }; + + speed = (u16)((cd->slu_unitcfg >>28 ) &0x0full ); +if (speed >=ARRAY_SIZE (T )) +return -1 ;/* illegal value */ + +return T [speed]; +} + +/** +* genwqe_setup_pf_jtimer() - Setup PF hardware timeouts for DDCB execution +* +* Do this _after_ card_reset() is called. Otherwise the values will +* vanish. The settings need to be done when the queues are inactive. +* +* The max. timeout value is 2^(10+x) * T (6ns for 166MHz) * 15/16. +* The min. timeout value is 2^(10+x) * T (6ns for 166MHz) * 14/16. +*/ +static bool genwqe_setup_pf_jtimer (struct genwqe_dev *cd) +{ +u32 T =genwqe_T_psec (cd); +u64 x; + +if (genwqe_pf_jobtimeout_msec ==0 ) +return false; + +/* PF: large value needed, flash update 2sec per block */ + x =ilog2 (genwqe_pf_jobtimeout_msec * +16000000000uL /(T *15 )) -10 ; + +genwqe_write_jtimer (cd,0 , (0xff00 | (x &0xff ))); +return true; +} + +/** +* genwqe_setup_vf_jtimer() - Setup VF hardware timeouts for DDCB execution +*/ +static bool genwqe_setup_vf_jtimer (struct genwqe_dev *cd) +{ +struct pci_dev *pci_dev = cd->pci_dev; +unsigned int vf; +u32 T =genwqe_T_psec (cd); +u64 x; + +for (vf =0 ; vf <pci_sriov_get_totalvfs (pci_dev); vf++) { + +if (cd->vf_jobtimeout_msec[vf] ==0 ) +continue ; + + x =ilog2 (cd->vf_jobtimeout_msec[vf] * +16000000000uL /(T *15 )) -10 ; + +genwqe_write_jtimer (cd, vf +1 , (0xff00 | (x &0xff ))); + } +return true; +} + +static int genwqe_ffdc_buffs_alloc (struct genwqe_dev *cd) +{ +unsigned int type, e =0 ; + +for (type =0 ; type <GENWQE_DBG_UNITS ; type++) { +switch (type) { +case GENWQE_DBG_UNIT0 : + e =genwqe_ffdc_buff_size (cd,0 ); +break ; +case GENWQE_DBG_UNIT1 : + e =genwqe_ffdc_buff_size (cd,1 ); +break ; +case GENWQE_DBG_UNIT2 : + e =genwqe_ffdc_buff_size (cd,2 ); +break ; +case GENWQE_DBG_REGS : + e =GENWQE_FFDC_REGS ; +break ; + } + +/* currently support only the debug units mentioned here */ + cd->ffdc[type].entries = e; + cd->ffdc[type].regs =kmalloc (e *sizeof (struct genwqe_reg ), +GFP_KERNEL ); +/* +* regs == NULL is ok, the using code treats this as no regs, +* Printing warning is ok in this case. +*/ + } +return 0 ; +} + +static void genwqe_ffdc_buffs_free (struct genwqe_dev *cd) +{ +unsigned int type; + +for (type =0 ; type <GENWQE_DBG_UNITS ; type++) { +kfree (cd->ffdc[type].regs); + cd->ffdc[type].regs =NULL ; + } +} + +static int genwqe_read_ids (struct genwqe_dev *cd) +{ +int err =0 ; +int slu_id; +struct pci_dev *pci_dev = cd->pci_dev; + + cd->slu_unitcfg =__genwqe_readq (cd,IO_SLU_UNITCFG ); +if (cd->slu_unitcfg ==IO_ILLEGAL_VALUE ) { +dev_err (&pci_dev->dev, +"err: SLUID=%016llx\n" , cd->slu_unitcfg); + err = -EIO ; + goto out_err; + } + + slu_id =genwqe_get_slu_id (cd); +if (slu_id <GENWQE_SLU_ARCH_REQ || slu_id ==0xff ) { +dev_err (&pci_dev->dev, +"err: incompatible SLU Architecture %u\n" , slu_id); + err = -ENOENT ; + goto out_err; + } + + cd->app_unitcfg =__genwqe_readq (cd,IO_APP_UNITCFG ); +if (cd->app_unitcfg ==IO_ILLEGAL_VALUE ) { +dev_err (&pci_dev->dev, +"err: APPID=%016llx\n" , cd->app_unitcfg); + err = -EIO ; + goto out_err; + } +genwqe_read_app_id (cd, cd->app_name,sizeof (cd->app_name)); + +/* +* Is access to all registers possible? If we are a VF the +* answer is obvious. If we run fully virtualized, we need to +* check if we can access all registers. If we do not have +* full access we will cause an UR and some informational FIRs +* in the PF, but that should not harm. +*/ +if (pci_dev->is_virtfn) + cd->is_privileged =0 ; +else + cd->is_privileged = (__genwqe_readq (cd,IO_SLU_BITSTREAM ) + !=IO_ILLEGAL_VALUE ); + + out_err: +return err; +} + +static int genwqe_start (struct genwqe_dev *cd) +{ +int err; +struct pci_dev *pci_dev = cd->pci_dev; + + err =genwqe_read_ids (cd); +if (err) +return err; + +if (genwqe_is_privileged (cd)) { +/* do this after the tweaks. alloc fail is acceptable */ +genwqe_ffdc_buffs_alloc (cd); +genwqe_stop_traps (cd); + +/* Collect registers e.g. FIRs, UNITIDs, traces ... */ +genwqe_read_ffdc_regs (cd, cd->ffdc[GENWQE_DBG_REGS ].regs, + cd->ffdc[GENWQE_DBG_REGS ].entries,0 ); + +genwqe_ffdc_buff_read (cd,GENWQE_DBG_UNIT0 , + cd->ffdc[GENWQE_DBG_UNIT0 ].regs, + cd->ffdc[GENWQE_DBG_UNIT0 ].entries); + +genwqe_ffdc_buff_read (cd,GENWQE_DBG_UNIT1 , + cd->ffdc[GENWQE_DBG_UNIT1 ].regs, + cd->ffdc[GENWQE_DBG_UNIT1 ].entries); + +genwqe_ffdc_buff_read (cd,GENWQE_DBG_UNIT2 , + cd->ffdc[GENWQE_DBG_UNIT2 ].regs, + cd->ffdc[GENWQE_DBG_UNIT2 ].entries); + +genwqe_start_traps (cd); + +if (cd->card_state ==GENWQE_CARD_FATAL_ERROR ) { +dev_warn (&pci_dev->dev, +"[%s] chip reload/recovery!\n" , __func__); + +/* +* Stealth Mode: Reload chip on either hot +* reset or PERST. +*/ + cd->softreset =0x7Cull ; +__genwqe_writeq (cd,IO_SLC_CFGREG_SOFTRESET , + cd->softreset); + + err =genwqe_bus_reset (cd); +if (err !=0 ) { +dev_err (&pci_dev->dev, +"[%s] err: bus reset failed!\n" , + __func__); + goto out; + } + +/* +* Re-read the IDs because +* it could happen that the bitstream load +* failed! +*/ + err =genwqe_read_ids (cd); +if (err) + goto out; + } + } + + err =genwqe_setup_service_layer (cd);/* does a reset to the card */ +if (err !=0 ) { +dev_err (&pci_dev->dev, +"[%s] err: could not setup servicelayer!\n" , __func__); + err = -ENODEV ; + goto out; + } + +if (genwqe_is_privileged (cd)) {/* code is running _after_ reset */ +genwqe_tweak_hardware (cd); + +genwqe_setup_pf_jtimer (cd); +genwqe_setup_vf_jtimer (cd); + } + + err =genwqe_device_create (cd); +if (err <0 ) { +dev_err (&pci_dev->dev, +"err: chdev init failed! (err=%d)\n" , err); + goto out_release_service_layer; + } +return 0 ; + + out_release_service_layer: +genwqe_release_service_layer (cd); + out: +if (genwqe_is_privileged (cd)) +genwqe_ffdc_buffs_free (cd); +return -EIO ; +} + +/** +* genwqe_stop() - Stop card operation +* +* Recovery notes: +* As long as genwqe_thread runs we might access registers during +* error data capture. Same is with the genwqe_health_thread. +* When genwqe_bus_reset() fails this function might called two times: +* first by the genwqe_health_thread() and later by genwqe_remove() to +* unbind the device. We must be able to survive that. +* +* This function must be robust enough to be called twice. +*/ +static int genwqe_stop (struct genwqe_dev *cd) +{ +genwqe_finish_queue (cd);/* no register access */ +genwqe_device_remove (cd);/* device removed, procs killed */ +genwqe_release_service_layer (cd);/* here genwqe_thread is stopped */ + +if (genwqe_is_privileged (cd)) { +pci_disable_sriov (cd->pci_dev);/* access pci config space */ +genwqe_ffdc_buffs_free (cd); + } + +return 0 ; +} + +/** +* genwqe_recover_card() - Try to recover the card if it is possible +* +* If fatal_err is set no register access is possible anymore. It is +* likely that genwqe_start fails in that situation. Proper error +* handling is required in this case. +* +* genwqe_bus_reset() will cause the pci code to call genwqe_remove() +* and later genwqe_probe() for all virtual functions. +*/ +static int genwqe_recover_card (struct genwqe_dev *cd,int fatal_err) +{ +int rc; +struct pci_dev *pci_dev = cd->pci_dev; + +genwqe_stop (cd); + +/* +* Make sure chip is not reloaded to maintain FFDC. Write SLU +* Reset Register, CPLDReset field to 0. +*/ +if (!fatal_err) { + cd->softreset =0x70ull ; +__genwqe_writeq (cd,IO_SLC_CFGREG_SOFTRESET , cd->softreset); + } + + rc =genwqe_bus_reset (cd); +if (rc !=0 ) { +dev_err (&pci_dev->dev, +"[%s] err: card recovery impossible!\n" , __func__); +return rc; + } + + rc =genwqe_start (cd); +if (rc <0 ) { +dev_err (&pci_dev->dev, +"[%s] err: failed to launch device!\n" , __func__); +return rc; + } +return 0 ; +} + +static int genwqe_health_check_cond (struct genwqe_dev *cd,u64 *gfir) +{ + *gfir =__genwqe_readq (cd,IO_SLC_CFGREG_GFIR ); +return (*gfir &GFIR_ERR_TRIGGER ) && +genwqe_recovery_on_fatal_gfir_required (cd); +} + +/** +* genwqe_fir_checking() - Check the fault isolation registers of the card +* +* If this code works ok, can be tried out with help of the genwqe_poke tool: +* sudo ./tools/genwqe_poke 0x8 0xfefefefefef +* +* Now the relevant FIRs/sFIRs should be printed out and the driver should +* invoke recovery (devices are removed and readded). +*/ +static u64 genwqe_fir_checking (struct genwqe_dev *cd) +{ +int j, iterations =0 ; +u64 mask, fir, fec, uid, gfir, gfir_masked, sfir, sfec; +u32 fir_addr, fir_clr_addr, fec_addr, sfir_addr, sfec_addr; +struct pci_dev *pci_dev = cd->pci_dev; + + healthMonitor: + iterations++; +if (iterations >16 ) { +dev_err (&pci_dev->dev,"* exit looping after %d times\n" , + iterations); + goto fatal_error; + } + + gfir =__genwqe_readq (cd,IO_SLC_CFGREG_GFIR ); +if (gfir !=0x0 ) +dev_err (&pci_dev->dev,"* 0x%08x 0x%016llx\n" , +IO_SLC_CFGREG_GFIR , gfir); +if (gfir ==IO_ILLEGAL_VALUE ) + goto fatal_error; + +/* +* Avoid printing when to GFIR bit is on prevents contignous +* printout e.g. for the following bug: +* FIR set without a 2ndary FIR/FIR cannot be cleared +* Comment out the following if to get the prints: +*/ +if (gfir ==0 ) +return 0 ; + + gfir_masked = gfir &GFIR_ERR_TRIGGER ;/* fatal errors */ + +for (uid =0 ; uid <GENWQE_MAX_UNITS ; uid++) {/* 0..2 in zEDC */ + +/* read the primary FIR (pfir) */ + fir_addr = (uid <<24 ) +0x08 ; + fir =__genwqe_readq (cd, fir_addr); +if (fir ==0x0 ) +continue ;/* no error in this unit */ + +dev_err (&pci_dev->dev,"* 0x%08x 0x%016llx\n" , fir_addr, fir); +if (fir ==IO_ILLEGAL_VALUE ) + goto fatal_error; + +/* read primary FEC */ + fec_addr = (uid <<24 ) +0x18 ; + fec =__genwqe_readq (cd, fec_addr); + +dev_err (&pci_dev->dev,"* 0x%08x 0x%016llx\n" , fec_addr, fec); +if (fec ==IO_ILLEGAL_VALUE ) + goto fatal_error; + +for (j =0 , mask =1ULL ; j <64 ; j++, mask <<=1 ) { + +/* secondary fir empty, skip it */ +if ((fir & mask) ==0x0 ) +continue ; + + sfir_addr = (uid <<24 ) +0x100 +0x08 * j; + sfir =__genwqe_readq (cd, sfir_addr); + +if (sfir ==IO_ILLEGAL_VALUE ) + goto fatal_error; +dev_err (&pci_dev->dev, +"* 0x%08x 0x%016llx\n" , sfir_addr, sfir); + + sfec_addr = (uid <<24 ) +0x300 +0x08 * j; + sfec =__genwqe_readq (cd, sfec_addr); + +if (sfec ==IO_ILLEGAL_VALUE ) + goto fatal_error; +dev_err (&pci_dev->dev, +"* 0x%08x 0x%016llx\n" , sfec_addr, sfec); + + gfir =__genwqe_readq (cd,IO_SLC_CFGREG_GFIR ); +if (gfir ==IO_ILLEGAL_VALUE ) + goto fatal_error; + +/* gfir turned on during routine! get out and +start over. */ +if ((gfir_masked ==0x0 ) && + (gfir &GFIR_ERR_TRIGGER )) { + goto healthMonitor; + } + +/* do not clear if we entered with a fatal gfir */ +if (gfir_masked ==0x0 ) { + +/* NEW clear by mask the logged bits */ + sfir_addr = (uid <<24 ) +0x100 +0x08 * j; +__genwqe_writeq (cd, sfir_addr, sfir); + +dev_dbg (&pci_dev->dev, +"[HM] Clearing 2ndary FIR 0x%08x " +"with 0x%016llx\n" , sfir_addr, sfir); + +/* +* note, these cannot be error-Firs +* since gfir_masked is 0 after sfir +* was read. Also, it is safe to do +* this write if sfir=0. Still need to +* clear the primary. This just means +* there is no secondary FIR. +*/ + +/* clear by mask the logged bit. */ + fir_clr_addr = (uid <<24 ) +0x10 ; +__genwqe_writeq (cd, fir_clr_addr, mask); + +dev_dbg (&pci_dev->dev, +"[HM] Clearing primary FIR 0x%08x " +"with 0x%016llx\n" , fir_clr_addr, + mask); + } + } + } + gfir =__genwqe_readq (cd,IO_SLC_CFGREG_GFIR ); +if (gfir ==IO_ILLEGAL_VALUE ) + goto fatal_error; + +if ((gfir_masked ==0x0 ) && (gfir &GFIR_ERR_TRIGGER )) { +/* +* Check once more that it didn't go on after all the +* FIRS were cleared. +*/ +dev_dbg (&pci_dev->dev,"ACK! Another FIR! Recursing %d!\n" , + iterations); + goto healthMonitor; + } +return gfir_masked; + + fatal_error: +return IO_ILLEGAL_VALUE ; +} + +/** +* genwqe_health_thread() - Health checking thread +* +* This thread is only started for the PF of the card. +* +* This thread monitors the health of the card. A critical situation +* is when we read registers which contain -1 (IO_ILLEGAL_VALUE). In +* this case we need to be recovered from outside. Writing to +* registers will very likely not work either. +* +* This thread must only exit if kthread_should_stop() becomes true. +* +* Condition for the health-thread to trigger: +* a) when a kthread_stop() request comes in or +* b) a critical GFIR occured +* +* Informational GFIRs are checked and potentially printed in +* health_check_interval seconds. +*/ +static int genwqe_health_thread (void *data) +{ +int rc, should_stop =0 ; +struct genwqe_dev *cd = data; +struct pci_dev *pci_dev = cd->pci_dev; +u64 gfir, gfir_masked, slu_unitcfg, app_unitcfg; + +while (!kthread_should_stop ()) { + rc =wait_event_interruptible_timeout (cd->health_waitq, + (genwqe_health_check_cond (cd, &gfir) || + (should_stop =kthread_should_stop ())), + genwqe_health_check_interval *HZ ); + +if (should_stop) +break ; + +if (gfir ==IO_ILLEGAL_VALUE ) { +dev_err (&pci_dev->dev, +"[%s] GFIR=%016llx\n" , __func__, gfir); + goto fatal_error; + } + + slu_unitcfg =__genwqe_readq (cd,IO_SLU_UNITCFG ); +if (slu_unitcfg ==IO_ILLEGAL_VALUE ) { +dev_err (&pci_dev->dev, +"[%s] SLU_UNITCFG=%016llx\n" , + __func__, slu_unitcfg); + goto fatal_error; + } + + app_unitcfg =__genwqe_readq (cd,IO_APP_UNITCFG ); +if (app_unitcfg ==IO_ILLEGAL_VALUE ) { +dev_err (&pci_dev->dev, +"[%s] APP_UNITCFG=%016llx\n" , + __func__, app_unitcfg); + goto fatal_error; + } + + gfir =__genwqe_readq (cd,IO_SLC_CFGREG_GFIR ); +if (gfir ==IO_ILLEGAL_VALUE ) { +dev_err (&pci_dev->dev, +"[%s] %s: GFIR=%016llx\n" , __func__, + (gfir &GFIR_ERR_TRIGGER ) ?"err" :"info" , + gfir); + goto fatal_error; + } + + gfir_masked =genwqe_fir_checking (cd); +if (gfir_masked ==IO_ILLEGAL_VALUE ) + goto fatal_error; + +/* +* GFIR ErrorTrigger bits set => reset the card! +* Never do this for old/manufacturing images! +*/ +if ((gfir_masked) && !cd->skip_recovery && +genwqe_recovery_on_fatal_gfir_required (cd)) { + + cd->card_state =GENWQE_CARD_FATAL_ERROR ; + + rc =genwqe_recover_card (cd,0 ); +if (rc <0 ) { +/* FIXME Card is unusable and needs unbind! */ + goto fatal_error; + } + } + + cd->last_gfir = gfir; +cond_resched (); + } + +return 0 ; + + fatal_error: +dev_err (&pci_dev->dev, +"[%s] card unusable. Please trigger unbind!\n" , __func__); + +/* Bring down logical devices to inform user space via udev remove. */ + cd->card_state =GENWQE_CARD_FATAL_ERROR ; +genwqe_stop (cd); + +/* genwqe_bus_reset failed(). Now wait for genwqe_remove(). */ +while (!kthread_should_stop ()) +cond_resched (); + +return -EIO ; +} + +static int genwqe_health_check_start (struct genwqe_dev *cd) +{ +int rc; + +if (genwqe_health_check_interval <=0 ) +return 0 ;/* valid for disabling the service */ + +/* moved before request_irq() */ +/* init_waitqueue_head(&cd->health_waitq); */ + + cd->health_thread =kthread_run (genwqe_health_thread, cd, +GENWQE_DEVNAME "%d_health" , + cd->card_idx); +if (IS_ERR (cd->health_thread)) { + rc =PTR_ERR (cd->health_thread); + cd->health_thread =NULL ; +return rc; + } +return 0 ; +} + +static int genwqe_health_thread_running (struct genwqe_dev *cd) +{ +return (cd->health_thread !=NULL ); +} + +static int genwqe_health_check_stop (struct genwqe_dev *cd) +{ +int rc; + +if (!genwqe_health_thread_running (cd)) +return -EIO ; + + rc =kthread_stop (cd->health_thread); + cd->health_thread =NULL ; +return 0 ; +} + +/** +* genwqe_pci_setup() - Allocate PCIe related resources for our card +*/ +static int genwqe_pci_setup (struct genwqe_dev *cd) +{ +int err, bars; +struct pci_dev *pci_dev = cd->pci_dev; + + bars =pci_select_bars (pci_dev,IORESOURCE_MEM ); + err =pci_enable_device_mem (pci_dev); +if (err) { +dev_err (&pci_dev->dev, +"err: failed to enable pci memory (err=%d)\n" , err); + goto err_out; + } + +/* Reserve PCI I/O and memory resources */ + err =pci_request_selected_regions (pci_dev, bars, genwqe_driver_name); +if (err) { +dev_err (&pci_dev->dev, +"[%s] err: request bars failed (%d)\n" , __func__, err); + err = -EIO ; + goto err_disable_device; + } + +/* check for 64-bit DMA address supported (DAC) */ +if (!pci_set_dma_mask (pci_dev,DMA_BIT_MASK (64 ))) { + err =pci_set_consistent_dma_mask (pci_dev,DMA_BIT_MASK (64 )); +if (err) { +dev_err (&pci_dev->dev, +"err: DMA64 consistent mask error\n" ); + err = -EIO ; + goto out_release_resources; + } +/* check for 32-bit DMA address supported (SAC) */ + }else if (!pci_set_dma_mask (pci_dev,DMA_BIT_MASK (32 ))) { + err =pci_set_consistent_dma_mask (pci_dev,DMA_BIT_MASK (32 )); +if (err) { +dev_err (&pci_dev->dev, +"err: DMA32 consistent mask error\n" ); + err = -EIO ; + goto out_release_resources; + } + }else { +dev_err (&pci_dev->dev, +"err: neither DMA32 nor DMA64 supported\n" ); + err = -EIO ; + goto out_release_resources; + } + +pci_set_master (pci_dev); +pci_enable_pcie_error_reporting (pci_dev); + +/* request complete BAR-0 space (length = 0) */ + cd->mmio_len =pci_resource_len (pci_dev,0 ); + cd->mmio =pci_iomap (pci_dev,0 ,0 ); +if (cd->mmio ==NULL ) { +dev_err (&pci_dev->dev, +"[%s] err: mapping BAR0 failed\n" , __func__); + err = -ENOMEM ; + goto out_release_resources; + } + + cd->num_vfs =pci_sriov_get_totalvfs (pci_dev); + + err =genwqe_read_ids (cd); +if (err) + goto out_iounmap; + +return 0 ; + + out_iounmap: +pci_iounmap (pci_dev, cd->mmio); + out_release_resources: +pci_release_selected_regions (pci_dev, bars); + err_disable_device: +pci_disable_device (pci_dev); + err_out: +return err; +} + +/** +* genwqe_pci_remove() - Free PCIe related resources for our card +*/ +static void genwqe_pci_remove (struct genwqe_dev *cd) +{ +int bars; +struct pci_dev *pci_dev = cd->pci_dev; + +if (cd->mmio) +pci_iounmap (pci_dev, cd->mmio); + + bars =pci_select_bars (pci_dev,IORESOURCE_MEM ); +pci_release_selected_regions (pci_dev, bars); +pci_disable_device (pci_dev); +} + +/** +* genwqe_probe() - Device initialization +* @pdev: PCI device information struct +* +* Callable for multiple cards. This function is called on bind. +* +* Return: 0 if succeeded, < 0 when failed +*/ +static int genwqe_probe (struct pci_dev *pci_dev, +const struct pci_device_id *id) +{ +int err; +struct genwqe_dev *cd; + +init_crc32 (); + + cd =genwqe_dev_alloc (); +if (IS_ERR (cd)) { +dev_err (&pci_dev->dev,"err: could not alloc mem (err=%d)!\n" , + (int )PTR_ERR (cd)); +return PTR_ERR (cd); + } + +dev_set_drvdata (&pci_dev->dev, cd); + cd->pci_dev = pci_dev; + + err =genwqe_pci_setup (cd); +if (err <0 ) { +dev_err (&pci_dev->dev, +"err: problems with PCI setup (err=%d)\n" , err); + goto out_free_dev; + } + + err =genwqe_start (cd); +if (err <0 ) { +dev_err (&pci_dev->dev, +"err: cannot start card services! (err=%d)\n" , err); + goto out_pci_remove; + } + +if (genwqe_is_privileged (cd)) { + err =genwqe_health_check_start (cd); +if (err <0 ) { +dev_err (&pci_dev->dev, +"err: cannot start health checking! " +"(err=%d)\n" , err); + goto out_stop_services; + } + } +return 0 ; + + out_stop_services: +genwqe_stop (cd); + out_pci_remove: +genwqe_pci_remove (cd); + out_free_dev: +genwqe_dev_free (cd); +return err; +} + +/** +* genwqe_remove() - Called when device is removed (hot-plugable) +* +* Or when driver is unloaded respecitively when unbind is done. +*/ +static void genwqe_remove (struct pci_dev *pci_dev) +{ +struct genwqe_dev *cd =dev_get_drvdata (&pci_dev->dev); + +genwqe_health_check_stop (cd); + +/* +* genwqe_stop() must survive if it is called twice +* sequentially. This happens when the health thread calls it +* and fails on genwqe_bus_reset(). +*/ +genwqe_stop (cd); +genwqe_pci_remove (cd); +genwqe_dev_free (cd); +} + +/* +* genwqe_err_error_detected() - Error detection callback +* +* This callback is called by the PCI subsystem whenever a PCI bus +* error is detected. +*/ +static pci_ers_result_t genwqe_err_error_detected (struct pci_dev *pci_dev, +enum pci_channel_state state) +{ +struct genwqe_dev *cd; + +dev_err (&pci_dev->dev,"[%s] state=%d\n" , __func__, state); + +if (pci_dev ==NULL ) +return PCI_ERS_RESULT_NEED_RESET ; + + cd =dev_get_drvdata (&pci_dev->dev); +if (cd ==NULL ) +return PCI_ERS_RESULT_NEED_RESET ; + +switch (state) { +case pci_channel_io_normal: +return PCI_ERS_RESULT_CAN_RECOVER ; +case pci_channel_io_frozen: +return PCI_ERS_RESULT_NEED_RESET ; +case pci_channel_io_perm_failure: +return PCI_ERS_RESULT_DISCONNECT ; + } + +return PCI_ERS_RESULT_NEED_RESET ; +} + +static pci_ers_result_t genwqe_err_result_none (struct pci_dev *dev) +{ +return PCI_ERS_RESULT_NONE ; +} + +static void genwqe_err_resume (struct pci_dev *dev) +{ +} + +static int genwqe_sriov_configure (struct pci_dev *dev,int numvfs) +{ +struct genwqe_dev *cd =dev_get_drvdata (&dev->dev); + +if (numvfs >0 ) { +genwqe_setup_vf_jtimer (cd); +pci_enable_sriov (dev, numvfs); +return numvfs; + } +if (numvfs ==0 ) { +pci_disable_sriov (dev); +return 0 ; + } +return 0 ; +} + +static struct pci_error_handlers genwqe_err_handler = { + .error_detected = genwqe_err_error_detected, + .mmio_enabled = genwqe_err_result_none, + .link_reset = genwqe_err_result_none, + .slot_reset = genwqe_err_result_none, + .resume = genwqe_err_resume, +}; + +static struct pci_driver genwqe_driver = { + .name = genwqe_driver_name, + .id_table = genwqe_device_table, + .probe = genwqe_probe, + .remove = genwqe_remove, + .sriov_configure = genwqe_sriov_configure, + .err_handler = &genwqe_err_handler, +}; + +/** +* genwqe_init_module() - Driver registration and initialization +*/ +static int __init genwqe_init_module (void ) +{ +int rc; + + class_genwqe =class_create (THIS_MODULE ,GENWQE_DEVNAME ); +if (IS_ERR (class_genwqe)) { +pr_err ("[%s] create class failed\n" , __func__); +return -ENOMEM ; + } + + debugfs_genwqe =debugfs_create_dir (GENWQE_DEVNAME ,NULL ); +if (!debugfs_genwqe) { + rc = -ENOMEM ; + goto err_out; + } + + rc =pci_register_driver (&genwqe_driver); +if (rc !=0 ) { +pr_err ("[%s] pci_reg_driver (rc=%d)\n" , __func__, rc); + goto err_out0; + } + +return rc; + + err_out0: +debugfs_remove (debugfs_genwqe); + err_out: +class_destroy (class_genwqe); +return rc; +} + +/** +* genwqe_exit_module() - Driver exit +*/ +static void __exit genwqe_exit_module(void) +{ +pci_unregister_driver (&genwqe_driver); +debugfs_remove (debugfs_genwqe); +class_destroy (class_genwqe); +} + +module_init (genwqe_init_module); +module_exit (genwqe_exit_module);
drivers/misc/genwqe/card_base.h new file +570 -0
570 lines not on this page · raw message
drivers/misc/genwqe/genwqe_driver.h new file +75 -0
75 lines not on this page · raw message
include/linux/genwqe/genwqe_card.h new file +547 -0
547 lines not on this page · raw message
Signature · 1 line
1.7.1
Greg KH
maintainerRe: [PATCH 1/6] GenWQE PCI support, health monitoring and recovery
Quoted 34 lines · Frank Haverkamp
include/linux/genwqe/genwqe_card.h new file +31
-0@@ -0,0 +1,547 @@ +#ifndef __GENWQE_CARD_H__ +#define __GENWQE_CARD_H__ + +/** +* IBM Accelerator Family 'GenWQE' +* +* (C) Copyright IBM Corp. 2013 +* +* Author: Frank Haverkamp <[email protected]> +* Author: Joerg-Stephan Vogt <[email protected]> +* Author: Michael Jung <[email protected]> +* Author: Michael Ruettger <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License (version 2 only) +* 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. +*/ + +/* +* User-space API for the GenWQE card. For debugging and test purposes +* the register addresses are included here too. +*/ + +#ifdef __KERNEL__ +# include <linux/types.h> +# include <linux/ioctl.h>
include/linux/genwqe/genwqe_card.h line 41
Quoted 10 lines
include/linux/genwqe/genwqe_card.h new file +10
-0+#else +# include <stdint.h> +# include <asm/ioctl.h> +# include <stddef.h> +# include <string.h> +# +# ifndef __user +# define __user +# endif +#endif
Ick, really?
Anyway, userspace .h files need to be in include/uapi/, not in include/linux/, please split only the userspace side of this file out to that directory, the other bits that do not need to go to userspace can probably go back down in your local directory, right?
Quoted 235 lines
include/linux/genwqe/genwqe_card.h new file +235
-0+ +/* Basename of sysfs, debugfs and /dev interfaces */ +#define GENWQE_DEVNAME "genwqe" + +#define GENWQE_TYPE_ALTERA_230 0x00/* GenWQE4 Stratix-IV-230 */ +#define GENWQE_TYPE_ALTERA_530 0x01/* GenWQE4 Stratix-IV-530 */ +#define GENWQE_TYPE_ALTERA_A4 0x02/* GenWQE5 A4 Stratix-V-A4 */ +#define GENWQE_TYPE_ALTERA_A7 0x03/* GenWQE5 A7 Stratix-V-A7 */ + +/* MMIO Unit offsets: Each UnitID occupies a defined address range */ +#define UID_OFFS (uid) ((uid) << 24) + +#define SLU_OFFS UID_OFFS(0) +#define HSU_OFFS UID_OFFS(1) +#define APP_OFFS UID_OFFS(2) +#define MEMC0_OFFS UID_OFFS(3) +#define MEMC1_OFFS UID_OFFS(4) +#define ETH0_OFFS UID_OFFS(5) +#define ETH1_OFFS UID_OFFS(6) +#define GENWQE_MAX_UNITS 3 + +/* Common offsets per UnitID */ +#define IO_EXTENDED_ERROR_POINTER 0x00000048 +#define IO_ERROR_INJECT_SELECTOR 0x00000060 +#define IO_EXTENDED_DIAG_SELECTOR 0x00000070 +#define IO_EXTENDED_DIAG_READ_MBX 0x00000078 +#define IO_EXTENDED_DIAG_MAP (ring) (0x00000500 | ((ring) << 3)) + +#define EXTENDED_DIAG_SELECTOR (ring, trace) (((ring) << 8) | (trace)) + +/* UnitID 0: Service Layer Unit (SLU) */ + +/* SLU: Unit Configuration Register */ +#define IO_SLU_UNITCFG 0x00000000 +#define SLU_UNITCFG_TYPE_MASK 0x000000000ff00000/* 27:20 */ + +/* SLU: Fault Isolation Register (FIR) (ac_slu_fir) */ +#define IO_SLU_FIR 0x00000008/* read only, wr direct */ +#define IO_SLU_FIR_CLR 0x00000010/* read and clear */ + +/* SLU: First Error Capture Register (FEC/WOF) */ +#define IO_SLU_FEC 0x00000018 + +#define IO_SLU_ERR_ACT_MASK 0x00000020 +#define IO_SLU_ERR_ATTN_MASK 0x00000028 +#define IO_SLU_FIRX1_ACT_MASK 0x00000030 +#define IO_SLU_FIRX0_ACT_MASK 0x00000038 +#define IO_SLU_SEC_LEM_DEBUG_OVR 0x00000040 +#define IO_SLU_EXTENDED_ERR_PTR 0x00000048 +#define IO_SLU_COMMON_CONFIG 0x00000060 + +/* SLU: Flash FIR */ +#define IO_SLU_FLASH_FIR 0x00000108 + +/* SLU: SLC FIR (This section needs to be updated for A5) */ +#define IO_SLU_SLC_FIR 0x00000110 + +/* SLU: RIU Secondary Trap Register */ +#define IO_SLU_RIU_TRAP 0x00000280 + +/* SLU: Flash FEC */ +#define IO_SLU_FLASH_FEC 0x00000308 + +/* SLU: SLC secondary FEC */ +#define IO_SLU_SLC_FEC 0x00000310 + +#define W1CLR_OFFS 0x00400000 +#define W1SET_OFFS 0x00800000 + +/* +* The Virtual Function's Access is from offset 0x00010000 +* The Physical Function's Access is from offset 0x00050000 +* Single Shared Registers exists only at offset 0x00060000 +*/ + +/* +* SLC: Queue Virtual Window Window for accessing into a specific VF +* queue. When accessing the 0x10000 space using the 0x50000 address +* segment, the value indicated here is used to specify which VF +* register is decoded. This register, and the 0x50000 register space +* can only be accessed by the PF. Example, if this register is set to +* 0x2, then a read from 0x50000 is the same as a read from 0x10000 +* from VF=2. +*/ + +/* SLC: Queue Segment */ +#define IO_SLC_QUEUE_SEGMENT 0x00010000 +#define IO_SLC_VF_QUEUE_SEGMENT 0x00050000 + +/* SLC: Queue Offset */ +#define IO_SLC_QUEUE_OFFSET 0x00010008 +#define IO_SLC_VF_QUEUE_OFFSET 0x00050008 + +/* SLC: Queue Configuration */ +#define IO_SLC_QUEUE_CONFIG 0x00010010 +#define IO_SLC_VF_QUEUE_CONFIG 0x00050010 + +/* SLC: Job Timout/Only accessible for the PF */ +#define IO_SLC_APPJOB_TIMEOUT 0x00010018 +#define IO_SLC_VF_APPJOB_TIMEOUT 0x00050018 +#define TIMEOUT_250MS 0x0000000full +#define HEARTBEAT_DISABLE 0x0000ff00ull + +/* SLC: Queue InitSequence Register */ +#define IO_SLC_QUEUE_INITSQN 0x00010020 +#define IO_SLC_VF_QUEUE_INITSQN 0x00050020 + +/* SLC: Queue Wrap */ +#define IO_SLC_QUEUE_WRAP 0x00010028 +#define IO_SLC_VF_QUEUE_WRAP 0x00050028 + +/* SLC: Queue Status */ +#define IO_SLC_QUEUE_STATUS 0x00010100 +#define IO_SLC_VF_QUEUE_STATUS 0x00050100 + +/* SLC: Queue Working Time */ +#define IO_SLC_QUEUE_WTIME 0x00010030 +#define IO_SLC_VF_QUEUE_WTIME 0x00050030 + +/* SLC: Queue Error Counts */ +#define IO_SLC_QUEUE_ERRCNTS 0x00010038 +#define IO_SLC_VF_QUEUE_ERRCNTS 0x00050038 + +/* SLC: Queue Loast Response Word */ +#define IO_SLC_QUEUE_LRW 0x00010040 +#define IO_SLC_VF_QUEUE_LRW 0x00050040 + +/* SLC: Freerunning Timer */ +#define IO_SLC_FREE_RUNNING_TIMER 0x00010108 +#define IO_SLC_VF_FREE_RUNNING_TIMER 0x00050108 + +/* SLC: Queue Virtual Access Region */ +#define IO_PF_SLC_VIRTUAL_REGION 0x00050000 + +/* SLC: Queue Virtual Window */ +#define IO_PF_SLC_VIRTUAL_WINDOW 0x00060000 + +/* SLC: DDCB Application Job Pending [n] (n=0:63) */ +#define IO_PF_SLC_JOBPEND (n) (0x00061000 + 8*(n)) +#define IO_SLC_JOBPEND (n) IO_PF_SLC_JOBPEND(n) + +/* SLC: Parser Trap RAM [n] (n=0:31) */ +#define IO_SLU_SLC_PARSE_TRAP (n) (0x00011000 + 8*(n)) + +/* SLC: Dispatcher Trap RAM [n] (n=0:31) */ +#define IO_SLU_SLC_DISP_TRAP (n) (0x00011200 + 8*(n)) + +/* Global Fault Isolation Register (GFIR) */ +#define IO_SLC_CFGREG_GFIR 0x00020000 +#define GFIR_ERR_TRIGGER 0x000000000000ffffull + +/* SLU: Soft Reset Register */ +#define IO_SLC_CFGREG_SOFTRESET 0x00020018 + +/* SLU: Misc Debug Register */ +#define IO_SLC_MISC_DEBUG 0x00020060 +#define IO_SLC_MISC_DEBUG_CLR 0x00020068 +#define IO_SLC_MISC_DEBUG_SET 0x00020070 + +/* Temperature Sensor Reading */ +#define IO_SLU_TEMPERATURE_SENSOR 0x00030000 +#define IO_SLU_TEMPERATURE_CONFIG 0x00030008 + +/* Voltage Margining Control */ +#define IO_SLU_VOLTAGE_CONTROL 0x00030080 +#define VOLTAGE_NOMINAL 0x00000000ull +#define VOLTAGE_DOWN5 0x00000006ull +#define VOLTAGE_UP5 0x00000007ull + +/* Direct LED Control Register */ +#define IO_SLU_LEDCONTROL 0x00030100 + +/* SLU: Flashbus Direct Access -A5 */ +#define IO_SLU_FLASH_DIRECTACCESS 0x00040010 + +/* SLU: Flashbus Direct Access2 -A5 */ +#define IO_SLU_FLASH_DIRECTACCESS2 0x00040020 + +/* SLU: Flashbus Command Interface -A5 */ +#define IO_SLU_FLASH_CMDINTF 0x00040030 + +/* SLU: BitStream Loaded */ +#define IO_SLU_BITSTREAM 0x00040040 + +/* This Register has a switch which will change the CAs to UR */ +#define IO_HSU_ERR_BEHAVIOR 0x01001010 + +#define IO_SLC2_SQB_TRAP 0x00062000 +#define IO_SLC2_QUEUE_MANAGER_TRAP 0x00062008 +#define IO_SLC2_FLS_MASTER_TRAP 0x00062010 + +/* UnitID 1: HSU Registers */ +#define IO_HSU_UNITCFG 0x01000000 +#define IO_HSU_FIR 0x01000008 +#define IO_HSU_FIR_CLR 0x01000010 +#define IO_HSU_FEC 0x01000018 +#define IO_HSU_ERR_ACT_MASK 0x01000020 +#define IO_HSU_ERR_ATTN_MASK 0x01000028 +#define IO_HSU_FIRX1_ACT_MASK 0x01000030 +#define IO_HSU_FIRX0_ACT_MASK 0x01000038 +#define IO_HSU_SEC_LEM_DEBUG_OVR 0x01000040 +#define IO_HSU_EXTENDED_ERR_PTR 0x01000048 +#define IO_HSU_COMMON_CONFIG 0x01000060 + +/* UnitID 2: Application Unit (APP) */ +#define IO_APP_UNITCFG 0x02000000 +#define IO_APP_FIR 0x02000008 +#define IO_APP_FIR_CLR 0x02000010 +#define IO_APP_FEC 0x02000018 +#define IO_APP_ERR_ACT_MASK 0x02000020 +#define IO_APP_ERR_ATTN_MASK 0x02000028 +#define IO_APP_FIRX1_ACT_MASK 0x02000030 +#define IO_APP_FIRX0_ACT_MASK 0x02000038 +#define IO_APP_SEC_LEM_DEBUG_OVR 0x02000040 +#define IO_APP_EXTENDED_ERR_PTR 0x02000048 +#define IO_APP_COMMON_CONFIG 0x02000060 + +#define IO_APP_DEBUG_REG_01 0x02010000 +#define IO_APP_DEBUG_REG_02 0x02010008 +#define IO_APP_DEBUG_REG_03 0x02010010 +#define IO_APP_DEBUG_REG_04 0x02010018 +#define IO_APP_DEBUG_REG_05 0x02010020 +#define IO_APP_DEBUG_REG_06 0x02010028 +#define IO_APP_DEBUG_REG_07 0x02010030 +#define IO_APP_DEBUG_REG_08 0x02010038 +#define IO_APP_DEBUG_REG_09 0x02010040 +#define IO_APP_DEBUG_REG_10 0x02010048 +#define IO_APP_DEBUG_REG_11 0x02010050 +#define IO_APP_DEBUG_REG_12 0x02010058 +#define IO_APP_DEBUG_REG_13 0x02010060 +#define IO_APP_DEBUG_REG_14 0x02010068 +#define IO_APP_DEBUG_REG_15 0x02010070 +#define IO_APP_DEBUG_REG_16 0x02010078 +#define IO_APP_DEBUG_REG_17 0x02010080 +#define IO_APP_DEBUG_REG_18 0x02010088
include/linux/genwqe/genwqe_card.h line 286
Quoted 10 lines
include/linux/genwqe/genwqe_card.h new file +10
-0+ +/* Read/write from/to registers */ +struct regs_io { +uint32_t num;/* register offset/address */ +union { +uint64_t val64; +uint32_t val32; +uint16_t define; + }; +};
For all of your userspace structures, they need to use proper variable types. For a unsigned 32 bit number, that would be __u32. Please fix up all of your structures for that.
Also, have you properly audited the structures for 32bit user / 64bit kernel issues?
include/linux/genwqe/genwqe_card.h line 372
Quoted 4 lines
include/linux/genwqe/genwqe_card.h new file +4
-0+/* common struct for chip image exchange */ +struct chip_bitstream { +uint8_t __user *pdata;/* pointer to image data */ +int size;/* size of image file */
I think this fails the 32/64bit issue, right?
thanks,
greg k-h
Re: [PATCH 1/6] GenWQE PCI support, health monitoring and recovery
Hi Greg,
Am Mittwoch, den 27.11.2013, 11:16 -0800 schrieb Greg KH:
Quoted 39 lines · Frank Haverkamp
Quoted 38 lines
include/linux/genwqe/genwqe_card.h new file +35
-0@@ -0,0 +1,547 @@ +#ifndef __GENWQE_CARD_H__ +#define __GENWQE_CARD_H__ + +/** +* IBM Accelerator Family 'GenWQE' +* +* (C) Copyright IBM Corp. 2013 +* +* Author: Frank Haverkamp <[email protected]> +* Author: Joerg-Stephan Vogt <[email protected]> +* Author: Michael Jung <[email protected]> +* Author: Michael Ruettger <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License (version 2 only) +* 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. +*/ + +/* +* User-space API for the GenWQE card. For debugging and test purposes +* the register addresses are included here too. +*/ + +#ifdef __KERNEL__ +# include <linux/types.h> +# include <linux/ioctl.h> +#else +# include <stdint.h> +# include <asm/ioctl.h> +# include <stddef.h>
Quoted 8 lines
include/linux/genwqe/genwqe_card.h line 41
Quoted 6 lines
include/linux/genwqe/genwqe_card.h new file +6
-0+# include <string.h> +# +# ifndef __user +# define __user +# endif +#endif Ick, really?
Yes, looks ugly. I got rid of that.
Quoted 5 lines
Anyway, userspace .h files need to be in
include/uapi/, not ininclude/linux/, please split only the userspace side of this file out to that directory, the other bits that do not need to go to userspace can probably go back down in your local directory, right?
Sure. I moved the file over, found some constants/struct names with sub-optimal prefixes, and fixed those too.
Quoted 242 lines
Quoted 242 lines
include/linux/genwqe/genwqe_card.h new file +241
-0+ +/* Basename of sysfs, debugfs and /dev interfaces */ +#define GENWQE_DEVNAME "genwqe" + +#define GENWQE_TYPE_ALTERA_230 0x00/* GenWQE4 Stratix-IV-230 */ +#define GENWQE_TYPE_ALTERA_530 0x01/* GenWQE4 Stratix-IV-530 */ +#define GENWQE_TYPE_ALTERA_A4 0x02/* GenWQE5 A4 Stratix-V-A4 */ +#define GENWQE_TYPE_ALTERA_A7 0x03/* GenWQE5 A7 Stratix-V-A7 */ + +/* MMIO Unit offsets: Each UnitID occupies a defined address range */ +#define UID_OFFS (uid) ((uid) << 24) + +#define SLU_OFFS UID_OFFS(0) +#define HSU_OFFS UID_OFFS(1) +#define APP_OFFS UID_OFFS(2) +#define MEMC0_OFFS UID_OFFS(3) +#define MEMC1_OFFS UID_OFFS(4) +#define ETH0_OFFS UID_OFFS(5) +#define ETH1_OFFS UID_OFFS(6) +#define GENWQE_MAX_UNITS 3 + +/* Common offsets per UnitID */ +#define IO_EXTENDED_ERROR_POINTER 0x00000048 +#define IO_ERROR_INJECT_SELECTOR 0x00000060 +#define IO_EXTENDED_DIAG_SELECTOR 0x00000070 +#define IO_EXTENDED_DIAG_READ_MBX 0x00000078 +#define IO_EXTENDED_DIAG_MAP (ring) (0x00000500 | ((ring) << 3)) + +#define EXTENDED_DIAG_SELECTOR (ring, trace) (((ring) << 8) | (trace)) + +/* UnitID 0: Service Layer Unit (SLU) */ + +/* SLU: Unit Configuration Register */ +#define IO_SLU_UNITCFG 0x00000000 +#define SLU_UNITCFG_TYPE_MASK 0x000000000ff00000/* 27:20 */ + +/* SLU: Fault Isolation Register (FIR) (ac_slu_fir) */ +#define IO_SLU_FIR 0x00000008/* read only, wr direct */ +#define IO_SLU_FIR_CLR 0x00000010/* read and clear */ + +/* SLU: First Error Capture Register (FEC/WOF) */ +#define IO_SLU_FEC 0x00000018 + +#define IO_SLU_ERR_ACT_MASK 0x00000020 +#define IO_SLU_ERR_ATTN_MASK 0x00000028 +#define IO_SLU_FIRX1_ACT_MASK 0x00000030 +#define IO_SLU_FIRX0_ACT_MASK 0x00000038 +#define IO_SLU_SEC_LEM_DEBUG_OVR 0x00000040 +#define IO_SLU_EXTENDED_ERR_PTR 0x00000048 +#define IO_SLU_COMMON_CONFIG 0x00000060 + +/* SLU: Flash FIR */ +#define IO_SLU_FLASH_FIR 0x00000108 + +/* SLU: SLC FIR (This section needs to be updated for A5) */ +#define IO_SLU_SLC_FIR 0x00000110 + +/* SLU: RIU Secondary Trap Register */ +#define IO_SLU_RIU_TRAP 0x00000280 + +/* SLU: Flash FEC */ +#define IO_SLU_FLASH_FEC 0x00000308 + +/* SLU: SLC secondary FEC */ +#define IO_SLU_SLC_FEC 0x00000310 + +#define W1CLR_OFFS 0x00400000 +#define W1SET_OFFS 0x00800000 + +/* +* The Virtual Function's Access is from offset 0x00010000 +* The Physical Function's Access is from offset 0x00050000 +* Single Shared Registers exists only at offset 0x00060000 +*/ + +/* +* SLC: Queue Virtual Window Window for accessing into a specific VF +* queue. When accessing the 0x10000 space using the 0x50000 address +* segment, the value indicated here is used to specify which VF +* register is decoded. This register, and the 0x50000 register space +* can only be accessed by the PF. Example, if this register is set to +* 0x2, then a read from 0x50000 is the same as a read from 0x10000 +* from VF=2. +*/ + +/* SLC: Queue Segment */ +#define IO_SLC_QUEUE_SEGMENT 0x00010000 +#define IO_SLC_VF_QUEUE_SEGMENT 0x00050000 + +/* SLC: Queue Offset */ +#define IO_SLC_QUEUE_OFFSET 0x00010008 +#define IO_SLC_VF_QUEUE_OFFSET 0x00050008 + +/* SLC: Queue Configuration */ +#define IO_SLC_QUEUE_CONFIG 0x00010010 +#define IO_SLC_VF_QUEUE_CONFIG 0x00050010 + +/* SLC: Job Timout/Only accessible for the PF */ +#define IO_SLC_APPJOB_TIMEOUT 0x00010018 +#define IO_SLC_VF_APPJOB_TIMEOUT 0x00050018 +#define TIMEOUT_250MS 0x0000000full +#define HEARTBEAT_DISABLE 0x0000ff00ull + +/* SLC: Queue InitSequence Register */ +#define IO_SLC_QUEUE_INITSQN 0x00010020 +#define IO_SLC_VF_QUEUE_INITSQN 0x00050020 + +/* SLC: Queue Wrap */ +#define IO_SLC_QUEUE_WRAP 0x00010028 +#define IO_SLC_VF_QUEUE_WRAP 0x00050028 + +/* SLC: Queue Status */ +#define IO_SLC_QUEUE_STATUS 0x00010100 +#define IO_SLC_VF_QUEUE_STATUS 0x00050100 + +/* SLC: Queue Working Time */ +#define IO_SLC_QUEUE_WTIME 0x00010030 +#define IO_SLC_VF_QUEUE_WTIME 0x00050030 + +/* SLC: Queue Error Counts */ +#define IO_SLC_QUEUE_ERRCNTS 0x00010038 +#define IO_SLC_VF_QUEUE_ERRCNTS 0x00050038 + +/* SLC: Queue Loast Response Word */ +#define IO_SLC_QUEUE_LRW 0x00010040 +#define IO_SLC_VF_QUEUE_LRW 0x00050040 + +/* SLC: Freerunning Timer */ +#define IO_SLC_FREE_RUNNING_TIMER 0x00010108 +#define IO_SLC_VF_FREE_RUNNING_TIMER 0x00050108 + +/* SLC: Queue Virtual Access Region */ +#define IO_PF_SLC_VIRTUAL_REGION 0x00050000 + +/* SLC: Queue Virtual Window */ +#define IO_PF_SLC_VIRTUAL_WINDOW 0x00060000 + +/* SLC: DDCB Application Job Pending [n] (n=0:63) */ +#define IO_PF_SLC_JOBPEND (n) (0x00061000 + 8*(n)) +#define IO_SLC_JOBPEND (n) IO_PF_SLC_JOBPEND(n) + +/* SLC: Parser Trap RAM [n] (n=0:31) */ +#define IO_SLU_SLC_PARSE_TRAP (n) (0x00011000 + 8*(n)) + +/* SLC: Dispatcher Trap RAM [n] (n=0:31) */ +#define IO_SLU_SLC_DISP_TRAP (n) (0x00011200 + 8*(n)) + +/* Global Fault Isolation Register (GFIR) */ +#define IO_SLC_CFGREG_GFIR 0x00020000 +#define GFIR_ERR_TRIGGER 0x000000000000ffffull + +/* SLU: Soft Reset Register */ +#define IO_SLC_CFGREG_SOFTRESET 0x00020018 + +/* SLU: Misc Debug Register */ +#define IO_SLC_MISC_DEBUG 0x00020060 +#define IO_SLC_MISC_DEBUG_CLR 0x00020068 +#define IO_SLC_MISC_DEBUG_SET 0x00020070 + +/* Temperature Sensor Reading */ +#define IO_SLU_TEMPERATURE_SENSOR 0x00030000 +#define IO_SLU_TEMPERATURE_CONFIG 0x00030008 + +/* Voltage Margining Control */ +#define IO_SLU_VOLTAGE_CONTROL 0x00030080 +#define VOLTAGE_NOMINAL 0x00000000ull +#define VOLTAGE_DOWN5 0x00000006ull +#define VOLTAGE_UP5 0x00000007ull + +/* Direct LED Control Register */ +#define IO_SLU_LEDCONTROL 0x00030100 + +/* SLU: Flashbus Direct Access -A5 */ +#define IO_SLU_FLASH_DIRECTACCESS 0x00040010 + +/* SLU: Flashbus Direct Access2 -A5 */ +#define IO_SLU_FLASH_DIRECTACCESS2 0x00040020 + +/* SLU: Flashbus Command Interface -A5 */ +#define IO_SLU_FLASH_CMDINTF 0x00040030 + +/* SLU: BitStream Loaded */ +#define IO_SLU_BITSTREAM 0x00040040 + +/* This Register has a switch which will change the CAs to UR */ +#define IO_HSU_ERR_BEHAVIOR 0x01001010 + +#define IO_SLC2_SQB_TRAP 0x00062000 +#define IO_SLC2_QUEUE_MANAGER_TRAP 0x00062008 +#define IO_SLC2_FLS_MASTER_TRAP 0x00062010 + +/* UnitID 1: HSU Registers */ +#define IO_HSU_UNITCFG 0x01000000 +#define IO_HSU_FIR 0x01000008 +#define IO_HSU_FIR_CLR 0x01000010 +#define IO_HSU_FEC 0x01000018 +#define IO_HSU_ERR_ACT_MASK 0x01000020 +#define IO_HSU_ERR_ATTN_MASK 0x01000028 +#define IO_HSU_FIRX1_ACT_MASK 0x01000030 +#define IO_HSU_FIRX0_ACT_MASK 0x01000038 +#define IO_HSU_SEC_LEM_DEBUG_OVR 0x01000040 +#define IO_HSU_EXTENDED_ERR_PTR 0x01000048 +#define IO_HSU_COMMON_CONFIG 0x01000060 + +/* UnitID 2: Application Unit (APP) */ +#define IO_APP_UNITCFG 0x02000000 +#define IO_APP_FIR 0x02000008 +#define IO_APP_FIR_CLR 0x02000010 +#define IO_APP_FEC 0x02000018 +#define IO_APP_ERR_ACT_MASK 0x02000020 +#define IO_APP_ERR_ATTN_MASK 0x02000028 +#define IO_APP_FIRX1_ACT_MASK 0x02000030 +#define IO_APP_FIRX0_ACT_MASK 0x02000038 +#define IO_APP_SEC_LEM_DEBUG_OVR 0x02000040 +#define IO_APP_EXTENDED_ERR_PTR 0x02000048 +#define IO_APP_COMMON_CONFIG 0x02000060 + +#define IO_APP_DEBUG_REG_01 0x02010000 +#define IO_APP_DEBUG_REG_02 0x02010008 +#define IO_APP_DEBUG_REG_03 0x02010010 +#define IO_APP_DEBUG_REG_04 0x02010018 +#define IO_APP_DEBUG_REG_05 0x02010020 +#define IO_APP_DEBUG_REG_06 0x02010028 +#define IO_APP_DEBUG_REG_07 0x02010030 +#define IO_APP_DEBUG_REG_08 0x02010038 +#define IO_APP_DEBUG_REG_09 0x02010040 +#define IO_APP_DEBUG_REG_10 0x02010048 +#define IO_APP_DEBUG_REG_11 0x02010050 +#define IO_APP_DEBUG_REG_12 0x02010058 +#define IO_APP_DEBUG_REG_13 0x02010060 +#define IO_APP_DEBUG_REG_14 0x02010068 +#define IO_APP_DEBUG_REG_15 0x02010070 +#define IO_APP_DEBUG_REG_16 0x02010078 +#define IO_APP_DEBUG_REG_17 0x02010080 +#define IO_APP_DEBUG_REG_18 0x02010088 + +/* Read/write from/to registers */ +struct regs_io { +uint32_t num;/* register offset/address */ +union { +uint64_t val64;
Quoted 8 lines
include/linux/genwqe/genwqe_card.h line 286
Quoted 4 lines
include/linux/genwqe/genwqe_card.h new file +4
-0+uint32_t val32; +uint16_t define; + }; +};For all of your userspace structures, they need to use proper variable types. For a unsigned 32 bit number, that would be
__u32. Please fix up all of your structures for that.
Fixed them.
Quoted 3 lines
Also, have you properly audited the structures for 32bit user / 64bit kernel issues?
As you point out below, I failed doing so ;-).
Quoted 7 lines
include/linux/genwqe/genwqe_card.h line 372
Quoted 5 lines
include/linux/genwqe/genwqe_card.h new file +4
-0+/* common struct for chip image exchange */ +struct chip_bitstream { +uint8_t __user *pdata;/* pointer to image data */ +int size;/* size of image file */ I think this fails the 32/64bit issue, right?
Yes. I replaced those by something like
__u32 data_addr;
I hope that is fixing the 32/64bit issue.
Quoted 4 lines
thanks,
greg k-h
Thanks
Frank
Greg KH
maintainerRe: [PATCH 1/6] GenWQE PCI support, health monitoring and recovery
Quoted 10 lines · Frank Haverkamp
Quoted 6 lines
include/linux/genwqe/genwqe_card.h line 372
Quoted 4 lines
include/linux/genwqe/genwqe_card.h new file +4
-0+/* common struct for chip image exchange */ +struct chip_bitstream { +uint8_t __user *pdata;/* pointer to image data */ +int size;/* size of image file */ I think this fails the 32/64bit issue, right?
Yes. I replaced those by something like
__u32data_addr;
I hope that is fixing the 32/64bit issue.
No, not at all, how are you going to put a 64bit userspace pointer in there?
Re: [PATCH 1/6] GenWQE PCI support, health monitoring and recovery
Am Dienstag, den 03.12.2013, 06:30 -0800 schrieb Greg KH:
Quoted 8 lines · Frank Haverkamp
Quoted 7 lines
Quoted 6 lines
include/linux/genwqe/genwqe_card.h line 372
Quoted 4 lines
include/linux/genwqe/genwqe_card.h new file +4
-0+/* common struct for chip image exchange */ +struct chip_bitstream { +uint8_t __user *pdata;/* pointer to image data */ +int size;/* size of image file */ I think this fails the 32/64bit issue, right?
Quoted 7 lines
Quoted 3 lines
Yes. I replaced those by something like
__u32data_addr;
I hope that is fixing the 32/64bit issue.No, not at all, how are you going to put a 64bit userspace pointer in there?
Ohh, sorry __u64 of course:
/* common struct for chip image exchange */
struct genwqe_bitstream {
__u64 data_addr; /* pointer to image data */
__u32 size; /* size of image file */
__u32 crc; /* crc of this image */
__u8 partition; /* '0', '1', or 'v' */
__u64 target_addr; /* starting address in Flash */
__u8 uid; /* 1=host/x=dram */ __u64 slu_id; /* informational/sim: SluID */
__u64 app_id; /* informational/sim: AppID */
__u16 retc; /* returned from processing */
__u16 attn; /* attention code from
processing */
__u32 progress; /* progress code from processing
*/
};
and than I do in my userspace application:
load.data_addr = (unsigned long)buf;
Is that ok, or must I consider more?
Regards
Frank
Arnd Bergmann
maintainerRe: [PATCH 1/6] GenWQE PCI support, health monitoring and recovery
Quoted 21 lines · Frank Haverkamp
Ohh, sorry
__u64of course:/* common struct for chip image exchange */
structgenwqe_bitstream{__u64 data_addr; /* pointer to image data */ __u32 size; /* size of image file */ __u32 crc; /* crc of this image */ __u8 partition; /* '0', '1', or 'v' */ __u64 target_addr; /* starting address in Flash */ __u8 uid; /* 1=host/x=dram */
__u64slu_id; /* informational/sim: SluID */
__u64app_id; /* informational/sim: AppID */
__u16retc; /* returned from processing */
__u16attn; /* attention code from
processing */
__u32progress; /* progress code from processing
*/
};
Quoted 6 lines
and than I do in my userspace application:
load.data_addr = (unsigned long)buf;Is that ok, or must I consider more?
I haven't followed the recent discussions, jumping into the middle here:
The structure above is not safe for a generic ioctl interface because it has different padding on x86-32 and x86-64, where __u64 has different alignment.
You can try to avoid the implicit padding by sorting the members by size, by making some members larger or by adding explicit padding.
Arnd
Re: [PATCH 1/6] GenWQE PCI support, health monitoring and recovery
Hi Arnd,
thanks for helping to review the code.
Am Dienstag, den 03.12.2013, 16:05 +0100 schrieb Arnd Bergmann:
Quoted 34 lines · Frank Haverkamp
Quoted 21 lines
Ohh, sorry
__u64of course:/* common struct for chip image exchange */
structgenwqe_bitstream{__u64 data_addr; /* pointer to image data */ __u32 size; /* size of image file */ __u32 crc; /* crc of this image */ __u8 partition; /* '0', '1', or 'v' */ __u64 target_addr; /* starting address in Flash */ __u8 uid; /* 1=host/x=dram */
__u64slu_id; /* informational/sim: SluID */
__u64app_id; /* informational/sim: AppID */
__u16retc; /* returned from processing */
__u16attn; /* attention code from
processing */
__u32progress; /* progress code from processing
*/
};Quoted 6 lines
and than I do in my userspace application:
load.data_addr = (unsigned long)buf;Is that ok, or must I consider more?
I haven't followed the recent discussions, jumping into the middle here:
The structure above is not safe for a generic ioctl interface because it has different padding on x86-32 and x86-64, where__u64has different alignment.
Quoted 5 lines
You can try to avoid the implicit padding by sorting the members by size,
by making some lignments for 32-bit and 64-bit. I avoid umembers larger or by adding explicit padding.Arnd
Ok, let me try to sort my entries a little differently and modify some sizes, to avoid different alignments for 32-bit and 64-bit. I avoid using __u8 now such that I always have nice 64-bit blocks. Would the following version work?
struct genwqe_bitstream {
__u64 data_addr; /* pointer to image data */
__u32 size; /* size of image file */
__u32 crc; /* crc of this image */
__u64 target_addr; /* starting address in Flash */
__u32 partition; /* '0', '1', or 'v' */
__u32 uid; /* 1=host/x=dram */
__u64 slu_id; /* informational/sim: SluID */
__u64 app_id; /* informational/sim: AppID */
__u16 retc; /* returned from processing */
__u16 attn; /* attention code from processing */
__u32 progress; /* progress code from processing */
};If not, I might have missed something, and I would appreciate if you could make up an example how a good version should look like.
Thanks
Frank
Greg KH
maintainerRe: [PATCH 1/6] GenWQE PCI support, health monitoring and recovery
In reply to Frank HaverkampQuoted 6 lines · Frank Haverkamp
drivers/misc/genwqe/card_base.h new file +6
-0+/* +* Flags for extended output (dbg_print) +* We define different levels of debugging for the appropriate unit. +*/ +#define dbg_card 0x00000001 +#define dbg_card_ddcb 0x00000004
drivers/misc/genwqe/card_base.h line 93
Quoted 10 lines
drivers/misc/genwqe/card_base.h new file +10
-0+#define dbg_card_regs 0x00000008 +#define dbg_card_sglist 0x00000400 +#define dbg_card_pinning 0x00000800 + +#define genwqe_dprintk (_cd, dbg_unit, fmt, ...) do { \ + struct genwqe_dev *__cd = (_cd); \ + if ((_cd)->debug & (dbg_unit)) \ + dev_info(&__cd->pci_dev->dev, fmt, \ + ## __VA_ARGS__); \ + } while (0)
Ugh, really? How is a debugging printk being sent out with dev_info()?
And why not just use dynamic kernel debugging and not create your own masks and macros? We are trying to make everything use the same infrastructure, please don't create new ones for every individual driver in the kernel, that's a mess.
thanks,
greg k-h
Re: [PATCH 1/6] GenWQE PCI support, health monitoring and recovery
Hi Greg,
Am Mittwoch, den 27.11.2013, 11:20 -0800 schrieb Greg KH:
Quoted 20 lines · Frank Haverkamp
Quoted 6 lines
drivers/misc/genwqe/card_base.h new file +6
-0+/* +* Flags for extended output (dbg_print) +* We define different levels of debugging for the appropriate unit. +*/ +#define dbg_card 0x00000001 +#define dbg_card_ddcb 0x00000004drivers/misc/genwqe/card_base.h line 93
Quoted 10 lines
drivers/misc/genwqe/card_base.h new file +10
-0+#define dbg_card_regs 0x00000008 +#define dbg_card_sglist 0x00000400 +#define dbg_card_pinning 0x00000800 + +#define genwqe_dprintk (_cd, dbg_unit, fmt, ...) do { \ + struct genwqe_dev *__cd = (_cd); \ + if ((_cd)->debug & (dbg_unit)) \ + dev_info(&__cd->pci_dev->dev, fmt, \ + ## __VA_ARGS__); \ + } while (0)Ugh, really? How is a debugging printk being sent out with
dev_info()?
Quoted 4 lines
And why not just use dynamic kernel debugging and not create your own masks and macros? We are trying to make everything use the same infrastructure, please don't create new ones for every individual driver in the kernel, that's a mess.
I removed the genwqe_dprintk function completely. Our debug flag I kept for the moment, because I like to use the kernel hexdump functions to print my control blocks for debugging:
if (cd->debug & dbg_card_ddcb) {
dev_dbg(&pci_dev->dev, "FINISHED DDCB#%d\n", req->num);
genwqe_hexdump(pci_dev, pddcb, sizeof(*pddcb));
}Or is there something allowing me to do those hexdumps with the dynamic_debug feature too? dynamic_hex_dump() looks like what I want. So let me try to use that and get rid of my own debug support.
Quoted 5 lines
thanks,
greg k-h
Regards
Frank
Greg KH
maintainerRe: [PATCH 1/6] GenWQE PCI support, health monitoring and recovery
Quoted 32 lines · Frank Haverkamp
Hi Greg,
Am Mittwoch, den 27.11.2013, 11:20 -0800 schrieb Greg KH:
Quoted 20 lines · Frank Haverkamp
Quoted 6 lines
drivers/misc/genwqe/card_base.h new file +6
-0+/* +* Flags for extended output (dbg_print) +* We define different levels of debugging for the appropriate unit. +*/ +#define dbg_card 0x00000001 +#define dbg_card_ddcb 0x00000004drivers/misc/genwqe/card_base.h line 93
Quoted 10 lines
drivers/misc/genwqe/card_base.h new file +10
-0+#define dbg_card_regs 0x00000008 +#define dbg_card_sglist 0x00000400 +#define dbg_card_pinning 0x00000800 + +#define genwqe_dprintk (_cd, dbg_unit, fmt, ...) do { \ + struct genwqe_dev *__cd = (_cd); \ + if ((_cd)->debug & (dbg_unit)) \ + dev_info(&__cd->pci_dev->dev, fmt, \ + ## __VA_ARGS__); \ + } while (0)Ugh, really? How is a debugging printk being sent out with
dev_info()?Quoted 4 lines
And why not just use dynamic kernel debugging and not create your own masks and macros? We are trying to make everything use the same infrastructure, please don't create new ones for every individual driver in the kernel, that's a mess.
I removed the
genwqe_dprintkfunction completely. Our debug flag I kept for the moment, because I like to use the kernel hexdump functions to print my control blocks for debugging:
Quoted 7 lines
if (cd->debug & dbg_card_ddcb) { dev_dbg(&pci_dev->dev, "FINISHED DDCB#%d\n", req->num); genwqe_hexdump(pci_dev, pddcb, sizeof(*pddcb)); }Or is there something allowing me to do those hexdumps with the
dynamic_debugfeature too?dynamic_hex_dump()looks like what I want.
Yes, that is what to use.
PATCH 2/6 GenWQE Character device and DDCB queue
In reply to Frank HaverkampThe GenWQE card itself provides access to a generic work queue into which the work can be put, which should be executed, e.g. compression or decompression request, or whatever the card was configured to do.
Each request comes with a set of input data (ASV) and will produce some output data (ASIV). The request will also contain a sequence number, some timestamps and a command code/subcode plus some fields for hardware-/ software-interaction.
A request can contain references to blocks of memory. Since the card requires DMA-addresses of that memory, the driver provides two ways to solve that task:
1) The drivers mmap() will allocate some DMAable memory for the user. The driver has a lookup table such that the virtual userspace address can properly be replaced and checked.
2) The user allocates memory and the driver will pin/unpin that memory and setup a scatter gatherlist with matching DMA addresses.
Currently work requests are synchronous.
Co-authors: Joerg-Stephan Vogt <[email protected]>,
Michael Jung <[email protected]>, Michael Ruettger <[email protected]>
--- drivers/misc/genwqe/card_ddcb.c | 1380 +++++++++++++++++++++++++++++++++++ drivers/misc/genwqe/card_ddcb.h | 188 +++++ drivers/misc/genwqe/card_dev.c | 1499 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 3067 insertions(+), 0 deletions(-) create mode 100644 drivers/misc/genwqe/card_ddcb.c create mode 100644 drivers/misc/genwqe/card_ddcb.h create mode 100644 drivers/misc/genwqe/card_dev.c
drivers/misc/genwqe/card_ddcb.c new file +1380 -0
@@ -0,0 +1,1380 @@ +/** +* IBM Accelerator Family 'GenWQE' +* +* (C) Copyright IBM Corp. 2013 +* +* Author: Frank Haverkamp <[email protected]> +* Author: Joerg-Stephan Vogt <[email protected]> +* Author: Michael Jung <[email protected]> +* Author: Michael Ruettger <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License (version 2 only) +* 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. +*/ + +/* +* Device Driver Control Block (DDCB) queue support. Definition of +* interrupt handlers for queue support as well as triggering the +* health monitor code in case of problems. The current hardware uses +* an MSI interrupt which is shared between error handling and +* functional code. +*/ + +#include <linux/types.h> +#include <linux/module.h> +#include <linux/sched.h> +#include <linux/wait.h> +#include <linux/pci.h> +#include <linux/string.h> +#include <linux/dma-mapping.h> +#include <linux/delay.h> +#include <linux/module.h> +#include <linux/interrupt.h> +#include <linux/crc-itu-t.h> + +#include "card_ddcb.h" + +/* +* N: next DDCB, this is where the next DDCB will be put. +* A: active DDCB, this is where the code will look for the next completion. +* x: DDCB is enqueued, we are waiting for its completion. + +* Situation (1): Empty queue +* +---+---+---+---+---+---+---+---+ +* | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | +* | | | | | | | | | +* +---+---+---+---+---+---+---+---+ +* A/N +* enqueued_ddcbs = A - N = 2 - 2 = 0 +* +* Situation (2): Wrapped, N > A +* +---+---+---+---+---+---+---+---+ +* | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | +* | | | x | x | | | | | +* +---+---+---+---+---+---+---+---+ +* A N +* enqueued_ddcbs = N - A = 4 - 2 = 2 +* +* Situation (3): Queue wrapped, A > N +* +---+---+---+---+---+---+---+---+ +* | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | +* | x | x | | | x | x | x | x | +* +---+---+---+---+---+---+---+---+ +* N A +* enqueued_ddcbs = queue_max - (A - N) = 8 - (4 - 2) = 6 +* +* Situation (4a): Queue full N > A +* +---+---+---+---+---+---+---+---+ +* | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | +* | x | x | x | x | x | x | x | | +* +---+---+---+---+---+---+---+---+ +* A N +* +* enqueued_ddcbs = N - A = 7 - 0 = 7 +* +* Situation (4a): Queue full A > N +* +---+---+---+---+---+---+---+---+ +* | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | +* | x | x | x | | x | x | x | x | +* +---+---+---+---+---+---+---+---+ +* N A +* enqueued_ddcbs = queue_max - (A - N) = 8 - (4 - 3) = 7 +*/ + +static int queue_empty (struct ddcb_queue *queue) +{ +return (queue->ddcb_next == queue->ddcb_act); +} + +static int queue_enqueued_ddcbs (struct ddcb_queue *queue) +{ +if (queue->ddcb_next >= queue->ddcb_act) +return queue->ddcb_next - queue->ddcb_act; + +return queue->ddcb_max - (queue->ddcb_act - queue->ddcb_next); +} + +static int queue_free_ddcbs (struct ddcb_queue *queue) +{ +int free_ddcbs = queue->ddcb_max -queue_enqueued_ddcbs (queue) -1 ; + +if (WARN_ON_ONCE (free_ddcbs <0 )) {/* must never ever happen! */ +return 0 ; + } +return free_ddcbs; +} + +/* +* Use of the PRIV field in the DDCB for queue debugging: +* +* (1) Trying to get rid of a DDCB which saw a timeout: +* pddcb->priv[6] = 0xcc; # cleared +* +* (2) Append a DDCB via NEXT bit: +* pddcb->priv[7] = 0xaa; # appended +* +* (3) DDCB needed tapping: +* pddcb->priv[7] = 0xbb; # tapped +* +* (4) DDCB marked as correctly finished: +* pddcb->priv[6] = 0xff; # finished +*/ + +static inline void ddcb_mark_tapped (struct ddcb *pddcb) +{ + pddcb->priv[7 ] =0xbb ;/* tapped */ +} + +static inline void ddcb_mark_appended (struct ddcb *pddcb) +{ + pddcb->priv[7 ] =0xaa ;/* appended */ +} + +static inline void ddcb_mark_cleared (struct ddcb *pddcb) +{ + pddcb->priv[6 ] =0xcc ;/* cleared */ +} + +static inline void ddcb_mark_finished (struct ddcb *pddcb) +{ + pddcb->priv[6 ] =0xff ;/* finished */ +} + +static inline void ddcb_mark_unused (struct ddcb *pddcb) +{ + pddcb->priv_64 =cpu_to_be64 (0 );/* not tapped */ +} + +/** +* genwqe_crc16() - Generate 16-bit crc as required for DDCBs +* @buff: pointer to data buffer +* @len: length of data for calculation +* @init: initial crc (0xffff at start) +* +* Polynomial = x^16 + x^12 + x^5 + 1 (0x1021) +* Example: 4 bytes 0x01 0x02 0x03 0x04 with init = 0xffff +* should result in a crc16 of 0x89c3 +* +* Return: crc16 checksum in big endian format ! +*/ +static inline u16 genwqe_crc16 (const u8 *buff,size_t len,u16 init) +{ +return crc_itu_t (init, buff, len); +} + +static void print_ddcb_info (struct genwqe_dev *cd,struct ddcb_queue *queue) +{ +int i; +struct ddcb *pddcb; +unsigned long flags; +struct pci_dev *pci_dev = cd->pci_dev; + +spin_lock_irqsave (&cd->print_lock, flags); + +dev_info (&pci_dev->dev, +"DDCB list for card #%d (ddcb_act=%d / ddcb_next=%d):\n" , + cd->card_idx, queue->ddcb_act, queue->ddcb_next); + + pddcb = queue->ddcb_vaddr; +for (i =0 ; i < queue->ddcb_max; i++) { +dev_err (&pci_dev->dev, +" %c %-3d: RETC=%03x SEQ=%04x " +"HSI=%02X SHI=%02x PRIV=%06llx CMD=%03x\n" , + i == queue->ddcb_act ?'>' :' ' , + i, +be16_to_cpu (pddcb->retc_16), +be16_to_cpu (pddcb->seqnum_16), + pddcb->hsi, + pddcb->shi, +be64_to_cpu (pddcb->priv_64), + pddcb->cmd); + pddcb++; + } +spin_unlock_irqrestore (&cd->print_lock, flags); +} + +struct genwqe_ddcb_cmd *ddcb_requ_alloc (void ) +{ +struct ddcb_requ *req; + + req =kzalloc (sizeof (*req),GFP_ATOMIC ); +if (!req) +return NULL ; + +return &req->cmd; +} + +void ddcb_requ_free (struct genwqe_ddcb_cmd *cmd) +{ + struct ddcb_requ *req = container_of(cmd, struct ddcb_requ, cmd); +kfree (req); +} + +static inline enum genwqe_requ_state ddcb_requ_get_state (struct ddcb_requ *req) +{ +return req->req_state; +} + +static inline void ddcb_requ_set_state (struct ddcb_requ *req, +enum genwqe_requ_state new_state) +{ + req->req_state = new_state; +} + +static inline int ddcb_requ_collect_debug_data (struct ddcb_requ *req) +{ +return (req->cmd.debug_data !=NULL ); +} + +/** +* ddcb_requ_finished() - Returns the hardware state of the associated DDCB +* @cd: pointer to genwqe device descriptor +* @req: DDCB work request +* +* Status of ddcb_requ mirrors this hardware state, but is copied in +* the ddcb_requ on interrupt/polling function. The lowlevel code +* should check the hardware state directly, the higher level code +* should check the copy. +* +* This function will also return true if the state of the queue is +* not GENWQE_CARD_USED. This enables us to purge all DDCBs in the +* shutdown case. +*/ +static int ddcb_requ_finished (struct genwqe_dev *cd,struct ddcb_requ *req) +{ +return ((ddcb_requ_get_state (req) ==GENWQE_REQU_FINISHED ) || + (cd->card_state !=GENWQE_CARD_USED )); +} + +/** +* enqueue_ddcb() - Enqueue a DDCB +* @cd: pointer to genwqe device descriptor +* @queue: queue this operation should be done on +* @ddcb_no: pointer to ddcb number being tapped +* +* Start execution of DDCB by tapping or append to queue via NEXT +* bit. This is done by an atomic 'compare and swap' instruction and +* checking SHI and HSI of the previous DDCB. +* +* This function must only be called with ddcb_lock held. +* +* Return: 1 if new DDCB is appended to previous +* 2 if DDCB queue is tapped via register/simulation +*/ +#define RET_DDCB_APPENDED 1 +#define RET_DDCB_TAPPED 2 + +static int enqueue_ddcb (struct genwqe_dev *cd,struct ddcb_queue *queue, +struct ddcb *pddcb,int ddcb_no) +{ +unsigned int try; +int prev_no; +struct ddcb *prev_ddcb; +u32 old, new, icrc_hsi_shi; +u64 num; + +/* +* For performance checks a Dispatch Timestamp can be put into +* DDCB It is supposed to use the SLU's free running counter, +* but this requires PCIe cycles. +*/ +ddcb_mark_unused (pddcb); + +/* check previous DDCB if already fetched */ + prev_no = (ddcb_no ==0 ) ? queue->ddcb_max -1 : ddcb_no -1 ; + prev_ddcb = &queue->ddcb_vaddr[prev_no]; + +/* +* It might have happened that the HSI.FETCHED bit is +* set. Retry in this case. Therefore I expect maximum 2 times +* trying. +*/ +ddcb_mark_appended (pddcb); +for (try =0 ; try <2 ; try++) { + old = prev_ddcb->icrc_hsi_shi_32;/* read SHI/HSI in BE32 */ + +/* try to append via NEXT bit if prev DDCB is not completed */ +if ((old &DDCB_COMPLETED_BE32 ) !=0x00000000 ) +break ; + + new = (old |DDCB_NEXT_BE32 ); + icrc_hsi_shi =cmpxchg (&prev_ddcb->icrc_hsi_shi_32, old, new); + +if (icrc_hsi_shi == old) +return RET_DDCB_APPENDED ;/* appended to queue */ + } + +/* Queue must be re-started by updating QUEUE_OFFSET */ +ddcb_mark_tapped (pddcb); + num = (u64 )ddcb_no <<8 ; +__genwqe_writeq (cd, queue->IO_QUEUE_OFFSET, num);/* start queue */ + +return RET_DDCB_TAPPED ; +} + +/** +* copy_ddcb_results() - Copy output state from real DDCB to request +* +* Copy DDCB ASV to request struct. There is no endian +* conversion made, since data structure in ASV is still +* unknown here. +* +* This is needed by: +* - genwqe_purge_ddcb() +* - genwqe_check_ddcb_queue() +*/ +static void copy_ddcb_results (struct ddcb_requ *req,int ddcb_no) +{ +struct ddcb_queue *queue = req->queue; +struct ddcb *pddcb = &queue->ddcb_vaddr[req->num]; + +memcpy (&req->cmd.asv[0 ], &pddcb->asv[0 ],DDCB_ASV_LENGTH ); + +/* copy status flags of the variant part */ + req->cmd.vcrc =be16_to_cpu (pddcb->vcrc_16); + req->cmd.deque_ts =be64_to_cpu (pddcb->deque_ts_64); + req->cmd.cmplt_ts =be64_to_cpu (pddcb->cmplt_ts_64); + + req->cmd.attn =be16_to_cpu (pddcb->attn_16); + req->cmd.progress =be32_to_cpu (pddcb->progress_32); + req->cmd.retc =be16_to_cpu (pddcb->retc_16); + +if (ddcb_requ_collect_debug_data (req)) { +int prev_no = (ddcb_no ==0 ) ? + queue->ddcb_max -1 : ddcb_no -1 ; +struct ddcb *prev_pddcb = &queue->ddcb_vaddr[prev_no]; + +memcpy (&req->debug_data.ddcb_finished, pddcb, +sizeof (req->debug_data.ddcb_finished)); +memcpy (&req->debug_data.ddcb_prev, prev_pddcb, +sizeof (req->debug_data.ddcb_prev)); + } +} + +/** +* genwqe_check_ddcb_queue() - Checks DDCB queue for completed work equests. +* @cd: pointer to genwqe device descriptor +* +* Return: Number of DDCBs which were finished +*/ +static int genwqe_check_ddcb_queue (struct genwqe_dev *cd, +struct ddcb_queue *queue) +{ +unsigned long flags; +int ddcbs_finished =0 ; +struct pci_dev *pci_dev = cd->pci_dev; + +spin_lock_irqsave (&queue->ddcb_lock, flags); + +/* FIXME avoid soft locking CPU */ +while (!queue_empty (queue) && (ddcbs_finished < queue->ddcb_max)) { + +struct ddcb *pddcb; +struct ddcb_requ *req; +u16 vcrc, vcrc_16, retc_16; + + pddcb = &queue->ddcb_vaddr[queue->ddcb_act]; + +if ((pddcb->icrc_hsi_shi_32 &DDCB_COMPLETED_BE32 ) == +0x00000000 ) + goto go_home;/* not completed, continue waiting */ + +/* Note: DDCB could be purged */ + + req = queue->ddcb_req[queue->ddcb_act]; +if (req ==NULL ) { +/* this occurs if DDCB is purged, not an error */ +/* Move active DDCB further; Nothing to do anymore. */ + goto pick_next_one; + } + +/* +* HSI=0x44 (fetched and completed), but RETC is +* 0x101, or even worse 0x000. +* +* In case of seeing the queue in inconsistent state +* we read the errcnts and the queue status to provide +* a trigger for our PCIe analyzer stop capturing. +*/ + retc_16 =be16_to_cpu (pddcb->retc_16); +if ((pddcb->hsi ==0x44 ) && (retc_16 <=0x101 )) { +u64 errcnts, status; +u64 ddcb_offs = (u64 )pddcb - (u64 )queue->ddcb_vaddr; + + errcnts =__genwqe_readq (cd, queue->IO_QUEUE_ERRCNTS); + status =__genwqe_readq (cd, queue->IO_QUEUE_STATUS); + +dev_err (&pci_dev->dev, +"[%s] SEQN=%04x HSI=%02x RETC=%03x " +" Q_ERRCNTS=%016llx Q_STATUS=%016llx\n" +" DDCB_DMA_ADDR=%016llx\n" , + __func__,be16_to_cpu (pddcb->seqnum_16), + pddcb->hsi, retc_16, errcnts, status, + queue->ddcb_daddr + ddcb_offs); + } + +copy_ddcb_results (req, queue->ddcb_act); + queue->ddcb_req[queue->ddcb_act] =NULL ;/* take from queue */ + +if (cd->debug & dbg_card_ddcb) { +genwqe_dprintk (cd, dbg_card_ddcb,"FINISHED DDCB#%d\n" , + req->num); +genwqe_hexdump (pci_dev, pddcb,sizeof (*pddcb)); + } + +ddcb_mark_finished (pddcb); + +/* calculate CRC_16 to see if VCRC is correct */ + vcrc =genwqe_crc16 (pddcb->asv, +VCRC_LENGTH (req->cmd.asv_length), +0xffff ); + vcrc_16 =be16_to_cpu (pddcb->vcrc_16); +if (vcrc != vcrc_16) { +printk_ratelimited (KERN_ERR +"%s %s: err: wrong VCRC pre=%02x vcrc_len=%d " +"bytes vcrc_data=%04x is not vcrc_card=%04x\n" , +GENWQE_DEVNAME ,dev_name (&pci_dev->dev), + pddcb->pre,VCRC_LENGTH (req->cmd.asv_length), + vcrc, vcrc_16); + } + +ddcb_requ_set_state (req,GENWQE_REQU_FINISHED ); + queue->ddcbs_completed++; + queue->ddcbs_in_flight--; + +/* wake up process waiting for this DDCB */ +wake_up_interruptible (&queue->ddcb_waitqs[queue->ddcb_act]); + +pick_next_one: + queue->ddcb_act = (queue->ddcb_act +1 ) % queue->ddcb_max; + ddcbs_finished++; + } + + go_home: +spin_unlock_irqrestore (&queue->ddcb_lock, flags); +return ddcbs_finished; +} + +/** +* __genwqe_wait_ddcb(): Waits until DDCB is completed +* @cd: pointer to genwqe device descriptor +* @req: pointer to requsted DDCB parameters +* +* The Service Layer will update the RETC in DDCB when processing is +* pending or done. +* +* Return: > 0 remaining jiffies, DDCB completed +* -ETIMEDOUT when timeout +* -ERESTARTSYS when ^C +* -EINVAL when unknown error condition +* +* When an error is returned the called needs to ensure that +* purge_ddcb() is being called to get the &req removed from the +* queue. +*/ +int __genwqe_wait_ddcb (struct genwqe_dev *cd,struct ddcb_requ *req) +{ +int rc; +unsigned int ddcb_no; +struct ddcb_queue *queue; +struct pci_dev *pci_dev = cd->pci_dev; + +if (req ==NULL ) +return -EINVAL ; + + queue = req->queue; +if (queue ==NULL ) +return -EINVAL ; + + ddcb_no = req->num; +if (ddcb_no >= queue->ddcb_max) +return -EINVAL ; + + rc =wait_event_interruptible_timeout (queue->ddcb_waitqs[ddcb_no], +ddcb_requ_finished (cd, req), + genwqe_ddcb_software_timeout *HZ ); + +/* +* We need to distinguish 3 cases here: +* 1. rc == 0 timeout occured +* 2. rc == -ERESTARTSYS signal received +* 3. rc > 0 remaining jiffies condition is true +*/ +if (rc ==0 ) { +struct ddcb_queue *queue = req->queue; + +/* +* Timeout may be caused by long task switching time. +* When timeout happens, check if the request has +* meanwhile completed. +*/ +genwqe_check_ddcb_queue (cd, req->queue); +if (ddcb_requ_finished (cd, req)) +return rc; + +dev_err (&pci_dev->dev, +"[%s] err: DDCB#%d timeout rc=%d state=%d req @ %p\n" , + __func__, req->num, rc,ddcb_requ_get_state (req), + req); +dev_err (&pci_dev->dev, +"[%s] IO_QUEUE_STATUS=0x%016llx\n" , __func__, +__genwqe_readq (cd, queue->IO_QUEUE_STATUS)); + +if (cd->debug & dbg_card_ddcb) { +struct ddcb *pddcb = &queue->ddcb_vaddr[req->num]; +genwqe_hexdump (pci_dev, pddcb,sizeof (*pddcb)); + } +print_ddcb_info (cd, req->queue); +return -ETIMEDOUT ; + + }else if (rc == -ERESTARTSYS ) { +return rc; +/* +* EINTR: Stops the application +* ERESTARTSYS: Restartable systemcall; called again +*/ + + }else if (rc <0 ) { +dev_err (&pci_dev->dev, +"[%s] err: DDCB#%d unknown result (rc=%d) %d!\n" , + __func__, req->num, rc,ddcb_requ_get_state (req)); +return -EINVAL ; + } + +/* Severe error occured. Driver is forced to stop operation */ +if (cd->card_state !=GENWQE_CARD_USED ) { +dev_err (&pci_dev->dev, +"[%s] err: DDCB#%d forced to stop (rc=%d)\n" , + __func__, req->num, rc); +return -EIO ; + } +return rc; +} + +/** +* get_next_ddcb() - Get next available DDCB +* @cd: pointer to genwqe device descriptor +* +* DDCB's content is completely cleared but presets for PRE and +* SEQNUM. This function must only be called when ddcb_lock is held. +* +* Return: NULL if no empty DDCB available otherwise ptr to next DDCB. +*/ +static struct ddcb *get_next_ddcb (struct genwqe_dev *cd, +struct ddcb_queue *queue, +int *num) +{ +u64 *pu64; +struct ddcb *pddcb; + +if (queue_free_ddcbs (queue) ==0 )/* queue is full */ +return NULL ; + +/* find new ddcb */ + pddcb = &queue->ddcb_vaddr[queue->ddcb_next]; + +/* if it is not completed, we are not allowed to use it */ +/* barrier(); */ +if ((pddcb->icrc_hsi_shi_32 &DDCB_COMPLETED_BE32 ) ==0x00000000 ) +return NULL ; + + *num = queue->ddcb_next;/* internal DDCB number */ + queue->ddcb_next = (queue->ddcb_next +1 ) % queue->ddcb_max; + +/* clear important DDCB fields */ + pu64 = (u64 *)pddcb; + pu64[0 ] =0ULL ;/* offs 0x00 (ICRC,HSI,SHI,...) */ + pu64[1 ] =0ULL ;/* offs 0x01 (ACFUNC,CMD...) */ + +/* destroy previous results in ASV */ + pu64[0x80 /8 ] =0ULL ;/* offs 0x80 (ASV + 0) */ + pu64[0x88 /8 ] =0ULL ;/* offs 0x88 (ASV + 0x08) */ + pu64[0x90 /8 ] =0ULL ;/* offs 0x90 (ASV + 0x10) */ + pu64[0x98 /8 ] =0ULL ;/* offs 0x98 (ASV + 0x18) */ + pu64[0xd0 /8 ] =0ULL ;/* offs 0xd0 (RETC,ATTN...) */ + + pddcb->pre =DDCB_PRESET_PRE ;/* 128 */ + pddcb->seqnum_16 =cpu_to_be16 (queue->ddcb_seq++); +return pddcb; +} + +/** +* __genwqe_purge_ddcb() - Remove a DDCB from the workqueue +* @cd: genwqe device descriptor +* @req: DDCB request +* +* This will fail when the request was already FETCHED. In this case +* we need to wait until it is finished. Else the DDCB can be +* reused. This function also ensures that the request data structure +* is removed from ddcb_req[]. +* +* Do not forget to call this function when genwqe_wait_ddcb() fails, +* such that the request gets really removed from ddcb_req[]. +* +* Return: 0 success +*/ +int __genwqe_purge_ddcb (struct genwqe_dev *cd,struct ddcb_requ *req) +{ +struct ddcb *pddcb =NULL ; +unsigned int t; +unsigned long flags; +struct ddcb_queue *queue = req->queue; +struct pci_dev *pci_dev = cd->pci_dev; +u32 icrc_hsi_shi =0x0000 ; +u64 queue_status; +u32 old, new; + +/* unsigned long flags; */ +if (genwqe_ddcb_software_timeout <=0 ) { +dev_err (&pci_dev->dev, +"[%s] err: software timeout is not set!\n" , __func__); +return -EFAULT ; + } + + pddcb = &queue->ddcb_vaddr[req->num]; + +for (t =0 ; t < genwqe_ddcb_software_timeout *10 ; t++) { + +spin_lock_irqsave (&queue->ddcb_lock, flags); + +/* Check if req was meanwhile finished */ +if (ddcb_requ_get_state (req) ==GENWQE_REQU_FINISHED ) + goto go_home; + +/* try to set PURGE bit if FETCHED/COMPLETED are not set */ + old = pddcb->icrc_hsi_shi_32;/* read SHI/HSI in BE32 */ +if ((old &DDCB_FETCHED_BE32 ) ==0x00000000 ) { + + new = (old |DDCB_PURGE_BE32 ); + icrc_hsi_shi =cmpxchg (&pddcb->icrc_hsi_shi_32, + old, new); +if (icrc_hsi_shi == old) + goto finish_ddcb; + } + +/* normal finish with HSI bit */ +barrier (); + icrc_hsi_shi = pddcb->icrc_hsi_shi_32; +if (icrc_hsi_shi &DDCB_COMPLETED_BE32 ) + goto finish_ddcb; + +spin_unlock_irqrestore (&queue->ddcb_lock, flags); + +/* +* Here the check_ddcb() function will most likely +* discover this DDCB to be finished some point in +* time. It will mark the req finished and free it up +* in the list. +*/ + +copy_ddcb_results (req, req->num);/* for the failing case */ +msleep (100 );/* sleep for 1/10 second and try again */ +continue ; + +finish_ddcb: +copy_ddcb_results (req, req->num); +ddcb_requ_set_state (req,GENWQE_REQU_FINISHED ); + queue->ddcbs_in_flight--; + queue->ddcb_req[req->num] =NULL ;/* delete from array */ +ddcb_mark_cleared (pddcb); + +/* Move active DDCB further; Nothing to do here anymore. */ + +/* +* We need to ensure that there is at least one free +* DDCB in the queue. To do that, we must update +* ddcb_act only if the COMPLETED bit is set for the +* DDCB we are working on else we treat that DDCB even +* if we PURGED it as occupied (hardware is supposed +* to set the COMPLETED bit yet!). +*/ + icrc_hsi_shi = pddcb->icrc_hsi_shi_32; +if ((icrc_hsi_shi &DDCB_COMPLETED_BE32 ) && + (queue->ddcb_act == req->num)) { + queue->ddcb_act = ((queue->ddcb_act +1 ) % + queue->ddcb_max); + } +go_home: +spin_unlock_irqrestore (&queue->ddcb_lock, flags); +return 0 ; + } + +/* +* If the card is dead and the queue is forced to stop, we +* might see this in the queue status register. +*/ + queue_status =__genwqe_readq (cd, queue->IO_QUEUE_STATUS); + +if (cd->debug & dbg_card_ddcb) { +genwqe_dprintk (cd, dbg_card_ddcb,"UN/FINISHED DDCB#%d\n" , + req->num); +genwqe_hexdump (pci_dev, pddcb,sizeof (*pddcb)); + } +dev_err (&pci_dev->dev, +"[%s] err: DDCB#%d not purged and not completed " +"after %d seconds QSTAT=%016llx!!\n" , + __func__, req->num, genwqe_ddcb_software_timeout, + queue_status); + +print_ddcb_info (cd, req->queue); + +return -EFAULT ; +} + +int genwqe_init_debug_data (struct genwqe_dev *cd,struct genwqe_debug_data *d) +{ +int len; +struct pci_dev *pci_dev = cd->pci_dev; + +if (d ==NULL ) { +dev_err (&pci_dev->dev, +"[%s] err: invalid memory for debug data!\n" , + __func__); +return -EFAULT ; + } + + len =sizeof (d->driver_version); +snprintf (d->driver_version, len,"%s" ,DRV_VERS_STRING ); + d->slu_unitcfg = cd->slu_unitcfg; + d->app_unitcfg = cd->app_unitcfg; +return 0 ; +} + +/** +* __genwqe_enqueue_ddcb() - Enqueue a DDCB +* @cd: pointer to genwqe device descriptor +* @req: pointer to DDCB execution request +* +* Return: 0 if enqueuing succeeded +* -EIO if card is unusable/PCIe problems +* -EBUSY if enqueuing failed +*/ +int __genwqe_enqueue_ddcb (struct genwqe_dev *cd,struct ddcb_requ *req) +{ +struct ddcb *pddcb; +unsigned long flags; +struct ddcb_queue *queue; +struct pci_dev *pci_dev = cd->pci_dev; +u16 icrc; + +if (cd->card_state !=GENWQE_CARD_USED ) { +printk_ratelimited (KERN_ERR +"%s %s: [%s] Card is unusable/PCIe problem Req#%d\n" , +GENWQE_DEVNAME ,dev_name (&pci_dev->dev), + __func__, req->num); +return -EIO ; + } + + queue = req->queue = &cd->queue; + +/* FIXME circumvention to improve performance when no irq is +* there. +*/ +if (genwqe_polling_enabled) +genwqe_check_ddcb_queue (cd, queue); + +/* +* It must be ensured to process all DDCBs in successive +* order. Use a lock here in order to prevent nested DDCB +* enqueuing. +*/ +spin_lock_irqsave (&queue->ddcb_lock, flags); + + pddcb =get_next_ddcb (cd, queue, &req->num);/* get ptr and num */ +if (pddcb ==NULL ) { +spin_unlock_irqrestore (&queue->ddcb_lock, flags); + queue->busy++; +return -EBUSY ; + } + +if (queue->ddcb_req[req->num] !=NULL ) { +spin_unlock_irqrestore (&queue->ddcb_lock, flags); + +dev_err (&pci_dev->dev, +"[%s] picked DDCB %d with req=%p still in use!!\n" , + __func__, req->num, req); +return -EFAULT ; + } +ddcb_requ_set_state (req,GENWQE_REQU_ENQUEUED ); + queue->ddcb_req[req->num] = req; + + pddcb->cmdopts_16 =cpu_to_be16 (req->cmd.cmdopts); + pddcb->cmd = req->cmd.cmd; + pddcb->acfunc = req->cmd.acfunc;/* functional unit */ + +/* +* We know that we can get retc 0x104 with CRC error, do not +* stop the queue in those cases for this command. XDIR = 1 +* does not work for old SLU versions. +* +* Last bitstream with the old XDIR behavior had SLU_ID +* 0x34199. +*/ +if ((cd->slu_unitcfg &0xFFFF0ull ) >0x34199ull ) + pddcb->xdir =0x1 ; +else + pddcb->xdir =0x0 ; + + + pddcb->psp = (((req->cmd.asiv_length /8 ) <<4 ) | + ((req->cmd.asv_length /8 ))); + pddcb->disp_ts_64 =cpu_to_be64 (req->cmd.disp_ts); + +/* +* If copying the whole DDCB_ASIV_LENGTH is impacting +* performance we need to change it to +* req->cmd.asiv_length. But simulation benefits from some +* non-architectured bits behind the architectured content. +* +* How much data is copied depends on the availability of the +* ATS field, which was introduced late. If the ATS field is +* supported ASIV is 8 bytes shorter than it used to be. Since +* the ATS field is copied too, the code should do exactly +* what it did before, but I wanted to make copying of the ATS +* field very explicit. +*/ +if (genwqe_get_slu_id (cd) <=0x2 ) { +memcpy (&pddcb->__asiv[0 ],/* destination */ + &req->cmd.__asiv[0 ],/* source */ +DDCB_ASIV_LENGTH );/* req->cmd.asiv_length */ + }else { + pddcb->n.ats_64 = req->cmd.ats; +memcpy (&pddcb->n.asiv[0 ],/* destination */ + &req->cmd.asiv[0 ],/* source */ +DDCB_ASIV_LENGTH_ATS );/* req->cmd.asiv_length */ + } + + pddcb->icrc_hsi_shi_32 =cpu_to_be32 (0x00000000 );/* for crc */ + +/* +* Calculate CRC_16 for corresponding range PSP(7:4). Include +* empty 4 bytes prior to the data. +*/ + icrc =genwqe_crc16 ((const u8 *)pddcb, +ICRC_LENGTH (req->cmd.asiv_length),0xffff ); + pddcb->icrc_hsi_shi_32 =cpu_to_be32 ((u32 )icrc <<16 ); + +/* enable DDCB completion irq */ +if (!genwqe_polling_enabled) + pddcb->icrc_hsi_shi_32 |=DDCB_INTR_BE32 ; + +if (cd->debug & dbg_card_ddcb) { +genwqe_dprintk (cd, dbg_card_ddcb,"INPUT DDCB#%d\n" , req->num); +genwqe_hexdump (pci_dev, pddcb,sizeof (*pddcb)); + } + +if (ddcb_requ_collect_debug_data (req)) { +/* use the kernel copy of debug data. copying back to +user buffer happens later */ + +genwqe_init_debug_data (cd, &req->debug_data); +memcpy (&req->debug_data.ddcb_before, pddcb, +sizeof (req->debug_data.ddcb_before)); + } + +enqueue_ddcb (cd, queue, pddcb, req->num); + queue->ddcbs_in_flight++; + +if (queue->ddcbs_in_flight > queue->ddcbs_max_in_flight) + queue->ddcbs_max_in_flight = queue->ddcbs_in_flight; + +ddcb_requ_set_state (req,GENWQE_REQU_TAPPED ); +spin_unlock_irqrestore (&queue->ddcb_lock, flags); +wake_up_interruptible (&cd->queue_waitq); + +return 0 ; +} + +/** +* __genwqe_execute_raw_ddcb() - Setup and execute DDCB +* @cd: pointer to genwqe device descriptor +* @req: user provided DDCB request +*/ +int __genwqe_execute_raw_ddcb (struct genwqe_dev *cd, +struct genwqe_ddcb_cmd *cmd) +{ +int rc =0 ; +struct pci_dev *pci_dev = cd->pci_dev; + struct ddcb_requ *req = container_of(cmd, struct ddcb_requ, cmd); + +if (cmd->asiv_length >DDCB_ASIV_LENGTH ) { +dev_err (&pci_dev->dev,"[%s] err: wrong asiv_length of %d\n" , + __func__, cmd->asiv_length); +return -EINVAL ; + } +if (cmd->asv_length >DDCB_ASV_LENGTH ) { +dev_err (&pci_dev->dev,"[%s] err: wrong asv_length of %d\n" , + __func__, cmd->asiv_length); +return -EINVAL ; + } + rc =__genwqe_enqueue_ddcb (cd, req); +if (rc !=0 ) +return rc; + + rc =__genwqe_wait_ddcb (cd, req); +if (rc <0 )/* error or signal interrupt */ + goto err_exit; + +if (ddcb_requ_collect_debug_data (req)) { +if (copy_to_user (cmd->debug_data, &req->debug_data, +sizeof (*cmd->debug_data))) { +return -EFAULT ; + } + } + +/* +* Higher values than 0x102 indicate completion with faults, +* lower values than 0x102 indicate processing faults. Note +* that DDCB might have been purged. E.g. Cntl+C. +*/ +if (cmd->retc !=DDCB_RETC_COMPLETE ) { +/* This might happen e.g. flash read, and needs to be +handled by the upper layer code. */ + rc = -EBADMSG ;/* not processed/error retc */ + } + +return rc; + + err_exit: +__genwqe_purge_ddcb (cd, req); + +if (ddcb_requ_collect_debug_data (req)) { +if (copy_to_user (cmd->debug_data, &req->debug_data, +sizeof (*cmd->debug_data))) { +return -EFAULT ; + } + } +return rc; +} + +/** +* genwqe_next_ddcb_ready() - Figure out if the next DDCB is already finished +* +* We use this as condition for our wait-queue code. +*/ +static int genwqe_next_ddcb_ready (struct genwqe_dev *cd) +{ +unsigned long flags; +struct ddcb *pddcb; +struct ddcb_queue *queue = &cd->queue; + +spin_lock_irqsave (&queue->ddcb_lock, flags); + +if (queue_empty (queue)) {/* emtpy queue */ +spin_unlock_irqrestore (&queue->ddcb_lock, flags); +return 0 ; + } + + pddcb = &queue->ddcb_vaddr[queue->ddcb_act]; +if (pddcb->icrc_hsi_shi_32 &DDCB_COMPLETED_BE32 ) {/* ddcb ready */ +spin_unlock_irqrestore (&queue->ddcb_lock, flags); +return 1 ; + } + +spin_unlock_irqrestore (&queue->ddcb_lock, flags); +return 0 ; +} + +/** +* genwqe_ddcbs_in_flight() - Check how many DDCBs are in flight +* +* Keep track on the number of DDCBs which ware currently in the +* queue. This is needed for statistics as well as conditon if we want +* to wait or better do polling in case of no interrupts available. +*/ +int genwqe_ddcbs_in_flight (struct genwqe_dev *cd) +{ +unsigned long flags; +int ddcbs_in_flight =0 ; +struct ddcb_queue *queue = &cd->queue; + +spin_lock_irqsave (&queue->ddcb_lock, flags); + ddcbs_in_flight += queue->ddcbs_in_flight; +spin_unlock_irqrestore (&queue->ddcb_lock, flags); + +return ddcbs_in_flight; +} + +static int setup_ddcb_queue (struct genwqe_dev *cd,struct ddcb_queue *queue) +{ +int rc, i; +struct ddcb *pddcb; +u64 val64; +unsigned int queue_size; +struct pci_dev *pci_dev = cd->pci_dev; + +if (genwqe_ddcb_max <2 ) +return -EINVAL ; + + queue_size =roundup (genwqe_ddcb_max *sizeof (struct ddcb ),PAGE_SIZE ); + + queue->ddcbs_in_flight =0 ;/* statistics */ + queue->ddcbs_max_in_flight =0 ; + queue->ddcbs_completed =0 ; + queue->busy =0 ; + + queue->ddcb_seq =0x100 ;/* start sequence number */ + queue->ddcb_max = genwqe_ddcb_max;/* module parameter */ + queue->ddcb_vaddr =__genwqe_alloc_consistent (cd, queue_size, + &queue->ddcb_daddr); +if (queue->ddcb_vaddr ==NULL ) { +dev_err (&pci_dev->dev, +"[%s] **err: could not allocate DDCB **\n" , __func__); +return -ENOMEM ; + } +memset (queue->ddcb_vaddr,0 , queue_size); + + queue->ddcb_req =kzalloc (sizeof (struct ddcb_requ *) * + queue->ddcb_max,GFP_KERNEL ); +if (!queue->ddcb_req) { + rc = -ENOMEM ; + goto free_ddcbs; + } + + queue->ddcb_waitqs =kzalloc (sizeof (wait_queue_head_t) * + queue->ddcb_max,GFP_KERNEL ); +if (!queue->ddcb_waitqs) { + rc = -ENOMEM ; + goto free_requs; + } + +for (i =0 ; i < queue->ddcb_max; i++) { + pddcb = &queue->ddcb_vaddr[i];/* DDCBs */ + pddcb->icrc_hsi_shi_32 =DDCB_COMPLETED_BE32 ; + pddcb->retc_16 =cpu_to_be16 (0xfff ); + + queue->ddcb_req[i] =NULL ;/* requests */ +init_waitqueue_head (&queue->ddcb_waitqs[i]);/* waitqueues */ + } + + queue->ddcb_act =0 ; + queue->ddcb_next =0 ;/* queue is empty */ + +spin_lock_init (&queue->ddcb_lock); +init_waitqueue_head (&queue->ddcb_waitq); + + val64 = ((u64)(queue->ddcb_max -1 ) <<8 );/* lastptr */ +__genwqe_writeq (cd, queue->IO_QUEUE_CONFIG,0x07 );/* iCRC/vCRC */ +__genwqe_writeq (cd, queue->IO_QUEUE_SEGMENT, queue->ddcb_daddr); +__genwqe_writeq (cd, queue->IO_QUEUE_INITSQN, queue->ddcb_seq); +__genwqe_writeq (cd, queue->IO_QUEUE_WRAP, val64); +return 0 ; + + free_requs: +kfree (queue->ddcb_req); + queue->ddcb_req =NULL ; + free_ddcbs: +__genwqe_free_consistent (cd, queue_size, queue->ddcb_vaddr, + queue->ddcb_daddr); + queue->ddcb_vaddr =NULL ; + queue->ddcb_daddr =0ull ; +return -ENODEV ; + +} + +static int ddcb_queue_initialized (struct ddcb_queue *queue) +{ +return (queue->ddcb_vaddr !=NULL ); +} + +static void free_ddcb_queue (struct genwqe_dev *cd,struct ddcb_queue *queue) +{ +unsigned int queue_size; + + queue_size =roundup (queue->ddcb_max *sizeof (struct ddcb ),PAGE_SIZE ); + +kfree (queue->ddcb_req); + queue->ddcb_req =NULL ; + +if (queue->ddcb_vaddr) { +__genwqe_free_consistent (cd, queue_size, queue->ddcb_vaddr, + queue->ddcb_daddr); + queue->ddcb_vaddr =NULL ; + queue->ddcb_daddr =0ull ; + } +} + +static irqreturn_t genwqe_pf_isr (int irq,void *dev_id) +{ +u64 gfir; +struct genwqe_dev *cd = (struct genwqe_dev *)dev_id; +struct pci_dev *pci_dev = cd->pci_dev; + +/* +* In case of fatal FIR error the queue is stopped, such that +* we can safely check it without risking anything. +*/ + cd->irqs_processed++; +wake_up_interruptible (&cd->queue_waitq); + +/* +* Checking for errors before kicking the queue might be +* safer, but slower for the good-case ... See above. +*/ + gfir =__genwqe_readq (cd,IO_SLC_CFGREG_GFIR ); +if ((gfir &GFIR_ERR_TRIGGER ) !=0x0 ) { + +wake_up_interruptible (&cd->health_waitq); + +/* +* By default GFIRs causes recovery actions. This +* count is just for debug when recovery is masked. +*/ +printk_ratelimited (KERN_ERR +"%s %s: [%s] GFIR=%016llx\n" , +GENWQE_DEVNAME ,dev_name (&pci_dev->dev), + __func__, gfir); + } + +return IRQ_HANDLED ; +} + +static irqreturn_t genwqe_vf_isr (int irq,void *dev_id) +{ +struct genwqe_dev *cd = (struct genwqe_dev *)dev_id; + + cd->irqs_processed++; +wake_up_interruptible (&cd->queue_waitq); + +return IRQ_HANDLED ; +} + +/** +* genwqe_card_thread() - Work thread for the DDCB queue +* +* The idea is to check if there are DDCBs in processing. If there are +* some finished DDCBs, we process them and wakeup the +* requestors. Otherwise we give other processes time using +* cond_resched(). +*/ +static int genwqe_card_thread (void *data) +{ +int should_stop =0 , rc =0 ; +struct genwqe_dev *cd = (struct genwqe_dev *)data; + +while (!kthread_should_stop ()) { + +genwqe_check_ddcb_queue (cd, &cd->queue); + +if (genwqe_polling_enabled) { + rc =wait_event_interruptible_timeout ( + cd->queue_waitq, +genwqe_ddcbs_in_flight (cd) || + (should_stop =kthread_should_stop ()),1 ); + }else { + rc =wait_event_interruptible_timeout ( + cd->queue_waitq, +genwqe_next_ddcb_ready (cd) || + (should_stop =kthread_should_stop ()),HZ ); + } +if (should_stop) +break ; + +/* +* Avoid soft lockups on heavy loads; we do not want +* to disable our interrupts. +*/ +cond_resched (); + } +return 0 ; +} + +/** +* genwqe_setup_service_layer() - Setup DDCB queue +* @cd: pointer to genwqe device descriptor +* +* Allocate DDCBs. Configure Service Layer Controller (SLC). +* +* Return: 0 success +*/ +int genwqe_setup_service_layer (struct genwqe_dev *cd) +{ +int rc; +struct ddcb_queue *queue; +struct pci_dev *pci_dev = cd->pci_dev; + +if (genwqe_is_privileged (cd)) { + rc =genwqe_card_reset (cd); +if (rc <0 ) { +dev_err (&pci_dev->dev, +"[%s] err: reset failed.\n" , __func__); +return rc; + } +genwqe_read_softreset (cd); + } + + queue = &cd->queue; + queue->IO_QUEUE_CONFIG =IO_SLC_QUEUE_CONFIG ; + queue->IO_QUEUE_STATUS =IO_SLC_QUEUE_STATUS ; + queue->IO_QUEUE_SEGMENT =IO_SLC_QUEUE_SEGMENT ; + queue->IO_QUEUE_INITSQN =IO_SLC_QUEUE_INITSQN ; + queue->IO_QUEUE_OFFSET =IO_SLC_QUEUE_OFFSET ; + queue->IO_QUEUE_WRAP =IO_SLC_QUEUE_WRAP ; + queue->IO_QUEUE_WTIME =IO_SLC_QUEUE_WTIME ; + queue->IO_QUEUE_ERRCNTS =IO_SLC_QUEUE_ERRCNTS ; + queue->IO_QUEUE_LRW =IO_SLC_QUEUE_LRW ; + + rc =setup_ddcb_queue (cd, queue); +if (rc !=0 ) { + rc = -ENODEV ; + goto err_out; + } + +init_waitqueue_head (&cd->queue_waitq); + cd->card_thread =kthread_run (genwqe_card_thread, cd, +GENWQE_DEVNAME "%d_thread" , + cd->card_idx); +if (IS_ERR (cd->card_thread)) { + rc =PTR_ERR (cd->card_thread); + cd->card_thread =NULL ; + goto stop_free_queue; + } + + rc =genwqe_set_interrupt_capability (cd,GENWQE_MSI_IRQS ); +if (rc >0 ) + rc =genwqe_set_interrupt_capability (cd, rc); +if (rc !=0 ) { + rc = -ENODEV ; + goto stop_kthread; + } + +/* +* We must have all wait-queues initialized when we enable the +* interrupts. Otherwise we might crash if we get an early +* irq. +*/ +init_waitqueue_head (&cd->health_waitq); + +if (genwqe_is_privileged (cd)) { + rc =request_irq (pci_dev->irq, genwqe_pf_isr,IRQF_SHARED , +GENWQE_DEVNAME , cd); + }else { + rc =request_irq (pci_dev->irq, genwqe_vf_isr,IRQF_SHARED , +GENWQE_DEVNAME , cd); + } +if (rc <0 ) { +dev_err (&pci_dev->dev,"irq %d not free.\n" , pci_dev->irq); + goto stop_irq_cap; + } + + cd->card_state =GENWQE_CARD_USED ; +return 0 ; + + stop_irq_cap: +genwqe_reset_interrupt_capability (cd); + stop_kthread: +kthread_stop (cd->card_thread); + cd->card_thread =NULL ; + stop_free_queue: +free_ddcb_queue (cd, queue); + err_out: +return rc; +} + +/** +* queue_wake_up_all() - Handles fatal error case +* +* The PCI device got unusable and we have to stop all pending +* requests as fast as we can. The code after this must purge the +* DDCBs in question and ensure that all mappings are freed. +*/ +static int queue_wake_up_all (struct genwqe_dev *cd) +{ +unsigned int i; +unsigned long flags; +struct ddcb_queue *queue = &cd->queue; + +spin_lock_irqsave (&queue->ddcb_lock, flags); + +for (i =0 ; i < queue->ddcb_max; i++) +wake_up_interruptible (&queue->ddcb_waitqs[queue->ddcb_act]); + +spin_unlock_irqrestore (&queue->ddcb_lock, flags); + +return 0 ; +} + +/** +* genwqe_finish_queue() - Remove any genwqe devices and user-interfaces +* +* Relies on the pre-condition that there are no users of the card +* device anymore e.g. with open file-descriptors. +* +* This function must be robust enough to be called twice. +*/ +int genwqe_finish_queue (struct genwqe_dev *cd) +{ +int i, rc, in_flight; +int waitmax = genwqe_ddcb_software_timeout; +struct pci_dev *pci_dev = cd->pci_dev; +struct ddcb_queue *queue = &cd->queue; + +if (!ddcb_queue_initialized (queue)) +return 0 ; + +/* Do not wipe out the error state. */ +if (cd->card_state ==GENWQE_CARD_USED ) + cd->card_state =GENWQE_CARD_UNUSED ; + +/* Wake up all requests in the DDCB queue such that they +should be removed nicely. */ +queue_wake_up_all (cd); + +/* We must wait to get rid of the DDCBs in flight */ +for (i =0 ; i < waitmax; i++) { + in_flight =genwqe_ddcbs_in_flight (cd); + +if (in_flight ==0 ) +break ; + +dev_info (&pci_dev->dev, +" DEBUG [%d/%d] waiting for queue to get empty: " +"%d requests!\n" , i, waitmax, in_flight); + +/* +* Severe severe error situation: The card itself has +* 16 DDCB queues, each queue has e.g. 32 entries, +* each DDBC has a hardware timeout of currently 250 +* msec but the PFs have a hardware timeout of 8 sec +* ... so I take something large. +*/ +msleep (1000 ); + } +if (i == waitmax) { +dev_err (&pci_dev->dev," [%s] err: queue is not empty!!\n" , + __func__); + rc = -EIO ; + } +return rc; +} + +/** +* genwqe_release_service_layer() - Shutdown DDCB queue +* @cd: genwqe device descriptor +* +* This function must be robust enough to be called twice. +*/ +int genwqe_release_service_layer (struct genwqe_dev *cd) +{ +struct pci_dev *pci_dev = cd->pci_dev; + +if (!ddcb_queue_initialized (&cd->queue)) +return 1 ; + +free_irq (pci_dev->irq, cd); +genwqe_reset_interrupt_capability (cd); + +if (cd->card_thread !=NULL ) { +kthread_stop (cd->card_thread); + cd->card_thread =NULL ; + } + +free_ddcb_queue (cd, &cd->queue); +return 0 ; +}
drivers/misc/genwqe/card_ddcb.h new file +188 -0
188 lines not on this page · raw message
drivers/misc/genwqe/card_dev.c new file +1499 -0
1,432 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Signature · 1 line
1.7.1
Part of the diff is not shown here. View the raw message.
PATCH 3/6 GenWQE Utility functions
In reply to Frank HaverkampMiscelanous functionality used in the other GenWQE driver parts.
Co-authors: Joerg-Stephan Vogt <[email protected]>,
Michael Jung <[email protected]>, Michael Ruettger <[email protected]>
--- drivers/misc/genwqe/card_utils.c | 983 ++++++++++++++++++++++++++++++++++++++ 1 files changed, 983 insertions(+), 0 deletions(-) create mode 100644 drivers/misc/genwqe/card_utils.c
drivers/misc/genwqe/card_utils.c new file +983 -0
@@ -0,0 +1,983 @@ +/** +* IBM Accelerator Family 'GenWQE' +* +* (C) Copyright IBM Corp. 2013 +* +* Author: Frank Haverkamp <[email protected]> +* Author: Joerg-Stephan Vogt <[email protected]> +* Author: Michael Jung <[email protected]> +* Author: Michael Ruettger <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License (version 2 only) +* 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. +*/ + +/* +* Miscelanous functionality used in the other GenWQE driver parts. +*/ + +#include <linux/kernel.h> +#include <linux/dma-mapping.h> +#include <linux/sched.h> +#include <linux/vmalloc.h> +#include <linux/page-flags.h> +#include <linux/scatterlist.h> +#include <linux/hugetlb.h> +#include <linux/iommu.h> +#include <linux/delay.h> +#include <linux/pci.h> +#include <linux/dma-mapping.h> +#include <linux/ctype.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/delay.h> +#include <asm/pgtable.h> + +#include "genwqe_driver.h" +#include "card_base.h" +#include "card_ddcb.h" + +/** +* __genwqe_writeq() - Write 64-bit register +* @cd: genwqe device descriptor +* @byte_offs: byte offset within BAR +* @val: 64-bit value +* +* Return: 0 if success; < 0 if error +*/ +int __genwqe_writeq (struct genwqe_dev *cd,u64 byte_offs,u64 val) +{ +genwqe_dprintk (cd, dbg_card_regs, +" genwqe_writeq: reg=%08llx val=%016llx\n" , + byte_offs, val); + +if (cd->err_inject &GENWQE_INJECT_HARDWARE_FAILURE ) +return -EIO ; + +if (cd->mmio ==NULL ) +return -EIO ; + +__raw_writeq (cpu_to_be64 ((val)), (cd->mmio + byte_offs)); +return 0 ; +} + +/** +* __genwqe_readq() - Read 64-bit register +* @cd: genwqe device descriptor +* @byte_offs: offset within BAR +* +* Return: value from register +*/ +u64 __genwqe_readq (struct genwqe_dev *cd,u64 byte_offs) +{ +u64 val; + +if (cd->err_inject &GENWQE_INJECT_HARDWARE_FAILURE ) +return 0xffffffffffffffffull ; + +if ((cd->err_inject &GENWQE_INJECT_GFIR_FATAL ) && + (byte_offs ==IO_SLC_CFGREG_GFIR )) +return 0x000000000000ffffull ; + +if ((cd->err_inject &GENWQE_INJECT_GFIR_INFO ) && + (byte_offs ==IO_SLC_CFGREG_GFIR )) +return 0x00000000ffff0000ull ; + +if (cd->mmio ==NULL ) +return 0xffffffffffffffffull ; + + val =be64_to_cpu (__raw_readq (cd->mmio + byte_offs)); + +genwqe_dprintk (cd, dbg_card_regs, +" genwqe_readq: reg=%08llx val=%016llx\n" , + byte_offs, val); + +return val; +} + +/** +* __genwqe_writel() - Write 32-bit register +* @cd: genwqe device descriptor +* @byte_offs: byte offset within BAR +* @val: 32-bit value +* +* Return: 0 if success; < 0 if error +*/ +int __genwqe_writel (struct genwqe_dev *cd,uint64_t byte_offs,u32 val) +{ +genwqe_dprintk (cd, dbg_card_regs, +" genwqe_writel: reg=%08llx val=%08x\n" , + byte_offs, val); + +if (cd->err_inject &GENWQE_INJECT_HARDWARE_FAILURE ) +return -EIO ; + +if (cd->mmio ==NULL ) +return -EIO ; + +__raw_writel (cpu_to_be32 ((val)), cd->mmio + byte_offs); +return 0 ; +} + +/** +* __genwqe_readl() - Read 32-bit register +* @cd: genwqe device descriptor +* @byte_offs: offset within BAR +* +* Return: Value from register +*/ +u32 __genwqe_readl (struct genwqe_dev *cd,uint64_t byte_offs) +{ +if (cd->err_inject &GENWQE_INJECT_HARDWARE_FAILURE ) +return 0xffffffff ; + +if (cd->mmio ==NULL ) +return 0xffffffff ; + +return be32_to_cpu (__raw_readl (cd->mmio + byte_offs)); +} + +/** +* genwqe_read_app_id() - Extract app_id +* +* app_unitcfg need to be filled with valid data first +*/ +int genwqe_read_app_id (struct genwqe_dev *cd,char *app_name,int len) +{ +int i, j; +u32 app_id = (u32 )cd->app_unitcfg; + +memset (app_name,0 , len); +for (i =0 , j =0 ; j <min (len,4 ); j++) { +char ch = (char )((app_id >> (24 - j*8 )) &0xff ); +if (ch ==' ' ) +continue ; + app_name[i++] =isprint (ch) ? ch :'X' ; + } +return i; +} + +/** +* init_crc32() - Prepare a lookup table for fast crc32 calculations +* +* Existing kernel functions seem to use a different polynom, +* therefore we could not use them here. +* +* Genwqe's Polynomial = 0x20044009 +*/ +#define CRC32_POLYNOMIAL 0x20044009 +static u32 crc32_tab[256 ];/* crc32 lookup table */ + +void init_crc32 (void ) +{ +int i, j; +u32 crc; + +for (i =0 ; i <256 ; i++) { + crc = i <<24 ; +for (j =0 ; j <8 ; j++) { +if (crc &0x80000000 ) + crc = (crc <<1 ) ^CRC32_POLYNOMIAL ; +else + crc = (crc <<1 ); + } + crc32_tab[i] = crc; + } +} + +/** +* genwqe_crc32() - Generate 32-bit crc as required for DDCBs +* @buff: pointer to data buffer +* @len: length of data for calculation +* @init: initial crc (0xffffffff at start) +* +* polynomial = x^32 * + x^29 + x^18 + x^14 + x^3 + 1 (0x20044009) + +* Example: 4 bytes 0x01 0x02 0x03 0x04 with init=0xffffffff should +* result in a crc32 of 0xf33cb7d3. +* +* The existing kernel crc functions did not cover this polynom yet. +* +* Return: crc32 checksum. +*/ +u32 genwqe_crc32 (u8 *buff,size_t len,u32 init) +{ +int i; +u32 crc; + + crc = init; +while (len--) { + i = ((crc >>24 ) ^ *buff++) &0xFF ; + crc = (crc <<8 ) ^ crc32_tab[i]; + } +return crc; +} + +void *__genwqe_alloc_consistent (struct genwqe_dev *cd,size_t size, +dma_addr_t *dma_handle) +{ +if (get_order (size) >MAX_ORDER ) +return NULL ; + +return pci_alloc_consistent (cd->pci_dev, size, dma_handle); +} + +void __genwqe_free_consistent (struct genwqe_dev *cd,size_t size, +void *vaddr,dma_addr_t dma_handle) +{ +if (vaddr ==NULL ) +return ; +pci_free_consistent (cd->pci_dev, size, vaddr, dma_handle); +} + +static void genwqe_unmap_pages (struct genwqe_dev *cd,dma_addr_t *dma_list, +int num_pages) +{ +int i; +struct pci_dev *pci_dev = cd->pci_dev; + +for (i =0 ; (i < num_pages) && (dma_list[i] !=0x0 ); i++) { +pci_unmap_page (pci_dev, dma_list[i], +PAGE_SIZE ,PCI_DMA_BIDIRECTIONAL ); + dma_list[i] =0x0 ; + } +} + +static int genwqe_map_pages (struct genwqe_dev *cd, +struct page **page_list,int num_pages, +dma_addr_t *dma_list) +{ +int i; +struct pci_dev *pci_dev = cd->pci_dev; + +/* establish DMA mapping for requested pages */ +for (i =0 ; i < num_pages; i++) { +dma_addr_t daddr; + + dma_list[i] =0x0 ; + daddr =pci_map_page (pci_dev, page_list[i], +0 ,/* map_offs */ +PAGE_SIZE , +PCI_DMA_BIDIRECTIONAL );/* FIXME rd/rw */ + +if (pci_dma_mapping_error (pci_dev, daddr)) { +dev_err (&pci_dev->dev, +"[%s] err: no dma addr daddr=%016llx!\n" , + __func__, (long long )daddr); + goto err; + } + + dma_list[i] = daddr; + } +return 0 ; + + err: +genwqe_unmap_pages (cd, dma_list, num_pages); +return -EIO ; +} + +static int genwqe_sgl_size (int num_pages) +{ +int len, num_tlb = num_pages /7 ; + + len =sizeof (struct sg_entry ) * (num_pages+num_tlb +1 ); +return roundup (len,PAGE_SIZE ); +} + +struct sg_entry *genwqe_alloc_sgl (struct genwqe_dev *cd,int num_pages, +dma_addr_t *dma_addr,size_t *sgl_size) +{ +struct pci_dev *pci_dev = cd->pci_dev; +struct sg_entry *sgl; + + *sgl_size =genwqe_sgl_size (num_pages); +if (get_order (*sgl_size) >MAX_ORDER ) { +dev_err (&pci_dev->dev, +"[%s] err: too much memory requested!\n" , __func__); +return NULL ; + } + + sgl =__genwqe_alloc_consistent (cd, *sgl_size, dma_addr); +if (sgl ==NULL ) { +dev_err (&pci_dev->dev, +"[%s] err: no memory available!\n" , __func__); +return NULL ; + } + +return sgl; +} + +static void genwqe_dump_sgl (struct genwqe_dev *cd,struct sg_entry *sgl, +size_t sgl_size) +{ +unsigned int i, j; +struct pci_dev *pci_dev = cd->pci_dev; + +for (j =0 , i =0 ; i < sgl_size/sizeof (struct sg_entry ); i++, j++) { +if (j ==8 ) { +dev_info (&pci_dev->dev," --\n" ); + j =0 ; + } +dev_info (&pci_dev->dev," %016llx %08x %08x %s\n" , +be64_to_cpu (sgl[i].target_addr), +be32_to_cpu (sgl[i].len), +be32_to_cpu (sgl[i].flags), + (be32_to_cpu (sgl[i].len) >PAGE_SIZE ) ?"C" :"" ); + +if (be32_to_cpu (sgl[i].flags) ==SG_END_LIST ) +break ; + } +} + +int genwqe_setup_sgl (struct genwqe_dev *cd, +unsigned long offs, +unsigned long size, +struct sg_entry *sgl,/* genwqe sgl */ +dma_addr_t dma_addr,size_t sgl_size, +dma_addr_t *dma_list,int page_offs,int num_pages) +{ +int i =0 , j =0 , p; +unsigned long dma_offs, map_offs; +struct pci_dev *pci_dev = cd->pci_dev; +dma_addr_t prev_daddr =0 ; +struct sg_entry *s, *last_s =NULL ; + +/* sanity checks */ +if (offs >PAGE_SIZE ) { +dev_err (&pci_dev->dev, +"[%s] too large start offs %08lx\n" , __func__, offs); +return -EFAULT ; + } +if (sgl_size <genwqe_sgl_size (num_pages)) { +dev_err (&pci_dev->dev, +"[%s] sgl_size too small %08lx for %d pages\n" , + __func__, sgl_size, num_pages); +return -EFAULT ; + } + + dma_offs =128 ;/* next block if needed/dma_offset */ + map_offs = offs;/* offset in first page */ + + s = &sgl[0 ];/* first set of 8 entries */ + p =0 ;/* page */ +while (p < num_pages) { +dma_addr_t daddr; +unsigned int size_to_map; + +/* always write the chaining entry, cleanup is done later */ + j =0 ; + s[j].target_addr =cpu_to_be64 (dma_addr + dma_offs); + s[j].len =cpu_to_be32 (128 ); + s[j].flags =cpu_to_be32 (SG_CHAINED ); + j++; + +while (j <8 ) { +/* DMA mapping for requested page, offs, size */ + size_to_map =min (size,PAGE_SIZE - map_offs); + daddr = dma_list[page_offs + p] + map_offs; + size -= size_to_map; + map_offs =0 ; + +if (prev_daddr == daddr) { +u32 prev_len =be32_to_cpu (last_s->len); + +/* pr_info("daddr combining: " +"%016llx/%08x -> %016llx\n", +prev_daddr, prev_len, daddr); */ + + last_s->len =cpu_to_be32 (prev_len + + size_to_map); + + p++;/* process next page */ +if (p == num_pages) + goto fixup;/* nothing to do */ + + prev_daddr = daddr + size_to_map; +continue ; + } + +/* start new entry */ + s[j].target_addr =cpu_to_be64 (daddr); + s[j].len =cpu_to_be32 (size_to_map); + s[j].flags =cpu_to_be32 (SG_DATA ); + prev_daddr = daddr + size_to_map; + last_s = &s[j]; + j++; + + p++;/* process next page */ +if (p == num_pages) + goto fixup;/* nothing to do */ + } + dma_offs +=128 ; + s +=8 ;/* continue 8 elements further */ + } + fixup: +if (j ==1 ) {/* combining happend on last entry! */ + s -=8 ;/* full shift needed on previous sgl block */ + j =7 ;/* shift all elements */ + } + +for (i =0 ; i < j; i++)/* move elements 1 up */ + s[i] = s[i +1 ]; + + s[i].target_addr =cpu_to_be64 (0 ); + s[i].len =cpu_to_be32 (0 ); + s[i].flags =cpu_to_be32 (SG_END_LIST ); + +if (cd->debug & dbg_card_sglist) { +genwqe_dprintk (cd, dbg_card_sglist, +" genwqe_sglist %d/sgl poffs=%d %d\n" , + j, page_offs, num_pages); +genwqe_dump_sgl (cd, sgl, sgl_size); + } +return 0 ; +} + +void genwqe_free_sgl (struct genwqe_dev *cd,struct sg_entry *sg_list, +dma_addr_t dma_addr,size_t size) +{ +__genwqe_free_consistent (cd, size, sg_list, dma_addr); +} + +/** +* free_user_pages() - Give pinned pages back +* +* Documentation of get_user_pages is in mm/memory.c: +* +* If the page is written to, set_page_dirty (or set_page_dirty_lock, +* as appropriate) must be called after the page is finished with, and +* before put_page is called. +*/ +static int free_user_pages (struct page **page_list,unsigned int nr_pages, +int dirty) +{ +unsigned int i; + +for (i =0 ; i < nr_pages; i++) { +if (page_list[i] !=NULL ) { +if (dirty) +set_page_dirty_lock (page_list[i]); +put_page (page_list[i]); + } + } +return 0 ; +} + +/** +* user_vmap() - Map user-space memory to virtual kernel memory +* @cd: pointer to genwqe device +* @m: mapping params +* @uaddr: user virtual address +* @size: size of memory to be mapped +* +* We need to think about how we could speed this up. Of course it is +* not a good idea to do this over and over again, like we are +* currently doing it. Nevertheless, I am curious where on the path +* the performance is spend. Most probably within the memory +* allocation functions, but maybe also in the DMA mapping code. +* +* Restrictions: The maximum size of the possible mapping currently depends +* on the amount of memory we can get using kzalloc() for the +* page_list and pci_alloc_coherent for the sg_list. +* The sg_list is currently itself not scattered, which could +* be fixed with some effort. The page_list must be split into +* PAGE_SIZE chunks too. All that will make the complicated +* code more complicated. +* +* Return: 0 if success +*/ +int user_vmap (struct genwqe_dev *cd,struct dma_mapping *m,void *uaddr, +unsigned long size,struct ddcb_requ *req) +{ +int rc = -EINVAL ; +unsigned long data, offs; +struct pci_dev *pci_dev = cd->pci_dev; + +if ((uaddr ==NULL ) || (size ==0 )) { + m->size =0 ;/* mark unused and not added */ +return -EINVAL ; + } + m->u_vaddr = uaddr; + m->size = size; + +/* determine space needed for page_list. */ + data = (unsigned long )uaddr; + offs =offset_in_page (data); + m->nr_pages =DIV_ROUND_UP (offs + size,PAGE_SIZE ); + + m->page_list =kcalloc (m->nr_pages, +sizeof (struct page *) +sizeof (dma_addr_t), +GFP_KERNEL ); +if (!m->page_list) { +dev_err (&pci_dev->dev,"err: alloc page_list failed\n" ); + m->nr_pages =0 ; + m->u_vaddr =NULL ; + m->size =0 ;/* mark unused and not added */ +return -ENOMEM ; + } + m->dma_list = (dma_addr_t *)(m->page_list + m->nr_pages); + +/* pin user pages in memory */ + rc =get_user_pages_fast (data &PAGE_MASK ,/* page aligned addr */ + m->nr_pages, +1 ,/* write by caller */ + m->page_list);/* ptrs to pages */ + +/* assumption: get_user_pages can be killed by signals. */ +if (rc < m->nr_pages) { +free_user_pages (m->page_list, rc,0 ); + rc = -EFAULT ; + goto fail_get_user_pages; + } + + rc =genwqe_map_pages (cd, m->page_list, m->nr_pages, m->dma_list); +if (rc !=0 ) + goto fail_free_user_pages; + +return 0 ; + + fail_free_user_pages: +free_user_pages (m->page_list, m->nr_pages,0 ); + + fail_get_user_pages: +kfree (m->page_list); + m->page_list =NULL ; + m->dma_list =NULL ; + m->nr_pages =0 ; + m->u_vaddr =NULL ; + m->size =0 ;/* mark unused and not added */ +return rc; +} + +/** +* user_vunmap() - Undo mapping of user-space memory to virtual kernel memory +* @cd: pointer to genwqe device +* @m: mapping params +*/ +int user_vunmap (struct genwqe_dev *cd,struct dma_mapping *m, +struct ddcb_requ *req) +{ +struct pci_dev *pci_dev = cd->pci_dev; + +if (!dma_mapping_used (m)) { +dev_err (&pci_dev->dev,"[%s] err: mapping %p not used!\n" , + __func__, m); +return -EINVAL ; + } + +if (m->dma_list) +genwqe_unmap_pages (cd, m->dma_list, m->nr_pages); + +if (m->page_list) { +free_user_pages (m->page_list, m->nr_pages,1 ); + +kfree (m->page_list); + m->page_list =NULL ; + m->dma_list =NULL ; + m->nr_pages =0 ; + } + + m->u_vaddr =NULL ; + m->size =0 ;/* mark as unused and not added */ +return 0 ; +} + +/** +* genwqe_card_type() - Get chip type SLU Configuration Register +* @cd: pointer to the genwqe device descriptor +* Return: 0: Altera Stratix-IV 230 +* 1: Altera Stratix-IV 530 +* 2: Altera Stratix-V A4 +* 3: Altera Stratix-V A7 +*/ +u8 genwqe_card_type (struct genwqe_dev *cd) +{ +u64 card_type = cd->slu_unitcfg; +return (u8)((card_type &SLU_UNITCFG_TYPE_MASK ) >>20 ); +} + +/** +* genwqe_card_reset() - Reset the card +* @cd: pointer to the genwqe device descriptor +*/ +int genwqe_card_reset (struct genwqe_dev *cd) +{ +u64 softrst; +struct pci_dev *pci_dev = cd->pci_dev; + +if (!genwqe_is_privileged (cd)) +return -ENODEV ; + +/* new SL */ +__genwqe_writeq (cd,IO_SLC_CFGREG_SOFTRESET ,0x1ull ); +msleep (1000 ); +__genwqe_readq (cd,IO_HSU_FIR_CLR ); +__genwqe_readq (cd,IO_APP_FIR_CLR ); +__genwqe_readq (cd,IO_SLU_FIR_CLR ); + +/* +* Read-modify-write to preserve the stealth bits +* +* For SL >= 039, Stealth WE bit allows removing +* the read-modify-wrote. +* r-m-w may require a mask 0x3C to avoid hitting hard +* reset again for error reset (should be 0, chicken). +*/ + softrst =__genwqe_readq (cd,IO_SLC_CFGREG_SOFTRESET ) &0x3cull ; +__genwqe_writeq (cd,IO_SLC_CFGREG_SOFTRESET , softrst |0x2ull ); + +/* give ERRORRESET some time to finish */ +msleep (50 ); + +if (genwqe_need_err_masking (cd)) { +dev_info (&pci_dev->dev, +"[%s] masking errors for old bitstreams\n" , __func__); +__genwqe_writeq (cd,IO_SLC_MISC_DEBUG ,0x0aull ); + } +return 0 ; +} + +int genwqe_read_softreset (struct genwqe_dev *cd) +{ +u64 bitstream; + +if (!genwqe_is_privileged (cd)) +return -ENODEV ; + + bitstream =__genwqe_readq (cd,IO_SLU_BITSTREAM ) &0x1 ; + cd->softreset = (bitstream ==0 ) ?0x8ull :0xcull ; +return 0 ; +} + +/** +* genwqe_set_interrupt_capability() - Configure MSI capability structure +* @cd: pointer to the device +* Return: 0 if no error +*/ +int genwqe_set_interrupt_capability (struct genwqe_dev *cd,int count) +{ +int rc; +struct pci_dev *pci_dev = cd->pci_dev; + + rc =pci_enable_msi_block (pci_dev, count); +if (rc ==0 ) + cd->flags |=GENWQE_FLAG_MSI_ENABLED ; +return rc; +} + +/** +* genwqe_reset_interrupt_capability() - Undo genwqe_set_interrupt_capability() +* @cd: pointer to the device +*/ +void genwqe_reset_interrupt_capability (struct genwqe_dev *cd) +{ +struct pci_dev *pci_dev = cd->pci_dev; + +if (cd->flags &GENWQE_FLAG_MSI_ENABLED ) { +pci_disable_msi (pci_dev); + cd->flags &= ~GENWQE_FLAG_MSI_ENABLED ; + } +} + +/** +* set_reg_idx() - Fill array with data. Ignore illegal offsets. +* @cd: card device +* @r: debug register array +* @i: index to desired entry +* @m: maximum possible entries +* @addr: addr which is read +* @index: index in debug array +* @val: read value +*/ +static int set_reg_idx (struct genwqe_dev *cd,struct genwqe_reg *r, +unsigned int *i,unsigned int m,u32 addr,u32 idx, +u64 val) +{ +if (WARN_ON_ONCE (*i >= m)) +return -EFAULT ; + + r[*i].addr = addr; + r[*i].idx = idx; + r[*i].val = val; + ++*i; +return 0 ; +} + +static int set_reg (struct genwqe_dev *cd,struct genwqe_reg *r, +unsigned int *i,unsigned int m,u32 addr,u64 val) +{ +return set_reg_idx (cd, r, i, m, addr,0 , val); +} + +int genwqe_read_ffdc_regs (struct genwqe_dev *cd,struct genwqe_reg *regs, +unsigned int max_regs,int all) +{ +unsigned int i, j, idx =0 ; +u32 ufir_addr, ufec_addr, sfir_addr, sfec_addr; +u64 gfir, sluid, appid, ufir, ufec, sfir, sfec; + +/* Global FIR */ + gfir =__genwqe_readq (cd,IO_SLC_CFGREG_GFIR ); +set_reg (cd, regs, &idx, max_regs,IO_SLC_CFGREG_GFIR , gfir); + +/* UnitCfg for SLU */ + sluid =__genwqe_readq (cd,IO_SLU_UNITCFG );/* 0x00000000 */ +set_reg (cd, regs, &idx, max_regs,IO_SLU_UNITCFG , sluid); + +/* UnitCfg for APP */ + appid =__genwqe_readq (cd,IO_APP_UNITCFG );/* 0x02000000 */ +set_reg (cd, regs, &idx, max_regs,IO_APP_UNITCFG , appid); + +/* Check all chip Units */ +for (i =0 ; i <GENWQE_MAX_UNITS ; i++) { + +/* Unit FIR */ + ufir_addr = (i <<24 ) |0x008 ; + ufir =__genwqe_readq (cd, ufir_addr); +set_reg (cd, regs, &idx, max_regs, ufir_addr, ufir); + +/* Unit FEC */ + ufec_addr = (i <<24 ) |0x018 ; + ufec =__genwqe_readq (cd, ufec_addr); +set_reg (cd, regs, &idx, max_regs, ufec_addr, ufec); + +for (j =0 ; j <64 ; j++) { +/* wherever there is a primary 1, read the 2ndary */ +if (!all && (!(ufir & (1ull << j)))) +continue ; + + sfir_addr = (i <<24 ) | (0x100 +8 * j); + sfir =__genwqe_readq (cd, sfir_addr); +set_reg (cd, regs, &idx, max_regs, sfir_addr, sfir); + + sfec_addr = (i <<24 ) | (0x300 +8 * j); + sfec =__genwqe_readq (cd, sfec_addr); +set_reg (cd, regs, &idx, max_regs, sfec_addr, sfec); + } + } + +/* fill with invalid data until end */ +for (i = idx; i < max_regs; i++) { + regs[i].addr =0xffffffff ; + regs[i].val =0xffffffffffffffffull ; + } +return idx; +} + +/** +* genwqe_ffdc_buff_size() - Calculates the number of dump registers +*/ +int genwqe_ffdc_buff_size (struct genwqe_dev *cd,int uid) +{ +int entries =0 , ring, traps, traces, trace_entries; +uint32_t eevptr_addr, l_addr, d_len, d_type; +uint64_t eevptr, val, addr; + + eevptr_addr =UID_OFFS (uid) |IO_EXTENDED_ERROR_POINTER ; + eevptr =__genwqe_readq (cd, eevptr_addr); + +if ((eevptr !=0x0 ) && (eevptr !=-1ull )) { + l_addr =UID_OFFS (uid) | eevptr; + +while (1 ) { + val =__genwqe_readq (cd, l_addr); + +if ((val ==0x0 ) || (val ==-1ull )) +break ; + +/* 38:24 */ + d_len = (val &0x0000007fff000000ull ) >>24 ; + +/* 39 */ + d_type = (val &0x0000008000000000ull ) >>36 ; + +if (d_type) {/* repeat */ + entries += d_len; + }else {/* size in bytes! */ + entries += d_len >>3 ; + } + + l_addr +=8 ; + } + } + +for (ring =0 ; ring <8 ; ring++) { + addr =UID_OFFS (uid) |IO_EXTENDED_DIAG_MAP (ring); + val =__genwqe_readq (cd, addr); + +if ((val ==0x0ull ) || (val ==-1ull )) +continue ; + + traps = (val >>24 ) &0xff ; + traces = (val >>16 ) &0xff ; + trace_entries = val &0xffff ; + + entries += traps + (traces * trace_entries); + } +return entries; +} + +/** +* genwqe_ffdc_buff_read() - Implements LogoutExtendedErrorRegisters procedure +*/ +int genwqe_ffdc_buff_read (struct genwqe_dev *cd,int uid, +struct genwqe_reg *regs,unsigned int max_regs) +{ +int i, traps, traces, trace, trace_entries, trace_entry, ring; +unsigned int idx =0 ; +uint32_t eevptr_addr, l_addr, d_addr, d_len, d_type; +uint64_t eevptr, e, val, addr; + + eevptr_addr =UID_OFFS (uid) |IO_EXTENDED_ERROR_POINTER ; + eevptr =__genwqe_readq (cd, eevptr_addr); + +if ((eevptr !=0x0 ) && (eevptr !=0xffffffffffffffffull )) { + l_addr =UID_OFFS (uid) | eevptr; +while (1 ) { + e =__genwqe_readq (cd, l_addr); +if ((e ==0x0 ) || (e ==0xffffffffffffffffull )) +break ; + + d_addr = (e &0x0000000000ffffffull );/* 23:0 */ + d_len = (e &0x0000007fff000000ull ) >>24 ;/* 38:24 */ + d_type = (e &0x0000008000000000ull ) >>36 ;/* 39 */ + d_addr |=UID_OFFS (uid); + +if (d_type) { +for (i =0 ; i < (int )d_len; i++) { + val =__genwqe_readq (cd, d_addr); +set_reg_idx (cd, regs, &idx, max_regs, + d_addr, i, val); + } + }else { + d_len >>=3 ;/* Size in bytes! */ +for (i =0 ; i < (int )d_len; i++, d_addr +=8 ) { + val =__genwqe_readq (cd, d_addr); +set_reg_idx (cd, regs, &idx, max_regs, + d_addr,0 , val); + } + } + l_addr +=8 ; + } + } + +/* +* To save time, there are only 6 traces poplulated on Uid=2, +* Ring=1. each with iters=512. +*/ +for (ring =0 ; ring <8 ; ring++) {/* 0 is fls, 1 is fds, +2...7 are ASI rings */ + addr =UID_OFFS (uid) |IO_EXTENDED_DIAG_MAP (ring); + val =__genwqe_readq (cd, addr); + +if ((val ==0x0ull ) || (val ==-1ull )) +continue ; + + traps = (val >>24 ) &0xff ;/* Number of Traps */ + traces = (val >>16 ) &0xff ;/* Number of Traces */ + trace_entries = val &0xffff ;/* Entries per trace */ + +/* Note: This is a combined loop that dumps both the traps */ +/* (for the trace == 0 case) as well as the traces 1 to */ +/* 'traces'. */ +for (trace =0 ; trace <= traces; trace++) { +uint32_t diag_sel = +EXTENDED_DIAG_SELECTOR (ring, trace); + + addr =UID_OFFS (uid) |IO_EXTENDED_DIAG_SELECTOR ; +__genwqe_writeq (cd, addr, diag_sel); + +for (trace_entry =0 ; + trace_entry < (trace ? trace_entries : traps); + trace_entry++) { + addr =UID_OFFS (uid)|IO_EXTENDED_DIAG_READ_MBX ; + val =__genwqe_readq (cd, addr); +set_reg_idx (cd, regs, &idx, max_regs, addr, + (diag_sel<<16 ) | trace_entry, val); + } + } + } +return 0 ; +} + +/** +* genwqe_write_jtimer() - Write jobtimeout register +* +* Sets the jobtimeout and heartbeat rate timers for this queue. +* Note, this register is accessible only to the PF through the +* VF-window. It is not intended for the VF to initialize this. +* +* It is an error to write to this register while the queue is active, +* i.e. when Queue Status(7:6) != 0. +*/ +int genwqe_write_jtimer (struct genwqe_dev *cd,int func,u64 jtimer) +{ +__genwqe_writeq (cd,IO_PF_SLC_VIRTUAL_WINDOW , func &0xf ); +__genwqe_writeq (cd,IO_SLC_VF_APPJOB_TIMEOUT , jtimer); +return 0 ; +} + +u64 genwqe_read_jtimer (struct genwqe_dev *cd,int func) +{ +u64 jtimer; + +__genwqe_writeq (cd,IO_PF_SLC_VIRTUAL_WINDOW , func &0xf ); + jtimer =__genwqe_readq (cd,IO_SLC_VF_APPJOB_TIMEOUT ); + +return jtimer; +} + +/** +* genwqe_base_clock_frequency() - Deteremine base clock frequency of the card +* +* Note: From a design perspective it turned out to be a bad idea to +* use codes here to specifiy the frequency/speed values. An old +* driver cannot understand new codes and is therefore always a +* problem. Better is to measure out the value or put the +* speed/frequency directly into a register which is always a valid +* value for old as well as for new software. +* +* Return: Card clock in MHz +*/ +int genwqe_base_clock_frequency (struct genwqe_dev *cd) +{ +u16 speed;/* MHz MHz MHz MHz */ +static const int speed_grade[] = {250 ,200 ,166 ,175 }; + + speed = (u16)((cd->slu_unitcfg >>28 ) &0x0full ); +if (speed >=ARRAY_SIZE (speed_grade)) +return 0 ;/* illegal value */ + +return speed_grade[speed]; +} + +/** +* genwqe_stop_traps() - Stop traps +* +* Before reading out the analysis data, we need to stop the traps. +*/ +void genwqe_stop_traps (struct genwqe_dev *cd) +{ +/* Halt the traps while dumping FFDC. */ +__genwqe_writeq (cd,IO_SLC_MISC_DEBUG_SET ,0xcull ); +} + +/** +* genwqe_start_traps() - Start traps +* +* After having read the data, we can/must enable the traps again. +*/ +void genwqe_start_traps (struct genwqe_dev *cd) +{ +/* Restart the traps. */ +__genwqe_writeq (cd,IO_SLC_MISC_DEBUG_CLR ,0xcull ); + +if (genwqe_need_err_masking (cd)) +__genwqe_writeq (cd,IO_SLC_MISC_DEBUG ,0x0aull ); +}
Signature · 1 line
1.7.1
Greg KH
maintainerRe: [PATCH 3/6] GenWQE Utility functions
drivers/misc/genwqe/card_utils.c line 177
Quoted 12 lines · Frank Haverkamp
drivers/misc/genwqe/card_utils.c new file +12
-0+/** +* init_crc32() - Prepare a lookup table for fast crc32 calculations +* +* Existing kernel functions seem to use a different polynom, +* therefore we could not use them here. +* +* Genwqe's Polynomial = 0x20044009 +*/ +#define CRC32_POLYNOMIAL 0x20044009 +static u32 crc32_tab[256 ];/* crc32 lookup table */ + +void init_crc32 (void )
That's a _very_ generic function name to now be global in the whole kernel.
And why not just add new polynomial functionality to the existing crc32 in-kernel code instead of rolling your own here?
Quoted 11 lines
drivers/misc/genwqe/card_utils.c new file +11
-0+static void genwqe_dump_sgl (struct genwqe_dev *cd,struct sg_entry *sgl, +size_t sgl_size) +{ +unsigned int i, j; +struct pci_dev *pci_dev = cd->pci_dev; + +for (j =0 , i =0 ; i < sgl_size/sizeof (struct sg_entry ); i++, j++) { +if (j ==8 ) { +dev_info (&pci_dev->dev," --\n" ); + j =0 ; + }
drivers/misc/genwqe/card_utils.c line 336
Quoted 10 lines
drivers/misc/genwqe/card_utils.c new file +10
-0+dev_info (&pci_dev->dev," %016llx %08x %08x %s\n" , +be64_to_cpu (sgl[i].target_addr), +be32_to_cpu (sgl[i].len), +be32_to_cpu (sgl[i].flags), + (be32_to_cpu (sgl[i].len) >PAGE_SIZE ) ?"C" :"" ); + +if (be32_to_cpu (sgl[i].flags) ==SG_END_LIST ) +break ; + } +}
That's a lot of kernel log mess, why?
Quoted 39 lines
drivers/misc/genwqe/card_utils.c new file +39
-0+/** +* free_user_pages() - Give pinned pages back +* +* Documentation of get_user_pages is in mm/memory.c: +* +* If the page is written to, set_page_dirty (or set_page_dirty_lock, +* as appropriate) must be called after the page is finished with, and +* before put_page is called. +*/ +static int free_user_pages (struct page **page_list,unsigned int nr_pages, +int dirty) +{ +unsigned int i; + +for (i =0 ; i < nr_pages; i++) { +if (page_list[i] !=NULL ) { +if (dirty) +set_page_dirty_lock (page_list[i]); +put_page (page_list[i]); + } + } +return 0 ; +} + +/** +* user_vmap() - Map user-space memory to virtual kernel memory +* @cd: pointer to genwqe device +* @m: mapping params +* @uaddr: user virtual address +* @size: size of memory to be mapped +* +* We need to think about how we could speed this up. Of course it is +* not a good idea to do this over and over again, like we are +* currently doing it. Nevertheless, I am curious where on the path +* the performance is spend. Most probably within the memory +* allocation functions, but maybe also in the DMA mapping code. +* +* Restrictions: The maximum size of the possible mapping currently depends +* on the amount of memory we can get using kzalloc() for the
drivers/misc/genwqe/card_utils.c line 496
Quoted 10 lines
drivers/misc/genwqe/card_utils.c new file +10
-0+* page_list and pci_alloc_coherent for the sg_list. +* The sg_list is currently itself not scattered, which could +* be fixed with some effort. The page_list must be split into +* PAGE_SIZE chunks too. All that will make the complicated +* code more complicated. +* +* Return: 0 if success +*/ +int user_vmap (struct genwqe_dev *cd,struct dma_mapping *m,void *uaddr, +unsigned long size,struct ddcb_requ *req)
Again, _very_ generic global symbol name. Please audit all of these.
And shouldn't this just be a core mm function? Why is this in a driver?
drivers/misc/genwqe/card_utils.c line 564
Quoted 7 lines
drivers/misc/genwqe/card_utils.c new file +7
-0+/** +* user_vunmap() - Undo mapping of user-space memory to virtual kernel memory +* @cd: pointer to genwqe device +* @m: mapping params +*/ +int user_vunmap (struct genwqe_dev *cd,struct dma_mapping *m, +struct ddcb_requ *req)
Same as above.
thanks,
greg k-h
Re: [PATCH 3/6] GenWQE Utility functions
Hi Greg,
Am Mittwoch, den 27.11.2013, 11:26 -0800 schrieb Greg KH:
Quoted 17 lines · Frank Haverkamp
drivers/misc/genwqe/card_utils.c line 177
Quoted 12 lines
drivers/misc/genwqe/card_utils.c new file +12
-0+/** +* init_crc32() - Prepare a lookup table for fast crc32 calculations +* +* Existing kernel functions seem to use a different polynom, +* therefore we could not use them here. +* +* Genwqe's Polynomial = 0x20044009 +*/ +#define CRC32_POLYNOMIAL 0x20044009 +static u32 crc32_tab[256 ];/* crc32 lookup table */ + +void init_crc32 (void )That's a _very_ generic function name to now be global in the whole kernel.
Quoted 3 lines
And why not just add new polynomial functionality to the existing crc32 in-kernel code instead of rolling your own here?
The name is indeed to generic. I fixed that. It is for sure a candidate to be covered by the in-kernel crc support. I had a look and found that
static void crc32init_be(void)
is unfortunately defined static and that the polynomial is missing. Maybe:
void crc32init_be_generic(const uint32_t polynomial,
uint32_t (*tab)[256])
inline u32 __pure crc32_be_generic(u32 crc, unsigned char const *p,
size_t len, const u32 (*tab)[256],
u32 polynomial)would be good to have. Adding my own "crc32table_genwqe_be[]" to the generic code might be waste memory. None except of us are using that particular polynomial, as far as I saw. So enhancing the table generation function and exporting that and the crc32_be_generic might be a good idea.
In my latest version of the patchset I did not include such a proposal (yet).
Quoted 15 lines
Quoted 15 lines
drivers/misc/genwqe/card_utils.c new file +15
-0+static void genwqe_dump_sgl (struct genwqe_dev *cd,struct sg_entry *sgl, +size_t sgl_size) +{ +unsigned int i, j; +struct pci_dev *pci_dev = cd->pci_dev; + +for (j =0 , i =0 ; i < sgl_size/sizeof (struct sg_entry ); i++, j++) { +if (j ==8 ) { +dev_info (&pci_dev->dev," --\n" ); + j =0 ; + } + dev_info(&pci_dev->dev, " %016llx %08x %08x %s\n", + be64_to_cpu(sgl[i].target_addr), + be32_to_cpu(sgl[i].len), + be32_to_cpu(sgl[i].flags),
Quoted 8 lines
drivers/misc/genwqe/card_utils.c line 336
Quoted 6 lines
drivers/misc/genwqe/card_utils.c new file +6
-0+ (be32_to_cpu(sgl[i].len) > PAGE_SIZE) ? "C" : ""); + +if (be32_to_cpu (sgl[i].flags) ==SG_END_LIST ) +break ; + } +}That's a lot of kernel log mess, why?
I removed it. It was for debugging the scatter gather lists our hardware uses. Since it works now, I can get rid of the printing.
Quoted 43 lines
Quoted 43 lines
drivers/misc/genwqe/card_utils.c new file +43
-0+/** +* free_user_pages() - Give pinned pages back +* +* Documentation of get_user_pages is in mm/memory.c: +* +* If the page is written to, set_page_dirty (or set_page_dirty_lock, +* as appropriate) must be called after the page is finished with, and +* before put_page is called. +*/ +static int free_user_pages (struct page **page_list,unsigned int nr_pages, +int dirty) +{ +unsigned int i; + +for (i =0 ; i < nr_pages; i++) { +if (page_list[i] !=NULL ) { +if (dirty) +set_page_dirty_lock (page_list[i]); +put_page (page_list[i]); + } + } +return 0 ; +} + +/** +* user_vmap() - Map user-space memory to virtual kernel memory +* @cd: pointer to genwqe device +* @m: mapping params +* @uaddr: user virtual address +* @size: size of memory to be mapped +* +* We need to think about how we could speed this up. Of course it is +* not a good idea to do this over and over again, like we are +* currently doing it. Nevertheless, I am curious where on the path +* the performance is spend. Most probably within the memory +* allocation functions, but maybe also in the DMA mapping code. +* +* Restrictions: The maximum size of the possible mapping currently depends +* on the amount of memory we can get using kzalloc() for the +* page_list and pci_alloc_coherent for the sg_list. +* The sg_list is currently itself not scattered, which could +* be fixed with some effort. The page_list must be split into +* PAGE_SIZE chunks too. All that will make the complicated
Quoted 8 lines
drivers/misc/genwqe/card_utils.c line 496
Quoted 6 lines
+ * code more complicated.
+ *
+ * Return: 0 if success
+ */drivers/misc/genwqe/card_utils.c new file +2
-0+int user_vmap (struct genwqe_dev *cd,struct dma_mapping *m,void *uaddr, +unsigned long size,struct ddcb_requ *req)Again, _very_ generic global symbol name. Please audit all of these.
I prefixed those and found some others too. I hope that I have found all similar cases in our code.
Quoted 1 line
And shouldn't this just be a core mm function? Why is this in a driver?
The current implementation is at the moment not generic enough to be useful for others. But you are right, something alike might be useful if there is a 2nd or 3rd user with same/similar needs.
Quoted 10 lines
drivers/misc/genwqe/card_utils.c line 564
Quoted 7 lines
drivers/misc/genwqe/card_utils.c new file +7
-0+/** +* user_vunmap() - Undo mapping of user-space memory to virtual kernel memory +* @cd: pointer to genwqe device +* @m: mapping params +*/ +int user_vunmap (struct genwqe_dev *cd,struct dma_mapping *m, +struct ddcb_requ *req)Same as above.
Quoted 4 lines
thanks,
greg k-h
Regards
Frank
PATCH 4/6 GenWQE Debugfs interfaces
In reply to Frank HaverkampDebugfs interfaces for the GenWQE card. Help to debug potential problems. Dump internal chip state for debugging and failure determination.
Co-authors: Joerg-Stephan Vogt <[email protected]>,
Michael Jung <[email protected]>, Michael Ruettger <[email protected]>
--- Documentation/ABI/testing/debugfs-driver-genwqe | 70 ++++ drivers/misc/genwqe/card_debugfs.c | 480 +++++++++++++++++++++++ 2 files changed, 550 insertions(+), 0 deletions(-) create mode 100644 Documentation/ABI/testing/debugfs-driver-genwqe create mode 100644 drivers/misc/genwqe/card_debugfs.c
Documentation/ABI/testing/debugfs-driver-genwqe new file +70 -0
@@ -0,0 +1,70 @@ +What: /sys/kernel/debug/genwqe/genwqe<n>_card/ddcb_info +Date: Oct 2013 +Contact: [email protected] +Description: DDCB queue dump used for debugging queueing problems. + +What: /sys/kernel/debug/genwqe/genwqe<n>_card/curr_regs +Date: Oct 2013 +Contact: [email protected] +Description: Dump of the current error registers. + +What: /sys/kernel/debug/genwqe/genwqe<n>_card/curr_dbg_uid0 +Date: Oct 2013 +Contact: [email protected] +Description: Internal chip state of UID0 (unit id 0). + +What: /sys/kernel/debug/genwqe/genwqe<n>_card/curr_dbg_uid1 +Date: Oct 2013 +Contact: [email protected] +Description: Internal chip state of UID1. + +What: /sys/kernel/debug/genwqe/genwqe<n>_card/curr_dbg_uid2 +Date: Oct 2013 +Contact: [email protected] +Description: Internal chip state of UID2. + +What: /sys/kernel/debug/genwqe/genwqe<n>_card/prev_regs +Date: Oct 2013 +Contact: [email protected] +Description: Dump of the error registers before the last reset of + the card occured. + +What: /sys/kernel/debug/genwqe/genwqe<n>_card/prev_dbg_uid0 +Date: Oct 2013 +Contact: [email protected] +Description: Internal chip state of UID0 before card was reset. + +What: /sys/kernel/debug/genwqe/genwqe<n>_card/prev_dbg_uid1 +Date: Oct 2013 +Contact: [email protected] +Description: Internal chip state of UID1 before card was reset. + +What: /sys/kernel/debug/genwqe/genwqe<n>_card/prev_dbg_uid2 +Date: Oct 2013 +Contact: [email protected] +Description: Internal chip state of UID2 before card was reset. + +What: /sys/kernel/debug/genwqe/genwqe<n>_card/info +Date: Oct 2013 +Contact: [email protected] +Description: Comprehensive summary of bitstream version and software + version. Used bitstream and bitstream clocking information. + +What: /sys/kernel/debug/genwqe/genwqe<n>_card/err_inject +Date: Oct 2013 +Contact: [email protected] +Description: Possibility to inject error cases to ensure that the drivers + error handling code works well. + +What: /sys/kernel/debug/genwqe/genwqe<n>_card/vf<0..14>_jobtimeout_msec +Date: Oct 2013 +Contact: [email protected] +Description: Default VF timeout 250ms. Testing might require 1000ms. + Using 0 will use the cards default value (whatever that is). + + The timeout depends on the max number of available cards + in the system and the maximum allowed queue size. + + The driver ensures that the settings are done just before + the VFs get enabled. Changing the timeouts in flight is not + possible.
drivers/misc/genwqe/card_debugfs.c new file +480 -0
480 lines not on this page · raw message
Signature · 1 line
1.7.1
PATCH 5/6 GenWQE Sysfs interfaces
In reply to Frank HaverkampSysfs interfaces for the GenWQE card. There are attributes to query the version of the bitstream as well as some for the driver. For debugging, please also see the debugfs interfaces of this driver.
Co-authors: Joerg-Stephan Vogt <[email protected]>,
Michael Jung <[email protected]>, Michael Ruettger <[email protected]>
--- Documentation/ABI/testing/sysfs-driver-genwqe | 50 +++++ drivers/misc/genwqe/card_sysfs.c | 277 +++++++++++++++++++++++++ 2 files changed, 327 insertions(+), 0 deletions(-) create mode 100644 Documentation/ABI/testing/sysfs-driver-genwqe create mode 100644 drivers/misc/genwqe/card_sysfs.c
Documentation/ABI/testing/sysfs-driver-genwqe new file +50 -0
@@ -0,0 +1,50 @@ +What: /sys/class/genwqe/genwqe<n>_card/version +Date: Oct 2013 +Contact: [email protected] +Description: Unique bitstream identification e.g. + '0000000330336283.00000000475a4950'. + +What: /sys/class/genwqe/genwqe<n>_card/appid +Date: Oct 2013 +Contact: [email protected] +Description: Identifies the currently active card application e.g. 'GZIP' + for compression/decompression. + +What: /sys/class/genwqe/genwqe<n>_card/type +Date: Oct 2013 +Contact: [email protected] +Description: Type of the card e.g. 'GenWQE5-A7'. + +What: /sys/class/genwqe/genwqe<n>_card/curr_bitstream +Date: Oct 2013 +Contact: [email protected] +Description: Currently active bitstream. 1 is default, 0 is backup. + +What: /sys/class/genwqe/genwqe<n>_card/next_bitstream +Date: Oct 2013 +Contact: [email protected] +Description: Interface to set the next bitstream to be used. + +What: /sys/class/genwqe/genwqe<n>_card/tempsens +Date: Oct 2013 +Contact: [email protected] +Description: Interface to read the cards temperature sense register. + +What: /sys/class/genwqe/genwqe<n>_card/state +Date: Oct 2013 +Contact: [email protected] +Description: State of the card: "unused", "used", "error". + +What: /sys/class/genwqe/genwqe<n>_card/base_clock +Date: Oct 2013 +Contact: [email protected] +Description: Base clock frequency of the card. + +What: /sys/class/genwqe/genwqe<n>_card/device/sriov_numvfs +Date: Oct 2013 +Contact: [email protected] +Description: Enable VFs (1..15): + sudo sh -c 'echo 15 > \ + /sys/bus/pci/devices/0000\:1b\:00.0/sriov_numvfs' + Disable VFs: + Write a 0 into the same sysfs entry.
drivers/misc/genwqe/card_sysfs.c new file +277 -0
277 lines not on this page · raw message
Signature · 1 line
1.7.1
Greg KH
maintainerRe: [PATCH 5/6] GenWQE Sysfs interfaces
drivers/misc/genwqe/card_sysfs.c line 269
Quoted 13 lines · Frank Haverkamp
drivers/misc/genwqe/card_sysfs.c new file +13
-0+/** +* genwqe_init_sysfs() - Setup sysfs entries of the card device +*/ +int genwqe_init_sysfs (struct genwqe_dev *cd) +{ +int rc; + + rc =sysfs_create_group (&cd->dev->kobj, &genwqe_attribute_group); +if (rc) +return -ENXIO ; + +return 0 ; +}
Why isn't this group the "default" one for the device? That way you don't have to explicitly create/remove it, the driver core handles it all automatically for you, and you don't race with userspace when it is created/announced.
thanks,
greg k-h
Re: [PATCH 5/6] GenWQE Sysfs interfaces
Hi Greg,
thanks for taking your time to review our code once more.
Am Mittwoch, den 27.11.2013, 11:22 -0800 schrieb Greg KH:
Quoted 11 lines · Frank Haverkamp
Quoted 10 lines
drivers/misc/genwqe/card_sysfs.c new file +10
-0+/** +* genwqe_init_sysfs() - Setup sysfs entries of the card device +*/ +int genwqe_init_sysfs (struct genwqe_dev *cd) +{ +int rc; + + rc =sysfs_create_group (&cd->dev->kobj, &genwqe_attribute_group); +if (rc) +return -ENXIO ;
Quoted 8 lines
drivers/misc/genwqe/card_sysfs.c line 250
Quoted 3 lines
drivers/misc/genwqe/card_sysfs.c new file +3
-0+ +return 0 ; +}Why isn't this group the "default" one for the device? That way you don't have to explicitly create/remove it, the driver core handles it all automatically for you, and you don't race with userspace when it is created/announced.
I found the ..._with_groups variant of device_create:
cd->dev = device_create_with_groups(cd->class_genwqe,
&cd->pci_dev->dev,
cd->devnum_genwqe, cd,
genwqe_attribute_groups,
GENWQE_DEVNAME "%u_card",
cd->card_idx);This works nicely for me too. Is that what you had in mind? It saves two functions and if it gets rid of the race, nice.
Quoted 4 lines
thanks,
greg k-h
Regards
Frank
Greg KH
maintainerRe: [PATCH 5/6] GenWQE Sysfs interfaces
Quoted 26 lines · Frank Haverkamp
Hi Greg,
thanks for taking your time to review our code once more.
Am Mittwoch, den 27.11.2013, 11:22 -0800 schrieb Greg KH:
Quoted 11 lines · Frank Haverkamp
Quoted 10 lines
drivers/misc/genwqe/card_sysfs.c new file +10
-0+/** +* genwqe_init_sysfs() - Setup sysfs entries of the card device +*/ +int genwqe_init_sysfs (struct genwqe_dev *cd) +{ +int rc; + + rc =sysfs_create_group (&cd->dev->kobj, &genwqe_attribute_group); +if (rc) +return -ENXIO ;Quoted 8 lines
drivers/misc/genwqe/card_sysfs.c line 250
Quoted 3 lines
drivers/misc/genwqe/card_sysfs.c new file +3
-0+ +return 0 ; +}Why isn't this group the "default" one for the device? That way you don't have to explicitly create/remove it, the driver core handles it all automatically for you, and you don't race with userspace when it is created/announced.
I found the ..._with_groups variant of
device_create:
Quoted 8 lines
cd->dev = device_create_with_groups(cd->class_genwqe, &cd->pci_dev->dev, cd->devnum_genwqe, cd, genwqe_attribute_groups, GENWQE_DEVNAME "%u_card", cd->card_idx);This works nicely for me too. Is that what you had in mind?
Yes, that's what it was created for :)
PATCH 6/6 GenWQE Enable driver
In reply to Frank HaverkampEnable possiblity to configure and build this driver.
Co-authors: Joerg-Stephan Vogt <[email protected]>,
Michael Jung <[email protected]>, Michael Ruettger <[email protected]>
--- drivers/misc/Kconfig | 1 + drivers/misc/Makefile | 1 + drivers/misc/genwqe/Kconfig | 13 +++++++++++++ drivers/misc/genwqe/Makefile | 8 ++++++++ 4 files changed, 23 insertions(+), 0 deletions(-) create mode 100644 drivers/misc/genwqe/Kconfig create mode 100644 drivers/misc/genwqe/Makefile
drivers/misc/Kconfig +1 -0
@@ -537,4 +537,5 @@ source "drivers/misc/carma/Kconfig" source "drivers/misc/altera-stapl/Kconfig" source "drivers/misc/mei/Kconfig" source "drivers/misc/vmw_vmci/Kconfig" +source "drivers/misc/genwqe/Kconfig" endmenu
drivers/misc/Makefile +1 -0
@@ -53,3 +53,4 @@ obj-$(CONFIG_INTEL_MEI) += mei/ obj-$(CONFIG_VMWARE_VMCI) += vmw_vmci/ obj-$(CONFIG_LATTICE_ECP3_CONFIG) += lattice-ecp3-config.o obj-$(CONFIG_SRAM) += sram.o +obj-$(CONFIG_GENWQE) += genwqe/
drivers/misc/genwqe/Kconfig new file +13 -0
@@ -0,0 +1,13 @@ +# +# IBM Accelerator Family 'GenWQE' +# + +menuconfig GENWQE + tristate "GenWQE PCIe Accelerator" + depends on PCI && 64BIT + select CRC_ITU_T + default n + help + Enables PCIe card driver for IBM GenWQE accelerators. + The user-space interface is described in + include/linux/genwqe/genwqe_card.h.
drivers/misc/genwqe/Makefile new file +8 -0
@@ -0,0 +1,8 @@ +# +# Makefile for GenWQE driver +# + +# card driver +obj-$(CONFIG_GENWQE) := genwqe_card.o +genwqe_card-objs := card_base.o card_dev.o card_ddcb.o card_sysfs.o \ + card_debugfs.o card_utils.o
Signature · 1 line
1.7.1
Hello Greg and others,
is the patchset ok this way, or do you see anything more I should change/improve?
Regards
Frank
Greg KH
maintainerQuoted 4 lines · Frank Haverkamp
Hello Greg and others,
is the patchset ok this way, or do you see anything more I should change/improve?
It is the middle of the 3.13-rc1 merge window, and we are all busy off doing other work at the moment. So please give us a chance to catch up with that, and then, after -rc1 is out, I'll get back to my pending patch queue:
$ mdfrm -c ~/mail/todo 1945 messages in /home/gregkh/mail/todo
thanks,
greg k-h
Hi Greg,
Am Freitag, den 22.11.2013, 08:52 -0800 schrieb Greg KH:
Quoted 8 lines · Frank Haverkamp
Quoted 4 lines
Hello Greg and others,
is the patchset ok this way, or do you see anything more I should change/improve?
It is the middle of the 3.13-rc1 merge window, and we are all busy off doing other work at the moment.
Thanks for the information. If I saw correctly 3.13-rc1 is out now since last Friday.
Quoted 9 lines
So please give us a chance to catch up
with that, and then, after -rc1 is out, I'll get back to my pending patch queue:$ mdfrm -c ~/mail/todo 1945 messages in /home/gregkh/mail/todothanks,
greg k-h
I hope you were able to start reducing the size of your todo queue. I don't want to annoy you, but is there any progress on our GenWQE driver?
Thanks
Frank