umass_scsipi.c revision 1.60
1 /* $NetBSD: umass_scsipi.c,v 1.60 2019/02/10 19:23:55 jdolecek Exp $ */ 2 3 /* 4 * Copyright (c) 2001, 2003, 2012 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Lennart Augustsson (lennart (at) augustsson.net) at 9 * Carlstedt Research & Technology, Charles M. Hamnnum and Matthew R. Green. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #include <sys/cdefs.h> 34 __KERNEL_RCSID(0, "$NetBSD: umass_scsipi.c,v 1.60 2019/02/10 19:23:55 jdolecek Exp $"); 35 36 #ifdef _KERNEL_OPT 37 #include "opt_usb.h" 38 #endif 39 40 #include "atapibus.h" 41 #include "scsibus.h" 42 43 #include <sys/param.h> 44 #include <sys/buf.h> 45 #include <sys/bufq.h> 46 #include <sys/conf.h> 47 #include <sys/device.h> 48 #include <sys/disk.h> /* XXX */ 49 #include <sys/ioctl.h> 50 #include <sys/kernel.h> 51 #include <sys/kmem.h> 52 #include <sys/lwp.h> 53 #include <sys/malloc.h> 54 #include <sys/systm.h> 55 56 /* SCSI & ATAPI */ 57 #include <sys/scsiio.h> 58 #include <dev/scsipi/scsi_spc.h> 59 #include <dev/scsipi/scsi_all.h> 60 #include <dev/scsipi/scsipi_all.h> 61 #include <dev/scsipi/scsiconf.h> 62 63 #include <dev/scsipi/atapiconf.h> 64 65 #include <dev/scsipi/scsipi_disk.h> 66 #include <dev/scsipi/scsi_disk.h> 67 #include <dev/scsipi/scsi_changer.h> 68 69 #include <dev/scsipi/sdvar.h> /* XXX */ 70 71 /* USB */ 72 #include <dev/usb/usb.h> 73 #include <dev/usb/usbdi.h> 74 #include <dev/usb/usbdi_util.h> 75 #include <dev/usb/usbdevs.h> 76 #include <dev/usb/usbhist.h> 77 78 #include <dev/usb/umassvar.h> 79 #include <dev/usb/umass_scsipi.h> 80 81 struct umass_scsipi_softc { 82 struct umassbus_softc base; 83 84 struct atapi_adapter sc_atapi_adapter; 85 #define sc_adapter sc_atapi_adapter._generic 86 struct scsipi_channel sc_channel; 87 usbd_status sc_sync_status; 88 struct scsi_request_sense sc_sense_cmd; 89 }; 90 91 92 #define SHORT_INQUIRY_LENGTH 36 /* XXX */ 93 94 #define UMASS_ATAPI_DRIVE 0 95 96 Static void umass_scsipi_request(struct scsipi_channel *, 97 scsipi_adapter_req_t, void *); 98 Static void umass_scsipi_minphys(struct buf *); 99 Static int umass_scsipi_ioctl(struct scsipi_channel *, u_long, 100 void *, int, proc_t *); 101 Static int umass_scsipi_getgeom(struct scsipi_periph *, 102 struct disk_parms *, u_long); 103 104 Static void umass_scsipi_cb(struct umass_softc *, void *, 105 int, int); 106 Static void umass_scsipi_sense_cb(struct umass_softc *, void *, 107 int, int); 108 109 Static struct umass_scsipi_softc *umass_scsipi_setup(struct umass_softc *); 110 111 #if NATAPIBUS > 0 112 Static void umass_atapi_probe_device(struct atapibus_softc *, int); 113 114 const struct scsipi_bustype umass_atapi_bustype = { 115 SCSIPI_BUSTYPE_ATAPI, 116 atapi_scsipi_cmd, 117 atapi_interpret_sense, 118 atapi_print_addr, 119 scsi_kill_pending, 120 NULL, 121 }; 122 #endif 123 124 125 #if NSCSIBUS > 0 126 int 127 umass_scsi_attach(struct umass_softc *sc) 128 { 129 UMASSHIST_FUNC(); UMASSHIST_CALLED(); 130 struct umass_scsipi_softc *scbus; 131 132 scbus = umass_scsipi_setup(sc); 133 134 scbus->sc_channel.chan_bustype = &scsi_bustype; 135 scbus->sc_channel.chan_ntargets = 2; 136 scbus->sc_channel.chan_nluns = sc->maxlun + 1; 137 scbus->sc_channel.chan_id = scbus->sc_channel.chan_ntargets - 1; 138 DPRINTFM(UDMASS_USB, "sc %#jx: SCSI", (uintptr_t)sc, 0, 0, 0); 139 140 mutex_enter(&sc->sc_lock); 141 sc->sc_refcnt++; 142 mutex_exit(&sc->sc_lock); 143 scbus->base.sc_child = 144 config_found_ia(sc->sc_dev, "scsi", &scbus->sc_channel, 145 scsiprint); 146 mutex_enter(&sc->sc_lock); 147 if (--sc->sc_refcnt < 0) 148 cv_broadcast(&sc->sc_detach_cv); 149 mutex_exit(&sc->sc_lock); 150 151 152 return 0; 153 } 154 155 void 156 umass_scsi_detach(struct umass_softc *sc) 157 { 158 struct umass_scsipi_softc *scbus = (struct umass_scsipi_softc *)sc->bus; 159 160 kmem_free(scbus, sizeof(*scbus)); 161 sc->bus = NULL; 162 } 163 #endif 164 165 #if NATAPIBUS > 0 166 int 167 umass_atapi_attach(struct umass_softc *sc) 168 { 169 UMASSHIST_FUNC(); UMASSHIST_CALLED(); 170 struct umass_scsipi_softc *scbus; 171 172 scbus = umass_scsipi_setup(sc); 173 scbus->sc_atapi_adapter.atapi_probe_device = umass_atapi_probe_device; 174 175 scbus->sc_channel.chan_bustype = &umass_atapi_bustype; 176 scbus->sc_channel.chan_ntargets = 2; 177 scbus->sc_channel.chan_nluns = 1; 178 179 scbus->sc_channel.chan_defquirks |= sc->sc_busquirks; 180 DPRINTFM(UDMASS_USB, "sc %#jxp: ATAPI", (uintptr_t)sc, 0, 0, 0); 181 182 mutex_enter(&sc->sc_lock); 183 sc->sc_refcnt++; 184 mutex_exit(&sc->sc_lock); 185 scbus->base.sc_child = 186 config_found_ia(sc->sc_dev, "atapi", &scbus->sc_channel, 187 atapiprint); 188 mutex_enter(&sc->sc_lock); 189 if (--sc->sc_refcnt < 0) 190 cv_broadcast(&sc->sc_detach_cv); 191 mutex_exit(&sc->sc_lock); 192 193 return 0; 194 } 195 196 void 197 umass_atapi_detach(struct umass_softc *sc) 198 { 199 struct umass_scsipi_softc *scbus = (struct umass_scsipi_softc *)sc->bus; 200 201 kmem_free(scbus, sizeof(*scbus)); 202 sc->bus = NULL; 203 } 204 #endif 205 206 Static struct umass_scsipi_softc * 207 umass_scsipi_setup(struct umass_softc *sc) 208 { 209 struct umass_scsipi_softc *scbus; 210 211 scbus = kmem_zalloc(sizeof(*scbus), KM_SLEEP); 212 sc->bus = &scbus->base; 213 214 /* Only use big commands for USB SCSI devices. */ 215 sc->sc_busquirks |= PQUIRK_ONLYBIG; 216 217 /* Fill in the adapter. */ 218 memset(&scbus->sc_adapter, 0, sizeof(scbus->sc_adapter)); 219 scbus->sc_adapter.adapt_dev = sc->sc_dev; 220 scbus->sc_adapter.adapt_nchannels = 1; 221 scbus->sc_adapter.adapt_request = umass_scsipi_request; 222 scbus->sc_adapter.adapt_minphys = umass_scsipi_minphys; 223 scbus->sc_adapter.adapt_ioctl = umass_scsipi_ioctl; 224 scbus->sc_adapter.adapt_getgeom = umass_scsipi_getgeom; 225 scbus->sc_adapter.adapt_flags = SCSIPI_ADAPT_MPSAFE; 226 227 /* Fill in the channel. */ 228 memset(&scbus->sc_channel, 0, sizeof(scbus->sc_channel)); 229 scbus->sc_channel.chan_adapter = &scbus->sc_adapter; 230 scbus->sc_channel.chan_channel = 0; 231 scbus->sc_channel.chan_flags = SCSIPI_CHAN_OPENINGS | SCSIPI_CHAN_NOSETTLE; 232 scbus->sc_channel.chan_openings = 1; 233 scbus->sc_channel.chan_max_periph = 1; 234 scbus->sc_channel.chan_defquirks |= sc->sc_busquirks; 235 236 return scbus; 237 } 238 239 Static void 240 umass_scsipi_request(struct scsipi_channel *chan, 241 scsipi_adapter_req_t req, void *arg) 242 { 243 UMASSHIST_FUNC(); UMASSHIST_CALLED(); 244 struct scsipi_adapter *adapt = chan->chan_adapter; 245 struct scsipi_periph *periph; 246 struct scsipi_xfer *xs; 247 struct umass_softc *sc = device_private(adapt->adapt_dev); 248 struct umass_scsipi_softc *scbus = (struct umass_scsipi_softc *)sc->bus; 249 struct scsipi_generic *cmd; 250 int cmdlen; 251 int dir; 252 #ifdef UMASS_DEBUG 253 microtime(&sc->tv); 254 #endif 255 switch(req) { 256 case ADAPTER_REQ_RUN_XFER: 257 xs = arg; 258 periph = xs->xs_periph; 259 DIF(UDMASS_UPPER, periph->periph_dbflags |= SCSIPI_DEBUG_FLAGS); 260 261 DPRINTFM(UDMASS_CMD, "sc %#jxp: %jd:%jd xs=%#jxp", 262 (uintptr_t)sc, periph->periph_target, periph->periph_lun, 263 (uintptr_t)xs); 264 DPRINTFM(UDMASS_CMD, "cmd=0x%02jx datalen=%jd (quirks=0x%jx, " 265 "poll=%jd)", xs->cmd->opcode, xs->datalen, 266 periph->periph_quirks, !!(xs->xs_control & XS_CTL_POLL)); 267 #if defined(UMASS_DEBUG) && defined(SCSIPI_DEBUG) 268 if (umassdebug & UDMASS_SCSI) 269 show_scsipi_xs(xs); 270 else if (umassdebug & ~UDMASS_CMD) 271 show_scsipi_cmd(xs); 272 #endif 273 274 if (sc->sc_dying) { 275 xs->error = XS_DRIVER_STUFFUP; 276 goto done; 277 } 278 279 #ifdef UMASS_DEBUG 280 if (SCSIPI_BUSTYPE_TYPE(chan->chan_bustype->bustype_type) == 281 SCSIPI_BUSTYPE_ATAPI ? 282 periph->periph_target != UMASS_ATAPI_DRIVE : 283 periph->periph_target == chan->chan_id) { 284 DPRINTFM(UDMASS_SCSI, "sc %#jx: wrong SCSI ID %jd", 285 (uintptr_t)sc, periph->periph_target, 0, 0); 286 xs->error = XS_DRIVER_STUFFUP; 287 goto done; 288 } 289 #endif 290 291 cmd = xs->cmd; 292 cmdlen = xs->cmdlen; 293 294 dir = DIR_NONE; 295 if (xs->datalen) { 296 switch (xs->xs_control & 297 (XS_CTL_DATA_IN | XS_CTL_DATA_OUT)) { 298 case XS_CTL_DATA_IN: 299 dir = DIR_IN; 300 break; 301 case XS_CTL_DATA_OUT: 302 dir = DIR_OUT; 303 break; 304 } 305 } 306 307 if (xs->datalen > UMASS_MAX_TRANSFER_SIZE) { 308 printf("umass_cmd: large datalen, %d\n", xs->datalen); 309 xs->error = XS_DRIVER_STUFFUP; 310 goto done; 311 } 312 313 if (xs->xs_control & XS_CTL_POLL) { 314 /* Use sync transfer. XXX Broken! */ 315 DPRINTFM(UDMASS_SCSI, "sync dir=%jd\n", dir, 0, 0, 0); 316 scbus->sc_sync_status = USBD_INVAL; 317 sc->sc_methods->wire_xfer(sc, periph->periph_lun, cmd, 318 cmdlen, xs->data, 319 xs->datalen, dir, 320 xs->timeout, USBD_SYNCHRONOUS, 321 0, xs); 322 DPRINTFM(UDMASS_SCSI, "done err=%jd", 323 scbus->sc_sync_status, 0, 0, 0); 324 switch (scbus->sc_sync_status) { 325 case USBD_NORMAL_COMPLETION: 326 xs->error = XS_NOERROR; 327 break; 328 case USBD_TIMEOUT: 329 xs->error = XS_TIMEOUT; 330 break; 331 default: 332 xs->error = XS_DRIVER_STUFFUP; 333 break; 334 } 335 goto done; 336 } else { 337 DPRINTFM(UDMASS_SCSI, "async dir=%jd, cmdlen=%jd" 338 " datalen=%jd", dir, cmdlen, xs->datalen, 0); 339 sc->sc_methods->wire_xfer(sc, periph->periph_lun, cmd, 340 cmdlen, xs->data, 341 xs->datalen, dir, 342 xs->timeout, 0, 343 umass_scsipi_cb, xs); 344 return; 345 } 346 347 /* Return if command finishes early. */ 348 done: 349 scsipi_done(xs); 350 return; 351 default: 352 /* Not supported, nothing to do. */ 353 ; 354 } 355 } 356 357 Static void 358 umass_scsipi_minphys(struct buf *bp) 359 { 360 #ifdef DIAGNOSTIC 361 if (bp->b_bcount <= 0) { 362 printf("umass_scsipi_minphys count(%d) <= 0\n", 363 bp->b_bcount); 364 bp->b_bcount = UMASS_MAX_TRANSFER_SIZE; 365 } 366 #endif 367 if (bp->b_bcount > UMASS_MAX_TRANSFER_SIZE) 368 bp->b_bcount = UMASS_MAX_TRANSFER_SIZE; 369 minphys(bp); 370 } 371 372 int 373 umass_scsipi_ioctl(struct scsipi_channel *chan, u_long cmd, 374 void *arg, int flag, proc_t *p) 375 { 376 /*struct umass_softc *sc = link->adapter_softc;*/ 377 /*struct umass_scsipi_softc *scbus = sc->bus;*/ 378 379 switch (cmd) { 380 #if 0 381 case SCBUSIORESET: 382 ccb->ccb_h.status = CAM_REQ_INPROG; 383 umass_reset(sc, umass_cam_cb, (void *) ccb); 384 return 0; 385 #endif 386 default: 387 return ENOTTY; 388 } 389 } 390 391 Static int 392 umass_scsipi_getgeom(struct scsipi_periph *periph, struct disk_parms *dp, 393 u_long sectors) 394 { 395 struct umass_softc *sc = 396 device_private(periph->periph_channel->chan_adapter->adapt_dev); 397 398 /* If it's not a floppy, we don't know what to do. */ 399 if (sc->sc_cmd != UMASS_CPROTO_UFI) 400 return 0; 401 402 switch (sectors) { 403 case 1440: 404 /* Most likely a single density 3.5" floppy. */ 405 dp->heads = 2; 406 dp->sectors = 9; 407 dp->cyls = 80; 408 return 1; 409 case 2880: 410 /* Most likely a double density 3.5" floppy. */ 411 dp->heads = 2; 412 dp->sectors = 18; 413 dp->cyls = 80; 414 return 1; 415 default: 416 return 0; 417 } 418 } 419 420 Static void 421 umass_scsipi_cb(struct umass_softc *sc, void *priv, int residue, int status) 422 { 423 UMASSHIST_FUNC(); UMASSHIST_CALLED(); 424 struct umass_scsipi_softc *scbus = (struct umass_scsipi_softc *)sc->bus; 425 struct scsipi_xfer *xs = priv; 426 struct scsipi_periph *periph = xs->xs_periph; 427 int cmdlen, senselen; 428 #ifdef UMASS_DEBUG 429 struct timeval tv; 430 u_int delta; 431 microtime(&tv); 432 delta = (tv.tv_sec - sc->tv.tv_sec) * 1000000 + tv.tv_usec - sc->tv.tv_usec; 433 DPRINTFM(UDMASS_CMD, "delta=%ju: xs=%#jx residue=%jd status=%jd", 434 delta, (uintptr_t)xs, residue, status); 435 #endif 436 437 438 xs->resid = residue; 439 440 switch (status) { 441 case STATUS_CMD_OK: 442 xs->error = XS_NOERROR; 443 break; 444 445 case STATUS_CMD_UNKNOWN: 446 /* FALLTHROUGH */ 447 case STATUS_CMD_FAILED: 448 /* fetch sense data */ 449 sc->sc_sense = 1; 450 memset(&scbus->sc_sense_cmd, 0, sizeof(scbus->sc_sense_cmd)); 451 scbus->sc_sense_cmd.opcode = SCSI_REQUEST_SENSE; 452 scbus->sc_sense_cmd.byte2 = periph->periph_lun << 453 SCSI_CMD_LUN_SHIFT; 454 455 if (sc->sc_cmd == UMASS_CPROTO_UFI || 456 sc->sc_cmd == UMASS_CPROTO_ATAPI) 457 cmdlen = UFI_COMMAND_LENGTH; /* XXX */ 458 else 459 cmdlen = sizeof(scbus->sc_sense_cmd); 460 if (periph->periph_version < 0x05) /* SPC-3 */ 461 senselen = 18; 462 else 463 senselen = sizeof(xs->sense); 464 scbus->sc_sense_cmd.length = senselen; 465 sc->sc_methods->wire_xfer(sc, periph->periph_lun, 466 &scbus->sc_sense_cmd, cmdlen, 467 &xs->sense, senselen, 468 DIR_IN, xs->timeout, 0, 469 umass_scsipi_sense_cb, xs); 470 return; 471 472 case STATUS_WIRE_FAILED: 473 xs->error = XS_RESET; 474 break; 475 476 case STATUS_TIMEOUT: 477 xs->error = XS_TIMEOUT; 478 break; 479 480 default: 481 panic("%s: Unknown status %d in umass_scsipi_cb", 482 device_xname(sc->sc_dev), status); 483 } 484 485 DPRINTFM(UDMASS_CMD, "return xs->error=%jd, xs->xs_status=0x%jx" 486 " xs->resid=%jd", xs->error, xs->xs_status, xs->resid, 0); 487 488 scsipi_done(xs); 489 } 490 491 /* 492 * Finalise a completed autosense operation 493 */ 494 Static void 495 umass_scsipi_sense_cb(struct umass_softc *sc, void *priv, int residue, 496 int status) 497 { 498 UMASSHIST_FUNC(); UMASSHIST_CALLED(); 499 struct scsipi_xfer *xs = priv; 500 501 DPRINTFM(UDMASS_CMD, "sc %#jx: xs=%#jx residue=%jd status=%jd", 502 (uintptr_t)sc, (uintptr_t)xs, residue, status); 503 504 sc->sc_sense = 0; 505 switch (status) { 506 case STATUS_CMD_OK: 507 case STATUS_CMD_UNKNOWN: 508 /* getting sense data succeeded */ 509 if (residue == 0 || residue == 14)/* XXX */ 510 xs->error = XS_SENSE; 511 else 512 xs->error = XS_SHORTSENSE; 513 break; 514 default: 515 DPRINTFM(UDMASS_SCSI, "sc %#jx: Autosense failed, status %jd", 516 (uintptr_t)sc, status, 0, 0); 517 xs->error = XS_DRIVER_STUFFUP; 518 break; 519 } 520 521 DPRINTFM(UDMASS_CMD, "return xs->error=%jd, xs->xs_status=0x%jx" 522 " xs->resid=%jd", xs->error, xs->xs_status, xs->resid, 0); 523 524 scsipi_done(xs); 525 } 526 527 #if NATAPIBUS > 0 528 Static void 529 umass_atapi_probe_device(struct atapibus_softc *atapi, int target) 530 { 531 UMASSHIST_FUNC(); UMASSHIST_CALLED(); 532 struct scsipi_channel *chan = atapi->sc_channel; 533 struct scsipi_periph *periph; 534 struct scsipibus_attach_args sa; 535 char vendor[33], product[65], revision[17]; 536 struct scsipi_inquiry_data inqbuf; 537 538 DPRINTFM(UDMASS_SCSI, "atapi=%#jx target=%jd", (uintptr_t)atapi, 539 target, 0, 0); 540 541 if (target != UMASS_ATAPI_DRIVE) /* only probe drive 0 */ 542 return; 543 544 /* skip if already attached */ 545 if (scsipi_lookup_periph(chan, target, 0) != NULL) { 546 return; 547 } 548 549 periph = scsipi_alloc_periph(M_NOWAIT); 550 if (periph == NULL) { 551 aprint_error_dev(atapi->sc_dev, 552 "can't allocate link for drive %d\n", target); 553 return; 554 } 555 556 DIF(UDMASS_UPPER, periph->periph_dbflags |= 1); /* XXX 1 */ 557 periph->periph_channel = chan; 558 periph->periph_switch = &atapi_probe_periphsw; 559 periph->periph_target = target; 560 periph->periph_quirks = chan->chan_defquirks; 561 562 DPRINTFM(UDMASS_SCSI, "doing inquiry", 0, 0, 0, 0); 563 /* Now go ask the device all about itself. */ 564 memset(&inqbuf, 0, sizeof(inqbuf)); 565 if (scsipi_inquire(periph, &inqbuf, XS_CTL_DISCOVERY) != 0) { 566 DPRINTFM(UDMASS_SCSI, "scsipi_inquire failed", 0, 0, 0, 0); 567 free(periph, M_DEVBUF); 568 return; 569 } 570 571 strnvisx(vendor, sizeof(vendor), inqbuf.vendor, 8, 572 VIS_TRIM|VIS_SAFE|VIS_OCTAL); 573 strnvisx(product, sizeof(product), inqbuf.product, 16, 574 VIS_TRIM|VIS_SAFE|VIS_OCTAL); 575 strnvisx(revision, sizeof(revision), inqbuf.revision, 4, 576 VIS_TRIM|VIS_SAFE|VIS_OCTAL); 577 578 sa.sa_periph = periph; 579 sa.sa_inqbuf.type = inqbuf.device; 580 sa.sa_inqbuf.removable = inqbuf.dev_qual2 & SID_REMOVABLE ? 581 T_REMOV : T_FIXED; 582 if (sa.sa_inqbuf.removable) 583 periph->periph_flags |= PERIPH_REMOVABLE; 584 sa.sa_inqbuf.vendor = vendor; 585 sa.sa_inqbuf.product = product; 586 sa.sa_inqbuf.revision = revision; 587 sa.sa_inqptr = NULL; 588 589 atapi_probe_device(atapi, target, periph, &sa); 590 /* atapi_probe_device() frees the periph when there is no device.*/ 591 } 592 #endif 593
Indexes created Mon Sep 29 03:10:08 GMT 2025