1 /*-
2 * Copyright (c) 2012 Robert N. M. Watson
3 * All rights reserved.
4 *
5 * This software was developed by SRI International and the University of
6 * Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237)
7 * ("CTSRD"), as part of the DARPA CRASH research programme.
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 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 */
30
31 #include <sys/cdefs.h>
32 __FBSDID("$FreeBSD$");
33
34 #include "opt_altera_sdcard.h"
35
36 #include <sys/param.h>
37 #include <sys/bus.h>
38 #include <sys/condvar.h>
39 #include <sys/conf.h>
40 #include <sys/bio.h>
41 #include <sys/kernel.h>
42 #include <sys/lock.h>
43 #include <sys/malloc.h>
44 #include <sys/module.h>
45 #include <sys/mutex.h>
46 #include <sys/rman.h>
47 #include <sys/systm.h>
48 #include <sys/taskqueue.h>
49
50 #include <machine/bus.h>
51 #include <machine/resource.h>
52
53 #include <geom/geom_disk.h>
54
55 #include <dev/altera/sdcard/altera_sdcard.h>
56
57 /*
58 * Device driver for the Altera University Program Secure Data Card IP Core,
59 * as described in the similarly named SOPC Builder IP Core specification.
60 * This soft core is not a full SD host controller interface (SDHCI) but
61 * instead provides a set of memory mapped registers and memory buffer that
62 * mildly abstract the SD Card protocol, but without providing DMA or
63 * interrupts. However, it does hide the details of voltage and
64 * communications negotiation. This driver implements disk(9), but due to the
65 * lack of interrupt support, must rely on timer-driven polling to determine
66 * when I/Os have completed.
67 *
68 * TODO:
69 *
70 * 1. Implement DISKFLAG_CANDELETE / SD Card sector erase support.
71 * 2. Implement d_ident from SD Card CID serial number field.
72 * 3. Handle read-only SD Cards.
73 * 4. Tune timeouts based on real-world SD Card speeds.
74 */
75 devclass_t altera_sdcard_devclass;
76
77 void
78 altera_sdcard_attach(struct altera_sdcard_softc *sc)
79 {
80
81 ALTERA_SDCARD_LOCK_INIT(sc);
82 ALTERA_SDCARD_CONDVAR_INIT(sc);
83 sc->as_disk = NULL;
84 bioq_init(&sc->as_bioq);
85 sc->as_currentbio = NULL;
86 sc->as_state = ALTERA_SDCARD_STATE_NOCARD;
87 sc->as_taskqueue = taskqueue_create("altera_sdcardc taskq", M_WAITOK,
88 taskqueue_thread_enqueue, &sc->as_taskqueue);
89 taskqueue_start_threads(&sc->as_taskqueue, 1, PI_DISK,
90 "altera_sdcardc%d taskqueue", sc->as_unit);
91 TIMEOUT_TASK_INIT(sc->as_taskqueue, &sc->as_task, 0,
92 altera_sdcard_task, sc);
93
94 /*
95 * Kick off timer-driven processing with a manual poll so that we
96 * synchronously detect an already-inserted SD Card during the boot or
97 * other driver attach point.
98 */
99 altera_sdcard_task(sc, 1);
100 }
101
102 void
103 altera_sdcard_detach(struct altera_sdcard_softc *sc)
104 {
105
106 KASSERT(sc->as_taskqueue != NULL, ("%s: taskqueue not present",
107 __func__));
108
109 /*
110 * Winding down the driver on detach is a bit complex. Update the
111 * flags to indicate that a detach has been requested, and then wait
112 * for in-progress I/O to wind down before continuing.
113 */
114 ALTERA_SDCARD_LOCK(sc);
115 sc->as_flags |= ALTERA_SDCARD_FLAG_DETACHREQ;
116 while (sc->as_state != ALTERA_SDCARD_STATE_DETACHED)
117 ALTERA_SDCARD_CONDVAR_WAIT(sc);
118 ALTERA_SDCARD_UNLOCK(sc);
119
120 /*
121 * Now wait for the possibly still executing taskqueue to drain. In
122 * principle no more events will be scheduled as we've transitioned to
123 * a detached state, but there might still be a request in execution.
124 */
125 while (taskqueue_cancel_timeout(sc->as_taskqueue, &sc->as_task, NULL))
126 taskqueue_drain_timeout(sc->as_taskqueue, &sc->as_task);
127
128 /*
129 * Simulate a disk removal if one is present to deal with any pending
130 * or queued I/O.
131 */
132 if (sc->as_disk != NULL)
133 altera_sdcard_disk_remove(sc);
134 KASSERT(bioq_first(&sc->as_bioq) == NULL,
135 ("%s: non-empty bioq", __func__));
136
137 /*
138 * Free any remaining allocated resources.
139 */
140 taskqueue_free(sc->as_taskqueue);
141 sc->as_taskqueue = NULL;
142 ALTERA_SDCARD_CONDVAR_DESTROY(sc);
143 ALTERA_SDCARD_LOCK_DESTROY(sc);
144 }
145
146 /*
147 * Set up and start the next I/O. Transition to the I/O state, but allow the
148 * caller to schedule the next timeout, as this may be called either from an
149 * initial attach context, or from the task queue, which requires different
150 * behaviour.
151 */
152 static void
153 altera_sdcard_nextio(struct altera_sdcard_softc *sc)
154 {
155 struct bio *bp;
156
157 ALTERA_SDCARD_LOCK_ASSERT(sc);
158 KASSERT(sc->as_currentbio == NULL,
159 ("%s: bio already active", __func__));
160
161 bp = bioq_takefirst(&sc->as_bioq);
162 if (bp == NULL)
163 panic("%s: bioq empty", __func__);
164 altera_sdcard_io_start(sc, bp);
165 sc->as_state = ALTERA_SDCARD_STATE_IO;
166 }
167
168 static void
169 altera_sdcard_task_nocard(struct altera_sdcard_softc *sc)
170 {
171
172 ALTERA_SDCARD_LOCK_ASSERT(sc);
173
174 /*
175 * Handle device driver detach.
176 */
177 if (sc->as_flags & ALTERA_SDCARD_FLAG_DETACHREQ) {
178 sc->as_state = ALTERA_SDCARD_STATE_DETACHED;
179 return;
180 }
181
182 /*
183 * If there is no card insertion, remain in NOCARD.
184 */
185 if (!(altera_sdcard_read_asr(sc) & ALTERA_SDCARD_ASR_CARDPRESENT))
186 return;
187
188 /*
189 * Read the CSD -- it may contain values that the driver can't handle,
190 * either because of an unsupported version/feature, or because the
191 * card is misbehaving. This triggers a transition to
192 * ALTERA_SDCARD_STATE_BADCARD. We rely on the CSD read to print a
193 * banner about how the card is problematic, since it has more
194 * information. The bad card state allows us to print that banner
195 * once rather than each time we notice the card is there, and still
196 * bad.
197 */
198 if (altera_sdcard_read_csd(sc) != 0) {
199 sc->as_state = ALTERA_SDCARD_STATE_BADCARD;
200 return;
201 }
202
203 /*
204 * Process card insertion and upgrade to the IDLE state.
205 */
206 altera_sdcard_disk_insert(sc);
207 sc->as_state = ALTERA_SDCARD_STATE_IDLE;
208 }
209
210 static void
211 altera_sdcard_task_badcard(struct altera_sdcard_softc *sc)
212 {
213
214 ALTERA_SDCARD_LOCK_ASSERT(sc);
215
216 /*
217 * Handle device driver detach.
218 */
219 if (sc->as_flags & ALTERA_SDCARD_FLAG_DETACHREQ) {
220 sc->as_state = ALTERA_SDCARD_STATE_DETACHED;
221 return;
222 }
223
224 /*
225 * Handle safe card removal -- no teardown is required, just a state
226 * transition.
227 */
228 if (!(altera_sdcard_read_asr(sc) & ALTERA_SDCARD_ASR_CARDPRESENT))
229 sc->as_state = ALTERA_SDCARD_STATE_NOCARD;
230 }
231
232 static void
233 altera_sdcard_task_idle(struct altera_sdcard_softc *sc)
234 {
235
236 ALTERA_SDCARD_LOCK_ASSERT(sc);
237
238 /*
239 * Handle device driver detach.
240 */
241 if (sc->as_flags & ALTERA_SDCARD_FLAG_DETACHREQ) {
242 sc->as_state = ALTERA_SDCARD_STATE_DETACHED;
243 return;
244 }
245
246 /*
247 * Handle safe card removal.
248 */
249 if (!(altera_sdcard_read_asr(sc) & ALTERA_SDCARD_ASR_CARDPRESENT)) {
250 altera_sdcard_disk_remove(sc);
251 sc->as_state = ALTERA_SDCARD_STATE_NOCARD;
252 }
253 }
254
255 static void
256 altera_sdcard_task_io(struct altera_sdcard_softc *sc)
257 {
258 uint16_t asr;
259
260 ALTERA_SDCARD_LOCK_ASSERT(sc);
261 KASSERT(sc->as_currentbio != NULL, ("%s: no current I/O", __func__));
262
263 #ifdef ALTERA_SDCARD_FAST_SIM
264 recheck:
265 #endif
266 asr = altera_sdcard_read_asr(sc);
267
268 /*
269 * Check for unexpected card removal during an I/O.
270 */
271 if (!(asr & ALTERA_SDCARD_ASR_CARDPRESENT)) {
272 altera_sdcard_disk_remove(sc);
273 if (sc->as_flags & ALTERA_SDCARD_FLAG_DETACHREQ)
274 sc->as_state = ALTERA_SDCARD_STATE_DETACHED;
275 else
276 sc->as_state = ALTERA_SDCARD_STATE_NOCARD;
277 return;
278 }
279
280 /*
281 * If the I/O isn't complete, remain in the IO state without further
282 * action, even if DETACHREQ is in flight.
283 */
284 if (asr & ALTERA_SDCARD_ASR_CMDINPROGRESS)
285 return;
286
287 /*
288 * Handle various forms of I/O completion, successful and otherwise.
289 * The I/O layer may restart the transaction if an error occurred, in
290 * which case remain in the IO state and reschedule.
291 */
292 if (!altera_sdcard_io_complete(sc, asr))
293 return;
294
295 /*
296 * Now that I/O is complete, process detach requests in preference to
297 * starting new I/O.
298 */
299 if (sc->as_flags & ALTERA_SDCARD_FLAG_DETACHREQ) {
300 sc->as_state = ALTERA_SDCARD_STATE_DETACHED;
301 return;
302 }
303
304 /*
305 * Finally, either start the next I/O or transition to the IDLE state.
306 */
307 if (bioq_first(&sc->as_bioq) != NULL) {
308 altera_sdcard_nextio(sc);
309 #ifdef ALTERA_SDCARD_FAST_SIM
310 goto recheck;
311 #endif
312 } else
313 sc->as_state = ALTERA_SDCARD_STATE_IDLE;
314 }
315
316 static void
317 altera_sdcard_task_rechedule(struct altera_sdcard_softc *sc)
318 {
319 int interval;
320
321 /*
322 * Reschedule based on new state. Or not, if detaching the device
323 * driver. Treat a bad card as though it were no card at all.
324 */
325 switch (sc->as_state) {
326 case ALTERA_SDCARD_STATE_NOCARD:
327 case ALTERA_SDCARD_STATE_BADCARD:
328 interval = ALTERA_SDCARD_TIMEOUT_NOCARD;
329 break;
330
331 case ALTERA_SDCARD_STATE_IDLE:
332 interval = ALTERA_SDCARD_TIMEOUT_IDLE;
333 break;
334
335 case ALTERA_SDCARD_STATE_IO:
336 if (sc->as_flags & ALTERA_SDCARD_FLAG_IOERROR)
337 interval = ALTERA_SDCARD_TIMEOUT_IOERROR;
338 else
339 interval = ALTERA_SDCARD_TIMEOUT_IO;
340 break;
341
342 default:
343 panic("%s: invalid exit state %d", __func__, sc->as_state);
344 }
345 taskqueue_enqueue_timeout(sc->as_taskqueue, &sc->as_task, interval);
346 }
347
348 /*
349 * Because the Altera SD Card IP Core doesn't support interrupts, we do all
350 * asynchronous work from a timeout. Poll at two different rates -- an
351 * infrequent check for card insertion status changes, and a frequent one for
352 * I/O completion. The task should never start in DETACHED, as that would
353 * imply that a previous instance failed to cancel rather than reschedule.
354 */
355 void
356 altera_sdcard_task(void *arg, int pending)
357 {
358 struct altera_sdcard_softc *sc;
359
360 sc = arg;
361 KASSERT(sc->as_state != ALTERA_SDCARD_STATE_DETACHED,
362 ("%s: already in detached", __func__));
363
364 ALTERA_SDCARD_LOCK(sc);
365 switch (sc->as_state) {
366 case ALTERA_SDCARD_STATE_NOCARD:
367 altera_sdcard_task_nocard(sc);
368 break;
369
370 case ALTERA_SDCARD_STATE_BADCARD:
371 altera_sdcard_task_badcard(sc);
372 break;
373
374 case ALTERA_SDCARD_STATE_IDLE:
375 altera_sdcard_task_idle(sc);
376 break;
377
378 case ALTERA_SDCARD_STATE_IO:
379 altera_sdcard_task_io(sc);
380 break;
381
382 default:
383 panic("%s: invalid enter state %d", __func__, sc->as_state);
384 }
385
386 /*
387 * If we have transitioned to DETACHED, signal the detach thread and
388 * cancel the timeout-driven task. Otherwise reschedule on an
389 * appropriate timeout.
390 */
391 if (sc->as_state == ALTERA_SDCARD_STATE_DETACHED)
392 ALTERA_SDCARD_CONDVAR_SIGNAL(sc);
393 else
394 altera_sdcard_task_rechedule(sc);
395 ALTERA_SDCARD_UNLOCK(sc);
396 }
397
398 void
399 altera_sdcard_start(struct altera_sdcard_softc *sc)
400 {
401
402 ALTERA_SDCARD_LOCK_ASSERT(sc);
403
404 KASSERT(sc->as_state == ALTERA_SDCARD_STATE_IDLE,
405 ("%s: starting when not IDLE", __func__));
406
407 taskqueue_cancel_timeout(sc->as_taskqueue, &sc->as_task, NULL);
408 altera_sdcard_nextio(sc);
409 #ifdef ALTERA_SDCARD_FAST_SIM
410 altera_sdcard_task_io(sc);
411 #endif
412 altera_sdcard_task_rechedule(sc);
413 }
Cache object: 0d26f0c7c7af104e1290eaaa7aeb03bf
|