1/*-
2 * Copyright (c) 2007, Juniper Networks, Inc.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the author nor the names of any co-contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
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,
22 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
24 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
25 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30#include <sys/cdefs.h>
|
31__FBSDID("$FreeBSD: head/sys/dev/cfi/cfi_dev.c 222198 2011-05-22 20:55:54Z attilio $");
|
| 31__FBSDID("$FreeBSD: head/sys/dev/cfi/cfi_dev.c 233553 2012-03-27 15:13:12Z jchandra $"); |
32
33#include "opt_cfi.h"
34
35#include <sys/param.h>
36#include <sys/systm.h>
37#include <sys/bus.h>
38#include <sys/conf.h>
39#include <sys/ioccom.h>
40#include <sys/kernel.h>
41#include <sys/malloc.h>
42#include <sys/proc.h>
43#include <sys/sysctl.h>
44#include <sys/types.h>
45#include <sys/uio.h>
46
47#include <sys/cfictl.h>
48
49#include <machine/atomic.h>
50#include <machine/bus.h>
51
52#include <dev/cfi/cfi_var.h>
53
54static d_open_t cfi_devopen;
55static d_close_t cfi_devclose;
56static d_read_t cfi_devread;
57static d_write_t cfi_devwrite;
58static d_ioctl_t cfi_devioctl;
59
60struct cdevsw cfi_cdevsw = {
61 .d_version = D_VERSION,
62 .d_flags = 0,
63 .d_name = cfi_driver_name,
64 .d_open = cfi_devopen,
65 .d_close = cfi_devclose,
66 .d_read = cfi_devread,
67 .d_write = cfi_devwrite,
68 .d_ioctl = cfi_devioctl,
69};
70
71/*
72 * Begin writing into a new block/sector. We read the sector into
73 * memory and keep updating that, until we move into another sector
74 * or the process stops writing. At that time we write the whole
75 * sector to flash (see cfi_block_finish).
76 */
77int
78cfi_block_start(struct cfi_softc *sc, u_int ofs)
79{
80 union {
81 uint8_t *x8;
82 uint16_t *x16;
83 uint32_t *x32;
84 } ptr;
85 u_int rofs, rsz;
86 uint32_t val;
87 int r;
88
89 rofs = 0;
90 for (r = 0; r < sc->sc_regions; r++) {
91 rsz = sc->sc_region[r].r_blocks * sc->sc_region[r].r_blksz;
92 if (ofs < rofs + rsz)
93 break;
94 rofs += rsz;
95 }
96 if (r == sc->sc_regions)
97 return (EFAULT);
98
99 sc->sc_wrbufsz = sc->sc_region[r].r_blksz;
100 sc->sc_wrbuf = malloc(sc->sc_wrbufsz, M_TEMP, M_WAITOK);
101 sc->sc_wrofs = ofs - (ofs - rofs) % sc->sc_wrbufsz;
102
103 /* Read the block from flash for byte-serving. */
104 ptr.x8 = sc->sc_wrbuf;
105 for (r = 0; r < sc->sc_wrbufsz; r += sc->sc_width) {
|
106 val = cfi_read(sc, sc->sc_wrofs + r);
|
| 106 val = cfi_read_raw(sc, sc->sc_wrofs + r); |
107 switch (sc->sc_width) {
108 case 1:
109 *(ptr.x8)++ = val;
110 break;
111 case 2:
112 *(ptr.x16)++ = val;
113 break;
114 case 4:
115 *(ptr.x32)++ = val;
116 break;
117 }
118 }
119 sc->sc_writing = 1;
120 return (0);
121}
122
123/*
124 * Finish updating the current block/sector by writing the compound
125 * set of changes to the flash.
126 */
127int
128cfi_block_finish(struct cfi_softc *sc)
129{
130 int error;
131
132 error = cfi_write_block(sc);
133 free(sc->sc_wrbuf, M_TEMP);
134 sc->sc_wrbuf = NULL;
135 sc->sc_wrbufsz = 0;
136 sc->sc_wrofs = 0;
137 sc->sc_writing = 0;
138 return (error);
139}
140
141static int
142cfi_devopen(struct cdev *dev, int oflags, int devtype, struct thread *td)
143{
144 struct cfi_softc *sc;
145
146 sc = dev->si_drv1;
147 /* We allow only 1 open. */
148 if (!atomic_cmpset_acq_ptr((uintptr_t *)&sc->sc_opened,
149 (uintptr_t)NULL, (uintptr_t)td->td_proc))
150 return (EBUSY);
151 return (0);
152}
153
154static int
155cfi_devclose(struct cdev *dev, int fflag, int devtype, struct thread *td)
156{
157 struct cfi_softc *sc;
158 int error;
159
160 sc = dev->si_drv1;
161 /* Sanity. Not really necessary. */
162 if (sc->sc_opened != td->td_proc)
163 return (ENXIO);
164
165 error = (sc->sc_writing) ? cfi_block_finish(sc) : 0;
166 sc->sc_opened = NULL;
167 return (error);
168}
169
170static int
171cfi_devread(struct cdev *dev, struct uio *uio, int ioflag)
172{
173 union {
174 uint8_t x8[4];
175 uint16_t x16[2];
176 uint32_t x32[1];
177 } buf;
178 struct cfi_softc *sc;
179 u_int ofs;
180 uint32_t val;
181 int error;
182
183 sc = dev->si_drv1;
184
185 error = (sc->sc_writing) ? cfi_block_finish(sc) : 0;
186 if (!error)
187 error = (uio->uio_offset > sc->sc_size) ? EIO : 0;
188
189 while (error == 0 && uio->uio_resid > 0 &&
190 uio->uio_offset < sc->sc_size) {
191 ofs = uio->uio_offset;
|
192 val = cfi_read(sc, ofs);
|
| 192 val = cfi_read_raw(sc, ofs); |
193 switch (sc->sc_width) {
194 case 1:
195 buf.x8[0] = val;
196 break;
197 case 2:
198 buf.x16[0] = val;
199 break;
200 case 4:
201 buf.x32[0] = val;
202 break;
203 }
204 ofs &= sc->sc_width - 1;
205 error = uiomove(buf.x8 + ofs,
206 MIN(uio->uio_resid, sc->sc_width - ofs), uio);
207 }
208 return (error);
209}
210
211static int
212cfi_devwrite(struct cdev *dev, struct uio *uio, int ioflag)
213{
214 struct cfi_softc *sc;
215 u_int ofs, top;
216 int error;
217
218 sc = dev->si_drv1;
219
220 error = (uio->uio_offset > sc->sc_size) ? EIO : 0;
221 while (error == 0 && uio->uio_resid > 0 &&
222 uio->uio_offset < sc->sc_size) {
223 ofs = uio->uio_offset;
224
225 /*
226 * Finish the current block if we're about to write
227 * to a different block.
228 */
229 if (sc->sc_writing) {
230 top = sc->sc_wrofs + sc->sc_wrbufsz;
231 if (ofs < sc->sc_wrofs || ofs >= top)
232 cfi_block_finish(sc);
233 }
234
235 /* Start writing to a (new) block if applicable. */
236 if (!sc->sc_writing) {
237 error = cfi_block_start(sc, uio->uio_offset);
238 if (error)
239 break;
240 }
241
242 top = sc->sc_wrofs + sc->sc_wrbufsz;
243 error = uiomove(sc->sc_wrbuf + ofs - sc->sc_wrofs,
244 MIN(top - ofs, uio->uio_resid), uio);
245 }
246 return (error);
247}
248
249static int
250cfi_devioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag,
251 struct thread *td)
252{
253 struct cfi_softc *sc;
254 struct cfiocqry *rq;
255 int error;
256 u_char val;
257
258 sc = dev->si_drv1;
259 error = 0;
260
261 switch (cmd) {
262 case CFIOCQRY:
263 if (sc->sc_writing) {
264 error = cfi_block_finish(sc);
265 if (error)
266 break;
267 }
268 rq = (struct cfiocqry *)data;
269 if (rq->offset >= sc->sc_size / sc->sc_width)
270 return (ESPIPE);
271 if (rq->offset + rq->count > sc->sc_size / sc->sc_width)
272 return (ENOSPC);
273
274 while (!error && rq->count--) {
275 val = cfi_read_qry(sc, rq->offset++);
276 error = copyout(&val, rq->buffer++, 1);
277 }
278 break;
279#ifdef CFI_SUPPORT_STRATAFLASH
280 case CFIOCGFACTORYPR:
281 error = cfi_intel_get_factory_pr(sc, (uint64_t *)data);
282 break;
283 case CFIOCGOEMPR:
284 error = cfi_intel_get_oem_pr(sc, (uint64_t *)data);
285 break;
286 case CFIOCSOEMPR:
287 error = cfi_intel_set_oem_pr(sc, *(uint64_t *)data);
288 break;
289 case CFIOCGPLR:
290 error = cfi_intel_get_plr(sc, (uint32_t *)data);
291 break;
292 case CFIOCSPLR:
293 error = cfi_intel_set_plr(sc);
294 break;
295#endif /* CFI_SUPPORT_STRATAFLASH */
296 default:
297 error = ENOIOCTL;
298 break;
299 }
300 return (error);
301}
|