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         STAILQ_HEAD(, pccard_config_entry) cfe_head;
 120         STAILQ_ENTRY(pccard_function) pf_list;
 121         /* run-time state */
 122         struct pccard_softc *sc;
 123         struct device *child;
 124         struct pccard_config_entry *cfe;
 125         struct pccard_mem_handle pf_pcmh;
 126 #define pf_ccrt         pf_pcmh.memt
 127 #define pf_ccrh         pf_pcmh.memh
 128 #define pf_ccr_mhandle  pf_pcmh.mhandle
 129 #define pf_ccr_realsize pf_pcmh.realsize
 130         bus_addr_t      pf_ccr_offset;
 131         int             pf_ccr_window;
 132         long            pf_mfc_iobase;
 133         long            pf_mfc_iomax;
 134         int             (*ih_fct)(void *);
 135         void            *ih_arg;
 136         int             ih_ipl;
 137         int             pf_flags;
 138 };
 139
 140 /* pf_flags */
 141 #define PFF_ENABLED     0x0001          /* function is enabled */
 142
 143 struct pccard_card {
 144         int             cis1_major;
 145         int             cis1_minor;
 146         /* XXX waste of space? */
 147         char            cis1_info_buf[256];
 148         char            *cis1_info[4];
 149         /*
 150          * Use int32_t for manufacturer and product so that they can
 151          * hold the id value found in card CIS and special value that
 152          * indicates no id was found.
 153          */
 154         int32_t         manufacturer;
 155 #define PCCARD_VENDOR_INVALID   -1
 156         int32_t         product;
 157 #define PCCARD_PRODUCT_INVALID          -1
 158         u_int16_t       error;
 159 #define PCCARD_CIS_INVALID              { NULL, NULL, NULL, NULL }
 160         STAILQ_HEAD(, pccard_function) pf_head;
 161 };
 162
 163 /* More later? */
 164 struct pccard_ivar {
 165         struct resource_list resources;
 166         int     slotnum;
 167 };
 168
 169 struct pccard_softc {
 170
 171         /* this stuff is for the socket */
 172         pccard_chipset_tag_t pct;
 173         pccard_chipset_handle_t pch;
 174
 175         /* this stuff is for the card */
 176         struct pccard_card card;
 177         void            *ih;
 178         int             sc_enabled_count;       /* how many functions are
 179                                                    enabled */
 180
 181         /*
 182          * These are passed down from the PCCARD chip, and exist only
 183          * so that cards with Very Special address allocation needs
 184          * know what range they should be dealing with.
 185          */
 186         bus_addr_t iobase;              /* start i/o space allocation here */
 187         bus_size_t iosize;              /* size of the i/o space range */
 188 };
 189
 190 void
 191 pccardbus_if_setup(struct pccard_softc*);
 192
 193 struct pccard_cis_quirk {
 194         int32_t manufacturer;
 195         int32_t product;
 196         char *cis1_info[4];
 197         struct pccard_function *pf;
 198         struct pccard_config_entry *cfe;
 199 };
 200
 201 struct pccard_attach_args {
 202         int32_t manufacturer;
 203         int32_t product;
 204         struct pccard_card *card;
 205         struct pccard_function *pf;
 206 };
 207
 208 struct pccard_tuple {
 209         unsigned int    code;
 210         unsigned int    length;
 211         u_long          mult;
 212         bus_addr_t      ptr;
 213         bus_space_tag_t memt;
 214         bus_space_handle_t memh;
 215 };
 216
 217 void    pccard_read_cis(struct pccard_softc *);
 218 void    pccard_check_cis_quirks(device_t);
 219 void    pccard_print_cis(device_t);
 220 int     pccard_scan_cis(struct device * dev,
 221             int (*) (struct pccard_tuple *, void *), void *);
 222
 223 #define pccard_cis_read_1(tuple, idx0)                                  \
 224         (bus_space_read_1((tuple)->memt, (tuple)->memh, (tuple)->mult*(idx0)))
 225
 226 #define pccard_tuple_read_1(tuple, idx1)                                \
 227         (pccard_cis_read_1((tuple), ((tuple)->ptr+(2+(idx1)))))
 228
 229 #define pccard_tuple_read_2(tuple, idx2)                                \
 230         (pccard_tuple_read_1((tuple), (idx2)) |                         \
 231          (pccard_tuple_read_1((tuple), (idx2)+1)<<8))
 232
 233 #define pccard_tuple_read_3(tuple, idx3)                                \
 234         (pccard_tuple_read_1((tuple), (idx3)) |                         \
 235          (pccard_tuple_read_1((tuple), (idx3)+1)<<8) |                  \
 236          (pccard_tuple_read_1((tuple), (idx3)+2)<<16))
 237
 238 #define pccard_tuple_read_4(tuple, idx4)                                \
 239         (pccard_tuple_read_1((tuple), (idx4)) |                         \
 240          (pccard_tuple_read_1((tuple), (idx4)+1)<<8) |                  \
 241          (pccard_tuple_read_1((tuple), (idx4)+2)<<16) |                 \
 242          (pccard_tuple_read_1((tuple), (idx4)+3)<<24))
 243
 244 #define pccard_tuple_read_n(tuple, n, idxn)                             \
 245         (((n)==1)?pccard_tuple_read_1((tuple), (idxn)) :                \
 246          (((n)==2)?pccard_tuple_read_2((tuple), (idxn)) :               \
 247           (((n)==3)?pccard_tuple_read_3((tuple), (idxn)) :              \
 248            /* n == 4 */ pccard_tuple_read_4((tuple), (idxn)))))
 249
 250 #define PCCARD_SPACE_MEMORY     1
 251 #define PCCARD_SPACE_IO         2
 252
 253 int     pccard_ccr_read(struct pccard_function *, int);
 254 void    pccard_ccr_write(struct pccard_function *, int, int);
 255
 256 #define pccard_mfc(sc)  (STAILQ_FIRST(&(sc)->card.pf_head) &&           \
 257                  STAILQ_NEXT(STAILQ_FIRST(&(sc)->card.pf_head),pf_list))
 258
 259 void    pccard_function_init(struct pccard_function *,
 260             struct pccard_config_entry *);
 261 int     pccard_function_enable(struct pccard_function *);
 262 void    pccard_function_disable(struct pccard_function *);
 263
 264 #define pccard_io_alloc(pf, start, size, align, pciop)                  \
 265         (pccard_chip_io_alloc((pf)->sc->pct, pf->sc->pch, (start),      \
 266          (size), (align), (pciop)))
 267
 268 #define pccard_io_free(pf, pciohp)                                      \
 269         (pccard_chip_io_free((pf)->sc->pct, (pf)->sc->pch, (pciohp)))
 270
 271 int     pccard_io_map(struct pccard_function *, int, bus_addr_t,
 272             bus_size_t, struct pccard_io_handle *, int *);
 273 void    pccard_io_unmap(struct pccard_function *, int);
 274
 275 #define pccard_mem_alloc(pf, size, pcmhp)                               \
 276         (pccard_chip_mem_alloc((pf)->sc->pct, (pf)->sc->pch, (size), (pcmhp)))
 277
 278 #define pccard_mem_free(pf, pcmhp)                                      \
 279         (pccard_chip_mem_free((pf)->sc->pct, (pf)->sc->pch, (pcmhp)))
 280
 281 #define pccard_mem_map(pf, kind, card_addr, size, pcmhp, offsetp, windowp) \
 282         (pccard_chip_mem_map((pf)->sc->pct, (pf)->sc->pch, (kind),      \
 283          (card_addr), (size), (pcmhp), (offsetp), (windowp)))
 284
 285 #define pccard_mem_unmap(pf, window)                                    \
 286         (pccard_chip_mem_unmap((pf)->sc->pct, (pf)->sc->pch, (window)))
 287
 288 void    *pccard_intr_establish(struct pccard_function *, int,
 289             int (*) (void *), void *);
 290 void    pccard_intr_disestablish(struct pccard_function *, void *);