Print this page
NEX-17521 Unable to install Nexentastor on Lenovo SR650 platform
8702 PCI addresses with physaddr > 0xffffffff can't be mapped in
8703 pci/npe DDI_CTLOPS_REGSIZE should be 64-bit aware
8704 want OFF_MAX in the kernel
8705 unsupported 64-bit prefetch memory on pci-pci bridge
Contributed by: Robert Mustacchi <rm@joyent.com>
Reviewed by: Patrick Mooney <patrick.mooney@joyent.com>
Reviewed by: Jerry Jelinek <jerry.jelinek@joyent.com>
Reviewed by: Albert Lee <trisk@forkgnu.org>
9550 Create hub symlinks for xhci devices
Contributed by: Alexander Pyhalov <apyhalov@gmail.com>
Reviewed by: Andy Stormont <astormont@racktopsystems.com>
Reviewed by: Robert Mustacchi <rm@joyent.com>
Reviewed by: Toomas Soome <tsoome@me.com>
Reviewed by: Yuri Pankov <yuri.pankov@nexenta.com>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/devfsadm/usb_link.c
+++ new/usr/src/cmd/devfsadm/usb_link.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 *
21 21 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
22 22 * Use is subject to license terms.
23 23 */
24 24
25 25 #include <devfsadm.h>
26 26 #include <stdio.h>
27 27 #include <stdlib.h>
28 28 #include <limits.h>
29 29 #include <string.h>
30 30 #include <unistd.h>
31 31 #include <sys/types.h>
32 32 #include <sys/stat.h>
33 33 #include <strings.h>
34 34
35 35 extern char *devfsadm_get_devices_dir();
36 36 static int usb_process(di_minor_t minor, di_node_t node);
37 37
38 38 static void ugen_create_link(char *p_path, char *node_name,
39 39 di_node_t node, di_minor_t minor);
40 40
41 41
42 42 /* Rules for creating links */
43 43 static devfsadm_create_t usb_cbt[] = {
44 44 { "usb", NULL, "usb_ac", DRV_EXACT,
45 45 ILEVEL_0, usb_process },
46 46 { "usb", NULL, "usb_as", DRV_EXACT,
47 47 ILEVEL_0, usb_process },
48 48 { "usb", NULL, "ddivs_usbc", DRV_EXACT,
49 49 ILEVEL_0, usb_process },
50 50 { "usb", NULL, "usbvc", DRV_EXACT,
51 51 ILEVEL_0, usb_process },
52 52 { "usb", NULL, "hid", DRV_EXACT,
53 53 ILEVEL_0, usb_process },
|
↓ open down ↓ |
53 lines elided |
↑ open up ↑ |
54 54 { "usb", NULL, "hwarc", DRV_EXACT,
55 55 ILEVEL_0, usb_process },
56 56 { "usb", NULL, "wusb_ca", DRV_EXACT,
57 57 ILEVEL_0, usb_process },
58 58 { "usb", DDI_NT_NEXUS, "hubd", DRV_EXACT|TYPE_EXACT,
59 59 ILEVEL_0, usb_process },
60 60 { "usb", DDI_NT_NEXUS, "ohci", DRV_EXACT|TYPE_EXACT,
61 61 ILEVEL_0, usb_process },
62 62 { "usb", DDI_NT_NEXUS, "ehci", DRV_EXACT|TYPE_EXACT,
63 63 ILEVEL_0, usb_process },
64 + { "usb", DDI_NT_NEXUS, "xhci", DRV_EXACT|TYPE_EXACT,
65 + ILEVEL_0, usb_process },
64 66 { "usb", DDI_NT_SCSI_NEXUS, "scsa2usb", DRV_EXACT|TYPE_EXACT,
65 67 ILEVEL_0, usb_process },
66 68 { "usb", DDI_NT_UGEN, "scsa2usb", DRV_EXACT|TYPE_EXACT,
67 69 ILEVEL_0, usb_process },
68 70 { "usb", DDI_NT_NEXUS, "uhci", DRV_EXACT|TYPE_EXACT,
69 71 ILEVEL_0, usb_process },
70 72 { "usb", DDI_NT_UGEN, "ugen", DRV_EXACT|TYPE_EXACT,
71 73 ILEVEL_0, usb_process },
72 74 { "usb", DDI_NT_NEXUS, "usb_mid", DRV_EXACT|TYPE_EXACT,
73 75 ILEVEL_0, usb_process },
74 76 { "usb", DDI_NT_UGEN, "usb_mid", DRV_EXACT|TYPE_EXACT,
75 77 ILEVEL_0, usb_process },
76 78 { "usb", DDI_NT_PRINTER, "usbprn", DRV_EXACT|TYPE_EXACT,
77 79 ILEVEL_0, usb_process },
78 80 { "usb", DDI_NT_UGEN, "usbprn", DRV_EXACT|TYPE_EXACT,
79 81 ILEVEL_0, usb_process },
80 82 { "usb", DDI_NT_NEXUS, "hwahc", DRV_EXACT|TYPE_EXACT,
81 83 ILEVEL_0, usb_process },
82 84 };
83 85
84 86 /* For debug printing (-V filter) */
85 87 static char *debug_mid = "usb_mid";
86 88
87 89 DEVFSADM_CREATE_INIT_V0(usb_cbt);
88 90
89 91 /* USB device links */
90 92 #define USB_LINK_RE_AUDIO "^usb/audio[0-9]+$"
91 93 #define USB_LINK_RE_AUDIOMUX "^usb/audio-mux[0-9]+$"
92 94 #define USB_LINK_RE_AUDIOCTL "^usb/audio-control[0-9]+$"
93 95 #define USB_LINK_RE_AUDIOSTREAM "^usb/audio-stream[0-9]+$"
94 96 #define USB_LINK_RE_DDIVS_USBC "^usb/ddivs_usbc[0-9]+$"
95 97 #define USB_LINK_RE_VIDEO "^usb/video[0-9]+$"
96 98 #define USB_LINK_RE_VIDEO2 "^video[0-9]+$"
97 99 #define USB_LINK_RE_DEVICE "^usb/device[0-9]+$"
98 100 #define USB_LINK_RE_HID "^usb/hid[0-9]+$"
99 101 #define USB_LINK_RE_HUB "^usb/hub[0-9]+$"
100 102 #define USB_LINK_RE_MASS_STORE "^usb/mass-storage[0-9]+$"
101 103 #define USB_LINK_RE_UGEN "^usb/[0-9,a-f]+\\.[0-9,a-f]+/[0-9]+/.+$"
102 104 #define USB_LINK_RE_USBPRN "^usb/printer[0-9]+$"
103 105 #define USB_LINK_RE_WHOST "^usb/whost[0-9]+$"
104 106 #define USB_LINK_RE_HWARC "^usb/hwarc[0-9]+$"
105 107 #define USB_LINK_RE_WUSB_CA "^usb/wusb_ca[0-9]+$"
106 108
107 109 /* Rules for removing links */
108 110 static devfsadm_remove_t usb_remove_cbt[] = {
109 111 { "usb", USB_LINK_RE_AUDIO, RM_POST | RM_HOT | RM_ALWAYS, ILEVEL_0,
110 112 devfsadm_rm_all },
111 113 { "usb", USB_LINK_RE_AUDIOMUX, RM_POST | RM_HOT | RM_ALWAYS, ILEVEL_0,
112 114 devfsadm_rm_all },
113 115 { "usb", USB_LINK_RE_AUDIOCTL, RM_POST | RM_HOT | RM_ALWAYS, ILEVEL_0,
114 116 devfsadm_rm_all },
115 117 { "usb", USB_LINK_RE_AUDIOSTREAM, RM_POST | RM_HOT | RM_ALWAYS,
116 118 ILEVEL_0, devfsadm_rm_all },
117 119 { "usb", USB_LINK_RE_DDIVS_USBC, RM_POST | RM_HOT | RM_ALWAYS,
118 120 ILEVEL_0, devfsadm_rm_all },
119 121 { "usb", USB_LINK_RE_VIDEO2, RM_POST | RM_HOT | RM_ALWAYS, ILEVEL_0,
120 122 devfsadm_rm_all },
121 123 { "usb", USB_LINK_RE_VIDEO, RM_POST | RM_HOT | RM_ALWAYS, ILEVEL_0,
122 124 devfsadm_rm_all },
123 125 { "usb", USB_LINK_RE_DEVICE, RM_POST | RM_HOT, ILEVEL_0,
124 126 devfsadm_rm_all },
125 127 { "usb", USB_LINK_RE_HID, RM_POST | RM_HOT | RM_ALWAYS, ILEVEL_0,
126 128 devfsadm_rm_all },
127 129 { "usb", USB_LINK_RE_HUB, RM_POST | RM_HOT, ILEVEL_0, devfsadm_rm_all },
128 130 { "usb", USB_LINK_RE_MASS_STORE, RM_POST | RM_HOT | RM_ALWAYS,
129 131 ILEVEL_0, devfsadm_rm_all },
130 132 { "usb", USB_LINK_RE_UGEN, RM_POST | RM_HOT | RM_ALWAYS, ILEVEL_0,
131 133 devfsadm_rm_all },
132 134 { "usb", USB_LINK_RE_USBPRN, RM_POST | RM_HOT | RM_ALWAYS, ILEVEL_0,
133 135 devfsadm_rm_link },
134 136 { "usb", USB_LINK_RE_WHOST, RM_POST | RM_HOT, ILEVEL_0,
135 137 devfsadm_rm_all },
136 138 { "usb", USB_LINK_RE_HWARC, RM_POST | RM_HOT | RM_ALWAYS, ILEVEL_0,
137 139 devfsadm_rm_all },
138 140 { "usb", USB_LINK_RE_WUSB_CA, RM_POST | RM_HOT | RM_ALWAYS, ILEVEL_0,
139 141 devfsadm_rm_all }
140 142 };
141 143
142 144 /*
143 145 * Rules for different USB devices except ugen which is dynamically
144 146 * created
145 147 */
146 148 static devfsadm_enumerate_t audio_rules[1] =
147 149 {"^usb$/^audio([0-9]+)$", 1, MATCH_ALL};
148 150 static devfsadm_enumerate_t audio_mux_rules[1] =
149 151 {"^usb$/^audio-mux([0-9]+)$", 1, MATCH_ALL};
150 152 static devfsadm_enumerate_t audio_control_rules[1] =
151 153 {"^usb$/^audio-control([0-9]+)$", 1, MATCH_ALL};
152 154 static devfsadm_enumerate_t audio_stream_rules[1] =
153 155 {"^usb$/^audio-stream([0-9]+)$", 1, MATCH_ALL};
154 156 static devfsadm_enumerate_t ddivs_usbc_rules[1] =
155 157 {"^usb$/^ddivs_usbc([0-9]+)$", 1, MATCH_ALL};
156 158 static devfsadm_enumerate_t video_rules[1] =
157 159 {"^usb$/^video([0-9]+)$", 1, MATCH_ALL};
158 160 static devfsadm_enumerate_t device_rules[1] =
159 161 {"^usb$/^device([0-9]+)$", 1, MATCH_ALL};
160 162 static devfsadm_enumerate_t hid_rules[1] =
161 163 {"^usb$/^hid([0-9]+)$", 1, MATCH_ALL};
162 164 static devfsadm_enumerate_t hub_rules[1] =
163 165 {"^usb$/^hub([0-9]+)$", 1, MATCH_ALL};
164 166 static devfsadm_enumerate_t mass_storage_rules[1] =
165 167 {"^usb$/^mass-storage([0-9]+)$", 1, MATCH_ALL};
166 168 static devfsadm_enumerate_t usbprn_rules[1] =
167 169 {"^usb$/^printer([0-9]+)$", 1, MATCH_ALL};
168 170 static devfsadm_enumerate_t whost_rules[1] =
169 171 {"^usb$/^whost([0-9]+)$", 1, MATCH_ALL};
170 172 static devfsadm_enumerate_t hwarc_rules[1] =
171 173 {"^usb$/^hwarc([0-9]+)$", 1, MATCH_ALL};
172 174 static devfsadm_enumerate_t wusb_ca_rules[1] =
173 175 {"^usb$/^wusb_ca([0-9]+)$", 1, MATCH_ALL};
174 176
175 177 DEVFSADM_REMOVE_INIT_V0(usb_remove_cbt);
176 178
177 179 int
178 180 minor_init(void)
179 181 {
180 182 devfsadm_print(debug_mid, "usb_link: minor_init\n");
181 183 return (DEVFSADM_SUCCESS);
|
↓ open down ↓ |
108 lines elided |
↑ open up ↑ |
182 184 }
183 185
184 186 int
185 187 minor_fini(void)
186 188 {
187 189 devfsadm_print(debug_mid, "usb_link: minor_fini\n");
188 190 return (DEVFSADM_SUCCESS);
189 191 }
190 192
191 193 typedef enum {
192 - DRIVER_HUBD = 0,
193 - DRIVER_OHCI = 1,
194 - DRIVER_EHCI = 2,
195 - DRIVER_UHCI = 3,
196 - DRIVER_USB_AC = 4,
197 - DRIVER_USB_AS = 5,
198 - DRIVER_HID = 6,
199 - DRIVER_USB_MID = 7,
200 - DRIVER_DDIVS_USBC = 8,
201 - DRIVER_SCSA2USB = 9,
202 - DRIVER_USBPRN = 10,
203 - DRIVER_UGEN = 11,
204 - DRIVER_VIDEO = 12,
205 - DRIVER_HWAHC = 13,
206 - DRIVER_HWARC = 14,
207 - DRIVER_WUSB_CA = 15,
208 - DRIVER_UNKNOWN = 16
194 + DRIVER_HUBD,
195 + DRIVER_OHCI,
196 + DRIVER_EHCI,
197 + DRIVER_UHCI,
198 + DRIVER_XHCI,
199 + DRIVER_USB_AC,
200 + DRIVER_USB_AS,
201 + DRIVER_HID,
202 + DRIVER_USB_MID,
203 + DRIVER_DDIVS_USBC,
204 + DRIVER_SCSA2USB,
205 + DRIVER_USBPRN,
206 + DRIVER_UGEN,
207 + DRIVER_VIDEO,
208 + DRIVER_HWAHC,
209 + DRIVER_HWARC,
210 + DRIVER_WUSB_CA,
211 + DRIVER_UNKNOWN
209 212 } driver_defs_t;
210 213
211 214 typedef struct {
212 215 char *driver_name;
213 - int index;
216 + driver_defs_t index;
214 217 } driver_name_table_entry_t;
215 218
216 219 driver_name_table_entry_t driver_name_table[] = {
217 220 { "hubd", DRIVER_HUBD },
218 221 { "ohci", DRIVER_OHCI },
219 222 { "ehci", DRIVER_EHCI },
220 223 { "uhci", DRIVER_UHCI },
224 + { "xhci", DRIVER_XHCI },
221 225 { "usb_ac", DRIVER_USB_AC },
222 226 { "usb_as", DRIVER_USB_AS },
223 227 { "hid", DRIVER_HID },
224 228 { "usb_mid", DRIVER_USB_MID },
225 229 { "ddivs_usbc", DRIVER_DDIVS_USBC },
226 230 { "scsa2usb", DRIVER_SCSA2USB },
227 231 { "usbprn", DRIVER_USBPRN },
228 232 { "ugen", DRIVER_UGEN },
229 233 { "usbvc", DRIVER_VIDEO },
230 234 { "hwahc", DRIVER_HWAHC },
231 235 { "hwarc", DRIVER_HWARC },
232 236 { "wusb_ca", DRIVER_WUSB_CA },
233 237 { NULL, DRIVER_UNKNOWN }
234 238 };
235 239
236 240 /*
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
237 241 * This function is called for every usb minor node.
238 242 * Calls enumerate to assign a logical usb id, and then
239 243 * devfsadm_mklink to make the link.
240 244 */
241 245 static int
242 246 usb_process(di_minor_t minor, di_node_t node)
243 247 {
244 248 devfsadm_enumerate_t rules[1];
245 249 char *l_path, *p_path, *buf, *devfspath;
246 250 char *minor_nm, *drvr_nm, *name = (char *)NULL;
247 - int i, index;
251 + int i;
252 + driver_defs_t index;
248 253 int flags = 0;
249 254 int create_secondary_link = 0;
250 255
251 256 minor_nm = di_minor_name(minor);
252 257 drvr_nm = di_driver_name(node);
253 258 if ((minor_nm == NULL) || (drvr_nm == NULL)) {
254 259 return (DEVFSADM_CONTINUE);
255 260 }
256 261
257 262 devfsadm_print(debug_mid, "usb_process: minor=%s node=%s type=%s\n",
258 263 minor_nm, di_node_name(node), di_minor_nodetype(minor));
259 264
260 265 devfspath = di_devfs_path(node);
261 266 if (devfspath == NULL) {
262 267 devfsadm_print(debug_mid,
263 268 "USB_process: devfspath is NULL\n");
264 269 return (DEVFSADM_CONTINUE);
265 270 }
266 271
267 272 l_path = (char *)malloc(PATH_MAX);
268 273 if (l_path == NULL) {
269 274 di_devfs_path_free(devfspath);
270 275 devfsadm_print(debug_mid, "usb_process: malloc() failed\n");
271 276 return (DEVFSADM_CONTINUE);
272 277 }
273 278
274 279 p_path = (char *)malloc(PATH_MAX);
275 280 if (p_path == NULL) {
276 281 devfsadm_print(debug_mid, "usb_process: malloc() failed\n");
277 282 di_devfs_path_free(devfspath);
278 283 free(l_path);
279 284 return (DEVFSADM_CONTINUE);
280 285 }
281 286
282 287 (void) strcpy(p_path, devfspath);
283 288 (void) strcat(p_path, ":");
284 289 (void) strcat(p_path, minor_nm);
285 290 di_devfs_path_free(devfspath);
286 291
287 292 devfsadm_print(debug_mid, "usb_process: path %s\n", p_path);
288 293
289 294 for (i = 0; ; i++) {
290 295 if ((driver_name_table[i].driver_name == NULL) ||
291 296 (strcmp(drvr_nm, driver_name_table[i].driver_name) == 0)) {
292 297 index = driver_name_table[i].index;
293 298 break;
294 299 }
295 300 }
296 301
297 302 if (strcmp(di_minor_nodetype(minor), DDI_NT_UGEN) == 0) {
298 303 ugen_create_link(p_path, minor_nm, node, minor);
299 304 free(l_path);
|
↓ open down ↓ |
42 lines elided |
↑ open up ↑ |
300 305 free(p_path);
301 306 return (DEVFSADM_CONTINUE);
302 307 }
303 308
304 309 /* Figure out which rules to apply */
305 310 switch (index) {
306 311 case DRIVER_HUBD:
307 312 case DRIVER_OHCI:
308 313 case DRIVER_EHCI:
309 314 case DRIVER_UHCI:
315 + case DRIVER_XHCI:
310 316 rules[0] = hub_rules[0]; /* For HUBs */
311 317 name = "hub";
312 318
313 319 break;
314 320 case DRIVER_USB_AC:
315 321 if (strcmp(minor_nm, "sound,audio") == 0) {
316 322 rules[0] = audio_rules[0];
317 323 name = "audio"; /* For audio */
318 324 create_secondary_link = 1;
319 325 } else if (strcmp(minor_nm, "sound,audioctl") == 0) {
320 326 rules[0] = audio_control_rules[0];
321 327 name = "audio-control"; /* For audio */
322 328 create_secondary_link = 1;
323 329 } else if (strcmp(minor_nm, "mux") == 0) {
324 330 rules[0] = audio_mux_rules[0];
325 331 name = "audio-mux"; /* For audio */
326 332 } else {
327 333 free(l_path);
328 334 free(p_path);
329 335 return (DEVFSADM_CONTINUE);
330 336 }
331 337 break;
332 338 case DRIVER_USB_AS:
333 339 rules[0] = audio_stream_rules[0];
334 340 name = "audio-stream"; /* For audio */
335 341 break;
336 342 case DRIVER_VIDEO:
337 343 rules[0] = video_rules[0];
338 344 name = "video"; /* For video */
339 345 create_secondary_link = 1;
340 346 break;
341 347 case DRIVER_HID:
342 348 rules[0] = hid_rules[0];
343 349 name = "hid"; /* For HIDs */
344 350 break;
345 351 case DRIVER_USB_MID:
346 352 rules[0] = device_rules[0];
347 353 name = "device"; /* For other USB devices */
348 354 break;
349 355 case DRIVER_DDIVS_USBC:
350 356 rules[0] = ddivs_usbc_rules[0];
351 357 name = "device"; /* For other USB devices */
352 358 break;
353 359 case DRIVER_SCSA2USB:
354 360 rules[0] = mass_storage_rules[0];
355 361 name = "mass-storage"; /* For mass-storage devices */
356 362 break;
357 363 case DRIVER_USBPRN:
358 364 rules[0] = usbprn_rules[0];
359 365 name = "printer";
360 366 break;
361 367 case DRIVER_HWAHC:
362 368 if (strcmp(minor_nm, "hwahc") == 0) {
363 369 rules[0] = whost_rules[0];
364 370 name = "whost"; /* For HWA HC */
365 371 } else if (strcmp(minor_nm, "hubd") == 0) {
366 372 rules[0] = hub_rules[0];
367 373 name = "hub"; /* For HWA HC */
368 374 } else {
369 375 free(l_path);
370 376 free(p_path);
371 377 return (DEVFSADM_CONTINUE);
372 378 }
373 379 break;
374 380 case DRIVER_HWARC:
375 381 rules[0] = hwarc_rules[0];
376 382 name = "hwarc"; /* For UWB HWA Radio Controllers */
377 383 break;
378 384 case DRIVER_WUSB_CA:
379 385 rules[0] = wusb_ca_rules[0];
380 386 name = "wusb_ca"; /* for wusb cable association */
381 387 break;
382 388 default:
383 389 devfsadm_print(debug_mid, "usb_process: unknown driver=%s\n",
384 390 drvr_nm);
385 391 free(l_path);
386 392 free(p_path);
387 393 return (DEVFSADM_CONTINUE);
388 394 }
389 395
390 396 /*
391 397 * build the physical path from the components.
392 398 * find the logical usb id, and stuff it in buf
393 399 */
394 400 if (devfsadm_enumerate_int(p_path, 0, &buf, rules, 1)) {
395 401 devfsadm_print(debug_mid, "usb_process: exit/continue\n");
396 402 free(l_path);
397 403 free(p_path);
398 404 return (DEVFSADM_CONTINUE);
399 405 }
400 406
401 407 (void) snprintf(l_path, PATH_MAX, "usb/%s%s", name, buf);
402 408
403 409 devfsadm_print(debug_mid, "usb_process: p_path=%s buf=%s\n",
404 410 p_path, buf);
405 411
406 412 free(buf);
407 413
408 414 devfsadm_print(debug_mid, "mklink %s -> %s\n", l_path, p_path);
409 415
410 416 (void) devfsadm_mklink(l_path, node, minor, flags);
411 417
412 418 if (create_secondary_link) {
413 419 /*
414 420 * Create secondary links to make newly hotplugged
415 421 * usb audio device the primary device.
416 422 */
417 423 if (strcmp(name, "audio") == 0) {
418 424 (void) devfsadm_secondary_link("audio", l_path, 0);
419 425 } else if (strcmp(name, "audio-control") == 0) {
420 426 (void) devfsadm_secondary_link("audioctl", l_path, 0);
421 427 } else if (strcmp(name, "video") == 0) {
422 428 (void) devfsadm_secondary_link(l_path + 4, l_path, 0);
423 429 }
424 430 }
425 431
426 432 free(p_path);
427 433 free(l_path);
428 434
429 435 return (DEVFSADM_CONTINUE);
430 436 }
431 437
432 438 static void
433 439 ugen_create_link(char *p_path, char *node_name,
434 440 di_node_t node, di_minor_t minor)
435 441 {
436 442 char *buf, s[MAXPATHLEN];
437 443 char *lasts = s;
438 444 char *vid, *pid;
439 445 char *minor_name;
440 446 char ugen_RE[128];
441 447 devfsadm_enumerate_t ugen_rules[1];
442 448 char l_path[PATH_MAX];
443 449 int flags = 0;
444 450
445 451 devfsadm_print(debug_mid, "ugen_create_link: p_path=%s name=%s\n",
446 452 p_path, node_name);
447 453
448 454 (void) strlcpy(s, node_name, sizeof (s));
449 455
450 456 /* get vid, pid and minor name strings */
451 457 vid = strtok_r(lasts, ".", &lasts);
452 458 pid = strtok_r(NULL, ".", &lasts);
453 459 minor_name = lasts;
454 460
455 461 if ((vid == NULL) || (pid == NULL) || (minor_name == NULL)) {
456 462 return;
457 463 }
458 464
459 465 /* create regular expression contain vid and pid */
460 466 (void) snprintf(ugen_RE, sizeof (ugen_RE),
461 467 "^usb$/^%s\\.%s$/^([0-9]+)$", vid, pid);
462 468 devfsadm_print(debug_mid,
463 469 "ugen_create_link: ugen_RE=%s minor_name=%s\n",
464 470 ugen_RE, minor_name);
465 471
466 472 bzero(ugen_rules, sizeof (ugen_rules));
467 473
468 474 ugen_rules[0].re = ugen_RE;
469 475 ugen_rules[0].subexp = 1;
470 476 ugen_rules[0].flags = MATCH_ADDR;
471 477
472 478 /*
473 479 * build the physical path from the components.
474 480 * find the logical usb id, and stuff it in buf
475 481 */
476 482 if (devfsadm_enumerate_int(p_path, 0, &buf, ugen_rules, 1)) {
477 483 devfsadm_print(debug_mid, "ugen_create_link: exit/continue\n");
478 484 return;
479 485 }
480 486
481 487 (void) snprintf(l_path, sizeof (l_path), "usb/%s.%s/%s/%s",
482 488 vid, pid, buf, minor_name);
483 489
484 490 devfsadm_print(debug_mid, "mklink %s -> %s\n", l_path, p_path);
485 491
486 492 (void) devfsadm_mklink(l_path, node, minor, flags);
487 493
488 494 free(buf);
489 495 }
|
↓ open down ↓ |
170 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX