sys/dev/pccard/pccardvar.h

   1 /*      $NetBSD: pcmciavar.h,v 1.9 1998/12/29 09:00:28 marc Exp $       */
   2 /* $FreeBSD$ */
   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 #include <dev/pccard/pccardchip.h>
  39
  40 extern int      pccard_verbose;
  41
  42 /*
  43  * Contains information about mapped/allocated i/o spaces.
  44  */
  45 struct pccard_io_handle {
  46         bus_space_tag_t iot;            /* bus space tag (from chipset) */
  47         bus_space_handle_t ioh;         /* mapped space handle */
  48         bus_addr_t      addr;           /* resulting address in bus space */
  49         bus_size_t      size;           /* size of i/o space */
  50         int             flags;          /* misc. information */
  51         int             width;
  52 };
  53
  54 #define PCCARD_IO_ALLOCATED     0x01    /* i/o space was allocated */
  55
  56 /*
  57  * Contains information about allocated memory space.
  58  */
  59 struct pccard_mem_handle {
  60         bus_space_tag_t memt;           /* bus space tag (from chipset) */
  61         bus_space_handle_t memh;        /* mapped space handle */
  62         bus_addr_t      addr;           /* resulting address in bus space */
  63         bus_size_t      size;           /* size of mem space */
  64         pccard_mem_handle_t mhandle;    /* opaque memory handle */
  65         bus_size_t      realsize;       /* how much we really allocated */
  66         long            offset;
  67         int             kind;
  68 };
  69
  70 /* pccard itself */
  71
  72 #define PCCARD_CFE_MWAIT_REQUIRED       0x0001
  73 #define PCCARD_CFE_RDYBSY_ACTIVE        0x0002
  74 #define PCCARD_CFE_WP_ACTIVE            0x0004
  75 #define PCCARD_CFE_BVD_ACTIVE           0x0008
  76 #define PCCARD_CFE_IO8                  0x0010
  77 #define PCCARD_CFE_IO16                 0x0020
  78 #define PCCARD_CFE_IRQSHARE             0x0040
  79 #define PCCARD_CFE_IRQPULSE             0x0080
  80 #define PCCARD_CFE_IRQLEVEL             0x0100
  81 #define PCCARD_CFE_POWERDOWN            0x0200
  82 #define PCCARD_CFE_READONLY             0x0400
  83 #define PCCARD_CFE_AUDIO                0x0800
  84
  85 struct pccard_config_entry {
  86         int             number;
  87         u_int32_t       flags;
  88         int             iftype;
  89         int             num_iospace;
  90
  91         /*
  92          * The card will only decode this mask in any case, so we can
  93          * do dynamic allocation with this in mind, in case the suggestions
  94          * below are no good.
  95          */
  96         u_long          iomask;
  97         struct {
  98                 u_long  length;
  99                 u_long  start;
 100         } iospace[4];           /* XXX this could be as high as 16 */
 101         u_int16_t       irqmask;
 102         int             num_memspace;
 103         struct {
 104                 u_long  length;
 105                 u_long  cardaddr;
 106                 u_long  hostaddr;
 107         } memspace[2];          /* XXX this could be as high as 8 */
 108         int             maxtwins;
 109         STAILQ_ENTRY(pccard_config_entry) cfe_list;
 110 };
 111
 112 struct pccard_function {
 113         /* read off the card */
 114         int             number;
 115         int             function;
 116         int             last_config_index;
 117         u_long          ccr_base;
 118         u_long          ccr_mask;
 119         struct resource *ccr_res;
 120         int             ccr_rid;
 121         STAILQ_HEAD(, pccard_config_entry) cfe_head;
 122         STAILQ_ENTRY(pccard_function) pf_list;
 123         /* run-time state */
 124         struct pccard_softc *sc;
 125         struct device *child;
 126         struct pccard_config_entry *cfe;
 127         struct pccard_mem_handle pf_pcmh;
 128 #define pf_ccrt         pf_pcmh.memt
 129 #define pf_ccrh         pf_pcmh.memh
 130 #define pf_ccr_mhandle  pf_pcmh.mhandle
 131 #define pf_ccr_realsize pf_pcmh.realsize
 132         bus_addr_t      pf_ccr_offset;
 133         int             pf_ccr_window;
 134         long            pf_mfc_iobase;
 135         long            pf_mfc_iomax;
 136         int             (*ih_fct)(void *);
 137         void            *ih_arg;
 138         int             ih_ipl;
 139         int             pf_flags;
 140 };
 141
 142 /* pf_flags */
 143 #define PFF_ENABLED     0x0001          /* function is enabled */
 144
 145 struct pccard_card {
 146         int             cis1_major;
 147         int             cis1_minor;
 148         /* XXX waste of space? */
 149         char            cis1_info_buf[256];
 150         char            *cis1_info[4];
 151         /*
 152          * Use int32_t for manufacturer and product so that they can
 153          * hold the id value found in card CIS and special value that
 154          * indicates no id was found.
 155          */
 156         int32_t         manufacturer;
 157 #define PCCARD_VENDOR_INVALID   -1
 158         int32_t         product;
 159 #define PCCARD_PRODUCT_INVALID          -1
 160         u_int16_t       error;
 161 #define PCCARD_CIS_INVALID              { NULL, NULL, NULL, NULL }
 162         STAILQ_HEAD(, pccard_function) pf_head;
 163 };
 164
 165 /* More later? */
 166 struct pccard_ivar {
 167         struct resource_list resources;
 168         int     slotnum;
 169 };
 170
 171 struct pccard_softc {
 172         device_t                dev;
 173         /* this stuff is for the socket */
 174
 175         /* this stuff is for the card */
 176         struct pccard_card card;
 177         void            *ih;
 178         int             sc_enabled_count;       /* num functions enabled */
 179
 180 };
 181
 182 void
 183 pccardbus_if_setup(struct pccard_softc*);
 184
 185 struct pccard_cis_quirk {
 186         int32_t manufacturer;
 187         int32_t product;
 188         char *cis1_info[4];
 189         struct pccard_function *pf;
 190         struct pccard_config_entry *cfe;
 191 };
 192
 193 struct pccard_tuple {
 194         unsigned int    code;
 195         unsigned int    length;
 196         u_long          mult;
 197         bus_addr_t      ptr;
 198         bus_space_tag_t memt;
 199         bus_space_handle_t memh;
 200 };
 201
 202 void    pccard_read_cis(struct pccard_softc *);
 203 void    pccard_check_cis_quirks(device_t);
 204 void    pccard_print_cis(device_t);
 205 int     pccard_scan_cis(struct device * dev,
 206             int (*) (struct pccard_tuple *, void *), void *);
 207
 208 #define pccard_cis_read_1(tuple, idx0)                                  \
 209         (bus_space_read_1((tuple)->memt, (tuple)->memh, (tuple)->mult*(idx0)))
 210
 211 #define pccard_tuple_read_1(tuple, idx1)                                \
 212         (pccard_cis_read_1((tuple), ((tuple)->ptr+(2+(idx1)))))
 213
 214 #define pccard_tuple_read_2(tuple, idx2)                                \
 215         (pccard_tuple_read_1((tuple), (idx2)) |                         \
 216          (pccard_tuple_read_1((tuple), (idx2)+1)<<8))
 217
 218 #define pccard_tuple_read_3(tuple, idx3)                                \
 219         (pccard_tuple_read_1((tuple), (idx3)) |                         \
 220          (pccard_tuple_read_1((tuple), (idx3)+1)<<8) |                  \
 221          (pccard_tuple_read_1((tuple), (idx3)+2)<<16))
 222
 223 #define pccard_tuple_read_4(tuple, idx4)                                \
 224         (pccard_tuple_read_1((tuple), (idx4)) |                         \
 225          (pccard_tuple_read_1((tuple), (idx4)+1)<<8) |                  \
 226          (pccard_tuple_read_1((tuple), (idx4)+2)<<16) |                 \
 227          (pccard_tuple_read_1((tuple), (idx4)+3)<<24))
 228
 229 #define pccard_tuple_read_n(tuple, n, idxn)                             \
 230         (((n)==1)?pccard_tuple_read_1((tuple), (idxn)) :                \
 231          (((n)==2)?pccard_tuple_read_2((tuple), (idxn)) :               \
 232           (((n)==3)?pccard_tuple_read_3((tuple), (idxn)) :              \
 233            /* n == 4 */ pccard_tuple_read_4((tuple), (idxn)))))
 234
 235 #define PCCARD_SPACE_MEMORY     1
 236 #define PCCARD_SPACE_IO         2
 237
 238 int     pccard_ccr_read(struct pccard_function *, int);
 239 void    pccard_ccr_write(struct pccard_function *, int, int);
 240
 241 #define pccard_mfc(sc)  (STAILQ_FIRST(&(sc)->card.pf_head) &&           \
 242                  STAILQ_NEXT(STAILQ_FIRST(&(sc)->card.pf_head),pf_list))
 243
 244 void    pccard_function_init(struct pccard_function *,
 245             struct pccard_config_entry *);
 246 int     pccard_function_enable(struct pccard_function *);
 247 void    pccard_function_disable(struct pccard_function *);
 248
 249 #define pccard_io_alloc(pf, start, size, align, pciop)                  \
 250         (pccard_chip_io_alloc((pf)->sc->pct, pf->sc->pch, (start),      \
 251          (size), (align), (pciop)))
 252
 253 #define pccard_io_free(pf, pciohp)                                      \
 254         (pccard_chip_io_free((pf)->sc->pct, (pf)->sc->pch, (pciohp)))
 255
 256 int     pccard_io_map(struct pccard_function *, int, bus_addr_t,
 257             bus_size_t, struct pccard_io_handle *, int *);
 258 void    pccard_io_unmap(struct pccard_function *, int);
 259
 260 #define pccard_mem_alloc(pf, size, pcmhp)                               \
 261         (pccard_chip_mem_alloc((pf)->sc->pct, (pf)->sc->pch, (size), (pcmhp)))
 262
 263 #define pccard_mem_free(pf, pcmhp)                                      \
 264         (pccard_chip_mem_free((pf)->sc->pct, (pf)->sc->pch, (pcmhp)))
 265
 266 #define pccard_mem_map(pf, kind, card_addr, size, pcmhp, offsetp, windowp) \
 267         (pccard_chip_mem_map((pf)->sc->pct, (pf)->sc->pch, (kind),      \
 268          (card_addr), (size), (pcmhp), (offsetp), (windowp)))
 269
 270 #define pccard_mem_unmap(pf, window)                                    \
 271         (pccard_chip_mem_unmap((pf)->sc->pct, (pf)->sc->pch, (window)))