sys/i4b/layer1/i4b_avm_a1.c

   1 /*
   2  *   Copyright (c) 1996 Andrew Gordon. All rights reserved.
   3  *
   4  *   Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
   5  *
   6  *   Redistribution and use in source and binary forms, with or without
   7  *   modification, are permitted provided that the following conditions
   8  *   are met:
   9  *
  10  *   1. Redistributions of source code must retain the above copyright
  11  *      notice, this list of conditions and the following disclaimer.
  12  *   2. Redistributions in binary form must reproduce the above copyright
  13  *      notice, this list of conditions and the following disclaimer in the
  14  *      documentation and/or other materials provided with the distribution.
  15  *   3. Neither the name of the author nor the names of any co-contributors
  16  *      may be used to endorse or promote products derived from this software
  17  *      without specific prior written permission.
  18  *   4. Altered versions must be plainly marked as such, and must not be
  19  *      misrepresented as being the original software and/or documentation.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  22  *   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  *   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  *   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  25  *   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  *   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  *   OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  *   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  *   OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  *   SUCH DAMAGE.
  32  *
  33  *---------------------------------------------------------------------------
  34  *
  35  *      i4b_avm_a1.c - AVM A1/Fritz passive card driver for isdn4bsd
  36  *      ------------------------------------------------------------
  37  *
  38  *      $Id: i4b_avm_a1.c,v 1.2 1999/12/13 21:25:26 hm Exp $
  39  *
  40  * $FreeBSD$
  41  *
  42  *      last edit-date: [Mon Dec 13 21:58:36 1999]
  43  *
  44  *---------------------------------------------------------------------------*/
  45
  46 #include "isic.h"
  47 #include "opt_i4b.h"
  48
  49 #if NISIC > 0 && defined(AVM_A1)
  50
  51 #include <sys/param.h>
  52 #include <sys/ioccom.h>
  53 #include <sys/kernel.h>
  54 #include <sys/systm.h>
  55 #include <sys/mbuf.h>
  56 #include <sys/socket.h>
  57
  58 #include <net/if.h>
  59
  60 #include <machine/clock.h>
  61
  62 #include <machine/i4b_debug.h>
  63 #include <machine/i4b_ioctl.h>
  64
  65 #include <i4b/include/i4b_global.h>
  66
  67 #include <i4b/layer1/i4b_l1.h>
  68 #include <i4b/layer1/i4b_isac.h>
  69 #include <i4b/layer1/i4b_hscx.h>
  70
  71 /*---------------------------------------------------------------------------*
  72  *      AVM A1 and AVM Fritz! Card special registers
  73  *---------------------------------------------------------------------------*/
  74
  75 #define AVM_CONF_REG    0x1800          /* base offset for config register */
  76 #define AVM_CONF_IRQ    0x1801          /* base offset for IRQ register    */
  77                                         /* config register write           */
  78 #define  AVM_CONF_WR_RESET      0x01    /* 1 = RESET ISAC and HSCX         */
  79 #define  AVM_CONF_WR_CCL        0x02    /* 1 = clear counter low nibble    */
  80 #define  AVM_CONF_WR_CCH        0x04    /* 1 = clear counter high nibble   */
  81 #define  AVM_CONF_WR_IRQEN      0x08    /* 1 = enable IRQ                  */
  82 #define  AVM_CONF_WR_TEST       0x10    /* test bit                        */
  83                                         /* config register read            */
  84 #define  AVM_CONF_RD_IIRQ       0x01    /* 0 = ISAC IRQ active             */
  85 #define  AVM_CONF_RD_HIRQ       0x02    /* 0 = HSCX IRQ active             */
  86 #define  AVM_CONF_RD_CIRQ       0x04    /* 0 = counter IRQ active          */
  87 #define  AVM_CONF_RD_ZER1       0x08    /* unused, always read 0           */
  88 #define  AVM_CONF_RD_TEST       0x10    /* test bit read back              */
  89 #define  AVM_CONF_RD_ZER2       0x20    /* unused, always read 0           */
  90
  91 #define AVM_ISAC_R_OFFS         (0x1400-0x20)
  92 #define AVM_HSCXA_R_OFFS        (0x400-0x20)
  93 #define AVM_HSCXB_R_OFFS        (0xc00-0x20)
  94 #define AVM_ISAC_F_OFFS         (0x1400-0x20-0x3e0)
  95 #define AVM_HSCXA_F_OFFS        (0x400-0x20-0x3e0)
  96 #define AVM_HSCXB_F_OFFS        (0xc00-0x20-0x3e0)
  97
  98 /*---------------------------------------------------------------------------*
  99  *      AVM read fifo routine
 100  *---------------------------------------------------------------------------*/
 101 static void
 102 avma1_read_fifo(struct l1_softc *sc, int what, void *buf, size_t size)
 103 {
 104         bus_space_tag_t t = rman_get_bustag(sc->sc_resources.io_base[what+4]);
 105         bus_space_handle_t h = rman_get_bushandle(sc->sc_resources.io_base[what+4]);
 106         bus_space_read_multi_1(t, h, 0, buf, size);
 107 }
 108
 109 /*---------------------------------------------------------------------------*
 110  *      AVM write fifo routine
 111  *---------------------------------------------------------------------------*/
 112 static void
 113 avma1_write_fifo(struct l1_softc *sc, int what, void *buf, size_t size)
 114 {
 115         bus_space_tag_t t = rman_get_bustag(sc->sc_resources.io_base[what+4]);
 116         bus_space_handle_t h = rman_get_bushandle(sc->sc_resources.io_base[what+4]);
 117         bus_space_write_multi_1(t, h, 0, (u_int8_t*)buf, size);
 118 }
 119
 120 /*---------------------------------------------------------------------------*
 121  *      AVM write register routine
 122  *---------------------------------------------------------------------------*/
 123 static void
 124 avma1_write_reg(struct l1_softc *sc, int what, bus_size_t offs, u_int8_t data)
 125 {
 126         bus_space_tag_t t = rman_get_bustag(sc->sc_resources.io_base[what+1]);
 127         bus_space_handle_t h = rman_get_bushandle(sc->sc_resources.io_base[what+1]);
 128         bus_space_write_1(t, h, offs, data);
 129 }
 130
 131 /*---------------------------------------------------------------------------*
 132  *      AVM read register routine
 133  *---------------------------------------------------------------------------*/
 134 static u_int8_t
 135 avma1_read_reg(struct l1_softc *sc, int what, bus_size_t offs)
 136 {
 137         bus_space_tag_t t = rman_get_bustag(sc->sc_resources.io_base[what+1]);
 138         bus_space_handle_t h = rman_get_bushandle(sc->sc_resources.io_base[what+1]);
 139         return bus_space_read_1(t, h, offs);
 140 }
 141
 142 /*---------------------------------------------------------------------------*
 143  *      allocate an io port
 144  *---------------------------------------------------------------------------*/
 145 static int
 146 isic_alloc_port(device_t dev, int rid, u_int base, u_int len)
 147 {
 148         size_t unit = device_get_unit(dev);
 149         struct l1_softc *sc = &l1_sc[unit];
 150
 151         sc->sc_resources.io_rid[rid] = rid;
 152
 153         bus_set_resource(dev, SYS_RES_IOPORT, rid, base, len);
 154
 155         if(!(sc->sc_resources.io_base[rid] =
 156                 bus_alloc_resource(dev, SYS_RES_IOPORT,
 157                                    &sc->sc_resources.io_rid[rid],
 158                                    0ul, ~0ul, 1, RF_ACTIVE)))
 159         {
 160                 printf("isic%d: Error, failed to reserve io #%d!\n", unit, rid);
 161                 isic_detach_common(dev);
 162                 return(ENXIO);
 163         }
 164         return(0);
 165 }
 166
 167 /*---------------------------------------------------------------------------*
 168  *      isic_probe_avma1 - probe for AVM A1 and compatibles
 169  *---------------------------------------------------------------------------*/
 170 int
 171 isic_probe_avma1(device_t dev)
 172 {
 173         size_t unit = device_get_unit(dev);     /* get unit */
 174         struct l1_softc *sc = 0;        /* pointer to softc */
 175         void *ih = 0;                   /* dummy */
 176         bus_space_tag_t    t;           /* bus things */
 177         bus_space_handle_t h;
 178         u_char savebyte;
 179         u_char byte;
 180
 181         /* check max unit range */
 182
 183         if(unit >= ISIC_MAXUNIT)
 184         {
 185                 printf("isic%d: Error, unit %d >= ISIC_MAXUNIT for AVM A1/Fritz!\n",
 186                                 unit, unit);
 187                 return(ENXIO);
 188         }
 189
 190         sc = &l1_sc[unit];                      /* get pointer to softc */
 191         sc->sc_unit = unit;                     /* set unit */
 192         sc->sc_flags = FLAG_AVM_A1;             /* set flags */
 193
 194         /* see if an io base was supplied */
 195
 196         if(!(sc->sc_resources.io_base[0] =
 197                         bus_alloc_resource(dev, SYS_RES_IOPORT,
 198                                            &sc->sc_resources.io_rid[0],
 199                                            0ul, ~0ul, 1, RF_ACTIVE)))
 200         {
 201                 printf("isic%d: Could not get iobase for AVM A1/Fritz!\n",
 202                                 unit);
 203                 return(ENXIO);
 204         }
 205
 206         /* set io base */
 207
 208         sc->sc_port = rman_get_start(sc->sc_resources.io_base[0]);
 209
 210         /* release io base */
 211
 212         bus_release_resource(dev, SYS_RES_IOPORT, sc->sc_resources.io_rid[0],
 213                         sc->sc_resources.io_base[0]);
 214
 215         switch(sc->sc_port)
 216         {
 217                 case 0x200:
 218                 case 0x240:
 219                 case 0x300:
 220                 case 0x340:
 221                         break;
 222
 223                 default:
 224                         printf("isic%d: Error, invalid iobase 0x%x specified for AVM A1/Fritz!\n",
 225                                 unit, sc->sc_port);
 226                         return(ENXIO);
 227                         break;
 228         }
 229
 230         if(isic_alloc_port(dev, 0, sc->sc_port+AVM_CONF_REG, 0x20))
 231                 return(ENXIO);
 232
 233         if(isic_alloc_port(dev, 1, sc->sc_port+AVM_ISAC_R_OFFS, 0x20))
 234                 return(ENXIO);
 235
 236         if(isic_alloc_port(dev, 2, sc->sc_port+AVM_HSCXA_R_OFFS, 0x20))
 237                 return(ENXIO);
 238
 239         if(isic_alloc_port(dev, 3, sc->sc_port+AVM_HSCXB_R_OFFS, 0x20))
 240                 return(ENXIO);
 241
 242         if(isic_alloc_port(dev, 4, sc->sc_port+AVM_ISAC_F_OFFS, 0x20))
 243                 return(ENXIO);
 244
 245         if(isic_alloc_port(dev, 5, sc->sc_port+AVM_HSCXA_F_OFFS, 0x20))
 246                 return(ENXIO);
 247
 248         if(isic_alloc_port(dev, 6, sc->sc_port+AVM_HSCXB_F_OFFS, 0x20))
 249                 return(ENXIO);
 250
 251         /* get our irq */
 252
 253         if(!(sc->sc_resources.irq =
 254                 bus_alloc_resource(dev, SYS_RES_IRQ,
 255                                    &sc->sc_resources.irq_rid,
 256                                    0ul, ~0ul, 1, RF_ACTIVE)))
 257         {
 258                 printf("isic%d: Could not get an irq for AVM A1/Fritz!\n",unit);
 259                 isic_detach_common(dev);
 260                 return ENXIO;
 261         }
 262
 263         /* get the irq number */
 264         sc->sc_irq = rman_get_start(sc->sc_resources.irq);
 265
 266         /* register interupt routine */
 267         bus_setup_intr(dev, sc->sc_resources.irq, INTR_TYPE_NET,
 268                         (void(*)(void *))(isicintr),
 269                         sc, &ih);
 270
 271         /* check IRQ validity */
 272
 273         switch(sc->sc_irq)
 274         {
 275                 case 3:
 276                 case 4:
 277                 case 5:
 278                 case 6:
 279                 case 7:
 280                 case 8:
 281                 case 10:
 282                 case 11:
 283                 case 12:
 284                 case 13:
 285                 case 14:
 286                 case 15:
 287                         break;
 288
 289                 default:
 290                         printf("isic%d: Error, invalid IRQ [%d] specified for AVM A1/Fritz!\n",
 291                                 unit, sc->sc_irq);
 292                         isic_detach_common(dev);
 293                         return(ENXIO);
 294                         break;
 295         }
 296
 297         sc->clearirq = NULL;
 298         sc->readreg = avma1_read_reg;
 299         sc->writereg = avma1_write_reg;
 300
 301         sc->readfifo = avma1_read_fifo;
 302         sc->writefifo = avma1_write_fifo;
 303
 304         /* setup card type */
 305
 306         sc->sc_cardtyp = CARD_TYPEP_AVMA1;
 307
 308         /* setup IOM bus type */
 309
 310         sc->sc_bustyp = BUS_TYPE_IOM2;
 311
 312         sc->sc_ipac = 0;
 313         sc->sc_bfifolen = HSCX_FIFO_LEN;
 314
 315         /*
 316          * Read HSCX A/B VSTR.
 317          * Expected value for AVM A1 is 0x04 or 0x05 and for the
 318          * AVM Fritz!Card is 0x05 in the least significant bits.
 319          */
 320
 321         if( (((HSCX_READ(0, H_VSTR) & 0xf) != 0x5) &&
 322              ((HSCX_READ(0, H_VSTR) & 0xf) != 0x4))     ||
 323             (((HSCX_READ(1, H_VSTR) & 0xf) != 0x5) &&
 324              ((HSCX_READ(1, H_VSTR) & 0xf) != 0x4)) )
 325         {
 326                 printf("isic%d: HSCX VSTR test failed for AVM A1/Fritz\n",
 327                         unit);
 328                 printf("isic%d: HSC0: VSTR: %#x\n",
 329                         unit, HSCX_READ(0, H_VSTR));
 330                 printf("isic%d: HSC1: VSTR: %#x\n",
 331                         unit, HSCX_READ(1, H_VSTR));
 332                 return(ENXIO);
 333         }
 334
 335         /* AVM A1 or Fritz! control register bits:      */
 336         /*        read                write             */
 337         /* 0x01  hscx irq*           RESET              */
 338         /* 0x02  isac irq*           clear counter1     */
 339         /* 0x04  counter irq*        clear counter2     */
 340         /* 0x08  always 0            irq enable         */
 341         /* 0x10  read test bit       set test bit       */
 342         /* 0x20  always 0            unused             */
 343
 344         /*
 345          * XXX the following test may be destructive, to prevent the
 346          * worst case, we save the byte first, and in case the test
 347          * fails, we write back the saved byte .....
 348          */
 349
 350         t = rman_get_bustag(sc->sc_resources.io_base[0]);
 351         h = rman_get_bushandle(sc->sc_resources.io_base[0]);
 352
 353         savebyte = bus_space_read_1(t, h, 0);
 354
 355         /* write low to test bit */
 356
 357         bus_space_write_1(t, h, 0, 0x00);
 358
 359         /* test bit and next higher and lower bit must be 0 */
 360
 361         if((byte = bus_space_read_1(t, h, 0) & 0x38) != 0x00)
 362         {
 363                 printf("isic%d: Error, probe-1 failed, 0x%02x should be 0x00 for AVM A1/Fritz!\n",
 364                                 unit, byte);
 365                 bus_space_write_1(t, h, 0, savebyte);
 366                 return(ENXIO);
 367         }
 368
 369         /* write high to test bit */
 370
 371         bus_space_write_1(t, h, 0, 0x10);
 372
 373         /* test bit must be high, next higher and lower bit must be 0 */
 374
 375         if((byte = bus_space_read_1(t, h, 0) & 0x38) != 0x10)
 376         {
 377                 printf("isic%d: Error, probe-2 failed, 0x%02x should be 0x10 for AVM A1/Fritz!\n",
 378                                 unit, byte);
 379                 bus_space_write_1(t, h, 0, savebyte);
 380                 return(ENXIO);
 381         }
 382         return(0);
 383 }
 384
 385 /*---------------------------------------------------------------------------*
 386  *      isic_attach_avma1 - attach AVM A1 and compatibles
 387  *---------------------------------------------------------------------------*/
 388 int
 389 isic_attach_avma1(device_t dev)
 390 {
 391         size_t unit = device_get_unit(dev);
 392         struct l1_softc *sc = &l1_sc[unit];
 393         bus_space_tag_t t = rman_get_bustag(sc->sc_resources.io_base[0]);
 394         bus_space_handle_t h = rman_get_bushandle(sc->sc_resources.io_base[0]);
 395
 396         /* reset ISAC/HSCX */
 397
 398         bus_space_write_1(t, h, 0, 0x00);
 399         DELAY(SEC_DELAY / 10);
 400
 401         bus_space_write_1(t, h, 0, AVM_CONF_WR_RESET);
 402         DELAY(SEC_DELAY / 10);
 403
 404         bus_space_write_1(t, h, 0, 0x00);
 405         DELAY(SEC_DELAY / 10);
 406
 407         /* setup IRQ */
 408
 409         bus_space_write_1(t, h, 1, sc->sc_irq);
 410         DELAY(SEC_DELAY / 10);
 411
 412         /* enable IRQ, disable counter IRQ */
 413
 414         bus_space_write_1(t, h, 0, AVM_CONF_WR_IRQEN |
 415                                 AVM_CONF_WR_CCH | AVM_CONF_WR_CCL);
 416         DELAY(SEC_DELAY / 10);
 417
 418         return(0);
 419 }
 420
 421 #endif /* NISIC > 0 && defined(AVM_A1) */