sys/arm/xscale/pxa/pxa_space.c

   1 /*      $NetBSD: obio_space.c,v 1.6 2003/07/15 00:25:05 lukem Exp $     */
   2
   3 /*-
   4  * Copyright (c) 2001, 2002, 2003 Wasabi Systems, Inc.
   5  * All rights reserved.
   6  *
   7  * Written by Jason R. Thorpe for Wasabi Systems, Inc.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgement:
  19  *      This product includes software developed for the NetBSD Project by
  20  *      Wasabi Systems, Inc.
  21  * 4. The name of Wasabi Systems, Inc. may not be used to endorse
  22  *    or promote products derived from this software without specific prior
  23  *    written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  27  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  28  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASABI SYSTEMS, INC
  29  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  30  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  31  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  33  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  34  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  35  * POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38 /*
  39  * bus_space functions for PXA devices
  40  */
  41
  42 #include <sys/cdefs.h>
  43 __FBSDID("$FreeBSD$");
  44
  45 #include <sys/param.h>
  46 #include <sys/systm.h>
  47 #include <sys/bus.h>
  48 #include <sys/kernel.h>
  49 #include <sys/malloc.h>
  50
  51 #include <machine/bus.h>
  52
  53 #include <arm/xscale/pxa/pxareg.h>
  54 #include <arm/xscale/pxa/pxavar.h>
  55
  56 static MALLOC_DEFINE(M_PXATAG, "PXA bus_space tags", "Bus_space tags for PXA");
  57
  58 /* Prototypes for all the bus_space structure functions */
  59 bs_protos(generic);
  60 bs_protos(generic_armv4);
  61 bs_protos(pxa);
  62
  63 /*
  64  * The obio bus space tag.  This is constant for all instances, so
  65  * we never have to explicitly "create" it.
  66  */
  67 struct bus_space _base_tag = {
  68         /* cookie */
  69         (void *) 0,
  70
  71         /* mapping/unmapping */
  72         generic_bs_map,
  73         generic_bs_unmap,
  74         generic_bs_subregion,
  75
  76         /* allocation/deallocation */
  77         generic_bs_alloc,
  78         generic_bs_free,
  79
  80         /* barrier */
  81         generic_bs_barrier,
  82
  83         /* read (single) */
  84         pxa_bs_r_1,
  85         pxa_bs_r_2,
  86         pxa_bs_r_4,
  87         NULL,
  88
  89         /* read multiple */
  90         pxa_bs_rm_1,
  91         pxa_bs_rm_2,
  92         NULL,
  93         NULL,
  94
  95         /* read region */
  96         pxa_bs_rr_1,
  97         NULL,
  98         NULL,
  99         NULL,
 100
 101         /* write (single) */
 102         pxa_bs_w_1,
 103         pxa_bs_w_2,
 104         pxa_bs_w_4,
 105         NULL,
 106
 107         /* write multiple */
 108         pxa_bs_wm_1,
 109         pxa_bs_wm_2,
 110         NULL,
 111         NULL,
 112
 113         /* write region */
 114         NULL,
 115         NULL,
 116         NULL,
 117         NULL,
 118
 119         /* set multiple */
 120         NULL,
 121         NULL,
 122         NULL,
 123         NULL,
 124
 125         /* set region */
 126         NULL,
 127         NULL,
 128         NULL,
 129         NULL,
 130
 131         /* copy */
 132         NULL,
 133         NULL,
 134         NULL,
 135         NULL,
 136 };
 137
 138 static struct bus_space _obio_tag;
 139
 140 bus_space_tag_t         base_tag = &_base_tag;
 141 bus_space_tag_t         obio_tag = NULL;
 142
 143 void
 144 pxa_obio_tag_init()
 145 {
 146
 147         bcopy(&_base_tag, &_obio_tag, sizeof(struct bus_space));
 148         _obio_tag.bs_cookie = (void *)PXA2X0_PERIPH_OFFSET;
 149         obio_tag = &_obio_tag;
 150 }
 151
 152 bus_space_tag_t
 153 pxa_bus_tag_alloc(bus_addr_t offset)
 154 {
 155         struct  bus_space *tag;
 156
 157         tag = (struct bus_space *)malloc(sizeof(struct bus_space), M_PXATAG,
 158             M_WAITOK);
 159         if (tag == NULL) {
 160                 return (NULL);
 161         }
 162
 163         bcopy(&_base_tag, tag, sizeof(struct bus_space));
 164         tag->bs_cookie = (void *)offset;
 165
 166         return ((bus_space_tag_t)tag);
 167 }
 168
 169
 170 #define READ_SINGLE(type, proto, base)                                  \
 171         type                                                            \
 172         proto(void *cookie, bus_space_handle_t bsh, bus_size_t offset)  \
 173         {                                                               \
 174                 bus_addr_t      tag_offset;                             \
 175                 type            value;                                  \
 176                 tag_offset = (bus_addr_t)cookie;                        \
 177                 value = base(NULL, bsh + tag_offset, offset);           \
 178                 return (value);                                         \
 179         }
 180
 181 READ_SINGLE(u_int8_t,  pxa_bs_r_1, generic_bs_r_1)
 182 READ_SINGLE(u_int16_t, pxa_bs_r_2, generic_armv4_bs_r_2)
 183 READ_SINGLE(u_int32_t, pxa_bs_r_4, generic_bs_r_4)
 184
 185 #undef READ_SINGLE
 186
 187 #define WRITE_SINGLE(type, proto, base)                                 \
 188         void                                                            \
 189         proto(void *cookie, bus_space_handle_t bsh, bus_size_t offset,  \
 190             type value)                                                 \
 191         {                                                               \
 192                 bus_addr_t      tag_offset;                             \
 193                 tag_offset = (bus_addr_t)cookie;                        \
 194                 base(NULL, bsh + tag_offset, offset, value);            \
 195         }
 196
 197 WRITE_SINGLE(u_int8_t,  pxa_bs_w_1, generic_bs_w_1)
 198 WRITE_SINGLE(u_int16_t, pxa_bs_w_2, generic_armv4_bs_w_2)
 199 WRITE_SINGLE(u_int32_t, pxa_bs_w_4, generic_bs_w_4)
 200
 201 #undef WRITE_SINGLE
 202
 203 #define READ_MULTI(type, proto, base)                                   \
 204         void                                                            \
 205         proto(void *cookie, bus_space_handle_t bsh, bus_size_t offset,  \
 206             type *dest, bus_size_t count)                               \
 207         {                                                               \
 208                 bus_addr_t      tag_offset;                             \
 209                 tag_offset = (bus_addr_t)cookie;                        \
 210                 base(NULL, bsh + tag_offset, offset, dest, count);      \
 211         }
 212
 213 READ_MULTI(u_int8_t,  pxa_bs_rm_1, generic_bs_rm_1)
 214 READ_MULTI(u_int16_t, pxa_bs_rm_2, generic_armv4_bs_rm_2)
 215
 216 READ_MULTI(u_int8_t,  pxa_bs_rr_1, generic_bs_rr_1)
 217
 218 #undef READ_MULTI
 219
 220 #define WRITE_MULTI(type, proto, base)                                  \
 221         void                                                            \
 222         proto(void *cookie, bus_space_handle_t bsh, bus_size_t offset,  \
 223             const type *src, bus_size_t count)                          \
 224         {                                                               \
 225                 bus_addr_t      tag_offset;                             \
 226                 tag_offset = (bus_addr_t)cookie;                        \
 227                 base(NULL, bsh + tag_offset, offset, src, count);       \
 228         }
 229
 230 WRITE_MULTI(u_int8_t,  pxa_bs_wm_1, generic_bs_wm_1)
 231 WRITE_MULTI(u_int16_t, pxa_bs_wm_2, generic_armv4_bs_wm_2)
 232
 233 #undef WRITE_MULTI