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 */
|
---|
47 | typedef 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 */
|
---|
55 | virtual_function_t virtual_functions[] = {
|
---|
56 | #include "devices.def"
|
---|
57 | /* Terminating item */
|
---|
58 | {
|
---|
59 | .name = NULL,
|
---|
60 | .match_id = NULL
|
---|
61 | }
|
---|
62 | };
|
---|
63 |
|
---|
64 | static errno_t virt_dev_add(ddf_dev_t *dev);
|
---|
65 | static errno_t virt_dev_remove(ddf_dev_t *dev);
|
---|
66 | static errno_t virt_fun_online(ddf_fun_t *fun);
|
---|
67 | static errno_t virt_fun_offline(ddf_fun_t *fun);
|
---|
68 |
|
---|
69 | static 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 |
|
---|
76 | static driver_t virt_driver = {
|
---|
77 | .name = NAME,
|
---|
78 | .driver_ops = &virt_ops
|
---|
79 | };
|
---|
80 |
|
---|
81 | /* Device soft state */
|
---|
82 | typedef struct {
|
---|
83 | ddf_dev_t *dev;
|
---|
84 | list_t functions;
|
---|
85 | } virt_t;
|
---|
86 |
|
---|
87 | /* Function soft state */
|
---|
88 | typedef struct {
|
---|
89 | ddf_fun_t *fun;
|
---|
90 | link_t dev_link;
|
---|
91 | } virt_fun_t;
|
---|
92 |
|
---|
93 | static 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 | */
|
---|
101 | static 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 |
|
---|
149 | static 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 |
|
---|
172 | static 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 |
|
---|
205 | static 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 |
|
---|
224 | static 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 |
|
---|
230 | static 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 |
|
---|
236 | int 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 | */
|
---|