sys/dev/serial/rp/rp_isa.c

   1 /*
   2  * Copyright (c) Comtrol Corporation <support@comtrol.com>
   3  * All rights reserved.
   4  *
   5  * ISA-specific part separated from:
   6  * sys/i386/isa/rp.c,v 1.33 1999/09/28 11:45:27 phk Exp
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted prodived that the follwoing conditions
  10  * are met.
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notive, this list of conditions and the following disclainer.
  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 prodided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *       This product includes software developed by Comtrol Corporation.
  19  * 4. The name of Comtrol Corporation may not be used to endorse or
  20  *    promote products derived from this software without specific
  21  *    prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY COMTROL CORPORATION ``AS IS'' AND ANY
  24  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL COMTROL CORPORATION BE LIABLE FOR
  27  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, LIFE OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  *
  35  * $FreeBSD: src/sys/dev/rp/rp_isa.c,v 1.3.2.1 2002/06/18 03:11:46 obrien Exp $
  36  */
  37
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/fcntl.h>
  41 #include <sys/malloc.h>
  42 #include <sys/tty.h>
  43 #include <sys/conf.h>
  44 #include <sys/kernel.h>
  45 #include <sys/bus.h>
  46 #include <sys/rman.h>
  47
  48 #define ROCKET_C
  49 #include "rpreg.h"
  50 #include "rpvar.h"
  51
  52 #include <bus/isa/isavar.h>
  53
  54 /* ISA-specific part of CONTROLLER_t */
  55 struct ISACONTROLLER_T {
  56         int             MBaseIO;        /* rid of the Mudbac controller for this controller */
  57         int             MReg0IO;        /* offset0 of the Mudbac controller for this controller */
  58         int             MReg1IO;        /* offset1 of the Mudbac controller for this controller */
  59         int             MReg2IO;        /* offset2 of the Mudbac controller for this controller */
  60         int             MReg3IO;        /* offset3 of the Mudbac controller for this controller */
  61         Byte_t          MReg2;
  62         Byte_t          MReg3;
  63 };
  64 typedef struct ISACONTROLLER_T ISACONTROLLER_t;
  65
  66 #define ISACTL(ctlp) ((ISACONTROLLER_t *)((ctlp)->bus_ctlp))
  67
  68 /***************************************************************************
  69 Function: sControllerEOI
  70 Purpose:  Strobe the MUDBAC's End Of Interrupt bit.
  71 Call:     sControllerEOI(MudbacCtlP,CtlP)
  72           CONTROLLER_T *MudbacCtlP; Ptr to Mudbac controller structure
  73           CONTROLLER_T *CtlP; Ptr to controller structure
  74 */
  75 #define sControllerEOI(MudbacCtlP,CtlP) \
  76         rp_writeio1(MudbacCtlP,ISACTL(CtlP)->MBaseIO,ISACTL(CtlP)->MReg2IO,ISACTL(CtlP)->MReg2 | INT_STROB)
  77
  78 /***************************************************************************
  79 Function: sDisAiop
  80 Purpose:  Disable I/O access to an AIOP
  81 Call:     sDisAiop(MudbacCtlP,CtlP)
  82           CONTROLLER_T *MudbacCtlP; Ptr to Mudbac controller structure
  83           CONTROLLER_T *CtlP; Ptr to controller structure
  84           int AiopNum; Number of AIOP on controller
  85 */
  86 #define sDisAiop(MudbacCtlP,CtlP,AIOPNUM) \
  87 { \
  88    ISACTL(CtlP)->MReg3 &= rp_sBitMapClrTbl[AIOPNUM]; \
  89    rp_writeio1(MudbacCtlP,ISACTL(CtlP)->MBaseIO,ISACTL(CtlP)->MReg3IO,ISACTL(CtlP)->MReg3); \
  90 }
  91
  92 /***************************************************************************
  93 Function: sEnAiop
  94 Purpose:  Enable I/O access to an AIOP
  95 Call:     sEnAiop(MudbacCtlP,CtlP)
  96           CONTROLLER_T *MudbacCtlP; Ptr to Mudbac controller structure
  97           CONTROLLER_T *CtlP; Ptr to controller structure
  98           int AiopNum; Number of AIOP on controller
  99 */
 100 #define sEnAiop(MudbacCtlP,CtlP,AIOPNUM) \
 101 { \
 102    ISACTL(CtlP)->MReg3 |= rp_sBitMapSetTbl[AIOPNUM]; \
 103    rp_writeio1(MudbacCtlP,ISACTL(CtlP)->MBaseIO,ISACTL(CtlP)->MReg3IO,ISACTL(CtlP)->MReg3); \
 104 }
 105
 106 /***************************************************************************
 107 Function: sGetControllerIntStatus
 108 Purpose:  Get the controller interrupt status
 109 Call:     sGetControllerIntStatus(MudbacCtlP,CtlP)
 110           CONTROLLER_T *MudbacCtlP; Ptr to Mudbac controller structure
 111           CONTROLLER_T *CtlP; Ptr to controller structure
 112 Return:   Byte_t: The controller interrupt status in the lower 4
 113                          bits.  Bits 0 through 3 represent AIOP's 0
 114                          through 3 respectively.  If a bit is set that
 115                          AIOP is interrupting.  Bits 4 through 7 will
 116                          always be cleared.
 117 */
 118 #define sGetControllerIntStatus(MudbacCtlP,CtlP) \
 119         (rp_readio1(MudbacCtlP,ISACTL(CtlP)->MBaseIO,ISACTL(CtlP)->MReg1IO) & 0x0f)
 120
 121 static devclass_t rp_devclass;
 122 static CONTROLLER_t *rp_controller;
 123 static int rp_nisadevs;
 124
 125 static int rp_probe(device_t dev);
 126 static int rp_attach(device_t dev);
 127 static void rp_isareleaseresource(CONTROLLER_t *ctlp);
 128 static int sInitController(CONTROLLER_T *CtlP,
 129                            CONTROLLER_T *MudbacCtlP,
 130                            int AiopNum,
 131                            int IRQNum,
 132                            Byte_t Frequency,
 133                            int PeriodicOnly);
 134 static rp_aiop2rid_t rp_isa_aiop2rid;
 135 static rp_aiop2off_t rp_isa_aiop2off;
 136 static rp_ctlmask_t rp_isa_ctlmask;
 137
 138 static int
 139 rp_probe(device_t dev)
 140 {
 141         int unit;
 142         CONTROLLER_t *controller;
 143         int num_aiops;
 144         CONTROLLER_t *ctlp;
 145         int retval;
 146
 147         /*
 148          * We have no PnP RocketPort cards.
 149          * (At least according to LINT)
 150          */
 151         if (isa_get_logicalid(dev) != 0)
 152                 return (ENXIO);
 153
 154         /* We need IO port resource to configure an ISA device. */
 155         if (bus_get_resource_count(dev, SYS_RES_IOPORT, 0) == 0)
 156                 return (ENXIO);
 157
 158         unit = device_get_unit(dev);
 159         if (unit >= 4) {
 160                 device_printf(dev, "rpprobe: unit number %d invalid.\n", unit);
 161                 return (ENXIO);
 162         }
 163         device_printf(dev, "probing for RocketPort(ISA) unit %d.\n", unit);
 164
 165         ctlp = device_get_softc(dev);
 166         bzero(ctlp, sizeof(*ctlp));
 167         ctlp->dev = dev;
 168         ctlp->aiop2rid = rp_isa_aiop2rid;
 169         ctlp->aiop2off = rp_isa_aiop2off;
 170         ctlp->ctlmask = rp_isa_ctlmask;
 171
 172         /* The IO ports of AIOPs for an ISA controller are discrete. */
 173         ctlp->io_num = 1;
 174         ctlp->io_rid = kmalloc(sizeof(*(ctlp->io_rid)) * MAX_AIOPS_PER_BOARD,
 175                                 M_DEVBUF, M_WAITOK | M_ZERO);
 176         ctlp->io = kmalloc(sizeof(*(ctlp->io)) * MAX_AIOPS_PER_BOARD,
 177                                 M_DEVBUF, M_WAITOK | M_ZERO);
 178
 179         ctlp->bus_ctlp = kmalloc(sizeof(ISACONTROLLER_t) * 1,
 180                                 M_DEVBUF, M_WAITOK | M_ZERO);
 181
 182         ctlp->io_rid[0] = 0;
 183         if (rp_controller != NULL) {
 184                 controller = rp_controller;
 185                 ctlp->io[0] = bus_alloc_resource(dev, SYS_RES_IOPORT, &ctlp->io_rid[0], 0, ~0, 0x40, RF_ACTIVE);
 186         } else {
 187                 controller = rp_controller = ctlp;
 188                 ctlp->io[0] = bus_alloc_resource(dev, SYS_RES_IOPORT, &ctlp->io_rid[0], 0, ~0, 0x44, RF_ACTIVE);
 189         }
 190         if (ctlp->io[0] == NULL) {
 191                 device_printf(dev, "rp_attach: Resource not available.\n");
 192                 retval = ENXIO;
 193                 goto nogo;
 194         }
 195
 196         num_aiops = sInitController(ctlp,
 197                                 controller,
 198                                 MAX_AIOPS_PER_BOARD, 0,
 199                                 FREQ_DIS, 0);
 200         if (num_aiops <= 0) {
 201                 device_printf(dev, "board%d init failed.\n", unit);
 202                 retval = ENXIO;
 203                 goto nogo;
 204         }
 205
 206         if (rp_controller == NULL)
 207                 rp_controller = controller;
 208         rp_nisadevs++;
 209
 210         device_set_desc(dev, "RocketPort ISA");
 211
 212         return (0);
 213
 214 nogo:
 215         rp_isareleaseresource(ctlp);
 216
 217         return (retval);
 218 }
 219
 220 static int
 221 rp_attach(device_t dev)
 222 {
 223         int     unit;
 224         int     num_ports, num_aiops;
 225         int     aiop;
 226         CONTROLLER_t    *ctlp;
 227         int     retval;
 228
 229         unit = device_get_unit(dev);
 230
 231         ctlp = device_get_softc(dev);
 232
 233 #if 0 /* notdef */
 234         num_aiops = sInitController(ctlp,
 235                                 rp_controller,
 236                                 MAX_AIOPS_PER_BOARD, 0,
 237                                 FREQ_DIS, 0);
 238 #else
 239         num_aiops = ctlp->NumAiop;
 240 #endif /* notdef */
 241
 242         num_ports = 0;
 243         for(aiop=0; aiop < num_aiops; aiop++) {
 244                 sResetAiopByNum(ctlp, aiop);
 245                 sEnAiop(rp_controller, ctlp, aiop);
 246                 num_ports += sGetAiopNumChan(ctlp, aiop);
 247         }
 248
 249         retval = rp_attachcommon(ctlp, num_aiops, num_ports);
 250         if (retval != 0)
 251                 goto nogo;
 252
 253         return (0);
 254
 255 nogo:
 256         rp_isareleaseresource(ctlp);
 257
 258         return (retval);
 259 }
 260
 261 static void
 262 rp_isareleaseresource(CONTROLLER_t *ctlp)
 263 {
 264         int i;
 265
 266         rp_releaseresource(ctlp);
 267
 268         if (ctlp == rp_controller)
 269                 rp_controller = NULL;
 270         if (ctlp->io != NULL) {
 271                 for (i = 0 ; i < MAX_AIOPS_PER_BOARD ; i++)
 272                         if (ctlp->io[i] != NULL)
 273                                 bus_release_resource(ctlp->dev, SYS_RES_IOPORT, ctlp->io_rid[i], ctlp->io[i]);
 274                 kfree(ctlp->io, M_DEVBUF);
 275         }
 276         if (ctlp->io_rid != NULL)
 277                 kfree(ctlp->io_rid, M_DEVBUF);
 278         if (rp_controller != NULL && rp_controller->io[ISACTL(ctlp)->MBaseIO] != NULL) {
 279                 bus_release_resource(rp_controller->dev, SYS_RES_IOPORT, rp_controller->io_rid[ISACTL(ctlp)->MBaseIO], rp_controller->io[ISACTL(ctlp)->MBaseIO]);
 280                 rp_controller->io[ISACTL(ctlp)->MBaseIO] = NULL;
 281                 rp_controller->io_rid[ISACTL(ctlp)->MBaseIO] = 0;
 282         }
 283         if (ctlp->bus_ctlp != NULL)
 284                 kfree(ctlp->bus_ctlp, M_DEVBUF);
 285 }
 286
 287 /***************************************************************************
 288 Function: sInitController
 289 Purpose:  Initialization of controller global registers and controller
 290           structure.
 291 Call:     sInitController(CtlP,MudbacCtlP,AiopNum,
 292                           IRQNum,Frequency,PeriodicOnly)
 293           CONTROLLER_T *CtlP; Ptr to controller structure
 294           CONTROLLER_T *MudbacCtlP; Ptr to Mudbac controller structure
 295           int AiopNum; Number of Aiops
 296           int IRQNum; Interrupt Request number.  Can be any of the following:
 297                          0: Disable global interrupts
 298                          3: IRQ 3
 299                          4: IRQ 4
 300                          5: IRQ 5
 301                          9: IRQ 9
 302                          10: IRQ 10
 303                          11: IRQ 11
 304                          12: IRQ 12
 305                          15: IRQ 15
 306           Byte_t Frequency: A flag identifying the frequency
 307                    of the periodic interrupt, can be any one of the following:
 308                       FREQ_DIS - periodic interrupt disabled
 309                       FREQ_137HZ - 137 Hertz
 310                       FREQ_69HZ - 69 Hertz
 311                       FREQ_34HZ - 34 Hertz
 312                       FREQ_17HZ - 17 Hertz
 313                       FREQ_9HZ - 9 Hertz
 314                       FREQ_4HZ - 4 Hertz
 315                    If IRQNum is set to 0 the Frequency parameter is
 316                    overidden, it is forced to a value of FREQ_DIS.
 317           int PeriodicOnly: TRUE if all interrupts except the periodic
 318                                interrupt are to be blocked.
 319                             FALSE is both the periodic interrupt and
 320                                other channel interrupts are allowed.
 321                             If IRQNum is set to 0 the PeriodicOnly parameter is
 322                                overidden, it is forced to a value of FALSE.
 323 Return:   int: Number of AIOPs on the controller, or CTLID_NULL if controller
 324                initialization failed.
 325
 326 Comments:
 327           If periodic interrupts are to be disabled but AIOP interrupts
 328           are allowed, set Frequency to FREQ_DIS and PeriodicOnly to FALSE.
 329
 330           If interrupts are to be completely disabled set IRQNum to 0.
 331
 332           Setting Frequency to FREQ_DIS and PeriodicOnly to TRUE is an
 333           invalid combination.
 334
 335           This function performs initialization of global interrupt modes,
 336           but it does not actually enable global interrupts.  To enable
 337           and disable global interrupts use functions sEnGlobalInt() and
 338           sDisGlobalInt().  Enabling of global interrupts is normally not
 339           done until all other initializations are complete.
 340
 341           Even if interrupts are globally enabled, they must also be
 342           individually enabled for each channel that is to generate
 343           interrupts.
 344
 345 Warnings: No range checking on any of the parameters is done.
 346
 347           No context switches are allowed while executing this function.
 348
 349           After this function all AIOPs on the controller are disabled,
 350           they can be enabled with sEnAiop().
 351 */
 352 static int
 353 sInitController(        CONTROLLER_T *CtlP,
 354                         CONTROLLER_T *MudbacCtlP,
 355                         int AiopNum,
 356                         int IRQNum,
 357                         Byte_t Frequency,
 358                         int PeriodicOnly)
 359 {
 360         int             i;
 361         int             ctl_base, aiop_base, aiop_size;
 362
 363         CtlP->CtlID = CTLID_0001;               /* controller release 1 */
 364
 365         ISACTL(CtlP)->MBaseIO = rp_nisadevs;
 366         if (MudbacCtlP->io[ISACTL(CtlP)->MBaseIO] != NULL) {
 367                 ISACTL(CtlP)->MReg0IO = 0x40 + 0;
 368                 ISACTL(CtlP)->MReg1IO = 0x40 + 1;
 369                 ISACTL(CtlP)->MReg2IO = 0x40 + 2;
 370                 ISACTL(CtlP)->MReg3IO = 0x40 + 3;
 371         } else {
 372                 MudbacCtlP->io_rid[ISACTL(CtlP)->MBaseIO] = ISACTL(CtlP)->MBaseIO;
 373                 ctl_base = rman_get_start(MudbacCtlP->io[0]) + 0x40 + 0x400 * rp_nisadevs;
 374                 MudbacCtlP->io[ISACTL(CtlP)->MBaseIO] = bus_alloc_resource(MudbacCtlP->dev, SYS_RES_IOPORT, &CtlP->io_rid[ISACTL(CtlP)->MBaseIO], ctl_base, ctl_base + 3, 4, RF_ACTIVE);
 375                 ISACTL(CtlP)->MReg0IO = 0;
 376                 ISACTL(CtlP)->MReg1IO = 1;
 377                 ISACTL(CtlP)->MReg2IO = 2;
 378                 ISACTL(CtlP)->MReg3IO = 3;
 379         }
 380 #if 1
 381         ISACTL(CtlP)->MReg2 = 0;                        /* interrupt disable */
 382         ISACTL(CtlP)->MReg3 = 0;                        /* no periodic interrupts */
 383 #else
 384         if(sIRQMap[IRQNum] == 0)                /* interrupts globally disabled */
 385         {
 386                 ISACTL(CtlP)->MReg2 = 0;                /* interrupt disable */
 387                 ISACTL(CtlP)->MReg3 = 0;                /* no periodic interrupts */
 388         }
 389         else
 390         {
 391                 ISACTL(CtlP)->MReg2 = sIRQMap[IRQNum];  /* set IRQ number */
 392                 ISACTL(CtlP)->MReg3 = Frequency;        /* set frequency */
 393                 if(PeriodicOnly)                /* periodic interrupt only */
 394                 {
 395                         ISACTL(CtlP)->MReg3 |= PERIODIC_ONLY;
 396                 }
 397         }
 398 #endif
 399         rp_writeio1(MudbacCtlP,ISACTL(CtlP)->MBaseIO,ISACTL(CtlP)->MReg2IO,ISACTL(CtlP)->MReg2);
 400         rp_writeio1(MudbacCtlP,ISACTL(CtlP)->MBaseIO,ISACTL(CtlP)->MReg3IO,ISACTL(CtlP)->MReg3);
 401         sControllerEOI(MudbacCtlP,CtlP);                        /* clear EOI if warm init */
 402
 403         /* Init AIOPs */
 404         CtlP->NumAiop = 0;
 405         for(i=0; i < AiopNum; i++)
 406         {
 407                 if (CtlP->io[i] == NULL) {
 408                         CtlP->io_rid[i] = i;
 409                         aiop_base = rman_get_start(CtlP->io[0]) + 0x400 * i;
 410                         if (rp_nisadevs == 0)
 411                                 aiop_size = 0x44;
 412                         else
 413                                 aiop_size = 0x40;
 414                         CtlP->io[i] = bus_alloc_resource(CtlP->dev, SYS_RES_IOPORT, &CtlP->io_rid[i], aiop_base, aiop_base + aiop_size - 1, aiop_size, RF_ACTIVE);
 415                 } else
 416                         aiop_base = rman_get_start(CtlP->io[i]);
 417                 rp_writeio1(MudbacCtlP,ISACTL(CtlP)->MBaseIO,
 418                             ISACTL(CtlP)->MReg2IO,
 419                             ISACTL(CtlP)->MReg2 | (i & 0x03));  /* AIOP index */
 420                 rp_writeio1(MudbacCtlP,ISACTL(CtlP)->MBaseIO,
 421                             ISACTL(CtlP)->MReg0IO,
 422                             (Byte_t)(aiop_base >> 6));          /* set up AIOP I/O in MUDBAC */
 423                 sEnAiop(MudbacCtlP,CtlP,i);                     /* enable the AIOP */
 424
 425                 CtlP->AiopID[i] = sReadAiopID(CtlP, i);         /* read AIOP ID */
 426                 if(CtlP->AiopID[i] == AIOPID_NULL)              /* if AIOP does not exist */
 427                 {
 428                         sDisAiop(MudbacCtlP,CtlP,i);            /* disable AIOP */
 429                         bus_release_resource(CtlP->dev, SYS_RES_IOPORT, CtlP->io_rid[i], CtlP->io[i]);
 430                         CtlP->io[i] = NULL;
 431                         break;                                  /* done looking for AIOPs */
 432                 }
 433
 434                 CtlP->AiopNumChan[i] = sReadAiopNumChan(CtlP, i);       /* num channels in AIOP */
 435                 rp_writeaiop2(CtlP,i,_INDX_ADDR,_CLK_PRE);      /* clock prescaler */
 436                 rp_writeaiop1(CtlP,i,_INDX_DATA,CLOCK_PRESC);
 437                 CtlP->NumAiop++;                                /* bump count of AIOPs */
 438                 sDisAiop(MudbacCtlP,CtlP,i);                    /* disable AIOP */
 439         }
 440
 441         if(CtlP->NumAiop == 0)
 442                 return(-1);
 443         else
 444                 return(CtlP->NumAiop);
 445 }
 446
 447 /*
 448  * ARGSUSED
 449  * Maps (aiop, offset) to rid.
 450  */
 451 static int
 452 rp_isa_aiop2rid(int aiop, int offset)
 453 {
 454         /* rid equals to aiop for an ISA controller. */
 455         return aiop;
 456 }
 457
 458 /*
 459  * ARGSUSED
 460  * Maps (aiop, offset) to the offset of resource.
 461  */
 462 static int
 463 rp_isa_aiop2off(int aiop, int offset)
 464 {
 465         /* Each aiop has its own resource. */
 466         return offset;
 467 }
 468
 469 /* Read the int status for an ISA controller. */
 470 unsigned char
 471 rp_isa_ctlmask(CONTROLLER_t *ctlp)
 472 {
 473         return sGetControllerIntStatus(rp_controller,ctlp);
 474 }
 475
 476 static device_method_t rp_methods[] = {
 477         /* Device interface */
 478         DEVMETHOD(device_probe,         rp_probe),
 479         DEVMETHOD(device_attach,        rp_attach),
 480
 481         { 0, 0 }
 482 };
 483
 484 static driver_t rp_driver = {
 485         "rp",
 486         rp_methods,
 487         sizeof(CONTROLLER_t),
 488 };
 489
 490 /*
 491  * rp can be attached to an isa bus.
 492  */
 493 DRIVER_MODULE(rp, isa, rp_driver, rp_devclass, NULL, NULL);