sys/compat/linuxkpi/common/include/linux/dma-mapping.h
360	Shouldn't this here be dma_unmap_sg_attrs with the attrs passed in (even though it's later ignored) so in case our version will ever respect "attrs" it'll do the right thing here already?

Use dma_unmap_sg_attrs in dma_unmap_sgtable

Harbormaster completed remote builds in B46856: Diff 109151.Aug 11 2022, 7:54 AM

manu marked an inline comment as done.Aug 11 2022, 7:54 AM

bz accepted this revision.Aug 11 2022, 11:29 AM

This revision is now accepted and ready to land.Aug 11 2022, 11:29 AM

Closed by commit rG9202c95f47c2: linuxkpi: Add dma_{un,}map_sgtable (authored by manu). · Explain WhyAug 18 2022, 9:13 AM

This revision was automatically updated to reflect the committed changes.

manu added a commit: rG9202c95f47c2: linuxkpi: Add dma_{un,}map_sgtable.

manu added a commit: rG5a82e33df4ce: linuxkpi: Add dma_{un,}map_sgtable.Sep 7 2022, 3:12 PM

Revision Contents
Changeset List

Path

Size

sys/

compat/

linuxkpi/

common/

include/

linux/

dma-mapping.h

20 lines

Diff 109151

View Options

sys/compat/linuxkpi/common/include/linux/dma-mapping.h

