WebSVN – HelenOS – Diff – /branches/dynload/kernel/arch/sparc64/src/drivers/pci.c


/*
 * Copyright (c) 2006 Jakub Jermar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup sparc64
 * @{
 */
/**
 * @file
 * @brief   PCI driver.
 */
 
#include <arch/drivers/pci.h>
#include <genarch/ofw/ofw_tree.h>
#include <arch/trap/interrupt.h>
#include <mm/page.h>
#include <mm/slab.h>
#include <arch/types.h>
#include <debug.h>
#include <print.h>
#include <func.h>
#include <arch/asm.h>
#include <sysinfo/sysinfo.h>
 
#define SABRE_INTERNAL_REG  0
#define PSYCHO_INTERNAL_REG 2   
 
#define OBIO_IMR_BASE   0x200
#define OBIO_IMR(ino)   (OBIO_IMR_BASE + ((ino) & INO_MASK))
 
#define OBIO_CIR_BASE   0x300
#define OBIO_CIR(ino)   (OBIO_CIR_BASE + ((ino) & INO_MASK))
 
static void obio_enable_interrupt(pci_t *, int);
static void obio_clear_interrupt(pci_t *, int);
 
static pci_t *pci_sabre_init(ofw_tree_node_t *);
static pci_t *pci_psycho_init(ofw_tree_node_t *);
 
/** PCI operations for Sabre model. */
static pci_operations_t pci_sabre_ops = {
    .enable_interrupt = obio_enable_interrupt,
    .clear_interrupt = obio_clear_interrupt
};
/** PCI operations for Psycho model. */
static pci_operations_t pci_psycho_ops = {
    .enable_interrupt = obio_enable_interrupt,
    .clear_interrupt = obio_clear_interrupt
};
 
/** Initialize PCI controller (model Sabre).
 *
 * @param node      OpenFirmware device tree node of the Sabre.
 *
 * @return      Address of the initialized PCI structure.
 */
pci_t *pci_sabre_init(ofw_tree_node_t *node)
{
    pci_t *pci;
    ofw_tree_property_t *prop;
 
    /*
     * Get registers.
     */
    prop = ofw_tree_getprop(node, "reg");
    if (!prop || !prop->value)
        return NULL;
 
    ofw_upa_reg_t *reg = prop->value;
    count_t regs = prop->size / sizeof(ofw_upa_reg_t);
 
    if (regs < SABRE_INTERNAL_REG + 1)
        return NULL;
 
    uintptr_t paddr;
    if (!ofw_upa_apply_ranges(node->parent, &reg[SABRE_INTERNAL_REG],
        &paddr))
        return NULL;
 
    pci = (pci_t *) malloc(sizeof(pci_t), FRAME_ATOMIC);
    if (!pci)
        return NULL;
 
    pci->model = PCI_SABRE;
    pci->op = &pci_sabre_ops;
    pci->reg = (uint64_t *) hw_map(paddr, reg[SABRE_INTERNAL_REG].size);
 
    /*
     * Set sysinfo data needed by the uspace OBIO driver.
     */
    sysinfo_set_item_val("obio.base.physical", NULL, paddr);
    sysinfo_set_item_val("kbd.cir.obio", NULL, 1);
 
    return pci;
}
 
 
/** Initialize the Psycho PCI controller.
 *
 * @param node      OpenFirmware device tree node of the Psycho.
 *
 * @return      Address of the initialized PCI structure.
 */
pci_t *pci_psycho_init(ofw_tree_node_t *node)
{
    pci_t *pci;
    ofw_tree_property_t *prop;
 
    /*
     * Get registers.
     */
    prop = ofw_tree_getprop(node, "reg");
    if (!prop || !prop->value)
        return NULL;
 
    ofw_upa_reg_t *reg = prop->value;
    count_t regs = prop->size / sizeof(ofw_upa_reg_t);
 
    if (regs < PSYCHO_INTERNAL_REG + 1)
        return NULL;
 
    uintptr_t paddr;
    if (!ofw_upa_apply_ranges(node->parent, &reg[PSYCHO_INTERNAL_REG],
        &paddr))
        return NULL;
 
    pci = (pci_t *) malloc(sizeof(pci_t), FRAME_ATOMIC);
    if (!pci)
        return NULL;
 
    pci->model = PCI_PSYCHO;
    pci->op = &pci_psycho_ops;
    pci->reg = (uint64_t *) hw_map(paddr, reg[PSYCHO_INTERNAL_REG].size);
 
    /*
     * Set sysinfo data needed by the uspace OBIO driver.
     */
    sysinfo_set_item_val("obio.base.physical", NULL, paddr);
    sysinfo_set_item_val("kbd.cir.obio", NULL, 1);
 
    return pci;
}
 
