ld_sdmmc.c revision 1.4.2.1
1 /* $NetBSD: ld_sdmmc.c,v 1.4.2.1 2010/10/22 07:22:15 uebayasi Exp $ */ 2 3 /* 4 * Copyright (c) 2008 KIYOHARA Takashi 5 * 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 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 20 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 22 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 24 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 25 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 * 28 */ 29 30 #include <sys/cdefs.h> 31 __KERNEL_RCSID(0, "$NetBSD: ld_sdmmc.c,v 1.4.2.1 2010/10/22 07:22:15 uebayasi Exp $"); 32 33 #include "rnd.h" 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/kernel.h> 38 #include <sys/device.h> 39 #include <sys/buf.h> 40 #include <sys/bufq.h> 41 #include <sys/bus.h> 42 #include <sys/callout.h> 43 #include <sys/endian.h> 44 #include <sys/dkio.h> 45 #include <sys/disk.h> 46 #include <sys/kthread.h> 47 #if NRND > 0 48 #include <sys/rnd.h> 49 #endif 50 51 #include <uvm/uvm_extern.h> 52 53 #include <dev/ldvar.h> 54 55 #include <dev/sdmmc/sdmmcvar.h> 56 57 #ifdef SDMMC_DEBUG 58 #define DPRINTF(s) printf s 59 #else 60 #define DPRINTF(s) /**/ 61 #endif 62 63 struct ld_sdmmc_softc; 64 65 struct ld_sdmmc_task { 66 struct sdmmc_task task; 67 68 struct ld_sdmmc_softc *task_sc; 69 struct buf *task_bp; 70 callout_t task_callout; 71 }; 72 73 struct ld_sdmmc_softc { 74 struct ld_softc sc_ld; 75 int sc_hwunit; 76 77 struct sdmmc_function *sc_sf; 78 struct ld_sdmmc_task sc_task; 79 }; 80 81 static int ld_sdmmc_match(device_t, cfdata_t, void *); 82 static void ld_sdmmc_attach(device_t, device_t, void *); 83 static int ld_sdmmc_detach(device_t, int); 84 85 static int ld_sdmmc_dump(struct ld_softc *, void *, int, int); 86 static int ld_sdmmc_start(struct ld_softc *, struct buf *); 87 88 static void ld_sdmmc_doattach(void *); 89 static void ld_sdmmc_dobio(void *); 90 static void ld_sdmmc_timeout(void *); 91 92 CFATTACH_DECL_NEW(ld_sdmmc, sizeof(struct ld_sdmmc_softc), 93 ld_sdmmc_match, ld_sdmmc_attach, ld_sdmmc_detach, NULL); 94 95 96 /* ARGSUSED */ 97 static int 98 ld_sdmmc_match(device_t parent, cfdata_t match, void *aux) 99 { 100 struct sdmmc_softc *sdmsc = device_private(parent); 101 102 if (ISSET(sdmsc->sc_flags, SMF_MEM_MODE)) 103 return 1; 104 return 0; 105 } 106 107 /* ARGSUSED */ 108 static void 109 ld_sdmmc_attach(device_t parent, device_t self, void *aux) 110 { 111 struct ld_sdmmc_softc *sc = device_private(self); 112 struct sdmmc_attach_args *sa = aux; 113 struct ld_softc *ld = &sc->sc_ld; 114 struct lwp *lwp; 115 116 ld->sc_dv = self; 117 118 aprint_normal(": <%s>\n", sa->sf->cid.pnm); 119 aprint_naive("\n"); 120 121 callout_init(&sc->sc_task.task_callout, CALLOUT_MPSAFE); 122 123 sc->sc_hwunit = 0; /* always 0? */ 124 sc->sc_sf = sa->sf; 125 126 ld->sc_flags = LDF_ENABLED; 127 ld->sc_secperunit = sc->sc_sf->csd.capacity; 128 ld->sc_secsize = SDMMC_SECTOR_SIZE; 129 ld->sc_maxxfer = MAXPHYS; 130 ld->sc_maxqueuecnt = 1; 131 ld->sc_dump = ld_sdmmc_dump; 132 ld->sc_start = ld_sdmmc_start; 133 134 /* 135 * It is avoided that the error occurs when the card attaches it, 136 * when wedge is supported. 137 */ 138 if (kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL, 139 ld_sdmmc_doattach, sc, &lwp, "%sattach", device_xname(self))) { 140 aprint_error_dev(self, "couldn't create thread\n"); 141 } 142 } 143 144 static void 145 ld_sdmmc_doattach(void *arg) 146 { 147 struct ld_sdmmc_softc *sc = (struct ld_sdmmc_softc *)arg; 148 struct ld_softc *ld = &sc->sc_ld; 149 struct sdmmc_softc *ssc = device_private(device_parent(ld->sc_dv)); 150 151 ldattach(ld); 152 aprint_normal_dev(ld->sc_dv, "%d-bit width, bus clock", 153 sc->sc_sf->width); 154 if ((ssc->sc_busclk / 1000) != 0) 155 aprint_normal(" %u.%03u MHz\n", 156 ssc->sc_busclk / 1000, ssc->sc_busclk % 1000); 157 else 158 aprint_normal(" %u KHz\n", ssc->sc_busclk % 1000); 159 kthread_exit(0); 160 } 161 162 static int 163 ld_sdmmc_detach(device_t dev, int flags) 164 { 165 struct ld_sdmmc_softc *sc = device_private(dev); 166 struct ld_softc *ld = &sc->sc_ld; 167 int rv; 168 169 if ((rv = ldbegindetach(ld, flags)) != 0) 170 return rv; 171 ldenddetach(ld); 172 173 return 0; 174 } 175 176 static int 177 ld_sdmmc_start(struct ld_softc *ld, struct buf *bp) 178 { 179 struct ld_sdmmc_softc *sc = device_private(ld->sc_dv); 180 struct ld_sdmmc_task *task = &sc->sc_task; 181 182 task->task_sc = sc; 183 task->task_bp = bp; 184 sdmmc_init_task(&task->task, ld_sdmmc_dobio, task); 185 186 callout_reset(&task->task_callout, hz, ld_sdmmc_timeout, task); 187 sdmmc_add_task(sc->sc_sf->sc, &task->task); 188 189 return 0; 190 } 191 192 static void 193 ld_sdmmc_dobio(void *arg) 194 { 195 struct ld_sdmmc_task *task = (struct ld_sdmmc_task *)arg; 196 struct ld_sdmmc_softc *sc = task->task_sc; 197 struct buf *bp = task->task_bp; 198 int error, s; 199 200 callout_stop(&task->task_callout); 201 202 /* 203 * I/O operation 204 */ 205 DPRINTF(("%s: I/O operation (dir=%s, blkno=0x%jx, bcnt=0x%x)\n", 206 device_xname(sc->sc_ld.sc_dv), bp->b_flags & B_READ ? "IN" : "OUT", 207 bp->b_rawblkno, bp->b_bcount)); 208 209 /* is everything done in terms of blocks? */ 210 if (bp->b_rawblkno >= sc->sc_sf->csd.capacity) { 211 /* trying to read or write past end of device */ 212 DPRINTF(("%s: blkno exceeds capacity 0x%x\n", 213 device_xname(sc->sc_ld.sc_dv), sc->sc_sf->csd.capacity)); 214 bp->b_error = EIO; /* XXX */ 215 bp->b_resid = bp->b_bcount; 216 lddone(&sc->sc_ld, bp); 217 return; 218 } 219 220 s = splbio(); 221 if (bp->b_flags & B_READ) 222 error = sdmmc_mem_read_block(sc->sc_sf, bp->b_rawblkno, 223 bp->b_data, bp->b_bcount); 224 else 225 error = sdmmc_mem_write_block(sc->sc_sf, bp->b_rawblkno, 226 bp->b_data, bp->b_bcount); 227 if (error) { 228 DPRINTF(("%s: error %d\n", device_xname(sc->sc_ld.sc_dv), 229 error)); 230 bp->b_error = EIO; /* XXXX */ 231 bp->b_resid = bp->b_bcount; 232 } else { 233 bp->b_resid = 0; 234 } 235 splx(s); 236 237 lddone(&sc->sc_ld, bp); 238 } 239 240 static void 241 ld_sdmmc_timeout(void *arg) 242 { 243 struct ld_sdmmc_task *task = (struct ld_sdmmc_task *)arg; 244 struct ld_sdmmc_softc *sc = task->task_sc; 245 struct buf *bp = task->task_bp; 246 int s; 247 248 s = splbio(); 249 if (!sdmmc_task_pending(&task->task)) { 250 splx(s); 251 return; 252 } 253 bp->b_error = EIO; /* XXXX */ 254 bp->b_resid = bp->b_bcount; 255 sdmmc_del_task(&task->task); 256 splx(s); 257 258 lddone(&sc->sc_ld, bp); 259 } 260 261 static int 262 ld_sdmmc_dump(struct ld_softc *ld, void *data, int blkno, int blkcnt) 263 { 264 struct ld_sdmmc_softc *sc = device_private(ld->sc_dv); 265 266 return sdmmc_mem_write_block(sc->sc_sf, blkno, data, 267 blkcnt * ld->sc_secsize); 268 } 269
Indexes created Wed Oct 22 06:10:02 GMT 2025