| Message ID | 1466507202-23222-3-git-send-email-tomeu.vizoso@collabora.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
On Tue, Jun 21, 2016 at 01:06:41PM +0200, Tomeu Vizoso wrote: [...] > diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c [...] > +static int > +drm_add_fake_info_node(struct drm_minor *minor, > + struct dentry *ent, > + const void *key) Nit: this fits on two lines instead of four. > +{ > + struct drm_info_node *node; > + > + node = kmalloc(sizeof(*node), GFP_KERNEL); > + if (node == NULL) { > + debugfs_remove(ent); You already remove this in the caller upon returning an error, no need to do it twice. The caller is where it should be removed. > + return -ENOMEM; > + } > + > + node->minor = minor; > + node->dent = ent; > + node->info_ent = (void *) key; > + > + mutex_lock(&minor->debugfs_lock); > + list_add(&node->list, &minor->debugfs_list); > + mutex_unlock(&minor->debugfs_lock); > + > + return 0; > +} Is there a specific reason why you use the drm_info_node infrastructure here? Seems like it'd be simpler just doing plain debugfs. > + > +static int crc_control_show(struct seq_file *m, void *data) > +{ > + struct drm_device *dev = m->private; > + struct drm_crtc *crtc; > + > + drm_for_each_crtc(crtc, dev) > + seq_printf(m, "crtc %d %s\n", crtc->index, > + crtc->crc.source ? crtc->crc.source : "none"); > + > + return 0; > +} Why are these control files not per-CRTC? I'd imagine you could do something like control the CRC generation on writes and provide the sampled CRCs on reads. > +static int crc_control_open(struct inode *inode, struct file *file) > +{ > + struct drm_device *dev = inode->i_private; > + > + return single_open(file, crc_control_show, dev); > +} > + > +static int crc_control_update_crtc(struct drm_crtc *crtc, const char *source) > +{ > + struct drm_crtc_crc *crc = &crtc->crc; > + struct drm_crtc_crc_entry *entries; > + int ret; > + > + if (!strcmp(source, "none")) Nit: I think it's more idiomatic to write the == 0 explicitly for strcmp() for readability. My brain always interprets !strcmp() as "strings are not equal", whereas == 0 is more explicit as in "the difference between strings is 0". But perhaps that's just personal taste. > + source = NULL; > + > + if (!crc->source && !source) > + return 0; > + > + if (crc->source && source && !strcmp(crc->source, source)) > + return 0; > + > + /* Forbid changing the source without going back to "none". */ > + if (crc->source && source) > + return -EINVAL; Why? It seems to me that if a driver doesn't support switching from one source to another directly, then it should internally handle that. After all the source parameter is already driver-specific, so it seems odd to impose this kind of policy on it at this level. > + if (!crtc->funcs->set_crc_source) > + return -ENOTSUPP; > + > + if (source) { > + entries = kcalloc(DRM_CRTC_CRC_ENTRIES_NR, > + sizeof(crc->entries[0]), > + GFP_KERNEL); > + if (!entries) > + return -ENOMEM; > + > + spin_lock_irq(&crc->lock); > + kfree(crc->entries); > + crc->entries = entries; > + crc->head = 0; > + crc->tail = 0; > + spin_unlock_irq(&crc->lock); > + } Why are we reallocating? Couldn't we simply allocate once and keep reusing the existing array? > + > + ret = crtc->funcs->set_crc_source(crtc, source); > + if (ret) > + return ret; > + > + kfree(crc->source); > + crc->source = source ? kstrdup(source, GFP_KERNEL) : NULL; > + > + if (!source) { > + spin_lock_irq(&crc->lock); > + entries = crc->entries; > + crc->entries = NULL; > + crc->head = 0; > + crc->tail = 0; > + spin_unlock_irq(&crc->lock); > + > + kfree(entries); > + } This frees the entries array after resetting source to "none", but what if we never do that? Aren't we going to leak that data at CRTC removal? > +static struct drm_crtc *crtc_from_index(struct drm_device *dev, int index) unsigned int index? > +{ > + struct drm_crtc *crtc; > + int i = 0; unsigned int? > + > + drm_for_each_crtc(crtc, dev) > + if (i++ == index) > + return crtc; > + > + return NULL; > +} This looks like a candidate for the core. I know that at least Tegra implements a variant of this, and I think i915 does, too. > +/* > + * Parse CRC command strings: > + * command: wsp* object wsp+ (crtc | pipe) wsp+ source wsp* Should the "(crtc | pipe)" in the above be "object"? > + * object: ('crtc' | 'pipe') Because you define that here? > + * crtc: (0 | 1 | 2 | ...) > + * pipe: (A | B | C) > + * source: (none | plane1 | plane2 | ...) I wouldn't provide "plane1 | plane2 |" here, since the parameter is passed as-is to drivers, which may or may not support plane1 or plane2. > + * wsp: (#0x20 | #0x9 | #0xA)+ > + * > + * eg.: > + * "crtc 0 plane1" -> Start CRC computations on plane1 of first CRTC > + * "crtc 0 none" -> Stop CRC I've said this above, but again, it seems odd to me that you'd have to configure the CRC per-CRTC in one per-device file and read out the CRC from per-CRTC files. > + return n_words; > +} > + > +static int crc_control_parse_crtc(const char *buf, unsigned int *crtc_index) > +{ > + const char letter = buf[0]; > + > + if (!kstrtouint(buf, 10, crtc_index)) Nit: Same comment as for !strcmp(). > + return 0; > + > + /* Backwards compatibility for Intel-style pipe letters */ > + if (letter < 'A' || letter > 'Z') > + return -EINVAL; > + > + *crtc_index = letter - 'A'; > + > + return 0; > +} Perhaps it would be more readable to write the above as: err = kstrtouint(buf, 10, crtc_index); if (err < 0) { if (letter < 'A' || letter > 'Z') { *crtc_index = letter - 'A'; err = 0; } } return err; > +static int crc_control_parse(struct drm_device *dev, char *buf, size_t len) > +{ > +#define N_WORDS 3 > + int n_words; unsigned int? > + char *words[N_WORDS]; > + unsigned int crtc_index; > + struct drm_crtc *crtc; > + > + n_words = crc_control_tokenize(buf, words, N_WORDS); > + if (n_words != N_WORDS) { > + DRM_DEBUG_KMS("tokenize failed, a command is %d words\n", %u for unsigned int. > + N_WORDS); n_words > + return -EINVAL; > + } > + > + if (strcmp(words[0], "crtc") && strcmp(words[0], "pipe")) { > + DRM_DEBUG_KMS("Invalid command %s\n", words[0]); > + return -EINVAL; > + } > + > + if (crc_control_parse_crtc(words[1], &crtc_index) < 0) { > + DRM_DEBUG_KMS("Invalid CRTC index: %s\n", words[1]); > + return -EINVAL; > + } Propagate the error from crc_control_parse_crtc()? > + > + crtc = crtc_from_index(dev, crtc_index); > + if (!crtc) { > + DRM_DEBUG_KMS("Unknown CRTC index: %d\n", crtc_index); %u for unsigned int. > + return -EINVAL; > + } > + > + return crc_control_update_crtc(crtc, words[2]); > +} > + > +static ssize_t crc_control_write(struct file *file, const char __user *ubuf, > + size_t len, loff_t *offp) > +{ > + struct seq_file *m = file->private_data; > + struct drm_device *dev = m->private; > + char *tmpbuf; > + int ret; > + > + if (len == 0) > + return 0; > + > + if (len > PAGE_SIZE - 1) { > + DRM_DEBUG_KMS("expected <%lu bytes into crtc crc control\n", "CRTC" and "CRC", and perhaps a space after <. > @@ -157,10 +413,23 @@ int drm_debugfs_init(struct drm_minor *minor, int minor_id, > ret = drm_debugfs_create_files(drm_debugfs_list, DRM_DEBUGFS_ENTRIES, > minor->debugfs_root, minor); > if (ret) { > - debugfs_remove(minor->debugfs_root); > - minor->debugfs_root = NULL; > DRM_ERROR("Failed to create core drm debugfs files\n"); > - return ret; > + goto error_remove_dir; I think we can do without the error_ prefix on these labels. > +static ssize_t crtc_crc_read(struct file *filep, char __user *user_buf, > + size_t count, loff_t *pos) > +{ > + struct drm_crtc *crtc = filep->f_inode->i_private; > + struct drm_crtc_crc *crc = &crtc->crc; > + char buf[CRC_BUFFER_LEN]; > + int n_entries; unsigned int? > + ssize_t bytes_read; > + > + /* > + * Don't allow user space to provide buffers not big enough to hold > + * a line of data. > + */ > + if (count < CRC_LINE_LEN) > + return -EINVAL; > + > + if (!crc->source) > + return 0; > + > + /* Nothing to read? */ > + spin_lock_irq(&crc->lock); > + while (crtc_crc_data_count(crc) == 0) { > + int ret; > + > + if (filep->f_flags & O_NONBLOCK) { > + spin_unlock_irq(&crc->lock); > + return -EAGAIN; > + } > + > + ret = wait_event_interruptible_lock_irq(crc->wq, > + crtc_crc_data_count(crc), crc->lock); > + if (ret) { > + spin_unlock_irq(&crc->lock); > + return ret; > + } > + } > + > + /* We now have one or more entries to read */ > + n_entries = count / CRC_LINE_LEN; > + > + bytes_read = 0; > + while (n_entries > 0) { > + struct drm_crtc_crc_entry *entry = > + &crc->entries[crc->tail]; Fits on one line. > + int ret; > + > + if (CIRC_CNT(crc->head, crc->tail, DRM_CRTC_CRC_ENTRIES_NR) < 1) > + break; > + > + BUILD_BUG_ON_NOT_POWER_OF_2(DRM_CRTC_CRC_ENTRIES_NR); > + crc->tail = (crc->tail + 1) & (DRM_CRTC_CRC_ENTRIES_NR - 1); > + > + bytes_read += snprintf(buf, CRC_BUFFER_LEN, > + "%8u %8x %8x %8x %8x %8x\n", uint32_t can be 9 characters long in decimal representation. Also I think it'd be safer to go through a separate variable here, to avoid inadvertantly subtracting from bytes_read. And then you can also make the bytes_read variable size_t. > + entry->frame, entry->crc[0], > + entry->crc[1], entry->crc[2], > + entry->crc[3], entry->crc[4]); What about drivers that only support one uint32_t for the CRC? Do they also need to output all unused uint32_t:s? > + > + spin_unlock_irq(&crc->lock); Is it really safe to unlock here? I thought the whole point of this lock was to prevent someone from reconfiguring the CRC mid-way, but after the unlock above that's exactly what could happen. > + > + ret = copy_to_user(user_buf, buf, CRC_LINE_LEN); > + if (ret == CRC_LINE_LEN) > + return -EFAULT; > > + user_buf += CRC_LINE_LEN; > + n_entries--; > + > + spin_lock_irq(&crc->lock); > + } > + > + spin_unlock_irq(&crc->lock); > + > + return bytes_read; > +} > + > +const struct file_operations drm_crtc_crc_fops = { > + .owner = THIS_MODULE, > + .open = crtc_crc_open, > + .read = crtc_crc_read, > + .release = crtc_crc_release, > +}; Do we want to support poll? > + > +static int drm_debugfs_crtc_add_for_minor(struct drm_crtc *crtc, > + struct drm_minor *minor) > +{ > + struct dentry *ent; > + char *name; > + > + if (!minor->debugfs_root) > + return -1; Can this ever happen? Perhaps turn this into a symbolic name if you really need it. > + > + name = kasprintf(GFP_KERNEL, "drm_crtc_%d_crc", crtc->index); > + if (!name) > + return -ENOMEM; I think it might be preferable to move this all into per-CRTC debugfs directories, perhaps even collapse the "crc" and "control" files. But in any case I think the drm_ prefix is redundant here and should be dropped. > + ent = debugfs_create_file(name, S_IRUGO, minor->debugfs_root, crtc, > + &drm_crtc_crc_fops); > + kfree(name); > + if (!ent) > + return PTR_ERR(ent); > + > + crtc->crc.debugfs_entries[minor->type] = ent; > + > + return 0; > +} > + > +int drm_debugfs_crtc_add(struct drm_crtc *crtc) > +{ > + int ret; > + > + ret = drm_debugfs_crtc_add_for_minor(crtc, crtc->dev->control); > + if (ret) > + return ret; > + > + ret = drm_debugfs_crtc_add_for_minor(crtc, crtc->dev->primary); > + if (ret) > + return ret; > + > + ret = drm_debugfs_crtc_add_for_minor(crtc, crtc->dev->render); > + if (ret) > + return ret; > + > + return 0; > +} Do we really want these for all minors? Is ->primary not enough? It certainly seems completely misplaced in ->render, and I don't think anything really uses ->control anymore. Also I think you need to export this symbol. > +void drm_debugfs_crtc_remove(struct drm_crtc *crtc) > +{ > + int i; unsigned int > + > + for (i = 0; i < DRM_MINOR_CNT; i++) { > + debugfs_remove_recursive(crtc->crc.debugfs_entries[i]); > + crtc->crc.debugfs_entries[i] = NULL; > + } > +} This also needs an export, I think. > + > +void drm_crtc_add_crc_entry(struct drm_crtc *crtc, uint32_t frame, > + uint32_t crc0, uint32_t crc1, uint32_t crc2, > + uint32_t crc3, uint32_t crc4) Perhaps allow passing the CRC as an array with a count parameter? I can imagine that a lot of hardware will only give you a single uint32_t for the CRC, in which case you could do: drm_crtc_add_crc_entry(crtc, frame, &crc, 1); instead of: drm_crtc_add_crc_entry(crtc, frame, crc, 0, 0, 0, 0); It would probably save poor users of the interface, such as myself, a lot of headaches because they can't remember how many uint32_t:s the function needs. > +{ > + struct drm_crtc_crc *crc = &crtc->crc; > + struct drm_crtc_crc_entry *entry; > + int head, tail; unsigned int > + > + spin_lock(&crc->lock); > + > + head = crc->head; > + tail = crc->tail; > + > + if (CIRC_SPACE(head, tail, DRM_CRTC_CRC_ENTRIES_NR) < 1) { Perhaps "== 0"? > + spin_unlock(&crc->lock); > + DRM_ERROR("Overflow of CRC buffer, userspace reads too slow.\n"); > + return; > + } Maybe return an error here? And perhaps use some sort of printk rate limiting here to avoid this from spamming logs? > + > + entry = &crc->entries[head]; > + > + entry->frame = frame; > + entry->crc[0] = crc0; > + entry->crc[1] = crc1; > + entry->crc[2] = crc2; > + entry->crc[3] = crc3; > + entry->crc[4] = crc4; > + > + head = (head + 1) & (DRM_CRTC_CRC_ENTRIES_NR - 1); > + crc->head = head; > + > + spin_unlock(&crc->lock); > + > + wake_up_interruptible(&crc->wq); > +} > + > +#endif /* CONFIG_DEBUG_FS */ > diff --git a/drivers/gpu/drm/drm_internal.h b/drivers/gpu/drm/drm_internal.h > index 38401d406532..e5b124d937f5 100644 > --- a/drivers/gpu/drm/drm_internal.h > +++ b/drivers/gpu/drm/drm_internal.h > @@ -100,6 +100,8 @@ int drm_debugfs_init(struct drm_minor *minor, int minor_id, > int drm_debugfs_cleanup(struct drm_minor *minor); > int drm_debugfs_connector_add(struct drm_connector *connector); > void drm_debugfs_connector_remove(struct drm_connector *connector); > +int drm_debugfs_crtc_add(struct drm_crtc *crtc); > +void drm_debugfs_crtc_remove(struct drm_crtc *crtc); Oh... this isn't something that drivers are supposed to call? > #else > static inline int drm_debugfs_init(struct drm_minor *minor, int minor_id, > struct dentry *root) > @@ -119,4 +121,12 @@ static inline int drm_debugfs_connector_add(struct drm_connector *connector) > static inline void drm_debugfs_connector_remove(struct drm_connector *connector) > { > } > + > +static inline int drm_debugfs_crtc_add(struct drm_crtc *crtc) > +{ > + return 0; > +} > +static inline void drm_debugfs_crtc_remove(struct drm_crtc *crtc) > +{ > +} > #endif > diff --git a/include/drm/drmP.h b/include/drm/drmP.h > index 084fd141e8bf..ec2f91c8b7cd 100644 > --- a/include/drm/drmP.h > +++ b/include/drm/drmP.h > @@ -1142,6 +1142,11 @@ static __inline__ bool drm_can_sleep(void) > return true; > } > > +#if defined(CONFIG_DEBUG_FS) > +extern const struct file_operations drm_crc_control_fops; > +extern const struct file_operations drm_crtc_crc_fops; > +#endif > + > /* helper for handling conditionals in various for_each macros */ > #define for_each_if(condition) if (!(condition)) {} else > > diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h > index c2734979f164..141335a3c647 100644 > --- a/include/drm/drm_crtc.h > +++ b/include/drm/drm_crtc.h > @@ -376,6 +376,22 @@ struct drm_crtc_state { > struct drm_atomic_state *state; > }; > > +struct drm_crtc_crc_entry { > + uint32_t frame; > + uint32_t crc[5]; > +}; > + > +#define DRM_CRTC_CRC_ENTRIES_NR 128 > +struct drm_crtc_crc { > + spinlock_t lock; > + const char *source; > + bool opened; /* exclusive access to the result file */ You could probably have done this with an atomic and avoid the spin lock for exclusive access, but it's probably not worth it. > + struct drm_crtc_crc_entry *entries; > + int head, tail; unsigned int? > + wait_queue_head_t wq; > + struct dentry **debugfs_entries; > +}; > + > /** > * struct drm_crtc_funcs - control CRTCs for a given device > * > @@ -704,6 +720,29 @@ struct drm_crtc_funcs { > const struct drm_crtc_state *state, > struct drm_property *property, > uint64_t *val); > + > + /** > + * @set_crc_source: > + * > + * Changes the source of CRC checksums of frames at the request of > + * userspace, typically for testing purposes. The sources available are > + * specific of each driver and a %NULL value indicates that CRC > + * generation is to be switched off. Perhaps also mention that "none" is an alias for NULL? > + * > + * When CRC generation is enabled, the driver should call > + * drm_crtc_add_crc_entry() at each frame, providing any information > + * that characterizes the frame contents in the crcN arguments, as > + * provided from the configured source. Drivers should accept a "auto" > + * source name that will select a default source for this CRTC. Would it be useful to provide some more aliases? "enable" and "on" for "auto", "disable" and "off" for "none"? Thierry
On 21 June 2016 at 17:07, Thierry Reding <thierry.reding@gmail.com> wrote: > On Tue, Jun 21, 2016 at 01:06:41PM +0200, Tomeu Vizoso wrote: > [...] >> diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c > [...] > >> + >> +static int crc_control_show(struct seq_file *m, void *data) >> +{ >> + struct drm_device *dev = m->private; >> + struct drm_crtc *crtc; >> + >> + drm_for_each_crtc(crtc, dev) >> + seq_printf(m, "crtc %d %s\n", crtc->index, >> + crtc->crc.source ? crtc->crc.source : "none"); >> + >> + return 0; >> +} > > Why are these control files not per-CRTC? I'd imagine you could do > something like control the CRC generation on writes and provide the > sampled CRCs on reads. We just thought there wasn't a strong point for breaking the existing API in a fundamental way. The current proposal allows us to reuse more code between the new and legacy CRC implementations in i915 and in IGT. >> + source = NULL; >> + >> + if (!crc->source && !source) >> + return 0; >> + >> + if (crc->source && source && !strcmp(crc->source, source)) >> + return 0; >> + >> + /* Forbid changing the source without going back to "none". */ >> + if (crc->source && source) >> + return -EINVAL; > > Why? It seems to me that if a driver doesn't support switching from one > source to another directly, then it should internally handle that. After > all the source parameter is already driver-specific, so it seems odd to > impose this kind of policy on it at this level. Hmm, I don't see when that would make sense for userspace. If userspace has a source configured and changes directly to another, how does it know what's the last CRC for the old source? I think that if userspace does that it's shooting in its foot and it's good to give an error. >> + >> + drm_for_each_crtc(crtc, dev) >> + if (i++ == index) >> + return crtc; >> + >> + return NULL; >> +} > > This looks like a candidate for the core. I know that at least Tegra > implements a variant of this, and I think i915 does, too. And a few others. I would go this way but when I pinged danvet on irc he didn't reply so I just went with the safe option. >> +/* >> + * Parse CRC command strings: >> + * command: wsp* object wsp+ (crtc | pipe) wsp+ source wsp* > > Should the "(crtc | pipe)" in the above be "object"? In one case they are literals and in the other symbols. >> + * object: ('crtc' | 'pipe') > > Because you define that here? > >> + * crtc: (0 | 1 | 2 | ...) >> + * pipe: (A | B | C) >> + * source: (none | plane1 | plane2 | ...) > > I wouldn't provide "plane1 | plane2 |" here, since the parameter is > passed as-is to drivers, which may or may not support plane1 or plane2. Agreed, feels more confusing than clarifying. >> + * wsp: (#0x20 | #0x9 | #0xA)+ >> + * >> + * eg.: >> + * "crtc 0 plane1" -> Start CRC computations on plane1 of first CRTC >> + * "crtc 0 none" -> Stop CRC > > I've said this above, but again, it seems odd to me that you'd have to > configure the CRC per-CRTC in one per-device file and read out the CRC > from per-CRTC files. Not sure, I like that the per-crtc files just provide CRC data, and that there's a separate control file that can be queried for the current state. > >> + entry->frame, entry->crc[0], >> + entry->crc[1], entry->crc[2], >> + entry->crc[3], entry->crc[4]); > > What about drivers that only support one uint32_t for the CRC? Do they > also need to output all unused uint32_t:s? Yeah, do you think that could be a problem? >> + >> + ret = copy_to_user(user_buf, buf, CRC_LINE_LEN); >> + if (ret == CRC_LINE_LEN) >> + return -EFAULT; >> >> + user_buf += CRC_LINE_LEN; >> + n_entries--; >> + >> + spin_lock_irq(&crc->lock); >> + } >> + >> + spin_unlock_irq(&crc->lock); >> + >> + return bytes_read; >> +} >> + >> +const struct file_operations drm_crtc_crc_fops = { >> + .owner = THIS_MODULE, >> + .open = crtc_crc_open, >> + .read = crtc_crc_read, >> + .release = crtc_crc_release, >> +}; > > Do we want to support poll? Don't see the point of it, TBH. >> + >> +static int drm_debugfs_crtc_add_for_minor(struct drm_crtc *crtc, >> + struct drm_minor *minor) >> +{ >> + struct dentry *ent; >> + char *name; >> + >> + if (!minor->debugfs_root) >> + return -1; > > Can this ever happen? Perhaps turn this into a symbolic name if you > really need it. Sorry, can you explain what you mean by that? >> + >> + name = kasprintf(GFP_KERNEL, "drm_crtc_%d_crc", crtc->index); >> + if (!name) >> + return -ENOMEM; > > I think it might be preferable to move this all into per-CRTC debugfs > directories, perhaps even collapse the "crc" and "control" files. But in > any case I think the drm_ prefix is redundant here and should be > dropped. Yeah, I kind of like the redundancy as in the client code you will only sometimes find the file name next to the directory name, but I don't particularly care myself. >> +int drm_debugfs_crtc_add(struct drm_crtc *crtc) >> +{ >> + int ret; >> + >> + ret = drm_debugfs_crtc_add_for_minor(crtc, crtc->dev->control); >> + if (ret) >> + return ret; >> + >> + ret = drm_debugfs_crtc_add_for_minor(crtc, crtc->dev->primary); >> + if (ret) >> + return ret; >> + >> + ret = drm_debugfs_crtc_add_for_minor(crtc, crtc->dev->render); >> + if (ret) >> + return ret; >> + >> + return 0; >> +} > > Do we really want these for all minors? Is ->primary not enough? It > certainly seems completely misplaced in ->render, and I don't think > anything really uses ->control anymore. Agreed. >> +void drm_crtc_add_crc_entry(struct drm_crtc *crtc, uint32_t frame, >> + uint32_t crc0, uint32_t crc1, uint32_t crc2, >> + uint32_t crc3, uint32_t crc4) > > Perhaps allow passing the CRC as an array with a count parameter? I can > imagine that a lot of hardware will only give you a single uint32_t for > the CRC, in which case you could do: > > drm_crtc_add_crc_entry(crtc, frame, &crc, 1); > > instead of: > > drm_crtc_add_crc_entry(crtc, frame, crc, 0, 0, 0, 0); > > It would probably save poor users of the interface, such as myself, a > lot of headaches because they can't remember how many uint32_t:s the > function needs. Sounds good to me, I don't really know how common multiple sources of complex CRC data will be in the future. >> diff --git a/drivers/gpu/drm/drm_internal.h b/drivers/gpu/drm/drm_internal.h >> index 38401d406532..e5b124d937f5 100644 >> --- a/drivers/gpu/drm/drm_internal.h >> +++ b/drivers/gpu/drm/drm_internal.h >> @@ -100,6 +100,8 @@ int drm_debugfs_init(struct drm_minor *minor, int minor_id, >> int drm_debugfs_cleanup(struct drm_minor *minor); >> int drm_debugfs_connector_add(struct drm_connector *connector); >> void drm_debugfs_connector_remove(struct drm_connector *connector); >> +int drm_debugfs_crtc_add(struct drm_crtc *crtc); >> +void drm_debugfs_crtc_remove(struct drm_crtc *crtc); > > Oh... this isn't something that drivers are supposed to call? Right, it's analogous to drm_debugfs_connector_add. >> + * >> + * When CRC generation is enabled, the driver should call >> + * drm_crtc_add_crc_entry() at each frame, providing any information >> + * that characterizes the frame contents in the crcN arguments, as >> + * provided from the configured source. Drivers should accept a "auto" >> + * source name that will select a default source for this CRTC. > > Would it be useful to provide some more aliases? "enable" and "on" for > "auto", "disable" and "off" for "none"? Not sure, TBH, i like to keep my interfaces simple. Do you think this could be helpful? Thanks for the great review! Tomeu
On Wed, Jun 22, 2016 at 10:26:36AM +0200, Tomeu Vizoso wrote: > On 21 June 2016 at 17:07, Thierry Reding <thierry.reding@gmail.com> wrote: > > On Tue, Jun 21, 2016 at 01:06:41PM +0200, Tomeu Vizoso wrote: > > [...] > >> diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c > > [...] > > > >> + > >> +static int crc_control_show(struct seq_file *m, void *data) > >> +{ > >> + struct drm_device *dev = m->private; > >> + struct drm_crtc *crtc; > >> + > >> + drm_for_each_crtc(crtc, dev) > >> + seq_printf(m, "crtc %d %s\n", crtc->index, > >> + crtc->crc.source ? crtc->crc.source : "none"); > >> + > >> + return 0; > >> +} > > > > Why are these control files not per-CRTC? I'd imagine you could do > > something like control the CRC generation on writes and provide the > > sampled CRCs on reads. > > We just thought there wasn't a strong point for breaking the existing > API in a fundamental way. The current proposal allows us to reuse more > code between the new and legacy CRC implementations in i915 and in > IGT. This is pretty much the last chance to make changes to this interface, so I think it'd be good to spend at least some time thinking about it and if there's anything that could be improved. > >> + source = NULL; > >> + > >> + if (!crc->source && !source) > >> + return 0; > >> + > >> + if (crc->source && source && !strcmp(crc->source, source)) > >> + return 0; > >> + > >> + /* Forbid changing the source without going back to "none". */ > >> + if (crc->source && source) > >> + return -EINVAL; > > > > Why? It seems to me that if a driver doesn't support switching from one > > source to another directly, then it should internally handle that. After > > all the source parameter is already driver-specific, so it seems odd to > > impose this kind of policy on it at this level. > > Hmm, I don't see when that would make sense for userspace. If > userspace has a source configured and changes directly to another, how > does it know what's the last CRC for the old source? I think that if > userspace does that it's shooting in its foot and it's good to give an > error. You do clear the ring buffer when the configured source is changed, right? If so, then userspace would automatically get the new CRC upon the next read. How is that different than switching via the "none" source? > >> + > >> + drm_for_each_crtc(crtc, dev) > >> + if (i++ == index) > >> + return crtc; > >> + > >> + return NULL; > >> +} > > > > This looks like a candidate for the core. I know that at least Tegra > > implements a variant of this, and I think i915 does, too. > > And a few others. I would go this way but when I pinged danvet on irc > he didn't reply so I just went with the safe option. It could be a follow up patch, I don't mind much either way. > >> +/* > >> + * Parse CRC command strings: > >> + * command: wsp* object wsp+ (crtc | pipe) wsp+ source wsp* > > > > Should the "(crtc | pipe)" in the above be "object"? > > In one case they are literals and in the other symbols. > > >> + * object: ('crtc' | 'pipe') > > > > Because you define that here? Right, I see now. > >> + * wsp: (#0x20 | #0x9 | #0xA)+ > >> + * > >> + * eg.: > >> + * "crtc 0 plane1" -> Start CRC computations on plane1 of first CRTC > >> + * "crtc 0 none" -> Stop CRC > > > > I've said this above, but again, it seems odd to me that you'd have to > > configure the CRC per-CRTC in one per-device file and read out the CRC > > from per-CRTC files. > > Not sure, I like that the per-crtc files just provide CRC data, and > that there's a separate control file that can be queried for the > current state. In my opinion that makes things needlessly complicated for userspace. If you want to query the state of a specific CRTC, you have to read out the entire file and parse each line to find the correct CRTC. On the other hand, chances are that you already need to know the path to the CRTC because you want to read the CRC out of the per-CRTC CRC file. In that case it would be much easier to simply concatenate the CRTC path and the CRC (or control) filename and read a single line (actually a single word) out of it to get at the same information. Furthermore if you have everything per-CRTC you no longer have to worry about pipe vs. index (that's always confusing because in the DRM core they're actually synonymous) because the CRTC path is canonical and will have the correct context. Per-CRTC directory with a single duplex file, or separate control and CRC files, is much simpler than the mix proposed here. No tokenization required when parsing in userspace, and no tokenization required to parse in the kernel either. > >> + entry->frame, entry->crc[0], > >> + entry->crc[1], entry->crc[2], > >> + entry->crc[3], entry->crc[4]); > > > > What about drivers that only support one uint32_t for the CRC? Do they > > also need to output all unused uint32_t:s? > > Yeah, do you think that could be a problem? I worry slightly about the flexibility of this. On one hand it's redundant to have to read 5 values if you only get one that's valid. It's also ambiguous if you receive one value and 4 zeroes, because zero could technically be a valid CRC. Furthermore what if some hardware needed to provide more than five values? One simple solution would be to make the number of values per entry variable (and perhaps even include the count as first value in the debugfs file). On that note: what if there's hardware that doesn't fit into the above format at all? I can't immediately think of anything, but that's not a guarantee that it won't happen. I suppose we have to settle on something for the sake of genericity, so one option would be for eccentric drivers to encode whatever format they have into uint32_t:s. Also, anything that doesn't fit into a couple of uint32_t:s could well be considered not a CRC at all. > >> + > >> + ret = copy_to_user(user_buf, buf, CRC_LINE_LEN); > >> + if (ret == CRC_LINE_LEN) > >> + return -EFAULT; > >> > >> + user_buf += CRC_LINE_LEN; > >> + n_entries--; > >> + > >> + spin_lock_irq(&crc->lock); > >> + } > >> + > >> + spin_unlock_irq(&crc->lock); > >> + > >> + return bytes_read; > >> +} > >> + > >> +const struct file_operations drm_crtc_crc_fops = { > >> + .owner = THIS_MODULE, > >> + .open = crtc_crc_open, > >> + .read = crtc_crc_read, > >> + .release = crtc_crc_release, > >> +}; > > > > Do we want to support poll? > > Don't see the point of it, TBH. I have difficulty coming up with a concrete use-case, but given that we have most of the infrastructure to support it already, it might be nice to have. Could of course be added later on if there's a need. > >> +static int drm_debugfs_crtc_add_for_minor(struct drm_crtc *crtc, > >> + struct drm_minor *minor) > >> +{ > >> + struct dentry *ent; > >> + char *name; > >> + > >> + if (!minor->debugfs_root) > >> + return -1; > > > > Can this ever happen? Perhaps turn this into a symbolic name if you > > really need it. > > Sorry, can you explain what you mean by that? I was referring to -1 not being a proper error code. Although I also questioned whether the check is even necessary. Under what circumstances will minor->debugfs_root be NULL at this point? > >> + > >> + name = kasprintf(GFP_KERNEL, "drm_crtc_%d_crc", crtc->index); > >> + if (!name) > >> + return -ENOMEM; > > > > I think it might be preferable to move this all into per-CRTC debugfs > > directories, perhaps even collapse the "crc" and "control" files. But in > > any case I think the drm_ prefix is redundant here and should be > > dropped. > > Yeah, I kind of like the redundancy as in the client code you will > only sometimes find the file name next to the directory name, but I > don't particularly care myself. Any client code dealing with display CRCs is going to be fairly DRM/KMS specific, no? As such the use of the drm_ prefix is pretty redundant no matter what. > >> +void drm_crtc_add_crc_entry(struct drm_crtc *crtc, uint32_t frame, > >> + uint32_t crc0, uint32_t crc1, uint32_t crc2, > >> + uint32_t crc3, uint32_t crc4) > > > > Perhaps allow passing the CRC as an array with a count parameter? I can > > imagine that a lot of hardware will only give you a single uint32_t for > > the CRC, in which case you could do: > > > > drm_crtc_add_crc_entry(crtc, frame, &crc, 1); > > > > instead of: > > > > drm_crtc_add_crc_entry(crtc, frame, crc, 0, 0, 0, 0); > > > > It would probably save poor users of the interface, such as myself, a > > lot of headaches because they can't remember how many uint32_t:s the > > function needs. > > Sounds good to me, I don't really know how common multiple sources of > complex CRC data will be in the future. When you mention multiple sources, are the additional values meant to be CRCs for additional sources? Or is it that some hardware generates more than 32 bits for the CRC and drivers are supposed to split them up into several values. > > >> diff --git a/drivers/gpu/drm/drm_internal.h b/drivers/gpu/drm/drm_internal.h > >> index 38401d406532..e5b124d937f5 100644 > >> --- a/drivers/gpu/drm/drm_internal.h > >> +++ b/drivers/gpu/drm/drm_internal.h > >> @@ -100,6 +100,8 @@ int drm_debugfs_init(struct drm_minor *minor, int minor_id, > >> int drm_debugfs_cleanup(struct drm_minor *minor); > >> int drm_debugfs_connector_add(struct drm_connector *connector); > >> void drm_debugfs_connector_remove(struct drm_connector *connector); > >> +int drm_debugfs_crtc_add(struct drm_crtc *crtc); > >> +void drm_debugfs_crtc_remove(struct drm_crtc *crtc); > > > > Oh... this isn't something that drivers are supposed to call? > > Right, it's analogous to drm_debugfs_connector_add. I recall seeing calls to this function from within the i915 driver, wouldn't that cause the build to fail if i915 was built as a loadable module? > >> + * > >> + * When CRC generation is enabled, the driver should call > >> + * drm_crtc_add_crc_entry() at each frame, providing any information > >> + * that characterizes the frame contents in the crcN arguments, as > >> + * provided from the configured source. Drivers should accept a "auto" > >> + * source name that will select a default source for this CRTC. > > > > Would it be useful to provide some more aliases? "enable" and "on" for > > "auto", "disable" and "off" for "none"? > > Not sure, TBH, i like to keep my interfaces simple. Do you think this > could be helpful? I don't know. It's probably okay to not have the aliases, and it should be trivial to add them later on if we see that people get annoyed by the fact that they have to write "auto" instead of "on" or "enable". Thierry
On Wed, Jun 22, 2016 at 3:32 PM, Thierry Reding <thierry.reding@gmail.com> wrote: >> >> + * wsp: (#0x20 | #0x9 | #0xA)+ >> >> + * >> >> + * eg.: >> >> + * "crtc 0 plane1" -> Start CRC computations on plane1 of first CRTC >> >> + * "crtc 0 none" -> Stop CRC >> > >> > I've said this above, but again, it seems odd to me that you'd have to >> > configure the CRC per-CRTC in one per-device file and read out the CRC >> > from per-CRTC files. >> >> Not sure, I like that the per-crtc files just provide CRC data, and >> that there's a separate control file that can be queried for the >> current state. > > In my opinion that makes things needlessly complicated for userspace. If > you want to query the state of a specific CRTC, you have to read out the > entire file and parse each line to find the correct CRTC. On the other > hand, chances are that you already need to know the path to the CRTC > because you want to read the CRC out of the per-CRTC CRC file. In that > case it would be much easier to simply concatenate the CRTC path and the > CRC (or control) filename and read a single line (actually a single > word) out of it to get at the same information. > > Furthermore if you have everything per-CRTC you no longer have to worry > about pipe vs. index (that's always confusing because in the DRM core > they're actually synonymous) because the CRTC path is canonical and will > have the correct context. > > Per-CRTC directory with a single duplex file, or separate control and > CRC files, is much simpler than the mix proposed here. No tokenization > required when parsing in userspace, and no tokenization required to > parse in the kernel either. Just jumping on this one here. I agree that if we remodel the interface making the control file per-crtc would make sense. I think separate control and read files makes sense, that's much less magic. And by reading the control file you can check what's the currently selected source easily. I'm not sure on the canonical CRTC path - right now we don't have that in debugfs. I think just using index numbers is ok, we use those all over the place already. Or maybe we could indeed add a new per-crtc subdir in debugfs for this. Either way is fine with me. -Daniel
On Wed, Jun 22, 2016 at 3:32 PM, Thierry Reding <thierry.reding@gmail.com> wrote: >> >> +const struct file_operations drm_crtc_crc_fops = { >> >> + .owner = THIS_MODULE, >> >> + .open = crtc_crc_open, >> >> + .read = crtc_crc_read, >> >> + .release = crtc_crc_release, >> >> +}; >> > >> > Do we want to support poll? >> >> Don't see the point of it, TBH. > > I have difficulty coming up with a concrete use-case, but given that we > have most of the infrastructure to support it already, it might be nice > to have. Could of course be added later on if there's a need. O_NONBLOCK is definitely needed to be able to write testcases, so that you can schedule flips and collect CRCs for them in parallel (e.g. to validate atomic flips by making sure there's never an intermediate CRC with garbage). I haven't seen a need yet for poll, and like you say it's easy to add if we ever need it. -Daniel
On Tue, Jun 21, 2016 at 01:06:41PM +0200, Tomeu Vizoso wrote: > Adds a per-device debugfile "drm_crc_control" that allows selecting a > source for frame checksums in each CRTC that supports them. > > The checksums for each subsequent frame can be read from the per-CRTC > file "drm_crtc_N_crc". > > The code is taken from the i915 driver and other drivers can now provide > frame CRCs by implementing the set_crc_source callback in > drm_crtc_funcs. > > Signed-off-by: Tomeu Vizoso <tomeu.vizoso@collabora.com> > --- > > drivers/gpu/drm/drm_crtc.c | 28 ++- > drivers/gpu/drm/drm_debugfs.c | 506 ++++++++++++++++++++++++++++++++++++++++- > drivers/gpu/drm/drm_internal.h | 10 + > include/drm/drmP.h | 5 + > include/drm/drm_crtc.h | 72 ++++++ > 5 files changed, 611 insertions(+), 10 deletions(-) I think we should finalize the internal and external api first, but this needs a bit better documentation. For that I think it'd be good to extract this to a new file like drm_debugfs_crc.[hc] and pull that into a new section (maybe under the testing and validation section, next to the igt howto) in drm-uapi.rst. More doc bikeshedding below. > > diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c > index e7c862bd2f19..4dae42b122d9 100644 > --- a/drivers/gpu/drm/drm_crtc.c > +++ b/drivers/gpu/drm/drm_crtc.c > @@ -657,8 +657,8 @@ int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc, > drm_num_crtcs(dev)); > } > if (!crtc->name) { > - drm_mode_object_unregister(dev, &crtc->base); > - return -ENOMEM; > + ret = -ENOMEM; > + goto err_unregister; > } > > crtc->base.properties = &crtc->properties; > @@ -673,12 +673,30 @@ int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc, > if (cursor) > cursor->possible_crtcs = 1 << drm_crtc_index(crtc); > > +#ifdef CONFIG_DEBUG_FS > + spin_lock_init(&crtc->crc.lock); > + init_waitqueue_head(&crtc->crc.wq); > + crtc->crc.debugfs_entries = kmalloc_array(DRM_MINOR_CNT, > + sizeof(*crtc->crc.debugfs_entries), > + GFP_KERNEL); > + > + ret = drm_debugfs_crtc_add(crtc); > + if (ret) > + goto err_free_name; > +#endif > + > if (drm_core_check_feature(dev, DRIVER_ATOMIC)) { > drm_object_attach_property(&crtc->base, config->prop_active, 0); > drm_object_attach_property(&crtc->base, config->prop_mode_id, 0); > } > > return 0; > + > +err_free_name: > + kfree(crtc->name); > +err_unregister: > + drm_mode_object_unregister(dev, &crtc->base); > + return ret; > } > EXPORT_SYMBOL(drm_crtc_init_with_planes); > > @@ -699,6 +717,12 @@ void drm_crtc_cleanup(struct drm_crtc *crtc) > * the indices on the drm_crtc after us in the crtc_list. > */ > > +#ifdef CONFIG_DEBUG_FS > + drm_debugfs_crtc_remove(crtc); > + kfree(crtc->crc.debugfs_entries); > + kfree(crtc->crc.source); > +#endif > + > kfree(crtc->gamma_store); > crtc->gamma_store = NULL; > > diff --git a/drivers/gpu/drm/drm_debugfs.c b/drivers/gpu/drm/drm_debugfs.c > index fa10cef2ba37..cdc8836bc22a 100644 > --- a/drivers/gpu/drm/drm_debugfs.c > +++ b/drivers/gpu/drm/drm_debugfs.c > @@ -30,6 +30,8 @@ > * OTHER DEALINGS IN THE SOFTWARE. > */ > > +#include <linux/circ_buf.h> > +#include <linux/ctype.h> > #include <linux/debugfs.h> > #include <linux/seq_file.h> > #include <linux/slab.h> > @@ -127,6 +129,259 @@ fail: > } > EXPORT_SYMBOL(drm_debugfs_create_files); > > +static int > +drm_add_fake_info_node(struct drm_minor *minor, > + struct dentry *ent, > + const void *key) > +{ > + struct drm_info_node *node; > + > + node = kmalloc(sizeof(*node), GFP_KERNEL); > + if (node == NULL) { > + debugfs_remove(ent); > + return -ENOMEM; > + } > + > + node->minor = minor; > + node->dent = ent; > + node->info_ent = (void *) key; > + > + mutex_lock(&minor->debugfs_lock); > + list_add(&node->list, &minor->debugfs_list); > + mutex_unlock(&minor->debugfs_lock); > + > + return 0; > +} > + > +static int crc_control_show(struct seq_file *m, void *data) > +{ > + struct drm_device *dev = m->private; > + struct drm_crtc *crtc; > + > + drm_for_each_crtc(crtc, dev) > + seq_printf(m, "crtc %d %s\n", crtc->index, > + crtc->crc.source ? crtc->crc.source : "none"); > + > + return 0; > +} > + > +static int crc_control_open(struct inode *inode, struct file *file) > +{ > + struct drm_device *dev = inode->i_private; > + > + return single_open(file, crc_control_show, dev); > +} > + > +static int crc_control_update_crtc(struct drm_crtc *crtc, const char *source) > +{ > + struct drm_crtc_crc *crc = &crtc->crc; > + struct drm_crtc_crc_entry *entries; > + int ret; > + > + if (!strcmp(source, "none")) > + source = NULL; > + > + if (!crc->source && !source) > + return 0; > + > + if (crc->source && source && !strcmp(crc->source, source)) > + return 0; > + > + /* Forbid changing the source without going back to "none". */ > + if (crc->source && source) > + return -EINVAL; > + > + if (!crtc->funcs->set_crc_source) > + return -ENOTSUPP; > + > + if (source) { > + entries = kcalloc(DRM_CRTC_CRC_ENTRIES_NR, > + sizeof(crc->entries[0]), > + GFP_KERNEL); > + if (!entries) > + return -ENOMEM; > + > + spin_lock_irq(&crc->lock); > + kfree(crc->entries); > + crc->entries = entries; > + crc->head = 0; > + crc->tail = 0; > + spin_unlock_irq(&crc->lock); > + } > + > + ret = crtc->funcs->set_crc_source(crtc, source); > + if (ret) > + return ret; > + > + kfree(crc->source); > + crc->source = source ? kstrdup(source, GFP_KERNEL) : NULL; > + > + if (!source) { > + spin_lock_irq(&crc->lock); > + entries = crc->entries; > + crc->entries = NULL; > + crc->head = 0; > + crc->tail = 0; > + spin_unlock_irq(&crc->lock); > + > + kfree(entries); > + } > + > + return 0; > +} > + > +static struct drm_crtc *crtc_from_index(struct drm_device *dev, int index) > +{ > + struct drm_crtc *crtc; > + int i = 0; > + > + drm_for_each_crtc(crtc, dev) > + if (i++ == index) > + return crtc; > + > + return NULL; > +} > + > +/* > + * Parse CRC command strings: > + * command: wsp* object wsp+ (crtc | pipe) wsp+ source wsp* > + * object: ('crtc' | 'pipe') > + * crtc: (0 | 1 | 2 | ...) > + * pipe: (A | B | C) > + * source: (none | plane1 | plane2 | ...) > + * wsp: (#0x20 | #0x9 | #0xA)+ > + * > + * eg.: > + * "crtc 0 plane1" -> Start CRC computations on plane1 of first CRTC > + * "crtc 0 none" -> Stop CRC > + */ > +static int crc_control_tokenize(char *buf, char *words[], int max_words) > +{ > + int n_words = 0; > + > + while (*buf) { > + char *end; > + > + /* skip leading white space */ > + buf = skip_spaces(buf); > + if (!*buf) > + break; /* end of buffer */ > + > + /* find end of word */ > + for (end = buf; *end && !isspace(*end); end++) > + ; > + > + if (n_words == max_words) { > + DRM_DEBUG_KMS("too many words, allowed <= %d\n", > + max_words); > + return -EINVAL; /* ran out of words[] before bytes */ > + } > + > + if (*end) > + *end++ = '\0'; > + words[n_words++] = buf; > + buf = end; > + } > + > + return n_words; > +} > + > +static int crc_control_parse_crtc(const char *buf, unsigned int *crtc_index) > +{ > + const char letter = buf[0]; > + > + if (!kstrtouint(buf, 10, crtc_index)) > + return 0; > + > + /* Backwards compatibility for Intel-style pipe letters */ > + if (letter < 'A' || letter > 'Z') > + return -EINVAL; > + > + *crtc_index = letter - 'A'; > + > + return 0; > +} > + > +static int crc_control_parse(struct drm_device *dev, char *buf, size_t len) > +{ > +#define N_WORDS 3 > + int n_words; > + char *words[N_WORDS]; > + unsigned int crtc_index; > + struct drm_crtc *crtc; > + > + n_words = crc_control_tokenize(buf, words, N_WORDS); > + if (n_words != N_WORDS) { > + DRM_DEBUG_KMS("tokenize failed, a command is %d words\n", > + N_WORDS); > + return -EINVAL; > + } > + > + if (strcmp(words[0], "crtc") && strcmp(words[0], "pipe")) { > + DRM_DEBUG_KMS("Invalid command %s\n", words[0]); > + return -EINVAL; > + } > + > + if (crc_control_parse_crtc(words[1], &crtc_index) < 0) { > + DRM_DEBUG_KMS("Invalid CRTC index: %s\n", words[1]); > + return -EINVAL; > + } > + > + crtc = crtc_from_index(dev, crtc_index); > + if (!crtc) { > + DRM_DEBUG_KMS("Unknown CRTC index: %d\n", crtc_index); > + return -EINVAL; > + } > + > + return crc_control_update_crtc(crtc, words[2]); > +} > + > +static ssize_t crc_control_write(struct file *file, const char __user *ubuf, > + size_t len, loff_t *offp) > +{ > + struct seq_file *m = file->private_data; > + struct drm_device *dev = m->private; > + char *tmpbuf; > + int ret; > + > + if (len == 0) > + return 0; > + > + if (len > PAGE_SIZE - 1) { > + DRM_DEBUG_KMS("expected <%lu bytes into crtc crc control\n", > + PAGE_SIZE); > + return -E2BIG; > + } > + > + tmpbuf = kmalloc(len + 1, GFP_KERNEL); > + if (!tmpbuf) > + return -ENOMEM; > + > + if (copy_from_user(tmpbuf, ubuf, len)) { > + ret = -EFAULT; > + goto out; > + } > + tmpbuf[len] = '\0'; > + > + ret = crc_control_parse(dev, tmpbuf, len); > +out: > + kfree(tmpbuf); > + if (ret < 0) > + return ret; > + > + *offp += len; > + return len; > +} > + > +const struct file_operations drm_crc_control_fops = { > + .owner = THIS_MODULE, > + .open = crc_control_open, > + .read = seq_read, > + .llseek = seq_lseek, > + .release = single_release, > + .write = crc_control_write > +}; > + > /** > * Initialize the DRI debugfs filesystem for a device > * > @@ -142,8 +397,9 @@ int drm_debugfs_init(struct drm_minor *minor, int minor_id, > struct dentry *root) > { > struct drm_device *dev = minor->dev; > + struct dentry *ent; > char name[64]; > - int ret; > + int ret = 0; > > INIT_LIST_HEAD(&minor->debugfs_list); > mutex_init(&minor->debugfs_lock); > @@ -157,10 +413,23 @@ int drm_debugfs_init(struct drm_minor *minor, int minor_id, > ret = drm_debugfs_create_files(drm_debugfs_list, DRM_DEBUGFS_ENTRIES, > minor->debugfs_root, minor); > if (ret) { > - debugfs_remove(minor->debugfs_root); > - minor->debugfs_root = NULL; > DRM_ERROR("Failed to create core drm debugfs files\n"); > - return ret; > + goto error_remove_dir; > + } > + > + ent = debugfs_create_file("drm_crc_control", S_IRUGO | S_IWUSR, > + minor->debugfs_root, dev, > + &drm_crc_control_fops); > + if (!ent) { > + DRM_ERROR("Failed to create CRC control debugfs files\n"); > + ret = -ENOMEM; > + goto error_remove_files; > + } > + > + ret = drm_add_fake_info_node(minor, ent, &drm_crc_control_fops); > + if (ret) { > + DRM_ERROR("Failed to create CRC control debugfs files\n"); > + goto error_remove_crc; > } > > if (dev->driver->debugfs_init) { > @@ -171,7 +440,18 @@ int drm_debugfs_init(struct drm_minor *minor, int minor_id, > return ret; > } > } > + > return 0; > + > +error_remove_crc: > + debugfs_remove(ent); > +error_remove_files: > + drm_debugfs_remove_files(drm_debugfs_list, DRM_DEBUGFS_ENTRIES, minor); > +error_remove_dir: > + debugfs_remove(minor->debugfs_root); > + minor->debugfs_root = NULL; > + > + return ret; > } > > > @@ -407,13 +687,223 @@ error: > > void drm_debugfs_connector_remove(struct drm_connector *connector) > { > - if (!connector->debugfs_entry) > - return; > - > debugfs_remove_recursive(connector->debugfs_entry); > > connector->debugfs_entry = NULL; > } > > -#endif /* CONFIG_DEBUG_FS */ > +static int crtc_crc_open(struct inode *inode, struct file *filep) > +{ > + struct drm_crtc *crtc = inode->i_private; > + struct drm_crtc_crc *crc = &crtc->crc; > + > + spin_lock_irq(&crc->lock); > + > + if (crc->opened) { > + spin_unlock_irq(&crc->lock); > + return -EBUSY; > + } > + > + crc->opened = true; > + > + spin_unlock_irq(&crc->lock); > + > + return 0; > +} > + > +static int crtc_crc_release(struct inode *inode, struct file *filep) > +{ > + struct drm_crtc *crtc = filep->f_inode->i_private; > + struct drm_crtc_crc *crc = &crtc->crc; > + > + spin_lock_irq(&crc->lock); > + crc->opened = false; > + spin_unlock_irq(&crc->lock); > + > + return 0; > +} > + > +/* (6 fields, 8 chars each, space separated (5) + '\n') */ > +#define CRC_LINE_LEN (6 * 8 + 5 + 1) > +/* account for \'0' */ > +#define CRC_BUFFER_LEN (CRC_LINE_LEN + 1) > + > +static int crtc_crc_data_count(struct drm_crtc_crc *crc) > +{ > + assert_spin_locked(&crc->lock); > + return CIRC_CNT(crc->head, crc->tail, > + DRM_CRTC_CRC_ENTRIES_NR); > +} > + > +static ssize_t crtc_crc_read(struct file *filep, char __user *user_buf, > + size_t count, loff_t *pos) > +{ > + struct drm_crtc *crtc = filep->f_inode->i_private; > + struct drm_crtc_crc *crc = &crtc->crc; > + char buf[CRC_BUFFER_LEN]; > + int n_entries; > + ssize_t bytes_read; > + > + /* > + * Don't allow user space to provide buffers not big enough to hold > + * a line of data. > + */ > + if (count < CRC_LINE_LEN) > + return -EINVAL; > + > + if (!crc->source) > + return 0; > + > + /* Nothing to read? */ > + spin_lock_irq(&crc->lock); > + while (crtc_crc_data_count(crc) == 0) { > + int ret; > + > + if (filep->f_flags & O_NONBLOCK) { > + spin_unlock_irq(&crc->lock); > + return -EAGAIN; > + } > + > + ret = wait_event_interruptible_lock_irq(crc->wq, > + crtc_crc_data_count(crc), crc->lock); > + if (ret) { > + spin_unlock_irq(&crc->lock); > + return ret; > + } > + } > + > + /* We now have one or more entries to read */ > + n_entries = count / CRC_LINE_LEN; > + > + bytes_read = 0; > + while (n_entries > 0) { > + struct drm_crtc_crc_entry *entry = > + &crc->entries[crc->tail]; > + int ret; > + > + if (CIRC_CNT(crc->head, crc->tail, DRM_CRTC_CRC_ENTRIES_NR) < 1) > + break; > + > + BUILD_BUG_ON_NOT_POWER_OF_2(DRM_CRTC_CRC_ENTRIES_NR); > + crc->tail = (crc->tail + 1) & (DRM_CRTC_CRC_ENTRIES_NR - 1); > + > + bytes_read += snprintf(buf, CRC_BUFFER_LEN, > + "%8u %8x %8x %8x %8x %8x\n", > + entry->frame, entry->crc[0], > + entry->crc[1], entry->crc[2], > + entry->crc[3], entry->crc[4]); > + > + spin_unlock_irq(&crc->lock); > + > + ret = copy_to_user(user_buf, buf, CRC_LINE_LEN); > + if (ret == CRC_LINE_LEN) > + return -EFAULT; > > + user_buf += CRC_LINE_LEN; > + n_entries--; > + > + spin_lock_irq(&crc->lock); > + } > + > + spin_unlock_irq(&crc->lock); > + > + return bytes_read; > +} > + > +const struct file_operations drm_crtc_crc_fops = { > + .owner = THIS_MODULE, > + .open = crtc_crc_open, > + .read = crtc_crc_read, > + .release = crtc_crc_release, > +}; > + > +static int drm_debugfs_crtc_add_for_minor(struct drm_crtc *crtc, > + struct drm_minor *minor) > +{ > + struct dentry *ent; > + char *name; > + > + if (!minor->debugfs_root) > + return -1; > + > + name = kasprintf(GFP_KERNEL, "drm_crtc_%d_crc", crtc->index); I'd check for set_crc_source here and just not add the file if it's not set. Seems a bit silly to expose an interface when it's not there. -Daniel > + if (!name) > + return -ENOMEM; > + > + ent = debugfs_create_file(name, S_IRUGO, minor->debugfs_root, crtc, > + &drm_crtc_crc_fops); > + kfree(name); > + if (!ent) > + return PTR_ERR(ent); > + > + crtc->crc.debugfs_entries[minor->type] = ent; > + > + return 0; > +} > + > +int drm_debugfs_crtc_add(struct drm_crtc *crtc) > +{ > + int ret; > + > + ret = drm_debugfs_crtc_add_for_minor(crtc, crtc->dev->control); > + if (ret) > + return ret; > + > + ret = drm_debugfs_crtc_add_for_minor(crtc, crtc->dev->primary); > + if (ret) > + return ret; > + > + ret = drm_debugfs_crtc_add_for_minor(crtc, crtc->dev->render); > + if (ret) > + return ret; > + > + return 0; > +} > + > +void drm_debugfs_crtc_remove(struct drm_crtc *crtc) > +{ > + int i; > + > + for (i = 0; i < DRM_MINOR_CNT; i++) { > + debugfs_remove_recursive(crtc->crc.debugfs_entries[i]); > + crtc->crc.debugfs_entries[i] = NULL; > + } > +} > + > +void drm_crtc_add_crc_entry(struct drm_crtc *crtc, uint32_t frame, > + uint32_t crc0, uint32_t crc1, uint32_t crc2, > + uint32_t crc3, uint32_t crc4) > +{ > + struct drm_crtc_crc *crc = &crtc->crc; > + struct drm_crtc_crc_entry *entry; > + int head, tail; > + > + spin_lock(&crc->lock); > + > + head = crc->head; > + tail = crc->tail; > + > + if (CIRC_SPACE(head, tail, DRM_CRTC_CRC_ENTRIES_NR) < 1) { > + spin_unlock(&crc->lock); > + DRM_ERROR("Overflow of CRC buffer, userspace reads too slow.\n"); > + return; > + } > + > + entry = &crc->entries[head]; > + > + entry->frame = frame; > + entry->crc[0] = crc0; > + entry->crc[1] = crc1; > + entry->crc[2] = crc2; > + entry->crc[3] = crc3; > + entry->crc[4] = crc4; > + > + head = (head + 1) & (DRM_CRTC_CRC_ENTRIES_NR - 1); > + crc->head = head; > + > + spin_unlock(&crc->lock); > + > + wake_up_interruptible(&crc->wq); > +} > + > +#endif /* CONFIG_DEBUG_FS */ > diff --git a/drivers/gpu/drm/drm_internal.h b/drivers/gpu/drm/drm_internal.h > index 38401d406532..e5b124d937f5 100644 > --- a/drivers/gpu/drm/drm_internal.h > +++ b/drivers/gpu/drm/drm_internal.h > @@ -100,6 +100,8 @@ int drm_debugfs_init(struct drm_minor *minor, int minor_id, > int drm_debugfs_cleanup(struct drm_minor *minor); > int drm_debugfs_connector_add(struct drm_connector *connector); > void drm_debugfs_connector_remove(struct drm_connector *connector); > +int drm_debugfs_crtc_add(struct drm_crtc *crtc); > +void drm_debugfs_crtc_remove(struct drm_crtc *crtc); > #else > static inline int drm_debugfs_init(struct drm_minor *minor, int minor_id, > struct dentry *root) > @@ -119,4 +121,12 @@ static inline int drm_debugfs_connector_add(struct drm_connector *connector) > static inline void drm_debugfs_connector_remove(struct drm_connector *connector) > { > } > + > +static inline int drm_debugfs_crtc_add(struct drm_crtc *crtc) > +{ > + return 0; > +} > +static inline void drm_debugfs_crtc_remove(struct drm_crtc *crtc) > +{ > +} > #endif > diff --git a/include/drm/drmP.h b/include/drm/drmP.h > index 084fd141e8bf..ec2f91c8b7cd 100644 > --- a/include/drm/drmP.h > +++ b/include/drm/drmP.h > @@ -1142,6 +1142,11 @@ static __inline__ bool drm_can_sleep(void) > return true; > } > > +#if defined(CONFIG_DEBUG_FS) > +extern const struct file_operations drm_crc_control_fops; > +extern const struct file_operations drm_crtc_crc_fops; > +#endif > + > /* helper for handling conditionals in various for_each macros */ > #define for_each_if(condition) if (!(condition)) {} else > > diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h > index c2734979f164..141335a3c647 100644 > --- a/include/drm/drm_crtc.h > +++ b/include/drm/drm_crtc.h > @@ -376,6 +376,22 @@ struct drm_crtc_state { > struct drm_atomic_state *state; > }; > > +struct drm_crtc_crc_entry { > + uint32_t frame; > + uint32_t crc[5]; > +}; > + > +#define DRM_CRTC_CRC_ENTRIES_NR 128 > +struct drm_crtc_crc { > + spinlock_t lock; > + const char *source; > + bool opened; /* exclusive access to the result file */ > + struct drm_crtc_crc_entry *entries; > + int head, tail; > + wait_queue_head_t wq; > + struct dentry **debugfs_entries; > +}; I think the above two should be moved into drm_debugfs_crc.h and also documented with kerneldoc. > + > /** > * struct drm_crtc_funcs - control CRTCs for a given device > * > @@ -704,6 +720,29 @@ struct drm_crtc_funcs { > const struct drm_crtc_state *state, > struct drm_property *property, > uint64_t *val); > + > + /** > + * @set_crc_source: > + * > + * Changes the source of CRC checksums of frames at the request of > + * userspace, typically for testing purposes. The sources available are > + * specific of each driver and a %NULL value indicates that CRC > + * generation is to be switched off. > + * > + * When CRC generation is enabled, the driver should call > + * drm_crtc_add_crc_entry() at each frame, providing any information > + * that characterizes the frame contents in the crcN arguments, as > + * provided from the configured source. Drivers should accept a "auto" > + * source name that will select a default source for this CRTC. > + * > + * This callback is optional if the driver does not support any CRC > + * generation functionality. > + * > + * RETURNS: > + * > + * 0 on success or a negative error code on failure. > + */ > + int (*set_crc_source)(struct drm_crtc *crtc, const char *source); > }; > > /** > @@ -817,6 +856,15 @@ struct drm_crtc { > * context. > */ > struct drm_modeset_acquire_ctx *acquire_ctx; > + > +#ifdef CONFIG_DEBUG_FS > + /** > + * @drm_crtc_crc: > + * > + * Configuration settings of CRC capture. > + */ > + struct drm_crtc_crc crc; > +#endif > }; > > /** > @@ -2496,6 +2544,30 @@ static inline uint32_t drm_crtc_mask(struct drm_crtc *crtc) > return 1 << drm_crtc_index(crtc); > } > > +/** > + * drm_crtc_add_crc_entry - Add entry with CRC information for a frame > + * @crtc: CRTC to which the frame belongs > + * @frame: number of the frame characterized by the CRC data > + * @crc0: piece of data about frame > + * @crc1: piece of data about frame > + * @crc2: piece of data about frame > + * @crc3: piece of data about frame > + * @crc4: piece of data about frame > + * > + * For each frame, the driver polls the source of CRCs for new data and calls > + * this function to add them to the buffer from where userspace reads. > + */ Generally we put the kerneldoc for functions into the source file. Only static inlines and structures are documented in the headers. > +#if defined(CONFIG_DEBUG_FS) > +void drm_crtc_add_crc_entry(struct drm_crtc *crtc, uint32_t frame, > + uint32_t crc0, uint32_t crc1, uint32_t crc2, > + uint32_t crc3, uint32_t crc4); > +#else > +static inline void drm_crtc_add_crc_entry(struct drm_crtc *crtc, uint32_t frame, > + uint32_t crc0, uint32_t crc1, > + uint32_t crc2, uint32_t crc3, > + uint32_t crc4) {} > +#endif > + > extern void drm_connector_ida_init(void); > extern void drm_connector_ida_destroy(void); > extern int drm_connector_init(struct drm_device *dev, > -- > 2.5.5 > > _______________________________________________ > dri-devel mailing list > dri-devel@lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/dri-devel
On Wed, Jun 22, 2016 at 04:08:52PM +0200, Daniel Vetter wrote: > On Wed, Jun 22, 2016 at 3:32 PM, Thierry Reding > <thierry.reding@gmail.com> wrote: > >> >> + * wsp: (#0x20 | #0x9 | #0xA)+ > >> >> + * > >> >> + * eg.: > >> >> + * "crtc 0 plane1" -> Start CRC computations on plane1 of first CRTC > >> >> + * "crtc 0 none" -> Stop CRC > >> > > >> > I've said this above, but again, it seems odd to me that you'd have to > >> > configure the CRC per-CRTC in one per-device file and read out the CRC > >> > from per-CRTC files. > >> > >> Not sure, I like that the per-crtc files just provide CRC data, and > >> that there's a separate control file that can be queried for the > >> current state. > > > > In my opinion that makes things needlessly complicated for userspace. If > > you want to query the state of a specific CRTC, you have to read out the > > entire file and parse each line to find the correct CRTC. On the other > > hand, chances are that you already need to know the path to the CRTC > > because you want to read the CRC out of the per-CRTC CRC file. In that > > case it would be much easier to simply concatenate the CRTC path and the > > CRC (or control) filename and read a single line (actually a single > > word) out of it to get at the same information. > > > > Furthermore if you have everything per-CRTC you no longer have to worry > > about pipe vs. index (that's always confusing because in the DRM core > > they're actually synonymous) because the CRTC path is canonical and will > > have the correct context. > > > > Per-CRTC directory with a single duplex file, or separate control and > > CRC files, is much simpler than the mix proposed here. No tokenization > > required when parsing in userspace, and no tokenization required to > > parse in the kernel either. > > Just jumping on this one here. I agree that if we remodel the > interface making the control file per-crtc would make sense. I think > separate control and read files makes sense, that's much less magic. Agreed, separate files would be a little simpler. I must admit that my proposal is partially motivated by a desire to avoid cumbersome naming of files. If we have separate files, what do you name them? crc for reading, crc_control for writing? crc_values for reading and crc for writing? Perhaps another way to avoid that would be to put the two files into a separate directory, as in: /sys/kernel/debug/dri/<minor>/crtc-<pipe>/crc/ +-- control +-- data That's slightly on the deeply nested side, but on the other hand it nicely uses the filesystem for namespacing, which is what filesystems are really good at. > And by reading the control file you can check what's the currently > selected source easily. Is that really a useful feature? If you're going to capture CRCs, you likely just want to set whatever you expect to receive irrespective of the current setting. > I'm not sure on the canonical CRTC path - right now we don't have that > in debugfs. I think just using index numbers is ok, we use those all > over the place already. Or maybe we could indeed add a new per-crtc > subdir in debugfs for this. Either way is fine with me. I can imagine that we'd like to expose a number of other per-CRTC properties (name, parts of the state, object ID, one day perhaps VBLANK counts, ...) this way, so a per-CRTC directory makes a lot of sense in my opinion. Thierry
On Wed, Jun 22, 2016 at 4:31 PM, Thierry Reding <thierry.reding@gmail.com> wrote: > On Wed, Jun 22, 2016 at 04:08:52PM +0200, Daniel Vetter wrote: >> On Wed, Jun 22, 2016 at 3:32 PM, Thierry Reding >> <thierry.reding@gmail.com> wrote: >> >> >> + * wsp: (#0x20 | #0x9 | #0xA)+ >> >> >> + * >> >> >> + * eg.: >> >> >> + * "crtc 0 plane1" -> Start CRC computations on plane1 of first CRTC >> >> >> + * "crtc 0 none" -> Stop CRC >> >> > >> >> > I've said this above, but again, it seems odd to me that you'd have to >> >> > configure the CRC per-CRTC in one per-device file and read out the CRC >> >> > from per-CRTC files. >> >> >> >> Not sure, I like that the per-crtc files just provide CRC data, and >> >> that there's a separate control file that can be queried for the >> >> current state. >> > >> > In my opinion that makes things needlessly complicated for userspace. If >> > you want to query the state of a specific CRTC, you have to read out the >> > entire file and parse each line to find the correct CRTC. On the other >> > hand, chances are that you already need to know the path to the CRTC >> > because you want to read the CRC out of the per-CRTC CRC file. In that >> > case it would be much easier to simply concatenate the CRTC path and the >> > CRC (or control) filename and read a single line (actually a single >> > word) out of it to get at the same information. >> > >> > Furthermore if you have everything per-CRTC you no longer have to worry >> > about pipe vs. index (that's always confusing because in the DRM core >> > they're actually synonymous) because the CRTC path is canonical and will >> > have the correct context. >> > >> > Per-CRTC directory with a single duplex file, or separate control and >> > CRC files, is much simpler than the mix proposed here. No tokenization >> > required when parsing in userspace, and no tokenization required to >> > parse in the kernel either. >> >> Just jumping on this one here. I agree that if we remodel the >> interface making the control file per-crtc would make sense. I think >> separate control and read files makes sense, that's much less magic. > > Agreed, separate files would be a little simpler. I must admit that my > proposal is partially motivated by a desire to avoid cumbersome naming > of files. If we have separate files, what do you name them? crc for > reading, crc_control for writing? crc_values for reading and crc for > writing? > > Perhaps another way to avoid that would be to put the two files into a > separate directory, as in: > > /sys/kernel/debug/dri/<minor>/crtc-<pipe>/crc/ > +-- control > +-- data > > That's slightly on the deeply nested side, but on the other hand it > nicely uses the filesystem for namespacing, which is what filesystems > are really good at. crtc-<index>/crc/(control|data) sounds great. >> And by reading the control file you can check what's the currently >> selected source easily. > > Is that really a useful feature? If you're going to capture CRCs, you > likely just want to set whatever you expect to receive irrespective of > the current setting. I think it's useful for hacking together your driver support, going through tests it one more indirection. And I have a really bad attention span ;-) >> I'm not sure on the canonical CRTC path - right now we don't have that >> in debugfs. I think just using index numbers is ok, we use those all >> over the place already. Or maybe we could indeed add a new per-crtc >> subdir in debugfs for this. Either way is fine with me. > > I can imagine that we'd like to expose a number of other per-CRTC > properties (name, parts of the state, object ID, one day perhaps VBLANK > counts, ...) this way, so a per-CRTC directory makes a lot of sense in > my opinion. Yeah, we might have room for more ... otoh for read-only debug information I prefer big files that dump everything. Easier to extend. But for tests/automation the one-value-per-file idea from sysfs, or at least going much closer to that idea is a good idea. -Daniel
On Wed, 22 Jun 2016, Daniel Vetter <daniel@ffwll.ch> wrote: > On Wed, Jun 22, 2016 at 4:31 PM, Thierry Reding > <thierry.reding@gmail.com> wrote: >> Perhaps another way to avoid that would be to put the two files into a >> separate directory, as in: >> >> /sys/kernel/debug/dri/<minor>/crtc-<pipe>/crc/ >> +-- control >> +-- data >> >> That's slightly on the deeply nested side, but on the other hand it >> nicely uses the filesystem for namespacing, which is what filesystems >> are really good at. > > crtc-<index>/crc/(control|data) sounds great. Side note, we should eventually do the same for sink CRCs, but I guess under the connectors. i915 currently has a special cased version for eDP (named "i915_sink_crc_eDP1"...), reading the data from DPCD. BR, Jani.
On 23 June 2016 at 10:21, Jani Nikula <jani.nikula@linux.intel.com> wrote: > On Wed, 22 Jun 2016, Daniel Vetter <daniel@ffwll.ch> wrote: >> On Wed, Jun 22, 2016 at 4:31 PM, Thierry Reding >> <thierry.reding@gmail.com> wrote: >>> Perhaps another way to avoid that would be to put the two files into a >>> separate directory, as in: >>> >>> /sys/kernel/debug/dri/<minor>/crtc-<pipe>/crc/ >>> +-- control >>> +-- data >>> >>> That's slightly on the deeply nested side, but on the other hand it >>> nicely uses the filesystem for namespacing, which is what filesystems >>> are really good at. >> >> crtc-<index>/crc/(control|data) sounds great. > > Side note, we should eventually do the same for sink CRCs, but I guess > under the connectors. i915 currently has a special cased version for eDP > (named "i915_sink_crc_eDP1"...), reading the data from DPCD. Was hoping we could just add one more source to this interface to expose those. Regards, Tomeu
On Thu, Jun 23, 2016 at 10:24:46AM +0200, Tomeu Vizoso wrote: > On 23 June 2016 at 10:21, Jani Nikula <jani.nikula@linux.intel.com> wrote: > > On Wed, 22 Jun 2016, Daniel Vetter <daniel@ffwll.ch> wrote: > >> On Wed, Jun 22, 2016 at 4:31 PM, Thierry Reding > >> <thierry.reding@gmail.com> wrote: > >>> Perhaps another way to avoid that would be to put the two files into a > >>> separate directory, as in: > >>> > >>> /sys/kernel/debug/dri/<minor>/crtc-<pipe>/crc/ > >>> +-- control > >>> +-- data > >>> > >>> That's slightly on the deeply nested side, but on the other hand it > >>> nicely uses the filesystem for namespacing, which is what filesystems > >>> are really good at. > >> > >> crtc-<index>/crc/(control|data) sounds great. > > > > Side note, we should eventually do the same for sink CRCs, but I guess > > under the connectors. i915 currently has a special cased version for eDP > > (named "i915_sink_crc_eDP1"...), reading the data from DPCD. > > Was hoping we could just add one more source to this interface to expose those. I don't think that would be easy to achieve. You'd have to determine that a sink source is connected to the CRTC and then ajdust the list of possible sources dynamically. For connectors we already have separate directories in debugfs and a sink can easily be found from the connector it is attached to. It's also possible, though I don't know of any that do so currently, that eventually sinks will support several types (i.e. "sources") of CRC, which will further complicate to represent this in the CRTC's list of CRC sources. And it may also be useful to have both CRCs at the same time. The eDP specification for example defines a very specific polynomial that is used to compute the CRC, whereas not all display hardware uses a CRC algorithm that's documented. Finally, the data that will be checksummed by the CRTC isn't necessarily the same as that arriving at the sink. Thierry
On Thu, Jun 23, 2016 at 10:43 AM, Thierry Reding <thierry.reding@gmail.com> wrote: > On Thu, Jun 23, 2016 at 10:24:46AM +0200, Tomeu Vizoso wrote: >> On 23 June 2016 at 10:21, Jani Nikula <jani.nikula@linux.intel.com> wrote: >> > On Wed, 22 Jun 2016, Daniel Vetter <daniel@ffwll.ch> wrote: >> >> On Wed, Jun 22, 2016 at 4:31 PM, Thierry Reding >> >> <thierry.reding@gmail.com> wrote: >> >>> Perhaps another way to avoid that would be to put the two files into a >> >>> separate directory, as in: >> >>> >> >>> /sys/kernel/debug/dri/<minor>/crtc-<pipe>/crc/ >> >>> +-- control >> >>> +-- data >> >>> >> >>> That's slightly on the deeply nested side, but on the other hand it >> >>> nicely uses the filesystem for namespacing, which is what filesystems >> >>> are really good at. >> >> >> >> crtc-<index>/crc/(control|data) sounds great. >> > >> > Side note, we should eventually do the same for sink CRCs, but I guess >> > under the connectors. i915 currently has a special cased version for eDP >> > (named "i915_sink_crc_eDP1"...), reading the data from DPCD. >> >> Was hoping we could just add one more source to this interface to expose those. > > I don't think that would be easy to achieve. You'd have to determine > that a sink source is connected to the CRTC and then ajdust the list > of possible sources dynamically. > > For connectors we already have separate directories in debugfs and a > sink can easily be found from the connector it is attached to. > > It's also possible, though I don't know of any that do so currently, > that eventually sinks will support several types (i.e. "sources") of > CRC, which will further complicate to represent this in the CRTC's > list of CRC sources. > > And it may also be useful to have both CRCs at the same time. The eDP > specification for example defines a very specific polynomial that is > used to compute the CRC, whereas not all display hardware uses a CRC > algorithm that's documented. > > Finally, the data that will be checksummed by the CRTC isn't necessarily > the same as that arriving at the sink. We already do all that for i915. On some platforms the normal end-of-pipe CRC doesn't work together with DP, instead you need to use a special port (= connector/encoder) based CRC. The "auto" one automatically walks the modeset config on those platforms to figure out which one to pick. It would be kinda hard for userspace to automatically figure out when the auto CRC doesn't work on the CRTC and it would instead need to use the connector one. I think it'd better to hide that in the kernel driver, where it's known. Wrt specific polynomials: We could just spec that the "eDP-sink" source is the one with CRC computed per the eDP spec. Similar for anything else standardize. Heck you could even do the same with vendor specific CRCs on IP blocks by using special names. Wrt CRC measuring different data: That's also already the case on i915. We have CRC for pre-gamma, post-gamma, post panel-fitter, on the port, with or without audio stream included, .... And this all even varies between platforms. The only thing that's specifified is that "auto" should be some CRC after all the blending/color-correction has been applied, but before any port specific scrambling happens which might make the CRC change with each frame. E.g. on platforms where auto aliases the DP ports we need to set a special bit to reset the scrambler state on each vblank to ensure stable CRCs. Given all that I think putting sink crc capture into the same framework makes sense. -Daniel
diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c index e7c862bd2f19..4dae42b122d9 100644 --- a/drivers/gpu/drm/drm_crtc.c +++ b/drivers/gpu/drm/drm_crtc.c @@ -657,8 +657,8 @@ int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc, drm_num_crtcs(dev)); } if (!crtc->name) { - drm_mode_object_unregister(dev, &crtc->base); - return -ENOMEM; + ret = -ENOMEM; + goto err_unregister; } crtc->base.properties = &crtc->properties; @@ -673,12 +673,30 @@ int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc, if (cursor) cursor->possible_crtcs = 1 << drm_crtc_index(crtc); +#ifdef CONFIG_DEBUG_FS + spin_lock_init(&crtc->crc.lock); + init_waitqueue_head(&crtc->crc.wq); + crtc->crc.debugfs_entries = kmalloc_array(DRM_MINOR_CNT, + sizeof(*crtc->crc.debugfs_entries), + GFP_KERNEL); + + ret = drm_debugfs_crtc_add(crtc); + if (ret) + goto err_free_name; +#endif + if (drm_core_check_feature(dev, DRIVER_ATOMIC)) { drm_object_attach_property(&crtc->base, config->prop_active, 0); drm_object_attach_property(&crtc->base, config->prop_mode_id, 0); } return 0; + +err_free_name: + kfree(crtc->name); +err_unregister: + drm_mode_object_unregister(dev, &crtc->base); + return ret; } EXPORT_SYMBOL(drm_crtc_init_with_planes); @@ -699,6 +717,12 @@ void drm_crtc_cleanup(struct drm_crtc *crtc) * the indices on the drm_crtc after us in the crtc_list. */ +#ifdef CONFIG_DEBUG_FS + drm_debugfs_crtc_remove(crtc); + kfree(crtc->crc.debugfs_entries); + kfree(crtc->crc.source); +#endif + kfree(crtc->gamma_store); crtc->gamma_store = NULL; diff --git a/drivers/gpu/drm/drm_debugfs.c b/drivers/gpu/drm/drm_debugfs.c index fa10cef2ba37..cdc8836bc22a 100644 --- a/drivers/gpu/drm/drm_debugfs.c +++ b/drivers/gpu/drm/drm_debugfs.c @@ -30,6 +30,8 @@ * OTHER DEALINGS IN THE SOFTWARE. */ +#include <linux/circ_buf.h> +#include <linux/ctype.h> #include <linux/debugfs.h> #include <linux/seq_file.h> #include <linux/slab.h> @@ -127,6 +129,259 @@ fail: } EXPORT_SYMBOL(drm_debugfs_create_files); +static int +drm_add_fake_info_node(struct drm_minor *minor, + struct dentry *ent, + const void *key) +{ + struct drm_info_node *node; + + node = kmalloc(sizeof(*node), GFP_KERNEL); + if (node == NULL) { + debugfs_remove(ent); + return -ENOMEM; + } + + node->minor = minor; + node->dent = ent; + node->info_ent = (void *) key; + + mutex_lock(&minor->debugfs_lock); + list_add(&node->list, &minor->debugfs_list); + mutex_unlock(&minor->debugfs_lock); + + return 0; +} + +static int crc_control_show(struct seq_file *m, void *data) +{ + struct drm_device *dev = m->private; + struct drm_crtc *crtc; + + drm_for_each_crtc(crtc, dev) + seq_printf(m, "crtc %d %s\n", crtc->index, + crtc->crc.source ? crtc->crc.source : "none"); + + return 0; +} + +static int crc_control_open(struct inode *inode, struct file *file) +{ + struct drm_device *dev = inode->i_private; + + return single_open(file, crc_control_show, dev); +} + +static int crc_control_update_crtc(struct drm_crtc *crtc, const char *source) +{ + struct drm_crtc_crc *crc = &crtc->crc; + struct drm_crtc_crc_entry *entries; + int ret; + + if (!strcmp(source, "none")) + source = NULL; + + if (!crc->source && !source) + return 0; + + if (crc->source && source && !strcmp(crc->source, source)) + return 0; + + /* Forbid changing the source without going back to "none". */ + if (crc->source && source) + return -EINVAL; + + if (!crtc->funcs->set_crc_source) + return -ENOTSUPP; + + if (source) { + entries = kcalloc(DRM_CRTC_CRC_ENTRIES_NR, + sizeof(crc->entries[0]), + GFP_KERNEL); + if (!entries) + return -ENOMEM; + + spin_lock_irq(&crc->lock); + kfree(crc->entries); + crc->entries = entries; + crc->head = 0; + crc->tail = 0; + spin_unlock_irq(&crc->lock); + } + + ret = crtc->funcs->set_crc_source(crtc, source); + if (ret) + return ret; + + kfree(crc->source); + crc->source = source ? kstrdup(source, GFP_KERNEL) : NULL; + + if (!source) { + spin_lock_irq(&crc->lock); + entries = crc->entries; + crc->entries = NULL; + crc->head = 0; + crc->tail = 0; + spin_unlock_irq(&crc->lock); + + kfree(entries); + } + + return 0; +} + +static struct drm_crtc *crtc_from_index(struct drm_device *dev, int index) +{ + struct drm_crtc *crtc; + int i = 0; + + drm_for_each_crtc(crtc, dev) + if (i++ == index) + return crtc; + + return NULL; +} + +/* + * Parse CRC command strings: + * command: wsp* object wsp+ (crtc | pipe) wsp+ source wsp* + * object: ('crtc' | 'pipe') + * crtc: (0 | 1 | 2 | ...) + * pipe: (A | B | C) + * source: (none | plane1 | plane2 | ...) + * wsp: (#0x20 | #0x9 | #0xA)+ + * + * eg.: + * "crtc 0 plane1" -> Start CRC computations on plane1 of first CRTC + * "crtc 0 none" -> Stop CRC + */ +static int crc_control_tokenize(char *buf, char *words[], int max_words) +{ + int n_words = 0; + + while (*buf) { + char *end; + + /* skip leading white space */ + buf = skip_spaces(buf); + if (!*buf) + break; /* end of buffer */ + + /* find end of word */ + for (end = buf; *end && !isspace(*end); end++) + ; + + if (n_words == max_words) { + DRM_DEBUG_KMS("too many words, allowed <= %d\n", + max_words); + return -EINVAL; /* ran out of words[] before bytes */ + } + + if (*end) + *end++ = '\0'; + words[n_words++] = buf; + buf = end; + } + + return n_words; +} + +static int crc_control_parse_crtc(const char *buf, unsigned int *crtc_index) +{ + const char letter = buf[0]; + + if (!kstrtouint(buf, 10, crtc_index)) + return 0; + + /* Backwards compatibility for Intel-style pipe letters */ + if (letter < 'A' || letter > 'Z') + return -EINVAL; + + *crtc_index = letter - 'A'; + + return 0; +} + +static int crc_control_parse(struct drm_device *dev, char *buf, size_t len) +{ +#define N_WORDS 3 + int n_words; + char *words[N_WORDS]; + unsigned int crtc_index; + struct drm_crtc *crtc; + + n_words = crc_control_tokenize(buf, words, N_WORDS); + if (n_words != N_WORDS) { + DRM_DEBUG_KMS("tokenize failed, a command is %d words\n", + N_WORDS); + return -EINVAL; + } + + if (strcmp(words[0], "crtc") && strcmp(words[0], "pipe")) { + DRM_DEBUG_KMS("Invalid command %s\n", words[0]); + return -EINVAL; + } + + if (crc_control_parse_crtc(words[1], &crtc_index) < 0) { + DRM_DEBUG_KMS("Invalid CRTC index: %s\n", words[1]); + return -EINVAL; + } + + crtc = crtc_from_index(dev, crtc_index); + if (!crtc) { + DRM_DEBUG_KMS("Unknown CRTC index: %d\n", crtc_index); + return -EINVAL; + } + + return crc_control_update_crtc(crtc, words[2]); +} + +static ssize_t crc_control_write(struct file *file, const char __user *ubuf, + size_t len, loff_t *offp) +{ + struct seq_file *m = file->private_data; + struct drm_device *dev = m->private; + char *tmpbuf; + int ret; + + if (len == 0) + return 0; + + if (len > PAGE_SIZE - 1) { + DRM_DEBUG_KMS("expected <%lu bytes into crtc crc control\n", + PAGE_SIZE); + return -E2BIG; + } + + tmpbuf = kmalloc(len + 1, GFP_KERNEL); + if (!tmpbuf) + return -ENOMEM; + + if (copy_from_user(tmpbuf, ubuf, len)) { + ret = -EFAULT; + goto out; + } + tmpbuf[len] = '\0'; + + ret = crc_control_parse(dev, tmpbuf, len); +out: + kfree(tmpbuf); + if (ret < 0) + return ret; + + *offp += len; + return len; +} + +const struct file_operations drm_crc_control_fops = { + .owner = THIS_MODULE, + .open = crc_control_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, + .write = crc_control_write +}; + /** * Initialize the DRI debugfs filesystem for a device * @@ -142,8 +397,9 @@ int drm_debugfs_init(struct drm_minor *minor, int minor_id, struct dentry *root) { struct drm_device *dev = minor->dev; + struct dentry *ent; char name[64]; - int ret; + int ret = 0; INIT_LIST_HEAD(&minor->debugfs_list); mutex_init(&minor->debugfs_lock); @@ -157,10 +413,23 @@ int drm_debugfs_init(struct drm_minor *minor, int minor_id, ret = drm_debugfs_create_files(drm_debugfs_list, DRM_DEBUGFS_ENTRIES, minor->debugfs_root, minor); if (ret) { - debugfs_remove(minor->debugfs_root); - minor->debugfs_root = NULL; DRM_ERROR("Failed to create core drm debugfs files\n"); - return ret; + goto error_remove_dir; + } + + ent = debugfs_create_file("drm_crc_control", S_IRUGO | S_IWUSR, + minor->debugfs_root, dev, + &drm_crc_control_fops); + if (!ent) { + DRM_ERROR("Failed to create CRC control debugfs files\n"); + ret = -ENOMEM; + goto error_remove_files; + } + + ret = drm_add_fake_info_node(minor, ent, &drm_crc_control_fops); + if (ret) { + DRM_ERROR("Failed to create CRC control debugfs files\n"); + goto error_remove_crc; } if (dev->driver->debugfs_init) { @@ -171,7 +440,18 @@ int drm_debugfs_init(struct drm_minor *minor, int minor_id, return ret; } } + return 0; + +error_remove_crc: + debugfs_remove(ent); +error_remove_files: + drm_debugfs_remove_files(drm_debugfs_list, DRM_DEBUGFS_ENTRIES, minor); +error_remove_dir: + debugfs_remove(minor->debugfs_root); + minor->debugfs_root = NULL; + + return ret; } @@ -407,13 +687,223 @@ error: void drm_debugfs_connector_remove(struct drm_connector *connector) { - if (!connector->debugfs_entry) - return; - debugfs_remove_recursive(connector->debugfs_entry); connector->debugfs_entry = NULL; } -#endif /* CONFIG_DEBUG_FS */ +static int crtc_crc_open(struct inode *inode, struct file *filep) +{ + struct drm_crtc *crtc = inode->i_private; + struct drm_crtc_crc *crc = &crtc->crc; + + spin_lock_irq(&crc->lock); + + if (crc->opened) { + spin_unlock_irq(&crc->lock); + return -EBUSY; + } + + crc->opened = true; + + spin_unlock_irq(&crc->lock); + + return 0; +} + +static int crtc_crc_release(struct inode *inode, struct file *filep) +{ + struct drm_crtc *crtc = filep->f_inode->i_private; + struct drm_crtc_crc *crc = &crtc->crc; + + spin_lock_irq(&crc->lock); + crc->opened = false; + spin_unlock_irq(&crc->lock); + + return 0; +} + +/* (6 fields, 8 chars each, space separated (5) + '\n') */ +#define CRC_LINE_LEN (6 * 8 + 5 + 1) +/* account for \'0' */ +#define CRC_BUFFER_LEN (CRC_LINE_LEN + 1) + +static int crtc_crc_data_count(struct drm_crtc_crc *crc) +{ + assert_spin_locked(&crc->lock); + return CIRC_CNT(crc->head, crc->tail, + DRM_CRTC_CRC_ENTRIES_NR); +} + +static ssize_t crtc_crc_read(struct file *filep, char __user *user_buf, + size_t count, loff_t *pos) +{ + struct drm_crtc *crtc = filep->f_inode->i_private; + struct drm_crtc_crc *crc = &crtc->crc; + char buf[CRC_BUFFER_LEN]; + int n_entries; + ssize_t bytes_read; + + /* + * Don't allow user space to provide buffers not big enough to hold + * a line of data. + */ + if (count < CRC_LINE_LEN) + return -EINVAL; + + if (!crc->source) + return 0; + + /* Nothing to read? */ + spin_lock_irq(&crc->lock); + while (crtc_crc_data_count(crc) == 0) { + int ret; + + if (filep->f_flags & O_NONBLOCK) { + spin_unlock_irq(&crc->lock); + return -EAGAIN; + } + + ret = wait_event_interruptible_lock_irq(crc->wq, + crtc_crc_data_count(crc), crc->lock); + if (ret) { + spin_unlock_irq(&crc->lock); + return ret; + } + } + + /* We now have one or more entries to read */ + n_entries = count / CRC_LINE_LEN; + + bytes_read = 0; + while (n_entries > 0) { + struct drm_crtc_crc_entry *entry = + &crc->entries[crc->tail]; + int ret; + + if (CIRC_CNT(crc->head, crc->tail, DRM_CRTC_CRC_ENTRIES_NR) < 1) + break; + + BUILD_BUG_ON_NOT_POWER_OF_2(DRM_CRTC_CRC_ENTRIES_NR); + crc->tail = (crc->tail + 1) & (DRM_CRTC_CRC_ENTRIES_NR - 1); + + bytes_read += snprintf(buf, CRC_BUFFER_LEN, + "%8u %8x %8x %8x %8x %8x\n", + entry->frame, entry->crc[0], + entry->crc[1], entry->crc[2], + entry->crc[3], entry->crc[4]); + + spin_unlock_irq(&crc->lock); + + ret = copy_to_user(user_buf, buf, CRC_LINE_LEN); + if (ret == CRC_LINE_LEN) + return -EFAULT; + user_buf += CRC_LINE_LEN; + n_entries--; + + spin_lock_irq(&crc->lock); + } + + spin_unlock_irq(&crc->lock); + + return bytes_read; +} + +const struct file_operations drm_crtc_crc_fops = { + .owner = THIS_MODULE, + .open = crtc_crc_open, + .read = crtc_crc_read, + .release = crtc_crc_release, +}; + +static int drm_debugfs_crtc_add_for_minor(struct drm_crtc *crtc, + struct drm_minor *minor) +{ + struct dentry *ent; + char *name; + + if (!minor->debugfs_root) + return -1; + + name = kasprintf(GFP_KERNEL, "drm_crtc_%d_crc", crtc->index); + if (!name) + return -ENOMEM; + + ent = debugfs_create_file(name, S_IRUGO, minor->debugfs_root, crtc, + &drm_crtc_crc_fops); + kfree(name); + if (!ent) + return PTR_ERR(ent); + + crtc->crc.debugfs_entries[minor->type] = ent; + + return 0; +} + +int drm_debugfs_crtc_add(struct drm_crtc *crtc) +{ + int ret; + + ret = drm_debugfs_crtc_add_for_minor(crtc, crtc->dev->control); + if (ret) + return ret; + + ret = drm_debugfs_crtc_add_for_minor(crtc, crtc->dev->primary); + if (ret) + return ret; + + ret = drm_debugfs_crtc_add_for_minor(crtc, crtc->dev->render); + if (ret) + return ret; + + return 0; +} + +void drm_debugfs_crtc_remove(struct drm_crtc *crtc) +{ + int i; + + for (i = 0; i < DRM_MINOR_CNT; i++) { + debugfs_remove_recursive(crtc->crc.debugfs_entries[i]); + crtc->crc.debugfs_entries[i] = NULL; + } +} + +void drm_crtc_add_crc_entry(struct drm_crtc *crtc, uint32_t frame, + uint32_t crc0, uint32_t crc1, uint32_t crc2, + uint32_t crc3, uint32_t crc4) +{ + struct drm_crtc_crc *crc = &crtc->crc; + struct drm_crtc_crc_entry *entry; + int head, tail; + + spin_lock(&crc->lock); + + head = crc->head; + tail = crc->tail; + + if (CIRC_SPACE(head, tail, DRM_CRTC_CRC_ENTRIES_NR) < 1) { + spin_unlock(&crc->lock); + DRM_ERROR("Overflow of CRC buffer, userspace reads too slow.\n"); + return; + } + + entry = &crc->entries[head]; + + entry->frame = frame; + entry->crc[0] = crc0; + entry->crc[1] = crc1; + entry->crc[2] = crc2; + entry->crc[3] = crc3; + entry->crc[4] = crc4; + + head = (head + 1) & (DRM_CRTC_CRC_ENTRIES_NR - 1); + crc->head = head; + + spin_unlock(&crc->lock); + + wake_up_interruptible(&crc->wq); +} + +#endif /* CONFIG_DEBUG_FS */ diff --git a/drivers/gpu/drm/drm_internal.h b/drivers/gpu/drm/drm_internal.h index 38401d406532..e5b124d937f5 100644 --- a/drivers/gpu/drm/drm_internal.h +++ b/drivers/gpu/drm/drm_internal.h @@ -100,6 +100,8 @@ int drm_debugfs_init(struct drm_minor *minor, int minor_id, int drm_debugfs_cleanup(struct drm_minor *minor); int drm_debugfs_connector_add(struct drm_connector *connector); void drm_debugfs_connector_remove(struct drm_connector *connector); +int drm_debugfs_crtc_add(struct drm_crtc *crtc); +void drm_debugfs_crtc_remove(struct drm_crtc *crtc); #else static inline int drm_debugfs_init(struct drm_minor *minor, int minor_id, struct dentry *root) @@ -119,4 +121,12 @@ static inline int drm_debugfs_connector_add(struct drm_connector *connector) static inline void drm_debugfs_connector_remove(struct drm_connector *connector) { } + +static inline int drm_debugfs_crtc_add(struct drm_crtc *crtc) +{ + return 0; +} +static inline void drm_debugfs_crtc_remove(struct drm_crtc *crtc) +{ +} #endif diff --git a/include/drm/drmP.h b/include/drm/drmP.h index 084fd141e8bf..ec2f91c8b7cd 100644 --- a/include/drm/drmP.h +++ b/include/drm/drmP.h @@ -1142,6 +1142,11 @@ static __inline__ bool drm_can_sleep(void) return true; } +#if defined(CONFIG_DEBUG_FS) +extern const struct file_operations drm_crc_control_fops; +extern const struct file_operations drm_crtc_crc_fops; +#endif + /* helper for handling conditionals in various for_each macros */ #define for_each_if(condition) if (!(condition)) {} else diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h index c2734979f164..141335a3c647 100644 --- a/include/drm/drm_crtc.h +++ b/include/drm/drm_crtc.h @@ -376,6 +376,22 @@ struct drm_crtc_state { struct drm_atomic_state *state; }; +struct drm_crtc_crc_entry { + uint32_t frame; + uint32_t crc[5]; +}; + +#define DRM_CRTC_CRC_ENTRIES_NR 128 +struct drm_crtc_crc { + spinlock_t lock; + const char *source; + bool opened; /* exclusive access to the result file */ + struct drm_crtc_crc_entry *entries; + int head, tail; + wait_queue_head_t wq; + struct dentry **debugfs_entries; +}; + /** * struct drm_crtc_funcs - control CRTCs for a given device * @@ -704,6 +720,29 @@ struct drm_crtc_funcs { const struct drm_crtc_state *state, struct drm_property *property, uint64_t *val); + + /** + * @set_crc_source: + * + * Changes the source of CRC checksums of frames at the request of + * userspace, typically for testing purposes. The sources available are + * specific of each driver and a %NULL value indicates that CRC + * generation is to be switched off. + * + * When CRC generation is enabled, the driver should call + * drm_crtc_add_crc_entry() at each frame, providing any information + * that characterizes the frame contents in the crcN arguments, as + * provided from the configured source. Drivers should accept a "auto" + * source name that will select a default source for this CRTC. + * + * This callback is optional if the driver does not support any CRC + * generation functionality. + * + * RETURNS: + * + * 0 on success or a negative error code on failure. + */ + int (*set_crc_source)(struct drm_crtc *crtc, const char *source); }; /** @@ -817,6 +856,15 @@ struct drm_crtc { * context. */ struct drm_modeset_acquire_ctx *acquire_ctx; + +#ifdef CONFIG_DEBUG_FS + /** + * @drm_crtc_crc: + * + * Configuration settings of CRC capture. + */ + struct drm_crtc_crc crc; +#endif }; /** @@ -2496,6 +2544,30 @@ static inline uint32_t drm_crtc_mask(struct drm_crtc *crtc) return 1 << drm_crtc_index(crtc); } +/** + * drm_crtc_add_crc_entry - Add entry with CRC information for a frame + * @crtc: CRTC to which the frame belongs + * @frame: number of the frame characterized by the CRC data + * @crc0: piece of data about frame + * @crc1: piece of data about frame + * @crc2: piece of data about frame + * @crc3: piece of data about frame + * @crc4: piece of data about frame + * + * For each frame, the driver polls the source of CRCs for new data and calls + * this function to add them to the buffer from where userspace reads. + */ +#if defined(CONFIG_DEBUG_FS) +void drm_crtc_add_crc_entry(struct drm_crtc *crtc, uint32_t frame, + uint32_t crc0, uint32_t crc1, uint32_t crc2, + uint32_t crc3, uint32_t crc4); +#else +static inline void drm_crtc_add_crc_entry(struct drm_crtc *crtc, uint32_t frame, + uint32_t crc0, uint32_t crc1, + uint32_t crc2, uint32_t crc3, + uint32_t crc4) {} +#endif + extern void drm_connector_ida_init(void); extern void drm_connector_ida_destroy(void); extern int drm_connector_init(struct drm_device *dev,
Adds a per-device debugfile "drm_crc_control" that allows selecting a source for frame checksums in each CRTC that supports them. The checksums for each subsequent frame can be read from the per-CRTC file "drm_crtc_N_crc". The code is taken from the i915 driver and other drivers can now provide frame CRCs by implementing the set_crc_source callback in drm_crtc_funcs. Signed-off-by: Tomeu Vizoso <tomeu.vizoso@collabora.com> --- drivers/gpu/drm/drm_crtc.c | 28 ++- drivers/gpu/drm/drm_debugfs.c | 506 ++++++++++++++++++++++++++++++++++++++++- drivers/gpu/drm/drm_internal.h | 10 + include/drm/drmP.h | 5 + include/drm/drm_crtc.h | 72 ++++++ 5 files changed, 611 insertions(+), 10 deletions(-)