2 * Copyright (c) 2007, Juniper Networks, Inc.
3 * Copyright (c) 2012-2013, SRI International
6 * Portions of this software were developed by SRI International and the
7 * University of Cambridge Computer Laboratory under DARPA/AFRL contract
8 * (FA8750-10-C-0237) ("CTSRD"), as part of the DARPA CRASH research
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. Neither the name of the author nor the names of any co-contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
28 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
30 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
31 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 #include <sys/cdefs.h>
37 __FBSDID("$FreeBSD$");
41 #include <sys/param.h>
42 #include <sys/systm.h>
45 #include <sys/ioccom.h>
46 #include <sys/kernel.h>
47 #include <sys/malloc.h>
49 #include <sys/sysctl.h>
50 #include <sys/types.h>
53 #include <sys/cfictl.h>
55 #include <machine/atomic.h>
56 #include <machine/bus.h>
58 #include <dev/cfi/cfi_var.h>
60 static d_open_t cfi_devopen;
61 static d_close_t cfi_devclose;
62 static d_read_t cfi_devread;
63 static d_write_t cfi_devwrite;
64 static d_ioctl_t cfi_devioctl;
66 struct cdevsw cfi_cdevsw = {
67 .d_version = D_VERSION,
69 .d_name = cfi_driver_name,
70 .d_open = cfi_devopen,
71 .d_close = cfi_devclose,
72 .d_read = cfi_devread,
73 .d_write = cfi_devwrite,
74 .d_ioctl = cfi_devioctl,
78 * Begin writing into a new block/sector. We read the sector into
79 * memory and keep updating that, until we move into another sector
80 * or the process stops writing. At that time we write the whole
81 * sector to flash (see cfi_block_finish). To avoid unneeded erase
82 * cycles, keep a pristine copy of the sector on hand.
85 cfi_block_start(struct cfi_softc *sc, u_int ofs)
97 for (r = 0; r < sc->sc_regions; r++) {
98 rsz = sc->sc_region[r].r_blocks * sc->sc_region[r].r_blksz;
103 if (r == sc->sc_regions)
106 sc->sc_wrbufsz = sc->sc_region[r].r_blksz;
107 sc->sc_wrbuf = malloc(sc->sc_wrbufsz, M_TEMP, M_WAITOK);
108 sc->sc_wrofs = ofs - (ofs - rofs) % sc->sc_wrbufsz;
110 /* Read the block from flash for byte-serving. */
111 ptr.x8 = sc->sc_wrbuf;
112 for (r = 0; r < sc->sc_wrbufsz; r += sc->sc_width) {
113 val = cfi_read_raw(sc, sc->sc_wrofs + r);
114 switch (sc->sc_width) {
126 sc->sc_wrbufcpy = malloc(sc->sc_wrbufsz, M_TEMP, M_WAITOK);
127 memcpy(sc->sc_wrbufcpy, sc->sc_wrbuf, sc->sc_wrbufsz);
133 * Finish updating the current block/sector by writing the compound
134 * set of changes to the flash.
137 cfi_block_finish(struct cfi_softc *sc)
141 error = cfi_write_block(sc);
142 free(sc->sc_wrbuf, M_TEMP);
143 free(sc->sc_wrbufcpy, M_TEMP);
152 cfi_devopen(struct cdev *dev, int oflags, int devtype, struct thread *td)
154 struct cfi_softc *sc;
157 /* We allow only 1 open. */
158 if (!atomic_cmpset_acq_ptr((uintptr_t *)&sc->sc_opened,
159 (uintptr_t)NULL, (uintptr_t)td->td_proc))
165 cfi_devclose(struct cdev *dev, int fflag, int devtype, struct thread *td)
167 struct cfi_softc *sc;
171 /* Sanity. Not really necessary. */
172 if (sc->sc_opened != td->td_proc)
175 error = (sc->sc_writing) ? cfi_block_finish(sc) : 0;
176 sc->sc_opened = NULL;
181 cfi_devread(struct cdev *dev, struct uio *uio, int ioflag)
188 struct cfi_softc *sc;
195 error = (sc->sc_writing) ? cfi_block_finish(sc) : 0;
197 error = (uio->uio_offset > sc->sc_size) ? EIO : 0;
199 while (error == 0 && uio->uio_resid > 0 &&
200 uio->uio_offset < sc->sc_size) {
201 ofs = uio->uio_offset;
202 val = cfi_read_raw(sc, ofs);
203 switch (sc->sc_width) {
214 ofs &= sc->sc_width - 1;
215 error = uiomove(buf.x8 + ofs,
216 MIN(uio->uio_resid, sc->sc_width - ofs), uio);
222 cfi_devwrite(struct cdev *dev, struct uio *uio, int ioflag)
224 struct cfi_softc *sc;
230 error = (uio->uio_offset > sc->sc_size) ? EIO : 0;
231 while (error == 0 && uio->uio_resid > 0 &&
232 uio->uio_offset < sc->sc_size) {
233 ofs = uio->uio_offset;
236 * Finish the current block if we're about to write
237 * to a different block.
239 if (sc->sc_writing) {
240 top = sc->sc_wrofs + sc->sc_wrbufsz;
241 if (ofs < sc->sc_wrofs || ofs >= top)
242 cfi_block_finish(sc);
245 /* Start writing to a (new) block if applicable. */
246 if (!sc->sc_writing) {
247 error = cfi_block_start(sc, uio->uio_offset);
252 top = sc->sc_wrofs + sc->sc_wrbufsz;
253 error = uiomove(sc->sc_wrbuf + ofs - sc->sc_wrofs,
254 MIN(top - ofs, uio->uio_resid), uio);
260 cfi_devioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag,
263 struct cfi_softc *sc;
273 if (sc->sc_writing) {
274 error = cfi_block_finish(sc);
278 rq = (struct cfiocqry *)data;
279 if (rq->offset >= sc->sc_size / sc->sc_width)
281 if (rq->offset + rq->count > sc->sc_size / sc->sc_width)
284 while (!error && rq->count--) {
285 val = cfi_read_qry(sc, rq->offset++);
286 error = copyout(&val, rq->buffer++, 1);
289 #ifdef CFI_SUPPORT_STRATAFLASH
290 case CFIOCGFACTORYPR:
291 error = cfi_intel_get_factory_pr(sc, (uint64_t *)data);
294 error = cfi_intel_get_oem_pr(sc, (uint64_t *)data);
297 error = cfi_intel_set_oem_pr(sc, *(uint64_t *)data);
300 error = cfi_intel_get_plr(sc, (uint32_t *)data);
303 error = cfi_intel_set_plr(sc);
305 #endif /* CFI_SUPPORT_STRATAFLASH */