usr/src/uts/sparc/ml/sparc_ddi.s

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26 /*
  27  * Copyright 2012  Garrett D'Amore <garrett@damore.org>.  All rights reserved.
  28  */
  29
  30 /*
  31  * Assembler routines to make some DDI routines go faster.
  32  * These routines should ONLY be ISA-dependent.
  33  */
  34
  35 #if defined(lint)
  36
  37 #include <sys/types.h>
  38 #include <sys/systm.h>
  39 #include <sys/file.h>
  40 #include <sys/sunddi.h>
  41
  42 #else   /* lint */
  43
  44 #include <sys/asm_linkage.h>
  45 #include <sys/clock.h>
  46 #include <sys/intreg.h>
  47
  48 #include "assym.h"              /* for FKIOCTL etc. */
  49
  50 #endif  /* lint */
  51
  52
  53 /*
  54  * Layered driver routines.
  55  *
  56  * At the time of writing, the compiler converts
  57  *
  58  * a() { return (b()); }
  59  *
  60  * into
  61  *      save, call b, restore
  62  *
  63  * Though this is sort of ok, if the called routine is leaf routine,
  64  * then we just burnt a register window.
  65  *
  66  * When the compiler understands this optimization, many
  67  * of these routines can go back to C again.
  68  */
  69
  70 #define FLATCALL(routine)       \
  71         mov     %o7, %g1;       \
  72         call    routine;        \
  73         mov     %g1, %o7
  74
  75 #ifdef  lint
  76
  77 int
  78 ddi_copyin(const void *buf, void *kernbuf, size_t size, int flags)
  79 {
  80         if (flags & FKIOCTL)
  81                 return (kcopy(buf, kernbuf, size) ? -1 : 0);
  82         return (copyin(buf, kernbuf, size));
  83 }
  84
  85 #else   /* lint */
  86
  87         ENTRY(ddi_copyin)
  88         set     FKIOCTL, %o4
  89         andcc   %o3, %o4, %g0
  90         bne     .do_kcopy       ! share code with ddi_copyout
  91         FLATCALL(copyin)
  92         /*NOTREACHED*/
  93
  94 .do_kcopy:
  95         save    %sp, -SA(MINFRAME), %sp
  96         mov     %i2, %o2
  97         mov     %i1, %o1
  98         call    kcopy
  99         mov     %i0, %o0
 100         orcc    %g0, %o0, %i0   ! if kcopy returns EFAULT ..
 101         bne,a   1f
 102         mov     -1, %i0         ! .. we return -1
 103 1:      ret
 104         restore
 105         SET_SIZE(ddi_copyin)
 106
 107 #endif  /* lint */
 108
 109 #ifdef  lint
 110
 111 int
 112 ddi_copyout(const void *buf, void *kernbuf, size_t size, int flags)
 113 {
 114         if (flags & FKIOCTL)
 115                 return (kcopy(buf, kernbuf, size) ? -1 : 0);
 116         return (copyout(buf, kernbuf, size));
 117 }
 118
 119 #else   /* lint */
 120
 121         ENTRY(ddi_copyout)
 122         set     FKIOCTL, %o4
 123         andcc   %o3, %o4, %g0
 124         bne     .do_kcopy       ! share code with ddi_copyin
 125         FLATCALL(copyout)
 126         /*NOTREACHED*/
 127         SET_SIZE(ddi_copyout)
 128
 129 #endif  /* lint */
 130
 131 /*
 132  * DDI spine wrapper routines - here so as to not have to
 133  * buy register windows when climbing the device tree (which cost!)
 134  */
 135
 136 #if     defined(lint)
 137
 138 /*ARGSUSED*/
 139 int
 140 ddi_ctlops(dev_info_t *d, dev_info_t *r, ddi_ctl_enum_t op, void *a, void *v)
 141 {
 142         return (DDI_SUCCESS);
 143 }
 144
 145 #else   /* lint */
 146
 147         ENTRY(ddi_ctlops)
 148         tst     %o0             ! dip != 0?
 149         be,pn   %ncc, 2f        ! nope
 150         tst     %o1             ! rdip != 0?
 151         be,pn   %ncc, 2f        ! nope
 152         ldn     [%o0 + DEVI_BUS_CTL], %o0
 153                                 ! dip = (dev_info_t *)DEVI(dip)->devi_bus_ctl;
 154         brz,pn  %o0, 2f
 155         nop                     ! Delay slot
 156         ldn     [%o0 + DEVI_DEV_OPS], %g1       ! dip->dev_ops
 157         ldn     [%g1 + DEVI_BUS_OPS], %g1       ! dip->dev_ops->devo_bus_ops
 158         ldn     [%g1 + OPS_CTL], %g1    ! dip->dev_ops->devo_bus_ops->bus_ctl
 159         jmpl    %g1, %g0        ! bop off to new routine
 160         nop                     ! as if we had never been here
 161 2:      retl
 162         sub     %g0, 1, %o0     ! return (DDI_FAILURE);
 163         SET_SIZE(ddi_ctlops)
 164
 165 #endif  /* lint */
 166
 167 #if     defined(lint)
 168
 169 /* ARGSUSED */
 170 int
 171 ddi_dma_allochdl(dev_info_t *dip, dev_info_t *rdip, ddi_dma_attr_t *attr,
 172         int (*waitfp)(caddr_t), caddr_t arg, ddi_dma_handle_t *handlep)
 173 {
 174         return (DDI_SUCCESS);
 175 }
 176
 177 #else   /* lint */
 178
 179         ENTRY(ddi_dma_allochdl)
 180         ldn     [%o0 + DEVI_BUS_DMA_ALLOCHDL], %o0
 181                         ! dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_allochdl;
 182         ldn     [%o0 + DEVI_DEV_OPS], %g1       ! dip->dev_ops
 183         ldn     [%g1 + DEVI_BUS_OPS], %g1       ! dip->dev_ops->devo_bus_ops
 184         ldn     [%g1 + OPS_ALLOCHDL], %g1
 185                         ! dip->dev_ops->devo_bus_ops->bus_dma_allochdl
 186         jmpl    %g1, %g0        ! bop off to new routine
 187         nop                     ! as if we had never been here
 188         SET_SIZE(ddi_dma_allochdl)
 189
 190 #endif  /* lint */
 191
 192 #if     defined(lint)
 193
 194 /* ARGSUSED */
 195 int
 196 ddi_dma_freehdl(dev_info_t *dip, dev_info_t *rdip, ddi_dma_handle_t handlep)
 197 {
 198         return (DDI_SUCCESS);
 199 }
 200
 201 #else   /* lint */
 202
 203         ENTRY(ddi_dma_freehdl)
 204         ldn     [%o0 + DEVI_BUS_DMA_FREEHDL], %o0
 205                         ! dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_freehdl;
 206         ldn     [%o0 + DEVI_DEV_OPS], %g1       ! dip->dev_ops
 207         ldn     [%g1 + DEVI_BUS_OPS], %g1       ! dip->dev_ops->devo_bus_ops
 208         ldn     [%g1 + OPS_FREEHDL], %g1
 209                         ! dip->dev_ops->devo_bus_ops->bus_dma_freehdl
 210         jmpl    %g1, %g0        ! bop off to new routine
 211         nop                     ! as if we had never been here
 212         SET_SIZE(ddi_dma_freehdl)
 213
 214 #endif  /* lint */
 215
 216 #if     defined(lint)
 217
 218 /* ARGSUSED */
 219 int
 220 ddi_dma_bindhdl(dev_info_t *dip, dev_info_t *rdip,
 221         ddi_dma_handle_t handle, struct ddi_dma_req *dmareq,
 222         ddi_dma_cookie_t *cp, u_int *ccountp)
 223 {
 224         return (DDI_SUCCESS);
 225 }
 226
 227 #else   /* lint */
 228
 229         ENTRY(ddi_dma_bindhdl)
 230         ldn     [%o0 + DEVI_BUS_DMA_BINDHDL], %o0
 231                         ! dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_bindhdl;
 232         ldn     [%o0 + DEVI_DEV_OPS], %g1       ! dip->dev_ops
 233         ldn     [%g1 + DEVI_BUS_OPS], %g1       ! dip->dev_ops->devo_bus_ops
 234         ldn     [%g1 + OPS_BINDHDL], %g1
 235                         ! dip->dev_ops->devo_bus_ops->bus_dma_bindhdl
 236         jmpl    %g1, %g0        ! bop off to new routine
 237         nop                     ! as if we had never been here
 238         SET_SIZE(ddi_dma_bindhdl)
 239
 240 #endif  /* lint */
 241
 242 #if     defined(lint)
 243
 244 /* ARGSUSED */
 245 int
 246 ddi_dma_unbindhdl(dev_info_t *dip, dev_info_t *rdip,
 247         ddi_dma_handle_t handle)
 248 {
 249         return (DDI_SUCCESS);
 250 }
 251
 252 #else   /* lint */
 253
 254         ENTRY(ddi_dma_unbindhdl)
 255         ldn     [%o0 + DEVI_BUS_DMA_UNBINDHDL], %o0
 256                         ! dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_unbindhdl;
 257         ldn     [%o0 + DEVI_DEV_OPS], %g1       ! dip->dev_ops
 258         ldn     [%g1 + DEVI_BUS_OPS], %g1       ! dip->dev_ops->devo_bus_ops
 259         ldn     [%g1 + OPS_UNBINDHDL], %g1
 260                         ! dip->dev_ops->devo_bus_ops->bus_dma_unbindhdl
 261         jmpl    %g1, %g0        ! bop off to new routine
 262         nop                     ! as if we had never been here
 263         SET_SIZE(ddi_dma_unbindhdl)
 264
 265 #endif  /* lint */
 266
 267 #if     defined(lint)
 268
 269 /* ARGSUSED */
 270 int
 271 ddi_dma_flush(dev_info_t *dip, dev_info_t *rdip,
 272         ddi_dma_handle_t handle, off_t off, size_t len,
 273         u_int cache_flags)
 274 {
 275         return (DDI_SUCCESS);
 276 }
 277
 278 #else   /* lint */
 279
 280         ENTRY(ddi_dma_flush)
 281         ldn     [%o0 + DEVI_BUS_DMA_FLUSH], %o0
 282                         ! dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_flush;
 283         ldn     [%o0 + DEVI_DEV_OPS], %g1       ! dip->dev_ops
 284         ldn     [%g1 + DEVI_BUS_OPS], %g1       ! dip->dev_ops->devo_bus_ops
 285         ldn     [%g1 + OPS_FLUSH], %g1
 286                         ! dip->dev_ops->devo_bus_ops->bus_dma_flush
 287         jmpl    %g1, %g0        ! bop off to new routine
 288         nop                     ! as if we had never been here
 289         SET_SIZE(ddi_dma_flush)
 290
 291 #endif  /* lint */
 292
 293 #if     defined(lint)
 294
 295 /* ARGSUSED */
 296 int
 297 ddi_dma_win(dev_info_t *dip, dev_info_t *rdip,
 298         ddi_dma_handle_t handle, uint_t win, off_t *offp,
 299         size_t *lenp, ddi_dma_cookie_t *cookiep, uint_t *ccountp)
 300 {
 301         return (DDI_SUCCESS);
 302 }
 303
 304 #else   /* lint */
 305
 306         ENTRY(ddi_dma_win)
 307         ldn     [%o0 + DEVI_BUS_DMA_WIN], %o0
 308                         ! dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_win;
 309         ldn     [%o0 + DEVI_DEV_OPS], %g1       ! dip->dev_ops
 310         ldn     [%g1 + DEVI_BUS_OPS], %g1       ! dip->dev_ops->devo_bus_ops
 311         ldn     [%g1 + OPS_WIN], %g1
 312                         ! dip->dev_ops->devo_bus_ops->bus_dma_win
 313         jmpl    %g1, %g0        ! bop off to new routine
 314         nop                     ! as if we had never been here
 315         SET_SIZE(ddi_dma_win)
 316
 317 #endif  /* lint */
 318
 319 #if     defined(lint)
 320
 321 /* ARGSUSED */
 322 int
 323 ddi_dma_sync(ddi_dma_handle_t h, off_t o, size_t l, u_int whom)
 324 {
 325         return (DDI_SUCCESS);
 326 }
 327
 328 #else   /* lint */
 329
 330         ENTRY(ddi_dma_sync)
 331         ld      [%o0 + DMA_HANDLE_RFLAGS], %o4  ! hp->dmai_rflags;
 332         sethi   %hi(DMP_NOSYNC), %o5
 333         and     %o4, %o5, %o4
 334         cmp     %o4, %o5
 335         bne     1f
 336         mov     %o3, %o5
 337         retl
 338         clr     %o0
 339 1:      mov     %o1, %o3
 340         ldn     [%o0 + DMA_HANDLE_RDIP], %o1    ! dip = hp->dmai_rdip;
 341         mov     %o0, %g2
 342         ldn     [%o1 + DEVI_BUS_DMA_FLUSH], %o0
 343                         ! dip = DEVI(dip)->devi_bus_dma_flush;
 344         ldn     [%o0 + DEVI_DEV_OPS], %g1       ! dip->dev_ops
 345         mov     %o2, %o4
 346         ldn     [%g1 + DEVI_BUS_OPS], %g1       ! dip->dev_ops->devo_bus_ops
 347         mov     %g2, %o2
 348         ldn     [%g1 + OPS_FLUSH], %g1
 349                         ! dip->dev_ops->devo_bus_ops->bus_dma_flush
 350         jmpl    %g1, %g0        ! bop off to new routine
 351         nop                     ! as if we had never been here
 352         SET_SIZE(ddi_dma_sync)
 353
 354 #endif  /* lint */
 355
 356 #if     defined(lint)
 357
 358 /* ARGSUSED */
 359 int
 360 ddi_dma_unbind_handle(ddi_dma_handle_t h)
 361 {
 362         return (DDI_SUCCESS);
 363 }
 364
 365 #else   /* lint */
 366
 367         ENTRY(ddi_dma_unbind_handle)
 368         ldn     [%o0 + DMA_HANDLE_RDIP], %o1    ! dip = hp->dmai_rdip;
 369         mov     %o0, %o2
 370         ldn     [%o1 + DEVI_BUS_DMA_UNBINDFUNC ], %g1
 371                     ! funcp = DEVI(dip)->devi_bus_dma_unbindfunc;
 372         jmpl    %g1, %g0        ! bop off to new routine
 373         ldn     [%o1 + DEVI_BUS_DMA_UNBINDHDL], %o0
 374                     ! hdip = (dev_info_t *)DEVI(dip)->devi_bus_dma_unbindhdl;
 375         SET_SIZE(ddi_dma_unbind_handle)
 376
 377 #endif  /* lint */
 378
 379
 380 #if     defined(lint)
 381
 382 /*ARGSUSED*/
 383 int
 384 ddi_dma_mctl(register dev_info_t *dip, dev_info_t *rdip,
 385     ddi_dma_handle_t handle, enum ddi_dma_ctlops request,
 386     off_t *offp, size_t *lenp, caddr_t *objp, u_int flags)
 387 {
 388         return (DDI_SUCCESS);
 389 }
 390
 391 #else   /* lint */
 392
 393         ENTRY(ddi_dma_mctl)
 394         ldn     [%o0 + DEVI_BUS_DMA_CTL], %o0
 395                         ! dip = (dev_info_t *)DEVI(dip)->devi_bus_dma_ctl;
 396         ldn     [%o0 + DEVI_DEV_OPS], %g1       ! dip->dev_ops
 397         ldn     [%g1 + DEVI_BUS_OPS], %g1       ! dip->dev_ops->devo_bus_ops
 398         ldn     [%g1 + OPS_MCTL], %g1 ! dip->dev_ops->devo_bus_ops->bus_dma_ctl
 399         jmpl    %g1, %g0        ! bop off to new routine
 400         nop                     ! as if we had never been here
 401         SET_SIZE(ddi_dma_mctl)
 402
 403 #endif  /* lint */