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 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* 27 * Sun NDI hotplug interfaces 28 */ 29 30 #include <sys/note.h> 31 #include <sys/sysmacros.h> 32 #include <sys/types.h> 33 #include <sys/param.h> 34 #include <sys/systm.h> 35 #include <sys/kmem.h> 36 #include <sys/cmn_err.h> 37 #include <sys/debug.h> 38 #include <sys/avintr.h> 39 #include <sys/autoconf.h> 40 #include <sys/sunndi.h> 41 #include <sys/ndi_impldefs.h> 42 #include <sys/ddi.h> 43 #include <sys/disp.h> 44 #include <sys/stat.h> 45 #include <sys/callb.h> 46 #include <sys/sysevent.h> 47 #include <sys/sysevent/eventdefs.h> 48 #include <sys/sysevent/dr.h> 49 #include <sys/taskq.h> 50 51 /* Local functions prototype */ 52 static void ddihp_cn_run_event(void *arg); 53 static int ddihp_cn_req_handler(ddi_hp_cn_handle_t *hdlp, 54 ddi_hp_cn_state_t target_state); 55 56 /* 57 * Global functions (called by hotplug controller or nexus drivers) 58 */ 59 60 /* 61 * Register the Hotplug Connection (CN) 62 */ 63 int 64 ndi_hp_register(dev_info_t *dip, ddi_hp_cn_info_t *info_p) 65 { 66 ddi_hp_cn_handle_t *hdlp; 67 int count; 68 69 DDI_HP_NEXDBG((CE_CONT, "ndi_hp_register: dip %p, info_p %p\n", 70 (void *)dip, (void *)info_p)); 71 72 ASSERT(!servicing_interrupt()); 73 if (servicing_interrupt()) 74 return (NDI_FAILURE); 75 76 /* Validate the arguments */ 77 if ((dip == NULL) || (info_p == NULL)) 78 return (NDI_EINVAL); 79 80 if (!NEXUS_HAS_HP_OP(dip)) { 81 return (NDI_ENOTSUP); 82 } 83 /* Lock before access */ 84 ndi_devi_enter(dip, &count); 85 86 hdlp = ddihp_cn_name_to_handle(dip, info_p->cn_name); 87 if (hdlp) { 88 /* This cn_name is already registered. */ 89 ndi_devi_exit(dip, count); 90 91 return (NDI_SUCCESS); 92 } 93 /* 94 * Create and initialize hotplug Connection handle 95 */ 96 hdlp = (ddi_hp_cn_handle_t *)kmem_zalloc( 97 (sizeof (ddi_hp_cn_handle_t)), KM_SLEEP); 98 99 /* Copy the Connection information */ 100 hdlp->cn_dip = dip; 101 bcopy(info_p, &(hdlp->cn_info), sizeof (*info_p)); 102 103 /* Copy cn_name */ 104 hdlp->cn_info.cn_name = ddi_strdup(info_p->cn_name, KM_SLEEP); 105 106 if (ddihp_cn_getstate(hdlp) != DDI_SUCCESS) { 107 DDI_HP_NEXDBG((CE_CONT, "ndi_hp_register: dip %p, hdlp %p" 108 "ddi_cn_getstate failed\n", (void *)dip, (void *)hdlp)); 109 110 goto fail; 111 } 112 113 /* 114 * Append the handle to the list 115 */ 116 DDIHP_LIST_APPEND(ddi_hp_cn_handle_t, (DEVI(dip)->devi_hp_hdlp), 117 hdlp); 118 119 ndi_devi_exit(dip, count); 120 121 return (NDI_SUCCESS); 122 123 fail: 124 kmem_free(hdlp->cn_info.cn_name, strlen(hdlp->cn_info.cn_name) + 1); 125 kmem_free(hdlp, sizeof (ddi_hp_cn_handle_t)); 126 ndi_devi_exit(dip, count); 127 128 return (NDI_FAILURE); 129 } 130 131 /* 132 * Unregister a Hotplug Connection (CN) 133 */ 134 int 135 ndi_hp_unregister(dev_info_t *dip, char *cn_name) 136 { 137 ddi_hp_cn_handle_t *hdlp; 138 int count; 139 int ret; 140 141 DDI_HP_NEXDBG((CE_CONT, "ndi_hp_unregister: dip %p, cn name %s\n", 142 (void *)dip, cn_name)); 143 144 ASSERT(!servicing_interrupt()); 145 if (servicing_interrupt()) 146 return (NDI_FAILURE); 147 148 /* Validate the arguments */ 149 if ((dip == NULL) || (cn_name == NULL)) 150 return (NDI_EINVAL); 151 152 ndi_devi_enter(dip, &count); 153 154 hdlp = ddihp_cn_name_to_handle(dip, cn_name); 155 if (hdlp == NULL) { 156 ndi_devi_exit(dip, count); 157 return (NDI_EINVAL); 158 } 159 160 switch (ddihp_cn_unregister(hdlp)) { 161 case DDI_SUCCESS: 162 ret = NDI_SUCCESS; 163 break; 164 case DDI_EINVAL: 165 ret = NDI_EINVAL; 166 break; 167 case DDI_EBUSY: 168 ret = NDI_BUSY; 169 break; 170 default: 171 ret = NDI_FAILURE; 172 break; 173 } 174 175 ndi_devi_exit(dip, count); 176 177 return (ret); 178 } 179 180 /* 181 * Notify the Hotplug Connection (CN) to change state. 182 * Flag: 183 * DDI_HP_REQ_SYNC Return after the change is finished. 184 * DDI_HP_REQ_ASYNC Return after the request is dispatched. 185 */ 186 int 187 ndi_hp_state_change_req(dev_info_t *dip, char *cn_name, 188 ddi_hp_cn_state_t state, uint_t flag) 189 { 190 ddi_hp_cn_async_event_entry_t *eventp; 191 192 DDI_HP_NEXDBG((CE_CONT, "ndi_hp_state_change_req: dip %p " 193 "cn_name: %s, state %x, flag %x\n", 194 (void *)dip, cn_name, state, flag)); 195 196 /* Validate the arguments */ 197 if (dip == NULL || cn_name == NULL) 198 return (NDI_EINVAL); 199 200 if (!NEXUS_HAS_HP_OP(dip)) { 201 return (NDI_ENOTSUP); 202 } 203 /* 204 * If the request is to handle the event synchronously, then call 205 * the event handler without queuing the event. 206 */ 207 if (flag & DDI_HP_REQ_SYNC) { 208 ddi_hp_cn_handle_t *hdlp; 209 int count; 210 int ret; 211 212 ASSERT(!servicing_interrupt()); 213 if (servicing_interrupt()) 214 return (NDI_FAILURE); 215 216 ndi_devi_enter(dip, &count); 217 218 hdlp = ddihp_cn_name_to_handle(dip, cn_name); 219 if (hdlp == NULL) { 220 ndi_devi_exit(dip, count); 221 222 return (NDI_EINVAL); 223 } 224 225 DDI_HP_NEXDBG((CE_CONT, "ndi_hp_state_change_req: hdlp %p " 226 "calling ddihp_cn_req_handler() directly to handle " 227 "target_state %x\n", (void *)hdlp, state)); 228 229 ret = ddihp_cn_req_handler(hdlp, state); 230 231 ndi_devi_exit(dip, count); 232 233 return (ret); 234 } 235 236 eventp = kmem_zalloc(sizeof (ddi_hp_cn_async_event_entry_t), 237 KM_NOSLEEP); 238 if (eventp == NULL) 239 return (NDI_NOMEM); 240 241 eventp->cn_name = ddi_strdup(cn_name, KM_NOSLEEP); 242 if (eventp->cn_name == NULL) { 243 kmem_free(eventp, sizeof (ddi_hp_cn_async_event_entry_t)); 244 return (NDI_NOMEM); 245 } 246 eventp->dip = dip; 247 eventp->target_state = state; 248 249 /* 250 * Hold the parent's ref so that it won't disappear when the taskq is 251 * scheduled to run. 252 */ 253 ndi_hold_devi(dip); 254 255 if (taskq_dispatch(system_taskq, ddihp_cn_run_event, eventp, 256 TQ_NOSLEEP) == TASKQID_INVALID) { 257 ndi_rele_devi(dip); 258 DDI_HP_NEXDBG((CE_CONT, "ndi_hp_state_change_req: " 259 "taskq_dispatch failed! dip %p " 260 "target_state %x\n", (void *)dip, state)); 261 return (NDI_NOMEM); 262 } 263 264 return (NDI_CLAIMED); 265 } 266 267 /* 268 * Walk the link of Hotplug Connection handles of a dip: 269 * DEVI(dip)->devi_hp_hdlp->[link of connections] 270 */ 271 void 272 ndi_hp_walk_cn(dev_info_t *dip, int (*f)(ddi_hp_cn_info_t *, 273 void *), void *arg) 274 { 275 int count; 276 ddi_hp_cn_handle_t *head, *curr, *prev; 277 278 DDI_HP_NEXDBG((CE_CONT, "ndi_hp_walk_cn: dip %p arg %p\n", 279 (void *)dip, arg)); 280 281 ASSERT(!servicing_interrupt()); 282 if (servicing_interrupt()) 283 return; 284 285 /* Validate the arguments */ 286 if (dip == NULL) 287 return; 288 289 ndi_devi_enter(dip, &count); 290 291 head = DEVI(dip)->devi_hp_hdlp; 292 curr = head; 293 prev = NULL; 294 while (curr != NULL) { 295 DDI_HP_NEXDBG((CE_CONT, "ndi_hp_walk_cn: dip %p " 296 "current cn_name: %s\n", 297 (void *)dip, curr->cn_info.cn_name)); 298 switch ((*f)(&(curr->cn_info), arg)) { 299 case DDI_WALK_TERMINATE: 300 ndi_devi_exit(dip, count); 301 302 return; 303 case DDI_WALK_CONTINUE: 304 default: 305 if (DEVI(dip)->devi_hp_hdlp != head) { 306 /* 307 * The current node is head and it is removed 308 * by last call to (*f)() 309 */ 310 head = DEVI(dip)->devi_hp_hdlp; 311 curr = head; 312 prev = NULL; 313 } else if (prev && prev->next != curr) { 314 /* 315 * The current node is a middle node or tail 316 * node and it is removed by last call to 317 * (*f)() 318 */ 319 curr = prev->next; 320 } else { 321 /* no removal accurred on curr node */ 322 prev = curr; 323 curr = curr->next; 324 } 325 } 326 } 327 ndi_devi_exit(dip, count); 328 } 329 330 /* 331 * Local functions (called within this file) 332 */ 333 334 /* 335 * Wrapper function for ddihp_cn_req_handler() called from taskq 336 */ 337 static void 338 ddihp_cn_run_event(void *arg) 339 { 340 ddi_hp_cn_async_event_entry_t *eventp = 341 (ddi_hp_cn_async_event_entry_t *)arg; 342 dev_info_t *dip = eventp->dip; 343 ddi_hp_cn_handle_t *hdlp; 344 int count; 345 346 /* Lock before access */ 347 ndi_devi_enter(dip, &count); 348 349 hdlp = ddihp_cn_name_to_handle(dip, eventp->cn_name); 350 if (hdlp) { 351 (void) ddihp_cn_req_handler(hdlp, eventp->target_state); 352 } else { 353 DDI_HP_NEXDBG((CE_CONT, "ddihp_cn_run_event: no handle for " 354 "cn_name: %s dip %p. Request for target_state %x is" 355 " dropped. \n", 356 eventp->cn_name, (void *)dip, eventp->target_state)); 357 } 358 359 ndi_devi_exit(dip, count); 360 361 /* Release the devi's ref that is held from interrupt context. */ 362 ndi_rele_devi((dev_info_t *)DEVI(dip)); 363 kmem_free(eventp->cn_name, strlen(eventp->cn_name) + 1); 364 kmem_free(eventp, sizeof (ddi_hp_cn_async_event_entry_t)); 365 } 366 367 /* 368 * Handle state change request of a Hotplug Connection (CN) 369 */ 370 static int 371 ddihp_cn_req_handler(ddi_hp_cn_handle_t *hdlp, 372 ddi_hp_cn_state_t target_state) 373 { 374 dev_info_t *dip = hdlp->cn_dip; 375 int ret = DDI_SUCCESS; 376 377 DDI_HP_NEXDBG((CE_CONT, "ddihp_cn_req_handler:" 378 " hdlp %p, target_state %x\n", 379 (void *)hdlp, target_state)); 380 381 ASSERT(DEVI_BUSY_OWNED(dip)); 382 383 if (ddihp_cn_getstate(hdlp) != DDI_SUCCESS) { 384 DDI_HP_NEXDBG((CE_CONT, "ddihp_cn_req_handler: dip %p, " 385 "hdlp %p ddi_cn_getstate failed\n", (void *)dip, 386 (void *)hdlp)); 387 388 return (NDI_UNCLAIMED); 389 } 390 if (hdlp->cn_info.cn_state != target_state) { 391 ddi_hp_cn_state_t result_state = 0; 392 393 DDIHP_CN_OPS(hdlp, DDI_HPOP_CN_CHANGE_STATE, 394 (void *)&target_state, (void *)&result_state, ret); 395 396 DDI_HP_NEXDBG((CE_CONT, "ddihp_cn_req_handler: dip %p, " 397 "hdlp %p changed state to %x, ret=%x\n", 398 (void *)dip, (void *)hdlp, result_state, ret)); 399 } 400 401 if (ret == DDI_SUCCESS) 402 return (NDI_CLAIMED); 403 else 404 return (NDI_UNCLAIMED); 405 } 406