source: mainline/uspace/drv/root/virt/virt.c

Last change on this file was 09ab0a9a, checked in by Jiri Svoboda <jiri@…>, 7 years ago

Fix vertical spacing with new Ccheck revision.

  • Property mode set to 100644
File size: 5.7 KB
Line 
1/*
2 * Copyright (c) 2010 Vojtech Horky
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
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
15 * derived from this software without specific prior written permission.
16 *
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
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
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
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
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/**
30 * @addtogroup virt
31 * @{
32 */
33
34/** @file
35 */
36
37#include <assert.h>
38#include <stdio.h>
39#include <errno.h>
40#include <str_error.h>
41#include <ddf/driver.h>
42#include <ddf/log.h>
43
44#define NAME "virt"
45
46/** Virtual function entry */
47typedef struct {
48 /** Function name */
49 const char *name;
50 /** Function match ID */
51 const char *match_id;
52} virtual_function_t;
53
54/** List of existing virtual functions */
55virtual_function_t virtual_functions[] = {
56#include "devices.def"
57 /* Terminating item */
58 {
59 .name = NULL,
60 .match_id = NULL
61 }
62};
63
64static errno_t virt_dev_add(ddf_dev_t *dev);
65static errno_t virt_dev_remove(ddf_dev_t *dev);
66static errno_t virt_fun_online(ddf_fun_t *fun);
67static errno_t virt_fun_offline(ddf_fun_t *fun);
68
69static driver_ops_t virt_ops = {
70 .dev_add = &virt_dev_add,
71 .dev_remove = &virt_dev_remove,
72 .fun_online = &virt_fun_online,
73 .fun_offline = &virt_fun_offline
74};
75
76static driver_t virt_driver = {
77 .name = NAME,
78 .driver_ops = &virt_ops
79};
80
81/* Device soft state */
82typedef struct {
83 ddf_dev_t *dev;
84 list_t functions;
85} virt_t;
86
87/* Function soft state */
88typedef struct {
89 ddf_fun_t *fun;
90 link_t dev_link;
91} virt_fun_t;
92
93static int instances = 0;
94
95/** Add function to the virtual device.
96 *
97 * @param vdev The virtual device
98 * @param vfun Virtual function description
99 * @return EOK on success or an error code.
100 */
101static errno_t virt_add_fun(virt_t *virt, virtual_function_t *vfun)
102{
103 ddf_dev_t *vdev = virt->dev;
104 ddf_fun_t *fun;
105 virt_fun_t *rvfun;
106 errno_t rc;
107
108 ddf_msg(LVL_DEBUG, "Registering function `%s' (match \"%s\")",
109 vfun->name, vfun->match_id);
110
111 fun = ddf_fun_create(vdev, fun_inner, vfun->name);
112 if (fun == NULL) {
113 ddf_msg(LVL_ERROR, "Failed creating function %s", vfun->name);
114 return ENOMEM;
115 }
116
117 rvfun = ddf_fun_data_alloc(fun, sizeof(virt_fun_t));
118 if (rvfun == NULL) {
119 ddf_msg(LVL_ERROR, "Failed allocating soft state for %s.",
120 vfun->name);
121 ddf_fun_destroy(fun);
122 return ENOMEM;
123 }
124
125 rvfun->fun = fun;
126
127 rc = ddf_fun_add_match_id(fun, vfun->match_id, 10);
128 if (rc != EOK) {
129 ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s",
130 vfun->name);
131 ddf_fun_destroy(fun);
132 return rc;
133 }
134
135 rc = ddf_fun_bind(fun);
136 if (rc != EOK) {
137 ddf_msg(LVL_ERROR, "Failed binding function %s: %s",
138 vfun->name, str_error(rc));
139 ddf_fun_destroy(fun);
140 return rc;
141 }
142
143 list_append(&rvfun->dev_link, &virt->functions);
144
145 ddf_msg(LVL_NOTE, "Registered child device `%s'", vfun->name);
146 return EOK;
147}
148
149static errno_t virt_fun_remove(virt_fun_t *rvfun)
150{
151 errno_t rc;
152 const char *name = ddf_fun_get_name(rvfun->fun);
153
154 ddf_msg(LVL_DEBUG, "virt_fun_remove('%s')", name);
155 rc = ddf_fun_offline(rvfun->fun);
156 if (rc != EOK) {
157 ddf_msg(LVL_ERROR, "Error offlining function '%s'.", name);
158 return rc;
159 }
160
161 rc = ddf_fun_unbind(rvfun->fun);
162 if (rc != EOK) {
163 ddf_msg(LVL_ERROR, "Failed unbinding function '%s'.", name);
164 return rc;
165 }
166
167 list_remove(&rvfun->dev_link);
168 ddf_fun_destroy(rvfun->fun);
169 return EOK;
170}
171
172static errno_t virt_dev_add(ddf_dev_t *dev)
173{
174 virt_t *virt;
175
176 /*
177 * Allow only single instance of root virtual device.
178 */
179 if (++instances > 1) {
180 return ELIMIT;
181 }
182
183 ddf_msg(LVL_DEBUG, "dev_add(handle=%d)", (int)ddf_dev_get_handle(dev));
184
185 virt = ddf_dev_data_alloc(dev, sizeof(virt_t));
186 if (virt == NULL)
187 return ENOMEM;
188
189 virt->dev = dev;
190 list_initialize(&virt->functions);
191
192 /*
193 * Go through all virtual functions and try to add them.
194 * We silently ignore failures.
195 */
196 virtual_function_t *vfun = virtual_functions;
197 while (vfun->name != NULL) {
198 (void) virt_add_fun(virt, vfun);
199 vfun++;
200 }
201
202 return EOK;
203}
204
205static errno_t virt_dev_remove(ddf_dev_t *dev)
206{
207 virt_t *virt = (virt_t *)ddf_dev_data_get(dev);
208 errno_t rc;
209
210 while (!list_empty(&virt->functions)) {
211 virt_fun_t *rvfun = list_get_instance(
212 list_first(&virt->functions), virt_fun_t,
213 dev_link);
214
215 rc = virt_fun_remove(rvfun);
216 if (rc != EOK)
217 return rc;
218 }
219
220 --instances;
221 return EOK;
222}
223
224static errno_t virt_fun_online(ddf_fun_t *fun)
225{
226 ddf_msg(LVL_DEBUG, "virt_fun_online()");
227 return ddf_fun_online(fun);
228}
229
230static errno_t virt_fun_offline(ddf_fun_t *fun)
231{
232 ddf_msg(LVL_DEBUG, "virt_fun_offline()");
233 return ddf_fun_offline(fun);
234}
235
236int main(int argc, char *argv[])
237{
238 printf(NAME ": HelenOS virtual devices root driver\n");
239
240 ddf_log_init(NAME);
241 return ddf_driver_main(&virt_driver);
242}
243
244/**
245 * @}
246 */
Note: See TracBrowser for help on using the repository browser.