drivers: use SPDX tag for Cavium copyright files
[dpdk.git] / drivers / net / liquidio / base / lio_23xx_vf.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2017 Cavium, Inc
3  */
4
5 #include <string.h>
6
7 #include <rte_ethdev.h>
8 #include <rte_cycles.h>
9 #include <rte_malloc.h>
10
11 #include "lio_logs.h"
12 #include "lio_23xx_vf.h"
13 #include "lio_23xx_reg.h"
14 #include "lio_mbox.h"
15
16 static int
17 cn23xx_vf_reset_io_queues(struct lio_device *lio_dev, uint32_t num_queues)
18 {
19         uint32_t loop = CN23XX_VF_BUSY_READING_REG_LOOP_COUNT;
20         uint64_t d64, q_no;
21         int ret_val = 0;
22
23         PMD_INIT_FUNC_TRACE();
24
25         for (q_no = 0; q_no < num_queues; q_no++) {
26                 /* set RST bit to 1. This bit applies to both IQ and OQ */
27                 d64 = lio_read_csr64(lio_dev,
28                                      CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
29                 d64 = d64 | CN23XX_PKT_INPUT_CTL_RST;
30                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(q_no),
31                                 d64);
32         }
33
34         /* wait until the RST bit is clear or the RST and QUIET bits are set */
35         for (q_no = 0; q_no < num_queues; q_no++) {
36                 volatile uint64_t reg_val;
37
38                 reg_val = lio_read_csr64(lio_dev,
39                                          CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
40                 while ((reg_val & CN23XX_PKT_INPUT_CTL_RST) &&
41                                 !(reg_val & CN23XX_PKT_INPUT_CTL_QUIET) &&
42                                 loop) {
43                         reg_val = lio_read_csr64(
44                                         lio_dev,
45                                         CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
46                         loop = loop - 1;
47                 }
48
49                 if (loop == 0) {
50                         lio_dev_err(lio_dev,
51                                     "clearing the reset reg failed or setting the quiet reg failed for qno: %lu\n",
52                                     (unsigned long)q_no);
53                         return -1;
54                 }
55
56                 reg_val = reg_val & ~CN23XX_PKT_INPUT_CTL_RST;
57                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(q_no),
58                                 reg_val);
59
60                 reg_val = lio_read_csr64(
61                     lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
62                 if (reg_val & CN23XX_PKT_INPUT_CTL_RST) {
63                         lio_dev_err(lio_dev,
64                                     "clearing the reset failed for qno: %lu\n",
65                                     (unsigned long)q_no);
66                         ret_val = -1;
67                 }
68         }
69
70         return ret_val;
71 }
72
73 static int
74 cn23xx_vf_setup_global_input_regs(struct lio_device *lio_dev)
75 {
76         uint64_t q_no;
77         uint64_t d64;
78
79         PMD_INIT_FUNC_TRACE();
80
81         if (cn23xx_vf_reset_io_queues(lio_dev,
82                                       lio_dev->sriov_info.rings_per_vf))
83                 return -1;
84
85         for (q_no = 0; q_no < (lio_dev->sriov_info.rings_per_vf); q_no++) {
86                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_DOORBELL(q_no),
87                                 0xFFFFFFFF);
88
89                 d64 = lio_read_csr64(lio_dev,
90                                      CN23XX_SLI_IQ_INSTR_COUNT64(q_no));
91
92                 d64 &= 0xEFFFFFFFFFFFFFFFL;
93
94                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_INSTR_COUNT64(q_no),
95                                 d64);
96
97                 /* Select ES, RO, NS, RDSIZE,DPTR Fomat#0 for
98                  * the Input Queues
99                  */
100                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(q_no),
101                                 CN23XX_PKT_INPUT_CTL_MASK);
102         }
103
104         return 0;
105 }
106
107 static void
108 cn23xx_vf_setup_global_output_regs(struct lio_device *lio_dev)
109 {
110         uint32_t reg_val;
111         uint32_t q_no;
112
113         PMD_INIT_FUNC_TRACE();
114
115         for (q_no = 0; q_no < lio_dev->sriov_info.rings_per_vf; q_no++) {
116                 lio_write_csr(lio_dev, CN23XX_SLI_OQ_PKTS_CREDIT(q_no),
117                               0xFFFFFFFF);
118
119                 reg_val =
120                     lio_read_csr(lio_dev, CN23XX_SLI_OQ_PKTS_SENT(q_no));
121
122                 reg_val &= 0xEFFFFFFFFFFFFFFFL;
123
124                 reg_val =
125                     lio_read_csr(lio_dev, CN23XX_SLI_OQ_PKT_CONTROL(q_no));
126
127                 /* set IPTR & DPTR */
128                 reg_val |=
129                     (CN23XX_PKT_OUTPUT_CTL_IPTR | CN23XX_PKT_OUTPUT_CTL_DPTR);
130
131                 /* reset BMODE */
132                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_BMODE);
133
134                 /* No Relaxed Ordering, No Snoop, 64-bit Byte swap
135                  * for Output Queue Scatter List
136                  * reset ROR_P, NSR_P
137                  */
138                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_ROR_P);
139                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_NSR_P);
140
141 #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
142                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_ES_P);
143 #elif RTE_BYTE_ORDER == RTE_BIG_ENDIAN
144                 reg_val |= (CN23XX_PKT_OUTPUT_CTL_ES_P);
145 #endif
146                 /* No Relaxed Ordering, No Snoop, 64-bit Byte swap
147                  * for Output Queue Data
148                  * reset ROR, NSR
149                  */
150                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_ROR);
151                 reg_val &= ~(CN23XX_PKT_OUTPUT_CTL_NSR);
152                 /* set the ES bit */
153                 reg_val |= (CN23XX_PKT_OUTPUT_CTL_ES);
154
155                 /* write all the selected settings */
156                 lio_write_csr(lio_dev, CN23XX_SLI_OQ_PKT_CONTROL(q_no),
157                               reg_val);
158         }
159 }
160
161 static int
162 cn23xx_vf_setup_device_regs(struct lio_device *lio_dev)
163 {
164         PMD_INIT_FUNC_TRACE();
165
166         if (cn23xx_vf_setup_global_input_regs(lio_dev))
167                 return -1;
168
169         cn23xx_vf_setup_global_output_regs(lio_dev);
170
171         return 0;
172 }
173
174 static void
175 cn23xx_vf_setup_iq_regs(struct lio_device *lio_dev, uint32_t iq_no)
176 {
177         struct lio_instr_queue *iq = lio_dev->instr_queue[iq_no];
178         uint64_t pkt_in_done = 0;
179
180         PMD_INIT_FUNC_TRACE();
181
182         /* Write the start of the input queue's ring and its size */
183         lio_write_csr64(lio_dev, CN23XX_SLI_IQ_BASE_ADDR64(iq_no),
184                         iq->base_addr_dma);
185         lio_write_csr(lio_dev, CN23XX_SLI_IQ_SIZE(iq_no), iq->max_count);
186
187         /* Remember the doorbell & instruction count register addr
188          * for this queue
189          */
190         iq->doorbell_reg = (uint8_t *)lio_dev->hw_addr +
191                                 CN23XX_SLI_IQ_DOORBELL(iq_no);
192         iq->inst_cnt_reg = (uint8_t *)lio_dev->hw_addr +
193                                 CN23XX_SLI_IQ_INSTR_COUNT64(iq_no);
194         lio_dev_dbg(lio_dev, "InstQ[%d]:dbell reg @ 0x%p instcnt_reg @ 0x%p\n",
195                     iq_no, iq->doorbell_reg, iq->inst_cnt_reg);
196
197         /* Store the current instruction counter (used in flush_iq
198          * calculation)
199          */
200         pkt_in_done = rte_read64(iq->inst_cnt_reg);
201
202         /* Clear the count by writing back what we read, but don't
203          * enable data traffic here
204          */
205         rte_write64(pkt_in_done, iq->inst_cnt_reg);
206 }
207
208 static void
209 cn23xx_vf_setup_oq_regs(struct lio_device *lio_dev, uint32_t oq_no)
210 {
211         struct lio_droq *droq = lio_dev->droq[oq_no];
212
213         PMD_INIT_FUNC_TRACE();
214
215         lio_write_csr64(lio_dev, CN23XX_SLI_OQ_BASE_ADDR64(oq_no),
216                         droq->desc_ring_dma);
217         lio_write_csr(lio_dev, CN23XX_SLI_OQ_SIZE(oq_no), droq->max_count);
218
219         lio_write_csr(lio_dev, CN23XX_SLI_OQ_BUFF_INFO_SIZE(oq_no),
220                       (droq->buffer_size | (OCTEON_RH_SIZE << 16)));
221
222         /* Get the mapped address of the pkt_sent and pkts_credit regs */
223         droq->pkts_sent_reg = (uint8_t *)lio_dev->hw_addr +
224                                         CN23XX_SLI_OQ_PKTS_SENT(oq_no);
225         droq->pkts_credit_reg = (uint8_t *)lio_dev->hw_addr +
226                                         CN23XX_SLI_OQ_PKTS_CREDIT(oq_no);
227 }
228
229 static void
230 cn23xx_vf_free_mbox(struct lio_device *lio_dev)
231 {
232         PMD_INIT_FUNC_TRACE();
233
234         rte_free(lio_dev->mbox[0]);
235         lio_dev->mbox[0] = NULL;
236
237         rte_free(lio_dev->mbox);
238         lio_dev->mbox = NULL;
239 }
240
241 static int
242 cn23xx_vf_setup_mbox(struct lio_device *lio_dev)
243 {
244         struct lio_mbox *mbox;
245
246         PMD_INIT_FUNC_TRACE();
247
248         if (lio_dev->mbox == NULL) {
249                 lio_dev->mbox = rte_zmalloc(NULL, sizeof(void *), 0);
250                 if (lio_dev->mbox == NULL)
251                         return -ENOMEM;
252         }
253
254         mbox = rte_zmalloc(NULL, sizeof(struct lio_mbox), 0);
255         if (mbox == NULL) {
256                 rte_free(lio_dev->mbox);
257                 lio_dev->mbox = NULL;
258                 return -ENOMEM;
259         }
260
261         rte_spinlock_init(&mbox->lock);
262
263         mbox->lio_dev = lio_dev;
264
265         mbox->q_no = 0;
266
267         mbox->state = LIO_MBOX_STATE_IDLE;
268
269         /* VF mbox interrupt reg */
270         mbox->mbox_int_reg = (uint8_t *)lio_dev->hw_addr +
271                                 CN23XX_VF_SLI_PKT_MBOX_INT(0);
272         /* VF reads from SIG0 reg */
273         mbox->mbox_read_reg = (uint8_t *)lio_dev->hw_addr +
274                                 CN23XX_SLI_PKT_PF_VF_MBOX_SIG(0, 0);
275         /* VF writes into SIG1 reg */
276         mbox->mbox_write_reg = (uint8_t *)lio_dev->hw_addr +
277                                 CN23XX_SLI_PKT_PF_VF_MBOX_SIG(0, 1);
278
279         lio_dev->mbox[0] = mbox;
280
281         rte_write64(LIO_PFVFSIG, mbox->mbox_read_reg);
282
283         return 0;
284 }
285
286 static int
287 cn23xx_vf_enable_io_queues(struct lio_device *lio_dev)
288 {
289         uint32_t q_no;
290
291         PMD_INIT_FUNC_TRACE();
292
293         for (q_no = 0; q_no < lio_dev->num_iqs; q_no++) {
294                 uint64_t reg_val;
295
296                 /* set the corresponding IQ IS_64B bit */
297                 if (lio_dev->io_qmask.iq64B & (1ULL << q_no)) {
298                         reg_val = lio_read_csr64(
299                                         lio_dev,
300                                         CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
301                         reg_val = reg_val | CN23XX_PKT_INPUT_CTL_IS_64B;
302                         lio_write_csr64(lio_dev,
303                                         CN23XX_SLI_IQ_PKT_CONTROL64(q_no),
304                                         reg_val);
305                 }
306
307                 /* set the corresponding IQ ENB bit */
308                 if (lio_dev->io_qmask.iq & (1ULL << q_no)) {
309                         reg_val = lio_read_csr64(
310                                         lio_dev,
311                                         CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
312                         reg_val = reg_val | CN23XX_PKT_INPUT_CTL_RING_ENB;
313                         lio_write_csr64(lio_dev,
314                                         CN23XX_SLI_IQ_PKT_CONTROL64(q_no),
315                                         reg_val);
316                 }
317         }
318         for (q_no = 0; q_no < lio_dev->num_oqs; q_no++) {
319                 uint32_t reg_val;
320
321                 /* set the corresponding OQ ENB bit */
322                 if (lio_dev->io_qmask.oq & (1ULL << q_no)) {
323                         reg_val = lio_read_csr(
324                                         lio_dev,
325                                         CN23XX_SLI_OQ_PKT_CONTROL(q_no));
326                         reg_val = reg_val | CN23XX_PKT_OUTPUT_CTL_RING_ENB;
327                         lio_write_csr(lio_dev,
328                                       CN23XX_SLI_OQ_PKT_CONTROL(q_no),
329                                       reg_val);
330                 }
331         }
332
333         return 0;
334 }
335
336 static void
337 cn23xx_vf_disable_io_queues(struct lio_device *lio_dev)
338 {
339         uint32_t num_queues;
340
341         PMD_INIT_FUNC_TRACE();
342
343         /* per HRM, rings can only be disabled via reset operation,
344          * NOT via SLI_PKT()_INPUT/OUTPUT_CONTROL[ENB]
345          */
346         num_queues = lio_dev->num_iqs;
347         if (num_queues < lio_dev->num_oqs)
348                 num_queues = lio_dev->num_oqs;
349
350         cn23xx_vf_reset_io_queues(lio_dev, num_queues);
351 }
352
353 void
354 cn23xx_vf_ask_pf_to_do_flr(struct lio_device *lio_dev)
355 {
356         struct lio_mbox_cmd mbox_cmd;
357
358         memset(&mbox_cmd, 0, sizeof(struct lio_mbox_cmd));
359         mbox_cmd.msg.s.type = LIO_MBOX_REQUEST;
360         mbox_cmd.msg.s.resp_needed = 0;
361         mbox_cmd.msg.s.cmd = LIO_VF_FLR_REQUEST;
362         mbox_cmd.msg.s.len = 1;
363         mbox_cmd.q_no = 0;
364         mbox_cmd.recv_len = 0;
365         mbox_cmd.recv_status = 0;
366         mbox_cmd.fn = NULL;
367         mbox_cmd.fn_arg = 0;
368
369         lio_mbox_write(lio_dev, &mbox_cmd);
370 }
371
372 static void
373 cn23xx_pfvf_hs_callback(struct lio_device *lio_dev,
374                         struct lio_mbox_cmd *cmd, void *arg)
375 {
376         uint32_t major = 0;
377
378         PMD_INIT_FUNC_TRACE();
379
380         rte_memcpy((uint8_t *)&lio_dev->pfvf_hsword, cmd->msg.s.params, 6);
381         if (cmd->recv_len > 1) {
382                 struct lio_version *lio_ver = (struct lio_version *)cmd->data;
383
384                 major = lio_ver->major;
385                 major = major << 16;
386         }
387
388         rte_atomic64_set((rte_atomic64_t *)arg, major | 1);
389 }
390
391 int
392 cn23xx_pfvf_handshake(struct lio_device *lio_dev)
393 {
394         struct lio_mbox_cmd mbox_cmd;
395         struct lio_version *lio_ver = (struct lio_version *)&mbox_cmd.data[0];
396         uint32_t q_no, count = 0;
397         rte_atomic64_t status;
398         uint32_t pfmajor;
399         uint32_t vfmajor;
400         uint32_t ret;
401
402         PMD_INIT_FUNC_TRACE();
403
404         /* Sending VF_ACTIVE indication to the PF driver */
405         lio_dev_dbg(lio_dev, "requesting info from PF\n");
406
407         mbox_cmd.msg.mbox_msg64 = 0;
408         mbox_cmd.msg.s.type = LIO_MBOX_REQUEST;
409         mbox_cmd.msg.s.resp_needed = 1;
410         mbox_cmd.msg.s.cmd = LIO_VF_ACTIVE;
411         mbox_cmd.msg.s.len = 2;
412         mbox_cmd.data[0] = 0;
413         lio_ver->major = LIO_BASE_MAJOR_VERSION;
414         lio_ver->minor = LIO_BASE_MINOR_VERSION;
415         lio_ver->micro = LIO_BASE_MICRO_VERSION;
416         mbox_cmd.q_no = 0;
417         mbox_cmd.recv_len = 0;
418         mbox_cmd.recv_status = 0;
419         mbox_cmd.fn = (lio_mbox_callback)cn23xx_pfvf_hs_callback;
420         mbox_cmd.fn_arg = (void *)&status;
421
422         if (lio_mbox_write(lio_dev, &mbox_cmd)) {
423                 lio_dev_err(lio_dev, "Write to mailbox failed\n");
424                 return -1;
425         }
426
427         rte_atomic64_set(&status, 0);
428
429         do {
430                 rte_delay_ms(1);
431         } while ((rte_atomic64_read(&status) == 0) && (count++ < 10000));
432
433         ret = rte_atomic64_read(&status);
434         if (ret == 0) {
435                 lio_dev_err(lio_dev, "cn23xx_pfvf_handshake timeout\n");
436                 return -1;
437         }
438
439         for (q_no = 0; q_no < lio_dev->num_iqs; q_no++)
440                 lio_dev->instr_queue[q_no]->txpciq.s.pkind =
441                                                 lio_dev->pfvf_hsword.pkind;
442
443         vfmajor = LIO_BASE_MAJOR_VERSION;
444         pfmajor = ret >> 16;
445         if (pfmajor != vfmajor) {
446                 lio_dev_err(lio_dev,
447                             "VF LiquidIO driver (major version %d) is not compatible with LiquidIO PF driver (major version %d)\n",
448                             vfmajor, pfmajor);
449                 ret = -EPERM;
450         } else {
451                 lio_dev_dbg(lio_dev,
452                             "VF LiquidIO driver (major version %d), LiquidIO PF driver (major version %d)\n",
453                             vfmajor, pfmajor);
454                 ret = 0;
455         }
456
457         lio_dev_dbg(lio_dev, "got data from PF pkind is %d\n",
458                     lio_dev->pfvf_hsword.pkind);
459
460         return ret;
461 }
462
463 void
464 cn23xx_vf_handle_mbox(struct lio_device *lio_dev)
465 {
466         uint64_t mbox_int_val;
467
468         /* read and clear by writing 1 */
469         mbox_int_val = rte_read64(lio_dev->mbox[0]->mbox_int_reg);
470         rte_write64(mbox_int_val, lio_dev->mbox[0]->mbox_int_reg);
471         if (lio_mbox_read(lio_dev->mbox[0]))
472                 lio_mbox_process_message(lio_dev->mbox[0]);
473 }
474
475 int
476 cn23xx_vf_setup_device(struct lio_device *lio_dev)
477 {
478         uint64_t reg_val;
479
480         PMD_INIT_FUNC_TRACE();
481
482         /* INPUT_CONTROL[RPVF] gives the VF IOq count */
483         reg_val = lio_read_csr64(lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(0));
484
485         lio_dev->pf_num = (reg_val >> CN23XX_PKT_INPUT_CTL_PF_NUM_POS) &
486                                 CN23XX_PKT_INPUT_CTL_PF_NUM_MASK;
487         lio_dev->vf_num = (reg_val >> CN23XX_PKT_INPUT_CTL_VF_NUM_POS) &
488                                 CN23XX_PKT_INPUT_CTL_VF_NUM_MASK;
489
490         reg_val = reg_val >> CN23XX_PKT_INPUT_CTL_RPVF_POS;
491
492         lio_dev->sriov_info.rings_per_vf =
493                                 reg_val & CN23XX_PKT_INPUT_CTL_RPVF_MASK;
494
495         lio_dev->default_config = lio_get_conf(lio_dev);
496         if (lio_dev->default_config == NULL)
497                 return -1;
498
499         lio_dev->fn_list.setup_iq_regs          = cn23xx_vf_setup_iq_regs;
500         lio_dev->fn_list.setup_oq_regs          = cn23xx_vf_setup_oq_regs;
501         lio_dev->fn_list.setup_mbox             = cn23xx_vf_setup_mbox;
502         lio_dev->fn_list.free_mbox              = cn23xx_vf_free_mbox;
503
504         lio_dev->fn_list.setup_device_regs      = cn23xx_vf_setup_device_regs;
505
506         lio_dev->fn_list.enable_io_queues       = cn23xx_vf_enable_io_queues;
507         lio_dev->fn_list.disable_io_queues      = cn23xx_vf_disable_io_queues;
508
509         return 0;
510 }
511
512 int
513 cn23xx_vf_set_io_queues_off(struct lio_device *lio_dev)
514 {
515         uint32_t loop = CN23XX_VF_BUSY_READING_REG_LOOP_COUNT;
516         uint64_t q_no;
517
518         /* Disable the i/p and o/p queues for this Octeon.
519          * IOQs will already be in reset.
520          * If RST bit is set, wait for Quiet bit to be set
521          * Once Quiet bit is set, clear the RST bit
522          */
523         PMD_INIT_FUNC_TRACE();
524
525         for (q_no = 0; q_no < lio_dev->sriov_info.rings_per_vf; q_no++) {
526                 volatile uint64_t reg_val;
527
528                 reg_val = lio_read_csr64(lio_dev,
529                                          CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
530                 while ((reg_val & CN23XX_PKT_INPUT_CTL_RST) && !(reg_val &
531                                          CN23XX_PKT_INPUT_CTL_QUIET) && loop) {
532                         reg_val = lio_read_csr64(
533                                         lio_dev,
534                                         CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
535                         loop = loop - 1;
536                 }
537
538                 if (loop == 0) {
539                         lio_dev_err(lio_dev,
540                                     "clearing the reset reg failed or setting the quiet reg failed for qno %lu\n",
541                                     (unsigned long)q_no);
542                         return -1;
543                 }
544
545                 reg_val = reg_val & ~CN23XX_PKT_INPUT_CTL_RST;
546                 lio_write_csr64(lio_dev, CN23XX_SLI_IQ_PKT_CONTROL64(q_no),
547                                 reg_val);
548
549                 reg_val = lio_read_csr64(lio_dev,
550                                          CN23XX_SLI_IQ_PKT_CONTROL64(q_no));
551                 if (reg_val & CN23XX_PKT_INPUT_CTL_RST) {
552                         lio_dev_err(lio_dev, "unable to reset qno %lu\n",
553                                     (unsigned long)q_no);
554                         return -1;
555                 }
556         }
557
558         return 0;
559 }