This file was added.

				/*-
				* Copyright (c) 2014 Alexander V. Chernikov. All rights reserved.
				* Copyright (c) 2020, Ryan Moeller <freqlabs@FreeBSD.org>
				*
				* Redistribution and use in source and binary forms, with or without
				* modification, are permitted provided that the following conditions
				* are met:
				* 1. Redistributions of source code must retain the above copyright
				* notice, this list of conditions and the following disclaimer.
				* 2. Redistributions in binary form must reproduce the above copyright
				* notice, this list of conditions and the following disclaimer in the
				* documentation and/or other materials provided with the distribution.
				*
				* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
				* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
				* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
				* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
				* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
				* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
				* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
				* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
				* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
				* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
				* SUCH DAMAGE.
				*
				* $FreeBSD$
				*/

				#include <sys/types.h>
				#include <sys/param.h>
				#include <sys/ioctl.h>
				#include <sys/socket.h>

				#include <net/if.h>
				#include <net/sff8436.h>
				#include <net/sff8472.h>

				#include <math.h>
				#include <err.h>
				#include <errno.h>
				#include <fcntl.h>
				#include <stdbool.h>
				#include <stdio.h>
				#include <stdlib.h>
				#include <string.h>
				#include <unistd.h>

				#include <libifconfig.h>
				#include <libifconfig_internal.h>
				#include <libifconfig_sfp.h>
				#include <libifconfig_sfp_tables_internal.h>

				#define SFF_8636_EXT_COMPLIANCE 0x80

				struct i2c_info {
				struct ifreq ifr;
				ifconfig_handle_t *h;
				int error; /* Store first error */
				bool qsfp; /* True if transceiver is QSFP */
				};
				melifaroUnsubmitted Done Inline Actions This boilerplate seem also to be required only because of approach taken in .h melifaro: This boilerplate seem also to be required only because of approach taken in .h

				static uint8_t
				find_zero_bit(const struct sfp_enum_metadata *table, int value, int sz)
				{
				int v, m;

				for (v = 1, m = 1 << (8 * sz); v < m; v <<= 1) {
				if ((value & v) == 0)
				continue;
				if (find_metadata(table, value & v) != NULL) {
				return (value & v);
				}
				}
				return (0);
				}

				/*
				* Reads i2c data from opened kernel socket.
				*/
				static int
				read_i2c(struct i2c_info *ii, uint8_t addr, uint8_t off, uint8_t len,
				uint8_t *buf)
				{
				struct ifi2creq req;
				int i, l;

				if (ii->error != 0)
				return (ii->error);

				ii->ifr.ifr_data = (caddr_t)&req;

				i = 0;
				l = 0;
				memset(&req, 0, sizeof(req));
				req.dev_addr = addr;
				req.offset = off;
				req.len = len;

				while (len > 0) {
				l = MIN(sizeof(req.data), len);
				req.len = l;
				if (ifconfig_ioctlwrap(ii->h, AF_LOCAL, SIOCGI2C,
				&ii->ifr) != 0) {
				ii->error = errno;
				return (errno);
				}

				memcpy(&buf[i], req.data, l);
				len -= l;
				i += l;
				req.offset += l;
				}

				return (0);
				}

				static int
				i2c_info_init(struct i2c_info ii, ifconfig_handle_t h, const char *name)
				{
				uint8_t id_byte;

				memset(ii, 0, sizeof(*ii));
				strlcpy(ii->ifr.ifr_name, name, sizeof(ii->ifr.ifr_name));
				ii->h = h;

				/*
				* Try to read byte 0 from i2c:
				* Both SFF-8472 and SFF-8436 use it as
				* 'identification byte'.
				* Stop reading status on zero as value -
				* this might happen in case of empty transceiver slot.
				*/
				id_byte = 0;
				read_i2c(ii, SFF_8472_BASE, SFF_8472_ID, 1, &id_byte);
				if (ii->error != 0)
				return (-1);
				switch (id_byte) {
				case 0:
				h->error.errtype = OTHER;
				h->error.errcode = ENOENT;
				return (-1);
				case SFF_8024_ID_QSFP:
				case SFF_8024_ID_QSFPPLUS:
				case SFF_8024_ID_QSFP28:
				ii->qsfp = true;
				default:
				return (0);
				}
				}

				static int
				get_sfp_info(struct i2c_info ii, struct ifconfig_sfp_info sfp)
				{
				uint8_t code;

				read_i2c(ii, SFF_8472_BASE, SFF_8472_ID, 1, &sfp->sfp_id);
				read_i2c(ii, SFF_8472_BASE, SFF_8472_CONNECTOR, 1, &sfp->sfp_conn);

				/* Use extended compliance code if it's valid */
				read_i2c(ii, SFF_8472_BASE, SFF_8472_TRANS, 1, &sfp->sfp_eth_ext);
				if (sfp->sfp_eth_ext == 0) {
				/* Next, check 10G Ethernet/IB CCs */
				read_i2c(ii, SFF_8472_BASE, SFF_8472_TRANS_START, 1, &code);
				sfp->sfp_eth_10g = find_zero_bit(sfp_eth_10g_table, code, 1);
				if (sfp->sfp_eth_10g == 0) {
				/* No match. Try Ethernet 1G */
				read_i2c(ii, SFF_8472_BASE, SFF_8472_TRANS_START + 3,
				1, &code);
				sfp->sfp_eth = find_zero_bit(sfp_eth_table, code, 1);
				}
				}

				return (ii->error);
				}

				static int
				get_qsfp_info(struct i2c_info ii, struct ifconfig_sfp_info sfp)
				{
				uint8_t code;

				read_i2c(ii, SFF_8436_BASE, SFF_8436_ID, 1, &sfp->sfp_id);
				read_i2c(ii, SFF_8436_BASE, SFF_8436_CONNECTOR, 1, &sfp->sfp_conn);

				read_i2c(ii, SFF_8436_BASE, SFF_8436_STATUS, 1, &sfp->sfp_rev);

				/* Check for extended specification compliance */
				read_i2c(ii, SFF_8436_BASE, SFF_8436_CODE_E1040100G, 1, &code);
				if (code & SFF_8636_EXT_COMPLIANCE) {
				read_i2c(ii, SFF_8436_BASE, SFF_8436_OPTIONS_START, 1,
				&sfp->sfp_eth_ext);
				} else {
				/* Check 10/40G Ethernet class only */
				sfp->sfp_eth_1040g =
				find_zero_bit(sfp_eth_1040g_table, code, 1);
				}

				return (ii->error);
				}

				int
				ifconfig_sfp_get_sfp_info(ifconfig_handle_t *h,
				const char name, struct ifconfig_sfp_info sfp)
				{
				struct i2c_info ii;
				char buf[8];

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

				if (i2c_info_init(&ii, h, name) != 0)
				return (-1);

				/* Read bytes 3-10 at once */
				read_i2c(&ii, SFF_8472_BASE, SFF_8472_TRANS_START, 8, buf);
				if (ii.error != 0)
				return (ii.error);

				/* Check 10G ethernet first */
				sfp->sfp_eth_10g = find_zero_bit(sfp_eth_10g_table, buf[0], 1);
				if (sfp->sfp_eth_10g == 0) {
				/* No match. Try 1G */
				sfp->sfp_eth = find_zero_bit(sfp_eth_table, buf[3], 1);
				}
				sfp->sfp_fc_len = find_zero_bit(sfp_fc_len_table, buf[4], 1);
				sfp->sfp_fc_media = find_zero_bit(sfp_fc_media_table, buf[6], 1);
				sfp->sfp_fc_speed = find_zero_bit(sfp_fc_speed_table, buf[7], 1);
				sfp->sfp_cab_tech =
				find_zero_bit(sfp_cab_tech_table, (buf[4] << 8) \| buf[5], 2);

				if (ii.qsfp)
				return (get_qsfp_info(&ii, sfp));
				return (get_sfp_info(&ii, sfp));
				}

				/*
				* Print SFF-8472/SFF-8436 string to supplied buffer.
				* All (vendor-specific) strings are padded right with '0x20'.
				*/
				static void
				get_sff_string(struct i2c_info ii, uint8_t addr, uint8_t off, char dst)
				{
				read_i2c(ii, addr, off, SFF_VENDOR_STRING_SIZE, dst);
				dst += SFF_VENDOR_STRING_SIZE;
				do { dst-- = '\0'; } while (dst == 0x20);
				}

				static void
				get_sff_date(struct i2c_info ii, uint8_t addr, uint8_t off, char dst)
				{
				char buf[SFF_VENDOR_DATE_SIZE];

				read_i2c(ii, addr, off, SFF_VENDOR_DATE_SIZE, buf);
				sprintf(dst, "20%c%c-%c%c-%c%c", buf[0], buf[1], buf[2], buf[3],
				buf[4], buf[5]);
				}

				static int
				get_sfp_vendor_info(struct i2c_info ii, struct ifconfig_sfp_vendor_info vi)
				{
				get_sff_string(ii, SFF_8472_BASE, SFF_8472_VENDOR_START, vi->name);
				get_sff_string(ii, SFF_8472_BASE, SFF_8472_PN_START, vi->pn);
				get_sff_string(ii, SFF_8472_BASE, SFF_8472_SN_START, vi->sn);
				get_sff_date(ii, SFF_8472_BASE, SFF_8472_DATE_START, vi->date);
				return (ii->error);
				}

				static int
				get_qsfp_vendor_info(struct i2c_info ii, struct ifconfig_sfp_vendor_info vi)
				{
				get_sff_string(ii, SFF_8436_BASE, SFF_8436_VENDOR_START, vi->name);
				get_sff_string(ii, SFF_8436_BASE, SFF_8436_PN_START, vi->pn);
				get_sff_string(ii, SFF_8436_BASE, SFF_8436_SN_START, vi->sn);
				get_sff_date(ii, SFF_8436_BASE, SFF_8436_DATE_START, vi->date);
				return (ii->error);
				}

				int
				ifconfig_sfp_get_sfp_vendor_info(ifconfig_handle_t *h,
				const char name, struct ifconfig_sfp_vendor_info vi)
				{
				struct i2c_info ii;

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

				if (i2c_info_init(&ii, h, name) != 0)
				return (-1);

				if (ii.qsfp)
				return (get_qsfp_vendor_info(&ii, vi));
				return (get_sfp_vendor_info(&ii, vi));
				}

				/*
				* Converts internal temperature (SFF-8472, SFF-8436)
				* 16-bit unsigned value to human-readable representation:
				*
				* Internally measured Module temperature are represented
				* as a 16-bit signed twos complement value in increments of
				* 1/256 degrees Celsius, yielding a total range of –128C to +128C
				* that is considered valid between –40 and +125C.
				*/
				static double
				get_sff_temp(struct i2c_info *ii, uint8_t addr, uint8_t off)
				{
				double d;
				uint8_t buf[2];

				read_i2c(ii, addr, off, 2, buf);
				d = (double)buf[0];
				d += (double)buf[1] / 256;
				return (d);
				}

				/*
				* Retrieves supplied voltage (SFF-8472, SFF-8436).
				* 16-bit usigned value, treated as range 0..+6.55 Volts
				*/
				static double
				get_sff_voltage(struct i2c_info *ii, uint8_t addr, uint8_t off)
				{
				double d;
				uint8_t buf[2];

				read_i2c(ii, addr, off, 2, buf);
				d = (double)((buf[0] << 8) \| buf[1]);
				return (d / 10000);
				}

				double
				mW_to_dBm(uint16_t mW)
				{
				/*
				* Assume internally-calibrated data.
				* This is always true for SFF-8346, and explicitly
				* checked for SFF-8472.
				*/
				return (10.0 * log10(1.0 * mW / 10000));
				}

				static uint16_t
				get_sff_power(struct i2c_info *ii, uint8_t addr, uint8_t off)
				{
				uint8_t buf[2];

				read_i2c(ii, addr, off, 2, buf);
				if (ii->error != 0)
				return (0);

				return ((buf[0] << 8) + buf[1]);
				}

				static int
				get_sfp_status(struct i2c_info ii, struct ifconfig_sfp_status ss)
				{
				uint8_t diag_type, flags;

				/* Read diagnostic monitoring type */
				read_i2c(ii, SFF_8472_BASE, SFF_8472_DIAG_TYPE, 1, (caddr_t)&diag_type);
				if (ii->error != 0)
				return (-1);

				/*
				* Read monitoring data IFF it is supplied AND is
				* internally calibrated
				*/
				flags = SFF_8472_DDM_DONE \| SFF_8472_DDM_INTERNAL;
				if ((diag_type & flags) != flags) {
				ii->h->error.errtype = OTHER;
				ii->h->error.errcode = ENXIO;
				return (-1);
				}

				ss->temp = get_sff_temp(ii, SFF_8472_DIAG, SFF_8472_TEMP);
				ss->voltage = get_sff_voltage(ii, SFF_8472_DIAG, SFF_8472_VCC);
				ss->power[0].rx = get_sff_power(ii, SFF_8472_DIAG, SFF_8472_RX_POWER);
				ss->power[0].tx = get_sff_power(ii, SFF_8472_DIAG, SFF_8472_TX_POWER);
				return (ii->error);
				}

				static uint32_t
				get_qsfp_bitrate(struct i2c_info *ii)
				{
				uint8_t code;
				uint32_t rate;

				code = 0;
				read_i2c(ii, SFF_8436_BASE, SFF_8436_BITRATE, 1, &code);
				rate = code * 100;
				if (code == 0xFF) {
				read_i2c(ii, SFF_8436_BASE, SFF_8636_BITRATE, 1, &code);
				rate = code * 250;
				}

				return (rate);
				}

				static int
				get_qsfp_status(struct i2c_info ii, struct ifconfig_sfp_status ss)
				{
				ss->temp = get_sff_temp(ii, SFF_8436_BASE, SFF_8436_TEMP);
				ss->voltage = get_sff_voltage(ii, SFF_8436_BASE, SFF_8436_VCC);
				for (size_t chan = 0; chan < nitems(ss->power); ++chan) {
				uint8_t rxoffs = SFF_8436_RX_CH1_MSB + chan * sizeof(uint16_t);
				uint8_t txoffs = SFF_8436_TX_CH1_MSB + chan * sizeof(uint16_t);
				ss->power[chan].rx = get_sff_power(ii, SFF_8436_BASE, rxoffs);
				ss->power[chan].tx = get_sff_power(ii, SFF_8436_BASE, txoffs);
				}
				ss->bitrate = get_qsfp_bitrate(ii);
				return (ii->error);
				}

				int
				ifconfig_sfp_get_sfp_status(ifconfig_handle_t h, const char name,
				struct ifconfig_sfp_status *ss)
				{
				struct i2c_info ii;

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

				if (i2c_info_init(&ii, h, name) != 0)
				return (-1);

				if (ii.qsfp)
				return (get_qsfp_status(&ii, ss));
				return (get_sfp_status(&ii, ss));
				}

				static const char *
				sfp_id_string_alt(uint8_t value)
				{
				const char *id;

				if (value <= SFF_8024_ID_LAST)
				id = sff_8024_id[value];
				else if (value > 0x80)
				id = "Vendor specific";
				else
				id = "Reserved";

				return (id);
				}

				static const char *
				sfp_conn_string_alt(uint8_t value)
				{
				const char *conn;

				if (value >= 0x0D && value <= 0x1F)
				conn = "Unallocated";
				else if (value >= 0x24 && value <= 0x7F)
				conn = "Unallocated";
				else
				conn = "Vendor specific";

				return (conn);
				}

				void
				ifconfig_sfp_get_sfp_info_strings(struct ifconfig_sfp_info *sfp,
				struct ifconfig_sfp_info_strings *strings)
				{
				get_sfp_info_strings(sfp, strings);
				if (strings->sfp_id == NULL)
				strings->sfp_id = sfp_id_string_alt(sfp->sfp_id);
				if (strings->sfp_conn == NULL)
				strings->sfp_conn = sfp_conn_string_alt(sfp->sfp_conn);
				if (strings->sfp_rev == NULL)
				strings->sfp_rev = "Unallocated";
				}

				int
				ifconfig_sfp_get_sfp_dump(ifconfig_handle_t h, const char name,
				struct ifconfig_sfp_dump *dump)
				{
				struct i2c_info ii;
				uint8_t *buf = dump->data;

				memset(dump->data, 0, sizeof(dump->data));

				if (i2c_info_init(&ii, h, name) != 0)
				return (-1);

				if (ii.qsfp) {
				dump->qsfp = true;
				read_i2c(&ii, SFF_8436_BASE, QSFP_DUMP0_START, QSFP_DUMP0_SIZE,
				buf);
				read_i2c(&ii, SFF_8436_BASE, QSFP_DUMP1_START, QSFP_DUMP1_SIZE,
				buf + QSFP_DUMP1_START);
				} else {
				read_i2c(&ii, SFF_8472_BASE, SFP_DUMP_START, SFP_DUMP_SIZE,
				buf);
				}

				return (ii.error != 0 ? -1 : 0);
				}
				melifaroUnsubmitted Done Inline Actions Can this be put in a separate file (if this code existence is really necessary) ? melifaro: Can this be put in a separate file (if this code existence is really necessary) ?
				freqlabsAuthorUnsubmitted Done Inline Actions Sure, both of the macro sections could be hidden away in separate files. I can also add comments with instructions how to make changes. If not for shortcomings of the C preprocessor, most of the macro code here could be mechanically generated as well. freqlabs: Sure, both of the macro sections could be hidden away in separate files. I can also add…

linuxkpi: Add dma_{un,}map_sgtableClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 109151

sys/compat/linuxkpi/common/include/linux/dma-mapping.h

linuxkpi: Add dma_{un,}map_sgtable
ClosedPublic
Actions

Revision Contents
Changeset List