VirtioPci-solaris.c

Last change on this file was 106061, checked in by vboxsync, 3 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 24.6 KB

Line
1	/* $Id: VirtioPci-solaris.c 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* VirtualBox Guest Additions - Virtio Driver for Solaris, PCI Hypervisor Interface.
4	*/
5
6	/*
7	* Copyright (C) 2010-2024 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#include "VirtioPci-solaris.h"
42
43	#include <iprt/asm.h>
44	#include <iprt/assert.h>
45	#include <iprt/mem.h>
46	#include <iprt/param.h>
47	#include <VBox/log.h>
48
49	#include <sys/pci.h>
50	#include <sys/param.h>
51
52
53	/*********************************************************************************************************************************
54	* Defined Constants And Macros *
55	*********************************************************************************************************************************/
56	/*
57	* Pci Register offsets.
58	*/
59	#define VIRTIO_PCI_HOST_FEATURES 0x00
60	#define VIRTIO_PCI_GUEST_FEATURES 0x04
61	#define VIRTIO_PCI_QUEUE_PFN 0x08
62	#define VIRTIO_PCI_QUEUE_NUM 0x0C
63	#define VIRTIO_PCI_QUEUE_SEL 0x0E
64	#define VIRTIO_PCI_QUEUE_NOTIFY 0x10
65	#define VIRTIO_PCI_STATUS 0x12
66	#define VIRTIO_PCI_ISR 0x13
67	#define VIRTIO_PCI_CONFIG 0x14
68
69	#define VIRTIO_PCI_RING_ALIGN PAGE_SIZE
70	#define VIRTIO_PCI_QUEUE_ADDR_SHIFT PAGE_SHIFT
71
72	/**
73	* virtio_pci_t: Private data per device instance.
74	*/
75	typedef struct virtio_pci_t
76	{
77	ddi_acc_handle_t hIO; /* IO handle */
78	caddr_t addrIOBase; /* IO base address */
79	} virtio_pci_t;
80
81	/**
82	* virtio_pci_queue_t: Private data per queue instance.
83	*/
84	typedef struct virtio_pci_queue_t
85	{
86	ddi_dma_handle_t hDMA; /* DMA handle. */
87	ddi_acc_handle_t hIO; /* IO handle. */
88	size_t cbBuf; /* Physical address of buffer. */
89	paddr_t physBuf; /* Size of buffer. */
90	pfn_t pageBuf; /* Page frame number of buffer. */
91	} virtio_pci_queue_t;
92
93	static ddi_device_acc_attr_t g_VirtioPciAccAttrRegs =
94	{
95	DDI_DEVICE_ATTR_V0, /* Version */
96	DDI_STRUCTURE_LE_ACC, /* Structural data access in little endian. */
97	DDI_STRICTORDER_ACC, /* Strict ordering. */
98	DDI_DEFAULT_ACC /* Default access, possible panic on errors*/
99	};
100
101	static ddi_device_acc_attr_t g_VirtioPciAccAttrRing =
102	{
103	DDI_DEVICE_ATTR_V0, /* Version. */
104	DDI_NEVERSWAP_ACC, /* Data access with no byte swapping*/
105	DDI_STRICTORDER_ACC, /* Strict ordering. */
106	DDI_DEFAULT_ACC /* Default access, possible panic on errors*/
107	};
108
109	static ddi_dma_attr_t g_VirtioPciDmaAttrRing =
110	{
111	DMA_ATTR_V0, /* Version. */
112	0, /* Lowest usable address. */
113	0xffffffffffffffffULL, /* Highest usable address. */
114	0x7fffffff, /* Maximum DMAable byte count. */
115	VIRTIO_PCI_RING_ALIGN, /* Alignment in bytes. */
116	0x7ff, /* Bitmap of burst sizes */
117	1, /* Minimum transfer. */
118	0xffffffffU, /* Maximum transfer. */
119	0xffffffffffffffffULL, /* Maximum segment length. */
120	1, /* Maximum number of segments. */
121	1, /* Granularity. */
122	0 /* Flags (reserved). */
123	};
124
125	/** Pointer to the interrupt handle vector */
126	static ddi_intr_handle_t *g_pIntr;
127	/** Number of actually allocated interrupt handles */
128	static size_t g_cIntrAllocated;
129	/** The IRQ Mutex */
130	static kmutex_t g_IrqMtx;
131
132
133	/*********************************************************************************************************************************
134	* Internal Functions *
135	*********************************************************************************************************************************/
136	static void *VirtioPciAlloc(PVIRTIODEVICE pDevice);
137	static void VirtioPciFree(PVIRTIODEVICE pDevice);
138	static int VirtioPciAttach(PVIRTIODEVICE pDevice);
139	static int VirtioPciDetach(PVIRTIODEVICE pDevice);
140	static uint32_t VirtioPciGetFeatures(PVIRTIODEVICE pDevice);
141	static void VirtioPciSetFeatures(PVIRTIODEVICE pDevice, uint32_t fFeatures);
142	static int VirtioPciNotifyQueue(PVIRTIODEVICE pDevice, PVIRTIOQUEUE pQueue);
143	static void VirtioPciGet(PVIRTIODEVICE pDevice, off_t off, void *pv, size_t cb);
144	static void VirtioPciSet(PVIRTIODEVICE pDevice, off_t off, void *pv, size_t cb);
145	static void *VirtioPciGetQueue(PVIRTIODEVICE pDevice, PVIRTIOQUEUE pQueue);
146	static void VirtioPciPutQueue(PVIRTIODEVICE pDevice, PVIRTIOQUEUE pQueue);
147	static void VirtioPciSetStatus(PVIRTIODEVICE pDevice, uint8_t Status);
148
149	static uint_t VirtioPciISR(caddr_t Arg);
150	static int VirtioPciSetupIRQ(dev_info_t *pDip);
151	static void VirtioPciRemoveIRQ(dev_info_t *pDip);
152
153	/**
154	* Hypervisor operations for Virtio Pci.
155	*/
156	VIRTIOHYPEROPS g_VirtioHyperOpsPci =
157	{
158	VirtioPciAlloc,
159	VirtioPciFree,
160	VirtioPciAttach,
161	VirtioPciDetach,
162	VirtioPciGetFeatures,
163	VirtioPciSetFeatures,
164	VirtioPciNotifyQueue,
165	VirtioPciGet,
166	VirtioPciSet,
167	VirtioPciGetQueue,
168	VirtioPciPutQueue,
169	VirtioPciSetStatus
170	};
171
172
173	/**
174	* Virtio Pci private data allocation routine.
175	*
176	* @param pDevice Pointer to the Virtio device instance.
177	* @return Allocated private data structure which must only be freed by calling
178	* VirtioPciFree().
179	*/
180	static void *VirtioPciAlloc(PVIRTIODEVICE pDevice)
181	{
182	LogFlowFunc((VIRTIOLOGNAME ":VirtioPciAlloc pDevice=%p\n", pDevice));
183	virtio_pci_t *pPciData = RTMemAllocZ(sizeof(virtio_pci_t));
184	return pPciData;
185	}
186
187
188	/**
189	* Virtio Pci private data deallocation routine.
190	*
191	* @param pDevice Pointer to the Virtio device instance.
192	*/
193	static void VirtioPciFree(PVIRTIODEVICE pDevice)
194	{
195	LogFlowFunc((VIRTIOLOGNAME ":VirtioPciFree pDevice=%p\n", pDevice));
196	virtio_pci_t *pPciData = pDevice->pvHyper;
197	if (pPciData)
198	{
199	RTMemFree(pDevice->pvHyper);
200	pDevice->pvHyper = NULL;
201	}
202	}
203
204
205	/**
206	* Virtio Pci attach routine, called from driver attach.
207	*
208	* @param pDevice Pointer to the Virtio device instance.
209	*
210	* @return Solaris DDI error code. DDI_SUCCESS or DDI_FAILURE.
211	*/
212	static int VirtioPciAttach(PVIRTIODEVICE pDevice)
213	{
214	LogFlowFunc((VIRTIOLOGNAME ":VirtioPciAttach pDevice=%p\n", pDevice));
215	virtio_pci_t *pPciData = pDevice->pvHyper;
216	AssertReturn(pPciData, DDI_FAILURE);
217
218	int rc = ddi_regs_map_setup(pDevice->pDip,
219	1, /* reg. num */
220	&pPciData->addrIOBase,
221	0, /* offset */
222	0, /* length */
223	&g_VirtioPciAccAttrRegs,
224	&pPciData->hIO);
225	if (rc == DDI_SUCCESS)
226	{
227	/*
228	* Reset the device.
229	*/
230	VirtioPciSetStatus(pDevice, 0);
231
232	/*
233	* Add interrupt handler.
234	*/
235	VirtioPciSetupIRQ(pDevice->pDip);
236
237	LogFlow((VIRTIOLOGNAME ":VirtioPciAttach: successfully mapped registers.\n"));
238	return DDI_SUCCESS;
239	}
240	else
241	LogRel((VIRTIOLOGNAME ":VirtioPciAttach: ddi_regs_map_setup failed. rc=%d\n", rc));
242	return DDI_FAILURE;
243	}
244
245
246	/**
247	* Virtio Pci detach routine, called from driver detach.
248	*
249	* @param pDevice Pointer to the Virtio device instance.
250	*
251	* @return Solaris DDI error code. DDI_SUCCESS or DDI_FAILURE.
252	*/
253	static int VirtioPciDetach(PVIRTIODEVICE pDevice)
254	{
255	LogFlowFunc((VIRTIOLOGNAME ":VirtioPciDetach pDevice=%p\n", pDevice));
256	virtio_pci_t *pPciData = pDevice->pvHyper;
257	AssertReturn(pPciData, DDI_FAILURE);
258
259	VirtioPciRemoveIRQ(pDevice->pDip);
260	ddi_regs_map_free(&pPciData->hIO);
261	return DDI_SUCCESS;
262	}
263
264
265	/**
266	* Get host supported features.
267	*
268	* @param pDevice Pointer to the Virtio device instance.
269	*
270	* @return Mask of host features.
271	*/
272	static uint32_t VirtioPciGetFeatures(PVIRTIODEVICE pDevice)
273	{
274	LogFlowFunc((VIRTIOLOGNAME ":VirtioPciGetFeatures pDevice=%p\n", pDevice));
275	virtio_pci_t *pPciData = pDevice->pvHyper;
276	AssertReturn(pPciData, 0);
277
278	return ddi_get32(pPciData->hIO, (uint32_t *)(pPciData->addrIOBase + VIRTIO_PCI_HOST_FEATURES));
279	}
280
281
282	/**
283	* Set guest supported features.
284	*
285	* @param pDevice Pointer to the Virtio device instance.
286	* @param u32Features Mask of guest supported features.
287	*/
288	static void VirtioPciSetFeatures(PVIRTIODEVICE pDevice, uint32_t u32Features)
289	{
290	LogFlowFunc((VIRTIOLOGNAME ":VirtioPciSetFeatures pDevice=%p\n", pDevice));
291	virtio_pci_t *pPciData = pDevice->pvHyper;
292	AssertReturnVoid(pPciData);
293
294	ddi_put32(pPciData->hIO, (uint32_t *)(pPciData->addrIOBase + VIRTIO_PCI_GUEST_FEATURES), u32Features);
295	}
296
297
298	/**
299	* Update the queue, notify the host.
300	*
301	* @param pDevice Pointer to the Virtio device instance.
302	* @param pQueue Pointer to the Queue that is doing the notification.
303	*
304	* @return Solaris DDI error code. DDI_SUCCESS or DDI_FAILURE.
305	*/
306	static int VirtioPciNotifyQueue(PVIRTIODEVICE pDevice, PVIRTIOQUEUE pQueue)
307	{
308	LogFlowFunc((VIRTIOLOGNAME ":VirtioPciNotifyQueue pDevice=%p pQueue=%p\n", pDevice, pQueue));
309	virtio_pci_t *pPciData = pDevice->pvHyper;
310	AssertReturn(pPciData, DDI_FAILURE);
311
312	pQueue->Ring.pRingAvail->Index += pQueue->cBufs;
313	pQueue->cBufs = 0;
314
315	ASMCompilerBarrier();
316
317	ddi_put16(pPciData->hIO, (uint16_t *)(pPciData->addrIOBase + VIRTIO_PCI_QUEUE_NOTIFY), pQueue->QueueIndex);
318	cmn_err(CE_NOTE, "VirtioPciNotifyQueue\n");
319	}
320
321
322
323	/**
324	* Virtio Pci set (write) routine.
325	*
326	* @param pDevice Pointer to the Virtio device instance.
327	* @param off Offset into the PCI config space.
328	* @param pv Pointer to the buffer to write from.
329	* @param cb Size of the buffer in bytes.
330	*/
331	static void VirtioPciSet(PVIRTIODEVICE pDevice, off_t off, void *pv, size_t cb)
332	{
333	LogFlowFunc((VIRTIOLOGNAME ":VirtioPciSet pDevice=%p\n", pDevice));
334	virtio_pci_t *pPciData = pDevice->pvHyper;
335	AssertReturnVoid(pPciData);
336
337	uint8_t *pb = pv;
338	for (size_t i = 0; i < cb; i++, pb++)
339	ddi_put8(pPciData->hIO, (uint8_t )(pPciData->addrIOBase + VIRTIO_PCI_CONFIG + off + i), pb);
340	}
341
342
343	/**
344	* Virtio Pci get (read) routine.
345	*
346	* @param pDevice Pointer to the Virtio device instance.
347	* @param off Offset into the PCI config space.
348	* @param pv Where to store the read data.
349	* @param cb Size of the buffer in bytes.
350	*/
351	static void VirtioPciGet(PVIRTIODEVICE pDevice, off_t off, void *pv, size_t cb)
352	{
353	LogFlowFunc((VIRTIOLOGNAME ":VirtioPciGet pDevice=%p off=%u pv=%p cb=%u\n", pDevice, off, pv, cb));
354	virtio_pci_t *pPciData = pDevice->pvHyper;
355	AssertReturnVoid(pPciData);
356
357	uint8_t *pb = pv;
358	for (size_t i = 0; i < cb; i++, pb++)
359	pb = ddi_get8(pPciData->hIO, (uint8_t )(pPciData->addrIOBase + VIRTIO_PCI_CONFIG + off + i));
360	}
361
362
363	/**
364	* Virtio Pci put queue routine. Places the queue and frees associated queue.
365	*
366	* @param pDevice Pointer to the Virtio device instance.
367	* @param pQueue Pointer to the queue.
368	*/
369	static void VirtioPciPutQueue(PVIRTIODEVICE pDevice, PVIRTIOQUEUE pQueue)
370	{
371	LogFlowFunc((VIRTIOLOGNAME ":VirtioPciPutQueue pDevice=%p pQueue=%p\n", pDevice, pQueue));
372	AssertReturnVoid(pDevice);
373	AssertReturnVoid(pQueue);
374
375	virtio_pci_t *pPci = pDevice->pvHyper;
376	AssertReturnVoid(pPci);
377	virtio_pci_queue_t *pPciQueue = pQueue->pvData;
378	if (RT_UNLIKELY(!pPciQueue))
379	{
380	LogRel((VIRTIOLOGNAME ":VirtioPciPutQueue missing Pci queue.\n"));
381	return;
382	}
383
384	ddi_put16(pPci->hIO, (uint16_t *)(pPci->addrIOBase + VIRTIO_PCI_QUEUE_SEL), pQueue->QueueIndex);
385	ddi_put32(pPci->hIO, (uint32_t *)(pPci->addrIOBase + VIRTIO_PCI_QUEUE_PFN), 0);
386
387	ddi_dma_unbind_handle(pPciQueue->hDMA);
388	ddi_dma_mem_free(&pPciQueue->hIO);
389	ddi_dma_free_handle(&pPciQueue->hDMA);
390	RTMemFree(pPciQueue);
391	}
392
393
394	/**
395	* Virtio Pci get queue routine. Allocates a PCI queue and DMA resources.
396	*
397	* @param pDevice Pointer to the Virtio device instance.
398	* @param pQueue Where to store the queue.
399	*
400	* @return An allocated Virtio Pci queue, or NULL in case of errors.
401	*/
402	static void *VirtioPciGetQueue(PVIRTIODEVICE pDevice, PVIRTIOQUEUE pQueue)
403	{
404	LogFlowFunc((VIRTIOLOGNAME ":VirtioPciGetQueue pDevice=%p pQueue=%p\n", pDevice, pQueue));
405	AssertReturn(pDevice, NULL);
406
407	virtio_pci_t *pPci = pDevice->pvHyper;
408	AssertReturn(pPci, NULL);
409
410	/*
411	* Select a Queue.
412	*/
413	ddi_put16(pPci->hIO, (uint16_t *)(pPci->addrIOBase + VIRTIO_PCI_QUEUE_SEL), pQueue->QueueIndex);
414
415	/*
416	* Get the currently selected Queue's size.
417	*/
418	pQueue->Ring.cDesc = ddi_get16(pPci->hIO, (uint16_t *)(pPci->addrIOBase + VIRTIO_PCI_QUEUE_NUM));
419	if (RT_UNLIKELY(!pQueue->Ring.cDesc))
420	{
421	LogRel((VIRTIOLOGNAME ": VirtioPciGetQueue: Queue[%d] has no descriptors.\n", pQueue->QueueIndex));
422	return NULL;
423	}
424
425	/*
426	* Check if it's already active.
427	*/
428	uint32_t QueuePFN = ddi_get32(pPci->hIO, (uint32_t *)(pPci->addrIOBase + VIRTIO_PCI_QUEUE_PFN));
429	if (QueuePFN != 0)
430	{
431	LogRel((VIRTIOLOGNAME ":VirtioPciGetQueue: Queue[%d] is already used.\n", pQueue->QueueIndex));
432	return NULL;
433	}
434
435	LogFlow(("Queue[%d] has %d slots.\n", pQueue->QueueIndex, pQueue->Ring.cDesc));
436
437	/*
438	* Allocate and initialize Pci queue data.
439	*/
440	virtio_pci_queue_t *pPciQueue = RTMemAllocZ(sizeof(virtio_pci_queue_t));
441	if (pPciQueue)
442	{
443	/*
444	* Setup DMA.
445	*/
446	size_t cbQueue = VirtioRingSize(pQueue->Ring.cDesc, VIRTIO_PCI_RING_ALIGN);
447	int rc = ddi_dma_alloc_handle(pDevice->pDip, &g_VirtioPciDmaAttrRing, DDI_DMA_SLEEP, 0 /* addr */, &pPciQueue->hDMA);
448	if (rc == DDI_SUCCESS)
449	{
450	rc = ddi_dma_mem_alloc(pPciQueue->hDMA, cbQueue, &g_VirtioPciAccAttrRing, DDI_DMA_CONSISTENT,
451	DDI_DMA_SLEEP, 0 /* addr */, &pQueue->pQueue, &pPciQueue->cbBuf,
452	&pPciQueue->hIO);
453	if (rc == DDI_SUCCESS)
454	{
455	AssertRelease(pPciQueue->cbBuf >= cbQueue);
456	ddi_dma_cookie_t DmaCookie;
457	uint_t cCookies;
458	rc = ddi_dma_addr_bind_handle(pPciQueue->hDMA, NULL /* addrspace */, pQueue->pQueue, pPciQueue->cbBuf,
459	DDI_DMA_RDWR \| DDI_DMA_CONSISTENT, DDI_DMA_SLEEP,
460	0 /* addr */, &DmaCookie, &cCookies);
461	if (rc == DDI_SUCCESS)
462	{
463	pPciQueue->physBuf = DmaCookie.dmac_laddress;
464	pPciQueue->pageBuf = pPciQueue->physBuf >> VIRTIO_PCI_QUEUE_ADDR_SHIFT;
465
466	LogFlow((VIRTIOLOGNAME ":VirtioPciGetQueue: Queue[%d]%p physBuf=%x pfn of Buf %#x\n", pQueue->QueueIndex,
467	pQueue->pQueue, pPciQueue->physBuf, pPciQueue->pageBuf));
468	cmn_err(CE_NOTE, ":VirtioPciGetQueue: Queue[%d]%p physBuf=%x pfn of Buf %x\n", pQueue->QueueIndex,
469	pQueue->pQueue, pPciQueue->physBuf, pPciQueue->pageBuf);
470
471	/*
472	* Activate the queue and initialize a ring for the queue.
473	*/
474	memset(pQueue->pQueue, 0, pPciQueue->cbBuf);
475	ddi_put32(pPci->hIO, (uint32_t *)(pPci->addrIOBase + VIRTIO_PCI_QUEUE_PFN), pPciQueue->pageBuf);
476	VirtioRingInit(pQueue, pQueue->Ring.cDesc, pQueue->pQueue, VIRTIO_PCI_RING_ALIGN);
477	return pPciQueue;
478	}
479	else
480	LogRel((VIRTIOLOGNAME ":VirtioPciGetQueue: ddi_dma_addr_bind_handle failed. rc=%d\n", rc));
481
482	ddi_dma_mem_free(&pPciQueue->hIO);
483	}
484	else
485	LogRel((VIRTIOLOGNAME ":VirtioPciGetQueue: ddi_dma_mem_alloc failed for %u bytes rc=%d\n", cbQueue, rc));
486
487	ddi_dma_free_handle(&pPciQueue->hDMA);
488	}
489	else
490	LogRel((VIRTIOLOGNAME ":VirtioPciGetQueue: ddi_dma_alloc_handle failed. rc=%d\n", rc));
491
492	RTMemFree(pPciQueue);
493	}
494	else
495	LogRel((VIRTIOLOGNAME ":VirtioPciGetQueue: failed to alloc %u bytes for Pci Queue data.\n", sizeof(virtio_pci_queue_t)));
496
497	return NULL;
498	}
499
500
501	/**
502	* Set the Virtio PCI status bit.
503	*
504	* @param pDevice Pointer to the Virtio device instance.
505	* @param Status The status to set.
506	*/
507	static void VirtioPciSetStatus(PVIRTIODEVICE pDevice, uint8_t Status)
508	{
509	virtio_pci_t *pPciData = pDevice->pvHyper;
510	ddi_put8(pPciData->hIO, (uint8_t *)(pPciData->addrIOBase + VIRTIO_PCI_STATUS), Status);
511	}
512
513
514	/**
515	* Sets up IRQ for Virtio PCI.
516	*
517	* @param pDip Pointer to the device info structure.
518	*
519	* @return Solaris error code.
520	*/
521	static int VirtioPciSetupIRQ(dev_info_t *pDip)
522	{
523	LogFlow((VIRTIOLOGNAME ":VirtioPciSetupIRQ: pDip=%p\n", pDip));
524	cmn_err(CE_NOTE, "VirtioPciSetupIRQ\n");
525
526	int IntrType = 0;
527	int rc = ddi_intr_get_supported_types(pDip, &IntrType);
528	if (rc == DDI_SUCCESS)
529	{
530	/* We won't need to bother about MSIs. */
531	if (IntrType & DDI_INTR_TYPE_FIXED)
532	{
533	int IntrCount = 0;
534	rc = ddi_intr_get_nintrs(pDip, IntrType, &IntrCount);
535	if ( rc == DDI_SUCCESS
536	&& IntrCount > 0)
537	{
538	int IntrAvail = 0;
539	rc = ddi_intr_get_navail(pDip, IntrType, &IntrAvail);
540	if ( rc == DDI_SUCCESS
541	&& IntrAvail > 0)
542	{
543	/* Allocated kernel memory for the interrupt handles. The allocation size is stored internally. */
544	g_pIntr = RTMemAllocZ(IntrCount * sizeof(ddi_intr_handle_t));
545	if (g_pIntr)
546	{
547	int IntrAllocated;
548	rc = ddi_intr_alloc(pDip, g_pIntr, IntrType, 0, IntrCount, &IntrAllocated, DDI_INTR_ALLOC_NORMAL);
549	if ( rc == DDI_SUCCESS
550	&& IntrAllocated > 0)
551	{
552	g_cIntrAllocated = IntrAllocated;
553	uint_t uIntrPriority;
554	rc = ddi_intr_get_pri(g_pIntr[0], &uIntrPriority);
555	if (rc == DDI_SUCCESS)
556	{
557	/* Initialize the mutex. */
558	mutex_init(&g_IrqMtx, NULL, MUTEX_DRIVER, DDI_INTR_PRI(uIntrPriority));
559
560	/* Assign interrupt handler functions and enable interrupts. */
561	for (int i = 0; i < IntrAllocated; i++)
562	{
563	rc = ddi_intr_add_handler(g_pIntr[i], (ddi_intr_handler_t *)VirtioPciISR,
564	NULL /* No Private Data */, NULL);
565	if (rc == DDI_SUCCESS)
566	rc = ddi_intr_enable(g_pIntr[i]);
567	if (rc != DDI_SUCCESS)
568	{
569	/* Changing local IntrAllocated to hold so-far allocated handles for freeing. */
570	IntrAllocated = i;
571	break;
572	}
573	}
574	if (rc == DDI_SUCCESS)
575	{
576	cmn_err(CE_NOTE, "VirtioPciSetupIRQ success\n");
577	return rc;
578	}
579
580	/* Remove any assigned handlers */
581	LogRel((VIRTIOLOGNAME ":VirtioPciSetupIRQ failed to assign IRQs allocated=%d\n", IntrAllocated));
582	for (int x = 0; x < IntrAllocated; x++)
583	ddi_intr_remove_handler(g_pIntr[x]);
584	}
585	else
586	LogRel((VIRTIOLOGNAME ":VirtioPciSetupIRQ failed to get priority of interrupt. rc=%d\n", rc));
587
588	/* Remove allocated IRQs, too bad we can free only one handle at a time. */
589	for (int k = 0; k < g_cIntrAllocated; k++)
590	ddi_intr_free(g_pIntr[k]);
591	}
592	else
593	LogRel((VIRTIOLOGNAME ":VirtioPciSetupIRQ: failed to allocated IRQs. count=%d\n", IntrCount));
594	RTMemFree(g_pIntr);
595	}
596	else
597	LogRel((VIRTIOLOGNAME ":VirtioPciSetupIRQ: failed to allocated IRQs. count=%d\n", IntrCount));
598	}
599	else
600	{
601	LogRel((VIRTIOLOGNAME ":VirtioPciSetupIRQ: failed to get or insufficient available IRQs. rc=%d IntrAvail=%d\n",
602	rc, IntrAvail));
603	}
604	}
605	else
606	{
607	LogRel((VIRTIOLOGNAME ":VirtioPciSetupIRQ: failed to get or insufficient number of IRQs. rc=%d IntrCount=%d\n", rc,
608	IntrCount));
609	}
610	}
611	else
612	LogRel((VIRTIOLOGNAME ":VirtioPciSetupIRQ: invalid irq type. IntrType=%#x\n", IntrType));
613	}
614	else
615	LogRel((VIRTIOLOGNAME ":VirtioPciSetupIRQ: failed to get supported interrupt types\n"));
616	return rc;
617	}
618
619
620	/**
621	* Removes IRQ for Virtio PCI device.
622	*
623	* @param pDip Pointer to the device info structure.
624	*/
625	static void VirtioPciRemoveIRQ(dev_info_t *pDip)
626	{
627	LogFlow((VIRTIOLOGNAME ":VirtioPciRemoveIRQ pDip=%p:\n", pDip));
628
629	for (int i = 0; i < g_cIntrAllocated; i++)
630	{
631	int rc = ddi_intr_disable(g_pIntr[i]);
632	if (rc == DDI_SUCCESS)
633	{
634	rc = ddi_intr_remove_handler(g_pIntr[i]);
635	if (rc == DDI_SUCCESS)
636	ddi_intr_free(g_pIntr[i]);
637	}
638	}
639	RTMemFree(g_pIntr);
640	mutex_destroy(&g_IrqMtx);
641	}
642
643
644	/**
645	* Interrupt Service Routine for Virtio PCI device.
646	*
647	* @param Arg Private data (unused, will be NULL).
648	* @returns DDI_INTR_CLAIMED if it's our interrupt, DDI_INTR_UNCLAIMED if it isn't.
649	*/
650	static uint_t VirtioPciISR(caddr_t Arg)
651	{
652	LogFlow((VIRTIOLOGNAME ":VBoxGuestSolarisISR\n"));
653	cmn_err(CE_NOTE, "VBoxGuestSolarisISRd Arg=%p\n", Arg);
654
655	mutex_enter(&g_IrqMtx);
656	bool fOurIRQ = false;
657	/*
658	* Call the DeviceOps ISR routine somehow which should notify all Virtio queues
659	* on the interrupt.
660	*/
661	mutex_exit(&g_IrqMtx);
662
663	return fOurIRQ ? DDI_INTR_CLAIMED : DDI_INTR_UNCLAIMED;
664	}
665

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Additions/solaris/Virtio/VirtioPci-solaris.c

Download in other formats: