Lines Matching defs:brdp
555 #define EBRDINIT(brdp) \
556 if (brdp->init != NULL) \
557 (* brdp->init)(brdp)
559 #define EBRDENABLE(brdp) \
560 if (brdp->enable != NULL) \
561 (* brdp->enable)(brdp);
563 #define EBRDDISABLE(brdp) \
564 if (brdp->disable != NULL) \
565 (* brdp->disable)(brdp);
567 #define EBRDINTR(brdp) \
568 if (brdp->intr != NULL) \
569 (* brdp->intr)(brdp);
571 #define EBRDRESET(brdp) \
572 if (brdp->reset != NULL) \
573 (* brdp->reset)(brdp);
575 #define EBRDGETMEMPTR(brdp,offset) \
576 (* brdp->getmemptr)(brdp, offset, __LINE__)
619 static int stli_brdinit(struct stlibrd *brdp);
620 static int stli_startbrd(struct stlibrd *brdp);
624 static void stli_brdpoll(struct stlibrd *brdp, cdkhdr_t __iomem *hdrp);
626 static int stli_hostcmd(struct stlibrd *brdp, struct stliport *portp);
627 static int stli_initopen(struct tty_struct *tty, struct stlibrd *brdp, struct stliport *portp);
628 static int stli_rawopen(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait);
629 static int stli_rawclose(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait);
631 static int stli_cmdwait(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback);
632 static void stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback);
633 static void __stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback);
638 static void stli_read(struct stlibrd *brdp, struct stliport *portp);
649 static void stli_ecpinit(struct stlibrd *brdp);
650 static void stli_ecpenable(struct stlibrd *brdp);
651 static void stli_ecpdisable(struct stlibrd *brdp);
652 static void __iomem *stli_ecpgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
653 static void stli_ecpreset(struct stlibrd *brdp);
654 static void stli_ecpintr(struct stlibrd *brdp);
655 static void stli_ecpeiinit(struct stlibrd *brdp);
656 static void stli_ecpeienable(struct stlibrd *brdp);
657 static void stli_ecpeidisable(struct stlibrd *brdp);
658 static void __iomem *stli_ecpeigetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
659 static void stli_ecpeireset(struct stlibrd *brdp);
660 static void stli_ecpmcenable(struct stlibrd *brdp);
661 static void stli_ecpmcdisable(struct stlibrd *brdp);
662 static void __iomem *stli_ecpmcgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
663 static void stli_ecpmcreset(struct stlibrd *brdp);
664 static void stli_ecppciinit(struct stlibrd *brdp);
665 static void __iomem *stli_ecppcigetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
666 static void stli_ecppcireset(struct stlibrd *brdp);
668 static void stli_onbinit(struct stlibrd *brdp);
669 static void stli_onbenable(struct stlibrd *brdp);
670 static void stli_onbdisable(struct stlibrd *brdp);
671 static void __iomem *stli_onbgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
672 static void stli_onbreset(struct stlibrd *brdp);
673 static void stli_onbeinit(struct stlibrd *brdp);
674 static void stli_onbeenable(struct stlibrd *brdp);
675 static void stli_onbedisable(struct stlibrd *brdp);
676 static void __iomem *stli_onbegetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
677 static void stli_onbereset(struct stlibrd *brdp);
678 static void stli_bbyinit(struct stlibrd *brdp);
679 static void __iomem *stli_bbygetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
680 static void stli_bbyreset(struct stlibrd *brdp);
681 static void stli_stalinit(struct stlibrd *brdp);
682 static void __iomem *stli_stalgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
683 static void stli_stalreset(struct stlibrd *brdp);
687 static int stli_initecp(struct stlibrd *brdp);
688 static int stli_initonb(struct stlibrd *brdp);
690 static int stli_eisamemprobe(struct stlibrd *brdp);
692 static int stli_initports(struct stlibrd *brdp);
730 static void stli_cleanup_ports(struct stlibrd *brdp)
737 portp = brdp->ports[j];
797 struct stlibrd *brdp = stli_brds[portp->brdnr];
800 if ((rc = stli_initopen(tty, brdp, portp)) >= 0)
808 struct stlibrd *brdp;
816 brdp = stli_brds[brdnr];
817 if (brdp == NULL)
819 if (!test_bit(BST_STARTED, &brdp->state))
822 if (portnr > brdp->nrports)
825 portp = brdp->ports[portnr];
840 struct stlibrd *brdp;
847 brdp = stli_brds[portp->brdnr];
848 if (brdp == NULL)
859 stli_rawclose(brdp, portp, 0, 0);
867 stli_cmdwait(brdp, portp, A_FLUSH, &ftype, sizeof(u32), 0);
895 struct stlibrd *brdp, struct stliport *portp)
901 if ((rc = stli_rawopen(brdp, portp, 0, 1)) < 0)
907 if ((rc = stli_cmdwait(brdp, portp, A_SETNOTIFY, &nt,
912 if ((rc = stli_cmdwait(brdp, portp, A_SETPORT, &aport,
917 if ((rc = stli_cmdwait(brdp, portp, A_GETSIGNALS, &portp->asig,
923 if ((rc = stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
939 static int stli_rawopen(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait)
969 EBRDENABLE(brdp);
970 cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
973 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
974 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
977 EBRDDISABLE(brdp);
1010 static int stli_rawclose(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait)
1034 EBRDENABLE(brdp);
1035 cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
1038 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1039 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
1042 EBRDDISABLE(brdp);
1074 static int stli_cmdwait(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
1085 stli_sendcmd(brdp, portp, cmd, arg, size, copyback);
1107 struct stlibrd *brdp;
1114 brdp = stli_brds[portp->brdnr];
1115 if (brdp == NULL)
1119 return(stli_cmdwait(brdp, portp, A_SETPORT, &aport, sizeof(asyport_t), 0));
1133 struct stlibrd *brdp = stli_brds[portp->brdnr];
1135 if (stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
1157 struct stlibrd *brdp;
1168 brdp = stli_brds[portp->brdnr];
1169 if (brdp == NULL)
1177 EBRDENABLE(brdp);
1178 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1194 shbuf = (char __iomem *) EBRDGETMEMPTR(brdp, portp->txoffset);
1209 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1215 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1216 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
1220 EBRDDISABLE(brdp);
1265 struct stlibrd *brdp;
1289 brdp = stli_brds[portp->brdnr];
1290 if (brdp == NULL)
1294 EBRDENABLE(brdp);
1296 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1312 shbuf = EBRDGETMEMPTR(brdp, portp->txoffset);
1328 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1335 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1336 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
1341 EBRDDISABLE(brdp);
1351 struct stlibrd *brdp;
1367 brdp = stli_brds[portp->brdnr];
1368 if (brdp == NULL)
1372 EBRDENABLE(brdp);
1373 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->txq;
1380 EBRDDISABLE(brdp);
1404 struct stlibrd *brdp;
1415 brdp = stli_brds[portp->brdnr];
1416 if (brdp == NULL)
1420 EBRDENABLE(brdp);
1421 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->txq;
1429 EBRDDISABLE(brdp);
1444 struct stlibrd *brdp;
1458 brdp = stli_brds[portp->brdnr];
1459 if (brdp != NULL)
1460 sio.port = brdp->iobase;
1507 struct stlibrd *brdp;
1514 brdp = stli_brds[portp->brdnr];
1515 if (brdp == NULL)
1520 if ((rc = stli_cmdwait(brdp, portp, A_GETSIGNALS,
1531 struct stlibrd *brdp;
1538 brdp = stli_brds[portp->brdnr];
1539 if (brdp == NULL)
1555 return stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
1562 struct stlibrd *brdp;
1571 brdp = stli_brds[portp->brdnr];
1572 if (brdp == NULL)
1628 struct stlibrd *brdp;
1637 brdp = stli_brds[portp->brdnr];
1638 if (brdp == NULL)
1644 stli_cmdwait(brdp, portp, A_SETPORT, &aport, sizeof(asyport_t), 0);
1646 stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
1738 struct stlibrd *brdp;
1746 brdp = stli_brds[portp->brdnr];
1747 if (brdp == NULL)
1764 __stli_sendcmd(brdp, portp, A_FLUSH, &ftype, sizeof(u32), 0);
1774 struct stlibrd *brdp;
1783 brdp = stli_brds[portp->brdnr];
1784 if (brdp == NULL)
1788 stli_cmdwait(brdp, portp, A_BREAK, &arg, sizeof(long), 0);
1820 struct stlibrd *brdp;
1829 brdp = stli_brds[portp->brdnr];
1830 if (brdp == NULL)
1842 stli_cmdwait(brdp, portp, A_PORTCTRL, &actrl, sizeof(asyctrl_t), 0);
1845 static void stli_portinfo(struct seq_file *m, struct stlibrd *brdp, struct stliport *portp, int portnr)
1853 if (test_bit(BST_STARTED, &brdp->state)) {
1862 if (test_bit(BST_STARTED, &brdp->state) && rc >= 0) {
1914 struct stlibrd *brdp;
1927 brdp = stli_brds[brdnr];
1928 if (brdp == NULL)
1930 if (brdp->state == 0)
1934 for (portnr = 0; (portnr < brdp->nrports); portnr++,
1936 portp = brdp->ports[portnr];
1939 stli_portinfo(m, brdp, portp, totalport);
1973 static void __stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
1985 EBRDENABLE(brdp);
1986 cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
1996 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1997 bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
2001 EBRDDISABLE(brdp);
2004 static void stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
2009 __stli_sendcmd(brdp, portp, cmd, arg, size, copyback);
2023 static void stli_read(struct stlibrd *brdp, struct stliport *portp)
2037 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->rxq;
2053 shbuf = (char __iomem *) EBRDGETMEMPTR(brdp, portp->rxoffset);
2068 rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->rxq;
2134 static int stli_hostcmd(struct stlibrd *brdp, struct stliport *portp)
2143 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
2231 EBRDENABLE(brdp);
2240 EBRDENABLE(brdp);
2249 stli_read(brdp, portp);
2263 stli_read(brdp, portp);
2281 static void stli_brdpoll(struct stlibrd *brdp, cdkhdr_t __iomem *hdrp)
2290 bitsize = brdp->bitsize;
2291 nrdevs = brdp->nrdevs;
2300 memcpy_fromio(&hostbits[0], (((unsigned char __iomem *) hdrp) + brdp->hostoffset),
2312 portp = brdp->ports[(channr - 1)];
2313 if (stli_hostcmd(brdp, portp)) {
2327 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
2328 slavep = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset;
2350 struct stlibrd *brdp;
2359 brdp = stli_brds[brdnr];
2360 if (brdp == NULL)
2362 if (!test_bit(BST_STARTED, &brdp->state))
2366 EBRDENABLE(brdp);
2367 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
2369 stli_brdpoll(brdp, hdrp);
2370 EBRDDISABLE(brdp);
2532 static int stli_initports(struct stlibrd *brdp)
2537 for (i = 0, panelnr = 0, panelport = 0; (i < brdp->nrports); i++) {
2547 portp->brdnr = brdp->brdnr;
2556 if (panelport >= brdp->panels[panelnr]) {
2560 brdp->ports[i] = portp;
2572 static void stli_ecpinit(struct stlibrd *brdp)
2576 outb(ECP_ATSTOP, (brdp->iobase + ECP_ATCONFR));
2578 outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
2581 memconf = (brdp->memaddr & ECP_ATADDRMASK) >> ECP_ATADDRSHFT;
2582 outb(memconf, (brdp->iobase + ECP_ATMEMAR));
2587 static void stli_ecpenable(struct stlibrd *brdp)
2589 outb(ECP_ATENABLE, (brdp->iobase + ECP_ATCONFR));
2594 static void stli_ecpdisable(struct stlibrd *brdp)
2596 outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
2601 static void __iomem *stli_ecpgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2606 if (offset > brdp->memsize) {
2609 (int) offset, line, __LINE__, brdp->brdnr);
2613 ptr = brdp->membase + (offset % ECP_ATPAGESIZE);
2616 outb(val, (brdp->iobase + ECP_ATMEMPR));
2622 static void stli_ecpreset(struct stlibrd *brdp)
2624 outb(ECP_ATSTOP, (brdp->iobase + ECP_ATCONFR));
2626 outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
2632 static void stli_ecpintr(struct stlibrd *brdp)
2634 outb(0x1, brdp->iobase);
2643 static void stli_ecpeiinit(struct stlibrd *brdp)
2647 outb(0x1, (brdp->iobase + ECP_EIBRDENAB));
2648 outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR));
2650 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
2653 memconf = (brdp->memaddr & ECP_EIADDRMASKL) >> ECP_EIADDRSHFTL;
2654 outb(memconf, (brdp->iobase + ECP_EIMEMARL));
2655 memconf = (brdp->memaddr & ECP_EIADDRMASKH) >> ECP_EIADDRSHFTH;
2656 outb(memconf, (brdp->iobase + ECP_EIMEMARH));
2661 static void stli_ecpeienable(struct stlibrd *brdp)
2663 outb(ECP_EIENABLE, (brdp->iobase + ECP_EICONFR));
2668 static void stli_ecpeidisable(struct stlibrd *brdp)
2670 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
2675 static void __iomem *stli_ecpeigetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2680 if (offset > brdp->memsize) {
2683 (int) offset, line, __LINE__, brdp->brdnr);
2687 ptr = brdp->membase + (offset % ECP_EIPAGESIZE);
2693 outb(val, (brdp->iobase + ECP_EICONFR));
2699 static void stli_ecpeireset(struct stlibrd *brdp)
2701 outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR));
2703 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
2713 static void stli_ecpmcenable(struct stlibrd *brdp)
2715 outb(ECP_MCENABLE, (brdp->iobase + ECP_MCCONFR));
2720 static void stli_ecpmcdisable(struct stlibrd *brdp)
2722 outb(ECP_MCDISABLE, (brdp->iobase + ECP_MCCONFR));
2727 static void __iomem *stli_ecpmcgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2732 if (offset > brdp->memsize) {
2735 (int) offset, line, __LINE__, brdp->brdnr);
2739 ptr = brdp->membase + (offset % ECP_MCPAGESIZE);
2742 outb(val, (brdp->iobase + ECP_MCCONFR));
2748 static void stli_ecpmcreset(struct stlibrd *brdp)
2750 outb(ECP_MCSTOP, (brdp->iobase + ECP_MCCONFR));
2752 outb(ECP_MCDISABLE, (brdp->iobase + ECP_MCCONFR));
2762 static void stli_ecppciinit(struct stlibrd *brdp)
2764 outb(ECP_PCISTOP, (brdp->iobase + ECP_PCICONFR));
2766 outb(0, (brdp->iobase + ECP_PCICONFR));
2772 static void __iomem *stli_ecppcigetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2777 if (offset > brdp->memsize) {
2780 (int) offset, line, __LINE__, brdp->brdnr);
2784 ptr = brdp->membase + (offset % ECP_PCIPAGESIZE);
2787 outb(val, (brdp->iobase + ECP_PCICONFR));
2793 static void stli_ecppcireset(struct stlibrd *brdp)
2795 outb(ECP_PCISTOP, (brdp->iobase + ECP_PCICONFR));
2797 outb(0, (brdp->iobase + ECP_PCICONFR));
2807 static void stli_onbinit(struct stlibrd *brdp)
2811 outb(ONB_ATSTOP, (brdp->iobase + ONB_ATCONFR));
2813 outb(ONB_ATDISABLE, (brdp->iobase + ONB_ATCONFR));
2816 memconf = (brdp->memaddr & ONB_ATADDRMASK) >> ONB_ATADDRSHFT;
2817 outb(memconf, (brdp->iobase + ONB_ATMEMAR));
2818 outb(0x1, brdp->iobase);
2824 static void stli_onbenable(struct stlibrd *brdp)
2826 outb((brdp->enabval | ONB_ATENABLE), (brdp->iobase + ONB_ATCONFR));
2831 static void stli_onbdisable(struct stlibrd *brdp)
2833 outb((brdp->enabval | ONB_ATDISABLE), (brdp->iobase + ONB_ATCONFR));
2838 static void __iomem *stli_onbgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2842 if (offset > brdp->memsize) {
2845 (int) offset, line, __LINE__, brdp->brdnr);
2848 ptr = brdp->membase + (offset % ONB_ATPAGESIZE);
2855 static void stli_onbreset(struct stlibrd *brdp)
2857 outb(ONB_ATSTOP, (brdp->iobase + ONB_ATCONFR));
2859 outb(ONB_ATDISABLE, (brdp->iobase + ONB_ATCONFR));
2869 static void stli_onbeinit(struct stlibrd *brdp)
2873 outb(0x1, (brdp->iobase + ONB_EIBRDENAB));
2874 outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
2876 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
2879 memconf = (brdp->memaddr & ONB_EIADDRMASKL) >> ONB_EIADDRSHFTL;
2880 outb(memconf, (brdp->iobase + ONB_EIMEMARL));
2881 memconf = (brdp->memaddr & ONB_EIADDRMASKH) >> ONB_EIADDRSHFTH;
2882 outb(memconf, (brdp->iobase + ONB_EIMEMARH));
2883 outb(0x1, brdp->iobase);
2889 static void stli_onbeenable(struct stlibrd *brdp)
2891 outb(ONB_EIENABLE, (brdp->iobase + ONB_EICONFR));
2896 static void stli_onbedisable(struct stlibrd *brdp)
2898 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
2903 static void __iomem *stli_onbegetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2908 if (offset > brdp->memsize) {
2911 (int) offset, line, __LINE__, brdp->brdnr);
2915 ptr = brdp->membase + (offset % ONB_EIPAGESIZE);
2921 outb(val, (brdp->iobase + ONB_EICONFR));
2927 static void stli_onbereset(struct stlibrd *brdp)
2929 outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
2931 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
2941 static void stli_bbyinit(struct stlibrd *brdp)
2943 outb(BBY_ATSTOP, (brdp->iobase + BBY_ATCONFR));
2945 outb(0, (brdp->iobase + BBY_ATCONFR));
2947 outb(0x1, brdp->iobase);
2953 static void __iomem *stli_bbygetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2958 BUG_ON(offset > brdp->memsize);
2960 ptr = brdp->membase + (offset % BBY_PAGESIZE);
2962 outb(val, (brdp->iobase + BBY_ATCONFR));
2968 static void stli_bbyreset(struct stlibrd *brdp)
2970 outb(BBY_ATSTOP, (brdp->iobase + BBY_ATCONFR));
2972 outb(0, (brdp->iobase + BBY_ATCONFR));
2982 static void stli_stalinit(struct stlibrd *brdp)
2984 outb(0x1, brdp->iobase);
2990 static void __iomem *stli_stalgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2992 BUG_ON(offset > brdp->memsize);
2993 return brdp->membase + (offset % STAL_PAGESIZE);
2998 static void stli_stalreset(struct stlibrd *brdp)
3002 vecp = (u32 __iomem *) (brdp->membase + 0x30);
3004 outb(0, brdp->iobase);
3015 static int stli_initecp(struct stlibrd *brdp)
3023 if ((brdp->iobase == 0) || (brdp->memaddr == 0)) {
3028 brdp->iosize = ECP_IOSIZE;
3030 if (!request_region(brdp->iobase, brdp->iosize, "istallion")) {
3040 switch (brdp->brdtype) {
3042 brdp->memsize = ECP_MEMSIZE;
3043 brdp->pagesize = ECP_ATPAGESIZE;
3044 brdp->init = stli_ecpinit;
3045 brdp->enable = stli_ecpenable;
3046 brdp->reenable = stli_ecpenable;
3047 brdp->disable = stli_ecpdisable;
3048 brdp->getmemptr = stli_ecpgetmemptr;
3049 brdp->intr = stli_ecpintr;
3050 brdp->reset = stli_ecpreset;
3055 brdp->memsize = ECP_MEMSIZE;
3056 brdp->pagesize = ECP_EIPAGESIZE;
3057 brdp->init = stli_ecpeiinit;
3058 brdp->enable = stli_ecpeienable;
3059 brdp->reenable = stli_ecpeienable;
3060 brdp->disable = stli_ecpeidisable;
3061 brdp->getmemptr = stli_ecpeigetmemptr;
3062 brdp->intr = stli_ecpintr;
3063 brdp->reset = stli_ecpeireset;
3068 brdp->memsize = ECP_MEMSIZE;
3069 brdp->pagesize = ECP_MCPAGESIZE;
3070 brdp->init = NULL;
3071 brdp->enable = stli_ecpmcenable;
3072 brdp->reenable = stli_ecpmcenable;
3073 brdp->disable = stli_ecpmcdisable;
3074 brdp->getmemptr = stli_ecpmcgetmemptr;
3075 brdp->intr = stli_ecpintr;
3076 brdp->reset = stli_ecpmcreset;
3081 brdp->memsize = ECP_PCIMEMSIZE;
3082 brdp->pagesize = ECP_PCIPAGESIZE;
3083 brdp->init = stli_ecppciinit;
3084 brdp->enable = NULL;
3085 brdp->reenable = NULL;
3086 brdp->disable = NULL;
3087 brdp->getmemptr = stli_ecppcigetmemptr;
3088 brdp->intr = stli_ecpintr;
3089 brdp->reset = stli_ecppcireset;
3104 EBRDINIT(brdp);
3106 brdp->membase = ioremap_nocache(brdp->memaddr, brdp->memsize);
3107 if (brdp->membase == NULL) {
3117 EBRDENABLE(brdp);
3118 sigsp = (cdkecpsig_t __iomem *) EBRDGETMEMPTR(brdp, CDK_SIGADDR);
3120 EBRDDISABLE(brdp);
3136 brdp->panelids[panelnr] = status;
3140 brdp->panels[panelnr] = nrports;
3141 brdp->nrports += nrports;
3143 brdp->nrpanels++;
3147 set_bit(BST_FOUND, &brdp->state);
3150 iounmap(brdp->membase);
3151 brdp->membase = NULL;
3153 release_region(brdp->iobase, brdp->iosize);
3165 static int stli_initonb(struct stlibrd *brdp)
3175 if (brdp->iobase == 0 || brdp->memaddr == 0) {
3180 brdp->iosize = ONB_IOSIZE;
3182 if (!request_region(brdp->iobase, brdp->iosize, "istallion")) {
3192 switch (brdp->brdtype) {
3195 brdp->memsize = ONB_MEMSIZE;
3196 brdp->pagesize = ONB_ATPAGESIZE;
3197 brdp->init = stli_onbinit;
3198 brdp->enable = stli_onbenable;
3199 brdp->reenable = stli_onbenable;
3200 brdp->disable = stli_onbdisable;
3201 brdp->getmemptr = stli_onbgetmemptr;
3202 brdp->intr = stli_ecpintr;
3203 brdp->reset = stli_onbreset;
3204 if (brdp->memaddr > 0x100000)
3205 brdp->enabval = ONB_MEMENABHI;
3207 brdp->enabval = ONB_MEMENABLO;
3212 brdp->memsize = ONB_EIMEMSIZE;
3213 brdp->pagesize = ONB_EIPAGESIZE;
3214 brdp->init = stli_onbeinit;
3215 brdp->enable = stli_onbeenable;
3216 brdp->reenable = stli_onbeenable;
3217 brdp->disable = stli_onbedisable;
3218 brdp->getmemptr = stli_onbegetmemptr;
3219 brdp->intr = stli_ecpintr;
3220 brdp->reset = stli_onbereset;
3225 brdp->memsize = BBY_MEMSIZE;
3226 brdp->pagesize = BBY_PAGESIZE;
3227 brdp->init = stli_bbyinit;
3228 brdp->enable = NULL;
3229 brdp->reenable = NULL;
3230 brdp->disable = NULL;
3231 brdp->getmemptr = stli_bbygetmemptr;
3232 brdp->intr = stli_ecpintr;
3233 brdp->reset = stli_bbyreset;
3238 brdp->memsize = STAL_MEMSIZE;
3239 brdp->pagesize = STAL_PAGESIZE;
3240 brdp->init = stli_stalinit;
3241 brdp->enable = NULL;
3242 brdp->reenable = NULL;
3243 brdp->disable = NULL;
3244 brdp->getmemptr = stli_stalgetmemptr;
3245 brdp->intr = stli_ecpintr;
3246 brdp->reset = stli_stalreset;
3261 EBRDINIT(brdp);
3263 brdp->membase = ioremap_nocache(brdp->memaddr, brdp->memsize);
3264 if (brdp->membase == NULL) {
3274 EBRDENABLE(brdp);
3275 sigsp = (cdkonbsig_t __iomem *) EBRDGETMEMPTR(brdp, CDK_SIGADDR);
3277 EBRDDISABLE(brdp);
3291 brdp->nrpanels = 1;
3293 brdp->nrports = 32;
3299 brdp->nrports = i;
3301 brdp->panels[0] = brdp->nrports;
3304 set_bit(BST_FOUND, &brdp->state);
3307 iounmap(brdp->membase);
3308 brdp->membase = NULL;
3310 release_region(brdp->iobase, brdp->iosize);
3323 static int stli_startbrd(struct stlibrd *brdp)
3335 EBRDENABLE(brdp);
3336 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
3340 if (nrdevs < (brdp->nrports + 1)) {
3343 brdp->nrports = nrdevs - 1;
3345 brdp->nrdevs = nrdevs;
3346 brdp->hostoffset = hdrp->hostp - CDK_CDKADDR;
3347 brdp->slaveoffset = hdrp->slavep - CDK_CDKADDR;
3348 brdp->bitsize = (nrdevs + 7) / 8;
3350 if (memoff > brdp->memsize) {
3355 memp = (cdkmem_t __iomem *) EBRDGETMEMPTR(brdp, memoff);
3370 portp = brdp->ports[portnr];
3388 portp = brdp->ports[portnr];
3393 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
3403 EBRDDISABLE(brdp);
3407 set_bit(BST_STARTED, &brdp->state);
3423 static int __devinit stli_brdinit(struct stlibrd *brdp)
3427 switch (brdp->brdtype) {
3432 retval = stli_initecp(brdp);
3439 retval = stli_initonb(brdp);
3443 "type=%d\n", brdp->brdnr, brdp->brdtype);
3450 stli_initports(brdp);
3452 "nrpanels=%d nrports=%d\n", stli_brdnames[brdp->brdtype],
3453 brdp->brdnr, brdp->iobase, (int) brdp->memaddr,
3454 brdp->nrpanels, brdp->nrports);
3466 static int stli_eisamemprobe(struct stlibrd *brdp)
3478 if (brdp->brdtype == BRD_ECPE) {
3479 outb(0x1, (brdp->iobase + ECP_EIBRDENAB));
3480 outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR));
3482 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
3484 stli_ecpeienable(brdp);
3485 } else if (brdp->brdtype == BRD_ONBOARDE) {
3486 outb(0x1, (brdp->iobase + ONB_EIBRDENAB));
3487 outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
3489 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
3491 outb(0x1, brdp->iobase);
3493 stli_onbeenable(brdp);
3499 brdp->memsize = ECP_MEMSIZE;
3506 brdp->memaddr = stli_eisamemprobeaddrs[i];
3507 brdp->membase = ioremap_nocache(brdp->memaddr, brdp->memsize);
3508 if (brdp->membase == NULL)
3511 if (brdp->brdtype == BRD_ECPE) {
3512 ecpsigp = stli_ecpeigetmemptr(brdp,
3518 onbsigp = (cdkonbsig_t __iomem *) stli_onbegetmemptr(brdp,
3528 iounmap(brdp->membase);
3537 if (brdp->brdtype == BRD_ECPE)
3538 stli_ecpeidisable(brdp);
3540 stli_onbedisable(brdp);
3543 brdp->memaddr = 0;
3544 brdp->membase = NULL;
3547 stli_brdnames[brdp->brdtype], (brdp->iobase >> 12));
3583 struct stlibrd *brdp;
3609 brdp = stli_brds[i];
3610 if (brdp == NULL)
3612 if (brdp->iobase == iobase)
3622 if ((brdp = stli_allocbrd()) == NULL)
3627 brdp->brdnr = (unsigned int)brdnr;
3630 brdp->brdtype = BRD_ECPE;
3632 brdp->brdtype = BRD_ONBOARDE;
3634 brdp->brdtype = BRD_UNKNOWN;
3635 brdp->iobase = iobase;
3637 if (stli_eisamemprobe(brdp))
3639 if (stli_brdinit(brdp) < 0) {
3640 kfree(brdp);
3644 stli_brds[brdp->brdnr] = brdp;
3647 for (i = 0; i < brdp->nrports; i++)
3649 brdp->brdnr * STL_MAXPORTS + i, NULL);
3675 struct stlibrd *brdp;
3682 brdp = stli_allocbrd();
3683 if (brdp == NULL) {
3696 brdp->brdnr = (unsigned int)brdnr;
3697 stli_brds[brdp->brdnr] = brdp;
3699 brdp->brdtype = BRD_ECPPCI;
3704 brdp->iobase = pci_resource_start(pdev, 3);
3705 brdp->memaddr = pci_resource_start(pdev, 2);
3706 retval = stli_brdinit(brdp);
3710 set_bit(BST_PROBED, &brdp->state);
3711 pci_set_drvdata(pdev, brdp);
3713 EBRDENABLE(brdp);
3714 brdp->enable = NULL;
3715 brdp->disable = NULL;
3717 for (i = 0; i < brdp->nrports; i++)
3718 tty_register_device(stli_serial, brdp->brdnr * STL_MAXPORTS + i,
3723 stli_brds[brdp->brdnr] = NULL;
3725 kfree(brdp);
3732 struct stlibrd *brdp = pci_get_drvdata(pdev);
3734 stli_cleanup_ports(brdp);
3736 iounmap(brdp->membase);
3737 if (brdp->iosize > 0)
3738 release_region(brdp->iobase, brdp->iosize);
3740 stli_brds[brdp->brdnr] = NULL;
3741 kfree(brdp);
3758 struct stlibrd *brdp;
3760 brdp = kzalloc(sizeof(struct stlibrd), GFP_KERNEL);
3761 if (!brdp) {
3766 brdp->magic = STLI_BOARDMAGIC;
3767 return brdp;
3779 struct stlibrd *brdp, *nxtbrdp;
3789 if ((brdp = stli_allocbrd()) == NULL)
3791 brdp->brdnr = stli_nrbrds;
3792 brdp->brdtype = conf.brdtype;
3793 brdp->iobase = conf.ioaddr1;
3794 brdp->memaddr = conf.memaddr;
3795 if (stli_brdinit(brdp) < 0) {
3796 kfree(brdp);
3799 stli_brds[brdp->brdnr] = brdp;
3802 for (i = 0; i < brdp->nrports; i++)
3804 brdp->brdnr * STL_MAXPORTS + i, NULL);
3819 brdp = stli_brds[i];
3820 if (brdp == NULL)
3826 if ((brdp->membase >= nxtbrdp->membase) &&
3827 (brdp->membase <= (nxtbrdp->membase +
3838 brdp = stli_brds[i];
3839 if (brdp == NULL)
3841 if (test_bit(BST_FOUND, &brdp->state)) {
3842 EBRDENABLE(brdp);
3843 brdp->enable = NULL;
3844 brdp->disable = NULL;
3873 struct stlibrd *brdp;
3882 brdp = stli_brds[brdnr];
3883 if (brdp == NULL)
3885 if (brdp->state == 0)
3887 if (off >= brdp->memsize || off + count < off)
3890 size = min(count, (size_t)(brdp->memsize - off));
3902 EBRDENABLE(brdp);
3903 memptr = EBRDGETMEMPTR(brdp, off);
3904 n = min(size, (int)(brdp->pagesize - (((unsigned long) off) % brdp->pagesize)));
3907 EBRDDISABLE(brdp);
3930 struct stlibrd *brdp;
3941 brdp = stli_brds[brdnr];
3942 if (brdp == NULL)
3944 if (brdp->state == 0)
3946 if (off >= brdp->memsize || off + count < off)
3950 size = min(count, (size_t)(brdp->memsize - off));
3961 n = min(size, (int)(brdp->pagesize - (((unsigned long) off) % brdp->pagesize)));
3969 EBRDENABLE(brdp);
3970 memptr = EBRDGETMEMPTR(brdp, off);
3972 EBRDDISABLE(brdp);
3992 struct stlibrd *brdp;
3999 brdp = stli_brds[stli_brdstats.brd];
4000 if (brdp == NULL)
4005 stli_brdstats.brd = brdp->brdnr;
4006 stli_brdstats.type = brdp->brdtype;
4008 stli_brdstats.state = brdp->state;
4009 stli_brdstats.ioaddr = brdp->iobase;
4010 stli_brdstats.memaddr = brdp->memaddr;
4011 stli_brdstats.nrpanels = brdp->nrpanels;
4012 stli_brdstats.nrports = brdp->nrports;
4013 for (i = 0; (i < brdp->nrpanels); i++) {
4015 stli_brdstats.panels[i].hwid = brdp->panelids[i];
4016 stli_brdstats.panels[i].nrports = brdp->panels[i];
4033 struct stlibrd *brdp;
4038 brdp = stli_brds[brdnr];
4039 if (brdp == NULL)
4042 portnr += brdp->panels[i];
4043 if (portnr >= brdp->nrports)
4045 return brdp->ports[portnr];
4059 struct stlibrd *brdp;
4066 brdp = stli_brds[portp->brdnr];
4067 if (brdp == NULL)
4071 if (test_bit(BST_STARTED, &brdp->state)) {
4072 if ((rc = stli_cmdwait(brdp, portp, A_GETSTATS,
4137 struct stlibrd *brdp;
4149 brdp = stli_brds[portp->brdnr];
4150 if (!brdp)
4168 struct stlibrd *brdp;
4180 brdp = stli_brds[portp->brdnr];
4181 if (!brdp)
4186 if (test_bit(BST_STARTED, &brdp->state)) {
4187 if ((rc = stli_cmdwait(brdp, portp, A_CLEARSTATS, NULL, 0, 0)) < 0) {
4235 struct stlibrd *brdp;
4241 brdp = stli_brds[stli_dummybrd.brdnr];
4242 if (!brdp)
4244 if (copy_to_user(arg, brdp, sizeof(struct stlibrd)))
4259 struct stlibrd *brdp;
4301 brdp = stli_brds[brdnr];
4302 if (!brdp)
4304 if (brdp->state == 0)
4309 EBRDINTR(brdp);
4312 rc = stli_startbrd(brdp);
4315 clear_bit(BST_STARTED, &brdp->state);
4318 clear_bit(BST_STARTED, &brdp->state);
4319 EBRDRESET(brdp);
4321 if (brdp->reenable != NULL)
4322 (* brdp->reenable)(brdp);
4370 struct stlibrd *brdp;
4374 if ((brdp = stli_brds[j]) == NULL ||
4375 test_bit(BST_PROBED, &brdp->state))
4378 stli_cleanup_ports(brdp);
4380 iounmap(brdp->membase);
4381 if (brdp->iosize > 0)
4382 release_region(brdp->iobase, brdp->iosize);
4383 kfree(brdp);