Lines Matching defs:csp
293 #define BSCBUS_TX_PENDING(csp) ((csp)->cmdp > (csp)->cmdbuf)
384 bscbus_trace(struct bscbus_channel_state *csp, char code, const char *caller,
391 if (csp->ssp->debug & (1 << (code-'@'))) {
402 (void) strlog(csp->ssp->majornum, csp->ssp->instance,
458 bscbus_put_reg(struct bscbus_channel_state *csp, uint_t reg, uint8_t val)
460 if (csp->ch_handle != NULL && !csp->xio_fault) {
461 ddi_put8(csp->ch_handle,
462 csp->ch_regs + reg, val);
467 bscbus_get_reg(struct bscbus_channel_state *csp, uint_t reg)
471 if (csp->ch_handle != NULL && !csp->xio_fault)
472 val = ddi_get8(csp->ch_handle,
473 csp->ch_regs + reg);
481 bscbus_check_fault_status(struct bscbus_channel_state *csp)
483 csp->xio_fault =
484 ddi_check_acc_handle(csp->ch_handle) != DDI_SUCCESS;
488 bscbus_faulty(struct bscbus_channel_state *csp)
490 if (!csp->xio_fault)
491 bscbus_check_fault_status(csp);
492 return (csp->xio_fault);
499 bscbus_pat_dog(struct bscbus_channel_state *csp, uint8_t val)
504 bscbus_trace(csp, 'W', "bscbus_pat_dog:", "");
506 bscbus_cmd_log(csp, BSC_CMD_DOGPAT, 0, val);
507 status = bscbus_get_reg(csp, H8_STR);
509 if (csp->pat_retry_count > BSCBUS_PAT_RETRY_LIMIT) {
517 bscbus_put_reg(csp, H8_IDRC, val);
518 bscbus_trace(csp, 'W', "bscbus_pat_dog:",
524 csp->pat_fail_count++;
525 csp->pat_retry_count++;
527 bscbus_put_reg(csp, H8_IDRC, val);
528 bscbus_trace(csp, 'W', "bscbus_pat_dog:",
533 status = bscbus_get_reg(csp, H8_STR);
535 bscbus_put_reg(csp, H8_IDRC, val);
536 csp->pat_retry_count = 0;
611 bscbus_process_sending(struct bscbus_channel_state *csp, uint8_t status)
617 ASSERT(BSCBUS_TX_PENDING(csp));
619 bscbus_put_reg(csp, H8_IDRD, *--csp->cmdp);
620 bscbus_trace(csp, 'P', "bscbus_process_sending",
622 csp->cmdstate, *csp->cmdp);
623 if (!BSCBUS_TX_PENDING(csp)) {
624 bscbus_cmd_log(csp, BSC_CMD_SENT,
625 status, *csp->cmdp);
627 bscbus_trace(csp, 'P', "bscbus_process_sending",
629 csp->cmdstate = BSCBUS_CMDSTATE_WAITING;
631 csp->deadline = ddi_get_lbolt() +
635 bscbus_cmd_log(csp, BSC_CMD_SENDING,
636 status, *csp->cmdp);
637 csp->cmdstate = BSCBUS_CMDSTATE_PENDING;
638 bscbus_trace(csp, 'P', "bscbus_process_sending",
645 bscbus_process_clearing(struct bscbus_channel_state *csp,
655 bscbus_cmd_log(csp, BSC_CMD_CLEARED, status, data);
656 csp->cmdstate = BSCBUS_CMDSTATE_SENDING;
658 bscbus_trace(csp, 'P', "bscbus_process_clearing",
666 bscbus_process_sending(csp, status);
669 bscbus_cmd_log(csp, BSC_CMD_CLEARING, status, data);
675 bscbus_process_pending(struct bscbus_channel_state *csp, uint8_t status)
679 bscbus_cmd_log(csp, BSC_CMD_PENDING,
680 status, *csp->cmdp);
681 bscbus_trace(csp, 'P', "bscbus_process_pending",
683 csp->cmdstate = BSCBUS_CMDSTATE_SENDING;
690 bscbus_process_sending(csp, status);
695 bscbus_process_waiting(struct bscbus_channel_state *csp,
703 csp->reply[rcvd = csp->index] = data;
705 csp->index = rcvd;
707 bscbus_trace(csp, 'D', "bscbus_process_waiting",
710 csp->reply[0], csp->reply[1],
711 csp->reply[2], csp->reply[3],
712 csp->reply[4], csp->reply[5],
713 csp->reply[6], csp->reply[7]);
729 bscbus_cmd_log(csp, BSC_CMD_ERROR_OFLOW, status, data);
730 csp->index = 0;
731 csp->cmdstate = BSCBUS_CMDSTATE_ERROR;
732 csp->error = LOMBUS_ERR_OFLOW;
739 bscbus_cmd_log(csp, BSC_CMD_REPLY, status, data);
742 bscbus_cmd_log(csp, BSC_CMD_ERROR_STATUS, status, data);
744 csp->cmdstate = BSCBUS_CMDSTATE_ERROR;
745 csp->error = LOMBUS_ERR_BADSTATUS;
747 } else if ((data & BSCBUS_SEQ) != csp->sequence) {
749 bscbus_cmd_log(csp, BSC_CMD_ERROR_SEQ, status, data);
751 csp->cmdstate = BSCBUS_CMDSTATE_ERROR;
752 csp->error = LOMBUS_ERR_SEQUENCE;
765 bscbus_cmd_log(csp, BSC_CMD_COMPLETE, status, data);
766 csp->async = (data & BSCBUS_STATUS_ASYNC) ? 1 : 0;
768 tmp = ((data & BSCBUS_STATUS_MSB) ? 0x80 : 0) | csp->reply[0];
770 csp->cmdstate = BSCBUS_CMDSTATE_ERROR;
771 csp->error = tmp;
773 csp->cmdstate = BSCBUS_CMDSTATE_READY;
774 csp->result = tmp;
789 bscbus_process(struct bscbus_channel_state *csp,
794 ASSERT(mutex_owned(csp->lo_mutex));
797 bscbus_trace(csp, 'D', "bscbus_process",
799 csp->cmdstate, csp->error);
802 switch (csp->cmdstate) {
804 bscbus_process_clearing(csp, status, data);
807 bscbus_process_sending(csp, status);
810 bscbus_process_pending(csp, status);
813 ready = bscbus_process_waiting(csp, status, data);
828 ((ddi_get_lbolt() - csp->deadline) > 0) &&
829 csp->cmdstate != BSCBUS_CMDSTATE_READY &&
830 csp->cmdstate != BSCBUS_CMDSTATE_ERROR) {
831 bscbus_trace(csp, 'P', "bscbus_process",
833 csp->cmdstate, csp->error);
834 bscbus_cmd_log(csp, BSC_CMD_ERROR_TOUT, status, data);
835 if (csp->cmdstate == BSCBUS_CMDSTATE_CLEARING) {
837 csp->cmdstate = BSCBUS_CMDSTATE_SENDING;
839 csp->deadline += drv_usectohz(LOMBUS_CMD_TIMEOUT/1000);
840 } else if (csp->cmdstate != BSCBUS_CMDSTATE_IDLE) {
841 csp->cmdstate = BSCBUS_CMDSTATE_ERROR;
842 csp->error = LOMBUS_ERR_TIMEOUT;
848 bscbus_trace(csp, 'D', "bscbus_process",
850 data, csp->cmdstate, csp->error, ready);
853 cv_broadcast(csp->lo_cv);
859 struct bscbus_channel_state *csp = (void *)arg;
864 mutex_enter(csp->lo_mutex);
872 status = bscbus_get_reg(csp, H8_STR);
873 data = bscbus_get_reg(csp, H8_ODR);
875 bscbus_cmd_log(csp, BSC_CMD_V1INTRUNCL, status, data);
876 csp->unclaimed_count++;
878 bscbus_cmd_log(csp, BSC_CMD_V1INTR, status, data);
881 bscbus_process(csp, status, data);
882 if (csp->interrupt_failed) {
883 bscbus_trace(csp, 'I', "bscbus_hwintr:",
884 "interrupt fault cleared channel %d", csp->chno);
885 csp->interrupt_failed = B_FALSE;
886 csp->poll_hz = drv_usectohz(BSCBUS_CMD_POLL / 1000);
890 mutex_exit(csp->lo_mutex);
895 bscbus_poll(struct bscbus_channel_state *csp)
908 ASSERT(mutex_owned(csp->lo_mutex));
911 status = bscbus_get_reg(csp, H8_STR);
914 data = bscbus_get_reg(csp, H8_ODR);
915 bscbus_cmd_log(csp, BSC_CMD_PROCESS, status, data);
917 bscbus_process(csp, status, data);
928 struct bscbus_channel_state *csp;
938 csp = HANDLE_PRIVATE(hdlp);
939 mutex_enter(csp->lo_mutex);
940 while (csp->cmdstate != BSCBUS_CMDSTATE_IDLE && !ddi_in_panic())
941 cv_wait(csp->lo_cv, csp->lo_mutex);
943 csp->cmdstate = BSCBUS_CMDSTATE_BUSY;
944 csp->sequence = (csp->sequence + BSCBUS_SEQ_LSB) & BSCBUS_SEQ;
954 csp->cmdp = &csp->cmdbuf[0];
955 *csp->cmdp++ = BSCBUS_CMD | csp->sequence | cmd;
958 *csp->cmdp++ = val & 0x7f;
960 csp->cmdbuf[0] |= BSCBUS_CMD_WMSB;
964 *csp->cmdp++ = BSCBUS_VREG_HI(vreg);
965 csp->cmdbuf[0] |= BSCBUS_CMD_XADDR;
967 *csp->cmdp++ = BSCBUS_VREG_LO(vreg);
981 bscbus_check_fault_status(csp);
989 csp->deadline = start + drv_usectohz(LOMBUS_CMD_TIMEOUT/1000);
990 csp->error = 0;
991 csp->index = 0;
992 csp->result = DUMMY_VALUE;
994 status = bscbus_get_reg(csp, H8_STR);
996 bscbus_cmd_log(csp, BSC_CMD_BUSY, status, 0xfd);
1001 csp->cmdstate = BSCBUS_CMDSTATE_CLEARING;
1002 bscbus_trace(csp, 'P', "bscbus_cmd",
1006 csp->cmdstate = BSCBUS_CMDSTATE_SENDING;
1007 bscbus_trace(csp, 'P', "bscbus_cmd",
1009 bscbus_poll(csp);
1012 csp->poll_hz = drv_usectohz(
1013 (csp->interrupt_failed ?
1016 while ((csp->cmdstate != BSCBUS_CMDSTATE_READY) &&
1017 (csp->cmdstate != BSCBUS_CMDSTATE_ERROR)) {
1018 ASSERT(csp->cmdstate != BSCBUS_CMDSTATE_IDLE);
1020 if ((cv_reltimedwait(csp->lo_cv, csp->lo_mutex,
1021 csp->poll_hz, TR_CLOCK_TICK) == -1) &&
1022 csp->cmdstate != BSCBUS_CMDSTATE_READY &&
1023 csp->cmdstate != BSCBUS_CMDSTATE_ERROR) {
1024 if (!csp->interrupt_failed) {
1025 bscbus_trace(csp, 'I', "bscbus_cmd:",
1026 "interrupt_failed channel %d", csp->chno);
1027 csp->interrupt_failed = B_TRUE;
1028 csp->poll_hz = drv_usectohz(
1031 bscbus_poll(csp);
1038 val = csp->result;
1039 if (bscbus_faulty(csp)) {
1042 } else if (csp->cmdstate != BSCBUS_CMDSTATE_READY) {
1048 if (csp->error != 0)
1049 HANDLE_FAULT(hdlp) = csp->error;
1057 csp->index = 0;
1058 csp->cmdstate = BSCBUS_CMDSTATE_IDLE;
1059 cv_broadcast(csp->lo_cv);
1060 mutex_exit(csp->lo_mutex);
1179 struct bscbus_channel_state *csp;
1195 csp = HANDLE_PRIVATE(hdlp);
1196 mutex_enter(csp->dog_mutex);
1197 bscbus_pat_dog(csp, val);
1198 mutex_exit(csp->dog_mutex);
1231 struct bscbus_channel_state *csp;
1251 csp = HANDLE_PRIVATE(hdlp);
1252 return (csp->async);
1311 struct bscbus_channel_state *csp;
1349 csp = HANDLE_PRIVATE(hdlp);
1350 return (csp->async);
1585 bscbus_hw_reset(struct bscbus_channel_state *csp)
1590 if (csp->map_count == 0) {
1595 bscbus_trace(csp, 'R', "bscbus_hw_reset",
1596 "resetting channel %d", csp->chno);
1598 status = bscbus_get_reg(csp, H8_STR);
1606 bscbus_cmd_log(csp, BSC_CMD_BUSY, status, 0);
1607 bscbus_trace(csp, 'R', "bscbus_hw_reset",
1616 status = bscbus_get_reg(csp, H8_STR);
1618 bscbus_trace(csp, 'R', "bscbus_hw_reset",
1619 "clearing busy status for channel %d", csp->chno);
1625 (void) bscbus_get_reg(csp, H8_ODR);
1636 status = bscbus_get_reg(csp, H8_STR);
1649 (void) bscbus_get_reg(csp, H8_ODR);
1717 bscbus_claim_channel(struct bscbus_channel_state *csp, boolean_t map_dog)
1721 mutex_enter(csp->ssp->ch_mutex);
1722 csp->map_count++;
1723 bscbus_trace(csp, 'C', "bscbus_claim_channel",
1725 csp->chno, csp->map_count);
1727 if (csp->map_count == 1) {
1729 bscbus_trace(csp, 'C', "bscbus_claim_channel",
1731 csp->chno, csp->map_count);
1733 mutex_init(csp->dog_mutex, NULL, MUTEX_DRIVER,
1735 csp->map_dog = map_dog;
1736 csp->interrupt_failed = B_FALSE;
1737 csp->cmdstate = BSCBUS_CMDSTATE_IDLE;
1738 csp->pat_retry_count = 0;
1739 csp->pat_fail_count = 0;
1742 if (csp->ssp->per_channel_regs == B_TRUE) {
1746 err = ddi_regs_map_setup(csp->ssp->dip, csp->chno,
1753 csp->ch_handle = h;
1754 csp->ch_regs = (void *)p;
1756 bscbus_trace(csp, 'C', "bscbus_claim_channel",
1758 csp->chno, h, p);
1764 csp->ch_handle = csp->ssp->h8_handle;
1765 csp->ch_regs =
1766 csp->ssp->h8_regs +
1767 BSCBUS_CHANNEL_TO_OFFSET(csp->chno);
1771 bscbus_hw_reset(csp);
1773 if (csp->map_dog == 1) {
1779 mutex_init(csp->lo_mutex, NULL,
1781 cv_init(csp->lo_cv, NULL,
1783 csp->unclaimed_count = 0;
1792 err = ddi_dev_nintrs(csp->ssp->dip, &ninterrupts);
1798 if (ninterrupts <= csp->chno) {
1801 "bscbus channel %d", csp->chno);
1805 if (ddi_intr_hilevel(csp->ssp->dip, csp->chno) != 0) {
1811 err = ddi_get_iblock_cookie(csp->ssp->dip,
1812 csp->chno, &csp->lo_iblk);
1817 mutex_init(csp->lo_mutex, NULL,
1818 MUTEX_DRIVER, csp->lo_iblk);
1819 cv_init(csp->lo_cv, NULL,
1821 csp->unclaimed_count = 0;
1823 err = ddi_add_intr(csp->ssp->dip, csp->chno,
1824 &csp->lo_iblk, NULL,
1825 bscbus_hwintr, (caddr_t)csp);
1827 cv_destroy(csp->lo_cv);
1828 mutex_destroy(csp->lo_mutex);
1837 } else if (csp->map_dog != map_dog) {
1838 bscbus_trace(csp, 'C', "bscbus_claim_channel",
1840 csp->map_dog, map_dog);
1843 mutex_exit(csp->ssp->ch_mutex);
1848 if (csp->ssp->per_channel_regs == B_TRUE) {
1849 ddi_regs_map_free(&csp->ch_handle);
1851 csp->ch_handle = NULL;
1852 csp->ch_regs = (void *)NULL;
1854 csp->map_count--;
1855 mutex_exit(csp->ssp->ch_mutex);
1860 bscbus_release_channel(struct bscbus_channel_state *csp)
1862 mutex_enter(csp->ssp->ch_mutex);
1863 if (csp->map_count == 1) {
1865 bscbus_trace(csp, 'C', "bscbus_release_channel",
1867 csp->chno, csp->map_count);
1869 if (csp->map_dog == 0) {
1870 ASSERT(!ddi_intr_hilevel(csp->ssp->dip, csp->chno));
1871 ddi_remove_intr(csp->ssp->dip, csp->chno, csp->lo_iblk);
1873 cv_destroy(csp->lo_cv);
1874 mutex_destroy(csp->lo_mutex);
1875 mutex_destroy(csp->dog_mutex);
1876 bscbus_hw_reset(csp);
1879 if (csp->ssp->per_channel_regs == B_TRUE) {
1880 ddi_regs_map_free(&csp->ch_handle);
1882 csp->ch_handle = NULL;
1883 csp->ch_regs = (void *)NULL;
1885 csp->map_count--;
1886 bscbus_trace(csp, 'C', "bscbus_release_channel",
1888 csp->chno, csp->map_count);
1889 mutex_exit(csp->ssp->ch_mutex);
1981 bscbus_map_handle(struct bscbus_channel_state *csp, ddi_map_op_t op,
1990 if (bscbus_claim_channel(csp,
2013 hdlp->ah_bus_private = csp;
2019 bscbus_release_channel(csp);
2027 bscbus_map_handle(struct bscbus_channel_state *csp, ddi_map_op_t op,
2038 if (bscbus_claim_channel(csp,
2121 hdlp->ah_bus_private = csp;
2127 bscbus_release_channel(csp);
2422 struct bscbus_channel_state *csp = &ssp->channel[chno];
2429 csp->ssp = ssp;
2430 csp->chno = chno;
2431 csp->map_count = 0;
2432 csp->map_dog = B_FALSE;
2610 void bscbus_cmd_log(struct bscbus_channel_state *csp, bsc_cmd_stamp_t cat,
2617 if ((csp) == NULL)
2619 if ((ssp = (csp)->ssp) == NULL)
2630 logp->bcl_chno = csp->chno;
2631 logp->bcl_cmdstate = csp->cmdstate;