From f19f22fcc8ef21b363b873c499cbd2e690af29f8 Mon Sep 17 00:00:00 2001 From: Terje Bergstrom Date: Fri, 15 Dec 2017 10:25:22 -0800 Subject: gpu: nvgpu: Remove support for channel events Remove support for events for bare channels. All users have already moved to TSGs and TSG events. Bug 1842197 Change-Id: Ib3ff68134ad9515ee761d0f0e19a3150a0b744ab Signed-off-by: Terje Bergstrom Reviewed-on: https://git-master.nvidia.com/r/1618906 Reviewed-by: Deepak Nibade Reviewed-by: mobile promotions Tested-by: mobile promotions --- drivers/gpu/nvgpu/common/linux/ioctl_channel.c | 260 ------------------------- drivers/gpu/nvgpu/common/linux/ioctl_channel.h | 2 - drivers/gpu/nvgpu/common/linux/ioctl_tsg.c | 77 +++++++- drivers/gpu/nvgpu/common/linux/vgpu/vgpu.c | 23 +-- drivers/gpu/nvgpu/gk20a/channel_gk20a.c | 22 +-- drivers/gpu/nvgpu/gk20a/channel_gk20a.h | 26 --- drivers/gpu/nvgpu/gk20a/fifo_gk20a.c | 1 - drivers/gpu/nvgpu/gk20a/gr_gk20a.c | 34 +--- drivers/gpu/nvgpu/gk20a/tsg_gk20a.h | 19 ++ drivers/gpu/nvgpu/gp10b/gr_gp10b.c | 24 +-- 10 files changed, 122 insertions(+), 366 deletions(-) diff --git a/drivers/gpu/nvgpu/common/linux/ioctl_channel.c b/drivers/gpu/nvgpu/common/linux/ioctl_channel.c index 5319b829..65d560c7 100644 --- a/drivers/gpu/nvgpu/common/linux/ioctl_channel.c +++ b/drivers/gpu/nvgpu/common/linux/ioctl_channel.c @@ -709,262 +709,6 @@ notif_clean_up: return ret; } -static unsigned int gk20a_event_id_poll(struct file *filep, poll_table *wait) -{ - unsigned int mask = 0; - struct gk20a_event_id_data *event_id_data = filep->private_data; - struct gk20a *g = event_id_data->g; - u32 event_id = event_id_data->event_id; - - gk20a_dbg(gpu_dbg_fn | gpu_dbg_info, ""); - - poll_wait(filep, &event_id_data->event_id_wq.wq, wait); - - nvgpu_mutex_acquire(&event_id_data->lock); - - if (event_id_data->is_tsg) { - struct tsg_gk20a *tsg = g->fifo.tsg + event_id_data->id; - - if (event_id_data->event_posted) { - gk20a_dbg_info( - "found pending event_id=%d on TSG=%d\n", - event_id, tsg->tsgid); - mask = (POLLPRI | POLLIN); - event_id_data->event_posted = false; - } - } else { - struct channel_gk20a *ch = g->fifo.channel - + event_id_data->id; - - if (event_id_data->event_posted) { - gk20a_dbg_info( - "found pending event_id=%d on chid=%d\n", - event_id, ch->chid); - mask = (POLLPRI | POLLIN); - event_id_data->event_posted = false; - } - } - - nvgpu_mutex_release(&event_id_data->lock); - - return mask; -} - -static int gk20a_event_id_release(struct inode *inode, struct file *filp) -{ - struct gk20a_event_id_data *event_id_data = filp->private_data; - struct gk20a *g = event_id_data->g; - - if (event_id_data->is_tsg) { - struct tsg_gk20a *tsg = g->fifo.tsg + event_id_data->id; - - nvgpu_mutex_acquire(&tsg->event_id_list_lock); - nvgpu_list_del(&event_id_data->event_id_node); - nvgpu_mutex_release(&tsg->event_id_list_lock); - } else { - struct channel_gk20a *ch = g->fifo.channel + event_id_data->id; - - nvgpu_mutex_acquire(&ch->event_id_list_lock); - nvgpu_list_del(&event_id_data->event_id_node); - nvgpu_mutex_release(&ch->event_id_list_lock); - } - - nvgpu_mutex_destroy(&event_id_data->lock); - gk20a_put(g); - nvgpu_kfree(g, event_id_data); - filp->private_data = NULL; - - return 0; -} - -const struct file_operations gk20a_event_id_ops = { - .owner = THIS_MODULE, - .poll = gk20a_event_id_poll, - .release = gk20a_event_id_release, -}; - -static int gk20a_channel_get_event_data_from_id(struct channel_gk20a *ch, - u32 event_id, - struct gk20a_event_id_data **event_id_data) -{ - struct gk20a_event_id_data *local_event_id_data; - bool event_found = false; - - nvgpu_mutex_acquire(&ch->event_id_list_lock); - nvgpu_list_for_each_entry(local_event_id_data, &ch->event_id_list, - gk20a_event_id_data, event_id_node) { - if (local_event_id_data->event_id == event_id) { - event_found = true; - break; - } - } - nvgpu_mutex_release(&ch->event_id_list_lock); - - if (event_found) { - *event_id_data = local_event_id_data; - return 0; - } else { - return -1; - } -} - -/* - * Convert common event_id of the form NVGPU_EVENT_ID_* to Linux specific - * event_id of the form NVGPU_IOCTL_CHANNEL_EVENT_ID_* which is used in IOCTLs - */ -u32 nvgpu_event_id_to_ioctl_channel_event_id(u32 event_id) -{ - switch (event_id) { - case NVGPU_EVENT_ID_BPT_INT: - return NVGPU_IOCTL_CHANNEL_EVENT_ID_BPT_INT; - case NVGPU_EVENT_ID_BPT_PAUSE: - return NVGPU_IOCTL_CHANNEL_EVENT_ID_BPT_PAUSE; - case NVGPU_EVENT_ID_BLOCKING_SYNC: - return NVGPU_IOCTL_CHANNEL_EVENT_ID_BLOCKING_SYNC; - case NVGPU_EVENT_ID_CILP_PREEMPTION_STARTED: - return NVGPU_IOCTL_CHANNEL_EVENT_ID_CILP_PREEMPTION_STARTED; - case NVGPU_EVENT_ID_CILP_PREEMPTION_COMPLETE: - return NVGPU_IOCTL_CHANNEL_EVENT_ID_CILP_PREEMPTION_COMPLETE; - case NVGPU_EVENT_ID_GR_SEMAPHORE_WRITE_AWAKEN: - return NVGPU_IOCTL_CHANNEL_EVENT_ID_GR_SEMAPHORE_WRITE_AWAKEN; - } - - return NVGPU_IOCTL_CHANNEL_EVENT_ID_MAX; -} - -void gk20a_channel_event_id_post_event(struct channel_gk20a *ch, - u32 __event_id) -{ - struct gk20a_event_id_data *event_id_data; - u32 event_id; - int err = 0; - - event_id = nvgpu_event_id_to_ioctl_channel_event_id(__event_id); - if (event_id >= NVGPU_IOCTL_CHANNEL_EVENT_ID_MAX) - return; - - err = gk20a_channel_get_event_data_from_id(ch, event_id, - &event_id_data); - if (err) - return; - - nvgpu_mutex_acquire(&event_id_data->lock); - - gk20a_dbg_info( - "posting event for event_id=%d on ch=%d\n", - event_id, ch->chid); - event_id_data->event_posted = true; - - nvgpu_cond_broadcast_interruptible(&event_id_data->event_id_wq); - - nvgpu_mutex_release(&event_id_data->lock); -} - -static int gk20a_channel_event_id_enable(struct channel_gk20a *ch, - int event_id, - int *fd) -{ - struct gk20a *g; - int err = 0; - int local_fd; - struct file *file; - char name[64]; - struct gk20a_event_id_data *event_id_data; - - g = gk20a_get(ch->g); - if (!g) - return -ENODEV; - - err = gk20a_channel_get_event_data_from_id(ch, - event_id, &event_id_data); - if (err == 0) { - /* We already have event enabled */ - err = -EINVAL; - goto free_ref; - } - - err = get_unused_fd_flags(O_RDWR); - if (err < 0) - goto free_ref; - local_fd = err; - - snprintf(name, sizeof(name), "nvgpu-event%d-fd%d", - event_id, local_fd); - file = anon_inode_getfile(name, &gk20a_event_id_ops, - NULL, O_RDWR); - if (IS_ERR(file)) { - err = PTR_ERR(file); - goto clean_up; - } - - event_id_data = nvgpu_kzalloc(ch->g, sizeof(*event_id_data)); - if (!event_id_data) { - err = -ENOMEM; - goto clean_up_file; - } - event_id_data->g = g; - event_id_data->id = ch->chid; - event_id_data->is_tsg = false; - event_id_data->event_id = event_id; - - nvgpu_cond_init(&event_id_data->event_id_wq); - err = nvgpu_mutex_init(&event_id_data->lock); - if (err) - goto clean_up_free; - nvgpu_init_list_node(&event_id_data->event_id_node); - - nvgpu_mutex_acquire(&ch->event_id_list_lock); - nvgpu_list_add_tail(&event_id_data->event_id_node, &ch->event_id_list); - nvgpu_mutex_release(&ch->event_id_list_lock); - - fd_install(local_fd, file); - file->private_data = event_id_data; - - *fd = local_fd; - - return 0; - -clean_up_free: - nvgpu_kfree(g, event_id_data); -clean_up_file: - fput(file); -clean_up: - put_unused_fd(local_fd); -free_ref: - gk20a_put(g); - return err; -} - -static int gk20a_channel_event_id_ctrl(struct channel_gk20a *ch, - struct nvgpu_event_id_ctrl_args *args) -{ - int err = 0; - int fd = -1; - - if (args->event_id >= NVGPU_IOCTL_CHANNEL_EVENT_ID_MAX) - return -EINVAL; - - if (gk20a_is_channel_marked_as_tsg(ch)) - return -EINVAL; - - switch (args->cmd) { - case NVGPU_IOCTL_CHANNEL_EVENT_ID_CMD_ENABLE: - err = gk20a_channel_event_id_enable(ch, args->event_id, &fd); - if (!err) - args->event_fd = fd; - break; - - default: - nvgpu_err(ch->g, - "unrecognized channel event id cmd: 0x%x", - args->cmd); - err = -EINVAL; - break; - } - - return err; -} - static int gk20a_channel_zcull_bind(struct channel_gk20a *ch, struct nvgpu_zcull_bind_args *args) { @@ -1467,10 +1211,6 @@ long gk20a_channel_ioctl(struct file *filp, NVGPU_ERR_NOTIFIER_RESETCHANNEL_VERIF_ERROR, true); gk20a_idle(ch->g); break; - case NVGPU_IOCTL_CHANNEL_EVENT_ID_CTRL: - err = gk20a_channel_event_id_ctrl(ch, - (struct nvgpu_event_id_ctrl_args *)buf); - break; #ifdef CONFIG_GK20A_CYCLE_STATS case NVGPU_IOCTL_CHANNEL_CYCLE_STATS_SNAPSHOT: err = gk20a_busy(ch->g); diff --git a/drivers/gpu/nvgpu/common/linux/ioctl_channel.h b/drivers/gpu/nvgpu/common/linux/ioctl_channel.h index c37108c4..48cff1ea 100644 --- a/drivers/gpu/nvgpu/common/linux/ioctl_channel.h +++ b/drivers/gpu/nvgpu/common/linux/ioctl_channel.h @@ -39,10 +39,8 @@ int gk20a_channel_open_ioctl(struct gk20a *g, int gk20a_channel_free_cycle_stats_snapshot(struct channel_gk20a *ch); void gk20a_channel_free_cycle_stats_buffer(struct channel_gk20a *ch); -extern const struct file_operations gk20a_event_id_ops; extern const struct file_operations gk20a_channel_ops; -u32 nvgpu_event_id_to_ioctl_channel_event_id(u32 event_id); u32 nvgpu_get_common_runlist_level(u32 level); u32 nvgpu_get_ioctl_graphics_preempt_mode_flags(u32 graphics_preempt_mode_flags); diff --git a/drivers/gpu/nvgpu/common/linux/ioctl_tsg.c b/drivers/gpu/nvgpu/common/linux/ioctl_tsg.c index b17d7e74..445199c2 100644 --- a/drivers/gpu/nvgpu/common/linux/ioctl_tsg.c +++ b/drivers/gpu/nvgpu/common/linux/ioctl_tsg.c @@ -18,6 +18,7 @@ #include #include #include +#include #include #include @@ -79,6 +80,30 @@ static int gk20a_tsg_get_event_data_from_id(struct tsg_gk20a *tsg, } } +/* + * Convert common event_id of the form NVGPU_EVENT_ID_* to Linux specific + * event_id of the form NVGPU_IOCTL_CHANNEL_EVENT_ID_* which is used in IOCTLs + */ +static u32 nvgpu_event_id_to_ioctl_channel_event_id(u32 event_id) +{ + switch (event_id) { + case NVGPU_EVENT_ID_BPT_INT: + return NVGPU_IOCTL_CHANNEL_EVENT_ID_BPT_INT; + case NVGPU_EVENT_ID_BPT_PAUSE: + return NVGPU_IOCTL_CHANNEL_EVENT_ID_BPT_PAUSE; + case NVGPU_EVENT_ID_BLOCKING_SYNC: + return NVGPU_IOCTL_CHANNEL_EVENT_ID_BLOCKING_SYNC; + case NVGPU_EVENT_ID_CILP_PREEMPTION_STARTED: + return NVGPU_IOCTL_CHANNEL_EVENT_ID_CILP_PREEMPTION_STARTED; + case NVGPU_EVENT_ID_CILP_PREEMPTION_COMPLETE: + return NVGPU_IOCTL_CHANNEL_EVENT_ID_CILP_PREEMPTION_COMPLETE; + case NVGPU_EVENT_ID_GR_SEMAPHORE_WRITE_AWAKEN: + return NVGPU_IOCTL_CHANNEL_EVENT_ID_GR_SEMAPHORE_WRITE_AWAKEN; + } + + return NVGPU_IOCTL_CHANNEL_EVENT_ID_MAX; +} + void gk20a_tsg_event_id_post_event(struct tsg_gk20a *tsg, int __event_id) { @@ -107,6 +132,57 @@ void gk20a_tsg_event_id_post_event(struct tsg_gk20a *tsg, nvgpu_mutex_release(&event_id_data->lock); } +static unsigned int gk20a_event_id_poll(struct file *filep, poll_table *wait) +{ + unsigned int mask = 0; + struct gk20a_event_id_data *event_id_data = filep->private_data; + struct gk20a *g = event_id_data->g; + u32 event_id = event_id_data->event_id; + struct tsg_gk20a *tsg = g->fifo.tsg + event_id_data->id; + + gk20a_dbg(gpu_dbg_fn | gpu_dbg_info, ""); + + poll_wait(filep, &event_id_data->event_id_wq.wq, wait); + + nvgpu_mutex_acquire(&event_id_data->lock); + + if (event_id_data->event_posted) { + gk20a_dbg_info( + "found pending event_id=%d on TSG=%d\n", + event_id, tsg->tsgid); + mask = (POLLPRI | POLLIN); + event_id_data->event_posted = false; + } + + nvgpu_mutex_release(&event_id_data->lock); + + return mask; +} + +static int gk20a_event_id_release(struct inode *inode, struct file *filp) +{ + struct gk20a_event_id_data *event_id_data = filp->private_data; + struct gk20a *g = event_id_data->g; + struct tsg_gk20a *tsg = g->fifo.tsg + event_id_data->id; + + nvgpu_mutex_acquire(&tsg->event_id_list_lock); + nvgpu_list_del(&event_id_data->event_id_node); + nvgpu_mutex_release(&tsg->event_id_list_lock); + + nvgpu_mutex_destroy(&event_id_data->lock); + gk20a_put(g); + nvgpu_kfree(g, event_id_data); + filp->private_data = NULL; + + return 0; +} + +const struct file_operations gk20a_event_id_ops = { + .owner = THIS_MODULE, + .poll = gk20a_event_id_poll, + .release = gk20a_event_id_release, +}; + static int gk20a_tsg_event_id_enable(struct tsg_gk20a *tsg, int event_id, int *fd) @@ -152,7 +228,6 @@ static int gk20a_tsg_event_id_enable(struct tsg_gk20a *tsg, } event_id_data->g = g; event_id_data->id = tsg->tsgid; - event_id_data->is_tsg = true; event_id_data->event_id = event_id; nvgpu_cond_init(&event_id_data->event_id_wq); diff --git a/drivers/gpu/nvgpu/common/linux/vgpu/vgpu.c b/drivers/gpu/nvgpu/common/linux/vgpu/vgpu.c index 3ff68ec2..7900f53f 100644 --- a/drivers/gpu/nvgpu/common/linux/vgpu/vgpu.c +++ b/drivers/gpu/nvgpu/common/linux/vgpu/vgpu.c @@ -125,27 +125,22 @@ int vgpu_get_attribute(u64 handle, u32 attrib, u32 *value) static void vgpu_handle_channel_event(struct gk20a *g, struct tegra_vgpu_channel_event_info *info) { + struct tsg_gk20a *tsg; + + if (!info->is_tsg) { + nvgpu_err(g, "channel event posted"); + return; + } + if (info->id >= g->fifo.num_channels || info->event_id >= NVGPU_IOCTL_CHANNEL_EVENT_ID_MAX) { nvgpu_err(g, "invalid channel event"); return; } - if (info->is_tsg) { - struct tsg_gk20a *tsg = &g->fifo.tsg[info->id]; + tsg = &g->fifo.tsg[info->id]; - gk20a_tsg_event_id_post_event(tsg, info->event_id); - } else { - struct channel_gk20a *ch = &g->fifo.channel[info->id]; - - if (!gk20a_channel_get(ch)) { - nvgpu_err(g, "invalid channel %d for event %d", - (int)info->id, (int)info->event_id); - return; - } - gk20a_channel_event_id_post_event(ch, info->event_id); - gk20a_channel_put(ch); - } + gk20a_tsg_event_id_post_event(tsg, info->event_id); } diff --git a/drivers/gpu/nvgpu/gk20a/channel_gk20a.c b/drivers/gpu/nvgpu/gk20a/channel_gk20a.c index e10be3c9..07ae5a16 100644 --- a/drivers/gpu/nvgpu/gk20a/channel_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/channel_gk20a.c @@ -689,7 +689,6 @@ struct channel_gk20a *gk20a_open_new_channel(struct gk20a *g, { struct fifo_gk20a *f = &g->fifo; struct channel_gk20a *ch; - struct gk20a_event_id_data *event_id_data, *event_id_data_temp; /* compatibility with existing code */ if (!gk20a_fifo_is_valid_runlist_id(g, runlist_id)) { @@ -730,16 +729,6 @@ struct channel_gk20a *gk20a_open_new_channel(struct gk20a *g, ch->pid = current->pid; ch->tgid = current->tgid; /* process granularity for FECS traces */ - /* unhook all events created on this channel */ - nvgpu_mutex_acquire(&ch->event_id_list_lock); - nvgpu_list_for_each_entry_safe(event_id_data, event_id_data_temp, - &ch->event_id_list, - gk20a_event_id_data, - event_id_node) { - nvgpu_list_del(&event_id_data->event_id_node); - } - nvgpu_mutex_release(&ch->event_id_list_lock); - /* By default, channel is regular (non-TSG) channel */ ch->tsgid = NVGPU_INVALID_TSG_ID; @@ -2134,7 +2123,6 @@ int gk20a_init_channel_support(struct gk20a *g, u32 chid) nvgpu_init_list_node(&c->joblist.dynamic.jobs); nvgpu_init_list_node(&c->dbg_s_list); - nvgpu_init_list_node(&c->event_id_list); nvgpu_init_list_node(&c->worker_item); err = nvgpu_mutex_init(&c->ioctl_lock); @@ -2157,19 +2145,14 @@ int gk20a_init_channel_support(struct gk20a *g, u32 chid) if (err) goto fail_5; #endif - err = nvgpu_mutex_init(&c->event_id_list_lock); - if (err) - goto fail_6; err = nvgpu_mutex_init(&c->dbg_s_lock); if (err) - goto fail_7; + goto fail_6; nvgpu_list_add(&c->free_chs, &g->fifo.free_chs); return 0; -fail_7: - nvgpu_mutex_destroy(&c->event_id_list_lock); fail_6: #if defined(CONFIG_GK20A_CYCLE_STATS) nvgpu_mutex_destroy(&c->cs_client_mutex); @@ -2286,9 +2269,6 @@ void gk20a_channel_semaphore_wakeup(struct gk20a *g, bool post_events) gk20a_tsg_event_id_post_event(tsg, NVGPU_EVENT_ID_BLOCKING_SYNC); - } else { - gk20a_channel_event_id_post_event(c, - NVGPU_EVENT_ID_BLOCKING_SYNC); } } /* diff --git a/drivers/gpu/nvgpu/gk20a/channel_gk20a.h b/drivers/gpu/nvgpu/gk20a/channel_gk20a.h index e6f73cf6..b43c5638 100644 --- a/drivers/gpu/nvgpu/gk20a/channel_gk20a.h +++ b/drivers/gpu/nvgpu/gk20a/channel_gk20a.h @@ -124,27 +124,6 @@ struct channel_gk20a_timeout { u64 pb_get; }; -struct gk20a_event_id_data { - struct gk20a *g; - - int id; /* ch or tsg */ - bool is_tsg; - u32 event_id; - - bool event_posted; - - struct nvgpu_cond event_id_wq; - struct nvgpu_mutex lock; - struct nvgpu_list_node event_id_node; -}; - -static inline struct gk20a_event_id_data * -gk20a_event_id_data_from_event_id_node(struct nvgpu_list_node *node) -{ - return (struct gk20a_event_id_data *) - ((uintptr_t)node - offsetof(struct gk20a_event_id_data, event_id_node)); -}; - /* * Track refcount actions, saving their stack traces. This number specifies how * many most recent actions are stored in a buffer. Set to 0 to disable. 128 @@ -265,9 +244,6 @@ struct channel_gk20a { struct nvgpu_mutex dbg_s_lock; struct nvgpu_list_node dbg_s_list; - struct nvgpu_list_node event_id_list; - struct nvgpu_mutex event_id_list_lock; - bool has_timedout; u32 timeout_ms_max; bool timeout_debug_dump; @@ -385,8 +361,6 @@ int gk20a_channel_get_timescale_from_timeslice(struct gk20a *g, int *__timeslice_timeout, int *__timeslice_scale); int gk20a_channel_set_runlist_interleave(struct channel_gk20a *ch, u32 level); -void gk20a_channel_event_id_post_event(struct channel_gk20a *ch, - u32 event_id); int channel_gk20a_alloc_job(struct channel_gk20a *c, struct channel_gk20a_job **job_out); diff --git a/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c b/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c index c5c06df9..fc71e907 100644 --- a/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c @@ -564,7 +564,6 @@ static void gk20a_remove_fifo_support(struct fifo_gk20a *f) nvgpu_mutex_destroy(&c->cyclestate.cyclestate_buffer_mutex); nvgpu_mutex_destroy(&c->cs_client_mutex); #endif - nvgpu_mutex_destroy(&c->event_id_list_lock); nvgpu_mutex_destroy(&c->dbg_s_lock); } diff --git a/drivers/gpu/nvgpu/gk20a/gr_gk20a.c b/drivers/gpu/nvgpu/gk20a/gr_gk20a.c index ea4d1d24..f07a54b1 100644 --- a/drivers/gpu/nvgpu/gk20a/gr_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/gr_gk20a.c @@ -5256,16 +5256,10 @@ static int gk20a_gr_handle_semaphore_pending(struct gk20a *g, { struct fifo_gk20a *f = &g->fifo; struct channel_gk20a *ch = &f->channel[isr_data->chid]; + struct tsg_gk20a *tsg = &g->fifo.tsg[ch->tsgid]; - if (gk20a_is_channel_marked_as_tsg(ch)) { - struct tsg_gk20a *tsg = &g->fifo.tsg[ch->tsgid]; - - gk20a_tsg_event_id_post_event(tsg, - NVGPU_EVENT_ID_GR_SEMAPHORE_WRITE_AWAKEN); - } else { - gk20a_channel_event_id_post_event(ch, - NVGPU_EVENT_ID_GR_SEMAPHORE_WRITE_AWAKEN); - } + gk20a_tsg_event_id_post_event(tsg, + NVGPU_EVENT_ID_GR_SEMAPHORE_WRITE_AWAKEN); nvgpu_cond_broadcast(&ch->semaphore_wq); @@ -5806,26 +5800,16 @@ static int gk20a_gr_post_bpt_events(struct gk20a *g, struct channel_gk20a *ch, u32 global_esr) { if (global_esr & gr_gpc0_tpc0_sm_hww_global_esr_bpt_int_pending_f()) { - if (gk20a_is_channel_marked_as_tsg(ch)) { - struct tsg_gk20a *tsg = &g->fifo.tsg[ch->tsgid]; + struct tsg_gk20a *tsg = &g->fifo.tsg[ch->tsgid]; - gk20a_tsg_event_id_post_event(tsg, - NVGPU_EVENT_ID_BPT_INT); - } else { - gk20a_channel_event_id_post_event(ch, - NVGPU_EVENT_ID_BPT_INT); - } + gk20a_tsg_event_id_post_event(tsg, + NVGPU_EVENT_ID_BPT_INT); } if (global_esr & gr_gpc0_tpc0_sm_hww_global_esr_bpt_pause_pending_f()) { - if (gk20a_is_channel_marked_as_tsg(ch)) { - struct tsg_gk20a *tsg = &g->fifo.tsg[ch->tsgid]; + struct tsg_gk20a *tsg = &g->fifo.tsg[ch->tsgid]; - gk20a_tsg_event_id_post_event(tsg, - NVGPU_EVENT_ID_BPT_PAUSE); - } else { - gk20a_channel_event_id_post_event(ch, - NVGPU_EVENT_ID_BPT_PAUSE); - } + gk20a_tsg_event_id_post_event(tsg, + NVGPU_EVENT_ID_BPT_PAUSE); } return 0; diff --git a/drivers/gpu/nvgpu/gk20a/tsg_gk20a.h b/drivers/gpu/nvgpu/gk20a/tsg_gk20a.h index 5e2b9b82..08fe0365 100644 --- a/drivers/gpu/nvgpu/gk20a/tsg_gk20a.h +++ b/drivers/gpu/nvgpu/gk20a/tsg_gk20a.h @@ -87,5 +87,24 @@ u32 gk20a_tsg_get_timeslice(struct tsg_gk20a *tsg); int gk20a_tsg_set_priority(struct gk20a *g, struct tsg_gk20a *tsg, u32 priority); +struct gk20a_event_id_data { + struct gk20a *g; + + int id; /* ch or tsg */ + u32 event_id; + + bool event_posted; + + struct nvgpu_cond event_id_wq; + struct nvgpu_mutex lock; + struct nvgpu_list_node event_id_node; +}; + +static inline struct gk20a_event_id_data * +gk20a_event_id_data_from_event_id_node(struct nvgpu_list_node *node) +{ + return (struct gk20a_event_id_data *) + ((uintptr_t)node - offsetof(struct gk20a_event_id_data, event_id_node)); +}; #endif /* __TSG_GK20A_H_ */ diff --git a/drivers/gpu/nvgpu/gp10b/gr_gp10b.c b/drivers/gpu/nvgpu/gp10b/gr_gp10b.c index 3b63626c..b5194223 100644 --- a/drivers/gpu/nvgpu/gp10b/gr_gp10b.c +++ b/drivers/gpu/nvgpu/gp10b/gr_gp10b.c @@ -1709,6 +1709,7 @@ int gr_gp10b_set_cilp_preempt_pending(struct gk20a *g, { int ret; struct gr_ctx_desc *gr_ctx = fault_ch->ch_ctx.gr_ctx; + struct tsg_gk20a *tsg; gk20a_dbg(gpu_dbg_fn | gpu_dbg_gpu_dbg | gpu_dbg_intr, ""); @@ -1773,15 +1774,10 @@ int gr_gp10b_set_cilp_preempt_pending(struct gk20a *g, gr_ctx->cilp_preempt_pending = true; g->gr.cilp_preempt_pending_chid = fault_ch->chid; - if (gk20a_is_channel_marked_as_tsg(fault_ch)) { - struct tsg_gk20a *tsg = &g->fifo.tsg[fault_ch->tsgid]; + tsg = &g->fifo.tsg[fault_ch->tsgid]; - gk20a_tsg_event_id_post_event(tsg, - NVGPU_EVENT_ID_CILP_PREEMPTION_STARTED); - } else { - gk20a_channel_event_id_post_event(fault_ch, - NVGPU_EVENT_ID_CILP_PREEMPTION_STARTED); - } + gk20a_tsg_event_id_post_event(tsg, + NVGPU_EVENT_ID_CILP_PREEMPTION_STARTED); return 0; } @@ -1948,6 +1944,7 @@ int gr_gp10b_handle_fecs_error(struct gk20a *g, struct channel_gk20a *ch; int chid = -1; int ret = 0; + struct tsg_gk20a *tsg; gk20a_dbg(gpu_dbg_fn | gpu_dbg_gpu_dbg | gpu_dbg_intr, ""); @@ -1984,15 +1981,10 @@ int gr_gp10b_handle_fecs_error(struct gk20a *g, /* Post events to UMD */ gk20a_dbg_gpu_post_events(ch); - if (gk20a_is_channel_marked_as_tsg(ch)) { - struct tsg_gk20a *tsg = &g->fifo.tsg[ch->tsgid]; + tsg = &g->fifo.tsg[ch->tsgid]; - gk20a_tsg_event_id_post_event(tsg, - NVGPU_EVENT_ID_CILP_PREEMPTION_COMPLETE); - } else { - gk20a_channel_event_id_post_event(ch, - NVGPU_EVENT_ID_CILP_PREEMPTION_COMPLETE); - } + gk20a_tsg_event_id_post_event(tsg, + NVGPU_EVENT_ID_CILP_PREEMPTION_COMPLETE); gk20a_channel_put(ch); } -- cgit v1.2.2