void obio_enable_interrupt(pci_t *pci, int inr)
{
    pci->reg[OBIO_IMR(inr & INO_MASK)] |= IMAP_V_MASK;
}
 
void obio_clear_interrupt(pci_t *pci, int inr)
{
    pci->reg[OBIO_CIR(inr & INO_MASK)] = 0; /* set IDLE */
}
 
/** Initialize PCI controller. */
pci_t *pci_init(ofw_tree_node_t *node)
{
    ofw_tree_property_t *prop;
 
    /*
     * First, verify this is a PCI node.
     */
    ASSERT(strcmp(ofw_tree_node_name(node), "pci") == 0);
 
    /*
     * Determine PCI controller model.
     */
    prop = ofw_tree_getprop(node, "model");
    if (!prop || !prop->value)
        return NULL;
   
    if (strcmp(prop->value, "SUNW,sabre") == 0) {
        /*
         * PCI controller Sabre.
         * This model is found on UltraSPARC IIi based machines.
         */
        return pci_sabre_init(node);
    } else if (strcmp(prop->value, "SUNW,psycho") == 0) {
        /*
         * PCI controller Psycho.
         * Used on UltraSPARC II based processors, for instance,
         * on Ultra 60.
         */
        return pci_psycho_init(node);
    } else {
        /*
         * Unsupported model.
         */
        printf("Unsupported PCI controller model (%s).\n", prop->value);
    }
 
    return NULL;
}
 
void pci_enable_interrupt(pci_t *pci, int inr)
{
    ASSERT(pci->op && pci->op->enable_interrupt);
    pci->op->enable_interrupt(pci, inr);
}
 
void pci_clear_interrupt(void *pcip, int inr)
{
    pci_t *pci = (pci_t *)pcip;
 
    ASSERT(pci->op && pci->op->clear_interrupt);
    pci->op->clear_interrupt(pci, inr);
}
 
/** @}
 */
 

