167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * IBM Accelerator Family 'GenWQE' 367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * (C) Copyright IBM Corp. 2013 567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Author: Frank Haverkamp <haver@linux.vnet.ibm.com> 767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Author: Joerg-Stephan Vogt <jsvogt@de.ibm.com> 826d8f6f15112b8b0fbff360c360e8c42bf2bc370Frank Haverkamp * Author: Michael Jung <mijung@gmx.net> 967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Author: Michael Ruettger <michael@ibmra.de> 1067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 1167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * This program is free software; you can redistribute it and/or modify 1267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * it under the terms of the GNU General Public License (version 2 only) 1367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * as published by the Free Software Foundation. 1467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 1567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * This program is distributed in the hope that it will be useful, 1667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * but WITHOUT ANY WARRANTY; without even the implied warranty of 1767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * GNU General Public License for more details. 1967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 2067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 2167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/* 2267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Miscelanous functionality used in the other GenWQE driver parts. 2367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 2467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 2567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include <linux/kernel.h> 2667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include <linux/dma-mapping.h> 2767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include <linux/sched.h> 2867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include <linux/vmalloc.h> 2967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include <linux/page-flags.h> 3067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include <linux/scatterlist.h> 3167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include <linux/hugetlb.h> 3267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include <linux/iommu.h> 3367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include <linux/delay.h> 3467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include <linux/pci.h> 3567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include <linux/dma-mapping.h> 3667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include <linux/ctype.h> 3767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include <linux/module.h> 3867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include <linux/platform_device.h> 3967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include <linux/delay.h> 4067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include <asm/pgtable.h> 4167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 4267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include "genwqe_driver.h" 4367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include "card_base.h" 4467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#include "card_ddcb.h" 4567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 4667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 4767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * __genwqe_writeq() - Write 64-bit register 4867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @cd: genwqe device descriptor 4967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @byte_offs: byte offset within BAR 5067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @val: 64-bit value 5167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 5267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Return: 0 if success; < 0 if error 5367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 5467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampint __genwqe_writeq(struct genwqe_dev *cd, u64 byte_offs, u64 val) 5567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 56fb145456fa4f4311f90703aeee058bab3b274bf8Kleber Sacilotto de Souza struct pci_dev *pci_dev = cd->pci_dev; 57fb145456fa4f4311f90703aeee058bab3b274bf8Kleber Sacilotto de Souza 5867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (cd->err_inject & GENWQE_INJECT_HARDWARE_FAILURE) 5967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return -EIO; 6067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 6167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (cd->mmio == NULL) 6267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return -EIO; 6367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 64fb145456fa4f4311f90703aeee058bab3b274bf8Kleber Sacilotto de Souza if (pci_channel_offline(pci_dev)) 65fb145456fa4f4311f90703aeee058bab3b274bf8Kleber Sacilotto de Souza return -EIO; 66fb145456fa4f4311f90703aeee058bab3b274bf8Kleber Sacilotto de Souza 67a45a0258d1f817b60fcd5bc67dc7ef692f4615bbFrank Haverkamp __raw_writeq((__force u64)cpu_to_be64(val), cd->mmio + byte_offs); 6867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0; 6967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 7067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 7167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 7267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * __genwqe_readq() - Read 64-bit register 7367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @cd: genwqe device descriptor 7467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @byte_offs: offset within BAR 7567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 7667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Return: value from register 7767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 7867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampu64 __genwqe_readq(struct genwqe_dev *cd, u64 byte_offs) 7967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 8067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (cd->err_inject & GENWQE_INJECT_HARDWARE_FAILURE) 8167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0xffffffffffffffffull; 8267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 8367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if ((cd->err_inject & GENWQE_INJECT_GFIR_FATAL) && 8467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp (byte_offs == IO_SLC_CFGREG_GFIR)) 8567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0x000000000000ffffull; 8667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 8767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if ((cd->err_inject & GENWQE_INJECT_GFIR_INFO) && 8867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp (byte_offs == IO_SLC_CFGREG_GFIR)) 8967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0x00000000ffff0000ull; 9067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 9167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (cd->mmio == NULL) 9267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0xffffffffffffffffull; 9367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 9458d66ce732378fed7a35ca79c763057b8c1e8aedFrank Haverkamp return be64_to_cpu((__force __be64)__raw_readq(cd->mmio + byte_offs)); 9567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 9667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 9767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 9867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * __genwqe_writel() - Write 32-bit register 9967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @cd: genwqe device descriptor 10067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @byte_offs: byte offset within BAR 10167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @val: 32-bit value 10267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 10367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Return: 0 if success; < 0 if error 10467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 10567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampint __genwqe_writel(struct genwqe_dev *cd, u64 byte_offs, u32 val) 10667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 107fb145456fa4f4311f90703aeee058bab3b274bf8Kleber Sacilotto de Souza struct pci_dev *pci_dev = cd->pci_dev; 108fb145456fa4f4311f90703aeee058bab3b274bf8Kleber Sacilotto de Souza 10967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (cd->err_inject & GENWQE_INJECT_HARDWARE_FAILURE) 11067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return -EIO; 11167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 11267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (cd->mmio == NULL) 11367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return -EIO; 11467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 115fb145456fa4f4311f90703aeee058bab3b274bf8Kleber Sacilotto de Souza if (pci_channel_offline(pci_dev)) 116fb145456fa4f4311f90703aeee058bab3b274bf8Kleber Sacilotto de Souza return -EIO; 117fb145456fa4f4311f90703aeee058bab3b274bf8Kleber Sacilotto de Souza 11858d66ce732378fed7a35ca79c763057b8c1e8aedFrank Haverkamp __raw_writel((__force u32)cpu_to_be32(val), cd->mmio + byte_offs); 11967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0; 12067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 12167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 12267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 12367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * __genwqe_readl() - Read 32-bit register 12467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @cd: genwqe device descriptor 12567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @byte_offs: offset within BAR 12667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 12767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Return: Value from register 12867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 12967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampu32 __genwqe_readl(struct genwqe_dev *cd, u64 byte_offs) 13067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 13167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (cd->err_inject & GENWQE_INJECT_HARDWARE_FAILURE) 13267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0xffffffff; 13367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 13467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (cd->mmio == NULL) 13567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0xffffffff; 13667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 13758d66ce732378fed7a35ca79c763057b8c1e8aedFrank Haverkamp return be32_to_cpu((__force __be32)__raw_readl(cd->mmio + byte_offs)); 13867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 13967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 14067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 14167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * genwqe_read_app_id() - Extract app_id 14267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 14367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * app_unitcfg need to be filled with valid data first 14467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 14567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampint genwqe_read_app_id(struct genwqe_dev *cd, char *app_name, int len) 14667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 14767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp int i, j; 14867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp u32 app_id = (u32)cd->app_unitcfg; 14967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 15067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp memset(app_name, 0, len); 15167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp for (i = 0, j = 0; j < min(len, 4); j++) { 15267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp char ch = (char)((app_id >> (24 - j*8)) & 0xff); 153d9c11d45b33c9226abd50a50c87e19bfa7c7a2cbFrank Haverkamp 15467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (ch == ' ') 15567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp continue; 15667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp app_name[i++] = isprint(ch) ? ch : 'X'; 15767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 15867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return i; 15967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 16067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 16167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 16267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * genwqe_init_crc32() - Prepare a lookup table for fast crc32 calculations 16367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 16467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Existing kernel functions seem to use a different polynom, 16567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * therefore we could not use them here. 16667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 16767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Genwqe's Polynomial = 0x20044009 16867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 16967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp#define CRC32_POLYNOMIAL 0x20044009 17067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampstatic u32 crc32_tab[256]; /* crc32 lookup table */ 17167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 17267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampvoid genwqe_init_crc32(void) 17367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 17467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp int i, j; 17567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp u32 crc; 17667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 17767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp for (i = 0; i < 256; i++) { 17867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp crc = i << 24; 17967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp for (j = 0; j < 8; j++) { 18067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (crc & 0x80000000) 18167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp crc = (crc << 1) ^ CRC32_POLYNOMIAL; 18267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp else 18367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp crc = (crc << 1); 18467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 18567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp crc32_tab[i] = crc; 18667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 18767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 18867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 18967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 19067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * genwqe_crc32() - Generate 32-bit crc as required for DDCBs 19167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @buff: pointer to data buffer 19267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @len: length of data for calculation 19367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @init: initial crc (0xffffffff at start) 19467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 19567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * polynomial = x^32 * + x^29 + x^18 + x^14 + x^3 + 1 (0x20044009) 19667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 19767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Example: 4 bytes 0x01 0x02 0x03 0x04 with init=0xffffffff should 19867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * result in a crc32 of 0xf33cb7d3. 19967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 20067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * The existing kernel crc functions did not cover this polynom yet. 20167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 20267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Return: crc32 checksum. 20367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 20467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampu32 genwqe_crc32(u8 *buff, size_t len, u32 init) 20567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 20667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp int i; 20767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp u32 crc; 20867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 20967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp crc = init; 21067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp while (len--) { 21167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp i = ((crc >> 24) ^ *buff++) & 0xFF; 21267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp crc = (crc << 8) ^ crc32_tab[i]; 21367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 21467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return crc; 21567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 21667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 21767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampvoid *__genwqe_alloc_consistent(struct genwqe_dev *cd, size_t size, 21867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp dma_addr_t *dma_handle) 21967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 22067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (get_order(size) > MAX_ORDER) 22167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return NULL; 22267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 22367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return pci_alloc_consistent(cd->pci_dev, size, dma_handle); 22467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 22567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 22667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampvoid __genwqe_free_consistent(struct genwqe_dev *cd, size_t size, 22767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp void *vaddr, dma_addr_t dma_handle) 22867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 22967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (vaddr == NULL) 23067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return; 23167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 23267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp pci_free_consistent(cd->pci_dev, size, vaddr, dma_handle); 23367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 23467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 23567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampstatic void genwqe_unmap_pages(struct genwqe_dev *cd, dma_addr_t *dma_list, 23667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp int num_pages) 23767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 23867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp int i; 23967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp struct pci_dev *pci_dev = cd->pci_dev; 24067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 24167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp for (i = 0; (i < num_pages) && (dma_list[i] != 0x0); i++) { 24267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp pci_unmap_page(pci_dev, dma_list[i], 24367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp PAGE_SIZE, PCI_DMA_BIDIRECTIONAL); 24467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp dma_list[i] = 0x0; 24567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 24667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 24767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 24867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampstatic int genwqe_map_pages(struct genwqe_dev *cd, 24967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp struct page **page_list, int num_pages, 25067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp dma_addr_t *dma_list) 25167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 25267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp int i; 25367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp struct pci_dev *pci_dev = cd->pci_dev; 25467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 25567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* establish DMA mapping for requested pages */ 25667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp for (i = 0; i < num_pages; i++) { 25767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp dma_addr_t daddr; 25867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 25967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp dma_list[i] = 0x0; 26067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp daddr = pci_map_page(pci_dev, page_list[i], 26167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 0, /* map_offs */ 26267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp PAGE_SIZE, 26367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp PCI_DMA_BIDIRECTIONAL); /* FIXME rd/rw */ 26467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 26567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (pci_dma_mapping_error(pci_dev, daddr)) { 26667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp dev_err(&pci_dev->dev, 26767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp "[%s] err: no dma addr daddr=%016llx!\n", 26867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp __func__, (long long)daddr); 26967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp goto err; 27067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 27167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 27267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp dma_list[i] = daddr; 27367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 27467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0; 27567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 27667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp err: 27767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp genwqe_unmap_pages(cd, dma_list, num_pages); 27867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return -EIO; 27967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 28067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 28167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampstatic int genwqe_sgl_size(int num_pages) 28267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 28367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp int len, num_tlb = num_pages / 7; 28467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 28567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp len = sizeof(struct sg_entry) * (num_pages+num_tlb + 1); 28667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return roundup(len, PAGE_SIZE); 28767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 28867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 289718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp/** 290718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp * genwqe_alloc_sync_sgl() - Allocate memory for sgl and overlapping pages 291718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp * 292718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp * Allocates memory for sgl and overlapping pages. Pages which might 293718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp * overlap other user-space memory blocks are being cached for DMAs, 294718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp * such that we do not run into syncronization issues. Data is copied 295718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp * from user-space into the cached pages. 296718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp */ 297718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkampint genwqe_alloc_sync_sgl(struct genwqe_dev *cd, struct genwqe_sgl *sgl, 298718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp void __user *user_addr, size_t user_size) 29967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 300718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp int rc; 30167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp struct pci_dev *pci_dev = cd->pci_dev; 30267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 303718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->fpage_offs = offset_in_page((unsigned long)user_addr); 304718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->fpage_size = min_t(size_t, PAGE_SIZE-sgl->fpage_offs, user_size); 305718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->nr_pages = DIV_ROUND_UP(sgl->fpage_offs + user_size, PAGE_SIZE); 306718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->lpage_size = (user_size - sgl->fpage_size) % PAGE_SIZE; 307718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp 308d9c11d45b33c9226abd50a50c87e19bfa7c7a2cbFrank Haverkamp dev_dbg(&pci_dev->dev, "[%s] uaddr=%p usize=%8ld nr_pages=%ld fpage_offs=%lx fpage_size=%ld lpage_size=%ld\n", 309718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp __func__, user_addr, user_size, sgl->nr_pages, 310718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->fpage_offs, sgl->fpage_size, sgl->lpage_size); 311718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp 312718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->user_addr = user_addr; 313718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->user_size = user_size; 314718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->sgl_size = genwqe_sgl_size(sgl->nr_pages); 315718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp 316718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp if (get_order(sgl->sgl_size) > MAX_ORDER) { 31767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp dev_err(&pci_dev->dev, 31867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp "[%s] err: too much memory requested!\n", __func__); 319718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp return -ENOMEM; 32067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 32167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 322718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->sgl = __genwqe_alloc_consistent(cd, sgl->sgl_size, 323718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp &sgl->sgl_dma_addr); 324718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp if (sgl->sgl == NULL) { 32567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp dev_err(&pci_dev->dev, 32667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp "[%s] err: no memory available!\n", __func__); 327718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp return -ENOMEM; 32867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 32967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 330718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp /* Only use buffering on incomplete pages */ 331718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp if ((sgl->fpage_size != 0) && (sgl->fpage_size != PAGE_SIZE)) { 332718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->fpage = __genwqe_alloc_consistent(cd, PAGE_SIZE, 333718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp &sgl->fpage_dma_addr); 334718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp if (sgl->fpage == NULL) 335718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp goto err_out; 336718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp 337718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp /* Sync with user memory */ 338718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp if (copy_from_user(sgl->fpage + sgl->fpage_offs, 339718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp user_addr, sgl->fpage_size)) { 340718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp rc = -EFAULT; 341718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp goto err_out; 342718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp } 343718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp } 344718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp if (sgl->lpage_size != 0) { 345718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->lpage = __genwqe_alloc_consistent(cd, PAGE_SIZE, 346718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp &sgl->lpage_dma_addr); 347718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp if (sgl->lpage == NULL) 348718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp goto err_out1; 349718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp 350718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp /* Sync with user memory */ 351718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp if (copy_from_user(sgl->lpage, user_addr + user_size - 352718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->lpage_size, sgl->lpage_size)) { 353718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp rc = -EFAULT; 354718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp goto err_out1; 355718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp } 356718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp } 357718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp return 0; 358718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp 359718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp err_out1: 360718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp __genwqe_free_consistent(cd, PAGE_SIZE, sgl->fpage, 361718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->fpage_dma_addr); 362718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp err_out: 363718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp __genwqe_free_consistent(cd, sgl->sgl_size, sgl->sgl, 364718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->sgl_dma_addr); 365718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp return -ENOMEM; 36667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 36767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 368718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkampint genwqe_setup_sgl(struct genwqe_dev *cd, struct genwqe_sgl *sgl, 369718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp dma_addr_t *dma_list) 37067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 37167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp int i = 0, j = 0, p; 37267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp unsigned long dma_offs, map_offs; 37367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp dma_addr_t prev_daddr = 0; 37467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp struct sg_entry *s, *last_s = NULL; 375718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp size_t size = sgl->user_size; 37667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 37767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp dma_offs = 128; /* next block if needed/dma_offset */ 378718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp map_offs = sgl->fpage_offs; /* offset in first page */ 37967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 380718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp s = &sgl->sgl[0]; /* first set of 8 entries */ 38167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp p = 0; /* page */ 382718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp while (p < sgl->nr_pages) { 38367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp dma_addr_t daddr; 38467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp unsigned int size_to_map; 38567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 38667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* always write the chaining entry, cleanup is done later */ 38767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp j = 0; 388718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp s[j].target_addr = cpu_to_be64(sgl->sgl_dma_addr + dma_offs); 38967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp s[j].len = cpu_to_be32(128); 39067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp s[j].flags = cpu_to_be32(SG_CHAINED); 39167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp j++; 39267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 39367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp while (j < 8) { 39467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* DMA mapping for requested page, offs, size */ 39567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp size_to_map = min(size, PAGE_SIZE - map_offs); 396718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp 397718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp if ((p == 0) && (sgl->fpage != NULL)) { 398718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp daddr = sgl->fpage_dma_addr + map_offs; 399718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp 400718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp } else if ((p == sgl->nr_pages - 1) && 401718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp (sgl->lpage != NULL)) { 402718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp daddr = sgl->lpage_dma_addr; 403718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp } else { 404718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp daddr = dma_list[p] + map_offs; 405718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp } 406718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp 40767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp size -= size_to_map; 40867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp map_offs = 0; 40967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 41067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (prev_daddr == daddr) { 41167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp u32 prev_len = be32_to_cpu(last_s->len); 41267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 41367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* pr_info("daddr combining: " 41467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp "%016llx/%08x -> %016llx\n", 41567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp prev_daddr, prev_len, daddr); */ 41667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 41767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp last_s->len = cpu_to_be32(prev_len + 41867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp size_to_map); 41967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 42067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp p++; /* process next page */ 421718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp if (p == sgl->nr_pages) 42267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp goto fixup; /* nothing to do */ 42367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 42467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp prev_daddr = daddr + size_to_map; 42567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp continue; 42667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 42767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 42867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* start new entry */ 42967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp s[j].target_addr = cpu_to_be64(daddr); 43067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp s[j].len = cpu_to_be32(size_to_map); 43167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp s[j].flags = cpu_to_be32(SG_DATA); 43267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp prev_daddr = daddr + size_to_map; 43367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp last_s = &s[j]; 43467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp j++; 43567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 43667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp p++; /* process next page */ 437718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp if (p == sgl->nr_pages) 43867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp goto fixup; /* nothing to do */ 43967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 44067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp dma_offs += 128; 44167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp s += 8; /* continue 8 elements further */ 44267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 44367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp fixup: 44467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (j == 1) { /* combining happend on last entry! */ 44567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp s -= 8; /* full shift needed on previous sgl block */ 44667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp j = 7; /* shift all elements */ 44767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 44867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 44967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp for (i = 0; i < j; i++) /* move elements 1 up */ 45067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp s[i] = s[i + 1]; 45167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 45267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp s[i].target_addr = cpu_to_be64(0); 45367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp s[i].len = cpu_to_be32(0); 45467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp s[i].flags = cpu_to_be32(SG_END_LIST); 45567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0; 45667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 45767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 458718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp/** 459718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp * genwqe_free_sync_sgl() - Free memory for sgl and overlapping pages 460718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp * 461718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp * After the DMA transfer has been completed we free the memory for 462718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp * the sgl and the cached pages. Data is being transfered from cached 463718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp * pages into user-space buffers. 464718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp */ 465718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkampint genwqe_free_sync_sgl(struct genwqe_dev *cd, struct genwqe_sgl *sgl) 46667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 46763fa80cd582321693474f9cf9203329a2f8a8494Christian Engelmayer int rc = 0; 468718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp struct pci_dev *pci_dev = cd->pci_dev; 469718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp 470718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp if (sgl->fpage) { 471718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp if (copy_to_user(sgl->user_addr, sgl->fpage + sgl->fpage_offs, 472718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->fpage_size)) { 473718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp dev_err(&pci_dev->dev, "[%s] err: copying fpage!\n", 474718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp __func__); 475718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp rc = -EFAULT; 476718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp } 477718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp __genwqe_free_consistent(cd, PAGE_SIZE, sgl->fpage, 478718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->fpage_dma_addr); 479718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->fpage = NULL; 480718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->fpage_dma_addr = 0; 481718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp } 482718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp if (sgl->lpage) { 483718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp if (copy_to_user(sgl->user_addr + sgl->user_size - 484718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->lpage_size, sgl->lpage, 485718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->lpage_size)) { 486718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp dev_err(&pci_dev->dev, "[%s] err: copying lpage!\n", 487718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp __func__); 488718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp rc = -EFAULT; 489718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp } 490718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp __genwqe_free_consistent(cd, PAGE_SIZE, sgl->lpage, 491718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->lpage_dma_addr); 492718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->lpage = NULL; 493718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->lpage_dma_addr = 0; 494718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp } 495718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp __genwqe_free_consistent(cd, sgl->sgl_size, sgl->sgl, 496718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->sgl_dma_addr); 497718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp 498718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->sgl = NULL; 499718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->sgl_dma_addr = 0x0; 500718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp sgl->sgl_size = 0; 501718f762efc454796d02f172a929d051f2d6ec01aFrank Haverkamp return rc; 50267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 50367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 50467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 50567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * free_user_pages() - Give pinned pages back 50667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 50767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Documentation of get_user_pages is in mm/memory.c: 50867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 50967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * If the page is written to, set_page_dirty (or set_page_dirty_lock, 51067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * as appropriate) must be called after the page is finished with, and 51167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * before put_page is called. 51267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 51367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * FIXME Could be of use to others and might belong in the generic 51467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * code, if others agree. E.g. 51567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * ll_free_user_pages in drivers/staging/lustre/lustre/llite/rw26.c 51667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * ceph_put_page_vector in net/ceph/pagevec.c 51767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * maybe more? 51867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 51967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampstatic int free_user_pages(struct page **page_list, unsigned int nr_pages, 52067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp int dirty) 52167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 52267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp unsigned int i; 52367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 52467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp for (i = 0; i < nr_pages; i++) { 52567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (page_list[i] != NULL) { 52667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (dirty) 52767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp set_page_dirty_lock(page_list[i]); 52867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp put_page(page_list[i]); 52967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 53067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 53167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0; 53267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 53367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 53467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 53567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * genwqe_user_vmap() - Map user-space memory to virtual kernel memory 53667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @cd: pointer to genwqe device 53767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @m: mapping params 53867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @uaddr: user virtual address 53967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @size: size of memory to be mapped 54067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 54167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * We need to think about how we could speed this up. Of course it is 54267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * not a good idea to do this over and over again, like we are 54367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * currently doing it. Nevertheless, I am curious where on the path 54467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * the performance is spend. Most probably within the memory 54567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * allocation functions, but maybe also in the DMA mapping code. 54667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 54767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Restrictions: The maximum size of the possible mapping currently depends 54867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * on the amount of memory we can get using kzalloc() for the 54967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * page_list and pci_alloc_consistent for the sg_list. 55067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * The sg_list is currently itself not scattered, which could 55167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * be fixed with some effort. The page_list must be split into 55267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * PAGE_SIZE chunks too. All that will make the complicated 55367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * code more complicated. 55467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 55567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Return: 0 if success 55667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 55767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampint genwqe_user_vmap(struct genwqe_dev *cd, struct dma_mapping *m, void *uaddr, 55867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp unsigned long size, struct ddcb_requ *req) 55967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 56067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp int rc = -EINVAL; 56167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp unsigned long data, offs; 56267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp struct pci_dev *pci_dev = cd->pci_dev; 56367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 56467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if ((uaddr == NULL) || (size == 0)) { 56567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->size = 0; /* mark unused and not added */ 56667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return -EINVAL; 56767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 56867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->u_vaddr = uaddr; 56967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->size = size; 57067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 57167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* determine space needed for page_list. */ 57267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp data = (unsigned long)uaddr; 57367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp offs = offset_in_page(data); 57467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->nr_pages = DIV_ROUND_UP(offs + size, PAGE_SIZE); 57567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 57667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->page_list = kcalloc(m->nr_pages, 57767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp sizeof(struct page *) + sizeof(dma_addr_t), 57867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp GFP_KERNEL); 57967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (!m->page_list) { 58067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp dev_err(&pci_dev->dev, "err: alloc page_list failed\n"); 58167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->nr_pages = 0; 58267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->u_vaddr = NULL; 58367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->size = 0; /* mark unused and not added */ 58467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return -ENOMEM; 58567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 58667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->dma_list = (dma_addr_t *)(m->page_list + m->nr_pages); 58767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 58867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* pin user pages in memory */ 58967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp rc = get_user_pages_fast(data & PAGE_MASK, /* page aligned addr */ 59067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->nr_pages, 59167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 1, /* write by caller */ 59267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->page_list); /* ptrs to pages */ 59367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 59467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* assumption: get_user_pages can be killed by signals. */ 59567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (rc < m->nr_pages) { 59667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp free_user_pages(m->page_list, rc, 0); 59767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp rc = -EFAULT; 59867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp goto fail_get_user_pages; 59967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 60067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 60167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp rc = genwqe_map_pages(cd, m->page_list, m->nr_pages, m->dma_list); 60267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (rc != 0) 60367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp goto fail_free_user_pages; 60467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 60567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0; 60667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 60767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp fail_free_user_pages: 60867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp free_user_pages(m->page_list, m->nr_pages, 0); 60967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 61067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp fail_get_user_pages: 61167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp kfree(m->page_list); 61267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->page_list = NULL; 61367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->dma_list = NULL; 61467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->nr_pages = 0; 61567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->u_vaddr = NULL; 61667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->size = 0; /* mark unused and not added */ 61767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return rc; 61867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 61967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 62067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 62167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * genwqe_user_vunmap() - Undo mapping of user-space mem to virtual kernel 62267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * memory 62367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @cd: pointer to genwqe device 62467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @m: mapping params 62567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 62667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampint genwqe_user_vunmap(struct genwqe_dev *cd, struct dma_mapping *m, 62767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp struct ddcb_requ *req) 62867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 62967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp struct pci_dev *pci_dev = cd->pci_dev; 63067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 63167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (!dma_mapping_used(m)) { 63267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp dev_err(&pci_dev->dev, "[%s] err: mapping %p not used!\n", 63367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp __func__, m); 63467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return -EINVAL; 63567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 63667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 63767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (m->dma_list) 63867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp genwqe_unmap_pages(cd, m->dma_list, m->nr_pages); 63967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 64067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (m->page_list) { 64167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp free_user_pages(m->page_list, m->nr_pages, 1); 64267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 64367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp kfree(m->page_list); 64467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->page_list = NULL; 64567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->dma_list = NULL; 64667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->nr_pages = 0; 64767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 64867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 64967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->u_vaddr = NULL; 65067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp m->size = 0; /* mark as unused and not added */ 65167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0; 65267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 65367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 65467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 65567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * genwqe_card_type() - Get chip type SLU Configuration Register 65667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @cd: pointer to the genwqe device descriptor 65767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Return: 0: Altera Stratix-IV 230 65867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 1: Altera Stratix-IV 530 65967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 2: Altera Stratix-V A4 66067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 3: Altera Stratix-V A7 66167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 66267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampu8 genwqe_card_type(struct genwqe_dev *cd) 66367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 66467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp u64 card_type = cd->slu_unitcfg; 665d9c11d45b33c9226abd50a50c87e19bfa7c7a2cbFrank Haverkamp 66667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return (u8)((card_type & IO_SLU_UNITCFG_TYPE_MASK) >> 20); 66767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 66867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 66967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 67067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * genwqe_card_reset() - Reset the card 67167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @cd: pointer to the genwqe device descriptor 67267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 67367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampint genwqe_card_reset(struct genwqe_dev *cd) 67467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 67567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp u64 softrst; 67667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp struct pci_dev *pci_dev = cd->pci_dev; 67767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 67867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (!genwqe_is_privileged(cd)) 67967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return -ENODEV; 68067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 68167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* new SL */ 68267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp __genwqe_writeq(cd, IO_SLC_CFGREG_SOFTRESET, 0x1ull); 68367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp msleep(1000); 68467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp __genwqe_readq(cd, IO_HSU_FIR_CLR); 68567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp __genwqe_readq(cd, IO_APP_FIR_CLR); 68667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp __genwqe_readq(cd, IO_SLU_FIR_CLR); 68767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 68867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* 68967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Read-modify-write to preserve the stealth bits 69067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 69167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * For SL >= 039, Stealth WE bit allows removing 69267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * the read-modify-wrote. 69367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * r-m-w may require a mask 0x3C to avoid hitting hard 69467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * reset again for error reset (should be 0, chicken). 69567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 69667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp softrst = __genwqe_readq(cd, IO_SLC_CFGREG_SOFTRESET) & 0x3cull; 69767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp __genwqe_writeq(cd, IO_SLC_CFGREG_SOFTRESET, softrst | 0x2ull); 69867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 69967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* give ERRORRESET some time to finish */ 70067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp msleep(50); 70167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 70267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (genwqe_need_err_masking(cd)) { 70367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp dev_info(&pci_dev->dev, 70467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp "[%s] masking errors for old bitstreams\n", __func__); 70567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp __genwqe_writeq(cd, IO_SLC_MISC_DEBUG, 0x0aull); 70667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 70767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0; 70867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 70967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 71067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampint genwqe_read_softreset(struct genwqe_dev *cd) 71167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 71267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp u64 bitstream; 71367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 71467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (!genwqe_is_privileged(cd)) 71567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return -ENODEV; 71667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 71767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp bitstream = __genwqe_readq(cd, IO_SLU_BITSTREAM) & 0x1; 71867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp cd->softreset = (bitstream == 0) ? 0x8ull : 0xcull; 71967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0; 72067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 72167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 72267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 72367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * genwqe_set_interrupt_capability() - Configure MSI capability structure 72467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @cd: pointer to the device 72567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Return: 0 if no error 72667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 72767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampint genwqe_set_interrupt_capability(struct genwqe_dev *cd, int count) 72867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 72967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp int rc; 73067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp struct pci_dev *pci_dev = cd->pci_dev; 73167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 7327276883f1f98cd0a92fdc049f69bdc0912f7fc16Sebastian Ott rc = pci_enable_msi_range(pci_dev, 1, count); 7337276883f1f98cd0a92fdc049f69bdc0912f7fc16Sebastian Ott if (rc < 0) 7347276883f1f98cd0a92fdc049f69bdc0912f7fc16Sebastian Ott return rc; 7357276883f1f98cd0a92fdc049f69bdc0912f7fc16Sebastian Ott 7367276883f1f98cd0a92fdc049f69bdc0912f7fc16Sebastian Ott cd->flags |= GENWQE_FLAG_MSI_ENABLED; 7377276883f1f98cd0a92fdc049f69bdc0912f7fc16Sebastian Ott return 0; 73867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 73967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 74067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 74167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * genwqe_reset_interrupt_capability() - Undo genwqe_set_interrupt_capability() 74267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @cd: pointer to the device 74367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 74467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampvoid genwqe_reset_interrupt_capability(struct genwqe_dev *cd) 74567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 74667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp struct pci_dev *pci_dev = cd->pci_dev; 74767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 74867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (cd->flags & GENWQE_FLAG_MSI_ENABLED) { 74967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp pci_disable_msi(pci_dev); 75067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp cd->flags &= ~GENWQE_FLAG_MSI_ENABLED; 75167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 75267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 75367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 75467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 75567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * set_reg_idx() - Fill array with data. Ignore illegal offsets. 75667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @cd: card device 75767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @r: debug register array 75867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @i: index to desired entry 75967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @m: maximum possible entries 76067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @addr: addr which is read 76167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @index: index in debug array 76267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * @val: read value 76367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 76467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampstatic int set_reg_idx(struct genwqe_dev *cd, struct genwqe_reg *r, 76567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp unsigned int *i, unsigned int m, u32 addr, u32 idx, 76667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp u64 val) 76767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 76867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (WARN_ON_ONCE(*i >= m)) 76967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return -EFAULT; 77067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 77167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp r[*i].addr = addr; 77267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp r[*i].idx = idx; 77367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp r[*i].val = val; 77467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp ++*i; 77567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0; 77667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 77767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 77867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampstatic int set_reg(struct genwqe_dev *cd, struct genwqe_reg *r, 77967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp unsigned int *i, unsigned int m, u32 addr, u64 val) 78067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 78167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return set_reg_idx(cd, r, i, m, addr, 0, val); 78267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 78367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 78467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampint genwqe_read_ffdc_regs(struct genwqe_dev *cd, struct genwqe_reg *regs, 78567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp unsigned int max_regs, int all) 78667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 78767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp unsigned int i, j, idx = 0; 78867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp u32 ufir_addr, ufec_addr, sfir_addr, sfec_addr; 78967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp u64 gfir, sluid, appid, ufir, ufec, sfir, sfec; 79067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 79167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* Global FIR */ 79267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp gfir = __genwqe_readq(cd, IO_SLC_CFGREG_GFIR); 79367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp set_reg(cd, regs, &idx, max_regs, IO_SLC_CFGREG_GFIR, gfir); 79467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 79567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* UnitCfg for SLU */ 79667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp sluid = __genwqe_readq(cd, IO_SLU_UNITCFG); /* 0x00000000 */ 79767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp set_reg(cd, regs, &idx, max_regs, IO_SLU_UNITCFG, sluid); 79867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 79967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* UnitCfg for APP */ 80067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp appid = __genwqe_readq(cd, IO_APP_UNITCFG); /* 0x02000000 */ 80167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp set_reg(cd, regs, &idx, max_regs, IO_APP_UNITCFG, appid); 80267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 80367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* Check all chip Units */ 80467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp for (i = 0; i < GENWQE_MAX_UNITS; i++) { 80567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 80667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* Unit FIR */ 80767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp ufir_addr = (i << 24) | 0x008; 80867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp ufir = __genwqe_readq(cd, ufir_addr); 80967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp set_reg(cd, regs, &idx, max_regs, ufir_addr, ufir); 81067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 81167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* Unit FEC */ 81267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp ufec_addr = (i << 24) | 0x018; 81367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp ufec = __genwqe_readq(cd, ufec_addr); 81467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp set_reg(cd, regs, &idx, max_regs, ufec_addr, ufec); 81567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 81667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp for (j = 0; j < 64; j++) { 81767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* wherever there is a primary 1, read the 2ndary */ 81867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (!all && (!(ufir & (1ull << j)))) 81967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp continue; 82067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 82167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp sfir_addr = (i << 24) | (0x100 + 8 * j); 82267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp sfir = __genwqe_readq(cd, sfir_addr); 82367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp set_reg(cd, regs, &idx, max_regs, sfir_addr, sfir); 82467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 82567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp sfec_addr = (i << 24) | (0x300 + 8 * j); 82667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp sfec = __genwqe_readq(cd, sfec_addr); 82767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp set_reg(cd, regs, &idx, max_regs, sfec_addr, sfec); 82867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 82967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 83067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 83167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* fill with invalid data until end */ 83267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp for (i = idx; i < max_regs; i++) { 83367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp regs[i].addr = 0xffffffff; 83467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp regs[i].val = 0xffffffffffffffffull; 83567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 83667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return idx; 83767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 83867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 83967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 84067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * genwqe_ffdc_buff_size() - Calculates the number of dump registers 84167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 84267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampint genwqe_ffdc_buff_size(struct genwqe_dev *cd, int uid) 84367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 84467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp int entries = 0, ring, traps, traces, trace_entries; 84567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp u32 eevptr_addr, l_addr, d_len, d_type; 84667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp u64 eevptr, val, addr; 84767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 84867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp eevptr_addr = GENWQE_UID_OFFS(uid) | IO_EXTENDED_ERROR_POINTER; 84967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp eevptr = __genwqe_readq(cd, eevptr_addr); 85067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 85167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if ((eevptr != 0x0) && (eevptr != -1ull)) { 85267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp l_addr = GENWQE_UID_OFFS(uid) | eevptr; 85367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 85467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp while (1) { 85567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp val = __genwqe_readq(cd, l_addr); 85667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 85767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if ((val == 0x0) || (val == -1ull)) 85867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp break; 85967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 86067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* 38:24 */ 86167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp d_len = (val & 0x0000007fff000000ull) >> 24; 86267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 86367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* 39 */ 86467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp d_type = (val & 0x0000008000000000ull) >> 36; 86567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 86667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (d_type) { /* repeat */ 86767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp entries += d_len; 86867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } else { /* size in bytes! */ 86967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp entries += d_len >> 3; 87067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 87167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 87267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp l_addr += 8; 87367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 87467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 87567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 87667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp for (ring = 0; ring < 8; ring++) { 87767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp addr = GENWQE_UID_OFFS(uid) | IO_EXTENDED_DIAG_MAP(ring); 87867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp val = __genwqe_readq(cd, addr); 87967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 88067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if ((val == 0x0ull) || (val == -1ull)) 88167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp continue; 88267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 88367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp traps = (val >> 24) & 0xff; 88467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp traces = (val >> 16) & 0xff; 88567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp trace_entries = val & 0xffff; 88667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 88767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp entries += traps + (traces * trace_entries); 88867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 88967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return entries; 89067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 89167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 89267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 89367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * genwqe_ffdc_buff_read() - Implements LogoutExtendedErrorRegisters procedure 89467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 89567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampint genwqe_ffdc_buff_read(struct genwqe_dev *cd, int uid, 89667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp struct genwqe_reg *regs, unsigned int max_regs) 89767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 89867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp int i, traps, traces, trace, trace_entries, trace_entry, ring; 89967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp unsigned int idx = 0; 90067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp u32 eevptr_addr, l_addr, d_addr, d_len, d_type; 90167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp u64 eevptr, e, val, addr; 90267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 90367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp eevptr_addr = GENWQE_UID_OFFS(uid) | IO_EXTENDED_ERROR_POINTER; 90467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp eevptr = __genwqe_readq(cd, eevptr_addr); 90567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 90667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if ((eevptr != 0x0) && (eevptr != 0xffffffffffffffffull)) { 90767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp l_addr = GENWQE_UID_OFFS(uid) | eevptr; 90867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp while (1) { 90967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp e = __genwqe_readq(cd, l_addr); 91067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if ((e == 0x0) || (e == 0xffffffffffffffffull)) 91167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp break; 91267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 91367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp d_addr = (e & 0x0000000000ffffffull); /* 23:0 */ 91467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp d_len = (e & 0x0000007fff000000ull) >> 24; /* 38:24 */ 91567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp d_type = (e & 0x0000008000000000ull) >> 36; /* 39 */ 91667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp d_addr |= GENWQE_UID_OFFS(uid); 91767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 91867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (d_type) { 91967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp for (i = 0; i < (int)d_len; i++) { 92067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp val = __genwqe_readq(cd, d_addr); 92167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp set_reg_idx(cd, regs, &idx, max_regs, 92267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp d_addr, i, val); 92367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 92467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } else { 92567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp d_len >>= 3; /* Size in bytes! */ 92667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp for (i = 0; i < (int)d_len; i++, d_addr += 8) { 92767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp val = __genwqe_readq(cd, d_addr); 92867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp set_reg_idx(cd, regs, &idx, max_regs, 92967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp d_addr, 0, val); 93067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 93167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 93267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp l_addr += 8; 93367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 93467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 93567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 93667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* 93767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * To save time, there are only 6 traces poplulated on Uid=2, 93867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Ring=1. each with iters=512. 93967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 94067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp for (ring = 0; ring < 8; ring++) { /* 0 is fls, 1 is fds, 94167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 2...7 are ASI rings */ 94267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp addr = GENWQE_UID_OFFS(uid) | IO_EXTENDED_DIAG_MAP(ring); 94367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp val = __genwqe_readq(cd, addr); 94467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 94567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if ((val == 0x0ull) || (val == -1ull)) 94667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp continue; 94767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 94867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp traps = (val >> 24) & 0xff; /* Number of Traps */ 94967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp traces = (val >> 16) & 0xff; /* Number of Traces */ 95067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp trace_entries = val & 0xffff; /* Entries per trace */ 95167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 95267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* Note: This is a combined loop that dumps both the traps */ 95367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* (for the trace == 0 case) as well as the traces 1 to */ 95467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp /* 'traces'. */ 95567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp for (trace = 0; trace <= traces; trace++) { 95667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp u32 diag_sel = 95767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp GENWQE_EXTENDED_DIAG_SELECTOR(ring, trace); 95867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 95967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp addr = (GENWQE_UID_OFFS(uid) | 96067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp IO_EXTENDED_DIAG_SELECTOR); 96167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp __genwqe_writeq(cd, addr, diag_sel); 96267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 96367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp for (trace_entry = 0; 96467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp trace_entry < (trace ? trace_entries : traps); 96567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp trace_entry++) { 96667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp addr = (GENWQE_UID_OFFS(uid) | 96767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp IO_EXTENDED_DIAG_READ_MBX); 96867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp val = __genwqe_readq(cd, addr); 96967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp set_reg_idx(cd, regs, &idx, max_regs, addr, 97067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp (diag_sel<<16) | trace_entry, val); 97167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 97267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 97367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp } 97467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0; 97567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 97667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 97767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 97867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * genwqe_write_vreg() - Write register in virtual window 97967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 98067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Note, these registers are only accessible to the PF through the 98167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * VF-window. It is not intended for the VF to access. 98267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 98367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampint genwqe_write_vreg(struct genwqe_dev *cd, u32 reg, u64 val, int func) 98467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 98567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp __genwqe_writeq(cd, IO_PF_SLC_VIRTUAL_WINDOW, func & 0xf); 98667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp __genwqe_writeq(cd, reg, val); 98767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0; 98867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 98967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 99067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 99167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * genwqe_read_vreg() - Read register in virtual window 99267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 99367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Note, these registers are only accessible to the PF through the 99467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * VF-window. It is not intended for the VF to access. 99567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 99667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampu64 genwqe_read_vreg(struct genwqe_dev *cd, u32 reg, int func) 99767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 99867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp __genwqe_writeq(cd, IO_PF_SLC_VIRTUAL_WINDOW, func & 0xf); 99967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return __genwqe_readq(cd, reg); 100067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 100167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 100267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 100367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * genwqe_base_clock_frequency() - Deteremine base clock frequency of the card 100467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 100567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Note: From a design perspective it turned out to be a bad idea to 100667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * use codes here to specifiy the frequency/speed values. An old 100767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * driver cannot understand new codes and is therefore always a 100867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * problem. Better is to measure out the value or put the 100967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * speed/frequency directly into a register which is always a valid 101067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * value for old as well as for new software. 101167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 101267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Return: Card clock in MHz 101367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 101467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampint genwqe_base_clock_frequency(struct genwqe_dev *cd) 101567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 101667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp u16 speed; /* MHz MHz MHz MHz */ 101767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp static const int speed_grade[] = { 250, 200, 166, 175 }; 101867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 101967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp speed = (u16)((cd->slu_unitcfg >> 28) & 0x0full); 102067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (speed >= ARRAY_SIZE(speed_grade)) 102167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return 0; /* illegal value */ 102267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 102367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp return speed_grade[speed]; 102467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 102567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 102667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 102767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * genwqe_stop_traps() - Stop traps 102867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 102967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * Before reading out the analysis data, we need to stop the traps. 103067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 103167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampvoid genwqe_stop_traps(struct genwqe_dev *cd) 103267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 103367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp __genwqe_writeq(cd, IO_SLC_MISC_DEBUG_SET, 0xcull); 103467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 103567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 103667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp/** 103767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * genwqe_start_traps() - Start traps 103867f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * 103967f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp * After having read the data, we can/must enable the traps again. 104067f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp */ 104167f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkampvoid genwqe_start_traps(struct genwqe_dev *cd) 104267f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp{ 104367f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp __genwqe_writeq(cd, IO_SLC_MISC_DEBUG_CLR, 0xcull); 104467f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp 104567f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp if (genwqe_need_err_masking(cd)) 104667f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp __genwqe_writeq(cd, IO_SLC_MISC_DEBUG, 0x0aull); 104767f4addbb8fe68b9de8e8042c5367bd17db36520Frank Haverkamp} 1048