uspace/drv/test/test1/test1.c

   1 /*
   2  * Copyright (c) 2010 Vojtech Horky
   3  * Copyright (c) 2011 Jiri Svoboda
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * - Redistributions of source code must retain the above copyright
  11  *   notice, this list of conditions and the following disclaimer.
  12  * - Redistributions in binary form must reproduce the above copyright
  13  *   notice, this list of conditions and the following disclaimer in the
  14  *   documentation and/or other materials provided with the distribution.
  15  * - The name of the author may not be used to endorse or promote products
  16  *   derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 /** @file
  31  */
  32
  33 #include <assert.h>
  34 #include <stdio.h>
  35 #include <errno.h>
  36 #include <str_error.h>
  37 #include <ddf/driver.h>
  38 #include <ddf/log.h>
  39
  40 #include "test1.h"
  41
  42 static errno_t test1_dev_add(ddf_dev_t *dev);
  43 static errno_t test1_dev_remove(ddf_dev_t *dev);
  44 static errno_t test1_dev_gone(ddf_dev_t *dev);
  45 static errno_t test1_fun_online(ddf_fun_t *fun);
  46 static errno_t test1_fun_offline(ddf_fun_t *fun);
  47
  48 static driver_ops_t driver_ops = {
  49         .dev_add = &test1_dev_add,
  50         .dev_remove = &test1_dev_remove,
  51         .dev_gone = &test1_dev_gone,
  52         .fun_online = &test1_fun_online,
  53         .fun_offline = &test1_fun_offline
  54 };
  55
  56 static driver_t test1_driver = {
  57         .name = NAME,
  58         .driver_ops = &driver_ops
  59 };
  60
  61 typedef struct {
  62         ddf_fun_t *fun_a;
  63         ddf_fun_t *clone;
  64         ddf_fun_t *child;
  65 } test1_t;
  66
  67 /** Register child and inform user about it.
  68  *
  69  * @param parent Parent device.
  70  * @param message Message for the user.
  71  * @param name Device name.
  72  * @param match_id Device match id.
  73  * @param score Device match score.
  74  */
  75 static errno_t register_fun_verbose(ddf_dev_t *parent, const char *message,
  76     const char *name, const char *match_id, int match_score,
  77     errno_t expected_rc, ddf_fun_t **pfun)
  78 {
  79         ddf_fun_t *fun = NULL;
  80         errno_t rc;
  81
  82         ddf_msg(LVL_DEBUG, "Registering function `%s': %s.", name, message);
  83
  84         fun = ddf_fun_create(parent, fun_inner, name);
  85         if (fun == NULL) {
  86                 ddf_msg(LVL_ERROR, "Failed creating function %s", name);
  87                 rc = ENOMEM;
  88                 goto leave;
  89         }
  90
  91         rc = ddf_fun_add_match_id(fun, match_id, match_score);
  92         if (rc != EOK) {
  93                 ddf_msg(LVL_ERROR, "Failed adding match IDs to function %s",
  94                     name);
  95                 goto leave;
  96         }
  97
  98         rc = ddf_fun_bind(fun);
  99         if (rc != EOK) {
 100                 ddf_msg(LVL_ERROR, "Failed binding function %s: %s", name,
 101                     str_error(rc));
 102                 goto leave;
 103         }
 104
 105         ddf_msg(LVL_NOTE, "Registered child device `%s'", name);
 106         rc = EOK;
 107
 108 leave:
 109         if (rc != expected_rc) {
 110                 fprintf(stderr,
 111                     NAME ": Unexpected error registering function `%s'.\n"
 112                     NAME ":     Expected \"%s\" but got \"%s\".\n",
 113                     name, str_error(expected_rc), str_error(rc));
 114         }
 115
 116         if ((rc != EOK) && (fun != NULL)) {
 117                 ddf_fun_destroy(fun);
 118         }
 119
 120         if (pfun != NULL)
 121                 *pfun = fun;
 122
 123         return rc;
 124 }
 125
 126 /** Callback when new device is passed to this driver.
 127  * This function is the body of the test: it shall register new child
 128  * (named `clone') that shall be driven by the same task. When the clone
 129  * is added, it registers another child (named `child') that is also driven
 130  * by this task. The conditions ensure that we do not recurse indefinitely.
 131  * When successful, the device tree shall contain following fragment:
 132  *
 133  * /virtual/test1
 134  * /virtual/test1/clone
 135  * /virtual/test1/clone/child
 136  *
 137  * and the DDF shall not deadlock.
 138  *
 139  *
 140  * @param dev New device.
 141  * @return Error code reporting success of the operation.
 142  */
 143 static errno_t test1_dev_add(ddf_dev_t *dev)
 144 {
 145         ddf_fun_t *fun_a;
 146         test1_t *test1;
 147         const char *dev_name;
 148         errno_t rc;
 149
 150         dev_name = ddf_dev_get_name(dev);
 151         ddf_msg(LVL_DEBUG, "dev_add(name=\"%s\", handle=%d)",
 152             dev_name, (int) ddf_dev_get_handle(dev));
 153
 154         test1 = ddf_dev_data_alloc(dev, sizeof(test1_t));
 155         if (test1 == NULL) {
 156                 ddf_msg(LVL_ERROR, "Failed allocating soft state.\n");
 157                 rc = ENOMEM;
 158                 goto error;
 159         }
 160
 161         fun_a = ddf_fun_create(dev, fun_exposed, "a");
 162         if (fun_a == NULL) {
 163                 ddf_msg(LVL_ERROR, "Failed creating function 'a'.");
 164                 rc = ENOMEM;
 165                 goto error;
 166         }
 167
 168         test1->fun_a = fun_a;
 169
 170         rc = ddf_fun_bind(fun_a);
 171         if (rc != EOK) {
 172                 ddf_msg(LVL_ERROR, "Failed binding function 'a'.");
 173                 ddf_fun_destroy(fun_a);
 174                 goto error;
 175         }
 176
 177         ddf_fun_add_to_category(fun_a, "virtual");
 178
 179         if (str_cmp(dev_name, "test1") == 0) {
 180                 (void) register_fun_verbose(dev,
 181                     "cloning myself ;-)", "clone",
 182                     "virtual&test1", 10, EOK, &test1->clone);
 183                 (void) register_fun_verbose(dev,
 184                     "cloning myself twice ;-)", "clone",
 185                     "virtual&test1", 10, EEXIST, NULL);
 186         } else if (str_cmp(dev_name, "clone") == 0) {
 187                 (void) register_fun_verbose(dev,
 188                     "run by the same task", "child",
 189                     "virtual&test1&child", 10, EOK, &test1->child);
 190         }
 191
 192         ddf_msg(LVL_DEBUG, "Device `%s' accepted.", dev_name);
 193         return EOK;
 194 error:
 195         return rc;
 196 }
 197
 198 static errno_t fun_remove(ddf_fun_t *fun, const char *name)
 199 {
 200         errno_t rc;
 201
 202         ddf_msg(LVL_DEBUG, "fun_remove(%p, '%s')", fun, name);
 203         rc = ddf_fun_offline(fun);
 204         if (rc != EOK) {
 205                 ddf_msg(LVL_ERROR, "Error offlining function '%s'.", name);
 206                 return rc;
 207         }
 208
 209         rc = ddf_fun_unbind(fun);
 210         if (rc != EOK) {
 211                 ddf_msg(LVL_ERROR, "Failed unbinding function '%s'.", name);
 212                 return rc;
 213         }
 214
 215         ddf_fun_destroy(fun);
 216         return EOK;
 217 }
 218
 219 static errno_t fun_unbind(ddf_fun_t *fun, const char *name)
 220 {
 221         errno_t rc;
 222
 223         ddf_msg(LVL_DEBUG, "fun_unbind(%p, '%s')", fun, name);
 224         rc = ddf_fun_unbind(fun);
 225         if (rc != EOK) {
 226                 ddf_msg(LVL_ERROR, "Failed unbinding function '%s'.", name);
 227                 return rc;
 228         }
 229
 230         ddf_fun_destroy(fun);
 231         return EOK;
 232 }
 233
 234 static errno_t test1_dev_remove(ddf_dev_t *dev)
 235 {
 236         test1_t *test1 = (test1_t *)ddf_dev_data_get(dev);
 237         errno_t rc;
 238
 239         ddf_msg(LVL_DEBUG, "test1_dev_remove(%p)", dev);
 240
 241         if (test1->fun_a != NULL) {
 242                 rc = fun_remove(test1->fun_a, "a");
 243                 if (rc != EOK)
 244                         return rc;
 245         }
 246
 247         if (test1->clone != NULL) {
 248                 rc = fun_remove(test1->clone, "clone");
 249                 if (rc != EOK)
 250                         return rc;
 251         }
 252
 253         if (test1->child != NULL) {
 254                 rc = fun_remove(test1->child, "child");
 255                 if (rc != EOK)
 256                         return rc;
 257         }
 258
 259         return EOK;
 260 }
 261
 262 static errno_t test1_dev_gone(ddf_dev_t *dev)
 263 {
 264         test1_t *test1 = (test1_t *)ddf_dev_data_get(dev);
 265         errno_t rc;
 266
 267         ddf_msg(LVL_DEBUG, "test1_dev_remove(%p)", dev);
 268
 269         if (test1->fun_a != NULL) {
 270                 rc = fun_unbind(test1->fun_a, "a");
 271                 if (rc != EOK)
 272                         return rc;
 273         }
 274
 275         if (test1->clone != NULL) {
 276                 rc = fun_unbind(test1->clone, "clone");
 277                 if (rc != EOK)
 278                         return rc;
 279         }
 280
 281         if (test1->child != NULL) {
 282                 rc = fun_unbind(test1->child, "child");
 283                 if (rc != EOK)
 284                         return rc;
 285         }
 286
 287         return EOK;
 288 }
 289
 290 static errno_t test1_fun_online(ddf_fun_t *fun)
 291 {
 292         ddf_msg(LVL_DEBUG, "test1_fun_online()");
 293         return ddf_fun_online(fun);
 294 }
 295
 296 static errno_t test1_fun_offline(ddf_fun_t *fun)
 297 {
 298         ddf_msg(LVL_DEBUG, "test1_fun_offline()");
 299         return ddf_fun_offline(fun);
 300 }
 301
 302 int main(int argc, char *argv[])
 303 {
 304         printf(NAME ": HelenOS test1 virtual device driver\n");
 305         ddf_log_init(NAME);
 306         return ddf_driver_main(&test1_driver);
 307 }
 308