Lines Matching defs:atppc
1 /* $NetBSD: atppc.c,v 1.42 2025/07/29 19:07:53 andvar Exp $ */
34 __KERNEL_RCSID(0, "$NetBSD: atppc.c,v 1.42 2025/07/29 19:07:53 andvar Exp $");
139 * Generic attach and detach functions for atppc device. If sc_dev_ok in soft
143 /* Soft configuration attach for atppc */
281 * Machine independent detection routines for atppc driver.
362 atppc_detect_chipset(struct atppc_softc *atppc)
367 if ((mode = chipset_detect[i](atppc)) != -1) {
368 atppc->sc_mode = mode;
378 atppc_detect_generic(struct atppc_softc *atppc)
380 u_int8_t ecr_sav = atppc_r_ecr(atppc);
381 u_int8_t ctr_sav = atppc_r_ctr(atppc);
382 u_int8_t str_sav = atppc_r_str(atppc);
384 atppc_barrier_r(atppc);
387 atppc->sc_type = ATPPC_TYPE_GENERIC;
388 atppc->sc_model = GENERIC;
391 tmp = atppc_r_ecr(atppc);
392 atppc_barrier_r(atppc);
394 atppc_w_ecr(atppc, 0x34);
395 atppc_barrier_w(atppc);
396 tmp = atppc_r_ecr(atppc);
397 atppc_barrier_r(atppc);
399 atppc->sc_has |= ATPPC_HAS_ECP;
404 if (atppc->sc_has & ATPPC_HAS_ECP) {
405 atppc_w_ecr(atppc, ATPPC_ECR_EPP);
406 atppc_barrier_w(atppc);
409 if (atppc_check_epp_timeout(atppc->sc_dev) != 0) {
410 atppc->sc_has |= ATPPC_HAS_EPP;
411 atppc->sc_epp = ATPPC_EPP_1_9;
412 if (atppc->sc_has & ATPPC_HAS_ECP) {
414 atppc->sc_model = SMC_LIKE;
415 atppc->sc_type = ATPPC_TYPE_SMCLIKE;
420 if (atppc->sc_has & ATPPC_HAS_ECP) {
422 atppc_w_ecr(atppc, ATPPC_ECR_PS2);
423 atppc_barrier_w(atppc);
426 atppc_w_ctr(atppc, 0x20);
427 atppc_barrier_w(atppc);
432 atppc_w_dtr(atppc, 0xaa);
433 atppc_barrier_w(atppc);
434 tmp = atppc_r_dtr(atppc);
435 atppc_barrier_r(atppc);
437 atppc_w_dtr(atppc, 0x55);
438 atppc_barrier_w(atppc);
439 tmp = atppc_r_dtr(atppc);
440 atppc_barrier_r(atppc);
442 atppc->sc_has |= ATPPC_HAS_PS2;
447 atppc_w_ecr(atppc, ecr_sav);
448 atppc_w_ctr(atppc, ctr_sav);
449 atppc_w_str(atppc, str_sav);
450 atppc_barrier_w(atppc);
459 atppc_detect_fifo(struct atppc_softc *atppc)
462 device_t dev = atppc->sc_dev;
471 if (!(atppc->sc_has & ATPPC_HAS_ECP)) {
476 ecr_sav = atppc_r_ecr(atppc);
477 ctr_sav = atppc_r_ctr(atppc);
478 str_sav = atppc_r_str(atppc);
479 atppc_barrier_r(atppc);
482 atppc_w_ecr(atppc, (ATPPC_ECR_CFG | ATPPC_SERVICE_INTR) &
484 atppc_barrier_w(atppc);
487 atppc->sc_pword = (atppc_r_cnfgA(atppc) & ATPPC_PWORD_MASK);
488 atppc_barrier_r(atppc);
491 if (atppc->sc_pword != ATPPC_PWORD_8) {
493 __func__, device_xname(dev), atppc->sc_pword));
498 atppc_w_ecr(atppc, ATPPC_ECR_PS2 | ATPPC_SERVICE_INTR);
499 atppc_w_ctr(atppc, (ctr_sav & ~IRQENABLE) | PCD);
501 atppc_w_ecr(atppc, ATPPC_ECR_TST | ATPPC_SERVICE_INTR);
502 atppc_barrier_w(atppc);
506 atppc_r_fifo(atppc);
507 atppc_barrier_r(atppc);
508 cc = atppc_r_ecr(atppc);
509 atppc_barrier_r(atppc);
520 atppc_w_ecr(atppc, ATPPC_ECR_TST);
521 atppc_barrier_w(atppc);
524 for (i = atppc->sc_rthr = atppc->sc_fifo = 0; i < 1024; i++) {
525 atppc_w_fifo(atppc, (char)i);
526 atppc_barrier_w(atppc);
527 cc = atppc_r_ecr(atppc);
528 atppc_barrier_r(atppc);
529 if ((atppc->sc_rthr == 0) && (cc & ATPPC_SERVICE_INTR)) {
531 atppc->sc_rthr = i + 1;
534 atppc->sc_fifo = i + 1;
545 atppc_w_ctr(atppc, (ctr_sav & ~IRQENABLE) & ~PCD);
546 atppc_barrier_w(atppc);
549 atppc_w_ecr(atppc, ATPPC_ECR_TST);
550 atppc_barrier_w(atppc);
553 for (atppc->sc_wthr = 0; i > -1; i--) {
554 atppc);
555 atppc_barrier_r(atppc);
556 if (cc != (char)(atppc->sc_fifo - i - 1)) {
562 cc = atppc_r_ecr(atppc);
563 atppc_barrier_r(atppc);
564 if ((atppc->sc_wthr == 0) && (cc & ATPPC_SERVICE_INTR)) {
566 atppc->sc_wthr = atppc->sc_fifo - i;
578 cc = atppc_r_ecr(atppc);
579 atppc_barrier_r(atppc);
587 atppc_w_ctr(atppc, ctr_sav);
588 atppc_w_str(atppc, str_sav);
589 atppc_w_ecr(atppc, ecr_sav);
590 atppc_barrier_w(atppc);
593 atppc->sc_has |= ATPPC_HAS_FIFO;
599 atppc_w_ctr(atppc, ctr_sav);
600 atppc_w_str(atppc, str_sav);
601 atppc_w_ecr(atppc, ecr_sav);
602 atppc_barrier_w(atppc);
607 /* Interrupt handler for atppc device: wakes up read/write functions */
612 struct atppc_softc *atppc = device_private(dev);
616 mutex_enter(&atppc->sc_lock);
619 atppc->sc_str_intr = atppc_r_str(atppc);
620 atppc->sc_ctr_intr = atppc_r_ctr(atppc);
621 atppc->sc_ecr_intr = atppc_r_ecr(atppc);
622 atppc_barrier_r(atppc);
625 switch (atppc->sc_mode) {
628 atppc->sc_irqstat = ATPPC_IRQ_nACK;
629 if (atppc->sc_outb)
638 if (!(atppc->sc_str_intr & nACK)) {
642 atppc->sc_irqstat = ATPPC_IRQ_nACK;
643 if (atppc->sc_inb)
650 if (atppc->sc_ecr_intr & ATPPC_SERVICE_INTR) {
651 if (atppc->sc_ecr_intr & ATPPC_ENABLE_DMA)
652 atppc->sc_irqstat |= ATPPC_IRQ_DMA;
654 atppc->sc_irqstat |= ATPPC_IRQ_FIFO;
657 if (atppc->sc_mode & ATPPC_MODE_ECP) {
658 if (atppc->sc_ctr_intr & PCD) {
659 if (atppc->sc_inb)
664 if (atppc->sc_outb)
670 if (atppc->sc_outb)
677 if ((atppc->sc_mode & ATPPC_MODE_ECP) &&
678 (atppc->sc_ecr_intr & ATPPC_nFAULT_INTR) &&
679 !(atppc->sc_str_intr & nFAULT)) {
682 atppc->sc_irqstat |= ATPPC_IRQ_nFAULT;
689 atppc->sc_irqstat = ATPPC_IRQ_nACK;
690 if (atppc->sc_inb)
692 else if (atppc->sc_outb)
708 cv_broadcast(&atppc->sc_in_cv);
712 cv_broadcast(&atppc->sc_out_cv);
720 SLIST_FOREACH(callback, &(atppc->sc_handler_listhead),
726 mutex_exit(&atppc->sc_lock);
739 struct atppc_softc *atppc = device_private(dev);
742 mutex_enter(&atppc->sc_lock);
745 error = !(atppc_r_str(atppc) & TIMEOUT);
746 atppc_barrier_r(atppc);
748 mutex_exit(&atppc->sc_lock);
763 struct atppc_softc *atppc = device_private(dev);
766 r = atppc_r_str(atppc);
767 atppc_barrier_r(atppc);
768 atppc_w_str(atppc, r | 0x1);
769 atppc_barrier_w(atppc);
770 atppc_w_str(atppc, r & 0xfe);
771 atppc_barrier_w(atppc);
777 /* Read from atppc device: returns 0 on success. */
782 struct atppc_softc *atppc = device_private(dev);
785 mutex_enter(&atppc->sc_lock);
790 atppc->sc_inb = atppc->sc_inbstart = buf;
791 atppc->sc_inb_nbytes = len;
794 atppc->sc_inerr = 0;
797 switch(atppc->sc_mode) {
804 atppc_nibble_read(atppc);
808 atppc_byte_read(atppc);
812 atppc_ecp_read(atppc);
816 atppc_epp_read(atppc);
825 *cnt = (atppc->sc_inbstart - atppc->sc_inb);
828 atppc->sc_inb = atppc->sc_inbstart = NULL;
829 atppc->sc_inb_nbytes = 0;
832 error = atppc->sc_inerr;
834 mutex_exit(&atppc->sc_lock);
839 /* Write to atppc device: returns 0 on success. */
843 struct atppc_softc * const atppc = device_private(dev);
848 mutex_enter(&atppc->sc_lock);
851 atppc->sc_outb = atppc->sc_outbstart = buf;
852 atppc->sc_outb_nbytes = len;
855 atppc->sc_outerr = 0;
858 switch (atppc->sc_mode) {
860 atppc_std_write(atppc);
870 atppc_fifo_write(atppc);
874 atppc_epp_write(atppc);
883 *cnt = (atppc->sc_outbstart - atppc->sc_outb);
886 atppc->sc_outb = atppc->sc_outbstart = NULL;
887 atppc->sc_outb_nbytes = 0;
890 error = atppc->sc_outerr;
892 mutex_exit(&atppc->sc_lock);
911 struct atppc_softc *atppc = device_private(dev);
916 mutex_enter(&atppc->sc_lock);
919 if (atppc->sc_has & ATPPC_HAS_ECP) {
921 ecr = (atppc_r_ecr(atppc) & 0x1f);
922 atppc_barrier_r(atppc);
933 if (atppc->sc_has & ATPPC_HAS_EPP) {
975 atppc_w_ecr(atppc, ATPPC_ECR_PS2);
976 atppc_barrier_w(atppc);
979 atppc_w_ecr(atppc, ecr);
980 atppc_barrier_w(atppc);
984 if (atppc->sc_has & ATPPC_HAS_EPP) {
993 if (atppc->sc_has & ATPPC_HAS_PS2) {
1022 atppc->sc_mode = chipset_mode;
1025 ecr = atppc_r_ctr(atppc);
1026 atppc_barrier_r(atppc);
1028 atppc_w_ctr(atppc, ecr);
1029 atppc_barrier_w(atppc);
1033 mutex_exit(&atppc->sc_lock);
1042 struct atppc_softc *atppc = device_private(dev);
1045 mutex_enter(&atppc->sc_lock);
1048 switch (atppc->sc_mode) {
1079 mutex_exit(&atppc->sc_lock);
1089 struct atppc_softc *atppc = device_private(dev);
1093 mutex_enter(&atppc->sc_lock);
1099 r = atppc_r_ecr(atppc);
1100 atppc_barrier_r(atppc);
1102 if (!(atppc->sc_has & ATPPC_HAS_ECP) || ((r != ATPPC_ECR_ECP)
1109 r = atppc_r_ecr(atppc);
1110 atppc_barrier_r(atppc);
1121 mutex_exit(&atppc->sc_lock);
1130 struct atppc_softc *atppc = device_private(dev);
1141 mutex_enter(&atppc->sc_lock);
1145 #define r_reg(register,atppc) bus_space_read_1((atppc)->sc_iot, \
1146 (atppc)->sc_ioh, (register))
1147 #define w_reg(register, atppc, byte) bus_space_write_1((atppc)->sc_iot, \
1148 (atppc)->sc_ioh, (register), (byte))
1154 cc = r_reg(mi->arg[0].i, atppc);
1155 atppc_barrier_r(atppc);
1158 w_reg(mi->arg[0].i, atppc, cc);
1159 atppc_barrier_w(atppc);
1165 ptr = atppc->sc_ptr;
1168 accum = atppc->sc_accum;
1170 w_reg(reg, atppc, *ptr++);
1171 atppc_barrier_w(atppc);
1173 atppc->sc_accum = accum;
1176 w_reg(reg, atppc, *ptr++);
1177 atppc_barrier_w(atppc);
1181 atppc->sc_ptr = ptr;
1188 ptr = atppc->sc_ptr;
1191 accum = atppc->sc_accum;
1193 *ptr++ = r_reg(reg, atppc) & mask;
1194 atppc_barrier_r(atppc);
1196 atppc->sc_accum = accum;
1199 *ptr++ = r_reg(reg, atppc) & mask;
1200 atppc_barrier_r(atppc);
1204 atppc->sc_ptr = ptr;
1209 *((char *)mi->arg[2].p) = r_reg(mi->arg[0].i, atppc) &
1211 atppc_barrier_r(atppc);
1220 w_reg(mi->arg[0].i, atppc,
1222 atppc_barrier_w(atppc);
1233 tsleep(atppc, PPBUSPRI, "atppcdelay",
1246 w_reg(reg, atppc, *p++);
1247 atppc_barrier_w(atppc);
1255 atppc->sc_accum = mi->arg[0].i;
1260 if (--atppc->sc_accum > 0) {
1268 cc = atppc_r_str(atppc);
1269 atppc_barrier_r(atppc);
1277 cc = atppc_r_str(atppc);
1278 atppc_barrier_r(atppc);
1286 cc = atppc_r_str(atppc);
1287 atppc_barrier_r(atppc);
1301 atppc->sc_ptr))) {
1302 mutex_exit(&atppc->sc_lock);
1309 atppc->sc_ptr = (char *)mi->arg[0].p;
1346 * Can't return to atppc level during the execution
1350 panic("%s: cannot return to atppc level",
1353 /* update pc for atppc level of execution */
1356 mutex_exit(&atppc->sc_lock);
1377 struct atppc_softc *atppc = device_private(dev);
1380 mutex_enter(&atppc->sc_lock);
1384 bus_space_write_multi_1(atppc->sc_iot, atppc->sc_ioh,
1388 bus_space_write_multi_2(atppc->sc_iot, atppc->sc_ioh,
1392 bus_space_write_multi_4(atppc->sc_iot, atppc->sc_ioh,
1396 bus_space_read_multi_1(atppc->sc_iot, atppc->sc_ioh,
1400 bus_space_read_multi_2(atppc->sc_iot, atppc->sc_ioh,
1404 bus_space_read_multi_4(atppc->sc_iot, atppc->sc_ioh,
1408 val = (atppc_r_dtr(atppc));
1411 val = (atppc_r_str(atppc));
1414 val = (atppc_r_ctr(atppc));
1417 val = (atppc_r_eppA(atppc));
1420 val = (atppc_r_eppD(atppc));
1423 val = (atppc_r_ecr(atppc));
1426 val = (atppc_r_fifo(atppc));
1429 atppc_w_dtr(atppc, byte);
1432 atppc_w_str(atppc, byte);
1435 atppc_w_ctr(atppc, byte);
1438 atppc_w_eppA(atppc, byte);
1441 atppc_w_eppD(atppc, byte);
1444 atppc_w_ecr(atppc, byte);
1447 atppc_w_fifo(atppc, byte);
1455 atppc_barrier(atppc);
1457 mutex_exit(&atppc->sc_lock);
1462 /* Read "instance variables" of atppc device */
1466 struct atppc_softc *atppc = device_private(dev);
1469 mutex_enter(&atppc->sc_lock);
1473 if (atppc->sc_epp == ATPPC_EPP_1_9)
1475 else if (atppc->sc_epp == ATPPC_EPP_1_7)
1481 *val = ((atppc->sc_use & ATPPC_USE_INTR) != 0);
1485 *val = ((atppc->sc_use & ATPPC_USE_DMA) != 0);
1492 mutex_exit(&atppc->sc_lock);
1497 /* Write "instance variables" of atppc device */
1501 struct atppc_softc *atppc = device_private(dev);
1504 mutex_enter(&atppc->sc_lock);
1509 atppc->sc_epp = *val;
1516 atppc->sc_use &= ~ATPPC_USE_INTR;
1517 else if (atppc->sc_has & ATPPC_HAS_INTR)
1518 atppc->sc_use |= ATPPC_USE_INTR;
1525 atppc->sc_use &= ~ATPPC_USE_DMA;
1526 else if (atppc->sc_has & ATPPC_HAS_DMA)
1527 atppc->sc_use |= ATPPC_USE_DMA;
1536 mutex_exit(&atppc->sc_lock);
1545 struct atppc_softc *atppc = device_private(dev);
1557 mutex_enter(&atppc->sc_lock);
1558 SLIST_INSERT_HEAD(&(atppc->sc_handler_listhead),
1560 mutex_exit(&atppc->sc_lock);
1569 struct atppc_softc *atppc = device_private(dev);
1573 mutex_enter(&atppc->sc_lock);
1575 if (SLIST_EMPTY(&(atppc->sc_handler_listhead)))
1580 SLIST_FOREACH(callback, &(atppc->sc_handler_listhead), entries) {
1582 SLIST_REMOVE(&(atppc->sc_handler_listhead), callback,
1589 mutex_exit(&atppc->sc_lock);
1612 atppc_nibble_read(struct atppc_softc *atppc)
1620 if (atppc->sc_use & ATPPC_USE_INTR) {
1621 ctr = atppc_r_ctr(atppc);
1622 atppc_barrier_r(atppc);
1625 atppc_w_ctr(atppc, ctr);
1626 atppc_barrier_w(atppc);
1630 while (atppc->sc_inbstart < (atppc->sc_inb + atppc->sc_inb_nbytes)) {
1632 str = atppc_r_str(atppc);
1633 atppc_barrier_r(atppc);
1641 ctr = atppc_r_ctr(atppc);
1642 atppc_barrier_r(atppc);
1644 atppc_w_ctr(atppc, ctr);
1645 atppc_barrier_w(atppc);
1650 atppc->sc_inerr = atppc_poll_str(atppc, 0, PTRCLK);
1651 if (atppc->sc_inerr)
1655 nibble[i] = atppc_r_str(atppc);
1659 atppc_w_ctr(atppc, ctr);
1662 if (atppc->sc_use & ATPPC_USE_INTR)
1663 atppc->sc_inerr = atppc_wait_interrupt(atppc,
1664 &atppc->sc_in_cv, ATPPC_IRQ_nACK);
1666 atppc->sc_inerr = atppc_poll_str(atppc, PTRCLK,
1668 if (atppc->sc_inerr)
1673 *(atppc->sc_inbstart) = ((nibble2char(nibble[1]) << 4) & 0xf0) |
1675 atppc->sc_inbstart++;
1681 atppc_byte_read(struct atppc_softc * const atppc)
1687 ctr = atppc_r_ctr(atppc);
1688 atppc_barrier_r(atppc);
1691 "bit set.", device_xname(atppc->sc_dev)));
1692 atppc->sc_inerr = ENODEV;
1696 if (atppc->sc_use & ATPPC_USE_INTR) {
1699 atppc_w_ctr(atppc, ctr);
1700 atppc_barrier_w(atppc);
1705 while (atppc->sc_inbstart < (atppc->sc_inb + atppc->sc_inb_nbytes)) {
1707 str = atppc_r_str(atppc);
1708 atppc_barrier_r(atppc);
1715 atppc_w_ctr(atppc, ctr);
1716 atppc_barrier_w(atppc);
1719 atppc->sc_inerr = atppc_poll_str(atppc, 0, PTRCLK);
1720 if (atppc->sc_inerr)
1724 *(atppc->sc_inbstart) = atppc_r_dtr(atppc);
1725 atppc_barrier_r(atppc);
1729 atppc_w_ctr(atppc, ctr);
1730 atppc_barrier_w(atppc);
1733 if (atppc->sc_use & ATPPC_USE_INTR)
1734 atppc->sc_inerr = atppc_wait_interrupt(atppc,
1735 &atppc->sc_in_cv, ATPPC_IRQ_nACK);
1737 atppc->sc_inerr = atppc_poll_str(atppc, PTRCLK, PTRCLK);
1738 if (atppc->sc_inerr)
1743 atppc_w_str(atppc, str);
1744 atppc_barrier_w(atppc);
1747 atppc_w_str(atppc, str);
1748 atppc_barrier_w(atppc);
1751 atppc->sc_inbstart++;
1757 atppc_epp_read(struct atppc_softc * atppc)
1759 if (atppc->sc_epp == ATPPC_EPP_1_9) {
1764 atppc_reset_epp_timeout(atppc->sc_dev);
1765 for (i = 0; i < atppc->sc_inb_nbytes; i++) {
1766 *(atppc->sc_inbstart) = atppc_r_eppD(atppc);
1767 atppc_barrier_r(atppc);
1768 str = atppc_r_str(atppc);
1769 atppc_barrier_r(atppc);
1771 atppc->sc_inerr = EIO;
1774 atppc->sc_inbstart++;
1779 atppc_r_eppD_multi(atppc, atppc->sc_inbstart,
1780 atppc->sc_inb_nbytes);
1781 atppc_barrier_r(atppc);
1783 atppc->sc_inbstart += atppc->sc_inb_nbytes;
1791 atppc_ecp_read(struct atppc_softc *atppc)
1796 const unsigned char ctr_sav = atppc_r_ctr(atppc);
1797 const unsigned char ecr_sav = atppc_r_ecr(atppc);
1802 atppc_barrier_r(atppc);
1805 "bit set.", device_xname(atppc->sc_dev)));
1806 atppc->sc_inerr = ENODEV;
1811 if (atppc->sc_use & ATPPC_USE_INTR)
1812 atppc->sc_irqstat &= ~ATPPC_IRQ_nFAULT;
1814 while (atppc->sc_inbstart < (atppc->sc_inb + atppc->sc_inb_nbytes)) {
1815 ecr = atppc_r_ecr(atppc);
1816 atppc_barrier_r(atppc);
1820 atppc_ecp_read_error(atppc);
1825 str = atppc_r_str(atppc);
1826 atppc_barrier_r(atppc);
1831 if (atppc->sc_use & ATPPC_USE_INTR) {
1834 atppc_w_ecr(atppc, ecr);
1835 atppc_barrier_w(atppc);
1837 atppc->sc_inerr = atppc_wait_interrupt(atppc,
1838 &atppc->sc_in_cv, ATPPC_IRQ_FIFO);
1839 if (atppc->sc_inerr)
1848 worklen = atppc->sc_fifo;
1852 worklen = atppc->sc_rthr;
1858 if ((atppc->sc_use & ATPPC_USE_INTR) &&
1859 (atppc->sc_use & ATPPC_USE_DMA)) {
1861 atppc_ecp_read_dma(atppc, &worklen, ecr);
1863 atppc_ecp_read_pio(atppc, &worklen, ecr);
1866 if (atppc->sc_inerr) {
1867 atppc_ecp_read_error(atppc);
1872 atppc->sc_inbstart += worklen;
1875 atppc_w_ctr(atppc, ctr_sav);
1876 atppc_w_ecr(atppc, ecr_sav);
1877 atppc_barrier_w(atppc);
1882 atppc_ecp_read_dma(struct atppc_softc *atppc, unsigned int *length,
1886 *length = uimin(*length, atppc->sc_dma_maxsize);
1887 atppc->sc_dmastat = ATPPC_DMA_INIT;
1888 atppc->sc_dma_start(atppc, atppc->sc_inbstart, *length,
1891 atppc->sc_dmastat = ATPPC_DMA_STARTED;
1896 atppc_w_ecr(atppc, ecr);
1897 atppc_barrier_w(atppc);
1900 atppc->sc_inerr = atppc_wait_interrupt(atppc, &atppc->sc_in_cv,
1902 if (atppc->sc_inerr)
1906 ecr = atppc->sc_ecr_intr;
1908 atppc->sc_dma_finish(atppc);
1909 atppc->sc_dmastat = ATPPC_DMA_COMPLETE;
1912 atppc_w_ecr(atppc, ecr);
1913 atppc_barrier_w(atppc);
1918 atppc_ecp_read_pio(struct atppc_softc *atppc, unsigned int *length,
1923 atppc_w_ecr(atppc, ecr);
1924 atppc_barrier_w(atppc);
1927 atppc_r_fifo_multi(atppc, atppc->sc_inbstart, *length);
1932 atppc_ecp_read_error(struct atppc_softc *atppc)
1934 unsigned char ecr = atppc_r_ecr(atppc);
1937 if (atppc->sc_dmastat == ATPPC_DMA_STARTED) {
1938 atppc->sc_dma_abort(atppc);
1946 atppc_w_ecr(atppc, ATPPC_ECR_PS2);
1947 atppc_barrier_w(atppc);
1958 atppc_std_write(struct atppc_softc * const atppc)
1962 ctr = atppc_r_ctr(atppc);
1963 atppc_barrier_r(atppc);
1965 if (atppc->sc_use & ATPPC_USE_INTR) {
1968 atppc_w_ctr(atppc, ctr);
1969 atppc_barrier_w(atppc);
1973 while (atppc->sc_outbstart < (atppc->sc_outb + atppc->sc_outb_nbytes)) {
1975 atppc->sc_outerr = atppc_poll_str(atppc, SPP_READY, SPP_MASK);
1976 if (atppc->sc_outerr)
1980 atppc_w_dtr(atppc, *(atppc->sc_outbstart));
1981 atppc_barrier_w(atppc);
1986 atppc_w_ctr(atppc, ctr);
1987 atppc_barrier_w(atppc);
1990 atppc_w_ctr(atppc, ctr);
1991 atppc_barrier_w(atppc);
1994 if (atppc->sc_use & ATPPC_USE_INTR) {
1995 atppc->sc_outerr = atppc_wait_interrupt(atppc,
1996 &atppc->sc_out_cv, ATPPC_IRQ_nACK);
1997 if (atppc->sc_outerr)
2001 atppc->sc_outerr = atppc_poll_str(atppc, 0, nACK);
2002 if (atppc->sc_outerr)
2004 atppc->sc_outerr = atppc_poll_str(atppc, nACK, nACK);
2005 if (atppc->sc_outerr)
2010 atppc->sc_outbstart++;
2017 atppc_epp_write(struct atppc_softc *atppc)
2019 if (atppc->sc_epp == ATPPC_EPP_1_9) {
2024 atppc_reset_epp_timeout(atppc->sc_dev);
2025 for (i = 0; i < atppc->sc_outb_nbytes; i++) {
2026 atppc_w_eppD(atppc, *(atppc->sc_outbstart));
2027 atppc_barrier_w(atppc);
2028 str = atppc_r_str(atppc);
2029 atppc_barrier_r(atppc);
2031 atppc->sc_outerr = EIO;
2034 atppc->sc_outbstart++;
2039 atppc_w_eppD_multi(atppc, atppc->sc_outbstart,
2040 atppc->sc_outb_nbytes);
2041 atppc_barrier_w(atppc);
2043 atppc->sc_outbstart += atppc->sc_outb_nbytes;
2052 atppc_fifo_write(struct atppc_softc * const atppc)
2056 const unsigned char ctr_sav = atppc_r_ctr(atppc);
2057 const unsigned char ecr_sav = atppc_r_ecr(atppc);
2061 atppc_barrier_r(atppc);
2064 atppc_w_ecr(atppc, ATPPC_ECR_PS2);
2065 atppc_barrier_w(atppc);
2068 atppc_w_ctr(atppc, ctr);
2069 atppc_barrier_w(atppc);
2071 atppc_w_ecr(atppc, ecr);
2072 atppc_barrier_w(atppc);
2075 if ((atppc->sc_use & ATPPC_USE_DMA) &&
2076 (atppc->sc_use & ATPPC_USE_INTR)) {
2078 atppc_fifo_write_dma(atppc, ecr, ctr);
2080 atppc_fifo_write_pio(atppc, ecr, ctr);
2084 atppc_w_ctr(atppc, ctr_sav);
2085 atppc_w_ecr(atppc, ecr_sav);
2086 atppc_barrier_w(atppc);
2090 atppc_fifo_write_dma(struct atppc_softc * const atppc, unsigned char ecr,
2096 for (len = (atppc->sc_outb + atppc->sc_outb_nbytes) -
2097 atppc->sc_outbstart; len > 0; len = (atppc->sc_outb +
2098 atppc->sc_outb_nbytes) - atppc->sc_outbstart) {
2101 atppc->sc_outerr = atppc_poll_str(atppc, SPP_READY, SPP_MASK);
2102 if (atppc->sc_outerr)
2106 atppc_w_ecr(atppc, ATPPC_ECR_PS2);
2107 atppc_barrier_w(atppc);
2108 atppc_w_ecr(atppc, ecr);
2109 atppc_barrier_w(atppc);
2112 worklen = uimin(len, atppc->sc_dma_maxsize);
2113 atppc->sc_dmastat = ATPPC_DMA_INIT;
2114 atppc->sc_dma_start(atppc, atppc->sc_outbstart,
2116 atppc->sc_dmastat = ATPPC_DMA_STARTED;
2121 atppc_w_ecr(atppc, ecr);
2122 atppc_barrier_w(atppc);
2125 atppc->sc_outerr = atppc_wait_interrupt(atppc,
2126 &atppc->sc_out_cv, ATPPC_IRQ_DMA);
2127 if (atppc->sc_outerr) {
2128 atppc_fifo_write_error(atppc, worklen);
2132 ecr = atppc->sc_ecr_intr;
2134 atppc->sc_dma_finish(atppc);
2135 atppc->sc_dmastat = ATPPC_DMA_COMPLETE;
2138 atppc_w_ecr(atppc, ecr);
2139 atppc_barrier_w(atppc);
2145 atppc->sc_outerr = EIO;
2146 atppc_fifo_write_error(atppc, worklen);
2155 atppc_w_ecr(atppc, ecr);
2156 atppc_barrier_w(atppc);
2158 atppc->sc_outerr = atppc_wait_interrupt(atppc,
2159 &atppc->sc_out_cv, ATPPC_IRQ_FIFO);
2160 if (atppc->sc_outerr) {
2161 atppc_fifo_write_error(atppc, worklen);
2166 ecr = atppc->sc_ecr_intr;
2170 atppc->sc_outbstart += worklen;
2175 atppc_fifo_write_pio(struct atppc_softc * const atppc, unsigned char ecr,
2184 atppc_w_ecr(atppc, ecr);
2185 atppc_barrier_w(atppc);
2187 for (len = (atppc->sc_outb + atppc->sc_outb_nbytes) -
2188 atppc->sc_outbstart; len > 0; len = (atppc->sc_outb +
2189 atppc->sc_outb_nbytes) - atppc->sc_outbstart) {
2192 atppc->sc_outerr = atppc_poll_str(atppc, SPP_READY, SPP_MASK);
2193 if (atppc->sc_outerr)
2197 worklen = uimin(len, atppc->sc_fifo);
2200 atppc_w_fifo_multi(atppc, atppc->sc_outbstart, worklen);
2203 if (atppc->sc_use & ATPPC_USE_INTR) {
2204 ecr = atppc_r_ecr(atppc);
2205 atppc_barrier_w(atppc);
2211 atppc->sc_outerr = EIO;
2212 atppc_fifo_write_error(atppc,
2222 atppc_w_ecr(atppc, ecr);
2223 atppc_barrier_w(atppc);
2225 atppc->sc_outerr = atppc_wait_interrupt(atppc,
2226 &atppc->sc_out_cv, ATPPC_IRQ_FIFO);
2227 if (atppc->sc_outerr) {
2228 atppc_fifo_write_error(atppc, worklen);
2233 ecr = atppc->sc_ecr_intr;
2239 ecr = atppc_r_ecr(atppc);
2240 atppc_barrier_r(atppc);
2243 atppc->sc_outerr = EIO;
2244 atppc_fifo_write_error(atppc,
2255 atppc->sc_outerr = EIO;
2256 atppc_fifo_write_error(atppc, worklen);
2262 atppc->sc_outbstart += worklen;
2267 atppc_fifo_write_error(struct atppc_softc * const atppc,
2270 unsigned char ecr = atppc_r_ecr(atppc);
2273 if (atppc->sc_dmastat == ATPPC_DMA_STARTED) {
2274 atppc->sc_dma_abort(atppc);
2282 unsigned char ctr = atppc_r_ctr(atppc);
2287 device_xname(atppc->sc_dev)));
2291 atppc_w_ctr(atppc, ctr);
2292 atppc_barrier_w(atppc);
2295 for (i = 0; i < atppc->sc_fifo; i++) {
2296 atppc_w_fifo(atppc, (unsigned char)i);
2297 ecr = atppc_r_ecr(atppc);
2298 atppc_barrier_r(atppc);
2302 bytes_left = (atppc->sc_fifo) - (i + 1);
2307 atppc->sc_outbstart += (worklen - bytes_left);
2310 atppc->sc_outbstart += worklen;
2314 atppc_w_ecr(atppc, ATPPC_ECR_PS2);
2315 atppc_barrier_w(atppc);
2323 atppc_poll_str(const struct atppc_softc * const atppc, const u_int8_t status,
2334 str = atppc_r_str(atppc);
2335 atppc_barrier_r(atppc);
2348 atppc_wait_interrupt(struct atppc_softc * const atppc, kcondvar_t *cv,
2353 atppc->sc_irqstat &= ~irqstat;
2356 error = cv_timedwait_sig(cv, &atppc->sc_lock, MAXBUSYWAIT);
2358 if (!(error) && (atppc->sc_irqstat & irqstat)) {
2359 atppc->sc_irqstat &= ~irqstat;
Indexes created Thu Oct 02 10:09:58 GMT 2025