tests/pm_rps.c

   1 /*
   2  * Copyright © 2012 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *    Ben Widawsky <ben@bwidawsk.net>
  25  *    Jeff McGee <jeff.mcgee@intel.com>
  26  *
  27  */
  28
  29 #define _GNU_SOURCE
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <unistd.h>
  34 #include <getopt.h>
  35 #include "drmtest.h"
  36
  37 static bool verbose = false;
  38
  39 static const char sysfs_base_path[] = "/sys/class/drm/card%d/gt_%s_freq_mhz";
  40 enum {
  41         CUR,
  42         MIN,
  43         MAX,
  44         RP0,
  45         RP1,
  46         RPn,
  47         NUMFREQ
  48 };
  49
  50 static int origfreqs[NUMFREQ];
  51
  52 struct junk {
  53         const char *name;
  54         const char *mode;
  55         FILE *filp;
  56 } stuff[] = {
  57         { "cur", "r", NULL }, { "min", "rb+", NULL }, { "max", "rb+", NULL }, { "RP0", "r", NULL }, { "RP1", "r", NULL }, { "RPn", "r", NULL }, { NULL, NULL, NULL }
  58 };
  59
  60 static int readval(FILE *filp)
  61 {
  62         int val;
  63         int scanned;
  64
  65         rewind(filp);
  66         scanned = fscanf(filp, "%d", &val);
  67         igt_assert(scanned == 1);
  68
  69         return val;
  70 }
  71
  72 static void read_freqs(int *freqs)
  73 {
  74         int i;
  75
  76         for (i = 0; i < NUMFREQ; i++)
  77                 freqs[i] = readval(stuff[i].filp);
  78 }
  79
  80 static int do_writeval(FILE *filp, int val, int lerrno)
  81 {
  82         int ret, orig;
  83
  84         orig = readval(filp);
  85         rewind(filp);
  86         ret = fprintf(filp, "%d", val);
  87
  88         if (lerrno) {
  89                 /* Expecting specific error */
  90                 igt_assert(ret == EOF && errno == lerrno);
  91                 igt_assert(readval(filp) == orig);
  92         } else {
  93                 /* Expecting no error */
  94                 igt_assert(ret != EOF);
  95                 igt_assert(readval(filp) == val);
  96         }
  97
  98         return ret;
  99 }
 100 #define writeval(filp, val) do_writeval(filp, val, 0)
 101 #define writeval_inval(filp, val) do_writeval(filp, val, EINVAL)
 102
 103 static void setfreq(int val)
 104 {
 105         if (val > readval(stuff[MAX].filp)) {
 106                 writeval(stuff[MAX].filp, val);
 107                 writeval(stuff[MIN].filp, val);
 108         } else {
 109                 writeval(stuff[MIN].filp, val);
 110                 writeval(stuff[MAX].filp, val);
 111         }
 112 }
 113
 114 static void checkit(const int *freqs)
 115 {
 116         igt_assert(freqs[MIN] <= freqs[MAX]);
 117         igt_assert(freqs[CUR] <= freqs[MAX]);
 118         igt_assert(freqs[MIN] <= freqs[CUR]);
 119         igt_assert(freqs[RPn] <= freqs[MIN]);
 120         igt_assert(freqs[MAX] <= freqs[RP0]);
 121         igt_assert(freqs[RP1] <= freqs[RP0]);
 122         igt_assert(freqs[RPn] <= freqs[RP1]);
 123         igt_assert(freqs[RP0] != 0);
 124         igt_assert(freqs[RP1] != 0);
 125 }
 126
 127 static void dumpit(const int *freqs)
 128 {
 129         int i;
 130
 131         printf("gt freq (MHz):");
 132         for (i = 0; i < NUMFREQ; i++)
 133                 printf("  %s=%d", stuff[i].name, freqs[i]);
 134
 135         printf("\n");
 136 }
 137 #define dump(x) if (verbose) dumpit(x)
 138 #define log(...) if (verbose) printf(__VA_ARGS__)
 139
 140 static void min_max_config(void (*check)(void))
 141 {
 142         int fmid = (origfreqs[RPn] + origfreqs[RP0]) / 2;
 143
 144         log("\nCheck original min and max...\n");
 145         check();
 146
 147         log("\nSet min=RPn and max=RP0...\n");
 148         writeval(stuff[MIN].filp, origfreqs[RPn]);
 149         writeval(stuff[MAX].filp, origfreqs[RP0]);
 150         check();
 151
 152         log("\nIncrease min to midpoint...\n");
 153         writeval(stuff[MIN].filp, fmid);
 154         check();
 155
 156         log("\nIncrease min to RP0...\n");
 157         writeval(stuff[MIN].filp, origfreqs[RP0]);
 158         check();
 159
 160         log("\nIncrease min above RP0 (invalid)...\n");
 161         writeval_inval(stuff[MIN].filp, origfreqs[RP0] + 1000);
 162         check();
 163
 164         log("\nDecrease max to RPn (invalid)...\n");
 165         writeval_inval(stuff[MAX].filp, origfreqs[RPn]);
 166         check();
 167
 168         log("\nDecrease min to midpoint...\n");
 169         writeval(stuff[MIN].filp, fmid);
 170         check();
 171
 172         log("\nDecrease min to RPn...\n");
 173         writeval(stuff[MIN].filp, origfreqs[RPn]);
 174         check();
 175
 176         log("\nDecrease min below RPn (invalid)...\n");
 177         writeval_inval(stuff[MIN].filp, 0);
 178         check();
 179
 180         log("\nDecrease max to midpoint...\n");
 181         writeval(stuff[MAX].filp, fmid);
 182         check();
 183
 184         log("\nDecrease max to RPn...\n");
 185         writeval(stuff[MAX].filp, origfreqs[RPn]);
 186         check();
 187
 188         log("\nDecrease max below RPn (invalid)...\n");
 189         writeval_inval(stuff[MAX].filp, 0);
 190         check();
 191
 192         log("\nIncrease min to RP0 (invalid)...\n");
 193         writeval_inval(stuff[MIN].filp, origfreqs[RP0]);
 194         check();
 195
 196         log("\nIncrease max to midpoint...\n");
 197         writeval(stuff[MAX].filp, fmid);
 198         check();
 199
 200         log("\nIncrease max to RP0...\n");
 201         writeval(stuff[MAX].filp, origfreqs[RP0]);
 202         check();
 203
 204         log("\nIncrease max above RP0 (invalid)...\n");
 205         writeval_inval(stuff[MAX].filp, origfreqs[RP0] + 1000);
 206         check();
 207 }
 208
 209 static void idle_check(void)
 210 {
 211         int freqs[NUMFREQ];
 212
 213         read_freqs(freqs);
 214         dump(freqs);
 215         checkit(freqs);
 216 }
 217
 218 static void pm_rps_exit_handler(int sig)
 219 {
 220         if (origfreqs[MIN] > readval(stuff[MAX].filp)) {
 221                 writeval(stuff[MAX].filp, origfreqs[MAX]);
 222                 writeval(stuff[MIN].filp, origfreqs[MIN]);
 223         } else {
 224                 writeval(stuff[MIN].filp, origfreqs[MIN]);
 225                 writeval(stuff[MAX].filp, origfreqs[MAX]);
 226         }
 227 }
 228
 229 static int opt_handler(int opt, int opt_index)
 230 {
 231         switch (opt) {
 232         case 'v':
 233                 verbose = true;
 234                 break;
 235         default:
 236                 assert(0);
 237         }
 238
 239         return 0;
 240 }
 241
 242 /* Mod of igt_subtest_init that adds our extra options */
 243 static void subtest_init(int argc, char **argv)
 244 {
 245         struct option long_opts[] = {
 246                 {"verbose", 0, 0, 'v'}
 247         };
 248         const char *help_str = "  -v, --verbose";
 249         int ret;
 250
 251         ret = igt_subtest_init_parse_opts(argc, argv, "v", long_opts,
 252                                           help_str, opt_handler);
 253
 254         if (ret < 0)
 255                 /* exit with no error for -h/--help */
 256                 exit(ret == -1 ? 0 : ret);
 257 }
 258
 259 int main(int argc, char **argv)
 260 {
 261         subtest_init(argc, argv);
 262
 263         igt_skip_on_simulation();
 264
 265         igt_fixture {
 266                 const int device = drm_get_card();
 267                 struct junk *junk = stuff;
 268                 int fd, ret;
 269
 270                 /* Use drm_open_any to verify device existence */
 271                 fd = drm_open_any();
 272                 close(fd);
 273
 274                 do {
 275                         int val = -1;
 276                         char *path;
 277                         ret = asprintf(&path, sysfs_base_path, device, junk->name);
 278                         igt_assert(ret != -1);
 279                         junk->filp = fopen(path, junk->mode);
 280                         igt_require(junk->filp);
 281                         setbuf(junk->filp, NULL);
 282
 283                         val = readval(junk->filp);
 284                         igt_assert(val >= 0);
 285                         junk++;
 286                 } while(junk->name != NULL);
 287
 288                 read_freqs(origfreqs);
 289
 290                 igt_install_exit_handler(pm_rps_exit_handler);
 291         }
 292
 293         igt_subtest("basic-api")
 294                 min_max_config(idle_check);
 295
 296         igt_exit();
 297 }