Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel-alx/patches-5.4/0209-5.4.110-all-fixes.patch

    Annotation of /trunk/kernel-alx/patches-5.4/0209-5.4.110-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 3637 - (hide annotations) (download)
    Mon Oct 24 12:40:44 2022 UTC (23 months ago) by niro
    File size: 178834 byte(s) 
    -add missing
    1 niro 3637 diff --git a/Makefile b/Makefile
    2     index e037662c369ba..b028b5ead5f7e 100644
    3     --- a/Makefile
    4     +++ b/Makefile
    5     @@ -1,7 +1,7 @@
    6     # SPDX-License-Identifier: GPL-2.0
    7     VERSION = 5
    8     PATCHLEVEL = 4
    9     -SUBLEVEL = 109
    10     +SUBLEVEL = 110
    11     EXTRAVERSION =
    12     NAME = Kleptomaniac Octopus
    13    
    14     diff --git a/arch/powerpc/include/asm/cpu_has_feature.h b/arch/powerpc/include/asm/cpu_has_feature.h
    15     index 7897d16e09904..727d4b3219379 100644
    16     --- a/arch/powerpc/include/asm/cpu_has_feature.h
    17     +++ b/arch/powerpc/include/asm/cpu_has_feature.h
    18     @@ -7,7 +7,7 @@
    19     #include <linux/bug.h>
    20     #include <asm/cputable.h>
    21    
    22     -static inline bool early_cpu_has_feature(unsigned long feature)
    23     +static __always_inline bool early_cpu_has_feature(unsigned long feature)
    24     {
    25     return !!((CPU_FTRS_ALWAYS & feature) ||
    26     (CPU_FTRS_POSSIBLE & cur_cpu_spec->cpu_features & feature));
    27     @@ -46,7 +46,7 @@ static __always_inline bool cpu_has_feature(unsigned long feature)
    28     return static_branch_likely(&cpu_feature_keys[i]);
    29     }
    30     #else
    31     -static inline bool cpu_has_feature(unsigned long feature)
    32     +static __always_inline bool cpu_has_feature(unsigned long feature)
    33     {
    34     return early_cpu_has_feature(feature);
    35     }
    36     diff --git a/arch/xtensa/kernel/coprocessor.S b/arch/xtensa/kernel/coprocessor.S
    37     index 80828b95a51f0..d956f87fcb095 100644
    38     --- a/arch/xtensa/kernel/coprocessor.S
    39     +++ b/arch/xtensa/kernel/coprocessor.S
    40     @@ -108,37 +108,6 @@
    41    
    42     .previous
    43    
    44     -/*
    45     - * coprocessor_flush(struct thread_info*, index)
    46     - * a2 a3
    47     - *
    48     - * Save coprocessor registers for coprocessor 'index'.
    49     - * The register values are saved to or loaded from the coprocessor area
    50     - * inside the task_info structure.
    51     - *
    52     - * Note that this function doesn't update the coprocessor_owner information!
    53     - *
    54     - */
    55     -
    56     -ENTRY(coprocessor_flush)
    57     -
    58     - /* reserve 4 bytes on stack to save a0 */
    59     - abi_entry(4)
    60     -
    61     - s32i a0, a1, 0
    62     - movi a0, .Lsave_cp_regs_jump_table
    63     - addx8 a3, a3, a0
    64     - l32i a4, a3, 4
    65     - l32i a3, a3, 0
    66     - add a2, a2, a4
    67     - beqz a3, 1f
    68     - callx0 a3
    69     -1: l32i a0, a1, 0
    70     -
    71     - abi_ret(4)
    72     -
    73     -ENDPROC(coprocessor_flush)
    74     -
    75     /*
    76     * Entry condition:
    77     *
    78     @@ -261,6 +230,39 @@ ENTRY(fast_coprocessor)
    79    
    80     ENDPROC(fast_coprocessor)
    81    
    82     + .text
    83     +
    84     +/*
    85     + * coprocessor_flush(struct thread_info*, index)
    86     + * a2 a3
    87     + *
    88     + * Save coprocessor registers for coprocessor 'index'.
    89     + * The register values are saved to or loaded from the coprocessor area
    90     + * inside the task_info structure.
    91     + *
    92     + * Note that this function doesn't update the coprocessor_owner information!
    93     + *
    94     + */
    95     +
    96     +ENTRY(coprocessor_flush)
    97     +
    98     + /* reserve 4 bytes on stack to save a0 */
    99     + abi_entry(4)
    100     +
    101     + s32i a0, a1, 0
    102     + movi a0, .Lsave_cp_regs_jump_table
    103     + addx8 a3, a3, a0
    104     + l32i a4, a3, 4
    105     + l32i a3, a3, 0
    106     + add a2, a2, a4
    107     + beqz a3, 1f
    108     + callx0 a3
    109     +1: l32i a0, a1, 0
    110     +
    111     + abi_ret(4)
    112     +
    113     +ENDPROC(coprocessor_flush)
    114     +
    115     .data
    116    
    117     ENTRY(coprocessor_owner)
    118     diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
    119     index e0c4ef06ca917..94785083c018a 100644
    120     --- a/drivers/base/power/runtime.c
    121     +++ b/drivers/base/power/runtime.c
    122     @@ -1663,8 +1663,8 @@ void pm_runtime_get_suppliers(struct device *dev)
    123     device_links_read_lock_held())
    124     if (link->flags & DL_FLAG_PM_RUNTIME) {
    125     link->supplier_preactivated = true;
    126     - refcount_inc(&link->rpm_active);
    127     pm_runtime_get_sync(link->supplier);
    128     + refcount_inc(&link->rpm_active);
    129     }
    130    
    131     device_links_read_unlock(idx);
    132     @@ -1677,6 +1677,8 @@ void pm_runtime_get_suppliers(struct device *dev)
    133     void pm_runtime_put_suppliers(struct device *dev)
    134     {
    135     struct device_link *link;
    136     + unsigned long flags;
    137     + bool put;
    138     int idx;
    139    
    140     idx = device_links_read_lock();
    141     @@ -1685,7 +1687,11 @@ void pm_runtime_put_suppliers(struct device *dev)
    142     device_links_read_lock_held())
    143     if (link->supplier_preactivated) {
    144     link->supplier_preactivated = false;
    145     - if (refcount_dec_not_one(&link->rpm_active))
    146     + spin_lock_irqsave(&dev->power.lock, flags);
    147     + put = pm_runtime_status_suspended(dev) &&
    148     + refcount_dec_not_one(&link->rpm_active);
    149     + spin_unlock_irqrestore(&dev->power.lock, flags);
    150     + if (put)
    151     pm_runtime_put(link->supplier);
    152     }
    153    
    154     diff --git a/drivers/extcon/extcon.c b/drivers/extcon/extcon.c
    155     index e055893fd5c39..5c9e156cd0862 100644
    156     --- a/drivers/extcon/extcon.c
    157     +++ b/drivers/extcon/extcon.c
    158     @@ -1241,6 +1241,7 @@ int extcon_dev_register(struct extcon_dev *edev)
    159     sizeof(*edev->nh), GFP_KERNEL);
    160     if (!edev->nh) {
    161     ret = -ENOMEM;
    162     + device_unregister(&edev->dev);
    163     goto err_dev;
    164     }
    165    
    166     diff --git a/drivers/firewire/nosy.c b/drivers/firewire/nosy.c
    167     index 0cc7466736773..9ee747a85ee49 100644
    168     --- a/drivers/firewire/nosy.c
    169     +++ b/drivers/firewire/nosy.c
    170     @@ -346,6 +346,7 @@ nosy_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    171     struct client *client = file->private_data;
    172     spinlock_t *client_list_lock = &client->lynx->client_list_lock;
    173     struct nosy_stats stats;
    174     + int ret;
    175    
    176     switch (cmd) {
    177     case NOSY_IOC_GET_STATS:
    178     @@ -360,11 +361,15 @@ nosy_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    179     return 0;
    180    
    181     case NOSY_IOC_START:
    182     + ret = -EBUSY;
    183     spin_lock_irq(client_list_lock);
    184     - list_add_tail(&client->link, &client->lynx->client_list);
    185     + if (list_empty(&client->link)) {
    186     + list_add_tail(&client->link, &client->lynx->client_list);
    187     + ret = 0;
    188     + }
    189     spin_unlock_irq(client_list_lock);
    190    
    191     - return 0;
    192     + return ret;
    193    
    194     case NOSY_IOC_STOP:
    195     spin_lock_irq(client_list_lock);
    196     diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
    197     index 6335bd4ae374a..fb47ddc6f7f4e 100644
    198     --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
    199     +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
    200     @@ -2123,8 +2123,8 @@ int amdgpu_vm_bo_map(struct amdgpu_device *adev,
    201     uint64_t eaddr;
    202    
    203     /* validate the parameters */
    204     - if (saddr & AMDGPU_GPU_PAGE_MASK || offset & AMDGPU_GPU_PAGE_MASK ||
    205     - size == 0 || size & AMDGPU_GPU_PAGE_MASK)
    206     + if (saddr & ~PAGE_MASK || offset & ~PAGE_MASK ||
    207     + size == 0 || size & ~PAGE_MASK)
    208     return -EINVAL;
    209    
    210     /* make sure object fit at this offset */
    211     @@ -2188,8 +2188,8 @@ int amdgpu_vm_bo_replace_map(struct amdgpu_device *adev,
    212     int r;
    213    
    214     /* validate the parameters */
    215     - if (saddr & AMDGPU_GPU_PAGE_MASK || offset & AMDGPU_GPU_PAGE_MASK ||
    216     - size == 0 || size & AMDGPU_GPU_PAGE_MASK)
    217     + if (saddr & ~PAGE_MASK || offset & ~PAGE_MASK ||
    218     + size == 0 || size & ~PAGE_MASK)
    219     return -EINVAL;
    220    
    221     /* make sure object fit at this offset */
    222     @@ -2333,7 +2333,7 @@ int amdgpu_vm_bo_clear_mappings(struct amdgpu_device *adev,
    223     after->start = eaddr + 1;
    224     after->last = tmp->last;
    225     after->offset = tmp->offset;
    226     - after->offset += after->start - tmp->start;
    227     + after->offset += (after->start - tmp->start) << PAGE_SHIFT;
    228     after->flags = tmp->flags;
    229     after->bo_va = tmp->bo_va;
    230     list_add(&after->list, &tmp->bo_va->invalids);
    231     diff --git a/drivers/net/can/Makefile b/drivers/net/can/Makefile
    232     index 22164300122d5..a2b4463d84802 100644
    233     --- a/drivers/net/can/Makefile
    234     +++ b/drivers/net/can/Makefile
    235     @@ -7,12 +7,7 @@ obj-$(CONFIG_CAN_VCAN) += vcan.o
    236     obj-$(CONFIG_CAN_VXCAN) += vxcan.o
    237     obj-$(CONFIG_CAN_SLCAN) += slcan.o
    238    
    239     -obj-$(CONFIG_CAN_DEV) += can-dev.o
    240     -can-dev-y += dev.o
    241     -can-dev-y += rx-offload.o
    242     -
    243     -can-dev-$(CONFIG_CAN_LEDS) += led.o
    244     -
    245     +obj-y += dev/
    246     obj-y += rcar/
    247     obj-y += spi/
    248     obj-y += usb/
    249     diff --git a/drivers/net/can/dev.c b/drivers/net/can/dev.c
    250     deleted file mode 100644
    251     index 1e0c1a05df82d..0000000000000
    252     --- a/drivers/net/can/dev.c
    253     +++ /dev/null
    254     @@ -1,1310 +0,0 @@
    255     -// SPDX-License-Identifier: GPL-2.0-only
    256     -/* Copyright (C) 2005 Marc Kleine-Budde, Pengutronix
    257     - * Copyright (C) 2006 Andrey Volkov, Varma Electronics
    258     - * Copyright (C) 2008-2009 Wolfgang Grandegger <wg@grandegger.com>
    259     - */
    260     -
    261     -#include <linux/module.h>
    262     -#include <linux/kernel.h>
    263     -#include <linux/slab.h>
    264     -#include <linux/netdevice.h>
    265     -#include <linux/if_arp.h>
    266     -#include <linux/workqueue.h>
    267     -#include <linux/can.h>
    268     -#include <linux/can/can-ml.h>
    269     -#include <linux/can/dev.h>
    270     -#include <linux/can/skb.h>
    271     -#include <linux/can/netlink.h>
    272     -#include <linux/can/led.h>
    273     -#include <linux/of.h>
    274     -#include <net/rtnetlink.h>
    275     -
    276     -#define MOD_DESC "CAN device driver interface"
    277     -
    278     -MODULE_DESCRIPTION(MOD_DESC);
    279     -MODULE_LICENSE("GPL v2");
    280     -MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
    281     -
    282     -/* CAN DLC to real data length conversion helpers */
    283     -
    284     -static const u8 dlc2len[] = {0, 1, 2, 3, 4, 5, 6, 7,
    285     - 8, 12, 16, 20, 24, 32, 48, 64};
    286     -
    287     -/* get data length from can_dlc with sanitized can_dlc */
    288     -u8 can_dlc2len(u8 can_dlc)
    289     -{
    290     - return dlc2len[can_dlc & 0x0F];
    291     -}
    292     -EXPORT_SYMBOL_GPL(can_dlc2len);
    293     -
    294     -static const u8 len2dlc[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, /* 0 - 8 */
    295     - 9, 9, 9, 9, /* 9 - 12 */
    296     - 10, 10, 10, 10, /* 13 - 16 */
    297     - 11, 11, 11, 11, /* 17 - 20 */
    298     - 12, 12, 12, 12, /* 21 - 24 */
    299     - 13, 13, 13, 13, 13, 13, 13, 13, /* 25 - 32 */
    300     - 14, 14, 14, 14, 14, 14, 14, 14, /* 33 - 40 */
    301     - 14, 14, 14, 14, 14, 14, 14, 14, /* 41 - 48 */
    302     - 15, 15, 15, 15, 15, 15, 15, 15, /* 49 - 56 */
    303     - 15, 15, 15, 15, 15, 15, 15, 15}; /* 57 - 64 */
    304     -
    305     -/* map the sanitized data length to an appropriate data length code */
    306     -u8 can_len2dlc(u8 len)
    307     -{
    308     - if (unlikely(len > 64))
    309     - return 0xF;
    310     -
    311     - return len2dlc[len];
    312     -}
    313     -EXPORT_SYMBOL_GPL(can_len2dlc);
    314     -
    315     -#ifdef CONFIG_CAN_CALC_BITTIMING
    316     -#define CAN_CALC_MAX_ERROR 50 /* in one-tenth of a percent */
    317     -#define CAN_CALC_SYNC_SEG 1
    318     -
    319     -/* Bit-timing calculation derived from:
    320     - *
    321     - * Code based on LinCAN sources and H8S2638 project
    322     - * Copyright 2004-2006 Pavel Pisa - DCE FELK CVUT cz
    323     - * Copyright 2005 Stanislav Marek
    324     - * email: pisa@cmp.felk.cvut.cz
    325     - *
    326     - * Calculates proper bit-timing parameters for a specified bit-rate
    327     - * and sample-point, which can then be used to set the bit-timing
    328     - * registers of the CAN controller. You can find more information
    329     - * in the header file linux/can/netlink.h.
    330     - */
    331     -static int
    332     -can_update_sample_point(const struct can_bittiming_const *btc,
    333     - unsigned int sample_point_nominal, unsigned int tseg,
    334     - unsigned int *tseg1_ptr, unsigned int *tseg2_ptr,
    335     - unsigned int *sample_point_error_ptr)
    336     -{
    337     - unsigned int sample_point_error, best_sample_point_error = UINT_MAX;
    338     - unsigned int sample_point, best_sample_point = 0;
    339     - unsigned int tseg1, tseg2;
    340     - int i;
    341     -
    342     - for (i = 0; i <= 1; i++) {
    343     - tseg2 = tseg + CAN_CALC_SYNC_SEG -
    344     - (sample_point_nominal * (tseg + CAN_CALC_SYNC_SEG)) /
    345     - 1000 - i;
    346     - tseg2 = clamp(tseg2, btc->tseg2_min, btc->tseg2_max);
    347     - tseg1 = tseg - tseg2;
    348     - if (tseg1 > btc->tseg1_max) {
    349     - tseg1 = btc->tseg1_max;
    350     - tseg2 = tseg - tseg1;
    351     - }
    352     -
    353     - sample_point = 1000 * (tseg + CAN_CALC_SYNC_SEG - tseg2) /
    354     - (tseg + CAN_CALC_SYNC_SEG);
    355     - sample_point_error = abs(sample_point_nominal - sample_point);
    356     -
    357     - if (sample_point <= sample_point_nominal &&
    358     - sample_point_error < best_sample_point_error) {
    359     - best_sample_point = sample_point;
    360     - best_sample_point_error = sample_point_error;
    361     - *tseg1_ptr = tseg1;
    362     - *tseg2_ptr = tseg2;
    363     - }
    364     - }
    365     -
    366     - if (sample_point_error_ptr)
    367     - *sample_point_error_ptr = best_sample_point_error;
    368     -
    369     - return best_sample_point;
    370     -}
    371     -
    372     -static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt,
    373     - const struct can_bittiming_const *btc)
    374     -{
    375     - struct can_priv *priv = netdev_priv(dev);
    376     - unsigned int bitrate; /* current bitrate */
    377     - unsigned int bitrate_error; /* difference between current and nominal value */
    378     - unsigned int best_bitrate_error = UINT_MAX;
    379     - unsigned int sample_point_error; /* difference between current and nominal value */
    380     - unsigned int best_sample_point_error = UINT_MAX;
    381     - unsigned int sample_point_nominal; /* nominal sample point */
    382     - unsigned int best_tseg = 0; /* current best value for tseg */
    383     - unsigned int best_brp = 0; /* current best value for brp */
    384     - unsigned int brp, tsegall, tseg, tseg1 = 0, tseg2 = 0;
    385     - u64 v64;
    386     -
    387     - /* Use CiA recommended sample points */
    388     - if (bt->sample_point) {
    389     - sample_point_nominal = bt->sample_point;
    390     - } else {
    391     - if (bt->bitrate > 800000)
    392     - sample_point_nominal = 750;
    393     - else if (bt->bitrate > 500000)
    394     - sample_point_nominal = 800;
    395     - else
    396     - sample_point_nominal = 875;
    397     - }
    398     -
    399     - /* tseg even = round down, odd = round up */
    400     - for (tseg = (btc->tseg1_max + btc->tseg2_max) * 2 + 1;
    401     - tseg >= (btc->tseg1_min + btc->tseg2_min) * 2; tseg--) {
    402     - tsegall = CAN_CALC_SYNC_SEG + tseg / 2;
    403     -
    404     - /* Compute all possible tseg choices (tseg=tseg1+tseg2) */
    405     - brp = priv->clock.freq / (tsegall * bt->bitrate) + tseg % 2;
    406     -
    407     - /* choose brp step which is possible in system */
    408     - brp = (brp / btc->brp_inc) * btc->brp_inc;
    409     - if (brp < btc->brp_min || brp > btc->brp_max)
    410     - continue;
    411     -
    412     - bitrate = priv->clock.freq / (brp * tsegall);
    413     - bitrate_error = abs(bt->bitrate - bitrate);
    414     -
    415     - /* tseg brp biterror */
    416     - if (bitrate_error > best_bitrate_error)
    417     - continue;
    418     -
    419     - /* reset sample point error if we have a better bitrate */
    420     - if (bitrate_error < best_bitrate_error)
    421     - best_sample_point_error = UINT_MAX;
    422     -
    423     - can_update_sample_point(btc, sample_point_nominal, tseg / 2,
    424     - &tseg1, &tseg2, &sample_point_error);
    425     - if (sample_point_error > best_sample_point_error)
    426     - continue;
    427     -
    428     - best_sample_point_error = sample_point_error;
    429     - best_bitrate_error = bitrate_error;
    430     - best_tseg = tseg / 2;
    431     - best_brp = brp;
    432     -
    433     - if (bitrate_error == 0 && sample_point_error == 0)
    434     - break;
    435     - }
    436     -
    437     - if (best_bitrate_error) {
    438     - /* Error in one-tenth of a percent */
    439     - v64 = (u64)best_bitrate_error * 1000;
    440     - do_div(v64, bt->bitrate);
    441     - bitrate_error = (u32)v64;
    442     - if (bitrate_error > CAN_CALC_MAX_ERROR) {
    443     - netdev_err(dev,
    444     - "bitrate error %d.%d%% too high\n",
    445     - bitrate_error / 10, bitrate_error % 10);
    446     - return -EDOM;
    447     - }
    448     - netdev_warn(dev, "bitrate error %d.%d%%\n",
    449     - bitrate_error / 10, bitrate_error % 10);
    450     - }
    451     -
    452     - /* real sample point */
    453     - bt->sample_point = can_update_sample_point(btc, sample_point_nominal,
    454     - best_tseg, &tseg1, &tseg2,
    455     - NULL);
    456     -
    457     - v64 = (u64)best_brp * 1000 * 1000 * 1000;
    458     - do_div(v64, priv->clock.freq);
    459     - bt->tq = (u32)v64;
    460     - bt->prop_seg = tseg1 / 2;
    461     - bt->phase_seg1 = tseg1 - bt->prop_seg;
    462     - bt->phase_seg2 = tseg2;
    463     -
    464     - /* check for sjw user settings */
    465     - if (!bt->sjw || !btc->sjw_max) {
    466     - bt->sjw = 1;
    467     - } else {
    468     - /* bt->sjw is at least 1 -> sanitize upper bound to sjw_max */
    469     - if (bt->sjw > btc->sjw_max)
    470     - bt->sjw = btc->sjw_max;
    471     - /* bt->sjw must not be higher than tseg2 */
    472     - if (tseg2 < bt->sjw)
    473     - bt->sjw = tseg2;
    474     - }
    475     -
    476     - bt->brp = best_brp;
    477     -
    478     - /* real bitrate */
    479     - bt->bitrate = priv->clock.freq /
    480     - (bt->brp * (CAN_CALC_SYNC_SEG + tseg1 + tseg2));
    481     -
    482     - return 0;
    483     -}
    484     -#else /* !CONFIG_CAN_CALC_BITTIMING */
    485     -static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt,
    486     - const struct can_bittiming_const *btc)
    487     -{
    488     - netdev_err(dev, "bit-timing calculation not available\n");
    489     - return -EINVAL;
    490     -}
    491     -#endif /* CONFIG_CAN_CALC_BITTIMING */
    492     -
    493     -/* Checks the validity of the specified bit-timing parameters prop_seg,
    494     - * phase_seg1, phase_seg2 and sjw and tries to determine the bitrate
    495     - * prescaler value brp. You can find more information in the header
    496     - * file linux/can/netlink.h.
    497     - */
    498     -static int can_fixup_bittiming(struct net_device *dev, struct can_bittiming *bt,
    499     - const struct can_bittiming_const *btc)
    500     -{
    501     - struct can_priv *priv = netdev_priv(dev);
    502     - int tseg1, alltseg;
    503     - u64 brp64;
    504     -
    505     - tseg1 = bt->prop_seg + bt->phase_seg1;
    506     - if (!bt->sjw)
    507     - bt->sjw = 1;
    508     - if (bt->sjw > btc->sjw_max ||
    509     - tseg1 < btc->tseg1_min || tseg1 > btc->tseg1_max ||
    510     - bt->phase_seg2 < btc->tseg2_min || bt->phase_seg2 > btc->tseg2_max)
    511     - return -ERANGE;
    512     -
    513     - brp64 = (u64)priv->clock.freq * (u64)bt->tq;
    514     - if (btc->brp_inc > 1)
    515     - do_div(brp64, btc->brp_inc);
    516     - brp64 += 500000000UL - 1;
    517     - do_div(brp64, 1000000000UL); /* the practicable BRP */
    518     - if (btc->brp_inc > 1)
    519     - brp64 *= btc->brp_inc;
    520     - bt->brp = (u32)brp64;
    521     -
    522     - if (bt->brp < btc->brp_min || bt->brp > btc->brp_max)
    523     - return -EINVAL;
    524     -
    525     - alltseg = bt->prop_seg + bt->phase_seg1 + bt->phase_seg2 + 1;
    526     - bt->bitrate = priv->clock.freq / (bt->brp * alltseg);
    527     - bt->sample_point = ((tseg1 + 1) * 1000) / alltseg;
    528     -
    529     - return 0;
    530     -}
    531     -
    532     -/* Checks the validity of predefined bitrate settings */
    533     -static int
    534     -can_validate_bitrate(struct net_device *dev, struct can_bittiming *bt,
    535     - const u32 *bitrate_const,
    536     - const unsigned int bitrate_const_cnt)
    537     -{
    538     - struct can_priv *priv = netdev_priv(dev);
    539     - unsigned int i;
    540     -
    541     - for (i = 0; i < bitrate_const_cnt; i++) {
    542     - if (bt->bitrate == bitrate_const[i])
    543     - break;
    544     - }
    545     -
    546     - if (i >= priv->bitrate_const_cnt)
    547     - return -EINVAL;
    548     -
    549     - return 0;
    550     -}
    551     -
    552     -static int can_get_bittiming(struct net_device *dev, struct can_bittiming *bt,
    553     - const struct can_bittiming_const *btc,
    554     - const u32 *bitrate_const,
    555     - const unsigned int bitrate_const_cnt)
    556     -{
    557     - int err;
    558     -
    559     - /* Depending on the given can_bittiming parameter structure the CAN
    560     - * timing parameters are calculated based on the provided bitrate OR
    561     - * alternatively the CAN timing parameters (tq, prop_seg, etc.) are
    562     - * provided directly which are then checked and fixed up.
    563     - */
    564     - if (!bt->tq && bt->bitrate && btc)
    565     - err = can_calc_bittiming(dev, bt, btc);
    566     - else if (bt->tq && !bt->bitrate && btc)
    567     - err = can_fixup_bittiming(dev, bt, btc);
    568     - else if (!bt->tq && bt->bitrate && bitrate_const)
    569     - err = can_validate_bitrate(dev, bt, bitrate_const,
    570     - bitrate_const_cnt);
    571     - else
    572     - err = -EINVAL;
    573     -
    574     - return err;
    575     -}
    576     -
    577     -static void can_update_state_error_stats(struct net_device *dev,
    578     - enum can_state new_state)
    579     -{
    580     - struct can_priv *priv = netdev_priv(dev);
    581     -
    582     - if (new_state <= priv->state)
    583     - return;
    584     -
    585     - switch (new_state) {
    586     - case CAN_STATE_ERROR_WARNING:
    587     - priv->can_stats.error_warning++;
    588     - break;
    589     - case CAN_STATE_ERROR_PASSIVE:
    590     - priv->can_stats.error_passive++;
    591     - break;
    592     - case CAN_STATE_BUS_OFF:
    593     - priv->can_stats.bus_off++;
    594     - break;
    595     - default:
    596     - break;
    597     - }
    598     -}
    599     -
    600     -static int can_tx_state_to_frame(struct net_device *dev, enum can_state state)
    601     -{
    602     - switch (state) {
    603     - case CAN_STATE_ERROR_ACTIVE:
    604     - return CAN_ERR_CRTL_ACTIVE;
    605     - case CAN_STATE_ERROR_WARNING:
    606     - return CAN_ERR_CRTL_TX_WARNING;
    607     - case CAN_STATE_ERROR_PASSIVE:
    608     - return CAN_ERR_CRTL_TX_PASSIVE;
    609     - default:
    610     - return 0;
    611     - }
    612     -}
    613     -
    614     -static int can_rx_state_to_frame(struct net_device *dev, enum can_state state)
    615     -{
    616     - switch (state) {
    617     - case CAN_STATE_ERROR_ACTIVE:
    618     - return CAN_ERR_CRTL_ACTIVE;
    619     - case CAN_STATE_ERROR_WARNING:
    620     - return CAN_ERR_CRTL_RX_WARNING;
    621     - case CAN_STATE_ERROR_PASSIVE:
    622     - return CAN_ERR_CRTL_RX_PASSIVE;
    623     - default:
    624     - return 0;
    625     - }
    626     -}
    627     -
    628     -void can_change_state(struct net_device *dev, struct can_frame *cf,
    629     - enum can_state tx_state, enum can_state rx_state)
    630     -{
    631     - struct can_priv *priv = netdev_priv(dev);
    632     - enum can_state new_state = max(tx_state, rx_state);
    633     -
    634     - if (unlikely(new_state == priv->state)) {
    635     - netdev_warn(dev, "%s: oops, state did not change", __func__);
    636     - return;
    637     - }
    638     -
    639     - netdev_dbg(dev, "New error state: %d\n", new_state);
    640     -
    641     - can_update_state_error_stats(dev, new_state);
    642     - priv->state = new_state;
    643     -
    644     - if (!cf)
    645     - return;
    646     -
    647     - if (unlikely(new_state == CAN_STATE_BUS_OFF)) {
    648     - cf->can_id |= CAN_ERR_BUSOFF;
    649     - return;
    650     - }
    651     -
    652     - cf->can_id |= CAN_ERR_CRTL;
    653     - cf->data[1] |= tx_state >= rx_state ?
    654     - can_tx_state_to_frame(dev, tx_state) : 0;
    655     - cf->data[1] |= tx_state <= rx_state ?
    656     - can_rx_state_to_frame(dev, rx_state) : 0;
    657     -}
    658     -EXPORT_SYMBOL_GPL(can_change_state);
    659     -
    660     -/* Local echo of CAN messages
    661     - *
    662     - * CAN network devices *should* support a local echo functionality
    663     - * (see Documentation/networking/can.rst). To test the handling of CAN
    664     - * interfaces that do not support the local echo both driver types are
    665     - * implemented. In the case that the driver does not support the echo
    666     - * the IFF_ECHO remains clear in dev->flags. This causes the PF_CAN core
    667     - * to perform the echo as a fallback solution.
    668     - */
    669     -static void can_flush_echo_skb(struct net_device *dev)
    670     -{
    671     - struct can_priv *priv = netdev_priv(dev);
    672     - struct net_device_stats *stats = &dev->stats;
    673     - int i;
    674     -
    675     - for (i = 0; i < priv->echo_skb_max; i++) {
    676     - if (priv->echo_skb[i]) {
    677     - kfree_skb(priv->echo_skb[i]);
    678     - priv->echo_skb[i] = NULL;
    679     - stats->tx_dropped++;
    680     - stats->tx_aborted_errors++;
    681     - }
    682     - }
    683     -}
    684     -
    685     -/* Put the skb on the stack to be looped backed locally lateron
    686     - *
    687     - * The function is typically called in the start_xmit function
    688     - * of the device driver. The driver must protect access to
    689     - * priv->echo_skb, if necessary.
    690     - */
    691     -void can_put_echo_skb(struct sk_buff *skb, struct net_device *dev,
    692     - unsigned int idx)
    693     -{
    694     - struct can_priv *priv = netdev_priv(dev);
    695     -
    696     - BUG_ON(idx >= priv->echo_skb_max);
    697     -
    698     - /* check flag whether this packet has to be looped back */
    699     - if (!(dev->flags & IFF_ECHO) || skb->pkt_type != PACKET_LOOPBACK ||
    700     - (skb->protocol != htons(ETH_P_CAN) &&
    701     - skb->protocol != htons(ETH_P_CANFD))) {
    702     - kfree_skb(skb);
    703     - return;
    704     - }
    705     -
    706     - if (!priv->echo_skb[idx]) {
    707     - skb = can_create_echo_skb(skb);
    708     - if (!skb)
    709     - return;
    710     -
    711     - /* make settings for echo to reduce code in irq context */
    712     - skb->pkt_type = PACKET_BROADCAST;
    713     - skb->ip_summed = CHECKSUM_UNNECESSARY;
    714     - skb->dev = dev;
    715     -
    716     - /* save this skb for tx interrupt echo handling */
    717     - priv->echo_skb[idx] = skb;
    718     - } else {
    719     - /* locking problem with netif_stop_queue() ?? */
    720     - netdev_err(dev, "%s: BUG! echo_skb is occupied!\n", __func__);
    721     - kfree_skb(skb);
    722     - }
    723     -}
    724     -EXPORT_SYMBOL_GPL(can_put_echo_skb);
    725     -
    726     -struct sk_buff *
    727     -__can_get_echo_skb(struct net_device *dev, unsigned int idx, u8 *len_ptr)
    728     -{
    729     - struct can_priv *priv = netdev_priv(dev);
    730     -
    731     - if (idx >= priv->echo_skb_max) {
    732     - netdev_err(dev, "%s: BUG! Trying to access can_priv::echo_skb out of bounds (%u/max %u)\n",
    733     - __func__, idx, priv->echo_skb_max);
    734     - return NULL;
    735     - }
    736     -
    737     - if (priv->echo_skb[idx]) {
    738     - /* Using "struct canfd_frame::len" for the frame
    739     - * length is supported on both CAN and CANFD frames.
    740     - */
    741     - struct sk_buff *skb = priv->echo_skb[idx];
    742     - struct canfd_frame *cf = (struct canfd_frame *)skb->data;
    743     -
    744     - /* get the real payload length for netdev statistics */
    745     - if (cf->can_id & CAN_RTR_FLAG)
    746     - *len_ptr = 0;
    747     - else
    748     - *len_ptr = cf->len;
    749     -
    750     - priv->echo_skb[idx] = NULL;
    751     -
    752     - return skb;
    753     - }
    754     -
    755     - return NULL;
    756     -}
    757     -
    758     -/* Get the skb from the stack and loop it back locally
    759     - *
    760     - * The function is typically called when the TX done interrupt
    761     - * is handled in the device driver. The driver must protect
    762     - * access to priv->echo_skb, if necessary.
    763     - */
    764     -unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx)
    765     -{
    766     - struct sk_buff *skb;
    767     - u8 len;
    768     -
    769     - skb = __can_get_echo_skb(dev, idx, &len);
    770     - if (!skb)
    771     - return 0;
    772     -
    773     - skb_get(skb);
    774     - if (netif_rx(skb) == NET_RX_SUCCESS)
    775     - dev_consume_skb_any(skb);
    776     - else
    777     - dev_kfree_skb_any(skb);
    778     -
    779     - return len;
    780     -}
    781     -EXPORT_SYMBOL_GPL(can_get_echo_skb);
    782     -
    783     -/* Remove the skb from the stack and free it.
    784     - *
    785     - * The function is typically called when TX failed.
    786     - */
    787     -void can_free_echo_skb(struct net_device *dev, unsigned int idx)
    788     -{
    789     - struct can_priv *priv = netdev_priv(dev);
    790     -
    791     - BUG_ON(idx >= priv->echo_skb_max);
    792     -
    793     - if (priv->echo_skb[idx]) {
    794     - dev_kfree_skb_any(priv->echo_skb[idx]);
    795     - priv->echo_skb[idx] = NULL;
    796     - }
    797     -}
    798     -EXPORT_SYMBOL_GPL(can_free_echo_skb);
    799     -
    800     -/* CAN device restart for bus-off recovery */
    801     -static void can_restart(struct net_device *dev)
    802     -{
    803     - struct can_priv *priv = netdev_priv(dev);
    804     - struct net_device_stats *stats = &dev->stats;
    805     - struct sk_buff *skb;
    806     - struct can_frame *cf;
    807     - int err;
    808     -
    809     - BUG_ON(netif_carrier_ok(dev));
    810     -
    811     - /* No synchronization needed because the device is bus-off and
    812     - * no messages can come in or go out.
    813     - */
    814     - can_flush_echo_skb(dev);
    815     -
    816     - /* send restart message upstream */
    817     - skb = alloc_can_err_skb(dev, &cf);
    818     - if (!skb) {
    819     - err = -ENOMEM;
    820     - goto restart;
    821     - }
    822     - cf->can_id |= CAN_ERR_RESTARTED;
    823     -
    824     - stats->rx_packets++;
    825     - stats->rx_bytes += cf->can_dlc;
    826     -
    827     - netif_rx_ni(skb);
    828     -
    829     -restart:
    830     - netdev_dbg(dev, "restarted\n");
    831     - priv->can_stats.restarts++;
    832     -
    833     - /* Now restart the device */
    834     - err = priv->do_set_mode(dev, CAN_MODE_START);
    835     -
    836     - netif_carrier_on(dev);
    837     - if (err)
    838     - netdev_err(dev, "Error %d during restart", err);
    839     -}
    840     -
    841     -static void can_restart_work(struct work_struct *work)
    842     -{
    843     - struct delayed_work *dwork = to_delayed_work(work);
    844     - struct can_priv *priv = container_of(dwork, struct can_priv,
    845     - restart_work);
    846     -
    847     - can_restart(priv->dev);
    848     -}
    849     -
    850     -int can_restart_now(struct net_device *dev)
    851     -{
    852     - struct can_priv *priv = netdev_priv(dev);
    853     -
    854     - /* A manual restart is only permitted if automatic restart is
    855     - * disabled and the device is in the bus-off state
    856     - */
    857     - if (priv->restart_ms)
    858     - return -EINVAL;
    859     - if (priv->state != CAN_STATE_BUS_OFF)
    860     - return -EBUSY;
    861     -
    862     - cancel_delayed_work_sync(&priv->restart_work);
    863     - can_restart(dev);
    864     -
    865     - return 0;
    866     -}
    867     -
    868     -/* CAN bus-off
    869     - *
    870     - * This functions should be called when the device goes bus-off to
    871     - * tell the netif layer that no more packets can be sent or received.
    872     - * If enabled, a timer is started to trigger bus-off recovery.
    873     - */
    874     -void can_bus_off(struct net_device *dev)
    875     -{
    876     - struct can_priv *priv = netdev_priv(dev);
    877     -
    878     - netdev_info(dev, "bus-off\n");
    879     -
    880     - netif_carrier_off(dev);
    881     -
    882     - if (priv->restart_ms)
    883     - schedule_delayed_work(&priv->restart_work,
    884     - msecs_to_jiffies(priv->restart_ms));
    885     -}
    886     -EXPORT_SYMBOL_GPL(can_bus_off);
    887     -
    888     -static void can_setup(struct net_device *dev)
    889     -{
    890     - dev->type = ARPHRD_CAN;
    891     - dev->mtu = CAN_MTU;
    892     - dev->hard_header_len = 0;
    893     - dev->addr_len = 0;
    894     - dev->tx_queue_len = 10;
    895     -
    896     - /* New-style flags. */
    897     - dev->flags = IFF_NOARP;
    898     - dev->features = NETIF_F_HW_CSUM;
    899     -}
    900     -
    901     -struct sk_buff *alloc_can_skb(struct net_device *dev, struct can_frame **cf)
    902     -{
    903     - struct sk_buff *skb;
    904     -
    905     - skb = netdev_alloc_skb(dev, sizeof(struct can_skb_priv) +
    906     - sizeof(struct can_frame));
    907     - if (unlikely(!skb))
    908     - return NULL;
    909     -
    910     - skb->protocol = htons(ETH_P_CAN);
    911     - skb->pkt_type = PACKET_BROADCAST;
    912     - skb->ip_summed = CHECKSUM_UNNECESSARY;
    913     -
    914     - skb_reset_mac_header(skb);
    915     - skb_reset_network_header(skb);
    916     - skb_reset_transport_header(skb);
    917     -
    918     - can_skb_reserve(skb);
    919     - can_skb_prv(skb)->ifindex = dev->ifindex;
    920     - can_skb_prv(skb)->skbcnt = 0;
    921     -
    922     - *cf = skb_put_zero(skb, sizeof(struct can_frame));
    923     -
    924     - return skb;
    925     -}
    926     -EXPORT_SYMBOL_GPL(alloc_can_skb);
    927     -
    928     -struct sk_buff *alloc_canfd_skb(struct net_device *dev,
    929     - struct canfd_frame **cfd)
    930     -{
    931     - struct sk_buff *skb;
    932     -
    933     - skb = netdev_alloc_skb(dev, sizeof(struct can_skb_priv) +
    934     - sizeof(struct canfd_frame));
    935     - if (unlikely(!skb))
    936     - return NULL;
    937     -
    938     - skb->protocol = htons(ETH_P_CANFD);
    939     - skb->pkt_type = PACKET_BROADCAST;
    940     - skb->ip_summed = CHECKSUM_UNNECESSARY;
    941     -
    942     - skb_reset_mac_header(skb);
    943     - skb_reset_network_header(skb);
    944     - skb_reset_transport_header(skb);
    945     -
    946     - can_skb_reserve(skb);
    947     - can_skb_prv(skb)->ifindex = dev->ifindex;
    948     - can_skb_prv(skb)->skbcnt = 0;
    949     -
    950     - *cfd = skb_put_zero(skb, sizeof(struct canfd_frame));
    951     -
    952     - return skb;
    953     -}
    954     -EXPORT_SYMBOL_GPL(alloc_canfd_skb);
    955     -
    956     -struct sk_buff *alloc_can_err_skb(struct net_device *dev, struct can_frame **cf)
    957     -{
    958     - struct sk_buff *skb;
    959     -
    960     - skb = alloc_can_skb(dev, cf);
    961     - if (unlikely(!skb))
    962     - return NULL;
    963     -
    964     - (*cf)->can_id = CAN_ERR_FLAG;
    965     - (*cf)->can_dlc = CAN_ERR_DLC;
    966     -
    967     - return skb;
    968     -}
    969     -EXPORT_SYMBOL_GPL(alloc_can_err_skb);
    970     -
    971     -/* Allocate and setup space for the CAN network device */
    972     -struct net_device *alloc_candev_mqs(int sizeof_priv, unsigned int echo_skb_max,
    973     - unsigned int txqs, unsigned int rxqs)
    974     -{
    975     - struct net_device *dev;
    976     - struct can_priv *priv;
    977     - int size;
    978     -
    979     - /* We put the driver's priv, the CAN mid layer priv and the
    980     - * echo skb into the netdevice's priv. The memory layout for
    981     - * the netdev_priv is like this:
    982     - *
    983     - * +-------------------------+
    984     - * | driver's priv |
    985     - * +-------------------------+
    986     - * | struct can_ml_priv |
    987     - * +-------------------------+
    988     - * | array of struct sk_buff |
    989     - * +-------------------------+
    990     - */
    991     -
    992     - size = ALIGN(sizeof_priv, NETDEV_ALIGN) + sizeof(struct can_ml_priv);
    993     -
    994     - if (echo_skb_max)
    995     - size = ALIGN(size, sizeof(struct sk_buff *)) +
    996     - echo_skb_max * sizeof(struct sk_buff *);
    997     -
    998     - dev = alloc_netdev_mqs(size, "can%d", NET_NAME_UNKNOWN, can_setup,
    999     - txqs, rxqs);
    1000     - if (!dev)
    1001     - return NULL;
    1002     -
    1003     - priv = netdev_priv(dev);
    1004     - priv->dev = dev;
    1005     -
    1006     - dev->ml_priv = (void *)priv + ALIGN(sizeof_priv, NETDEV_ALIGN);
    1007     -
    1008     - if (echo_skb_max) {
    1009     - priv->echo_skb_max = echo_skb_max;
    1010     - priv->echo_skb = (void *)priv +
    1011     - (size - echo_skb_max * sizeof(struct sk_buff *));
    1012     - }
    1013     -
    1014     - priv->state = CAN_STATE_STOPPED;
    1015     -
    1016     - INIT_DELAYED_WORK(&priv->restart_work, can_restart_work);
    1017     -
    1018     - return dev;
    1019     -}
    1020     -EXPORT_SYMBOL_GPL(alloc_candev_mqs);
    1021     -
    1022     -/* Free space of the CAN network device */
    1023     -void free_candev(struct net_device *dev)
    1024     -{
    1025     - free_netdev(dev);
    1026     -}
    1027     -EXPORT_SYMBOL_GPL(free_candev);
    1028     -
    1029     -/* changing MTU and control mode for CAN/CANFD devices */
    1030     -int can_change_mtu(struct net_device *dev, int new_mtu)
    1031     -{
    1032     - struct can_priv *priv = netdev_priv(dev);
    1033     -
    1034     - /* Do not allow changing the MTU while running */
    1035     - if (dev->flags & IFF_UP)
    1036     - return -EBUSY;
    1037     -
    1038     - /* allow change of MTU according to the CANFD ability of the device */
    1039     - switch (new_mtu) {
    1040     - case CAN_MTU:
    1041     - /* 'CANFD-only' controllers can not switch to CAN_MTU */
    1042     - if (priv->ctrlmode_static & CAN_CTRLMODE_FD)
    1043     - return -EINVAL;
    1044     -
    1045     - priv->ctrlmode &= ~CAN_CTRLMODE_FD;
    1046     - break;
    1047     -
    1048     - case CANFD_MTU:
    1049     - /* check for potential CANFD ability */
    1050     - if (!(priv->ctrlmode_supported & CAN_CTRLMODE_FD) &&
    1051     - !(priv->ctrlmode_static & CAN_CTRLMODE_FD))
    1052     - return -EINVAL;
    1053     -
    1054     - priv->ctrlmode |= CAN_CTRLMODE_FD;
    1055     - break;
    1056     -
    1057     - default:
    1058     - return -EINVAL;
    1059     - }
    1060     -
    1061     - dev->mtu = new_mtu;
    1062     - return 0;
    1063     -}
    1064     -EXPORT_SYMBOL_GPL(can_change_mtu);
    1065     -
    1066     -/* Common open function when the device gets opened.
    1067     - *
    1068     - * This function should be called in the open function of the device
    1069     - * driver.
    1070     - */
    1071     -int open_candev(struct net_device *dev)
    1072     -{
    1073     - struct can_priv *priv = netdev_priv(dev);
    1074     -
    1075     - if (!priv->bittiming.bitrate) {
    1076     - netdev_err(dev, "bit-timing not yet defined\n");
    1077     - return -EINVAL;
    1078     - }
    1079     -
    1080     - /* For CAN FD the data bitrate has to be >= the arbitration bitrate */
    1081     - if ((priv->ctrlmode & CAN_CTRLMODE_FD) &&
    1082     - (!priv->data_bittiming.bitrate ||
    1083     - priv->data_bittiming.bitrate < priv->bittiming.bitrate)) {
    1084     - netdev_err(dev, "incorrect/missing data bit-timing\n");
    1085     - return -EINVAL;
    1086     - }
    1087     -
    1088     - /* Switch carrier on if device was stopped while in bus-off state */
    1089     - if (!netif_carrier_ok(dev))
    1090     - netif_carrier_on(dev);
    1091     -
    1092     - return 0;
    1093     -}
    1094     -EXPORT_SYMBOL_GPL(open_candev);
    1095     -
    1096     -#ifdef CONFIG_OF
    1097     -/* Common function that can be used to understand the limitation of
    1098     - * a transceiver when it provides no means to determine these limitations
    1099     - * at runtime.
    1100     - */
    1101     -void of_can_transceiver(struct net_device *dev)
    1102     -{
    1103     - struct device_node *dn;
    1104     - struct can_priv *priv = netdev_priv(dev);
    1105     - struct device_node *np = dev->dev.parent->of_node;
    1106     - int ret;
    1107     -
    1108     - dn = of_get_child_by_name(np, "can-transceiver");
    1109     - if (!dn)
    1110     - return;
    1111     -
    1112     - ret = of_property_read_u32(dn, "max-bitrate", &priv->bitrate_max);
    1113     - of_node_put(dn);
    1114     - if ((ret && ret != -EINVAL) || (!ret && !priv->bitrate_max))
    1115     - netdev_warn(dev, "Invalid value for transceiver max bitrate. Ignoring bitrate limit.\n");
    1116     -}
    1117     -EXPORT_SYMBOL_GPL(of_can_transceiver);
    1118     -#endif
    1119     -
    1120     -/* Common close function for cleanup before the device gets closed.
    1121     - *
    1122     - * This function should be called in the close function of the device
    1123     - * driver.
    1124     - */
    1125     -void close_candev(struct net_device *dev)
    1126     -{
    1127     - struct can_priv *priv = netdev_priv(dev);
    1128     -
    1129     - cancel_delayed_work_sync(&priv->restart_work);
    1130     - can_flush_echo_skb(dev);
    1131     -}
    1132     -EXPORT_SYMBOL_GPL(close_candev);
    1133     -
    1134     -/* CAN netlink interface */
    1135     -static const struct nla_policy can_policy[IFLA_CAN_MAX + 1] = {
    1136     - [IFLA_CAN_STATE] = { .type = NLA_U32 },
    1137     - [IFLA_CAN_CTRLMODE] = { .len = sizeof(struct can_ctrlmode) },
    1138     - [IFLA_CAN_RESTART_MS] = { .type = NLA_U32 },
    1139     - [IFLA_CAN_RESTART] = { .type = NLA_U32 },
    1140     - [IFLA_CAN_BITTIMING] = { .len = sizeof(struct can_bittiming) },
    1141     - [IFLA_CAN_BITTIMING_CONST]
    1142     - = { .len = sizeof(struct can_bittiming_const) },
    1143     - [IFLA_CAN_CLOCK] = { .len = sizeof(struct can_clock) },
    1144     - [IFLA_CAN_BERR_COUNTER] = { .len = sizeof(struct can_berr_counter) },
    1145     - [IFLA_CAN_DATA_BITTIMING]
    1146     - = { .len = sizeof(struct can_bittiming) },
    1147     - [IFLA_CAN_DATA_BITTIMING_CONST]
    1148     - = { .len = sizeof(struct can_bittiming_const) },
    1149     - [IFLA_CAN_TERMINATION] = { .type = NLA_U16 },
    1150     -};
    1151     -
    1152     -static int can_validate(struct nlattr *tb[], struct nlattr *data[],
    1153     - struct netlink_ext_ack *extack)
    1154     -{
    1155     - bool is_can_fd = false;
    1156     -
    1157     - /* Make sure that valid CAN FD configurations always consist of
    1158     - * - nominal/arbitration bittiming
    1159     - * - data bittiming
    1160     - * - control mode with CAN_CTRLMODE_FD set
    1161     - */
    1162     -
    1163     - if (!data)
    1164     - return 0;
    1165     -
    1166     - if (data[IFLA_CAN_CTRLMODE]) {
    1167     - struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]);
    1168     -
    1169     - is_can_fd = cm->flags & cm->mask & CAN_CTRLMODE_FD;
    1170     - }
    1171     -
    1172     - if (is_can_fd) {
    1173     - if (!data[IFLA_CAN_BITTIMING] || !data[IFLA_CAN_DATA_BITTIMING])
    1174     - return -EOPNOTSUPP;
    1175     - }
    1176     -
    1177     - if (data[IFLA_CAN_DATA_BITTIMING]) {
    1178     - if (!is_can_fd || !data[IFLA_CAN_BITTIMING])
    1179     - return -EOPNOTSUPP;
    1180     - }
    1181     -
    1182     - return 0;
    1183     -}
    1184     -
    1185     -static int can_changelink(struct net_device *dev, struct nlattr *tb[],
    1186     - struct nlattr *data[],
    1187     - struct netlink_ext_ack *extack)
    1188     -{
    1189     - struct can_priv *priv = netdev_priv(dev);
    1190     - int err;
    1191     -
    1192     - /* We need synchronization with dev->stop() */
    1193     - ASSERT_RTNL();
    1194     -
    1195     - if (data[IFLA_CAN_BITTIMING]) {
    1196     - struct can_bittiming bt;
    1197     -
    1198     - /* Do not allow changing bittiming while running */
    1199     - if (dev->flags & IFF_UP)
    1200     - return -EBUSY;
    1201     -
    1202     - /* Calculate bittiming parameters based on
    1203     - * bittiming_const if set, otherwise pass bitrate
    1204     - * directly via do_set_bitrate(). Bail out if neither
    1205     - * is given.
    1206     - */
    1207     - if (!priv->bittiming_const && !priv->do_set_bittiming)
    1208     - return -EOPNOTSUPP;
    1209     -
    1210     - memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt));
    1211     - err = can_get_bittiming(dev, &bt,
    1212     - priv->bittiming_const,
    1213     - priv->bitrate_const,
    1214     - priv->bitrate_const_cnt);
    1215     - if (err)
    1216     - return err;
    1217     -
    1218     - if (priv->bitrate_max && bt.bitrate > priv->bitrate_max) {
    1219     - netdev_err(dev, "arbitration bitrate surpasses transceiver capabilities of %d bps\n",
    1220     - priv->bitrate_max);
    1221     - return -EINVAL;
    1222     - }
    1223     -
    1224     - memcpy(&priv->bittiming, &bt, sizeof(bt));
    1225     -
    1226     - if (priv->do_set_bittiming) {
    1227     - /* Finally, set the bit-timing registers */
    1228     - err = priv->do_set_bittiming(dev);
    1229     - if (err)
    1230     - return err;
    1231     - }
    1232     - }
    1233     -
    1234     - if (data[IFLA_CAN_CTRLMODE]) {
    1235     - struct can_ctrlmode *cm;
    1236     - u32 ctrlstatic;
    1237     - u32 maskedflags;
    1238     -
    1239     - /* Do not allow changing controller mode while running */
    1240     - if (dev->flags & IFF_UP)
    1241     - return -EBUSY;
    1242     - cm = nla_data(data[IFLA_CAN_CTRLMODE]);
    1243     - ctrlstatic = priv->ctrlmode_static;
    1244     - maskedflags = cm->flags & cm->mask;
    1245     -
    1246     - /* check whether provided bits are allowed to be passed */
    1247     - if (cm->mask & ~(priv->ctrlmode_supported | ctrlstatic))
    1248     - return -EOPNOTSUPP;
    1249     -
    1250     - /* do not check for static fd-non-iso if 'fd' is disabled */
    1251     - if (!(maskedflags & CAN_CTRLMODE_FD))
    1252     - ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO;
    1253     -
    1254     - /* make sure static options are provided by configuration */
    1255     - if ((maskedflags & ctrlstatic) != ctrlstatic)
    1256     - return -EOPNOTSUPP;
    1257     -
    1258     - /* clear bits to be modified and copy the flag values */
    1259     - priv->ctrlmode &= ~cm->mask;
    1260     - priv->ctrlmode |= maskedflags;
    1261     -
    1262     - /* CAN_CTRLMODE_FD can only be set when driver supports FD */
    1263     - if (priv->ctrlmode & CAN_CTRLMODE_FD)
    1264     - dev->mtu = CANFD_MTU;
    1265     - else
    1266     - dev->mtu = CAN_MTU;
    1267     - }
    1268     -
    1269     - if (data[IFLA_CAN_RESTART_MS]) {
    1270     - /* Do not allow changing restart delay while running */
    1271     - if (dev->flags & IFF_UP)
    1272     - return -EBUSY;
    1273     - priv->restart_ms = nla_get_u32(data[IFLA_CAN_RESTART_MS]);
    1274     - }
    1275     -
    1276     - if (data[IFLA_CAN_RESTART]) {
    1277     - /* Do not allow a restart while not running */
    1278     - if (!(dev->flags & IFF_UP))
    1279     - return -EINVAL;
    1280     - err = can_restart_now(dev);
    1281     - if (err)
    1282     - return err;
    1283     - }
    1284     -
    1285     - if (data[IFLA_CAN_DATA_BITTIMING]) {
    1286     - struct can_bittiming dbt;
    1287     -
    1288     - /* Do not allow changing bittiming while running */
    1289     - if (dev->flags & IFF_UP)
    1290     - return -EBUSY;
    1291     -
    1292     - /* Calculate bittiming parameters based on
    1293     - * data_bittiming_const if set, otherwise pass bitrate
    1294     - * directly via do_set_bitrate(). Bail out if neither
    1295     - * is given.
    1296     - */
    1297     - if (!priv->data_bittiming_const && !priv->do_set_data_bittiming)
    1298     - return -EOPNOTSUPP;
    1299     -
    1300     - memcpy(&dbt, nla_data(data[IFLA_CAN_DATA_BITTIMING]),
    1301     - sizeof(dbt));
    1302     - err = can_get_bittiming(dev, &dbt,
    1303     - priv->data_bittiming_const,
    1304     - priv->data_bitrate_const,
    1305     - priv->data_bitrate_const_cnt);
    1306     - if (err)
    1307     - return err;
    1308     -
    1309     - if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) {
    1310     - netdev_err(dev, "canfd data bitrate surpasses transceiver capabilities of %d bps\n",
    1311     - priv->bitrate_max);
    1312     - return -EINVAL;
    1313     - }
    1314     -
    1315     - memcpy(&priv->data_bittiming, &dbt, sizeof(dbt));
    1316     -
    1317     - if (priv->do_set_data_bittiming) {
    1318     - /* Finally, set the bit-timing registers */
    1319     - err = priv->do_set_data_bittiming(dev);
    1320     - if (err)
    1321     - return err;
    1322     - }
    1323     - }
    1324     -
    1325     - if (data[IFLA_CAN_TERMINATION]) {
    1326     - const u16 termval = nla_get_u16(data[IFLA_CAN_TERMINATION]);
    1327     - const unsigned int num_term = priv->termination_const_cnt;
    1328     - unsigned int i;
    1329     -
    1330     - if (!priv->do_set_termination)
    1331     - return -EOPNOTSUPP;
    1332     -
    1333     - /* check whether given value is supported by the interface */
    1334     - for (i = 0; i < num_term; i++) {
    1335     - if (termval == priv->termination_const[i])
    1336     - break;
    1337     - }
    1338     - if (i >= num_term)
    1339     - return -EINVAL;
    1340     -
    1341     - /* Finally, set the termination value */
    1342     - err = priv->do_set_termination(dev, termval);
    1343     - if (err)
    1344     - return err;
    1345     -
    1346     - priv->termination = termval;
    1347     - }
    1348     -
    1349     - return 0;
    1350     -}
    1351     -
    1352     -static size_t can_get_size(const struct net_device *dev)
    1353     -{
    1354     - struct can_priv *priv = netdev_priv(dev);
    1355     - size_t size = 0;
    1356     -
    1357     - if (priv->bittiming.bitrate) /* IFLA_CAN_BITTIMING */
    1358     - size += nla_total_size(sizeof(struct can_bittiming));
    1359     - if (priv->bittiming_const) /* IFLA_CAN_BITTIMING_CONST */
    1360     - size += nla_total_size(sizeof(struct can_bittiming_const));
    1361     - size += nla_total_size(sizeof(struct can_clock)); /* IFLA_CAN_CLOCK */
    1362     - size += nla_total_size(sizeof(u32)); /* IFLA_CAN_STATE */
    1363     - size += nla_total_size(sizeof(struct can_ctrlmode)); /* IFLA_CAN_CTRLMODE */
    1364     - size += nla_total_size(sizeof(u32)); /* IFLA_CAN_RESTART_MS */
    1365     - if (priv->do_get_berr_counter) /* IFLA_CAN_BERR_COUNTER */
    1366     - size += nla_total_size(sizeof(struct can_berr_counter));
    1367     - if (priv->data_bittiming.bitrate) /* IFLA_CAN_DATA_BITTIMING */
    1368     - size += nla_total_size(sizeof(struct can_bittiming));
    1369     - if (priv->data_bittiming_const) /* IFLA_CAN_DATA_BITTIMING_CONST */
    1370     - size += nla_total_size(sizeof(struct can_bittiming_const));
    1371     - if (priv->termination_const) {
    1372     - size += nla_total_size(sizeof(priv->termination)); /* IFLA_CAN_TERMINATION */
    1373     - size += nla_total_size(sizeof(*priv->termination_const) * /* IFLA_CAN_TERMINATION_CONST */
    1374     - priv->termination_const_cnt);
    1375     - }
    1376     - if (priv->bitrate_const) /* IFLA_CAN_BITRATE_CONST */
    1377     - size += nla_total_size(sizeof(*priv->bitrate_const) *
    1378     - priv->bitrate_const_cnt);
    1379     - if (priv->data_bitrate_const) /* IFLA_CAN_DATA_BITRATE_CONST */
    1380     - size += nla_total_size(sizeof(*priv->data_bitrate_const) *
    1381     - priv->data_bitrate_const_cnt);
    1382     - size += sizeof(priv->bitrate_max); /* IFLA_CAN_BITRATE_MAX */
    1383     -
    1384     - return size;
    1385     -}
    1386     -
    1387     -static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)
    1388     -{
    1389     - struct can_priv *priv = netdev_priv(dev);
    1390     - struct can_ctrlmode cm = {.flags = priv->ctrlmode};
    1391     - struct can_berr_counter bec = { };
    1392     - enum can_state state = priv->state;
    1393     -
    1394     - if (priv->do_get_state)
    1395     - priv->do_get_state(dev, &state);
    1396     -
    1397     - if ((priv->bittiming.bitrate &&
    1398     - nla_put(skb, IFLA_CAN_BITTIMING,
    1399     - sizeof(priv->bittiming), &priv->bittiming)) ||
    1400     -
    1401     - (priv->bittiming_const &&
    1402     - nla_put(skb, IFLA_CAN_BITTIMING_CONST,
    1403     - sizeof(*priv->bittiming_const), priv->bittiming_const)) ||
    1404     -
    1405     - nla_put(skb, IFLA_CAN_CLOCK, sizeof(priv->clock), &priv->clock) ||
    1406     - nla_put_u32(skb, IFLA_CAN_STATE, state) ||
    1407     - nla_put(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm) ||
    1408     - nla_put_u32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms) ||
    1409     -
    1410     - (priv->do_get_berr_counter &&
    1411     - !priv->do_get_berr_counter(dev, &bec) &&
    1412     - nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) ||
    1413     -
    1414     - (priv->data_bittiming.bitrate &&
    1415     - nla_put(skb, IFLA_CAN_DATA_BITTIMING,
    1416     - sizeof(priv->data_bittiming), &priv->data_bittiming)) ||
    1417     -
    1418     - (priv->data_bittiming_const &&
    1419     - nla_put(skb, IFLA_CAN_DATA_BITTIMING_CONST,
    1420     - sizeof(*priv->data_bittiming_const),
    1421     - priv->data_bittiming_const)) ||
    1422     -
    1423     - (priv->termination_const &&
    1424     - (nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) ||
    1425     - nla_put(skb, IFLA_CAN_TERMINATION_CONST,
    1426     - sizeof(*priv->termination_const) *
    1427     - priv->termination_const_cnt,
    1428     - priv->termination_const))) ||
    1429     -
    1430     - (priv->bitrate_const &&
    1431     - nla_put(skb, IFLA_CAN_BITRATE_CONST,
    1432     - sizeof(*priv->bitrate_const) *
    1433     - priv->bitrate_const_cnt,
    1434     - priv->bitrate_const)) ||
    1435     -
    1436     - (priv->data_bitrate_const &&
    1437     - nla_put(skb, IFLA_CAN_DATA_BITRATE_CONST,
    1438     - sizeof(*priv->data_bitrate_const) *
    1439     - priv->data_bitrate_const_cnt,
    1440     - priv->data_bitrate_const)) ||
    1441     -
    1442     - (nla_put(skb, IFLA_CAN_BITRATE_MAX,
    1443     - sizeof(priv->bitrate_max),
    1444     - &priv->bitrate_max))
    1445     - )
    1446     -
    1447     - return -EMSGSIZE;
    1448     -
    1449     - return 0;
    1450     -}
    1451     -
    1452     -static size_t can_get_xstats_size(const struct net_device *dev)
    1453     -{
    1454     - return sizeof(struct can_device_stats);
    1455     -}
    1456     -
    1457     -static int can_fill_xstats(struct sk_buff *skb, const struct net_device *dev)
    1458     -{
    1459     - struct can_priv *priv = netdev_priv(dev);
    1460     -
    1461     - if (nla_put(skb, IFLA_INFO_XSTATS,
    1462     - sizeof(priv->can_stats), &priv->can_stats))
    1463     - goto nla_put_failure;
    1464     - return 0;
    1465     -
    1466     -nla_put_failure:
    1467     - return -EMSGSIZE;
    1468     -}
    1469     -
    1470     -static int can_newlink(struct net *src_net, struct net_device *dev,
    1471     - struct nlattr *tb[], struct nlattr *data[],
    1472     - struct netlink_ext_ack *extack)
    1473     -{
    1474     - return -EOPNOTSUPP;
    1475     -}
    1476     -
    1477     -static void can_dellink(struct net_device *dev, struct list_head *head)
    1478     -{
    1479     -}
    1480     -
    1481     -static struct rtnl_link_ops can_link_ops __read_mostly = {
    1482     - .kind = "can",
    1483     - .netns_refund = true,
    1484     - .maxtype = IFLA_CAN_MAX,
    1485     - .policy = can_policy,
    1486     - .setup = can_setup,
    1487     - .validate = can_validate,
    1488     - .newlink = can_newlink,
    1489     - .changelink = can_changelink,
    1490     - .dellink = can_dellink,
    1491     - .get_size = can_get_size,
    1492     - .fill_info = can_fill_info,
    1493     - .get_xstats_size = can_get_xstats_size,
    1494     - .fill_xstats = can_fill_xstats,
    1495     -};
    1496     -
    1497     -/* Register the CAN network device */
    1498     -int register_candev(struct net_device *dev)
    1499     -{
    1500     - struct can_priv *priv = netdev_priv(dev);
    1501     -
    1502     - /* Ensure termination_const, termination_const_cnt and
    1503     - * do_set_termination consistency. All must be either set or
    1504     - * unset.
    1505     - */
    1506     - if ((!priv->termination_const != !priv->termination_const_cnt) ||
    1507     - (!priv->termination_const != !priv->do_set_termination))
    1508     - return -EINVAL;
    1509     -
    1510     - if (!priv->bitrate_const != !priv->bitrate_const_cnt)
    1511     - return -EINVAL;
    1512     -
    1513     - if (!priv->data_bitrate_const != !priv->data_bitrate_const_cnt)
    1514     - return -EINVAL;
    1515     -
    1516     - dev->rtnl_link_ops = &can_link_ops;
    1517     - netif_carrier_off(dev);
    1518     -
    1519     - return register_netdev(dev);
    1520     -}
    1521     -EXPORT_SYMBOL_GPL(register_candev);
    1522     -
    1523     -/* Unregister the CAN network device */
    1524     -void unregister_candev(struct net_device *dev)
    1525     -{
    1526     - unregister_netdev(dev);
    1527     -}
    1528     -EXPORT_SYMBOL_GPL(unregister_candev);
    1529     -
    1530     -/* Test if a network device is a candev based device
    1531     - * and return the can_priv* if so.
    1532     - */
    1533     -struct can_priv *safe_candev_priv(struct net_device *dev)
    1534     -{
    1535     - if (dev->type != ARPHRD_CAN || dev->rtnl_link_ops != &can_link_ops)
    1536     - return NULL;
    1537     -
    1538     - return netdev_priv(dev);
    1539     -}
    1540     -EXPORT_SYMBOL_GPL(safe_candev_priv);
    1541     -
    1542     -static __init int can_dev_init(void)
    1543     -{
    1544     - int err;
    1545     -
    1546     - can_led_notifier_init();
    1547     -
    1548     - err = rtnl_link_register(&can_link_ops);
    1549     - if (!err)
    1550     - pr_info(MOD_DESC "\n");
    1551     -
    1552     - return err;
    1553     -}
    1554     -module_init(can_dev_init);
    1555     -
    1556     -static __exit void can_dev_exit(void)
    1557     -{
    1558     - rtnl_link_unregister(&can_link_ops);
    1559     -
    1560     - can_led_notifier_exit();
    1561     -}
    1562     -module_exit(can_dev_exit);
    1563     -
    1564     -MODULE_ALIAS_RTNL_LINK("can");
    1565     diff --git a/drivers/net/can/dev/Makefile b/drivers/net/can/dev/Makefile
    1566     new file mode 100644
    1567     index 0000000000000..cba92e6bcf6f5
    1568     --- /dev/null
    1569     +++ b/drivers/net/can/dev/Makefile
    1570     @@ -0,0 +1,7 @@
    1571     +# SPDX-License-Identifier: GPL-2.0
    1572     +
    1573     +obj-$(CONFIG_CAN_DEV) += can-dev.o
    1574     +can-dev-y += dev.o
    1575     +can-dev-y += rx-offload.o
    1576     +
    1577     +can-dev-$(CONFIG_CAN_LEDS) += led.o
    1578     diff --git a/drivers/net/can/dev/dev.c b/drivers/net/can/dev/dev.c
    1579     new file mode 100644
    1580     index 0000000000000..322da89cb9c60
    1581     --- /dev/null
    1582     +++ b/drivers/net/can/dev/dev.c
    1583     @@ -0,0 +1,1312 @@
    1584     +// SPDX-License-Identifier: GPL-2.0-only
    1585     +/* Copyright (C) 2005 Marc Kleine-Budde, Pengutronix
    1586     + * Copyright (C) 2006 Andrey Volkov, Varma Electronics
    1587     + * Copyright (C) 2008-2009 Wolfgang Grandegger <wg@grandegger.com>
    1588     + */
    1589     +
    1590     +#include <linux/module.h>
    1591     +#include <linux/kernel.h>
    1592     +#include <linux/slab.h>
    1593     +#include <linux/netdevice.h>
    1594     +#include <linux/if_arp.h>
    1595     +#include <linux/workqueue.h>
    1596     +#include <linux/can.h>
    1597     +#include <linux/can/can-ml.h>
    1598     +#include <linux/can/dev.h>
    1599     +#include <linux/can/skb.h>
    1600     +#include <linux/can/netlink.h>
    1601     +#include <linux/can/led.h>
    1602     +#include <linux/of.h>
    1603     +#include <net/rtnetlink.h>
    1604     +
    1605     +#define MOD_DESC "CAN device driver interface"
    1606     +
    1607     +MODULE_DESCRIPTION(MOD_DESC);
    1608     +MODULE_LICENSE("GPL v2");
    1609     +MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
    1610     +
    1611     +/* CAN DLC to real data length conversion helpers */
    1612     +
    1613     +static const u8 dlc2len[] = {0, 1, 2, 3, 4, 5, 6, 7,
    1614     + 8, 12, 16, 20, 24, 32, 48, 64};
    1615     +
    1616     +/* get data length from can_dlc with sanitized can_dlc */
    1617     +u8 can_dlc2len(u8 can_dlc)
    1618     +{
    1619     + return dlc2len[can_dlc & 0x0F];
    1620     +}
    1621     +EXPORT_SYMBOL_GPL(can_dlc2len);
    1622     +
    1623     +static const u8 len2dlc[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, /* 0 - 8 */
    1624     + 9, 9, 9, 9, /* 9 - 12 */
    1625     + 10, 10, 10, 10, /* 13 - 16 */
    1626     + 11, 11, 11, 11, /* 17 - 20 */
    1627     + 12, 12, 12, 12, /* 21 - 24 */
    1628     + 13, 13, 13, 13, 13, 13, 13, 13, /* 25 - 32 */
    1629     + 14, 14, 14, 14, 14, 14, 14, 14, /* 33 - 40 */
    1630     + 14, 14, 14, 14, 14, 14, 14, 14, /* 41 - 48 */
    1631     + 15, 15, 15, 15, 15, 15, 15, 15, /* 49 - 56 */
    1632     + 15, 15, 15, 15, 15, 15, 15, 15}; /* 57 - 64 */
    1633     +
    1634     +/* map the sanitized data length to an appropriate data length code */
    1635     +u8 can_len2dlc(u8 len)
    1636     +{
    1637     + if (unlikely(len > 64))
    1638     + return 0xF;
    1639     +
    1640     + return len2dlc[len];
    1641     +}
    1642     +EXPORT_SYMBOL_GPL(can_len2dlc);
    1643     +
    1644     +#ifdef CONFIG_CAN_CALC_BITTIMING
    1645     +#define CAN_CALC_MAX_ERROR 50 /* in one-tenth of a percent */
    1646     +#define CAN_CALC_SYNC_SEG 1
    1647     +
    1648     +/* Bit-timing calculation derived from:
    1649     + *
    1650     + * Code based on LinCAN sources and H8S2638 project
    1651     + * Copyright 2004-2006 Pavel Pisa - DCE FELK CVUT cz
    1652     + * Copyright 2005 Stanislav Marek
    1653     + * email: pisa@cmp.felk.cvut.cz
    1654     + *
    1655     + * Calculates proper bit-timing parameters for a specified bit-rate
    1656     + * and sample-point, which can then be used to set the bit-timing
    1657     + * registers of the CAN controller. You can find more information
    1658     + * in the header file linux/can/netlink.h.
    1659     + */
    1660     +static int
    1661     +can_update_sample_point(const struct can_bittiming_const *btc,
    1662     + unsigned int sample_point_nominal, unsigned int tseg,
    1663     + unsigned int *tseg1_ptr, unsigned int *tseg2_ptr,
    1664     + unsigned int *sample_point_error_ptr)
    1665     +{
    1666     + unsigned int sample_point_error, best_sample_point_error = UINT_MAX;
    1667     + unsigned int sample_point, best_sample_point = 0;
    1668     + unsigned int tseg1, tseg2;
    1669     + int i;
    1670     +
    1671     + for (i = 0; i <= 1; i++) {
    1672     + tseg2 = tseg + CAN_CALC_SYNC_SEG -
    1673     + (sample_point_nominal * (tseg + CAN_CALC_SYNC_SEG)) /
    1674     + 1000 - i;
    1675     + tseg2 = clamp(tseg2, btc->tseg2_min, btc->tseg2_max);
    1676     + tseg1 = tseg - tseg2;
    1677     + if (tseg1 > btc->tseg1_max) {
    1678     + tseg1 = btc->tseg1_max;
    1679     + tseg2 = tseg - tseg1;
    1680     + }
    1681     +
    1682     + sample_point = 1000 * (tseg + CAN_CALC_SYNC_SEG - tseg2) /
    1683     + (tseg + CAN_CALC_SYNC_SEG);
    1684     + sample_point_error = abs(sample_point_nominal - sample_point);
    1685     +
    1686     + if (sample_point <= sample_point_nominal &&
    1687     + sample_point_error < best_sample_point_error) {
    1688     + best_sample_point = sample_point;
    1689     + best_sample_point_error = sample_point_error;
    1690     + *tseg1_ptr = tseg1;
    1691     + *tseg2_ptr = tseg2;
    1692     + }
    1693     + }
    1694     +
    1695     + if (sample_point_error_ptr)
    1696     + *sample_point_error_ptr = best_sample_point_error;
    1697     +
    1698     + return best_sample_point;
    1699     +}
    1700     +
    1701     +static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt,
    1702     + const struct can_bittiming_const *btc)
    1703     +{
    1704     + struct can_priv *priv = netdev_priv(dev);
    1705     + unsigned int bitrate; /* current bitrate */
    1706     + unsigned int bitrate_error; /* difference between current and nominal value */
    1707     + unsigned int best_bitrate_error = UINT_MAX;
    1708     + unsigned int sample_point_error; /* difference between current and nominal value */
    1709     + unsigned int best_sample_point_error = UINT_MAX;
    1710     + unsigned int sample_point_nominal; /* nominal sample point */
    1711     + unsigned int best_tseg = 0; /* current best value for tseg */
    1712     + unsigned int best_brp = 0; /* current best value for brp */
    1713     + unsigned int brp, tsegall, tseg, tseg1 = 0, tseg2 = 0;
    1714     + u64 v64;
    1715     +
    1716     + /* Use CiA recommended sample points */
    1717     + if (bt->sample_point) {
    1718     + sample_point_nominal = bt->sample_point;
    1719     + } else {
    1720     + if (bt->bitrate > 800000)
    1721     + sample_point_nominal = 750;
    1722     + else if (bt->bitrate > 500000)
    1723     + sample_point_nominal = 800;
    1724     + else
    1725     + sample_point_nominal = 875;
    1726     + }
    1727     +
    1728     + /* tseg even = round down, odd = round up */
    1729     + for (tseg = (btc->tseg1_max + btc->tseg2_max) * 2 + 1;
    1730     + tseg >= (btc->tseg1_min + btc->tseg2_min) * 2; tseg--) {
    1731     + tsegall = CAN_CALC_SYNC_SEG + tseg / 2;
    1732     +
    1733     + /* Compute all possible tseg choices (tseg=tseg1+tseg2) */
    1734     + brp = priv->clock.freq / (tsegall * bt->bitrate) + tseg % 2;
    1735     +
    1736     + /* choose brp step which is possible in system */
    1737     + brp = (brp / btc->brp_inc) * btc->brp_inc;
    1738     + if (brp < btc->brp_min || brp > btc->brp_max)
    1739     + continue;
    1740     +
    1741     + bitrate = priv->clock.freq / (brp * tsegall);
    1742     + bitrate_error = abs(bt->bitrate - bitrate);
    1743     +
    1744     + /* tseg brp biterror */
    1745     + if (bitrate_error > best_bitrate_error)
    1746     + continue;
    1747     +
    1748     + /* reset sample point error if we have a better bitrate */
    1749     + if (bitrate_error < best_bitrate_error)
    1750     + best_sample_point_error = UINT_MAX;
    1751     +
    1752     + can_update_sample_point(btc, sample_point_nominal, tseg / 2,
    1753     + &tseg1, &tseg2, &sample_point_error);
    1754     + if (sample_point_error > best_sample_point_error)
    1755     + continue;
    1756     +
    1757     + best_sample_point_error = sample_point_error;
    1758     + best_bitrate_error = bitrate_error;
    1759     + best_tseg = tseg / 2;
    1760     + best_brp = brp;
    1761     +
    1762     + if (bitrate_error == 0 && sample_point_error == 0)
    1763     + break;
    1764     + }
    1765     +
    1766     + if (best_bitrate_error) {
    1767     + /* Error in one-tenth of a percent */
    1768     + v64 = (u64)best_bitrate_error * 1000;
    1769     + do_div(v64, bt->bitrate);
    1770     + bitrate_error = (u32)v64;
    1771     + if (bitrate_error > CAN_CALC_MAX_ERROR) {
    1772     + netdev_err(dev,
    1773     + "bitrate error %d.%d%% too high\n",
    1774     + bitrate_error / 10, bitrate_error % 10);
    1775     + return -EDOM;
    1776     + }
    1777     + netdev_warn(dev, "bitrate error %d.%d%%\n",
    1778     + bitrate_error / 10, bitrate_error % 10);
    1779     + }
    1780     +
    1781     + /* real sample point */
    1782     + bt->sample_point = can_update_sample_point(btc, sample_point_nominal,
    1783     + best_tseg, &tseg1, &tseg2,
    1784     + NULL);
    1785     +
    1786     + v64 = (u64)best_brp * 1000 * 1000 * 1000;
    1787     + do_div(v64, priv->clock.freq);
    1788     + bt->tq = (u32)v64;
    1789     + bt->prop_seg = tseg1 / 2;
    1790     + bt->phase_seg1 = tseg1 - bt->prop_seg;
    1791     + bt->phase_seg2 = tseg2;
    1792     +
    1793     + /* check for sjw user settings */
    1794     + if (!bt->sjw || !btc->sjw_max) {
    1795     + bt->sjw = 1;
    1796     + } else {
    1797     + /* bt->sjw is at least 1 -> sanitize upper bound to sjw_max */
    1798     + if (bt->sjw > btc->sjw_max)
    1799     + bt->sjw = btc->sjw_max;
    1800     + /* bt->sjw must not be higher than tseg2 */
    1801     + if (tseg2 < bt->sjw)
    1802     + bt->sjw = tseg2;
    1803     + }
    1804     +
    1805     + bt->brp = best_brp;
    1806     +
    1807     + /* real bitrate */
    1808     + bt->bitrate = priv->clock.freq /
    1809     + (bt->brp * (CAN_CALC_SYNC_SEG + tseg1 + tseg2));
    1810     +
    1811     + return 0;
    1812     +}
    1813     +#else /* !CONFIG_CAN_CALC_BITTIMING */
    1814     +static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt,
    1815     + const struct can_bittiming_const *btc)
    1816     +{
    1817     + netdev_err(dev, "bit-timing calculation not available\n");
    1818     + return -EINVAL;
    1819     +}
    1820     +#endif /* CONFIG_CAN_CALC_BITTIMING */
    1821     +
    1822     +/* Checks the validity of the specified bit-timing parameters prop_seg,
    1823     + * phase_seg1, phase_seg2 and sjw and tries to determine the bitrate
    1824     + * prescaler value brp. You can find more information in the header
    1825     + * file linux/can/netlink.h.
    1826     + */
    1827     +static int can_fixup_bittiming(struct net_device *dev, struct can_bittiming *bt,
    1828     + const struct can_bittiming_const *btc)
    1829     +{
    1830     + struct can_priv *priv = netdev_priv(dev);
    1831     + int tseg1, alltseg;
    1832     + u64 brp64;
    1833     +
    1834     + tseg1 = bt->prop_seg + bt->phase_seg1;
    1835     + if (!bt->sjw)
    1836     + bt->sjw = 1;
    1837     + if (bt->sjw > btc->sjw_max ||
    1838     + tseg1 < btc->tseg1_min || tseg1 > btc->tseg1_max ||
    1839     + bt->phase_seg2 < btc->tseg2_min || bt->phase_seg2 > btc->tseg2_max)
    1840     + return -ERANGE;
    1841     +
    1842     + brp64 = (u64)priv->clock.freq * (u64)bt->tq;
    1843     + if (btc->brp_inc > 1)
    1844     + do_div(brp64, btc->brp_inc);
    1845     + brp64 += 500000000UL - 1;
    1846     + do_div(brp64, 1000000000UL); /* the practicable BRP */
    1847     + if (btc->brp_inc > 1)
    1848     + brp64 *= btc->brp_inc;
    1849     + bt->brp = (u32)brp64;
    1850     +
    1851     + if (bt->brp < btc->brp_min || bt->brp > btc->brp_max)
    1852     + return -EINVAL;
    1853     +
    1854     + alltseg = bt->prop_seg + bt->phase_seg1 + bt->phase_seg2 + 1;
    1855     + bt->bitrate = priv->clock.freq / (bt->brp * alltseg);
    1856     + bt->sample_point = ((tseg1 + 1) * 1000) / alltseg;
    1857     +
    1858     + return 0;
    1859     +}
    1860     +
    1861     +/* Checks the validity of predefined bitrate settings */
    1862     +static int
    1863     +can_validate_bitrate(struct net_device *dev, struct can_bittiming *bt,
    1864     + const u32 *bitrate_const,
    1865     + const unsigned int bitrate_const_cnt)
    1866     +{
    1867     + struct can_priv *priv = netdev_priv(dev);
    1868     + unsigned int i;
    1869     +
    1870     + for (i = 0; i < bitrate_const_cnt; i++) {
    1871     + if (bt->bitrate == bitrate_const[i])
    1872     + break;
    1873     + }
    1874     +
    1875     + if (i >= priv->bitrate_const_cnt)
    1876     + return -EINVAL;
    1877     +
    1878     + return 0;
    1879     +}
    1880     +
    1881     +static int can_get_bittiming(struct net_device *dev, struct can_bittiming *bt,
    1882     + const struct can_bittiming_const *btc,
    1883     + const u32 *bitrate_const,
    1884     + const unsigned int bitrate_const_cnt)
    1885     +{
    1886     + int err;
    1887     +
    1888     + /* Depending on the given can_bittiming parameter structure the CAN
    1889     + * timing parameters are calculated based on the provided bitrate OR
    1890     + * alternatively the CAN timing parameters (tq, prop_seg, etc.) are
    1891     + * provided directly which are then checked and fixed up.
    1892     + */
    1893     + if (!bt->tq && bt->bitrate && btc)
    1894     + err = can_calc_bittiming(dev, bt, btc);
    1895     + else if (bt->tq && !bt->bitrate && btc)
    1896     + err = can_fixup_bittiming(dev, bt, btc);
    1897     + else if (!bt->tq && bt->bitrate && bitrate_const)
    1898     + err = can_validate_bitrate(dev, bt, bitrate_const,
    1899     + bitrate_const_cnt);
    1900     + else
    1901     + err = -EINVAL;
    1902     +
    1903     + return err;
    1904     +}
    1905     +
    1906     +static void can_update_state_error_stats(struct net_device *dev,
    1907     + enum can_state new_state)
    1908     +{
    1909     + struct can_priv *priv = netdev_priv(dev);
    1910     +
    1911     + if (new_state <= priv->state)
    1912     + return;
    1913     +
    1914     + switch (new_state) {
    1915     + case CAN_STATE_ERROR_WARNING:
    1916     + priv->can_stats.error_warning++;
    1917     + break;
    1918     + case CAN_STATE_ERROR_PASSIVE:
    1919     + priv->can_stats.error_passive++;
    1920     + break;
    1921     + case CAN_STATE_BUS_OFF:
    1922     + priv->can_stats.bus_off++;
    1923     + break;
    1924     + default:
    1925     + break;
    1926     + }
    1927     +}
    1928     +
    1929     +static int can_tx_state_to_frame(struct net_device *dev, enum can_state state)
    1930     +{
    1931     + switch (state) {
    1932     + case CAN_STATE_ERROR_ACTIVE:
    1933     + return CAN_ERR_CRTL_ACTIVE;
    1934     + case CAN_STATE_ERROR_WARNING:
    1935     + return CAN_ERR_CRTL_TX_WARNING;
    1936     + case CAN_STATE_ERROR_PASSIVE:
    1937     + return CAN_ERR_CRTL_TX_PASSIVE;
    1938     + default:
    1939     + return 0;
    1940     + }
    1941     +}
    1942     +
    1943     +static int can_rx_state_to_frame(struct net_device *dev, enum can_state state)
    1944     +{
    1945     + switch (state) {
    1946     + case CAN_STATE_ERROR_ACTIVE:
    1947     + return CAN_ERR_CRTL_ACTIVE;
    1948     + case CAN_STATE_ERROR_WARNING:
    1949     + return CAN_ERR_CRTL_RX_WARNING;
    1950     + case CAN_STATE_ERROR_PASSIVE:
    1951     + return CAN_ERR_CRTL_RX_PASSIVE;
    1952     + default:
    1953     + return 0;
    1954     + }
    1955     +}
    1956     +
    1957     +void can_change_state(struct net_device *dev, struct can_frame *cf,
    1958     + enum can_state tx_state, enum can_state rx_state)
    1959     +{
    1960     + struct can_priv *priv = netdev_priv(dev);
    1961     + enum can_state new_state = max(tx_state, rx_state);
    1962     +
    1963     + if (unlikely(new_state == priv->state)) {
    1964     + netdev_warn(dev, "%s: oops, state did not change", __func__);
    1965     + return;
    1966     + }
    1967     +
    1968     + netdev_dbg(dev, "New error state: %d\n", new_state);
    1969     +
    1970     + can_update_state_error_stats(dev, new_state);
    1971     + priv->state = new_state;
    1972     +
    1973     + if (!cf)
    1974     + return;
    1975     +
    1976     + if (unlikely(new_state == CAN_STATE_BUS_OFF)) {
    1977     + cf->can_id |= CAN_ERR_BUSOFF;
    1978     + return;
    1979     + }
    1980     +
    1981     + cf->can_id |= CAN_ERR_CRTL;
    1982     + cf->data[1] |= tx_state >= rx_state ?
    1983     + can_tx_state_to_frame(dev, tx_state) : 0;
    1984     + cf->data[1] |= tx_state <= rx_state ?
    1985     + can_rx_state_to_frame(dev, rx_state) : 0;
    1986     +}
    1987     +EXPORT_SYMBOL_GPL(can_change_state);
    1988     +
    1989     +/* Local echo of CAN messages
    1990     + *
    1991     + * CAN network devices *should* support a local echo functionality
    1992     + * (see Documentation/networking/can.rst). To test the handling of CAN
    1993     + * interfaces that do not support the local echo both driver types are
    1994     + * implemented. In the case that the driver does not support the echo
    1995     + * the IFF_ECHO remains clear in dev->flags. This causes the PF_CAN core
    1996     + * to perform the echo as a fallback solution.
    1997     + */
    1998     +static void can_flush_echo_skb(struct net_device *dev)
    1999     +{
    2000     + struct can_priv *priv = netdev_priv(dev);
    2001     + struct net_device_stats *stats = &dev->stats;
    2002     + int i;
    2003     +
    2004     + for (i = 0; i < priv->echo_skb_max; i++) {
    2005     + if (priv->echo_skb[i]) {
    2006     + kfree_skb(priv->echo_skb[i]);
    2007     + priv->echo_skb[i] = NULL;
    2008     + stats->tx_dropped++;
    2009     + stats->tx_aborted_errors++;
    2010     + }
    2011     + }
    2012     +}
    2013     +
    2014     +/* Put the skb on the stack to be looped backed locally lateron
    2015     + *
    2016     + * The function is typically called in the start_xmit function
    2017     + * of the device driver. The driver must protect access to
    2018     + * priv->echo_skb, if necessary.
    2019     + */
    2020     +void can_put_echo_skb(struct sk_buff *skb, struct net_device *dev,
    2021     + unsigned int idx)
    2022     +{
    2023     + struct can_priv *priv = netdev_priv(dev);
    2024     +
    2025     + BUG_ON(idx >= priv->echo_skb_max);
    2026     +
    2027     + /* check flag whether this packet has to be looped back */
    2028     + if (!(dev->flags & IFF_ECHO) || skb->pkt_type != PACKET_LOOPBACK ||
    2029     + (skb->protocol != htons(ETH_P_CAN) &&
    2030     + skb->protocol != htons(ETH_P_CANFD))) {
    2031     + kfree_skb(skb);
    2032     + return;
    2033     + }
    2034     +
    2035     + if (!priv->echo_skb[idx]) {
    2036     + skb = can_create_echo_skb(skb);
    2037     + if (!skb)
    2038     + return;
    2039     +
    2040     + /* make settings for echo to reduce code in irq context */
    2041     + skb->pkt_type = PACKET_BROADCAST;
    2042     + skb->ip_summed = CHECKSUM_UNNECESSARY;
    2043     + skb->dev = dev;
    2044     +
    2045     + /* save this skb for tx interrupt echo handling */
    2046     + priv->echo_skb[idx] = skb;
    2047     + } else {
    2048     + /* locking problem with netif_stop_queue() ?? */
    2049     + netdev_err(dev, "%s: BUG! echo_skb is occupied!\n", __func__);
    2050     + kfree_skb(skb);
    2051     + }
    2052     +}
    2053     +EXPORT_SYMBOL_GPL(can_put_echo_skb);
    2054     +
    2055     +struct sk_buff *
    2056     +__can_get_echo_skb(struct net_device *dev, unsigned int idx, u8 *len_ptr)
    2057     +{
    2058     + struct can_priv *priv = netdev_priv(dev);
    2059     +
    2060     + if (idx >= priv->echo_skb_max) {
    2061     + netdev_err(dev, "%s: BUG! Trying to access can_priv::echo_skb out of bounds (%u/max %u)\n",
    2062     + __func__, idx, priv->echo_skb_max);
    2063     + return NULL;
    2064     + }
    2065     +
    2066     + if (priv->echo_skb[idx]) {
    2067     + /* Using "struct canfd_frame::len" for the frame
    2068     + * length is supported on both CAN and CANFD frames.
    2069     + */
    2070     + struct sk_buff *skb = priv->echo_skb[idx];
    2071     + struct canfd_frame *cf = (struct canfd_frame *)skb->data;
    2072     +
    2073     + /* get the real payload length for netdev statistics */
    2074     + if (cf->can_id & CAN_RTR_FLAG)
    2075     + *len_ptr = 0;
    2076     + else
    2077     + *len_ptr = cf->len;
    2078     +
    2079     + priv->echo_skb[idx] = NULL;
    2080     +
    2081     + return skb;
    2082     + }
    2083     +
    2084     + return NULL;
    2085     +}
    2086     +
    2087     +/* Get the skb from the stack and loop it back locally
    2088     + *
    2089     + * The function is typically called when the TX done interrupt
    2090     + * is handled in the device driver. The driver must protect
    2091     + * access to priv->echo_skb, if necessary.
    2092     + */
    2093     +unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx)
    2094     +{
    2095     + struct sk_buff *skb;
    2096     + u8 len;
    2097     +
    2098     + skb = __can_get_echo_skb(dev, idx, &len);
    2099     + if (!skb)
    2100     + return 0;
    2101     +
    2102     + skb_get(skb);
    2103     + if (netif_rx(skb) == NET_RX_SUCCESS)
    2104     + dev_consume_skb_any(skb);
    2105     + else
    2106     + dev_kfree_skb_any(skb);
    2107     +
    2108     + return len;
    2109     +}
    2110     +EXPORT_SYMBOL_GPL(can_get_echo_skb);
    2111     +
    2112     +/* Remove the skb from the stack and free it.
    2113     + *
    2114     + * The function is typically called when TX failed.
    2115     + */
    2116     +void can_free_echo_skb(struct net_device *dev, unsigned int idx)
    2117     +{
    2118     + struct can_priv *priv = netdev_priv(dev);
    2119     +
    2120     + BUG_ON(idx >= priv->echo_skb_max);
    2121     +
    2122     + if (priv->echo_skb[idx]) {
    2123     + dev_kfree_skb_any(priv->echo_skb[idx]);
    2124     + priv->echo_skb[idx] = NULL;
    2125     + }
    2126     +}
    2127     +EXPORT_SYMBOL_GPL(can_free_echo_skb);
    2128     +
    2129     +/* CAN device restart for bus-off recovery */
    2130     +static void can_restart(struct net_device *dev)
    2131     +{
    2132     + struct can_priv *priv = netdev_priv(dev);
    2133     + struct net_device_stats *stats = &dev->stats;
    2134     + struct sk_buff *skb;
    2135     + struct can_frame *cf;
    2136     + int err;
    2137     +
    2138     + BUG_ON(netif_carrier_ok(dev));
    2139     +
    2140     + /* No synchronization needed because the device is bus-off and
    2141     + * no messages can come in or go out.
    2142     + */
    2143     + can_flush_echo_skb(dev);
    2144     +
    2145     + /* send restart message upstream */
    2146     + skb = alloc_can_err_skb(dev, &cf);
    2147     + if (!skb) {
    2148     + err = -ENOMEM;
    2149     + goto restart;
    2150     + }
    2151     + cf->can_id |= CAN_ERR_RESTARTED;
    2152     +
    2153     + stats->rx_packets++;
    2154     + stats->rx_bytes += cf->can_dlc;
    2155     +
    2156     + netif_rx_ni(skb);
    2157     +
    2158     +restart:
    2159     + netdev_dbg(dev, "restarted\n");
    2160     + priv->can_stats.restarts++;
    2161     +
    2162     + /* Now restart the device */
    2163     + err = priv->do_set_mode(dev, CAN_MODE_START);
    2164     +
    2165     + netif_carrier_on(dev);
    2166     + if (err)
    2167     + netdev_err(dev, "Error %d during restart", err);
    2168     +}
    2169     +
    2170     +static void can_restart_work(struct work_struct *work)
    2171     +{
    2172     + struct delayed_work *dwork = to_delayed_work(work);
    2173     + struct can_priv *priv = container_of(dwork, struct can_priv,
    2174     + restart_work);
    2175     +
    2176     + can_restart(priv->dev);
    2177     +}
    2178     +
    2179     +int can_restart_now(struct net_device *dev)
    2180     +{
    2181     + struct can_priv *priv = netdev_priv(dev);
    2182     +
    2183     + /* A manual restart is only permitted if automatic restart is
    2184     + * disabled and the device is in the bus-off state
    2185     + */
    2186     + if (priv->restart_ms)
    2187     + return -EINVAL;
    2188     + if (priv->state != CAN_STATE_BUS_OFF)
    2189     + return -EBUSY;
    2190     +
    2191     + cancel_delayed_work_sync(&priv->restart_work);
    2192     + can_restart(dev);
    2193     +
    2194     + return 0;
    2195     +}
    2196     +
    2197     +/* CAN bus-off
    2198     + *
    2199     + * This functions should be called when the device goes bus-off to
    2200     + * tell the netif layer that no more packets can be sent or received.
    2201     + * If enabled, a timer is started to trigger bus-off recovery.
    2202     + */
    2203     +void can_bus_off(struct net_device *dev)
    2204     +{
    2205     + struct can_priv *priv = netdev_priv(dev);
    2206     +
    2207     + netdev_info(dev, "bus-off\n");
    2208     +
    2209     + netif_carrier_off(dev);
    2210     +
    2211     + if (priv->restart_ms)
    2212     + schedule_delayed_work(&priv->restart_work,
    2213     + msecs_to_jiffies(priv->restart_ms));
    2214     +}
    2215     +EXPORT_SYMBOL_GPL(can_bus_off);
    2216     +
    2217     +static void can_setup(struct net_device *dev)
    2218     +{
    2219     + dev->type = ARPHRD_CAN;
    2220     + dev->mtu = CAN_MTU;
    2221     + dev->hard_header_len = 0;
    2222     + dev->addr_len = 0;
    2223     + dev->tx_queue_len = 10;
    2224     +
    2225     + /* New-style flags. */
    2226     + dev->flags = IFF_NOARP;
    2227     + dev->features = NETIF_F_HW_CSUM;
    2228     +}
    2229     +
    2230     +struct sk_buff *alloc_can_skb(struct net_device *dev, struct can_frame **cf)
    2231     +{
    2232     + struct sk_buff *skb;
    2233     +
    2234     + skb = netdev_alloc_skb(dev, sizeof(struct can_skb_priv) +
    2235     + sizeof(struct can_frame));
    2236     + if (unlikely(!skb))
    2237     + return NULL;
    2238     +
    2239     + skb->protocol = htons(ETH_P_CAN);
    2240     + skb->pkt_type = PACKET_BROADCAST;
    2241     + skb->ip_summed = CHECKSUM_UNNECESSARY;
    2242     +
    2243     + skb_reset_mac_header(skb);
    2244     + skb_reset_network_header(skb);
    2245     + skb_reset_transport_header(skb);
    2246     +
    2247     + can_skb_reserve(skb);
    2248     + can_skb_prv(skb)->ifindex = dev->ifindex;
    2249     + can_skb_prv(skb)->skbcnt = 0;
    2250     +
    2251     + *cf = skb_put_zero(skb, sizeof(struct can_frame));
    2252     +
    2253     + return skb;
    2254     +}
    2255     +EXPORT_SYMBOL_GPL(alloc_can_skb);
    2256     +
    2257     +struct sk_buff *alloc_canfd_skb(struct net_device *dev,
    2258     + struct canfd_frame **cfd)
    2259     +{
    2260     + struct sk_buff *skb;
    2261     +
    2262     + skb = netdev_alloc_skb(dev, sizeof(struct can_skb_priv) +
    2263     + sizeof(struct canfd_frame));
    2264     + if (unlikely(!skb))
    2265     + return NULL;
    2266     +
    2267     + skb->protocol = htons(ETH_P_CANFD);
    2268     + skb->pkt_type = PACKET_BROADCAST;
    2269     + skb->ip_summed = CHECKSUM_UNNECESSARY;
    2270     +
    2271     + skb_reset_mac_header(skb);
    2272     + skb_reset_network_header(skb);
    2273     + skb_reset_transport_header(skb);
    2274     +
    2275     + can_skb_reserve(skb);
    2276     + can_skb_prv(skb)->ifindex = dev->ifindex;
    2277     + can_skb_prv(skb)->skbcnt = 0;
    2278     +
    2279     + *cfd = skb_put_zero(skb, sizeof(struct canfd_frame));
    2280     +
    2281     + return skb;
    2282     +}
    2283     +EXPORT_SYMBOL_GPL(alloc_canfd_skb);
    2284     +
    2285     +struct sk_buff *alloc_can_err_skb(struct net_device *dev, struct can_frame **cf)
    2286     +{
    2287     + struct sk_buff *skb;
    2288     +
    2289     + skb = alloc_can_skb(dev, cf);
    2290     + if (unlikely(!skb))
    2291     + return NULL;
    2292     +
    2293     + (*cf)->can_id = CAN_ERR_FLAG;
    2294     + (*cf)->can_dlc = CAN_ERR_DLC;
    2295     +
    2296     + return skb;
    2297     +}
    2298     +EXPORT_SYMBOL_GPL(alloc_can_err_skb);
    2299     +
    2300     +/* Allocate and setup space for the CAN network device */
    2301     +struct net_device *alloc_candev_mqs(int sizeof_priv, unsigned int echo_skb_max,
    2302     + unsigned int txqs, unsigned int rxqs)
    2303     +{
    2304     + struct can_ml_priv *can_ml;
    2305     + struct net_device *dev;
    2306     + struct can_priv *priv;
    2307     + int size;
    2308     +
    2309     + /* We put the driver's priv, the CAN mid layer priv and the
    2310     + * echo skb into the netdevice's priv. The memory layout for
    2311     + * the netdev_priv is like this:
    2312     + *
    2313     + * +-------------------------+
    2314     + * | driver's priv |
    2315     + * +-------------------------+
    2316     + * | struct can_ml_priv |
    2317     + * +-------------------------+
    2318     + * | array of struct sk_buff |
    2319     + * +-------------------------+
    2320     + */
    2321     +
    2322     + size = ALIGN(sizeof_priv, NETDEV_ALIGN) + sizeof(struct can_ml_priv);
    2323     +
    2324     + if (echo_skb_max)
    2325     + size = ALIGN(size, sizeof(struct sk_buff *)) +
    2326     + echo_skb_max * sizeof(struct sk_buff *);
    2327     +
    2328     + dev = alloc_netdev_mqs(size, "can%d", NET_NAME_UNKNOWN, can_setup,
    2329     + txqs, rxqs);
    2330     + if (!dev)
    2331     + return NULL;
    2332     +
    2333     + priv = netdev_priv(dev);
    2334     + priv->dev = dev;
    2335     +
    2336     + can_ml = (void *)priv + ALIGN(sizeof_priv, NETDEV_ALIGN);
    2337     + can_set_ml_priv(dev, can_ml);
    2338     +
    2339     + if (echo_skb_max) {
    2340     + priv->echo_skb_max = echo_skb_max;
    2341     + priv->echo_skb = (void *)priv +
    2342     + (size - echo_skb_max * sizeof(struct sk_buff *));
    2343     + }
    2344     +
    2345     + priv->state = CAN_STATE_STOPPED;
    2346     +
    2347     + INIT_DELAYED_WORK(&priv->restart_work, can_restart_work);
    2348     +
    2349     + return dev;
    2350     +}
    2351     +EXPORT_SYMBOL_GPL(alloc_candev_mqs);
    2352     +
    2353     +/* Free space of the CAN network device */
    2354     +void free_candev(struct net_device *dev)
    2355     +{
    2356     + free_netdev(dev);
    2357     +}
    2358     +EXPORT_SYMBOL_GPL(free_candev);
    2359     +
    2360     +/* changing MTU and control mode for CAN/CANFD devices */
    2361     +int can_change_mtu(struct net_device *dev, int new_mtu)
    2362     +{
    2363     + struct can_priv *priv = netdev_priv(dev);
    2364     +
    2365     + /* Do not allow changing the MTU while running */
    2366     + if (dev->flags & IFF_UP)
    2367     + return -EBUSY;
    2368     +
    2369     + /* allow change of MTU according to the CANFD ability of the device */
    2370     + switch (new_mtu) {
    2371     + case CAN_MTU:
    2372     + /* 'CANFD-only' controllers can not switch to CAN_MTU */
    2373     + if (priv->ctrlmode_static & CAN_CTRLMODE_FD)
    2374     + return -EINVAL;
    2375     +
    2376     + priv->ctrlmode &= ~CAN_CTRLMODE_FD;
    2377     + break;
    2378     +
    2379     + case CANFD_MTU:
    2380     + /* check for potential CANFD ability */
    2381     + if (!(priv->ctrlmode_supported & CAN_CTRLMODE_FD) &&
    2382     + !(priv->ctrlmode_static & CAN_CTRLMODE_FD))
    2383     + return -EINVAL;
    2384     +
    2385     + priv->ctrlmode |= CAN_CTRLMODE_FD;
    2386     + break;
    2387     +
    2388     + default:
    2389     + return -EINVAL;
    2390     + }
    2391     +
    2392     + dev->mtu = new_mtu;
    2393     + return 0;
    2394     +}
    2395     +EXPORT_SYMBOL_GPL(can_change_mtu);
    2396     +
    2397     +/* Common open function when the device gets opened.
    2398     + *
    2399     + * This function should be called in the open function of the device
    2400     + * driver.
    2401     + */
    2402     +int open_candev(struct net_device *dev)
    2403     +{
    2404     + struct can_priv *priv = netdev_priv(dev);
    2405     +
    2406     + if (!priv->bittiming.bitrate) {
    2407     + netdev_err(dev, "bit-timing not yet defined\n");
    2408     + return -EINVAL;
    2409     + }
    2410     +
    2411     + /* For CAN FD the data bitrate has to be >= the arbitration bitrate */
    2412     + if ((priv->ctrlmode & CAN_CTRLMODE_FD) &&
    2413     + (!priv->data_bittiming.bitrate ||
    2414     + priv->data_bittiming.bitrate < priv->bittiming.bitrate)) {
    2415     + netdev_err(dev, "incorrect/missing data bit-timing\n");
    2416     + return -EINVAL;
    2417     + }
    2418     +
    2419     + /* Switch carrier on if device was stopped while in bus-off state */
    2420     + if (!netif_carrier_ok(dev))
    2421     + netif_carrier_on(dev);
    2422     +
    2423     + return 0;
    2424     +}
    2425     +EXPORT_SYMBOL_GPL(open_candev);
    2426     +
    2427     +#ifdef CONFIG_OF
    2428     +/* Common function that can be used to understand the limitation of
    2429     + * a transceiver when it provides no means to determine these limitations
    2430     + * at runtime.
    2431     + */
    2432     +void of_can_transceiver(struct net_device *dev)
    2433     +{
    2434     + struct device_node *dn;
    2435     + struct can_priv *priv = netdev_priv(dev);
    2436     + struct device_node *np = dev->dev.parent->of_node;
    2437     + int ret;
    2438     +
    2439     + dn = of_get_child_by_name(np, "can-transceiver");
    2440     + if (!dn)
    2441     + return;
    2442     +
    2443     + ret = of_property_read_u32(dn, "max-bitrate", &priv->bitrate_max);
    2444     + of_node_put(dn);
    2445     + if ((ret && ret != -EINVAL) || (!ret && !priv->bitrate_max))
    2446     + netdev_warn(dev, "Invalid value for transceiver max bitrate. Ignoring bitrate limit.\n");
    2447     +}
    2448     +EXPORT_SYMBOL_GPL(of_can_transceiver);
    2449     +#endif
    2450     +
    2451     +/* Common close function for cleanup before the device gets closed.
    2452     + *
    2453     + * This function should be called in the close function of the device
    2454     + * driver.
    2455     + */
    2456     +void close_candev(struct net_device *dev)
    2457     +{
    2458     + struct can_priv *priv = netdev_priv(dev);
    2459     +
    2460     + cancel_delayed_work_sync(&priv->restart_work);
    2461     + can_flush_echo_skb(dev);
    2462     +}
    2463     +EXPORT_SYMBOL_GPL(close_candev);
    2464     +
    2465     +/* CAN netlink interface */
    2466     +static const struct nla_policy can_policy[IFLA_CAN_MAX + 1] = {
    2467     + [IFLA_CAN_STATE] = { .type = NLA_U32 },
    2468     + [IFLA_CAN_CTRLMODE] = { .len = sizeof(struct can_ctrlmode) },
    2469     + [IFLA_CAN_RESTART_MS] = { .type = NLA_U32 },
    2470     + [IFLA_CAN_RESTART] = { .type = NLA_U32 },
    2471     + [IFLA_CAN_BITTIMING] = { .len = sizeof(struct can_bittiming) },
    2472     + [IFLA_CAN_BITTIMING_CONST]
    2473     + = { .len = sizeof(struct can_bittiming_const) },
    2474     + [IFLA_CAN_CLOCK] = { .len = sizeof(struct can_clock) },
    2475     + [IFLA_CAN_BERR_COUNTER] = { .len = sizeof(struct can_berr_counter) },
    2476     + [IFLA_CAN_DATA_BITTIMING]
    2477     + = { .len = sizeof(struct can_bittiming) },
    2478     + [IFLA_CAN_DATA_BITTIMING_CONST]
    2479     + = { .len = sizeof(struct can_bittiming_const) },
    2480     + [IFLA_CAN_TERMINATION] = { .type = NLA_U16 },
    2481     +};
    2482     +
    2483     +static int can_validate(struct nlattr *tb[], struct nlattr *data[],
    2484     + struct netlink_ext_ack *extack)
    2485     +{
    2486     + bool is_can_fd = false;
    2487     +
    2488     + /* Make sure that valid CAN FD configurations always consist of
    2489     + * - nominal/arbitration bittiming
    2490     + * - data bittiming
    2491     + * - control mode with CAN_CTRLMODE_FD set
    2492     + */
    2493     +
    2494     + if (!data)
    2495     + return 0;
    2496     +
    2497     + if (data[IFLA_CAN_CTRLMODE]) {
    2498     + struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]);
    2499     +
    2500     + is_can_fd = cm->flags & cm->mask & CAN_CTRLMODE_FD;
    2501     + }
    2502     +
    2503     + if (is_can_fd) {
    2504     + if (!data[IFLA_CAN_BITTIMING] || !data[IFLA_CAN_DATA_BITTIMING])
    2505     + return -EOPNOTSUPP;
    2506     + }
    2507     +
    2508     + if (data[IFLA_CAN_DATA_BITTIMING]) {
    2509     + if (!is_can_fd || !data[IFLA_CAN_BITTIMING])
    2510     + return -EOPNOTSUPP;
    2511     + }
    2512     +
    2513     + return 0;
    2514     +}
    2515     +
    2516     +static int can_changelink(struct net_device *dev, struct nlattr *tb[],
    2517     + struct nlattr *data[],
    2518     + struct netlink_ext_ack *extack)
    2519     +{
    2520     + struct can_priv *priv = netdev_priv(dev);
    2521     + int err;
    2522     +
    2523     + /* We need synchronization with dev->stop() */
    2524     + ASSERT_RTNL();
    2525     +
    2526     + if (data[IFLA_CAN_BITTIMING]) {
    2527     + struct can_bittiming bt;
    2528     +
    2529     + /* Do not allow changing bittiming while running */
    2530     + if (dev->flags & IFF_UP)
    2531     + return -EBUSY;
    2532     +
    2533     + /* Calculate bittiming parameters based on
    2534     + * bittiming_const if set, otherwise pass bitrate
    2535     + * directly via do_set_bitrate(). Bail out if neither
    2536     + * is given.
    2537     + */
    2538     + if (!priv->bittiming_const && !priv->do_set_bittiming)
    2539     + return -EOPNOTSUPP;
    2540     +
    2541     + memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt));
    2542     + err = can_get_bittiming(dev, &bt,
    2543     + priv->bittiming_const,
    2544     + priv->bitrate_const,
    2545     + priv->bitrate_const_cnt);
    2546     + if (err)
    2547     + return err;
    2548     +
    2549     + if (priv->bitrate_max && bt.bitrate > priv->bitrate_max) {
    2550     + netdev_err(dev, "arbitration bitrate surpasses transceiver capabilities of %d bps\n",
    2551     + priv->bitrate_max);
    2552     + return -EINVAL;
    2553     + }
    2554     +
    2555     + memcpy(&priv->bittiming, &bt, sizeof(bt));
    2556     +
    2557     + if (priv->do_set_bittiming) {
    2558     + /* Finally, set the bit-timing registers */
    2559     + err = priv->do_set_bittiming(dev);
    2560     + if (err)
    2561     + return err;
    2562     + }
    2563     + }
    2564     +
    2565     + if (data[IFLA_CAN_CTRLMODE]) {
    2566     + struct can_ctrlmode *cm;
    2567     + u32 ctrlstatic;
    2568     + u32 maskedflags;
    2569     +
    2570     + /* Do not allow changing controller mode while running */
    2571     + if (dev->flags & IFF_UP)
    2572     + return -EBUSY;
    2573     + cm = nla_data(data[IFLA_CAN_CTRLMODE]);
    2574     + ctrlstatic = priv->ctrlmode_static;
    2575     + maskedflags = cm->flags & cm->mask;
    2576     +
    2577     + /* check whether provided bits are allowed to be passed */
    2578     + if (cm->mask & ~(priv->ctrlmode_supported | ctrlstatic))
    2579     + return -EOPNOTSUPP;
    2580     +
    2581     + /* do not check for static fd-non-iso if 'fd' is disabled */
    2582     + if (!(maskedflags & CAN_CTRLMODE_FD))
    2583     + ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO;
    2584     +
    2585     + /* make sure static options are provided by configuration */
    2586     + if ((maskedflags & ctrlstatic) != ctrlstatic)
    2587     + return -EOPNOTSUPP;
    2588     +
    2589     + /* clear bits to be modified and copy the flag values */
    2590     + priv->ctrlmode &= ~cm->mask;
    2591     + priv->ctrlmode |= maskedflags;
    2592     +
    2593     + /* CAN_CTRLMODE_FD can only be set when driver supports FD */
    2594     + if (priv->ctrlmode & CAN_CTRLMODE_FD)
    2595     + dev->mtu = CANFD_MTU;
    2596     + else
    2597     + dev->mtu = CAN_MTU;
    2598     + }
    2599     +
    2600     + if (data[IFLA_CAN_RESTART_MS]) {
    2601     + /* Do not allow changing restart delay while running */
    2602     + if (dev->flags & IFF_UP)
    2603     + return -EBUSY;
    2604     + priv->restart_ms = nla_get_u32(data[IFLA_CAN_RESTART_MS]);
    2605     + }
    2606     +
    2607     + if (data[IFLA_CAN_RESTART]) {
    2608     + /* Do not allow a restart while not running */
    2609     + if (!(dev->flags & IFF_UP))
    2610     + return -EINVAL;
    2611     + err = can_restart_now(dev);
    2612     + if (err)
    2613     + return err;
    2614     + }
    2615     +
    2616     + if (data[IFLA_CAN_DATA_BITTIMING]) {
    2617     + struct can_bittiming dbt;
    2618     +
    2619     + /* Do not allow changing bittiming while running */
    2620     + if (dev->flags & IFF_UP)
    2621     + return -EBUSY;
    2622     +
    2623     + /* Calculate bittiming parameters based on
    2624     + * data_bittiming_const if set, otherwise pass bitrate
    2625     + * directly via do_set_bitrate(). Bail out if neither
    2626     + * is given.
    2627     + */
    2628     + if (!priv->data_bittiming_const && !priv->do_set_data_bittiming)
    2629     + return -EOPNOTSUPP;
    2630     +
    2631     + memcpy(&dbt, nla_data(data[IFLA_CAN_DATA_BITTIMING]),
    2632     + sizeof(dbt));
    2633     + err = can_get_bittiming(dev, &dbt,
    2634     + priv->data_bittiming_const,
    2635     + priv->data_bitrate_const,
    2636     + priv->data_bitrate_const_cnt);
    2637     + if (err)
    2638     + return err;
    2639     +
    2640     + if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) {
    2641     + netdev_err(dev, "canfd data bitrate surpasses transceiver capabilities of %d bps\n",
    2642     + priv->bitrate_max);
    2643     + return -EINVAL;
    2644     + }
    2645     +
    2646     + memcpy(&priv->data_bittiming, &dbt, sizeof(dbt));
    2647     +
    2648     + if (priv->do_set_data_bittiming) {
    2649     + /* Finally, set the bit-timing registers */
    2650     + err = priv->do_set_data_bittiming(dev);
    2651     + if (err)
    2652     + return err;
    2653     + }
    2654     + }
    2655     +
    2656     + if (data[IFLA_CAN_TERMINATION]) {
    2657     + const u16 termval = nla_get_u16(data[IFLA_CAN_TERMINATION]);
    2658     + const unsigned int num_term = priv->termination_const_cnt;
    2659     + unsigned int i;
    2660     +
    2661     + if (!priv->do_set_termination)
    2662     + return -EOPNOTSUPP;
    2663     +
    2664     + /* check whether given value is supported by the interface */
    2665     + for (i = 0; i < num_term; i++) {
    2666     + if (termval == priv->termination_const[i])
    2667     + break;
    2668     + }
    2669     + if (i >= num_term)
    2670     + return -EINVAL;
    2671     +
    2672     + /* Finally, set the termination value */
    2673     + err = priv->do_set_termination(dev, termval);
    2674     + if (err)
    2675     + return err;
    2676     +
    2677     + priv->termination = termval;
    2678     + }
    2679     +
    2680     + return 0;
    2681     +}
    2682     +
    2683     +static size_t can_get_size(const struct net_device *dev)
    2684     +{
    2685     + struct can_priv *priv = netdev_priv(dev);
    2686     + size_t size = 0;
    2687     +
    2688     + if (priv->bittiming.bitrate) /* IFLA_CAN_BITTIMING */
    2689     + size += nla_total_size(sizeof(struct can_bittiming));
    2690     + if (priv->bittiming_const) /* IFLA_CAN_BITTIMING_CONST */
    2691     + size += nla_total_size(sizeof(struct can_bittiming_const));
    2692     + size += nla_total_size(sizeof(struct can_clock)); /* IFLA_CAN_CLOCK */
    2693     + size += nla_total_size(sizeof(u32)); /* IFLA_CAN_STATE */
    2694     + size += nla_total_size(sizeof(struct can_ctrlmode)); /* IFLA_CAN_CTRLMODE */
    2695     + size += nla_total_size(sizeof(u32)); /* IFLA_CAN_RESTART_MS */
    2696     + if (priv->do_get_berr_counter) /* IFLA_CAN_BERR_COUNTER */
    2697     + size += nla_total_size(sizeof(struct can_berr_counter));
    2698     + if (priv->data_bittiming.bitrate) /* IFLA_CAN_DATA_BITTIMING */
    2699     + size += nla_total_size(sizeof(struct can_bittiming));
    2700     + if (priv->data_bittiming_const) /* IFLA_CAN_DATA_BITTIMING_CONST */
    2701     + size += nla_total_size(sizeof(struct can_bittiming_const));
    2702     + if (priv->termination_const) {
    2703     + size += nla_total_size(sizeof(priv->termination)); /* IFLA_CAN_TERMINATION */
    2704     + size += nla_total_size(sizeof(*priv->termination_const) * /* IFLA_CAN_TERMINATION_CONST */
    2705     + priv->termination_const_cnt);
    2706     + }
    2707     + if (priv->bitrate_const) /* IFLA_CAN_BITRATE_CONST */
    2708     + size += nla_total_size(sizeof(*priv->bitrate_const) *
    2709     + priv->bitrate_const_cnt);
    2710     + if (priv->data_bitrate_const) /* IFLA_CAN_DATA_BITRATE_CONST */
    2711     + size += nla_total_size(sizeof(*priv->data_bitrate_const) *
    2712     + priv->data_bitrate_const_cnt);
    2713     + size += sizeof(priv->bitrate_max); /* IFLA_CAN_BITRATE_MAX */
    2714     +
    2715     + return size;
    2716     +}
    2717     +
    2718     +static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)
    2719     +{
    2720     + struct can_priv *priv = netdev_priv(dev);
    2721     + struct can_ctrlmode cm = {.flags = priv->ctrlmode};
    2722     + struct can_berr_counter bec = { };
    2723     + enum can_state state = priv->state;
    2724     +
    2725     + if (priv->do_get_state)
    2726     + priv->do_get_state(dev, &state);
    2727     +
    2728     + if ((priv->bittiming.bitrate &&
    2729     + nla_put(skb, IFLA_CAN_BITTIMING,
    2730     + sizeof(priv->bittiming), &priv->bittiming)) ||
    2731     +
    2732     + (priv->bittiming_const &&
    2733     + nla_put(skb, IFLA_CAN_BITTIMING_CONST,
    2734     + sizeof(*priv->bittiming_const), priv->bittiming_const)) ||
    2735     +
    2736     + nla_put(skb, IFLA_CAN_CLOCK, sizeof(priv->clock), &priv->clock) ||
    2737     + nla_put_u32(skb, IFLA_CAN_STATE, state) ||
    2738     + nla_put(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm) ||
    2739     + nla_put_u32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms) ||
    2740     +
    2741     + (priv->do_get_berr_counter &&
    2742     + !priv->do_get_berr_counter(dev, &bec) &&
    2743     + nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) ||
    2744     +
    2745     + (priv->data_bittiming.bitrate &&
    2746     + nla_put(skb, IFLA_CAN_DATA_BITTIMING,
    2747     + sizeof(priv->data_bittiming), &priv->data_bittiming)) ||
    2748     +
    2749     + (priv->data_bittiming_const &&
    2750     + nla_put(skb, IFLA_CAN_DATA_BITTIMING_CONST,
    2751     + sizeof(*priv->data_bittiming_const),
    2752     + priv->data_bittiming_const)) ||
    2753     +
    2754     + (priv->termination_const &&
    2755     + (nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) ||
    2756     + nla_put(skb, IFLA_CAN_TERMINATION_CONST,
    2757     + sizeof(*priv->termination_const) *
    2758     + priv->termination_const_cnt,
    2759     + priv->termination_const))) ||
    2760     +
    2761     + (priv->bitrate_const &&
    2762     + nla_put(skb, IFLA_CAN_BITRATE_CONST,
    2763     + sizeof(*priv->bitrate_const) *
    2764     + priv->bitrate_const_cnt,
    2765     + priv->bitrate_const)) ||
    2766     +
    2767     + (priv->data_bitrate_const &&
    2768     + nla_put(skb, IFLA_CAN_DATA_BITRATE_CONST,
    2769     + sizeof(*priv->data_bitrate_const) *
    2770     + priv->data_bitrate_const_cnt,
    2771     + priv->data_bitrate_const)) ||
    2772     +
    2773     + (nla_put(skb, IFLA_CAN_BITRATE_MAX,
    2774     + sizeof(priv->bitrate_max),
    2775     + &priv->bitrate_max))
    2776     + )
    2777     +
    2778     + return -EMSGSIZE;
    2779     +
    2780     + return 0;
    2781     +}
    2782     +
    2783     +static size_t can_get_xstats_size(const struct net_device *dev)
    2784     +{
    2785     + return sizeof(struct can_device_stats);
    2786     +}
    2787     +
    2788     +static int can_fill_xstats(struct sk_buff *skb, const struct net_device *dev)
    2789     +{
    2790     + struct can_priv *priv = netdev_priv(dev);
    2791     +
    2792     + if (nla_put(skb, IFLA_INFO_XSTATS,
    2793     + sizeof(priv->can_stats), &priv->can_stats))
    2794     + goto nla_put_failure;
    2795     + return 0;
    2796     +
    2797     +nla_put_failure:
    2798     + return -EMSGSIZE;
    2799     +}
    2800     +
    2801     +static int can_newlink(struct net *src_net, struct net_device *dev,
    2802     + struct nlattr *tb[], struct nlattr *data[],
    2803     + struct netlink_ext_ack *extack)
    2804     +{
    2805     + return -EOPNOTSUPP;
    2806     +}
    2807     +
    2808     +static void can_dellink(struct net_device *dev, struct list_head *head)
    2809     +{
    2810     +}
    2811     +
    2812     +static struct rtnl_link_ops can_link_ops __read_mostly = {
    2813     + .kind = "can",
    2814     + .netns_refund = true,
    2815     + .maxtype = IFLA_CAN_MAX,
    2816     + .policy = can_policy,
    2817     + .setup = can_setup,
    2818     + .validate = can_validate,
    2819     + .newlink = can_newlink,
    2820     + .changelink = can_changelink,
    2821     + .dellink = can_dellink,
    2822     + .get_size = can_get_size,
    2823     + .fill_info = can_fill_info,
    2824     + .get_xstats_size = can_get_xstats_size,
    2825     + .fill_xstats = can_fill_xstats,
    2826     +};
    2827     +
    2828     +/* Register the CAN network device */
    2829     +int register_candev(struct net_device *dev)
    2830     +{
    2831     + struct can_priv *priv = netdev_priv(dev);
    2832     +
    2833     + /* Ensure termination_const, termination_const_cnt and
    2834     + * do_set_termination consistency. All must be either set or
    2835     + * unset.
    2836     + */
    2837     + if ((!priv->termination_const != !priv->termination_const_cnt) ||
    2838     + (!priv->termination_const != !priv->do_set_termination))
    2839     + return -EINVAL;
    2840     +
    2841     + if (!priv->bitrate_const != !priv->bitrate_const_cnt)
    2842     + return -EINVAL;
    2843     +
    2844     + if (!priv->data_bitrate_const != !priv->data_bitrate_const_cnt)
    2845     + return -EINVAL;
    2846     +
    2847     + dev->rtnl_link_ops = &can_link_ops;
    2848     + netif_carrier_off(dev);
    2849     +
    2850     + return register_netdev(dev);
    2851     +}
    2852     +EXPORT_SYMBOL_GPL(register_candev);
    2853     +
    2854     +/* Unregister the CAN network device */
    2855     +void unregister_candev(struct net_device *dev)
    2856     +{
    2857     + unregister_netdev(dev);
    2858     +}
    2859     +EXPORT_SYMBOL_GPL(unregister_candev);
    2860     +
    2861     +/* Test if a network device is a candev based device
    2862     + * and return the can_priv* if so.
    2863     + */
    2864     +struct can_priv *safe_candev_priv(struct net_device *dev)
    2865     +{
    2866     + if (dev->type != ARPHRD_CAN || dev->rtnl_link_ops != &can_link_ops)
    2867     + return NULL;
    2868     +
    2869     + return netdev_priv(dev);
    2870     +}
    2871     +EXPORT_SYMBOL_GPL(safe_candev_priv);
    2872     +
    2873     +static __init int can_dev_init(void)
    2874     +{
    2875     + int err;
    2876     +
    2877     + can_led_notifier_init();
    2878     +
    2879     + err = rtnl_link_register(&can_link_ops);
    2880     + if (!err)
    2881     + pr_info(MOD_DESC "\n");
    2882     +
    2883     + return err;
    2884     +}
    2885     +module_init(can_dev_init);
    2886     +
    2887     +static __exit void can_dev_exit(void)
    2888     +{
    2889     + rtnl_link_unregister(&can_link_ops);
    2890     +
    2891     + can_led_notifier_exit();
    2892     +}
    2893     +module_exit(can_dev_exit);
    2894     +
    2895     +MODULE_ALIAS_RTNL_LINK("can");
    2896     diff --git a/drivers/net/can/dev/rx-offload.c b/drivers/net/can/dev/rx-offload.c
    2897     new file mode 100644
    2898     index 0000000000000..7e75a87a8a6a9
    2899     --- /dev/null
    2900     +++ b/drivers/net/can/dev/rx-offload.c
    2901     @@ -0,0 +1,395 @@
    2902     +// SPDX-License-Identifier: GPL-2.0-only
    2903     +/*
    2904     + * Copyright (c) 2014 David Jander, Protonic Holland
    2905     + * Copyright (C) 2014-2017 Pengutronix, Marc Kleine-Budde <kernel@pengutronix.de>
    2906     + */
    2907     +
    2908     +#include <linux/can/dev.h>
    2909     +#include <linux/can/rx-offload.h>
    2910     +
    2911     +struct can_rx_offload_cb {
    2912     + u32 timestamp;
    2913     +};
    2914     +
    2915     +static inline struct can_rx_offload_cb *can_rx_offload_get_cb(struct sk_buff *skb)
    2916     +{
    2917     + BUILD_BUG_ON(sizeof(struct can_rx_offload_cb) > sizeof(skb->cb));
    2918     +
    2919     + return (struct can_rx_offload_cb *)skb->cb;
    2920     +}
    2921     +
    2922     +static inline bool can_rx_offload_le(struct can_rx_offload *offload, unsigned int a, unsigned int b)
    2923     +{
    2924     + if (offload->inc)
    2925     + return a <= b;
    2926     + else
    2927     + return a >= b;
    2928     +}
    2929     +
    2930     +static inline unsigned int can_rx_offload_inc(struct can_rx_offload *offload, unsigned int *val)
    2931     +{
    2932     + if (offload->inc)
    2933     + return (*val)++;
    2934     + else
    2935     + return (*val)--;
    2936     +}
    2937     +
    2938     +static int can_rx_offload_napi_poll(struct napi_struct *napi, int quota)
    2939     +{
    2940     + struct can_rx_offload *offload = container_of(napi, struct can_rx_offload, napi);
    2941     + struct net_device *dev = offload->dev;
    2942     + struct net_device_stats *stats = &dev->stats;
    2943     + struct sk_buff *skb;
    2944     + int work_done = 0;
    2945     +
    2946     + while ((work_done < quota) &&
    2947     + (skb = skb_dequeue(&offload->skb_queue))) {
    2948     + struct can_frame *cf = (struct can_frame *)skb->data;
    2949     +
    2950     + work_done++;
    2951     + stats->rx_packets++;
    2952     + stats->rx_bytes += cf->can_dlc;
    2953     + netif_receive_skb(skb);
    2954     + }
    2955     +
    2956     + if (work_done < quota) {
    2957     + napi_complete_done(napi, work_done);
    2958     +
    2959     + /* Check if there was another interrupt */
    2960     + if (!skb_queue_empty(&offload->skb_queue))
    2961     + napi_reschedule(&offload->napi);
    2962     + }
    2963     +
    2964     + can_led_event(offload->dev, CAN_LED_EVENT_RX);
    2965     +
    2966     + return work_done;
    2967     +}
    2968     +
    2969     +static inline void __skb_queue_add_sort(struct sk_buff_head *head, struct sk_buff *new,
    2970     + int (*compare)(struct sk_buff *a, struct sk_buff *b))
    2971     +{
    2972     + struct sk_buff *pos, *insert = NULL;
    2973     +
    2974     + skb_queue_reverse_walk(head, pos) {
    2975     + const struct can_rx_offload_cb *cb_pos, *cb_new;
    2976     +
    2977     + cb_pos = can_rx_offload_get_cb(pos);
    2978     + cb_new = can_rx_offload_get_cb(new);
    2979     +
    2980     + netdev_dbg(new->dev,
    2981     + "%s: pos=0x%08x, new=0x%08x, diff=%10d, queue_len=%d\n",
    2982     + __func__,
    2983     + cb_pos->timestamp, cb_new->timestamp,
    2984     + cb_new->timestamp - cb_pos->timestamp,
    2985     + skb_queue_len(head));
    2986     +
    2987     + if (compare(pos, new) < 0)
    2988     + continue;
    2989     + insert = pos;
    2990     + break;
    2991     + }
    2992     + if (!insert)
    2993     + __skb_queue_head(head, new);
    2994     + else
    2995     + __skb_queue_after(head, insert, new);
    2996     +}
    2997     +
    2998     +static int can_rx_offload_compare(struct sk_buff *a, struct sk_buff *b)
    2999     +{
    3000     + const struct can_rx_offload_cb *cb_a, *cb_b;
    3001     +
    3002     + cb_a = can_rx_offload_get_cb(a);
    3003     + cb_b = can_rx_offload_get_cb(b);
    3004     +
    3005     + /* Substract two u32 and return result as int, to keep
    3006     + * difference steady around the u32 overflow.
    3007     + */
    3008     + return cb_b->timestamp - cb_a->timestamp;
    3009     +}
    3010     +
    3011     +/**
    3012     + * can_rx_offload_offload_one() - Read one CAN frame from HW
    3013     + * @offload: pointer to rx_offload context
    3014     + * @n: number of mailbox to read
    3015     + *
    3016     + * The task of this function is to read a CAN frame from mailbox @n
    3017     + * from the device and return the mailbox's content as a struct
    3018     + * sk_buff.
    3019     + *
    3020     + * If the struct can_rx_offload::skb_queue exceeds the maximal queue
    3021     + * length (struct can_rx_offload::skb_queue_len_max) or no skb can be
    3022     + * allocated, the mailbox contents is discarded by reading it into an
    3023     + * overflow buffer. This way the mailbox is marked as free by the
    3024     + * driver.
    3025     + *
    3026     + * Return: A pointer to skb containing the CAN frame on success.
    3027     + *
    3028     + * NULL if the mailbox @n is empty.
    3029     + *
    3030     + * ERR_PTR() in case of an error
    3031     + */
    3032     +static struct sk_buff *
    3033     +can_rx_offload_offload_one(struct can_rx_offload *offload, unsigned int n)
    3034     +{
    3035     + struct sk_buff *skb = NULL, *skb_error = NULL;
    3036     + struct can_rx_offload_cb *cb;
    3037     + struct can_frame *cf;
    3038     + int ret;
    3039     +
    3040     + if (likely(skb_queue_len(&offload->skb_queue) <
    3041     + offload->skb_queue_len_max)) {
    3042     + skb = alloc_can_skb(offload->dev, &cf);
    3043     + if (unlikely(!skb))
    3044     + skb_error = ERR_PTR(-ENOMEM); /* skb alloc failed */
    3045     + } else {
    3046     + skb_error = ERR_PTR(-ENOBUFS); /* skb_queue is full */
    3047     + }
    3048     +
    3049     + /* If queue is full or skb not available, drop by reading into
    3050     + * overflow buffer.
    3051     + */
    3052     + if (unlikely(skb_error)) {
    3053     + struct can_frame cf_overflow;
    3054     + u32 timestamp;
    3055     +
    3056     + ret = offload->mailbox_read(offload, &cf_overflow,
    3057     + &timestamp, n);
    3058     +
    3059     + /* Mailbox was empty. */
    3060     + if (unlikely(!ret))
    3061     + return NULL;
    3062     +
    3063     + /* Mailbox has been read and we're dropping it or
    3064     + * there was a problem reading the mailbox.
    3065     + *
    3066     + * Increment error counters in any case.
    3067     + */
    3068     + offload->dev->stats.rx_dropped++;
    3069     + offload->dev->stats.rx_fifo_errors++;
    3070     +
    3071     + /* There was a problem reading the mailbox, propagate
    3072     + * error value.
    3073     + */
    3074     + if (unlikely(ret < 0))
    3075     + return ERR_PTR(ret);
    3076     +
    3077     + return skb_error;
    3078     + }
    3079     +
    3080     + cb = can_rx_offload_get_cb(skb);
    3081     + ret = offload->mailbox_read(offload, cf, &cb->timestamp, n);
    3082     +
    3083     + /* Mailbox was empty. */
    3084     + if (unlikely(!ret)) {
    3085     + kfree_skb(skb);
    3086     + return NULL;
    3087     + }
    3088     +
    3089     + /* There was a problem reading the mailbox, propagate error value. */
    3090     + if (unlikely(ret < 0)) {
    3091     + kfree_skb(skb);
    3092     +
    3093     + offload->dev->stats.rx_dropped++;
    3094     + offload->dev->stats.rx_fifo_errors++;
    3095     +
    3096     + return ERR_PTR(ret);
    3097     + }
    3098     +
    3099     + /* Mailbox was read. */
    3100     + return skb;
    3101     +}
    3102     +
    3103     +int can_rx_offload_irq_offload_timestamp(struct can_rx_offload *offload, u64 pending)
    3104     +{
    3105     + struct sk_buff_head skb_queue;
    3106     + unsigned int i;
    3107     +
    3108     + __skb_queue_head_init(&skb_queue);
    3109     +
    3110     + for (i = offload->mb_first;
    3111     + can_rx_offload_le(offload, i, offload->mb_last);
    3112     + can_rx_offload_inc(offload, &i)) {
    3113     + struct sk_buff *skb;
    3114     +
    3115     + if (!(pending & BIT_ULL(i)))
    3116     + continue;
    3117     +
    3118     + skb = can_rx_offload_offload_one(offload, i);
    3119     + if (IS_ERR_OR_NULL(skb))
    3120     + continue;
    3121     +
    3122     + __skb_queue_add_sort(&skb_queue, skb, can_rx_offload_compare);
    3123     + }
    3124     +
    3125     + if (!skb_queue_empty(&skb_queue)) {
    3126     + unsigned long flags;
    3127     + u32 queue_len;
    3128     +
    3129     + spin_lock_irqsave(&offload->skb_queue.lock, flags);
    3130     + skb_queue_splice_tail(&skb_queue, &offload->skb_queue);
    3131     + spin_unlock_irqrestore(&offload->skb_queue.lock, flags);
    3132     +
    3133     + if ((queue_len = skb_queue_len(&offload->skb_queue)) >
    3134     + (offload->skb_queue_len_max / 8))
    3135     + netdev_dbg(offload->dev, "%s: queue_len=%d\n",
    3136     + __func__, queue_len);
    3137     +
    3138     + can_rx_offload_schedule(offload);
    3139     + }
    3140     +
    3141     + return skb_queue_len(&skb_queue);
    3142     +}
    3143     +EXPORT_SYMBOL_GPL(can_rx_offload_irq_offload_timestamp);
    3144     +
    3145     +int can_rx_offload_irq_offload_fifo(struct can_rx_offload *offload)
    3146     +{
    3147     + struct sk_buff *skb;
    3148     + int received = 0;
    3149     +
    3150     + while (1) {
    3151     + skb = can_rx_offload_offload_one(offload, 0);
    3152     + if (IS_ERR(skb))
    3153     + continue;
    3154     + if (!skb)
    3155     + break;
    3156     +
    3157     + skb_queue_tail(&offload->skb_queue, skb);
    3158     + received++;
    3159     + }
    3160     +
    3161     + if (received)
    3162     + can_rx_offload_schedule(offload);
    3163     +
    3164     + return received;
    3165     +}
    3166     +EXPORT_SYMBOL_GPL(can_rx_offload_irq_offload_fifo);
    3167     +
    3168     +int can_rx_offload_queue_sorted(struct can_rx_offload *offload,
    3169     + struct sk_buff *skb, u32 timestamp)
    3170     +{
    3171     + struct can_rx_offload_cb *cb;
    3172     + unsigned long flags;
    3173     +
    3174     + if (skb_queue_len(&offload->skb_queue) >
    3175     + offload->skb_queue_len_max) {
    3176     + dev_kfree_skb_any(skb);
    3177     + return -ENOBUFS;
    3178     + }
    3179     +
    3180     + cb = can_rx_offload_get_cb(skb);
    3181     + cb->timestamp = timestamp;
    3182     +
    3183     + spin_lock_irqsave(&offload->skb_queue.lock, flags);
    3184     + __skb_queue_add_sort(&offload->skb_queue, skb, can_rx_offload_compare);
    3185     + spin_unlock_irqrestore(&offload->skb_queue.lock, flags);
    3186     +
    3187     + can_rx_offload_schedule(offload);
    3188     +
    3189     + return 0;
    3190     +}
    3191     +EXPORT_SYMBOL_GPL(can_rx_offload_queue_sorted);
    3192     +
    3193     +unsigned int can_rx_offload_get_echo_skb(struct can_rx_offload *offload,
    3194     + unsigned int idx, u32 timestamp)
    3195     +{
    3196     + struct net_device *dev = offload->dev;
    3197     + struct net_device_stats *stats = &dev->stats;
    3198     + struct sk_buff *skb;
    3199     + u8 len;
    3200     + int err;
    3201     +
    3202     + skb = __can_get_echo_skb(dev, idx, &len);
    3203     + if (!skb)
    3204     + return 0;
    3205     +
    3206     + err = can_rx_offload_queue_sorted(offload, skb, timestamp);
    3207     + if (err) {
    3208     + stats->rx_errors++;
    3209     + stats->tx_fifo_errors++;
    3210     + }
    3211     +
    3212     + return len;
    3213     +}
    3214     +EXPORT_SYMBOL_GPL(can_rx_offload_get_echo_skb);
    3215     +
    3216     +int can_rx_offload_queue_tail(struct can_rx_offload *offload,
    3217     + struct sk_buff *skb)
    3218     +{
    3219     + if (skb_queue_len(&offload->skb_queue) >
    3220     + offload->skb_queue_len_max) {
    3221     + dev_kfree_skb_any(skb);
    3222     + return -ENOBUFS;
    3223     + }
    3224     +
    3225     + skb_queue_tail(&offload->skb_queue, skb);
    3226     + can_rx_offload_schedule(offload);
    3227     +
    3228     + return 0;
    3229     +}
    3230     +EXPORT_SYMBOL_GPL(can_rx_offload_queue_tail);
    3231     +
    3232     +static int can_rx_offload_init_queue(struct net_device *dev, struct can_rx_offload *offload, unsigned int weight)
    3233     +{
    3234     + offload->dev = dev;
    3235     +
    3236     + /* Limit queue len to 4x the weight (rounted to next power of two) */
    3237     + offload->skb_queue_len_max = 2 << fls(weight);
    3238     + offload->skb_queue_len_max *= 4;
    3239     + skb_queue_head_init(&offload->skb_queue);
    3240     +
    3241     + can_rx_offload_reset(offload);
    3242     + netif_napi_add(dev, &offload->napi, can_rx_offload_napi_poll, weight);
    3243     +
    3244     + dev_dbg(dev->dev.parent, "%s: skb_queue_len_max=%d\n",
    3245     + __func__, offload->skb_queue_len_max);
    3246     +
    3247     + return 0;
    3248     +}
    3249     +
    3250     +int can_rx_offload_add_timestamp(struct net_device *dev, struct can_rx_offload *offload)
    3251     +{
    3252     + unsigned int weight;
    3253     +
    3254     + if (offload->mb_first > BITS_PER_LONG_LONG ||
    3255     + offload->mb_last > BITS_PER_LONG_LONG || !offload->mailbox_read)
    3256     + return -EINVAL;
    3257     +
    3258     + if (offload->mb_first < offload->mb_last) {
    3259     + offload->inc = true;
    3260     + weight = offload->mb_last - offload->mb_first;
    3261     + } else {
    3262     + offload->inc = false;
    3263     + weight = offload->mb_first - offload->mb_last;
    3264     + }
    3265     +
    3266     + return can_rx_offload_init_queue(dev, offload, weight);
    3267     +}
    3268     +EXPORT_SYMBOL_GPL(can_rx_offload_add_timestamp);
    3269     +
    3270     +int can_rx_offload_add_fifo(struct net_device *dev, struct can_rx_offload *offload, unsigned int weight)
    3271     +{
    3272     + if (!offload->mailbox_read)
    3273     + return -EINVAL;
    3274     +
    3275     + return can_rx_offload_init_queue(dev, offload, weight);
    3276     +}
    3277     +EXPORT_SYMBOL_GPL(can_rx_offload_add_fifo);
    3278     +
    3279     +void can_rx_offload_enable(struct can_rx_offload *offload)
    3280     +{
    3281     + can_rx_offload_reset(offload);
    3282     + napi_enable(&offload->napi);
    3283     +}
    3284     +EXPORT_SYMBOL_GPL(can_rx_offload_enable);
    3285     +
    3286     +void can_rx_offload_del(struct can_rx_offload *offload)
    3287     +{
    3288     + netif_napi_del(&offload->napi);
    3289     + skb_queue_purge(&offload->skb_queue);
    3290     +}
    3291     +EXPORT_SYMBOL_GPL(can_rx_offload_del);
    3292     +
    3293     +void can_rx_offload_reset(struct can_rx_offload *offload)
    3294     +{
    3295     +}
    3296     +EXPORT_SYMBOL_GPL(can_rx_offload_reset);
    3297     diff --git a/drivers/net/can/m_can/tcan4x5x.c b/drivers/net/can/m_can/tcan4x5x.c
    3298     index 32cb479fe6ac8..0d66582bd3560 100644
    3299     --- a/drivers/net/can/m_can/tcan4x5x.c
    3300     +++ b/drivers/net/can/m_can/tcan4x5x.c
    3301     @@ -88,7 +88,7 @@
    3302    
    3303     #define TCAN4X5X_MRAM_START 0x8000
    3304     #define TCAN4X5X_MCAN_OFFSET 0x1000
    3305     -#define TCAN4X5X_MAX_REGISTER 0x8fff
    3306     +#define TCAN4X5X_MAX_REGISTER 0x8ffc
    3307    
    3308     #define TCAN4X5X_CLEAR_ALL_INT 0xffffffff
    3309     #define TCAN4X5X_SET_ALL_INT 0xffffffff
    3310     diff --git a/drivers/net/can/rx-offload.c b/drivers/net/can/rx-offload.c
    3311     deleted file mode 100644
    3312     index 7e75a87a8a6a9..0000000000000
    3313     --- a/drivers/net/can/rx-offload.c
    3314     +++ /dev/null
    3315     @@ -1,395 +0,0 @@
    3316     -// SPDX-License-Identifier: GPL-2.0-only
    3317     -/*
    3318     - * Copyright (c) 2014 David Jander, Protonic Holland
    3319     - * Copyright (C) 2014-2017 Pengutronix, Marc Kleine-Budde <kernel@pengutronix.de>
    3320     - */
    3321     -
    3322     -#include <linux/can/dev.h>
    3323     -#include <linux/can/rx-offload.h>
    3324     -
    3325     -struct can_rx_offload_cb {
    3326     - u32 timestamp;
    3327     -};
    3328     -
    3329     -static inline struct can_rx_offload_cb *can_rx_offload_get_cb(struct sk_buff *skb)
    3330     -{
    3331     - BUILD_BUG_ON(sizeof(struct can_rx_offload_cb) > sizeof(skb->cb));
    3332     -
    3333     - return (struct can_rx_offload_cb *)skb->cb;
    3334     -}
    3335     -
    3336     -static inline bool can_rx_offload_le(struct can_rx_offload *offload, unsigned int a, unsigned int b)
    3337     -{
    3338     - if (offload->inc)
    3339     - return a <= b;
    3340     - else
    3341     - return a >= b;
    3342     -}
    3343     -
    3344     -static inline unsigned int can_rx_offload_inc(struct can_rx_offload *offload, unsigned int *val)
    3345     -{
    3346     - if (offload->inc)
    3347     - return (*val)++;
    3348     - else
    3349     - return (*val)--;
    3350     -}
    3351     -
    3352     -static int can_rx_offload_napi_poll(struct napi_struct *napi, int quota)
    3353     -{
    3354     - struct can_rx_offload *offload = container_of(napi, struct can_rx_offload, napi);
    3355     - struct net_device *dev = offload->dev;
    3356     - struct net_device_stats *stats = &dev->stats;
    3357     - struct sk_buff *skb;
    3358     - int work_done = 0;
    3359     -
    3360     - while ((work_done < quota) &&
    3361     - (skb = skb_dequeue(&offload->skb_queue))) {
    3362     - struct can_frame *cf = (struct can_frame *)skb->data;
    3363     -
    3364     - work_done++;
    3365     - stats->rx_packets++;
    3366     - stats->rx_bytes += cf->can_dlc;
    3367     - netif_receive_skb(skb);
    3368     - }
    3369     -
    3370     - if (work_done < quota) {
    3371     - napi_complete_done(napi, work_done);
    3372     -
    3373     - /* Check if there was another interrupt */
    3374     - if (!skb_queue_empty(&offload->skb_queue))
    3375     - napi_reschedule(&offload->napi);
    3376     - }
    3377     -
    3378     - can_led_event(offload->dev, CAN_LED_EVENT_RX);
    3379     -
    3380     - return work_done;
    3381     -}
    3382     -
    3383     -static inline void __skb_queue_add_sort(struct sk_buff_head *head, struct sk_buff *new,
    3384     - int (*compare)(struct sk_buff *a, struct sk_buff *b))
    3385     -{
    3386     - struct sk_buff *pos, *insert = NULL;
    3387     -
    3388     - skb_queue_reverse_walk(head, pos) {
    3389     - const struct can_rx_offload_cb *cb_pos, *cb_new;
    3390     -
    3391     - cb_pos = can_rx_offload_get_cb(pos);
    3392     - cb_new = can_rx_offload_get_cb(new);
    3393     -
    3394     - netdev_dbg(new->dev,
    3395     - "%s: pos=0x%08x, new=0x%08x, diff=%10d, queue_len=%d\n",
    3396     - __func__,
    3397     - cb_pos->timestamp, cb_new->timestamp,
    3398     - cb_new->timestamp - cb_pos->timestamp,
    3399     - skb_queue_len(head));
    3400     -
    3401     - if (compare(pos, new) < 0)
    3402     - continue;
    3403     - insert = pos;
    3404     - break;
    3405     - }
    3406     - if (!insert)
    3407     - __skb_queue_head(head, new);
    3408     - else
    3409     - __skb_queue_after(head, insert, new);
    3410     -}
    3411     -
    3412     -static int can_rx_offload_compare(struct sk_buff *a, struct sk_buff *b)
    3413     -{
    3414     - const struct can_rx_offload_cb *cb_a, *cb_b;
    3415     -
    3416     - cb_a = can_rx_offload_get_cb(a);
    3417     - cb_b = can_rx_offload_get_cb(b);
    3418     -
    3419     - /* Substract two u32 and return result as int, to keep
    3420     - * difference steady around the u32 overflow.
    3421     - */
    3422     - return cb_b->timestamp - cb_a->timestamp;
    3423     -}
    3424     -
    3425     -/**
    3426     - * can_rx_offload_offload_one() - Read one CAN frame from HW
    3427     - * @offload: pointer to rx_offload context
    3428     - * @n: number of mailbox to read
    3429     - *
    3430     - * The task of this function is to read a CAN frame from mailbox @n
    3431     - * from the device and return the mailbox's content as a struct
    3432     - * sk_buff.
    3433     - *
    3434     - * If the struct can_rx_offload::skb_queue exceeds the maximal queue
    3435     - * length (struct can_rx_offload::skb_queue_len_max) or no skb can be
    3436     - * allocated, the mailbox contents is discarded by reading it into an
    3437     - * overflow buffer. This way the mailbox is marked as free by the
    3438     - * driver.
    3439     - *
    3440     - * Return: A pointer to skb containing the CAN frame on success.
    3441     - *
    3442     - * NULL if the mailbox @n is empty.
    3443     - *
    3444     - * ERR_PTR() in case of an error
    3445     - */
    3446     -static struct sk_buff *
    3447     -can_rx_offload_offload_one(struct can_rx_offload *offload, unsigned int n)
    3448     -{
    3449     - struct sk_buff *skb = NULL, *skb_error = NULL;
    3450     - struct can_rx_offload_cb *cb;
    3451     - struct can_frame *cf;
    3452     - int ret;
    3453     -
    3454     - if (likely(skb_queue_len(&offload->skb_queue) <
    3455     - offload->skb_queue_len_max)) {
    3456     - skb = alloc_can_skb(offload->dev, &cf);
    3457     - if (unlikely(!skb))
    3458     - skb_error = ERR_PTR(-ENOMEM); /* skb alloc failed */
    3459     - } else {
    3460     - skb_error = ERR_PTR(-ENOBUFS); /* skb_queue is full */
    3461     - }
    3462     -
    3463     - /* If queue is full or skb not available, drop by reading into
    3464     - * overflow buffer.
    3465     - */
    3466     - if (unlikely(skb_error)) {
    3467     - struct can_frame cf_overflow;
    3468     - u32 timestamp;
    3469     -
    3470     - ret = offload->mailbox_read(offload, &cf_overflow,
    3471     - &timestamp, n);
    3472     -
    3473     - /* Mailbox was empty. */
    3474     - if (unlikely(!ret))
    3475     - return NULL;
    3476     -
    3477     - /* Mailbox has been read and we're dropping it or
    3478     - * there was a problem reading the mailbox.
    3479     - *
    3480     - * Increment error counters in any case.
    3481     - */
    3482     - offload->dev->stats.rx_dropped++;
    3483     - offload->dev->stats.rx_fifo_errors++;
    3484     -
    3485     - /* There was a problem reading the mailbox, propagate
    3486     - * error value.
    3487     - */
    3488     - if (unlikely(ret < 0))
    3489     - return ERR_PTR(ret);
    3490     -
    3491     - return skb_error;
    3492     - }
    3493     -
    3494     - cb = can_rx_offload_get_cb(skb);
    3495     - ret = offload->mailbox_read(offload, cf, &cb->timestamp, n);
    3496     -
    3497     - /* Mailbox was empty. */
    3498     - if (unlikely(!ret)) {
    3499     - kfree_skb(skb);
    3500     - return NULL;
    3501     - }
    3502     -
    3503     - /* There was a problem reading the mailbox, propagate error value. */
    3504     - if (unlikely(ret < 0)) {
    3505     - kfree_skb(skb);
    3506     -
    3507     - offload->dev->stats.rx_dropped++;
    3508     - offload->dev->stats.rx_fifo_errors++;
    3509     -
    3510     - return ERR_PTR(ret);
    3511     - }
    3512     -
    3513     - /* Mailbox was read. */
    3514     - return skb;
    3515     -}
    3516     -
    3517     -int can_rx_offload_irq_offload_timestamp(struct can_rx_offload *offload, u64 pending)
    3518     -{
    3519     - struct sk_buff_head skb_queue;
    3520     - unsigned int i;
    3521     -
    3522     - __skb_queue_head_init(&skb_queue);
    3523     -
    3524     - for (i = offload->mb_first;
    3525     - can_rx_offload_le(offload, i, offload->mb_last);
    3526     - can_rx_offload_inc(offload, &i)) {
    3527     - struct sk_buff *skb;
    3528     -
    3529     - if (!(pending & BIT_ULL(i)))
    3530     - continue;
    3531     -
    3532     - skb = can_rx_offload_offload_one(offload, i);
    3533     - if (IS_ERR_OR_NULL(skb))
    3534     - continue;
    3535     -
    3536     - __skb_queue_add_sort(&skb_queue, skb, can_rx_offload_compare);
    3537     - }
    3538     -
    3539     - if (!skb_queue_empty(&skb_queue)) {
    3540     - unsigned long flags;
    3541     - u32 queue_len;
    3542     -
    3543     - spin_lock_irqsave(&offload->skb_queue.lock, flags);
    3544     - skb_queue_splice_tail(&skb_queue, &offload->skb_queue);
    3545     - spin_unlock_irqrestore(&offload->skb_queue.lock, flags);
    3546     -
    3547     - if ((queue_len = skb_queue_len(&offload->skb_queue)) >
    3548     - (offload->skb_queue_len_max / 8))
    3549     - netdev_dbg(offload->dev, "%s: queue_len=%d\n",
    3550     - __func__, queue_len);
    3551     -
    3552     - can_rx_offload_schedule(offload);
    3553     - }
    3554     -
    3555     - return skb_queue_len(&skb_queue);
    3556     -}
    3557     -EXPORT_SYMBOL_GPL(can_rx_offload_irq_offload_timestamp);
    3558     -
    3559     -int can_rx_offload_irq_offload_fifo(struct can_rx_offload *offload)
    3560     -{
    3561     - struct sk_buff *skb;
    3562     - int received = 0;
    3563     -
    3564     - while (1) {
    3565     - skb = can_rx_offload_offload_one(offload, 0);
    3566     - if (IS_ERR(skb))
    3567     - continue;
    3568     - if (!skb)
    3569     - break;
    3570     -
    3571     - skb_queue_tail(&offload->skb_queue, skb);
    3572     - received++;
    3573     - }
    3574     -
    3575     - if (received)
    3576     - can_rx_offload_schedule(offload);
    3577     -
    3578     - return received;
    3579     -}
    3580     -EXPORT_SYMBOL_GPL(can_rx_offload_irq_offload_fifo);
    3581     -
    3582     -int can_rx_offload_queue_sorted(struct can_rx_offload *offload,
    3583     - struct sk_buff *skb, u32 timestamp)
    3584     -{
    3585     - struct can_rx_offload_cb *cb;
    3586     - unsigned long flags;
    3587     -
    3588     - if (skb_queue_len(&offload->skb_queue) >
    3589     - offload->skb_queue_len_max) {
    3590     - dev_kfree_skb_any(skb);
    3591     - return -ENOBUFS;
    3592     - }
    3593     -
    3594     - cb = can_rx_offload_get_cb(skb);
    3595     - cb->timestamp = timestamp;
    3596     -
    3597     - spin_lock_irqsave(&offload->skb_queue.lock, flags);
    3598     - __skb_queue_add_sort(&offload->skb_queue, skb, can_rx_offload_compare);
    3599     - spin_unlock_irqrestore(&offload->skb_queue.lock, flags);
    3600     -
    3601     - can_rx_offload_schedule(offload);
    3602     -
    3603     - return 0;
    3604     -}
    3605     -EXPORT_SYMBOL_GPL(can_rx_offload_queue_sorted);
    3606     -
    3607     -unsigned int can_rx_offload_get_echo_skb(struct can_rx_offload *offload,
    3608     - unsigned int idx, u32 timestamp)
    3609     -{
    3610     - struct net_device *dev = offload->dev;
    3611     - struct net_device_stats *stats = &dev->stats;
    3612     - struct sk_buff *skb;
    3613     - u8 len;
    3614     - int err;
    3615     -
    3616     - skb = __can_get_echo_skb(dev, idx, &len);
    3617     - if (!skb)
    3618     - return 0;
    3619     -
    3620     - err = can_rx_offload_queue_sorted(offload, skb, timestamp);
    3621     - if (err) {
    3622     - stats->rx_errors++;
    3623     - stats->tx_fifo_errors++;
    3624     - }
    3625     -
    3626     - return len;
    3627     -}
    3628     -EXPORT_SYMBOL_GPL(can_rx_offload_get_echo_skb);
    3629     -
    3630     -int can_rx_offload_queue_tail(struct can_rx_offload *offload,
    3631     - struct sk_buff *skb)
    3632     -{
    3633     - if (skb_queue_len(&offload->skb_queue) >
    3634     - offload->skb_queue_len_max) {
    3635     - dev_kfree_skb_any(skb);
    3636     - return -ENOBUFS;
    3637     - }
    3638     -
    3639     - skb_queue_tail(&offload->skb_queue, skb);
    3640     - can_rx_offload_schedule(offload);
    3641     -
    3642     - return 0;
    3643     -}
    3644     -EXPORT_SYMBOL_GPL(can_rx_offload_queue_tail);
    3645     -
    3646     -static int can_rx_offload_init_queue(struct net_device *dev, struct can_rx_offload *offload, unsigned int weight)
    3647     -{
    3648     - offload->dev = dev;
    3649     -
    3650     - /* Limit queue len to 4x the weight (rounted to next power of two) */
    3651     - offload->skb_queue_len_max = 2 << fls(weight);
    3652     - offload->skb_queue_len_max *= 4;
    3653     - skb_queue_head_init(&offload->skb_queue);
    3654     -
    3655     - can_rx_offload_reset(offload);
    3656     - netif_napi_add(dev, &offload->napi, can_rx_offload_napi_poll, weight);
    3657     -
    3658     - dev_dbg(dev->dev.parent, "%s: skb_queue_len_max=%d\n",
    3659     - __func__, offload->skb_queue_len_max);
    3660     -
    3661     - return 0;
    3662     -}
    3663     -
    3664     -int can_rx_offload_add_timestamp(struct net_device *dev, struct can_rx_offload *offload)
    3665     -{
    3666     - unsigned int weight;
    3667     -
    3668     - if (offload->mb_first > BITS_PER_LONG_LONG ||
    3669     - offload->mb_last > BITS_PER_LONG_LONG || !offload->mailbox_read)
    3670     - return -EINVAL;
    3671     -
    3672     - if (offload->mb_first < offload->mb_last) {
    3673     - offload->inc = true;
    3674     - weight = offload->mb_last - offload->mb_first;
    3675     - } else {
    3676     - offload->inc = false;
    3677     - weight = offload->mb_first - offload->mb_last;
    3678     - }
    3679     -
    3680     - return can_rx_offload_init_queue(dev, offload, weight);
    3681     -}
    3682     -EXPORT_SYMBOL_GPL(can_rx_offload_add_timestamp);
    3683     -
    3684     -int can_rx_offload_add_fifo(struct net_device *dev, struct can_rx_offload *offload, unsigned int weight)
    3685     -{
    3686     - if (!offload->mailbox_read)
    3687     - return -EINVAL;
    3688     -
    3689     - return can_rx_offload_init_queue(dev, offload, weight);
    3690     -}
    3691     -EXPORT_SYMBOL_GPL(can_rx_offload_add_fifo);
    3692     -
    3693     -void can_rx_offload_enable(struct can_rx_offload *offload)
    3694     -{
    3695     - can_rx_offload_reset(offload);
    3696     - napi_enable(&offload->napi);
    3697     -}
    3698     -EXPORT_SYMBOL_GPL(can_rx_offload_enable);
    3699     -
    3700     -void can_rx_offload_del(struct can_rx_offload *offload)
    3701     -{
    3702     - netif_napi_del(&offload->napi);
    3703     - skb_queue_purge(&offload->skb_queue);
    3704     -}
    3705     -EXPORT_SYMBOL_GPL(can_rx_offload_del);
    3706     -
    3707     -void can_rx_offload_reset(struct can_rx_offload *offload)
    3708     -{
    3709     -}
    3710     -EXPORT_SYMBOL_GPL(can_rx_offload_reset);
    3711     diff --git a/drivers/net/can/slcan.c b/drivers/net/can/slcan.c
    3712     index 4dfa459ef5c73..95fefb1eef361 100644
    3713     --- a/drivers/net/can/slcan.c
    3714     +++ b/drivers/net/can/slcan.c
    3715     @@ -519,6 +519,7 @@ static struct slcan *slc_alloc(void)
    3716     int i;
    3717     char name[IFNAMSIZ];
    3718     struct net_device *dev = NULL;
    3719     + struct can_ml_priv *can_ml;
    3720     struct slcan *sl;
    3721     int size;
    3722    
    3723     @@ -541,7 +542,8 @@ static struct slcan *slc_alloc(void)
    3724    
    3725     dev->base_addr = i;
    3726     sl = netdev_priv(dev);
    3727     - dev->ml_priv = (void *)sl + ALIGN(sizeof(*sl), NETDEV_ALIGN);
    3728     + can_ml = (void *)sl + ALIGN(sizeof(*sl), NETDEV_ALIGN);
    3729     + can_set_ml_priv(dev, can_ml);
    3730    
    3731     /* Initialize channel control data */
    3732     sl->magic = SLCAN_MAGIC;
    3733     diff --git a/drivers/net/can/vcan.c b/drivers/net/can/vcan.c
    3734     index 39ca14b0585dc..067705e2850b3 100644
    3735     --- a/drivers/net/can/vcan.c
    3736     +++ b/drivers/net/can/vcan.c
    3737     @@ -153,7 +153,7 @@ static void vcan_setup(struct net_device *dev)
    3738     dev->addr_len = 0;
    3739     dev->tx_queue_len = 0;
    3740     dev->flags = IFF_NOARP;
    3741     - dev->ml_priv = netdev_priv(dev);
    3742     + can_set_ml_priv(dev, netdev_priv(dev));
    3743    
    3744     /* set flags according to driver capabilities */
    3745     if (echo)
    3746     diff --git a/drivers/net/can/vxcan.c b/drivers/net/can/vxcan.c
    3747     index b1baa4ac1d537..7000c6cd1e48b 100644
    3748     --- a/drivers/net/can/vxcan.c
    3749     +++ b/drivers/net/can/vxcan.c
    3750     @@ -141,6 +141,8 @@ static const struct net_device_ops vxcan_netdev_ops = {
    3751    
    3752     static void vxcan_setup(struct net_device *dev)
    3753     {
    3754     + struct can_ml_priv *can_ml;
    3755     +
    3756     dev->type = ARPHRD_CAN;
    3757     dev->mtu = CANFD_MTU;
    3758     dev->hard_header_len = 0;
    3759     @@ -149,7 +151,9 @@ static void vxcan_setup(struct net_device *dev)
    3760     dev->flags = (IFF_NOARP|IFF_ECHO);
    3761     dev->netdev_ops = &vxcan_netdev_ops;
    3762     dev->needs_free_netdev = true;
    3763     - dev->ml_priv = netdev_priv(dev) + ALIGN(sizeof(struct vxcan_priv), NETDEV_ALIGN);
    3764     +
    3765     + can_ml = netdev_priv(dev) + ALIGN(sizeof(struct vxcan_priv), NETDEV_ALIGN);
    3766     + can_set_ml_priv(dev, can_ml);
    3767     }
    3768    
    3769     /* forward declaration for rtnl_create_link() */
    3770     diff --git a/drivers/net/ethernet/aquantia/atlantic/aq_main.c b/drivers/net/ethernet/aquantia/atlantic/aq_main.c
    3771     index bb65dd39f8474..72c7404ae6c5b 100644
    3772     --- a/drivers/net/ethernet/aquantia/atlantic/aq_main.c
    3773     +++ b/drivers/net/ethernet/aquantia/atlantic/aq_main.c
    3774     @@ -66,8 +66,10 @@ static int aq_ndev_open(struct net_device *ndev)
    3775     goto err_exit;
    3776    
    3777     err = aq_nic_start(aq_nic);
    3778     - if (err < 0)
    3779     + if (err < 0) {
    3780     + aq_nic_stop(aq_nic);
    3781     goto err_exit;
    3782     + }
    3783    
    3784     err_exit:
    3785     if (err < 0)
    3786     diff --git a/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c b/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
    3787     index 9a77b70ad601b..491bcfd36ac25 100644
    3788     --- a/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
    3789     +++ b/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
    3790     @@ -1073,7 +1073,7 @@ static void mvpp2_interrupts_unmask(void *arg)
    3791     u32 val;
    3792    
    3793     /* If the thread isn't used, don't do anything */
    3794     - if (smp_processor_id() > port->priv->nthreads)
    3795     + if (smp_processor_id() >= port->priv->nthreads)
    3796     return;
    3797    
    3798     val = MVPP2_CAUSE_MISC_SUM_MASK |
    3799     @@ -2078,7 +2078,7 @@ static void mvpp2_txq_sent_counter_clear(void *arg)
    3800     int queue;
    3801    
    3802     /* If the thread isn't used, don't do anything */
    3803     - if (smp_processor_id() > port->priv->nthreads)
    3804     + if (smp_processor_id() >= port->priv->nthreads)
    3805     return;
    3806    
    3807     for (queue = 0; queue < port->ntxqs; queue++) {
    3808     diff --git a/drivers/net/wan/lmc/lmc_main.c b/drivers/net/wan/lmc/lmc_main.c
    3809     index 0e6a51525d913..f3deb2a2fa47d 100644
    3810     --- a/drivers/net/wan/lmc/lmc_main.c
    3811     +++ b/drivers/net/wan/lmc/lmc_main.c
    3812     @@ -912,6 +912,8 @@ static int lmc_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
    3813     break;
    3814     default:
    3815     printk(KERN_WARNING "%s: LMC UNKNOWN CARD!\n", dev->name);
    3816     + unregister_hdlc_device(dev);
    3817     + return -EIO;
    3818     break;
    3819     }
    3820    
    3821     diff --git a/drivers/net/wireless/ath/ath10k/wmi-tlv.c b/drivers/net/wireless/ath/ath10k/wmi-tlv.c
    3822     index 3ec71f52e8fe1..d38276ac375e9 100644
    3823     --- a/drivers/net/wireless/ath/ath10k/wmi-tlv.c
    3824     +++ b/drivers/net/wireless/ath/ath10k/wmi-tlv.c
    3825     @@ -445,13 +445,13 @@ static void ath10k_wmi_event_tdls_peer(struct ath10k *ar, struct sk_buff *skb)
    3826     case WMI_TDLS_TEARDOWN_REASON_TX:
    3827     case WMI_TDLS_TEARDOWN_REASON_RSSI:
    3828     case WMI_TDLS_TEARDOWN_REASON_PTR_TIMEOUT:
    3829     + rcu_read_lock();
    3830     station = ieee80211_find_sta_by_ifaddr(ar->hw,
    3831     ev->peer_macaddr.addr,
    3832     NULL);
    3833     if (!station) {
    3834     ath10k_warn(ar, "did not find station from tdls peer event");
    3835     - kfree(tb);
    3836     - return;
    3837     + goto exit;
    3838     }
    3839     arvif = ath10k_get_arvif(ar, __le32_to_cpu(ev->vdev_id));
    3840     ieee80211_tdls_oper_request(
    3841     @@ -462,6 +462,9 @@ static void ath10k_wmi_event_tdls_peer(struct ath10k *ar, struct sk_buff *skb)
    3842     );
    3843     break;
    3844     }
    3845     +
    3846     +exit:
    3847     + rcu_read_unlock();
    3848     kfree(tb);
    3849     }
    3850    
    3851     diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c
    3852     index 4ca50353538ef..cd813c69a1781 100644
    3853     --- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c
    3854     +++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c
    3855     @@ -5382,7 +5382,8 @@ static bool brcmf_is_linkup(struct brcmf_cfg80211_vif *vif,
    3856     return false;
    3857     }
    3858    
    3859     -static bool brcmf_is_linkdown(const struct brcmf_event_msg *e)
    3860     +static bool brcmf_is_linkdown(struct brcmf_cfg80211_vif *vif,
    3861     + const struct brcmf_event_msg *e)
    3862     {
    3863     u32 event = e->event_code;
    3864     u16 flags = e->flags;
    3865     @@ -5391,6 +5392,8 @@ static bool brcmf_is_linkdown(const struct brcmf_event_msg *e)
    3866     (event == BRCMF_E_DISASSOC_IND) ||
    3867     ((event == BRCMF_E_LINK) && (!(flags & BRCMF_EVENT_MSG_LINK)))) {
    3868     brcmf_dbg(CONN, "Processing link down\n");
    3869     + clear_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, &vif->sme_state);
    3870     + clear_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, &vif->sme_state);
    3871     return true;
    3872     }
    3873     return false;
    3874     @@ -5683,7 +5686,7 @@ brcmf_notify_connect_status(struct brcmf_if *ifp,
    3875     } else
    3876     brcmf_bss_connect_done(cfg, ndev, e, true);
    3877     brcmf_net_setcarrier(ifp, true);
    3878     - } else if (brcmf_is_linkdown(e)) {
    3879     + } else if (brcmf_is_linkdown(ifp->vif, e)) {
    3880     brcmf_dbg(CONN, "Linkdown\n");
    3881     if (!brcmf_is_ibssmode(ifp->vif)) {
    3882     brcmf_bss_connect_done(cfg, ndev, e, false);
    3883     diff --git a/drivers/pinctrl/pinctrl-rockchip.c b/drivers/pinctrl/pinctrl-rockchip.c
    3884     index 930edfc32f597..59fe3204e965d 100644
    3885     --- a/drivers/pinctrl/pinctrl-rockchip.c
    3886     +++ b/drivers/pinctrl/pinctrl-rockchip.c
    3887     @@ -3386,12 +3386,15 @@ static int __maybe_unused rockchip_pinctrl_suspend(struct device *dev)
    3888     static int __maybe_unused rockchip_pinctrl_resume(struct device *dev)
    3889     {
    3890     struct rockchip_pinctrl *info = dev_get_drvdata(dev);
    3891     - int ret = regmap_write(info->regmap_base, RK3288_GRF_GPIO6C_IOMUX,
    3892     - rk3288_grf_gpio6c_iomux |
    3893     - GPIO6C6_SEL_WRITE_ENABLE);
    3894     + int ret;
    3895    
    3896     - if (ret)
    3897     - return ret;
    3898     + if (info->ctrl->type == RK3288) {
    3899     + ret = regmap_write(info->regmap_base, RK3288_GRF_GPIO6C_IOMUX,
    3900     + rk3288_grf_gpio6c_iomux |
    3901     + GPIO6C6_SEL_WRITE_ENABLE);
    3902     + if (ret)
    3903     + return ret;
    3904     + }
    3905    
    3906     return pinctrl_force_default(info->pctl_dev);
    3907     }
    3908     diff --git a/drivers/scsi/qla2xxx/qla_target.h b/drivers/scsi/qla2xxx/qla_target.h
    3909     index d006f0a97b8cf..2236751a3a568 100644
    3910     --- a/drivers/scsi/qla2xxx/qla_target.h
    3911     +++ b/drivers/scsi/qla2xxx/qla_target.h
    3912     @@ -116,7 +116,6 @@
    3913     (min(1270, ((ql) > 0) ? (QLA_TGT_DATASEGS_PER_CMD_24XX + \
    3914     QLA_TGT_DATASEGS_PER_CONT_24XX*((ql) - 1)) : 0))
    3915     #endif
    3916     -#endif
    3917    
    3918     #define GET_TARGET_ID(ha, iocb) ((HAS_EXTENDED_IDS(ha)) \
    3919     ? le16_to_cpu((iocb)->u.isp2x.target.extended) \
    3920     @@ -244,6 +243,7 @@ struct ctio_to_2xxx {
    3921     #ifndef CTIO_RET_TYPE
    3922     #define CTIO_RET_TYPE 0x17 /* CTIO return entry */
    3923     #define ATIO_TYPE7 0x06 /* Accept target I/O entry for 24xx */
    3924     +#endif
    3925    
    3926     struct fcp_hdr {
    3927     uint8_t r_ctl;
    3928     diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
    3929     index e3266a64a4770..2121e44c342f8 100644
    3930     --- a/drivers/scsi/st.c
    3931     +++ b/drivers/scsi/st.c
    3932     @@ -1267,8 +1267,8 @@ static int st_open(struct inode *inode, struct file *filp)
    3933     spin_lock(&st_use_lock);
    3934     if (STp->in_use) {
    3935     spin_unlock(&st_use_lock);
    3936     - scsi_tape_put(STp);
    3937     DEBC_printk(STp, "Device already in use.\n");
    3938     + scsi_tape_put(STp);
    3939     return (-EBUSY);
    3940     }
    3941    
    3942     diff --git a/drivers/staging/comedi/drivers/cb_pcidas.c b/drivers/staging/comedi/drivers/cb_pcidas.c
    3943     index 1893c70de0b93..10f097a7d847d 100644
    3944     --- a/drivers/staging/comedi/drivers/cb_pcidas.c
    3945     +++ b/drivers/staging/comedi/drivers/cb_pcidas.c
    3946     @@ -1281,7 +1281,7 @@ static int cb_pcidas_auto_attach(struct comedi_device *dev,
    3947     devpriv->amcc + AMCC_OP_REG_INTCSR);
    3948    
    3949     ret = request_irq(pcidev->irq, cb_pcidas_interrupt, IRQF_SHARED,
    3950     - dev->board_name, dev);
    3951     + "cb_pcidas", dev);
    3952     if (ret) {
    3953     dev_dbg(dev->class_dev, "unable to allocate irq %d\n",
    3954     pcidev->irq);
    3955     diff --git a/drivers/staging/comedi/drivers/cb_pcidas64.c b/drivers/staging/comedi/drivers/cb_pcidas64.c
    3956     index e1774e09a3203..9fe8b65cd9e3a 100644
    3957     --- a/drivers/staging/comedi/drivers/cb_pcidas64.c
    3958     +++ b/drivers/staging/comedi/drivers/cb_pcidas64.c
    3959     @@ -4035,7 +4035,7 @@ static int auto_attach(struct comedi_device *dev,
    3960     init_stc_registers(dev);
    3961    
    3962     retval = request_irq(pcidev->irq, handle_interrupt, IRQF_SHARED,
    3963     - dev->board_name, dev);
    3964     + "cb_pcidas64", dev);
    3965     if (retval) {
    3966     dev_dbg(dev->class_dev, "unable to allocate irq %u\n",
    3967     pcidev->irq);
    3968     diff --git a/drivers/staging/rtl8192e/rtllib.h b/drivers/staging/rtl8192e/rtllib.h
    3969     index 328f410daa035..2eeb9a43734e3 100644
    3970     --- a/drivers/staging/rtl8192e/rtllib.h
    3971     +++ b/drivers/staging/rtl8192e/rtllib.h
    3972     @@ -1105,7 +1105,7 @@ struct rtllib_network {
    3973     bool bWithAironetIE;
    3974     bool bCkipSupported;
    3975     bool bCcxRmEnable;
    3976     - u16 CcxRmState[2];
    3977     + u8 CcxRmState[2];
    3978     bool bMBssidValid;
    3979     u8 MBssidMask;
    3980     u8 MBssid[ETH_ALEN];
    3981     diff --git a/drivers/staging/rtl8192e/rtllib_rx.c b/drivers/staging/rtl8192e/rtllib_rx.c
    3982     index 0bae0a0a4cbe1..83c30e2d82f5f 100644
    3983     --- a/drivers/staging/rtl8192e/rtllib_rx.c
    3984     +++ b/drivers/staging/rtl8192e/rtllib_rx.c
    3985     @@ -1968,7 +1968,7 @@ static void rtllib_parse_mife_generic(struct rtllib_device *ieee,
    3986     info_element->data[2] == 0x96 &&
    3987     info_element->data[3] == 0x01) {
    3988     if (info_element->len == 6) {
    3989     - memcpy(network->CcxRmState, &info_element[4], 2);
    3990     + memcpy(network->CcxRmState, &info_element->data[4], 2);
    3991     if (network->CcxRmState[0] != 0)
    3992     network->bCcxRmEnable = true;
    3993     else
    3994     diff --git a/drivers/thermal/thermal_sysfs.c b/drivers/thermal/thermal_sysfs.c
    3995     index aa99edb4dff7d..4dce4a8f71ed9 100644
    3996     --- a/drivers/thermal/thermal_sysfs.c
    3997     +++ b/drivers/thermal/thermal_sysfs.c
    3998     @@ -770,6 +770,9 @@ void thermal_cooling_device_stats_update(struct thermal_cooling_device *cdev,
    3999     {
    4000     struct cooling_dev_stats *stats = cdev->stats;
    4001    
    4002     + if (!stats)
    4003     + return;
    4004     +
    4005     spin_lock(&stats->lock);
    4006    
    4007     if (stats->state == new_state)
    4008     diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
    4009     index 00bfc81f24702..2b672840dfd9a 100644
    4010     --- a/drivers/usb/class/cdc-acm.c
    4011     +++ b/drivers/usb/class/cdc-acm.c
    4012     @@ -147,17 +147,29 @@ static inline int acm_set_control(struct acm *acm, int control)
    4013     #define acm_send_break(acm, ms) \
    4014     acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
    4015    
    4016     -static void acm_kill_urbs(struct acm *acm)
    4017     +static void acm_poison_urbs(struct acm *acm)
    4018     {
    4019     int i;
    4020    
    4021     - usb_kill_urb(acm->ctrlurb);
    4022     + usb_poison_urb(acm->ctrlurb);
    4023     for (i = 0; i < ACM_NW; i++)
    4024     - usb_kill_urb(acm->wb[i].urb);
    4025     + usb_poison_urb(acm->wb[i].urb);
    4026     for (i = 0; i < acm->rx_buflimit; i++)
    4027     - usb_kill_urb(acm->read_urbs[i]);
    4028     + usb_poison_urb(acm->read_urbs[i]);
    4029     }
    4030    
    4031     +static void acm_unpoison_urbs(struct acm *acm)
    4032     +{
    4033     + int i;
    4034     +
    4035     + for (i = 0; i < acm->rx_buflimit; i++)
    4036     + usb_unpoison_urb(acm->read_urbs[i]);
    4037     + for (i = 0; i < ACM_NW; i++)
    4038     + usb_unpoison_urb(acm->wb[i].urb);
    4039     + usb_unpoison_urb(acm->ctrlurb);
    4040     +}
    4041     +
    4042     +
    4043     /*
    4044     * Write buffer management.
    4045     * All of these assume proper locks taken by the caller.
    4046     @@ -225,9 +237,10 @@ static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
    4047    
    4048     rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
    4049     if (rc < 0) {
    4050     - dev_err(&acm->data->dev,
    4051     - "%s - usb_submit_urb(write bulk) failed: %d\n",
    4052     - __func__, rc);
    4053     + if (rc != -EPERM)
    4054     + dev_err(&acm->data->dev,
    4055     + "%s - usb_submit_urb(write bulk) failed: %d\n",
    4056     + __func__, rc);
    4057     acm_write_done(acm, wb);
    4058     }
    4059     return rc;
    4060     @@ -312,8 +325,10 @@ static void acm_process_notification(struct acm *acm, unsigned char *buf)
    4061     acm->iocount.dsr++;
    4062     if (difference & ACM_CTRL_DCD)
    4063     acm->iocount.dcd++;
    4064     - if (newctrl & ACM_CTRL_BRK)
    4065     + if (newctrl & ACM_CTRL_BRK) {
    4066     acm->iocount.brk++;
    4067     + tty_insert_flip_char(&acm->port, 0, TTY_BREAK);
    4068     + }
    4069     if (newctrl & ACM_CTRL_RI)
    4070     acm->iocount.rng++;
    4071     if (newctrl & ACM_CTRL_FRAMING)
    4072     @@ -479,11 +494,6 @@ static void acm_read_bulk_callback(struct urb *urb)
    4073     dev_vdbg(&acm->data->dev, "got urb %d, len %d, status %d\n",
    4074     rb->index, urb->actual_length, status);
    4075    
    4076     - if (!acm->dev) {
    4077     - dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
    4078     - return;
    4079     - }
    4080     -
    4081     switch (status) {
    4082     case 0:
    4083     usb_mark_last_busy(acm->dev);
    4084     @@ -648,7 +658,8 @@ static void acm_port_dtr_rts(struct tty_port *port, int raise)
    4085    
    4086     res = acm_set_control(acm, val);
    4087     if (res && (acm->ctrl_caps & USB_CDC_CAP_LINE))
    4088     - dev_err(&acm->control->dev, "failed to set dtr/rts\n");
    4089     + /* This is broken in too many devices to spam the logs */
    4090     + dev_dbg(&acm->control->dev, "failed to set dtr/rts\n");
    4091     }
    4092    
    4093     static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
    4094     @@ -730,6 +741,7 @@ static void acm_port_shutdown(struct tty_port *port)
    4095     * Need to grab write_lock to prevent race with resume, but no need to
    4096     * hold it due to the tty-port initialised flag.
    4097     */
    4098     + acm_poison_urbs(acm);
    4099     spin_lock_irq(&acm->write_lock);
    4100     spin_unlock_irq(&acm->write_lock);
    4101    
    4102     @@ -746,7 +758,8 @@ static void acm_port_shutdown(struct tty_port *port)
    4103     usb_autopm_put_interface_async(acm->control);
    4104     }
    4105    
    4106     - acm_kill_urbs(acm);
    4107     + acm_unpoison_urbs(acm);
    4108     +
    4109     }
    4110    
    4111     static void acm_tty_cleanup(struct tty_struct *tty)
    4112     @@ -1516,12 +1529,16 @@ skip_countries:
    4113    
    4114     return 0;
    4115     alloc_fail6:
    4116     + if (!acm->combined_interfaces) {
    4117     + /* Clear driver data so that disconnect() returns early. */
    4118     + usb_set_intfdata(data_interface, NULL);
    4119     + usb_driver_release_interface(&acm_driver, data_interface);
    4120     + }
    4121     if (acm->country_codes) {
    4122     device_remove_file(&acm->control->dev,
    4123     &dev_attr_wCountryCodes);
    4124     device_remove_file(&acm->control->dev,
    4125     &dev_attr_iCountryCodeRelDate);
    4126     - kfree(acm->country_codes);
    4127     }
    4128     device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
    4129     alloc_fail5:
    4130     @@ -1553,8 +1570,14 @@ static void acm_disconnect(struct usb_interface *intf)
    4131     if (!acm)
    4132     return;
    4133    
    4134     - mutex_lock(&acm->mutex);
    4135     acm->disconnected = true;
    4136     + /*
    4137     + * there is a circular dependency. acm_softint() can resubmit
    4138     + * the URBs in error handling so we need to block any
    4139     + * submission right away
    4140     + */
    4141     + acm_poison_urbs(acm);
    4142     + mutex_lock(&acm->mutex);
    4143     if (acm->country_codes) {
    4144     device_remove_file(&acm->control->dev,
    4145     &dev_attr_wCountryCodes);
    4146     @@ -1573,7 +1596,6 @@ static void acm_disconnect(struct usb_interface *intf)
    4147     tty_kref_put(tty);
    4148     }
    4149    
    4150     - acm_kill_urbs(acm);
    4151     cancel_delayed_work_sync(&acm->dwork);
    4152    
    4153     tty_unregister_device(acm_tty_driver, acm->minor);
    4154     @@ -1615,7 +1637,7 @@ static int acm_suspend(struct usb_interface *intf, pm_message_t message)
    4155     if (cnt)
    4156     return 0;
    4157    
    4158     - acm_kill_urbs(acm);
    4159     + acm_poison_urbs(acm);
    4160     cancel_delayed_work_sync(&acm->dwork);
    4161     acm->urbs_in_error_delay = 0;
    4162    
    4163     @@ -1628,6 +1650,7 @@ static int acm_resume(struct usb_interface *intf)
    4164     struct urb *urb;
    4165     int rv = 0;
    4166    
    4167     + acm_unpoison_urbs(acm);
    4168     spin_lock_irq(&acm->write_lock);
    4169    
    4170     if (--acm->susp_count)
    4171     diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
    4172     index 239443ce52001..b8a4707dfafab 100644
    4173     --- a/drivers/usb/core/quirks.c
    4174     +++ b/drivers/usb/core/quirks.c
    4175     @@ -498,6 +498,10 @@ static const struct usb_device_id usb_quirk_list[] = {
    4176     /* DJI CineSSD */
    4177     { USB_DEVICE(0x2ca3, 0x0031), .driver_info = USB_QUIRK_NO_LPM },
    4178    
    4179     + /* Fibocom L850-GL LTE Modem */
    4180     + { USB_DEVICE(0x2cb7, 0x0007), .driver_info =
    4181     + USB_QUIRK_IGNORE_REMOTE_WAKEUP },
    4182     +
    4183     /* INTEL VALUE SSD */
    4184     { USB_DEVICE(0x8086, 0xf1a5), .driver_info = USB_QUIRK_RESET_RESUME },
    4185    
    4186     diff --git a/drivers/usb/dwc2/hcd.c b/drivers/usb/dwc2/hcd.c
    4187     index a91f2aa24118a..258056c822069 100644
    4188     --- a/drivers/usb/dwc2/hcd.c
    4189     +++ b/drivers/usb/dwc2/hcd.c
    4190     @@ -4322,7 +4322,8 @@ static int _dwc2_hcd_suspend(struct usb_hcd *hcd)
    4191     if (hsotg->op_state == OTG_STATE_B_PERIPHERAL)
    4192     goto unlock;
    4193    
    4194     - if (hsotg->params.power_down > DWC2_POWER_DOWN_PARAM_PARTIAL)
    4195     + if (hsotg->params.power_down != DWC2_POWER_DOWN_PARAM_PARTIAL ||
    4196     + hsotg->flags.b.port_connect_status == 0)
    4197     goto skip_power_saving;
    4198    
    4199     /*
    4200     @@ -5398,7 +5399,7 @@ int dwc2_host_enter_hibernation(struct dwc2_hsotg *hsotg)
    4201     dwc2_writel(hsotg, hprt0, HPRT0);
    4202    
    4203     /* Wait for the HPRT0.PrtSusp register field to be set */
    4204     - if (dwc2_hsotg_wait_bit_set(hsotg, HPRT0, HPRT0_SUSP, 3000))
    4205     + if (dwc2_hsotg_wait_bit_set(hsotg, HPRT0, HPRT0_SUSP, 5000))
    4206     dev_warn(hsotg->dev, "Suspend wasn't generated\n");
    4207    
    4208     /*
    4209     diff --git a/drivers/usb/gadget/udc/amd5536udc_pci.c b/drivers/usb/gadget/udc/amd5536udc_pci.c
    4210     index 57b6f66331cfa..362284057d307 100644
    4211     --- a/drivers/usb/gadget/udc/amd5536udc_pci.c
    4212     +++ b/drivers/usb/gadget/udc/amd5536udc_pci.c
    4213     @@ -154,6 +154,11 @@ static int udc_pci_probe(
    4214     pci_set_master(pdev);
    4215     pci_try_set_mwi(pdev);
    4216    
    4217     + dev->phys_addr = resource;
    4218     + dev->irq = pdev->irq;
    4219     + dev->pdev = pdev;
    4220     + dev->dev = &pdev->dev;
    4221     +
    4222     /* init dma pools */
    4223     if (use_dma) {
    4224     retval = init_dma_pools(dev);
    4225     @@ -161,11 +166,6 @@ static int udc_pci_probe(
    4226     goto err_dma;
    4227     }
    4228    
    4229     - dev->phys_addr = resource;
    4230     - dev->irq = pdev->irq;
    4231     - dev->pdev = pdev;
    4232     - dev->dev = &pdev->dev;
    4233     -
    4234     /* general probing */
    4235     if (udc_probe(dev)) {
    4236     retval = -ENODEV;
    4237     diff --git a/drivers/usb/host/xhci-mtk.c b/drivers/usb/host/xhci-mtk.c
    4238     index 09b67219fd146..5fc3ea6d46c56 100644
    4239     --- a/drivers/usb/host/xhci-mtk.c
    4240     +++ b/drivers/usb/host/xhci-mtk.c
    4241     @@ -397,6 +397,13 @@ static void xhci_mtk_quirks(struct device *dev, struct xhci_hcd *xhci)
    4242     xhci->quirks |= XHCI_SPURIOUS_SUCCESS;
    4243     if (mtk->lpm_support)
    4244     xhci->quirks |= XHCI_LPM_SUPPORT;
    4245     +
    4246     + /*
    4247     + * MTK xHCI 0.96: PSA is 1 by default even if doesn't support stream,
    4248     + * and it's 3 when support it.
    4249     + */
    4250     + if (xhci->hci_version < 0x100 && HCC_MAX_PSA(xhci->hcc_params) == 4)
    4251     + xhci->quirks |= XHCI_BROKEN_STREAMS;
    4252     }
    4253    
    4254     /* called during probe() after chip reset completes */
    4255     @@ -553,7 +560,8 @@ static int xhci_mtk_probe(struct platform_device *pdev)
    4256     if (ret)
    4257     goto put_usb3_hcd;
    4258    
    4259     - if (HCC_MAX_PSA(xhci->hcc_params) >= 4)
    4260     + if (HCC_MAX_PSA(xhci->hcc_params) >= 4 &&
    4261     + !(xhci->quirks & XHCI_BROKEN_STREAMS))
    4262     xhci->shared_hcd->can_do_streams = 1;
    4263    
    4264     ret = usb_add_hcd(xhci->shared_hcd, irq, IRQF_SHARED);
    4265     diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
    4266     index 9fcff4e94484e..166f68f639c28 100644
    4267     --- a/drivers/usb/musb/musb_core.c
    4268     +++ b/drivers/usb/musb/musb_core.c
    4269     @@ -1866,10 +1866,14 @@ static void musb_pm_runtime_check_session(struct musb *musb)
    4270     MUSB_DEVCTL_HR;
    4271     switch (devctl & ~s) {
    4272     case MUSB_QUIRK_B_DISCONNECT_99:
    4273     - musb_dbg(musb, "Poll devctl in case of suspend after disconnect\n");
    4274     - schedule_delayed_work(&musb->irq_work,
    4275     - msecs_to_jiffies(1000));
    4276     - break;
    4277     + if (musb->quirk_retries && !musb->flush_irq_work) {
    4278     + musb_dbg(musb, "Poll devctl in case of suspend after disconnect\n");
    4279     + schedule_delayed_work(&musb->irq_work,
    4280     + msecs_to_jiffies(1000));
    4281     + musb->quirk_retries--;
    4282     + break;
    4283     + }
    4284     + fallthrough;
    4285     case MUSB_QUIRK_B_INVALID_VBUS_91:
    4286     if (musb->quirk_retries && !musb->flush_irq_work) {
    4287     musb_dbg(musb,
    4288     diff --git a/drivers/usb/usbip/vhci_hcd.c b/drivers/usb/usbip/vhci_hcd.c
    4289     index fee511437abe3..1e0b618e2e6ec 100644
    4290     --- a/drivers/usb/usbip/vhci_hcd.c
    4291     +++ b/drivers/usb/usbip/vhci_hcd.c
    4292     @@ -595,6 +595,8 @@ static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
    4293     pr_err("invalid port number %d\n", wIndex);
    4294     goto error;
    4295     }
    4296     + if (wValue >= 32)
    4297     + goto error;
    4298     if (hcd->speed == HCD_USB3) {
    4299     if ((vhci_hcd->port_status[rhport] &
    4300     USB_SS_PORT_STAT_POWER) != 0) {
    4301     diff --git a/drivers/vfio/pci/Kconfig b/drivers/vfio/pci/Kconfig
    4302     index ac3c1dd3edeff..4abddbebd4b23 100644
    4303     --- a/drivers/vfio/pci/Kconfig
    4304     +++ b/drivers/vfio/pci/Kconfig
    4305     @@ -42,6 +42,6 @@ config VFIO_PCI_IGD
    4306    
    4307     config VFIO_PCI_NVLINK2
    4308     def_bool y
    4309     - depends on VFIO_PCI && PPC_POWERNV
    4310     + depends on VFIO_PCI && PPC_POWERNV && SPAPR_TCE_IOMMU
    4311     help
    4312     VFIO PCI support for P9 Witherspoon machine with NVIDIA V100 GPUs
    4313     diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c
    4314     index 57ab79fbcee95..a279ecacbf60a 100644
    4315     --- a/drivers/vhost/vhost.c
    4316     +++ b/drivers/vhost/vhost.c
    4317     @@ -320,8 +320,8 @@ static void vhost_vq_reset(struct vhost_dev *dev,
    4318     vq->kick = NULL;
    4319     vq->call_ctx = NULL;
    4320     vq->log_ctx = NULL;
    4321     - vhost_reset_is_le(vq);
    4322     vhost_disable_cross_endian(vq);
    4323     + vhost_reset_is_le(vq);
    4324     vq->busyloop_timeout = 0;
    4325     vq->umem = NULL;
    4326     vq->iotlb = NULL;
    4327     diff --git a/drivers/video/fbdev/core/fbcon.c b/drivers/video/fbdev/core/fbcon.c
    4328     index 4cf71ee0965a6..0a9202176ffc9 100644
    4329     --- a/drivers/video/fbdev/core/fbcon.c
    4330     +++ b/drivers/video/fbdev/core/fbcon.c
    4331     @@ -1339,6 +1339,9 @@ static void fbcon_cursor(struct vc_data *vc, int mode)
    4332    
    4333     ops->cursor_flash = (mode == CM_ERASE) ? 0 : 1;
    4334    
    4335     + if (!ops->cursor)
    4336     + return;
    4337     +
    4338     ops->cursor(vc, info, mode, get_color(vc, info, c, 1),
    4339     get_color(vc, info, c, 0));
    4340     }
    4341     diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
    4342     index 5aba67a504cf8..031ff3f190184 100644
    4343     --- a/fs/ext4/balloc.c
    4344     +++ b/fs/ext4/balloc.c
    4345     @@ -612,27 +612,41 @@ int ext4_claim_free_clusters(struct ext4_sb_info *sbi,
    4346    
    4347     /**
    4348     * ext4_should_retry_alloc() - check if a block allocation should be retried
    4349     - * @sb: super block
    4350     - * @retries: number of attemps has been made
    4351     + * @sb: superblock
    4352     + * @retries: number of retry attempts made so far
    4353     *
    4354     - * ext4_should_retry_alloc() is called when ENOSPC is returned, and if
    4355     - * it is profitable to retry the operation, this function will wait
    4356     - * for the current or committing transaction to complete, and then
    4357     - * return TRUE. We will only retry once.
    4358     + * ext4_should_retry_alloc() is called when ENOSPC is returned while
    4359     + * attempting to allocate blocks. If there's an indication that a pending
    4360     + * journal transaction might free some space and allow another attempt to
    4361     + * succeed, this function will wait for the current or committing transaction
    4362     + * to complete and then return TRUE.
    4363     */
    4364     int ext4_should_retry_alloc(struct super_block *sb, int *retries)
    4365     {
    4366     - if (!ext4_has_free_clusters(EXT4_SB(sb), 1, 0) ||
    4367     - (*retries)++ > 1 ||
    4368     - !EXT4_SB(sb)->s_journal)
    4369     + struct ext4_sb_info *sbi = EXT4_SB(sb);
    4370     +
    4371     + if (!sbi->s_journal)
    4372     return 0;
    4373    
    4374     - smp_mb();
    4375     - if (EXT4_SB(sb)->s_mb_free_pending == 0)
    4376     + if (++(*retries) > 3) {
    4377     + percpu_counter_inc(&sbi->s_sra_exceeded_retry_limit);
    4378     return 0;
    4379     + }
    4380    
    4381     + /*
    4382     + * if there's no indication that blocks are about to be freed it's
    4383     + * possible we just missed a transaction commit that did so
    4384     + */
    4385     + smp_mb();
    4386     + if (sbi->s_mb_free_pending == 0)
    4387     + return ext4_has_free_clusters(sbi, 1, 0);
    4388     +
    4389     + /*
    4390     + * it's possible we've just missed a transaction commit here,
    4391     + * so ignore the returned status
    4392     + */
    4393     jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);
    4394     - jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal);
    4395     + (void) jbd2_journal_force_commit_nested(sbi->s_journal);
    4396     return 1;
    4397     }
    4398    
    4399     diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
    4400     index 1c558b5547889..bf3eaa9030335 100644
    4401     --- a/fs/ext4/ext4.h
    4402     +++ b/fs/ext4/ext4.h
    4403     @@ -1420,6 +1420,7 @@ struct ext4_sb_info {
    4404     struct percpu_counter s_freeinodes_counter;
    4405     struct percpu_counter s_dirs_counter;
    4406     struct percpu_counter s_dirtyclusters_counter;
    4407     + struct percpu_counter s_sra_exceeded_retry_limit;
    4408     struct blockgroup_lock *s_blockgroup_lock;
    4409     struct proc_dir_entry *s_proc;
    4410     struct kobject s_kobj;
    4411     diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
    4412     index efce97b938b7a..1429d01d836bb 100644
    4413     --- a/fs/ext4/inode.c
    4414     +++ b/fs/ext4/inode.c
    4415     @@ -2076,13 +2076,13 @@ static int __ext4_journalled_writepage(struct page *page,
    4416     if (!ret)
    4417     ret = err;
    4418    
    4419     - if (!ext4_has_inline_data(inode))
    4420     - ext4_walk_page_buffers(NULL, page_bufs, 0, len,
    4421     - NULL, bput_one);
    4422     ext4_set_inode_state(inode, EXT4_STATE_JDATA);
    4423     out:
    4424     unlock_page(page);
    4425     out_no_pagelock:
    4426     + if (!inline_data && page_bufs)
    4427     + ext4_walk_page_buffers(NULL, page_bufs, 0, len,
    4428     + NULL, bput_one);
    4429     brelse(inode_bh);
    4430     return ret;
    4431     }
    4432     diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
    4433     index e992a9f156714..4c37abe768512 100644
    4434     --- a/fs/ext4/namei.c
    4435     +++ b/fs/ext4/namei.c
    4436     @@ -3731,14 +3731,14 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
    4437     */
    4438     retval = -ENOENT;
    4439     if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino)
    4440     - goto end_rename;
    4441     + goto release_bh;
    4442    
    4443     new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
    4444     &new.de, &new.inlined);
    4445     if (IS_ERR(new.bh)) {
    4446     retval = PTR_ERR(new.bh);
    4447     new.bh = NULL;
    4448     - goto end_rename;
    4449     + goto release_bh;
    4450     }
    4451     if (new.bh) {
    4452     if (!new.inode) {
    4453     @@ -3755,15 +3755,13 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
    4454     handle = ext4_journal_start(old.dir, EXT4_HT_DIR, credits);
    4455     if (IS_ERR(handle)) {
    4456     retval = PTR_ERR(handle);
    4457     - handle = NULL;
    4458     - goto end_rename;
    4459     + goto release_bh;
    4460     }
    4461     } else {
    4462     whiteout = ext4_whiteout_for_rename(&old, credits, &handle);
    4463     if (IS_ERR(whiteout)) {
    4464     retval = PTR_ERR(whiteout);
    4465     - whiteout = NULL;
    4466     - goto end_rename;
    4467     + goto release_bh;
    4468     }
    4469     }
    4470    
    4471     @@ -3871,16 +3869,18 @@ end_rename:
    4472     ext4_resetent(handle, &old,
    4473     old.inode->i_ino, old_file_type);
    4474     drop_nlink(whiteout);
    4475     + ext4_orphan_add(handle, whiteout);
    4476     }
    4477     unlock_new_inode(whiteout);
    4478     + ext4_journal_stop(handle);
    4479     iput(whiteout);
    4480     -
    4481     + } else {
    4482     + ext4_journal_stop(handle);
    4483     }
    4484     +release_bh:
    4485     brelse(old.dir_bh);
    4486     brelse(old.bh);
    4487     brelse(new.bh);
    4488     - if (handle)
    4489     - ext4_journal_stop(handle);
    4490     return retval;
    4491     }
    4492    
    4493     diff --git a/fs/ext4/super.c b/fs/ext4/super.c
    4494     index 06568467b0c27..2ecf4594a20dd 100644
    4495     --- a/fs/ext4/super.c
    4496     +++ b/fs/ext4/super.c
    4497     @@ -1017,6 +1017,7 @@ static void ext4_put_super(struct super_block *sb)
    4498     percpu_counter_destroy(&sbi->s_freeinodes_counter);
    4499     percpu_counter_destroy(&sbi->s_dirs_counter);
    4500     percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
    4501     + percpu_counter_destroy(&sbi->s_sra_exceeded_retry_limit);
    4502     percpu_free_rwsem(&sbi->s_writepages_rwsem);
    4503     #ifdef CONFIG_QUOTA
    4504     for (i = 0; i < EXT4_MAXQUOTAS; i++)
    4505     @@ -4597,6 +4598,9 @@ no_journal:
    4506     if (!err)
    4507     err = percpu_counter_init(&sbi->s_dirtyclusters_counter, 0,
    4508     GFP_KERNEL);
    4509     + if (!err)
    4510     + err = percpu_counter_init(&sbi->s_sra_exceeded_retry_limit, 0,
    4511     + GFP_KERNEL);
    4512     if (!err)
    4513     err = percpu_init_rwsem(&sbi->s_writepages_rwsem);
    4514    
    4515     @@ -4699,6 +4703,7 @@ failed_mount6:
    4516     percpu_counter_destroy(&sbi->s_freeinodes_counter);
    4517     percpu_counter_destroy(&sbi->s_dirs_counter);
    4518     percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
    4519     + percpu_counter_destroy(&sbi->s_sra_exceeded_retry_limit);
    4520     percpu_free_rwsem(&sbi->s_writepages_rwsem);
    4521     failed_mount5:
    4522     ext4_ext_release(sb);
    4523     diff --git a/fs/ext4/sysfs.c b/fs/ext4/sysfs.c
    4524     index eb1efad0e20a3..9394360ff1373 100644
    4525     --- a/fs/ext4/sysfs.c
    4526     +++ b/fs/ext4/sysfs.c
    4527     @@ -23,6 +23,7 @@ typedef enum {
    4528     attr_session_write_kbytes,
    4529     attr_lifetime_write_kbytes,
    4530     attr_reserved_clusters,
    4531     + attr_sra_exceeded_retry_limit,
    4532     attr_inode_readahead,
    4533     attr_trigger_test_error,
    4534     attr_first_error_time,
    4535     @@ -176,6 +177,7 @@ EXT4_ATTR_FUNC(delayed_allocation_blocks, 0444);
    4536     EXT4_ATTR_FUNC(session_write_kbytes, 0444);
    4537     EXT4_ATTR_FUNC(lifetime_write_kbytes, 0444);
    4538     EXT4_ATTR_FUNC(reserved_clusters, 0644);
    4539     +EXT4_ATTR_FUNC(sra_exceeded_retry_limit, 0444);
    4540    
    4541     EXT4_ATTR_OFFSET(inode_readahead_blks, 0644, inode_readahead,
    4542     ext4_sb_info, s_inode_readahead_blks);
    4543     @@ -207,6 +209,7 @@ static struct attribute *ext4_attrs[] = {
    4544     ATTR_LIST(session_write_kbytes),
    4545     ATTR_LIST(lifetime_write_kbytes),
    4546     ATTR_LIST(reserved_clusters),
    4547     + ATTR_LIST(sra_exceeded_retry_limit),
    4548     ATTR_LIST(inode_readahead_blks),
    4549     ATTR_LIST(inode_goal),
    4550     ATTR_LIST(mb_stats),
    4551     @@ -308,6 +311,10 @@ static ssize_t ext4_attr_show(struct kobject *kobj,
    4552     return snprintf(buf, PAGE_SIZE, "%llu\n",
    4553     (unsigned long long)
    4554     atomic64_read(&sbi->s_resv_clusters));
    4555     + case attr_sra_exceeded_retry_limit:
    4556     + return snprintf(buf, PAGE_SIZE, "%llu\n",
    4557     + (unsigned long long)
    4558     + percpu_counter_sum(&sbi->s_sra_exceeded_retry_limit));
    4559     case attr_inode_readahead:
    4560     case attr_pointer_ui:
    4561     if (!ptr)
    4562     diff --git a/fs/iomap/swapfile.c b/fs/iomap/swapfile.c
    4563     index 152a230f668d4..bd0cc3dcc9807 100644
    4564     --- a/fs/iomap/swapfile.c
    4565     +++ b/fs/iomap/swapfile.c
    4566     @@ -169,6 +169,16 @@ int iomap_swapfile_activate(struct swap_info_struct *sis,
    4567     return ret;
    4568     }
    4569    
    4570     + /*
    4571     + * If this swapfile doesn't contain even a single page-aligned
    4572     + * contiguous range of blocks, reject this useless swapfile to
    4573     + * prevent confusion later on.
    4574     + */
    4575     + if (isi.nr_pages == 0) {
    4576     + pr_warn("swapon: Cannot find a single usable page in file.\n");
    4577     + return -EINVAL;
    4578     + }
    4579     +
    4580     *pagespan = 1 + isi.highest_ppage - isi.lowest_ppage;
    4581     sis->max = isi.nr_pages;
    4582     sis->pages = isi.nr_pages - 1;
    4583     diff --git a/fs/nfsd/Kconfig b/fs/nfsd/Kconfig
    4584     index f2f81561ebb65..4d6e71335bce2 100644
    4585     --- a/fs/nfsd/Kconfig
    4586     +++ b/fs/nfsd/Kconfig
    4587     @@ -73,6 +73,7 @@ config NFSD_V4
    4588     select NFSD_V3
    4589     select FS_POSIX_ACL
    4590     select SUNRPC_GSS
    4591     + select CRYPTO
    4592     select CRYPTO_MD5
    4593     select CRYPTO_SHA256
    4594     select GRACE_PERIOD
    4595     diff --git a/fs/nfsd/nfs4callback.c b/fs/nfsd/nfs4callback.c
    4596     index efe55d101b0ed..3c50d18fe8a9b 100644
    4597     --- a/fs/nfsd/nfs4callback.c
    4598     +++ b/fs/nfsd/nfs4callback.c
    4599     @@ -1121,6 +1121,7 @@ static void nfsd4_cb_done(struct rpc_task *task, void *calldata)
    4600     switch (task->tk_status) {
    4601     case -EIO:
    4602     case -ETIMEDOUT:
    4603     + case -EACCES:
    4604     nfsd4_mark_cb_down(clp, task->tk_status);
    4605     }
    4606     break;
    4607     diff --git a/fs/reiserfs/xattr.h b/fs/reiserfs/xattr.h
    4608     index c764352447ba1..81bec2c80b25c 100644
    4609     --- a/fs/reiserfs/xattr.h
    4610     +++ b/fs/reiserfs/xattr.h
    4611     @@ -43,7 +43,7 @@ void reiserfs_security_free(struct reiserfs_security_handle *sec);
    4612    
    4613     static inline int reiserfs_xattrs_initialized(struct super_block *sb)
    4614     {
    4615     - return REISERFS_SB(sb)->priv_root != NULL;
    4616     + return REISERFS_SB(sb)->priv_root && REISERFS_SB(sb)->xattr_root;
    4617     }
    4618    
    4619     #define xattr_size(size) ((size) + sizeof(struct reiserfs_xattr_header))
    4620     diff --git a/include/linux/can/can-ml.h b/include/linux/can/can-ml.h
    4621     index 2f5d731ae251d..8afa92d15a664 100644
    4622     --- a/include/linux/can/can-ml.h
    4623     +++ b/include/linux/can/can-ml.h
    4624     @@ -44,6 +44,7 @@
    4625    
    4626     #include <linux/can.h>
    4627     #include <linux/list.h>
    4628     +#include <linux/netdevice.h>
    4629    
    4630     #define CAN_SFF_RCV_ARRAY_SZ (1 << CAN_SFF_ID_BITS)
    4631     #define CAN_EFF_RCV_HASH_BITS 10
    4632     @@ -65,4 +66,15 @@ struct can_ml_priv {
    4633     #endif
    4634     };
    4635    
    4636     +static inline struct can_ml_priv *can_get_ml_priv(struct net_device *dev)
    4637     +{
    4638     + return netdev_get_ml_priv(dev, ML_PRIV_CAN);
    4639     +}
    4640     +
    4641     +static inline void can_set_ml_priv(struct net_device *dev,
    4642     + struct can_ml_priv *ml_priv)
    4643     +{
    4644     + netdev_set_ml_priv(dev, ml_priv, ML_PRIV_CAN);
    4645     +}
    4646     +
    4647     #endif /* CAN_ML_H */
    4648     diff --git a/include/linux/extcon.h b/include/linux/extcon.h
    4649     index 2bdf643d85937..47d3e19a49ae4 100644
    4650     --- a/include/linux/extcon.h
    4651     +++ b/include/linux/extcon.h
    4652     @@ -271,6 +271,29 @@ static inline void devm_extcon_unregister_notifier(struct device *dev,
    4653     struct extcon_dev *edev, unsigned int id,
    4654     struct notifier_block *nb) { }
    4655    
    4656     +static inline int extcon_register_notifier_all(struct extcon_dev *edev,
    4657     + struct notifier_block *nb)
    4658     +{
    4659     + return 0;
    4660     +}
    4661     +
    4662     +static inline int extcon_unregister_notifier_all(struct extcon_dev *edev,
    4663     + struct notifier_block *nb)
    4664     +{
    4665     + return 0;
    4666     +}
    4667     +
    4668     +static inline int devm_extcon_register_notifier_all(struct device *dev,
    4669     + struct extcon_dev *edev,
    4670     + struct notifier_block *nb)
    4671     +{
    4672     + return 0;
    4673     +}
    4674     +
    4675     +static inline void devm_extcon_unregister_notifier_all(struct device *dev,
    4676     + struct extcon_dev *edev,
    4677     + struct notifier_block *nb) { }
    4678     +
    4679     static inline struct extcon_dev *extcon_get_extcon_dev(const char *extcon_name)
    4680     {
    4681     return ERR_PTR(-ENODEV);
    4682     diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
    4683     index db1b9623977c8..11a52f2fa35de 100644
    4684     --- a/include/linux/netdevice.h
    4685     +++ b/include/linux/netdevice.h
    4686     @@ -1555,6 +1555,12 @@ enum netdev_priv_flags {
    4687     #define IFF_L3MDEV_RX_HANDLER IFF_L3MDEV_RX_HANDLER
    4688     #define IFF_LIVE_RENAME_OK IFF_LIVE_RENAME_OK
    4689    
    4690     +/* Specifies the type of the struct net_device::ml_priv pointer */
    4691     +enum netdev_ml_priv_type {
    4692     + ML_PRIV_NONE,
    4693     + ML_PRIV_CAN,
    4694     +};
    4695     +
    4696     /**
    4697     * struct net_device - The DEVICE structure.
    4698     *
    4699     @@ -1732,6 +1738,7 @@ enum netdev_priv_flags {
    4700     * @nd_net: Network namespace this network device is inside
    4701     *
    4702     * @ml_priv: Mid-layer private
    4703     + * @ml_priv_type: Mid-layer private type
    4704     * @lstats: Loopback statistics
    4705     * @tstats: Tunnel statistics
    4706     * @dstats: Dummy statistics
    4707     @@ -2019,8 +2026,10 @@ struct net_device {
    4708     possible_net_t nd_net;
    4709    
    4710     /* mid-layer private */
    4711     + void *ml_priv;
    4712     + enum netdev_ml_priv_type ml_priv_type;
    4713     +
    4714     union {
    4715     - void *ml_priv;
    4716     struct pcpu_lstats __percpu *lstats;
    4717     struct pcpu_sw_netstats __percpu *tstats;
    4718     struct pcpu_dstats __percpu *dstats;
    4719     @@ -2167,6 +2176,29 @@ static inline void netdev_reset_rx_headroom(struct net_device *dev)
    4720     netdev_set_rx_headroom(dev, -1);
    4721     }
    4722    
    4723     +static inline void *netdev_get_ml_priv(struct net_device *dev,
    4724     + enum netdev_ml_priv_type type)
    4725     +{
    4726     + if (dev->ml_priv_type != type)
    4727     + return NULL;
    4728     +
    4729     + return dev->ml_priv;
    4730     +}
    4731     +
    4732     +static inline void netdev_set_ml_priv(struct net_device *dev,
    4733     + void *ml_priv,
    4734     + enum netdev_ml_priv_type type)
    4735     +{
    4736     + WARN(dev->ml_priv_type && dev->ml_priv_type != type,
    4737     + "Overwriting already set ml_priv_type (%u) with different ml_priv_type (%u)!\n",
    4738     + dev->ml_priv_type, type);
    4739     + WARN(!dev->ml_priv_type && dev->ml_priv,
    4740     + "Overwriting already set ml_priv and ml_priv_type is ML_PRIV_NONE!\n");
    4741     +
    4742     + dev->ml_priv = ml_priv;
    4743     + dev->ml_priv_type = type;
    4744     +}
    4745     +
    4746     /*
    4747     * Net namespace inlines
    4748     */
    4749     diff --git a/kernel/locking/mutex.c b/kernel/locking/mutex.c
    4750     index 468a9b8422e39..07a9f9f46e035 100644
    4751     --- a/kernel/locking/mutex.c
    4752     +++ b/kernel/locking/mutex.c
    4753     @@ -636,7 +636,7 @@ static inline int mutex_can_spin_on_owner(struct mutex *lock)
    4754     */
    4755     static __always_inline bool
    4756     mutex_optimistic_spin(struct mutex *lock, struct ww_acquire_ctx *ww_ctx,
    4757     - const bool use_ww_ctx, struct mutex_waiter *waiter)
    4758     + struct mutex_waiter *waiter)
    4759     {
    4760     if (!waiter) {
    4761     /*
    4762     @@ -712,7 +712,7 @@ fail:
    4763     #else
    4764     static __always_inline bool
    4765     mutex_optimistic_spin(struct mutex *lock, struct ww_acquire_ctx *ww_ctx,
    4766     - const bool use_ww_ctx, struct mutex_waiter *waiter)
    4767     + struct mutex_waiter *waiter)
    4768     {
    4769     return false;
    4770     }
    4771     @@ -932,6 +932,9 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
    4772     struct ww_mutex *ww;
    4773     int ret;
    4774    
    4775     + if (!use_ww_ctx)
    4776     + ww_ctx = NULL;
    4777     +
    4778     might_sleep();
    4779    
    4780     #ifdef CONFIG_DEBUG_MUTEXES
    4781     @@ -939,7 +942,7 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
    4782     #endif
    4783    
    4784     ww = container_of(lock, struct ww_mutex, base);
    4785     - if (use_ww_ctx && ww_ctx) {
    4786     + if (ww_ctx) {
    4787     if (unlikely(ww_ctx == READ_ONCE(ww->ctx)))
    4788     return -EALREADY;
    4789    
    4790     @@ -956,10 +959,10 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
    4791     mutex_acquire_nest(&lock->dep_map, subclass, 0, nest_lock, ip);
    4792    
    4793     if (__mutex_trylock(lock) ||
    4794     - mutex_optimistic_spin(lock, ww_ctx, use_ww_ctx, NULL)) {
    4795     + mutex_optimistic_spin(lock, ww_ctx, NULL)) {
    4796     /* got the lock, yay! */
    4797     lock_acquired(&lock->dep_map, ip);
    4798     - if (use_ww_ctx && ww_ctx)
    4799     + if (ww_ctx)
    4800     ww_mutex_set_context_fastpath(ww, ww_ctx);
    4801     preempt_enable();
    4802     return 0;
    4803     @@ -970,7 +973,7 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
    4804     * After waiting to acquire the wait_lock, try again.
    4805     */
    4806     if (__mutex_trylock(lock)) {
    4807     - if (use_ww_ctx && ww_ctx)
    4808     + if (ww_ctx)
    4809     __ww_mutex_check_waiters(lock, ww_ctx);
    4810    
    4811     goto skip_wait;
    4812     @@ -1023,7 +1026,7 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
    4813     goto err;
    4814     }
    4815    
    4816     - if (use_ww_ctx && ww_ctx) {
    4817     + if (ww_ctx) {
    4818     ret = __ww_mutex_check_kill(lock, &waiter, ww_ctx);
    4819     if (ret)
    4820     goto err;
    4821     @@ -1036,7 +1039,7 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
    4822     * ww_mutex needs to always recheck its position since its waiter
    4823     * list is not FIFO ordered.
    4824     */
    4825     - if ((use_ww_ctx && ww_ctx) || !first) {
    4826     + if (ww_ctx || !first) {
    4827     first = __mutex_waiter_is_first(lock, &waiter);
    4828     if (first)
    4829     __mutex_set_flag(lock, MUTEX_FLAG_HANDOFF);
    4830     @@ -1049,7 +1052,7 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
    4831     * or we must see its unlock and acquire.
    4832     */
    4833     if (__mutex_trylock(lock) ||
    4834     - (first && mutex_optimistic_spin(lock, ww_ctx, use_ww_ctx, &waiter)))
    4835     + (first && mutex_optimistic_spin(lock, ww_ctx, &waiter)))
    4836     break;
    4837    
    4838     spin_lock(&lock->wait_lock);
    4839     @@ -1058,7 +1061,7 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
    4840     acquired:
    4841     __set_current_state(TASK_RUNNING);
    4842    
    4843     - if (use_ww_ctx && ww_ctx) {
    4844     + if (ww_ctx) {
    4845     /*
    4846     * Wound-Wait; we stole the lock (!first_waiter), check the
    4847     * waiters as anyone might want to wound us.
    4848     @@ -1078,7 +1081,7 @@ skip_wait:
    4849     /* got the lock - cleanup and rejoice! */
    4850     lock_acquired(&lock->dep_map, ip);
    4851    
    4852     - if (use_ww_ctx && ww_ctx)
    4853     + if (ww_ctx)
    4854     ww_mutex_lock_acquired(ww, ww_ctx);
    4855    
    4856     spin_unlock(&lock->wait_lock);
    4857     diff --git a/kernel/module.c b/kernel/module.c
    4858     index ab1f97cfe18dc..c60559b5bf101 100644
    4859     --- a/kernel/module.c
    4860     +++ b/kernel/module.c
    4861     @@ -2908,20 +2908,14 @@ static int module_sig_check(struct load_info *info, int flags)
    4862     * enforcing, certain errors are non-fatal.
    4863     */
    4864     case -ENODATA:
    4865     - reason = "Loading of unsigned module";
    4866     - goto decide;
    4867     + reason = "unsigned module";
    4868     + break;
    4869     case -ENOPKG:
    4870     - reason = "Loading of module with unsupported crypto";
    4871     - goto decide;
    4872     + reason = "module with unsupported crypto";
    4873     + break;
    4874     case -ENOKEY:
    4875     - reason = "Loading of module with unavailable key";
    4876     - decide:
    4877     - if (is_module_sig_enforced()) {
    4878     - pr_notice("%s is rejected\n", reason);
    4879     - return -EKEYREJECTED;
    4880     - }
    4881     -
    4882     - return security_locked_down(LOCKDOWN_MODULE_SIGNATURE);
    4883     + reason = "module with unavailable key";
    4884     + break;
    4885    
    4886     /* All other errors are fatal, including nomem, unparseable
    4887     * signatures and signature check failures - even if signatures
    4888     @@ -2930,6 +2924,13 @@ static int module_sig_check(struct load_info *info, int flags)
    4889     default:
    4890     return err;
    4891     }
    4892     +
    4893     + if (is_module_sig_enforced()) {
    4894     + pr_notice("Loading of %s is rejected\n", reason);
    4895     + return -EKEYREJECTED;
    4896     + }
    4897     +
    4898     + return security_locked_down(LOCKDOWN_MODULE_SIGNATURE);
    4899     }
    4900     #else /* !CONFIG_MODULE_SIG */
    4901     static int module_sig_check(struct load_info *info, int flags)
    4902     @@ -2938,9 +2939,33 @@ static int module_sig_check(struct load_info *info, int flags)
    4903     }
    4904     #endif /* !CONFIG_MODULE_SIG */
    4905    
    4906     -/* Sanity checks against invalid binaries, wrong arch, weird elf version. */
    4907     -static int elf_header_check(struct load_info *info)
    4908     +static int validate_section_offset(struct load_info *info, Elf_Shdr *shdr)
    4909     +{
    4910     + unsigned long secend;
    4911     +
    4912     + /*
    4913     + * Check for both overflow and offset/size being
    4914     + * too large.
    4915     + */
    4916     + secend = shdr->sh_offset + shdr->sh_size;
    4917     + if (secend < shdr->sh_offset || secend > info->len)
    4918     + return -ENOEXEC;
    4919     +
    4920     + return 0;
    4921     +}
    4922     +
    4923     +/*
    4924     + * Sanity checks against invalid binaries, wrong arch, weird elf version.
    4925     + *
    4926     + * Also do basic validity checks against section offsets and sizes, the
    4927     + * section name string table, and the indices used for it (sh_name).
    4928     + */
    4929     +static int elf_validity_check(struct load_info *info)
    4930     {
    4931     + unsigned int i;
    4932     + Elf_Shdr *shdr, *strhdr;
    4933     + int err;
    4934     +
    4935     if (info->len < sizeof(*(info->hdr)))
    4936     return -ENOEXEC;
    4937    
    4938     @@ -2950,11 +2975,78 @@ static int elf_header_check(struct load_info *info)
    4939     || info->hdr->e_shentsize != sizeof(Elf_Shdr))
    4940     return -ENOEXEC;
    4941    
    4942     + /*
    4943     + * e_shnum is 16 bits, and sizeof(Elf_Shdr) is
    4944     + * known and small. So e_shnum * sizeof(Elf_Shdr)
    4945     + * will not overflow unsigned long on any platform.
    4946     + */
    4947     if (info->hdr->e_shoff >= info->len
    4948     || (info->hdr->e_shnum * sizeof(Elf_Shdr) >
    4949     info->len - info->hdr->e_shoff))
    4950     return -ENOEXEC;
    4951    
    4952     + info->sechdrs = (void *)info->hdr + info->hdr->e_shoff;
    4953     +
    4954     + /*
    4955     + * Verify if the section name table index is valid.
    4956     + */
    4957     + if (info->hdr->e_shstrndx == SHN_UNDEF
    4958     + || info->hdr->e_shstrndx >= info->hdr->e_shnum)
    4959     + return -ENOEXEC;
    4960     +
    4961     + strhdr = &info->sechdrs[info->hdr->e_shstrndx];
    4962     + err = validate_section_offset(info, strhdr);
    4963     + if (err < 0)
    4964     + return err;
    4965     +
    4966     + /*
    4967     + * The section name table must be NUL-terminated, as required
    4968     + * by the spec. This makes strcmp and pr_* calls that access
    4969     + * strings in the section safe.
    4970     + */
    4971     + info->secstrings = (void *)info->hdr + strhdr->sh_offset;
    4972     + if (info->secstrings[strhdr->sh_size - 1] != '\0')
    4973     + return -ENOEXEC;
    4974     +
    4975     + /*
    4976     + * The code assumes that section 0 has a length of zero and
    4977     + * an addr of zero, so check for it.
    4978     + */
    4979     + if (info->sechdrs[0].sh_type != SHT_NULL
    4980     + || info->sechdrs[0].sh_size != 0
    4981     + || info->sechdrs[0].sh_addr != 0)
    4982     + return -ENOEXEC;
    4983     +
    4984     + for (i = 1; i < info->hdr->e_shnum; i++) {
    4985     + shdr = &info->sechdrs[i];
    4986     + switch (shdr->sh_type) {
    4987     + case SHT_NULL:
    4988     + case SHT_NOBITS:
    4989     + continue;
    4990     + case SHT_SYMTAB:
    4991     + if (shdr->sh_link == SHN_UNDEF
    4992     + || shdr->sh_link >= info->hdr->e_shnum)
    4993     + return -ENOEXEC;
    4994     + fallthrough;
    4995     + default:
    4996     + err = validate_section_offset(info, shdr);
    4997     + if (err < 0) {
    4998     + pr_err("Invalid ELF section in module (section %u type %u)\n",
    4999     + i, shdr->sh_type);
    5000     + return err;
    5001     + }
    5002     +
    5003     + if (shdr->sh_flags & SHF_ALLOC) {
    5004     + if (shdr->sh_name >= strhdr->sh_size) {
    5005     + pr_err("Invalid ELF section name in module (section %u type %u)\n",
    5006     + i, shdr->sh_type);
    5007     + return -ENOEXEC;
    5008     + }
    5009     + }
    5010     + break;
    5011     + }
    5012     + }
    5013     +
    5014     return 0;
    5015     }
    5016    
    5017     @@ -3051,11 +3143,6 @@ static int rewrite_section_headers(struct load_info *info, int flags)
    5018    
    5019     for (i = 1; i < info->hdr->e_shnum; i++) {
    5020     Elf_Shdr *shdr = &info->sechdrs[i];
    5021     - if (shdr->sh_type != SHT_NOBITS
    5022     - && info->len < shdr->sh_offset + shdr->sh_size) {
    5023     - pr_err("Module len %lu truncated\n", info->len);
    5024     - return -ENOEXEC;
    5025     - }
    5026    
    5027     /* Mark all sections sh_addr with their address in the
    5028     temporary image. */
    5029     @@ -3087,11 +3174,6 @@ static int setup_load_info(struct load_info *info, int flags)
    5030     {
    5031     unsigned int i;
    5032    
    5033     - /* Set up the convenience variables */
    5034     - info->sechdrs = (void *)info->hdr + info->hdr->e_shoff;
    5035     - info->secstrings = (void *)info->hdr
    5036     - + info->sechdrs[info->hdr->e_shstrndx].sh_offset;
    5037     -
    5038     /* Try to find a name early so we can log errors with a module name */
    5039     info->index.info = find_sec(info, ".modinfo");
    5040     if (info->index.info)
    5041     @@ -3819,23 +3901,49 @@ static int load_module(struct load_info *info, const char __user *uargs,
    5042     long err = 0;
    5043     char *after_dashes;
    5044    
    5045     - err = elf_header_check(info);
    5046     + /*
    5047     + * Do the signature check (if any) first. All that
    5048     + * the signature check needs is info->len, it does
    5049     + * not need any of the section info. That can be
    5050     + * set up later. This will minimize the chances
    5051     + * of a corrupt module causing problems before
    5052     + * we even get to the signature check.
    5053     + *
    5054     + * The check will also adjust info->len by stripping
    5055     + * off the sig length at the end of the module, making
    5056     + * checks against info->len more correct.
    5057     + */
    5058     + err = module_sig_check(info, flags);
    5059     if (err)
    5060     goto free_copy;
    5061    
    5062     + /*
    5063     + * Do basic sanity checks against the ELF header and
    5064     + * sections.
    5065     + */
    5066     + err = elf_validity_check(info);
    5067     + if (err) {
    5068     + pr_err("Module has invalid ELF structures\n");
    5069     + goto free_copy;
    5070     + }
    5071     +
    5072     + /*
    5073     + * Everything checks out, so set up the section info
    5074     + * in the info structure.
    5075     + */
    5076     err = setup_load_info(info, flags);
    5077     if (err)
    5078     goto free_copy;
    5079    
    5080     + /*
    5081     + * Now that we know we have the correct module name, check
    5082     + * if it's blacklisted.
    5083     + */
    5084     if (blacklisted(info->name)) {
    5085     err = -EPERM;
    5086     goto free_copy;
    5087     }
    5088    
    5089     - err = module_sig_check(info, flags);
    5090     - if (err)
    5091     - goto free_copy;
    5092     -
    5093     err = rewrite_section_headers(info, flags);
    5094     if (err)
    5095     goto free_copy;
    5096     diff --git a/kernel/module_signature.c b/kernel/module_signature.c
    5097     index 4224a1086b7d8..00132d12487cd 100644
    5098     --- a/kernel/module_signature.c
    5099     +++ b/kernel/module_signature.c
    5100     @@ -25,7 +25,7 @@ int mod_check_sig(const struct module_signature *ms, size_t file_len,
    5101     return -EBADMSG;
    5102    
    5103     if (ms->id_type != PKEY_ID_PKCS7) {
    5104     - pr_err("%s: Module is not signed with expected PKCS#7 message\n",
    5105     + pr_err("%s: not signed with expected PKCS#7 message\n",
    5106     name);
    5107     return -ENOPKG;
    5108     }
    5109     diff --git a/kernel/module_signing.c b/kernel/module_signing.c
    5110     index 9d9fc678c91d6..8723ae70ea1fe 100644
    5111     --- a/kernel/module_signing.c
    5112     +++ b/kernel/module_signing.c
    5113     @@ -30,7 +30,7 @@ int mod_verify_sig(const void *mod, struct load_info *info)
    5114    
    5115     memcpy(&ms, mod + (modlen - sizeof(ms)), sizeof(ms));
    5116    
    5117     - ret = mod_check_sig(&ms, modlen, info->name);
    5118     + ret = mod_check_sig(&ms, modlen, "module");
    5119     if (ret)
    5120     return ret;
    5121    
    5122     diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
    5123     index 1a75610f5f57b..1b5f54b309be5 100644
    5124     --- a/kernel/trace/trace.c
    5125     +++ b/kernel/trace/trace.c
    5126     @@ -2857,7 +2857,8 @@ static void __ftrace_trace_stack(struct ring_buffer *buffer,
    5127    
    5128     size = nr_entries * sizeof(unsigned long);
    5129     event = __trace_buffer_lock_reserve(buffer, TRACE_STACK,
    5130     - sizeof(*entry) + size, flags, pc);
    5131     + (sizeof(*entry) - sizeof(entry->caller)) + size,
    5132     + flags, pc);
    5133     if (!event)
    5134     goto out;
    5135     entry = ring_buffer_event_data(event);
    5136     diff --git a/mm/memory.c b/mm/memory.c
    5137     index c432e7c764451..13a575ce2ec8f 100644
    5138     --- a/mm/memory.c
    5139     +++ b/mm/memory.c
    5140     @@ -150,7 +150,7 @@ static int __init init_zero_pfn(void)
    5141     zero_pfn = page_to_pfn(ZERO_PAGE(0));
    5142     return 0;
    5143     }
    5144     -core_initcall(init_zero_pfn);
    5145     +early_initcall(init_zero_pfn);
    5146    
    5147    
    5148     #if defined(SPLIT_RSS_COUNTING)
    5149     diff --git a/net/appletalk/ddp.c b/net/appletalk/ddp.c
    5150     index b41375d4d295d..4610c352849bc 100644
    5151     --- a/net/appletalk/ddp.c
    5152     +++ b/net/appletalk/ddp.c
    5153     @@ -1568,8 +1568,8 @@ static int atalk_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
    5154     struct sk_buff *skb;
    5155     struct net_device *dev;
    5156     struct ddpehdr *ddp;
    5157     - int size;
    5158     - struct atalk_route *rt;
    5159     + int size, hard_header_len;
    5160     + struct atalk_route *rt, *rt_lo = NULL;
    5161     int err;
    5162    
    5163     if (flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
    5164     @@ -1632,7 +1632,22 @@ static int atalk_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
    5165     SOCK_DEBUG(sk, "SK %p: Size needed %d, device %s\n",
    5166     sk, size, dev->name);
    5167    
    5168     - size += dev->hard_header_len;
    5169     + hard_header_len = dev->hard_header_len;
    5170     + /* Leave room for loopback hardware header if necessary */
    5171     + if (usat->sat_addr.s_node == ATADDR_BCAST &&
    5172     + (dev->flags & IFF_LOOPBACK || !(rt->flags & RTF_GATEWAY))) {
    5173     + struct atalk_addr at_lo;
    5174     +
    5175     + at_lo.s_node = 0;
    5176     + at_lo.s_net = 0;
    5177     +
    5178     + rt_lo = atrtr_find(&at_lo);
    5179     +
    5180     + if (rt_lo && rt_lo->dev->hard_header_len > hard_header_len)
    5181     + hard_header_len = rt_lo->dev->hard_header_len;
    5182     + }
    5183     +
    5184     + size += hard_header_len;
    5185     release_sock(sk);
    5186     skb = sock_alloc_send_skb(sk, size, (flags & MSG_DONTWAIT), &err);
    5187     lock_sock(sk);
    5188     @@ -1640,7 +1655,7 @@ static int atalk_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
    5189     goto out;
    5190    
    5191     skb_reserve(skb, ddp_dl->header_length);
    5192     - skb_reserve(skb, dev->hard_header_len);
    5193     + skb_reserve(skb, hard_header_len);
    5194     skb->dev = dev;
    5195    
    5196     SOCK_DEBUG(sk, "SK %p: Begin build.\n", sk);
    5197     @@ -1691,18 +1706,12 @@ static int atalk_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
    5198     /* loop back */
    5199     skb_orphan(skb);
    5200     if (ddp->deh_dnode == ATADDR_BCAST) {
    5201     - struct atalk_addr at_lo;
    5202     -
    5203     - at_lo.s_node = 0;
    5204     - at_lo.s_net = 0;
    5205     -
    5206     - rt = atrtr_find(&at_lo);
    5207     - if (!rt) {
    5208     + if (!rt_lo) {
    5209     kfree_skb(skb);
    5210     err = -ENETUNREACH;
    5211     goto out;
    5212     }
    5213     - dev = rt->dev;
    5214     + dev = rt_lo->dev;
    5215     skb->dev = dev;
    5216     }
    5217     ddp_dl->request(ddp_dl, skb, dev->dev_addr);
    5218     diff --git a/net/can/af_can.c b/net/can/af_can.c
    5219     index 306d3584a4417..c758a12ffe461 100644
    5220     --- a/net/can/af_can.c
    5221     +++ b/net/can/af_can.c
    5222     @@ -304,8 +304,8 @@ static struct can_dev_rcv_lists *can_dev_rcv_lists_find(struct net *net,
    5223     struct net_device *dev)
    5224     {
    5225     if (dev) {
    5226     - struct can_ml_priv *ml_priv = dev->ml_priv;
    5227     - return &ml_priv->dev_rcv_lists;
    5228     + struct can_ml_priv *can_ml = can_get_ml_priv(dev);
    5229     + return &can_ml->dev_rcv_lists;
    5230     } else {
    5231     return net->can.rx_alldev_list;
    5232     }
    5233     @@ -788,25 +788,6 @@ void can_proto_unregister(const struct can_proto *cp)
    5234     }
    5235     EXPORT_SYMBOL(can_proto_unregister);
    5236    
    5237     -/* af_can notifier to create/remove CAN netdevice specific structs */
    5238     -static int can_notifier(struct notifier_block *nb, unsigned long msg,
    5239     - void *ptr)
    5240     -{
    5241     - struct net_device *dev = netdev_notifier_info_to_dev(ptr);
    5242     -
    5243     - if (dev->type != ARPHRD_CAN)
    5244     - return NOTIFY_DONE;
    5245     -
    5246     - switch (msg) {
    5247     - case NETDEV_REGISTER:
    5248     - WARN(!dev->ml_priv,
    5249     - "No CAN mid layer private allocated, please fix your driver and use alloc_candev()!\n");
    5250     - break;
    5251     - }
    5252     -
    5253     - return NOTIFY_DONE;
    5254     -}
    5255     -
    5256     static int can_pernet_init(struct net *net)
    5257     {
    5258     spin_lock_init(&net->can.rcvlists_lock);
    5259     @@ -874,11 +855,6 @@ static const struct net_proto_family can_family_ops = {
    5260     .owner = THIS_MODULE,
    5261     };
    5262    
    5263     -/* notifier block for netdevice event */
    5264     -static struct notifier_block can_netdev_notifier __read_mostly = {
    5265     - .notifier_call = can_notifier,
    5266     -};
    5267     -
    5268     static struct pernet_operations can_pernet_ops __read_mostly = {
    5269     .init = can_pernet_init,
    5270     .exit = can_pernet_exit,
    5271     @@ -909,17 +885,12 @@ static __init int can_init(void)
    5272     err = sock_register(&can_family_ops);
    5273     if (err)
    5274     goto out_sock;
    5275     - err = register_netdevice_notifier(&can_netdev_notifier);
    5276     - if (err)
    5277     - goto out_notifier;
    5278    
    5279     dev_add_pack(&can_packet);
    5280     dev_add_pack(&canfd_packet);
    5281    
    5282     return 0;
    5283    
    5284     -out_notifier:
    5285     - sock_unregister(PF_CAN);
    5286     out_sock:
    5287     unregister_pernet_subsys(&can_pernet_ops);
    5288     out_pernet:
    5289     @@ -933,7 +904,6 @@ static __exit void can_exit(void)
    5290     /* protocol unregister */
    5291     dev_remove_pack(&canfd_packet);
    5292     dev_remove_pack(&can_packet);
    5293     - unregister_netdevice_notifier(&can_netdev_notifier);
    5294     sock_unregister(PF_CAN);
    5295    
    5296     unregister_pernet_subsys(&can_pernet_ops);
    5297     diff --git a/net/can/j1939/main.c b/net/can/j1939/main.c
    5298     index 137054bff9ec7..e52330f628c9f 100644
    5299     --- a/net/can/j1939/main.c
    5300     +++ b/net/can/j1939/main.c
    5301     @@ -140,9 +140,9 @@ static struct j1939_priv *j1939_priv_create(struct net_device *ndev)
    5302     static inline void j1939_priv_set(struct net_device *ndev,
    5303     struct j1939_priv *priv)
    5304     {
    5305     - struct can_ml_priv *can_ml_priv = ndev->ml_priv;
    5306     + struct can_ml_priv *can_ml = can_get_ml_priv(ndev);
    5307    
    5308     - can_ml_priv->j1939_priv = priv;
    5309     + can_ml->j1939_priv = priv;
    5310     }
    5311    
    5312     static void __j1939_priv_release(struct kref *kref)
    5313     @@ -211,12 +211,9 @@ static void __j1939_rx_release(struct kref *kref)
    5314     /* get pointer to priv without increasing ref counter */
    5315     static inline struct j1939_priv *j1939_ndev_to_priv(struct net_device *ndev)
    5316     {
    5317     - struct can_ml_priv *can_ml_priv = ndev->ml_priv;
    5318     + struct can_ml_priv *can_ml = can_get_ml_priv(ndev);
    5319    
    5320     - if (!can_ml_priv)
    5321     - return NULL;
    5322     -
    5323     - return can_ml_priv->j1939_priv;
    5324     + return can_ml->j1939_priv;
    5325     }
    5326    
    5327     static struct j1939_priv *j1939_priv_get_by_ndev_locked(struct net_device *ndev)
    5328     @@ -225,9 +222,6 @@ static struct j1939_priv *j1939_priv_get_by_ndev_locked(struct net_device *ndev)
    5329    
    5330     lockdep_assert_held(&j1939_netdev_lock);
    5331    
    5332     - if (ndev->type != ARPHRD_CAN)
    5333     - return NULL;
    5334     -
    5335     priv = j1939_ndev_to_priv(ndev);
    5336     if (priv)
    5337     j1939_priv_get(priv);
    5338     @@ -348,15 +342,16 @@ static int j1939_netdev_notify(struct notifier_block *nb,
    5339     unsigned long msg, void *data)
    5340     {
    5341     struct net_device *ndev = netdev_notifier_info_to_dev(data);
    5342     + struct can_ml_priv *can_ml = can_get_ml_priv(ndev);
    5343     struct j1939_priv *priv;
    5344    
    5345     + if (!can_ml)
    5346     + goto notify_done;
    5347     +
    5348     priv = j1939_priv_get_by_ndev(ndev);
    5349     if (!priv)
    5350     goto notify_done;
    5351    
    5352     - if (ndev->type != ARPHRD_CAN)
    5353     - goto notify_put;
    5354     -
    5355     switch (msg) {
    5356     case NETDEV_DOWN:
    5357     j1939_cancel_active_session(priv, NULL);
    5358     @@ -365,7 +360,6 @@ static int j1939_netdev_notify(struct notifier_block *nb,
    5359     break;
    5360     }
    5361    
    5362     -notify_put:
    5363     j1939_priv_put(priv);
    5364    
    5365     notify_done:
    5366     diff --git a/net/can/j1939/socket.c b/net/can/j1939/socket.c
    5367     index 0470909605392..d57475c8ba07f 100644
    5368     --- a/net/can/j1939/socket.c
    5369     +++ b/net/can/j1939/socket.c
    5370     @@ -12,6 +12,7 @@
    5371    
    5372     #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
    5373    
    5374     +#include <linux/can/can-ml.h>
    5375     #include <linux/can/core.h>
    5376     #include <linux/can/skb.h>
    5377     #include <linux/errqueue.h>
    5378     @@ -453,6 +454,7 @@ static int j1939_sk_bind(struct socket *sock, struct sockaddr *uaddr, int len)
    5379     j1939_jsk_del(priv, jsk);
    5380     j1939_local_ecu_put(priv, jsk->addr.src_name, jsk->addr.sa);
    5381     } else {
    5382     + struct can_ml_priv *can_ml;
    5383     struct net_device *ndev;
    5384    
    5385     ndev = dev_get_by_index(net, addr->can_ifindex);
    5386     @@ -461,15 +463,8 @@ static int j1939_sk_bind(struct socket *sock, struct sockaddr *uaddr, int len)
    5387     goto out_release_sock;
    5388     }
    5389    
    5390     - if (ndev->type != ARPHRD_CAN) {
    5391     - dev_put(ndev);
    5392     - ret = -ENODEV;
    5393     - goto out_release_sock;
    5394     - }
    5395     -
    5396     - if (!ndev->ml_priv) {
    5397     - netdev_warn_once(ndev,
    5398     - "No CAN mid layer private allocated, please fix your driver and use alloc_candev()!\n");
    5399     + can_ml = can_get_ml_priv(ndev);
    5400     + if (!can_ml) {
    5401     dev_put(ndev);
    5402     ret = -ENODEV;
    5403     goto out_release_sock;
    5404     diff --git a/net/can/proc.c b/net/can/proc.c
    5405     index 077af42c26ba5..a5fc63c78370e 100644
    5406     --- a/net/can/proc.c
    5407     +++ b/net/can/proc.c
    5408     @@ -329,8 +329,11 @@ static int can_rcvlist_proc_show(struct seq_file *m, void *v)
    5409    
    5410     /* receive list for registered CAN devices */
    5411     for_each_netdev_rcu(net, dev) {
    5412     - if (dev->type == ARPHRD_CAN && dev->ml_priv)
    5413     - can_rcvlist_proc_show_one(m, idx, dev, dev->ml_priv);
    5414     + struct can_ml_priv *can_ml = can_get_ml_priv(dev);
    5415     +
    5416     + if (can_ml)
    5417     + can_rcvlist_proc_show_one(m, idx, dev,
    5418     + &can_ml->dev_rcv_lists);
    5419     }
    5420    
    5421     rcu_read_unlock();
    5422     @@ -382,8 +385,10 @@ static int can_rcvlist_sff_proc_show(struct seq_file *m, void *v)
    5423    
    5424     /* sff receive list for registered CAN devices */
    5425     for_each_netdev_rcu(net, dev) {
    5426     - if (dev->type == ARPHRD_CAN && dev->ml_priv) {
    5427     - dev_rcv_lists = dev->ml_priv;
    5428     + struct can_ml_priv *can_ml = can_get_ml_priv(dev);
    5429     +
    5430     + if (can_ml) {
    5431     + dev_rcv_lists = &can_ml->dev_rcv_lists;
    5432     can_rcvlist_proc_show_array(m, dev, dev_rcv_lists->rx_sff,
    5433     ARRAY_SIZE(dev_rcv_lists->rx_sff));
    5434     }
    5435     @@ -413,8 +418,10 @@ static int can_rcvlist_eff_proc_show(struct seq_file *m, void *v)
    5436    
    5437     /* eff receive list for registered CAN devices */
    5438     for_each_netdev_rcu(net, dev) {
    5439     - if (dev->type == ARPHRD_CAN && dev->ml_priv) {
    5440     - dev_rcv_lists = dev->ml_priv;
    5441     + struct can_ml_priv *can_ml = can_get_ml_priv(dev);
    5442     +
    5443     + if (can_ml) {
    5444     + dev_rcv_lists = &can_ml->dev_rcv_lists;
    5445     can_rcvlist_proc_show_array(m, dev, dev_rcv_lists->rx_eff,
    5446     ARRAY_SIZE(dev_rcv_lists->rx_eff));
    5447     }
    5448     diff --git a/net/core/filter.c b/net/core/filter.c
    5449     index 524f3364f8a05..7fbb274b7fe32 100644
    5450     --- a/net/core/filter.c
    5451     +++ b/net/core/filter.c
    5452     @@ -3146,18 +3146,14 @@ static int bpf_skb_net_shrink(struct sk_buff *skb, u32 off, u32 len_diff,
    5453     return 0;
    5454     }
    5455    
    5456     -static u32 __bpf_skb_max_len(const struct sk_buff *skb)
    5457     -{
    5458     - return skb->dev ? skb->dev->mtu + skb->dev->hard_header_len :
    5459     - SKB_MAX_ALLOC;
    5460     -}
    5461     +#define BPF_SKB_MAX_LEN SKB_MAX_ALLOC
    5462    
    5463     BPF_CALL_4(bpf_skb_adjust_room, struct sk_buff *, skb, s32, len_diff,
    5464     u32, mode, u64, flags)
    5465     {
    5466     u32 len_cur, len_diff_abs = abs(len_diff);
    5467     u32 len_min = bpf_skb_net_base_len(skb);
    5468     - u32 len_max = __bpf_skb_max_len(skb);
    5469     + u32 len_max = BPF_SKB_MAX_LEN;
    5470     __be16 proto = skb->protocol;
    5471     bool shrink = len_diff < 0;
    5472     u32 off;
    5473     @@ -3237,7 +3233,7 @@ static int bpf_skb_trim_rcsum(struct sk_buff *skb, unsigned int new_len)
    5474     static inline int __bpf_skb_change_tail(struct sk_buff *skb, u32 new_len,
    5475     u64 flags)
    5476     {
    5477     - u32 max_len = __bpf_skb_max_len(skb);
    5478     + u32 max_len = BPF_SKB_MAX_LEN;
    5479     u32 min_len = __bpf_skb_min_len(skb);
    5480     int ret;
    5481    
    5482     @@ -3313,7 +3309,7 @@ static const struct bpf_func_proto sk_skb_change_tail_proto = {
    5483     static inline int __bpf_skb_change_head(struct sk_buff *skb, u32 head_room,
    5484     u64 flags)
    5485     {
    5486     - u32 max_len = __bpf_skb_max_len(skb);
    5487     + u32 max_len = BPF_SKB_MAX_LEN;
    5488     u32 new_len = skb->len + head_room;
    5489     int ret;
    5490    
    5491     diff --git a/net/core/flow_dissector.c b/net/core/flow_dissector.c
    5492     index e3bdd859c895c..da86c0e1b677d 100644
    5493     --- a/net/core/flow_dissector.c
    5494     +++ b/net/core/flow_dissector.c
    5495     @@ -1028,6 +1028,9 @@ proto_again:
    5496     key_control->addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
    5497     }
    5498    
    5499     + __skb_flow_dissect_ipv4(skb, flow_dissector,
    5500     + target_container, data, iph);
    5501     +
    5502     if (ip_is_fragment(iph)) {
    5503     key_control->flags |= FLOW_DIS_IS_FRAGMENT;
    5504    
    5505     @@ -1044,9 +1047,6 @@ proto_again:
    5506     }
    5507     }
    5508    
    5509     - __skb_flow_dissect_ipv4(skb, flow_dissector,
    5510     - target_container, data, iph);
    5511     -
    5512     break;
    5513     }
    5514     case htons(ETH_P_IPV6): {
    5515     diff --git a/net/dccp/ipv6.c b/net/dccp/ipv6.c
    5516     index 1e5e08cc0bfc3..9f73ccf46c9b1 100644
    5517     --- a/net/dccp/ipv6.c
    5518     +++ b/net/dccp/ipv6.c
    5519     @@ -319,6 +319,11 @@ static int dccp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
    5520     if (!ipv6_unicast_destination(skb))
    5521     return 0; /* discard, don't send a reset here */
    5522    
    5523     + if (ipv6_addr_v4mapped(&ipv6_hdr(skb)->saddr)) {
    5524     + __IP6_INC_STATS(sock_net(sk), NULL, IPSTATS_MIB_INHDRERRORS);
    5525     + return 0;
    5526     + }
    5527     +
    5528     if (dccp_bad_service_code(sk, service)) {
    5529     dcb->dccpd_reset_code = DCCP_RESET_CODE_BAD_SERVICE_CODE;
    5530     goto drop;
    5531     diff --git a/net/ipv6/ip6_input.c b/net/ipv6/ip6_input.c
    5532     index 3d71c7d6102c4..7e5df23cbe7bf 100644
    5533     --- a/net/ipv6/ip6_input.c
    5534     +++ b/net/ipv6/ip6_input.c
    5535     @@ -223,16 +223,6 @@ static struct sk_buff *ip6_rcv_core(struct sk_buff *skb, struct net_device *dev,
    5536     if (ipv6_addr_is_multicast(&hdr->saddr))
    5537     goto err;
    5538    
    5539     - /* While RFC4291 is not explicit about v4mapped addresses
    5540     - * in IPv6 headers, it seems clear linux dual-stack
    5541     - * model can not deal properly with these.
    5542     - * Security models could be fooled by ::ffff:127.0.0.1 for example.
    5543     - *
    5544     - * https://tools.ietf.org/html/draft-itojun-v6ops-v4mapped-harmful-02
    5545     - */
    5546     - if (ipv6_addr_v4mapped(&hdr->saddr))
    5547     - goto err;
    5548     -
    5549     skb->transport_header = skb->network_header + sizeof(*hdr);
    5550     IP6CB(skb)->nhoff = offsetof(struct ipv6hdr, nexthdr);
    5551    
    5552     diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
    5553     index b42fa41cfceb5..2f061a911bc2c 100644
    5554     --- a/net/ipv6/tcp_ipv6.c
    5555     +++ b/net/ipv6/tcp_ipv6.c
    5556     @@ -1093,6 +1093,11 @@ static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
    5557     if (!ipv6_unicast_destination(skb))
    5558     goto drop;
    5559    
    5560     + if (ipv6_addr_v4mapped(&ipv6_hdr(skb)->saddr)) {
    5561     + __IP6_INC_STATS(sock_net(sk), NULL, IPSTATS_MIB_INHDRERRORS);
    5562     + return 0;
    5563     + }
    5564     +
    5565     return tcp_conn_request(&tcp6_request_sock_ops,
    5566     &tcp_request_sock_ipv6_ops, sk, skb);
    5567    
    5568     diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c
    5569     index cf4d6d7e72822..d5470c7fe8792 100644
    5570     --- a/net/sunrpc/auth_gss/svcauth_gss.c
    5571     +++ b/net/sunrpc/auth_gss/svcauth_gss.c
    5572     @@ -1782,11 +1782,14 @@ static int
    5573     svcauth_gss_release(struct svc_rqst *rqstp)
    5574     {
    5575     struct gss_svc_data *gsd = (struct gss_svc_data *)rqstp->rq_auth_data;
    5576     - struct rpc_gss_wire_cred *gc = &gsd->clcred;
    5577     + struct rpc_gss_wire_cred *gc;
    5578     struct xdr_buf *resbuf = &rqstp->rq_res;
    5579     int stat = -EINVAL;
    5580     struct sunrpc_net *sn = net_generic(SVC_NET(rqstp), sunrpc_net_id);
    5581    
    5582     + if (!gsd)
    5583     + goto out;
    5584     + gc = &gsd->clcred;
    5585     if (gc->gc_proc != RPC_GSS_PROC_DATA)
    5586     goto out;
    5587     /* Release can be called twice, but we only wrap once. */
    5588     @@ -1827,10 +1830,10 @@ out_err:
    5589     if (rqstp->rq_cred.cr_group_info)
    5590     put_group_info(rqstp->rq_cred.cr_group_info);
    5591     rqstp->rq_cred.cr_group_info = NULL;
    5592     - if (gsd->rsci)
    5593     + if (gsd && gsd->rsci) {
    5594     cache_put(&gsd->rsci->h, sn->rsc_cache);
    5595     - gsd->rsci = NULL;
    5596     -
    5597     + gsd->rsci = NULL;
    5598     + }
    5599     return stat;
    5600     }
    5601    
    5602     diff --git a/net/vmw_vsock/af_vsock.c b/net/vmw_vsock/af_vsock.c
    5603     index 5d323574d04fe..c82e7b52ab1f8 100644
    5604     --- a/net/vmw_vsock/af_vsock.c
    5605     +++ b/net/vmw_vsock/af_vsock.c
    5606     @@ -620,6 +620,7 @@ struct sock *__vsock_create(struct net *net,
    5607     vsk->trusted = psk->trusted;
    5608     vsk->owner = get_cred(psk->owner);
    5609     vsk->connect_timeout = psk->connect_timeout;
    5610     + security_sk_clone(parent, sk);
    5611     } else {
    5612     vsk->trusted = ns_capable_noaudit(&init_user_ns, CAP_NET_ADMIN);
    5613     vsk->owner = get_current_cred();
    5614     diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
    5615     index febd16c9efd7a..ebb1ee69dd0c3 100644
    5616     --- a/sound/pci/hda/hda_intel.c
    5617     +++ b/sound/pci/hda/hda_intel.c
    5618     @@ -1022,8 +1022,12 @@ static int azx_prepare(struct device *dev)
    5619     struct snd_card *card = dev_get_drvdata(dev);
    5620     struct azx *chip;
    5621    
    5622     + if (!azx_is_pm_ready(card))
    5623     + return 0;
    5624     +
    5625     chip = card->private_data;
    5626     chip->pm_prepared = 1;
    5627     + snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
    5628    
    5629     flush_work(&azx_bus(chip)->unsol_work);
    5630    
    5631     @@ -1038,7 +1042,11 @@ static void azx_complete(struct device *dev)
    5632     struct snd_card *card = dev_get_drvdata(dev);
    5633     struct azx *chip;
    5634    
    5635     + if (!azx_is_pm_ready(card))
    5636     + return;
    5637     +
    5638     chip = card->private_data;
    5639     + snd_power_change_state(card, SNDRV_CTL_POWER_D0);
    5640     chip->pm_prepared = 0;
    5641     }
    5642    
    5643     diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
    5644     index 73580e8208ed1..3c9e072db3538 100644
    5645     --- a/sound/pci/hda/patch_realtek.c
    5646     +++ b/sound/pci/hda/patch_realtek.c
    5647     @@ -5192,7 +5192,7 @@ static void alc_determine_headset_type(struct hda_codec *codec)
    5648     case 0x10ec0274:
    5649     case 0x10ec0294:
    5650     alc_process_coef_fw(codec, coef0274);
    5651     - msleep(80);
    5652     + msleep(850);
    5653     val = alc_read_coef_idx(codec, 0x46);
    5654     is_ctia = (val & 0x00f0) == 0x00f0;
    5655     break;
    5656     @@ -5376,6 +5376,7 @@ static void alc_update_headset_jack_cb(struct hda_codec *codec,
    5657     struct hda_jack_callback *jack)
    5658     {
    5659     snd_hda_gen_hp_automute(codec, jack);
    5660     + alc_update_headset_mode(codec);
    5661     }
    5662    
    5663     static void alc_probe_headset_mode(struct hda_codec *codec)
    5664     diff --git a/sound/soc/codecs/cs42l42.c b/sound/soc/codecs/cs42l42.c
    5665     index 5125bb9b37b55..dcd2acb2c3cef 100644
    5666     --- a/sound/soc/codecs/cs42l42.c
    5667     +++ b/sound/soc/codecs/cs42l42.c
    5668     @@ -401,7 +401,7 @@ static const struct regmap_config cs42l42_regmap = {
    5669     };
    5670    
    5671     static DECLARE_TLV_DB_SCALE(adc_tlv, -9600, 100, false);
    5672     -static DECLARE_TLV_DB_SCALE(mixer_tlv, -6200, 100, false);
    5673     +static DECLARE_TLV_DB_SCALE(mixer_tlv, -6300, 100, true);
    5674    
    5675     static const char * const cs42l42_hpf_freq_text[] = {
    5676     "1.86Hz", "120Hz", "235Hz", "466Hz"
    5677     @@ -458,7 +458,7 @@ static const struct snd_kcontrol_new cs42l42_snd_controls[] = {
    5678     CS42L42_DAC_HPF_EN_SHIFT, true, false),
    5679     SOC_DOUBLE_R_TLV("Mixer Volume", CS42L42_MIXER_CHA_VOL,
    5680     CS42L42_MIXER_CHB_VOL, CS42L42_MIXER_CH_VOL_SHIFT,
    5681     - 0x3e, 1, mixer_tlv)
    5682     + 0x3f, 1, mixer_tlv)
    5683     };
    5684    
    5685     static int cs42l42_hpdrv_evt(struct snd_soc_dapm_widget *w,
    5686     @@ -691,24 +691,6 @@ static int cs42l42_pll_config(struct snd_soc_component *component)
    5687     CS42L42_CLK_OASRC_SEL_MASK,
    5688     CS42L42_CLK_OASRC_SEL_12 <<
    5689     CS42L42_CLK_OASRC_SEL_SHIFT);
    5690     - /* channel 1 on low LRCLK, 32 bit */
    5691     - snd_soc_component_update_bits(component,
    5692     - CS42L42_ASP_RX_DAI0_CH1_AP_RES,
    5693     - CS42L42_ASP_RX_CH_AP_MASK |
    5694     - CS42L42_ASP_RX_CH_RES_MASK,
    5695     - (CS42L42_ASP_RX_CH_AP_LOW <<
    5696     - CS42L42_ASP_RX_CH_AP_SHIFT) |
    5697     - (CS42L42_ASP_RX_CH_RES_32 <<
    5698     - CS42L42_ASP_RX_CH_RES_SHIFT));
    5699     - /* Channel 2 on high LRCLK, 32 bit */
    5700     - snd_soc_component_update_bits(component,
    5701     - CS42L42_ASP_RX_DAI0_CH2_AP_RES,
    5702     - CS42L42_ASP_RX_CH_AP_MASK |
    5703     - CS42L42_ASP_RX_CH_RES_MASK,
    5704     - (CS42L42_ASP_RX_CH_AP_HI <<
    5705     - CS42L42_ASP_RX_CH_AP_SHIFT) |
    5706     - (CS42L42_ASP_RX_CH_RES_32 <<
    5707     - CS42L42_ASP_RX_CH_RES_SHIFT));
    5708     if (pll_ratio_table[i].mclk_src_sel == 0) {
    5709     /* Pass the clock straight through */
    5710     snd_soc_component_update_bits(component,
    5711     @@ -797,27 +779,23 @@ static int cs42l42_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
    5712     /* Bitclock/frame inversion */
    5713     switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
    5714     case SND_SOC_DAIFMT_NB_NF:
    5715     + asp_cfg_val |= CS42L42_ASP_SCPOL_NOR << CS42L42_ASP_SCPOL_SHIFT;
    5716     break;
    5717     case SND_SOC_DAIFMT_NB_IF:
    5718     - asp_cfg_val |= CS42L42_ASP_POL_INV <<
    5719     - CS42L42_ASP_LCPOL_IN_SHIFT;
    5720     + asp_cfg_val |= CS42L42_ASP_SCPOL_NOR << CS42L42_ASP_SCPOL_SHIFT;
    5721     + asp_cfg_val |= CS42L42_ASP_LCPOL_INV << CS42L42_ASP_LCPOL_SHIFT;
    5722     break;
    5723     case SND_SOC_DAIFMT_IB_NF:
    5724     - asp_cfg_val |= CS42L42_ASP_POL_INV <<
    5725     - CS42L42_ASP_SCPOL_IN_DAC_SHIFT;
    5726     break;
    5727     case SND_SOC_DAIFMT_IB_IF:
    5728     - asp_cfg_val |= CS42L42_ASP_POL_INV <<
    5729     - CS42L42_ASP_LCPOL_IN_SHIFT;
    5730     - asp_cfg_val |= CS42L42_ASP_POL_INV <<
    5731     - CS42L42_ASP_SCPOL_IN_DAC_SHIFT;
    5732     + asp_cfg_val |= CS42L42_ASP_LCPOL_INV << CS42L42_ASP_LCPOL_SHIFT;
    5733     break;
    5734     }
    5735    
    5736     - snd_soc_component_update_bits(component, CS42L42_ASP_CLK_CFG,
    5737     - CS42L42_ASP_MODE_MASK |
    5738     - CS42L42_ASP_SCPOL_IN_DAC_MASK |
    5739     - CS42L42_ASP_LCPOL_IN_MASK, asp_cfg_val);
    5740     + snd_soc_component_update_bits(component, CS42L42_ASP_CLK_CFG, CS42L42_ASP_MODE_MASK |
    5741     + CS42L42_ASP_SCPOL_MASK |
    5742     + CS42L42_ASP_LCPOL_MASK,
    5743     + asp_cfg_val);
    5744    
    5745     return 0;
    5746     }
    5747     @@ -828,14 +806,29 @@ static int cs42l42_pcm_hw_params(struct snd_pcm_substream *substream,
    5748     {
    5749     struct snd_soc_component *component = dai->component;
    5750     struct cs42l42_private *cs42l42 = snd_soc_component_get_drvdata(component);
    5751     - int retval;
    5752     + unsigned int width = (params_width(params) / 8) - 1;
    5753     + unsigned int val = 0;
    5754    
    5755     cs42l42->srate = params_rate(params);
    5756     - cs42l42->swidth = params_width(params);
    5757    
    5758     - retval = cs42l42_pll_config(component);
    5759     + switch(substream->stream) {
    5760     + case SNDRV_PCM_STREAM_PLAYBACK:
    5761     + val |= width << CS42L42_ASP_RX_CH_RES_SHIFT;
    5762     + /* channel 1 on low LRCLK */
    5763     + snd_soc_component_update_bits(component, CS42L42_ASP_RX_DAI0_CH1_AP_RES,
    5764     + CS42L42_ASP_RX_CH_AP_MASK |
    5765     + CS42L42_ASP_RX_CH_RES_MASK, val);
    5766     + /* Channel 2 on high LRCLK */
    5767     + val |= CS42L42_ASP_RX_CH_AP_HI << CS42L42_ASP_RX_CH_AP_SHIFT;
    5768     + snd_soc_component_update_bits(component, CS42L42_ASP_RX_DAI0_CH2_AP_RES,
    5769     + CS42L42_ASP_RX_CH_AP_MASK |
    5770     + CS42L42_ASP_RX_CH_RES_MASK, val);
    5771     + break;
    5772     + default:
    5773     + break;
    5774     + }
    5775    
    5776     - return retval;
    5777     + return cs42l42_pll_config(component);
    5778     }
    5779    
    5780     static int cs42l42_set_sysclk(struct snd_soc_dai *dai,
    5781     @@ -900,9 +893,9 @@ static int cs42l42_digital_mute(struct snd_soc_dai *dai, int mute)
    5782     return 0;
    5783     }
    5784    
    5785     -#define CS42L42_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S18_3LE | \
    5786     - SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE | \
    5787     - SNDRV_PCM_FMTBIT_S32_LE)
    5788     +#define CS42L42_FORMATS (SNDRV_PCM_FMTBIT_S16_LE |\
    5789     + SNDRV_PCM_FMTBIT_S24_LE |\
    5790     + SNDRV_PCM_FMTBIT_S32_LE )
    5791    
    5792    
    5793     static const struct snd_soc_dai_ops cs42l42_ops = {
    5794     @@ -1803,7 +1796,7 @@ static int cs42l42_i2c_probe(struct i2c_client *i2c_client,
    5795     dev_dbg(&i2c_client->dev, "Found reset GPIO\n");
    5796     gpiod_set_value_cansleep(cs42l42->reset_gpio, 1);
    5797     }
    5798     - mdelay(3);
    5799     + usleep_range(CS42L42_BOOT_TIME_US, CS42L42_BOOT_TIME_US * 2);
    5800    
    5801     /* Request IRQ */
    5802     ret = devm_request_threaded_irq(&i2c_client->dev,
    5803     @@ -1928,6 +1921,7 @@ static int cs42l42_runtime_resume(struct device *dev)
    5804     }
    5805    
    5806     gpiod_set_value_cansleep(cs42l42->reset_gpio, 1);
    5807     + usleep_range(CS42L42_BOOT_TIME_US, CS42L42_BOOT_TIME_US * 2);
    5808    
    5809     regcache_cache_only(cs42l42->regmap, false);
    5810     regcache_sync(cs42l42->regmap);
    5811     diff --git a/sound/soc/codecs/cs42l42.h b/sound/soc/codecs/cs42l42.h
    5812     index 9e3cc528dcff0..866d7c873e3c9 100644
    5813     --- a/sound/soc/codecs/cs42l42.h
    5814     +++ b/sound/soc/codecs/cs42l42.h
    5815     @@ -258,11 +258,12 @@
    5816     #define CS42L42_ASP_SLAVE_MODE 0x00
    5817     #define CS42L42_ASP_MODE_SHIFT 4
    5818     #define CS42L42_ASP_MODE_MASK (1 << CS42L42_ASP_MODE_SHIFT)
    5819     -#define CS42L42_ASP_SCPOL_IN_DAC_SHIFT 2
    5820     -#define CS42L42_ASP_SCPOL_IN_DAC_MASK (1 << CS42L42_ASP_SCPOL_IN_DAC_SHIFT)
    5821     -#define CS42L42_ASP_LCPOL_IN_SHIFT 0
    5822     -#define CS42L42_ASP_LCPOL_IN_MASK (1 << CS42L42_ASP_LCPOL_IN_SHIFT)
    5823     -#define CS42L42_ASP_POL_INV 1
    5824     +#define CS42L42_ASP_SCPOL_SHIFT 2
    5825     +#define CS42L42_ASP_SCPOL_MASK (3 << CS42L42_ASP_SCPOL_SHIFT)
    5826     +#define CS42L42_ASP_SCPOL_NOR 3
    5827     +#define CS42L42_ASP_LCPOL_SHIFT 0
    5828     +#define CS42L42_ASP_LCPOL_MASK (3 << CS42L42_ASP_LCPOL_SHIFT)
    5829     +#define CS42L42_ASP_LCPOL_INV 3
    5830    
    5831     #define CS42L42_ASP_FRM_CFG (CS42L42_PAGE_12 + 0x08)
    5832     #define CS42L42_ASP_STP_SHIFT 4
    5833     @@ -739,6 +740,7 @@
    5834     #define CS42L42_FRAC2_VAL(val) (((val) & 0xff0000) >> 16)
    5835    
    5836     #define CS42L42_NUM_SUPPLIES 5
    5837     +#define CS42L42_BOOT_TIME_US 3000
    5838    
    5839     static const char *const cs42l42_supply_names[CS42L42_NUM_SUPPLIES] = {
    5840     "VA",
    5841     @@ -756,7 +758,6 @@ struct cs42l42_private {
    5842     struct completion pdn_done;
    5843     u32 sclk;
    5844     u32 srate;
    5845     - u32 swidth;
    5846     u8 plug_state;
    5847     u8 hs_type;
    5848     u8 ts_inv;
    5849     diff --git a/sound/soc/codecs/es8316.c b/sound/soc/codecs/es8316.c
    5850     index 36eef1fb3d181..b781b28de0126 100644
    5851     --- a/sound/soc/codecs/es8316.c
    5852     +++ b/sound/soc/codecs/es8316.c
    5853     @@ -63,13 +63,8 @@ static const SNDRV_CTL_TLVD_DECLARE_DB_RANGE(adc_pga_gain_tlv,
    5854     1, 1, TLV_DB_SCALE_ITEM(0, 0, 0),
    5855     2, 2, TLV_DB_SCALE_ITEM(250, 0, 0),
    5856     3, 3, TLV_DB_SCALE_ITEM(450, 0, 0),
    5857     - 4, 4, TLV_DB_SCALE_ITEM(700, 0, 0),
    5858     - 5, 5, TLV_DB_SCALE_ITEM(1000, 0, 0),
    5859     - 6, 6, TLV_DB_SCALE_ITEM(1300, 0, 0),
    5860     - 7, 7, TLV_DB_SCALE_ITEM(1600, 0, 0),
    5861     - 8, 8, TLV_DB_SCALE_ITEM(1800, 0, 0),
    5862     - 9, 9, TLV_DB_SCALE_ITEM(2100, 0, 0),
    5863     - 10, 10, TLV_DB_SCALE_ITEM(2400, 0, 0),
    5864     + 4, 7, TLV_DB_SCALE_ITEM(700, 300, 0),
    5865     + 8, 10, TLV_DB_SCALE_ITEM(1800, 300, 0),
    5866     );
    5867    
    5868     static const SNDRV_CTL_TLVD_DECLARE_DB_RANGE(hpout_vol_tlv,
    5869     diff --git a/sound/soc/codecs/rt5640.c b/sound/soc/codecs/rt5640.c
    5870     index 747ca248bf10c..3bc63fbcb1889 100644
    5871     --- a/sound/soc/codecs/rt5640.c
    5872     +++ b/sound/soc/codecs/rt5640.c
    5873     @@ -339,9 +339,9 @@ static bool rt5640_readable_register(struct device *dev, unsigned int reg)
    5874     }
    5875    
    5876     static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -4650, 150, 0);
    5877     -static const DECLARE_TLV_DB_SCALE(dac_vol_tlv, -65625, 375, 0);
    5878     +static const DECLARE_TLV_DB_MINMAX(dac_vol_tlv, -6562, 0);
    5879     static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -3450, 150, 0);
    5880     -static const DECLARE_TLV_DB_SCALE(adc_vol_tlv, -17625, 375, 0);
    5881     +static const DECLARE_TLV_DB_MINMAX(adc_vol_tlv, -1762, 3000);
    5882     static const DECLARE_TLV_DB_SCALE(adc_bst_tlv, 0, 1200, 0);
    5883    
    5884     /* {0, +20, +24, +30, +35, +40, +44, +50, +52} dB */
    5885     diff --git a/sound/soc/codecs/rt5651.c b/sound/soc/codecs/rt5651.c
    5886     index c506c9305043e..829cf552fe3e8 100644
    5887     --- a/sound/soc/codecs/rt5651.c
    5888     +++ b/sound/soc/codecs/rt5651.c
    5889     @@ -285,9 +285,9 @@ static bool rt5651_readable_register(struct device *dev, unsigned int reg)
    5890     }
    5891    
    5892     static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -4650, 150, 0);
    5893     -static const DECLARE_TLV_DB_SCALE(dac_vol_tlv, -65625, 375, 0);
    5894     +static const DECLARE_TLV_DB_MINMAX(dac_vol_tlv, -6562, 0);
    5895     static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -3450, 150, 0);
    5896     -static const DECLARE_TLV_DB_SCALE(adc_vol_tlv, -17625, 375, 0);
    5897     +static const DECLARE_TLV_DB_MINMAX(adc_vol_tlv, -1762, 3000);
    5898     static const DECLARE_TLV_DB_SCALE(adc_bst_tlv, 0, 1200, 0);
    5899    
    5900     /* {0, +20, +24, +30, +35, +40, +44, +50, +52} dB */
    5901     diff --git a/sound/soc/codecs/rt5659.c b/sound/soc/codecs/rt5659.c
    5902     index e66d08398f746..afd61599d94c9 100644
    5903     --- a/sound/soc/codecs/rt5659.c
    5904     +++ b/sound/soc/codecs/rt5659.c
    5905     @@ -3463,12 +3463,17 @@ static int rt5659_set_component_sysclk(struct snd_soc_component *component, int
    5906     {
    5907     struct rt5659_priv *rt5659 = snd_soc_component_get_drvdata(component);
    5908     unsigned int reg_val = 0;
    5909     + int ret;
    5910    
    5911     if (freq == rt5659->sysclk && clk_id == rt5659->sysclk_src)
    5912     return 0;
    5913    
    5914     switch (clk_id) {
    5915     case RT5659_SCLK_S_MCLK:
    5916     + ret = clk_set_rate(rt5659->mclk, freq);
    5917     + if (ret)
    5918     + return ret;
    5919     +
    5920     reg_val |= RT5659_SCLK_SRC_MCLK;
    5921     break;
    5922     case RT5659_SCLK_S_PLL1:
    5923     diff --git a/sound/soc/codecs/sgtl5000.c b/sound/soc/codecs/sgtl5000.c
    5924     index f5b59305c957a..8a1e485982d81 100644
    5925     --- a/sound/soc/codecs/sgtl5000.c
    5926     +++ b/sound/soc/codecs/sgtl5000.c
    5927     @@ -71,7 +71,7 @@ static const struct reg_default sgtl5000_reg_defaults[] = {
    5928     { SGTL5000_DAP_EQ_BASS_BAND4, 0x002f },
    5929     { SGTL5000_DAP_MAIN_CHAN, 0x8000 },
    5930     { SGTL5000_DAP_MIX_CHAN, 0x0000 },
    5931     - { SGTL5000_DAP_AVC_CTRL, 0x0510 },
    5932     + { SGTL5000_DAP_AVC_CTRL, 0x5100 },
    5933     { SGTL5000_DAP_AVC_THRESHOLD, 0x1473 },
    5934     { SGTL5000_DAP_AVC_ATTACK, 0x0028 },
    5935     { SGTL5000_DAP_AVC_DECAY, 0x0050 },
    5936     diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c
    5937     index 9fb03c646a88f..3d1585c12b074 100644
    5938     --- a/sound/usb/quirks.c
    5939     +++ b/sound/usb/quirks.c
    5940     @@ -1453,6 +1453,7 @@ bool snd_usb_get_sample_rate_quirk(struct snd_usb_audio *chip)
    5941     case USB_ID(0x21B4, 0x0081): /* AudioQuest DragonFly */
    5942     case USB_ID(0x2912, 0x30c8): /* Audioengine D1 */
    5943     case USB_ID(0x413c, 0xa506): /* Dell AE515 sound bar */
    5944     + case USB_ID(0x046d, 0x084c): /* Logitech ConferenceCam Connect */
    5945     return true;
    5946     }
    5947    
    5948     diff --git a/tools/testing/selftests/net/forwarding/tc_flower.sh b/tools/testing/selftests/net/forwarding/tc_flower.sh
    5949     index 058c746ee3006..b11d8e6b5bc14 100755
    5950     --- a/tools/testing/selftests/net/forwarding/tc_flower.sh
    5951     +++ b/tools/testing/selftests/net/forwarding/tc_flower.sh
    5952     @@ -3,7 +3,7 @@
    5953    
    5954     ALL_TESTS="match_dst_mac_test match_src_mac_test match_dst_ip_test \
    5955     match_src_ip_test match_ip_flags_test match_pcp_test match_vlan_test \
    5956     - match_ip_tos_test match_indev_test"
    5957     + match_ip_tos_test match_indev_test match_ip_ttl_test"
    5958     NUM_NETIFS=2
    5959     source tc_common.sh
    5960     source lib.sh
    5961     @@ -310,6 +310,42 @@ match_ip_tos_test()
    5962     log_test "ip_tos match ($tcflags)"
    5963     }
    5964    
    5965     +match_ip_ttl_test()
    5966     +{
    5967     + RET=0
    5968     +
    5969     + tc filter add dev $h2 ingress protocol ip pref 1 handle 101 flower \
    5970     + $tcflags dst_ip 192.0.2.2 ip_ttl 63 action drop
    5971     + tc filter add dev $h2 ingress protocol ip pref 2 handle 102 flower \
    5972     + $tcflags dst_ip 192.0.2.2 action drop
    5973     +
    5974     + $MZ $h1 -c 1 -p 64 -a $h1mac -b $h2mac -A 192.0.2.1 -B 192.0.2.2 \
    5975     + -t ip "ttl=63" -q
    5976     +
    5977     + $MZ $h1 -c 1 -p 64 -a $h1mac -b $h2mac -A 192.0.2.1 -B 192.0.2.2 \
    5978     + -t ip "ttl=63,mf,frag=256" -q
    5979     +
    5980     + tc_check_packets "dev $h2 ingress" 102 1
    5981     + check_fail $? "Matched on the wrong filter (no check on ttl)"
    5982     +
    5983     + tc_check_packets "dev $h2 ingress" 101 2
    5984     + check_err $? "Did not match on correct filter (ttl=63)"
    5985     +
    5986     + $MZ $h1 -c 1 -p 64 -a $h1mac -b $h2mac -A 192.0.2.1 -B 192.0.2.2 \
    5987     + -t ip "ttl=255" -q
    5988     +
    5989     + tc_check_packets "dev $h2 ingress" 101 3
    5990     + check_fail $? "Matched on a wrong filter (ttl=63)"
    5991     +
    5992     + tc_check_packets "dev $h2 ingress" 102 1
    5993     + check_err $? "Did not match on correct filter (no check on ttl)"
    5994     +
    5995     + tc filter del dev $h2 ingress protocol ip pref 2 handle 102 flower
    5996     + tc filter del dev $h2 ingress protocol ip pref 1 handle 101 flower
    5997     +
    5998     + log_test "ip_ttl match ($tcflags)"
    5999     +}
    6000     +
    6001     match_indev_test()
    6002     {
    6003     RET=0