| /* |
| * This file and its contents are supplied under the terms of the |
| * Common Development and Distribution License ("CDDL"), version 1.0. |
| * You may only use this file in accordance with the terms of version |
| * 1.0 of the CDDL. |
| * |
| * A full copy of the text of the CDDL should have accompanied this |
| * source. A copy of the CDDL is also available via the Internet at |
| * http://www.illumos.org/license/CDDL. |
| */ |
| |
| /* |
| * This file is part of the Chelsio T4 support code. |
| * |
| * Copyright (C) 2011-2013 Chelsio Communications. All rights reserved. |
| * |
| * 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 LICENSE file included in this |
| * release for licensing terms and conditions. |
| */ |
| |
| #include <sys/ddi.h> |
| #include <sys/sunddi.h> |
| #include <sys/queue.h> |
| |
| #include "t4nex.h" |
| #include "common/common.h" |
| #include "common/t4_regs.h" |
| |
| /* helpers */ |
| static int pci_rw(struct adapter *sc, void *data, int flags, int write); |
| static int reg_rw(struct adapter *sc, void *data, int flags, int write); |
| static void reg_block_dump(struct adapter *sc, uint8_t *buf, unsigned int start, |
| unsigned int end); |
| static int regdump(struct adapter *sc, void *data, int flags); |
| static int get_sge_context(struct adapter *sc, void *data, int flags); |
| static int get_devlog(struct adapter *sc, void *data, int flags); |
| static int validate_mem_range(struct adapter *, uint32_t, int); |
| static int read_card_mem(struct adapter *sc, void *data, int flags); |
| static int read_tid_tab(struct adapter *sc, void *data, int flags); |
| static int read_mbox(struct adapter *sc, void *data, int flags); |
| static int read_cim_la(struct adapter *sc, void *data, int flags); |
| static int read_cim_qcfg(struct adapter *sc, void *data, int flags); |
| static int read_cim_ibq(struct adapter *sc, void *data, int flags); |
| static int read_edc(struct adapter *sc, void *data, int flags); |
| static int flash_fw(struct adapter *, void *, int); |
| |
| int |
| t4_ioctl(struct adapter *sc, int cmd, void *data, int mode) |
| { |
| int rc = ENOTSUP; |
| |
| switch (cmd) { |
| case T4_IOCTL_PCIGET32: |
| case T4_IOCTL_PCIPUT32: |
| rc = pci_rw(sc, data, mode, cmd == T4_IOCTL_PCIPUT32); |
| break; |
| case T4_IOCTL_GET32: |
| case T4_IOCTL_PUT32: |
| rc = reg_rw(sc, data, mode, cmd == T4_IOCTL_PUT32); |
| break; |
| case T4_IOCTL_REGDUMP: |
| rc = regdump(sc, data, mode); |
| break; |
| case T4_IOCTL_SGE_CONTEXT: |
| rc = get_sge_context(sc, data, mode); |
| break; |
| case T4_IOCTL_DEVLOG: |
| rc = get_devlog(sc, data, mode); |
| break; |
| case T4_IOCTL_GET_MEM: |
| rc = read_card_mem(sc, data, mode); |
| break; |
| case T4_IOCTL_GET_TID_TAB: |
| rc = read_tid_tab(sc, data, mode); |
| break; |
| case T4_IOCTL_GET_MBOX: |
| rc = read_mbox(sc, data, mode); |
| break; |
| case T4_IOCTL_GET_CIM_LA: |
| rc = read_cim_la(sc, data, mode); |
| break; |
| case T4_IOCTL_GET_CIM_QCFG: |
| rc = read_cim_qcfg(sc, data, mode); |
| break; |
| case T4_IOCTL_GET_CIM_IBQ: |
| rc = read_cim_ibq(sc, data, mode); |
| break; |
| case T4_IOCTL_GET_EDC: |
| rc = read_edc(sc, data, mode); |
| break; |
| case T4_IOCTL_LOAD_FW: |
| rc = flash_fw(sc, data, mode); |
| break; |
| default: |
| return (EINVAL); |
| } |
| |
| return (rc); |
| } |
| |
| static int |
| pci_rw(struct adapter *sc, void *data, int flags, int write) |
| { |
| struct t4_reg32_cmd r; |
| |
| if (ddi_copyin(data, &r, sizeof (r), flags) < 0) |
| return (EFAULT); |
| |
| /* address must be 32 bit aligned */ |
| r.reg &= ~0x3; |
| |
| if (write != 0) |
| t4_os_pci_write_cfg4(sc, r.reg, r.value); |
| else { |
| t4_os_pci_read_cfg4(sc, r.reg, &r.value); |
| if (ddi_copyout(&r, data, sizeof (r), flags) < 0) |
| return (EFAULT); |
| } |
| |
| return (0); |
| } |
| |
| static int |
| reg_rw(struct adapter *sc, void *data, int flags, int write) |
| { |
| struct t4_reg32_cmd r; |
| |
| if (ddi_copyin(data, &r, sizeof (r), flags) < 0) |
| return (EFAULT); |
| |
| /* Register address must be 32 bit aligned */ |
| r.reg &= ~0x3; |
| |
| if (write != 0) |
| t4_write_reg(sc, r.reg, r.value); |
| else { |
| r.value = t4_read_reg(sc, r.reg); |
| if (ddi_copyout(&r, data, sizeof (r), flags) < 0) |
| return (EFAULT); |
| } |
| |
| return (0); |
| } |
| |
| static void |
| reg_block_dump(struct adapter *sc, uint8_t *buf, unsigned int start, |
| unsigned int end) |
| { |
| /* LINTED: E_BAD_PTR_CAST_ALIGN */ |
| uint32_t *p = (uint32_t *)(buf + start); |
| |
| for (/* */; start <= end; start += sizeof (uint32_t)) |
| *p++ = t4_read_reg(sc, start); |
| } |
| |
| /* |
| * Return a version number to identify the type of adapter. The scheme is: |
| * - bits 0..9: chip version |
| * - bits 10..15: chip revision |
| * - bits 16..23: register dump version |
| */ |
| static inline |
| unsigned int mk_adap_vers(const struct adapter *sc) |
| { |
| return CHELSIO_CHIP_VERSION(sc->params.chip) | |
| (CHELSIO_CHIP_RELEASE(sc->params.chip) << 10) | (1 << 16); |
| } |
| |
| static int |
| regdump(struct adapter *sc, void *data, int flags) |
| { |
| struct t4_regdump r; |
| uint8_t *buf; |
| static const unsigned int *reg_ranges; |
| int rc = 0, arr_size = 0, buf_size = 0, i; |
| static const unsigned int t4_reg_ranges[] = { |
| 0x1008, 0x1108, |
| 0x1180, 0x11b4, |
| 0x11fc, 0x123c, |
| 0x1300, 0x173c, |
| 0x1800, 0x18fc, |
| 0x3000, 0x30d8, |
| 0x30e0, 0x5924, |
| 0x5960, 0x59d4, |
| 0x5a00, 0x5af8, |
| 0x6000, 0x6098, |
| 0x6100, 0x6150, |
| 0x6200, 0x6208, |
| 0x6240, 0x6248, |
| 0x6280, 0x6338, |
| 0x6370, 0x638c, |
| 0x6400, 0x643c, |
| 0x6500, 0x6524, |
| 0x6a00, 0x6a38, |
| 0x6a60, 0x6a78, |
| 0x6b00, 0x6b84, |
| 0x6bf0, 0x6c84, |
| 0x6cf0, 0x6d84, |
| 0x6df0, 0x6e84, |
| 0x6ef0, 0x6f84, |
| 0x6ff0, 0x7084, |
| 0x70f0, 0x7184, |
| 0x71f0, 0x7284, |
| 0x72f0, 0x7384, |
| 0x73f0, 0x7450, |
| 0x7500, 0x7530, |
| 0x7600, 0x761c, |
| 0x7680, 0x76cc, |
| 0x7700, 0x7798, |
| 0x77c0, 0x77fc, |
| 0x7900, 0x79fc, |
| 0x7b00, 0x7c38, |
| 0x7d00, 0x7efc, |
| 0x8dc0, 0x8e1c, |
| 0x8e30, 0x8e78, |
| 0x8ea0, 0x8f6c, |
| 0x8fc0, 0x9074, |
| 0x90fc, 0x90fc, |
| 0x9400, 0x9458, |
| 0x9600, 0x96bc, |
| 0x9800, 0x9808, |
| 0x9820, 0x983c, |
| 0x9850, 0x9864, |
| 0x9c00, 0x9c6c, |
| 0x9c80, 0x9cec, |
| 0x9d00, 0x9d6c, |
| 0x9d80, 0x9dec, |
| 0x9e00, 0x9e6c, |
| 0x9e80, 0x9eec, |
| 0x9f00, 0x9f6c, |
| 0x9f80, 0x9fec, |
| 0xd004, 0xd03c, |
| 0xdfc0, 0xdfe0, |
| 0xe000, 0xea7c, |
| 0xf000, 0x11190, |
| 0x19040, 0x19124, |
| 0x19150, 0x191b0, |
| 0x191d0, 0x191e8, |
| 0x19238, 0x1924c, |
| 0x193f8, 0x19474, |
| 0x19490, 0x194f8, |
| 0x19800, 0x19f30, |
| 0x1a000, 0x1a06c, |
| 0x1a0b0, 0x1a120, |
| 0x1a128, 0x1a138, |
| 0x1a190, 0x1a1c4, |
| 0x1a1fc, 0x1a1fc, |
| 0x1e040, 0x1e04c, |
| 0x1e240, 0x1e28c, |
| 0x1e2c0, 0x1e2c0, |
| 0x1e2e0, 0x1e2e0, |
| 0x1e300, 0x1e384, |
| 0x1e3c0, 0x1e3c8, |
| 0x1e440, 0x1e44c, |
| 0x1e640, 0x1e68c, |
| 0x1e6c0, 0x1e6c0, |
| 0x1e6e0, 0x1e6e0, |
| 0x1e700, 0x1e784, |
| 0x1e7c0, 0x1e7c8, |
| 0x1e840, 0x1e84c, |
| 0x1ea40, 0x1ea8c, |
| 0x1eac0, 0x1eac0, |
| 0x1eae0, 0x1eae0, |
| 0x1eb00, 0x1eb84, |
| 0x1ebc0, 0x1ebc8, |
| 0x1ec40, 0x1ec4c, |
| 0x1ee40, 0x1ee8c, |
| 0x1eec0, 0x1eec0, |
| 0x1eee0, 0x1eee0, |
| 0x1ef00, 0x1ef84, |
| 0x1efc0, 0x1efc8, |
| 0x1f040, 0x1f04c, |
| 0x1f240, 0x1f28c, |
| 0x1f2c0, 0x1f2c0, |
| 0x1f2e0, 0x1f2e0, |
| 0x1f300, 0x1f384, |
| 0x1f3c0, 0x1f3c8, |
| 0x1f440, 0x1f44c, |
| 0x1f640, 0x1f68c, |
| 0x1f6c0, 0x1f6c0, |
| 0x1f6e0, 0x1f6e0, |
| 0x1f700, 0x1f784, |
| 0x1f7c0, 0x1f7c8, |
| 0x1f840, 0x1f84c, |
| 0x1fa40, 0x1fa8c, |
| 0x1fac0, 0x1fac0, |
| 0x1fae0, 0x1fae0, |
| 0x1fb00, 0x1fb84, |
| 0x1fbc0, 0x1fbc8, |
| 0x1fc40, 0x1fc4c, |
| 0x1fe40, 0x1fe8c, |
| 0x1fec0, 0x1fec0, |
| 0x1fee0, 0x1fee0, |
| 0x1ff00, 0x1ff84, |
| 0x1ffc0, 0x1ffc8, |
| 0x20000, 0x2002c, |
| 0x20100, 0x2013c, |
| 0x20190, 0x201c8, |
| 0x20200, 0x20318, |
| 0x20400, 0x20528, |
| 0x20540, 0x20614, |
| 0x21000, 0x21040, |
| 0x2104c, 0x21060, |
| 0x210c0, 0x210ec, |
| 0x21200, 0x21268, |
| 0x21270, 0x21284, |
| 0x212fc, 0x21388, |
| 0x21400, 0x21404, |
| 0x21500, 0x21518, |
| 0x2152c, 0x2153c, |
| 0x21550, 0x21554, |
| 0x21600, 0x21600, |
| 0x21608, 0x21628, |
| 0x21630, 0x2163c, |
| 0x21700, 0x2171c, |
| 0x21780, 0x2178c, |
| 0x21800, 0x21c38, |
| 0x21c80, 0x21d7c, |
| 0x21e00, 0x21e04, |
| 0x22000, 0x2202c, |
| 0x22100, 0x2213c, |
| 0x22190, 0x221c8, |
| 0x22200, 0x22318, |
| 0x22400, 0x22528, |
| 0x22540, 0x22614, |
| 0x23000, 0x23040, |
| 0x2304c, 0x23060, |
| 0x230c0, 0x230ec, |
| 0x23200, 0x23268, |
| 0x23270, 0x23284, |
| 0x232fc, 0x23388, |
| 0x23400, 0x23404, |
| 0x23500, 0x23518, |
| 0x2352c, 0x2353c, |
| 0x23550, 0x23554, |
| 0x23600, 0x23600, |
| 0x23608, 0x23628, |
| 0x23630, 0x2363c, |
| 0x23700, 0x2371c, |
| 0x23780, 0x2378c, |
| 0x23800, 0x23c38, |
| 0x23c80, 0x23d7c, |
| 0x23e00, 0x23e04, |
| 0x24000, 0x2402c, |
| 0x24100, 0x2413c, |
| 0x24190, 0x241c8, |
| 0x24200, 0x24318, |
| 0x24400, 0x24528, |
| 0x24540, 0x24614, |
| 0x25000, 0x25040, |
| 0x2504c, 0x25060, |
| 0x250c0, 0x250ec, |
| 0x25200, 0x25268, |
| 0x25270, 0x25284, |
| 0x252fc, 0x25388, |
| 0x25400, 0x25404, |
| 0x25500, 0x25518, |
| 0x2552c, 0x2553c, |
| 0x25550, 0x25554, |
| 0x25600, 0x25600, |
| 0x25608, 0x25628, |
| 0x25630, 0x2563c, |
| 0x25700, 0x2571c, |
| 0x25780, 0x2578c, |
| 0x25800, 0x25c38, |
| 0x25c80, 0x25d7c, |
| 0x25e00, 0x25e04, |
| 0x26000, 0x2602c, |
| 0x26100, 0x2613c, |
| 0x26190, 0x261c8, |
| 0x26200, 0x26318, |
| 0x26400, 0x26528, |
| 0x26540, 0x26614, |
| 0x27000, 0x27040, |
| 0x2704c, 0x27060, |
| 0x270c0, 0x270ec, |
| 0x27200, 0x27268, |
| 0x27270, 0x27284, |
| 0x272fc, 0x27388, |
| 0x27400, 0x27404, |
| 0x27500, 0x27518, |
| 0x2752c, 0x2753c, |
| 0x27550, 0x27554, |
| 0x27600, 0x27600, |
| 0x27608, 0x27628, |
| 0x27630, 0x2763c, |
| 0x27700, 0x2771c, |
| 0x27780, 0x2778c, |
| 0x27800, 0x27c38, |
| 0x27c80, 0x27d7c, |
| 0x27e00, 0x27e04 |
| }; |
| |
| static const unsigned int t5_reg_ranges[] = { |
| 0x1008, 0x10c0, |
| 0x10cc, 0x10f8, |
| 0x1100, 0x1100, |
| 0x110c, 0x1148, |
| 0x1180, 0x1184, |
| 0x1190, 0x1194, |
| 0x11a0, 0x11a4, |
| 0x11b0, 0x11b4, |
| 0x11fc, 0x123c, |
| 0x1280, 0x173c, |
| 0x1800, 0x18fc, |
| 0x3000, 0x3028, |
| 0x3060, 0x30b0, |
| 0x30b8, 0x30d8, |
| 0x30e0, 0x30fc, |
| 0x3140, 0x357c, |
| 0x35a8, 0x35cc, |
| 0x35ec, 0x35ec, |
| 0x3600, 0x5624, |
| 0x56cc, 0x56ec, |
| 0x56f4, 0x5720, |
| 0x5728, 0x575c, |
| 0x580c, 0x5814, |
| 0x5890, 0x589c, |
| 0x58a4, 0x58ac, |
| 0x58b8, 0x58bc, |
| 0x5940, 0x59c8, |
| 0x59d0, 0x59dc, |
| 0x59fc, 0x5a18, |
| 0x5a60, 0x5a70, |
| 0x5a80, 0x5a9c, |
| 0x5b94, 0x5bfc, |
| 0x6000, 0x6020, |
| 0x6028, 0x6040, |
| 0x6058, 0x609c, |
| 0x60a8, 0x614c, |
| 0x7700, 0x7798, |
| 0x77c0, 0x78fc, |
| 0x7b00, 0x7b58, |
| 0x7b60, 0x7b84, |
| 0x7b8c, 0x7c54, |
| 0x7d00, 0x7d38, |
| 0x7d40, 0x7d80, |
| 0x7d8c, 0x7ddc, |
| 0x7de4, 0x7e04, |
| 0x7e10, 0x7e1c, |
| 0x7e24, 0x7e38, |
| 0x7e40, 0x7e44, |
| 0x7e4c, 0x7e78, |
| 0x7e80, 0x7edc, |
| 0x7ee8, 0x7efc, |
| 0x8dc0, 0x8de0, |
| 0x8df8, 0x8e04, |
| 0x8e10, 0x8e84, |
| 0x8ea0, 0x8f84, |
| 0x8fc0, 0x9058, |
| 0x9060, 0x9060, |
| 0x9068, 0x90f8, |
| 0x9400, 0x9408, |
| 0x9410, 0x9470, |
| 0x9600, 0x9600, |
| 0x9608, 0x9638, |
| 0x9640, 0x96f4, |
| 0x9800, 0x9808, |
| 0x9820, 0x983c, |
| 0x9850, 0x9864, |
| 0x9c00, 0x9c6c, |
| 0x9c80, 0x9cec, |
| 0x9d00, 0x9d6c, |
| 0x9d80, 0x9dec, |
| 0x9e00, 0x9e6c, |
| 0x9e80, 0x9eec, |
| 0x9f00, 0x9f6c, |
| 0x9f80, 0xa020, |
| 0xd004, 0xd004, |
| 0xd010, 0xd03c, |
| 0xdfc0, 0xdfe0, |
| 0xe000, 0x1106c, |
| 0x11074, 0x11088, |
| 0x1109c, 0x1117c, |
| 0x11190, 0x11204, |
| 0x19040, 0x1906c, |
| 0x19078, 0x19080, |
| 0x1908c, 0x190e8, |
| 0x190f0, 0x190f8, |
| 0x19100, 0x19110, |
| 0x19120, 0x19124, |
| 0x19150, 0x19194, |
| 0x1919c, 0x191b0, |
| 0x191d0, 0x191e8, |
| 0x19238, 0x19290, |
| 0x193f8, 0x19428, |
| 0x19430, 0x19444, |
| 0x1944c, 0x1946c, |
| 0x19474, 0x19474, |
| 0x19490, 0x194cc, |
| 0x194f0, 0x194f8, |
| 0x19c00, 0x19c08, |
| 0x19c10, 0x19c60, |
| 0x19c94, 0x19ce4, |
| 0x19cf0, 0x19d40, |
| 0x19d50, 0x19d94, |
| 0x19da0, 0x19de8, |
| 0x19df0, 0x19e10, |
| 0x19e50, 0x19e90, |
| 0x19ea0, 0x19f24, |
| 0x19f34, 0x19f34, |
| 0x19f40, 0x19f50, |
| 0x19f90, 0x19fb4, |
| 0x19fc4, 0x19fe4, |
| 0x1a000, 0x1a004, |
| 0x1a010, 0x1a06c, |
| 0x1a0b0, 0x1a0e4, |
| 0x1a0ec, 0x1a0f8, |
| 0x1a100, 0x1a108, |
| 0x1a114, 0x1a120, |
| 0x1a128, 0x1a130, |
| 0x1a138, 0x1a138, |
| 0x1a190, 0x1a1c4, |
| 0x1a1fc, 0x1a1fc, |
| 0x1e008, 0x1e00c, |
| 0x1e040, 0x1e044, |
| 0x1e04c, 0x1e04c, |
| 0x1e284, 0x1e290, |
| 0x1e2c0, 0x1e2c0, |
| 0x1e2e0, 0x1e2e0, |
| 0x1e300, 0x1e384, |
| 0x1e3c0, 0x1e3c8, |
| 0x1e408, 0x1e40c, |
| 0x1e440, 0x1e444, |
| 0x1e44c, 0x1e44c, |
| 0x1e684, 0x1e690, |
| 0x1e6c0, 0x1e6c0, |
| 0x1e6e0, 0x1e6e0, |
| 0x1e700, 0x1e784, |
| 0x1e7c0, 0x1e7c8, |
| 0x1e808, 0x1e80c, |
| 0x1e840, 0x1e844, |
| 0x1e84c, 0x1e84c, |
| 0x1ea84, 0x1ea90, |
| 0x1eac0, 0x1eac0, |
| 0x1eae0, 0x1eae0, |
| 0x1eb00, 0x1eb84, |
| 0x1ebc0, 0x1ebc8, |
| 0x1ec08, 0x1ec0c, |
| 0x1ec40, 0x1ec44, |
| 0x1ec4c, 0x1ec4c, |
| 0x1ee84, 0x1ee90, |
| 0x1eec0, 0x1eec0, |
| 0x1eee0, 0x1eee0, |
| 0x1ef00, 0x1ef84, |
| 0x1efc0, 0x1efc8, |
| 0x1f008, 0x1f00c, |
| 0x1f040, 0x1f044, |
| 0x1f04c, 0x1f04c, |
| 0x1f284, 0x1f290, |
| 0x1f2c0, 0x1f2c0, |
| 0x1f2e0, 0x1f2e0, |
| 0x1f300, 0x1f384, |
| 0x1f3c0, 0x1f3c8, |
| 0x1f408, 0x1f40c, |
| 0x1f440, 0x1f444, |
| 0x1f44c, 0x1f44c, |
| 0x1f684, 0x1f690, |
| 0x1f6c0, 0x1f6c0, |
| 0x1f6e0, 0x1f6e0, |
| 0x1f700, 0x1f784, |
| 0x1f7c0, 0x1f7c8, |
| 0x1f808, 0x1f80c, |
| 0x1f840, 0x1f844, |
| 0x1f84c, 0x1f84c, |
| 0x1fa84, 0x1fa90, |
| 0x1fac0, 0x1fac0, |
| 0x1fae0, 0x1fae0, |
| 0x1fb00, 0x1fb84, |
| 0x1fbc0, 0x1fbc8, |
| 0x1fc08, 0x1fc0c, |
| 0x1fc40, 0x1fc44, |
| 0x1fc4c, 0x1fc4c, |
| 0x1fe84, 0x1fe90, |
| 0x1fec0, 0x1fec0, |
| 0x1fee0, 0x1fee0, |
| 0x1ff00, 0x1ff84, |
| 0x1ffc0, 0x1ffc8, |
| 0x30000, 0x30030, |
| 0x30038, 0x30038, |
| 0x30040, 0x30040, |
| 0x30100, 0x30144, |
| 0x30190, 0x301a0, |
| 0x301a8, 0x301b8, |
| 0x301c4, 0x301c8, |
| 0x301d0, 0x301d0, |
| 0x30200, 0x30318, |
| 0x30400, 0x304b4, |
| 0x304c0, 0x3052c, |
| 0x30540, 0x3061c, |
| 0x30800, 0x30828, |
| 0x30834, 0x30834, |
| 0x308c0, 0x30908, |
| 0x30910, 0x309ac, |
| 0x30a00, 0x30a14, |
| 0x30a1c, 0x30a2c, |
| 0x30a44, 0x30a50, |
| 0x30a74, 0x30a74, |
| 0x30a7c, 0x30afc, |
| 0x30b08, 0x30c24, |
| 0x30d00, 0x30d00, |
| 0x30d08, 0x30d14, |
| 0x30d1c, 0x30d20, |
| 0x30d3c, 0x30d3c, |
| 0x30d48, 0x30d50, |
| 0x31200, 0x3120c, |
| 0x31220, 0x31220, |
| 0x31240, 0x31240, |
| 0x31600, 0x3160c, |
| 0x31a00, 0x31a1c, |
| 0x31e00, 0x31e20, |
| 0x31e38, 0x31e3c, |
| 0x31e80, 0x31e80, |
| 0x31e88, 0x31ea8, |
| 0x31eb0, 0x31eb4, |
| 0x31ec8, 0x31ed4, |
| 0x31fb8, 0x32004, |
| 0x32200, 0x32200, |
| 0x32208, 0x32240, |
| 0x32248, 0x32280, |
| 0x32288, 0x322c0, |
| 0x322c8, 0x322fc, |
| 0x32600, 0x32630, |
| 0x32a00, 0x32abc, |
| 0x32b00, 0x32b10, |
| 0x32b20, 0x32b30, |
| 0x32b40, 0x32b50, |
| 0x32b60, 0x32b70, |
| 0x33000, 0x33028, |
| 0x33030, 0x33048, |
| 0x33060, 0x33068, |
| 0x33070, 0x3309c, |
| 0x330f0, 0x33128, |
| 0x33130, 0x33148, |
| 0x33160, 0x33168, |
| 0x33170, 0x3319c, |
| 0x331f0, 0x33238, |
| 0x33240, 0x33240, |
| 0x33248, 0x33250, |
| 0x3325c, 0x33264, |
| 0x33270, 0x332b8, |
| 0x332c0, 0x332e4, |
| 0x332f8, 0x33338, |
| 0x33340, 0x33340, |
| 0x33348, 0x33350, |
| 0x3335c, 0x33364, |
| 0x33370, 0x333b8, |
| 0x333c0, 0x333e4, |
| 0x333f8, 0x33428, |
| 0x33430, 0x33448, |
| 0x33460, 0x33468, |
| 0x33470, 0x3349c, |
| 0x334f0, 0x33528, |
| 0x33530, 0x33548, |
| 0x33560, 0x33568, |
| 0x33570, 0x3359c, |
| 0x335f0, 0x33638, |
| 0x33640, 0x33640, |
| 0x33648, 0x33650, |
| 0x3365c, 0x33664, |
| 0x33670, 0x336b8, |
| 0x336c0, 0x336e4, |
| 0x336f8, 0x33738, |
| 0x33740, 0x33740, |
| 0x33748, 0x33750, |
| 0x3375c, 0x33764, |
| 0x33770, 0x337b8, |
| 0x337c0, 0x337e4, |
| 0x337f8, 0x337fc, |
| 0x33814, 0x33814, |
| 0x3382c, 0x3382c, |
| 0x33880, 0x3388c, |
| 0x338e8, 0x338ec, |
| 0x33900, 0x33928, |
| 0x33930, 0x33948, |
| 0x33960, 0x33968, |
| 0x33970, 0x3399c, |
| 0x339f0, 0x33a38, |
| 0x33a40, 0x33a40, |
| 0x33a48, 0x33a50, |
| 0x33a5c, 0x33a64, |
| 0x33a70, 0x33ab8, |
| 0x33ac0, 0x33ae4, |
| 0x33af8, 0x33b10, |
| 0x33b28, 0x33b28, |
| 0x33b3c, 0x33b50, |
| 0x33bf0, 0x33c10, |
| 0x33c28, 0x33c28, |
| 0x33c3c, 0x33c50, |
| 0x33cf0, 0x33cfc, |
| 0x34000, 0x34030, |
| 0x34038, 0x34038, |
| 0x34040, 0x34040, |
| 0x34100, 0x34144, |
| 0x34190, 0x341a0, |
| 0x341a8, 0x341b8, |
| 0x341c4, 0x341c8, |
| 0x341d0, 0x341d0, |
| 0x34200, 0x34318, |
| 0x34400, 0x344b4, |
| 0x344c0, 0x3452c, |
| 0x34540, 0x3461c, |
| 0x34800, 0x34828, |
| 0x34834, 0x34834, |
| 0x348c0, 0x34908, |
| 0x34910, 0x349ac, |
| 0x34a00, 0x34a14, |
| 0x34a1c, 0x34a2c, |
| 0x34a44, 0x34a50, |
| 0x34a74, 0x34a74, |
| 0x34a7c, 0x34afc, |
| 0x34b08, 0x34c24, |
| 0x34d00, 0x34d00, |
| 0x34d08, 0x34d14, |
| 0x34d1c, 0x34d20, |
| 0x34d3c, 0x34d3c, |
| 0x34d48, 0x34d50, |
| 0x35200, 0x3520c, |
| 0x35220, 0x35220, |
| 0x35240, 0x35240, |
| 0x35600, 0x3560c, |
| 0x35a00, 0x35a1c, |
| 0x35e00, 0x35e20, |
| 0x35e38, 0x35e3c, |
| 0x35e80, 0x35e80, |
| 0x35e88, 0x35ea8, |
| 0x35eb0, 0x35eb4, |
| 0x35ec8, 0x35ed4, |
| 0x35fb8, 0x36004, |
| 0x36200, 0x36200, |
| 0x36208, 0x36240, |
| 0x36248, 0x36280, |
| 0x36288, 0x362c0, |
| 0x362c8, 0x362fc, |
| 0x36600, 0x36630, |
| 0x36a00, 0x36abc, |
| 0x36b00, 0x36b10, |
| 0x36b20, 0x36b30, |
| 0x36b40, 0x36b50, |
| 0x36b60, 0x36b70, |
| 0x37000, 0x37028, |
| 0x37030, 0x37048, |
| 0x37060, 0x37068, |
| 0x37070, 0x3709c, |
| 0x370f0, 0x37128, |
| 0x37130, 0x37148, |
| 0x37160, 0x37168, |
| 0x37170, 0x3719c, |
| 0x371f0, 0x37238, |
| 0x37240, 0x37240, |
| 0x37248, 0x37250, |
| 0x3725c, 0x37264, |
| 0x37270, 0x372b8, |
| 0x372c0, 0x372e4, |
| 0x372f8, 0x37338, |
| 0x37340, 0x37340, |
| 0x37348, 0x37350, |
| 0x3735c, 0x37364, |
| 0x37370, 0x373b8, |
| 0x373c0, 0x373e4, |
| 0x373f8, 0x37428, |
| 0x37430, 0x37448, |
| 0x37460, 0x37468, |
| 0x37470, 0x3749c, |
| 0x374f0, 0x37528, |
| 0x37530, 0x37548, |
| 0x37560, 0x37568, |
| 0x37570, 0x3759c, |
| 0x375f0, 0x37638, |
| 0x37640, 0x37640, |
| 0x37648, 0x37650, |
| 0x3765c, 0x37664, |
| 0x37670, 0x376b8, |
| 0x376c0, 0x376e4, |
| 0x376f8, 0x37738, |
| 0x37740, 0x37740, |
| 0x37748, 0x37750, |
| 0x3775c, 0x37764, |
| 0x37770, 0x377b8, |
| 0x377c0, 0x377e4, |
| 0x377f8, 0x377fc, |
| 0x37814, 0x37814, |
| 0x3782c, 0x3782c, |
| 0x37880, 0x3788c, |
| 0x378e8, 0x378ec, |
| 0x37900, 0x37928, |
| 0x37930, 0x37948, |
| 0x37960, 0x37968, |
| 0x37970, 0x3799c, |
| 0x379f0, 0x37a38, |
| 0x37a40, 0x37a40, |
| 0x37a48, 0x37a50, |
| 0x37a5c, 0x37a64, |
| 0x37a70, 0x37ab8, |
| 0x37ac0, 0x37ae4, |
| 0x37af8, 0x37b10, |
| 0x37b28, 0x37b28, |
| 0x37b3c, 0x37b50, |
| 0x37bf0, 0x37c10, |
| 0x37c28, 0x37c28, |
| 0x37c3c, 0x37c50, |
| 0x37cf0, 0x37cfc, |
| 0x38000, 0x38030, |
| 0x38038, 0x38038, |
| 0x38040, 0x38040, |
| 0x38100, 0x38144, |
| 0x38190, 0x381a0, |
| 0x381a8, 0x381b8, |
| 0x381c4, 0x381c8, |
| 0x381d0, 0x381d0, |
| 0x38200, 0x38318, |
| 0x38400, 0x384b4, |
| 0x384c0, 0x3852c, |
| 0x38540, 0x3861c, |
| 0x38800, 0x38828, |
| 0x38834, 0x38834, |
| 0x388c0, 0x38908, |
| 0x38910, 0x389ac, |
| 0x38a00, 0x38a14, |
| 0x38a1c, 0x38a2c, |
| 0x38a44, 0x38a50, |
| 0x38a74, 0x38a74, |
| 0x38a7c, 0x38afc, |
| 0x38b08, 0x38c24, |
| 0x38d00, 0x38d00, |
| 0x38d08, 0x38d14, |
| 0x38d1c, 0x38d20, |
| 0x38d3c, 0x38d3c, |
| 0x38d48, 0x38d50, |
| 0x39200, 0x3920c, |
| 0x39220, 0x39220, |
| 0x39240, 0x39240, |
| 0x39600, 0x3960c, |
| 0x39a00, 0x39a1c, |
| 0x39e00, 0x39e20, |
| 0x39e38, 0x39e3c, |
| 0x39e80, 0x39e80, |
| 0x39e88, 0x39ea8, |
| 0x39eb0, 0x39eb4, |
| 0x39ec8, 0x39ed4, |
| 0x39fb8, 0x3a004, |
| 0x3a200, 0x3a200, |
| 0x3a208, 0x3a240, |
| 0x3a248, 0x3a280, |
| 0x3a288, 0x3a2c0, |
| 0x3a2c8, 0x3a2fc, |
| 0x3a600, 0x3a630, |
| 0x3aa00, 0x3aabc, |
| 0x3ab00, 0x3ab10, |
| 0x3ab20, 0x3ab30, |
| 0x3ab40, 0x3ab50, |
| 0x3ab60, 0x3ab70, |
| 0x3b000, 0x3b028, |
| 0x3b030, 0x3b048, |
| 0x3b060, 0x3b068, |
| 0x3b070, 0x3b09c, |
| 0x3b0f0, 0x3b128, |
| 0x3b130, 0x3b148, |
| 0x3b160, 0x3b168, |
| 0x3b170, 0x3b19c, |
| 0x3b1f0, 0x3b238, |
| 0x3b240, 0x3b240, |
| 0x3b248, 0x3b250, |
| 0x3b25c, 0x3b264, |
| 0x3b270, 0x3b2b8, |
| 0x3b2c0, 0x3b2e4, |
| 0x3b2f8, 0x3b338, |
| 0x3b340, 0x3b340, |
| 0x3b348, 0x3b350, |
| 0x3b35c, 0x3b364, |
| 0x3b370, 0x3b3b8, |
| 0x3b3c0, 0x3b3e4, |
| 0x3b3f8, 0x3b428, |
| 0x3b430, 0x3b448, |
| 0x3b460, 0x3b468, |
| 0x3b470, 0x3b49c, |
| 0x3b4f0, 0x3b528, |
| 0x3b530, 0x3b548, |
| 0x3b560, 0x3b568, |
| 0x3b570, 0x3b59c, |
| 0x3b5f0, 0x3b638, |
| 0x3b640, 0x3b640, |
| 0x3b648, 0x3b650, |
| 0x3b65c, 0x3b664, |
| 0x3b670, 0x3b6b8, |
| 0x3b6c0, 0x3b6e4, |
| 0x3b6f8, 0x3b738, |
| 0x3b740, 0x3b740, |
| 0x3b748, 0x3b750, |
| 0x3b75c, 0x3b764, |
| 0x3b770, 0x3b7b8, |
| 0x3b7c0, 0x3b7e4, |
| 0x3b7f8, 0x3b7fc, |
| 0x3b814, 0x3b814, |
| 0x3b82c, 0x3b82c, |
| 0x3b880, 0x3b88c, |
| 0x3b8e8, 0x3b8ec, |
| 0x3b900, 0x3b928, |
| 0x3b930, 0x3b948, |
| 0x3b960, 0x3b968, |
| 0x3b970, 0x3b99c, |
| 0x3b9f0, 0x3ba38, |
| 0x3ba40, 0x3ba40, |
| 0x3ba48, 0x3ba50, |
| 0x3ba5c, 0x3ba64, |
| 0x3ba70, 0x3bab8, |
| 0x3bac0, 0x3bae4, |
| 0x3baf8, 0x3bb10, |
| 0x3bb28, 0x3bb28, |
| 0x3bb3c, 0x3bb50, |
| 0x3bbf0, 0x3bc10, |
| 0x3bc28, 0x3bc28, |
| 0x3bc3c, 0x3bc50, |
| 0x3bcf0, 0x3bcfc, |
| 0x3c000, 0x3c030, |
| 0x3c038, 0x3c038, |
| 0x3c040, 0x3c040, |
| 0x3c100, 0x3c144, |
| 0x3c190, 0x3c1a0, |
| 0x3c1a8, 0x3c1b8, |
| 0x3c1c4, 0x3c1c8, |
| 0x3c1d0, 0x3c1d0, |
| 0x3c200, 0x3c318, |
| 0x3c400, 0x3c4b4, |
| 0x3c4c0, 0x3c52c, |
| 0x3c540, 0x3c61c, |
| 0x3c800, 0x3c828, |
| 0x3c834, 0x3c834, |
| 0x3c8c0, 0x3c908, |
| 0x3c910, 0x3c9ac, |
| 0x3ca00, 0x3ca14, |
| 0x3ca1c, 0x3ca2c, |
| 0x3ca44, 0x3ca50, |
| 0x3ca74, 0x3ca74, |
| 0x3ca7c, 0x3cafc, |
| 0x3cb08, 0x3cc24, |
| 0x3cd00, 0x3cd00, |
| 0x3cd08, 0x3cd14, |
| 0x3cd1c, 0x3cd20, |
| 0x3cd3c, 0x3cd3c, |
| 0x3cd48, 0x3cd50, |
| 0x3d200, 0x3d20c, |
| 0x3d220, 0x3d220, |
| 0x3d240, 0x3d240, |
| 0x3d600, 0x3d60c, |
| 0x3da00, 0x3da1c, |
| 0x3de00, 0x3de20, |
| 0x3de38, 0x3de3c, |
| 0x3de80, 0x3de80, |
| 0x3de88, 0x3dea8, |
| 0x3deb0, 0x3deb4, |
| 0x3dec8, 0x3ded4, |
| 0x3dfb8, 0x3e004, |
| 0x3e200, 0x3e200, |
| 0x3e208, 0x3e240, |
| 0x3e248, 0x3e280, |
| 0x3e288, 0x3e2c0, |
| 0x3e2c8, 0x3e2fc, |
| 0x3e600, 0x3e630, |
| 0x3ea00, 0x3eabc, |
| 0x3eb00, 0x3eb10, |
| 0x3eb20, 0x3eb30, |
| 0x3eb40, 0x3eb50, |
| 0x3eb60, 0x3eb70, |
| 0x3f000, 0x3f028, |
| 0x3f030, 0x3f048, |
| 0x3f060, 0x3f068, |
| 0x3f070, 0x3f09c, |
| 0x3f0f0, 0x3f128, |
| 0x3f130, 0x3f148, |
| 0x3f160, 0x3f168, |
| 0x3f170, 0x3f19c, |
| 0x3f1f0, 0x3f238, |
| 0x3f240, 0x3f240, |
| 0x3f248, 0x3f250, |
| 0x3f25c, 0x3f264, |
| 0x3f270, 0x3f2b8, |
| 0x3f2c0, 0x3f2e4, |
| 0x3f2f8, 0x3f338, |
| 0x3f340, 0x3f340, |
| 0x3f348, 0x3f350, |
| 0x3f35c, 0x3f364, |
| 0x3f370, 0x3f3b8, |
| 0x3f3c0, 0x3f3e4, |
| 0x3f3f8, 0x3f428, |
| 0x3f430, 0x3f448, |
| 0x3f460, 0x3f468, |
| 0x3f470, 0x3f49c, |
| 0x3f4f0, 0x3f528, |
| 0x3f530, 0x3f548, |
| 0x3f560, 0x3f568, |
| 0x3f570, 0x3f59c, |
| 0x3f5f0, 0x3f638, |
| 0x3f640, 0x3f640, |
| 0x3f648, 0x3f650, |
| 0x3f65c, 0x3f664, |
| 0x3f670, 0x3f6b8, |
| 0x3f6c0, 0x3f6e4, |
| 0x3f6f8, 0x3f738, |
| 0x3f740, 0x3f740, |
| 0x3f748, 0x3f750, |
| 0x3f75c, 0x3f764, |
| 0x3f770, 0x3f7b8, |
| 0x3f7c0, 0x3f7e4, |
| 0x3f7f8, 0x3f7fc, |
| 0x3f814, 0x3f814, |
| 0x3f82c, 0x3f82c, |
| 0x3f880, 0x3f88c, |
| 0x3f8e8, 0x3f8ec, |
| 0x3f900, 0x3f928, |
| 0x3f930, 0x3f948, |
| 0x3f960, 0x3f968, |
| 0x3f970, 0x3f99c, |
| 0x3f9f0, 0x3fa38, |
| 0x3fa40, 0x3fa40, |
| 0x3fa48, 0x3fa50, |
| 0x3fa5c, 0x3fa64, |
| 0x3fa70, 0x3fab8, |
| 0x3fac0, 0x3fae4, |
| 0x3faf8, 0x3fb10, |
| 0x3fb28, 0x3fb28, |
| 0x3fb3c, 0x3fb50, |
| 0x3fbf0, 0x3fc10, |
| 0x3fc28, 0x3fc28, |
| 0x3fc3c, 0x3fc50, |
| 0x3fcf0, 0x3fcfc, |
| 0x40000, 0x4000c, |
| 0x40040, 0x40050, |
| 0x40060, 0x40068, |
| 0x4007c, 0x4008c, |
| 0x40094, 0x400b0, |
| 0x400c0, 0x40144, |
| 0x40180, 0x4018c, |
| 0x40200, 0x40254, |
| 0x40260, 0x40264, |
| 0x40270, 0x40288, |
| 0x40290, 0x40298, |
| 0x402ac, 0x402c8, |
| 0x402d0, 0x402e0, |
| 0x402f0, 0x402f0, |
| 0x40300, 0x4033c, |
| 0x403f8, 0x403fc, |
| 0x41304, 0x413c4, |
| 0x41400, 0x4140c, |
| 0x41414, 0x4141c, |
| 0x41480, 0x414d0, |
| 0x44000, 0x44054, |
| 0x4405c, 0x44078, |
| 0x440c0, 0x44174, |
| 0x44180, 0x441ac, |
| 0x441b4, 0x441b8, |
| 0x441c0, 0x44254, |
| 0x4425c, 0x44278, |
| 0x442c0, 0x44374, |
| 0x44380, 0x443ac, |
| 0x443b4, 0x443b8, |
| 0x443c0, 0x44454, |
| 0x4445c, 0x44478, |
| 0x444c0, 0x44574, |
| 0x44580, 0x445ac, |
| 0x445b4, 0x445b8, |
| 0x445c0, 0x44654, |
| 0x4465c, 0x44678, |
| 0x446c0, 0x44774, |
| 0x44780, 0x447ac, |
| 0x447b4, 0x447b8, |
| 0x447c0, 0x44854, |
| 0x4485c, 0x44878, |
| 0x448c0, 0x44974, |
| 0x44980, 0x449ac, |
| 0x449b4, 0x449b8, |
| 0x449c0, 0x449fc, |
| 0x45000, 0x45004, |
| 0x45010, 0x45030, |
| 0x45040, 0x45060, |
| 0x45068, 0x45068, |
| 0x45080, 0x45084, |
| 0x450a0, 0x450b0, |
| 0x45200, 0x45204, |
| 0x45210, 0x45230, |
| 0x45240, 0x45260, |
| 0x45268, 0x45268, |
| 0x45280, 0x45284, |
| 0x452a0, 0x452b0, |
| 0x460c0, 0x460e4, |
| 0x47000, 0x4703c, |
| 0x47044, 0x4708c, |
| 0x47200, 0x47250, |
| 0x47400, 0x47408, |
| 0x47414, 0x47420, |
| 0x47600, 0x47618, |
| 0x47800, 0x47814, |
| 0x48000, 0x4800c, |
| 0x48040, 0x48050, |
| 0x48060, 0x48068, |
| 0x4807c, 0x4808c, |
| 0x48094, 0x480b0, |
| 0x480c0, 0x48144, |
| 0x48180, 0x4818c, |
| 0x48200, 0x48254, |
| 0x48260, 0x48264, |
| 0x48270, 0x48288, |
| 0x48290, 0x48298, |
| 0x482ac, 0x482c8, |
| 0x482d0, 0x482e0, |
| 0x482f0, 0x482f0, |
| 0x48300, 0x4833c, |
| 0x483f8, 0x483fc, |
| 0x49304, 0x493c4, |
| 0x49400, 0x4940c, |
| 0x49414, 0x4941c, |
| 0x49480, 0x494d0, |
| 0x4c000, 0x4c054, |
| 0x4c05c, 0x4c078, |
| 0x4c0c0, 0x4c174, |
| 0x4c180, 0x4c1ac, |
| 0x4c1b4, 0x4c1b8, |
| 0x4c1c0, 0x4c254, |
| 0x4c25c, 0x4c278, |
| 0x4c2c0, 0x4c374, |
| 0x4c380, 0x4c3ac, |
| 0x4c3b4, 0x4c3b8, |
| 0x4c3c0, 0x4c454, |
| 0x4c45c, 0x4c478, |
| 0x4c4c0, 0x4c574, |
| 0x4c580, 0x4c5ac, |
| 0x4c5b4, 0x4c5b8, |
| 0x4c5c0, 0x4c654, |
| 0x4c65c, 0x4c678, |
| 0x4c6c0, 0x4c774, |
| 0x4c780, 0x4c7ac, |
| 0x4c7b4, 0x4c7b8, |
| 0x4c7c0, 0x4c854, |
| 0x4c85c, 0x4c878, |
| 0x4c8c0, 0x4c974, |
| 0x4c980, 0x4c9ac, |
| 0x4c9b4, 0x4c9b8, |
| 0x4c9c0, 0x4c9fc, |
| 0x4d000, 0x4d004, |
| 0x4d010, 0x4d030, |
| 0x4d040, 0x4d060, |
| 0x4d068, 0x4d068, |
| 0x4d080, 0x4d084, |
| 0x4d0a0, 0x4d0b0, |
| 0x4d200, 0x4d204, |
| 0x4d210, 0x4d230, |
| 0x4d240, 0x4d260, |
| 0x4d268, 0x4d268, |
| 0x4d280, 0x4d284, |
| 0x4d2a0, 0x4d2b0, |
| 0x4e0c0, 0x4e0e4, |
| 0x4f000, 0x4f03c, |
| 0x4f044, 0x4f08c, |
| 0x4f200, 0x4f250, |
| 0x4f400, 0x4f408, |
| 0x4f414, 0x4f420, |
| 0x4f600, 0x4f618, |
| 0x4f800, 0x4f814, |
| 0x50000, 0x50084, |
| 0x50090, 0x500cc, |
| 0x50400, 0x50400, |
| 0x50800, 0x50884, |
| 0x50890, 0x508cc, |
| 0x50c00, 0x50c00, |
| 0x51000, 0x5101c, |
| 0x51300, 0x51308, |
| }; |
| |
| if (ddi_copyin(data, &r, sizeof (r), flags) < 0) |
| return (EFAULT); |
| |
| if (r.len > T4_REGDUMP_SIZE) |
| r.len = T4_REGDUMP_SIZE; |
| else if (r.len < T4_REGDUMP_SIZE) |
| return (E2BIG); |
| |
| r.version = mk_adap_vers(sc); |
| |
| if (is_t4(sc->params.chip)) { |
| reg_ranges = &t4_reg_ranges[0]; |
| arr_size = ARRAY_SIZE(t4_reg_ranges); |
| buf_size = T4_REGDUMP_SIZE; |
| } else { |
| reg_ranges = &t5_reg_ranges[0]; |
| arr_size = ARRAY_SIZE(t5_reg_ranges); |
| buf_size = T5_REGDUMP_SIZE; |
| } |
| |
| buf = kmem_zalloc(buf_size, KM_SLEEP); |
| if (buf == NULL) |
| return (ENOMEM); |
| |
| for (i = 0; i < arr_size; i += 2) |
| reg_block_dump(sc, buf, reg_ranges[i], reg_ranges[i + 1]); |
| |
| if (ddi_copyout(buf, r.data, r.len, flags) < 0) |
| rc = EFAULT; |
| |
| if (rc == 0 && ddi_copyout(&r, data, sizeof (r), flags) < 0) |
| rc = EFAULT; |
| |
| kmem_free(buf, buf_size); |
| return (rc); |
| } |
| |
| static int |
| get_sge_context(struct adapter *sc, void *data, int flags) |
| { |
| struct t4_sge_context sgec; |
| uint32_t buff[SGE_CTXT_SIZE / 4]; |
| int rc = 0; |
| |
| if (ddi_copyin(data, &sgec, sizeof (sgec), flags) < 0) { |
| rc = EFAULT; |
| goto _exit; |
| } |
| |
| if (sgec.len < SGE_CTXT_SIZE || sgec.addr > M_CTXTQID) { |
| rc = EINVAL; |
| goto _exit; |
| } |
| |
| if ((sgec.mem_id != T4_CTXT_EGRESS) && (sgec.mem_id != T4_CTXT_FLM) && |
| (sgec.mem_id != T4_CTXT_INGRESS)) { |
| rc = EINVAL; |
| goto _exit; |
| } |
| |
| rc = (sc->flags & FW_OK) ? |
| -t4_sge_ctxt_rd(sc, sc->mbox, sgec.addr, sgec.mem_id, buff) : |
| -t4_sge_ctxt_rd_bd(sc, sgec.addr, sgec.mem_id, buff); |
| if (rc != 0) |
| goto _exit; |
| |
| sgec.version = 4 | (sc->params.chip << 10); |
| |
| /* copyout data and then t4_sge_context */ |
| rc = ddi_copyout(buff, sgec.data, sgec.len, flags); |
| if (rc == 0) |
| rc = ddi_copyout(&sgec, data, sizeof (sgec), flags); |
| /* if ddi_copyout fails, return EFAULT - for either of the two */ |
| if (rc != 0) |
| rc = EFAULT; |
| |
| _exit: |
| return (rc); |
| } |
| |
| static int |
| read_tid_tab(struct adapter *sc, void *data, int flags) |
| { |
| struct t4_tid_info t4tid; |
| uint32_t *buf, *b; |
| struct tid_info *t = &sc->tids; |
| int rc = 0; |
| |
| if (ddi_copyin(data, &t4tid, sizeof (t4tid), flags) < 0) { |
| rc = EFAULT; |
| goto _exit; |
| } |
| |
| buf = b = kmem_zalloc(t4tid.len, KM_NOSLEEP); |
| if (buf == NULL) { |
| rc = ENOMEM; |
| goto _exit; |
| } |
| |
| *b++ = t->tids_in_use; |
| *b++ = t->atids_in_use; |
| *b = t->stids_in_use; |
| |
| if (ddi_copyout(buf, t4tid.data, t4tid.len, flags) < 0) |
| rc = EFAULT; |
| |
| kmem_free(buf, t4tid.len); |
| |
| _exit: |
| return (rc); |
| } |
| |
| /* |
| * Verify that the memory range specified by the addr/len pair is valid and lies |
| * entirely within a single region (EDCx or MCx). |
| */ |
| static int |
| validate_mem_range(struct adapter *sc, uint32_t addr, int len) |
| { |
| uint32_t em, addr_len, maddr, mlen; |
| |
| /* Memory can only be accessed in naturally aligned 4 byte units */ |
| if (addr & 3 || len & 3 || len == 0) |
| return (EINVAL); |
| |
| /* Enabled memories */ |
| em = t4_read_reg(sc, A_MA_TARGET_MEM_ENABLE); |
| if (em & F_EDRAM0_ENABLE) { |
| addr_len = t4_read_reg(sc, A_MA_EDRAM0_BAR); |
| maddr = G_EDRAM0_BASE(addr_len) << 20; |
| mlen = G_EDRAM0_SIZE(addr_len) << 20; |
| if (mlen > 0 && addr >= maddr && addr < maddr + mlen && |
| addr + len <= maddr + mlen) |
| return (0); |
| } |
| if (em & F_EDRAM1_ENABLE) { |
| addr_len = t4_read_reg(sc, A_MA_EDRAM1_BAR); |
| maddr = G_EDRAM1_BASE(addr_len) << 20; |
| mlen = G_EDRAM1_SIZE(addr_len) << 20; |
| if (mlen > 0 && addr >= maddr && addr < maddr + mlen && |
| addr + len <= maddr + mlen) |
| return (0); |
| } |
| if (em & F_EXT_MEM_ENABLE) { |
| addr_len = t4_read_reg(sc, A_MA_EXT_MEMORY_BAR); |
| maddr = G_EXT_MEM_BASE(addr_len) << 20; |
| mlen = G_EXT_MEM_SIZE(addr_len) << 20; |
| if (mlen > 0 && addr >= maddr && addr < maddr + mlen && |
| addr + len <= maddr + mlen) |
| return (0); |
| } |
| if (!is_t4(sc->params.chip) && em & F_EXT_MEM1_ENABLE) { |
| addr_len = t4_read_reg(sc, A_MA_EXT_MEMORY1_BAR); |
| maddr = G_EXT_MEM1_BASE(addr_len) << 20; |
| mlen = G_EXT_MEM1_SIZE(addr_len) << 20; |
| if (mlen > 0 && addr >= maddr && addr < maddr + mlen && |
| addr + len <= maddr + mlen) |
| return (0); |
| } |
| |
| return (EFAULT); |
| } |
| |
| static int |
| read_card_mem(struct adapter *sc, void *data, int flags) |
| { |
| struct t4_mem_range mr; |
| uint32_t addr, off, remaining, i, n; |
| uint32_t *buf, *b; |
| int rc = 0; |
| uint32_t mw_base, mw_aperture; |
| uint8_t *dst; |
| |
| if (ddi_copyin(data, &mr, sizeof (mr), flags) < 0) { |
| rc = EFAULT; |
| goto _exit; |
| } |
| |
| rc = validate_mem_range(sc, mr.addr, mr.len); |
| if (rc != 0) |
| return (rc); |
| |
| memwin_info(sc, 2, &mw_base, &mw_aperture); |
| buf = b = kmem_zalloc(min(mr.len, mw_aperture), KM_NOSLEEP); |
| if (buf == NULL) { |
| rc = ENOMEM; |
| goto _exit; |
| } |
| |
| addr = mr.addr; |
| remaining = mr.len; |
| dst = (void *)mr.data; |
| |
| while (remaining) { |
| off = position_memwin(sc, 2, addr); |
| |
| /* number of bytes that we'll copy in the inner loop */ |
| n = min(remaining, mw_aperture - off); |
| |
| for (i = 0; i < n; i += 4) |
| *b++ = t4_read_reg(sc, mw_base + off + i); |
| rc = ddi_copyout(buf, dst, n, flags); |
| if (rc != 0) { |
| rc = EFAULT; |
| break; |
| } |
| |
| b = buf; |
| dst += n; |
| remaining -= n; |
| addr += n; |
| } |
| |
| kmem_free(buf, min(mr.len, mw_aperture)); |
| _exit: |
| return (rc); |
| } |
| |
| static int |
| get_devlog(struct adapter *sc, void *data, int flags) |
| { |
| struct devlog_params *dparams = &sc->params.devlog; |
| struct fw_devlog_e *buf; |
| struct t4_devlog dl; |
| int rc = 0; |
| |
| if (ddi_copyin(data, &dl, sizeof (dl), flags) < 0) { |
| rc = EFAULT; |
| goto done; |
| } |
| |
| if (dparams->start == 0) { |
| dparams->memtype = 0; |
| dparams->start = 0x84000; |
| dparams->size = 32768; |
| } |
| |
| if (dl.len < dparams->size) { |
| dl.len = dparams->size; |
| rc = ddi_copyout(&dl, data, sizeof (dl), flags); |
| /* |
| * rc = 0 indicates copyout was successful, then return ENOBUFS |
| * to indicate that the buffer size was not enough. Return of |
| * EFAULT indicates that the copyout was not successful. |
| */ |
| rc = (rc == 0) ? ENOBUFS : EFAULT; |
| goto done; |
| } |
| |
| buf = kmem_zalloc(dparams->size, KM_NOSLEEP); |
| if (buf == NULL) { |
| rc = ENOMEM; |
| goto done; |
| } |
| |
| rc = -t4_memory_rw(sc, sc->params.drv_memwin, dparams->memtype, |
| dparams->start, dparams->size, (void *)buf, |
| T4_MEMORY_READ); |
| if (rc != 0) |
| goto done1; |
| |
| /* Copyout device log buffer and then carrier buffer */ |
| if (ddi_copyout(buf, (void *)((uintptr_t)data + sizeof(dl)), dl.len, |
| flags) < 0) |
| rc = EFAULT; |
| |
| if (ddi_copyout(&dl, data, sizeof(dl), flags) < 0) |
| rc = EFAULT; |
| |
| done1: |
| kmem_free(buf, dparams->size); |
| |
| done: |
| return (rc); |
| } |
| |
| static int |
| read_cim_qcfg(struct adapter *sc, void *data, int flags) |
| { |
| struct t4_cim_qcfg t4cimqcfg; |
| int rc = 0; |
| unsigned int ibq_rdaddr, obq_rdaddr, nq; |
| |
| if (ddi_copyin(data, &t4cimqcfg, sizeof (t4cimqcfg), flags) < 0) { |
| rc = EFAULT; |
| goto _exit; |
| } |
| |
| if (is_t4(sc->params.chip)) { |
| t4cimqcfg.num_obq = CIM_NUM_OBQ; |
| ibq_rdaddr = A_UP_IBQ_0_RDADDR; |
| obq_rdaddr = A_UP_OBQ_0_REALADDR; |
| } else { |
| t4cimqcfg.num_obq = CIM_NUM_OBQ_T5; |
| ibq_rdaddr = A_UP_IBQ_0_SHADOW_RDADDR; |
| obq_rdaddr = A_UP_OBQ_0_SHADOW_REALADDR; |
| } |
| nq = CIM_NUM_IBQ + t4cimqcfg.num_obq; |
| |
| rc = -t4_cim_read(sc, ibq_rdaddr, 4 * nq, t4cimqcfg.stat); |
| if (rc == 0) |
| rc = -t4_cim_read(sc, obq_rdaddr, 2 * t4cimqcfg.num_obq, |
| t4cimqcfg.obq_wr); |
| if (rc != 0) |
| return (rc); |
| |
| t4_read_cimq_cfg(sc, t4cimqcfg.base, t4cimqcfg.size, t4cimqcfg.thres); |
| |
| if (ddi_copyout(&t4cimqcfg, data, sizeof (t4cimqcfg), flags) < 0) |
| rc = EFAULT; |
| |
| _exit: |
| return (rc); |
| } |
| |
| static int |
| read_edc(struct adapter *sc, void *data, int flags) |
| { |
| struct t4_edc t4edc; |
| int rc = 0; |
| u32 count, pos = 0; |
| u32 memoffset; |
| __be32 *edc = NULL; |
| |
| if (ddi_copyin(data, &t4edc, sizeof (t4edc), flags) < 0) { |
| rc = EFAULT; |
| goto _exit; |
| } |
| |
| if (t4edc.mem > 2) |
| goto _exit; |
| |
| edc = kmem_zalloc(t4edc.len, KM_NOSLEEP); |
| if (edc == NULL) { |
| rc = ENOMEM; |
| goto _exit; |
| } |
| /* |
| * Offset into the region of memory which is being accessed |
| * MEM_EDC0 = 0 |
| * MEM_EDC1 = 1 |
| * MEM_MC = 2 |
| */ |
| memoffset = (t4edc.mem * (5 * 1024 * 1024)); |
| count = t4edc.len; |
| pos = t4edc.pos; |
| |
| while (count) { |
| u32 len; |
| |
| rc = t4_memory_rw(sc, sc->params.drv_memwin, memoffset, pos, |
| count, edc, T4_MEMORY_READ); |
| if (rc != 0) { |
| kmem_free(edc, t4edc.len); |
| goto _exit; |
| } |
| |
| len = MEMWIN0_APERTURE; |
| pos += len; |
| count -= len; |
| } |
| |
| if (ddi_copyout(edc, t4edc.data, t4edc.len, flags) < 0) |
| rc = EFAULT; |
| |
| kmem_free(edc, t4edc.len); |
| _exit: |
| return (rc); |
| } |
| |
| static int |
| read_cim_ibq(struct adapter *sc, void *data, int flags) |
| { |
| struct t4_ibq t4ibq; |
| int rc = 0; |
| __be64 *buf; |
| |
| if (ddi_copyin(data, &t4ibq, sizeof (t4ibq), flags) < 0) { |
| rc = EFAULT; |
| goto _exit; |
| } |
| |
| buf = kmem_zalloc(t4ibq.len, KM_NOSLEEP); |
| if (buf == NULL) { |
| rc = ENOMEM; |
| goto _exit; |
| } |
| |
| rc = t4_read_cim_ibq(sc, 3, (u32 *)buf, CIM_IBQ_SIZE * 4); |
| if (rc < 0) { |
| kmem_free(buf, t4ibq.len); |
| return (rc); |
| } else |
| rc = 0; |
| |
| if (ddi_copyout(buf, t4ibq.data, t4ibq.len, flags) < 0) |
| rc = EFAULT; |
| |
| kmem_free(buf, t4ibq.len); |
| |
| _exit: |
| return (rc); |
| } |
| |
| static int |
| read_cim_la(struct adapter *sc, void *data, int flags) |
| { |
| struct t4_cim_la t4cimla; |
| int rc = 0; |
| unsigned int cfg; |
| __be64 *buf; |
| |
| rc = t4_cim_read(sc, A_UP_UP_DBG_LA_CFG, 1, &cfg); |
| if (rc != 0) |
| return (rc); |
| |
| if (ddi_copyin(data, &t4cimla, sizeof (t4cimla), flags) < 0) { |
| rc = EFAULT; |
| goto _exit; |
| } |
| |
| buf = kmem_zalloc(t4cimla.len, KM_NOSLEEP); |
| if (buf == NULL) { |
| rc = ENOMEM; |
| goto _exit; |
| } |
| |
| rc = t4_cim_read_la(sc, (u32 *)buf, NULL); |
| if (rc != 0) { |
| kmem_free(buf, t4cimla.len); |
| return (rc); |
| } |
| |
| if (ddi_copyout(buf, t4cimla.data, t4cimla.len, flags) < 0) |
| rc = EFAULT; |
| |
| kmem_free(buf, t4cimla.len); |
| |
| _exit: |
| return (rc); |
| } |
| |
| static int |
| read_mbox(struct adapter *sc, void *data, int flags) |
| { |
| struct t4_mbox t4mbox; |
| int rc = 0, i; |
| __be64 *p, *buf; |
| |
| u32 data_reg = PF_REG(4, A_CIM_PF_MAILBOX_DATA); |
| |
| if (ddi_copyin(data, &t4mbox, sizeof (t4mbox), flags) < 0) { |
| rc = EFAULT; |
| goto _exit; |
| } |
| |
| buf = p = kmem_zalloc(t4mbox.len, KM_NOSLEEP); |
| if (buf == NULL) { |
| rc = ENOMEM; |
| goto _exit; |
| } |
| |
| for (i = 0; i < t4mbox.len; i += 8, p++) |
| *p = t4_read_reg64(sc, data_reg + i); |
| |
| if (ddi_copyout(buf, t4mbox.data, t4mbox.len, flags) < 0) |
| rc = EFAULT; |
| |
| kmem_free(buf, t4mbox.len); |
| |
| _exit: |
| return (rc); |
| } |
| |
| static int |
| flash_fw(struct adapter *sc, void *data, int flags) |
| { |
| unsigned int mbox = M_PCIE_FW_MASTER + 1; |
| struct t4_ldfw fw; |
| u8 *ptr = NULL; |
| int rc = 0; |
| |
| if (ddi_copyin(data, &fw, sizeof(struct t4_ldfw), flags) < 0) |
| return EFAULT; |
| |
| if (!fw.len) |
| return EINVAL; |
| |
| ptr = (u8 *)kmem_zalloc(fw.len, KM_NOSLEEP); |
| if (ptr == NULL) |
| return ENOMEM; |
| |
| if (ddi_copyin((void *)((uintptr_t)data + sizeof(fw)), ptr, fw.len, |
| flags) < 0) { |
| kmem_free(ptr, fw.len); |
| return EFAULT; |
| } |
| |
| if (sc->flags & FULL_INIT_DONE) |
| mbox = sc->mbox; |
| |
| rc = -t4_fw_upgrade(sc, mbox, ptr, fw.len, true); |
| |
| kmem_free(ptr, fw.len); |
| |
| return (rc); |
| } |