drivers/video/fbdev/vermilion/vermilion.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (c) Intel Corp. 2007.
   4  * All Rights Reserved.
   5  *
   6  * Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
   7  * develop this driver.
   8  *
   9  * This file is part of the Vermilion Range fb driver.
  10  *
  11  * Authors:
  12  *   Thomas Hellström <thomas-at-tungstengraphics-dot-com>
  13  *   Michel Dänzer <michel-at-tungstengraphics-dot-com>
  14  *   Alan Hourihane <alanh-at-tungstengraphics-dot-com>
  15  */
  16
  17 #include <linux/aperture.h>
  18 #include <linux/module.h>
  19 #include <linux/kernel.h>
  20 #include <linux/errno.h>
  21 #include <linux/string.h>
  22 #include <linux/delay.h>
  23 #include <linux/slab.h>
  24 #include <linux/mm.h>
  25 #include <linux/fb.h>
  26 #include <linux/pci.h>
  27 #include <asm/set_memory.h>
  28 #include <asm/tlbflush.h>
  29 #include <linux/mmzone.h>
  30
  31 /* #define VERMILION_DEBUG */
  32
  33 #include "vermilion.h"
  34
  35 #define MODULE_NAME "vmlfb"
  36
  37 #define VML_TOHW(_val, _width) ((((_val) << (_width)) + 0x7FFF - (_val)) >> 16)
  38
  39 static struct mutex vml_mutex;
  40 static struct list_head global_no_mode;
  41 static struct list_head global_has_mode;
  42 static struct fb_ops vmlfb_ops;
  43 static struct vml_sys *subsys = NULL;
  44 static char *vml_default_mode = "1024x768@60";
  45 static const struct fb_videomode defaultmode = {
  46         NULL, 60, 1024, 768, 12896, 144, 24, 29, 3, 136, 6,
  47         0, FB_VMODE_NONINTERLACED
  48 };
  49
  50 static u32 vml_mem_requested = (10 * 1024 * 1024);
  51 static u32 vml_mem_contig = (4 * 1024 * 1024);
  52 static u32 vml_mem_min = (4 * 1024 * 1024);
  53
  54 static u32 vml_clocks[] = {
  55         6750,
  56         13500,
  57         27000,
  58         29700,
  59         37125,
  60         54000,
  61         59400,
  62         74250,
  63         120000,
  64         148500
  65 };
  66
  67 static u32 vml_num_clocks = ARRAY_SIZE(vml_clocks);
  68
  69 /*
  70  * Allocate a contiguous vram area and make its linear kernel map
  71  * uncached.
  72  */
  73
  74 static int vmlfb_alloc_vram_area(struct vram_area *va, unsigned max_order,
  75                                  unsigned min_order)
  76 {
  77         gfp_t flags;
  78         unsigned long i;
  79
  80         max_order++;
  81         do {
  82                 /*
  83                  * Really try hard to get the needed memory.
  84                  * We need memory below the first 32MB, so we
  85                  * add the __GFP_DMA flag that guarantees that we are
  86                  * below the first 16MB.
  87                  */
  88
  89                 flags = __GFP_DMA | __GFP_HIGH | __GFP_KSWAPD_RECLAIM;
  90                 va->logical =
  91                          __get_free_pages(flags, --max_order);
  92         } while (va->logical == 0 && max_order > min_order);
  93
  94         if (!va->logical)
  95                 return -ENOMEM;
  96
  97         va->phys = virt_to_phys((void *)va->logical);
  98         va->size = PAGE_SIZE << max_order;
  99         va->order = max_order;
 100
 101         /*
 102          * It seems like __get_free_pages only ups the usage count
 103          * of the first page. This doesn't work with fault mapping, so
 104          * up the usage count once more (XXX: should use split_page or
 105          * compound page).
 106          */
 107
 108         memset((void *)va->logical, 0x00, va->size);
 109         for (i = va->logical; i < va->logical + va->size; i += PAGE_SIZE) {
 110                 get_page(virt_to_page(i));
 111         }
 112
 113         /*
 114          * Change caching policy of the linear kernel map to avoid
 115          * mapping type conflicts with user-space mappings.
 116          */
 117         set_pages_uc(virt_to_page(va->logical), va->size >> PAGE_SHIFT);
 118
 119         printk(KERN_DEBUG MODULE_NAME
 120                ": Allocated %ld bytes vram area at 0x%08lx\n",
 121                va->size, va->phys);
 122
 123         return 0;
 124 }
 125
 126 /*
 127  * Free a contiguous vram area and reset its linear kernel map
 128  * mapping type.
 129  */
 130
 131 static void vmlfb_free_vram_area(struct vram_area *va)
 132 {
 133         unsigned long j;
 134
 135         if (va->logical) {
 136
 137                 /*
 138                  * Reset the linear kernel map caching policy.
 139                  */
 140
 141                 set_pages_wb(virt_to_page(va->logical),
 142                                  va->size >> PAGE_SHIFT);
 143
 144                 /*
 145                  * Decrease the usage count on the pages we've used
 146                  * to compensate for upping when allocating.
 147                  */
 148
 149                 for (j = va->logical; j < va->logical + va->size;
 150                      j += PAGE_SIZE) {
 151                         (void)put_page_testzero(virt_to_page(j));
 152                 }
 153
 154                 printk(KERN_DEBUG MODULE_NAME
 155                        ": Freeing %ld bytes vram area at 0x%08lx\n",
 156                        va->size, va->phys);
 157                 free_pages(va->logical, va->order);
 158
 159                 va->logical = 0;
 160         }
 161 }
 162
 163 /*
 164  * Free allocated vram.
 165  */
 166
 167 static void vmlfb_free_vram(struct vml_info *vinfo)
 168 {
 169         int i;
 170
 171         for (i = 0; i < vinfo->num_areas; ++i) {
 172                 vmlfb_free_vram_area(&vinfo->vram[i]);
 173         }
 174         vinfo->num_areas = 0;
 175 }
 176
 177 /*
 178  * Allocate vram. Currently we try to allocate contiguous areas from the
 179  * __GFP_DMA zone and puzzle them together. A better approach would be to
 180  * allocate one contiguous area for scanout and use one-page allocations for
 181  * offscreen areas. This requires user-space and GPU virtual mappings.
 182  */
 183
 184 static int vmlfb_alloc_vram(struct vml_info *vinfo,
 185                             size_t requested,
 186                             size_t min_total, size_t min_contig)
 187 {
 188         int i, j;
 189         int order;
 190         int contiguous;
 191         int err;
 192         struct vram_area *va;
 193         struct vram_area *va2;
 194
 195         vinfo->num_areas = 0;
 196         for (i = 0; i < VML_VRAM_AREAS; ++i) {
 197                 va = &vinfo->vram[i];
 198                 order = 0;
 199
 200                 while (requested > (PAGE_SIZE << order) && order <= MAX_ORDER)
 201                         order++;
 202
 203                 err = vmlfb_alloc_vram_area(va, order, 0);
 204
 205                 if (err)
 206                         break;
 207
 208                 if (i == 0) {
 209                         vinfo->vram_start = va->phys;
 210                         vinfo->vram_logical = (void __iomem *) va->logical;
 211                         vinfo->vram_contig_size = va->size;
 212                         vinfo->num_areas = 1;
 213                 } else {
 214                         contiguous = 0;
 215
 216                         for (j = 0; j < i; ++j) {
 217                                 va2 = &vinfo->vram[j];
 218                                 if (va->phys + va->size == va2->phys ||
 219                                     va2->phys + va2->size == va->phys) {
 220                                         contiguous = 1;
 221                                         break;
 222                                 }
 223                         }
 224
 225                         if (contiguous) {
 226                                 vinfo->num_areas++;
 227                                 if (va->phys < vinfo->vram_start) {
 228                                         vinfo->vram_start = va->phys;
 229                                         vinfo->vram_logical =
 230                                                 (void __iomem *)va->logical;
 231                                 }
 232                                 vinfo->vram_contig_size += va->size;
 233                         } else {
 234                                 vmlfb_free_vram_area(va);
 235                                 break;
 236                         }
 237                 }
 238
 239                 if (requested < va->size)
 240                         break;
 241                 else
 242                         requested -= va->size;
 243         }
 244
 245         if (vinfo->vram_contig_size > min_total &&
 246             vinfo->vram_contig_size > min_contig) {
 247
 248                 printk(KERN_DEBUG MODULE_NAME
 249                        ": Contiguous vram: %ld bytes at physical 0x%08lx.\n",
 250                        (unsigned long)vinfo->vram_contig_size,
 251                        (unsigned long)vinfo->vram_start);
 252
 253                 return 0;
 254         }
 255
 256         printk(KERN_ERR MODULE_NAME
 257                ": Could not allocate requested minimal amount of vram.\n");
 258
 259         vmlfb_free_vram(vinfo);
 260
 261         return -ENOMEM;
 262 }
 263
 264 /*
 265  * Find the GPU to use with our display controller.
 266  */
 267
 268 static int vmlfb_get_gpu(struct vml_par *par)
 269 {
 270         mutex_lock(&vml_mutex);
 271
 272         par->gpu = pci_get_device(PCI_VENDOR_ID_INTEL, VML_DEVICE_GPU, NULL);
 273
 274         if (!par->gpu) {
 275                 mutex_unlock(&vml_mutex);
 276                 return -ENODEV;
 277         }
 278
 279         mutex_unlock(&vml_mutex);
 280
 281         if (pci_enable_device(par->gpu) < 0) {
 282                 pci_dev_put(par->gpu);
 283                 return -ENODEV;
 284         }
 285
 286         return 0;
 287 }
 288
 289 /*
 290  * Find a contiguous vram area that contains a given offset from vram start.
 291  */
 292 static int vmlfb_vram_offset(struct vml_info *vinfo, unsigned long offset)
 293 {
 294         unsigned long aoffset;
 295         unsigned i;
 296
 297         for (i = 0; i < vinfo->num_areas; ++i) {
 298                 aoffset = offset - (vinfo->vram[i].phys - vinfo->vram_start);
 299
 300                 if (aoffset < vinfo->vram[i].size) {
 301                         return 0;
 302                 }
 303         }
 304
 305         return -EINVAL;
 306 }
 307
 308 /*
 309  * Remap the MMIO register spaces of the VDC and the GPU.
 310  */
 311
 312 static int vmlfb_enable_mmio(struct vml_par *par)
 313 {
 314         int err;
 315
 316         par->vdc_mem_base = pci_resource_start(par->vdc, 0);
 317         par->vdc_mem_size = pci_resource_len(par->vdc, 0);
 318         if (!request_mem_region(par->vdc_mem_base, par->vdc_mem_size, "vmlfb")) {
 319                 printk(KERN_ERR MODULE_NAME
 320                        ": Could not claim display controller MMIO.\n");
 321                 return -EBUSY;
 322         }
 323         par->vdc_mem = ioremap(par->vdc_mem_base, par->vdc_mem_size);
 324         if (par->vdc_mem == NULL) {
 325                 printk(KERN_ERR MODULE_NAME
 326                        ": Could not map display controller MMIO.\n");
 327                 err = -ENOMEM;
 328                 goto out_err_0;
 329         }
 330
 331         par->gpu_mem_base = pci_resource_start(par->gpu, 0);
 332         par->gpu_mem_size = pci_resource_len(par->gpu, 0);
 333         if (!request_mem_region(par->gpu_mem_base, par->gpu_mem_size, "vmlfb")) {
 334                 printk(KERN_ERR MODULE_NAME ": Could not claim GPU MMIO.\n");
 335                 err = -EBUSY;
 336                 goto out_err_1;
 337         }
 338         par->gpu_mem = ioremap(par->gpu_mem_base, par->gpu_mem_size);
 339         if (par->gpu_mem == NULL) {
 340                 printk(KERN_ERR MODULE_NAME ": Could not map GPU MMIO.\n");
 341                 err = -ENOMEM;
 342                 goto out_err_2;
 343         }
 344
 345         return 0;
 346
 347 out_err_2:
 348         release_mem_region(par->gpu_mem_base, par->gpu_mem_size);
 349 out_err_1:
 350         iounmap(par->vdc_mem);
 351 out_err_0:
 352         release_mem_region(par->vdc_mem_base, par->vdc_mem_size);
 353         return err;
 354 }
 355
 356 /*
 357  * Unmap the VDC and GPU register spaces.
 358  */
 359
 360 static void vmlfb_disable_mmio(struct vml_par *par)
 361 {
 362         iounmap(par->gpu_mem);
 363         release_mem_region(par->gpu_mem_base, par->gpu_mem_size);
 364         iounmap(par->vdc_mem);
 365         release_mem_region(par->vdc_mem_base, par->vdc_mem_size);
 366 }
 367
 368 /*
 369  * Release and uninit the VDC and GPU.
 370  */
 371
 372 static void vmlfb_release_devices(struct vml_par *par)
 373 {
 374         if (atomic_dec_and_test(&par->refcount)) {
 375                 pci_disable_device(par->gpu);
 376                 pci_disable_device(par->vdc);
 377         }
 378 }
 379
 380 /*
 381  * Free up allocated resources for a device.
 382  */
 383
 384 static void vml_pci_remove(struct pci_dev *dev)
 385 {
 386         struct fb_info *info;
 387         struct vml_info *vinfo;
 388         struct vml_par *par;
 389
 390         info = pci_get_drvdata(dev);
 391         if (info) {
 392                 vinfo = container_of(info, struct vml_info, info);
 393                 par = vinfo->par;
 394                 mutex_lock(&vml_mutex);
 395                 unregister_framebuffer(info);
 396                 fb_dealloc_cmap(&info->cmap);
 397                 vmlfb_free_vram(vinfo);
 398                 vmlfb_disable_mmio(par);
 399                 vmlfb_release_devices(par);
 400                 kfree(vinfo);
 401                 kfree(par);
 402                 mutex_unlock(&vml_mutex);
 403         }
 404 }
 405
 406 static void vmlfb_set_pref_pixel_format(struct fb_var_screeninfo *var)
 407 {
 408         switch (var->bits_per_pixel) {
 409         case 16:
 410                 var->blue.offset = 0;
 411                 var->blue.length = 5;
 412                 var->green.offset = 5;
 413                 var->green.length = 5;
 414                 var->red.offset = 10;
 415                 var->red.length = 5;
 416                 var->transp.offset = 15;
 417                 var->transp.length = 1;
 418                 break;
 419         case 32:
 420                 var->blue.offset = 0;
 421                 var->blue.length = 8;
 422                 var->green.offset = 8;
 423                 var->green.length = 8;
 424                 var->red.offset = 16;
 425                 var->red.length = 8;
 426                 var->transp.offset = 24;
 427                 var->transp.length = 0;
 428                 break;
 429         default:
 430                 break;
 431         }
 432
 433         var->blue.msb_right = var->green.msb_right =
 434             var->red.msb_right = var->transp.msb_right = 0;
 435 }
 436
 437 /*
 438  * Device initialization.
 439  * We initialize one vml_par struct per device and one vml_info
 440  * struct per pipe. Currently we have only one pipe.
 441  */
 442
 443 static int vml_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 444 {
 445         struct vml_info *vinfo;
 446         struct fb_info *info;
 447         struct vml_par *par;
 448         int err;
 449
 450         err = aperture_remove_conflicting_pci_devices(dev, "vmlfb");
 451         if (err)
 452                 return err;
 453
 454         par = kzalloc(sizeof(*par), GFP_KERNEL);
 455         if (par == NULL)
 456                 return -ENOMEM;
 457
 458         vinfo = kzalloc(sizeof(*vinfo), GFP_KERNEL);
 459         if (vinfo == NULL) {
 460                 err = -ENOMEM;
 461                 goto out_err_0;
 462         }
 463
 464         vinfo->par = par;
 465         par->vdc = dev;
 466         atomic_set(&par->refcount, 1);
 467
 468         switch (id->device) {
 469         case VML_DEVICE_VDC:
 470                 if ((err = vmlfb_get_gpu(par)))
 471                         goto out_err_1;
 472                 pci_set_drvdata(dev, &vinfo->info);
 473                 break;
 474         default:
 475                 err = -ENODEV;
 476                 goto out_err_1;
 477         }
 478
 479         info = &vinfo->info;
 480         info->flags = FBINFO_PARTIAL_PAN_OK;
 481
 482         err = vmlfb_enable_mmio(par);
 483         if (err)
 484                 goto out_err_2;
 485
 486         err = vmlfb_alloc_vram(vinfo, vml_mem_requested,
 487                                vml_mem_contig, vml_mem_min);
 488         if (err)
 489                 goto out_err_3;
 490
 491         strcpy(info->fix.id, "Vermilion Range");
 492         info->fix.mmio_start = 0;
 493         info->fix.mmio_len = 0;
 494         info->fix.smem_start = vinfo->vram_start;
 495         info->fix.smem_len = vinfo->vram_contig_size;
 496         info->fix.type = FB_TYPE_PACKED_PIXELS;
 497         info->fix.visual = FB_VISUAL_TRUECOLOR;
 498         info->fix.ypanstep = 1;
 499         info->fix.xpanstep = 1;
 500         info->fix.ywrapstep = 0;
 501         info->fix.accel = FB_ACCEL_NONE;
 502         info->screen_base = vinfo->vram_logical;
 503         info->pseudo_palette = vinfo->pseudo_palette;
 504         info->par = par;
 505         info->fbops = &vmlfb_ops;
 506         info->device = &dev->dev;
 507
 508         INIT_LIST_HEAD(&vinfo->head);
 509         vinfo->pipe_disabled = 1;
 510         vinfo->cur_blank_mode = FB_BLANK_UNBLANK;
 511
 512         info->var.grayscale = 0;
 513         info->var.bits_per_pixel = 16;
 514         vmlfb_set_pref_pixel_format(&info->var);
 515
 516         if (!fb_find_mode
 517             (&info->var, info, vml_default_mode, NULL, 0, &defaultmode, 16)) {
 518                 printk(KERN_ERR MODULE_NAME ": Could not find initial mode\n");
 519         }
 520
 521         if (fb_alloc_cmap(&info->cmap, 256, 1) < 0) {
 522                 err = -ENOMEM;
 523                 goto out_err_4;
 524         }
 525
 526         err = register_framebuffer(info);
 527         if (err) {
 528                 printk(KERN_ERR MODULE_NAME ": Register framebuffer error.\n");
 529                 goto out_err_5;
 530         }
 531
 532         printk("Initialized vmlfb\n");
 533
 534         return 0;
 535
 536 out_err_5:
 537         fb_dealloc_cmap(&info->cmap);
 538 out_err_4:
 539         vmlfb_free_vram(vinfo);
 540 out_err_3:
 541         vmlfb_disable_mmio(par);
 542 out_err_2:
 543         vmlfb_release_devices(par);
 544 out_err_1:
 545         kfree(vinfo);
 546 out_err_0:
 547         kfree(par);
 548         return err;
 549 }
 550
 551 static int vmlfb_open(struct fb_info *info, int user)
 552 {
 553         /*
 554          * Save registers here?
 555          */
 556         return 0;
 557 }
 558
 559 static int vmlfb_release(struct fb_info *info, int user)
 560 {
 561         /*
 562          * Restore registers here.
 563          */
 564
 565         return 0;
 566 }
 567
 568 static int vml_nearest_clock(int clock)
 569 {
 570
 571         int i;
 572         int cur_index;
 573         int cur_diff;
 574         int diff;
 575
 576         cur_index = 0;
 577         cur_diff = clock - vml_clocks[0];
 578         cur_diff = (cur_diff < 0) ? -cur_diff : cur_diff;
 579         for (i = 1; i < vml_num_clocks; ++i) {
 580                 diff = clock - vml_clocks[i];
 581                 diff = (diff < 0) ? -diff : diff;
 582                 if (diff < cur_diff) {
 583                         cur_index = i;
 584                         cur_diff = diff;
 585                 }
 586         }
 587         return vml_clocks[cur_index];
 588 }
 589
 590 static int vmlfb_check_var_locked(struct fb_var_screeninfo *var,
 591                                   struct vml_info *vinfo)
 592 {
 593         u32 pitch;
 594         u64 mem;
 595         int nearest_clock;
 596         int clock;
 597         int clock_diff;
 598         struct fb_var_screeninfo v;
 599
 600         v = *var;
 601         clock = PICOS2KHZ(var->pixclock);
 602
 603         if (subsys && subsys->nearest_clock) {
 604                 nearest_clock = subsys->nearest_clock(subsys, clock);
 605         } else {
 606                 nearest_clock = vml_nearest_clock(clock);
 607         }
 608
 609         /*
 610          * Accept a 20% diff.
 611          */
 612
 613         clock_diff = nearest_clock - clock;
 614         clock_diff = (clock_diff < 0) ? -clock_diff : clock_diff;
 615         if (clock_diff > clock / 5) {
 616 #if 0
 617                 printk(KERN_DEBUG MODULE_NAME ": Diff failure. %d %d\n",clock_diff,clock);
 618 #endif
 619                 return -EINVAL;
 620         }
 621
 622         v.pixclock = KHZ2PICOS(nearest_clock);
 623
 624         if (var->xres > VML_MAX_XRES || var->yres > VML_MAX_YRES) {
 625                 printk(KERN_DEBUG MODULE_NAME ": Resolution failure.\n");
 626                 return -EINVAL;
 627         }
 628         if (var->xres_virtual > VML_MAX_XRES_VIRTUAL) {
 629                 printk(KERN_DEBUG MODULE_NAME
 630                        ": Virtual resolution failure.\n");
 631                 return -EINVAL;
 632         }
 633         switch (v.bits_per_pixel) {
 634         case 0 ... 16:
 635                 v.bits_per_pixel = 16;
 636                 break;
 637         case 17 ... 32:
 638                 v.bits_per_pixel = 32;
 639                 break;
 640         default:
 641                 printk(KERN_DEBUG MODULE_NAME ": Invalid bpp: %d.\n",
 642                        var->bits_per_pixel);
 643                 return -EINVAL;
 644         }
 645
 646         pitch = ALIGN((var->xres * var->bits_per_pixel) >> 3, 0x40);
 647         mem = (u64)pitch * var->yres_virtual;
 648         if (mem > vinfo->vram_contig_size) {
 649                 return -ENOMEM;
 650         }
 651
 652         switch (v.bits_per_pixel) {
 653         case 16:
 654                 if (var->blue.offset != 0 ||
 655                     var->blue.length != 5 ||
 656                     var->green.offset != 5 ||
 657                     var->green.length != 5 ||
 658                     var->red.offset != 10 ||
 659                     var->red.length != 5 ||
 660                     var->transp.offset != 15 || var->transp.length != 1) {
 661                         vmlfb_set_pref_pixel_format(&v);
 662                 }
 663                 break;
 664         case 32:
 665                 if (var->blue.offset != 0 ||
 666                     var->blue.length != 8 ||
 667                     var->green.offset != 8 ||
 668                     var->green.length != 8 ||
 669                     var->red.offset != 16 ||
 670                     var->red.length != 8 ||
 671                     (var->transp.length != 0 && var->transp.length != 8) ||
 672                     (var->transp.length == 8 && var->transp.offset != 24)) {
 673                         vmlfb_set_pref_pixel_format(&v);
 674                 }
 675                 break;
 676         default:
 677                 return -EINVAL;
 678         }
 679
 680         *var = v;
 681
 682         return 0;
 683 }
 684
 685 static int vmlfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 686 {
 687         struct vml_info *vinfo = container_of(info, struct vml_info, info);
 688         int ret;
 689
 690         mutex_lock(&vml_mutex);
 691         ret = vmlfb_check_var_locked(var, vinfo);
 692         mutex_unlock(&vml_mutex);
 693
 694         return ret;
 695 }
 696
 697 static void vml_wait_vblank(struct vml_info *vinfo)
 698 {
 699         /* Wait for vblank. For now, just wait for a 50Hz cycle (20ms)) */
 700         mdelay(20);
 701 }
 702
 703 static void vmlfb_disable_pipe(struct vml_info *vinfo)
 704 {
 705         struct vml_par *par = vinfo->par;
 706
 707         /* Disable the MDVO pad */
 708         VML_WRITE32(par, VML_RCOMPSTAT, 0);
 709         while (!(VML_READ32(par, VML_RCOMPSTAT) & VML_MDVO_VDC_I_RCOMP)) ;
 710
 711         /* Disable display planes */
 712         VML_WRITE32(par, VML_DSPCCNTR,
 713                     VML_READ32(par, VML_DSPCCNTR) & ~VML_GFX_ENABLE);
 714         (void)VML_READ32(par, VML_DSPCCNTR);
 715         /* Wait for vblank for the disable to take effect */
 716         vml_wait_vblank(vinfo);
 717
 718         /* Next, disable display pipes */
 719         VML_WRITE32(par, VML_PIPEACONF, 0);
 720         (void)VML_READ32(par, VML_PIPEACONF);
 721
 722         vinfo->pipe_disabled = 1;
 723 }
 724
 725 #ifdef VERMILION_DEBUG
 726 static void vml_dump_regs(struct vml_info *vinfo)
 727 {
 728         struct vml_par *par = vinfo->par;
 729
 730         printk(KERN_DEBUG MODULE_NAME ": Modesetting register dump:\n");
 731         printk(KERN_DEBUG MODULE_NAME ": \tHTOTAL_A         : 0x%08x\n",
 732                (unsigned)VML_READ32(par, VML_HTOTAL_A));
 733         printk(KERN_DEBUG MODULE_NAME ": \tHBLANK_A         : 0x%08x\n",
 734                (unsigned)VML_READ32(par, VML_HBLANK_A));
 735         printk(KERN_DEBUG MODULE_NAME ": \tHSYNC_A          : 0x%08x\n",
 736                (unsigned)VML_READ32(par, VML_HSYNC_A));
 737         printk(KERN_DEBUG MODULE_NAME ": \tVTOTAL_A         : 0x%08x\n",
 738                (unsigned)VML_READ32(par, VML_VTOTAL_A));
 739         printk(KERN_DEBUG MODULE_NAME ": \tVBLANK_A         : 0x%08x\n",
 740                (unsigned)VML_READ32(par, VML_VBLANK_A));
 741         printk(KERN_DEBUG MODULE_NAME ": \tVSYNC_A          : 0x%08x\n",
 742                (unsigned)VML_READ32(par, VML_VSYNC_A));
 743         printk(KERN_DEBUG MODULE_NAME ": \tDSPCSTRIDE       : 0x%08x\n",
 744                (unsigned)VML_READ32(par, VML_DSPCSTRIDE));
 745         printk(KERN_DEBUG MODULE_NAME ": \tDSPCSIZE         : 0x%08x\n",
 746                (unsigned)VML_READ32(par, VML_DSPCSIZE));
 747         printk(KERN_DEBUG MODULE_NAME ": \tDSPCPOS          : 0x%08x\n",
 748                (unsigned)VML_READ32(par, VML_DSPCPOS));
 749         printk(KERN_DEBUG MODULE_NAME ": \tDSPARB           : 0x%08x\n",
 750                (unsigned)VML_READ32(par, VML_DSPARB));
 751         printk(KERN_DEBUG MODULE_NAME ": \tDSPCADDR         : 0x%08x\n",
 752                (unsigned)VML_READ32(par, VML_DSPCADDR));
 753         printk(KERN_DEBUG MODULE_NAME ": \tBCLRPAT_A        : 0x%08x\n",
 754                (unsigned)VML_READ32(par, VML_BCLRPAT_A));
 755         printk(KERN_DEBUG MODULE_NAME ": \tCANVSCLR_A       : 0x%08x\n",
 756                (unsigned)VML_READ32(par, VML_CANVSCLR_A));
 757         printk(KERN_DEBUG MODULE_NAME ": \tPIPEASRC         : 0x%08x\n",
 758                (unsigned)VML_READ32(par, VML_PIPEASRC));
 759         printk(KERN_DEBUG MODULE_NAME ": \tPIPEACONF        : 0x%08x\n",
 760                (unsigned)VML_READ32(par, VML_PIPEACONF));
 761         printk(KERN_DEBUG MODULE_NAME ": \tDSPCCNTR         : 0x%08x\n",
 762                (unsigned)VML_READ32(par, VML_DSPCCNTR));
 763         printk(KERN_DEBUG MODULE_NAME ": \tRCOMPSTAT        : 0x%08x\n",
 764                (unsigned)VML_READ32(par, VML_RCOMPSTAT));
 765         printk(KERN_DEBUG MODULE_NAME ": End of modesetting register dump.\n");
 766 }
 767 #endif
 768
 769 static int vmlfb_set_par_locked(struct vml_info *vinfo)
 770 {
 771         struct vml_par *par = vinfo->par;
 772         struct fb_info *info = &vinfo->info;
 773         struct fb_var_screeninfo *var = &info->var;
 774         u32 htotal, hactive, hblank_start, hblank_end, hsync_start, hsync_end;
 775         u32 vtotal, vactive, vblank_start, vblank_end, vsync_start, vsync_end;
 776         u32 dspcntr;
 777         int clock;
 778
 779         vinfo->bytes_per_pixel = var->bits_per_pixel >> 3;
 780         vinfo->stride = ALIGN(var->xres_virtual * vinfo->bytes_per_pixel, 0x40);
 781         info->fix.line_length = vinfo->stride;
 782
 783         if (!subsys)
 784                 return 0;
 785
 786         htotal =
 787             var->xres + var->right_margin + var->hsync_len + var->left_margin;
 788         hactive = var->xres;
 789         hblank_start = var->xres;
 790         hblank_end = htotal;
 791         hsync_start = hactive + var->right_margin;
 792         hsync_end = hsync_start + var->hsync_len;
 793
 794         vtotal =
 795             var->yres + var->lower_margin + var->vsync_len + var->upper_margin;
 796         vactive = var->yres;
 797         vblank_start = var->yres;
 798         vblank_end = vtotal;
 799         vsync_start = vactive + var->lower_margin;
 800         vsync_end = vsync_start + var->vsync_len;
 801
 802         dspcntr = VML_GFX_ENABLE | VML_GFX_GAMMABYPASS;
 803         clock = PICOS2KHZ(var->pixclock);
 804
 805         if (subsys->nearest_clock) {
 806                 clock = subsys->nearest_clock(subsys, clock);
 807         } else {
 808                 clock = vml_nearest_clock(clock);
 809         }
 810         printk(KERN_DEBUG MODULE_NAME
 811                ": Set mode Hfreq : %d kHz, Vfreq : %d Hz.\n", clock / htotal,
 812                ((clock / htotal) * 1000) / vtotal);
 813
 814         switch (var->bits_per_pixel) {
 815         case 16:
 816                 dspcntr |= VML_GFX_ARGB1555;
 817                 break;
 818         case 32:
 819                 if (var->transp.length == 8)
 820                         dspcntr |= VML_GFX_ARGB8888 | VML_GFX_ALPHAMULT;
 821                 else
 822                         dspcntr |= VML_GFX_RGB0888;
 823                 break;
 824         default:
 825                 return -EINVAL;
 826         }
 827
 828         vmlfb_disable_pipe(vinfo);
 829         mb();
 830
 831         if (subsys->set_clock)
 832                 subsys->set_clock(subsys, clock);
 833         else
 834                 return -EINVAL;
 835
 836         VML_WRITE32(par, VML_HTOTAL_A, ((htotal - 1) << 16) | (hactive - 1));
 837         VML_WRITE32(par, VML_HBLANK_A,
 838                     ((hblank_end - 1) << 16) | (hblank_start - 1));
 839         VML_WRITE32(par, VML_HSYNC_A,
 840                     ((hsync_end - 1) << 16) | (hsync_start - 1));
 841         VML_WRITE32(par, VML_VTOTAL_A, ((vtotal - 1) << 16) | (vactive - 1));
 842         VML_WRITE32(par, VML_VBLANK_A,
 843                     ((vblank_end - 1) << 16) | (vblank_start - 1));
 844         VML_WRITE32(par, VML_VSYNC_A,
 845                     ((vsync_end - 1) << 16) | (vsync_start - 1));
 846         VML_WRITE32(par, VML_DSPCSTRIDE, vinfo->stride);
 847         VML_WRITE32(par, VML_DSPCSIZE,
 848                     ((var->yres - 1) << 16) | (var->xres - 1));
 849         VML_WRITE32(par, VML_DSPCPOS, 0x00000000);
 850         VML_WRITE32(par, VML_DSPARB, VML_FIFO_DEFAULT);
 851         VML_WRITE32(par, VML_BCLRPAT_A, 0x00000000);
 852         VML_WRITE32(par, VML_CANVSCLR_A, 0x00000000);
 853         VML_WRITE32(par, VML_PIPEASRC,
 854                     ((var->xres - 1) << 16) | (var->yres - 1));
 855
 856         wmb();
 857         VML_WRITE32(par, VML_PIPEACONF, VML_PIPE_ENABLE);
 858         wmb();
 859         VML_WRITE32(par, VML_DSPCCNTR, dspcntr);
 860         wmb();
 861         VML_WRITE32(par, VML_DSPCADDR, (u32) vinfo->vram_start +
 862                     var->yoffset * vinfo->stride +
 863                     var->xoffset * vinfo->bytes_per_pixel);
 864
 865         VML_WRITE32(par, VML_RCOMPSTAT, VML_MDVO_PAD_ENABLE);
 866
 867         while (!(VML_READ32(par, VML_RCOMPSTAT) &
 868                  (VML_MDVO_VDC_I_RCOMP | VML_MDVO_PAD_ENABLE))) ;
 869
 870         vinfo->pipe_disabled = 0;
 871 #ifdef VERMILION_DEBUG
 872         vml_dump_regs(vinfo);
 873 #endif
 874
 875         return 0;
 876 }
 877
 878 static int vmlfb_set_par(struct fb_info *info)
 879 {
 880         struct vml_info *vinfo = container_of(info, struct vml_info, info);
 881         int ret;
 882
 883         mutex_lock(&vml_mutex);
 884         list_move(&vinfo->head, (subsys) ? &global_has_mode : &global_no_mode);
 885         ret = vmlfb_set_par_locked(vinfo);
 886
 887         mutex_unlock(&vml_mutex);
 888         return ret;
 889 }
 890
 891 static int vmlfb_blank_locked(struct vml_info *vinfo)
 892 {
 893         struct vml_par *par = vinfo->par;
 894         u32 cur = VML_READ32(par, VML_PIPEACONF);
 895
 896         switch (vinfo->cur_blank_mode) {
 897         case FB_BLANK_UNBLANK:
 898                 if (vinfo->pipe_disabled) {
 899                         vmlfb_set_par_locked(vinfo);
 900                 }
 901                 VML_WRITE32(par, VML_PIPEACONF, cur & ~VML_PIPE_FORCE_BORDER);
 902                 (void)VML_READ32(par, VML_PIPEACONF);
 903                 break;
 904         case FB_BLANK_NORMAL:
 905                 if (vinfo->pipe_disabled) {
 906                         vmlfb_set_par_locked(vinfo);
 907                 }
 908                 VML_WRITE32(par, VML_PIPEACONF, cur | VML_PIPE_FORCE_BORDER);
 909                 (void)VML_READ32(par, VML_PIPEACONF);
 910                 break;
 911         case FB_BLANK_VSYNC_SUSPEND:
 912         case FB_BLANK_HSYNC_SUSPEND:
 913                 if (!vinfo->pipe_disabled) {
 914                         vmlfb_disable_pipe(vinfo);
 915                 }
 916                 break;
 917         case FB_BLANK_POWERDOWN:
 918                 if (!vinfo->pipe_disabled) {
 919                         vmlfb_disable_pipe(vinfo);
 920                 }
 921                 break;
 922         default:
 923                 return -EINVAL;
 924         }
 925
 926         return 0;
 927 }
 928
 929 static int vmlfb_blank(int blank_mode, struct fb_info *info)
 930 {
 931         struct vml_info *vinfo = container_of(info, struct vml_info, info);
 932         int ret;
 933
 934         mutex_lock(&vml_mutex);
 935         vinfo->cur_blank_mode = blank_mode;
 936         ret = vmlfb_blank_locked(vinfo);
 937         mutex_unlock(&vml_mutex);
 938         return ret;
 939 }
 940
 941 static int vmlfb_pan_display(struct fb_var_screeninfo *var,
 942                              struct fb_info *info)
 943 {
 944         struct vml_info *vinfo = container_of(info, struct vml_info, info);
 945         struct vml_par *par = vinfo->par;
 946
 947         mutex_lock(&vml_mutex);
 948         VML_WRITE32(par, VML_DSPCADDR, (u32) vinfo->vram_start +
 949                     var->yoffset * vinfo->stride +
 950                     var->xoffset * vinfo->bytes_per_pixel);
 951         (void)VML_READ32(par, VML_DSPCADDR);
 952         mutex_unlock(&vml_mutex);
 953
 954         return 0;
 955 }
 956
 957 static int vmlfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
 958                            u_int transp, struct fb_info *info)
 959 {
 960         u32 v;
 961
 962         if (regno >= 16)
 963                 return -EINVAL;
 964
 965         if (info->var.grayscale) {
 966                 red = green = blue = (red * 77 + green * 151 + blue * 28) >> 8;
 967         }
 968
 969         if (info->fix.visual != FB_VISUAL_TRUECOLOR)
 970                 return -EINVAL;
 971
 972         red = VML_TOHW(red, info->var.red.length);
 973         blue = VML_TOHW(blue, info->var.blue.length);
 974         green = VML_TOHW(green, info->var.green.length);
 975         transp = VML_TOHW(transp, info->var.transp.length);
 976
 977         v = (red << info->var.red.offset) |
 978             (green << info->var.green.offset) |
 979             (blue << info->var.blue.offset) |
 980             (transp << info->var.transp.offset);
 981
 982         switch (info->var.bits_per_pixel) {
 983         case 16:
 984                 ((u32 *) info->pseudo_palette)[regno] = v;
 985                 break;
 986         case 24:
 987         case 32:
 988                 ((u32 *) info->pseudo_palette)[regno] = v;
 989                 break;
 990         }
 991         return 0;
 992 }
 993
 994 static int vmlfb_mmap(struct fb_info *info, struct vm_area_struct *vma)
 995 {
 996         struct vml_info *vinfo = container_of(info, struct vml_info, info);
 997         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
 998         int ret;
 999         unsigned long prot;
1000
1001         ret = vmlfb_vram_offset(vinfo, offset);
1002         if (ret)
1003                 return -EINVAL;
1004
1005         prot = pgprot_val(vma->vm_page_prot) & ~_PAGE_CACHE_MASK;
1006         pgprot_val(vma->vm_page_prot) =
1007                 prot | cachemode2protval(_PAGE_CACHE_MODE_UC_MINUS);
1008
1009         return vm_iomap_memory(vma, vinfo->vram_start,
1010                         vinfo->vram_contig_size);
1011 }
1012
1013 static int vmlfb_sync(struct fb_info *info)
1014 {
1015         return 0;
1016 }
1017
1018 static int vmlfb_cursor(struct fb_info *info, struct fb_cursor *cursor)
1019 {
1020         return -EINVAL; /* just to force soft_cursor() call */
1021 }
1022
1023 static struct fb_ops vmlfb_ops = {
1024         .owner = THIS_MODULE,
1025         .fb_open = vmlfb_open,
1026         .fb_release = vmlfb_release,
1027         .fb_check_var = vmlfb_check_var,
1028         .fb_set_par = vmlfb_set_par,
1029         .fb_blank = vmlfb_blank,
1030         .fb_pan_display = vmlfb_pan_display,
1031         .fb_fillrect = cfb_fillrect,
1032         .fb_copyarea = cfb_copyarea,
1033         .fb_imageblit = cfb_imageblit,
1034         .fb_cursor = vmlfb_cursor,
1035         .fb_sync = vmlfb_sync,
1036         .fb_mmap = vmlfb_mmap,
1037         .fb_setcolreg = vmlfb_setcolreg
1038 };
1039
1040 static const struct pci_device_id vml_ids[] = {
1041         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, VML_DEVICE_VDC)},
1042         {0}
1043 };
1044
1045 static struct pci_driver vmlfb_pci_driver = {
1046         .name = "vmlfb",
1047         .id_table = vml_ids,
1048         .probe = vml_pci_probe,
1049         .remove = vml_pci_remove,
1050 };
1051
1052 static void __exit vmlfb_cleanup(void)
1053 {
1054         pci_unregister_driver(&vmlfb_pci_driver);
1055 }
1056
1057 static int __init vmlfb_init(void)
1058 {
1059
1060 #ifndef MODULE
1061         char *option = NULL;
1062 #endif
1063
1064         if (fb_modesetting_disabled("vmlfb"))
1065                 return -ENODEV;
1066
1067 #ifndef MODULE
1068         if (fb_get_options(MODULE_NAME, &option))
1069                 return -ENODEV;
1070 #endif
1071
1072         printk(KERN_DEBUG MODULE_NAME ": initializing\n");
1073         mutex_init(&vml_mutex);
1074         INIT_LIST_HEAD(&global_no_mode);
1075         INIT_LIST_HEAD(&global_has_mode);
1076
1077         return pci_register_driver(&vmlfb_pci_driver);
1078 }
1079
1080 int vmlfb_register_subsys(struct vml_sys *sys)
1081 {
1082         struct vml_info *entry;
1083         struct list_head *list;
1084         u32 save_activate;
1085
1086         mutex_lock(&vml_mutex);
1087         if (subsys != NULL) {
1088                 subsys->restore(subsys);
1089         }
1090         subsys = sys;
1091         subsys->save(subsys);
1092
1093         /*
1094          * We need to restart list traversal for each item, since we
1095          * release the list mutex in the loop.
1096          */
1097
1098         list = global_no_mode.next;
1099         while (list != &global_no_mode) {
1100                 list_del_init(list);
1101                 entry = list_entry(list, struct vml_info, head);
1102
1103                 /*
1104                  * First, try the current mode which might not be
1105                  * completely validated with respect to the pixel clock.
1106                  */
1107
1108                 if (!vmlfb_check_var_locked(&entry->info.var, entry)) {
1109                         vmlfb_set_par_locked(entry);
1110                         list_add_tail(list, &global_has_mode);
1111                 } else {
1112
1113                         /*
1114                          * Didn't work. Try to find another mode,
1115                          * that matches this subsys.
1116                          */
1117
1118                         mutex_unlock(&vml_mutex);
1119                         save_activate = entry->info.var.activate;
1120                         entry->info.var.bits_per_pixel = 16;
1121                         vmlfb_set_pref_pixel_format(&entry->info.var);
1122                         if (fb_find_mode(&entry->info.var,
1123                                          &entry->info,
1124                                          vml_default_mode, NULL, 0, NULL, 16)) {
1125                                 entry->info.var.activate |=
1126                                     FB_ACTIVATE_FORCE | FB_ACTIVATE_NOW;
1127                                 fb_set_var(&entry->info, &entry->info.var);
1128                         } else {
1129                                 printk(KERN_ERR MODULE_NAME
1130                                        ": Sorry. no mode found for this subsys.\n");
1131                         }
1132                         entry->info.var.activate = save_activate;
1133                         mutex_lock(&vml_mutex);
1134                 }
1135                 vmlfb_blank_locked(entry);
1136                 list = global_no_mode.next;
1137         }
1138         mutex_unlock(&vml_mutex);
1139
1140         printk(KERN_DEBUG MODULE_NAME ": Registered %s subsystem.\n",
1141                                 subsys->name ? subsys->name : "unknown");
1142         return 0;
1143 }
1144
1145 EXPORT_SYMBOL_GPL(vmlfb_register_subsys);
1146
1147 void vmlfb_unregister_subsys(struct vml_sys *sys)
1148 {
1149         struct vml_info *entry, *next;
1150
1151         mutex_lock(&vml_mutex);
1152         if (subsys != sys) {
1153                 mutex_unlock(&vml_mutex);
1154                 return;
1155         }
1156         subsys->restore(subsys);
1157         subsys = NULL;
1158         list_for_each_entry_safe(entry, next, &global_has_mode, head) {
1159                 printk(KERN_DEBUG MODULE_NAME ": subsys disable pipe\n");
1160                 vmlfb_disable_pipe(entry);
1161                 list_move_tail(&entry->head, &global_no_mode);
1162         }
1163         mutex_unlock(&vml_mutex);
1164 }
1165
1166 EXPORT_SYMBOL_GPL(vmlfb_unregister_subsys);
1167
1168 module_init(vmlfb_init);
1169 module_exit(vmlfb_cleanup);
1170
1171 MODULE_AUTHOR("Tungsten Graphics");
1172 MODULE_DESCRIPTION("Initialization of the Vermilion display devices");
1173 MODULE_VERSION("1.0.0");
1174 MODULE_LICENSE("GPL");