sys/dev/sdio/sdio_subr.c

   1 /*-
   2  * Copyright (c) 2017 Ilya Bakulin.  All rights reserved.
   3  * Copyright (c) 2018-2019 The FreeBSD Foundation
   4  *
   5  * Portions of this software were developed by Björn Zeeb
   6  * under sponsorship from the FreeBSD Foundation.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  *
  29  * Portions of this software may have been developed with reference to
  30  * the SD Simplified Specification.  The following disclaimer may apply:
  31  *
  32  * The following conditions apply to the release of the simplified
  33  * specification ("Simplified Specification") by the SD Card Association and
  34  * the SD Group. The Simplified Specification is a subset of the complete SD
  35  * Specification which is owned by the SD Card Association and the SD
  36  * Group. This Simplified Specification is provided on a non-confidential
  37  * basis subject to the disclaimers below. Any implementation of the
  38  * Simplified Specification may require a license from the SD Card
  39  * Association, SD Group, SD-3C LLC or other third parties.
  40  *
  41  * Disclaimers:
  42  *
  43  * The information contained in the Simplified Specification is presented only
  44  * as a standard specification for SD Cards and SD Host/Ancillary products and
  45  * is provided "AS-IS" without any representations or warranties of any
  46  * kind. No responsibility is assumed by the SD Group, SD-3C LLC or the SD
  47  * Card Association for any damages, any infringements of patents or other
  48  * right of the SD Group, SD-3C LLC, the SD Card Association or any third
  49  * parties, which may result from its use. No license is granted by
  50  * implication, estoppel or otherwise under any patent or other rights of the
  51  * SD Group, SD-3C LLC, the SD Card Association or any third party. Nothing
  52  * herein shall be construed as an obligation by the SD Group, the SD-3C LLC
  53  * or the SD Card Association to disclose or distribute any technical
  54  * information, know-how or other confidential information to any third party.
  55  */
  56
  57 #include <sys/cdefs.h>
  58 __FBSDID("$FreeBSD$");
  59
  60 #include <sys/types.h>
  61 #include <sys/param.h>
  62 #include <sys/kernel.h>
  63 #include <sys/systm.h>
  64 #include <sys/bus.h>
  65 #include <sys/endian.h>
  66
  67 #include <dev/mmc/mmcreg.h>
  68
  69 #include <dev/sdio/sdiob.h>
  70 #include <dev/sdio/sdio_subr.h>
  71
  72 #include "sdio_if.h"
  73
  74 /* Works on F0. */
  75 static int
  76 sdio_set_bool_for_func(device_t dev, uint32_t addr, uint8_t fn, bool enable)
  77 {
  78         device_t pdev;
  79         int error;
  80         uint8_t val;
  81         bool enabled;
  82
  83         pdev = device_get_parent(dev);
  84         error = SDIO_READ_DIRECT(pdev, 0, addr, &val);
  85         if (error != 0)
  86                 return (error);
  87
  88         enabled = (val & (1 << fn)) ? true : false;
  89         if (enabled == enable)
  90                 return (0);
  91
  92         if (enable)
  93                 val |= (1 << fn);
  94         else
  95                 val &= ~(1 << fn);
  96         error = SDIO_WRITE_DIRECT(pdev, 0, addr, val);
  97         return (error);
  98 }
  99
 100 int
 101 sdio_enable_func(struct sdio_func *f)
 102 {
 103
 104         return (sdio_set_bool_for_func(f->dev, SD_IO_CCCR_FN_ENABLE,
 105             f->fn, true));
 106 }
 107
 108 int
 109 sdio_disable_func(struct sdio_func *f)
 110 {
 111
 112         return (sdio_set_bool_for_func(f->dev, SD_IO_CCCR_FN_ENABLE,
 113             f->fn, false));
 114 }
 115
 116 int
 117 sdio_set_block_size(struct sdio_func *f, uint16_t bs)
 118 {
 119         device_t pdev;
 120         int error;
 121         uint32_t addr;
 122         uint16_t v;
 123
 124         if (!sdio_get_support_multiblk(f->dev))
 125                 return (EOPNOTSUPP);
 126
 127         pdev = device_get_parent(f->dev);
 128         addr = SD_IO_FBR_START * f->fn + SD_IO_FBR_IOBLKSZ;
 129         v = htole16(bs);
 130         /* Always write through F0. */
 131         error = SDIO_WRITE_DIRECT(pdev, 0, addr, v & 0xff);
 132         if (error == 0)
 133                 error = SDIO_WRITE_DIRECT(pdev, 0, addr + 1,
 134                     (v >> 8) & 0xff);
 135         if (error == 0)
 136                 f->cur_blksize = bs;
 137
 138         return (error);
 139 }
 140
 141 uint8_t
 142 sdio_readb(struct sdio_func *f, uint32_t addr, int *err)
 143 {
 144         int error;
 145         uint8_t v;
 146
 147         error = SDIO_READ_DIRECT(device_get_parent(f->dev), f->fn, addr, &v);
 148         if (error) {
 149                 if (err != NULL)
 150                         *err = error;
 151                 return (0xff);
 152         } else {
 153                 if (err != NULL)
 154                         *err = 0;
 155                 return (v);
 156         }
 157 }
 158
 159 void
 160 sdio_writeb(struct sdio_func *f, uint8_t val, uint32_t addr, int *err)
 161 {
 162         int error;
 163
 164         error = SDIO_WRITE_DIRECT(device_get_parent(f->dev), f->fn, addr, val);
 165         if (err != NULL)
 166                 *err = error;
 167 }
 168
 169 uint32_t
 170 sdio_readl(struct sdio_func *f, uint32_t addr, int *err)
 171 {
 172         int error;
 173         uint32_t v;
 174
 175         error = SDIO_READ_EXTENDED(device_get_parent(f->dev), f->fn, addr,
 176             sizeof(v), (uint8_t *)&v, false);
 177         if (error) {
 178                 if (err != NULL)
 179                         *err = error;
 180                 return (0xffffffff);
 181         } else {
 182                 if (err != NULL)
 183                         *err = 0;
 184                 return (le32toh(v));
 185         }
 186 }
 187
 188 void
 189 sdio_writel(struct sdio_func *f, uint32_t val, uint32_t addr, int *err)
 190 {
 191         int error;
 192
 193         error = SDIO_WRITE_EXTENDED(device_get_parent(f->dev), f->fn, addr,
 194             sizeof(val), (uint8_t *)&val, false);
 195         if (err != NULL)
 196                 *err = error;
 197 }
 198
 199 uint8_t
 200 sdio_f0_readb(struct sdio_func *f, uint32_t addr, int *err)
 201 {
 202         int error;
 203         uint8_t v;
 204
 205         error = SDIO_READ_DIRECT(device_get_parent(f->dev), 0, addr, &v);
 206         if (error) {
 207                 if (err != NULL)
 208                         *err = error;
 209                 return (0xff);
 210         } else {
 211                 if (err != NULL)
 212                         *err = 0;
 213                 return (v);
 214         }
 215 }
 216
 217 void
 218 sdio_f0_writeb(struct sdio_func *f, uint8_t val, uint32_t addr, int *err)
 219 {
 220         int error;
 221
 222         error = SDIO_WRITE_DIRECT(device_get_parent(f->dev), 0, addr, val);
 223         if (err != NULL)
 224                 *err = error;
 225 }
 226
 227 /* end */