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 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26
27 /*
28 * The tvhci driver can be used to exercise the mpxio framework together
29 * with tphci/tclient.
30 */
31
32 #include <sys/conf.h>
33 #include <sys/file.h>
34 #include <sys/ddi.h>
35 #include <sys/sunddi.h>
36 #include <sys/scsi/scsi.h>
37 #include <sys/scsi/impl/scsi_reset_notify.h>
38 #include <sys/sunmdi.h>
39 #include <sys/mdi_impldefs.h>
40 #include <sys/disp.h>
41
42 /* cb_ops entry points */
43 static int tvhci_open(dev_t *, int, int, cred_t *);
44 static int tvhci_close(dev_t, int, int, cred_t *);
45 static int tvhci_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
46 static int tvhci_attach(dev_info_t *, ddi_attach_cmd_t);
47 static int tvhci_detach(dev_info_t *, ddi_detach_cmd_t);
48 static int tvhci_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
49
50 /* bus_ops entry points */
51 static int tvhci_ctl(dev_info_t *, dev_info_t *, ddi_ctl_enum_t, void *,
52 void *);
53 static int tvhci_initchild(dev_info_t *, dev_info_t *);
54 static int tvhci_uninitchild(dev_info_t *, dev_info_t *);
55 static int tvhci_bus_config(dev_info_t *, uint_t, ddi_bus_config_op_t, void *,
56 dev_info_t **);
57 static int tvhci_bus_unconfig(dev_info_t *, uint_t, ddi_bus_config_op_t,
58 void *);
59 static int tvhci_intr_op(dev_info_t *dip, dev_info_t *rdip,
60 ddi_intr_op_t op, ddi_intr_handle_impl_t *hdlp, void *result);
61
62 /* vhci ops */
63 static int tvhci_pi_init(dev_info_t *, mdi_pathinfo_t *, int);
64 static int tvhci_pi_uninit(dev_info_t *, mdi_pathinfo_t *, int);
65 static int tvhci_pi_state_change(dev_info_t *, mdi_pathinfo_t *,
66 mdi_pathinfo_state_t, uint32_t, int);
67 static int tvhci_failover(dev_info_t *, dev_info_t *, int);
68
69 static void *tvhci_state;
70 struct tvhci_state {
71 dev_info_t *dip;
72 };
73
74 static mdi_vhci_ops_t tvhci_opinfo = {
75 MDI_VHCI_OPS_REV,
76 tvhci_pi_init,
77 tvhci_pi_uninit,
78 tvhci_pi_state_change,
79 tvhci_failover
80 };
81
82 static struct cb_ops tvhci_cb_ops = {
83 tvhci_open, /* open */
84 tvhci_close, /* close */
85 nodev, /* strategy */
86 nodev, /* print */
87 nodev, /* dump */
88 nodev, /* read */
89 nodev, /* write */
90 tvhci_ioctl, /* ioctl */
91 nodev, /* devmap */
92 nodev, /* mmap */
93 nodev, /* segmap */
94 nochpoll, /* chpoll */
95 ddi_prop_op, /* cb_prop_op */
96 0, /* streamtab */
97 D_NEW | D_MP, /* cb_flag */
98 CB_REV, /* rev */
99 nodev, /* aread */
100 nodev /* awrite */
101 };
102
103 static struct bus_ops tvhci_bus_ops = {
104 BUSO_REV, /* busops_rev */
105 nullbusmap, /* bus_map */
106 NULL, /* bus_get_intrspec */
107 NULL, /* bus_add_interspec */
108 NULL, /* bus_remove_interspec */
109 i_ddi_map_fault, /* bus_map_fault */
110 ddi_no_dma_map, /* bus_dma_map */
111 ddi_no_dma_allochdl, /* bus_dma_allochdl */
112 NULL, /* bus_dma_freehdl */
113 NULL, /* bus_dma_bindhdl */
114 NULL, /* bus_dma_unbindhdl */
115 NULL, /* bus_dma_flush */
116 NULL, /* bus_dma_win */
117 NULL, /* bus_dma_ctl */
118 tvhci_ctl, /* bus_ctl */
119 ddi_bus_prop_op, /* bus_prop_op */
120 NULL, /* bus_get_eventcookie */
121 NULL, /* bus_add_eventcall */
122 NULL, /* bus_remove_event */
123 NULL, /* bus_post_event */
124 NULL, /* bus_intr_ctl */
125 tvhci_bus_config, /* bus_config */
126 tvhci_bus_unconfig, /* bus_unconfig */
127 NULL, /* bus_fm_init */
128 NULL, /* bus_fm_fini */
129 NULL, /* bus_fm_access_enter */
130 NULL, /* bus_fm_access_exit */
131 NULL, /* bus_power */
132 tvhci_intr_op /* bus_intr_op */
133 };
134
135 static struct dev_ops tvhci_ops = {
136 DEVO_REV,
137 0,
138 tvhci_getinfo,
139 nulldev, /* identify */
140 nulldev, /* probe */
141 tvhci_attach, /* attach and detach are mandatory */
142 tvhci_detach,
143 nodev, /* reset */
144 &tvhci_cb_ops, /* cb_ops */
145 &tvhci_bus_ops, /* bus_ops */
146 NULL, /* power */
147 ddi_quiesce_not_needed, /* quiesce */
148 };
149
150 extern struct mod_ops mod_driverops;
151
152 static struct modldrv modldrv = {
153 &mod_driverops,
154 "test vhci driver",
155 &tvhci_ops
156 };
157
158 static struct modlinkage modlinkage = {
159 MODREV_1,
160 &modldrv,
161 NULL
162 };
163
164 int
165 _init(void)
166 {
167 int rval;
168
169 if ((rval = ddi_soft_state_init(&tvhci_state,
170 sizeof (struct tvhci_state), 2)) != 0) {
171 return (rval);
172 }
173
174 if ((rval = mod_install(&modlinkage)) != 0) {
175 ddi_soft_state_fini(&tvhci_state);
176 }
177 return (rval);
178 }
179
180
181 int
182 _fini(void)
183 {
184 int rval;
185
186 /*
187 * don't start cleaning up until we know that the module remove
188 * has worked -- if this works, then we know that each instance
189 * has successfully been detached
190 */
191 if ((rval = mod_remove(&modlinkage)) != 0) {
192 return (rval);
193 }
194
195 ddi_soft_state_fini(&tvhci_state);
196
197 return (rval);
198 }
199
200 int
201 _info(struct modinfo *modinfop)
202 {
203 return (mod_info(&modlinkage, modinfop));
204 }
205
206 /* ARGSUSED */
207 static int
208 tvhci_open(dev_t *devp, int flag, int otype, cred_t *credp)
209 {
210 struct tvhci_state *vhci;
211
212 if (otype != OTYP_CHR) {
213 return (EINVAL);
214 }
215
216 vhci = ddi_get_soft_state(tvhci_state, getminor(*devp));
217 if (vhci == NULL) {
218 return (ENXIO);
219 }
220
221 return (0);
222 }
223
224
225 /* ARGSUSED */
226 static int
227 tvhci_close(dev_t dev, int flag, int otype, cred_t *credp)
228 {
229 struct tvhci_state *vhci;
230 if (otype != OTYP_CHR) {
231 return (EINVAL);
232 }
233
234 vhci = ddi_get_soft_state(tvhci_state, getminor(dev));
235 if (vhci == NULL) {
236 return (ENXIO);
237 }
238
239 return (0);
240 }
241
242 /* ARGSUSED */
243 static int
244 tvhci_ioctl(dev_t dev, int cmd, intptr_t data, int mode,
245 cred_t *credp, int *rval)
246 {
247 return (0);
248 }
249
250 /*
251 * attach the module
252 */
253 static int
254 tvhci_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
255 {
256 char *vclass;
257 int instance, vhci_regis = 0;
258 struct tvhci_state *vhci = NULL;
259 dev_info_t *pdip;
260
261 instance = ddi_get_instance(dip);
262
263 switch (cmd) {
264 case DDI_ATTACH:
265 break;
266
267 case DDI_RESUME:
268 case DDI_PM_RESUME:
269 return (0); /* nothing to do */
270
271 default:
272 return (DDI_FAILURE);
273 }
274
275 /*
276 * Allocate vhci data structure.
277 */
278 if (ddi_soft_state_zalloc(tvhci_state, instance) != DDI_SUCCESS) {
279 return (DDI_FAILURE);
280 }
281
282 vhci = ddi_get_soft_state(tvhci_state, instance);
283 ASSERT(vhci != NULL);
284 vhci->dip = dip;
285
286 /* parent must be /pshot */
287 pdip = ddi_get_parent(dip);
288 if (strcmp(ddi_driver_name(pdip), "pshot") != 0 ||
289 ddi_get_parent(pdip) != ddi_root_node()) {
290 cmn_err(CE_NOTE, "tvhci must be under /pshot/");
291 goto attach_fail;
292 }
293
294 /*
295 * XXX add mpxio-disable property. need to remove the check
296 * from the framework
297 */
298 (void) ddi_prop_update_string(DDI_DEV_T_NONE, dip,
299 "mpxio-disable", "no");
300
301 /* bus_addr is the <vhci_class> */
302 vclass = ddi_get_name_addr(dip);
303 if (vclass == NULL || vclass[1] == '\0') {
304 cmn_err(CE_NOTE, "tvhci invalid vhci class");
305 goto attach_fail;
306 }
307
308 /*
309 * Attach this instance with the mpxio framework
310 */
311 if (mdi_vhci_register(vclass, dip, &tvhci_opinfo, 0) != MDI_SUCCESS) {
312 cmn_err(CE_WARN, "%s mdi_vhci_register failed",
313 ddi_node_name(dip));
314 goto attach_fail;
315 }
316 vhci_regis++;
317
318 if (ddi_create_minor_node(dip, "devctl", S_IFCHR,
319 instance, DDI_NT_SCSI_NEXUS, 0) != DDI_SUCCESS) {
320 cmn_err(CE_NOTE, "%s ddi_create_minor_node failed",
321 ddi_node_name(dip));
322 goto attach_fail;
323 }
324
325 (void) ddi_prop_update_int(DDI_DEV_T_NONE, dip, DDI_NO_AUTODETACH, 1);
326 ddi_report_dev(dip);
327 return (DDI_SUCCESS);
328
329 attach_fail:
330 if (vhci_regis)
331 (void) mdi_vhci_unregister(dip, 0);
332
333 ddi_soft_state_free(tvhci_state, instance);
334 return (DDI_FAILURE);
335 }
336
337
338 /*ARGSUSED*/
339 static int
340 tvhci_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
341 {
342 int instance = ddi_get_instance(dip);
343
344 switch (cmd) {
345 case DDI_DETACH:
346 break;
347
348 case DDI_SUSPEND:
349 case DDI_PM_SUSPEND:
350 return (0); /* nothing to do */
351
352 default:
353 return (DDI_FAILURE);
354 }
355
356 if (mdi_vhci_unregister(dip, 0) != MDI_SUCCESS)
357 return (DDI_FAILURE);
358
359 ddi_remove_minor_node(dip, NULL);
360 ddi_soft_state_free(tvhci_state, instance);
361
362 return (DDI_SUCCESS);
363 }
364
365 /*
366 * tvhci_getinfo()
367 * Given the device number, return the devinfo pointer or the
368 * instance number.
369 * Note: always succeed DDI_INFO_DEVT2INSTANCE, even before attach.
370 */
371
372 /*ARGSUSED*/
373 static int
374 tvhci_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
375 {
376 struct tvhci_state *vhci;
377 int instance = getminor((dev_t)arg);
378
379 switch (cmd) {
380 case DDI_INFO_DEVT2DEVINFO:
381 vhci = ddi_get_soft_state(tvhci_state, instance);
382 if (vhci != NULL)
383 *result = vhci->dip;
384 else {
385 *result = NULL;
386 return (DDI_FAILURE);
387 }
388 break;
389
390 case DDI_INFO_DEVT2INSTANCE:
391 *result = (void *)(uintptr_t)instance;
392 break;
393
394 default:
395 return (DDI_FAILURE);
396 }
397
398 return (DDI_SUCCESS);
399 }
400
401 /*ARGSUSED*/
402 static int
403 tvhci_pi_init(dev_info_t *vdip, mdi_pathinfo_t *pip, int flags)
404 {
405 return (MDI_SUCCESS);
406 }
407
408 /*ARGSUSED*/
409 static int
410 tvhci_pi_uninit(dev_info_t *vdip, mdi_pathinfo_t *pip, int flags)
411 {
412 return (MDI_SUCCESS);
413 }
414
415 /*ARGSUSED*/
416 static int
417 tvhci_pi_state_change(dev_info_t *vdip, mdi_pathinfo_t *pip,
418 mdi_pathinfo_state_t state, uint32_t ext_state, int flags)
419 {
420 return (MDI_SUCCESS);
421 }
422
423 /*ARGSUSED*/
424 static int
425 tvhci_failover(dev_info_t *vdip, dev_info_t *cdip, int flags)
426 {
427 return (MDI_SUCCESS);
428 }
429
430 /*
431 * Interrupt stuff. NO OP for pseudo drivers.
432 */
433 /*ARGSUSED*/
434 static int
435 tvhci_intr_op(dev_info_t *dip, dev_info_t *rdip, ddi_intr_op_t op,
436 ddi_intr_handle_impl_t *hdlp, void *result)
437 {
438 return (DDI_FAILURE);
439 }
440
441 /*ARGSUSED*/
442 static int
443 tvhci_ctl(dev_info_t *dip, dev_info_t *rdip,
444 ddi_ctl_enum_t ctlop, void *arg, void *result)
445 {
446 switch (ctlop) {
447 case DDI_CTLOPS_REPORTDEV:
448 if (rdip == (dev_info_t *)0)
449 return (DDI_FAILURE);
450 cmn_err(CE_CONT, "?tvhci-device: %s%d\n",
451 ddi_get_name(rdip), ddi_get_instance(rdip));
452 return (DDI_SUCCESS);
453
454 case DDI_CTLOPS_INITCHILD:
455 {
456 dev_info_t *child = (dev_info_t *)arg;
457 return (tvhci_initchild(dip, child));
458 }
459
460 case DDI_CTLOPS_UNINITCHILD:
461 {
462 dev_info_t *child = (dev_info_t *)arg;
463 return (tvhci_uninitchild(dip, child));
464 }
465
466 case DDI_CTLOPS_DMAPMAPC:
467 case DDI_CTLOPS_REPORTINT:
468 case DDI_CTLOPS_REGSIZE:
469 case DDI_CTLOPS_NREGS:
470 case DDI_CTLOPS_SIDDEV:
471 case DDI_CTLOPS_SLAVEONLY:
472 case DDI_CTLOPS_AFFINITY:
473 case DDI_CTLOPS_POKE:
474 case DDI_CTLOPS_PEEK:
475 /*
476 * These ops correspond to functions that "shouldn't" be called
477 * by a pseudo driver. So we whine when we're called.
478 */
479 cmn_err(CE_CONT, "%s%d: invalid op (%d) from %s%d\n",
480 ddi_get_name(dip), ddi_get_instance(dip),
481 ctlop, ddi_get_name(rdip), ddi_get_instance(rdip));
482 return (DDI_FAILURE);
483
484 case DDI_CTLOPS_ATTACH:
485 case DDI_CTLOPS_BTOP:
486 case DDI_CTLOPS_BTOPR:
487 case DDI_CTLOPS_DETACH:
488 case DDI_CTLOPS_DVMAPAGESIZE:
489 case DDI_CTLOPS_IOMIN:
490 case DDI_CTLOPS_POWER:
491 case DDI_CTLOPS_PTOB:
492 default:
493 /*
494 * The ops that we pass up (default). We pass up memory
495 * allocation oriented ops that we receive - these may be
496 * associated with pseudo HBA drivers below us with target
497 * drivers below them that use ddi memory allocation
498 * interfaces like scsi_alloc_consistent_buf.
499 */
500 return (ddi_ctlops(dip, rdip, ctlop, arg, result));
501 }
502 }
503
504 /* set devi_addr to "g<guid>" */
505 static int
506 tvhci_initchild(dev_info_t *dip, dev_info_t *child)
507 {
508 _NOTE(ARGUNUSED(dip))
509 char *guid, *addr;
510
511 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS,
512 MDI_CLIENT_GUID_PROP, &guid) != DDI_SUCCESS) {
513 cmn_err(CE_NOTE, "tvhci_initchild - no guid property");
514 return (DDI_FAILURE);
515 }
516
517 addr = kmem_alloc(MAXNAMELEN, KM_SLEEP);
518 (void) snprintf(addr, MAXNAMELEN, "g%s", guid);
519 ddi_set_name_addr(child, addr);
520
521 kmem_free(addr, MAXNAMELEN);
522 ddi_prop_free(guid);
523 return (DDI_SUCCESS);
524 }
525
526 /*ARGSUSED*/
527 static int
528 tvhci_uninitchild(dev_info_t *dip, dev_info_t *child)
529 {
530 ddi_set_name_addr(child, NULL);
531 return (DDI_SUCCESS);
532 }
533
534 /* form paddr by cname@<phci_inst>,<guid> */
535 static char *
536 tvh_get_phci_devname(char *cname, char *guid,
537 dev_info_t *pdip, char *pname, int len)
538 {
539 (void) snprintf(pname, len, "%s@%d,%s",
540 cname, ddi_get_instance(pdip), guid);
541 return (pname);
542 }
543
544 /*
545 * Return a pointer to the guid part of the devnm.
546 * devnm format is "nodename@busaddr", busaddr format is "gGUID".
547 */
548 static char *
549 tvhci_devnm_to_guid(char *devnm)
550 {
551 char *cp = devnm;
552
553 if (devnm == NULL)
554 return (NULL);
555
556 while (*cp != '\0' && *cp != '@')
557 cp++;
558 if (*cp == '@' && *(cp + 1) == 'g')
559 return (cp + 2);
560 return (NULL);
561 }
562
563 static int
564 tvhci_bus_config(dev_info_t *pdip, uint_t flags, ddi_bus_config_op_t op,
565 void *arg, dev_info_t **child)
566 {
567 char *guid;
568
569 if (op == BUS_CONFIG_ONE || op == BUS_UNCONFIG_ONE)
570 guid = tvhci_devnm_to_guid((char *)arg);
571 else
572 guid = NULL;
573
574 if (mdi_vhci_bus_config(pdip, flags, op, arg, child, guid)
575 == MDI_SUCCESS)
576 return (NDI_SUCCESS);
577 else
578 return (NDI_FAILURE);
579 }
580
581 static int
582 tvhci_bus_unconfig(dev_info_t *parent, uint_t flags,
583 ddi_bus_config_op_t op, void *arg)
584 {
585 return (ndi_busop_bus_unconfig(parent, flags, op, arg));
586 }