1 /* $NetBSD: ld_iop.c,v 1.33 2008/12/15 18:35:48 mhitch Exp $ */ 2 3 /*- 4 * Copyright (c) 2000, 2001 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Andrew Doran. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * I2O front-end for ld(4) driver, supporting random block storage class 34 * devices. Currently, this doesn't handle anything more complex than 35 * fixed direct-access devices. 36 */ 37 38 #include <sys/cdefs.h> 39 __KERNEL_RCSID(0, "$NetBSD: ld_iop.c,v 1.33 2008/12/15 18:35:48 mhitch Exp $"); 40 41 #include "rnd.h" 42 43 #include <sys/param.h> 44 #include <sys/systm.h> 45 #include <sys/kernel.h> 46 #include <sys/device.h> 47 #include <sys/buf.h> 48 #include <sys/bufq.h> 49 #include <sys/endian.h> 50 #include <sys/dkio.h> 51 #include <sys/disk.h> 52 #include <sys/proc.h> 53 #if NRND > 0 54 #include <sys/rnd.h> 55 #endif 56 57 #include <sys/bus.h> 58 59 #include <dev/ldvar.h> 60 61 #include <dev/i2o/i2o.h> 62 #include <dev/i2o/iopio.h> 63 #include <dev/i2o/iopvar.h> 64 65 #define LD_IOP_TIMEOUT 30*1000 66 67 #define LD_IOP_CLAIMED 0x01 68 #define LD_IOP_NEW_EVTMASK 0x02 69 70 struct ld_iop_softc { 71 struct ld_softc sc_ld; 72 struct iop_initiator sc_ii; 73 struct iop_initiator sc_eventii; 74 int sc_flags; 75 }; 76 77 static void ld_iop_adjqparam(device_t, int); 78 static void ld_iop_attach(device_t, device_t, void *); 79 static int ld_iop_detach(device_t, int); 80 static int ld_iop_dump(struct ld_softc *, void *, int, int); 81 static int ld_iop_flush(struct ld_softc *, int); 82 static void ld_iop_intr(device_t, struct iop_msg *, void *); 83 static void ld_iop_intr_event(device_t, struct iop_msg *, void *); 84 static int ld_iop_match(device_t, cfdata_t, void *); 85 static int ld_iop_start(struct ld_softc *, struct buf *); 86 static void ld_iop_unconfig(struct ld_iop_softc *, int); 87 88 CFATTACH_DECL_NEW(ld_iop, sizeof(struct ld_iop_softc), 89 ld_iop_match, ld_iop_attach, ld_iop_detach, NULL); 90 91 static const char * const ld_iop_errors[] = { 92 "success", 93 "media error", 94 "access error", 95 "device failure", 96 "device not ready", 97 "media not present", 98 "media locked", 99 "media failure", 100 "protocol failure", 101 "bus failure", 102 "access violation", 103 "media write protected", 104 "device reset", 105 "volume changed, waiting for acknowledgement", 106 "timeout", 107 }; 108 109 static int 110 ld_iop_match(device_t parent, cfdata_t match, void *aux) 111 { 112 struct iop_attach_args *ia; 113 114 ia = aux; 115 116 return (ia->ia_class == I2O_CLASS_RANDOM_BLOCK_STORAGE); 117 } 118 119 static void 120 ld_iop_attach(device_t parent, device_t self, void *aux) 121 { 122 struct iop_attach_args *ia = aux; 123 struct ld_iop_softc *sc = device_private(self); 124 struct iop_softc *iop = device_private(parent); 125 struct ld_softc *ld = &sc->sc_ld; 126 int rv, evreg, enable; 127 const char *typestr, *fixedstr; 128 u_int cachesz; 129 u_int32_t timeoutbase, rwvtimeoutbase, rwvtimeout; 130 struct { 131 struct i2o_param_op_results pr; 132 struct i2o_param_read_results prr; 133 union { 134 struct i2o_param_rbs_cache_control cc; 135 struct i2o_param_rbs_device_info bdi; 136 } p; 137 } __packed param; 138 139 ld->sc_dv = self; 140 evreg = 0; 141 142 /* Register us as an initiator. */ 143 sc->sc_ii.ii_dv = self; 144 sc->sc_ii.ii_intr = ld_iop_intr; 145 sc->sc_ii.ii_adjqparam = ld_iop_adjqparam; 146 sc->sc_ii.ii_flags = 0; 147 sc->sc_ii.ii_tid = ia->ia_tid; 148 iop_initiator_register(iop, &sc->sc_ii); 149 150 /* Register another initiator to handle events from the device. */ 151 sc->sc_eventii.ii_dv = self; 152 sc->sc_eventii.ii_intr = ld_iop_intr_event; 153 sc->sc_eventii.ii_flags = II_NOTCTX | II_UTILITY; 154 sc->sc_eventii.ii_tid = ia->ia_tid; 155 iop_initiator_register(iop, &sc->sc_eventii); 156 157 rv = iop_util_eventreg(iop, &sc->sc_eventii, 158 I2O_EVENT_GEN_EVENT_MASK_MODIFIED | 159 I2O_EVENT_GEN_DEVICE_RESET | 160 I2O_EVENT_GEN_STATE_CHANGE | 161 I2O_EVENT_GEN_GENERAL_WARNING); 162 if (rv != 0) { 163 aprint_error_dev(self, "unable to register for events"); 164 goto bad; 165 } 166 evreg = 1; 167 168 /* 169 * Start out with one queued command. The `iop' driver will adjust 170 * the queue parameters once we're up and running. 171 */ 172 ld->sc_maxqueuecnt = 1; 173 174 ld->sc_maxxfer = IOP_MAX_XFER; 175 ld->sc_dump = ld_iop_dump; 176 ld->sc_flush = ld_iop_flush; 177 ld->sc_start = ld_iop_start; 178 179 /* Say what the device is. */ 180 printf(":"); 181 iop_print_ident(iop, ia->ia_tid); 182 183 /* 184 * Claim the device so that we don't get any nasty surprises. Allow 185 * failure. 186 */ 187 rv = iop_util_claim(iop, &sc->sc_ii, 0, 188 I2O_UTIL_CLAIM_CAPACITY_SENSITIVE | 189 I2O_UTIL_CLAIM_NO_PEER_SERVICE | 190 I2O_UTIL_CLAIM_NO_MANAGEMENT_SERVICE | 191 I2O_UTIL_CLAIM_PRIMARY_USER); 192 sc->sc_flags = rv ? 0 : LD_IOP_CLAIMED; 193 194 rv = iop_field_get_all(iop, ia->ia_tid, I2O_PARAM_RBS_DEVICE_INFO, 195 ¶m, sizeof(param), NULL); 196 if (rv != 0) 197 goto bad; 198 199 ld->sc_secsize = le32toh(param.p.bdi.blocksize); 200 ld->sc_secperunit = (int) 201 (le64toh(param.p.bdi.capacity) / ld->sc_secsize); 202 203 switch (param.p.bdi.type) { 204 case I2O_RBS_TYPE_DIRECT: 205 typestr = "direct access"; 206 enable = 1; 207 break; 208 case I2O_RBS_TYPE_WORM: 209 typestr = "WORM"; 210 enable = 0; 211 break; 212 case I2O_RBS_TYPE_CDROM: 213 typestr = "CD-ROM"; 214 enable = 0; 215 break; 216 case I2O_RBS_TYPE_OPTICAL: 217 typestr = "optical"; 218 enable = 0; 219 break; 220 default: 221 typestr = "unknown"; 222 enable = 0; 223 break; 224 } 225 226 if ((le32toh(param.p.bdi.capabilities) & I2O_RBS_CAP_REMOVABLE_MEDIA) 227 != 0) { 228 /* ld->sc_flags = LDF_REMOVABLE; */ 229 fixedstr = "removable"; 230 enable = 0; 231 } else 232 fixedstr = "fixed"; 233 234 printf(" %s, %s", typestr, fixedstr); 235 236 /* 237 * Determine if the device has an private cache. If so, print the 238 * cache size. Even if the device doesn't appear to have a cache, 239 * we perform a flush at shutdown. 240 */ 241 rv = iop_field_get_all(iop, ia->ia_tid, I2O_PARAM_RBS_CACHE_CONTROL, 242 ¶m, sizeof(param), NULL); 243 if (rv != 0) 244 goto bad; 245 246 if ((cachesz = le32toh(param.p.cc.totalcachesize)) != 0) 247 printf(", %dkB cache", cachesz >> 10); 248 249 printf("\n"); 250 251 /* 252 * Configure the DDM's timeout functions to time out all commands 253 * after 30 seconds. 254 */ 255 timeoutbase = htole32(LD_IOP_TIMEOUT * 1000); 256 rwvtimeoutbase = htole32(LD_IOP_TIMEOUT * 1000); 257 rwvtimeout = 0; 258 259 iop_field_set(iop, ia->ia_tid, I2O_PARAM_RBS_OPERATION, 260 &timeoutbase, sizeof(timeoutbase), 261 I2O_PARAM_RBS_OPERATION_timeoutbase); 262 iop_field_set(iop, ia->ia_tid, I2O_PARAM_RBS_OPERATION, 263 &rwvtimeoutbase, sizeof(rwvtimeoutbase), 264 I2O_PARAM_RBS_OPERATION_rwvtimeoutbase); 265 iop_field_set(iop, ia->ia_tid, I2O_PARAM_RBS_OPERATION, 266 &rwvtimeout, sizeof(rwvtimeout), 267 I2O_PARAM_RBS_OPERATION_rwvtimeoutbase); 268 269 if (enable) 270 ld->sc_flags |= LDF_ENABLED; 271 else 272 aprint_error_dev(self, "device not yet supported\n"); 273 274 ldattach(ld); 275 return; 276 277 bad: 278 ld_iop_unconfig(sc, evreg); 279 } 280 281 static void 282 ld_iop_unconfig(struct ld_iop_softc *sc, int evreg) 283 { 284 struct iop_softc *iop; 285 286 iop = device_private(device_parent(sc->sc_ld.sc_dv)); 287 288 if ((sc->sc_flags & LD_IOP_CLAIMED) != 0) 289 iop_util_claim(iop, &sc->sc_ii, 1, 290 I2O_UTIL_CLAIM_PRIMARY_USER); 291 292 if (evreg) { 293 /* 294 * Mask off events, and wait up to 5 seconds for a reply. 295 * Note that some adapters won't reply to this (XXX We 296 * should check the event capabilities). 297 */ 298 mutex_spin_enter(&iop->sc_intrlock); 299 sc->sc_flags &= ~LD_IOP_NEW_EVTMASK; 300 mutex_spin_exit(&iop->sc_intrlock); 301 302 iop_util_eventreg(iop, &sc->sc_eventii, 303 I2O_EVENT_GEN_EVENT_MASK_MODIFIED); 304 305 mutex_spin_enter(&iop->sc_intrlock); 306 if ((sc->sc_flags & LD_IOP_NEW_EVTMASK) == 0) 307 cv_timedwait(&sc->sc_eventii.ii_cv, 308 &iop->sc_intrlock, hz * 5); 309 mutex_spin_exit(&iop->sc_intrlock); 310 } 311 312 iop_initiator_unregister(iop, &sc->sc_eventii); 313 iop_initiator_unregister(iop, &sc->sc_ii); 314 } 315 316 static int 317 ld_iop_detach(device_t self, int flags) 318 { 319 struct ld_iop_softc *sc; 320 struct iop_softc *iop; 321 int rv; 322 323 sc = device_private(self); 324 iop = device_private(device_parent(self)); 325 326 if ((rv = ldbegindetach(&sc->sc_ld, flags)) != 0) 327 return (rv); 328 329 /* 330 * Abort any requests queued with the IOP, but allow requests that 331 * are already in progress to complete. 332 */ 333 if ((sc->sc_ld.sc_flags & LDF_ENABLED) != 0) 334 iop_util_abort(iop, &sc->sc_ii, 0, 0, 335 I2O_UTIL_ABORT_WILD | I2O_UTIL_ABORT_CLEAN); 336 337 ldenddetach(&sc->sc_ld); 338 339 /* Un-claim the target, and un-register our initiators. */ 340 if ((sc->sc_ld.sc_flags & LDF_ENABLED) != 0) 341 ld_iop_unconfig(sc, 1); 342 343 return (0); 344 } 345 346 static int 347 ld_iop_start(struct ld_softc *ld, struct buf *bp) 348 { 349 struct iop_msg *im; 350 struct iop_softc *iop; 351 struct ld_iop_softc *sc; 352 struct i2o_rbs_block_read *mf; 353 u_int rv, flags, write; 354 u_int64_t ba; 355 u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)]; 356 357 sc = device_private(ld->sc_dv); 358 iop = device_private(device_parent(ld->sc_dv)); 359 360 im = iop_msg_alloc(iop, 0); 361 im->im_dvcontext = bp; 362 363 write = ((bp->b_flags & B_READ) == 0); 364 ba = (u_int64_t)bp->b_rawblkno * ld->sc_secsize; 365 366 /* 367 * Write through the cache when performing synchronous writes. When 368 * performing a read, we don't request that the DDM cache the data, 369 * as there's little advantage to it. 370 */ 371 if (write) { 372 if ((bp->b_flags & B_ASYNC) == 0) 373 flags = I2O_RBS_BLOCK_WRITE_CACHE_WT; 374 else 375 flags = I2O_RBS_BLOCK_WRITE_CACHE_WB; 376 } else 377 flags = 0; 378 379 /* 380 * Fill the message frame. We can use the block_read structure for 381 * both reads and writes, as it's almost identical to the 382 * block_write structure. 383 */ 384 mf = (struct i2o_rbs_block_read *)mb; 385 mf->msgflags = I2O_MSGFLAGS(i2o_rbs_block_read); 386 mf->msgfunc = I2O_MSGFUNC(sc->sc_ii.ii_tid, 387 write ? I2O_RBS_BLOCK_WRITE : I2O_RBS_BLOCK_READ); 388 mf->msgictx = sc->sc_ii.ii_ictx; 389 mf->msgtctx = im->im_tctx; 390 mf->flags = flags | (1 << 16); /* flags & time multiplier */ 391 mf->datasize = bp->b_bcount; 392 mf->lowoffset = (u_int32_t)ba; 393 mf->highoffset = (u_int32_t)(ba >> 32); 394 395 /* Map the data transfer and enqueue the command. */ 396 rv = iop_msg_map_bio(iop, im, mb, bp->b_data, bp->b_bcount, write); 397 if (rv == 0) { 398 if ((rv = iop_post(iop, mb)) != 0) { 399 iop_msg_unmap(iop, im); 400 iop_msg_free(iop, im); 401 } 402 } 403 return (rv); 404 } 405 406 static int 407 ld_iop_dump(struct ld_softc *ld, void *data, int blkno, int blkcnt) 408 { 409 struct iop_msg *im; 410 struct iop_softc *iop; 411 struct ld_iop_softc *sc; 412 struct i2o_rbs_block_write *mf; 413 int rv, bcount; 414 u_int64_t ba; 415 u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)]; 416 417 sc = device_private(ld->sc_dv); 418 iop = device_private(device_parent(ld->sc_dv)); 419 bcount = blkcnt * ld->sc_secsize; 420 ba = (u_int64_t)blkno * ld->sc_secsize; 421 im = iop_msg_alloc(iop, IM_POLL); 422 423 mf = (struct i2o_rbs_block_write *)mb; 424 mf->msgflags = I2O_MSGFLAGS(i2o_rbs_block_write); 425 mf->msgfunc = I2O_MSGFUNC(sc->sc_ii.ii_tid, I2O_RBS_BLOCK_WRITE); 426 mf->msgictx = sc->sc_ii.ii_ictx; 427 mf->msgtctx = im->im_tctx; 428 mf->flags = I2O_RBS_BLOCK_WRITE_CACHE_WT | (1 << 16); 429 mf->datasize = bcount; 430 mf->lowoffset = (u_int32_t)ba; 431 mf->highoffset = (u_int32_t)(ba >> 32); 432 433 if ((rv = iop_msg_map(iop, im, mb, data, bcount, 1, NULL)) != 0) { 434 iop_msg_free(iop, im); 435 return (rv); 436 } 437 438 rv = iop_msg_post(iop, im, mb, LD_IOP_TIMEOUT * 2); 439 iop_msg_unmap(iop, im); 440 iop_msg_free(iop, im); 441 return (rv); 442 } 443 444 static int 445 ld_iop_flush(struct ld_softc *ld, int flags) 446 { 447 struct iop_msg *im; 448 struct iop_softc *iop; 449 struct ld_iop_softc *sc; 450 struct i2o_rbs_cache_flush mf; 451 int rv; 452 453 sc = device_private(ld->sc_dv); 454 iop = device_private(device_parent(ld->sc_dv)); 455 im = iop_msg_alloc(iop, IM_WAIT); 456 457 mf.msgflags = I2O_MSGFLAGS(i2o_rbs_cache_flush); 458 mf.msgfunc = I2O_MSGFUNC(sc->sc_ii.ii_tid, I2O_RBS_CACHE_FLUSH); 459 mf.msgictx = sc->sc_ii.ii_ictx; 460 mf.msgtctx = im->im_tctx; 461 mf.flags = 1 << 16; /* time multiplier */ 462 463 /* Ancient disks will return an error here. */ 464 rv = iop_msg_post(iop, im, &mf, LD_IOP_TIMEOUT * 2); 465 iop_msg_free(iop, im); 466 return (rv); 467 } 468 469 void 470 ld_iop_intr(device_t dv, struct iop_msg *im, void *reply) 471 { 472 struct i2o_rbs_reply *rb; 473 struct buf *bp; 474 struct ld_iop_softc *sc; 475 struct iop_softc *iop; 476 int err, detail; 477 const char *errstr; 478 479 rb = reply; 480 bp = im->im_dvcontext; 481 sc = device_private(dv); 482 iop = device_private(device_parent(dv)); 483 484 err = ((rb->msgflags & I2O_MSGFLAGS_FAIL) != 0); 485 486 if (!err && rb->reqstatus != I2O_STATUS_SUCCESS) { 487 detail = le16toh(rb->detail); 488 if (detail >= __arraycount(ld_iop_errors)) 489 errstr = "<unknown>"; 490 else 491 errstr = ld_iop_errors[detail]; 492 aprint_error_dev(dv, "error 0x%04x: %s\n", detail, errstr); 493 err = 1; 494 } 495 496 if (err) { 497 bp->b_error = EIO; 498 bp->b_resid = bp->b_bcount; 499 } else 500 bp->b_resid = bp->b_bcount - le32toh(rb->transfercount); 501 502 iop_msg_unmap(iop, im); 503 iop_msg_free(iop, im); 504 lddone(&sc->sc_ld, bp); 505 } 506 507 static void 508 ld_iop_intr_event(device_t dv, struct iop_msg *im, void *reply) 509 { 510 struct i2o_util_event_register_reply *rb; 511 struct ld_iop_softc *sc; 512 struct iop_softc *iop; 513 u_int event; 514 515 rb = reply; 516 517 if ((rb->msgflags & I2O_MSGFLAGS_FAIL) != 0) 518 return; 519 520 event = le32toh(rb->event); 521 sc = device_private(dv); 522 523 if (event == I2O_EVENT_GEN_EVENT_MASK_MODIFIED) { 524 iop = device_private(device_parent(dv)); 525 mutex_spin_enter(&iop->sc_intrlock); 526 sc->sc_flags |= LD_IOP_NEW_EVTMASK; 527 cv_broadcast(&sc->sc_eventii.ii_cv); 528 mutex_spin_exit(&iop->sc_intrlock); 529 return; 530 } 531 532 printf("%s: event 0x%08x received\n", device_xname(dv), event); 533 } 534 535 static void 536 ld_iop_adjqparam(device_t dv, int mpi) 537 { 538 struct ld_iop_softc *sc = device_private(dv); 539 struct iop_softc *iop = device_private(device_parent(dv)); 540 struct ld_softc *ld = &sc->sc_ld; 541 542 /* 543 * AMI controllers seem to loose the plot if you hand off lots of 544 * queued commands. 545 */ 546 if (le16toh(I2O_ORG_AMI) == iop->sc_status.orgid && mpi > 64) 547 mpi = 64; 548 549 ldadjqparam(ld, mpi); 550 } 551