1 // SPDX-License-Identifier: GPL-2.0-only 2 3 #include <linux/pci.h> 4 #include <linux/vmalloc.h> 5 6 #include <drm/drm_atomic.h> 7 #include <drm/drm_atomic_helper.h> 8 #include <drm/drm_drv.h> 9 #include <drm/drm_gem_atomic_helper.h> 10 #include <drm/drm_probe_helper.h> 11 12 #include "mgag200_ddc.h" 13 #include "mgag200_drv.h" 14 15 static int mgag200_g200_init_pci_options(struct pci_dev *pdev) 16 { 17 struct device *dev = &pdev->dev; 18 bool has_sgram; 19 u32 option; 20 int err; 21 22 err = pci_read_config_dword(pdev, PCI_MGA_OPTION, &option); 23 if (err != PCIBIOS_SUCCESSFUL) { 24 dev_err(dev, "pci_read_config_dword(PCI_MGA_OPTION) failed: %d\n", err); 25 return pcibios_err_to_errno(err); 26 } 27 28 has_sgram = !!(option & PCI_MGA_OPTION_HARDPWMSK); 29 30 if (has_sgram) 31 option = 0x4049cd21; 32 else 33 option = 0x40499121; 34 35 return mgag200_init_pci_options(pdev, option, 0x00008000); 36 } 37 38 static void mgag200_g200_init_registers(struct mgag200_g200_device *g200) 39 { 40 static const u8 dacvalue[] = { 41 MGAG200_DAC_DEFAULT(0x00, 0xc9, 0x1f, 42 0x04, 0x2d, 0x19) 43 }; 44 45 struct mga_device *mdev = &g200->base; 46 size_t i; 47 48 for (i = 0; i < ARRAY_SIZE(dacvalue); ++i) { 49 if ((i <= 0x17) || 50 (i == 0x1b) || 51 (i == 0x1c) || 52 ((i >= 0x1f) && (i <= 0x29)) || 53 ((i >= 0x30) && (i <= 0x37))) 54 continue; 55 WREG_DAC(i, dacvalue[i]); 56 } 57 58 mgag200_init_registers(mdev); 59 } 60 61 /* 62 * PIXPLLC 63 */ 64 65 static int mgag200_g200_pixpllc_atomic_check(struct drm_crtc *crtc, struct drm_atomic_state *new_state) 66 { 67 static const int post_div_max = 7; 68 static const int in_div_min = 1; 69 static const int in_div_max = 6; 70 static const int feed_div_min = 7; 71 static const int feed_div_max = 127; 72 73 struct drm_device *dev = crtc->dev; 74 struct mgag200_g200_device *g200 = to_mgag200_g200_device(dev); 75 struct drm_crtc_state *new_crtc_state = drm_atomic_get_new_crtc_state(new_state, crtc); 76 struct mgag200_crtc_state *new_mgag200_crtc_state = to_mgag200_crtc_state(new_crtc_state); 77 long clock = new_crtc_state->mode.clock; 78 struct mgag200_pll_values *pixpllc = &new_mgag200_crtc_state->pixpllc; 79 u8 testp, testm, testn; 80 u8 n = 0, m = 0, p, s; 81 long f_vco; 82 long computed; 83 long delta, tmp_delta; 84 long ref_clk = g200->ref_clk; 85 long p_clk_min = g200->pclk_min; 86 long p_clk_max = g200->pclk_max; 87 88 if (clock > p_clk_max) { 89 drm_err(dev, "Pixel Clock %ld too high\n", clock); 90 return -EINVAL; 91 } 92 93 if (clock < p_clk_min >> 3) 94 clock = p_clk_min >> 3; 95 96 f_vco = clock; 97 for (testp = 0; 98 testp <= post_div_max && f_vco < p_clk_min; 99 testp = (testp << 1) + 1, f_vco <<= 1) 100 ; 101 p = testp + 1; 102 103 delta = clock; 104 105 for (testm = in_div_min; testm <= in_div_max; testm++) { 106 for (testn = feed_div_min; testn <= feed_div_max; testn++) { 107 computed = ref_clk * (testn + 1) / (testm + 1); 108 if (computed < f_vco) 109 tmp_delta = f_vco - computed; 110 else 111 tmp_delta = computed - f_vco; 112 if (tmp_delta < delta) { 113 delta = tmp_delta; 114 m = testm + 1; 115 n = testn + 1; 116 } 117 } 118 } 119 f_vco = ref_clk * n / m; 120 if (f_vco < 100000) 121 s = 0; 122 else if (f_vco < 140000) 123 s = 1; 124 else if (f_vco < 180000) 125 s = 2; 126 else 127 s = 3; 128 129 drm_dbg_kms(dev, "clock: %ld vco: %ld m: %d n: %d p: %d s: %d\n", 130 clock, f_vco, m, n, p, s); 131 132 pixpllc->m = m; 133 pixpllc->n = n; 134 pixpllc->p = p; 135 pixpllc->s = s; 136 137 return 0; 138 } 139 140 static void mgag200_g200_pixpllc_atomic_update(struct drm_crtc *crtc, 141 struct drm_atomic_state *old_state) 142 { 143 struct drm_device *dev = crtc->dev; 144 struct mga_device *mdev = to_mga_device(dev); 145 struct drm_crtc_state *crtc_state = crtc->state; 146 struct mgag200_crtc_state *mgag200_crtc_state = to_mgag200_crtc_state(crtc_state); 147 struct mgag200_pll_values *pixpllc = &mgag200_crtc_state->pixpllc; 148 unsigned int pixpllcm, pixpllcn, pixpllcp, pixpllcs; 149 u8 xpixpllcm, xpixpllcn, xpixpllcp; 150 151 pixpllcm = pixpllc->m - 1; 152 pixpllcn = pixpllc->n - 1; 153 pixpllcp = pixpllc->p - 1; 154 pixpllcs = pixpllc->s; 155 156 xpixpllcm = pixpllcm; 157 xpixpllcn = pixpllcn; 158 xpixpllcp = (pixpllcs << 3) | pixpllcp; 159 160 WREG_MISC_MASKED(MGAREG_MISC_CLKSEL_MGA, MGAREG_MISC_CLKSEL_MASK); 161 162 WREG_DAC(MGA1064_PIX_PLLC_M, xpixpllcm); 163 WREG_DAC(MGA1064_PIX_PLLC_N, xpixpllcn); 164 WREG_DAC(MGA1064_PIX_PLLC_P, xpixpllcp); 165 } 166 167 /* 168 * Mode-setting pipeline 169 */ 170 171 static const struct drm_plane_helper_funcs mgag200_g200_primary_plane_helper_funcs = { 172 MGAG200_PRIMARY_PLANE_HELPER_FUNCS, 173 }; 174 175 static const struct drm_plane_funcs mgag200_g200_primary_plane_funcs = { 176 MGAG200_PRIMARY_PLANE_FUNCS, 177 }; 178 179 static const struct drm_crtc_helper_funcs mgag200_g200_crtc_helper_funcs = { 180 MGAG200_CRTC_HELPER_FUNCS, 181 }; 182 183 static const struct drm_crtc_funcs mgag200_g200_crtc_funcs = { 184 MGAG200_CRTC_FUNCS, 185 }; 186 187 static const struct drm_encoder_funcs mgag200_g200_dac_encoder_funcs = { 188 MGAG200_DAC_ENCODER_FUNCS, 189 }; 190 191 static const struct drm_connector_helper_funcs mgag200_g200_vga_connector_helper_funcs = { 192 MGAG200_VGA_CONNECTOR_HELPER_FUNCS, 193 }; 194 195 static const struct drm_connector_funcs mgag200_g200_vga_connector_funcs = { 196 MGAG200_VGA_CONNECTOR_FUNCS, 197 }; 198 199 static int mgag200_g200_pipeline_init(struct mga_device *mdev) 200 { 201 struct drm_device *dev = &mdev->base; 202 struct drm_plane *primary_plane = &mdev->primary_plane; 203 struct drm_crtc *crtc = &mdev->crtc; 204 struct drm_encoder *encoder = &mdev->encoder; 205 struct drm_connector *connector = &mdev->connector; 206 struct i2c_adapter *ddc; 207 int ret; 208 209 ret = drm_universal_plane_init(dev, primary_plane, 0, 210 &mgag200_g200_primary_plane_funcs, 211 mgag200_primary_plane_formats, 212 mgag200_primary_plane_formats_size, 213 mgag200_primary_plane_fmtmods, 214 DRM_PLANE_TYPE_PRIMARY, NULL); 215 if (ret) { 216 drm_err(dev, "drm_universal_plane_init() failed: %d\n", ret); 217 return ret; 218 } 219 drm_plane_helper_add(primary_plane, &mgag200_g200_primary_plane_helper_funcs); 220 drm_plane_enable_fb_damage_clips(primary_plane); 221 222 ret = drm_crtc_init_with_planes(dev, crtc, primary_plane, NULL, 223 &mgag200_g200_crtc_funcs, NULL); 224 if (ret) { 225 drm_err(dev, "drm_crtc_init_with_planes() failed: %d\n", ret); 226 return ret; 227 } 228 drm_crtc_helper_add(crtc, &mgag200_g200_crtc_helper_funcs); 229 230 /* FIXME: legacy gamma tables, but atomic gamma doesn't work without */ 231 drm_mode_crtc_set_gamma_size(crtc, MGAG200_LUT_SIZE); 232 drm_crtc_enable_color_mgmt(crtc, 0, false, MGAG200_LUT_SIZE); 233 234 encoder->possible_crtcs = drm_crtc_mask(crtc); 235 ret = drm_encoder_init(dev, encoder, &mgag200_g200_dac_encoder_funcs, 236 DRM_MODE_ENCODER_DAC, NULL); 237 if (ret) { 238 drm_err(dev, "drm_encoder_init() failed: %d\n", ret); 239 return ret; 240 } 241 242 ddc = mgag200_ddc_create(mdev); 243 if (IS_ERR(ddc)) { 244 ret = PTR_ERR(ddc); 245 drm_err(dev, "failed to add DDC bus: %d\n", ret); 246 return ret; 247 } 248 249 ret = drm_connector_init_with_ddc(dev, connector, 250 &mgag200_g200_vga_connector_funcs, 251 DRM_MODE_CONNECTOR_VGA, ddc); 252 if (ret) { 253 drm_err(dev, "drm_connector_init_with_ddc() failed: %d\n", ret); 254 return ret; 255 } 256 drm_connector_helper_add(connector, &mgag200_g200_vga_connector_helper_funcs); 257 258 ret = drm_connector_attach_encoder(connector, encoder); 259 if (ret) { 260 drm_err(dev, "drm_connector_attach_encoder() failed: %d\n", ret); 261 return ret; 262 } 263 264 return 0; 265 } 266 267 /* 268 * DRM Device 269 */ 270 271 static const struct mgag200_device_info mgag200_g200_device_info = 272 MGAG200_DEVICE_INFO_INIT(2048, 2048, 0, false, 1, 3, false); 273 274 static void mgag200_g200_interpret_bios(struct mgag200_g200_device *g200, 275 const unsigned char *bios, size_t size) 276 { 277 static const char matrox[] = {'M', 'A', 'T', 'R', 'O', 'X'}; 278 static const unsigned int expected_length[6] = { 279 0, 64, 64, 64, 128, 128 280 }; 281 struct mga_device *mdev = &g200->base; 282 struct drm_device *dev = &mdev->base; 283 const unsigned char *pins; 284 unsigned int pins_len, version; 285 int offset; 286 int tmp; 287 288 /* Test for MATROX string. */ 289 if (size < 45 + sizeof(matrox)) 290 return; 291 if (memcmp(&bios[45], matrox, sizeof(matrox)) != 0) 292 return; 293 294 /* Get the PInS offset. */ 295 if (size < MGA_BIOS_OFFSET + 2) 296 return; 297 offset = (bios[MGA_BIOS_OFFSET + 1] << 8) | bios[MGA_BIOS_OFFSET]; 298 299 /* Get PInS data structure. */ 300 301 if (size < offset + 6) 302 return; 303 pins = bios + offset; 304 if (pins[0] == 0x2e && pins[1] == 0x41) { 305 version = pins[5]; 306 pins_len = pins[2]; 307 } else { 308 version = 1; 309 pins_len = pins[0] + (pins[1] << 8); 310 } 311 312 if (version < 1 || version > 5) { 313 drm_warn(dev, "Unknown BIOS PInS version: %d\n", version); 314 return; 315 } 316 if (pins_len != expected_length[version]) { 317 drm_warn(dev, "Unexpected BIOS PInS size: %d expected: %d\n", 318 pins_len, expected_length[version]); 319 return; 320 } 321 if (size < offset + pins_len) 322 return; 323 324 drm_dbg_kms(dev, "MATROX BIOS PInS version %d size: %d found\n", version, pins_len); 325 326 /* Extract the clock values */ 327 328 switch (version) { 329 case 1: 330 tmp = pins[24] + (pins[25] << 8); 331 if (tmp) 332 g200->pclk_max = tmp * 10; 333 break; 334 case 2: 335 if (pins[41] != 0xff) 336 g200->pclk_max = (pins[41] + 100) * 1000; 337 break; 338 case 3: 339 if (pins[36] != 0xff) 340 g200->pclk_max = (pins[36] + 100) * 1000; 341 if (pins[52] & 0x20) 342 g200->ref_clk = 14318; 343 break; 344 case 4: 345 if (pins[39] != 0xff) 346 g200->pclk_max = pins[39] * 4 * 1000; 347 if (pins[92] & 0x01) 348 g200->ref_clk = 14318; 349 break; 350 case 5: 351 tmp = pins[4] ? 8000 : 6000; 352 if (pins[123] != 0xff) 353 g200->pclk_min = pins[123] * tmp; 354 if (pins[38] != 0xff) 355 g200->pclk_max = pins[38] * tmp; 356 if (pins[110] & 0x01) 357 g200->ref_clk = 14318; 358 break; 359 default: 360 break; 361 } 362 } 363 364 static void mgag200_g200_init_refclk(struct mgag200_g200_device *g200) 365 { 366 struct mga_device *mdev = &g200->base; 367 struct drm_device *dev = &mdev->base; 368 struct pci_dev *pdev = to_pci_dev(dev->dev); 369 unsigned char __iomem *rom; 370 unsigned char *bios; 371 size_t size; 372 373 g200->pclk_min = 50000; 374 g200->pclk_max = 230000; 375 g200->ref_clk = 27050; 376 377 rom = pci_map_rom(pdev, &size); 378 if (!rom) 379 return; 380 381 bios = vmalloc(size); 382 if (!bios) 383 goto out; 384 memcpy_fromio(bios, rom, size); 385 386 if (size != 0 && bios[0] == 0x55 && bios[1] == 0xaa) 387 mgag200_g200_interpret_bios(g200, bios, size); 388 389 drm_dbg_kms(dev, "pclk_min: %ld pclk_max: %ld ref_clk: %ld\n", 390 g200->pclk_min, g200->pclk_max, g200->ref_clk); 391 392 vfree(bios); 393 out: 394 pci_unmap_rom(pdev, rom); 395 } 396 397 static const struct mgag200_device_funcs mgag200_g200_device_funcs = { 398 .pixpllc_atomic_check = mgag200_g200_pixpllc_atomic_check, 399 .pixpllc_atomic_update = mgag200_g200_pixpllc_atomic_update, 400 }; 401 402 struct mga_device *mgag200_g200_device_create(struct pci_dev *pdev, const struct drm_driver *drv) 403 { 404 struct mgag200_g200_device *g200; 405 struct mga_device *mdev; 406 struct drm_device *dev; 407 resource_size_t vram_available; 408 int ret; 409 410 g200 = devm_drm_dev_alloc(&pdev->dev, drv, struct mgag200_g200_device, base.base); 411 if (IS_ERR(g200)) 412 return ERR_CAST(g200); 413 mdev = &g200->base; 414 dev = &mdev->base; 415 416 pci_set_drvdata(pdev, dev); 417 418 ret = mgag200_g200_init_pci_options(pdev); 419 if (ret) 420 return ERR_PTR(ret); 421 422 ret = mgag200_device_preinit(mdev); 423 if (ret) 424 return ERR_PTR(ret); 425 426 mgag200_g200_init_refclk(g200); 427 428 ret = mgag200_device_init(mdev, &mgag200_g200_device_info, 429 &mgag200_g200_device_funcs); 430 if (ret) 431 return ERR_PTR(ret); 432 433 mgag200_g200_init_registers(g200); 434 435 vram_available = mgag200_device_probe_vram(mdev); 436 437 ret = mgag200_mode_config_init(mdev, vram_available); 438 if (ret) 439 return ERR_PTR(ret); 440 441 ret = mgag200_g200_pipeline_init(mdev); 442 if (ret) 443 return ERR_PTR(ret); 444 445 drm_mode_config_reset(dev); 446 447 return mdev; 448 } 449