Lines Matching defs:pi1ppc
1 /* $NetBSD: pi1ppc.c,v 1.17 2022/11/01 19:45:35 andvar Exp $ */
36 __KERNEL_RCSID(0, "$NetBSD: pi1ppc.c,v 1.17 2022/11/01 19:45:35 andvar Exp $");
77 static uint8_t r_reg(int reg, struct pi1ppc_softc *pi1ppc);
78 static void w_reg(int reg, struct pi1ppc_softc *pi1ppc, uint8_t byte);
146 CFATTACH_DECL_NEW(pi1ppc, sizeof(struct pi1ppc_softc),
193 * Generic attach and detach functions for pi1ppc device.
199 /* Soft configuration attach for pi1ppc */
328 /* Interrupt handler for pi1ppc device: wakes up read/write functions */
335 struct pi1ppc_softc *pi1ppc = device_private(dev);
339 PI1PPC_LOCK(pi1ppc);
342 pi1ppc->sc_str_intr = pi1ppc_r_str(pi1ppc);
343 pi1ppc->sc_ctr_intr = pi1ppc_r_ctr(pi1ppc);
344 pi1ppc_barrier_r(pi1ppc);
463 /* Read from pi1ppc device: returns 0 on success. */
468 struct pi1ppc_softc *pi1ppc = device_private(dev);
471 PI1PPC_LOCK(pi1ppc);
476 pi1ppc->sc_inb = pi1ppc->sc_inbstart = buf;
477 pi1ppc->sc_inb_nbytes = len;
480 pi1ppc->sc_inerr = 0;
483 switch(pi1ppc->sc_mode) {
489 pi1ppc_nibble_read(pi1ppc);
493 pi1ppc_byte_read(pi1ppc);
502 *cnt = (pi1ppc->sc_inbstart - pi1ppc->sc_inb);
505 pi1ppc->sc_inb = pi1ppc->sc_inbstart = NULL;
506 pi1ppc->sc_inb_nbytes = 0;
509 error = pi1ppc->sc_inerr;
511 PI1PPC_UNLOCK(pi1ppc);
516 /* Write to pi1ppc device: returns 0 on success. */
520 struct pi1ppc_softc * const pi1ppc = device_private(dev);
525 PI1PPC_LOCK(pi1ppc);
528 pi1ppc->sc_outb = pi1ppc->sc_outbstart = buf;
529 pi1ppc->sc_outb_nbytes = len;
532 pi1ppc->sc_outerr = 0;
535 switch (pi1ppc->sc_mode) {
537 pi1ppc_std_write(pi1ppc);
551 *cnt = (pi1ppc->sc_outbstart - pi1ppc->sc_outb);
554 pi1ppc->sc_outb = pi1ppc->sc_outbstart = NULL;
555 pi1ppc->sc_outb_nbytes = 0;
558 error = pi1ppc->sc_outerr;
560 PI1PPC_UNLOCK(pi1ppc);
579 struct pi1ppc_softc *pi1ppc = device_private(dev);
584 PI1PPC_LOCK(pi1ppc);
613 pi1ppc->sc_mode = chipset_mode;
616 ecr = pi1ppc_r_ctr(pi1ppc);
617 pi1ppc_barrier_r(pi1ppc);
619 pi1ppc_w_ctr(pi1ppc, ecr);
620 pi1ppc_barrier_w(pi1ppc);
624 PI1PPC_UNLOCK(pi1ppc);
633 struct pi1ppc_softc *pi1ppc = device_private(dev);
636 PI1PPC_LOCK(pi1ppc);
639 switch (pi1ppc->sc_mode) {
658 PI1PPC_UNLOCK(pi1ppc);
682 r_reg(int reg, struct pi1ppc_softc *pi1ppc)
688 val = bus_space_read_4((pi1ppc)->sc_iot,
689 (pi1ppc)->sc_ioh, IOC_PLP_STAT);
703 val = bus_space_read_4((pi1ppc)->sc_iot,
704 (pi1ppc)->sc_ioh, IOC_PLP_CTL);
720 val = bus_space_read_4((pi1ppc)->sc_iot,
721 (pi1ppc)->sc_ioh, IOC_PLP_DATA);
731 w_reg(int reg, struct pi1ppc_softc *pi1ppc, uint8_t byte)
746 bus_space_write_4((pi1ppc)->sc_iot,
747 (pi1ppc)->sc_ioh, IOC_PLP_CTL, byte);
751 bus_space_write_4((pi1ppc)->sc_iot,
752 (pi1ppc)->sc_ioh, IOC_PLP_DATA, byte);
759 struct pi1ppc_softc *pi1ppc = device_private(dev);
770 PI1PPC_LOCK(pi1ppc);
776 cc = r_reg(mi->arg[0].i, pi1ppc);
777 pi1ppc_barrier_r(pi1ppc);
780 w_reg(mi->arg[0].i, pi1ppc, cc);
781 pi1ppc_barrier_w(pi1ppc);
787 ptr = pi1ppc->sc_ptr;
790 accum = pi1ppc->sc_accum;
792 w_reg(reg, pi1ppc, *ptr++);
793 pi1ppc_barrier_w(pi1ppc);
795 pi1ppc->sc_accum = accum;
798 w_reg(reg, pi1ppc, *ptr++);
799 pi1ppc_barrier_w(pi1ppc);
803 pi1ppc->sc_ptr = ptr;
810 ptr = pi1ppc->sc_ptr;
813 accum = pi1ppc->sc_accum;
815 *ptr++ = r_reg(reg, pi1ppc) & mask;
816 pi1ppc_barrier_r(pi1ppc);
818 pi1ppc->sc_accum = accum;
821 *ptr++ = r_reg(reg, pi1ppc) & mask;
822 pi1ppc_barrier_r(pi1ppc);
826 pi1ppc->sc_ptr = ptr;
831 *((char *)mi->arg[2].p) = r_reg(mi->arg[0].i, pi1ppc) &
833 pi1ppc_barrier_r(pi1ppc);
842 w_reg(mi->arg[0].i, pi1ppc,
844 pi1ppc_barrier_w(pi1ppc);
867 w_reg(reg, pi1ppc, *p++);
868 pi1ppc_barrier_w(pi1ppc);
876 pi1ppc->sc_accum = mi->arg[0].i;
881 if (--pi1ppc->sc_accum > 0) {
889 cc = pi1ppc_r_str(pi1ppc);
890 pi1ppc_barrier_r(pi1ppc);
898 cc = pi1ppc_r_str(pi1ppc);
899 pi1ppc_barrier_r(pi1ppc);
907 cc = pi1ppc_r_str(pi1ppc);
908 pi1ppc_barrier_r(pi1ppc);
922 pi1ppc->sc_ptr))) {
923 PI1PPC_UNLOCK(pi1ppc);
930 pi1ppc->sc_ptr = (char *)mi->arg[0].p;
967 * Can't return to pi1ppc level during the execution
971 panic("%s: cannot return to pi1ppc level",
974 /* update pc for pi1ppc level of execution */
977 PI1PPC_UNLOCK(pi1ppc);
997 struct pi1ppc_softc *pi1ppc = device_private(dev);
1000 PI1PPC_LOCK(pi1ppc);
1004 val = r_reg(AT_DATA_REG, pi1ppc);
1007 val = r_reg(AT_STAT_REG, pi1ppc);
1010 val = r_reg(AT_CTL_REG, pi1ppc);
1013 w_reg(AT_DATA_REG, pi1ppc, byte);
1019 w_reg(AT_CTL_REG, pi1ppc, byte);
1027 pi1ppc_barrier(pi1ppc);
1029 PI1PPC_UNLOCK(pi1ppc);
1034 /* Read "instance variables" of pi1ppc device */
1038 struct pi1ppc_softc *pi1ppc = device_private(dev);
1041 PI1PPC_LOCK(pi1ppc);
1045 *val = ((pi1ppc->sc_use & PI1PPC_USE_INTR) != 0);
1049 *val = ((pi1ppc->sc_use & PI1PPC_USE_DMA) != 0);
1056 PI1PPC_UNLOCK(pi1ppc);
1060 /* Write "instance variables" of pi1ppc device */
1064 struct pi1ppc_softc *pi1ppc = device_private(dev);
1067 PI1PPC_LOCK(pi1ppc);
1072 pi1ppc->sc_use &= ~PI1PPC_USE_INTR;
1073 else if (pi1ppc->sc_has & PI1PPC_HAS_INTR)
1074 pi1ppc->sc_use |= PI1PPC_USE_INTR;
1081 pi1ppc->sc_use &= ~PI1PPC_USE_DMA;
1082 else if (pi1ppc->sc_has & PI1PPC_HAS_DMA)
1083 pi1ppc->sc_use |= PI1PPC_USE_DMA;
1092 PI1PPC_UNLOCK(pi1ppc);
1100 struct pi1ppc_softc *pi1ppc = device_private(dev);
1110 PI1PPC_LOCK(pi1ppc);
1113 SLIST_INSERT_HEAD(&(pi1ppc->sc_handler_listhead), callback, entries);
1114 PI1PPC_UNLOCK(pi1ppc);
1123 struct pi1ppc_softc *pi1ppc = device_private(dev);
1127 PI1PPC_LOCK(pi1ppc);
1128 KASSERT(!SLIST_EMPTY(&(pi1ppc->sc_handler_listhead)));
1129 SLIST_FOREACH(callback, &(pi1ppc->sc_handler_listhead), entries) {
1131 SLIST_REMOVE(&(pi1ppc->sc_handler_listhead), callback,
1137 PI1PPC_UNLOCK(pi1ppc);
1165 pi1ppc_nibble_read(struct pi1ppc_softc *pi1ppc)
1173 if (pi1ppc->sc_use & PI1PPC_USE_INTR) {
1179 ctr = pi1ppc_r_ctr(pi1ppc);
1183 pi1ppc_w_ctr(pi1ppc, ctr);
1184 pi1ppc_barrier_w(pi1ppc);
1189 while (pi1ppc->sc_inbstart < (pi1ppc->sc_inb + pi1ppc->sc_inb_nbytes)) {
1191 str = pi1ppc_r_str(pi1ppc);
1192 pi1ppc_barrier_r(pi1ppc);
1200 ctr = pi1ppc_r_ctr(pi1ppc);
1201 pi1ppc_barrier_r(pi1ppc);
1203 pi1ppc_w_ctr(pi1ppc, ctr);
1204 pi1ppc_barrier_w(pi1ppc);
1209 pi1ppc->sc_inerr = pi1ppc_poll_str(pi1ppc, 0, PTRCLK);
1210 if (pi1ppc->sc_inerr)
1214 nibble[i] = pi1ppc_r_str(pi1ppc);
1218 pi1ppc_w_ctr(pi1ppc, ctr);
1221 if (pi1ppc->sc_use & PI1PPC_USE_INTR)
1222 pi1ppc->sc_inerr = pi1ppc_wait_interrupt(pi1ppc,
1223 &pi1ppc->sc_in_cv, PI1PPC_IRQ_nACK);
1225 pi1ppc->sc_inerr = pi1ppc_poll_str(pi1ppc, PTRCLK,
1227 if (pi1ppc->sc_inerr)
1232 *(pi1ppc->sc_inbstart) = ((nibble2char(nibble[1]) << 4) & 0xf0) |
1234 pi1ppc->sc_inbstart++;
1240 pi1ppc_byte_read(struct pi1ppc_softc * const pi1ppc)
1246 ctr = pi1ppc_r_ctr(pi1ppc);
1247 pi1ppc_barrier_r(pi1ppc);
1250 "bit set.", device_xname(pi1ppc->sc_dev)));
1251 pi1ppc->sc_inerr = ENODEV;
1258 if (pi1ppc->sc_use & PI1PPC_USE_INTR) {
1261 pi1ppc_w_ctr(pi1ppc, ctr);
1262 pi1ppc_barrier_w(pi1ppc);
1268 while (pi1ppc->sc_inbstart < (pi1ppc->sc_inb + pi1ppc->sc_inb_nbytes)) {
1270 str = pi1ppc_r_str(pi1ppc);
1271 pi1ppc_barrier_r(pi1ppc);
1278 pi1ppc_w_ctr(pi1ppc, ctr);
1279 pi1ppc_barrier_w(pi1ppc);
1282 pi1ppc->sc_inerr = pi1ppc_poll_str(pi1ppc, 0, PTRCLK);
1283 if (pi1ppc->sc_inerr)
1287 *(pi1ppc->sc_inbstart) = pi1ppc_r_dtr(pi1ppc);
1288 pi1ppc_barrier_r(pi1ppc);
1292 pi1ppc_w_ctr(pi1ppc, ctr);
1293 pi1ppc_barrier_w(pi1ppc);
1296 if (pi1ppc->sc_use & PI1PPC_USE_INTR)
1297 pi1ppc->sc_inerr = pi1ppc_wait_interrupt(pi1ppc,
1298 &pi1ppc->sc_in_cv, PI1PPC_IRQ_nACK);
1300 pi1ppc->sc_inerr = pi1ppc_poll_str(pi1ppc, PTRCLK, PTRCLK);
1301 if (pi1ppc->sc_inerr)
1306 pi1ppc_w_str(pi1ppc, str);
1307 pi1ppc_barrier_w(pi1ppc);
1310 pi1ppc_w_str(pi1ppc, str);
1311 pi1ppc_barrier_w(pi1ppc);
1314 pi1ppc->sc_inbstart++;
1324 pi1ppc_set_intr_mask(struct pi1ppc_softc * const pi1ppc, uint8_t mask)
1330 bus_space_write_4((pi1ppc)->sc_iot, (pi1ppc)->sc_ioh, IOC_PLP_INTMASK, mask);
1331 pi1ppc_barrier_w(pi1ppc);
1337 pi1ppc_get_intr_mask(struct pi1ppc_softc * const pi1ppc)
1340 val = bus_space_read_4((pi1ppc)->sc_iot, (pi1ppc)->sc_ioh, IOC_PLP_INTMASK);
1341 pi1ppc_barrier_r(pi1ppc);
1351 pi1ppc_get_intr_stat(struct pi1ppc_softc * const pi1ppc)
1354 val = bus_space_read_4((pi1ppc)->sc_iot, (pi1ppc)->sc_ioh, IOC_PLP_INTSTAT);
1355 pi1ppc_barrier_r(pi1ppc);
1362 pi1ppc_std_write(struct pi1ppc_softc * const pi1ppc)
1366 ctr = pi1ppc_r_ctr(pi1ppc);
1367 pi1ppc_barrier_r(pi1ppc);
1371 pi1ppc_w_ctr(pi1ppc, ctr);
1372 pi1ppc_barrier_w(pi1ppc);
1377 if (pi1ppc->sc_use & PI1PPC_USE_INTR) {
1380 pi1ppc_w_ctr(pi1ppc, ctr);
1381 pi1ppc_barrier_w(pi1ppc);
1386 while (pi1ppc->sc_outbstart < (pi1ppc->sc_outb + pi1ppc->sc_outb_nbytes)) {
1389 pi1ppc->sc_outerr = pi1ppc_poll_str(pi1ppc, SPP_READY, SPP_MASK);
1390 if (pi1ppc->sc_outerr) {
1391 printf("pi1ppc: timeout waiting for peripheral to become ready\n");
1396 pi1ppc_w_dtr(pi1ppc, *(pi1ppc->sc_outbstart));
1397 pi1ppc_barrier_w(pi1ppc);
1401 if (!(pi1ppc->sc_use & PI1PPC_USE_INTR)) {
1402 pi1ppc_get_intr_stat(pi1ppc); /* clear any pending intr */
1403 pi1ppc_set_intr_mask(pi1ppc, PI1_PLP_ACK_INTR);
1408 pi1ppc_w_ctr(pi1ppc, ctr);
1409 pi1ppc_barrier_w(pi1ppc);
1412 pi1ppc_w_ctr(pi1ppc, ctr);
1413 pi1ppc_barrier_w(pi1ppc);
1416 if (pi1ppc->sc_use & PI1PPC_USE_INTR) {
1417 pi1ppc->sc_outerr = pi1ppc_wait_interrupt(pi1ppc,
1418 &pi1ppc->sc_out_cv, PI1PPC_IRQ_nACK);
1419 if (pi1ppc->sc_outerr)
1423 pi1ppc->sc_outerr = pi1ppc_poll_interrupt_stat(pi1ppc,
1426 if (pi1ppc->sc_outerr) {
1427 printf("pi1ppc: timeout waiting for ACK: %02x\n",pi1ppc_r_str(pi1ppc));
1433 pi1ppc->sc_outbstart++;
1442 pi1ppc_poll_str(struct pi1ppc_softc * const pi1ppc, const uint8_t status,
1453 str = pi1ppc_r_str(pi1ppc);
1454 pi1ppc_barrier_r(pi1ppc);
1520 pi1ppc_poll_interrupt_stat(struct pi1ppc_softc * const pi1ppc,
1537 cur = pi1ppc_get_intr_stat(pi1ppc);
1547 cur = pi1ppc_r_str(pi1ppc);
1568 pi1ppc_get_intr_mask(pi1ppc),
1569 pi1ppc_get_intr_stat(pi1ppc),
Indexes created Thu Oct 02 07:10:07 GMT 2025