1 // SPDX-License-Identifier: GPL-2.0-only 2 /* Copyright (c) 2020 NVIDIA Corporation */ 3 4 #include <linux/host1x.h> 5 #include <linux/iommu.h> 6 #include <linux/list.h> 7 8 #include <drm/drm_drv.h> 9 #include <drm/drm_file.h> 10 #include <drm/drm_utils.h> 11 12 #include "drm.h" 13 #include "uapi.h" 14 15 static void tegra_drm_mapping_release(struct kref *ref) 16 { 17 struct tegra_drm_mapping *mapping = 18 container_of(ref, struct tegra_drm_mapping, ref); 19 20 host1x_bo_unpin(mapping->map); 21 host1x_bo_put(mapping->bo); 22 23 kfree(mapping); 24 } 25 26 void tegra_drm_mapping_put(struct tegra_drm_mapping *mapping) 27 { 28 kref_put(&mapping->ref, tegra_drm_mapping_release); 29 } 30 31 static void tegra_drm_channel_context_close(struct tegra_drm_context *context) 32 { 33 struct tegra_drm_mapping *mapping; 34 unsigned long id; 35 36 xa_for_each(&context->mappings, id, mapping) 37 tegra_drm_mapping_put(mapping); 38 39 xa_destroy(&context->mappings); 40 41 host1x_channel_put(context->channel); 42 43 kfree(context); 44 } 45 46 void tegra_drm_uapi_close_file(struct tegra_drm_file *file) 47 { 48 struct tegra_drm_context *context; 49 struct host1x_syncpt *sp; 50 unsigned long id; 51 52 xa_for_each(&file->contexts, id, context) 53 tegra_drm_channel_context_close(context); 54 55 xa_for_each(&file->syncpoints, id, sp) 56 host1x_syncpt_put(sp); 57 58 xa_destroy(&file->contexts); 59 xa_destroy(&file->syncpoints); 60 } 61 62 static struct tegra_drm_client *tegra_drm_find_client(struct tegra_drm *tegra, u32 class) 63 { 64 struct tegra_drm_client *client; 65 66 list_for_each_entry(client, &tegra->clients, list) 67 if (client->base.class == class) 68 return client; 69 70 return NULL; 71 } 72 73 int tegra_drm_ioctl_channel_open(struct drm_device *drm, void *data, struct drm_file *file) 74 { 75 struct tegra_drm_file *fpriv = file->driver_priv; 76 struct tegra_drm *tegra = drm->dev_private; 77 struct drm_tegra_channel_open *args = data; 78 struct tegra_drm_client *client = NULL; 79 struct tegra_drm_context *context; 80 int err; 81 82 if (args->flags) 83 return -EINVAL; 84 85 context = kzalloc(sizeof(*context), GFP_KERNEL); 86 if (!context) 87 return -ENOMEM; 88 89 client = tegra_drm_find_client(tegra, args->host1x_class); 90 if (!client) { 91 err = -ENODEV; 92 goto free; 93 } 94 95 if (client->shared_channel) { 96 context->channel = host1x_channel_get(client->shared_channel); 97 } else { 98 context->channel = host1x_channel_request(&client->base); 99 if (!context->channel) { 100 err = -EBUSY; 101 goto free; 102 } 103 } 104 105 err = xa_alloc(&fpriv->contexts, &args->context, context, XA_LIMIT(1, U32_MAX), 106 GFP_KERNEL); 107 if (err < 0) 108 goto put_channel; 109 110 context->client = client; 111 xa_init_flags(&context->mappings, XA_FLAGS_ALLOC1); 112 113 args->version = client->version; 114 args->capabilities = 0; 115 116 if (device_get_dma_attr(client->base.dev) == DEV_DMA_COHERENT) 117 args->capabilities |= DRM_TEGRA_CHANNEL_CAP_CACHE_COHERENT; 118 119 return 0; 120 121 put_channel: 122 host1x_channel_put(context->channel); 123 free: 124 kfree(context); 125 126 return err; 127 } 128 129 int tegra_drm_ioctl_channel_close(struct drm_device *drm, void *data, struct drm_file *file) 130 { 131 struct tegra_drm_file *fpriv = file->driver_priv; 132 struct drm_tegra_channel_close *args = data; 133 struct tegra_drm_context *context; 134 135 mutex_lock(&fpriv->lock); 136 137 context = xa_load(&fpriv->contexts, args->context); 138 if (!context) { 139 mutex_unlock(&fpriv->lock); 140 return -EINVAL; 141 } 142 143 xa_erase(&fpriv->contexts, args->context); 144 145 mutex_unlock(&fpriv->lock); 146 147 tegra_drm_channel_context_close(context); 148 149 return 0; 150 } 151 152 int tegra_drm_ioctl_channel_map(struct drm_device *drm, void *data, struct drm_file *file) 153 { 154 struct tegra_drm_file *fpriv = file->driver_priv; 155 struct drm_tegra_channel_map *args = data; 156 struct tegra_drm_mapping *mapping; 157 struct tegra_drm_context *context; 158 enum dma_data_direction direction; 159 int err = 0; 160 161 if (args->flags & ~DRM_TEGRA_CHANNEL_MAP_READ_WRITE) 162 return -EINVAL; 163 164 mutex_lock(&fpriv->lock); 165 166 context = xa_load(&fpriv->contexts, args->context); 167 if (!context) { 168 mutex_unlock(&fpriv->lock); 169 return -EINVAL; 170 } 171 172 mapping = kzalloc(sizeof(*mapping), GFP_KERNEL); 173 if (!mapping) { 174 err = -ENOMEM; 175 goto unlock; 176 } 177 178 kref_init(&mapping->ref); 179 180 mapping->bo = tegra_gem_lookup(file, args->handle); 181 if (!mapping->bo) { 182 err = -EINVAL; 183 goto free; 184 } 185 186 switch (args->flags & DRM_TEGRA_CHANNEL_MAP_READ_WRITE) { 187 case DRM_TEGRA_CHANNEL_MAP_READ_WRITE: 188 direction = DMA_BIDIRECTIONAL; 189 break; 190 191 case DRM_TEGRA_CHANNEL_MAP_WRITE: 192 direction = DMA_FROM_DEVICE; 193 break; 194 195 case DRM_TEGRA_CHANNEL_MAP_READ: 196 direction = DMA_TO_DEVICE; 197 break; 198 199 default: 200 err = -EINVAL; 201 goto put_gem; 202 } 203 204 mapping->map = host1x_bo_pin(context->client->base.dev, mapping->bo, direction, NULL); 205 if (IS_ERR(mapping->map)) { 206 err = PTR_ERR(mapping->map); 207 goto put_gem; 208 } 209 210 mapping->iova = mapping->map->phys; 211 mapping->iova_end = mapping->iova + host1x_to_tegra_bo(mapping->bo)->gem.size; 212 213 err = xa_alloc(&context->mappings, &args->mapping, mapping, XA_LIMIT(1, U32_MAX), 214 GFP_KERNEL); 215 if (err < 0) 216 goto unpin; 217 218 mutex_unlock(&fpriv->lock); 219 220 return 0; 221 222 unpin: 223 host1x_bo_unpin(mapping->map); 224 put_gem: 225 host1x_bo_put(mapping->bo); 226 free: 227 kfree(mapping); 228 unlock: 229 mutex_unlock(&fpriv->lock); 230 return err; 231 } 232 233 int tegra_drm_ioctl_channel_unmap(struct drm_device *drm, void *data, struct drm_file *file) 234 { 235 struct tegra_drm_file *fpriv = file->driver_priv; 236 struct drm_tegra_channel_unmap *args = data; 237 struct tegra_drm_mapping *mapping; 238 struct tegra_drm_context *context; 239 240 mutex_lock(&fpriv->lock); 241 242 context = xa_load(&fpriv->contexts, args->context); 243 if (!context) { 244 mutex_unlock(&fpriv->lock); 245 return -EINVAL; 246 } 247 248 mapping = xa_erase(&context->mappings, args->mapping); 249 250 mutex_unlock(&fpriv->lock); 251 252 if (!mapping) 253 return -EINVAL; 254 255 tegra_drm_mapping_put(mapping); 256 return 0; 257 } 258 259 int tegra_drm_ioctl_syncpoint_allocate(struct drm_device *drm, void *data, struct drm_file *file) 260 { 261 struct host1x *host1x = tegra_drm_to_host1x(drm->dev_private); 262 struct tegra_drm_file *fpriv = file->driver_priv; 263 struct drm_tegra_syncpoint_allocate *args = data; 264 struct host1x_syncpt *sp; 265 int err; 266 267 if (args->id) 268 return -EINVAL; 269 270 sp = host1x_syncpt_alloc(host1x, HOST1X_SYNCPT_CLIENT_MANAGED, current->comm); 271 if (!sp) 272 return -EBUSY; 273 274 args->id = host1x_syncpt_id(sp); 275 276 err = xa_insert(&fpriv->syncpoints, args->id, sp, GFP_KERNEL); 277 if (err) { 278 host1x_syncpt_put(sp); 279 return err; 280 } 281 282 return 0; 283 } 284 285 int tegra_drm_ioctl_syncpoint_free(struct drm_device *drm, void *data, struct drm_file *file) 286 { 287 struct tegra_drm_file *fpriv = file->driver_priv; 288 struct drm_tegra_syncpoint_allocate *args = data; 289 struct host1x_syncpt *sp; 290 291 mutex_lock(&fpriv->lock); 292 sp = xa_erase(&fpriv->syncpoints, args->id); 293 mutex_unlock(&fpriv->lock); 294 295 if (!sp) 296 return -EINVAL; 297 298 host1x_syncpt_put(sp); 299 300 return 0; 301 } 302 303 int tegra_drm_ioctl_syncpoint_wait(struct drm_device *drm, void *data, struct drm_file *file) 304 { 305 struct host1x *host1x = tegra_drm_to_host1x(drm->dev_private); 306 struct drm_tegra_syncpoint_wait *args = data; 307 signed long timeout_jiffies; 308 struct host1x_syncpt *sp; 309 310 if (args->padding != 0) 311 return -EINVAL; 312 313 sp = host1x_syncpt_get_by_id_noref(host1x, args->id); 314 if (!sp) 315 return -EINVAL; 316 317 timeout_jiffies = drm_timeout_abs_to_jiffies(args->timeout_ns); 318 319 return host1x_syncpt_wait(sp, args->threshold, timeout_jiffies, &args->value); 320 } 321