usr/src/lib/efcode/fcdriver/upload.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2000 by Sun Microsystems, Inc.
  24  * All rights reserved.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 #include <sys/stat.h>
  30 #include <fcntl.h>
  31 #include <unistd.h>
  32 #include <stdlib.h>
  33 #include <stdio.h>
  34 #include <strings.h>
  35 #include <fcntl.h>
  36
  37 #include <fcode/private.h>
  38 #include <fcode/log.h>
  39
  40 #include <fcdriver/fcdriver.h>
  41
  42 static void
  43 create_node(fcode_env_t *env, device_t *d)
  44 {
  45         int error;
  46         prop_t *p;
  47         instance_t *ih;
  48         char *service = FC_NEW_DEVICE;
  49         private_data_t *pd, *ppd;
  50         char *unit_str;
  51
  52         pd = (private_data_t *)d->private;
  53         ppd = (private_data_t *)d->parent->private;
  54
  55         ih = MYSELF;
  56         MYSELF = open_instance_chain(env, d, 0);
  57         p = lookup_package_property(env, "name", d);
  58         if (p == NULL) {
  59                 forth_abort(env, "create_node: '%s' name prop not found\n",
  60                     get_path(env, d));
  61         }
  62
  63         debug_msg(DEBUG_UPLOAD, "Create Node: %p\n", pd->node);
  64         debug_msg(DEBUG_UPLOAD, " Device Name: '%s'\n", p->data);
  65         debug_msg(DEBUG_UPLOAD, " Parent     : %p\n", ppd->node);
  66
  67         my_unit(env);
  68         (void) call_my_parent(env, "encode-unit");
  69         unit_str = pop_a_duped_string(env, NULL);
  70         if (unit_str == NULL) {
  71                 unit_str = STRDUP("");
  72         }
  73
  74         debug_msg(DEBUG_UPLOAD, " Unit Addr  : '%s'\n", unit_str);
  75
  76         error = fc_run_priv(pd->common, FC_NEW_DEVICE, 4, 0,
  77             fc_phandle2cell(pd->node), fc_phandle2cell(ppd->node),
  78             fc_ptr2cell(unit_str), fc_ptr2cell(p->data));
  79
  80         FREE(unit_str);
  81         close_instance_chain(env, MYSELF, 0);
  82         MYSELF = ih;
  83
  84         if (error)
  85                 log_message(MSG_ERROR, "%s: parent: '%s' new: '%s'\n", service,
  86                     get_path(env, d->parent), p->data);
  87 }
  88
  89 static void
  90 finish_node(fcode_env_t *env, device_t *d)
  91 {
  92         private_data_t *pd;
  93         int error;
  94
  95         pd = (private_data_t *)d->private;
  96
  97         debug_msg(DEBUG_UPLOAD, "Finish Node: %p\n", pd->node);
  98
  99         error = fc_run_priv(pd->common, FC_FINISH_DEVICE, 1, 0,
 100             fc_phandle2cell(pd->node));
 101         if (error)
 102                 log_message(MSG_ERROR, "%s: failed\n", FC_FINISH_DEVICE);
 103 }
 104
 105 static void
 106 upload_properties(fcode_env_t *env, device_t *d)
 107 {
 108         prop_t *p;
 109         private_data_t *pd;
 110         int error;
 111
 112         pd = (private_data_t *)d->private;
 113         debug_msg(DEBUG_UPLOAD, "Upload Properties: node %p upload: %d\n",
 114             pd->node, pd->upload);
 115
 116         if (!pd->upload)
 117                 return;
 118
 119         for (p = d->properties; p; p = p->next) {
 120                 DEBUGF(UPLOAD, print_property(env, p, " Upload: "));
 121
 122                 error = fc_run_priv(pd->common, FC_CREATE_PROPERTY, 4, 0,
 123                     fc_phandle2cell(pd->node), fc_int2cell(p->size),
 124                     fc_ptr2cell(p->data), fc_ptr2cell(p->name));
 125
 126                 if (error)
 127                         log_message(MSG_ERROR, "%s: '%s' failed\n",
 128                             FC_CREATE_PROPERTY, p->name);
 129         }
 130 }
 131
 132 static void
 133 upload_node(fcode_env_t *env, device_t *d)
 134 {
 135         private_data_t *pd = (private_data_t *)d->private;
 136
 137         if (pd) {
 138                 debug_msg(DEBUG_UPLOAD, "Upload Node: dev: %p node: %p"
 139                     " upload: %d\n", d, pd->node, pd->upload);
 140                 if (pd->upload) {
 141                         create_node(env, d);
 142                         upload_properties(env, d);
 143                         finish_node(env, d);
 144                 }
 145         } else
 146                 debug_msg(DEBUG_UPLOAD, "Upload Node: dev: %p NULL private\n",
 147                     d);
 148 }
 149
 150 void
 151 upload_nodes(fcode_env_t *env)
 152 {
 153         debug_msg(DEBUG_UPLOAD, "Upload Nodes: Recursing Tree\n");
 154         recurse_tree(env, env->root_node, upload_node);
 155 }
 156
 157 void
 158 validate_nodes(fcode_env_t *env)
 159 {
 160         int error;
 161         common_data_t *cdp = env->private;
 162
 163         error = ioctl(cdp->fcode_fd, FC_VALIDATE);
 164 }
 165
 166 #pragma init(_init)
 167
 168 static void
 169 _init(void)
 170 {
 171         fcode_env_t *env = initial_env;
 172
 173         ASSERT(env);
 174         NOTICE;
 175
 176         FORTH(0,        "upload-nodes",         upload_nodes);
 177         FORTH(0,        "validate-nodes",       validate_nodes);
 178 }