1/*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2009 Sam Leffler, Errno Consulting
5 * Copyright (c) 2012-2013, SRI International
6 * All rights reserved.
7 *
8 * Portions of this software were developed by SRI International and the
9 * University of Cambridge Computer Laboratory under DARPA/AFRL contract
10 * (FA8750-10-C-0237) ("CTSRD"), as part of the DARPA CRASH research
11 * programme.
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 * 1. Redistributions of source code must retain the above copyright
17 *    notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 *    notice, this list of conditions and the following disclaimer in the
20 *    documentation and/or other materials provided with the distribution.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34#include <sys/param.h>
35#include <sys/systm.h>
36#include <sys/bio.h>
37#include <sys/bus.h>
38#include <sys/conf.h>
39#include <sys/kernel.h>
40#include <sys/malloc.h>
41#include <sys/lock.h>
42#include <sys/mutex.h>
43#include <sys/module.h>
44#include <sys/rman.h>
45#include <sys/sysctl.h>
46#include <sys/taskqueue.h>
47
48#include <machine/bus.h>
49
50#include <dev/cfi/cfi_var.h>
51
52#include <geom/geom.h>
53#include <geom/geom_disk.h>
54
55struct cfi_disk_softc {
56	struct cfi_softc *parent;
57	struct disk	*disk;
58	int		flags;
59#define	CFI_DISK_OPEN	0x0001
60	struct bio_queue_head bioq;	/* bio queue */
61	struct mtx	qlock;		/* bioq lock */
62	struct taskqueue *tq;		/* private task queue for i/o request */
63	struct task	iotask;		/* i/o processing */
64};
65
66#define	CFI_DISK_SECSIZE	512
67#define	CFI_DISK_MAXIOSIZE	65536
68
69static int cfi_disk_detach(device_t);
70static int cfi_disk_open(struct disk *);
71static int cfi_disk_close(struct disk *);
72static void cfi_io_proc(void *, int);
73static int cfi_disk_getattr(struct bio *);
74static void cfi_disk_strategy(struct bio *);
75static int cfi_disk_ioctl(struct disk *, u_long, void *, int, struct thread *);
76
77static int
78cfi_disk_probe(device_t dev)
79{
80	return 0;
81}
82
83static int
84cfi_disk_attach(device_t dev)
85{
86	struct cfi_disk_softc *sc = device_get_softc(dev);
87
88	sc->parent = device_get_softc(device_get_parent(dev));
89	/* validate interface width; assumed by other code */
90	if (sc->parent->sc_width != 1 &&
91	    sc->parent->sc_width != 2 &&
92	    sc->parent->sc_width != 4)
93		return EINVAL;
94
95	sc->disk = disk_alloc();
96	if (sc->disk == NULL)
97		return ENOMEM;
98	sc->disk->d_name = "cfid";
99	sc->disk->d_unit = device_get_unit(dev);
100	sc->disk->d_open = cfi_disk_open;
101	sc->disk->d_close = cfi_disk_close;
102	sc->disk->d_strategy = cfi_disk_strategy;
103	sc->disk->d_ioctl = cfi_disk_ioctl;
104	sc->disk->d_dump = NULL;		/* NB: no dumps */
105	sc->disk->d_getattr = cfi_disk_getattr;
106	sc->disk->d_sectorsize = CFI_DISK_SECSIZE;
107	sc->disk->d_mediasize = sc->parent->sc_size;
108	sc->disk->d_maxsize = CFI_DISK_MAXIOSIZE;
109	/* NB: use stripesize to hold the erase/region size */
110	if (sc->parent->sc_regions) {
111		/*
112		 * Multiple regions, use the last one.  This is a
113		 * total hack as it's (presently) used only by
114		 * geom_redboot to locate the FIS directory which
115		 * lies at the start of the last erase region.
116		 */
117		sc->disk->d_stripesize =
118		    sc->parent->sc_region[sc->parent->sc_regions-1].r_blksz;
119	} else
120		sc->disk->d_stripesize = sc->disk->d_mediasize;
121	sc->disk->d_drv1 = sc;
122	disk_create(sc->disk, DISK_VERSION);
123
124	mtx_init(&sc->qlock, "CFID I/O lock", NULL, MTX_DEF);
125	bioq_init(&sc->bioq);
126
127	sc->tq = taskqueue_create("cfid_taskq", M_NOWAIT,
128		taskqueue_thread_enqueue, &sc->tq);
129	taskqueue_start_threads(&sc->tq, 1, PI_DISK, "cfid taskq");
130
131	TASK_INIT(&sc->iotask, 0, cfi_io_proc, sc);
132
133	return 0;
134}
135
136static int
137cfi_disk_detach(device_t dev)
138{
139	struct cfi_disk_softc *sc = device_get_softc(dev);
140
141	if (sc->flags & CFI_DISK_OPEN)
142		return EBUSY;
143	taskqueue_free(sc->tq);
144	/* XXX drain bioq */
145	disk_destroy(sc->disk);
146	mtx_destroy(&sc->qlock);
147	return 0;
148}
149
150static int
151cfi_disk_open(struct disk *dp)
152{
153	struct cfi_disk_softc *sc = dp->d_drv1;
154
155	/* XXX no interlock with /dev/cfi */
156	sc->flags |= CFI_DISK_OPEN;
157	return 0;
158}
159
160static int
161cfi_disk_close(struct disk *dp)
162{
163	struct cfi_disk_softc *sc = dp->d_drv1;
164
165	sc->flags &= ~CFI_DISK_OPEN;
166	return 0;
167}
168
169static void
170cfi_disk_read(struct cfi_softc *sc, struct bio *bp)
171{
172	long resid;
173
174	KASSERT(sc->sc_width == 1 || sc->sc_width == 2 || sc->sc_width == 4,
175	    ("sc_width %d", sc->sc_width));
176
177	if (sc->sc_writing) {
178		bp->bio_error = cfi_block_finish(sc);
179		if (bp->bio_error) {
180			bp->bio_flags |= BIO_ERROR;
181			goto done;
182		}
183	}
184	if (bp->bio_offset > sc->sc_size) {
185		bp->bio_flags |= BIO_ERROR;
186		bp->bio_error = EIO;
187		goto done;
188	}
189	resid = bp->bio_bcount;
190	if (sc->sc_width == 1) {
191		uint8_t *dp = (uint8_t *)bp->bio_data;
192		while (resid > 0 && bp->bio_offset < sc->sc_size) {
193			*dp++ = cfi_read_raw(sc, bp->bio_offset);
194			bp->bio_offset += 1, resid -= 1;
195		}
196	} else if (sc->sc_width == 2) {
197		uint16_t *dp = (uint16_t *)bp->bio_data;
198		while (resid > 0 && bp->bio_offset < sc->sc_size) {
199			*dp++ = cfi_read_raw(sc, bp->bio_offset);
200			bp->bio_offset += 2, resid -= 2;
201		}
202	} else {
203		uint32_t *dp = (uint32_t *)bp->bio_data;
204		while (resid > 0 && bp->bio_offset < sc->sc_size) {
205			*dp++ = cfi_read_raw(sc, bp->bio_offset);
206			bp->bio_offset += 4, resid -= 4;
207		}
208	}
209	bp->bio_resid = resid;
210done:
211	biodone(bp);
212}
213
214static void
215cfi_disk_write(struct cfi_softc *sc, struct bio *bp)
216{
217	long resid;
218	u_int top;
219
220	KASSERT(sc->sc_width == 1 || sc->sc_width == 2 || sc->sc_width == 4,
221	    ("sc_width %d", sc->sc_width));
222
223	if (bp->bio_offset > sc->sc_size) {
224		bp->bio_flags |= BIO_ERROR;
225		bp->bio_error = EIO;
226		goto done;
227	}
228	resid = bp->bio_bcount;
229	while (resid > 0) {
230		/*
231		 * Finish the current block if we're about to write
232		 * to a different block.
233		 */
234		if (sc->sc_writing) {
235			top = sc->sc_wrofs + sc->sc_wrbufsz;
236			if (bp->bio_offset < sc->sc_wrofs ||
237			    bp->bio_offset >= top)
238				cfi_block_finish(sc);
239		}
240
241		/* Start writing to a (new) block if applicable. */
242		if (!sc->sc_writing) {
243			bp->bio_error = cfi_block_start(sc, bp->bio_offset);
244			if (bp->bio_error) {
245				bp->bio_flags |= BIO_ERROR;
246				goto done;
247			}
248		}
249
250		top = sc->sc_wrofs + sc->sc_wrbufsz;
251		bcopy(bp->bio_data,
252		    sc->sc_wrbuf + bp->bio_offset - sc->sc_wrofs,
253		    MIN(top - bp->bio_offset, resid));
254		resid -= MIN(top - bp->bio_offset, resid);
255	}
256	bp->bio_resid = resid;
257done:
258	biodone(bp);
259}
260
261static void
262cfi_io_proc(void *arg, int pending)
263{
264	struct cfi_disk_softc *sc = arg;
265	struct cfi_softc *cfi = sc->parent;
266	struct bio *bp;
267
268	for (;;) {
269		mtx_lock(&sc->qlock);
270		bp = bioq_takefirst(&sc->bioq);
271		mtx_unlock(&sc->qlock);
272		if (bp == NULL)
273			break;
274
275		switch (bp->bio_cmd) {
276		case BIO_READ:
277			cfi_disk_read(cfi, bp);
278			break;
279		case BIO_WRITE:
280			cfi_disk_write(cfi, bp);
281			break;
282		}
283	}
284}
285
286static int
287cfi_disk_getattr(struct bio *bp)
288{
289	struct cfi_disk_softc *dsc;
290	struct cfi_softc *sc;
291	device_t dev;
292
293	if (bp->bio_disk == NULL || bp->bio_disk->d_drv1 == NULL)
294		return (ENXIO);
295
296	dsc = bp->bio_disk->d_drv1;
297	sc = dsc->parent;
298	dev = sc->sc_dev;
299
300	if (strcmp(bp->bio_attribute, "CFI::device") == 0) {
301		if (bp->bio_length != sizeof(dev))
302			return (EFAULT);
303		bcopy(&dev, bp->bio_data, sizeof(dev));
304	} else
305		return (-1);
306	return (0);
307}
308
309static void
310cfi_disk_strategy(struct bio *bp)
311{
312	struct cfi_disk_softc *sc = bp->bio_disk->d_drv1;
313
314	if (sc == NULL) {
315		biofinish(bp, NULL, EINVAL);
316		return;
317	}
318	if (bp->bio_bcount == 0) {
319		bp->bio_resid = bp->bio_bcount;
320		biodone(bp);
321		return;
322	}
323	switch (bp->bio_cmd) {
324	case BIO_READ:
325	case BIO_WRITE:
326		mtx_lock(&sc->qlock);
327		/* no value in sorting requests? */
328		bioq_insert_tail(&sc->bioq, bp);
329		mtx_unlock(&sc->qlock);
330		taskqueue_enqueue(sc->tq, &sc->iotask);
331		break;
332	default:
333		biofinish(bp, NULL, EOPNOTSUPP);
334		break;
335	}
336}
337
338static int
339cfi_disk_ioctl(struct disk *dp, u_long cmd, void *data, int fflag,
340	struct thread *td)
341{
342	return EINVAL;
343}
344
345static device_method_t cfi_disk_methods[] = {
346	DEVMETHOD(device_probe,		cfi_disk_probe),
347	DEVMETHOD(device_attach,	cfi_disk_attach),
348	DEVMETHOD(device_detach,	cfi_disk_detach),
349	{ 0, 0 }
350};
351static driver_t cfi_disk_driver = {
352	"cfid",
353	cfi_disk_methods,
354	sizeof(struct cfi_disk_softc),
355};
356DRIVER_MODULE(cfid, cfi, cfi_disk_driver, NULL, NULL);
357