usr/src/cmd/devfsadm/i386/drm_link_i386.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 (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  * Copyright 2012 Joyent, Inc.  All rights reserved.
  25  */
  26
  27 #include <regex.h>
  28 #include <devfsadm.h>
  29 #include <stdio.h>
  30 #include <strings.h>
  31 #include <stdlib.h>
  32 #include <limits.h>
  33 #include <ctype.h>
  34
  35 /*
  36  * Note: separate from misc_link_i386.c because this will later
  37  * move to the gfx-drm gate.
  38  */
  39
  40 static int agp_process(di_minor_t minor, di_node_t node);
  41 static int drm_node(di_minor_t minor, di_node_t node);
  42
  43 static devfsadm_create_t drm_cbt[] = {
  44         { "drm", "ddi_display:drm", NULL,
  45             TYPE_EXACT, ILEVEL_0,       drm_node
  46         },
  47         { "agp", "ddi_agp:pseudo", NULL,
  48             TYPE_EXACT, ILEVEL_0, agp_process
  49         },
  50         { "agp", "ddi_agp:target", NULL,
  51             TYPE_EXACT, ILEVEL_0, agp_process
  52         },
  53         { "agp", "ddi_agp:cpugart", NULL,
  54             TYPE_EXACT, ILEVEL_0, agp_process
  55         },
  56         { "agp", "ddi_agp:master", NULL,
  57             TYPE_EXACT, ILEVEL_0, agp_process
  58         },
  59 };
  60
  61 DEVFSADM_CREATE_INIT_V0(drm_cbt);
  62
  63 /*
  64  * For debugging, run devfsadm like this:
  65  *  devfsadm -V drm_mid -V devfsadm:enum -c drm
  66  */
  67 static char *debug_mid = "drm_mid";
  68
  69 typedef enum {
  70         DRIVER_AGPPSEUDO = 0,
  71         DRIVER_AGPTARGET,
  72         DRIVER_CPUGART,
  73         DRIVER_AGPMASTER_DRM_I915,
  74         DRIVER_AGPMASTER_DRM_RADEON,
  75         DRIVER_AGPMASTER_VGATEXT,
  76         DRIVER_UNKNOWN
  77 } driver_defs_t;
  78
  79 typedef struct {
  80         char    *driver_name;
  81         int     index;
  82 } driver_name_table_entry_t;
  83
  84 static driver_name_table_entry_t driver_name_table[] = {
  85         { "agpgart",            DRIVER_AGPPSEUDO },
  86         { "agptarget",          DRIVER_AGPTARGET },
  87         { "amd64_gart",         DRIVER_CPUGART },
  88         /* AGP master device managed by drm driver */
  89         { "i915",               DRIVER_AGPMASTER_DRM_I915 },
  90         { "radeon",             DRIVER_AGPMASTER_DRM_RADEON },
  91         { "vgatext",            DRIVER_AGPMASTER_VGATEXT },
  92         { NULL,                 DRIVER_UNKNOWN }
  93 };
  94
  95 static devfsadm_enumerate_t agptarget_rules[1] =
  96         { "^agp$/^agptarget([0-9]+)$", 1, MATCH_ALL };
  97 static devfsadm_enumerate_t cpugart_rules[1] =
  98         { "^agp$/^cpugart([0-9]+)$", 1, MATCH_ALL };
  99 static devfsadm_enumerate_t agpmaster_rules[1] =
 100         { "^agp$/^agpmaster([0-9]+)$", 1, MATCH_ALL };
 101 static devfsadm_enumerate_t drm_rules[1] =
 102         { "^dri$/^card([0-9]+)$", 1, MATCH_ALL };
 103
 104
 105 /*
 106  * HOT auto cleanup of drm+agp links not desired.
 107  */
 108 static devfsadm_remove_t drm_remove_cbt[] = {
 109         { "agp", "^agpgart$", RM_POST,
 110                 ILEVEL_0, devfsadm_rm_all
 111         },
 112         { "agp", "^agp/agpmaster[0-9]+$", RM_POST,
 113                 ILEVEL_0, devfsadm_rm_all
 114         },
 115         { "agp", "^agp/agptarget[0-9]+$", RM_POST,
 116                 ILEVEL_0, devfsadm_rm_all
 117         },
 118         { "agp", "^agp/cpugart[0-9]+$", RM_POST,
 119                 ILEVEL_0, devfsadm_rm_all
 120         },
 121         { "drm", "^dri/card[0-9]+$", RM_POST,
 122                 ILEVEL_0, devfsadm_rm_all
 123         },
 124 };
 125
 126 DEVFSADM_REMOVE_INIT_V0(drm_remove_cbt);
 127
 128 static int
 129 agp_process(di_minor_t minor, di_node_t node)
 130 {
 131         char *minor_nm, *drv_nm;
 132         char *devfspath;
 133         char *I_path, *p_path, *buf;
 134         char *name = (char *)NULL;
 135         int i, index;
 136         devfsadm_enumerate_t rules[1];
 137
 138         minor_nm = di_minor_name(minor);
 139         drv_nm = di_driver_name(node);
 140
 141         if ((minor_nm == NULL) || (drv_nm == NULL)) {
 142                 return (DEVFSADM_CONTINUE);
 143         }
 144
 145         devfsadm_print(debug_mid, "agp_process: minor=%s node=%s\n",
 146             minor_nm, di_node_name(node));
 147
 148         devfspath = di_devfs_path(node);
 149         if (devfspath == NULL) {
 150                 devfsadm_print(debug_mid, "agp_process: devfspath is NULL\n");
 151                 return (DEVFSADM_CONTINUE);
 152         }
 153
 154         I_path = (char *)malloc(PATH_MAX);
 155
 156         if (I_path == NULL) {
 157                 di_devfs_path_free(devfspath);
 158                 devfsadm_print(debug_mid,  "agp_process: malloc failed\n");
 159                 return (DEVFSADM_CONTINUE);
 160         }
 161
 162         p_path = (char *)malloc(PATH_MAX);
 163
 164         if (p_path == NULL) {
 165                 devfsadm_print(debug_mid,  "agp_process: malloc failed\n");
 166                 di_devfs_path_free(devfspath);
 167                 free(I_path);
 168                 return (DEVFSADM_CONTINUE);
 169         }
 170
 171         (void) strlcpy(p_path, devfspath, PATH_MAX);
 172         (void) strlcat(p_path, ":", PATH_MAX);
 173         (void) strlcat(p_path, minor_nm, PATH_MAX);
 174         di_devfs_path_free(devfspath);
 175
 176         devfsadm_print(debug_mid, "agp_process: path %s\n", p_path);
 177
 178         for (i = 0; ; i++) {
 179                 if ((driver_name_table[i].driver_name == NULL) ||
 180                     (strcmp(drv_nm, driver_name_table[i].driver_name) == 0)) {
 181                         index = driver_name_table[i].index;
 182                         break;
 183                 }
 184         }
 185         switch (index) {
 186         case DRIVER_AGPPSEUDO:
 187                 devfsadm_print(debug_mid,
 188                     "agp_process: psdeudo driver name\n");
 189                 name = "agpgart";
 190                 (void) snprintf(I_path, PATH_MAX, "%s", name);
 191                 devfsadm_print(debug_mid,
 192                     "mklink %s -> %s\n", I_path, p_path);
 193
 194                 (void) devfsadm_mklink(I_path, node, minor, 0);
 195
 196                 free(I_path);
 197                 free(p_path);
 198                 return (DEVFSADM_CONTINUE);
 199         case DRIVER_AGPTARGET:
 200                 devfsadm_print(debug_mid,
 201                     "agp_process: target driver name\n");
 202                 rules[0] = agptarget_rules[0];
 203                 name = "agptarget";
 204                 break;
 205         case DRIVER_CPUGART:
 206                 devfsadm_print(debug_mid,
 207                     "agp_process: cpugart driver name\n");
 208                 rules[0] = cpugart_rules[0];
 209                 name = "cpugart";
 210                 break;
 211         case DRIVER_AGPMASTER_DRM_I915:
 212         case DRIVER_AGPMASTER_DRM_RADEON:
 213         case DRIVER_AGPMASTER_VGATEXT:
 214                 devfsadm_print(debug_mid,
 215                     "agp_process: agpmaster driver name\n");
 216                 rules[0] = agpmaster_rules[0];
 217                 name = "agpmaster";
 218                 break;
 219         case DRIVER_UNKNOWN:
 220                 devfsadm_print(debug_mid,
 221                     "agp_process: unknown driver name=%s\n", drv_nm);
 222                 free(I_path);
 223                 free(p_path);
 224                 return (DEVFSADM_CONTINUE);
 225         }
 226
 227         if (devfsadm_enumerate_int(p_path, 0, &buf, rules, 1)) {
 228                 devfsadm_print(debug_mid, "agp_process: exit/coninue\n");
 229                 free(I_path);
 230                 free(p_path);
 231                 return (DEVFSADM_CONTINUE);
 232         }
 233
 234
 235         (void) snprintf(I_path, PATH_MAX, "agp/%s%s", name, buf);
 236
 237         devfsadm_print(debug_mid, "agp_process: p_path=%s buf=%s\n",
 238             p_path, buf);
 239
 240         free(buf);
 241
 242         devfsadm_print(debug_mid, "mklink %s -> %s\n", I_path, p_path);
 243
 244         (void) devfsadm_mklink(I_path, node, minor, 0);
 245
 246         free(p_path);
 247         free(I_path);
 248
 249         return (DEVFSADM_CONTINUE);
 250 }
 251
 252 static int
 253 drm_node(di_minor_t minor, di_node_t node)
 254 {
 255         char *minor_nm, *drv_nm;
 256         char *devfspath;
 257         char *I_path, *p_path, *buf;
 258         char *name = "card";
 259
 260         minor_nm = di_minor_name(minor);
 261         drv_nm = di_driver_name(node);
 262         if ((minor_nm == NULL) || (drv_nm == NULL)) {
 263                 return (DEVFSADM_CONTINUE);
 264         }
 265
 266         devfsadm_print(debug_mid, "drm_node: minor=%s node=%s type=%s\n",
 267             minor_nm, di_node_name(node), di_minor_nodetype(minor));
 268
 269         devfspath = di_devfs_path(node);
 270         if (devfspath == NULL) {
 271                 devfsadm_print(debug_mid, "drm_node: devfspath is NULL\n");
 272                 return (DEVFSADM_CONTINUE);
 273         }
 274
 275         I_path = (char *)malloc(PATH_MAX);
 276
 277         if (I_path == NULL) {
 278                 di_devfs_path_free(devfspath);
 279                 devfsadm_print(debug_mid,  "drm_node: malloc failed\n");
 280                 return (DEVFSADM_CONTINUE);
 281         }
 282
 283         p_path = (char *)malloc(PATH_MAX);
 284
 285         if (p_path == NULL) {
 286                 devfsadm_print(debug_mid,  "drm_node: malloc failed\n");
 287                 di_devfs_path_free(devfspath);
 288                 free(I_path);
 289                 return (DEVFSADM_CONTINUE);
 290         }
 291
 292         (void) strlcpy(p_path, devfspath, PATH_MAX);
 293         (void) strlcat(p_path, ":", PATH_MAX);
 294         (void) strlcat(p_path, minor_nm, PATH_MAX);
 295         di_devfs_path_free(devfspath);
 296
 297         devfsadm_print(debug_mid, "drm_node: p_path %s\n", p_path);
 298
 299         if (devfsadm_enumerate_int(p_path, 0, &buf, drm_rules, 1)) {
 300                 free(p_path);
 301                 devfsadm_print(debug_mid, "drm_node: exit/coninue\n");
 302                 return (DEVFSADM_CONTINUE);
 303         }
 304         (void) snprintf(I_path, PATH_MAX, "dri/%s%s", name, buf);
 305
 306         devfsadm_print(debug_mid, "drm_node: p_path=%s buf=%s\n",
 307             p_path, buf);
 308
 309         free(buf);
 310
 311         devfsadm_print(debug_mid, "mklink %s -> %s\n", I_path, p_path);
 312         (void) devfsadm_mklink(I_path, node, minor, 0);
 313
 314         free(p_path);
 315         free(I_path);
 316
 317         return (0);
 318 }