Commit 9382531e authored by Kalle Valo's avatar Kalle Valo
Browse files

Merge tag 'mt76-for-kvalo-2021-04-21' of https://github.com/nbd168/wireless 

mt76 patches for 5.13

* testmode improvements
* bugfixes
* device tree power limits support for 7615 and newer
* hardware recovery fixes
* mt7663 reset/init fixes
* mt7915 flash pre-calibration support
* mt7921/mt7663 runtime power management fixes

# gpg: Signature made Wed 21 Apr 2021 09:58:49 PM EEST using DSA key ID 02A76EF5
# gpg: Good signature from "Felix Fietkau <nbd@nbd.name>"
# gpg: WARNING: This key is not certified with a trusted signature!
# gpg:          There is no indication that the signature belongs to the owner.
# Primary key fingerprint: 75D1 1A7D 91A7 710F 4900  42EF D77D 141D 02A7 6EF5
parents 7a4fc715 3df93214

Documentation/devicetree/bindings/net/wireless/mediatek,mt76.yaml

+107 −0
Original line number Diff line number Diff line
@@ -72,6 +72,90 @@ properties: 
      led-sources:

        maxItems: 1



  power-limits:

    type: object

    additionalProperties: false

    patternProperties:

      "^r[0-9]+":

        type: object

        additionalProperties: false

        properties:

          regdomain:

            $ref: /schemas/types.yaml#/definitions/string

            description:

              Regdomain refers to a legal regulatory region. Different

              countries define different levels of allowable transmitter

              power, time that a channel can be occupied, and different

              available channels

            enum:

              - FCC

              - ETSI

              - JP



        patternProperties:

          "^txpower-[256]g$":

            type: object

            additionalProperties: false

            patternProperties:

              "^b[0-9]+$":

                type: object

                additionalProperties: false

                properties:

                  channels:

                    $ref: /schemas/types.yaml#/definitions/uint32-array

                    minItems: 2

                    maxItems: 2

                    description:

                      Pairs of first and last channel number of the selected

                      band



                  rates-cck:

                    $ref: /schemas/types.yaml#/definitions/uint8-array

                    minItems: 4

                    maxItems: 4

                    description:

                      4 half-dBm per-rate power limit values



                  rates-ofdm:

                    $ref: /schemas/types.yaml#/definitions/uint8-array

                    minItems: 8

                    maxItems: 8

                    description:

                      8 half-dBm per-rate power limit values



                  rates-mcs:

                    $ref: /schemas/types.yaml#/definitions/uint8-matrix

                    description:

                      Sets of per-rate power limit values for 802.11n/802.11ac

                      rates for multiple channel bandwidth settings.

                      Each set starts with the number of channel bandwidth

                      settings for which the rate set applies, followed by

                      either 8 or 10 power limit values. The order of the

                      channel bandwidth settings is 20, 40, 80 and 160 MHz.

                    maxItems: 4

                    items:

                      minItems: 9

                      maxItems: 11



                  rates-ru:

                    $ref: /schemas/types.yaml#/definitions/uint8-matrix

                    description:

                      Sets of per-rate power limit values for 802.11ax rates

                      for multiple channel bandwidth or resource unit settings.

                      Each set starts with the number of channel bandwidth or

                      resource unit settings for which the rate set applies,

                      followed by 12 power limit values. The order of the

                      channel resource unit settings is RU26, RU52, RU106,

                      RU242/SU20, RU484/SU40, RU996/SU80 and RU2x996/SU160.

                    items:

                      minItems: 13

                      maxItems: 13



                  txs-delta:

                    $ref: /schemas/types.yaml#/definitions/uint32-array

                    description:

                      Half-dBm power delta for different numbers of antennas



required:

  - compatible

  - reg
@@ -93,6 +177,29 @@ examples: 
        led {

          led-sources = <2>;

        };



        power-limits {

          r0 {

            regdomain = "FCC";

            txpower-5g {

               b0 {

                   channels = <36 48>;

                   rates-ofdm = /bits/ 8 <23 23 23 23 23 23 23 23>;

                   rates-mcs = /bits/ 8 <1 23 23 23 23 23 23 23 23 23 23>,

                                        <3 22 22 22 22 22 22 22 22 22 22>;

                   rates-ru = /bits/ 8 <3 22 22 22 22 22 22 22 22 22 22 22 22>,

                                       <4 20 20 20 20 20 20 20 20 20 20 20 20>;

               };

               b1 {

                   channels = <100 181>;

                   rates-ofdm = /bits/ 8 <14 14 14 14 14 14 14 14>;

                   rates-mcs = /bits/ 8  <4 14 14 14 14 14 14 14 14 14 14>;

                   txs-delta = <12 9 6>;

                   rates-ru = /bits/ 8  <7 14 14 14 14 14 14 14 14 14 14 14 14>;

               };

             };

          };

        };

      };

    };

