From patchwork Tue Jun 21 11:06:41 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tomeu Vizoso X-Patchwork-Id: 9190317 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id DBC066075E for ; Tue, 21 Jun 2016 11:07:32 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id C7B7C27F8C for ; Tue, 21 Jun 2016 11:07:32 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id B7E4A28068; Tue, 21 Jun 2016 11:07:32 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-4.1 required=2.0 tests=BAYES_00,DKIM_SIGNED, RCVD_IN_DNSWL_MED,T_DKIM_INVALID autolearn=ham version=3.3.1 Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 635A027F8C for ; Tue, 21 Jun 2016 11:07:31 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 3C4556E25A; Tue, 21 Jun 2016 11:07:29 +0000 (UTC) X-Original-To: dri-devel@lists.freedesktop.org Delivered-To: dri-devel@lists.freedesktop.org Received: from mail-lf0-x241.google.com (mail-lf0-x241.google.com [IPv6:2a00:1450:4010:c07::241]) by gabe.freedesktop.org (Postfix) with ESMTPS id D3AAB6E23D for ; Tue, 21 Jun 2016 11:07:26 +0000 (UTC) Received: by mail-lf0-x241.google.com with SMTP id a2so2726210lfe.3 for ; Tue, 21 Jun 2016 04:07:26 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references; bh=eCWJnLD2T//FQjvo2Xq0khx9rnJKwPgKpMjLEUqp3s4=; b=BjQ1dBZ93sB7ojeiZ2hZiybjjHK4tseMRfirtHj33EJ17WntGVGWOy1F733qRyCmJM IfOR69NULSSZGQKNhvhaYBZ/GPLfANQy+vgTEcScabXQTiE/fL9JY5t8i3W0LWoGYa4t c29iXiKS6EVe4w/r9znsPh/b7NbcSYYIvqUbvykcAyrXXH0L1V7FzwrA4XlVz7bg4ow5 j/fHUMt2erevpPVbabjQXtFZwn6EuXFQ7pvKiRcp+l/zHT/iCaksH3kbs3vksXLLdrN2 scUSi9G7FbyhnXCNoNkP+6BAGdx0j66/a0k4Vfu6T0RBhJX0NMd9DHsxBPONpB0PPr0h 0UAA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references; bh=eCWJnLD2T//FQjvo2Xq0khx9rnJKwPgKpMjLEUqp3s4=; b=SUmA54/DsngJD0FyeF7hwdbgn2/Qyvkk+5c9SZTHaTmDyS6wKkgTbXb1PKthe0ANuq KGraQrxCelqDiEkgGcTs9j7tt7m9+nptcnGt3eC/2U0HjCwDbzV8qCJk9BpFPVQ1BrJs qgBcRtlR4Akrq7/BS1UPpQKrIAQnvkI/j7PABZgoaPEr9J8DiDfY5DoDMIUOCWU9Rg+O AjS0N8jh5E/b/ge/dZ1lKFrZa9yGS5QnQp7ng8xlhnrC7DmRaCLrhhpEMsRRFJgYGt4f liMG8tIihthu+bjHBWqBbqh+YQsKiZHR5rKlh859Yf1734KvM6lGWXC5w+Aw5sg6dNRA keow== X-Gm-Message-State: ALyK8tJfdZCdTfYv4JtP3Z0NOKSBABtW5phNV383e9U1z3uo+OZNubhIWzyllek6bXUFKw== X-Received: by 10.28.31.204 with SMTP id f195mr2619025wmf.45.1466507243659; Tue, 21 Jun 2016 04:07:23 -0700 (PDT) Received: from cizrna.lan ([109.72.12.151]) by smtp.gmail.com with ESMTPSA id h8sm68231573wjg.9.2016.06.21.04.07.18 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 21 Jun 2016 04:07:22 -0700 (PDT) From: Tomeu Vizoso To: linux-kernel@vger.kernel.org Subject: [PATCH v1 2/3] drm: Add API for capturing frame CRCs Date: Tue, 21 Jun 2016 13:06:41 +0200 Message-Id: <1466507202-23222-3-git-send-email-tomeu.vizoso@collabora.com> X-Mailer: git-send-email 2.5.5 In-Reply-To: <1466507202-23222-1-git-send-email-tomeu.vizoso@collabora.com> References: <1466507202-23222-1-git-send-email-tomeu.vizoso@collabora.com> Cc: Daniel Vetter , dri-devel@lists.freedesktop.org, Tomeu Vizoso , Emil Velikov X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" X-Virus-Scanned: ClamAV using ClamSMTP 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 --- 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(-) 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 +#include #include #include #include @@ -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,