sys/bus/pccard/pccardvar.h

   1 /*      $NetBSD: pcmciavar.h,v 1.9 1998/12/29 09:00:28 marc Exp $       */
   2 /* $FreeBSD: src/sys/dev/pccard/pccardvar.h,v 1.6.2.3 2002/09/01 05:45:51 imp Exp $ */
   3
   4 /*
   5  * Copyright (c) 1997 Marc Horowitz.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  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. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *      This product includes software developed by Marc Horowitz.
  18  * 4. The name of the author may not be used to endorse or promote products
  19  *    derived from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <sys/types.h>
  34 #include <sys/queue.h>
  35
  36 #include <machine/bus.h>
  37
  38 extern int      pccard_verbose;
  39
  40 /*
  41  * Contains information about mapped/allocated i/o spaces.
  42  */
  43 struct pccard_io_handle {
  44         bus_space_tag_t iot;            /* bus space tag (from chipset) */
  45         bus_space_handle_t ioh;         /* mapped space handle */
  46         bus_addr_t      addr;           /* resulting address in bus space */
  47         bus_size_t      size;           /* size of i/o space */
  48         int             flags;          /* misc. information */
  49         int             width;
  50 };
  51
  52 #define PCCARD_IO_ALLOCATED     0x01    /* i/o space was allocated */
  53
  54 /*
  55  * Contains information about allocated memory space.
  56  */
  57 struct pccard_mem_handle {
  58         bus_space_tag_t memt;           /* bus space tag (from chipset) */
  59         bus_space_handle_t memh;        /* mapped space handle */
  60         bus_addr_t      addr;           /* resulting address in bus space */
  61         bus_size_t      size;           /* size of mem space */
  62         bus_size_t      realsize;       /* how much we really allocated */
  63         long            offset;
  64         int             kind;
  65 };
  66
  67 /* pccard itself */
  68
  69 #define PCCARD_CFE_MWAIT_REQUIRED       0x0001
  70 #define PCCARD_CFE_RDYBSY_ACTIVE        0x0002
  71 #define PCCARD_CFE_WP_ACTIVE            0x0004
  72 #define PCCARD_CFE_BVD_ACTIVE           0x0008
  73 #define PCCARD_CFE_IO8                  0x0010
  74 #define PCCARD_CFE_IO16                 0x0020
  75 #define PCCARD_CFE_IRQSHARE             0x0040
  76 #define PCCARD_CFE_IRQPULSE             0x0080
  77 #define PCCARD_CFE_IRQLEVEL             0x0100
  78 #define PCCARD_CFE_POWERDOWN            0x0200
  79 #define PCCARD_CFE_READONLY             0x0400
  80 #define PCCARD_CFE_AUDIO                0x0800
  81
  82 struct pccard_config_entry {
  83         int             number;
  84         u_int32_t       flags;
  85         int             iftype;
  86         int             num_iospace;
  87
  88         /*
  89          * The card will only decode this mask in any case, so we can
  90          * do dynamic allocation with this in mind, in case the suggestions
  91          * below are no good.
  92          */
  93         u_long          iomask;
  94         struct {
  95                 u_long  length;
  96                 u_long  start;
  97         } iospace[4];           /* XXX this could be as high as 16 */
  98         u_int16_t       irqmask;
  99         int             num_memspace;
 100         struct {
 101                 u_long  length;
 102                 u_long  cardaddr;
 103                 u_long  hostaddr;
 104         } memspace[2];          /* XXX this could be as high as 8 */
 105         int             maxtwins;
 106         STAILQ_ENTRY(pccard_config_entry) cfe_list;
 107 };
 108
 109 struct pccard_function {
 110         /* read off the card */
 111         int             number;
 112         int             function;
 113         int             last_config_index;
 114         u_long          ccr_base;
 115         u_long          ccr_mask;
 116         struct resource *ccr_res;
 117         int             ccr_rid;
 118         STAILQ_HEAD(, pccard_config_entry) cfe_head;
 119         STAILQ_ENTRY(pccard_function) pf_list;
 120         /* run-time state */
 121         struct pccard_softc *sc;
 122         struct pccard_config_entry *cfe;
 123         struct pccard_mem_handle pf_pcmh;
 124 #define pf_ccrt         pf_pcmh.memt
 125 #define pf_ccrh         pf_pcmh.memh
 126 #define pf_ccr_realsize pf_pcmh.realsize
 127         bus_addr_t      pf_ccr_offset;
 128         int             pf_ccr_window;
 129         long            pf_mfc_iobase;
 130         long            pf_mfc_iomax;
 131         int             (*ih_fct)(void *);
 132         void            *ih_arg;
 133         int             ih_ipl;
 134         int             pf_flags;
 135 };
 136
 137 /* pf_flags */
 138 #define PFF_ENABLED     0x0001          /* function is enabled */
 139
 140 struct pccard_card {
 141         int             cis1_major;
 142         int             cis1_minor;
 143         /* XXX waste of space? */
 144         char            cis1_info_buf[256];
 145         char            *cis1_info[4];
 146         /*
 147          * Use int32_t for manufacturer and product so that they can
 148          * hold the id value found in card CIS and special value that
 149          * indicates no id was found.
 150          */
 151         int32_t         manufacturer;
 152 #define PCCARD_VENDOR_INVALID   -1
 153         int32_t         product;
 154 #define PCCARD_PRODUCT_INVALID          -1
 155         u_int16_t       error;
 156 #define PCCARD_CIS_INVALID              { NULL, NULL, NULL, NULL }
 157         STAILQ_HEAD(, pccard_function) pf_head;
 158 };
 159
 160 #define PCCARD_MEM_ATTR         1
 161 #define PCCARD_MEM_COMMON       2
 162
 163 #define PCCARD_WIDTH_AUTO       0
 164 #define PCCARD_WIDTH_IO8        1
 165 #define PCCARD_WIDTH_IO16       2
 166
 167 /* More later? */
 168 struct pccard_ivar {
 169         struct resource_list resources;
 170         int     slotnum;
 171 };
 172
 173 struct pccard_softc {
 174         device_t                dev;
 175         /* this stuff is for the socket */
 176
 177         /* this stuff is for the card */
 178         struct pccard_card card;
 179         void            *ih;
 180         int             sc_enabled_count;       /* num functions enabled */
 181
 182 };
 183
 184 void
 185 pccardbus_if_setup(struct pccard_softc*);
 186
 187 struct pccard_cis_quirk {
 188         int32_t manufacturer;
 189         int32_t product;
 190         char *cis1_info[4];
 191         struct pccard_function *pf;
 192         struct pccard_config_entry *cfe;
 193 };
 194
 195 struct pccard_tuple {
 196         unsigned int    code;
 197         unsigned int    length;
 198         u_long          mult;
 199         bus_addr_t      ptr;
 200         bus_space_tag_t memt;
 201         bus_space_handle_t memh;
 202 };
 203
 204 void    pccard_read_cis(struct pccard_softc *);
 205 void    pccard_check_cis_quirks(device_t);
 206 void    pccard_print_cis(device_t);
 207 int     pccard_scan_cis(device_t,
 208                 int (*) (struct pccard_tuple *, void *), void *);
 209
 210 #define pccard_cis_read_1(tuple, idx0)                                  \
 211         (bus_space_read_1((tuple)->memt, (tuple)->memh, (tuple)->mult*(idx0)))
 212
 213 #define pccard_tuple_read_1(tuple, idx1)                                \
 214         (pccard_cis_read_1((tuple), ((tuple)->ptr+(2+(idx1)))))
 215
 216 #define pccard_tuple_read_2(tuple, idx2)                                \
 217         (pccard_tuple_read_1((tuple), (idx2)) |                         \
 218          (pccard_tuple_read_1((tuple), (idx2)+1)<<8))
 219
 220 #define pccard_tuple_read_3(tuple, idx3)                                \
 221         (pccard_tuple_read_1((tuple), (idx3)) |                         \
 222          (pccard_tuple_read_1((tuple), (idx3)+1)<<8) |                  \
 223          (pccard_tuple_read_1((tuple), (idx3)+2)<<16))
 224
 225 #define pccard_tuple_read_4(tuple, idx4)                                \
 226         (pccard_tuple_read_1((tuple), (idx4)) |                         \
 227          (pccard_tuple_read_1((tuple), (idx4)+1)<<8) |                  \
 228          (pccard_tuple_read_1((tuple), (idx4)+2)<<16) |                 \
 229          (pccard_tuple_read_1((tuple), (idx4)+3)<<24))
 230
 231 #define pccard_tuple_read_n(tuple, n, idxn)                             \
 232         (((n)==1)?pccard_tuple_read_1((tuple), (idxn)) :                \
 233          (((n)==2)?pccard_tuple_read_2((tuple), (idxn)) :               \
 234           (((n)==3)?pccard_tuple_read_3((tuple), (idxn)) :              \
 235            /* n == 4 */ pccard_tuple_read_4((tuple), (idxn)))))
 236
 237 #define PCCARD_SPACE_MEMORY     1
 238 #define PCCARD_SPACE_IO         2
 239
 240 int     pccard_ccr_read(struct pccard_function *, int);
 241 void    pccard_ccr_write(struct pccard_function *, int, int);
 242
 243 #define pccard_mfc(sc)  (STAILQ_FIRST(&(sc)->card.pf_head) &&           \
 244                  STAILQ_NEXT(STAILQ_FIRST(&(sc)->card.pf_head),pf_list))
 245
 246 void    pccard_function_init(struct pccard_function *,
 247             struct pccard_config_entry *);
 248 int     pccard_function_enable(struct pccard_function *);
 249 void    pccard_function_disable(struct pccard_function *);
 250
 251 #define pccard_io_alloc(pf, start, size, align, pciop)                  \
 252         (pccard_chip_io_alloc((pf)->sc->pct, pf->sc->pch, (start),      \
 253          (size), (align), (pciop)))
 254
 255 #define pccard_io_free(pf, pciohp)                                      \
 256         (pccard_chip_io_free((pf)->sc->pct, (pf)->sc->pch, (pciohp)))
 257
 258 int     pccard_io_map(struct pccard_function *, int, bus_addr_t,
 259             bus_size_t, struct pccard_io_handle *, int *);
 260 void    pccard_io_unmap(struct pccard_function *, int);
 261
 262 #define pccard_mem_alloc(pf, size, pcmhp)                               \
 263         (pccard_chip_mem_alloc((pf)->sc->pct, (pf)->sc->pch, (size), (pcmhp)))
 264
 265 #define pccard_mem_free(pf, pcmhp)                                      \
 266         (pccard_chip_mem_free((pf)->sc->pct, (pf)->sc->pch, (pcmhp)))
 267
 268 #define pccard_mem_map(pf, kind, card_addr, size, pcmhp, offsetp, windowp) \
 269         (pccard_chip_mem_map((pf)->sc->pct, (pf)->sc->pch, (kind),      \
 270          (card_addr), (size), (pcmhp), (offsetp), (windowp)))
 271
 272 #define pccard_mem_unmap(pf, window)                                    \
 273         (pccard_chip_mem_unmap((pf)->sc->pct, (pf)->sc->pch, (window)))
 274
 275 /* ivar interface */
 276 enum {
 277         PCCARD_IVAR_ETHADDR,    /* read ethernet address from CIS tupple */
 278         PCCARD_IVAR_VENDOR,
 279         PCCARD_IVAR_PRODUCT,
 280         PCCARD_IVAR_PRODEXT,
 281         PCCARD_IVAR_FUNCTION_NUMBER,
 282         PCCARD_IVAR_VENDOR_STR, /* CIS string for "Manufacturer" */
 283         PCCARD_IVAR_PRODUCT_STR,/* CIS strnig for "Product" */
 284         PCCARD_IVAR_CIS3_STR,
 285         PCCARD_IVAR_CIS4_STR,
 286         PCCARD_IVAR_FUNCTION
 287 };
 288
 289 /* read ethernet address from CIS tupple */
 290 __inline static int
 291 pccard_get_ether(device_t dev, u_char *enaddr)
 292 {
 293         return BUS_READ_IVAR(device_get_parent(dev), dev,
 294             PCCARD_IVAR_ETHADDR, (uintptr_t *)enaddr);
 295 }
 296
 297 /* shared memory flags */
 298 enum {
 299         PCCARD_A_MEM_ATTR=1,    /* attribute */
 300         PCCARD_A_MEM_COM,       /* common */
 301         PCCARD_A_MEM_8BIT,      /* 8 bit */
 302         PCCARD_A_MEM_16BIT      /* 16 bit */
 303 };