Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/dev/ppbus/immio.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 1998, 1999 Nicolas Souchu 3 * Copyright (c) 2001 Alcove - Nicolas Souchu 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 * 27 * 28 */ 29 30 #include <sys/cdefs.h> 31 __FBSDID("$FreeBSD$"); 32 33 /* 34 * Iomega ZIP+ Matchmaker Parallel Port Interface driver 35 * 36 * Thanks to David Campbell work on the Linux driver and the Iomega specs 37 * Thanks to Thiebault Moeglin for the drive 38 */ 39 #ifdef _KERNEL 40 #include <sys/param.h> 41 #include <sys/systm.h> 42 #include <sys/module.h> 43 #include <sys/bus.h> 44 #include <sys/malloc.h> 45 46 #endif /* _KERNEL */ 47 48 #include "opt_vpo.h" 49 50 #include <dev/ppbus/ppbio.h> 51 #include <dev/ppbus/ppbconf.h> 52 #include <dev/ppbus/ppb_msq.h> 53 #include <dev/ppbus/vpoio.h> 54 #include <dev/ppbus/ppb_1284.h> 55 56 #include "ppbus_if.h" 57 58 #define VP0_SELTMO 5000 /* select timeout */ 59 #define VP0_FAST_SPINTMO 500000 /* wait status timeout */ 60 #define VP0_LOW_SPINTMO 5000000 /* wait status timeout */ 61 62 #define VP0_SECTOR_SIZE 512 63 64 /* 65 * Microcode to execute very fast I/O sequences at the lowest bus level. 66 */ 67 68 #define WAIT_RET MS_PARAM(7, 2, MS_TYP_PTR) 69 #define WAIT_TMO MS_PARAM(1, 0, MS_TYP_INT) 70 71 #define DECLARE_WAIT_MICROSEQUENCE \ 72 struct ppb_microseq wait_microseq[] = { \ 73 MS_CASS(0x0c), \ 74 MS_SET(MS_UNKNOWN), \ 75 /* loop */ \ 76 MS_BRSET(nBUSY, 4 /* ready */), \ 77 MS_DBRA(-2 /* loop */), \ 78 MS_CASS(0x04), \ 79 MS_RET(1), /* timed out */ \ 80 /* ready */ \ 81 MS_CASS(0x04), \ 82 MS_RFETCH(MS_REG_STR, 0xb8, MS_UNKNOWN ), \ 83 MS_RET(0) /* no error */ \ 84 } 85 86 #define SELECT_TARGET MS_PARAM(6, 1, MS_TYP_CHA) 87 88 #define DECLARE_SELECT_MICROSEQUENCE \ 89 struct ppb_microseq select_microseq[] = { \ 90 MS_CASS(0xc), \ 91 /* first, check there is nothing holding onto the bus */ \ 92 MS_SET(VP0_SELTMO), \ 93 /* _loop: */ \ 94 MS_BRCLEAR(0x8, 2 /* _ready */), \ 95 MS_DBRA(-2 /* _loop */), \ 96 MS_RET(2), /* bus busy */ \ 97 /* _ready: */ \ 98 MS_CASS(0x4), \ 99 MS_DASS(MS_UNKNOWN /* 0x80 | 1 << target */), \ 100 MS_DELAY(1), \ 101 MS_CASS(0xc), \ 102 MS_CASS(0xd), \ 103 /* now, wait until the drive is ready */ \ 104 MS_SET(VP0_SELTMO), \ 105 /* loop: */ \ 106 MS_BRSET(0x8, 3 /* ready */), \ 107 MS_DBRA(-2 /* loop */), \ 108 /* error: */ \ 109 MS_CASS(0xc), \ 110 MS_RET(VP0_ESELECT_TIMEOUT), \ 111 /* ready: */ \ 112 MS_CASS(0xc), \ 113 MS_RET(0) \ 114 } 115 116 static struct ppb_microseq transfer_epilog[] = { 117 MS_CASS(0x4), 118 MS_CASS(0xc), 119 MS_CASS(0xe), 120 MS_CASS(0x4), 121 MS_RET(0) 122 }; 123 124 #define CPP_S1 MS_PARAM(10, 2, MS_TYP_PTR) 125 #define CPP_S2 MS_PARAM(13, 2, MS_TYP_PTR) 126 #define CPP_S3 MS_PARAM(16, 2, MS_TYP_PTR) 127 #define CPP_PARAM MS_PARAM(17, 1, MS_TYP_CHA) 128 129 #define DECLARE_CPP_MICROSEQ \ 130 struct ppb_microseq cpp_microseq[] = { \ 131 MS_CASS(0x0c), MS_DELAY(2), \ 132 MS_DASS(0xaa), MS_DELAY(10), \ 133 MS_DASS(0x55), MS_DELAY(10), \ 134 MS_DASS(0x00), MS_DELAY(10), \ 135 MS_DASS(0xff), MS_DELAY(10), \ 136 MS_RFETCH(MS_REG_STR, 0xb8, MS_UNKNOWN /* &s1 */), \ 137 MS_DASS(0x87), MS_DELAY(10), \ 138 MS_RFETCH(MS_REG_STR, 0xb8, MS_UNKNOWN /* &s2 */), \ 139 MS_DASS(0x78), MS_DELAY(10), \ 140 MS_RFETCH(MS_REG_STR, 0x38, MS_UNKNOWN /* &s3 */), \ 141 MS_DASS(MS_UNKNOWN /* param */), \ 142 MS_DELAY(2), \ 143 MS_CASS(0x0c), MS_DELAY(10), \ 144 MS_CASS(0x0d), MS_DELAY(2), \ 145 MS_CASS(0x0c), MS_DELAY(10), \ 146 MS_DASS(0xff), MS_DELAY(10), \ 147 MS_RET(0) \ 148 } 149 150 #define NEGOCIATED_MODE MS_PARAM(2, 1, MS_TYP_CHA) 151 152 #define DECLARE_NEGOCIATE_MICROSEQ \ 153 struct ppb_microseq negociate_microseq[] = { \ 154 MS_CASS(0x4), \ 155 MS_DELAY(5), \ 156 MS_DASS(MS_UNKNOWN /* mode */), \ 157 MS_DELAY(100), \ 158 MS_CASS(0x6), \ 159 MS_DELAY(5), \ 160 MS_BRSET(0x20, 5 /* continue */), \ 161 MS_DELAY(5), \ 162 MS_CASS(0x7), \ 163 MS_DELAY(5), \ 164 MS_CASS(0x6), \ 165 MS_RET(VP0_ENEGOCIATE), \ 166 /* continue: */ \ 167 MS_DELAY(5), \ 168 MS_CASS(0x7), \ 169 MS_DELAY(5), \ 170 MS_CASS(0x6), \ 171 MS_RET(0) \ 172 } 173 174 #define INB_NIBBLE_L MS_PARAM(3, 2, MS_TYP_PTR) 175 #define INB_NIBBLE_H MS_PARAM(6, 2, MS_TYP_PTR) 176 #define INB_NIBBLE_F MS_PARAM(9, 0, MS_TYP_FUN) 177 #define INB_NIBBLE_P MS_PARAM(9, 1, MS_TYP_PTR) 178 179 /* 180 * This is the sub-microseqence for MS_GET in NIBBLE mode 181 * Retrieve the two nibbles and call the C function to generate the character 182 * and store it in the buffer (see nibble_inbyte_hook()) 183 */ 184 185 #define DECLARE_NIBBLE_INBYTE_SUBMICROSEQ \ 186 struct ppb_microseq nibble_inbyte_submicroseq[] = { \ 187 MS_CASS(0x4), \ 188 /* loop: */ \ 189 MS_CASS(0x6), \ 190 MS_DELAY(1), \ 191 MS_RFETCH(MS_REG_STR, MS_FETCH_ALL, MS_UNKNOWN /* low nibble */),\ 192 MS_CASS(0x5), \ 193 MS_DELAY(1), \ 194 MS_RFETCH(MS_REG_STR, MS_FETCH_ALL, MS_UNKNOWN /* high nibble */),\ 195 MS_CASS(0x4), \ 196 MS_DELAY(1), \ 197 /* do a C call to format the received nibbles */ \ 198 MS_C_CALL(MS_UNKNOWN /* C hook */, MS_UNKNOWN /* param */), \ 199 MS_DBRA(-7 /* loop */), \ 200 MS_RET(0) \ 201 } 202 203 static struct ppb_microseq reset_microseq[] = { 204 MS_CASS(0x04), 205 MS_DASS(0x40), 206 MS_DELAY(1), 207 MS_CASS(0x0c), 208 MS_CASS(0x0d), 209 MS_DELAY(50), 210 MS_CASS(0x0c), 211 MS_CASS(0x04), 212 MS_RET(0) 213 }; 214 215 /* 216 * nibble_inbyte_hook() 217 * 218 * Formats high and low nibble into a character 219 */ 220 static int 221 nibble_inbyte_hook (void *p, char *ptr) 222 { 223 struct vpo_nibble *s = (struct vpo_nibble *)p; 224 225 /* increment the buffer pointer */ 226 *ptr = ((s->l >> 4) & 0x0f) + (s->h & 0xf0); 227 228 return (0); 229 } 230 231 /* 232 * This is the sub-microseqence for MS_GET in PS2 mode 233 */ 234 static struct ppb_microseq ps2_inbyte_submicroseq[] = { 235 MS_CASS(0x4), 236 237 /* loop: */ 238 MS_CASS(PCD | 0x6), 239 MS_RFETCH_P(1, MS_REG_DTR, MS_FETCH_ALL), 240 MS_CASS(PCD | 0x5), 241 MS_DBRA(-4 /* loop */), 242 243 MS_RET(0) 244 }; 245 246 /* 247 * This is the sub-microsequence for MS_PUT in both NIBBLE and PS2 modes 248 */ 249 static struct ppb_microseq spp_outbyte_submicroseq[] = { 250 MS_CASS(0x4), 251 252 /* loop: */ 253 MS_RASSERT_P(1, MS_REG_DTR), 254 MS_CASS(0x5), 255 MS_DBRA(0), /* decrement counter */ 256 MS_RASSERT_P(1, MS_REG_DTR), 257 MS_CASS(0x0), 258 MS_DBRA(-6 /* loop */), 259 260 /* return from the put call */ 261 MS_CASS(0x4), 262 MS_RET(0) 263 }; 264 265 /* EPP 1.7 microsequences, ptr and len set at runtime */ 266 static struct ppb_microseq epp17_outstr[] = { 267 MS_CASS(0x4), 268 MS_RASSERT_P(MS_ACCUM, MS_REG_EPP_D), 269 MS_CASS(0xc), 270 MS_RET(0), 271 }; 272 273 static struct ppb_microseq epp17_instr[] = { 274 MS_CASS(PCD | 0x4), 275 MS_RFETCH_P(MS_ACCUM, MS_REG_EPP_D, MS_FETCH_ALL), 276 MS_CASS(PCD | 0xc), 277 MS_RET(0), 278 }; 279 280 static int 281 imm_disconnect(struct vpoio_data *vpo, int *connected, int release_bus) 282 { 283 DECLARE_CPP_MICROSEQ; 284 285 device_t ppbus = device_get_parent(vpo->vpo_dev); 286 char s1, s2, s3; 287 int ret; 288 289 /* all should be ok */ 290 if (connected) 291 *connected = 0; 292 293 ppb_MS_init_msq(cpp_microseq, 4, CPP_S1, (void *)&s1, 294 CPP_S2, (void *)&s2, CPP_S3, (void *)&s3, 295 CPP_PARAM, 0x30); 296 297 ppb_MS_microseq(ppbus, vpo->vpo_dev, cpp_microseq, &ret); 298 299 if ((s1 != (char)0xb8 || s2 != (char)0x18 || s3 != (char)0x38)) { 300 if (bootverbose) 301 device_printf(vpo->vpo_dev, 302 "(disconnect) s1=0x%x s2=0x%x, s3=0x%x\n", 303 s1 & 0xff, s2 & 0xff, s3 & 0xff); 304 if (connected) 305 *connected = VP0_ECONNECT; 306 } 307 308 if (release_bus) 309 return (ppb_release_bus(ppbus, vpo->vpo_dev)); 310 else 311 return (0); 312 } 313 314 /* 315 * how : PPB_WAIT or PPB_DONTWAIT 316 */ 317 static int 318 imm_connect(struct vpoio_data *vpo, int how, int *disconnected, int request_bus) 319 { 320 DECLARE_CPP_MICROSEQ; 321 322 device_t ppbus = device_get_parent(vpo->vpo_dev); 323 char s1, s2, s3; 324 int error; 325 int ret; 326 327 /* all should be ok */ 328 if (disconnected) 329 *disconnected = 0; 330 331 if (request_bus) 332 if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, how))) 333 return (error); 334 335 ppb_MS_init_msq(cpp_microseq, 3, CPP_S1, (void *)&s1, 336 CPP_S2, (void *)&s2, CPP_S3, (void *)&s3); 337 338 /* select device 0 in compatible mode */ 339 ppb_MS_init_msq(cpp_microseq, 1, CPP_PARAM, 0xe0); 340 ppb_MS_microseq(ppbus, vpo->vpo_dev, cpp_microseq, &ret); 341 342 /* disconnect all devices */ 343 ppb_MS_init_msq(cpp_microseq, 1, CPP_PARAM, 0x30); 344 ppb_MS_microseq(ppbus, vpo->vpo_dev, cpp_microseq, &ret); 345 346 if (PPB_IN_EPP_MODE(ppbus)) 347 ppb_MS_init_msq(cpp_microseq, 1, CPP_PARAM, 0x28); 348 else 349 ppb_MS_init_msq(cpp_microseq, 1, CPP_PARAM, 0xe0); 350 351 ppb_MS_microseq(ppbus, vpo->vpo_dev, cpp_microseq, &ret); 352 353 if ((s1 != (char)0xb8 || s2 != (char)0x18 || s3 != (char)0x30)) { 354 if (bootverbose) 355 device_printf(vpo->vpo_dev, 356 "(connect) s1=0x%x s2=0x%x, s3=0x%x\n", 357 s1 & 0xff, s2 & 0xff, s3 & 0xff); 358 if (disconnected) 359 *disconnected = VP0_ECONNECT; 360 } 361 362 return (0); 363 } 364 365 /* 366 * imm_detect() 367 * 368 * Detect and initialise the VP0 adapter. 369 */ 370 static int 371 imm_detect(struct vpoio_data *vpo) 372 { 373 device_t ppbus = device_get_parent(vpo->vpo_dev); 374 int error; 375 376 if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, PPB_DONTWAIT))) 377 return (error); 378 379 /* disconnect the drive, keep the bus */ 380 imm_disconnect(vpo, NULL, 0); 381 382 vpo->vpo_mode_found = VP0_MODE_UNDEFINED; 383 error = 1; 384 385 /* try to enter EPP mode since vpoio failure put the bus in NIBBLE */ 386 if (ppb_set_mode(ppbus, PPB_EPP) != -1) { 387 imm_connect(vpo, PPB_DONTWAIT, &error, 0); 388 } 389 390 /* if connection failed try PS/2 then NIBBLE modes */ 391 if (error) { 392 if (ppb_set_mode(ppbus, PPB_PS2) != -1) { 393 imm_connect(vpo, PPB_DONTWAIT, &error, 0); 394 } 395 if (error) { 396 if (ppb_set_mode(ppbus, PPB_NIBBLE) != -1) { 397 imm_connect(vpo, PPB_DONTWAIT, &error, 0); 398 if (error) 399 goto error; 400 vpo->vpo_mode_found = VP0_MODE_NIBBLE; 401 } else { 402 device_printf(vpo->vpo_dev, 403 "NIBBLE mode unavailable!\n"); 404 goto error; 405 } 406 } else { 407 vpo->vpo_mode_found = VP0_MODE_PS2; 408 } 409 } else { 410 vpo->vpo_mode_found = VP0_MODE_EPP; 411 } 412 413 /* send SCSI reset signal */ 414 ppb_MS_microseq(ppbus, vpo->vpo_dev, reset_microseq, NULL); 415 416 /* release the bus now */ 417 imm_disconnect(vpo, &error, 1); 418 419 /* ensure we are disconnected or daisy chained peripheral 420 * may cause serious problem to the disk */ 421 422 if (error) { 423 if (bootverbose) 424 device_printf(vpo->vpo_dev, 425 "can't disconnect from the drive\n"); 426 goto error; 427 } 428 429 return (0); 430 431 error: 432 ppb_release_bus(ppbus, vpo->vpo_dev); 433 return (VP0_EINITFAILED); 434 } 435 436 /* 437 * imm_outstr() 438 */ 439 static int 440 imm_outstr(struct vpoio_data *vpo, char *buffer, int size) 441 { 442 device_t ppbus = device_get_parent(vpo->vpo_dev); 443 int error = 0; 444 445 if (PPB_IN_EPP_MODE(ppbus)) 446 ppb_reset_epp_timeout(ppbus); 447 448 ppb_MS_exec(ppbus, vpo->vpo_dev, MS_OP_PUT, (union ppb_insarg)buffer, 449 (union ppb_insarg)size, (union ppb_insarg)MS_UNKNOWN, &error); 450 451 return (error); 452 } 453 454 /* 455 * imm_instr() 456 */ 457 static int 458 imm_instr(struct vpoio_data *vpo, char *buffer, int size) 459 { 460 device_t ppbus = device_get_parent(vpo->vpo_dev); 461 int error = 0; 462 463 if (PPB_IN_EPP_MODE(ppbus)) 464 ppb_reset_epp_timeout(ppbus); 465 466 ppb_MS_exec(ppbus, vpo->vpo_dev, MS_OP_GET, (union ppb_insarg)buffer, 467 (union ppb_insarg)size, (union ppb_insarg)MS_UNKNOWN, &error); 468 469 return (error); 470 } 471 472 static char 473 imm_select(struct vpoio_data *vpo, int initiator, int target) 474 { 475 DECLARE_SELECT_MICROSEQUENCE; 476 device_t ppbus = device_get_parent(vpo->vpo_dev); 477 int ret; 478 479 /* initialize the select microsequence */ 480 ppb_MS_init_msq(select_microseq, 1, 481 SELECT_TARGET, 1 << initiator | 1 << target); 482 483 ppb_MS_microseq(ppbus, vpo->vpo_dev, select_microseq, &ret); 484 485 return (ret); 486 } 487 488 /* 489 * imm_wait() 490 * 491 * H_SELIN must be low. 492 * 493 */ 494 static char 495 imm_wait(struct vpoio_data *vpo, int tmo) 496 { 497 DECLARE_WAIT_MICROSEQUENCE; 498 499 device_t ppbus = device_get_parent(vpo->vpo_dev); 500 int ret, err; 501 502 /* 503 * Return some status information. 504 * Semantics : 0x88 = ZIP+ wants more data 505 * 0x98 = ZIP+ wants to send more data 506 * 0xa8 = ZIP+ wants command 507 * 0xb8 = end of transfer, ZIP+ is sending status 508 */ 509 510 ppb_MS_init_msq(wait_microseq, 2, 511 WAIT_RET, (void *)&ret, 512 WAIT_TMO, tmo); 513 514 ppb_MS_microseq(ppbus, vpo->vpo_dev, wait_microseq, &err); 515 516 if (err) 517 return (0); /* command timed out */ 518 519 return(ret); 520 } 521 522 static int 523 imm_negociate(struct vpoio_data *vpo) 524 { 525 DECLARE_NEGOCIATE_MICROSEQ; 526 device_t ppbus = device_get_parent(vpo->vpo_dev); 527 int negociate_mode; 528 int ret; 529 530 if (PPB_IN_NIBBLE_MODE(ppbus)) 531 negociate_mode = 0; 532 else if (PPB_IN_PS2_MODE(ppbus)) 533 negociate_mode = 1; 534 else 535 return (0); 536 537 #if 0 /* XXX use standalone code not to depend on ppb_1284 code yet */ 538 ret = ppb_1284_negociate(ppbus, negociate_mode); 539 540 if (ret) 541 return (VP0_ENEGOCIATE); 542 #endif 543 544 ppb_MS_init_msq(negociate_microseq, 1, 545 NEGOCIATED_MODE, negociate_mode); 546 547 ppb_MS_microseq(ppbus, vpo->vpo_dev, negociate_microseq, &ret); 548 549 return (ret); 550 } 551 552 /* 553 * imm_probe() 554 * 555 * Low level probe of vpo device 556 * 557 */ 558 int 559 imm_probe(device_t dev, struct vpoio_data *vpo) 560 { 561 int error; 562 563 /* ppbus dependent initialisation */ 564 vpo->vpo_dev = dev; 565 566 /* now, try to initialise the drive */ 567 if ((error = imm_detect(vpo))) { 568 return (error); 569 } 570 571 return (0); 572 } 573 574 /* 575 * imm_attach() 576 * 577 * Low level attachment of vpo device 578 * 579 */ 580 int 581 imm_attach(struct vpoio_data *vpo) 582 { 583 DECLARE_NIBBLE_INBYTE_SUBMICROSEQ; 584 device_t ppbus = device_get_parent(vpo->vpo_dev); 585 int error = 0; 586 587 /* 588 * Initialize microsequence code 589 */ 590 vpo->vpo_nibble_inbyte_msq = (struct ppb_microseq *)malloc( 591 sizeof(nibble_inbyte_submicroseq), M_DEVBUF, M_NOWAIT); 592 593 if (!vpo->vpo_nibble_inbyte_msq) 594 return (ENXIO); 595 596 bcopy((void *)nibble_inbyte_submicroseq, 597 (void *)vpo->vpo_nibble_inbyte_msq, 598 sizeof(nibble_inbyte_submicroseq)); 599 600 ppb_MS_init_msq(vpo->vpo_nibble_inbyte_msq, 4, 601 INB_NIBBLE_H, (void *)&(vpo)->vpo_nibble.h, 602 INB_NIBBLE_L, (void *)&(vpo)->vpo_nibble.l, 603 INB_NIBBLE_F, nibble_inbyte_hook, 604 INB_NIBBLE_P, (void *)&(vpo)->vpo_nibble); 605 606 /* 607 * Initialize mode dependent in/out microsequences 608 */ 609 ppb_lock(ppbus); 610 if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, PPB_WAIT))) 611 goto error; 612 613 /* ppbus automatically restore the last mode entered during detection */ 614 switch (vpo->vpo_mode_found) { 615 case VP0_MODE_EPP: 616 ppb_MS_GET_init(ppbus, vpo->vpo_dev, epp17_instr); 617 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, epp17_outstr); 618 device_printf(vpo->vpo_dev, "EPP mode\n"); 619 break; 620 case VP0_MODE_PS2: 621 ppb_MS_GET_init(ppbus, vpo->vpo_dev, ps2_inbyte_submicroseq); 622 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, spp_outbyte_submicroseq); 623 device_printf(vpo->vpo_dev, "PS2 mode\n"); 624 break; 625 case VP0_MODE_NIBBLE: 626 ppb_MS_GET_init(ppbus, vpo->vpo_dev, vpo->vpo_nibble_inbyte_msq); 627 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, spp_outbyte_submicroseq); 628 device_printf(vpo->vpo_dev, "NIBBLE mode\n"); 629 break; 630 default: 631 panic("imm: unknown mode %d", vpo->vpo_mode_found); 632 } 633 634 ppb_release_bus(ppbus, vpo->vpo_dev); 635 error: 636 ppb_unlock(ppbus); 637 return (error); 638 } 639 640 /* 641 * imm_reset_bus() 642 * 643 */ 644 int 645 imm_reset_bus(struct vpoio_data *vpo) 646 { 647 device_t ppbus = device_get_parent(vpo->vpo_dev); 648 int disconnected; 649 650 /* first, connect to the drive and request the bus */ 651 imm_connect(vpo, PPB_WAIT|PPB_INTR, &disconnected, 1); 652 653 if (!disconnected) { 654 655 /* reset the SCSI bus */ 656 ppb_MS_microseq(ppbus, vpo->vpo_dev, reset_microseq, NULL); 657 658 /* then disconnect */ 659 imm_disconnect(vpo, NULL, 1); 660 } 661 662 return (0); 663 } 664 665 /* 666 * imm_do_scsi() 667 * 668 * Send an SCSI command 669 * 670 */ 671 int 672 imm_do_scsi(struct vpoio_data *vpo, int host, int target, char *command, 673 int clen, char *buffer, int blen, int *result, int *count, 674 int *ret) 675 { 676 device_t ppbus = device_get_parent(vpo->vpo_dev); 677 register char r; 678 char l, h = 0; 679 int len, error = 0, not_connected = 0; 680 register int k; 681 int negociated = 0; 682 683 /* 684 * enter disk state, allocate the ppbus 685 * 686 * XXX 687 * Should we allow this call to be interruptible? 688 * The only way to report the interruption is to return 689 * EIO to upper SCSI code :^( 690 */ 691 if ((error = imm_connect(vpo, PPB_WAIT|PPB_INTR, ¬_connected, 1))) 692 return (error); 693 694 if (not_connected) { 695 *ret = VP0_ECONNECT; 696 goto error; 697 } 698 699 /* 700 * Select the drive ... 701 */ 702 if ((*ret = imm_select(vpo,host,target))) 703 goto error; 704 705 /* 706 * Send the command ... 707 */ 708 for (k = 0; k < clen; k+=2) { 709 if (imm_wait(vpo, VP0_FAST_SPINTMO) != (char)0xa8) { 710 *ret = VP0_ECMD_TIMEOUT; 711 goto error; 712 } 713 if (imm_outstr(vpo, &command[k], 2)) { 714 *ret = VP0_EPPDATA_TIMEOUT; 715 goto error; 716 } 717 } 718 719 if (!(r = imm_wait(vpo, VP0_LOW_SPINTMO))) { 720 *ret = VP0_ESTATUS_TIMEOUT; 721 goto error; 722 } 723 724 if ((r & 0x30) == 0x10) { 725 if (imm_negociate(vpo)) { 726 *ret = VP0_ENEGOCIATE; 727 goto error; 728 } else 729 negociated = 1; 730 } 731 732 /* 733 * Complete transfer ... 734 */ 735 *count = 0; 736 for (;;) { 737 738 if (!(r = imm_wait(vpo, VP0_LOW_SPINTMO))) { 739 *ret = VP0_ESTATUS_TIMEOUT; 740 goto error; 741 } 742 743 /* stop when the ZIP+ wants to send status */ 744 if (r == (char)0xb8) 745 break; 746 747 if (*count >= blen) { 748 *ret = VP0_EDATA_OVERFLOW; 749 goto error; 750 } 751 752 /* ZIP+ wants to send data? */ 753 if (r == (char)0x88) { 754 len = (((blen - *count) >= VP0_SECTOR_SIZE)) ? 755 VP0_SECTOR_SIZE : 2; 756 757 error = imm_outstr(vpo, &buffer[*count], len); 758 } else { 759 if (!PPB_IN_EPP_MODE(ppbus)) 760 len = 1; 761 else 762 len = (((blen - *count) >= VP0_SECTOR_SIZE)) ? 763 VP0_SECTOR_SIZE : 1; 764 765 error = imm_instr(vpo, &buffer[*count], len); 766 } 767 768 if (error) { 769 *ret = error; 770 goto error; 771 } 772 773 *count += len; 774 } 775 776 if ((PPB_IN_NIBBLE_MODE(ppbus) || 777 PPB_IN_PS2_MODE(ppbus)) && negociated) 778 ppb_MS_microseq(ppbus, vpo->vpo_dev, transfer_epilog, NULL); 779 780 /* 781 * Retrieve status ... 782 */ 783 if (imm_negociate(vpo)) { 784 *ret = VP0_ENEGOCIATE; 785 goto error; 786 } else 787 negociated = 1; 788 789 if (imm_instr(vpo, &l, 1)) { 790 *ret = VP0_EOTHER; 791 goto error; 792 } 793 794 /* check if the ZIP+ wants to send more status */ 795 if (imm_wait(vpo, VP0_FAST_SPINTMO) == (char)0xb8) 796 if (imm_instr(vpo, &h, 1)) { 797 *ret = VP0_EOTHER + 2; 798 goto error; 799 } 800 801 /* Experience showed that we should discard this */ 802 if (h == (char) -1) 803 h = 0; 804 805 *result = ((int) h << 8) | ((int) l & 0xff); 806 807 error: 808 if ((PPB_IN_NIBBLE_MODE(ppbus) || 809 PPB_IN_PS2_MODE(ppbus)) && negociated) 810 ppb_MS_microseq(ppbus, vpo->vpo_dev, transfer_epilog, NULL); 811 812 /* return to printer state, release the ppbus */ 813 imm_disconnect(vpo, NULL, 1); 814 815 return (0); 816 }
Cache object: f56cfb5d8c9a2a30fca13274c5e9d9ae
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]