atppc.c revision 1.15
1 /* $NetBSD: atppc.c,v 1.15 2004/02/24 17:41:09 drochner Exp $ */ 2 3 /* 4 * Copyright (c) 2001 Alcove - Nicolas Souchu 5 * Copyright (c) 2003, 2004 Gary Thorpe <gathorpe (at) users.sourceforge.net> 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * FreeBSD: src/sys/isa/ppc.c,v 1.26.2.5 2001/10/02 05:21:45 nsouch Exp 30 * 31 */ 32 33 #include <sys/cdefs.h> 34 __KERNEL_RCSID(0, "$NetBSD: atppc.c,v 1.15 2004/02/24 17:41:09 drochner Exp $"); 35 36 #include "opt_atppc.h" 37 38 #include <sys/types.h> 39 #include <sys/param.h> 40 #include <sys/kernel.h> 41 #include <sys/device.h> 42 #include <sys/malloc.h> 43 #include <sys/proc.h> 44 #include <sys/systm.h> 45 #include <sys/vnode.h> 46 #include <sys/syslog.h> 47 48 #include <machine/bus.h> 49 /*#include <machine/intr.h>*/ 50 51 #include <dev/isa/isareg.h> 52 53 #include <dev/ic/atppcreg.h> 54 #include <dev/ic/atppcvar.h> 55 56 #include <dev/ppbus/ppbus_conf.h> 57 #include <dev/ppbus/ppbus_msq.h> 58 #include <dev/ppbus/ppbus_io.h> 59 #include <dev/ppbus/ppbus_var.h> 60 61 #ifdef ATPPC_DEBUG 62 int atppc_debug = 1; 63 #endif 64 65 #ifdef ATPPC_VERBOSE 66 int atppc_verbose = 1; 67 #endif 68 69 /* List of supported chipsets detection routines */ 70 static int (*chipset_detect[])(struct atppc_softc *) = { 71 /* XXX Add these LATER: maybe as seperate devices? 72 atppc_pc873xx_detect, 73 atppc_smc37c66xgt_detect, 74 atppc_w83877f_detect, 75 atppc_smc37c935_detect, 76 */ 77 NULL 78 }; 79 80 81 /* Prototypes for functions. */ 82 83 /* Soft configuration attach */ 84 void atppc_sc_attach(struct atppc_softc *); 85 int atppc_sc_detach(struct atppc_softc *, int); 86 87 /* Interrupt handler for atppc device */ 88 int atppcintr(void *); 89 90 /* Print function for config_found_sm() */ 91 static int atppc_print(void *, const char *); 92 93 /* Detection routines */ 94 static int atppc_detect_fifo(struct atppc_softc *); 95 static int atppc_detect_chipset(struct atppc_softc *); 96 static int atppc_detect_generic(struct atppc_softc *); 97 98 /* Routines for ppbus interface (bus + device) */ 99 static int atppc_read(struct device *, char *, int, int, size_t *); 100 static int atppc_write(struct device *, char *, int, int, size_t *); 101 static int atppc_setmode(struct device *, int); 102 static int atppc_getmode(struct device *); 103 static int atppc_check_epp_timeout(struct device *); 104 static void atppc_reset_epp_timeout(struct device *); 105 static void atppc_ecp_sync(struct device *); 106 static int atppc_exec_microseq(struct device *, struct ppbus_microseq * *); 107 static u_int8_t atppc_io(struct device *, int, u_char *, int, u_char); 108 static int atppc_read_ivar(struct device *, int, unsigned int *); 109 static int atppc_write_ivar(struct device *, int, unsigned int *); 110 static int atppc_add_handler(struct device *, void (*)(void *), void *); 111 static int atppc_remove_handler(struct device *, void (*)(void *)); 112 113 /* Utility functions */ 114 115 /* Functions to read bytes into device's input buffer */ 116 static void atppc_nibble_read(struct atppc_softc * const); 117 static void atppc_byte_read(struct atppc_softc * const); 118 static void atppc_epp_read(struct atppc_softc * const); 119 static void atppc_ecp_read(struct atppc_softc * const); 120 static void atppc_ecp_read_dma(struct atppc_softc *, unsigned int *, 121 unsigned char); 122 static void atppc_ecp_read_pio(struct atppc_softc *, unsigned int *, 123 unsigned char); 124 static void atppc_ecp_read_error(struct atppc_softc *, const unsigned int); 125 126 127 /* Functions to write bytes to device's output buffer */ 128 static void atppc_std_write(struct atppc_softc * const); 129 static void atppc_epp_write(struct atppc_softc * const); 130 static void atppc_fifo_write(struct atppc_softc * const); 131 static void atppc_fifo_write_dma(struct atppc_softc * const, unsigned char, 132 unsigned char); 133 static void atppc_fifo_write_pio(struct atppc_softc * const, unsigned char, 134 unsigned char); 135 static void atppc_fifo_write_error(struct atppc_softc * const, 136 const unsigned int); 137 138 /* Miscellaneous */ 139 static int atppc_poll_str(const struct atppc_softc * const, const u_int8_t, 140 const u_int8_t); 141 static int atppc_wait_interrupt(struct atppc_softc * const, const caddr_t, 142 const u_int8_t); 143 144 145 /* 146 * Generic attach and detach functions for atppc device. If sc_dev_ok in soft 147 * configuration data is not ATPPC_ATTACHED, these should be skipped altogether. 148 */ 149 150 /* Soft configuration attach for atppc */ 151 void 152 atppc_sc_attach(struct atppc_softc *lsc) 153 { 154 /* Adapter used to configure ppbus device */ 155 struct parport_adapter sc_parport_adapter; 156 char buf[64]; 157 158 /* Probe and set up chipset */ 159 if (atppc_detect_chipset(lsc) != 0) { 160 if (atppc_detect_generic(lsc) != 0) { 161 ATPPC_DPRINTF(("%s: Error detecting chipset\n", 162 lsc->sc_dev.dv_xname)); 163 } 164 } 165 166 /* Probe and setup FIFO queue */ 167 if (atppc_detect_fifo(lsc) == 0) { 168 printf("%s: FIFO <depth,wthr,rthr>=<%d,%d,%d>\n", 169 lsc->sc_dev.dv_xname, lsc->sc_fifo, lsc->sc_wthr, 170 lsc->sc_rthr); 171 } 172 173 /* Print out chipset capabilities */ 174 bitmask_snprintf(lsc->sc_has, "\20\1INTR\2DMA\3FIFO\4PS2\5ECP\6EPP", 175 buf, sizeof(buf)); 176 printf("%s: capabilities=%s\n", lsc->sc_dev.dv_xname, buf); 177 178 /* Initialize device's buffer pointers */ 179 lsc->sc_outb = lsc->sc_outbstart = lsc->sc_inb = lsc->sc_inbstart 180 = NULL; 181 lsc->sc_inb_nbytes = lsc->sc_outb_nbytes = 0; 182 183 /* Last configuration step: set mode to standard mode */ 184 if (atppc_setmode(&(lsc->sc_dev), PPBUS_COMPATIBLE) != 0) { 185 ATPPC_DPRINTF(("%s: unable to initialize mode.\n", 186 lsc->sc_dev.dv_xname)); 187 } 188 189 #if defined (MULTIPROCESSOR) || defined (LOCKDEBUG) 190 /* Initialize lock structure */ 191 simple_lock_init(&(lsc->sc_lock)); 192 #endif 193 194 /* Set up parport_adapter structure */ 195 196 /* Set capabilites */ 197 sc_parport_adapter.capabilities = 0; 198 if (lsc->sc_has & ATPPC_HAS_INTR) { 199 sc_parport_adapter.capabilities |= PPBUS_HAS_INTR; 200 } 201 if (lsc->sc_has & ATPPC_HAS_DMA) { 202 sc_parport_adapter.capabilities |= PPBUS_HAS_DMA; 203 } 204 if (lsc->sc_has & ATPPC_HAS_FIFO) { 205 sc_parport_adapter.capabilities |= PPBUS_HAS_FIFO; 206 } 207 if (lsc->sc_has & ATPPC_HAS_PS2) { 208 sc_parport_adapter.capabilities |= PPBUS_HAS_PS2; 209 } 210 if (lsc->sc_has & ATPPC_HAS_EPP) { 211 sc_parport_adapter.capabilities |= PPBUS_HAS_EPP; 212 } 213 if (lsc->sc_has & ATPPC_HAS_ECP) { 214 sc_parport_adapter.capabilities |= PPBUS_HAS_ECP; 215 } 216 217 /* Set function pointers */ 218 sc_parport_adapter.parport_io = atppc_io; 219 sc_parport_adapter.parport_exec_microseq = atppc_exec_microseq; 220 sc_parport_adapter.parport_reset_epp_timeout = 221 atppc_reset_epp_timeout; 222 sc_parport_adapter.parport_setmode = atppc_setmode; 223 sc_parport_adapter.parport_getmode = atppc_getmode; 224 sc_parport_adapter.parport_ecp_sync = atppc_ecp_sync; 225 sc_parport_adapter.parport_read = atppc_read; 226 sc_parport_adapter.parport_write = atppc_write; 227 sc_parport_adapter.parport_read_ivar = atppc_read_ivar; 228 sc_parport_adapter.parport_write_ivar = atppc_write_ivar; 229 sc_parport_adapter.parport_dma_malloc = lsc->sc_dma_malloc; 230 sc_parport_adapter.parport_dma_free = lsc->sc_dma_free; 231 sc_parport_adapter.parport_add_handler = atppc_add_handler; 232 sc_parport_adapter.parport_remove_handler = atppc_remove_handler; 233 234 /* Initialize handler list, may be added to by grandchildren */ 235 SLIST_INIT(&(lsc->sc_handler_listhead)); 236 237 /* Initialize interrupt state */ 238 lsc->sc_irqstat = ATPPC_IRQ_NONE; 239 lsc->sc_ecr_intr = lsc->sc_ctr_intr = lsc->sc_str_intr = 0; 240 241 /* Disable DMA/interrupts (each ppbus driver selects usage itself) */ 242 lsc->sc_use = 0; 243 244 /* Configure child of the device. */ 245 lsc->child = config_found_sm(&(lsc->sc_dev), &(sc_parport_adapter), 246 atppc_print, NULL); 247 248 return; 249 } 250 251 /* Soft configuration detach */ 252 int atppc_sc_detach(struct atppc_softc *lsc, int flag) 253 { 254 struct device *dev = (struct device *)lsc; 255 256 /* Detach children devices */ 257 if (config_detach(lsc->child, flag) && !(flag & DETACH_QUIET)) { 258 printf("%s not able to detach child device, ", dev->dv_xname); 259 260 if (!(flag & DETACH_FORCE)) { 261 printf("cannot detach\n"); 262 return 1; 263 } else { 264 printf("continuing (DETACH_FORCE)\n"); 265 } 266 } 267 268 if (!(flag & DETACH_QUIET)) 269 printf("%s detached", dev->dv_xname); 270 271 return 0; 272 } 273 274 /* Used by config_found_sm() to print out device information */ 275 static int 276 atppc_print(void *aux, const char *name) 277 { 278 /* Print out something on failure. */ 279 if (name != NULL) { 280 printf("%s: child devices", name); 281 return UNCONF; 282 } 283 284 return QUIET; 285 } 286 287 /* 288 * Machine independent detection routines for atppc driver. 289 */ 290 291 /* Detect parallel port I/O port: taken from FreeBSD code directly. */ 292 int 293 atppc_detect_port(bus_space_tag_t iot, bus_space_handle_t ioh) 294 { 295 /* 296 * Much shorter than scheme used by lpt_isa_probe() and lpt_port_test() 297 * in original lpt driver. 298 * Write to data register common to all controllers and read back the 299 * values. Also tests control and status registers. 300 */ 301 302 /* 303 * Cannot use convenient macros because the device's config structure 304 * may not have been created yet: major change from FreeBSD code. 305 */ 306 307 int rval; 308 u_int8_t ctr_sav, dtr_sav, str_sav; 309 310 /* Store writtable registers' values and test if they can be read */ 311 str_sav = bus_space_read_1(iot, ioh, ATPPC_SPP_STR); 312 ctr_sav = bus_space_read_1(iot, ioh, ATPPC_SPP_CTR); 313 dtr_sav = bus_space_read_1(iot, ioh, ATPPC_SPP_DTR); 314 bus_space_barrier(iot, ioh, 0, IO_LPTSIZE, 315 BUS_SPACE_BARRIER_READ); 316 317 /* 318 * Ensure PS2 ports in output mode, also read back value of control 319 * register. 320 */ 321 bus_space_write_1(iot, ioh, ATPPC_SPP_CTR, 0x0c); 322 bus_space_barrier(iot, ioh, 0, IO_LPTSIZE, 323 BUS_SPACE_BARRIER_WRITE); 324 325 if (bus_space_read_1(iot, ioh, ATPPC_SPP_CTR) != 0x0c) { 326 rval = 0; 327 } else { 328 /* 329 * Test if two values can be written and read from the data 330 * register. 331 */ 332 bus_space_barrier(iot, ioh, 0, IO_LPTSIZE, 333 BUS_SPACE_BARRIER_READ); 334 bus_space_write_1(iot, ioh, ATPPC_SPP_DTR, 0xaa); 335 bus_space_barrier(iot, ioh, 0, IO_LPTSIZE, 336 BUS_SPACE_BARRIER_WRITE); 337 if (bus_space_read_1(iot, ioh, ATPPC_SPP_DTR) != 0xaa) { 338 rval = 1; 339 } else { 340 /* Second value to test */ 341 bus_space_barrier(iot, ioh, 0, IO_LPTSIZE, 342 BUS_SPACE_BARRIER_READ); 343 bus_space_write_1(iot, ioh, ATPPC_SPP_DTR, 0x55); 344 bus_space_barrier(iot, ioh, 0, IO_LPTSIZE, 345 BUS_SPACE_BARRIER_WRITE); 346 if (bus_space_read_1(iot, ioh, ATPPC_SPP_DTR) != 0x55) { 347 rval = 1; 348 } else { 349 rval = 0; 350 } 351 } 352 353 } 354 355 /* Restore registers */ 356 bus_space_barrier(iot, ioh, 0, IO_LPTSIZE, 357 BUS_SPACE_BARRIER_READ); 358 bus_space_write_1(iot, ioh, ATPPC_SPP_CTR, ctr_sav); 359 bus_space_write_1(iot, ioh, ATPPC_SPP_DTR, dtr_sav); 360 bus_space_write_1(iot, ioh, ATPPC_SPP_STR, str_sav); 361 bus_space_barrier(iot, ioh, 0, IO_LPTSIZE, 362 BUS_SPACE_BARRIER_WRITE); 363 364 return rval; 365 } 366 367 /* Detect parallel port chipset. */ 368 static int 369 atppc_detect_chipset(struct atppc_softc *atppc) 370 { 371 /* Try each detection routine. */ 372 int i, mode; 373 for (i = 0; chipset_detect[i] != NULL; i++) { 374 if ((mode = chipset_detect[i](atppc)) != -1) { 375 atppc->sc_mode = mode; 376 return 0; 377 } 378 } 379 380 return 1; 381 } 382 383 /* Detect generic capabilities. */ 384 static int 385 atppc_detect_generic(struct atppc_softc *atppc) 386 { 387 u_int8_t ecr_sav = atppc_r_ecr(atppc); 388 u_int8_t ctr_sav = atppc_r_ctr(atppc); 389 u_int8_t str_sav = atppc_r_str(atppc); 390 u_int8_t tmp; 391 atppc_barrier_r(atppc); 392 393 /* Default to generic */ 394 atppc->sc_type = ATPPC_TYPE_GENERIC; 395 atppc->sc_model = GENERIC; 396 397 /* Check for ECP */ 398 tmp = atppc_r_ecr(atppc); 399 atppc_barrier_r(atppc); 400 if ((tmp & ATPPC_FIFO_EMPTY) && !(tmp & ATPPC_FIFO_FULL)) { 401 atppc_w_ecr(atppc, 0x34); 402 atppc_barrier_w(atppc); 403 tmp = atppc_r_ecr(atppc); 404 atppc_barrier_r(atppc); 405 if (tmp == 0x35) { 406 atppc->sc_has |= ATPPC_HAS_ECP; 407 } 408 } 409 410 /* Allow search for SMC style ECP+EPP mode */ 411 if (atppc->sc_has & ATPPC_HAS_ECP) { 412 atppc_w_ecr(atppc, ATPPC_ECR_EPP); 413 atppc_barrier_w(atppc); 414 } 415 /* Check for EPP by checking for timeout bit */ 416 if (atppc_check_epp_timeout(&(atppc->sc_dev)) != 0) { 417 atppc->sc_has |= ATPPC_HAS_EPP; 418 atppc->sc_epp = ATPPC_EPP_1_9; 419 if (atppc->sc_has & ATPPC_HAS_ECP) { 420 /* SMC like chipset found */ 421 atppc->sc_model = SMC_LIKE; 422 atppc->sc_type = ATPPC_TYPE_SMCLIKE; 423 } 424 } 425 426 /* Detect PS2 mode */ 427 if (atppc->sc_has & ATPPC_HAS_ECP) { 428 /* Put ECP port into PS2 mode */ 429 atppc_w_ecr(atppc, ATPPC_ECR_PS2); 430 atppc_barrier_w(atppc); 431 } 432 /* Put PS2 port in input mode: writes should not be readable */ 433 atppc_w_ctr(atppc, 0x20); 434 atppc_barrier_w(atppc); 435 /* 436 * Write two values to data port: if neither are read back, 437 * bidirectional mode is functional. 438 */ 439 atppc_w_dtr(atppc, 0xaa); 440 atppc_barrier_w(atppc); 441 tmp = atppc_r_dtr(atppc); 442 atppc_barrier_r(atppc); 443 if (tmp != 0xaa) { 444 atppc_w_dtr(atppc, 0x55); 445 atppc_barrier_w(atppc); 446 tmp = atppc_r_dtr(atppc); 447 atppc_barrier_r(atppc); 448 if (tmp != 0x55) { 449 atppc->sc_has |= ATPPC_HAS_PS2; 450 } 451 } 452 453 /* Restore to previous state */ 454 atppc_w_ecr(atppc, ecr_sav); 455 atppc_w_ctr(atppc, ctr_sav); 456 atppc_w_str(atppc, str_sav); 457 atppc_barrier_w(atppc); 458 459 return 0; 460 } 461 462 /* 463 * Detect parallel port FIFO: taken from FreeBSD code directly. 464 */ 465 static int 466 atppc_detect_fifo(struct atppc_softc *atppc) 467 { 468 #ifdef ATPPC_DEBUG 469 struct device *dev = (struct device *)atppc; 470 #endif 471 u_int8_t ecr_sav; 472 u_int8_t ctr_sav; 473 u_int8_t str_sav; 474 u_int8_t cc; 475 short i; 476 477 /* If there is no ECP mode, we cannot config a FIFO */ 478 if (!(atppc->sc_has & ATPPC_HAS_ECP)) { 479 return (EINVAL); 480 } 481 482 /* save registers */ 483 ecr_sav = atppc_r_ecr(atppc); 484 ctr_sav = atppc_r_ctr(atppc); 485 str_sav = atppc_r_str(atppc); 486 atppc_barrier_r(atppc); 487 488 /* Enter ECP configuration mode, no interrupt, no DMA */ 489 atppc_w_ecr(atppc, (ATPPC_ECR_CFG | ATPPC_SERVICE_INTR) & 490 ~ATPPC_ENABLE_DMA); 491 atppc_barrier_w(atppc); 492 493 /* read PWord size - transfers in FIFO mode must be PWord aligned */ 494 atppc->sc_pword = (atppc_r_cnfgA(atppc) & ATPPC_PWORD_MASK); 495 atppc_barrier_r(atppc); 496 497 /* XXX 16 and 32 bits implementations not supported */ 498 if (atppc->sc_pword != ATPPC_PWORD_8) { 499 ATPPC_DPRINTF(("%s(%s): FIFO PWord(%d) not supported.\n", 500 __func__, dev->dv_xname, atppc->sc_pword)); 501 goto error; 502 } 503 504 /* Byte mode, reverse direction, no interrupt, no DMA */ 505 atppc_w_ecr(atppc, ATPPC_ECR_PS2 | ATPPC_SERVICE_INTR); 506 atppc_w_ctr(atppc, (ctr_sav & ~IRQENABLE) | PCD); 507 /* enter ECP test mode, no interrupt, no DMA */ 508 atppc_w_ecr(atppc, ATPPC_ECR_TST | ATPPC_SERVICE_INTR); 509 atppc_barrier_w(atppc); 510 511 /* flush the FIFO */ 512 for (i = 0; i < 1024; i++) { 513 atppc_r_fifo(atppc); 514 atppc_barrier_r(atppc); 515 cc = atppc_r_ecr(atppc); 516 atppc_barrier_r(atppc); 517 if (cc & ATPPC_FIFO_EMPTY) 518 break; 519 } 520 if (i >= 1024) { 521 ATPPC_DPRINTF(("%s(%s): cannot flush FIFO.\n", __func__, 522 dev->dv_xname)); 523 goto error; 524 } 525 526 /* Test mode, enable interrupts, no DMA */ 527 atppc_w_ecr(atppc, ATPPC_ECR_TST); 528 atppc_barrier_w(atppc); 529 530 /* Determine readIntrThreshold - fill FIFO until serviceIntr is set */ 531 for (i = atppc->sc_rthr = atppc->sc_fifo = 0; i < 1024; i++) { 532 atppc_w_fifo(atppc, (char)i); 533 atppc_barrier_w(atppc); 534 cc = atppc_r_ecr(atppc); 535 atppc_barrier_r(atppc); 536 if ((atppc->sc_rthr == 0) && (cc & ATPPC_SERVICE_INTR)) { 537 /* readThreshold reached */ 538 atppc->sc_rthr = i + 1; 539 } 540 if (cc & ATPPC_FIFO_FULL) { 541 atppc->sc_fifo = i + 1; 542 break; 543 } 544 } 545 if (i >= 1024) { 546 ATPPC_DPRINTF(("%s(%s): cannot fill FIFO.\n", __func__, 547 dev->dv_xname)); 548 goto error; 549 } 550 551 /* Change direction */ 552 atppc_w_ctr(atppc, (ctr_sav & ~IRQENABLE) & ~PCD); 553 atppc_barrier_w(atppc); 554 555 /* Clear the serviceIntr bit we've already set in the above loop */ 556 atppc_w_ecr(atppc, ATPPC_ECR_TST); 557 atppc_barrier_w(atppc); 558 559 /* Determine writeIntrThreshold - empty FIFO until serviceIntr is set */ 560 for (atppc->sc_wthr = 0; i > -1; i--) { 561 cc = atppc_r_fifo(atppc); 562 atppc_barrier_r(atppc); 563 if (cc != (char)(atppc->sc_fifo - i - 1)) { 564 ATPPC_DPRINTF(("%s(%s): invalid data in FIFO.\n", 565 __func__, dev->dv_xname)); 566 goto error; 567 } 568 569 cc = atppc_r_ecr(atppc); 570 atppc_barrier_r(atppc); 571 if ((atppc->sc_wthr == 0) && (cc & ATPPC_SERVICE_INTR)) { 572 /* writeIntrThreshold reached */ 573 atppc->sc_wthr = atppc->sc_fifo - i; 574 } 575 576 if (i > 0 && (cc & ATPPC_FIFO_EMPTY)) { 577 /* If FIFO empty before the last byte, error */ 578 ATPPC_DPRINTF(("%s(%s): data lost in FIFO.\n", __func__, 579 dev->dv_xname)); 580 goto error; 581 } 582 } 583 584 /* FIFO must be empty after the last byte */ 585 cc = atppc_r_ecr(atppc); 586 atppc_barrier_r(atppc); 587 if (!(cc & ATPPC_FIFO_EMPTY)) { 588 ATPPC_DPRINTF(("%s(%s): cannot empty the FIFO.\n", __func__, 589 dev->dv_xname)); 590 goto error; 591 } 592 593 /* Restore original registers */ 594 atppc_w_ctr(atppc, ctr_sav); 595 atppc_w_str(atppc, str_sav); 596 atppc_w_ecr(atppc, ecr_sav); 597 atppc_barrier_w(atppc); 598 599 /* Update capabilities */ 600 atppc->sc_has |= ATPPC_HAS_FIFO; 601 602 return 0; 603 604 error: 605 /* Restore original registers */ 606 atppc_w_ctr(atppc, ctr_sav); 607 atppc_w_str(atppc, str_sav); 608 atppc_w_ecr(atppc, ecr_sav); 609 atppc_barrier_w(atppc); 610 611 return (EINVAL); 612 } 613 614 /* Interrupt handler for atppc device: wakes up read/write functions */ 615 int 616 atppcintr(void *arg) 617 { 618 struct atppc_softc *atppc = (struct atppc_softc *)arg; 619 struct device *dev = &atppc->sc_dev; 620 int claim = 1; 621 enum { NONE, READER, WRITER } wake_up = NONE; 622 int s; 623 624 s = splatppc(); 625 ATPPC_LOCK(atppc); 626 627 /* Record registers' status */ 628 atppc->sc_str_intr = atppc_r_str(atppc); 629 atppc->sc_ctr_intr = atppc_r_ctr(atppc); 630 atppc->sc_ecr_intr = atppc_r_ecr(atppc); 631 atppc_barrier_r(atppc); 632 633 /* Determine cause of interrupt and wake up top half */ 634 switch (atppc->sc_mode) { 635 case ATPPC_MODE_STD: 636 /* nAck pulsed for 5 usec, too fast to check reliably, assume */ 637 atppc->sc_irqstat = ATPPC_IRQ_nACK; 638 if (atppc->sc_outb) 639 wake_up = WRITER; 640 else 641 claim = 0; 642 break; 643 644 case ATPPC_MODE_NIBBLE: 645 case ATPPC_MODE_PS2: 646 /* nAck is set low by device and then high on ack */ 647 if (!(atppc->sc_str_intr & nACK)) { 648 claim = 0; 649 break; 650 } 651 atppc->sc_irqstat = ATPPC_IRQ_nACK; 652 if (atppc->sc_inb) 653 wake_up = READER; 654 break; 655 656 case ATPPC_MODE_ECP: 657 case ATPPC_MODE_FAST: 658 /* Confirm interrupt cause: these are not pulsed as in nAck. */ 659 if (atppc->sc_ecr_intr & ATPPC_SERVICE_INTR) { 660 if (atppc->sc_ecr_intr & ATPPC_ENABLE_DMA) 661 atppc->sc_irqstat |= ATPPC_IRQ_DMA; 662 else 663 atppc->sc_irqstat |= ATPPC_IRQ_FIFO; 664 665 /* Decide where top half will be waiting */ 666 if (atppc->sc_mode & ATPPC_MODE_ECP) { 667 if (atppc->sc_ctr_intr & PCD) { 668 if (atppc->sc_inb) 669 wake_up = READER; 670 else 671 claim = 0; 672 } else { 673 if (atppc->sc_outb) 674 wake_up = WRITER; 675 else 676 claim = 0; 677 } 678 } else { 679 if (atppc->sc_outb) 680 wake_up = WRITER; 681 else 682 claim = 0; 683 } 684 } 685 /* Determine if nFault has occurred */ 686 if ((atppc->sc_mode & ATPPC_MODE_ECP) && 687 (atppc->sc_ecr_intr & ATPPC_nFAULT_INTR) && 688 !(atppc->sc_str_intr & nFAULT)) { 689 690 /* Device is requesting the channel */ 691 atppc->sc_irqstat |= ATPPC_IRQ_nFAULT; 692 claim = 1; 693 } 694 break; 695 696 case ATPPC_MODE_EPP: 697 /* nAck pulsed for 5 usec, too fast to check reliably */ 698 atppc->sc_irqstat = ATPPC_IRQ_nACK; 699 if (atppc->sc_inb) 700 wake_up = WRITER; 701 else if (atppc->sc_outb) 702 wake_up = READER; 703 else 704 claim = 0; 705 break; 706 707 default: 708 panic("%s: chipset is in invalid mode.", dev->dv_xname); 709 } 710 711 if (claim) { 712 switch (wake_up) { 713 case NONE: 714 break; 715 716 case READER: 717 wakeup(atppc->sc_inb); 718 break; 719 720 case WRITER: 721 wakeup(atppc->sc_outb); 722 break; 723 } 724 } 725 726 ATPPC_UNLOCK(atppc); 727 728 /* Call all of the installed handlers */ 729 if (claim) { 730 struct atppc_handler_node * callback; 731 SLIST_FOREACH(callback, &(atppc->sc_handler_listhead), 732 entries) { 733 (*callback->func)(callback->arg); 734 } 735 } 736 737 splx(s); 738 739 return claim; 740 } 741 742 743 /* Functions which support ppbus interface */ 744 745 746 /* Check EPP mode timeout */ 747 static int 748 atppc_check_epp_timeout(struct device *dev) 749 { 750 struct atppc_softc *atppc = (struct atppc_softc *)dev; 751 int s; 752 int error; 753 754 s = splatppc(); 755 ATPPC_LOCK(atppc); 756 757 atppc_reset_epp_timeout(dev); 758 error = !(atppc_r_str(atppc) & TIMEOUT); 759 atppc_barrier_r(atppc); 760 761 ATPPC_UNLOCK(atppc); 762 splx(s); 763 764 return (error); 765 } 766 767 /* 768 * EPP timeout, according to the PC87332 manual 769 * Semantics of clearing EPP timeout bit. 770 * PC87332 - reading SPP_STR does it... 771 * SMC - write 1 to EPP timeout bit XXX 772 * Others - (?) write 0 to EPP timeout bit 773 */ 774 static void 775 atppc_reset_epp_timeout(struct device *dev) 776 { 777 struct atppc_softc *atppc = (struct atppc_softc *)dev; 778 register unsigned char r; 779 780 r = atppc_r_str(atppc); 781 atppc_barrier_r(atppc); 782 atppc_w_str(atppc, r | 0x1); 783 atppc_barrier_w(atppc); 784 atppc_w_str(atppc, r & 0xfe); 785 atppc_barrier_w(atppc); 786 787 return; 788 } 789 790 791 /* Read from atppc device: returns 0 on success. */ 792 static int 793 atppc_read(struct device *dev, char *buf, int len, int ioflag, 794 size_t *cnt) 795 { 796 struct atppc_softc *atppc = (struct atppc_softc *)dev; 797 int error = 0; 798 int s; 799 800 s = splatppc(); 801 ATPPC_LOCK(atppc); 802 803 *cnt = 0; 804 805 /* Initialize buffer */ 806 atppc->sc_inb = atppc->sc_inbstart = buf; 807 atppc->sc_inb_nbytes = len; 808 809 /* Initialize device input error state for new operation */ 810 atppc->sc_inerr = 0; 811 812 /* Call appropriate function to read bytes */ 813 switch(atppc->sc_mode) { 814 case ATPPC_MODE_STD: 815 case ATPPC_MODE_FAST: 816 error = ENODEV; 817 break; 818 819 case ATPPC_MODE_NIBBLE: 820 atppc_nibble_read(atppc); 821 break; 822 823 case ATPPC_MODE_PS2: 824 atppc_byte_read(atppc); 825 break; 826 827 case ATPPC_MODE_ECP: 828 atppc_ecp_read(atppc); 829 break; 830 831 case ATPPC_MODE_EPP: 832 atppc_epp_read(atppc); 833 break; 834 835 default: 836 panic("%s(%s): chipset in invalid mode.\n", __func__, 837 dev->dv_xname); 838 } 839 840 /* Update counter*/ 841 *cnt = (atppc->sc_inbstart - atppc->sc_inb); 842 843 /* Reset buffer */ 844 atppc->sc_inb = atppc->sc_inbstart = NULL; 845 atppc->sc_inb_nbytes = 0; 846 847 if (!(error)) 848 error = atppc->sc_inerr; 849 850 ATPPC_UNLOCK(atppc); 851 splx(s); 852 853 return (error); 854 } 855 856 /* Write to atppc device: returns 0 on success. */ 857 static int 858 atppc_write(struct device *dev, char *buf, int len, int ioflag, size_t *cnt) 859 { 860 struct atppc_softc * const atppc = (struct atppc_softc *)dev; 861 int error = 0; 862 int s; 863 864 *cnt = 0; 865 866 s = splatppc(); 867 ATPPC_LOCK(atppc); 868 869 /* Set up line buffer */ 870 atppc->sc_outb = atppc->sc_outbstart = buf; 871 atppc->sc_outb_nbytes = len; 872 873 /* Initialize device output error state for new operation */ 874 atppc->sc_outerr = 0; 875 876 /* Call appropriate function to write bytes */ 877 switch (atppc->sc_mode) { 878 case ATPPC_MODE_STD: 879 atppc_std_write(atppc); 880 break; 881 882 case ATPPC_MODE_NIBBLE: 883 case ATPPC_MODE_PS2: 884 error = ENODEV; 885 break; 886 887 case ATPPC_MODE_FAST: 888 case ATPPC_MODE_ECP: 889 atppc_fifo_write(atppc); 890 break; 891 892 case ATPPC_MODE_EPP: 893 atppc_epp_write(atppc); 894 break; 895 896 default: 897 panic("%s(%s): chipset in invalid mode.\n", __func__, 898 dev->dv_xname); 899 } 900 901 /* Update counter*/ 902 *cnt = (atppc->sc_outbstart - atppc->sc_outb); 903 904 /* Reset output buffer */ 905 atppc->sc_outb = atppc->sc_outbstart = NULL; 906 atppc->sc_outb_nbytes = 0; 907 908 if (!(error)) 909 error = atppc->sc_outerr; 910 911 ATPPC_UNLOCK(atppc); 912 splx(s); 913 914 return (error); 915 } 916 917 /* 918 * Set mode of chipset to mode argument. Modes not supported are ignored. If 919 * multiple modes are flagged, the mode is not changed. Mode's are those 920 * defined for ppbus_softc.sc_mode in ppbus_conf.h. Only ECP-capable chipsets 921 * can change their mode of operation. However, ALL operation modes support 922 * centronics mode and nibble mode. Modes determine both hardware AND software 923 * behaviour. 924 * NOTE: the mode for ECP should only be changed when the channel is in 925 * forward idle mode. This function does not make sure FIFO's have flushed or 926 * any consistency checks. 927 */ 928 static int 929 atppc_setmode(struct device *dev, int mode) 930 { 931 struct atppc_softc *atppc = (struct atppc_softc *)dev; 932 u_int8_t ecr; 933 u_int8_t chipset_mode; 934 int s; 935 int rval = 0; 936 937 s = splatppc(); 938 ATPPC_LOCK(atppc); 939 940 /* If ECP capable, configure ecr register */ 941 if (atppc->sc_has & ATPPC_HAS_ECP) { 942 /* Read ECR with mode masked out */ 943 ecr = (atppc_r_ecr(atppc) & 0x1f); 944 atppc_barrier_r(atppc); 945 946 switch (mode) { 947 case PPBUS_ECP: 948 /* Set ECP mode */ 949 ecr |= ATPPC_ECR_ECP; 950 chipset_mode = ATPPC_MODE_ECP; 951 break; 952 953 case PPBUS_EPP: 954 /* Set EPP mode */ 955 if (atppc->sc_has & ATPPC_HAS_EPP) { 956 ecr |= ATPPC_ECR_EPP; 957 chipset_mode = ATPPC_MODE_EPP; 958 } else { 959 rval = ENODEV; 960 goto end; 961 } 962 break; 963 964 case PPBUS_FAST: 965 /* Set fast centronics mode */ 966 ecr |= ATPPC_ECR_FIFO; 967 chipset_mode = ATPPC_MODE_FAST; 968 break; 969 970 case PPBUS_PS2: 971 /* Set PS2 mode */ 972 ecr |= ATPPC_ECR_PS2; 973 chipset_mode = ATPPC_MODE_PS2; 974 break; 975 976 case PPBUS_COMPATIBLE: 977 /* Set standard mode */ 978 ecr |= ATPPC_ECR_STD; 979 chipset_mode = ATPPC_MODE_STD; 980 break; 981 982 case PPBUS_NIBBLE: 983 /* Set nibble mode: uses chipset standard mode */ 984 ecr |= ATPPC_ECR_STD; 985 chipset_mode = ATPPC_MODE_NIBBLE; 986 break; 987 988 default: 989 /* Invalid mode specified for ECP chip */ 990 ATPPC_DPRINTF(("%s(%s): invalid mode passed as " 991 "argument.\n", __func__, dev->dv_xname)); 992 rval = ENODEV; 993 goto end; 994 } 995 996 /* Switch to byte mode to be able to change modes. */ 997 atppc_w_ecr(atppc, ATPPC_ECR_PS2); 998 atppc_barrier_w(atppc); 999 1000 /* Update mode */ 1001 atppc_w_ecr(atppc, ecr); 1002 atppc_barrier_w(atppc); 1003 } else { 1004 switch (mode) { 1005 case PPBUS_EPP: 1006 if (atppc->sc_has & ATPPC_HAS_EPP) { 1007 chipset_mode = ATPPC_MODE_EPP; 1008 } else { 1009 rval = ENODEV; 1010 goto end; 1011 } 1012 break; 1013 1014 case PPBUS_PS2: 1015 if (atppc->sc_has & ATPPC_HAS_PS2) { 1016 chipset_mode = ATPPC_MODE_PS2; 1017 } else { 1018 rval = ENODEV; 1019 goto end; 1020 } 1021 break; 1022 1023 case PPBUS_NIBBLE: 1024 /* Set nibble mode (virtual) */ 1025 chipset_mode = ATPPC_MODE_NIBBLE; 1026 break; 1027 1028 case PPBUS_COMPATIBLE: 1029 chipset_mode = ATPPC_MODE_STD; 1030 break; 1031 1032 case PPBUS_ECP: 1033 rval = ENODEV; 1034 goto end; 1035 1036 default: 1037 ATPPC_DPRINTF(("%s(%s): invalid mode passed as " 1038 "argument.\n", __func__, dev->dv_xname)); 1039 rval = ENODEV; 1040 goto end; 1041 } 1042 } 1043 1044 atppc->sc_mode = chipset_mode; 1045 if (chipset_mode == ATPPC_MODE_PS2) { 1046 /* Set direction bit to reverse */ 1047 ecr = atppc_r_ctr(atppc); 1048 atppc_barrier_r(atppc); 1049 ecr |= PCD; 1050 atppc_w_ctr(atppc, ecr); 1051 atppc_barrier_w(atppc); 1052 } 1053 1054 end: 1055 ATPPC_UNLOCK(atppc); 1056 splx(s); 1057 1058 return rval; 1059 } 1060 1061 /* Get the current mode of chipset */ 1062 static int 1063 atppc_getmode(struct device *dev) 1064 { 1065 struct atppc_softc *atppc = (struct atppc_softc *)dev; 1066 int mode; 1067 int s; 1068 1069 s = splatppc(); 1070 ATPPC_LOCK(atppc); 1071 1072 /* The chipset can only be in one mode at a time logically */ 1073 switch (atppc->sc_mode) { 1074 case ATPPC_MODE_ECP: 1075 mode = PPBUS_ECP; 1076 break; 1077 1078 case ATPPC_MODE_EPP: 1079 mode = PPBUS_EPP; 1080 break; 1081 1082 case ATPPC_MODE_PS2: 1083 mode = PPBUS_PS2; 1084 break; 1085 1086 case ATPPC_MODE_STD: 1087 mode = PPBUS_COMPATIBLE; 1088 break; 1089 1090 case ATPPC_MODE_NIBBLE: 1091 mode = PPBUS_NIBBLE; 1092 break; 1093 1094 case ATPPC_MODE_FAST: 1095 mode = PPBUS_FAST; 1096 break; 1097 1098 default: 1099 panic("%s(%s): device is in invalid mode!", __func__, 1100 dev->dv_xname); 1101 break; 1102 } 1103 1104 ATPPC_UNLOCK(atppc); 1105 splx(s); 1106 1107 return mode; 1108 } 1109 1110 1111 /* Wait for FIFO buffer to empty for ECP-capable chipset */ 1112 static void 1113 atppc_ecp_sync(struct device *dev) 1114 { 1115 struct atppc_softc *atppc = (struct atppc_softc *)dev; 1116 int i; 1117 int s; 1118 u_int8_t r; 1119 1120 s = splatppc(); 1121 ATPPC_LOCK(atppc); 1122 1123 /* 1124 * Only wait for FIFO to empty if mode is chipset is ECP-capable AND 1125 * the mode is either ECP or Fast Centronics. 1126 */ 1127 r = atppc_r_ecr(atppc); 1128 atppc_barrier_r(atppc); 1129 r &= 0xe0; 1130 if (!(atppc->sc_has & ATPPC_HAS_ECP) || ((r != ATPPC_ECR_ECP) 1131 && (r != ATPPC_ECR_FIFO))) { 1132 goto end; 1133 } 1134 1135 /* Wait for FIFO to empty */ 1136 for (i = 0; i < ((MAXBUSYWAIT/hz) * 1000000); i += 100) { 1137 r = atppc_r_ecr(atppc); 1138 atppc_barrier_r(atppc); 1139 if (r & ATPPC_FIFO_EMPTY) { 1140 goto end; 1141 } 1142 delay(100); /* Supposed to be a 100 usec delay */ 1143 } 1144 1145 ATPPC_DPRINTF(("%s: ECP sync failed, data still in FIFO.\n", 1146 dev->dv_xname)); 1147 1148 end: 1149 ATPPC_UNLOCK(atppc); 1150 splx(s); 1151 1152 return; 1153 } 1154 1155 /* Execute a microsequence to handle fast I/O operations. */ 1156 static int 1157 atppc_exec_microseq(struct device *dev, struct ppbus_microseq **p_msq) 1158 { 1159 struct atppc_softc *atppc = (struct atppc_softc *)dev; 1160 struct ppbus_microseq *mi = *p_msq; 1161 char cc, *p; 1162 int i, iter, len; 1163 int error; 1164 int s; 1165 register int reg; 1166 register unsigned char mask; 1167 register int accum = 0; 1168 register char *ptr = NULL; 1169 struct ppbus_microseq *stack = NULL; 1170 1171 s = splatppc(); 1172 ATPPC_LOCK(atppc); 1173 1174 /* microsequence registers are equivalent to PC-like port registers */ 1175 1176 #define r_reg(register,atppc) bus_space_read_1((atppc)->sc_iot, \ 1177 (atppc)->sc_ioh, (register)) 1178 #define w_reg(register, atppc, byte) bus_space_write_1((atppc)->sc_iot, \ 1179 (atppc)->sc_ioh, (register), (byte)) 1180 1181 /* Loop until microsequence execution finishes (ending op code) */ 1182 for (;;) { 1183 switch (mi->opcode) { 1184 case MS_OP_RSET: 1185 cc = r_reg(mi->arg[0].i, atppc); 1186 atppc_barrier_r(atppc); 1187 cc &= (char)mi->arg[2].i; /* clear mask */ 1188 cc |= (char)mi->arg[1].i; /* assert mask */ 1189 w_reg(mi->arg[0].i, atppc, cc); 1190 atppc_barrier_w(atppc); 1191 mi++; 1192 break; 1193 1194 case MS_OP_RASSERT_P: 1195 reg = mi->arg[1].i; 1196 ptr = atppc->sc_ptr; 1197 1198 if ((len = mi->arg[0].i) == MS_ACCUM) { 1199 accum = atppc->sc_accum; 1200 for (; accum; accum--) { 1201 w_reg(reg, atppc, *ptr++); 1202 atppc_barrier_w(atppc); 1203 } 1204 atppc->sc_accum = accum; 1205 } else { 1206 for (i = 0; i < len; i++) { 1207 w_reg(reg, atppc, *ptr++); 1208 atppc_barrier_w(atppc); 1209 } 1210 } 1211 1212 atppc->sc_ptr = ptr; 1213 mi++; 1214 break; 1215 1216 case MS_OP_RFETCH_P: 1217 reg = mi->arg[1].i; 1218 mask = (char)mi->arg[2].i; 1219 ptr = atppc->sc_ptr; 1220 1221 if ((len = mi->arg[0].i) == MS_ACCUM) { 1222 accum = atppc->sc_accum; 1223 for (; accum; accum--) { 1224 *ptr++ = r_reg(reg, atppc) & mask; 1225 atppc_barrier_r(atppc); 1226 } 1227 atppc->sc_accum = accum; 1228 } else { 1229 for (i = 0; i < len; i++) { 1230 *ptr++ = r_reg(reg, atppc) & mask; 1231 atppc_barrier_r(atppc); 1232 } 1233 } 1234 1235 atppc->sc_ptr = ptr; 1236 mi++; 1237 break; 1238 1239 case MS_OP_RFETCH: 1240 *((char *)mi->arg[2].p) = r_reg(mi->arg[0].i, atppc) & 1241 (char)mi->arg[1].i; 1242 atppc_barrier_r(atppc); 1243 mi++; 1244 break; 1245 1246 case MS_OP_RASSERT: 1247 case MS_OP_DELAY: 1248 /* let's suppose the next instr. is the same */ 1249 do { 1250 for (;mi->opcode == MS_OP_RASSERT; mi++) { 1251 w_reg(mi->arg[0].i, atppc, 1252 (char)mi->arg[1].i); 1253 atppc_barrier_w(atppc); 1254 } 1255 1256 for (;mi->opcode == MS_OP_DELAY; mi++) { 1257 delay(mi->arg[0].i); 1258 } 1259 } while (mi->opcode == MS_OP_RASSERT); 1260 break; 1261 1262 case MS_OP_ADELAY: 1263 if (mi->arg[0].i) { 1264 tsleep(atppc, PPBUSPRI, "atppcdelay", 1265 mi->arg[0].i * (hz/1000)); 1266 } 1267 mi++; 1268 break; 1269 1270 case MS_OP_TRIG: 1271 reg = mi->arg[0].i; 1272 iter = mi->arg[1].i; 1273 p = (char *)mi->arg[2].p; 1274 1275 /* XXX delay limited to 255 us */ 1276 for (i = 0; i < iter; i++) { 1277 w_reg(reg, atppc, *p++); 1278 atppc_barrier_w(atppc); 1279 delay((unsigned char)*p++); 1280 } 1281 1282 mi++; 1283 break; 1284 1285 case MS_OP_SET: 1286 atppc->sc_accum = mi->arg[0].i; 1287 mi++; 1288 break; 1289 1290 case MS_OP_DBRA: 1291 if (--atppc->sc_accum > 0) { 1292 mi += mi->arg[0].i; 1293 } 1294 1295 mi++; 1296 break; 1297 1298 case MS_OP_BRSET: 1299 cc = atppc_r_str(atppc); 1300 atppc_barrier_r(atppc); 1301 if ((cc & (char)mi->arg[0].i) == (char)mi->arg[0].i) { 1302 mi += mi->arg[1].i; 1303 } 1304 mi++; 1305 break; 1306 1307 case MS_OP_BRCLEAR: 1308 cc = atppc_r_str(atppc); 1309 atppc_barrier_r(atppc); 1310 if ((cc & (char)mi->arg[0].i) == 0) { 1311 mi += mi->arg[1].i; 1312 } 1313 mi++; 1314 break; 1315 1316 case MS_OP_BRSTAT: 1317 cc = atppc_r_str(atppc); 1318 atppc_barrier_r(atppc); 1319 if ((cc & ((char)mi->arg[0].i | (char)mi->arg[1].i)) == 1320 (char)mi->arg[0].i) { 1321 mi += mi->arg[2].i; 1322 } 1323 mi++; 1324 break; 1325 1326 case MS_OP_C_CALL: 1327 /* 1328 * If the C call returns !0 then end the microseq. 1329 * The current state of ptr is passed to the C function 1330 */ 1331 if ((error = mi->arg[0].f(mi->arg[1].p, 1332 atppc->sc_ptr))) { 1333 ATPPC_UNLOCK(atppc); 1334 splx(s); 1335 return (error); 1336 } 1337 mi++; 1338 break; 1339 1340 case MS_OP_PTR: 1341 atppc->sc_ptr = (char *)mi->arg[0].p; 1342 mi++; 1343 break; 1344 1345 case MS_OP_CALL: 1346 if (stack) { 1347 panic("%s - %s: too much calls", dev->dv_xname, 1348 __func__); 1349 } 1350 1351 if (mi->arg[0].p) { 1352 /* store state of the actual microsequence */ 1353 stack = mi; 1354 1355 /* jump to the new microsequence */ 1356 mi = (struct ppbus_microseq *)mi->arg[0].p; 1357 } else { 1358 mi++; 1359 } 1360 break; 1361 1362 case MS_OP_SUBRET: 1363 /* retrieve microseq and pc state before the call */ 1364 mi = stack; 1365 1366 /* reset the stack */ 1367 stack = 0; 1368 1369 /* XXX return code */ 1370 1371 mi++; 1372 break; 1373 1374 case MS_OP_PUT: 1375 case MS_OP_GET: 1376 case MS_OP_RET: 1377 /* 1378 * Can't return to atppc level during the execution 1379 * of a submicrosequence. 1380 */ 1381 if (stack) { 1382 panic("%s: cannot return to atppc level", 1383 __func__); 1384 } 1385 /* update pc for atppc level of execution */ 1386 *p_msq = mi; 1387 1388 ATPPC_UNLOCK(atppc); 1389 splx(s); 1390 return (0); 1391 break; 1392 1393 default: 1394 panic("%s: unknown microsequence " 1395 "opcode 0x%x", __func__, mi->opcode); 1396 break; 1397 } 1398 } 1399 1400 /* Should not be reached! */ 1401 #ifdef ATPPC_DEBUG 1402 panic("%s: unexpected code reached!\n", __func__); 1403 #endif 1404 } 1405 1406 /* General I/O routine */ 1407 static u_int8_t 1408 atppc_io(struct device *dev, int iop, u_char *addr, int cnt, u_char byte) 1409 { 1410 struct atppc_softc *atppc = (struct atppc_softc *)dev; 1411 u_int8_t val = 0; 1412 int s; 1413 1414 s = splatppc(); 1415 ATPPC_LOCK(atppc); 1416 1417 switch (iop) { 1418 case PPBUS_OUTSB_EPP: 1419 bus_space_write_multi_1(atppc->sc_iot, atppc->sc_ioh, 1420 ATPPC_EPP_DATA, addr, cnt); 1421 break; 1422 case PPBUS_OUTSW_EPP: 1423 bus_space_write_multi_2(atppc->sc_iot, atppc->sc_ioh, 1424 ATPPC_EPP_DATA, (u_int16_t *)addr, cnt); 1425 break; 1426 case PPBUS_OUTSL_EPP: 1427 bus_space_write_multi_4(atppc->sc_iot, atppc->sc_ioh, 1428 ATPPC_EPP_DATA, (u_int32_t *)addr, cnt); 1429 break; 1430 case PPBUS_INSB_EPP: 1431 bus_space_read_multi_1(atppc->sc_iot, atppc->sc_ioh, 1432 ATPPC_EPP_DATA, addr, cnt); 1433 break; 1434 case PPBUS_INSW_EPP: 1435 bus_space_read_multi_2(atppc->sc_iot, atppc->sc_ioh, 1436 ATPPC_EPP_DATA, (u_int16_t *)addr, cnt); 1437 break; 1438 case PPBUS_INSL_EPP: 1439 bus_space_read_multi_4(atppc->sc_iot, atppc->sc_ioh, 1440 ATPPC_EPP_DATA, (u_int32_t *)addr, cnt); 1441 break; 1442 case PPBUS_RDTR: 1443 val = (atppc_r_dtr(atppc)); 1444 break; 1445 case PPBUS_RSTR: 1446 val = (atppc_r_str(atppc)); 1447 break; 1448 case PPBUS_RCTR: 1449 val = (atppc_r_ctr(atppc)); 1450 break; 1451 case PPBUS_REPP_A: 1452 val = (atppc_r_eppA(atppc)); 1453 break; 1454 case PPBUS_REPP_D: 1455 val = (atppc_r_eppD(atppc)); 1456 break; 1457 case PPBUS_RECR: 1458 val = (atppc_r_ecr(atppc)); 1459 break; 1460 case PPBUS_RFIFO: 1461 val = (atppc_r_fifo(atppc)); 1462 break; 1463 case PPBUS_WDTR: 1464 atppc_w_dtr(atppc, byte); 1465 break; 1466 case PPBUS_WSTR: 1467 atppc_w_str(atppc, byte); 1468 break; 1469 case PPBUS_WCTR: 1470 atppc_w_ctr(atppc, byte); 1471 break; 1472 case PPBUS_WEPP_A: 1473 atppc_w_eppA(atppc, byte); 1474 break; 1475 case PPBUS_WEPP_D: 1476 atppc_w_eppD(atppc, byte); 1477 break; 1478 case PPBUS_WECR: 1479 atppc_w_ecr(atppc, byte); 1480 break; 1481 case PPBUS_WFIFO: 1482 atppc_w_fifo(atppc, byte); 1483 break; 1484 default: 1485 panic("%s(%s): unknown I/O operation", dev->dv_xname, 1486 __func__); 1487 break; 1488 } 1489 1490 atppc_barrier(atppc); 1491 1492 ATPPC_UNLOCK(atppc); 1493 splx(s); 1494 1495 return val; 1496 } 1497 1498 /* Read "instance variables" of atppc device */ 1499 static int 1500 atppc_read_ivar(struct device *dev, int index, unsigned int *val) 1501 { 1502 struct atppc_softc *atppc = (struct atppc_softc *)dev; 1503 int rval = 0; 1504 int s; 1505 1506 s = splatppc(); 1507 ATPPC_LOCK(atppc); 1508 1509 switch(index) { 1510 case PPBUS_IVAR_EPP_PROTO: 1511 if (atppc->sc_epp == ATPPC_EPP_1_9) 1512 *val = PPBUS_EPP_1_9; 1513 else if (atppc->sc_epp == ATPPC_EPP_1_7) 1514 *val = PPBUS_EPP_1_7; 1515 /* XXX what if not using EPP ? */ 1516 break; 1517 1518 case PPBUS_IVAR_INTR: 1519 *val = ((atppc->sc_use & ATPPC_USE_INTR) != 0); 1520 break; 1521 1522 case PPBUS_IVAR_DMA: 1523 *val = ((atppc->sc_use & ATPPC_USE_DMA) != 0); 1524 break; 1525 1526 default: 1527 rval = ENODEV; 1528 } 1529 1530 ATPPC_UNLOCK(atppc); 1531 splx(s); 1532 1533 return rval; 1534 } 1535 1536 /* Write "instance varaibles" of atppc device */ 1537 static int 1538 atppc_write_ivar(struct device *dev, int index, unsigned int *val) 1539 { 1540 struct atppc_softc *atppc = (struct atppc_softc *)dev; 1541 int rval = 0; 1542 int s; 1543 1544 s = splatppc(); 1545 ATPPC_LOCK(atppc); 1546 1547 switch(index) { 1548 case PPBUS_IVAR_EPP_PROTO: 1549 if (*val == PPBUS_EPP_1_9 || *val == PPBUS_EPP_1_7) 1550 atppc->sc_epp = *val; 1551 else 1552 rval = EINVAL; 1553 break; 1554 1555 case PPBUS_IVAR_INTR: 1556 if (*val == 0) 1557 atppc->sc_use &= ~ATPPC_USE_INTR; 1558 else if (atppc->sc_has & ATPPC_HAS_INTR) 1559 atppc->sc_use |= ATPPC_USE_INTR; 1560 else 1561 rval = ENODEV; 1562 break; 1563 1564 case PPBUS_IVAR_DMA: 1565 if (*val == 0) 1566 atppc->sc_use &= ~ATPPC_USE_DMA; 1567 else if (atppc->sc_has & ATPPC_HAS_DMA) 1568 atppc->sc_use |= ATPPC_USE_DMA; 1569 else 1570 rval = ENODEV; 1571 break; 1572 1573 default: 1574 rval = ENODEV; 1575 } 1576 1577 ATPPC_UNLOCK(atppc); 1578 splx(s); 1579 1580 return rval; 1581 } 1582 1583 /* Add a handler routine to be called by the interrupt handler */ 1584 static int 1585 atppc_add_handler(struct device *dev, void (*handler)(void *), void *arg) 1586 { 1587 struct atppc_softc *atppc = (struct atppc_softc *)dev; 1588 struct atppc_handler_node *callback; 1589 int rval = 0; 1590 int s; 1591 1592 s = splatppc(); 1593 ATPPC_LOCK(atppc); 1594 1595 if (handler == NULL) { 1596 ATPPC_DPRINTF(("%s(%s): attempt to register NULL handler.\n", 1597 __func__, dev->dv_xname)); 1598 rval = EINVAL; 1599 } else { 1600 callback = malloc(sizeof(struct atppc_handler_node), M_DEVBUF, 1601 M_NOWAIT); 1602 if (callback) { 1603 callback->func = handler; 1604 callback->arg = arg; 1605 SLIST_INSERT_HEAD(&(atppc->sc_handler_listhead), 1606 callback, entries); 1607 } else { 1608 rval = ENOMEM; 1609 } 1610 } 1611 1612 ATPPC_UNLOCK(atppc); 1613 splx(s); 1614 1615 return rval; 1616 } 1617 1618 /* Remove a handler added by atppc_add_handler() */ 1619 static int 1620 atppc_remove_handler(struct device *dev, void (*handler)(void *)) 1621 { 1622 struct atppc_softc *atppc = (struct atppc_softc *)dev; 1623 struct atppc_handler_node *callback; 1624 int rval = EINVAL; 1625 int s; 1626 1627 s = splatppc(); 1628 ATPPC_LOCK(atppc); 1629 1630 if (SLIST_EMPTY(&(atppc->sc_handler_listhead))) 1631 panic("%s(%s): attempt to remove handler from empty list.\n", 1632 __func__, dev->dv_xname); 1633 1634 /* Search list for handler */ 1635 SLIST_FOREACH(callback, &(atppc->sc_handler_listhead), entries) { 1636 if (callback->func == handler) { 1637 SLIST_REMOVE(&(atppc->sc_handler_listhead), callback, 1638 atppc_handler_node, entries); 1639 free(callback, M_DEVBUF); 1640 rval = 0; 1641 break; 1642 } 1643 } 1644 1645 ATPPC_UNLOCK(atppc); 1646 splx(s); 1647 1648 return rval; 1649 } 1650 1651 /* Utility functions */ 1652 1653 1654 /* 1655 * Functions that read bytes from port into buffer: called from interrupt 1656 * handler depending on current chipset mode and cause of interrupt. Return 1657 * value: number of bytes moved. 1658 */ 1659 1660 /* Only the lower 4 bits of the final value are valid */ 1661 #define nibble2char(s) ((((s) & ~nACK) >> 3) | (~(s) & nBUSY) >> 4) 1662 1663 /* Read bytes in nibble mode */ 1664 static void 1665 atppc_nibble_read(struct atppc_softc *atppc) 1666 { 1667 int i; 1668 u_int8_t nibble[2]; 1669 u_int8_t ctr; 1670 u_int8_t str; 1671 1672 /* Enable interrupts if needed */ 1673 if (atppc->sc_use & ATPPC_USE_INTR) { 1674 ctr = atppc_r_ctr(atppc); 1675 atppc_barrier_r(atppc); 1676 if (!(ctr & IRQENABLE)) { 1677 ctr |= IRQENABLE; 1678 atppc_w_ctr(atppc, ctr); 1679 atppc_barrier_w(atppc); 1680 } 1681 } 1682 1683 while (atppc->sc_inbstart < (atppc->sc_inb + atppc->sc_inb_nbytes)) { 1684 /* Check if device has data to send in idle phase */ 1685 str = atppc_r_str(atppc); 1686 atppc_barrier_r(atppc); 1687 if (str & nDATAVAIL) { 1688 return; 1689 } 1690 1691 /* Nibble-mode handshake transfer */ 1692 for (i = 0; i < 2; i++) { 1693 /* Event 7 - ready to take data (HOSTBUSY low) */ 1694 ctr = atppc_r_ctr(atppc); 1695 atppc_barrier_r(atppc); 1696 ctr |= HOSTBUSY; 1697 atppc_w_ctr(atppc, ctr); 1698 atppc_barrier_w(atppc); 1699 1700 /* Event 8 - peripheral writes the first nibble */ 1701 1702 /* Event 9 - peripheral set nAck low */ 1703 atppc->sc_inerr = atppc_poll_str(atppc, 0, PTRCLK); 1704 if (atppc->sc_inerr) 1705 return; 1706 1707 /* read nibble */ 1708 nibble[i] = atppc_r_str(atppc); 1709 1710 /* Event 10 - ack, nibble received */ 1711 ctr &= ~HOSTBUSY; 1712 atppc_w_ctr(atppc, ctr); 1713 1714 /* Event 11 - wait ack from peripherial */ 1715 if (atppc->sc_use & ATPPC_USE_INTR) 1716 atppc->sc_inerr = atppc_wait_interrupt(atppc, 1717 atppc->sc_inb, ATPPC_IRQ_nACK); 1718 else 1719 atppc->sc_inerr = atppc_poll_str(atppc, PTRCLK, 1720 PTRCLK); 1721 if (atppc->sc_inerr) 1722 return; 1723 } 1724 1725 /* Store byte transfered */ 1726 *(atppc->sc_inbstart) = ((nibble2char(nibble[1]) << 4) & 0xf0) | 1727 (nibble2char(nibble[0]) & 0x0f); 1728 atppc->sc_inbstart++; 1729 } 1730 } 1731 1732 /* Read bytes in bidirectional mode */ 1733 static void 1734 atppc_byte_read(struct atppc_softc * const atppc) 1735 { 1736 u_int8_t ctr; 1737 u_int8_t str; 1738 1739 /* Check direction bit */ 1740 ctr = atppc_r_ctr(atppc); 1741 atppc_barrier_r(atppc); 1742 if (!(ctr & PCD)) { 1743 ATPPC_DPRINTF(("%s: byte-mode read attempted without direction " 1744 "bit set.", atppc->sc_dev.dv_xname)); 1745 atppc->sc_inerr = ENODEV; 1746 return; 1747 } 1748 /* Enable interrupts if needed */ 1749 if (atppc->sc_use & ATPPC_USE_INTR) { 1750 if (!(ctr & IRQENABLE)) { 1751 ctr |= IRQENABLE; 1752 atppc_w_ctr(atppc, ctr); 1753 atppc_barrier_w(atppc); 1754 } 1755 } 1756 1757 /* Byte-mode handshake transfer */ 1758 while (atppc->sc_inbstart < (atppc->sc_inb + atppc->sc_inb_nbytes)) { 1759 /* Check if device has data to send */ 1760 str = atppc_r_str(atppc); 1761 atppc_barrier_r(atppc); 1762 if (str & nDATAVAIL) { 1763 return; 1764 } 1765 1766 /* Event 7 - ready to take data (nAUTO low) */ 1767 ctr |= HOSTBUSY; 1768 atppc_w_ctr(atppc, ctr); 1769 atppc_barrier_w(atppc); 1770 1771 /* Event 9 - peripheral set nAck low */ 1772 atppc->sc_inerr = atppc_poll_str(atppc, 0, PTRCLK); 1773 if (atppc->sc_inerr) 1774 return; 1775 1776 /* Store byte transfered */ 1777 *(atppc->sc_inbstart) = atppc_r_dtr(atppc); 1778 atppc_barrier_r(atppc); 1779 1780 /* Event 10 - data received, can't accept more */ 1781 ctr &= ~HOSTBUSY; 1782 atppc_w_ctr(atppc, ctr); 1783 atppc_barrier_w(atppc); 1784 1785 /* Event 11 - peripheral ack */ 1786 if (atppc->sc_use & ATPPC_USE_INTR) 1787 atppc->sc_inerr = atppc_wait_interrupt(atppc, 1788 atppc->sc_inb, ATPPC_IRQ_nACK); 1789 else 1790 atppc->sc_inerr = atppc_poll_str(atppc, PTRCLK, PTRCLK); 1791 if (atppc->sc_inerr) 1792 return; 1793 1794 /* Event 16 - strobe */ 1795 str |= HOSTCLK; 1796 atppc_w_str(atppc, str); 1797 atppc_barrier_w(atppc); 1798 DELAY(1); 1799 str &= ~HOSTCLK; 1800 atppc_w_str(atppc, str); 1801 atppc_barrier_w(atppc); 1802 1803 /* Update counter */ 1804 atppc->sc_inbstart++; 1805 } 1806 } 1807 1808 /* Read bytes in EPP mode */ 1809 static void 1810 atppc_epp_read(struct atppc_softc * atppc) 1811 { 1812 if (atppc->sc_epp == ATPPC_EPP_1_9) { 1813 { 1814 uint8_t str; 1815 int i; 1816 1817 atppc_reset_epp_timeout((struct device *)atppc); 1818 for (i = 0; i < atppc->sc_inb_nbytes; i++) { 1819 *(atppc->sc_inbstart) = atppc_r_eppD(atppc); 1820 atppc_barrier_r(atppc); 1821 str = atppc_r_str(atppc); 1822 atppc_barrier_r(atppc); 1823 if (str & TIMEOUT) { 1824 atppc->sc_inerr = EIO; 1825 break; 1826 } 1827 atppc->sc_inbstart++; 1828 } 1829 } 1830 } else { 1831 /* Read data block from EPP data register */ 1832 atppc_r_eppD_multi(atppc, atppc->sc_inbstart, 1833 atppc->sc_inb_nbytes); 1834 atppc_barrier_r(atppc); 1835 /* Update buffer position, byte count and counter */ 1836 atppc->sc_inbstart += atppc->sc_inb_nbytes; 1837 } 1838 1839 return; 1840 } 1841 1842 /* Read bytes in ECP mode */ 1843 static void 1844 atppc_ecp_read(struct atppc_softc *atppc) 1845 { 1846 u_int8_t ecr; 1847 u_int8_t ctr; 1848 u_int8_t str; 1849 const unsigned char ctr_sav = atppc_r_ctr(atppc); 1850 const unsigned char ecr_sav = atppc_r_ecr(atppc); 1851 unsigned int worklen; 1852 1853 /* Check direction bit */ 1854 ctr = ctr_sav; 1855 atppc_barrier_r(atppc); 1856 if (!(ctr & PCD)) { 1857 ATPPC_DPRINTF(("%s: ecp-mode read attempted without direction " 1858 "bit set.", atppc->sc_dev.dv_xname)); 1859 atppc->sc_inerr = ENODEV; 1860 goto end; 1861 } 1862 1863 /* Clear device request if any */ 1864 if (atppc->sc_use & ATPPC_USE_INTR) 1865 atppc->sc_irqstat &= ~ATPPC_IRQ_nFAULT; 1866 1867 while (atppc->sc_inbstart < (atppc->sc_inb + atppc->sc_inb_nbytes)) { 1868 ecr = atppc_r_ecr(atppc); 1869 atppc_barrier_r(atppc); 1870 if (ecr & ATPPC_FIFO_EMPTY) { 1871 /* Check for invalid state */ 1872 if (ecr & ATPPC_FIFO_FULL) { 1873 atppc_ecp_read_error(atppc, worklen); 1874 break; 1875 } 1876 1877 /* Check if device has data to send */ 1878 str = atppc_r_str(atppc); 1879 atppc_barrier_r(atppc); 1880 if (str & nDATAVAIL) { 1881 break; 1882 } 1883 1884 if (atppc->sc_use & ATPPC_USE_INTR) { 1885 /* Enable interrupts */ 1886 ecr &= ~ATPPC_SERVICE_INTR; 1887 atppc_w_ecr(atppc, ecr); 1888 atppc_barrier_w(atppc); 1889 /* Wait for FIFO to fill */ 1890 atppc->sc_inerr = atppc_wait_interrupt(atppc, 1891 atppc->sc_inb, ATPPC_IRQ_FIFO); 1892 if (atppc->sc_inerr) 1893 break; 1894 } else { 1895 DELAY(1); 1896 } 1897 continue; 1898 } 1899 else if (ecr & ATPPC_FIFO_FULL) { 1900 /* Transfer sc_fifo bytes */ 1901 worklen = atppc->sc_fifo; 1902 } 1903 else if (ecr & ATPPC_SERVICE_INTR) { 1904 /* Transfer sc_rthr bytes */ 1905 worklen = atppc->sc_rthr; 1906 } else { 1907 /* At least one byte is in the FIFO */ 1908 worklen = 1; 1909 } 1910 1911 if ((atppc->sc_use & ATPPC_USE_INTR) && 1912 (atppc->sc_use & ATPPC_USE_DMA)) { 1913 1914 atppc_ecp_read_dma(atppc, &worklen, ecr); 1915 } else { 1916 atppc_ecp_read_pio(atppc, &worklen, ecr); 1917 } 1918 1919 if (atppc->sc_inerr) { 1920 atppc_ecp_read_error(atppc, worklen); 1921 break; 1922 } 1923 1924 /* Update counter */ 1925 atppc->sc_inbstart += worklen; 1926 } 1927 end: 1928 atppc_w_ctr(atppc, ctr_sav); 1929 atppc_w_ecr(atppc, ecr_sav); 1930 atppc_barrier_w(atppc); 1931 } 1932 1933 /* Read bytes in ECP mode using DMA transfers */ 1934 static void 1935 atppc_ecp_read_dma(struct atppc_softc *atppc, unsigned int *length, 1936 unsigned char ecr) 1937 { 1938 /* Limit transfer to maximum DMA size and start it */ 1939 *length = min(*length, atppc->sc_dma_maxsize); 1940 atppc->sc_dmastat = ATPPC_DMA_INIT; 1941 atppc->sc_dma_start(atppc, atppc->sc_inbstart, *length, 1942 ATPPC_DMA_MODE_READ); 1943 1944 atppc->sc_dmastat = ATPPC_DMA_STARTED; 1945 1946 /* Enable interrupts, DMA */ 1947 ecr &= ~ATPPC_SERVICE_INTR; 1948 ecr |= ATPPC_ENABLE_DMA; 1949 atppc_w_ecr(atppc, ecr); 1950 atppc_barrier_w(atppc); 1951 1952 /* Wait for DMA completion */ 1953 atppc->sc_inerr = atppc_wait_interrupt(atppc, atppc->sc_inb, 1954 ATPPC_IRQ_DMA); 1955 if (atppc->sc_inerr) 1956 return; 1957 1958 /* Get register value recorded by interrupt handler */ 1959 ecr = atppc->sc_ecr_intr; 1960 /* Clear DMA programming */ 1961 atppc->sc_dma_finish(atppc); 1962 atppc->sc_dmastat = ATPPC_DMA_COMPLETE; 1963 /* Disable DMA */ 1964 ecr &= ~ATPPC_ENABLE_DMA; 1965 atppc_w_ecr(atppc, ecr); 1966 atppc_barrier_w(atppc); 1967 } 1968 1969 /* Read bytes in ECP mode using PIO transfers */ 1970 static void 1971 atppc_ecp_read_pio(struct atppc_softc *atppc, unsigned int *length, 1972 unsigned char ecr) 1973 { 1974 /* Disable DMA */ 1975 ecr &= ~ATPPC_ENABLE_DMA; 1976 atppc_w_ecr(atppc, ecr); 1977 atppc_barrier_w(atppc); 1978 1979 /* Read from FIFO */ 1980 atppc_r_fifo_multi(atppc, atppc->sc_inbstart, *length); 1981 } 1982 1983 /* Handle errors for ECP reads */ 1984 static void 1985 atppc_ecp_read_error(struct atppc_softc *atppc, const unsigned int worklen) 1986 { 1987 unsigned char ecr = atppc_r_ecr(atppc); 1988 1989 /* Abort DMA if not finished */ 1990 if (atppc->sc_dmastat == ATPPC_DMA_STARTED) { 1991 atppc->sc_dma_abort(atppc); 1992 ATPPC_DPRINTF(("%s: DMA interrupted.\n", __func__)); 1993 } 1994 1995 /* Check for invalid states */ 1996 if ((ecr & ATPPC_FIFO_EMPTY) && (ecr & ATPPC_FIFO_FULL)) { 1997 ATPPC_DPRINTF(("%s: FIFO full+empty bits set.\n", __func__)); 1998 ATPPC_DPRINTF(("%s: reseting FIFO.\n", __func__)); 1999 atppc_w_ecr(atppc, ATPPC_ECR_PS2); 2000 atppc_barrier_w(atppc); 2001 } 2002 } 2003 2004 /* 2005 * Functions that write bytes to port from buffer: called from atppc_write() 2006 * function depending on current chipset mode. Returns number of bytes moved. 2007 */ 2008 2009 /* Write bytes in std/bidirectional mode */ 2010 static void 2011 atppc_std_write(struct atppc_softc * const atppc) 2012 { 2013 unsigned int timecount; 2014 unsigned char ctr; 2015 2016 ctr = atppc_r_ctr(atppc); 2017 atppc_barrier_r(atppc); 2018 /* Enable interrupts if needed */ 2019 if (atppc->sc_use & ATPPC_USE_INTR) { 2020 if (!(ctr & IRQENABLE)) { 2021 ctr |= IRQENABLE; 2022 atppc_w_ctr(atppc, ctr); 2023 atppc_barrier_w(atppc); 2024 } 2025 } 2026 2027 while (atppc->sc_outbstart < (atppc->sc_outb + atppc->sc_outb_nbytes)) { 2028 /* Wait for peripheral to become ready for MAXBUSYWAIT */ 2029 atppc->sc_outerr = atppc_poll_str(atppc, SPP_READY, SPP_MASK); 2030 if (atppc->sc_outerr) 2031 return; 2032 2033 /* Put data in data register */ 2034 atppc_w_dtr(atppc, *(atppc->sc_outbstart)); 2035 atppc_barrier_w(atppc); 2036 DELAY(1); 2037 2038 /* Pulse strobe to indicate valid data on lines */ 2039 ctr |= STROBE; 2040 atppc_w_ctr(atppc, ctr); 2041 atppc_barrier_w(atppc); 2042 DELAY(1); 2043 ctr &= ~STROBE; 2044 atppc_w_ctr(atppc, ctr); 2045 atppc_barrier_w(atppc); 2046 2047 /* Wait for nACK for MAXBUSYWAIT */ 2048 timecount = 0; 2049 if (atppc->sc_use & ATPPC_USE_INTR) { 2050 atppc->sc_outerr = atppc_wait_interrupt(atppc, 2051 atppc->sc_outb, ATPPC_IRQ_nACK); 2052 if (atppc->sc_outerr) 2053 return; 2054 } else { 2055 /* Try to catch the pulsed acknowledgement */ 2056 atppc->sc_outerr = atppc_poll_str(atppc, 0, nACK); 2057 if (atppc->sc_outerr) 2058 return; 2059 atppc->sc_outerr = atppc_poll_str(atppc, nACK, nACK); 2060 if (atppc->sc_outerr) 2061 return; 2062 } 2063 2064 /* Update buffer position, byte count and counter */ 2065 atppc->sc_outbstart++; 2066 } 2067 } 2068 2069 2070 /* Write bytes in EPP mode */ 2071 static void 2072 atppc_epp_write(struct atppc_softc *atppc) 2073 { 2074 if (atppc->sc_epp == ATPPC_EPP_1_9) { 2075 { 2076 uint8_t str; 2077 int i; 2078 2079 atppc_reset_epp_timeout((struct device *)atppc); 2080 for (i = 0; i < atppc->sc_outb_nbytes; i++) { 2081 atppc_w_eppD(atppc, *(atppc->sc_outbstart)); 2082 atppc_barrier_w(atppc); 2083 str = atppc_r_str(atppc); 2084 atppc_barrier_r(atppc); 2085 if (str & TIMEOUT) { 2086 atppc->sc_outerr = EIO; 2087 break; 2088 } 2089 atppc->sc_outbstart++; 2090 } 2091 } 2092 } else { 2093 /* Write data block to EPP data register */ 2094 atppc_w_eppD_multi(atppc, atppc->sc_outbstart, 2095 atppc->sc_outb_nbytes); 2096 atppc_barrier_w(atppc); 2097 /* Update buffer position, byte count and counter */ 2098 atppc->sc_outbstart += atppc->sc_outb_nbytes; 2099 } 2100 2101 return; 2102 } 2103 2104 2105 /* Write bytes in ECP/Fast Centronics mode */ 2106 static void 2107 atppc_fifo_write(struct atppc_softc * const atppc) 2108 { 2109 unsigned char ctr; 2110 unsigned char ecr; 2111 const unsigned char ctr_sav = atppc_r_ctr(atppc); 2112 const unsigned char ecr_sav = atppc_r_ecr(atppc); 2113 2114 ctr = ctr_sav; 2115 ecr = ecr_sav; 2116 atppc_barrier_r(atppc); 2117 2118 /* Reset and flush FIFO */ 2119 atppc_w_ecr(atppc, ATPPC_ECR_PS2); 2120 atppc_barrier_w(atppc); 2121 /* Disable nAck interrupts and initialize port bits */ 2122 ctr &= ~(IRQENABLE | STROBE | AUTOFEED); 2123 atppc_w_ctr(atppc, ctr); 2124 atppc_barrier_w(atppc); 2125 /* Restore mode */ 2126 atppc_w_ecr(atppc, ecr); 2127 atppc_barrier_w(atppc); 2128 2129 /* DMA or Programmed IO */ 2130 if ((atppc->sc_use & ATPPC_USE_DMA) && 2131 (atppc->sc_use & ATPPC_USE_INTR)) { 2132 2133 atppc_fifo_write_dma(atppc, ecr, ctr); 2134 } else { 2135 atppc_fifo_write_pio(atppc, ecr, ctr); 2136 } 2137 2138 /* Restore original register values */ 2139 atppc_w_ctr(atppc, ctr_sav); 2140 atppc_w_ecr(atppc, ecr_sav); 2141 atppc_barrier_w(atppc); 2142 } 2143 2144 static void 2145 atppc_fifo_write_dma(struct atppc_softc * const atppc, unsigned char ecr, 2146 unsigned char ctr) 2147 { 2148 unsigned int len; 2149 unsigned int worklen; 2150 2151 for (len = (atppc->sc_outb + atppc->sc_outb_nbytes) - 2152 atppc->sc_outbstart; len > 0; len = (atppc->sc_outb + 2153 atppc->sc_outb_nbytes) - atppc->sc_outbstart) { 2154 2155 /* Wait for device to become ready */ 2156 atppc->sc_outerr = atppc_poll_str(atppc, SPP_READY, SPP_MASK); 2157 if (atppc->sc_outerr) 2158 return; 2159 2160 /* Reset chipset for next DMA transfer */ 2161 atppc_w_ecr(atppc, ATPPC_ECR_PS2); 2162 atppc_barrier_w(atppc); 2163 atppc_w_ecr(atppc, ecr); 2164 atppc_barrier_w(atppc); 2165 2166 /* Limit transfer to maximum DMA size and start it */ 2167 worklen = min(len, atppc->sc_dma_maxsize); 2168 atppc->sc_dmastat = ATPPC_DMA_INIT; 2169 atppc->sc_dma_start(atppc, atppc->sc_outbstart, 2170 worklen, ATPPC_DMA_MODE_WRITE); 2171 atppc->sc_dmastat = ATPPC_DMA_STARTED; 2172 2173 /* Enable interrupts, DMA */ 2174 ecr &= ~ATPPC_SERVICE_INTR; 2175 ecr |= ATPPC_ENABLE_DMA; 2176 atppc_w_ecr(atppc, ecr); 2177 atppc_barrier_w(atppc); 2178 2179 /* Wait for DMA completion */ 2180 atppc->sc_outerr = atppc_wait_interrupt(atppc, atppc->sc_outb, 2181 ATPPC_IRQ_DMA); 2182 if (atppc->sc_outerr) { 2183 atppc_fifo_write_error(atppc, worklen); 2184 return; 2185 } 2186 /* Get register value recorded by interrupt handler */ 2187 ecr = atppc->sc_ecr_intr; 2188 /* Clear DMA programming */ 2189 atppc->sc_dma_finish(atppc); 2190 atppc->sc_dmastat = ATPPC_DMA_COMPLETE; 2191 /* Disable DMA */ 2192 ecr &= ~ATPPC_ENABLE_DMA; 2193 atppc_w_ecr(atppc, ecr); 2194 atppc_barrier_w(atppc); 2195 2196 /* Wait for FIFO to empty */ 2197 for (;;) { 2198 if (ecr & ATPPC_FIFO_EMPTY) { 2199 if (ecr & ATPPC_FIFO_FULL) { 2200 atppc->sc_outerr = EIO; 2201 atppc_fifo_write_error(atppc, worklen); 2202 return; 2203 } else { 2204 break; 2205 } 2206 } 2207 2208 /* Enable service interrupt */ 2209 ecr &= ~ATPPC_SERVICE_INTR; 2210 atppc_w_ecr(atppc, ecr); 2211 atppc_barrier_w(atppc); 2212 2213 atppc->sc_outerr = atppc_wait_interrupt(atppc, 2214 atppc->sc_outb, ATPPC_IRQ_FIFO); 2215 if (atppc->sc_outerr) { 2216 atppc_fifo_write_error(atppc, worklen); 2217 return; 2218 } 2219 2220 /* Get register value recorded by interrupt handler */ 2221 ecr = atppc->sc_ecr_intr; 2222 } 2223 2224 /* Update pointer */ 2225 atppc->sc_outbstart += worklen; 2226 } 2227 } 2228 2229 static void 2230 atppc_fifo_write_pio(struct atppc_softc * const atppc, unsigned char ecr, 2231 unsigned char ctr) 2232 { 2233 unsigned int len; 2234 unsigned int worklen; 2235 unsigned int timecount; 2236 2237 /* Disable DMA */ 2238 ecr &= ~ATPPC_ENABLE_DMA; 2239 atppc_w_ecr(atppc, ecr); 2240 atppc_barrier_w(atppc); 2241 2242 for (len = (atppc->sc_outb + atppc->sc_outb_nbytes) - 2243 atppc->sc_outbstart; len > 0; len = (atppc->sc_outb + 2244 atppc->sc_outb_nbytes) - atppc->sc_outbstart) { 2245 2246 /* Wait for device to become ready */ 2247 atppc->sc_outerr = atppc_poll_str(atppc, SPP_READY, SPP_MASK); 2248 if (atppc->sc_outerr) 2249 return; 2250 2251 /* Limit transfer to minimum of space in FIFO and buffer */ 2252 worklen = min(len, atppc->sc_fifo); 2253 2254 /* Write to FIFO */ 2255 atppc_w_fifo_multi(atppc, atppc->sc_outbstart, worklen); 2256 2257 timecount = 0; 2258 if (atppc->sc_use & ATPPC_USE_INTR) { 2259 ecr = atppc_r_ecr(atppc); 2260 atppc_barrier_w(atppc); 2261 2262 /* Wait for interrupt */ 2263 for (;;) { 2264 if (ecr & ATPPC_FIFO_EMPTY) { 2265 if (ecr & ATPPC_FIFO_FULL) { 2266 atppc->sc_outerr = EIO; 2267 atppc_fifo_write_error(atppc, 2268 worklen); 2269 return; 2270 } else { 2271 break; 2272 } 2273 } 2274 2275 /* Enable service interrupt */ 2276 ecr &= ~ATPPC_SERVICE_INTR; 2277 atppc_w_ecr(atppc, ecr); 2278 atppc_barrier_w(atppc); 2279 2280 atppc->sc_outerr = atppc_wait_interrupt(atppc, 2281 atppc->sc_outb, ATPPC_IRQ_FIFO); 2282 if (atppc->sc_outerr) { 2283 atppc_fifo_write_error(atppc, worklen); 2284 return; 2285 } 2286 2287 /* Get ECR value saved by interrupt handler */ 2288 ecr = atppc->sc_ecr_intr; 2289 } 2290 } else { 2291 for (; timecount < ((MAXBUSYWAIT/hz)*1000000); 2292 timecount++) { 2293 2294 ecr = atppc_r_ecr(atppc); 2295 atppc_barrier_r(atppc); 2296 if (ecr & ATPPC_FIFO_EMPTY) { 2297 if (ecr & ATPPC_FIFO_FULL) { 2298 atppc->sc_outerr = EIO; 2299 atppc_fifo_write_error(atppc, 2300 worklen); 2301 return; 2302 } else { 2303 break; 2304 } 2305 } 2306 DELAY(1); 2307 } 2308 2309 if (((timecount*hz)/1000000) >= MAXBUSYWAIT) { 2310 atppc->sc_outerr = EIO; 2311 atppc_fifo_write_error(atppc, worklen); 2312 return; 2313 } 2314 } 2315 2316 /* Update pointer */ 2317 atppc->sc_outbstart += worklen; 2318 } 2319 } 2320 2321 static void 2322 atppc_fifo_write_error(struct atppc_softc * const atppc, 2323 const unsigned int worklen) 2324 { 2325 unsigned char ecr = atppc_r_ecr(atppc); 2326 2327 /* Abort DMA if not finished */ 2328 if (atppc->sc_dmastat == ATPPC_DMA_STARTED) { 2329 atppc->sc_dma_abort(atppc); 2330 ATPPC_DPRINTF(("%s: DMA interrupted.\n", __func__)); 2331 } 2332 2333 /* Check for invalid states */ 2334 if ((ecr & ATPPC_FIFO_EMPTY) && (ecr & ATPPC_FIFO_FULL)) { 2335 ATPPC_DPRINTF(("%s: FIFO full+empty bits set.\n", __func__)); 2336 } else if (!(ecr & ATPPC_FIFO_EMPTY)) { 2337 unsigned char ctr = atppc_r_ctr(atppc); 2338 int bytes_left; 2339 int i; 2340 2341 ATPPC_DPRINTF(("%s(%s): FIFO not empty.\n", __func__, 2342 atppc->sc_dev.dv_xname)); 2343 2344 /* Drive strobe low to stop data transfer */ 2345 ctr &= ~STROBE; 2346 atppc_w_ctr(atppc, ctr); 2347 atppc_barrier_w(atppc); 2348 2349 /* Determine how many bytes remain in FIFO */ 2350 for (i = 0; i < atppc->sc_fifo; i++) { 2351 atppc_w_fifo(atppc, (unsigned char)i); 2352 ecr = atppc_r_ecr(atppc); 2353 atppc_barrier_r(atppc); 2354 if (ecr & ATPPC_FIFO_FULL) 2355 break; 2356 } 2357 bytes_left = (atppc->sc_fifo) - (i + 1); 2358 ATPPC_DPRINTF(("%s: %d bytes left in FIFO.\n", __func__, 2359 bytes_left)); 2360 2361 /* Update counter */ 2362 atppc->sc_outbstart += (worklen - bytes_left); 2363 } else { 2364 /* Update counter */ 2365 atppc->sc_outbstart += worklen; 2366 } 2367 2368 ATPPC_DPRINTF(("%s: reseting FIFO.\n", __func__)); 2369 atppc_w_ecr(atppc, ATPPC_ECR_PS2); 2370 atppc_barrier_w(atppc); 2371 } 2372 2373 /* 2374 * Poll status register using mask and status for MAXBUSYWAIT. 2375 * Returns 0 if device ready, error value otherwise. 2376 */ 2377 static int 2378 atppc_poll_str(const struct atppc_softc * const atppc, const u_int8_t status, 2379 const u_int8_t mask) 2380 { 2381 unsigned int timecount; 2382 u_int8_t str; 2383 int error = EIO; 2384 2385 /* Wait for str to have status for MAXBUSYWAIT */ 2386 for (timecount = 0; timecount < ((MAXBUSYWAIT/hz)*1000000); 2387 timecount++) { 2388 2389 str = atppc_r_str(atppc); 2390 atppc_barrier_r(atppc); 2391 if ((str & mask) == status) { 2392 error = 0; 2393 break; 2394 } 2395 DELAY(1); 2396 } 2397 2398 return error; 2399 } 2400 2401 /* Wait for interrupt for MAXBUSYWAIT: returns 0 if acknowledge received. */ 2402 static int 2403 atppc_wait_interrupt(struct atppc_softc * const atppc, const caddr_t where, 2404 const u_int8_t irqstat) 2405 { 2406 int error = EIO; 2407 2408 atppc->sc_irqstat &= ~irqstat; 2409 2410 /* Wait for interrupt for MAXBUSYWAIT */ 2411 error = ltsleep(where, PPBUSPRI | PCATCH, __func__, MAXBUSYWAIT, 2412 ATPPC_SC_LOCK(atppc)); 2413 2414 if (!(error) && (atppc->sc_irqstat & irqstat)) { 2415 atppc->sc_irqstat &= ~irqstat; 2416 error = 0; 2417 } 2418 2419 return error; 2420 } 2421
Indexes created Fri Sep 26 20:09:58 GMT 2025