1 // SPDX-License-Identifier: GPL-2.0-or-later
3 #include <linux/virtio_pci_modern.h>
4 #include <linux/module.h>
6 #include <linux/delay.h>
9 * vp_modern_map_capability - map a part of virtio pci capability
10 * @mdev: the modern virtio-pci device
11 * @off: offset of the capability
12 * @minlen: minimal length of the capability
13 * @align: align requirement
14 * @start: start from the capability
16 * @len: the length that is actually mapped
17 * @pa: physical address of the capability
19 * Returns the io address of for the part of the capability
22 vp_modern_map_capability(struct virtio_pci_modern_device
*mdev
, int off
,
23 size_t minlen
, u32 align
, u32 start
, u32 size
,
24 size_t *len
, resource_size_t
*pa
)
26 struct pci_dev
*dev
= mdev
->pci_dev
;
31 pci_read_config_byte(dev
, off
+ offsetof(struct virtio_pci_cap
,
34 pci_read_config_dword(dev
, off
+ offsetof(struct virtio_pci_cap
, offset
),
36 pci_read_config_dword(dev
, off
+ offsetof(struct virtio_pci_cap
, length
),
39 /* Check if the BAR may have changed since we requested the region. */
40 if (bar
>= PCI_STD_NUM_BARS
|| !(mdev
->modern_bars
& (1 << bar
))) {
42 "virtio_pci: bar unexpectedly changed to %u\n", bar
);
46 if (length
<= start
) {
48 "virtio_pci: bad capability len %u (>%u expected)\n",
53 if (length
- start
< minlen
) {
55 "virtio_pci: bad capability len %u (>=%zu expected)\n",
62 if (start
+ offset
< offset
) {
64 "virtio_pci: map wrap-around %u+%u\n",
71 if (offset
& (align
- 1)) {
73 "virtio_pci: offset %u not aligned to %u\n",
84 if (minlen
+ offset
< minlen
||
85 minlen
+ offset
> pci_resource_len(dev
, bar
)) {
87 "virtio_pci: map virtio %zu@%u "
88 "out of range on bar %i length %lu\n",
90 bar
, (unsigned long)pci_resource_len(dev
, bar
));
94 p
= pci_iomap_range(dev
, bar
, offset
, length
);
97 "virtio_pci: unable to map virtio %u@%u on bar %i\n",
100 *pa
= pci_resource_start(dev
, bar
) + offset
;
106 * virtio_pci_find_capability - walk capabilities to find device info.
107 * @dev: the pci device
108 * @cfg_type: the VIRTIO_PCI_CAP_* value we seek
109 * @ioresource_types: IORESOURCE_MEM and/or IORESOURCE_IO.
110 * @bars: the bitmask of BARs
112 * Returns offset of the capability, or 0.
114 static inline int virtio_pci_find_capability(struct pci_dev
*dev
, u8 cfg_type
,
115 u32 ioresource_types
, int *bars
)
119 for (pos
= pci_find_capability(dev
, PCI_CAP_ID_VNDR
);
121 pos
= pci_find_next_capability(dev
, pos
, PCI_CAP_ID_VNDR
)) {
123 pci_read_config_byte(dev
, pos
+ offsetof(struct virtio_pci_cap
,
126 pci_read_config_byte(dev
, pos
+ offsetof(struct virtio_pci_cap
,
130 /* Ignore structures with reserved BAR values */
131 if (bar
>= PCI_STD_NUM_BARS
)
134 if (type
== cfg_type
) {
135 if (pci_resource_len(dev
, bar
) &&
136 pci_resource_flags(dev
, bar
) & ioresource_types
) {
145 /* This is part of the ABI. Don't screw with it. */
146 static inline void check_offsets(void)
148 /* Note: disk space was harmed in compilation of this function. */
149 BUILD_BUG_ON(VIRTIO_PCI_CAP_VNDR
!=
150 offsetof(struct virtio_pci_cap
, cap_vndr
));
151 BUILD_BUG_ON(VIRTIO_PCI_CAP_NEXT
!=
152 offsetof(struct virtio_pci_cap
, cap_next
));
153 BUILD_BUG_ON(VIRTIO_PCI_CAP_LEN
!=
154 offsetof(struct virtio_pci_cap
, cap_len
));
155 BUILD_BUG_ON(VIRTIO_PCI_CAP_CFG_TYPE
!=
156 offsetof(struct virtio_pci_cap
, cfg_type
));
157 BUILD_BUG_ON(VIRTIO_PCI_CAP_BAR
!=
158 offsetof(struct virtio_pci_cap
, bar
));
159 BUILD_BUG_ON(VIRTIO_PCI_CAP_OFFSET
!=
160 offsetof(struct virtio_pci_cap
, offset
));
161 BUILD_BUG_ON(VIRTIO_PCI_CAP_LENGTH
!=
162 offsetof(struct virtio_pci_cap
, length
));
163 BUILD_BUG_ON(VIRTIO_PCI_NOTIFY_CAP_MULT
!=
164 offsetof(struct virtio_pci_notify_cap
,
165 notify_off_multiplier
));
166 BUILD_BUG_ON(VIRTIO_PCI_COMMON_DFSELECT
!=
167 offsetof(struct virtio_pci_common_cfg
,
168 device_feature_select
));
169 BUILD_BUG_ON(VIRTIO_PCI_COMMON_DF
!=
170 offsetof(struct virtio_pci_common_cfg
, device_feature
));
171 BUILD_BUG_ON(VIRTIO_PCI_COMMON_GFSELECT
!=
172 offsetof(struct virtio_pci_common_cfg
,
173 guest_feature_select
));
174 BUILD_BUG_ON(VIRTIO_PCI_COMMON_GF
!=
175 offsetof(struct virtio_pci_common_cfg
, guest_feature
));
176 BUILD_BUG_ON(VIRTIO_PCI_COMMON_MSIX
!=
177 offsetof(struct virtio_pci_common_cfg
, msix_config
));
178 BUILD_BUG_ON(VIRTIO_PCI_COMMON_NUMQ
!=
179 offsetof(struct virtio_pci_common_cfg
, num_queues
));
180 BUILD_BUG_ON(VIRTIO_PCI_COMMON_STATUS
!=
181 offsetof(struct virtio_pci_common_cfg
, device_status
));
182 BUILD_BUG_ON(VIRTIO_PCI_COMMON_CFGGENERATION
!=
183 offsetof(struct virtio_pci_common_cfg
, config_generation
));
184 BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_SELECT
!=
185 offsetof(struct virtio_pci_common_cfg
, queue_select
));
186 BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_SIZE
!=
187 offsetof(struct virtio_pci_common_cfg
, queue_size
));
188 BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_MSIX
!=
189 offsetof(struct virtio_pci_common_cfg
, queue_msix_vector
));
190 BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_ENABLE
!=
191 offsetof(struct virtio_pci_common_cfg
, queue_enable
));
192 BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_NOFF
!=
193 offsetof(struct virtio_pci_common_cfg
, queue_notify_off
));
194 BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_DESCLO
!=
195 offsetof(struct virtio_pci_common_cfg
, queue_desc_lo
));
196 BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_DESCHI
!=
197 offsetof(struct virtio_pci_common_cfg
, queue_desc_hi
));
198 BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_AVAILLO
!=
199 offsetof(struct virtio_pci_common_cfg
, queue_avail_lo
));
200 BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_AVAILHI
!=
201 offsetof(struct virtio_pci_common_cfg
, queue_avail_hi
));
202 BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_USEDLO
!=
203 offsetof(struct virtio_pci_common_cfg
, queue_used_lo
));
204 BUILD_BUG_ON(VIRTIO_PCI_COMMON_Q_USEDHI
!=
205 offsetof(struct virtio_pci_common_cfg
, queue_used_hi
));
209 * vp_modern_probe: probe the modern virtio pci device, note that the
210 * caller is required to enable PCI device before calling this function.
211 * @mdev: the modern virtio-pci device
213 * Return 0 on succeed otherwise fail
215 int vp_modern_probe(struct virtio_pci_modern_device
*mdev
)
217 struct pci_dev
*pci_dev
= mdev
->pci_dev
;
218 int err
, common
, isr
, notify
, device
;
225 if (mdev
->device_id_check
) {
226 devid
= mdev
->device_id_check(pci_dev
);
229 mdev
->id
.device
= devid
;
231 /* We only own devices >= 0x1000 and <= 0x107f: leave the rest. */
232 if (pci_dev
->device
< 0x1000 || pci_dev
->device
> 0x107f)
235 if (pci_dev
->device
< 0x1040) {
236 /* Transitional devices: use the PCI subsystem device id as
237 * virtio device id, same as legacy driver always did.
239 mdev
->id
.device
= pci_dev
->subsystem_device
;
241 /* Modern devices: simply use PCI device id, but start from 0x1040. */
242 mdev
->id
.device
= pci_dev
->device
- 0x1040;
245 mdev
->id
.vendor
= pci_dev
->subsystem_vendor
;
247 /* check for a common config: if not, use legacy mode (bar 0). */
248 common
= virtio_pci_find_capability(pci_dev
, VIRTIO_PCI_CAP_COMMON_CFG
,
249 IORESOURCE_IO
| IORESOURCE_MEM
,
252 dev_info(&pci_dev
->dev
,
253 "virtio_pci: leaving for legacy driver\n");
257 /* If common is there, these should be too... */
258 isr
= virtio_pci_find_capability(pci_dev
, VIRTIO_PCI_CAP_ISR_CFG
,
259 IORESOURCE_IO
| IORESOURCE_MEM
,
261 notify
= virtio_pci_find_capability(pci_dev
, VIRTIO_PCI_CAP_NOTIFY_CFG
,
262 IORESOURCE_IO
| IORESOURCE_MEM
,
264 if (!isr
|| !notify
) {
265 dev_err(&pci_dev
->dev
,
266 "virtio_pci: missing capabilities %i/%i/%i\n",
267 common
, isr
, notify
);
271 err
= dma_set_mask_and_coherent(&pci_dev
->dev
,
272 mdev
->dma_mask
? : DMA_BIT_MASK(64));
274 err
= dma_set_mask_and_coherent(&pci_dev
->dev
,
277 dev_warn(&pci_dev
->dev
, "Failed to enable 64-bit or 32-bit DMA. Trying to continue, but this might not work.\n");
279 /* Device capability is only mandatory for devices that have
280 * device-specific configuration.
282 device
= virtio_pci_find_capability(pci_dev
, VIRTIO_PCI_CAP_DEVICE_CFG
,
283 IORESOURCE_IO
| IORESOURCE_MEM
,
286 err
= pci_request_selected_regions(pci_dev
, mdev
->modern_bars
,
287 "virtio-pci-modern");
292 mdev
->common
= vp_modern_map_capability(mdev
, common
,
293 sizeof(struct virtio_pci_common_cfg
), 4,
294 0, sizeof(struct virtio_pci_modern_common_cfg
),
298 mdev
->isr
= vp_modern_map_capability(mdev
, isr
, sizeof(u8
), 1,
304 /* Read notify_off_multiplier from config space. */
305 pci_read_config_dword(pci_dev
,
306 notify
+ offsetof(struct virtio_pci_notify_cap
,
307 notify_off_multiplier
),
308 &mdev
->notify_offset_multiplier
);
309 /* Read notify length and offset from config space. */
310 pci_read_config_dword(pci_dev
,
311 notify
+ offsetof(struct virtio_pci_notify_cap
,
315 pci_read_config_dword(pci_dev
,
316 notify
+ offsetof(struct virtio_pci_notify_cap
,
320 /* We don't know how many VQs we'll map, ahead of the time.
321 * If notify length is small, map it all now.
322 * Otherwise, map each VQ individually later.
324 if ((u64
)notify_length
+ (notify_offset
% PAGE_SIZE
) <= PAGE_SIZE
) {
325 mdev
->notify_base
= vp_modern_map_capability(mdev
, notify
,
330 if (!mdev
->notify_base
)
333 mdev
->notify_map_cap
= notify
;
336 /* Again, we don't know how much we should map, but PAGE_SIZE
337 * is more than enough for all existing devices.
340 mdev
->device
= vp_modern_map_capability(mdev
, device
, 0, 4,
351 if (mdev
->notify_base
)
352 pci_iounmap(pci_dev
, mdev
->notify_base
);
354 pci_iounmap(pci_dev
, mdev
->isr
);
356 pci_iounmap(pci_dev
, mdev
->common
);
358 pci_release_selected_regions(pci_dev
, mdev
->modern_bars
);
361 EXPORT_SYMBOL_GPL(vp_modern_probe
);
364 * vp_modern_remove: remove and cleanup the modern virtio pci device
365 * @mdev: the modern virtio-pci device
367 void vp_modern_remove(struct virtio_pci_modern_device
*mdev
)
369 struct pci_dev
*pci_dev
= mdev
->pci_dev
;
372 pci_iounmap(pci_dev
, mdev
->device
);
373 if (mdev
->notify_base
)
374 pci_iounmap(pci_dev
, mdev
->notify_base
);
375 pci_iounmap(pci_dev
, mdev
->isr
);
376 pci_iounmap(pci_dev
, mdev
->common
);
377 pci_release_selected_regions(pci_dev
, mdev
->modern_bars
);
379 EXPORT_SYMBOL_GPL(vp_modern_remove
);
382 * vp_modern_get_features - get features from device
383 * @mdev: the modern virtio-pci device
385 * Returns the features read from the device
387 u64
vp_modern_get_features(struct virtio_pci_modern_device
*mdev
)
389 struct virtio_pci_common_cfg __iomem
*cfg
= mdev
->common
;
393 vp_iowrite32(0, &cfg
->device_feature_select
);
394 features
= vp_ioread32(&cfg
->device_feature
);
395 vp_iowrite32(1, &cfg
->device_feature_select
);
396 features
|= ((u64
)vp_ioread32(&cfg
->device_feature
) << 32);
400 EXPORT_SYMBOL_GPL(vp_modern_get_features
);
403 * vp_modern_get_driver_features - get driver features from device
404 * @mdev: the modern virtio-pci device
406 * Returns the driver features read from the device
408 u64
vp_modern_get_driver_features(struct virtio_pci_modern_device
*mdev
)
410 struct virtio_pci_common_cfg __iomem
*cfg
= mdev
->common
;
414 vp_iowrite32(0, &cfg
->guest_feature_select
);
415 features
= vp_ioread32(&cfg
->guest_feature
);
416 vp_iowrite32(1, &cfg
->guest_feature_select
);
417 features
|= ((u64
)vp_ioread32(&cfg
->guest_feature
) << 32);
421 EXPORT_SYMBOL_GPL(vp_modern_get_driver_features
);
424 * vp_modern_set_features - set features to device
425 * @mdev: the modern virtio-pci device
426 * @features: the features set to device
428 void vp_modern_set_features(struct virtio_pci_modern_device
*mdev
,
431 struct virtio_pci_common_cfg __iomem
*cfg
= mdev
->common
;
433 vp_iowrite32(0, &cfg
->guest_feature_select
);
434 vp_iowrite32((u32
)features
, &cfg
->guest_feature
);
435 vp_iowrite32(1, &cfg
->guest_feature_select
);
436 vp_iowrite32(features
>> 32, &cfg
->guest_feature
);
438 EXPORT_SYMBOL_GPL(vp_modern_set_features
);
441 * vp_modern_generation - get the device genreation
442 * @mdev: the modern virtio-pci device
444 * Returns the genreation read from device
446 u32
vp_modern_generation(struct virtio_pci_modern_device
*mdev
)
448 struct virtio_pci_common_cfg __iomem
*cfg
= mdev
->common
;
450 return vp_ioread8(&cfg
->config_generation
);
452 EXPORT_SYMBOL_GPL(vp_modern_generation
);
455 * vp_modern_get_status - get the device status
456 * @mdev: the modern virtio-pci device
458 * Returns the status read from device
460 u8
vp_modern_get_status(struct virtio_pci_modern_device
*mdev
)
462 struct virtio_pci_common_cfg __iomem
*cfg
= mdev
->common
;
464 return vp_ioread8(&cfg
->device_status
);
466 EXPORT_SYMBOL_GPL(vp_modern_get_status
);
469 * vp_modern_set_status - set status to device
470 * @mdev: the modern virtio-pci device
471 * @status: the status set to device
473 void vp_modern_set_status(struct virtio_pci_modern_device
*mdev
,
476 struct virtio_pci_common_cfg __iomem
*cfg
= mdev
->common
;
479 * Per memory-barriers.txt, wmb() is not needed to guarantee
480 * that the cache coherent memory writes have completed
481 * before writing to the MMIO region.
483 vp_iowrite8(status
, &cfg
->device_status
);
485 EXPORT_SYMBOL_GPL(vp_modern_set_status
);
488 * vp_modern_get_queue_reset - get the queue reset status
489 * @mdev: the modern virtio-pci device
490 * @index: queue index
492 int vp_modern_get_queue_reset(struct virtio_pci_modern_device
*mdev
, u16 index
)
494 struct virtio_pci_modern_common_cfg __iomem
*cfg
;
496 cfg
= (struct virtio_pci_modern_common_cfg __iomem
*)mdev
->common
;
498 vp_iowrite16(index
, &cfg
->cfg
.queue_select
);
499 return vp_ioread16(&cfg
->queue_reset
);
501 EXPORT_SYMBOL_GPL(vp_modern_get_queue_reset
);
504 * vp_modern_set_queue_reset - reset the queue
505 * @mdev: the modern virtio-pci device
506 * @index: queue index
508 void vp_modern_set_queue_reset(struct virtio_pci_modern_device
*mdev
, u16 index
)
510 struct virtio_pci_modern_common_cfg __iomem
*cfg
;
512 cfg
= (struct virtio_pci_modern_common_cfg __iomem
*)mdev
->common
;
514 vp_iowrite16(index
, &cfg
->cfg
.queue_select
);
515 vp_iowrite16(1, &cfg
->queue_reset
);
517 while (vp_ioread16(&cfg
->queue_reset
))
520 while (vp_ioread16(&cfg
->cfg
.queue_enable
))
523 EXPORT_SYMBOL_GPL(vp_modern_set_queue_reset
);
526 * vp_modern_queue_vector - set the MSIX vector for a specific virtqueue
527 * @mdev: the modern virtio-pci device
528 * @index: queue index
529 * @vector: the config vector
531 * Returns the config vector read from the device
533 u16
vp_modern_queue_vector(struct virtio_pci_modern_device
*mdev
,
534 u16 index
, u16 vector
)
536 struct virtio_pci_common_cfg __iomem
*cfg
= mdev
->common
;
538 vp_iowrite16(index
, &cfg
->queue_select
);
539 vp_iowrite16(vector
, &cfg
->queue_msix_vector
);
540 /* Flush the write out to device */
541 return vp_ioread16(&cfg
->queue_msix_vector
);
543 EXPORT_SYMBOL_GPL(vp_modern_queue_vector
);
546 * vp_modern_config_vector - set the vector for config interrupt
547 * @mdev: the modern virtio-pci device
548 * @vector: the config vector
550 * Returns the config vector read from the device
552 u16
vp_modern_config_vector(struct virtio_pci_modern_device
*mdev
,
555 struct virtio_pci_common_cfg __iomem
*cfg
= mdev
->common
;
557 /* Setup the vector used for configuration events */
558 vp_iowrite16(vector
, &cfg
->msix_config
);
559 /* Verify we had enough resources to assign the vector */
560 /* Will also flush the write out to device */
561 return vp_ioread16(&cfg
->msix_config
);
563 EXPORT_SYMBOL_GPL(vp_modern_config_vector
);
566 * vp_modern_queue_address - set the virtqueue address
567 * @mdev: the modern virtio-pci device
568 * @index: the queue index
569 * @desc_addr: address of the descriptor area
570 * @driver_addr: address of the driver area
571 * @device_addr: address of the device area
573 void vp_modern_queue_address(struct virtio_pci_modern_device
*mdev
,
574 u16 index
, u64 desc_addr
, u64 driver_addr
,
577 struct virtio_pci_common_cfg __iomem
*cfg
= mdev
->common
;
579 vp_iowrite16(index
, &cfg
->queue_select
);
581 vp_iowrite64_twopart(desc_addr
, &cfg
->queue_desc_lo
,
582 &cfg
->queue_desc_hi
);
583 vp_iowrite64_twopart(driver_addr
, &cfg
->queue_avail_lo
,
584 &cfg
->queue_avail_hi
);
585 vp_iowrite64_twopart(device_addr
, &cfg
->queue_used_lo
,
586 &cfg
->queue_used_hi
);
588 EXPORT_SYMBOL_GPL(vp_modern_queue_address
);
591 * vp_modern_set_queue_enable - enable a virtqueue
592 * @mdev: the modern virtio-pci device
593 * @index: the queue index
594 * @enable: whether the virtqueue is enable or not
596 void vp_modern_set_queue_enable(struct virtio_pci_modern_device
*mdev
,
597 u16 index
, bool enable
)
599 vp_iowrite16(index
, &mdev
->common
->queue_select
);
600 vp_iowrite16(enable
, &mdev
->common
->queue_enable
);
602 EXPORT_SYMBOL_GPL(vp_modern_set_queue_enable
);
605 * vp_modern_get_queue_enable - enable a virtqueue
606 * @mdev: the modern virtio-pci device
607 * @index: the queue index
609 * Returns whether a virtqueue is enabled or not
611 bool vp_modern_get_queue_enable(struct virtio_pci_modern_device
*mdev
,
614 vp_iowrite16(index
, &mdev
->common
->queue_select
);
616 return vp_ioread16(&mdev
->common
->queue_enable
);
618 EXPORT_SYMBOL_GPL(vp_modern_get_queue_enable
);
621 * vp_modern_set_queue_size - set size for a virtqueue
622 * @mdev: the modern virtio-pci device
623 * @index: the queue index
624 * @size: the size of the virtqueue
626 void vp_modern_set_queue_size(struct virtio_pci_modern_device
*mdev
,
629 vp_iowrite16(index
, &mdev
->common
->queue_select
);
630 vp_iowrite16(size
, &mdev
->common
->queue_size
);
633 EXPORT_SYMBOL_GPL(vp_modern_set_queue_size
);
636 * vp_modern_get_queue_size - get size for a virtqueue
637 * @mdev: the modern virtio-pci device
638 * @index: the queue index
640 * Returns the size of the virtqueue
642 u16
vp_modern_get_queue_size(struct virtio_pci_modern_device
*mdev
,
645 vp_iowrite16(index
, &mdev
->common
->queue_select
);
647 return vp_ioread16(&mdev
->common
->queue_size
);
650 EXPORT_SYMBOL_GPL(vp_modern_get_queue_size
);
653 * vp_modern_get_num_queues - get the number of virtqueues
654 * @mdev: the modern virtio-pci device
656 * Returns the number of virtqueues
658 u16
vp_modern_get_num_queues(struct virtio_pci_modern_device
*mdev
)
660 return vp_ioread16(&mdev
->common
->num_queues
);
662 EXPORT_SYMBOL_GPL(vp_modern_get_num_queues
);
665 * vp_modern_get_queue_notify_off - get notification offset for a virtqueue
666 * @mdev: the modern virtio-pci device
667 * @index: the queue index
669 * Returns the notification offset for a virtqueue
671 static u16
vp_modern_get_queue_notify_off(struct virtio_pci_modern_device
*mdev
,
674 vp_iowrite16(index
, &mdev
->common
->queue_select
);
676 return vp_ioread16(&mdev
->common
->queue_notify_off
);
680 * vp_modern_map_vq_notify - map notification area for a
682 * @mdev: the modern virtio-pci device
683 * @index: the queue index
684 * @pa: the pointer to the physical address of the nofity area
686 * Returns the address of the notification area
688 void __iomem
*vp_modern_map_vq_notify(struct virtio_pci_modern_device
*mdev
,
689 u16 index
, resource_size_t
*pa
)
691 u16 off
= vp_modern_get_queue_notify_off(mdev
, index
);
693 if (mdev
->notify_base
) {
694 /* offset should not wrap */
695 if ((u64
)off
* mdev
->notify_offset_multiplier
+ 2
696 > mdev
->notify_len
) {
697 dev_warn(&mdev
->pci_dev
->dev
,
698 "bad notification offset %u (x %u) "
699 "for queue %u > %zd",
700 off
, mdev
->notify_offset_multiplier
,
701 index
, mdev
->notify_len
);
705 *pa
= mdev
->notify_pa
+
706 off
* mdev
->notify_offset_multiplier
;
707 return mdev
->notify_base
+ off
* mdev
->notify_offset_multiplier
;
709 return vp_modern_map_capability(mdev
,
710 mdev
->notify_map_cap
, 2, 2,
711 off
* mdev
->notify_offset_multiplier
, 2,
715 EXPORT_SYMBOL_GPL(vp_modern_map_vq_notify
);
717 MODULE_VERSION("0.1");
718 MODULE_DESCRIPTION("Modern Virtio PCI Device");
719 MODULE_AUTHOR("Jason Wang <jasowang@redhat.com>");
720 MODULE_LICENSE("GPL");