drivers/gpu/drm/selftests/test-drm_cmdline_parser.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2019 Bootlin
   4  */
   5
   6 #define pr_fmt(fmt) "drm_cmdline: " fmt
   7
   8 #include <linux/kernel.h>
   9 #include <linux/module.h>
  10
  11 #include <drm/drm_connector.h>
  12 #include <drm/drm_modes.h>
  13
  14 #define TESTS "drm_cmdline_selftests.h"
  15 #include "drm_selftest.h"
  16 #include "test-drm_modeset_common.h"
  17
  18 static const struct drm_connector no_connector = {};
  19
  20 static int drm_cmdline_test_force_e_only(void *ignored)
  21 {
  22         struct drm_cmdline_mode mode = { };
  23
  24         FAIL_ON(!drm_mode_parse_command_line_for_connector("e",
  25                                                            &no_connector,
  26                                                            &mode));
  27         FAIL_ON(mode.specified);
  28         FAIL_ON(mode.refresh_specified);
  29         FAIL_ON(mode.bpp_specified);
  30
  31         FAIL_ON(mode.rb);
  32         FAIL_ON(mode.cvt);
  33         FAIL_ON(mode.interlace);
  34         FAIL_ON(mode.margins);
  35         FAIL_ON(mode.force != DRM_FORCE_ON);
  36
  37         return 0;
  38 }
  39
  40 static int drm_cmdline_test_force_D_only_not_digital(void *ignored)
  41 {
  42         struct drm_cmdline_mode mode = { };
  43
  44         FAIL_ON(!drm_mode_parse_command_line_for_connector("D",
  45                                                            &no_connector,
  46                                                            &mode));
  47         FAIL_ON(mode.specified);
  48         FAIL_ON(mode.refresh_specified);
  49         FAIL_ON(mode.bpp_specified);
  50
  51         FAIL_ON(mode.rb);
  52         FAIL_ON(mode.cvt);
  53         FAIL_ON(mode.interlace);
  54         FAIL_ON(mode.margins);
  55         FAIL_ON(mode.force != DRM_FORCE_ON);
  56
  57         return 0;
  58 }
  59
  60 static const struct drm_connector connector_hdmi = {
  61         .connector_type = DRM_MODE_CONNECTOR_HDMIB,
  62 };
  63
  64 static int drm_cmdline_test_force_D_only_hdmi(void *ignored)
  65 {
  66         struct drm_cmdline_mode mode = { };
  67
  68         FAIL_ON(!drm_mode_parse_command_line_for_connector("D",
  69                                                            &connector_hdmi,
  70                                                            &mode));
  71         FAIL_ON(mode.specified);
  72         FAIL_ON(mode.refresh_specified);
  73         FAIL_ON(mode.bpp_specified);
  74
  75         FAIL_ON(mode.rb);
  76         FAIL_ON(mode.cvt);
  77         FAIL_ON(mode.interlace);
  78         FAIL_ON(mode.margins);
  79         FAIL_ON(mode.force != DRM_FORCE_ON_DIGITAL);
  80
  81         return 0;
  82 }
  83
  84 static const struct drm_connector connector_dvi = {
  85         .connector_type = DRM_MODE_CONNECTOR_DVII,
  86 };
  87
  88 static int drm_cmdline_test_force_D_only_dvi(void *ignored)
  89 {
  90         struct drm_cmdline_mode mode = { };
  91
  92         FAIL_ON(!drm_mode_parse_command_line_for_connector("D",
  93                                                            &connector_dvi,
  94                                                            &mode));
  95         FAIL_ON(mode.specified);
  96         FAIL_ON(mode.refresh_specified);
  97         FAIL_ON(mode.bpp_specified);
  98
  99         FAIL_ON(mode.rb);
 100         FAIL_ON(mode.cvt);
 101         FAIL_ON(mode.interlace);
 102         FAIL_ON(mode.margins);
 103         FAIL_ON(mode.force != DRM_FORCE_ON_DIGITAL);
 104
 105         return 0;
 106 }
 107
 108 static int drm_cmdline_test_force_d_only(void *ignored)
 109 {
 110         struct drm_cmdline_mode mode = { };
 111
 112         FAIL_ON(!drm_mode_parse_command_line_for_connector("d",
 113                                                            &no_connector,
 114                                                            &mode));
 115         FAIL_ON(mode.specified);
 116         FAIL_ON(mode.refresh_specified);
 117         FAIL_ON(mode.bpp_specified);
 118
 119         FAIL_ON(mode.rb);
 120         FAIL_ON(mode.cvt);
 121         FAIL_ON(mode.interlace);
 122         FAIL_ON(mode.margins);
 123         FAIL_ON(mode.force != DRM_FORCE_OFF);
 124
 125         return 0;
 126 }
 127
 128 static int drm_cmdline_test_margin_only(void *ignored)
 129 {
 130         struct drm_cmdline_mode mode = { };
 131
 132         FAIL_ON(drm_mode_parse_command_line_for_connector("m",
 133                                                           &no_connector,
 134                                                           &mode));
 135
 136         return 0;
 137 }
 138
 139 static int drm_cmdline_test_interlace_only(void *ignored)
 140 {
 141         struct drm_cmdline_mode mode = { };
 142
 143         FAIL_ON(drm_mode_parse_command_line_for_connector("i",
 144                                                           &no_connector,
 145                                                           &mode));
 146
 147         return 0;
 148 }
 149
 150 static int drm_cmdline_test_res(void *ignored)
 151 {
 152         struct drm_cmdline_mode mode = { };
 153
 154         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480",
 155                                                            &no_connector,
 156                                                            &mode));
 157         FAIL_ON(!mode.specified);
 158         FAIL_ON(mode.xres != 720);
 159         FAIL_ON(mode.yres != 480);
 160
 161         FAIL_ON(mode.refresh_specified);
 162
 163         FAIL_ON(mode.bpp_specified);
 164
 165         FAIL_ON(mode.rb);
 166         FAIL_ON(mode.cvt);
 167         FAIL_ON(mode.interlace);
 168         FAIL_ON(mode.margins);
 169         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 170
 171         return 0;
 172 }
 173
 174 static int drm_cmdline_test_res_missing_x(void *ignored)
 175 {
 176         struct drm_cmdline_mode mode = { };
 177
 178         FAIL_ON(drm_mode_parse_command_line_for_connector("x480",
 179                                                           &no_connector,
 180                                                           &mode));
 181
 182         return 0;
 183 }
 184
 185 static int drm_cmdline_test_res_missing_y(void *ignored)
 186 {
 187         struct drm_cmdline_mode mode = { };
 188
 189         FAIL_ON(drm_mode_parse_command_line_for_connector("1024x",
 190                                                           &no_connector,
 191                                                           &mode));
 192
 193         return 0;
 194 }
 195
 196 static int drm_cmdline_test_res_bad_y(void *ignored)
 197 {
 198         struct drm_cmdline_mode mode = { };
 199
 200         FAIL_ON(drm_mode_parse_command_line_for_connector("1024xtest",
 201                                                           &no_connector,
 202                                                           &mode));
 203
 204         return 0;
 205 }
 206
 207 static int drm_cmdline_test_res_missing_y_bpp(void *ignored)
 208 {
 209         struct drm_cmdline_mode mode = { };
 210
 211         FAIL_ON(drm_mode_parse_command_line_for_connector("1024x-24",
 212                                                           &no_connector,
 213                                                           &mode));
 214
 215         return 0;
 216 }
 217
 218 static int drm_cmdline_test_res_vesa(void *ignored)
 219 {
 220         struct drm_cmdline_mode mode = { };
 221
 222         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480M",
 223                                                            &no_connector,
 224                                                            &mode));
 225         FAIL_ON(!mode.specified);
 226         FAIL_ON(mode.xres != 720);
 227         FAIL_ON(mode.yres != 480);
 228
 229         FAIL_ON(mode.refresh_specified);
 230
 231         FAIL_ON(mode.bpp_specified);
 232
 233         FAIL_ON(mode.rb);
 234         FAIL_ON(!mode.cvt);
 235         FAIL_ON(mode.interlace);
 236         FAIL_ON(mode.margins);
 237         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 238
 239         return 0;
 240 }
 241
 242 static int drm_cmdline_test_res_vesa_rblank(void *ignored)
 243 {
 244         struct drm_cmdline_mode mode = { };
 245
 246         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480MR",
 247                                                            &no_connector,
 248                                                            &mode));
 249         FAIL_ON(!mode.specified);
 250         FAIL_ON(mode.xres != 720);
 251         FAIL_ON(mode.yres != 480);
 252
 253         FAIL_ON(mode.refresh_specified);
 254
 255         FAIL_ON(mode.bpp_specified);
 256
 257         FAIL_ON(!mode.rb);
 258         FAIL_ON(!mode.cvt);
 259         FAIL_ON(mode.interlace);
 260         FAIL_ON(mode.margins);
 261         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 262
 263         return 0;
 264 }
 265
 266 static int drm_cmdline_test_res_rblank(void *ignored)
 267 {
 268         struct drm_cmdline_mode mode = { };
 269
 270         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480R",
 271                                                            &no_connector,
 272                                                            &mode));
 273         FAIL_ON(!mode.specified);
 274         FAIL_ON(mode.xres != 720);
 275         FAIL_ON(mode.yres != 480);
 276
 277         FAIL_ON(mode.refresh_specified);
 278
 279         FAIL_ON(mode.bpp_specified);
 280
 281         FAIL_ON(!mode.rb);
 282         FAIL_ON(mode.cvt);
 283         FAIL_ON(mode.interlace);
 284         FAIL_ON(mode.margins);
 285         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 286
 287         return 0;
 288 }
 289
 290 static int drm_cmdline_test_res_bpp(void *ignored)
 291 {
 292         struct drm_cmdline_mode mode = { };
 293
 294         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480-24",
 295                                                            &no_connector,
 296                                                            &mode));
 297         FAIL_ON(!mode.specified);
 298         FAIL_ON(mode.xres != 720);
 299         FAIL_ON(mode.yres != 480);
 300
 301         FAIL_ON(mode.refresh_specified);
 302
 303         FAIL_ON(!mode.bpp_specified);
 304         FAIL_ON(mode.bpp != 24);
 305
 306         FAIL_ON(mode.rb);
 307         FAIL_ON(mode.cvt);
 308         FAIL_ON(mode.interlace);
 309         FAIL_ON(mode.margins);
 310         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 311
 312         return 0;
 313 }
 314
 315 static int drm_cmdline_test_res_bad_bpp(void *ignored)
 316 {
 317         struct drm_cmdline_mode mode = { };
 318
 319         FAIL_ON(drm_mode_parse_command_line_for_connector("720x480-test",
 320                                                           &no_connector,
 321                                                           &mode));
 322
 323         return 0;
 324 }
 325
 326 static int drm_cmdline_test_res_refresh(void *ignored)
 327 {
 328         struct drm_cmdline_mode mode = { };
 329
 330         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480@60",
 331                                                            &no_connector,
 332                                                            &mode));
 333         FAIL_ON(!mode.specified);
 334         FAIL_ON(mode.xres != 720);
 335         FAIL_ON(mode.yres != 480);
 336
 337         FAIL_ON(!mode.refresh_specified);
 338         FAIL_ON(mode.refresh != 60);
 339
 340         FAIL_ON(mode.bpp_specified);
 341
 342         FAIL_ON(mode.rb);
 343         FAIL_ON(mode.cvt);
 344         FAIL_ON(mode.interlace);
 345         FAIL_ON(mode.margins);
 346         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 347
 348         return 0;
 349 }
 350
 351 static int drm_cmdline_test_res_bad_refresh(void *ignored)
 352 {
 353         struct drm_cmdline_mode mode = { };
 354
 355         FAIL_ON(drm_mode_parse_command_line_for_connector("720x480@refresh",
 356                                                           &no_connector,
 357                                                           &mode));
 358
 359         return 0;
 360 }
 361
 362 static int drm_cmdline_test_res_bpp_refresh(void *ignored)
 363 {
 364         struct drm_cmdline_mode mode = { };
 365
 366         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480-24@60",
 367                                                            &no_connector,
 368                                                            &mode));
 369         FAIL_ON(!mode.specified);
 370         FAIL_ON(mode.xres != 720);
 371         FAIL_ON(mode.yres != 480);
 372
 373         FAIL_ON(!mode.refresh_specified);
 374         FAIL_ON(mode.refresh != 60);
 375
 376         FAIL_ON(!mode.bpp_specified);
 377         FAIL_ON(mode.bpp != 24);
 378
 379         FAIL_ON(mode.rb);
 380         FAIL_ON(mode.cvt);
 381         FAIL_ON(mode.interlace);
 382         FAIL_ON(mode.margins);
 383         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 384
 385         return 0;
 386 }
 387
 388 static int drm_cmdline_test_res_bpp_refresh_interlaced(void *ignored)
 389 {
 390         struct drm_cmdline_mode mode = { };
 391
 392         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480-24@60i",
 393                                                            &no_connector,
 394                                                            &mode));
 395         FAIL_ON(!mode.specified);
 396         FAIL_ON(mode.xres != 720);
 397         FAIL_ON(mode.yres != 480);
 398
 399         FAIL_ON(!mode.refresh_specified);
 400         FAIL_ON(mode.refresh != 60);
 401
 402         FAIL_ON(!mode.bpp_specified);
 403         FAIL_ON(mode.bpp != 24);
 404
 405         FAIL_ON(mode.rb);
 406         FAIL_ON(mode.cvt);
 407         FAIL_ON(!mode.interlace);
 408         FAIL_ON(mode.margins);
 409         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 410
 411         return 0;
 412 }
 413
 414 static int drm_cmdline_test_res_bpp_refresh_margins(void *ignored)
 415 {
 416         struct drm_cmdline_mode mode = { };
 417
 418         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480-24@60m",
 419                                                            &no_connector,
 420                                                            &mode));
 421         FAIL_ON(!mode.specified);
 422         FAIL_ON(mode.xres != 720);
 423         FAIL_ON(mode.yres != 480);
 424
 425         FAIL_ON(!mode.refresh_specified);
 426         FAIL_ON(mode.refresh != 60);
 427
 428         FAIL_ON(!mode.bpp_specified);
 429         FAIL_ON(mode.bpp != 24);
 430
 431         FAIL_ON(mode.rb);
 432         FAIL_ON(mode.cvt);
 433         FAIL_ON(mode.interlace);
 434         FAIL_ON(!mode.margins);
 435         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 436
 437         return 0;
 438 }
 439
 440 static int drm_cmdline_test_res_bpp_refresh_force_off(void *ignored)
 441 {
 442         struct drm_cmdline_mode mode = { };
 443
 444         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480-24@60d",
 445                                                            &no_connector,
 446                                                            &mode));
 447         FAIL_ON(!mode.specified);
 448         FAIL_ON(mode.xres != 720);
 449         FAIL_ON(mode.yres != 480);
 450
 451         FAIL_ON(!mode.refresh_specified);
 452         FAIL_ON(mode.refresh != 60);
 453
 454         FAIL_ON(!mode.bpp_specified);
 455         FAIL_ON(mode.bpp != 24);
 456
 457         FAIL_ON(mode.rb);
 458         FAIL_ON(mode.cvt);
 459         FAIL_ON(mode.interlace);
 460         FAIL_ON(mode.margins);
 461         FAIL_ON(mode.force != DRM_FORCE_OFF);
 462
 463         return 0;
 464 }
 465
 466 static int drm_cmdline_test_res_bpp_refresh_force_on_off(void *ignored)
 467 {
 468         struct drm_cmdline_mode mode = { };
 469
 470         FAIL_ON(drm_mode_parse_command_line_for_connector("720x480-24@60de",
 471                                                           &no_connector,
 472                                                           &mode));
 473
 474         return 0;
 475 }
 476
 477 static int drm_cmdline_test_res_bpp_refresh_force_on(void *ignored)
 478 {
 479         struct drm_cmdline_mode mode = { };
 480
 481         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480-24@60e",
 482                                                            &no_connector,
 483                                                            &mode));
 484         FAIL_ON(!mode.specified);
 485         FAIL_ON(mode.xres != 720);
 486         FAIL_ON(mode.yres != 480);
 487
 488         FAIL_ON(!mode.refresh_specified);
 489         FAIL_ON(mode.refresh != 60);
 490
 491         FAIL_ON(!mode.bpp_specified);
 492         FAIL_ON(mode.bpp != 24);
 493
 494         FAIL_ON(mode.rb);
 495         FAIL_ON(mode.cvt);
 496         FAIL_ON(mode.interlace);
 497         FAIL_ON(mode.margins);
 498         FAIL_ON(mode.force != DRM_FORCE_ON);
 499
 500         return 0;
 501 }
 502
 503 static int drm_cmdline_test_res_bpp_refresh_force_on_analog(void *ignored)
 504 {
 505         struct drm_cmdline_mode mode = { };
 506
 507         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480-24@60D",
 508                                                            &no_connector,
 509                                                            &mode));
 510         FAIL_ON(!mode.specified);
 511         FAIL_ON(mode.xres != 720);
 512         FAIL_ON(mode.yres != 480);
 513
 514         FAIL_ON(!mode.refresh_specified);
 515         FAIL_ON(mode.refresh != 60);
 516
 517         FAIL_ON(!mode.bpp_specified);
 518         FAIL_ON(mode.bpp != 24);
 519
 520         FAIL_ON(mode.rb);
 521         FAIL_ON(mode.cvt);
 522         FAIL_ON(mode.interlace);
 523         FAIL_ON(mode.margins);
 524         FAIL_ON(mode.force != DRM_FORCE_ON);
 525
 526         return 0;
 527 }
 528
 529 static int drm_cmdline_test_res_bpp_refresh_force_on_digital(void *ignored)
 530 {
 531         struct drm_cmdline_mode mode = { };
 532         static const struct drm_connector connector = {
 533                 .connector_type = DRM_MODE_CONNECTOR_DVII,
 534         };
 535
 536         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480-24@60D",
 537                                                            &connector,
 538                                                            &mode));
 539         FAIL_ON(!mode.specified);
 540         FAIL_ON(mode.xres != 720);
 541         FAIL_ON(mode.yres != 480);
 542
 543         FAIL_ON(!mode.refresh_specified);
 544         FAIL_ON(mode.refresh != 60);
 545
 546         FAIL_ON(!mode.bpp_specified);
 547         FAIL_ON(mode.bpp != 24);
 548
 549         FAIL_ON(mode.rb);
 550         FAIL_ON(mode.cvt);
 551         FAIL_ON(mode.interlace);
 552         FAIL_ON(mode.margins);
 553         FAIL_ON(mode.force != DRM_FORCE_ON_DIGITAL);
 554
 555         return 0;
 556 }
 557
 558 static int drm_cmdline_test_res_bpp_refresh_interlaced_margins_force_on(void *ignored)
 559 {
 560         struct drm_cmdline_mode mode = { };
 561
 562         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480-24@60ime",
 563                                                            &no_connector,
 564                                                            &mode));
 565         FAIL_ON(!mode.specified);
 566         FAIL_ON(mode.xres != 720);
 567         FAIL_ON(mode.yres != 480);
 568
 569         FAIL_ON(!mode.refresh_specified);
 570         FAIL_ON(mode.refresh != 60);
 571
 572         FAIL_ON(!mode.bpp_specified);
 573         FAIL_ON(mode.bpp != 24);
 574
 575         FAIL_ON(mode.rb);
 576         FAIL_ON(mode.cvt);
 577         FAIL_ON(!mode.interlace);
 578         FAIL_ON(!mode.margins);
 579         FAIL_ON(mode.force != DRM_FORCE_ON);
 580
 581         return 0;
 582 }
 583
 584 static int drm_cmdline_test_res_margins_force_on(void *ignored)
 585 {
 586         struct drm_cmdline_mode mode = { };
 587
 588         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480me",
 589                                                            &no_connector,
 590                                                            &mode));
 591         FAIL_ON(!mode.specified);
 592         FAIL_ON(mode.xres != 720);
 593         FAIL_ON(mode.yres != 480);
 594
 595         FAIL_ON(mode.refresh_specified);
 596
 597         FAIL_ON(mode.bpp_specified);
 598
 599         FAIL_ON(mode.rb);
 600         FAIL_ON(mode.cvt);
 601         FAIL_ON(mode.interlace);
 602         FAIL_ON(!mode.margins);
 603         FAIL_ON(mode.force != DRM_FORCE_ON);
 604
 605         return 0;
 606 }
 607
 608 static int drm_cmdline_test_res_vesa_margins(void *ignored)
 609 {
 610         struct drm_cmdline_mode mode = { };
 611
 612         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480Mm",
 613                                                            &no_connector,
 614                                                            &mode));
 615         FAIL_ON(!mode.specified);
 616         FAIL_ON(mode.xres != 720);
 617         FAIL_ON(mode.yres != 480);
 618
 619         FAIL_ON(mode.refresh_specified);
 620
 621         FAIL_ON(mode.bpp_specified);
 622
 623         FAIL_ON(mode.rb);
 624         FAIL_ON(!mode.cvt);
 625         FAIL_ON(mode.interlace);
 626         FAIL_ON(!mode.margins);
 627         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 628
 629         return 0;
 630 }
 631
 632 static int drm_cmdline_test_res_invalid_mode(void *ignored)
 633 {
 634         struct drm_cmdline_mode mode = { };
 635
 636         FAIL_ON(drm_mode_parse_command_line_for_connector("720x480f",
 637                                                           &no_connector,
 638                                                           &mode));
 639
 640         return 0;
 641 }
 642
 643 static int drm_cmdline_test_res_bpp_wrong_place_mode(void *ignored)
 644 {
 645         struct drm_cmdline_mode mode = { };
 646
 647         FAIL_ON(drm_mode_parse_command_line_for_connector("720x480e-24",
 648                                                           &no_connector,
 649                                                           &mode));
 650
 651         return 0;
 652 }
 653
 654 static int drm_cmdline_test_name(void *ignored)
 655 {
 656         struct drm_cmdline_mode mode = { };
 657
 658         FAIL_ON(!drm_mode_parse_command_line_for_connector("NTSC",
 659                                                            &no_connector,
 660                                                            &mode));
 661         FAIL_ON(strcmp(mode.name, "NTSC"));
 662         FAIL_ON(mode.refresh_specified);
 663         FAIL_ON(mode.bpp_specified);
 664
 665         return 0;
 666 }
 667
 668 static int drm_cmdline_test_name_bpp(void *ignored)
 669 {
 670         struct drm_cmdline_mode mode = { };
 671
 672         FAIL_ON(!drm_mode_parse_command_line_for_connector("NTSC-24",
 673                                                            &no_connector,
 674                                                            &mode));
 675         FAIL_ON(strcmp(mode.name, "NTSC"));
 676
 677         FAIL_ON(mode.refresh_specified);
 678
 679         FAIL_ON(!mode.bpp_specified);
 680         FAIL_ON(mode.bpp != 24);
 681
 682         return 0;
 683 }
 684
 685 static int drm_cmdline_test_name_bpp_refresh(void *ignored)
 686 {
 687         struct drm_cmdline_mode mode = { };
 688
 689         FAIL_ON(drm_mode_parse_command_line_for_connector("NTSC-24@60",
 690                                                           &no_connector,
 691                                                           &mode));
 692
 693         return 0;
 694 }
 695
 696 static int drm_cmdline_test_name_refresh(void *ignored)
 697 {
 698         struct drm_cmdline_mode mode = { };
 699
 700         FAIL_ON(drm_mode_parse_command_line_for_connector("NTSC@60",
 701                                                           &no_connector,
 702                                                           &mode));
 703
 704         return 0;
 705 }
 706
 707 static int drm_cmdline_test_name_refresh_wrong_mode(void *ignored)
 708 {
 709         struct drm_cmdline_mode mode = { };
 710
 711         FAIL_ON(drm_mode_parse_command_line_for_connector("NTSC@60m",
 712                                                           &no_connector,
 713                                                           &mode));
 714
 715         return 0;
 716 }
 717
 718 static int drm_cmdline_test_name_refresh_invalid_mode(void *ignored)
 719 {
 720         struct drm_cmdline_mode mode = { };
 721
 722         FAIL_ON(drm_mode_parse_command_line_for_connector("NTSC@60f",
 723                                                           &no_connector,
 724                                                           &mode));
 725
 726         return 0;
 727 }
 728
 729 static int drm_cmdline_test_name_option(void *ignored)
 730 {
 731         struct drm_cmdline_mode mode = { };
 732
 733         FAIL_ON(!drm_mode_parse_command_line_for_connector("NTSC,rotate=180",
 734                                                            &no_connector,
 735                                                            &mode));
 736         FAIL_ON(!mode.specified);
 737         FAIL_ON(strcmp(mode.name, "NTSC"));
 738         FAIL_ON(mode.rotation_reflection != DRM_MODE_ROTATE_180);
 739
 740         return 0;
 741 }
 742
 743 static int drm_cmdline_test_name_bpp_option(void *ignored)
 744 {
 745         struct drm_cmdline_mode mode = { };
 746
 747         FAIL_ON(!drm_mode_parse_command_line_for_connector("NTSC-24,rotate=180",
 748                                                            &no_connector,
 749                                                            &mode));
 750         FAIL_ON(!mode.specified);
 751         FAIL_ON(strcmp(mode.name, "NTSC"));
 752         FAIL_ON(mode.rotation_reflection != DRM_MODE_ROTATE_180);
 753         FAIL_ON(!mode.bpp_specified);
 754         FAIL_ON(mode.bpp != 24);
 755
 756         return 0;
 757 }
 758
 759 static int drm_cmdline_test_rotate_0(void *ignored)
 760 {
 761         struct drm_cmdline_mode mode = { };
 762
 763         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480,rotate=0",
 764                                                            &no_connector,
 765                                                            &mode));
 766         FAIL_ON(!mode.specified);
 767         FAIL_ON(mode.xres != 720);
 768         FAIL_ON(mode.yres != 480);
 769         FAIL_ON(mode.rotation_reflection != DRM_MODE_ROTATE_0);
 770
 771         FAIL_ON(mode.refresh_specified);
 772
 773         FAIL_ON(mode.bpp_specified);
 774
 775         FAIL_ON(mode.rb);
 776         FAIL_ON(mode.cvt);
 777         FAIL_ON(mode.interlace);
 778         FAIL_ON(mode.margins);
 779         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 780
 781         return 0;
 782 }
 783
 784 static int drm_cmdline_test_rotate_90(void *ignored)
 785 {
 786         struct drm_cmdline_mode mode = { };
 787
 788         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480,rotate=90",
 789                                                            &no_connector,
 790                                                            &mode));
 791         FAIL_ON(!mode.specified);
 792         FAIL_ON(mode.xres != 720);
 793         FAIL_ON(mode.yres != 480);
 794         FAIL_ON(mode.rotation_reflection != DRM_MODE_ROTATE_90);
 795
 796         FAIL_ON(mode.refresh_specified);
 797
 798         FAIL_ON(mode.bpp_specified);
 799
 800         FAIL_ON(mode.rb);
 801         FAIL_ON(mode.cvt);
 802         FAIL_ON(mode.interlace);
 803         FAIL_ON(mode.margins);
 804         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 805
 806         return 0;
 807 }
 808
 809 static int drm_cmdline_test_rotate_180(void *ignored)
 810 {
 811         struct drm_cmdline_mode mode = { };
 812
 813         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480,rotate=180",
 814                                                            &no_connector,
 815                                                            &mode));
 816         FAIL_ON(!mode.specified);
 817         FAIL_ON(mode.xres != 720);
 818         FAIL_ON(mode.yres != 480);
 819         FAIL_ON(mode.rotation_reflection != DRM_MODE_ROTATE_180);
 820
 821         FAIL_ON(mode.refresh_specified);
 822
 823         FAIL_ON(mode.bpp_specified);
 824
 825         FAIL_ON(mode.rb);
 826         FAIL_ON(mode.cvt);
 827         FAIL_ON(mode.interlace);
 828         FAIL_ON(mode.margins);
 829         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 830
 831         return 0;
 832 }
 833
 834 static int drm_cmdline_test_rotate_270(void *ignored)
 835 {
 836         struct drm_cmdline_mode mode = { };
 837
 838         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480,rotate=270",
 839                                                            &no_connector,
 840                                                            &mode));
 841         FAIL_ON(!mode.specified);
 842         FAIL_ON(mode.xres != 720);
 843         FAIL_ON(mode.yres != 480);
 844         FAIL_ON(mode.rotation_reflection != DRM_MODE_ROTATE_270);
 845
 846         FAIL_ON(mode.refresh_specified);
 847
 848         FAIL_ON(mode.bpp_specified);
 849
 850         FAIL_ON(mode.rb);
 851         FAIL_ON(mode.cvt);
 852         FAIL_ON(mode.interlace);
 853         FAIL_ON(mode.margins);
 854         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 855
 856         return 0;
 857 }
 858
 859 static int drm_cmdline_test_rotate_multiple(void *ignored)
 860 {
 861         struct drm_cmdline_mode mode = { };
 862
 863         FAIL_ON(drm_mode_parse_command_line_for_connector("720x480,rotate=0,rotate=90",
 864                                                           &no_connector,
 865                                                           &mode));
 866
 867         return 0;
 868 }
 869
 870 static int drm_cmdline_test_rotate_invalid_val(void *ignored)
 871 {
 872         struct drm_cmdline_mode mode = { };
 873
 874         FAIL_ON(drm_mode_parse_command_line_for_connector("720x480,rotate=42",
 875                                                           &no_connector,
 876                                                           &mode));
 877
 878         return 0;
 879 }
 880
 881 static int drm_cmdline_test_rotate_truncated(void *ignored)
 882 {
 883         struct drm_cmdline_mode mode = { };
 884
 885         FAIL_ON(drm_mode_parse_command_line_for_connector("720x480,rotate=",
 886                                                           &no_connector,
 887                                                           &mode));
 888
 889         return 0;
 890 }
 891
 892 static int drm_cmdline_test_hmirror(void *ignored)
 893 {
 894         struct drm_cmdline_mode mode = { };
 895
 896         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480,reflect_x",
 897                                                            &no_connector,
 898                                                            &mode));
 899         FAIL_ON(!mode.specified);
 900         FAIL_ON(mode.xres != 720);
 901         FAIL_ON(mode.yres != 480);
 902         FAIL_ON(mode.rotation_reflection != (DRM_MODE_ROTATE_0 | DRM_MODE_REFLECT_X));
 903
 904         FAIL_ON(mode.refresh_specified);
 905
 906         FAIL_ON(mode.bpp_specified);
 907
 908         FAIL_ON(mode.rb);
 909         FAIL_ON(mode.cvt);
 910         FAIL_ON(mode.interlace);
 911         FAIL_ON(mode.margins);
 912         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 913
 914         return 0;
 915 }
 916
 917 static int drm_cmdline_test_vmirror(void *ignored)
 918 {
 919         struct drm_cmdline_mode mode = { };
 920
 921         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480,reflect_y",
 922                                                            &no_connector,
 923                                                            &mode));
 924         FAIL_ON(!mode.specified);
 925         FAIL_ON(mode.xres != 720);
 926         FAIL_ON(mode.yres != 480);
 927         FAIL_ON(mode.rotation_reflection != (DRM_MODE_ROTATE_0 | DRM_MODE_REFLECT_Y));
 928
 929         FAIL_ON(mode.refresh_specified);
 930
 931         FAIL_ON(mode.bpp_specified);
 932
 933         FAIL_ON(mode.rb);
 934         FAIL_ON(mode.cvt);
 935         FAIL_ON(mode.interlace);
 936         FAIL_ON(mode.margins);
 937         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 938
 939         return 0;
 940 }
 941
 942 static int drm_cmdline_test_margin_options(void *ignored)
 943 {
 944         struct drm_cmdline_mode mode = { };
 945
 946         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480,margin_right=14,margin_left=24,margin_bottom=36,margin_top=42",
 947                                                            &no_connector,
 948                                                            &mode));
 949         FAIL_ON(!mode.specified);
 950         FAIL_ON(mode.xres != 720);
 951         FAIL_ON(mode.yres != 480);
 952         FAIL_ON(mode.tv_margins.right != 14);
 953         FAIL_ON(mode.tv_margins.left != 24);
 954         FAIL_ON(mode.tv_margins.bottom != 36);
 955         FAIL_ON(mode.tv_margins.top != 42);
 956
 957         FAIL_ON(mode.refresh_specified);
 958
 959         FAIL_ON(mode.bpp_specified);
 960
 961         FAIL_ON(mode.rb);
 962         FAIL_ON(mode.cvt);
 963         FAIL_ON(mode.interlace);
 964         FAIL_ON(mode.margins);
 965         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 966
 967         return 0;
 968 }
 969
 970 static int drm_cmdline_test_multiple_options(void *ignored)
 971 {
 972         struct drm_cmdline_mode mode = { };
 973
 974         FAIL_ON(!drm_mode_parse_command_line_for_connector("720x480,rotate=270,reflect_x",
 975                                                            &no_connector,
 976                                                            &mode));
 977         FAIL_ON(!mode.specified);
 978         FAIL_ON(mode.xres != 720);
 979         FAIL_ON(mode.yres != 480);
 980         FAIL_ON(mode.rotation_reflection != (DRM_MODE_ROTATE_270 | DRM_MODE_REFLECT_X));
 981
 982         FAIL_ON(mode.refresh_specified);
 983
 984         FAIL_ON(mode.bpp_specified);
 985
 986         FAIL_ON(mode.rb);
 987         FAIL_ON(mode.cvt);
 988         FAIL_ON(mode.interlace);
 989         FAIL_ON(mode.margins);
 990         FAIL_ON(mode.force != DRM_FORCE_UNSPECIFIED);
 991
 992         return 0;
 993 }
 994
 995 static int drm_cmdline_test_invalid_option(void *ignored)
 996 {
 997         struct drm_cmdline_mode mode = { };
 998
 999         FAIL_ON(drm_mode_parse_command_line_for_connector("720x480,test=42",
1000                                                           &no_connector,
1001                                                           &mode));
1002
1003         return 0;
1004 }
1005
1006 #include "drm_selftest.c"
1007
1008 static int __init test_drm_cmdline_init(void)
1009 {
1010         int err;
1011
1012         err = run_selftests(selftests, ARRAY_SIZE(selftests), NULL);
1013
1014         return err > 0 ? 0 : err;
1015 }
1016 module_init(test_drm_cmdline_init);
1017
1018 MODULE_AUTHOR("Maxime Ripard <maxime.ripard@bootlin.com>");
1019 MODULE_LICENSE("GPL");