sys/net/i4b/layer1/isic/i4b_avm_a1.c

   1 /*
   2  *   Copyright (c) 1996 Andrew Gordon. All rights reserved.
   3  *
   4  *   Copyright (c) 1997, 2001 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  * $FreeBSD: src/sys/i4b/layer1/isic/i4b_avm_a1.c,v 1.5.2.1 2001/08/10 14:08:38 obrien Exp $
  39  *
  40  *      last edit-date: [Wed Jan 24 09:25:23 2001]
  41  *
  42  *---------------------------------------------------------------------------*/
  43
  44 #include "isic.h"
  45 #include "opt_i4b.h"
  46
  47 #if NISIC > 0 && defined(AVM_A1)
  48
  49 #include <sys/param.h>
  50 #include <sys/systm.h>
  51 #include <sys/socket.h>
  52 #include <net/if.h>
  53
  54 #include <machine/i4b_ioctl.h>
  55 #include <machine/i4b_trace.h>
  56
  57 #include <i4b/layer1/i4b_l1.h>
  58 #include <i4b/layer1/isic/i4b_isic.h>
  59 #include <i4b/layer1/isic/i4b_hscx.h>
  60
  61 /*---------------------------------------------------------------------------*
  62  *      AVM A1 and AVM Fritz! Card special registers
  63  *---------------------------------------------------------------------------*/
  64
  65 #define AVM_CONF_REG    0x1800          /* base offset for config register */
  66 #define AVM_CONF_IRQ    0x1801          /* base offset for IRQ register    */
  67                                         /* config register write           */
  68 #define  AVM_CONF_WR_RESET      0x01    /* 1 = RESET ISAC and HSCX         */
  69 #define  AVM_CONF_WR_CCL        0x02    /* 1 = clear counter low nibble    */
  70 #define  AVM_CONF_WR_CCH        0x04    /* 1 = clear counter high nibble   */
  71 #define  AVM_CONF_WR_IRQEN      0x08    /* 1 = enable IRQ                  */
  72 #define  AVM_CONF_WR_TEST       0x10    /* test bit                        */
  73                                         /* config register read            */
  74 #define  AVM_CONF_RD_IIRQ       0x01    /* 0 = ISAC IRQ active             */
  75 #define  AVM_CONF_RD_HIRQ       0x02    /* 0 = HSCX IRQ active             */
  76 #define  AVM_CONF_RD_CIRQ       0x04    /* 0 = counter IRQ active          */
  77 #define  AVM_CONF_RD_ZER1       0x08    /* unused, always read 0           */
  78 #define  AVM_CONF_RD_TEST       0x10    /* test bit read back              */
  79 #define  AVM_CONF_RD_ZER2       0x20    /* unused, always read 0           */
  80
  81 #define AVM_ISAC_R_OFFS         (0x1400-0x20)
  82 #define AVM_HSCXA_R_OFFS        (0x400-0x20)
  83 #define AVM_HSCXB_R_OFFS        (0xc00-0x20)
  84 #define AVM_ISAC_F_OFFS         (0x1400-0x20-0x3e0)
  85 #define AVM_HSCXA_F_OFFS        (0x400-0x20-0x3e0)
  86 #define AVM_HSCXB_F_OFFS        (0xc00-0x20-0x3e0)
  87
  88 /*---------------------------------------------------------------------------*
  89  *      AVM read fifo routine
  90  *---------------------------------------------------------------------------*/
  91 static void
  92 avma1_read_fifo(struct l1_softc *sc, int what, void *buf, size_t size)
  93 {
  94         bus_space_tag_t t = rman_get_bustag(sc->sc_resources.io_base[what+4]);
  95         bus_space_handle_t h = rman_get_bushandle(sc->sc_resources.io_base[what+4]);
  96         bus_space_read_multi_1(t, h, 0, buf, size);
  97 }
  98
  99 /*---------------------------------------------------------------------------*
 100  *      AVM write fifo routine
 101  *---------------------------------------------------------------------------*/
 102 static void
 103 avma1_write_fifo(struct l1_softc *sc, int what, void *buf, size_t size)
 104 {
 105         bus_space_tag_t t = rman_get_bustag(sc->sc_resources.io_base[what+4]);
 106         bus_space_handle_t h = rman_get_bushandle(sc->sc_resources.io_base[what+4]);
 107         bus_space_write_multi_1(t, h, 0, (u_int8_t*)buf, size);
 108 }
 109
 110 /*---------------------------------------------------------------------------*
 111  *      AVM write register routine
 112  *---------------------------------------------------------------------------*/
 113 static void
 114 avma1_write_reg(struct l1_softc *sc, int what, bus_size_t offs, u_int8_t data)
 115 {
 116         bus_space_tag_t t = rman_get_bustag(sc->sc_resources.io_base[what+1]);
 117         bus_space_handle_t h = rman_get_bushandle(sc->sc_resources.io_base[what+1]);
 118         bus_space_write_1(t, h, offs, data);
 119 }
 120
 121 /*---------------------------------------------------------------------------*
 122  *      AVM read register routine
 123  *---------------------------------------------------------------------------*/
 124 static u_int8_t
 125 avma1_read_reg(struct l1_softc *sc, int what, bus_size_t offs)
 126 {
 127         bus_space_tag_t t = rman_get_bustag(sc->sc_resources.io_base[what+1]);
 128         bus_space_handle_t h = rman_get_bushandle(sc->sc_resources.io_base[what+1]);
 129         return bus_space_read_1(t, h, offs);
 130 }
 131
 132 /*---------------------------------------------------------------------------*
 133  *      allocate an io port
 134  *---------------------------------------------------------------------------*/
 135 static int
 136 isic_alloc_port(device_t dev, int rid, u_int base, u_int len)
 137 {
 138         size_t unit = device_get_unit(dev);
 139         struct l1_softc *sc = &l1_sc[unit];
 140
 141         sc->sc_resources.io_rid[rid] = rid;
 142
 143         bus_set_resource(dev, SYS_RES_IOPORT, rid, base, len);
 144
 145         if(!(sc->sc_resources.io_base[rid] =
 146                 bus_alloc_resource(dev, SYS_RES_IOPORT,
 147                                    &sc->sc_resources.io_rid[rid],
 148                                    0ul, ~0ul, 1, RF_ACTIVE)))
 149         {
 150                 printf("isic%d: Error, failed to reserve io #%d!\n", unit, rid);
 151                 isic_detach_common(dev);
 152                 return(ENXIO);
 153         }
 154         return(0);
 155 }
 156
 157 /*---------------------------------------------------------------------------*
 158  *      isic_probe_avma1 - probe for AVM A1 and compatibles
 159  *---------------------------------------------------------------------------*/
 160 int
 161 isic_probe_avma1(device_t dev)
 162 {
 163         size_t unit = device_get_unit(dev);     /* get unit */
 164         struct l1_softc *sc = 0;        /* pointer to softc */
 165         void *ih = 0;                   /* dummy */
 166         bus_space_tag_t    t;           /* bus things */
 167         bus_space_handle_t h;
 168         u_char savebyte;
 169         u_char byte;
 170
 171         /* check max unit range */
 172
 173         if(unit >= ISIC_MAXUNIT)
 174         {
 175                 printf("isic%d: Error, unit %d >= ISIC_MAXUNIT for AVM A1/Fritz!\n",
 176                                 unit, unit);
 177                 return(ENXIO);
 178         }
 179
 180         sc = &l1_sc[unit];                      /* get pointer to softc */
 181         sc->sc_unit = unit;                     /* set unit */
 182
 183         /* see if an io base was supplied */
 184
 185         if(!(sc->sc_resources.io_base[0] =
 186                         bus_alloc_resource(dev, SYS_RES_IOPORT,
 187                                            &sc->sc_resources.io_rid[0],
 188                                            0ul, ~0ul, 1, RF_ACTIVE)))
 189         {
 190                 printf("isic%d: Could not get iobase for AVM A1/Fritz!\n",
 191                                 unit);
 192                 return(ENXIO);
 193         }
 194
 195         /* set io base */
 196
 197         sc->sc_port = rman_get_start(sc->sc_resources.io_base[0]);
 198
 199         /* release io base */
 200
 201         bus_release_resource(dev, SYS_RES_IOPORT, sc->sc_resources.io_rid[0],
 202                         sc->sc_resources.io_base[0]);
 203
 204         switch(sc->sc_port)
 205         {
 206                 case 0x200:
 207                 case 0x240:
 208                 case 0x300:
 209                 case 0x340:
 210                         break;
 211
 212                 default:
 213                         printf("isic%d: Error, invalid iobase 0x%x specified for AVM A1/Fritz!\n",
 214                                 unit, sc->sc_port);
 215                         return(ENXIO);
 216                         break;
 217         }
 218
 219         if(isic_alloc_port(dev, 0, sc->sc_port+AVM_CONF_REG, 0x20))
 220                 return(ENXIO);
 221
 222         if(isic_alloc_port(dev, 1, sc->sc_port+AVM_ISAC_R_OFFS, 0x20))
 223                 return(ENXIO);
 224
 225         if(isic_alloc_port(dev, 2, sc->sc_port+AVM_HSCXA_R_OFFS, 0x20))
 226                 return(ENXIO);
 227
 228         if(isic_alloc_port(dev, 3, sc->sc_port+AVM_HSCXB_R_OFFS, 0x20))
 229                 return(ENXIO);
 230
 231         if(isic_alloc_port(dev, 4, sc->sc_port+AVM_ISAC_F_OFFS, 0x20))
 232                 return(ENXIO);
 233
 234         if(isic_alloc_port(dev, 5, sc->sc_port+AVM_HSCXA_F_OFFS, 0x20))
 235                 return(ENXIO);
 236
 237         if(isic_alloc_port(dev, 6, sc->sc_port+AVM_HSCXB_F_OFFS, 0x20))
 238                 return(ENXIO);
 239
 240         /* get our irq */
 241
 242         if(!(sc->sc_resources.irq =
 243                 bus_alloc_resource(dev, SYS_RES_IRQ,
 244                                    &sc->sc_resources.irq_rid,
 245                                    0ul, ~0ul, 1, RF_ACTIVE)))
 246         {
 247                 printf("isic%d: Could not get an irq for AVM A1/Fritz!\n",unit);
 248                 isic_detach_common(dev);
 249                 return ENXIO;
 250         }
 251
 252         /* get the irq number */
 253         sc->sc_irq = rman_get_start(sc->sc_resources.irq);
 254
 255         /* register interupt routine */
 256         bus_setup_intr(dev, sc->sc_resources.irq, INTR_TYPE_NET,
 257                         (void(*)(void *))(isicintr),
 258                         sc, &ih);
 259
 260         /* check IRQ validity */
 261
 262         switch(sc->sc_irq)
 263         {
 264                 case 3:
 265                 case 4:
 266                 case 5:
 267                 case 6:
 268                 case 7:
 269                 case 8:
 270                 case 10:
 271                 case 11:
 272                 case 12:
 273                 case 13:
 274                 case 14:
 275                 case 15:
 276                         break;
 277
 278                 default:
 279                         printf("isic%d: Error, invalid IRQ [%d] specified for AVM A1/Fritz!\n",
 280                                 unit, sc->sc_irq);
 281                         isic_detach_common(dev);
 282                         return(ENXIO);
 283                         break;
 284         }
 285
 286         sc->clearirq = NULL;
 287         sc->readreg = avma1_read_reg;
 288         sc->writereg = avma1_write_reg;
 289
 290         sc->readfifo = avma1_read_fifo;
 291         sc->writefifo = avma1_write_fifo;
 292
 293         /* setup card type */
 294
 295         sc->sc_cardtyp = CARD_TYPEP_AVMA1;
 296
 297         /* setup IOM bus type */
 298
 299         sc->sc_bustyp = BUS_TYPE_IOM2;
 300
 301         sc->sc_ipac = 0;
 302         sc->sc_bfifolen = HSCX_FIFO_LEN;
 303
 304         /*
 305          * Read HSCX A/B VSTR.
 306          * Expected value for AVM A1 is 0x04 or 0x05 and for the
 307          * AVM Fritz!Card is 0x05 in the least significant bits.
 308          */
 309
 310         if( (((HSCX_READ(0, H_VSTR) & 0xf) != 0x5) &&
 311              ((HSCX_READ(0, H_VSTR) & 0xf) != 0x4))     ||
 312             (((HSCX_READ(1, H_VSTR) & 0xf) != 0x5) &&
 313              ((HSCX_READ(1, H_VSTR) & 0xf) != 0x4)) )
 314         {
 315                 printf("isic%d: HSCX VSTR test failed for AVM A1/Fritz\n",
 316                         unit);
 317                 printf("isic%d: HSC0: VSTR: %#x\n",
 318                         unit, HSCX_READ(0, H_VSTR));
 319                 printf("isic%d: HSC1: VSTR: %#x\n",
 320                         unit, HSCX_READ(1, H_VSTR));
 321                 return(ENXIO);
 322         }
 323
 324         /* AVM A1 or Fritz! control register bits:      */
 325         /*        read                write             */
 326         /* 0x01  hscx irq*           RESET              */
 327         /* 0x02  isac irq*           clear counter1     */
 328         /* 0x04  counter irq*        clear counter2     */
 329         /* 0x08  always 0            irq enable         */
 330         /* 0x10  read test bit       set test bit       */
 331         /* 0x20  always 0            unused             */
 332
 333         /*
 334          * XXX the following test may be destructive, to prevent the
 335          * worst case, we save the byte first, and in case the test
 336          * fails, we write back the saved byte .....
 337          */
 338
 339         t = rman_get_bustag(sc->sc_resources.io_base[0]);
 340         h = rman_get_bushandle(sc->sc_resources.io_base[0]);
 341
 342         savebyte = bus_space_read_1(t, h, 0);
 343
 344         /* write low to test bit */
 345
 346         bus_space_write_1(t, h, 0, 0x00);
 347
 348         /* test bit and next higher and lower bit must be 0 */
 349
 350         if((byte = bus_space_read_1(t, h, 0) & 0x38) != 0x00)
 351         {
 352                 printf("isic%d: Error, probe-1 failed, 0x%02x should be 0x00 for AVM A1/Fritz!\n",
 353                                 unit, byte);
 354                 bus_space_write_1(t, h, 0, savebyte);
 355                 return(ENXIO);
 356         }
 357
 358         /* write high to test bit */
 359
 360         bus_space_write_1(t, h, 0, 0x10);
 361
 362         /* test bit must be high, next higher and lower bit must be 0 */
 363
 364         if((byte = bus_space_read_1(t, h, 0) & 0x38) != 0x10)
 365         {
 366                 printf("isic%d: Error, probe-2 failed, 0x%02x should be 0x10 for AVM A1/Fritz!\n",
 367                                 unit, byte);
 368                 bus_space_write_1(t, h, 0, savebyte);
 369                 return(ENXIO);
 370         }
 371         return(0);
 372 }
 373
 374 /*---------------------------------------------------------------------------*
 375  *      isic_attach_avma1 - attach AVM A1 and compatibles
 376  *---------------------------------------------------------------------------*/
 377 int
 378 isic_attach_avma1(device_t dev)
 379 {
 380         size_t unit = device_get_unit(dev);
 381         struct l1_softc *sc = &l1_sc[unit];
 382         bus_space_tag_t t = rman_get_bustag(sc->sc_resources.io_base[0]);
 383         bus_space_handle_t h = rman_get_bushandle(sc->sc_resources.io_base[0]);
 384
 385         /* reset ISAC/HSCX */
 386
 387         bus_space_write_1(t, h, 0, 0x00);
 388         DELAY(SEC_DELAY / 10);
 389
 390         bus_space_write_1(t, h, 0, AVM_CONF_WR_RESET);
 391         DELAY(SEC_DELAY / 10);
 392
 393         bus_space_write_1(t, h, 0, 0x00);
 394         DELAY(SEC_DELAY / 10);
 395
 396         /* setup IRQ */
 397
 398         bus_space_write_1(t, h, 1, sc->sc_irq);
 399         DELAY(SEC_DELAY / 10);
 400
 401         /* enable IRQ, disable counter IRQ */
 402
 403         bus_space_write_1(t, h, 0, AVM_CONF_WR_IRQEN |
 404                                 AVM_CONF_WR_CCH | AVM_CONF_WR_CCL);
 405         DELAY(SEC_DELAY / 10);
 406
 407         return(0);
 408 }
 409
 410 #endif /* NISIC > 0 && defined(AVM_A1) */