1 /* $NetBSD: dtv_scatter.c,v 1.6 2019/12/27 09:41:50 msaitoh Exp $ */
2
3 /*
4 * Copyright (c) 2008 Patrick Mahoney <pat@polycrystal.org>
5 * All rights reserved.
6 *
7 * This code was written by Patrick Mahoney (pat@polycrystal.org) as
8 * part of Google Summer of Code 2008.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 __KERNEL_RCSID(0, "$NetBSD: dtv_scatter.c,v 1.6 2019/12/27 09:41:50 msaitoh Exp $");
34
35 #include <sys/param.h>
36 #include <sys/ioctl.h>
37 #include <sys/fcntl.h>
38 #include <sys/vnode.h>
39 #include <sys/poll.h>
40 #include <sys/select.h>
41 #include <sys/kmem.h>
42 #include <sys/pool.h>
43 #include <sys/conf.h>
44 #include <sys/types.h>
45 #include <sys/device.h>
46 #include <sys/condvar.h>
47 #include <sys/queue.h>
48
49 #include <dev/dtv/dtvvar.h>
50
51 void
dtv_scatter_buf_init(struct dtv_scatter_buf * sb)52 dtv_scatter_buf_init(struct dtv_scatter_buf *sb)
53 {
54 sb->sb_pool = pool_cache_init(PAGE_SIZE, 0, 0, 0,
55 "dtvscatter", NULL, IPL_SCHED,
56 NULL, NULL, NULL);
57 sb->sb_size = 0;
58 sb->sb_npages = 0;
59 sb->sb_page_ary = NULL;
60 }
61
62 void
dtv_scatter_buf_destroy(struct dtv_scatter_buf * sb)63 dtv_scatter_buf_destroy(struct dtv_scatter_buf *sb)
64 {
65 /* Do we need to return everything to the pool first? */
66 dtv_scatter_buf_set_size(sb, 0);
67 pool_cache_destroy(sb->sb_pool);
68 sb->sb_pool = 0;
69 sb->sb_npages = 0;
70 sb->sb_page_ary = NULL;
71 }
72
73 /* Increase or decrease the size of the buffer */
74 int
dtv_scatter_buf_set_size(struct dtv_scatter_buf * sb,size_t sz)75 dtv_scatter_buf_set_size(struct dtv_scatter_buf *sb, size_t sz)
76 {
77 unsigned int i;
78 size_t npages, minpages, oldnpages;
79 uint8_t **old_ary;
80
81 npages = (sz >> PAGE_SHIFT) + ((sz & PAGE_MASK) > 0);
82
83 if (sb->sb_npages == npages) {
84 return 0;
85 }
86
87 oldnpages = sb->sb_npages;
88 old_ary = sb->sb_page_ary;
89
90 sb->sb_npages = npages;
91 if (npages > 0) {
92 sb->sb_page_ary =
93 kmem_alloc(sizeof(uint8_t *) * npages, KM_SLEEP);
94 } else {
95 sb->sb_page_ary = NULL;
96 }
97
98 minpages = uimin(npages, oldnpages);
99 /* copy any pages that will be reused */
100 for (i = 0; i < minpages; ++i)
101 sb->sb_page_ary[i] = old_ary[i];
102 /* allocate any new pages */
103 for (; i < npages; ++i) {
104 sb->sb_page_ary[i] = pool_cache_get(sb->sb_pool, PR_WAITOK);
105 /* TODO: does pool_cache_get return NULL on
106 * ENOMEM? If so, we need to release or note
107 * the pages with did allocate
108 * successfully. */
109 if (sb->sb_page_ary[i] == NULL) {
110 return ENOMEM;
111 }
112 }
113 /* return any pages no longer needed */
114 for (; i < oldnpages; ++i)
115 pool_cache_put(sb->sb_pool, old_ary[i]);
116
117 if (old_ary != NULL)
118 kmem_free(old_ary, sizeof(uint8_t *) * oldnpages);
119
120 sb->sb_size = sb->sb_npages << PAGE_SHIFT;
121
122 return 0;
123 }
124
125
126 paddr_t
dtv_scatter_buf_map(struct dtv_scatter_buf * sb,off_t off)127 dtv_scatter_buf_map(struct dtv_scatter_buf *sb, off_t off)
128 {
129 size_t pg;
130 paddr_t pa;
131
132 pg = off >> PAGE_SHIFT;
133
134 if (pg >= sb->sb_npages)
135 return -1;
136 else if (!pmap_extract(pmap_kernel(), (vaddr_t)sb->sb_page_ary[pg], &pa))
137 return -1;
138
139 return atop(pa);
140 }
141
142 /* Initialize data for an io operation on a scatter buffer. Returns
143 * true if the transfer is valid, or false if out of range. */
144 bool
dtv_scatter_io_init(struct dtv_scatter_buf * sb,off_t off,size_t len,struct dtv_scatter_io * sio)145 dtv_scatter_io_init(struct dtv_scatter_buf *sb,
146 off_t off, size_t len,
147 struct dtv_scatter_io *sio)
148 {
149 if ((off + len) > sb->sb_size) {
150 printf("dtv: %s failed: off=%" PRId64
151 " len=%zu sb->sb_size=%zu\n",
152 __func__, off, len, sb->sb_size);
153 return false;
154 }
155
156 sio->sio_buf = sb;
157 sio->sio_offset = off;
158 sio->sio_resid = len;
159
160 return true;
161 }
162
163 /* Store the pointer and size of the next contiguous segment. Returns
164 * true if the segment is valid, or false if all has been transferred.
165 * Does not check for overflow. */
166 bool
dtv_scatter_io_next(struct dtv_scatter_io * sio,void ** p,size_t * sz)167 dtv_scatter_io_next(struct dtv_scatter_io *sio, void **p, size_t *sz)
168 {
169 size_t pg, pgo;
170
171 if (sio->sio_resid == 0)
172 return false;
173
174 pg = sio->sio_offset >> PAGE_SHIFT;
175 pgo = sio->sio_offset & PAGE_MASK;
176
177 *sz = uimin(PAGE_SIZE - pgo, sio->sio_resid);
178 *p = sio->sio_buf->sb_page_ary[pg] + pgo;
179
180 sio->sio_offset += *sz;
181 sio->sio_resid -= *sz;
182
183 return true;
184 }
185
186 /* Semi-undo of a failed segment copy. Updates the scatter_io
187 * struct to the previous values prior to a failed segment copy. */
188 void
dtv_scatter_io_undo(struct dtv_scatter_io * sio,size_t sz)189 dtv_scatter_io_undo(struct dtv_scatter_io *sio, size_t sz)
190 {
191 sio->sio_offset -= sz;
192 sio->sio_resid += sz;
193 }
194
195 /* Copy data from src into the scatter_buf as described by io. */
196 void
dtv_scatter_io_copyin(struct dtv_scatter_io * sio,const void * p)197 dtv_scatter_io_copyin(struct dtv_scatter_io *sio, const void *p)
198 {
199 void *dst;
200 const uint8_t *src = p;
201 size_t sz;
202
203 while (dtv_scatter_io_next(sio, &dst, &sz)) {
204 memcpy(dst, src, sz);
205 src += sz;
206 }
207 }
208
209 /* --not used; commented to avoid compiler warnings--
210 void
211 dtv_scatter_io_copyout(struct dtv_scatter_io *sio, void *p)
212 {
213 void *src;
214 uint8_t *dst = p;
215 size_t sz;
216
217 while (dtv_scatter_io_next(sio, &src, &sz)) {
218 memcpy(dst, src, sz);
219 dst += sz;
220 }
221 }
222 */
223
224 /* Performat a series of uiomove calls on a scatter buf. Returns
225 * EFAULT if uiomove EFAULTs on the first segment. Otherwise, returns
226 * an incomplete transfer but with no error. */
227 int
dtv_scatter_io_uiomove(struct dtv_scatter_io * sio,struct uio * uio)228 dtv_scatter_io_uiomove(struct dtv_scatter_io *sio, struct uio *uio)
229 {
230 void *p;
231 size_t sz;
232 bool first = true;
233 int err;
234
235 while (dtv_scatter_io_next(sio, &p, &sz)) {
236 err = uiomove(p, sz, uio);
237 if (err == EFAULT) {
238 dtv_scatter_io_undo(sio, sz);
239 if (first)
240 return EFAULT;
241 else
242 return 0;
243 }
244 first = false;
245 }
246
247 return 0;
248 }
249