Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * SolidRun DPU driver for control plane
4 *
5 * Copyright (C) 2022-2023 SolidRun
6 *
7 * Author: Alvaro Karsz <alvaro.karsz@solid-run.com>
8 *
9 */
10#include <linux/iopoll.h>
11
12#include "snet_vdpa.h"
13
14/* SNET DPU device ID */
15#define SNET_DEVICE_ID 0x1000
16/* SNET signature */
17#define SNET_SIGNATURE 0xD0D06363
18/* Max. config version that we can work with */
19#define SNET_CFG_VERSION 0x2
20/* Queue align */
21#define SNET_QUEUE_ALIGNMENT PAGE_SIZE
22/* Kick value to notify that new data is available */
23#define SNET_KICK_VAL 0x1
24#define SNET_CONFIG_OFF 0x0
25/* How long we are willing to wait for a SNET device */
26#define SNET_DETECT_TIMEOUT 5000000
27/* How long should we wait for the DPU to read our config */
28#define SNET_READ_CFG_TIMEOUT 3000000
29/* Size of configs written to the DPU */
30#define SNET_GENERAL_CFG_LEN 36
31#define SNET_GENERAL_CFG_VQ_LEN 40
32
33static struct snet *vdpa_to_snet(struct vdpa_device *vdpa)
34{
35 return container_of(vdpa, struct snet, vdpa);
36}
37
38static irqreturn_t snet_cfg_irq_hndlr(int irq, void *data)
39{
40 struct snet *snet = data;
41 /* Call callback if any */
42 if (likely(snet->cb.callback))
43 return snet->cb.callback(snet->cb.private);
44
45 return IRQ_HANDLED;
46}
47
48static irqreturn_t snet_vq_irq_hndlr(int irq, void *data)
49{
50 struct snet_vq *vq = data;
51 /* Call callback if any */
52 if (likely(vq->cb.callback))
53 return vq->cb.callback(vq->cb.private);
54
55 return IRQ_HANDLED;
56}
57
58static void snet_free_irqs(struct snet *snet)
59{
60 struct psnet *psnet = snet->psnet;
61 struct pci_dev *pdev;
62 u32 i;
63
64 /* Which Device allcoated the IRQs? */
65 if (PSNET_FLAG_ON(psnet, SNET_CFG_FLAG_IRQ_PF))
66 pdev = snet->pdev->physfn;
67 else
68 pdev = snet->pdev;
69
70 /* Free config's IRQ */
71 if (snet->cfg_irq != -1) {
72 devm_free_irq(&pdev->dev, snet->cfg_irq, snet);
73 snet->cfg_irq = -1;
74 }
75 /* Free VQ IRQs */
76 for (i = 0; i < snet->cfg->vq_num; i++) {
77 if (snet->vqs[i] && snet->vqs[i]->irq != -1) {
78 devm_free_irq(&pdev->dev, snet->vqs[i]->irq, snet->vqs[i]);
79 snet->vqs[i]->irq = -1;
80 }
81 }
82
83 /* IRQ vectors are freed when the pci remove callback is called */
84}
85
86static int snet_set_vq_address(struct vdpa_device *vdev, u16 idx, u64 desc_area,
87 u64 driver_area, u64 device_area)
88{
89 struct snet *snet = vdpa_to_snet(vdev);
90 /* save received parameters in vqueue sturct */
91 snet->vqs[idx]->desc_area = desc_area;
92 snet->vqs[idx]->driver_area = driver_area;
93 snet->vqs[idx]->device_area = device_area;
94
95 return 0;
96}
97
98static void snet_set_vq_num(struct vdpa_device *vdev, u16 idx, u32 num)
99{
100 struct snet *snet = vdpa_to_snet(vdev);
101 /* save num in vqueue */
102 snet->vqs[idx]->num = num;
103}
104
105static void snet_kick_vq(struct vdpa_device *vdev, u16 idx)
106{
107 struct snet *snet = vdpa_to_snet(vdev);
108 /* not ready - ignore */
109 if (unlikely(!snet->vqs[idx]->ready))
110 return;
111
112 iowrite32(SNET_KICK_VAL, snet->vqs[idx]->kick_ptr);
113}
114
115static void snet_kick_vq_with_data(struct vdpa_device *vdev, u32 data)
116{
117 struct snet *snet = vdpa_to_snet(vdev);
118 u16 idx = data & 0xFFFF;
119
120 /* not ready - ignore */
121 if (unlikely(!snet->vqs[idx]->ready))
122 return;
123
124 iowrite32((data & 0xFFFF0000) | SNET_KICK_VAL, snet->vqs[idx]->kick_ptr);
125}
126
127static void snet_set_vq_cb(struct vdpa_device *vdev, u16 idx, struct vdpa_callback *cb)
128{
129 struct snet *snet = vdpa_to_snet(vdev);
130
131 snet->vqs[idx]->cb.callback = cb->callback;
132 snet->vqs[idx]->cb.private = cb->private;
133}
134
135static void snet_set_vq_ready(struct vdpa_device *vdev, u16 idx, bool ready)
136{
137 struct snet *snet = vdpa_to_snet(vdev);
138
139 snet->vqs[idx]->ready = ready;
140}
141
142static bool snet_get_vq_ready(struct vdpa_device *vdev, u16 idx)
143{
144 struct snet *snet = vdpa_to_snet(vdev);
145
146 return snet->vqs[idx]->ready;
147}
148
149static bool snet_vq_state_is_initial(struct snet *snet, const struct vdpa_vq_state *state)
150{
151 if (SNET_HAS_FEATURE(snet, VIRTIO_F_RING_PACKED)) {
152 const struct vdpa_vq_state_packed *p = &state->packed;
153
154 if (p->last_avail_counter == 1 && p->last_used_counter == 1 &&
155 p->last_avail_idx == 0 && p->last_used_idx == 0)
156 return true;
157 } else {
158 const struct vdpa_vq_state_split *s = &state->split;
159
160 if (s->avail_index == 0)
161 return true;
162 }
163
164 return false;
165}
166
167static int snet_set_vq_state(struct vdpa_device *vdev, u16 idx, const struct vdpa_vq_state *state)
168{
169 struct snet *snet = vdpa_to_snet(vdev);
170
171 /* We can set any state for config version 2+ */
172 if (SNET_CFG_VER(snet, 2)) {
173 memcpy(&snet->vqs[idx]->vq_state, state, sizeof(*state));
174 return 0;
175 }
176
177 /* Older config - we can't set the VQ state.
178 * Return 0 only if this is the initial state we use in the DPU.
179 */
180 if (snet_vq_state_is_initial(snet, state))
181 return 0;
182
183 return -EOPNOTSUPP;
184}
185
186static int snet_get_vq_state(struct vdpa_device *vdev, u16 idx, struct vdpa_vq_state *state)
187{
188 struct snet *snet = vdpa_to_snet(vdev);
189
190 return snet_read_vq_state(snet, idx, state);
191}
192
193static int snet_get_vq_irq(struct vdpa_device *vdev, u16 idx)
194{
195 struct snet *snet = vdpa_to_snet(vdev);
196
197 return snet->vqs[idx]->irq;
198}
199
200static u32 snet_get_vq_align(struct vdpa_device *vdev)
201{
202 return (u32)SNET_QUEUE_ALIGNMENT;
203}
204
205static int snet_reset_dev(struct snet *snet)
206{
207 struct pci_dev *pdev = snet->pdev;
208 int ret = 0;
209 u32 i;
210
211 /* If status is 0, nothing to do */
212 if (!snet->status)
213 return 0;
214
215 /* If DPU started, destroy it */
216 if (snet->status & VIRTIO_CONFIG_S_DRIVER_OK)
217 ret = snet_destroy_dev(snet);
218
219 /* Clear VQs */
220 for (i = 0; i < snet->cfg->vq_num; i++) {
221 if (!snet->vqs[i])
222 continue;
223 snet->vqs[i]->cb.callback = NULL;
224 snet->vqs[i]->cb.private = NULL;
225 snet->vqs[i]->desc_area = 0;
226 snet->vqs[i]->device_area = 0;
227 snet->vqs[i]->driver_area = 0;
228 snet->vqs[i]->ready = false;
229 }
230
231 /* Clear config callback */
232 snet->cb.callback = NULL;
233 snet->cb.private = NULL;
234 /* Free IRQs */
235 snet_free_irqs(snet);
236 /* Reset status */
237 snet->status = 0;
238 snet->dpu_ready = false;
239
240 if (ret)
241 SNET_WARN(pdev, "Incomplete reset to SNET[%u] device, err: %d\n", snet->sid, ret);
242 else
243 SNET_DBG(pdev, "Reset SNET[%u] device\n", snet->sid);
244
245 return 0;
246}
247
248static int snet_reset(struct vdpa_device *vdev)
249{
250 struct snet *snet = vdpa_to_snet(vdev);
251
252 return snet_reset_dev(snet);
253}
254
255static size_t snet_get_config_size(struct vdpa_device *vdev)
256{
257 struct snet *snet = vdpa_to_snet(vdev);
258
259 return (size_t)snet->cfg->cfg_size;
260}
261
262static u64 snet_get_features(struct vdpa_device *vdev)
263{
264 struct snet *snet = vdpa_to_snet(vdev);
265
266 return snet->cfg->features;
267}
268
269static int snet_set_drv_features(struct vdpa_device *vdev, u64 features)
270{
271 struct snet *snet = vdpa_to_snet(vdev);
272
273 snet->negotiated_features = snet->cfg->features & features;
274 return 0;
275}
276
277static u64 snet_get_drv_features(struct vdpa_device *vdev)
278{
279 struct snet *snet = vdpa_to_snet(vdev);
280
281 return snet->negotiated_features;
282}
283
284static u16 snet_get_vq_num_max(struct vdpa_device *vdev)
285{
286 struct snet *snet = vdpa_to_snet(vdev);
287
288 return (u16)snet->cfg->vq_size;
289}
290
291static void snet_set_config_cb(struct vdpa_device *vdev, struct vdpa_callback *cb)
292{
293 struct snet *snet = vdpa_to_snet(vdev);
294
295 snet->cb.callback = cb->callback;
296 snet->cb.private = cb->private;
297}
298
299static u32 snet_get_device_id(struct vdpa_device *vdev)
300{
301 struct snet *snet = vdpa_to_snet(vdev);
302
303 return snet->cfg->virtio_id;
304}
305
306static u32 snet_get_vendor_id(struct vdpa_device *vdev)
307{
308 return (u32)PCI_VENDOR_ID_SOLIDRUN;
309}
310
311static u8 snet_get_status(struct vdpa_device *vdev)
312{
313 struct snet *snet = vdpa_to_snet(vdev);
314
315 return snet->status;
316}
317
318static int snet_write_conf(struct snet *snet)
319{
320 u32 off, i, tmp;
321 int ret;
322
323 /* No need to write the config twice */
324 if (snet->dpu_ready)
325 return true;
326
327 /* Snet data :
328 *
329 * General data: SNET_GENERAL_CFG_LEN bytes long
330 * 0 0x4 0x8 0xC 0x10 0x14 0x1C 0x24
331 * | MAGIC NUMBER | CFG VER | SNET SID | NUMBER OF QUEUES | IRQ IDX | FEATURES | RSVD |
332 *
333 * For every VQ: SNET_GENERAL_CFG_VQ_LEN bytes long
334 * 0 0x4 0x8
335 * | VQ SID AND QUEUE SIZE | IRQ Index |
336 * | DESC AREA |
337 * | DEVICE AREA |
338 * | DRIVER AREA |
339 * | VQ STATE (CFG 2+) | RSVD |
340 *
341 * Magic number should be written last, this is the DPU indication that the data is ready
342 */
343
344 /* Init offset */
345 off = snet->psnet->cfg.host_cfg_off;
346
347 /* Ignore magic number for now */
348 off += 4;
349 snet_write32(snet, off, snet->psnet->negotiated_cfg_ver);
350 off += 4;
351 snet_write32(snet, off, snet->sid);
352 off += 4;
353 snet_write32(snet, off, snet->cfg->vq_num);
354 off += 4;
355 snet_write32(snet, off, snet->cfg_irq_idx);
356 off += 4;
357 snet_write64(snet, off, snet->negotiated_features);
358 off += 8;
359 /* Ignore reserved */
360 off += 8;
361 /* Write VQs */
362 for (i = 0 ; i < snet->cfg->vq_num ; i++) {
363 tmp = (i << 16) | (snet->vqs[i]->num & 0xFFFF);
364 snet_write32(snet, off, tmp);
365 off += 4;
366 snet_write32(snet, off, snet->vqs[i]->irq_idx);
367 off += 4;
368 snet_write64(snet, off, snet->vqs[i]->desc_area);
369 off += 8;
370 snet_write64(snet, off, snet->vqs[i]->device_area);
371 off += 8;
372 snet_write64(snet, off, snet->vqs[i]->driver_area);
373 off += 8;
374 /* Write VQ state if config version is 2+ */
375 if (SNET_CFG_VER(snet, 2))
376 snet_write32(snet, off, *(u32 *)&snet->vqs[i]->vq_state);
377 off += 4;
378
379 /* Ignore reserved */
380 off += 4;
381 }
382
383 /* Write magic number - data is ready */
384 snet_write32(snet, snet->psnet->cfg.host_cfg_off, SNET_SIGNATURE);
385
386 /* The DPU will ACK the config by clearing the signature */
387 ret = readx_poll_timeout(ioread32, snet->bar + snet->psnet->cfg.host_cfg_off,
388 tmp, !tmp, 10, SNET_READ_CFG_TIMEOUT);
389 if (ret) {
390 SNET_ERR(snet->pdev, "Timeout waiting for the DPU to read the config\n");
391 return false;
392 }
393
394 /* set DPU flag */
395 snet->dpu_ready = true;
396
397 return true;
398}
399
400static int snet_request_irqs(struct pci_dev *pdev, struct snet *snet)
401{
402 int ret, i, irq;
403
404 /* Request config IRQ */
405 irq = pci_irq_vector(pdev, snet->cfg_irq_idx);
406 ret = devm_request_irq(&pdev->dev, irq, snet_cfg_irq_hndlr, 0,
407 snet->cfg_irq_name, snet);
408 if (ret) {
409 SNET_ERR(pdev, "Failed to request IRQ\n");
410 return ret;
411 }
412 snet->cfg_irq = irq;
413
414 /* Request IRQ for every VQ */
415 for (i = 0; i < snet->cfg->vq_num; i++) {
416 irq = pci_irq_vector(pdev, snet->vqs[i]->irq_idx);
417 ret = devm_request_irq(&pdev->dev, irq, snet_vq_irq_hndlr, 0,
418 snet->vqs[i]->irq_name, snet->vqs[i]);
419 if (ret) {
420 SNET_ERR(pdev, "Failed to request IRQ\n");
421 return ret;
422 }
423 snet->vqs[i]->irq = irq;
424 }
425 return 0;
426}
427
428static void snet_set_status(struct vdpa_device *vdev, u8 status)
429{
430 struct snet *snet = vdpa_to_snet(vdev);
431 struct psnet *psnet = snet->psnet;
432 struct pci_dev *pdev = snet->pdev;
433 int ret;
434 bool pf_irqs;
435
436 if (status == snet->status)
437 return;
438
439 if ((status & VIRTIO_CONFIG_S_DRIVER_OK) &&
440 !(snet->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
441 /* Request IRQs */
442 pf_irqs = PSNET_FLAG_ON(psnet, SNET_CFG_FLAG_IRQ_PF);
443 ret = snet_request_irqs(pf_irqs ? pdev->physfn : pdev, snet);
444 if (ret)
445 goto set_err;
446
447 /* Write config to the DPU */
448 if (snet_write_conf(snet)) {
449 SNET_INFO(pdev, "Create SNET[%u] device\n", snet->sid);
450 } else {
451 snet_free_irqs(snet);
452 goto set_err;
453 }
454 }
455
456 /* Save the new status */
457 snet->status = status;
458 return;
459
460set_err:
461 snet->status |= VIRTIO_CONFIG_S_FAILED;
462}
463
464static void snet_get_config(struct vdpa_device *vdev, unsigned int offset,
465 void *buf, unsigned int len)
466{
467 struct snet *snet = vdpa_to_snet(vdev);
468 void __iomem *cfg_ptr = snet->cfg->virtio_cfg + offset;
469 u8 *buf_ptr = buf;
470 u32 i;
471
472 /* check for offset error */
473 if (offset + len > snet->cfg->cfg_size)
474 return;
475
476 /* Write into buffer */
477 for (i = 0; i < len; i++)
478 *buf_ptr++ = ioread8(cfg_ptr + i);
479}
480
481static void snet_set_config(struct vdpa_device *vdev, unsigned int offset,
482 const void *buf, unsigned int len)
483{
484 struct snet *snet = vdpa_to_snet(vdev);
485 void __iomem *cfg_ptr = snet->cfg->virtio_cfg + offset;
486 const u8 *buf_ptr = buf;
487 u32 i;
488
489 /* check for offset error */
490 if (offset + len > snet->cfg->cfg_size)
491 return;
492
493 /* Write into PCI BAR */
494 for (i = 0; i < len; i++)
495 iowrite8(*buf_ptr++, cfg_ptr + i);
496}
497
498static int snet_suspend(struct vdpa_device *vdev)
499{
500 struct snet *snet = vdpa_to_snet(vdev);
501 int ret;
502
503 ret = snet_suspend_dev(snet);
504 if (ret)
505 SNET_ERR(snet->pdev, "SNET[%u] suspend failed, err: %d\n", snet->sid, ret);
506 else
507 SNET_DBG(snet->pdev, "Suspend SNET[%u] device\n", snet->sid);
508
509 return ret;
510}
511
512static int snet_resume(struct vdpa_device *vdev)
513{
514 struct snet *snet = vdpa_to_snet(vdev);
515 int ret;
516
517 ret = snet_resume_dev(snet);
518 if (ret)
519 SNET_ERR(snet->pdev, "SNET[%u] resume failed, err: %d\n", snet->sid, ret);
520 else
521 SNET_DBG(snet->pdev, "Resume SNET[%u] device\n", snet->sid);
522
523 return ret;
524}
525
526static const struct vdpa_config_ops snet_config_ops = {
527 .set_vq_address = snet_set_vq_address,
528 .set_vq_num = snet_set_vq_num,
529 .kick_vq = snet_kick_vq,
530 .kick_vq_with_data = snet_kick_vq_with_data,
531 .set_vq_cb = snet_set_vq_cb,
532 .set_vq_ready = snet_set_vq_ready,
533 .get_vq_ready = snet_get_vq_ready,
534 .set_vq_state = snet_set_vq_state,
535 .get_vq_state = snet_get_vq_state,
536 .get_vq_irq = snet_get_vq_irq,
537 .get_vq_align = snet_get_vq_align,
538 .reset = snet_reset,
539 .get_config_size = snet_get_config_size,
540 .get_device_features = snet_get_features,
541 .set_driver_features = snet_set_drv_features,
542 .get_driver_features = snet_get_drv_features,
543 .get_vq_num_min = snet_get_vq_num_max,
544 .get_vq_num_max = snet_get_vq_num_max,
545 .set_config_cb = snet_set_config_cb,
546 .get_device_id = snet_get_device_id,
547 .get_vendor_id = snet_get_vendor_id,
548 .get_status = snet_get_status,
549 .set_status = snet_set_status,
550 .get_config = snet_get_config,
551 .set_config = snet_set_config,
552 .suspend = snet_suspend,
553 .resume = snet_resume,
554};
555
556static int psnet_open_pf_bar(struct pci_dev *pdev, struct psnet *psnet)
557{
558 char name[50];
559 int ret, i, mask = 0;
560 /* We don't know which BAR will be used to communicate..
561 * We will map every bar with len > 0.
562 *
563 * Later, we will discover the BAR and unmap all other BARs.
564 */
565 for (i = 0; i < PCI_STD_NUM_BARS; i++) {
566 if (pci_resource_len(pdev, i))
567 mask |= (1 << i);
568 }
569
570 /* No BAR can be used.. */
571 if (!mask) {
572 SNET_ERR(pdev, "Failed to find a PCI BAR\n");
573 return -ENODEV;
574 }
575
576 snprintf(name, sizeof(name), "psnet[%s]-bars", pci_name(pdev));
577 ret = pcim_iomap_regions(pdev, mask, name);
578 if (ret) {
579 SNET_ERR(pdev, "Failed to request and map PCI BARs\n");
580 return ret;
581 }
582
583 for (i = 0; i < PCI_STD_NUM_BARS; i++) {
584 if (mask & (1 << i))
585 psnet->bars[i] = pcim_iomap_table(pdev)[i];
586 }
587
588 return 0;
589}
590
591static int snet_open_vf_bar(struct pci_dev *pdev, struct snet *snet)
592{
593 char name[50];
594 int ret;
595
596 snprintf(name, sizeof(name), "snet[%s]-bar", pci_name(pdev));
597 /* Request and map BAR */
598 ret = pcim_iomap_regions(pdev, BIT(snet->psnet->cfg.vf_bar), name);
599 if (ret) {
600 SNET_ERR(pdev, "Failed to request and map PCI BAR for a VF\n");
601 return ret;
602 }
603
604 snet->bar = pcim_iomap_table(pdev)[snet->psnet->cfg.vf_bar];
605
606 return 0;
607}
608
609static void snet_free_cfg(struct snet_cfg *cfg)
610{
611 u32 i;
612
613 if (!cfg->devs)
614 return;
615
616 /* Free devices */
617 for (i = 0; i < cfg->devices_num; i++) {
618 if (!cfg->devs[i])
619 break;
620
621 kfree(cfg->devs[i]);
622 }
623 /* Free pointers to devices */
624 kfree(cfg->devs);
625}
626
627/* Detect which BAR is used for communication with the device. */
628static int psnet_detect_bar(struct psnet *psnet, u32 off)
629{
630 unsigned long exit_time;
631 int i;
632
633 exit_time = jiffies + usecs_to_jiffies(SNET_DETECT_TIMEOUT);
634
635 /* SNET DPU will write SNET's signature when the config is ready. */
636 while (time_before(jiffies, exit_time)) {
637 for (i = 0; i < PCI_STD_NUM_BARS; i++) {
638 /* Is this BAR mapped? */
639 if (!psnet->bars[i])
640 continue;
641
642 if (ioread32(psnet->bars[i] + off) == SNET_SIGNATURE)
643 return i;
644 }
645 usleep_range(1000, 10000);
646 }
647
648 return -ENODEV;
649}
650
651static void psnet_unmap_unused_bars(struct pci_dev *pdev, struct psnet *psnet)
652{
653 int i, mask = 0;
654
655 for (i = 0; i < PCI_STD_NUM_BARS; i++) {
656 if (psnet->bars[i] && i != psnet->barno)
657 mask |= (1 << i);
658 }
659
660 if (mask)
661 pcim_iounmap_regions(pdev, mask);
662}
663
664/* Read SNET config from PCI BAR */
665static int psnet_read_cfg(struct pci_dev *pdev, struct psnet *psnet)
666{
667 struct snet_cfg *cfg = &psnet->cfg;
668 u32 i, off;
669 int barno;
670
671 /* Move to where the config starts */
672 off = SNET_CONFIG_OFF;
673
674 /* Find BAR used for communication */
675 barno = psnet_detect_bar(psnet, off);
676 if (barno < 0) {
677 SNET_ERR(pdev, "SNET config is not ready.\n");
678 return barno;
679 }
680
681 /* Save used BAR number and unmap all other BARs */
682 psnet->barno = barno;
683 SNET_DBG(pdev, "Using BAR number %d\n", barno);
684
685 psnet_unmap_unused_bars(pdev, psnet);
686
687 /* load config from BAR */
688 cfg->key = psnet_read32(psnet, off);
689 off += 4;
690 cfg->cfg_size = psnet_read32(psnet, off);
691 off += 4;
692 cfg->cfg_ver = psnet_read32(psnet, off);
693 off += 4;
694 /* The negotiated config version is the lower one between this driver's config
695 * and the DPU's.
696 */
697 psnet->negotiated_cfg_ver = min_t(u32, cfg->cfg_ver, SNET_CFG_VERSION);
698 SNET_DBG(pdev, "SNET config version %u\n", psnet->negotiated_cfg_ver);
699
700 cfg->vf_num = psnet_read32(psnet, off);
701 off += 4;
702 cfg->vf_bar = psnet_read32(psnet, off);
703 off += 4;
704 cfg->host_cfg_off = psnet_read32(psnet, off);
705 off += 4;
706 cfg->max_size_host_cfg = psnet_read32(psnet, off);
707 off += 4;
708 cfg->virtio_cfg_off = psnet_read32(psnet, off);
709 off += 4;
710 cfg->kick_off = psnet_read32(psnet, off);
711 off += 4;
712 cfg->hwmon_off = psnet_read32(psnet, off);
713 off += 4;
714 cfg->ctrl_off = psnet_read32(psnet, off);
715 off += 4;
716 cfg->flags = psnet_read32(psnet, off);
717 off += 4;
718 /* Ignore Reserved */
719 off += sizeof(cfg->rsvd);
720
721 cfg->devices_num = psnet_read32(psnet, off);
722 off += 4;
723 /* Allocate memory to hold pointer to the devices */
724 cfg->devs = kcalloc(cfg->devices_num, sizeof(void *), GFP_KERNEL);
725 if (!cfg->devs)
726 return -ENOMEM;
727
728 /* Load device configuration from BAR */
729 for (i = 0; i < cfg->devices_num; i++) {
730 cfg->devs[i] = kzalloc(sizeof(*cfg->devs[i]), GFP_KERNEL);
731 if (!cfg->devs[i]) {
732 snet_free_cfg(cfg);
733 return -ENOMEM;
734 }
735 /* Read device config */
736 cfg->devs[i]->virtio_id = psnet_read32(psnet, off);
737 off += 4;
738 cfg->devs[i]->vq_num = psnet_read32(psnet, off);
739 off += 4;
740 cfg->devs[i]->vq_size = psnet_read32(psnet, off);
741 off += 4;
742 cfg->devs[i]->vfid = psnet_read32(psnet, off);
743 off += 4;
744 cfg->devs[i]->features = psnet_read64(psnet, off);
745 off += 8;
746 /* Ignore Reserved */
747 off += sizeof(cfg->devs[i]->rsvd);
748
749 cfg->devs[i]->cfg_size = psnet_read32(psnet, off);
750 off += 4;
751
752 /* Is the config witten to the DPU going to be too big? */
753 if (SNET_GENERAL_CFG_LEN + SNET_GENERAL_CFG_VQ_LEN * cfg->devs[i]->vq_num >
754 cfg->max_size_host_cfg) {
755 SNET_ERR(pdev, "Failed to read SNET config, the config is too big..\n");
756 snet_free_cfg(cfg);
757 return -EINVAL;
758 }
759 }
760 return 0;
761}
762
763static int psnet_alloc_irq_vector(struct pci_dev *pdev, struct psnet *psnet)
764{
765 int ret = 0;
766 u32 i, irq_num = 0;
767
768 /* Let's count how many IRQs we need, 1 for every VQ + 1 for config change */
769 for (i = 0; i < psnet->cfg.devices_num; i++)
770 irq_num += psnet->cfg.devs[i]->vq_num + 1;
771
772 ret = pci_alloc_irq_vectors(pdev, irq_num, irq_num, PCI_IRQ_MSIX);
773 if (ret != irq_num) {
774 SNET_ERR(pdev, "Failed to allocate IRQ vectors\n");
775 return ret;
776 }
777 SNET_DBG(pdev, "Allocated %u IRQ vectors from physical function\n", irq_num);
778
779 return 0;
780}
781
782static int snet_alloc_irq_vector(struct pci_dev *pdev, struct snet_dev_cfg *snet_cfg)
783{
784 int ret = 0;
785 u32 irq_num;
786
787 /* We want 1 IRQ for every VQ + 1 for config change events */
788 irq_num = snet_cfg->vq_num + 1;
789
790 ret = pci_alloc_irq_vectors(pdev, irq_num, irq_num, PCI_IRQ_MSIX);
791 if (ret <= 0) {
792 SNET_ERR(pdev, "Failed to allocate IRQ vectors\n");
793 return ret;
794 }
795
796 return 0;
797}
798
799static void snet_free_vqs(struct snet *snet)
800{
801 u32 i;
802
803 if (!snet->vqs)
804 return;
805
806 for (i = 0 ; i < snet->cfg->vq_num ; i++) {
807 if (!snet->vqs[i])
808 break;
809
810 kfree(snet->vqs[i]);
811 }
812 kfree(snet->vqs);
813}
814
815static int snet_build_vqs(struct snet *snet)
816{
817 u32 i;
818 /* Allocate the VQ pointers array */
819 snet->vqs = kcalloc(snet->cfg->vq_num, sizeof(void *), GFP_KERNEL);
820 if (!snet->vqs)
821 return -ENOMEM;
822
823 /* Allocate the VQs */
824 for (i = 0; i < snet->cfg->vq_num; i++) {
825 snet->vqs[i] = kzalloc(sizeof(*snet->vqs[i]), GFP_KERNEL);
826 if (!snet->vqs[i]) {
827 snet_free_vqs(snet);
828 return -ENOMEM;
829 }
830 /* Reset IRQ num */
831 snet->vqs[i]->irq = -1;
832 /* VQ serial ID */
833 snet->vqs[i]->sid = i;
834 /* Kick address - every VQ gets 4B */
835 snet->vqs[i]->kick_ptr = snet->bar + snet->psnet->cfg.kick_off +
836 snet->vqs[i]->sid * 4;
837 /* Clear kick address for this VQ */
838 iowrite32(0, snet->vqs[i]->kick_ptr);
839 }
840 return 0;
841}
842
843static int psnet_get_next_irq_num(struct psnet *psnet)
844{
845 int irq;
846
847 spin_lock(&psnet->lock);
848 irq = psnet->next_irq++;
849 spin_unlock(&psnet->lock);
850
851 return irq;
852}
853
854static void snet_reserve_irq_idx(struct pci_dev *pdev, struct snet *snet)
855{
856 struct psnet *psnet = snet->psnet;
857 int i;
858
859 /* one IRQ for every VQ, and one for config changes */
860 snet->cfg_irq_idx = psnet_get_next_irq_num(psnet);
861 snprintf(snet->cfg_irq_name, SNET_NAME_SIZE, "snet[%s]-cfg[%d]",
862 pci_name(pdev), snet->cfg_irq_idx);
863
864 for (i = 0; i < snet->cfg->vq_num; i++) {
865 /* Get next free IRQ ID */
866 snet->vqs[i]->irq_idx = psnet_get_next_irq_num(psnet);
867 /* Write IRQ name */
868 snprintf(snet->vqs[i]->irq_name, SNET_NAME_SIZE, "snet[%s]-vq[%d]",
869 pci_name(pdev), snet->vqs[i]->irq_idx);
870 }
871}
872
873/* Find a device config based on virtual function id */
874static struct snet_dev_cfg *snet_find_dev_cfg(struct snet_cfg *cfg, u32 vfid)
875{
876 u32 i;
877
878 for (i = 0; i < cfg->devices_num; i++) {
879 if (cfg->devs[i]->vfid == vfid)
880 return cfg->devs[i];
881 }
882 /* Oppss.. no config found.. */
883 return NULL;
884}
885
886/* Probe function for a physical PCI function */
887static int snet_vdpa_probe_pf(struct pci_dev *pdev)
888{
889 struct psnet *psnet;
890 int ret = 0;
891 bool pf_irqs = false;
892
893 ret = pcim_enable_device(pdev);
894 if (ret) {
895 SNET_ERR(pdev, "Failed to enable PCI device\n");
896 return ret;
897 }
898
899 /* Allocate a PCI physical function device */
900 psnet = kzalloc(sizeof(*psnet), GFP_KERNEL);
901 if (!psnet)
902 return -ENOMEM;
903
904 /* Init PSNET spinlock */
905 spin_lock_init(&psnet->lock);
906
907 pci_set_master(pdev);
908 pci_set_drvdata(pdev, psnet);
909
910 /* Open SNET MAIN BAR */
911 ret = psnet_open_pf_bar(pdev, psnet);
912 if (ret)
913 goto free_psnet;
914
915 /* Try to read SNET's config from PCI BAR */
916 ret = psnet_read_cfg(pdev, psnet);
917 if (ret)
918 goto free_psnet;
919
920 /* If SNET_CFG_FLAG_IRQ_PF flag is set, we should use
921 * PF MSI-X vectors
922 */
923 pf_irqs = PSNET_FLAG_ON(psnet, SNET_CFG_FLAG_IRQ_PF);
924
925 if (pf_irqs) {
926 ret = psnet_alloc_irq_vector(pdev, psnet);
927 if (ret)
928 goto free_cfg;
929 }
930
931 SNET_DBG(pdev, "Enable %u virtual functions\n", psnet->cfg.vf_num);
932 ret = pci_enable_sriov(pdev, psnet->cfg.vf_num);
933 if (ret) {
934 SNET_ERR(pdev, "Failed to enable SR-IOV\n");
935 goto free_irq;
936 }
937
938 /* Create HW monitor device */
939 if (PSNET_FLAG_ON(psnet, SNET_CFG_FLAG_HWMON)) {
940#if IS_ENABLED(CONFIG_HWMON)
941 psnet_create_hwmon(pdev);
942#else
943 SNET_WARN(pdev, "Can't start HWMON, CONFIG_HWMON is not enabled\n");
944#endif
945 }
946
947 return 0;
948
949free_irq:
950 if (pf_irqs)
951 pci_free_irq_vectors(pdev);
952free_cfg:
953 snet_free_cfg(&psnet->cfg);
954free_psnet:
955 kfree(psnet);
956 return ret;
957}
958
959/* Probe function for a virtual PCI function */
960static int snet_vdpa_probe_vf(struct pci_dev *pdev)
961{
962 struct pci_dev *pdev_pf = pdev->physfn;
963 struct psnet *psnet = pci_get_drvdata(pdev_pf);
964 struct snet_dev_cfg *dev_cfg;
965 struct snet *snet;
966 u32 vfid;
967 int ret;
968 bool pf_irqs = false;
969
970 /* Get virtual function id.
971 * (the DPU counts the VFs from 1)
972 */
973 ret = pci_iov_vf_id(pdev);
974 if (ret < 0) {
975 SNET_ERR(pdev, "Failed to find a VF id\n");
976 return ret;
977 }
978 vfid = ret + 1;
979
980 /* Find the snet_dev_cfg based on vfid */
981 dev_cfg = snet_find_dev_cfg(&psnet->cfg, vfid);
982 if (!dev_cfg) {
983 SNET_WARN(pdev, "Failed to find a VF config..\n");
984 return -ENODEV;
985 }
986
987 /* Which PCI device should allocate the IRQs?
988 * If the SNET_CFG_FLAG_IRQ_PF flag set, the PF device allocates the IRQs
989 */
990 pf_irqs = PSNET_FLAG_ON(psnet, SNET_CFG_FLAG_IRQ_PF);
991
992 ret = pcim_enable_device(pdev);
993 if (ret) {
994 SNET_ERR(pdev, "Failed to enable PCI VF device\n");
995 return ret;
996 }
997
998 /* Request for MSI-X IRQs */
999 if (!pf_irqs) {
1000 ret = snet_alloc_irq_vector(pdev, dev_cfg);
1001 if (ret)
1002 return ret;
1003 }
1004
1005 /* Allocate vdpa device */
1006 snet = vdpa_alloc_device(struct snet, vdpa, &pdev->dev, &snet_config_ops, 1, 1, NULL,
1007 false);
1008 if (!snet) {
1009 SNET_ERR(pdev, "Failed to allocate a vdpa device\n");
1010 ret = -ENOMEM;
1011 goto free_irqs;
1012 }
1013
1014 /* Init control mutex and spinlock */
1015 mutex_init(&snet->ctrl_lock);
1016 spin_lock_init(&snet->ctrl_spinlock);
1017
1018 /* Save pci device pointer */
1019 snet->pdev = pdev;
1020 snet->psnet = psnet;
1021 snet->cfg = dev_cfg;
1022 snet->dpu_ready = false;
1023 snet->sid = vfid;
1024 /* Reset IRQ value */
1025 snet->cfg_irq = -1;
1026
1027 ret = snet_open_vf_bar(pdev, snet);
1028 if (ret)
1029 goto put_device;
1030
1031 /* Create a VirtIO config pointer */
1032 snet->cfg->virtio_cfg = snet->bar + snet->psnet->cfg.virtio_cfg_off;
1033
1034 /* Clear control registers */
1035 snet_ctrl_clear(snet);
1036
1037 pci_set_master(pdev);
1038 pci_set_drvdata(pdev, snet);
1039
1040 ret = snet_build_vqs(snet);
1041 if (ret)
1042 goto put_device;
1043
1044 /* Reserve IRQ indexes,
1045 * The IRQs may be requested and freed multiple times,
1046 * but the indexes won't change.
1047 */
1048 snet_reserve_irq_idx(pf_irqs ? pdev_pf : pdev, snet);
1049
1050 /*set DMA device*/
1051 snet->vdpa.dma_dev = &pdev->dev;
1052
1053 /* Register VDPA device */
1054 ret = vdpa_register_device(&snet->vdpa, snet->cfg->vq_num);
1055 if (ret) {
1056 SNET_ERR(pdev, "Failed to register vdpa device\n");
1057 goto free_vqs;
1058 }
1059
1060 return 0;
1061
1062free_vqs:
1063 snet_free_vqs(snet);
1064put_device:
1065 put_device(&snet->vdpa.dev);
1066free_irqs:
1067 if (!pf_irqs)
1068 pci_free_irq_vectors(pdev);
1069 return ret;
1070}
1071
1072static int snet_vdpa_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1073{
1074 if (pdev->is_virtfn)
1075 return snet_vdpa_probe_vf(pdev);
1076 else
1077 return snet_vdpa_probe_pf(pdev);
1078}
1079
1080static void snet_vdpa_remove_pf(struct pci_dev *pdev)
1081{
1082 struct psnet *psnet = pci_get_drvdata(pdev);
1083
1084 pci_disable_sriov(pdev);
1085 /* If IRQs are allocated from the PF, we should free the IRQs */
1086 if (PSNET_FLAG_ON(psnet, SNET_CFG_FLAG_IRQ_PF))
1087 pci_free_irq_vectors(pdev);
1088
1089 snet_free_cfg(&psnet->cfg);
1090 kfree(psnet);
1091}
1092
1093static void snet_vdpa_remove_vf(struct pci_dev *pdev)
1094{
1095 struct snet *snet = pci_get_drvdata(pdev);
1096 struct psnet *psnet = snet->psnet;
1097
1098 vdpa_unregister_device(&snet->vdpa);
1099 snet_free_vqs(snet);
1100 /* If IRQs are allocated from the VF, we should free the IRQs */
1101 if (!PSNET_FLAG_ON(psnet, SNET_CFG_FLAG_IRQ_PF))
1102 pci_free_irq_vectors(pdev);
1103}
1104
1105static void snet_vdpa_remove(struct pci_dev *pdev)
1106{
1107 if (pdev->is_virtfn)
1108 snet_vdpa_remove_vf(pdev);
1109 else
1110 snet_vdpa_remove_pf(pdev);
1111}
1112
1113static struct pci_device_id snet_driver_pci_ids[] = {
1114 { PCI_DEVICE_SUB(PCI_VENDOR_ID_SOLIDRUN, SNET_DEVICE_ID,
1115 PCI_VENDOR_ID_SOLIDRUN, SNET_DEVICE_ID) },
1116 { 0 },
1117};
1118
1119MODULE_DEVICE_TABLE(pci, snet_driver_pci_ids);
1120
1121static struct pci_driver snet_vdpa_driver = {
1122 .name = "snet-vdpa-driver",
1123 .id_table = snet_driver_pci_ids,
1124 .probe = snet_vdpa_probe,
1125 .remove = snet_vdpa_remove,
1126};
1127
1128module_pci_driver(snet_vdpa_driver);
1129
1130MODULE_AUTHOR("Alvaro Karsz <alvaro.karsz@solid-run.com>");
1131MODULE_DESCRIPTION("SolidRun vDPA driver");
1132MODULE_LICENSE("GPL v2");