drivers/net/ethernet/mellanox/mlxsw/pci.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /* Copyright (c) 2015-2018 Mellanox Technologies. All rights reserved */
   3
   4 #include <linux/kernel.h>
   5 #include <linux/module.h>
   6 #include <linux/export.h>
   7 #include <linux/err.h>
   8 #include <linux/device.h>
   9 #include <linux/pci.h>
  10 #include <linux/interrupt.h>
  11 #include <linux/wait.h>
  12 #include <linux/types.h>
  13 #include <linux/skbuff.h>
  14 #include <linux/if_vlan.h>
  15 #include <linux/log2.h>
  16 #include <linux/string.h>
  17
  18 #include "pci_hw.h"
  19 #include "pci.h"
  20 #include "core.h"
  21 #include "cmd.h"
  22 #include "port.h"
  23 #include "resources.h"
  24
  25 #define mlxsw_pci_write32(mlxsw_pci, reg, val) \
  26         iowrite32be(val, (mlxsw_pci)->hw_addr + (MLXSW_PCI_ ## reg))
  27 #define mlxsw_pci_read32(mlxsw_pci, reg) \
  28         ioread32be((mlxsw_pci)->hw_addr + (MLXSW_PCI_ ## reg))
  29
  30 enum mlxsw_pci_queue_type {
  31         MLXSW_PCI_QUEUE_TYPE_SDQ,
  32         MLXSW_PCI_QUEUE_TYPE_RDQ,
  33         MLXSW_PCI_QUEUE_TYPE_CQ,
  34         MLXSW_PCI_QUEUE_TYPE_EQ,
  35 };
  36
  37 #define MLXSW_PCI_QUEUE_TYPE_COUNT      4
  38
  39 static const u16 mlxsw_pci_doorbell_type_offset[] = {
  40         MLXSW_PCI_DOORBELL_SDQ_OFFSET,  /* for type MLXSW_PCI_QUEUE_TYPE_SDQ */
  41         MLXSW_PCI_DOORBELL_RDQ_OFFSET,  /* for type MLXSW_PCI_QUEUE_TYPE_RDQ */
  42         MLXSW_PCI_DOORBELL_CQ_OFFSET,   /* for type MLXSW_PCI_QUEUE_TYPE_CQ */
  43         MLXSW_PCI_DOORBELL_EQ_OFFSET,   /* for type MLXSW_PCI_QUEUE_TYPE_EQ */
  44 };
  45
  46 static const u16 mlxsw_pci_doorbell_arm_type_offset[] = {
  47         0, /* unused */
  48         0, /* unused */
  49         MLXSW_PCI_DOORBELL_ARM_CQ_OFFSET, /* for type MLXSW_PCI_QUEUE_TYPE_CQ */
  50         MLXSW_PCI_DOORBELL_ARM_EQ_OFFSET, /* for type MLXSW_PCI_QUEUE_TYPE_EQ */
  51 };
  52
  53 struct mlxsw_pci_mem_item {
  54         char *buf;
  55         dma_addr_t mapaddr;
  56         size_t size;
  57 };
  58
  59 struct mlxsw_pci_queue_elem_info {
  60         char *elem; /* pointer to actual dma mapped element mem chunk */
  61         union {
  62                 struct {
  63                         struct sk_buff *skb;
  64                 } sdq;
  65                 struct {
  66                         struct sk_buff *skb;
  67                 } rdq;
  68         } u;
  69 };
  70
  71 struct mlxsw_pci_queue {
  72         spinlock_t lock; /* for queue accesses */
  73         struct mlxsw_pci_mem_item mem_item;
  74         struct mlxsw_pci_queue_elem_info *elem_info;
  75         u16 producer_counter;
  76         u16 consumer_counter;
  77         u16 count; /* number of elements in queue */
  78         u8 num; /* queue number */
  79         u8 elem_size; /* size of one element */
  80         enum mlxsw_pci_queue_type type;
  81         struct tasklet_struct tasklet; /* queue processing tasklet */
  82         struct mlxsw_pci *pci;
  83         union {
  84                 struct {
  85                         u32 comp_sdq_count;
  86                         u32 comp_rdq_count;
  87                         enum mlxsw_pci_cqe_v v;
  88                 } cq;
  89                 struct {
  90                         u32 ev_cmd_count;
  91                         u32 ev_comp_count;
  92                         u32 ev_other_count;
  93                 } eq;
  94         } u;
  95 };
  96
  97 struct mlxsw_pci_queue_type_group {
  98         struct mlxsw_pci_queue *q;
  99         u8 count; /* number of queues in group */
 100 };
 101
 102 struct mlxsw_pci {
 103         struct pci_dev *pdev;
 104         u8 __iomem *hw_addr;
 105         u64 free_running_clock_offset;
 106         u64 utc_sec_offset;
 107         u64 utc_nsec_offset;
 108         bool lag_mode_support;
 109         enum mlxsw_cmd_mbox_config_profile_lag_mode lag_mode;
 110         struct mlxsw_pci_queue_type_group queues[MLXSW_PCI_QUEUE_TYPE_COUNT];
 111         u32 doorbell_offset;
 112         struct mlxsw_core *core;
 113         struct {
 114                 struct mlxsw_pci_mem_item *items;
 115                 unsigned int count;
 116         } fw_area;
 117         struct {
 118                 struct mlxsw_pci_mem_item out_mbox;
 119                 struct mlxsw_pci_mem_item in_mbox;
 120                 struct mutex lock; /* Lock access to command registers */
 121                 bool nopoll;
 122                 wait_queue_head_t wait;
 123                 bool wait_done;
 124                 struct {
 125                         u8 status;
 126                         u64 out_param;
 127                 } comp;
 128         } cmd;
 129         struct mlxsw_bus_info bus_info;
 130         const struct pci_device_id *id;
 131         enum mlxsw_pci_cqe_v max_cqe_ver; /* Maximal supported CQE version */
 132         u8 num_sdq_cqs; /* Number of CQs used for SDQs */
 133         bool skip_reset;
 134 };
 135
 136 static void mlxsw_pci_queue_tasklet_schedule(struct mlxsw_pci_queue *q)
 137 {
 138         tasklet_schedule(&q->tasklet);
 139 }
 140
 141 static char *__mlxsw_pci_queue_elem_get(struct mlxsw_pci_queue *q,
 142                                         size_t elem_size, int elem_index)
 143 {
 144         return q->mem_item.buf + (elem_size * elem_index);
 145 }
 146
 147 static struct mlxsw_pci_queue_elem_info *
 148 mlxsw_pci_queue_elem_info_get(struct mlxsw_pci_queue *q, int elem_index)
 149 {
 150         return &q->elem_info[elem_index];
 151 }
 152
 153 static struct mlxsw_pci_queue_elem_info *
 154 mlxsw_pci_queue_elem_info_producer_get(struct mlxsw_pci_queue *q)
 155 {
 156         int index = q->producer_counter & (q->count - 1);
 157
 158         if ((u16) (q->producer_counter - q->consumer_counter) == q->count)
 159                 return NULL;
 160         return mlxsw_pci_queue_elem_info_get(q, index);
 161 }
 162
 163 static struct mlxsw_pci_queue_elem_info *
 164 mlxsw_pci_queue_elem_info_consumer_get(struct mlxsw_pci_queue *q)
 165 {
 166         int index = q->consumer_counter & (q->count - 1);
 167
 168         return mlxsw_pci_queue_elem_info_get(q, index);
 169 }
 170
 171 static char *mlxsw_pci_queue_elem_get(struct mlxsw_pci_queue *q, int elem_index)
 172 {
 173         return mlxsw_pci_queue_elem_info_get(q, elem_index)->elem;
 174 }
 175
 176 static bool mlxsw_pci_elem_hw_owned(struct mlxsw_pci_queue *q, bool owner_bit)
 177 {
 178         return owner_bit != !!(q->consumer_counter & q->count);
 179 }
 180
 181 static struct mlxsw_pci_queue_type_group *
 182 mlxsw_pci_queue_type_group_get(struct mlxsw_pci *mlxsw_pci,
 183                                enum mlxsw_pci_queue_type q_type)
 184 {
 185         return &mlxsw_pci->queues[q_type];
 186 }
 187
 188 static u8 __mlxsw_pci_queue_count(struct mlxsw_pci *mlxsw_pci,
 189                                   enum mlxsw_pci_queue_type q_type)
 190 {
 191         struct mlxsw_pci_queue_type_group *queue_group;
 192
 193         queue_group = mlxsw_pci_queue_type_group_get(mlxsw_pci, q_type);
 194         return queue_group->count;
 195 }
 196
 197 static u8 mlxsw_pci_sdq_count(struct mlxsw_pci *mlxsw_pci)
 198 {
 199         return __mlxsw_pci_queue_count(mlxsw_pci, MLXSW_PCI_QUEUE_TYPE_SDQ);
 200 }
 201
 202 static u8 mlxsw_pci_cq_count(struct mlxsw_pci *mlxsw_pci)
 203 {
 204         return __mlxsw_pci_queue_count(mlxsw_pci, MLXSW_PCI_QUEUE_TYPE_CQ);
 205 }
 206
 207 static struct mlxsw_pci_queue *
 208 __mlxsw_pci_queue_get(struct mlxsw_pci *mlxsw_pci,
 209                       enum mlxsw_pci_queue_type q_type, u8 q_num)
 210 {
 211         return &mlxsw_pci->queues[q_type].q[q_num];
 212 }
 213
 214 static struct mlxsw_pci_queue *mlxsw_pci_sdq_get(struct mlxsw_pci *mlxsw_pci,
 215                                                  u8 q_num)
 216 {
 217         return __mlxsw_pci_queue_get(mlxsw_pci,
 218                                      MLXSW_PCI_QUEUE_TYPE_SDQ, q_num);
 219 }
 220
 221 static struct mlxsw_pci_queue *mlxsw_pci_rdq_get(struct mlxsw_pci *mlxsw_pci,
 222                                                  u8 q_num)
 223 {
 224         return __mlxsw_pci_queue_get(mlxsw_pci,
 225                                      MLXSW_PCI_QUEUE_TYPE_RDQ, q_num);
 226 }
 227
 228 static struct mlxsw_pci_queue *mlxsw_pci_cq_get(struct mlxsw_pci *mlxsw_pci,
 229                                                 u8 q_num)
 230 {
 231         return __mlxsw_pci_queue_get(mlxsw_pci, MLXSW_PCI_QUEUE_TYPE_CQ, q_num);
 232 }
 233
 234 static struct mlxsw_pci_queue *mlxsw_pci_eq_get(struct mlxsw_pci *mlxsw_pci,
 235                                                 u8 q_num)
 236 {
 237         return __mlxsw_pci_queue_get(mlxsw_pci, MLXSW_PCI_QUEUE_TYPE_EQ, q_num);
 238 }
 239
 240 static void __mlxsw_pci_queue_doorbell_set(struct mlxsw_pci *mlxsw_pci,
 241                                            struct mlxsw_pci_queue *q,
 242                                            u16 val)
 243 {
 244         mlxsw_pci_write32(mlxsw_pci,
 245                           DOORBELL(mlxsw_pci->doorbell_offset,
 246                                    mlxsw_pci_doorbell_type_offset[q->type],
 247                                    q->num), val);
 248 }
 249
 250 static void __mlxsw_pci_queue_doorbell_arm_set(struct mlxsw_pci *mlxsw_pci,
 251                                                struct mlxsw_pci_queue *q,
 252                                                u16 val)
 253 {
 254         mlxsw_pci_write32(mlxsw_pci,
 255                           DOORBELL(mlxsw_pci->doorbell_offset,
 256                                    mlxsw_pci_doorbell_arm_type_offset[q->type],
 257                                    q->num), val);
 258 }
 259
 260 static void mlxsw_pci_queue_doorbell_producer_ring(struct mlxsw_pci *mlxsw_pci,
 261                                                    struct mlxsw_pci_queue *q)
 262 {
 263         wmb(); /* ensure all writes are done before we ring a bell */
 264         __mlxsw_pci_queue_doorbell_set(mlxsw_pci, q, q->producer_counter);
 265 }
 266
 267 static void mlxsw_pci_queue_doorbell_consumer_ring(struct mlxsw_pci *mlxsw_pci,
 268                                                    struct mlxsw_pci_queue *q)
 269 {
 270         wmb(); /* ensure all writes are done before we ring a bell */
 271         __mlxsw_pci_queue_doorbell_set(mlxsw_pci, q,
 272                                        q->consumer_counter + q->count);
 273 }
 274
 275 static void
 276 mlxsw_pci_queue_doorbell_arm_consumer_ring(struct mlxsw_pci *mlxsw_pci,
 277                                            struct mlxsw_pci_queue *q)
 278 {
 279         wmb(); /* ensure all writes are done before we ring a bell */
 280         __mlxsw_pci_queue_doorbell_arm_set(mlxsw_pci, q, q->consumer_counter);
 281 }
 282
 283 static dma_addr_t __mlxsw_pci_queue_page_get(struct mlxsw_pci_queue *q,
 284                                              int page_index)
 285 {
 286         return q->mem_item.mapaddr + MLXSW_PCI_PAGE_SIZE * page_index;
 287 }
 288
 289 static int mlxsw_pci_sdq_init(struct mlxsw_pci *mlxsw_pci, char *mbox,
 290                               struct mlxsw_pci_queue *q)
 291 {
 292         int tclass;
 293         int lp;
 294         int i;
 295         int err;
 296
 297         q->producer_counter = 0;
 298         q->consumer_counter = 0;
 299         tclass = q->num == MLXSW_PCI_SDQ_EMAD_INDEX ? MLXSW_PCI_SDQ_EMAD_TC :
 300                                                       MLXSW_PCI_SDQ_CTL_TC;
 301         lp = q->num == MLXSW_PCI_SDQ_EMAD_INDEX ? MLXSW_CMD_MBOX_SW2HW_DQ_SDQ_LP_IGNORE_WQE :
 302                                                   MLXSW_CMD_MBOX_SW2HW_DQ_SDQ_LP_WQE;
 303
 304         /* Set CQ of same number of this SDQ. */
 305         mlxsw_cmd_mbox_sw2hw_dq_cq_set(mbox, q->num);
 306         mlxsw_cmd_mbox_sw2hw_dq_sdq_lp_set(mbox, lp);
 307         mlxsw_cmd_mbox_sw2hw_dq_sdq_tclass_set(mbox, tclass);
 308         mlxsw_cmd_mbox_sw2hw_dq_log2_dq_sz_set(mbox, 3); /* 8 pages */
 309         for (i = 0; i < MLXSW_PCI_AQ_PAGES; i++) {
 310                 dma_addr_t mapaddr = __mlxsw_pci_queue_page_get(q, i);
 311
 312                 mlxsw_cmd_mbox_sw2hw_dq_pa_set(mbox, i, mapaddr);
 313         }
 314
 315         err = mlxsw_cmd_sw2hw_sdq(mlxsw_pci->core, mbox, q->num);
 316         if (err)
 317                 return err;
 318         mlxsw_pci_queue_doorbell_producer_ring(mlxsw_pci, q);
 319         return 0;
 320 }
 321
 322 static void mlxsw_pci_sdq_fini(struct mlxsw_pci *mlxsw_pci,
 323                                struct mlxsw_pci_queue *q)
 324 {
 325         mlxsw_cmd_hw2sw_sdq(mlxsw_pci->core, q->num);
 326 }
 327
 328 static int mlxsw_pci_wqe_frag_map(struct mlxsw_pci *mlxsw_pci, char *wqe,
 329                                   int index, char *frag_data, size_t frag_len,
 330                                   int direction)
 331 {
 332         struct pci_dev *pdev = mlxsw_pci->pdev;
 333         dma_addr_t mapaddr;
 334
 335         mapaddr = dma_map_single(&pdev->dev, frag_data, frag_len, direction);
 336         if (unlikely(dma_mapping_error(&pdev->dev, mapaddr))) {
 337                 dev_err_ratelimited(&pdev->dev, "failed to dma map tx frag\n");
 338                 return -EIO;
 339         }
 340         mlxsw_pci_wqe_address_set(wqe, index, mapaddr);
 341         mlxsw_pci_wqe_byte_count_set(wqe, index, frag_len);
 342         return 0;
 343 }
 344
 345 static void mlxsw_pci_wqe_frag_unmap(struct mlxsw_pci *mlxsw_pci, char *wqe,
 346                                      int index, int direction)
 347 {
 348         struct pci_dev *pdev = mlxsw_pci->pdev;
 349         size_t frag_len = mlxsw_pci_wqe_byte_count_get(wqe, index);
 350         dma_addr_t mapaddr = mlxsw_pci_wqe_address_get(wqe, index);
 351
 352         if (!frag_len)
 353                 return;
 354         dma_unmap_single(&pdev->dev, mapaddr, frag_len, direction);
 355 }
 356
 357 static int mlxsw_pci_rdq_skb_alloc(struct mlxsw_pci *mlxsw_pci,
 358                                    struct mlxsw_pci_queue_elem_info *elem_info,
 359                                    gfp_t gfp)
 360 {
 361         size_t buf_len = MLXSW_PORT_MAX_MTU;
 362         char *wqe = elem_info->elem;
 363         struct sk_buff *skb;
 364         int err;
 365
 366         skb = __netdev_alloc_skb_ip_align(NULL, buf_len, gfp);
 367         if (!skb)
 368                 return -ENOMEM;
 369
 370         err = mlxsw_pci_wqe_frag_map(mlxsw_pci, wqe, 0, skb->data,
 371                                      buf_len, DMA_FROM_DEVICE);
 372         if (err)
 373                 goto err_frag_map;
 374
 375         elem_info->u.rdq.skb = skb;
 376         return 0;
 377
 378 err_frag_map:
 379         dev_kfree_skb_any(skb);
 380         return err;
 381 }
 382
 383 static void mlxsw_pci_rdq_skb_free(struct mlxsw_pci *mlxsw_pci,
 384                                    struct mlxsw_pci_queue_elem_info *elem_info)
 385 {
 386         struct sk_buff *skb;
 387         char *wqe;
 388
 389         skb = elem_info->u.rdq.skb;
 390         wqe = elem_info->elem;
 391
 392         mlxsw_pci_wqe_frag_unmap(mlxsw_pci, wqe, 0, DMA_FROM_DEVICE);
 393         dev_kfree_skb_any(skb);
 394 }
 395
 396 static int mlxsw_pci_rdq_init(struct mlxsw_pci *mlxsw_pci, char *mbox,
 397                               struct mlxsw_pci_queue *q)
 398 {
 399         struct mlxsw_pci_queue_elem_info *elem_info;
 400         u8 sdq_count = mlxsw_pci_sdq_count(mlxsw_pci);
 401         int i;
 402         int err;
 403
 404         q->producer_counter = 0;
 405         q->consumer_counter = 0;
 406
 407         /* Set CQ of same number of this RDQ with base
 408          * above SDQ count as the lower ones are assigned to SDQs.
 409          */
 410         mlxsw_cmd_mbox_sw2hw_dq_cq_set(mbox, sdq_count + q->num);
 411         mlxsw_cmd_mbox_sw2hw_dq_log2_dq_sz_set(mbox, 3); /* 8 pages */
 412         for (i = 0; i < MLXSW_PCI_AQ_PAGES; i++) {
 413                 dma_addr_t mapaddr = __mlxsw_pci_queue_page_get(q, i);
 414
 415                 mlxsw_cmd_mbox_sw2hw_dq_pa_set(mbox, i, mapaddr);
 416         }
 417
 418         err = mlxsw_cmd_sw2hw_rdq(mlxsw_pci->core, mbox, q->num);
 419         if (err)
 420                 return err;
 421
 422         mlxsw_pci_queue_doorbell_producer_ring(mlxsw_pci, q);
 423
 424         for (i = 0; i < q->count; i++) {
 425                 elem_info = mlxsw_pci_queue_elem_info_producer_get(q);
 426                 BUG_ON(!elem_info);
 427                 err = mlxsw_pci_rdq_skb_alloc(mlxsw_pci, elem_info, GFP_KERNEL);
 428                 if (err)
 429                         goto rollback;
 430                 /* Everything is set up, ring doorbell to pass elem to HW */
 431                 q->producer_counter++;
 432                 mlxsw_pci_queue_doorbell_producer_ring(mlxsw_pci, q);
 433         }
 434
 435         return 0;
 436
 437 rollback:
 438         for (i--; i >= 0; i--) {
 439                 elem_info = mlxsw_pci_queue_elem_info_get(q, i);
 440                 mlxsw_pci_rdq_skb_free(mlxsw_pci, elem_info);
 441         }
 442         mlxsw_cmd_hw2sw_rdq(mlxsw_pci->core, q->num);
 443
 444         return err;
 445 }
 446
 447 static void mlxsw_pci_rdq_fini(struct mlxsw_pci *mlxsw_pci,
 448                                struct mlxsw_pci_queue *q)
 449 {
 450         struct mlxsw_pci_queue_elem_info *elem_info;
 451         int i;
 452
 453         mlxsw_cmd_hw2sw_rdq(mlxsw_pci->core, q->num);
 454         for (i = 0; i < q->count; i++) {
 455                 elem_info = mlxsw_pci_queue_elem_info_get(q, i);
 456                 mlxsw_pci_rdq_skb_free(mlxsw_pci, elem_info);
 457         }
 458 }
 459
 460 static void mlxsw_pci_cq_pre_init(struct mlxsw_pci *mlxsw_pci,
 461                                   struct mlxsw_pci_queue *q)
 462 {
 463         q->u.cq.v = mlxsw_pci->max_cqe_ver;
 464
 465         if (q->u.cq.v == MLXSW_PCI_CQE_V2 &&
 466             q->num < mlxsw_pci->num_sdq_cqs &&
 467             !mlxsw_core_sdq_supports_cqe_v2(mlxsw_pci->core))
 468                 q->u.cq.v = MLXSW_PCI_CQE_V1;
 469 }
 470
 471 static int mlxsw_pci_cq_init(struct mlxsw_pci *mlxsw_pci, char *mbox,
 472                              struct mlxsw_pci_queue *q)
 473 {
 474         int i;
 475         int err;
 476
 477         q->consumer_counter = 0;
 478
 479         for (i = 0; i < q->count; i++) {
 480                 char *elem = mlxsw_pci_queue_elem_get(q, i);
 481
 482                 mlxsw_pci_cqe_owner_set(q->u.cq.v, elem, 1);
 483         }
 484
 485         if (q->u.cq.v == MLXSW_PCI_CQE_V1)
 486                 mlxsw_cmd_mbox_sw2hw_cq_cqe_ver_set(mbox,
 487                                 MLXSW_CMD_MBOX_SW2HW_CQ_CQE_VER_1);
 488         else if (q->u.cq.v == MLXSW_PCI_CQE_V2)
 489                 mlxsw_cmd_mbox_sw2hw_cq_cqe_ver_set(mbox,
 490                                 MLXSW_CMD_MBOX_SW2HW_CQ_CQE_VER_2);
 491
 492         mlxsw_cmd_mbox_sw2hw_cq_c_eqn_set(mbox, MLXSW_PCI_EQ_COMP_NUM);
 493         mlxsw_cmd_mbox_sw2hw_cq_st_set(mbox, 0);
 494         mlxsw_cmd_mbox_sw2hw_cq_log_cq_size_set(mbox, ilog2(q->count));
 495         for (i = 0; i < MLXSW_PCI_AQ_PAGES; i++) {
 496                 dma_addr_t mapaddr = __mlxsw_pci_queue_page_get(q, i);
 497
 498                 mlxsw_cmd_mbox_sw2hw_cq_pa_set(mbox, i, mapaddr);
 499         }
 500         err = mlxsw_cmd_sw2hw_cq(mlxsw_pci->core, mbox, q->num);
 501         if (err)
 502                 return err;
 503         mlxsw_pci_queue_doorbell_consumer_ring(mlxsw_pci, q);
 504         mlxsw_pci_queue_doorbell_arm_consumer_ring(mlxsw_pci, q);
 505         return 0;
 506 }
 507
 508 static void mlxsw_pci_cq_fini(struct mlxsw_pci *mlxsw_pci,
 509                               struct mlxsw_pci_queue *q)
 510 {
 511         mlxsw_cmd_hw2sw_cq(mlxsw_pci->core, q->num);
 512 }
 513
 514 static unsigned int mlxsw_pci_read32_off(struct mlxsw_pci *mlxsw_pci,
 515                                          ptrdiff_t off)
 516 {
 517         return ioread32be(mlxsw_pci->hw_addr + off);
 518 }
 519
 520 static void mlxsw_pci_skb_cb_ts_set(struct mlxsw_pci *mlxsw_pci,
 521                                     struct sk_buff *skb,
 522                                     enum mlxsw_pci_cqe_v cqe_v, char *cqe)
 523 {
 524         u8 ts_type;
 525
 526         if (cqe_v != MLXSW_PCI_CQE_V2)
 527                 return;
 528
 529         ts_type = mlxsw_pci_cqe2_time_stamp_type_get(cqe);
 530
 531         if (ts_type != MLXSW_PCI_CQE_TIME_STAMP_TYPE_UTC &&
 532             ts_type != MLXSW_PCI_CQE_TIME_STAMP_TYPE_MIRROR_UTC)
 533                 return;
 534
 535         mlxsw_skb_cb(skb)->cqe_ts.sec = mlxsw_pci_cqe2_time_stamp_sec_get(cqe);
 536         mlxsw_skb_cb(skb)->cqe_ts.nsec =
 537                 mlxsw_pci_cqe2_time_stamp_nsec_get(cqe);
 538 }
 539
 540 static void mlxsw_pci_cqe_sdq_handle(struct mlxsw_pci *mlxsw_pci,
 541                                      struct mlxsw_pci_queue *q,
 542                                      u16 consumer_counter_limit,
 543                                      enum mlxsw_pci_cqe_v cqe_v,
 544                                      char *cqe)
 545 {
 546         struct pci_dev *pdev = mlxsw_pci->pdev;
 547         struct mlxsw_pci_queue_elem_info *elem_info;
 548         struct mlxsw_tx_info tx_info;
 549         char *wqe;
 550         struct sk_buff *skb;
 551         int i;
 552
 553         spin_lock(&q->lock);
 554         elem_info = mlxsw_pci_queue_elem_info_consumer_get(q);
 555         tx_info = mlxsw_skb_cb(elem_info->u.sdq.skb)->tx_info;
 556         skb = elem_info->u.sdq.skb;
 557         wqe = elem_info->elem;
 558         for (i = 0; i < MLXSW_PCI_WQE_SG_ENTRIES; i++)
 559                 mlxsw_pci_wqe_frag_unmap(mlxsw_pci, wqe, i, DMA_TO_DEVICE);
 560
 561         if (unlikely(!tx_info.is_emad &&
 562                      skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)) {
 563                 mlxsw_pci_skb_cb_ts_set(mlxsw_pci, skb, cqe_v, cqe);
 564                 mlxsw_core_ptp_transmitted(mlxsw_pci->core, skb,
 565                                            tx_info.local_port);
 566                 skb = NULL;
 567         }
 568
 569         if (skb)
 570                 dev_kfree_skb_any(skb);
 571         elem_info->u.sdq.skb = NULL;
 572
 573         if (q->consumer_counter++ != consumer_counter_limit)
 574                 dev_dbg_ratelimited(&pdev->dev, "Consumer counter does not match limit in SDQ\n");
 575         spin_unlock(&q->lock);
 576 }
 577
 578 static void mlxsw_pci_cqe_rdq_md_tx_port_init(struct sk_buff *skb,
 579                                               const char *cqe)
 580 {
 581         struct mlxsw_skb_cb *cb = mlxsw_skb_cb(skb);
 582
 583         if (mlxsw_pci_cqe2_tx_lag_get(cqe)) {
 584                 cb->rx_md_info.tx_port_is_lag = true;
 585                 cb->rx_md_info.tx_lag_id = mlxsw_pci_cqe2_tx_lag_id_get(cqe);
 586                 cb->rx_md_info.tx_lag_port_index =
 587                         mlxsw_pci_cqe2_tx_lag_subport_get(cqe);
 588         } else {
 589                 cb->rx_md_info.tx_port_is_lag = false;
 590                 cb->rx_md_info.tx_sys_port =
 591                         mlxsw_pci_cqe2_tx_system_port_get(cqe);
 592         }
 593
 594         if (cb->rx_md_info.tx_sys_port != MLXSW_PCI_CQE2_TX_PORT_MULTI_PORT &&
 595             cb->rx_md_info.tx_sys_port != MLXSW_PCI_CQE2_TX_PORT_INVALID)
 596                 cb->rx_md_info.tx_port_valid = 1;
 597         else
 598                 cb->rx_md_info.tx_port_valid = 0;
 599 }
 600
 601 static void mlxsw_pci_cqe_rdq_md_init(struct sk_buff *skb, const char *cqe)
 602 {
 603         struct mlxsw_skb_cb *cb = mlxsw_skb_cb(skb);
 604
 605         cb->rx_md_info.tx_congestion = mlxsw_pci_cqe2_mirror_cong_get(cqe);
 606         if (cb->rx_md_info.tx_congestion != MLXSW_PCI_CQE2_MIRROR_CONG_INVALID)
 607                 cb->rx_md_info.tx_congestion_valid = 1;
 608         else
 609                 cb->rx_md_info.tx_congestion_valid = 0;
 610         cb->rx_md_info.tx_congestion <<= MLXSW_PCI_CQE2_MIRROR_CONG_SHIFT;
 611
 612         cb->rx_md_info.latency = mlxsw_pci_cqe2_mirror_latency_get(cqe);
 613         if (cb->rx_md_info.latency != MLXSW_PCI_CQE2_MIRROR_LATENCY_INVALID)
 614                 cb->rx_md_info.latency_valid = 1;
 615         else
 616                 cb->rx_md_info.latency_valid = 0;
 617
 618         cb->rx_md_info.tx_tc = mlxsw_pci_cqe2_mirror_tclass_get(cqe);
 619         if (cb->rx_md_info.tx_tc != MLXSW_PCI_CQE2_MIRROR_TCLASS_INVALID)
 620                 cb->rx_md_info.tx_tc_valid = 1;
 621         else
 622                 cb->rx_md_info.tx_tc_valid = 0;
 623
 624         mlxsw_pci_cqe_rdq_md_tx_port_init(skb, cqe);
 625 }
 626
 627 static void mlxsw_pci_cqe_rdq_handle(struct mlxsw_pci *mlxsw_pci,
 628                                      struct mlxsw_pci_queue *q,
 629                                      u16 consumer_counter_limit,
 630                                      enum mlxsw_pci_cqe_v cqe_v, char *cqe)
 631 {
 632         struct pci_dev *pdev = mlxsw_pci->pdev;
 633         struct mlxsw_pci_queue_elem_info *elem_info;
 634         struct mlxsw_rx_info rx_info = {};
 635         char wqe[MLXSW_PCI_WQE_SIZE];
 636         struct sk_buff *skb;
 637         u16 byte_count;
 638         int err;
 639
 640         elem_info = mlxsw_pci_queue_elem_info_consumer_get(q);
 641         skb = elem_info->u.rdq.skb;
 642         memcpy(wqe, elem_info->elem, MLXSW_PCI_WQE_SIZE);
 643
 644         if (q->consumer_counter++ != consumer_counter_limit)
 645                 dev_dbg_ratelimited(&pdev->dev, "Consumer counter does not match limit in RDQ\n");
 646
 647         err = mlxsw_pci_rdq_skb_alloc(mlxsw_pci, elem_info, GFP_ATOMIC);
 648         if (err) {
 649                 dev_err_ratelimited(&pdev->dev, "Failed to alloc skb for RDQ\n");
 650                 goto out;
 651         }
 652
 653         mlxsw_pci_wqe_frag_unmap(mlxsw_pci, wqe, 0, DMA_FROM_DEVICE);
 654
 655         if (mlxsw_pci_cqe_lag_get(cqe_v, cqe)) {
 656                 rx_info.is_lag = true;
 657                 rx_info.u.lag_id = mlxsw_pci_cqe_lag_id_get(cqe_v, cqe);
 658                 rx_info.lag_port_index =
 659                         mlxsw_pci_cqe_lag_subport_get(cqe_v, cqe);
 660         } else {
 661                 rx_info.is_lag = false;
 662                 rx_info.u.sys_port = mlxsw_pci_cqe_system_port_get(cqe);
 663         }
 664
 665         rx_info.trap_id = mlxsw_pci_cqe_trap_id_get(cqe);
 666
 667         if (rx_info.trap_id == MLXSW_TRAP_ID_DISCARD_INGRESS_ACL ||
 668             rx_info.trap_id == MLXSW_TRAP_ID_DISCARD_EGRESS_ACL) {
 669                 u32 cookie_index = 0;
 670
 671                 if (mlxsw_pci->max_cqe_ver >= MLXSW_PCI_CQE_V2)
 672                         cookie_index = mlxsw_pci_cqe2_user_def_val_orig_pkt_len_get(cqe);
 673                 mlxsw_skb_cb(skb)->rx_md_info.cookie_index = cookie_index;
 674         } else if (rx_info.trap_id >= MLXSW_TRAP_ID_MIRROR_SESSION0 &&
 675                    rx_info.trap_id <= MLXSW_TRAP_ID_MIRROR_SESSION7 &&
 676                    mlxsw_pci->max_cqe_ver >= MLXSW_PCI_CQE_V2) {
 677                 rx_info.mirror_reason = mlxsw_pci_cqe2_mirror_reason_get(cqe);
 678                 mlxsw_pci_cqe_rdq_md_init(skb, cqe);
 679         } else if (rx_info.trap_id == MLXSW_TRAP_ID_PKT_SAMPLE &&
 680                    mlxsw_pci->max_cqe_ver >= MLXSW_PCI_CQE_V2) {
 681                 mlxsw_pci_cqe_rdq_md_tx_port_init(skb, cqe);
 682         }
 683
 684         mlxsw_pci_skb_cb_ts_set(mlxsw_pci, skb, cqe_v, cqe);
 685
 686         byte_count = mlxsw_pci_cqe_byte_count_get(cqe);
 687         if (mlxsw_pci_cqe_crc_get(cqe_v, cqe))
 688                 byte_count -= ETH_FCS_LEN;
 689         skb_put(skb, byte_count);
 690         mlxsw_core_skb_receive(mlxsw_pci->core, skb, &rx_info);
 691
 692 out:
 693         /* Everything is set up, ring doorbell to pass elem to HW */
 694         q->producer_counter++;
 695         mlxsw_pci_queue_doorbell_producer_ring(mlxsw_pci, q);
 696         return;
 697 }
 698
 699 static char *mlxsw_pci_cq_sw_cqe_get(struct mlxsw_pci_queue *q)
 700 {
 701         struct mlxsw_pci_queue_elem_info *elem_info;
 702         char *elem;
 703         bool owner_bit;
 704
 705         elem_info = mlxsw_pci_queue_elem_info_consumer_get(q);
 706         elem = elem_info->elem;
 707         owner_bit = mlxsw_pci_cqe_owner_get(q->u.cq.v, elem);
 708         if (mlxsw_pci_elem_hw_owned(q, owner_bit))
 709                 return NULL;
 710         q->consumer_counter++;
 711         rmb(); /* make sure we read owned bit before the rest of elem */
 712         return elem;
 713 }
 714
 715 static void mlxsw_pci_cq_tasklet(struct tasklet_struct *t)
 716 {
 717         struct mlxsw_pci_queue *q = from_tasklet(q, t, tasklet);
 718         struct mlxsw_pci *mlxsw_pci = q->pci;
 719         char *cqe;
 720         int items = 0;
 721         int credits = q->count >> 1;
 722
 723         while ((cqe = mlxsw_pci_cq_sw_cqe_get(q))) {
 724                 u16 wqe_counter = mlxsw_pci_cqe_wqe_counter_get(cqe);
 725                 u8 sendq = mlxsw_pci_cqe_sr_get(q->u.cq.v, cqe);
 726                 u8 dqn = mlxsw_pci_cqe_dqn_get(q->u.cq.v, cqe);
 727                 char ncqe[MLXSW_PCI_CQE_SIZE_MAX];
 728
 729                 memcpy(ncqe, cqe, q->elem_size);
 730                 mlxsw_pci_queue_doorbell_consumer_ring(mlxsw_pci, q);
 731
 732                 if (sendq) {
 733                         struct mlxsw_pci_queue *sdq;
 734
 735                         sdq = mlxsw_pci_sdq_get(mlxsw_pci, dqn);
 736                         mlxsw_pci_cqe_sdq_handle(mlxsw_pci, sdq,
 737                                                  wqe_counter, q->u.cq.v, ncqe);
 738                         q->u.cq.comp_sdq_count++;
 739                 } else {
 740                         struct mlxsw_pci_queue *rdq;
 741
 742                         rdq = mlxsw_pci_rdq_get(mlxsw_pci, dqn);
 743                         mlxsw_pci_cqe_rdq_handle(mlxsw_pci, rdq,
 744                                                  wqe_counter, q->u.cq.v, ncqe);
 745                         q->u.cq.comp_rdq_count++;
 746                 }
 747                 if (++items == credits)
 748                         break;
 749         }
 750         if (items)
 751                 mlxsw_pci_queue_doorbell_arm_consumer_ring(mlxsw_pci, q);
 752 }
 753
 754 static u16 mlxsw_pci_cq_elem_count(const struct mlxsw_pci_queue *q)
 755 {
 756         return q->u.cq.v == MLXSW_PCI_CQE_V2 ? MLXSW_PCI_CQE2_COUNT :
 757                                                MLXSW_PCI_CQE01_COUNT;
 758 }
 759
 760 static u8 mlxsw_pci_cq_elem_size(const struct mlxsw_pci_queue *q)
 761 {
 762         return q->u.cq.v == MLXSW_PCI_CQE_V2 ? MLXSW_PCI_CQE2_SIZE :
 763                                                MLXSW_PCI_CQE01_SIZE;
 764 }
 765
 766 static int mlxsw_pci_eq_init(struct mlxsw_pci *mlxsw_pci, char *mbox,
 767                              struct mlxsw_pci_queue *q)
 768 {
 769         int i;
 770         int err;
 771
 772         q->consumer_counter = 0;
 773
 774         for (i = 0; i < q->count; i++) {
 775                 char *elem = mlxsw_pci_queue_elem_get(q, i);
 776
 777                 mlxsw_pci_eqe_owner_set(elem, 1);
 778         }
 779
 780         mlxsw_cmd_mbox_sw2hw_eq_int_msix_set(mbox, 1); /* MSI-X used */
 781         mlxsw_cmd_mbox_sw2hw_eq_st_set(mbox, 1); /* armed */
 782         mlxsw_cmd_mbox_sw2hw_eq_log_eq_size_set(mbox, ilog2(q->count));
 783         for (i = 0; i < MLXSW_PCI_AQ_PAGES; i++) {
 784                 dma_addr_t mapaddr = __mlxsw_pci_queue_page_get(q, i);
 785
 786                 mlxsw_cmd_mbox_sw2hw_eq_pa_set(mbox, i, mapaddr);
 787         }
 788         err = mlxsw_cmd_sw2hw_eq(mlxsw_pci->core, mbox, q->num);
 789         if (err)
 790                 return err;
 791         mlxsw_pci_queue_doorbell_consumer_ring(mlxsw_pci, q);
 792         mlxsw_pci_queue_doorbell_arm_consumer_ring(mlxsw_pci, q);
 793         return 0;
 794 }
 795
 796 static void mlxsw_pci_eq_fini(struct mlxsw_pci *mlxsw_pci,
 797                               struct mlxsw_pci_queue *q)
 798 {
 799         mlxsw_cmd_hw2sw_eq(mlxsw_pci->core, q->num);
 800 }
 801
 802 static void mlxsw_pci_eq_cmd_event(struct mlxsw_pci *mlxsw_pci, char *eqe)
 803 {
 804         mlxsw_pci->cmd.comp.status = mlxsw_pci_eqe_cmd_status_get(eqe);
 805         mlxsw_pci->cmd.comp.out_param =
 806                 ((u64) mlxsw_pci_eqe_cmd_out_param_h_get(eqe)) << 32 |
 807                 mlxsw_pci_eqe_cmd_out_param_l_get(eqe);
 808         mlxsw_pci->cmd.wait_done = true;
 809         wake_up(&mlxsw_pci->cmd.wait);
 810 }
 811
 812 static char *mlxsw_pci_eq_sw_eqe_get(struct mlxsw_pci_queue *q)
 813 {
 814         struct mlxsw_pci_queue_elem_info *elem_info;
 815         char *elem;
 816         bool owner_bit;
 817
 818         elem_info = mlxsw_pci_queue_elem_info_consumer_get(q);
 819         elem = elem_info->elem;
 820         owner_bit = mlxsw_pci_eqe_owner_get(elem);
 821         if (mlxsw_pci_elem_hw_owned(q, owner_bit))
 822                 return NULL;
 823         q->consumer_counter++;
 824         rmb(); /* make sure we read owned bit before the rest of elem */
 825         return elem;
 826 }
 827
 828 static void mlxsw_pci_eq_tasklet(struct tasklet_struct *t)
 829 {
 830         struct mlxsw_pci_queue *q = from_tasklet(q, t, tasklet);
 831         struct mlxsw_pci *mlxsw_pci = q->pci;
 832         u8 cq_count = mlxsw_pci_cq_count(mlxsw_pci);
 833         unsigned long active_cqns[BITS_TO_LONGS(MLXSW_PCI_CQS_MAX)];
 834         char *eqe;
 835         u8 cqn;
 836         bool cq_handle = false;
 837         int items = 0;
 838         int credits = q->count >> 1;
 839
 840         memset(&active_cqns, 0, sizeof(active_cqns));
 841
 842         while ((eqe = mlxsw_pci_eq_sw_eqe_get(q))) {
 843
 844                 /* Command interface completion events are always received on
 845                  * queue MLXSW_PCI_EQ_ASYNC_NUM (EQ0) and completion events
 846                  * are mapped to queue MLXSW_PCI_EQ_COMP_NUM (EQ1).
 847                  */
 848                 switch (q->num) {
 849                 case MLXSW_PCI_EQ_ASYNC_NUM:
 850                         mlxsw_pci_eq_cmd_event(mlxsw_pci, eqe);
 851                         q->u.eq.ev_cmd_count++;
 852                         break;
 853                 case MLXSW_PCI_EQ_COMP_NUM:
 854                         cqn = mlxsw_pci_eqe_cqn_get(eqe);
 855                         set_bit(cqn, active_cqns);
 856                         cq_handle = true;
 857                         q->u.eq.ev_comp_count++;
 858                         break;
 859                 default:
 860                         q->u.eq.ev_other_count++;
 861                 }
 862                 if (++items == credits)
 863                         break;
 864         }
 865         if (items) {
 866                 mlxsw_pci_queue_doorbell_consumer_ring(mlxsw_pci, q);
 867                 mlxsw_pci_queue_doorbell_arm_consumer_ring(mlxsw_pci, q);
 868         }
 869
 870         if (!cq_handle)
 871                 return;
 872         for_each_set_bit(cqn, active_cqns, cq_count) {
 873                 q = mlxsw_pci_cq_get(mlxsw_pci, cqn);
 874                 mlxsw_pci_queue_tasklet_schedule(q);
 875         }
 876 }
 877
 878 struct mlxsw_pci_queue_ops {
 879         const char *name;
 880         enum mlxsw_pci_queue_type type;
 881         void (*pre_init)(struct mlxsw_pci *mlxsw_pci,
 882                          struct mlxsw_pci_queue *q);
 883         int (*init)(struct mlxsw_pci *mlxsw_pci, char *mbox,
 884                     struct mlxsw_pci_queue *q);
 885         void (*fini)(struct mlxsw_pci *mlxsw_pci,
 886                      struct mlxsw_pci_queue *q);
 887         void (*tasklet)(struct tasklet_struct *t);
 888         u16 (*elem_count_f)(const struct mlxsw_pci_queue *q);
 889         u8 (*elem_size_f)(const struct mlxsw_pci_queue *q);
 890         u16 elem_count;
 891         u8 elem_size;
 892 };
 893
 894 static const struct mlxsw_pci_queue_ops mlxsw_pci_sdq_ops = {
 895         .type           = MLXSW_PCI_QUEUE_TYPE_SDQ,
 896         .init           = mlxsw_pci_sdq_init,
 897         .fini           = mlxsw_pci_sdq_fini,
 898         .elem_count     = MLXSW_PCI_WQE_COUNT,
 899         .elem_size      = MLXSW_PCI_WQE_SIZE,
 900 };
 901
 902 static const struct mlxsw_pci_queue_ops mlxsw_pci_rdq_ops = {
 903         .type           = MLXSW_PCI_QUEUE_TYPE_RDQ,
 904         .init           = mlxsw_pci_rdq_init,
 905         .fini           = mlxsw_pci_rdq_fini,
 906         .elem_count     = MLXSW_PCI_WQE_COUNT,
 907         .elem_size      = MLXSW_PCI_WQE_SIZE
 908 };
 909
 910 static const struct mlxsw_pci_queue_ops mlxsw_pci_cq_ops = {
 911         .type           = MLXSW_PCI_QUEUE_TYPE_CQ,
 912         .pre_init       = mlxsw_pci_cq_pre_init,
 913         .init           = mlxsw_pci_cq_init,
 914         .fini           = mlxsw_pci_cq_fini,
 915         .tasklet        = mlxsw_pci_cq_tasklet,
 916         .elem_count_f   = mlxsw_pci_cq_elem_count,
 917         .elem_size_f    = mlxsw_pci_cq_elem_size
 918 };
 919
 920 static const struct mlxsw_pci_queue_ops mlxsw_pci_eq_ops = {
 921         .type           = MLXSW_PCI_QUEUE_TYPE_EQ,
 922         .init           = mlxsw_pci_eq_init,
 923         .fini           = mlxsw_pci_eq_fini,
 924         .tasklet        = mlxsw_pci_eq_tasklet,
 925         .elem_count     = MLXSW_PCI_EQE_COUNT,
 926         .elem_size      = MLXSW_PCI_EQE_SIZE
 927 };
 928
 929 static int mlxsw_pci_queue_init(struct mlxsw_pci *mlxsw_pci, char *mbox,
 930                                 const struct mlxsw_pci_queue_ops *q_ops,
 931                                 struct mlxsw_pci_queue *q, u8 q_num)
 932 {
 933         struct mlxsw_pci_mem_item *mem_item = &q->mem_item;
 934         int i;
 935         int err;
 936
 937         q->num = q_num;
 938         if (q_ops->pre_init)
 939                 q_ops->pre_init(mlxsw_pci, q);
 940
 941         spin_lock_init(&q->lock);
 942         q->count = q_ops->elem_count_f ? q_ops->elem_count_f(q) :
 943                                          q_ops->elem_count;
 944         q->elem_size = q_ops->elem_size_f ? q_ops->elem_size_f(q) :
 945                                             q_ops->elem_size;
 946         q->type = q_ops->type;
 947         q->pci = mlxsw_pci;
 948
 949         if (q_ops->tasklet)
 950                 tasklet_setup(&q->tasklet, q_ops->tasklet);
 951
 952         mem_item->size = MLXSW_PCI_AQ_SIZE;
 953         mem_item->buf = dma_alloc_coherent(&mlxsw_pci->pdev->dev,
 954                                            mem_item->size, &mem_item->mapaddr,
 955                                            GFP_KERNEL);
 956         if (!mem_item->buf)
 957                 return -ENOMEM;
 958
 959         q->elem_info = kcalloc(q->count, sizeof(*q->elem_info), GFP_KERNEL);
 960         if (!q->elem_info) {
 961                 err = -ENOMEM;
 962                 goto err_elem_info_alloc;
 963         }
 964
 965         /* Initialize dma mapped elements info elem_info for
 966          * future easy access.
 967          */
 968         for (i = 0; i < q->count; i++) {
 969                 struct mlxsw_pci_queue_elem_info *elem_info;
 970
 971                 elem_info = mlxsw_pci_queue_elem_info_get(q, i);
 972                 elem_info->elem =
 973                         __mlxsw_pci_queue_elem_get(q, q->elem_size, i);
 974         }
 975
 976         mlxsw_cmd_mbox_zero(mbox);
 977         err = q_ops->init(mlxsw_pci, mbox, q);
 978         if (err)
 979                 goto err_q_ops_init;
 980         return 0;
 981
 982 err_q_ops_init:
 983         kfree(q->elem_info);
 984 err_elem_info_alloc:
 985         dma_free_coherent(&mlxsw_pci->pdev->dev, mem_item->size,
 986                           mem_item->buf, mem_item->mapaddr);
 987         return err;
 988 }
 989
 990 static void mlxsw_pci_queue_fini(struct mlxsw_pci *mlxsw_pci,
 991                                  const struct mlxsw_pci_queue_ops *q_ops,
 992                                  struct mlxsw_pci_queue *q)
 993 {
 994         struct mlxsw_pci_mem_item *mem_item = &q->mem_item;
 995
 996         q_ops->fini(mlxsw_pci, q);
 997         kfree(q->elem_info);
 998         dma_free_coherent(&mlxsw_pci->pdev->dev, mem_item->size,
 999                           mem_item->buf, mem_item->mapaddr);
1000 }
1001
1002 static int mlxsw_pci_queue_group_init(struct mlxsw_pci *mlxsw_pci, char *mbox,
1003                                       const struct mlxsw_pci_queue_ops *q_ops,
1004                                       u8 num_qs)
1005 {
1006         struct mlxsw_pci_queue_type_group *queue_group;
1007         int i;
1008         int err;
1009
1010         queue_group = mlxsw_pci_queue_type_group_get(mlxsw_pci, q_ops->type);
1011         queue_group->q = kcalloc(num_qs, sizeof(*queue_group->q), GFP_KERNEL);
1012         if (!queue_group->q)
1013                 return -ENOMEM;
1014
1015         for (i = 0; i < num_qs; i++) {
1016                 err = mlxsw_pci_queue_init(mlxsw_pci, mbox, q_ops,
1017                                            &queue_group->q[i], i);
1018                 if (err)
1019                         goto err_queue_init;
1020         }
1021         queue_group->count = num_qs;
1022
1023         return 0;
1024
1025 err_queue_init:
1026         for (i--; i >= 0; i--)
1027                 mlxsw_pci_queue_fini(mlxsw_pci, q_ops, &queue_group->q[i]);
1028         kfree(queue_group->q);
1029         return err;
1030 }
1031
1032 static void mlxsw_pci_queue_group_fini(struct mlxsw_pci *mlxsw_pci,
1033                                        const struct mlxsw_pci_queue_ops *q_ops)
1034 {
1035         struct mlxsw_pci_queue_type_group *queue_group;
1036         int i;
1037
1038         queue_group = mlxsw_pci_queue_type_group_get(mlxsw_pci, q_ops->type);
1039         for (i = 0; i < queue_group->count; i++)
1040                 mlxsw_pci_queue_fini(mlxsw_pci, q_ops, &queue_group->q[i]);
1041         kfree(queue_group->q);
1042 }
1043
1044 static int mlxsw_pci_aqs_init(struct mlxsw_pci *mlxsw_pci, char *mbox)
1045 {
1046         struct pci_dev *pdev = mlxsw_pci->pdev;
1047         u8 num_sdqs;
1048         u8 sdq_log2sz;
1049         u8 num_rdqs;
1050         u8 rdq_log2sz;
1051         u8 num_cqs;
1052         u8 cq_log2sz;
1053         u8 cqv2_log2sz;
1054         u8 num_eqs;
1055         u8 eq_log2sz;
1056         int err;
1057
1058         mlxsw_cmd_mbox_zero(mbox);
1059         err = mlxsw_cmd_query_aq_cap(mlxsw_pci->core, mbox);
1060         if (err)
1061                 return err;
1062
1063         num_sdqs = mlxsw_cmd_mbox_query_aq_cap_max_num_sdqs_get(mbox);
1064         sdq_log2sz = mlxsw_cmd_mbox_query_aq_cap_log_max_sdq_sz_get(mbox);
1065         num_rdqs = mlxsw_cmd_mbox_query_aq_cap_max_num_rdqs_get(mbox);
1066         rdq_log2sz = mlxsw_cmd_mbox_query_aq_cap_log_max_rdq_sz_get(mbox);
1067         num_cqs = mlxsw_cmd_mbox_query_aq_cap_max_num_cqs_get(mbox);
1068         cq_log2sz = mlxsw_cmd_mbox_query_aq_cap_log_max_cq_sz_get(mbox);
1069         cqv2_log2sz = mlxsw_cmd_mbox_query_aq_cap_log_max_cqv2_sz_get(mbox);
1070         num_eqs = mlxsw_cmd_mbox_query_aq_cap_max_num_eqs_get(mbox);
1071         eq_log2sz = mlxsw_cmd_mbox_query_aq_cap_log_max_eq_sz_get(mbox);
1072
1073         if (num_sdqs + num_rdqs > num_cqs ||
1074             num_sdqs < MLXSW_PCI_SDQS_MIN ||
1075             num_cqs > MLXSW_PCI_CQS_MAX || num_eqs != MLXSW_PCI_EQS_COUNT) {
1076                 dev_err(&pdev->dev, "Unsupported number of queues\n");
1077                 return -EINVAL;
1078         }
1079
1080         if ((1 << sdq_log2sz != MLXSW_PCI_WQE_COUNT) ||
1081             (1 << rdq_log2sz != MLXSW_PCI_WQE_COUNT) ||
1082             (1 << cq_log2sz != MLXSW_PCI_CQE01_COUNT) ||
1083             (mlxsw_pci->max_cqe_ver == MLXSW_PCI_CQE_V2 &&
1084              (1 << cqv2_log2sz != MLXSW_PCI_CQE2_COUNT)) ||
1085             (1 << eq_log2sz != MLXSW_PCI_EQE_COUNT)) {
1086                 dev_err(&pdev->dev, "Unsupported number of async queue descriptors\n");
1087                 return -EINVAL;
1088         }
1089
1090         mlxsw_pci->num_sdq_cqs = num_sdqs;
1091
1092         err = mlxsw_pci_queue_group_init(mlxsw_pci, mbox, &mlxsw_pci_eq_ops,
1093                                          num_eqs);
1094         if (err) {
1095                 dev_err(&pdev->dev, "Failed to initialize event queues\n");
1096                 return err;
1097         }
1098
1099         err = mlxsw_pci_queue_group_init(mlxsw_pci, mbox, &mlxsw_pci_cq_ops,
1100                                          num_cqs);
1101         if (err) {
1102                 dev_err(&pdev->dev, "Failed to initialize completion queues\n");
1103                 goto err_cqs_init;
1104         }
1105
1106         err = mlxsw_pci_queue_group_init(mlxsw_pci, mbox, &mlxsw_pci_sdq_ops,
1107                                          num_sdqs);
1108         if (err) {
1109                 dev_err(&pdev->dev, "Failed to initialize send descriptor queues\n");
1110                 goto err_sdqs_init;
1111         }
1112
1113         err = mlxsw_pci_queue_group_init(mlxsw_pci, mbox, &mlxsw_pci_rdq_ops,
1114                                          num_rdqs);
1115         if (err) {
1116                 dev_err(&pdev->dev, "Failed to initialize receive descriptor queues\n");
1117                 goto err_rdqs_init;
1118         }
1119
1120         /* We have to poll in command interface until queues are initialized */
1121         mlxsw_pci->cmd.nopoll = true;
1122         return 0;
1123
1124 err_rdqs_init:
1125         mlxsw_pci_queue_group_fini(mlxsw_pci, &mlxsw_pci_sdq_ops);
1126 err_sdqs_init:
1127         mlxsw_pci_queue_group_fini(mlxsw_pci, &mlxsw_pci_cq_ops);
1128 err_cqs_init:
1129         mlxsw_pci_queue_group_fini(mlxsw_pci, &mlxsw_pci_eq_ops);
1130         return err;
1131 }
1132
1133 static void mlxsw_pci_aqs_fini(struct mlxsw_pci *mlxsw_pci)
1134 {
1135         mlxsw_pci->cmd.nopoll = false;
1136         mlxsw_pci_queue_group_fini(mlxsw_pci, &mlxsw_pci_rdq_ops);
1137         mlxsw_pci_queue_group_fini(mlxsw_pci, &mlxsw_pci_sdq_ops);
1138         mlxsw_pci_queue_group_fini(mlxsw_pci, &mlxsw_pci_cq_ops);
1139         mlxsw_pci_queue_group_fini(mlxsw_pci, &mlxsw_pci_eq_ops);
1140 }
1141
1142 static void
1143 mlxsw_pci_config_profile_swid_config(struct mlxsw_pci *mlxsw_pci,
1144                                      char *mbox, int index,
1145                                      const struct mlxsw_swid_config *swid)
1146 {
1147         u8 mask = 0;
1148
1149         if (swid->used_type) {
1150                 mlxsw_cmd_mbox_config_profile_swid_config_type_set(
1151                         mbox, index, swid->type);
1152                 mask |= 1;
1153         }
1154         if (swid->used_properties) {
1155                 mlxsw_cmd_mbox_config_profile_swid_config_properties_set(
1156                         mbox, index, swid->properties);
1157                 mask |= 2;
1158         }
1159         mlxsw_cmd_mbox_config_profile_swid_config_mask_set(mbox, index, mask);
1160 }
1161
1162 static int
1163 mlxsw_pci_profile_get_kvd_sizes(const struct mlxsw_pci *mlxsw_pci,
1164                                 const struct mlxsw_config_profile *profile,
1165                                 struct mlxsw_res *res)
1166 {
1167         u64 single_size, double_size, linear_size;
1168         int err;
1169
1170         err = mlxsw_core_kvd_sizes_get(mlxsw_pci->core, profile,
1171                                        &single_size, &double_size,
1172                                        &linear_size);
1173         if (err)
1174                 return err;
1175
1176         MLXSW_RES_SET(res, KVD_SINGLE_SIZE, single_size);
1177         MLXSW_RES_SET(res, KVD_DOUBLE_SIZE, double_size);
1178         MLXSW_RES_SET(res, KVD_LINEAR_SIZE, linear_size);
1179
1180         return 0;
1181 }
1182
1183 static int mlxsw_pci_config_profile(struct mlxsw_pci *mlxsw_pci, char *mbox,
1184                                     const struct mlxsw_config_profile *profile,
1185                                     struct mlxsw_res *res)
1186 {
1187         int i;
1188         int err;
1189
1190         mlxsw_cmd_mbox_zero(mbox);
1191
1192         if (profile->used_max_vepa_channels) {
1193                 mlxsw_cmd_mbox_config_profile_set_max_vepa_channels_set(
1194                         mbox, 1);
1195                 mlxsw_cmd_mbox_config_profile_max_vepa_channels_set(
1196                         mbox, profile->max_vepa_channels);
1197         }
1198         if (profile->used_max_lag) {
1199                 mlxsw_cmd_mbox_config_profile_set_max_lag_set(mbox, 1);
1200                 mlxsw_cmd_mbox_config_profile_max_lag_set(mbox,
1201                                                           profile->max_lag);
1202         }
1203         if (profile->used_max_mid) {
1204                 mlxsw_cmd_mbox_config_profile_set_max_mid_set(
1205                         mbox, 1);
1206                 mlxsw_cmd_mbox_config_profile_max_mid_set(
1207                         mbox, profile->max_mid);
1208         }
1209         if (profile->used_max_pgt) {
1210                 mlxsw_cmd_mbox_config_profile_set_max_pgt_set(
1211                         mbox, 1);
1212                 mlxsw_cmd_mbox_config_profile_max_pgt_set(
1213                         mbox, profile->max_pgt);
1214         }
1215         if (profile->used_max_system_port) {
1216                 mlxsw_cmd_mbox_config_profile_set_max_system_port_set(
1217                         mbox, 1);
1218                 mlxsw_cmd_mbox_config_profile_max_system_port_set(
1219                         mbox, profile->max_system_port);
1220         }
1221         if (profile->used_max_vlan_groups) {
1222                 mlxsw_cmd_mbox_config_profile_set_max_vlan_groups_set(
1223                         mbox, 1);
1224                 mlxsw_cmd_mbox_config_profile_max_vlan_groups_set(
1225                         mbox, profile->max_vlan_groups);
1226         }
1227         if (profile->used_max_regions) {
1228                 mlxsw_cmd_mbox_config_profile_set_max_regions_set(
1229                         mbox, 1);
1230                 mlxsw_cmd_mbox_config_profile_max_regions_set(
1231                         mbox, profile->max_regions);
1232         }
1233         if (profile->used_flood_tables) {
1234                 mlxsw_cmd_mbox_config_profile_set_flood_tables_set(
1235                         mbox, 1);
1236                 mlxsw_cmd_mbox_config_profile_max_flood_tables_set(
1237                         mbox, profile->max_flood_tables);
1238                 mlxsw_cmd_mbox_config_profile_max_vid_flood_tables_set(
1239                         mbox, profile->max_vid_flood_tables);
1240                 mlxsw_cmd_mbox_config_profile_max_fid_offset_flood_tables_set(
1241                         mbox, profile->max_fid_offset_flood_tables);
1242                 mlxsw_cmd_mbox_config_profile_fid_offset_flood_table_size_set(
1243                         mbox, profile->fid_offset_flood_table_size);
1244                 mlxsw_cmd_mbox_config_profile_max_fid_flood_tables_set(
1245                         mbox, profile->max_fid_flood_tables);
1246                 mlxsw_cmd_mbox_config_profile_fid_flood_table_size_set(
1247                         mbox, profile->fid_flood_table_size);
1248         }
1249         if (profile->used_flood_mode) {
1250                 mlxsw_cmd_mbox_config_profile_set_flood_mode_set(
1251                         mbox, 1);
1252                 mlxsw_cmd_mbox_config_profile_flood_mode_set(
1253                         mbox, profile->flood_mode);
1254         }
1255         if (profile->used_max_ib_mc) {
1256                 mlxsw_cmd_mbox_config_profile_set_max_ib_mc_set(
1257                         mbox, 1);
1258                 mlxsw_cmd_mbox_config_profile_max_ib_mc_set(
1259                         mbox, profile->max_ib_mc);
1260         }
1261         if (profile->used_max_pkey) {
1262                 mlxsw_cmd_mbox_config_profile_set_max_pkey_set(
1263                         mbox, 1);
1264                 mlxsw_cmd_mbox_config_profile_max_pkey_set(
1265                         mbox, profile->max_pkey);
1266         }
1267         if (profile->used_ar_sec) {
1268                 mlxsw_cmd_mbox_config_profile_set_ar_sec_set(
1269                         mbox, 1);
1270                 mlxsw_cmd_mbox_config_profile_ar_sec_set(
1271                         mbox, profile->ar_sec);
1272         }
1273         if (profile->used_adaptive_routing_group_cap) {
1274                 mlxsw_cmd_mbox_config_profile_set_adaptive_routing_group_cap_set(
1275                         mbox, 1);
1276                 mlxsw_cmd_mbox_config_profile_adaptive_routing_group_cap_set(
1277                         mbox, profile->adaptive_routing_group_cap);
1278         }
1279         if (profile->used_ubridge) {
1280                 mlxsw_cmd_mbox_config_profile_set_ubridge_set(mbox, 1);
1281                 mlxsw_cmd_mbox_config_profile_ubridge_set(mbox,
1282                                                           profile->ubridge);
1283         }
1284         if (profile->used_kvd_sizes && MLXSW_RES_VALID(res, KVD_SIZE)) {
1285                 err = mlxsw_pci_profile_get_kvd_sizes(mlxsw_pci, profile, res);
1286                 if (err)
1287                         return err;
1288
1289                 mlxsw_cmd_mbox_config_profile_set_kvd_linear_size_set(mbox, 1);
1290                 mlxsw_cmd_mbox_config_profile_kvd_linear_size_set(mbox,
1291                                         MLXSW_RES_GET(res, KVD_LINEAR_SIZE));
1292                 mlxsw_cmd_mbox_config_profile_set_kvd_hash_single_size_set(mbox,
1293                                                                            1);
1294                 mlxsw_cmd_mbox_config_profile_kvd_hash_single_size_set(mbox,
1295                                         MLXSW_RES_GET(res, KVD_SINGLE_SIZE));
1296                 mlxsw_cmd_mbox_config_profile_set_kvd_hash_double_size_set(
1297                                                                 mbox, 1);
1298                 mlxsw_cmd_mbox_config_profile_kvd_hash_double_size_set(mbox,
1299                                         MLXSW_RES_GET(res, KVD_DOUBLE_SIZE));
1300         }
1301
1302         for (i = 0; i < MLXSW_CONFIG_PROFILE_SWID_COUNT; i++)
1303                 mlxsw_pci_config_profile_swid_config(mlxsw_pci, mbox, i,
1304                                                      &profile->swid_config[i]);
1305
1306         if (mlxsw_pci->max_cqe_ver > MLXSW_PCI_CQE_V0) {
1307                 mlxsw_cmd_mbox_config_profile_set_cqe_version_set(mbox, 1);
1308                 mlxsw_cmd_mbox_config_profile_cqe_version_set(mbox, 1);
1309         }
1310
1311         if (profile->used_cqe_time_stamp_type) {
1312                 mlxsw_cmd_mbox_config_profile_set_cqe_time_stamp_type_set(mbox,
1313                                                                           1);
1314                 mlxsw_cmd_mbox_config_profile_cqe_time_stamp_type_set(mbox,
1315                                         profile->cqe_time_stamp_type);
1316         }
1317
1318         if (profile->lag_mode_prefer_sw && mlxsw_pci->lag_mode_support) {
1319                 enum mlxsw_cmd_mbox_config_profile_lag_mode lag_mode =
1320                         MLXSW_CMD_MBOX_CONFIG_PROFILE_LAG_MODE_SW;
1321
1322                 mlxsw_cmd_mbox_config_profile_set_lag_mode_set(mbox, 1);
1323                 mlxsw_cmd_mbox_config_profile_lag_mode_set(mbox, lag_mode);
1324                 mlxsw_pci->lag_mode = lag_mode;
1325         } else {
1326                 mlxsw_pci->lag_mode = MLXSW_CMD_MBOX_CONFIG_PROFILE_LAG_MODE_FW;
1327         }
1328         return mlxsw_cmd_config_profile_set(mlxsw_pci->core, mbox);
1329 }
1330
1331 static int mlxsw_pci_boardinfo(struct mlxsw_pci *mlxsw_pci, char *mbox)
1332 {
1333         struct mlxsw_bus_info *bus_info = &mlxsw_pci->bus_info;
1334         int err;
1335
1336         mlxsw_cmd_mbox_zero(mbox);
1337         err = mlxsw_cmd_boardinfo(mlxsw_pci->core, mbox);
1338         if (err)
1339                 return err;
1340         mlxsw_cmd_mbox_boardinfo_vsd_memcpy_from(mbox, bus_info->vsd);
1341         mlxsw_cmd_mbox_boardinfo_psid_memcpy_from(mbox, bus_info->psid);
1342         return 0;
1343 }
1344
1345 static int mlxsw_pci_fw_area_init(struct mlxsw_pci *mlxsw_pci, char *mbox,
1346                                   u16 num_pages)
1347 {
1348         struct mlxsw_pci_mem_item *mem_item;
1349         int nent = 0;
1350         int i;
1351         int err;
1352
1353         mlxsw_pci->fw_area.items = kcalloc(num_pages, sizeof(*mem_item),
1354                                            GFP_KERNEL);
1355         if (!mlxsw_pci->fw_area.items)
1356                 return -ENOMEM;
1357         mlxsw_pci->fw_area.count = num_pages;
1358
1359         mlxsw_cmd_mbox_zero(mbox);
1360         for (i = 0; i < num_pages; i++) {
1361                 mem_item = &mlxsw_pci->fw_area.items[i];
1362
1363                 mem_item->size = MLXSW_PCI_PAGE_SIZE;
1364                 mem_item->buf = dma_alloc_coherent(&mlxsw_pci->pdev->dev,
1365                                                    mem_item->size,
1366                                                    &mem_item->mapaddr, GFP_KERNEL);
1367                 if (!mem_item->buf) {
1368                         err = -ENOMEM;
1369                         goto err_alloc;
1370                 }
1371                 mlxsw_cmd_mbox_map_fa_pa_set(mbox, nent, mem_item->mapaddr);
1372                 mlxsw_cmd_mbox_map_fa_log2size_set(mbox, nent, 0); /* 1 page */
1373                 if (++nent == MLXSW_CMD_MAP_FA_VPM_ENTRIES_MAX) {
1374                         err = mlxsw_cmd_map_fa(mlxsw_pci->core, mbox, nent);
1375                         if (err)
1376                                 goto err_cmd_map_fa;
1377                         nent = 0;
1378                         mlxsw_cmd_mbox_zero(mbox);
1379                 }
1380         }
1381
1382         if (nent) {
1383                 err = mlxsw_cmd_map_fa(mlxsw_pci->core, mbox, nent);
1384                 if (err)
1385                         goto err_cmd_map_fa;
1386         }
1387
1388         return 0;
1389
1390 err_cmd_map_fa:
1391 err_alloc:
1392         for (i--; i >= 0; i--) {
1393                 mem_item = &mlxsw_pci->fw_area.items[i];
1394
1395                 dma_free_coherent(&mlxsw_pci->pdev->dev, mem_item->size,
1396                                   mem_item->buf, mem_item->mapaddr);
1397         }
1398         kfree(mlxsw_pci->fw_area.items);
1399         return err;
1400 }
1401
1402 static void mlxsw_pci_fw_area_fini(struct mlxsw_pci *mlxsw_pci)
1403 {
1404         struct mlxsw_pci_mem_item *mem_item;
1405         int i;
1406
1407         mlxsw_cmd_unmap_fa(mlxsw_pci->core);
1408
1409         for (i = 0; i < mlxsw_pci->fw_area.count; i++) {
1410                 mem_item = &mlxsw_pci->fw_area.items[i];
1411
1412                 dma_free_coherent(&mlxsw_pci->pdev->dev, mem_item->size,
1413                                   mem_item->buf, mem_item->mapaddr);
1414         }
1415         kfree(mlxsw_pci->fw_area.items);
1416 }
1417
1418 static irqreturn_t mlxsw_pci_eq_irq_handler(int irq, void *dev_id)
1419 {
1420         struct mlxsw_pci *mlxsw_pci = dev_id;
1421         struct mlxsw_pci_queue *q;
1422         int i;
1423
1424         for (i = 0; i < MLXSW_PCI_EQS_COUNT; i++) {
1425                 q = mlxsw_pci_eq_get(mlxsw_pci, i);
1426                 mlxsw_pci_queue_tasklet_schedule(q);
1427         }
1428         return IRQ_HANDLED;
1429 }
1430
1431 static int mlxsw_pci_mbox_alloc(struct mlxsw_pci *mlxsw_pci,
1432                                 struct mlxsw_pci_mem_item *mbox)
1433 {
1434         struct pci_dev *pdev = mlxsw_pci->pdev;
1435         int err = 0;
1436
1437         mbox->size = MLXSW_CMD_MBOX_SIZE;
1438         mbox->buf = dma_alloc_coherent(&pdev->dev, MLXSW_CMD_MBOX_SIZE,
1439                                        &mbox->mapaddr, GFP_KERNEL);
1440         if (!mbox->buf) {
1441                 dev_err(&pdev->dev, "Failed allocating memory for mailbox\n");
1442                 err = -ENOMEM;
1443         }
1444
1445         return err;
1446 }
1447
1448 static void mlxsw_pci_mbox_free(struct mlxsw_pci *mlxsw_pci,
1449                                 struct mlxsw_pci_mem_item *mbox)
1450 {
1451         struct pci_dev *pdev = mlxsw_pci->pdev;
1452
1453         dma_free_coherent(&pdev->dev, MLXSW_CMD_MBOX_SIZE, mbox->buf,
1454                           mbox->mapaddr);
1455 }
1456
1457 static int mlxsw_pci_sys_ready_wait(struct mlxsw_pci *mlxsw_pci,
1458                                     const struct pci_device_id *id,
1459                                     u32 *p_sys_status)
1460 {
1461         unsigned long end;
1462         u32 val;
1463
1464         /* We must wait for the HW to become responsive. */
1465         msleep(MLXSW_PCI_SW_RESET_WAIT_MSECS);
1466
1467         end = jiffies + msecs_to_jiffies(MLXSW_PCI_SW_RESET_TIMEOUT_MSECS);
1468         do {
1469                 val = mlxsw_pci_read32(mlxsw_pci, FW_READY);
1470                 if ((val & MLXSW_PCI_FW_READY_MASK) == MLXSW_PCI_FW_READY_MAGIC)
1471                         return 0;
1472                 cond_resched();
1473         } while (time_before(jiffies, end));
1474
1475         *p_sys_status = val & MLXSW_PCI_FW_READY_MASK;
1476
1477         return -EBUSY;
1478 }
1479
1480 static int mlxsw_pci_reset_at_pci_disable(struct mlxsw_pci *mlxsw_pci)
1481 {
1482         struct pci_dev *pdev = mlxsw_pci->pdev;
1483         char mrsr_pl[MLXSW_REG_MRSR_LEN];
1484         int err;
1485
1486         mlxsw_reg_mrsr_pack(mrsr_pl,
1487                             MLXSW_REG_MRSR_COMMAND_RESET_AT_PCI_DISABLE);
1488         err = mlxsw_reg_write(mlxsw_pci->core, MLXSW_REG(mrsr), mrsr_pl);
1489         if (err)
1490                 return err;
1491
1492         device_lock_assert(&pdev->dev);
1493
1494         pci_cfg_access_lock(pdev);
1495         pci_save_state(pdev);
1496
1497         err = __pci_reset_function_locked(pdev);
1498         if (err)
1499                 pci_err(pdev, "PCI function reset failed with %d\n", err);
1500
1501         pci_restore_state(pdev);
1502         pci_cfg_access_unlock(pdev);
1503
1504         return err;
1505 }
1506
1507 static int mlxsw_pci_reset_sw(struct mlxsw_pci *mlxsw_pci)
1508 {
1509         char mrsr_pl[MLXSW_REG_MRSR_LEN];
1510
1511         mlxsw_reg_mrsr_pack(mrsr_pl, MLXSW_REG_MRSR_COMMAND_SOFTWARE_RESET);
1512         return mlxsw_reg_write(mlxsw_pci->core, MLXSW_REG(mrsr), mrsr_pl);
1513 }
1514
1515 static int
1516 mlxsw_pci_reset(struct mlxsw_pci *mlxsw_pci, const struct pci_device_id *id)
1517 {
1518         struct pci_dev *pdev = mlxsw_pci->pdev;
1519         char mcam_pl[MLXSW_REG_MCAM_LEN];
1520         bool pci_reset_supported;
1521         u32 sys_status;
1522         int err;
1523
1524         err = mlxsw_pci_sys_ready_wait(mlxsw_pci, id, &sys_status);
1525         if (err) {
1526                 dev_err(&pdev->dev, "Failed to reach system ready status before reset. Status is 0x%x\n",
1527                         sys_status);
1528                 return err;
1529         }
1530
1531         /* PCI core already issued a PCI reset, do not issue another reset. */
1532         if (mlxsw_pci->skip_reset)
1533                 return 0;
1534
1535         mlxsw_reg_mcam_pack(mcam_pl,
1536                             MLXSW_REG_MCAM_FEATURE_GROUP_ENHANCED_FEATURES);
1537         err = mlxsw_reg_query(mlxsw_pci->core, MLXSW_REG(mcam), mcam_pl);
1538         if (err)
1539                 return err;
1540
1541         mlxsw_reg_mcam_unpack(mcam_pl, MLXSW_REG_MCAM_PCI_RESET,
1542                               &pci_reset_supported);
1543
1544         if (pci_reset_supported) {
1545                 pci_dbg(pdev, "Starting PCI reset flow\n");
1546                 err = mlxsw_pci_reset_at_pci_disable(mlxsw_pci);
1547         } else {
1548                 pci_dbg(pdev, "Starting software reset flow\n");
1549                 err = mlxsw_pci_reset_sw(mlxsw_pci);
1550         }
1551
1552         err = mlxsw_pci_sys_ready_wait(mlxsw_pci, id, &sys_status);
1553         if (err) {
1554                 dev_err(&pdev->dev, "Failed to reach system ready status after reset. Status is 0x%x\n",
1555                         sys_status);
1556                 return err;
1557         }
1558
1559         return 0;
1560 }
1561
1562 static int mlxsw_pci_alloc_irq_vectors(struct mlxsw_pci *mlxsw_pci)
1563 {
1564         int err;
1565
1566         err = pci_alloc_irq_vectors(mlxsw_pci->pdev, 1, 1, PCI_IRQ_MSIX);
1567         if (err < 0)
1568                 dev_err(&mlxsw_pci->pdev->dev, "MSI-X init failed\n");
1569         return err;
1570 }
1571
1572 static void mlxsw_pci_free_irq_vectors(struct mlxsw_pci *mlxsw_pci)
1573 {
1574         pci_free_irq_vectors(mlxsw_pci->pdev);
1575 }
1576
1577 static int mlxsw_pci_init(void *bus_priv, struct mlxsw_core *mlxsw_core,
1578                           const struct mlxsw_config_profile *profile,
1579                           struct mlxsw_res *res)
1580 {
1581         struct mlxsw_pci *mlxsw_pci = bus_priv;
1582         struct pci_dev *pdev = mlxsw_pci->pdev;
1583         char *mbox;
1584         u16 num_pages;
1585         int err;
1586
1587         mlxsw_pci->core = mlxsw_core;
1588
1589         mbox = mlxsw_cmd_mbox_alloc();
1590         if (!mbox)
1591                 return -ENOMEM;
1592
1593         err = mlxsw_pci_reset(mlxsw_pci, mlxsw_pci->id);
1594         if (err)
1595                 goto err_reset;
1596
1597         err = mlxsw_pci_alloc_irq_vectors(mlxsw_pci);
1598         if (err < 0) {
1599                 dev_err(&pdev->dev, "MSI-X init failed\n");
1600                 goto err_alloc_irq;
1601         }
1602
1603         err = mlxsw_cmd_query_fw(mlxsw_core, mbox);
1604         if (err)
1605                 goto err_query_fw;
1606
1607         mlxsw_pci->bus_info.fw_rev.major =
1608                 mlxsw_cmd_mbox_query_fw_fw_rev_major_get(mbox);
1609         mlxsw_pci->bus_info.fw_rev.minor =
1610                 mlxsw_cmd_mbox_query_fw_fw_rev_minor_get(mbox);
1611         mlxsw_pci->bus_info.fw_rev.subminor =
1612                 mlxsw_cmd_mbox_query_fw_fw_rev_subminor_get(mbox);
1613
1614         if (mlxsw_cmd_mbox_query_fw_cmd_interface_rev_get(mbox) != 1) {
1615                 dev_err(&pdev->dev, "Unsupported cmd interface revision ID queried from hw\n");
1616                 err = -EINVAL;
1617                 goto err_iface_rev;
1618         }
1619         if (mlxsw_cmd_mbox_query_fw_doorbell_page_bar_get(mbox) != 0) {
1620                 dev_err(&pdev->dev, "Unsupported doorbell page bar queried from hw\n");
1621                 err = -EINVAL;
1622                 goto err_doorbell_page_bar;
1623         }
1624
1625         mlxsw_pci->doorbell_offset =
1626                 mlxsw_cmd_mbox_query_fw_doorbell_page_offset_get(mbox);
1627
1628         if (mlxsw_cmd_mbox_query_fw_fr_rn_clk_bar_get(mbox) != 0) {
1629                 dev_err(&pdev->dev, "Unsupported free running clock BAR queried from hw\n");
1630                 err = -EINVAL;
1631                 goto err_fr_rn_clk_bar;
1632         }
1633
1634         mlxsw_pci->free_running_clock_offset =
1635                 mlxsw_cmd_mbox_query_fw_free_running_clock_offset_get(mbox);
1636
1637         if (mlxsw_cmd_mbox_query_fw_utc_sec_bar_get(mbox) != 0) {
1638                 dev_err(&pdev->dev, "Unsupported UTC sec BAR queried from hw\n");
1639                 err = -EINVAL;
1640                 goto err_utc_sec_bar;
1641         }
1642
1643         mlxsw_pci->utc_sec_offset =
1644                 mlxsw_cmd_mbox_query_fw_utc_sec_offset_get(mbox);
1645
1646         if (mlxsw_cmd_mbox_query_fw_utc_nsec_bar_get(mbox) != 0) {
1647                 dev_err(&pdev->dev, "Unsupported UTC nsec BAR queried from hw\n");
1648                 err = -EINVAL;
1649                 goto err_utc_nsec_bar;
1650         }
1651
1652         mlxsw_pci->utc_nsec_offset =
1653                 mlxsw_cmd_mbox_query_fw_utc_nsec_offset_get(mbox);
1654
1655         mlxsw_pci->lag_mode_support =
1656                 mlxsw_cmd_mbox_query_fw_lag_mode_support_get(mbox);
1657         num_pages = mlxsw_cmd_mbox_query_fw_fw_pages_get(mbox);
1658         err = mlxsw_pci_fw_area_init(mlxsw_pci, mbox, num_pages);
1659         if (err)
1660                 goto err_fw_area_init;
1661
1662         err = mlxsw_pci_boardinfo(mlxsw_pci, mbox);
1663         if (err)
1664                 goto err_boardinfo;
1665
1666         err = mlxsw_core_resources_query(mlxsw_core, mbox, res);
1667         if (err)
1668                 goto err_query_resources;
1669
1670         if (MLXSW_CORE_RES_VALID(mlxsw_core, CQE_V2) &&
1671             MLXSW_CORE_RES_GET(mlxsw_core, CQE_V2))
1672                 mlxsw_pci->max_cqe_ver = MLXSW_PCI_CQE_V2;
1673         else if (MLXSW_CORE_RES_VALID(mlxsw_core, CQE_V1) &&
1674                  MLXSW_CORE_RES_GET(mlxsw_core, CQE_V1))
1675                 mlxsw_pci->max_cqe_ver = MLXSW_PCI_CQE_V1;
1676         else if ((MLXSW_CORE_RES_VALID(mlxsw_core, CQE_V0) &&
1677                   MLXSW_CORE_RES_GET(mlxsw_core, CQE_V0)) ||
1678                  !MLXSW_CORE_RES_VALID(mlxsw_core, CQE_V0)) {
1679                 mlxsw_pci->max_cqe_ver = MLXSW_PCI_CQE_V0;
1680         } else {
1681                 dev_err(&pdev->dev, "Invalid supported CQE version combination reported\n");
1682                 goto err_cqe_v_check;
1683         }
1684
1685         err = mlxsw_pci_config_profile(mlxsw_pci, mbox, profile, res);
1686         if (err)
1687                 goto err_config_profile;
1688
1689         /* Some resources depend on details of config_profile, such as unified
1690          * bridge model. Query the resources again to get correct values.
1691          */
1692         err = mlxsw_core_resources_query(mlxsw_core, mbox, res);
1693         if (err)
1694                 goto err_requery_resources;
1695
1696         err = mlxsw_pci_aqs_init(mlxsw_pci, mbox);
1697         if (err)
1698                 goto err_aqs_init;
1699
1700         err = request_irq(pci_irq_vector(pdev, 0),
1701                           mlxsw_pci_eq_irq_handler, 0,
1702                           mlxsw_pci->bus_info.device_kind, mlxsw_pci);
1703         if (err) {
1704                 dev_err(&pdev->dev, "IRQ request failed\n");
1705                 goto err_request_eq_irq;
1706         }
1707
1708         goto mbox_put;
1709
1710 err_request_eq_irq:
1711         mlxsw_pci_aqs_fini(mlxsw_pci);
1712 err_aqs_init:
1713 err_requery_resources:
1714 err_config_profile:
1715 err_cqe_v_check:
1716 err_query_resources:
1717 err_boardinfo:
1718         mlxsw_pci_fw_area_fini(mlxsw_pci);
1719 err_fw_area_init:
1720 err_utc_nsec_bar:
1721 err_utc_sec_bar:
1722 err_fr_rn_clk_bar:
1723 err_doorbell_page_bar:
1724 err_iface_rev:
1725 err_query_fw:
1726         mlxsw_pci_free_irq_vectors(mlxsw_pci);
1727 err_alloc_irq:
1728 err_reset:
1729 mbox_put:
1730         mlxsw_cmd_mbox_free(mbox);
1731         return err;
1732 }
1733
1734 static void mlxsw_pci_fini(void *bus_priv)
1735 {
1736         struct mlxsw_pci *mlxsw_pci = bus_priv;
1737
1738         free_irq(pci_irq_vector(mlxsw_pci->pdev, 0), mlxsw_pci);
1739         mlxsw_pci_aqs_fini(mlxsw_pci);
1740         mlxsw_pci_fw_area_fini(mlxsw_pci);
1741         mlxsw_pci_free_irq_vectors(mlxsw_pci);
1742 }
1743
1744 static struct mlxsw_pci_queue *
1745 mlxsw_pci_sdq_pick(struct mlxsw_pci *mlxsw_pci,
1746                    const struct mlxsw_tx_info *tx_info)
1747 {
1748         u8 ctl_sdq_count = mlxsw_pci_sdq_count(mlxsw_pci) - 1;
1749         u8 sdqn;
1750
1751         if (tx_info->is_emad) {
1752                 sdqn = MLXSW_PCI_SDQ_EMAD_INDEX;
1753         } else {
1754                 BUILD_BUG_ON(MLXSW_PCI_SDQ_EMAD_INDEX != 0);
1755                 sdqn = 1 + (tx_info->local_port % ctl_sdq_count);
1756         }
1757
1758         return mlxsw_pci_sdq_get(mlxsw_pci, sdqn);
1759 }
1760
1761 static bool mlxsw_pci_skb_transmit_busy(void *bus_priv,
1762                                         const struct mlxsw_tx_info *tx_info)
1763 {
1764         struct mlxsw_pci *mlxsw_pci = bus_priv;
1765         struct mlxsw_pci_queue *q = mlxsw_pci_sdq_pick(mlxsw_pci, tx_info);
1766
1767         return !mlxsw_pci_queue_elem_info_producer_get(q);
1768 }
1769
1770 static int mlxsw_pci_skb_transmit(void *bus_priv, struct sk_buff *skb,
1771                                   const struct mlxsw_tx_info *tx_info)
1772 {
1773         struct mlxsw_pci *mlxsw_pci = bus_priv;
1774         struct mlxsw_pci_queue *q;
1775         struct mlxsw_pci_queue_elem_info *elem_info;
1776         char *wqe;
1777         int i;
1778         int err;
1779
1780         if (skb_shinfo(skb)->nr_frags > MLXSW_PCI_WQE_SG_ENTRIES - 1) {
1781                 err = skb_linearize(skb);
1782                 if (err)
1783                         return err;
1784         }
1785
1786         q = mlxsw_pci_sdq_pick(mlxsw_pci, tx_info);
1787         spin_lock_bh(&q->lock);
1788         elem_info = mlxsw_pci_queue_elem_info_producer_get(q);
1789         if (!elem_info) {
1790                 /* queue is full */
1791                 err = -EAGAIN;
1792                 goto unlock;
1793         }
1794         mlxsw_skb_cb(skb)->tx_info = *tx_info;
1795         elem_info->u.sdq.skb = skb;
1796
1797         wqe = elem_info->elem;
1798         mlxsw_pci_wqe_c_set(wqe, 1); /* always report completion */
1799         mlxsw_pci_wqe_lp_set(wqe, 0);
1800         mlxsw_pci_wqe_type_set(wqe, MLXSW_PCI_WQE_TYPE_ETHERNET);
1801
1802         err = mlxsw_pci_wqe_frag_map(mlxsw_pci, wqe, 0, skb->data,
1803                                      skb_headlen(skb), DMA_TO_DEVICE);
1804         if (err)
1805                 goto unlock;
1806
1807         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1808                 const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1809
1810                 err = mlxsw_pci_wqe_frag_map(mlxsw_pci, wqe, i + 1,
1811                                              skb_frag_address(frag),
1812                                              skb_frag_size(frag),
1813                                              DMA_TO_DEVICE);
1814                 if (err)
1815                         goto unmap_frags;
1816         }
1817
1818         if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP))
1819                 skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
1820
1821         /* Set unused sq entries byte count to zero. */
1822         for (i++; i < MLXSW_PCI_WQE_SG_ENTRIES; i++)
1823                 mlxsw_pci_wqe_byte_count_set(wqe, i, 0);
1824
1825         /* Everything is set up, ring producer doorbell to get HW going */
1826         q->producer_counter++;
1827         mlxsw_pci_queue_doorbell_producer_ring(mlxsw_pci, q);
1828
1829         goto unlock;
1830
1831 unmap_frags:
1832         for (; i >= 0; i--)
1833                 mlxsw_pci_wqe_frag_unmap(mlxsw_pci, wqe, i, DMA_TO_DEVICE);
1834 unlock:
1835         spin_unlock_bh(&q->lock);
1836         return err;
1837 }
1838
1839 static int mlxsw_pci_cmd_exec(void *bus_priv, u16 opcode, u8 opcode_mod,
1840                               u32 in_mod, bool out_mbox_direct,
1841                               char *in_mbox, size_t in_mbox_size,
1842                               char *out_mbox, size_t out_mbox_size,
1843                               u8 *p_status)
1844 {
1845         struct mlxsw_pci *mlxsw_pci = bus_priv;
1846         dma_addr_t in_mapaddr = 0, out_mapaddr = 0;
1847         bool evreq = mlxsw_pci->cmd.nopoll;
1848         unsigned long timeout = msecs_to_jiffies(MLXSW_PCI_CIR_TIMEOUT_MSECS);
1849         bool *p_wait_done = &mlxsw_pci->cmd.wait_done;
1850         int err;
1851
1852         *p_status = MLXSW_CMD_STATUS_OK;
1853
1854         err = mutex_lock_interruptible(&mlxsw_pci->cmd.lock);
1855         if (err)
1856                 return err;
1857
1858         if (in_mbox) {
1859                 memcpy(mlxsw_pci->cmd.in_mbox.buf, in_mbox, in_mbox_size);
1860                 in_mapaddr = mlxsw_pci->cmd.in_mbox.mapaddr;
1861         }
1862         mlxsw_pci_write32(mlxsw_pci, CIR_IN_PARAM_HI, upper_32_bits(in_mapaddr));
1863         mlxsw_pci_write32(mlxsw_pci, CIR_IN_PARAM_LO, lower_32_bits(in_mapaddr));
1864
1865         if (out_mbox)
1866                 out_mapaddr = mlxsw_pci->cmd.out_mbox.mapaddr;
1867         mlxsw_pci_write32(mlxsw_pci, CIR_OUT_PARAM_HI, upper_32_bits(out_mapaddr));
1868         mlxsw_pci_write32(mlxsw_pci, CIR_OUT_PARAM_LO, lower_32_bits(out_mapaddr));
1869
1870         mlxsw_pci_write32(mlxsw_pci, CIR_IN_MODIFIER, in_mod);
1871         mlxsw_pci_write32(mlxsw_pci, CIR_TOKEN, 0);
1872
1873         *p_wait_done = false;
1874
1875         wmb(); /* all needs to be written before we write control register */
1876         mlxsw_pci_write32(mlxsw_pci, CIR_CTRL,
1877                           MLXSW_PCI_CIR_CTRL_GO_BIT |
1878                           (evreq ? MLXSW_PCI_CIR_CTRL_EVREQ_BIT : 0) |
1879                           (opcode_mod << MLXSW_PCI_CIR_CTRL_OPCODE_MOD_SHIFT) |
1880                           opcode);
1881
1882         if (!evreq) {
1883                 unsigned long end;
1884
1885                 end = jiffies + timeout;
1886                 do {
1887                         u32 ctrl = mlxsw_pci_read32(mlxsw_pci, CIR_CTRL);
1888
1889                         if (!(ctrl & MLXSW_PCI_CIR_CTRL_GO_BIT)) {
1890                                 *p_wait_done = true;
1891                                 *p_status = ctrl >> MLXSW_PCI_CIR_CTRL_STATUS_SHIFT;
1892                                 break;
1893                         }
1894                         cond_resched();
1895                 } while (time_before(jiffies, end));
1896         } else {
1897                 wait_event_timeout(mlxsw_pci->cmd.wait, *p_wait_done, timeout);
1898                 *p_status = mlxsw_pci->cmd.comp.status;
1899         }
1900
1901         err = 0;
1902         if (*p_wait_done) {
1903                 if (*p_status)
1904                         err = -EIO;
1905         } else {
1906                 err = -ETIMEDOUT;
1907         }
1908
1909         if (!err && out_mbox && out_mbox_direct) {
1910                 /* Some commands don't use output param as address to mailbox
1911                  * but they store output directly into registers. In that case,
1912                  * copy registers into mbox buffer.
1913                  */
1914                 __be32 tmp;
1915
1916                 if (!evreq) {
1917                         tmp = cpu_to_be32(mlxsw_pci_read32(mlxsw_pci,
1918                                                            CIR_OUT_PARAM_HI));
1919                         memcpy(out_mbox, &tmp, sizeof(tmp));
1920                         tmp = cpu_to_be32(mlxsw_pci_read32(mlxsw_pci,
1921                                                            CIR_OUT_PARAM_LO));
1922                         memcpy(out_mbox + sizeof(tmp), &tmp, sizeof(tmp));
1923                 }
1924         } else if (!err && out_mbox) {
1925                 memcpy(out_mbox, mlxsw_pci->cmd.out_mbox.buf, out_mbox_size);
1926         }
1927
1928         mutex_unlock(&mlxsw_pci->cmd.lock);
1929
1930         return err;
1931 }
1932
1933 static u32 mlxsw_pci_read_frc_h(void *bus_priv)
1934 {
1935         struct mlxsw_pci *mlxsw_pci = bus_priv;
1936         u64 frc_offset_h;
1937
1938         frc_offset_h = mlxsw_pci->free_running_clock_offset;
1939         return mlxsw_pci_read32_off(mlxsw_pci, frc_offset_h);
1940 }
1941
1942 static u32 mlxsw_pci_read_frc_l(void *bus_priv)
1943 {
1944         struct mlxsw_pci *mlxsw_pci = bus_priv;
1945         u64 frc_offset_l;
1946
1947         frc_offset_l = mlxsw_pci->free_running_clock_offset + 4;
1948         return mlxsw_pci_read32_off(mlxsw_pci, frc_offset_l);
1949 }
1950
1951 static u32 mlxsw_pci_read_utc_sec(void *bus_priv)
1952 {
1953         struct mlxsw_pci *mlxsw_pci = bus_priv;
1954
1955         return mlxsw_pci_read32_off(mlxsw_pci, mlxsw_pci->utc_sec_offset);
1956 }
1957
1958 static u32 mlxsw_pci_read_utc_nsec(void *bus_priv)
1959 {
1960         struct mlxsw_pci *mlxsw_pci = bus_priv;
1961
1962         return mlxsw_pci_read32_off(mlxsw_pci, mlxsw_pci->utc_nsec_offset);
1963 }
1964
1965 static enum mlxsw_cmd_mbox_config_profile_lag_mode
1966 mlxsw_pci_lag_mode(void *bus_priv)
1967 {
1968         struct mlxsw_pci *mlxsw_pci = bus_priv;
1969
1970         return mlxsw_pci->lag_mode;
1971 }
1972
1973 static const struct mlxsw_bus mlxsw_pci_bus = {
1974         .kind                   = "pci",
1975         .init                   = mlxsw_pci_init,
1976         .fini                   = mlxsw_pci_fini,
1977         .skb_transmit_busy      = mlxsw_pci_skb_transmit_busy,
1978         .skb_transmit           = mlxsw_pci_skb_transmit,
1979         .cmd_exec               = mlxsw_pci_cmd_exec,
1980         .read_frc_h             = mlxsw_pci_read_frc_h,
1981         .read_frc_l             = mlxsw_pci_read_frc_l,
1982         .read_utc_sec           = mlxsw_pci_read_utc_sec,
1983         .read_utc_nsec          = mlxsw_pci_read_utc_nsec,
1984         .lag_mode               = mlxsw_pci_lag_mode,
1985         .features               = MLXSW_BUS_F_TXRX | MLXSW_BUS_F_RESET,
1986 };
1987
1988 static int mlxsw_pci_cmd_init(struct mlxsw_pci *mlxsw_pci)
1989 {
1990         int err;
1991
1992         mutex_init(&mlxsw_pci->cmd.lock);
1993         init_waitqueue_head(&mlxsw_pci->cmd.wait);
1994
1995         err = mlxsw_pci_mbox_alloc(mlxsw_pci, &mlxsw_pci->cmd.in_mbox);
1996         if (err)
1997                 goto err_in_mbox_alloc;
1998
1999         err = mlxsw_pci_mbox_alloc(mlxsw_pci, &mlxsw_pci->cmd.out_mbox);
2000         if (err)
2001                 goto err_out_mbox_alloc;
2002
2003         return 0;
2004
2005 err_out_mbox_alloc:
2006         mlxsw_pci_mbox_free(mlxsw_pci, &mlxsw_pci->cmd.in_mbox);
2007 err_in_mbox_alloc:
2008         mutex_destroy(&mlxsw_pci->cmd.lock);
2009         return err;
2010 }
2011
2012 static void mlxsw_pci_cmd_fini(struct mlxsw_pci *mlxsw_pci)
2013 {
2014         mlxsw_pci_mbox_free(mlxsw_pci, &mlxsw_pci->cmd.out_mbox);
2015         mlxsw_pci_mbox_free(mlxsw_pci, &mlxsw_pci->cmd.in_mbox);
2016         mutex_destroy(&mlxsw_pci->cmd.lock);
2017 }
2018
2019 static int mlxsw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2020 {
2021         const char *driver_name = dev_driver_string(&pdev->dev);
2022         struct mlxsw_pci *mlxsw_pci;
2023         int err;
2024
2025         mlxsw_pci = kzalloc(sizeof(*mlxsw_pci), GFP_KERNEL);
2026         if (!mlxsw_pci)
2027                 return -ENOMEM;
2028
2029         err = pci_enable_device(pdev);
2030         if (err) {
2031                 dev_err(&pdev->dev, "pci_enable_device failed\n");
2032                 goto err_pci_enable_device;
2033         }
2034
2035         err = pci_request_regions(pdev, driver_name);
2036         if (err) {
2037                 dev_err(&pdev->dev, "pci_request_regions failed\n");
2038                 goto err_pci_request_regions;
2039         }
2040
2041         err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
2042         if (err) {
2043                 err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
2044                 if (err) {
2045                         dev_err(&pdev->dev, "dma_set_mask failed\n");
2046                         goto err_pci_set_dma_mask;
2047                 }
2048         }
2049
2050         if (pci_resource_len(pdev, 0) < MLXSW_PCI_BAR0_SIZE) {
2051                 dev_err(&pdev->dev, "invalid PCI region size\n");
2052                 err = -EINVAL;
2053                 goto err_pci_resource_len_check;
2054         }
2055
2056         mlxsw_pci->hw_addr = ioremap(pci_resource_start(pdev, 0),
2057                                      pci_resource_len(pdev, 0));
2058         if (!mlxsw_pci->hw_addr) {
2059                 dev_err(&pdev->dev, "ioremap failed\n");
2060                 err = -EIO;
2061                 goto err_ioremap;
2062         }
2063         pci_set_master(pdev);
2064
2065         mlxsw_pci->pdev = pdev;
2066         pci_set_drvdata(pdev, mlxsw_pci);
2067
2068         err = mlxsw_pci_cmd_init(mlxsw_pci);
2069         if (err)
2070                 goto err_pci_cmd_init;
2071
2072         mlxsw_pci->bus_info.device_kind = driver_name;
2073         mlxsw_pci->bus_info.device_name = pci_name(mlxsw_pci->pdev);
2074         mlxsw_pci->bus_info.dev = &pdev->dev;
2075         mlxsw_pci->bus_info.read_clock_capable = true;
2076         mlxsw_pci->id = id;
2077
2078         err = mlxsw_core_bus_device_register(&mlxsw_pci->bus_info,
2079                                              &mlxsw_pci_bus, mlxsw_pci, false,
2080                                              NULL, NULL);
2081         if (err) {
2082                 dev_err(&pdev->dev, "cannot register bus device\n");
2083                 goto err_bus_device_register;
2084         }
2085
2086         return 0;
2087
2088 err_bus_device_register:
2089         mlxsw_pci_cmd_fini(mlxsw_pci);
2090 err_pci_cmd_init:
2091         iounmap(mlxsw_pci->hw_addr);
2092 err_ioremap:
2093 err_pci_resource_len_check:
2094 err_pci_set_dma_mask:
2095         pci_release_regions(pdev);
2096 err_pci_request_regions:
2097         pci_disable_device(pdev);
2098 err_pci_enable_device:
2099         kfree(mlxsw_pci);
2100         return err;
2101 }
2102
2103 static void mlxsw_pci_remove(struct pci_dev *pdev)
2104 {
2105         struct mlxsw_pci *mlxsw_pci = pci_get_drvdata(pdev);
2106
2107         mlxsw_core_bus_device_unregister(mlxsw_pci->core, false);
2108         mlxsw_pci_cmd_fini(mlxsw_pci);
2109         iounmap(mlxsw_pci->hw_addr);
2110         pci_release_regions(mlxsw_pci->pdev);
2111         pci_disable_device(mlxsw_pci->pdev);
2112         kfree(mlxsw_pci);
2113 }
2114
2115 static void mlxsw_pci_reset_prepare(struct pci_dev *pdev)
2116 {
2117         struct mlxsw_pci *mlxsw_pci = pci_get_drvdata(pdev);
2118
2119         mlxsw_core_bus_device_unregister(mlxsw_pci->core, false);
2120 }
2121
2122 static void mlxsw_pci_reset_done(struct pci_dev *pdev)
2123 {
2124         struct mlxsw_pci *mlxsw_pci = pci_get_drvdata(pdev);
2125
2126         mlxsw_pci->skip_reset = true;
2127         mlxsw_core_bus_device_register(&mlxsw_pci->bus_info, &mlxsw_pci_bus,
2128                                        mlxsw_pci, false, NULL, NULL);
2129         mlxsw_pci->skip_reset = false;
2130 }
2131
2132 static const struct pci_error_handlers mlxsw_pci_err_handler = {
2133         .reset_prepare = mlxsw_pci_reset_prepare,
2134         .reset_done = mlxsw_pci_reset_done,
2135 };
2136
2137 int mlxsw_pci_driver_register(struct pci_driver *pci_driver)
2138 {
2139         pci_driver->probe = mlxsw_pci_probe;
2140         pci_driver->remove = mlxsw_pci_remove;
2141         pci_driver->shutdown = mlxsw_pci_remove;
2142         pci_driver->err_handler = &mlxsw_pci_err_handler;
2143         return pci_register_driver(pci_driver);
2144 }
2145 EXPORT_SYMBOL(mlxsw_pci_driver_register);
2146
2147 void mlxsw_pci_driver_unregister(struct pci_driver *pci_driver)
2148 {
2149         pci_unregister_driver(pci_driver);
2150 }
2151 EXPORT_SYMBOL(mlxsw_pci_driver_unregister);
2152
2153 static int __init mlxsw_pci_module_init(void)
2154 {
2155         return 0;
2156 }
2157
2158 static void __exit mlxsw_pci_module_exit(void)
2159 {
2160 }
2161
2162 module_init(mlxsw_pci_module_init);
2163 module_exit(mlxsw_pci_module_exit);
2164
2165 MODULE_LICENSE("Dual BSD/GPL");
2166 MODULE_AUTHOR("Jiri Pirko <jiri@mellanox.com>");
2167 MODULE_DESCRIPTION("Mellanox switch PCI interface driver");