Rev 3674	Rev 4344
1	/*	1	/*
2	* Copyright (c) 2006 Jakub Jermar	2	* Copyright (c) 2006 Jakub Jermar
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup sparc64	29	/** @addtogroup sparc64
30	* @{	30	* @{
31	*/	31	*/
32	/**	32	/**
33	* @file	33	* @file
34	* @brief PCI driver.	34	* @brief PCI driver.
35	*/	35	*/
36		36
37	#include <arch/drivers/pci.h>	37	#include <arch/drivers/pci.h>
38	#include <genarch/ofw/ofw_tree.h>	38	#include <genarch/ofw/ofw_tree.h>
39	#include <arch/trap/interrupt.h>	39	#include <arch/trap/interrupt.h>
40	#include <mm/page.h>	40	#include <mm/page.h>
41	#include <mm/slab.h>	41	#include <mm/slab.h>
42	#include <arch/types.h>	42	#include <arch/types.h>
43	#include <debug.h>	43	#include <debug.h>
44	#include <print.h>	44	#include <print.h>
45	#include <func.h>	45	#include <func.h>
46	#include <arch/asm.h>	46	#include <arch/asm.h>
-		47	#include <sysinfo/sysinfo.h>
47		48
48	#define SABRE_INTERNAL_REG 0	49	#define SABRE_INTERNAL_REG 0
49	#define PSYCHO_INTERNAL_REG 2	50	#define PSYCHO_INTERNAL_REG 2
50		51
51	#define OBIO_IMR_BASE 0x200	52	#define OBIO_IMR_BASE 0x200
52	#define OBIO_IMR(ino) (OBIO_IMR_BASE + ((ino) & INO_MASK))	53	#define OBIO_IMR(ino) (OBIO_IMR_BASE + ((ino) & INO_MASK))
53		54
54	#define OBIO_CIR_BASE 0x300	55	#define OBIO_CIR_BASE 0x300
55	#define OBIO_CIR(ino) (OBIO_CIR_BASE + ((ino) & INO_MASK))	56	#define OBIO_CIR(ino) (OBIO_CIR_BASE + ((ino) & INO_MASK))
56		57
57	static void obio_enable_interrupt(pci_t *, int);	58	static void obio_enable_interrupt(pci_t *, int);
58	static void obio_clear_interrupt(pci_t *, int);	59	static void obio_clear_interrupt(pci_t *, int);
59		60
60	static pci_t pci_sabre_init(ofw_tree_node_t );	61	static pci_t pci_sabre_init(ofw_tree_node_t );
61	static pci_t pci_psycho_init(ofw_tree_node_t );	62	static pci_t pci_psycho_init(ofw_tree_node_t );
62		63
63	/** PCI operations for Sabre model. */	64	/** PCI operations for Sabre model. */
64	static pci_operations_t pci_sabre_ops = {	65	static pci_operations_t pci_sabre_ops = {
65	.enable_interrupt = obio_enable_interrupt,	66	.enable_interrupt = obio_enable_interrupt,
66	.clear_interrupt = obio_clear_interrupt	67	.clear_interrupt = obio_clear_interrupt
67	};	68	};
68	/** PCI operations for Psycho model. */	69	/** PCI operations for Psycho model. */
69	static pci_operations_t pci_psycho_ops = {	70	static pci_operations_t pci_psycho_ops = {
70	.enable_interrupt = obio_enable_interrupt,	71	.enable_interrupt = obio_enable_interrupt,
71	.clear_interrupt = obio_clear_interrupt	72	.clear_interrupt = obio_clear_interrupt
72	};	73	};
73		74
74	/** Initialize PCI controller (model Sabre).	75	/** Initialize PCI controller (model Sabre).
75	*	76	*
76	* @param node OpenFirmware device tree node of the Sabre.	77	* @param node OpenFirmware device tree node of the Sabre.
77	*	78	*
78	* @return Address of the initialized PCI structure.	79	* @return Address of the initialized PCI structure.
79	*/	80	*/
80	pci_t pci_sabre_init(ofw_tree_node_t node)	81	pci_t pci_sabre_init(ofw_tree_node_t node)
81	{	82	{
82	pci_t *pci;	83	pci_t *pci;
83	ofw_tree_property_t *prop;	84	ofw_tree_property_t *prop;
84		85
85	/*	86	/*
86	* Get registers.	87	* Get registers.
87	*/	88	*/
88	prop = ofw_tree_getprop(node, "reg");	89	prop = ofw_tree_getprop(node, "reg");
89	if (!prop \|\| !prop->value)	90	if (!prop \|\| !prop->value)
90	return NULL;	91	return NULL;
91		92
92	ofw_upa_reg_t *reg = prop->value;	93	ofw_upa_reg_t *reg = prop->value;
93	count_t regs = prop->size / sizeof(ofw_upa_reg_t);	94	count_t regs = prop->size / sizeof(ofw_upa_reg_t);
94		95
95	if (regs < SABRE_INTERNAL_REG + 1)	96	if (regs < SABRE_INTERNAL_REG + 1)
96	return NULL;	97	return NULL;
97		98
98	uintptr_t paddr;	99	uintptr_t paddr;
99	if (!ofw_upa_apply_ranges(node->parent, &reg[SABRE_INTERNAL_REG],	100	if (!ofw_upa_apply_ranges(node->parent, &reg[SABRE_INTERNAL_REG],
100	&paddr))	101	&paddr))
101	return NULL;	102	return NULL;
102		103
103	pci = (pci_t *) malloc(sizeof(pci_t), FRAME_ATOMIC);	104	pci = (pci_t *) malloc(sizeof(pci_t), FRAME_ATOMIC);
104	if (!pci)	105	if (!pci)
105	return NULL;	106	return NULL;
106		107
107	pci->model = PCI_SABRE;	108	pci->model = PCI_SABRE;
108	pci->op = &pci_sabre_ops;	109	pci->op = &pci_sabre_ops;
109	pci->reg = (uint64_t *) hw_map(paddr, reg[SABRE_INTERNAL_REG].size);	110	pci->reg = (uint64_t *) hw_map(paddr, reg[SABRE_INTERNAL_REG].size);
110		111
-		112	/*
-		113	* Set sysinfo data needed by the uspace OBIO driver.
-		114	*/
-		115	sysinfo_set_item_val("obio.base.physical", NULL, paddr);
-		116	sysinfo_set_item_val("kbd.cir.obio", NULL, 1);
-		117
111	return pci;	118	return pci;
112	}	119	}
113		120
114		121
115	/** Initialize the Psycho PCI controller.	122	/** Initialize the Psycho PCI controller.
116	*	123	*
117	* @param node OpenFirmware device tree node of the Psycho.	124	* @param node OpenFirmware device tree node of the Psycho.
118	*	125	*
119	* @return Address of the initialized PCI structure.	126	* @return Address of the initialized PCI structure.
120	*/	127	*/
121	pci_t pci_psycho_init(ofw_tree_node_t node)	128	pci_t pci_psycho_init(ofw_tree_node_t node)
122	{	129	{
123	pci_t *pci;	130	pci_t *pci;
124	ofw_tree_property_t *prop;	131	ofw_tree_property_t *prop;
125		132
126	/*	133	/*
127	* Get registers.	134	* Get registers.
128	*/	135	*/
129	prop = ofw_tree_getprop(node, "reg");	136	prop = ofw_tree_getprop(node, "reg");
130	if (!prop \|\| !prop->value)	137	if (!prop \|\| !prop->value)
131	return NULL;	138	return NULL;
132		139
133	ofw_upa_reg_t *reg = prop->value;	140	ofw_upa_reg_t *reg = prop->value;
134	count_t regs = prop->size / sizeof(ofw_upa_reg_t);	141	count_t regs = prop->size / sizeof(ofw_upa_reg_t);
135		142
136	if (regs < PSYCHO_INTERNAL_REG + 1)	143	if (regs < PSYCHO_INTERNAL_REG + 1)
137	return NULL;	144	return NULL;
138		145
139	uintptr_t paddr;	146	uintptr_t paddr;
140	if (!ofw_upa_apply_ranges(node->parent, &reg[PSYCHO_INTERNAL_REG],	147	if (!ofw_upa_apply_ranges(node->parent, &reg[PSYCHO_INTERNAL_REG],
141	&paddr))	148	&paddr))
142	return NULL;	149	return NULL;
143		150
144	pci = (pci_t *) malloc(sizeof(pci_t), FRAME_ATOMIC);	151	pci = (pci_t *) malloc(sizeof(pci_t), FRAME_ATOMIC);
145	if (!pci)	152	if (!pci)
146	return NULL;	153	return NULL;
147		154
148	pci->model = PCI_PSYCHO;	155	pci->model = PCI_PSYCHO;
149	pci->op = &pci_psycho_ops;	156	pci->op = &pci_psycho_ops;
150	pci->reg = (uint64_t *) hw_map(paddr, reg[PSYCHO_INTERNAL_REG].size);	157	pci->reg = (uint64_t *) hw_map(paddr, reg[PSYCHO_INTERNAL_REG].size);
151		158
-		159	/*
-		160	* Set sysinfo data needed by the uspace OBIO driver.
-		161	*/
-		162	sysinfo_set_item_val("obio.base.physical", NULL, paddr);
-		163	sysinfo_set_item_val("kbd.cir.obio", NULL, 1);
-		164
152	return pci;	165	return pci;
153	}	166	}
154		167
155	void obio_enable_interrupt(pci_t *pci, int inr)	168	void obio_enable_interrupt(pci_t *pci, int inr)
156	{	169	{
157	pci->reg[OBIO_IMR(inr & INO_MASK)] \|= IMAP_V_MASK;	170	pci->reg[OBIO_IMR(inr & INO_MASK)] \|= IMAP_V_MASK;
158	}	171	}
159		172
160	void obio_clear_interrupt(pci_t *pci, int inr)	173	void obio_clear_interrupt(pci_t *pci, int inr)
161	{	174	{
162	pci->reg[OBIO_CIR(inr & INO_MASK)] = 0; /* set IDLE */	175	pci->reg[OBIO_CIR(inr & INO_MASK)] = 0; /* set IDLE */
163	}	176	}
164		177
165	/** Initialize PCI controller. */	178	/** Initialize PCI controller. */
166	pci_t pci_init(ofw_tree_node_t node)	179	pci_t pci_init(ofw_tree_node_t node)
167	{	180	{
168	ofw_tree_property_t *prop;	181	ofw_tree_property_t *prop;
169		182
170	/*	183	/*
171	* First, verify this is a PCI node.	184	* First, verify this is a PCI node.
172	*/	185	*/
173	ASSERT(strcmp(ofw_tree_node_name(node), "pci") == 0);	186	ASSERT(strcmp(ofw_tree_node_name(node), "pci") == 0);
174		187
175	/*	188	/*
176	* Determine PCI controller model.	189	* Determine PCI controller model.
177	*/	190	*/
178	prop = ofw_tree_getprop(node, "model");	191	prop = ofw_tree_getprop(node, "model");
179	if (!prop \|\| !prop->value)	192	if (!prop \|\| !prop->value)
180	return NULL;	193	return NULL;
181		194
182	if (strcmp(prop->value, "SUNW,sabre") == 0) {	195	if (strcmp(prop->value, "SUNW,sabre") == 0) {
183	/*	196	/*
184	* PCI controller Sabre.	197	* PCI controller Sabre.
185	* This model is found on UltraSPARC IIi based machines.	198	* This model is found on UltraSPARC IIi based machines.
186	*/	199	*/
187	return pci_sabre_init(node);	200	return pci_sabre_init(node);
188	} else if (strcmp(prop->value, "SUNW,psycho") == 0) {	201	} else if (strcmp(prop->value, "SUNW,psycho") == 0) {
189	/*	202	/*
190	* PCI controller Psycho.	203	* PCI controller Psycho.
191	* Used on UltraSPARC II based processors, for instance,	204	* Used on UltraSPARC II based processors, for instance,
192	* on Ultra 60.	205	* on Ultra 60.
193	*/	206	*/
194	return pci_psycho_init(node);	207	return pci_psycho_init(node);
195	} else {	208	} else {
196	/*	209	/*
197	* Unsupported model.	210	* Unsupported model.
198	*/	211	*/
199	printf("Unsupported PCI controller model (%s).\n", prop->value);	212	printf("Unsupported PCI controller model (%s).\n", prop->value);
200	}	213	}
201		214
202	return NULL;	215	return NULL;
203	}	216	}
204		217
205	void pci_enable_interrupt(pci_t *pci, int inr)	218	void pci_enable_interrupt(pci_t *pci, int inr)
206	{	219	{
207	ASSERT(pci->op && pci->op->enable_interrupt);	220	ASSERT(pci->op && pci->op->enable_interrupt);
208	pci->op->enable_interrupt(pci, inr);	221	pci->op->enable_interrupt(pci, inr);
209	}	222	}
210		223
211	void pci_clear_interrupt(void *pcip, int inr)	224	void pci_clear_interrupt(void *pcip, int inr)
212	{	225	{
213	pci_t pci = (pci_t )pcip;	226	pci_t pci = (pci_t )pcip;
214		227
215	ASSERT(pci->op && pci->op->clear_interrupt);	228	ASSERT(pci->op && pci->op->clear_interrupt);
216	pci->op->clear_interrupt(pci, inr);	229	pci->op->clear_interrupt(pci, inr);
217	}	230	}
218		231
219	/** @}	232	/** @}
220	*/	233	*/
221		234

Subversion Repositories HelenOS

(root)/branches/dynload/kernel/arch/sparc64/src/drivers/pci.c – Rev 3674 → 4344