drivers/net/wireless/mediatek/mt76/debugfs.c

+28 −0
Original line number Diff line number Diff line
@@ -25,6 +25,32 @@ mt76_reg_get(void *data, u64 *val) 
DEFINE_DEBUGFS_ATTRIBUTE(fops_regval, mt76_reg_get, mt76_reg_set,

			 "0x%08llx\n");



static int

mt76_napi_threaded_set(void *data, u64 val)

{

	struct mt76_dev *dev = data;



	if (!mt76_is_mmio(dev))

		return -EOPNOTSUPP;



	if (dev->napi_dev.threaded != val)

		return dev_set_threaded(&dev->napi_dev, val);



	return 0;

}



static int

mt76_napi_threaded_get(void *data, u64 *val)

{

	struct mt76_dev *dev = data;



	*val = dev->napi_dev.threaded;

	return 0;

}



DEFINE_DEBUGFS_ATTRIBUTE(fops_napi_threaded, mt76_napi_threaded_get,

			 mt76_napi_threaded_set, "%llu\n");



int mt76_queues_read(struct seq_file *s, void *data)

{

	struct mt76_dev *dev = dev_get_drvdata(s->private);
@@ -102,6 +128,8 @@ struct dentry *mt76_register_debugfs(struct mt76_dev *dev) 
	debugfs_create_u32("regidx", 0600, dir, &dev->debugfs_reg);

	debugfs_create_file_unsafe("regval", 0600, dir, dev,

				   &fops_regval);

	debugfs_create_file_unsafe("napi_threaded", 0600, dir, dev,

				   &fops_napi_threaded);

	debugfs_create_blob("eeprom", 0400, dir, &dev->eeprom);

	if (dev->otp.data)

		debugfs_create_blob("otp", 0400, dir, &dev->otp);

drivers/net/wireless/mediatek/mt76/dma.c

+5 −5
Original line number Diff line number Diff line
@@ -602,8 +602,7 @@ mt76_dma_rx_process(struct mt76_dev *dev, struct mt76_queue *q, int budget) 
	return done;

}



static int

mt76_dma_rx_poll(struct napi_struct *napi, int budget)

int mt76_dma_rx_poll(struct napi_struct *napi, int budget)

{

	struct mt76_dev *dev;

	int qid, done = 0, cur;
@@ -626,9 +625,11 @@ mt76_dma_rx_poll(struct napi_struct *napi, int budget) 


	return done;

}

EXPORT_SYMBOL_GPL(mt76_dma_rx_poll);



static int

mt76_dma_init(struct mt76_dev *dev)

mt76_dma_init(struct mt76_dev *dev,

	      int (*poll)(struct napi_struct *napi, int budget))

{

	int i;
@@ -639,8 +640,7 @@ mt76_dma_init(struct mt76_dev *dev) 
	dev->napi_dev.threaded = 1;



	mt76_for_each_q_rx(dev, i) {

		netif_napi_add(&dev->napi_dev, &dev->napi[i], mt76_dma_rx_poll,

			       64);

		netif_napi_add(&dev->napi_dev, &dev->napi[i], poll, 64);

		mt76_dma_rx_fill(dev, &dev->q_rx[i]);

		napi_enable(&dev->napi[i]);

	}

drivers/net/wireless/mediatek/mt76/dma.h

+1 −0
Original line number Diff line number Diff line
@@ -45,6 +45,7 @@ enum mt76_mcu_evt_type { 
	EVT_EVENT_DFS_DETECT_RSP,

};



int mt76_dma_rx_poll(struct napi_struct *napi, int budget);

void mt76_dma_attach(struct mt76_dev *dev);

void mt76_dma_cleanup(struct mt76_dev *dev);

drivers/net/wireless/mediatek/mt76/eeprom.c

+225 −6
Original line number Diff line number Diff line
@@ -9,8 +9,7 @@ 
#include <linux/etherdevice.h>

#include "mt76.h"



static int

mt76_get_of_eeprom(struct mt76_dev *dev, int len)

int mt76_get_of_eeprom(struct mt76_dev *dev, void *eep, int offset, int len)

{

#if defined(CONFIG_OF) && defined(CONFIG_MTD)

	struct device_node *np = dev->dev->of_node;
@@ -18,7 +17,6 @@ mt76_get_of_eeprom(struct mt76_dev *dev, int len) 
	const __be32 *list;

	const char *part;

	phandle phandle;

	int offset = 0;

	int size;

	size_t retlen;

	int ret;
@@ -54,7 +52,7 @@ mt76_get_of_eeprom(struct mt76_dev *dev, int len) 
	}



	offset = be32_to_cpup(list);

	ret = mtd_read(mtd, offset, len, &retlen, dev->eeprom.data);

	ret = mtd_read(mtd, offset, len, &retlen, eep);

	put_mtd_device(mtd);

	if (ret)

		goto out_put_node;
@@ -65,7 +63,7 @@ mt76_get_of_eeprom(struct mt76_dev *dev, int len) 
	}



	if (of_property_read_bool(dev->dev->of_node, "big-endian")) {

		u8 *data = (u8 *)dev->eeprom.data;

		u8 *data = (u8 *)eep;

		int i;



		/* convert eeprom data in Little Endian */
@@ -86,6 +84,7 @@ mt76_get_of_eeprom(struct mt76_dev *dev, int len) 
	return -ENOENT;

#endif

}

EXPORT_SYMBOL_GPL(mt76_get_of_eeprom);



void

mt76_eeprom_override(struct mt76_phy *phy)
@@ -104,6 +103,226 @@ mt76_eeprom_override(struct mt76_phy *phy) 
}

EXPORT_SYMBOL_GPL(mt76_eeprom_override);



static bool mt76_string_prop_find(struct property *prop, const char *str)

{

	const char *cp = NULL;



	if (!prop || !str || !str[0])

		return false;



	while ((cp = of_prop_next_string(prop, cp)) != NULL)

		if (!strcasecmp(cp, str))

			return true;



	return false;

}



static struct device_node *

mt76_find_power_limits_node(struct mt76_dev *dev)

{

	struct device_node *np = dev->dev->of_node;

	const char *const region_names[] = {

		[NL80211_DFS_ETSI] = "etsi",

		[NL80211_DFS_FCC] = "fcc",

		[NL80211_DFS_JP] = "jp",

	};

	struct device_node *cur, *fallback = NULL;

	const char *region_name = NULL;



	if (dev->region < ARRAY_SIZE(region_names))

		region_name = region_names[dev->region];



	np = of_get_child_by_name(np, "power-limits");

	if (!np)

		return NULL;



	for_each_child_of_node(np, cur) {

		struct property *country = of_find_property(cur, "country", NULL);

		struct property *regd = of_find_property(cur, "regdomain", NULL);



		if (!country && !regd) {

			fallback = cur;

			continue;

		}



		if (mt76_string_prop_find(country, dev->alpha2) ||

		    mt76_string_prop_find(regd, region_name))

			return cur;

	}



	return fallback;

}



static const __be32 *

mt76_get_of_array(struct device_node *np, char *name, size_t *len, int min)

{

	struct property *prop = of_find_property(np, name, NULL);



	if (!prop || !prop->value || prop->length < min * 4)

		return NULL;



	*len = prop->length;



	return prop->value;

}



static struct device_node *

mt76_find_channel_node(struct device_node *np, struct ieee80211_channel *chan)

{

	struct device_node *cur;

	const __be32 *val;

	size_t len;



	for_each_child_of_node(np, cur) {

		val = mt76_get_of_array(cur, "channels", &len, 2);

		if (!val)

			continue;



		while (len >= 2 * sizeof(*val)) {

			if (chan->hw_value >= be32_to_cpu(val[0]) &&

			    chan->hw_value <= be32_to_cpu(val[1]))

				return cur;



			val += 2;

			len -= 2 * sizeof(*val);

		}

	}



	return NULL;

}



static s8

mt76_get_txs_delta(struct device_node *np, u8 nss)

{

	const __be32 *val;

	size_t len;



	val = mt76_get_of_array(np, "txs-delta", &len, nss);

	if (!val)

		return 0;



	return be32_to_cpu(val[nss - 1]);

}



