1 /* $NetBSD: linux_dma_buf.c,v 1.15 2022/04/09 23:44:44 riastradh Exp $ */ 2 3 /*- 4 * Copyright (c) 2018 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Taylor R. Campbell. 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: linux_dma_buf.c,v 1.15 2022/04/09 23:44:44 riastradh Exp $"); 34 35 #include <sys/types.h> 36 #include <sys/atomic.h> 37 #include <sys/file.h> 38 #include <sys/filedesc.h> 39 #include <sys/kmem.h> 40 #include <sys/mutex.h> 41 42 #include <linux/dma-buf.h> 43 #include <linux/err.h> 44 #include <linux/dma-resv.h> 45 46 static int dmabuf_fop_poll(struct file *, int); 47 static int dmabuf_fop_close(struct file *); 48 static int dmabuf_fop_kqfilter(struct file *, struct knote *); 49 static int dmabuf_fop_mmap(struct file *, off_t *, size_t, int, int *, 50 int *, struct uvm_object **, int *); 51 52 static const struct fileops dmabuf_fileops = { 53 .fo_name = "dmabuf", 54 .fo_read = fbadop_read, 55 .fo_write = fbadop_write, 56 .fo_ioctl = fbadop_ioctl, 57 .fo_fcntl = fnullop_fcntl, 58 .fo_poll = dmabuf_fop_poll, 59 .fo_stat = fbadop_stat, 60 .fo_close = dmabuf_fop_close, 61 .fo_kqfilter = dmabuf_fop_kqfilter, 62 .fo_restart = fnullop_restart, 63 .fo_mmap = dmabuf_fop_mmap, 64 }; 65 66 struct dma_buf * 67 dma_buf_export(struct dma_buf_export_info *info) 68 { 69 struct dma_buf *dmabuf; 70 71 if (info->resv == NULL) { 72 dmabuf = kmem_zalloc(offsetof(struct dma_buf, db_resv_int[1]), 73 KM_SLEEP); 74 } else { 75 dmabuf = kmem_zalloc(sizeof(*dmabuf), KM_SLEEP); 76 } 77 78 dmabuf->priv = info->priv; 79 dmabuf->ops = info->ops; 80 dmabuf->size = info->size; 81 dmabuf->resv = info->resv; 82 83 mutex_init(&dmabuf->db_lock, MUTEX_DEFAULT, IPL_NONE); 84 dmabuf->db_refcnt = 1; 85 dma_resv_poll_init(&dmabuf->db_resv_poll); 86 87 if (dmabuf->resv == NULL) { 88 dmabuf->resv = &dmabuf->db_resv_int[0]; 89 dma_resv_init(dmabuf->resv); 90 } 91 92 return dmabuf; 93 } 94 95 int 96 dma_buf_fd(struct dma_buf *dmabuf, int flags) 97 { 98 struct file *file; 99 int fd; 100 unsigned refcnt __diagused; 101 int ret; 102 103 /* XXX errno NetBSD->Linux */ 104 ret = -fd_allocfile(&file, &fd); 105 if (ret) 106 goto out0; 107 108 refcnt = atomic_inc_uint_nv(&dmabuf->db_refcnt); 109 KASSERT(refcnt > 1); 110 111 file->f_type = DTYPE_MISC; 112 file->f_flag = 0; /* XXX DRM code allows only O_CLOEXEC. */ 113 file->f_ops = &dmabuf_fileops; 114 file->f_data = dmabuf; 115 fd_set_exclose(curlwp, fd, (flags & O_CLOEXEC) != 0); 116 fd_affix(curproc, file, fd); 117 118 ret = fd; 119 out0: return ret; 120 } 121 122 struct dma_buf * 123 dma_buf_get(int fd) 124 { 125 struct file *file; 126 struct dma_buf *dmabuf; 127 unsigned refcnt __diagused; 128 int error; 129 130 if ((file = fd_getfile(fd)) == NULL) { 131 error = EBADF; 132 goto fail0; 133 } 134 if (file->f_type != DTYPE_MISC || file->f_ops != &dmabuf_fileops) { 135 error = EINVAL; 136 goto fail1; 137 } 138 139 dmabuf = file->f_data; 140 refcnt = atomic_inc_uint_nv(&dmabuf->db_refcnt); 141 KASSERT(refcnt > 1); 142 fd_putfile(fd); 143 return dmabuf; 144 145 fail1: fd_putfile(fd); 146 fail0: KASSERT(error); 147 return ERR_PTR(-error); 148 } 149 150 void 151 get_dma_buf(struct dma_buf *dmabuf) 152 { 153 unsigned refcnt __diagused; 154 155 refcnt = atomic_inc_uint_nv(&dmabuf->db_refcnt); 156 KASSERT(refcnt > 1); 157 } 158 159 void 160 dma_buf_put(struct dma_buf *dmabuf) 161 { 162 163 membar_release(); 164 if (atomic_dec_uint_nv(&dmabuf->db_refcnt) != 0) 165 return; 166 membar_acquire(); 167 168 dma_resv_poll_fini(&dmabuf->db_resv_poll); 169 mutex_destroy(&dmabuf->db_lock); 170 if (dmabuf->resv == &dmabuf->db_resv_int[0]) { 171 dma_resv_fini(dmabuf->resv); 172 kmem_free(dmabuf, offsetof(struct dma_buf, db_resv_int[1])); 173 } else { 174 kmem_free(dmabuf, sizeof(*dmabuf)); 175 } 176 } 177 178 struct dma_buf_attachment * 179 dma_buf_dynamic_attach(struct dma_buf *dmabuf, bus_dma_tag_t dmat, 180 bool dynamic_mapping) 181 { 182 struct dma_buf_attachment *attach; 183 int ret = 0; 184 185 attach = kmem_zalloc(sizeof(*attach), KM_SLEEP); 186 attach->dmabuf = dmabuf; 187 attach->dev = dmat; 188 attach->dynamic_mapping = dynamic_mapping; 189 190 mutex_enter(&dmabuf->db_lock); 191 if (dmabuf->ops->attach) 192 ret = dmabuf->ops->attach(dmabuf, attach); 193 mutex_exit(&dmabuf->db_lock); 194 if (ret) 195 goto fail0; 196 197 if (attach->dynamic_mapping != dmabuf->ops->dynamic_mapping) 198 panic("%s: NYI", __func__); 199 200 return attach; 201 202 fail0: kmem_free(attach, sizeof(*attach)); 203 return ERR_PTR(ret); 204 } 205 206 struct dma_buf_attachment * 207 dma_buf_attach(struct dma_buf *dmabuf, bus_dma_tag_t dmat) 208 { 209 210 return dma_buf_dynamic_attach(dmabuf, dmat, /*dynamic_mapping*/false); 211 } 212 213 void 214 dma_buf_detach(struct dma_buf *dmabuf, struct dma_buf_attachment *attach) 215 { 216 217 mutex_enter(&dmabuf->db_lock); 218 if (dmabuf->ops->detach) 219 dmabuf->ops->detach(dmabuf, attach); 220 mutex_exit(&dmabuf->db_lock); 221 222 kmem_free(attach, sizeof(*attach)); 223 } 224 225 struct sg_table * 226 dma_buf_map_attachment(struct dma_buf_attachment *attach, 227 enum dma_data_direction dir) 228 { 229 struct sg_table *sg; 230 231 if (attach->dmabuf->ops->dynamic_mapping) 232 dma_resv_lock(attach->dmabuf->resv, NULL); 233 sg = attach->dmabuf->ops->map_dma_buf(attach, dir); 234 if (attach->dmabuf->ops->dynamic_mapping) 235 dma_resv_unlock(attach->dmabuf->resv); 236 237 return sg; 238 } 239 240 void 241 dma_buf_unmap_attachment(struct dma_buf_attachment *attach, 242 struct sg_table *sg, enum dma_data_direction dir) 243 { 244 245 if (attach->dmabuf->ops->dynamic_mapping) 246 dma_resv_lock(attach->dmabuf->resv, NULL); 247 attach->dmabuf->ops->unmap_dma_buf(attach, sg, dir); 248 if (attach->dmabuf->ops->dynamic_mapping) 249 dma_resv_unlock(attach->dmabuf->resv); 250 } 251 252 static int 253 dmabuf_fop_close(struct file *file) 254 { 255 struct dma_buf *dmabuf = file->f_data; 256 257 dma_buf_put(dmabuf); 258 return 0; 259 } 260 261 static int 262 dmabuf_fop_poll(struct file *file, int events) 263 { 264 struct dma_buf *dmabuf = file->f_data; 265 struct dma_resv_poll *rpoll = &dmabuf->db_resv_poll; 266 267 return dma_resv_do_poll(dmabuf->resv, events, rpoll); 268 } 269 270 static int 271 dmabuf_fop_kqfilter(struct file *file, struct knote *kn) 272 { 273 struct dma_buf *dmabuf = file->f_data; 274 struct dma_resv_poll *rpoll = &dmabuf->db_resv_poll; 275 276 return dma_resv_kqfilter(dmabuf->resv, kn, rpoll); 277 } 278 279 static int 280 dmabuf_fop_mmap(struct file *file, off_t *offp, size_t size, int prot, 281 int *flagsp, int *advicep, struct uvm_object **uobjp, int *maxprotp) 282 { 283 struct dma_buf *dmabuf = file->f_data; 284 285 if (size > dmabuf->size) 286 return EINVAL; 287 288 return dmabuf->ops->mmap(dmabuf, offp, size, prot, flagsp, advicep, 289 uobjp, maxprotp); 290 } 291