static void

mt76_apply_array_limit(s8 *pwr, size_t pwr_len, const __be32 *data,

		       s8 target_power, s8 nss_delta, s8 *max_power)

{

	int i;



	if (!data)

		return;



	for (i = 0; i < pwr_len; i++) {

		pwr[i] = min_t(s8, target_power,

			       be32_to_cpu(data[i]) + nss_delta);

		*max_power = max(*max_power, pwr[i]);

	}

}



static void

mt76_apply_multi_array_limit(s8 *pwr, size_t pwr_len, s8 pwr_num,

			     const __be32 *data, size_t len, s8 target_power,

			     s8 nss_delta, s8 *max_power)

{

	int i, cur;



	if (!data)

		return;



	len /= 4;

	cur = be32_to_cpu(data[0]);

	for (i = 0; i < pwr_num; i++) {

		if (len < pwr_len + 1)

			break;



		mt76_apply_array_limit(pwr + pwr_len * i, pwr_len, data + 1,

				       target_power, nss_delta, max_power);

		if (--cur > 0)

			continue;



		data += pwr_len + 1;

		len -= pwr_len + 1;

		if (!len)

			break;



		cur = be32_to_cpu(data[0]);

	}

}



s8 mt76_get_rate_power_limits(struct mt76_phy *phy,

			      struct ieee80211_channel *chan,

			      struct mt76_power_limits *dest,

			      s8 target_power)

{

	struct mt76_dev *dev = phy->dev;

	struct device_node *np;

	const __be32 *val;

	char name[16];

	u32 mcs_rates = dev->drv->mcs_rates;

	u32 ru_rates = ARRAY_SIZE(dest->ru[0]);

	char band;

	size_t len;

	s8 max_power = 0;

	s8 txs_delta;



	if (!mcs_rates)

		mcs_rates = 10;



	memset(dest, target_power, sizeof(*dest));



	if (!IS_ENABLED(CONFIG_OF))

		return target_power;



	np = mt76_find_power_limits_node(dev);

	if (!np)

		return target_power;



	switch (chan->band) {

	case NL80211_BAND_2GHZ:

		band = '2';

		break;

	case NL80211_BAND_5GHZ:

		band = '5';

		break;

	default:

		return target_power;

	}



	snprintf(name, sizeof(name), "txpower-%cg", band);

	np = of_get_child_by_name(np, name);

	if (!np)

		return target_power;



	np = mt76_find_channel_node(np, chan);

	if (!np)

		return target_power;



	txs_delta = mt76_get_txs_delta(np, hweight8(phy->antenna_mask));



	val = mt76_get_of_array(np, "rates-cck", &len, ARRAY_SIZE(dest->cck));

	mt76_apply_array_limit(dest->cck, ARRAY_SIZE(dest->cck), val,

			       target_power, txs_delta, &max_power);



	val = mt76_get_of_array(np, "rates-ofdm",

				&len, ARRAY_SIZE(dest->ofdm));

	mt76_apply_array_limit(dest->ofdm, ARRAY_SIZE(dest->ofdm), val,

			       target_power, txs_delta, &max_power);



	val = mt76_get_of_array(np, "rates-mcs", &len, mcs_rates + 1);

	mt76_apply_multi_array_limit(dest->mcs[0], ARRAY_SIZE(dest->mcs[0]),

				     ARRAY_SIZE(dest->mcs), val, len,

				     target_power, txs_delta, &max_power);



	val = mt76_get_of_array(np, "rates-ru", &len, ru_rates + 1);

	mt76_apply_multi_array_limit(dest->ru[0], ARRAY_SIZE(dest->ru[0]),

				     ARRAY_SIZE(dest->ru), val, len,

				     target_power, txs_delta, &max_power);



	return max_power;

}

EXPORT_SYMBOL_GPL(mt76_get_rate_power_limits);



int

mt76_eeprom_init(struct mt76_dev *dev, int len)

{
@@ -112,6 +331,6 @@ mt76_eeprom_init(struct mt76_dev *dev, int len) 
	if (!dev->eeprom.data)

		return -ENOMEM;



	return !mt76_get_of_eeprom(dev, len);

	return !mt76_get_of_eeprom(dev, dev->eeprom.data, 0, len);

}

EXPORT_SYMBOL_GPL(mt76_eeprom_init);