mirrors
/
linux-stable
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
1
0
Fork 0
Code Issues Releases Wiki Activity

drm/nouveau: initial pass at moving to struct nvif_device 

This is an attempt at isolating some of the changes necessary to port
to NVIF in a separate commit.

Signed-off-by: Ben Skeggs <bskeggs@redhat.com>
This commit is contained in:
Ben Skeggs 2014-08-10 04:10:22 +10:00
parent db2bec187d
commit 967e7bde87
41 changed files with 459 additions and 388 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
drivers/gpu/drm/nouveau/dispnv04/arb.c
View File

@ -198,7 +198,7 @@ nv04_update_arb(struct drm_device *dev, int VClk, int bpp,
int *burst, int *lwm) int *burst, int *lwm)
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
struct nv_fifo_info fifo_data; struct nv_fifo_info fifo_data;
struct nv_sim_state sim_data; struct nv_sim_state sim_data;
int MClk = nouveau_hw_get_clock(dev, PLL_MEMORY); int MClk = nouveau_hw_get_clock(dev, PLL_MEMORY);
@ -227,7 +227,7 @@ nv04_update_arb(struct drm_device *dev, int VClk, int bpp,
sim_data.mem_page_miss = ((cfg1 >> 4) & 0xf) + ((cfg1 >> 31) & 0x1); sim_data.mem_page_miss = ((cfg1 >> 4) & 0xf) + ((cfg1 >> 31) & 0x1);
} }
if (nv_device(drm->device)->card_type == NV_04) if (drm->device.info.family == NV_DEVICE_INFO_V0_TNT)
nv04_calc_arb(&fifo_data, &sim_data); nv04_calc_arb(&fifo_data, &sim_data);
else else
nv10_calc_arb(&fifo_data, &sim_data); nv10_calc_arb(&fifo_data, &sim_data);
@ -254,7 +254,7 @@ nouveau_calc_arb(struct drm_device *dev, int vclk, int bpp, int *burst, int *lwm
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
if (nv_device(drm->device)->card_type < NV_20) if (drm->device.info.family < NV_DEVICE_INFO_V0_KELVIN)
nv04_update_arb(dev, vclk, bpp, burst, lwm); nv04_update_arb(dev, vclk, bpp, burst, lwm);
else if ((dev->pdev->device & 0xfff0) == 0x0240 /*CHIPSET_C51*/ || else if ((dev->pdev->device & 0xfff0) == 0x0240 /*CHIPSET_C51*/ ||
(dev->pdev->device & 0xfff0) == 0x03d0 /*CHIPSET_C512*/) { (dev->pdev->device & 0xfff0) == 0x03d0 /*CHIPSET_C512*/) {

38
drivers/gpu/drm/nouveau/dispnv04/crtc.c
View File

@ -111,8 +111,8 @@ static void nv_crtc_calc_state_ext(struct drm_crtc *crtc, struct drm_display_mod
{ {
struct drm_device *dev = crtc->dev; struct drm_device *dev = crtc->dev;
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_bios *bios = nouveau_bios(drm->device); struct nouveau_bios *bios = nvkm_bios(&drm->device);
struct nouveau_clock *clk = nouveau_clock(drm->device); struct nouveau_clock *clk = nvkm_clock(&drm->device);
struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc); struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
struct nv04_mode_state *state = &nv04_display(dev)->mode_reg; struct nv04_mode_state *state = &nv04_display(dev)->mode_reg;
struct nv04_crtc_reg *regp = &state->crtc_reg[nv_crtc->index]; struct nv04_crtc_reg *regp = &state->crtc_reg[nv_crtc->index];
@ -136,7 +136,7 @@ static void nv_crtc_calc_state_ext(struct drm_crtc *crtc, struct drm_display_mod
* has yet been observed in allowing the use a single stage pll on all * has yet been observed in allowing the use a single stage pll on all
* nv43 however. the behaviour of single stage use is untested on nv40 * nv43 however. the behaviour of single stage use is untested on nv40
*/ */
if (nv_device(drm->device)->chipset > 0x40 && dot_clock <= (pll_lim.vco1.max_freq / 2)) if (drm->device.info.chipset > 0x40 && dot_clock <= (pll_lim.vco1.max_freq / 2))
memset(&pll_lim.vco2, 0, sizeof(pll_lim.vco2)); memset(&pll_lim.vco2, 0, sizeof(pll_lim.vco2));
@ -146,10 +146,10 @@ static void nv_crtc_calc_state_ext(struct drm_crtc *crtc, struct drm_display_mod
state->pllsel &= PLLSEL_VPLL1_MASK | PLLSEL_VPLL2_MASK | PLLSEL_TV_MASK; state->pllsel &= PLLSEL_VPLL1_MASK | PLLSEL_VPLL2_MASK | PLLSEL_TV_MASK;
/* The blob uses this always, so let's do the same */ /* The blob uses this always, so let's do the same */
if (nv_device(drm->device)->card_type == NV_40) if (drm->device.info.family == NV_DEVICE_INFO_V0_CURIE)
state->pllsel |= NV_PRAMDAC_PLL_COEFF_SELECT_USE_VPLL2_TRUE; state->pllsel |= NV_PRAMDAC_PLL_COEFF_SELECT_USE_VPLL2_TRUE;
/* again nv40 and some nv43 act more like nv3x as described above */ /* again nv40 and some nv43 act more like nv3x as described above */
if (nv_device(drm->device)->chipset < 0x41) if (drm->device.info.chipset < 0x41)
state->pllsel |= NV_PRAMDAC_PLL_COEFF_SELECT_SOURCE_PROG_MPLL | state->pllsel |= NV_PRAMDAC_PLL_COEFF_SELECT_SOURCE_PROG_MPLL |
NV_PRAMDAC_PLL_COEFF_SELECT_SOURCE_PROG_NVPLL; NV_PRAMDAC_PLL_COEFF_SELECT_SOURCE_PROG_NVPLL;
state->pllsel |= nv_crtc->index ? PLLSEL_VPLL2_MASK : PLLSEL_VPLL1_MASK; state->pllsel |= nv_crtc->index ? PLLSEL_VPLL2_MASK : PLLSEL_VPLL1_MASK;
@ -275,7 +275,7 @@ nv_crtc_mode_set_vga(struct drm_crtc *crtc, struct drm_display_mode *mode)
horizEnd = horizTotal - 2; horizEnd = horizTotal - 2;
horizBlankEnd = horizTotal + 4; horizBlankEnd = horizTotal + 4;
#if 0 #if 0
if (dev->overlayAdaptor && nv_device(drm->device)->card_type >= NV_10) if (dev->overlayAdaptor && drm->device.info.family >= NV_DEVICE_INFO_V0_CELSIUS)
/* This reportedly works around some video overlay bandwidth problems */ /* This reportedly works around some video overlay bandwidth problems */
horizTotal += 2; horizTotal += 2;
#endif #endif
@ -509,7 +509,7 @@ nv_crtc_mode_set_regs(struct drm_crtc *crtc, struct drm_display_mode * mode)
regp->cursor_cfg = NV_PCRTC_CURSOR_CONFIG_CUR_LINES_64 | regp->cursor_cfg = NV_PCRTC_CURSOR_CONFIG_CUR_LINES_64 |
NV_PCRTC_CURSOR_CONFIG_CUR_PIXELS_64 | NV_PCRTC_CURSOR_CONFIG_CUR_PIXELS_64 |
NV_PCRTC_CURSOR_CONFIG_ADDRESS_SPACE_PNVM; NV_PCRTC_CURSOR_CONFIG_ADDRESS_SPACE_PNVM;
if (nv_device(drm->device)->chipset >= 0x11) if (drm->device.info.chipset >= 0x11)
regp->cursor_cfg |= NV_PCRTC_CURSOR_CONFIG_CUR_BPP_32; regp->cursor_cfg |= NV_PCRTC_CURSOR_CONFIG_CUR_BPP_32;
if (mode->flags & DRM_MODE_FLAG_DBLSCAN) if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
regp->cursor_cfg |= NV_PCRTC_CURSOR_CONFIG_DOUBLE_SCAN_ENABLE; regp->cursor_cfg |= NV_PCRTC_CURSOR_CONFIG_DOUBLE_SCAN_ENABLE;
@ -550,26 +550,26 @@ nv_crtc_mode_set_regs(struct drm_crtc *crtc, struct drm_display_mode * mode)
* 1 << 30 on 0x60.830), for no apparent reason */ * 1 << 30 on 0x60.830), for no apparent reason */
regp->CRTC[NV_CIO_CRE_59] = off_chip_digital; regp->CRTC[NV_CIO_CRE_59] = off_chip_digital;
if (nv_device(drm->device)->card_type >= NV_30) if (drm->device.info.family >= NV_DEVICE_INFO_V0_RANKINE)
regp->CRTC[0x9f] = off_chip_digital ? 0x11 : 0x1; regp->CRTC[0x9f] = off_chip_digital ? 0x11 : 0x1;
regp->crtc_830 = mode->crtc_vdisplay - 3; regp->crtc_830 = mode->crtc_vdisplay - 3;
regp->crtc_834 = mode->crtc_vdisplay - 1; regp->crtc_834 = mode->crtc_vdisplay - 1;
if (nv_device(drm->device)->card_type == NV_40) if (drm->device.info.family == NV_DEVICE_INFO_V0_CURIE)
/* This is what the blob does */ /* This is what the blob does */
regp->crtc_850 = NVReadCRTC(dev, 0, NV_PCRTC_850); regp->crtc_850 = NVReadCRTC(dev, 0, NV_PCRTC_850);
if (nv_device(drm->device)->card_type >= NV_30) if (drm->device.info.family >= NV_DEVICE_INFO_V0_RANKINE)
regp->gpio_ext = NVReadCRTC(dev, 0, NV_PCRTC_GPIO_EXT); regp->gpio_ext = NVReadCRTC(dev, 0, NV_PCRTC_GPIO_EXT);
if (nv_device(drm->device)->card_type >= NV_10) if (drm->device.info.family >= NV_DEVICE_INFO_V0_CELSIUS)
regp->crtc_cfg = NV10_PCRTC_CONFIG_START_ADDRESS_HSYNC; regp->crtc_cfg = NV10_PCRTC_CONFIG_START_ADDRESS_HSYNC;
else else
regp->crtc_cfg = NV04_PCRTC_CONFIG_START_ADDRESS_HSYNC; regp->crtc_cfg = NV04_PCRTC_CONFIG_START_ADDRESS_HSYNC;
/* Some misc regs */ /* Some misc regs */
if (nv_device(drm->device)->card_type == NV_40) { if (drm->device.info.family == NV_DEVICE_INFO_V0_CURIE) {
regp->CRTC[NV_CIO_CRE_85] = 0xFF; regp->CRTC[NV_CIO_CRE_85] = 0xFF;
regp->CRTC[NV_CIO_CRE_86] = 0x1; regp->CRTC[NV_CIO_CRE_86] = 0x1;
} }
@ -581,7 +581,7 @@ nv_crtc_mode_set_regs(struct drm_crtc *crtc, struct drm_display_mode * mode)
/* Generic PRAMDAC regs */ /* Generic PRAMDAC regs */
if (nv_device(drm->device)->card_type >= NV_10) if (drm->device.info.family >= NV_DEVICE_INFO_V0_CELSIUS)
/* Only bit that bios and blob set. */ /* Only bit that bios and blob set. */
regp->nv10_cursync = (1 << 25); regp->nv10_cursync = (1 << 25);
@ -590,7 +590,7 @@ nv_crtc_mode_set_regs(struct drm_crtc *crtc, struct drm_display_mode * mode)
NV_PRAMDAC_GENERAL_CONTROL_PIXMIX_ON; NV_PRAMDAC_GENERAL_CONTROL_PIXMIX_ON;
if (crtc->primary->fb->depth == 16) if (crtc->primary->fb->depth == 16)
regp->ramdac_gen_ctrl |= NV_PRAMDAC_GENERAL_CONTROL_ALT_MODE_SEL; regp->ramdac_gen_ctrl |= NV_PRAMDAC_GENERAL_CONTROL_ALT_MODE_SEL;
if (nv_device(drm->device)->chipset >= 0x11) if (drm->device.info.chipset >= 0x11)
regp->ramdac_gen_ctrl |= NV_PRAMDAC_GENERAL_CONTROL_PIPE_LONG; regp->ramdac_gen_ctrl |= NV_PRAMDAC_GENERAL_CONTROL_PIPE_LONG;
regp->ramdac_630 = 0; /* turn off green mode (tv test pattern?) */ regp->ramdac_630 = 0; /* turn off green mode (tv test pattern?) */
@ -653,7 +653,7 @@ nv_crtc_mode_set(struct drm_crtc *crtc, struct drm_display_mode *mode,
nv_crtc_mode_set_vga(crtc, adjusted_mode); nv_crtc_mode_set_vga(crtc, adjusted_mode);
/* calculated in nv04_dfp_prepare, nv40 needs it written before calculating PLLs */ /* calculated in nv04_dfp_prepare, nv40 needs it written before calculating PLLs */
if (nv_device(drm->device)->card_type == NV_40) if (drm->device.info.family == NV_DEVICE_INFO_V0_CURIE)
NVWriteRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK, nv04_display(dev)->mode_reg.sel_clk); NVWriteRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK, nv04_display(dev)->mode_reg.sel_clk);
nv_crtc_mode_set_regs(crtc, adjusted_mode); nv_crtc_mode_set_regs(crtc, adjusted_mode);
nv_crtc_calc_state_ext(crtc, mode, adjusted_mode->clock); nv_crtc_calc_state_ext(crtc, mode, adjusted_mode->clock);
@ -714,7 +714,7 @@ static void nv_crtc_prepare(struct drm_crtc *crtc)
/* Some more preparation. */ /* Some more preparation. */
NVWriteCRTC(dev, nv_crtc->index, NV_PCRTC_CONFIG, NV_PCRTC_CONFIG_START_ADDRESS_NON_VGA); NVWriteCRTC(dev, nv_crtc->index, NV_PCRTC_CONFIG, NV_PCRTC_CONFIG_START_ADDRESS_NON_VGA);
if (nv_device(drm->device)->card_type == NV_40) { if (drm->device.info.family == NV_DEVICE_INFO_V0_CURIE) {
uint32_t reg900 = NVReadRAMDAC(dev, nv_crtc->index, NV_PRAMDAC_900); uint32_t reg900 = NVReadRAMDAC(dev, nv_crtc->index, NV_PRAMDAC_900);
NVWriteRAMDAC(dev, nv_crtc->index, NV_PRAMDAC_900, reg900 & ~0x10000); NVWriteRAMDAC(dev, nv_crtc->index, NV_PRAMDAC_900, reg900 & ~0x10000);
} }
@ -888,7 +888,7 @@ nv04_crtc_do_mode_set_base(struct drm_crtc *crtc,
crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_FF_INDEX); crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_FF_INDEX);
crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_FFLWM__INDEX); crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_FFLWM__INDEX);
if (nv_device(drm->device)->card_type >= NV_20) { if (drm->device.info.family >= NV_DEVICE_INFO_V0_KELVIN) {
regp->CRTC[NV_CIO_CRE_47] = arb_lwm >> 8; regp->CRTC[NV_CIO_CRE_47] = arb_lwm >> 8;
crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_47); crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_47);
} }
@ -969,7 +969,7 @@ static void nv11_cursor_upload(struct drm_device *dev, struct nouveau_bo *src,
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
if (nv_device(drm->device)->chipset == 0x11) { if (drm->device.info.chipset == 0x11) {
pixel = ((pixel & 0x000000ff) << 24) | pixel = ((pixel & 0x000000ff) << 24) |
((pixel & 0x0000ff00) << 8) | ((pixel & 0x0000ff00) << 8) |
((pixel & 0x00ff0000) >> 8) | ((pixel & 0x00ff0000) >> 8) |
@ -1010,7 +1010,7 @@ nv04_crtc_cursor_set(struct drm_crtc *crtc, struct drm_file *file_priv,
if (ret) if (ret)
goto out; goto out;
if (nv_device(drm->device)->chipset >= 0x11) if (drm->device.info.chipset >= 0x11)
nv11_cursor_upload(dev, cursor, nv_crtc->cursor.nvbo); nv11_cursor_upload(dev, cursor, nv_crtc->cursor.nvbo);
else else
nv04_cursor_upload(dev, cursor, nv_crtc->cursor.nvbo); nv04_cursor_upload(dev, cursor, nv_crtc->cursor.nvbo);

2
drivers/gpu/drm/nouveau/dispnv04/cursor.c
View File

@ -55,7 +55,7 @@ nv04_cursor_set_offset(struct nouveau_crtc *nv_crtc, uint32_t offset)
crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_HCUR_ADDR0_INDEX); crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_HCUR_ADDR0_INDEX);
crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_HCUR_ADDR1_INDEX); crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_HCUR_ADDR1_INDEX);
crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_HCUR_ADDR2_INDEX); crtc_wr_cio_state(crtc, regp, NV_CIO_CRE_HCUR_ADDR2_INDEX);
if (nv_device(drm->device)->card_type == NV_40) if (drm->device.info.family == NV_DEVICE_INFO_V0_CURIE)
nv_fix_nv40_hw_cursor(dev, nv_crtc->index); nv_fix_nv40_hw_cursor(dev, nv_crtc->index);
} }

14
drivers/gpu/drm/nouveau/dispnv04/dac.c
View File

@ -65,8 +65,8 @@ int nv04_dac_output_offset(struct drm_encoder *encoder)
static int sample_load_twice(struct drm_device *dev, bool sense[2]) static int sample_load_twice(struct drm_device *dev, bool sense[2])
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
struct nouveau_timer *ptimer = nouveau_timer(device); struct nouveau_timer *ptimer = nvkm_timer(device);
int i; int i;
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
@ -128,7 +128,7 @@ static enum drm_connector_status nv04_dac_detect(struct drm_encoder *encoder,
struct drm_connector *connector) struct drm_connector *connector)
{ {
struct drm_device *dev = encoder->dev; struct drm_device *dev = encoder->dev;
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
uint8_t saved_seq1, saved_pi, saved_rpc1, saved_cr_mode; uint8_t saved_seq1, saved_pi, saved_rpc1, saved_cr_mode;
uint8_t saved_palette0[3], saved_palette_mask; uint8_t saved_palette0[3], saved_palette_mask;
@ -231,8 +231,8 @@ uint32_t nv17_dac_sample_load(struct drm_encoder *encoder)
{ {
struct drm_device *dev = encoder->dev; struct drm_device *dev = encoder->dev;
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
struct nouveau_gpio *gpio = nouveau_gpio(device); struct nouveau_gpio *gpio = nvkm_gpio(device);
struct dcb_output *dcb = nouveau_encoder(encoder)->dcb; struct dcb_output *dcb = nouveau_encoder(encoder)->dcb;
uint32_t sample, testval, regoffset = nv04_dac_output_offset(encoder); uint32_t sample, testval, regoffset = nv04_dac_output_offset(encoder);
uint32_t saved_powerctrl_2 = 0, saved_powerctrl_4 = 0, saved_routput, uint32_t saved_powerctrl_2 = 0, saved_powerctrl_4 = 0, saved_routput,
@ -283,7 +283,7 @@ uint32_t nv17_dac_sample_load(struct drm_encoder *encoder)
/* nv driver and nv31 use 0xfffffeee, nv34 and 6600 use 0xfffffece */ /* nv driver and nv31 use 0xfffffeee, nv34 and 6600 use 0xfffffece */
routput = (saved_routput & 0xfffffece) | head << 8; routput = (saved_routput & 0xfffffece) | head << 8;
if (nv_device(drm->device)->card_type >= NV_40) { if (drm->device.info.family >= NV_DEVICE_INFO_V0_CURIE) {
if (dcb->type == DCB_OUTPUT_TV) if (dcb->type == DCB_OUTPUT_TV)
routput |= 0x1a << 16; routput |= 0x1a << 16;
else else
@ -398,7 +398,7 @@ static void nv04_dac_mode_set(struct drm_encoder *encoder,
} }
/* This could use refinement for flatpanels, but it should work this way */ /* This could use refinement for flatpanels, but it should work this way */
if (nv_device(drm->device)->chipset < 0x44) if (drm->device.info.chipset < 0x44)
NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + nv04_dac_output_offset(encoder), 0xf0000000); NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + nv04_dac_output_offset(encoder), 0xf0000000);
else else
NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + nv04_dac_output_offset(encoder), 0x00100000); NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + nv04_dac_output_offset(encoder), 0x00100000);

12
drivers/gpu/drm/nouveau/dispnv04/dfp.c
View File

@ -281,7 +281,7 @@ static void nv04_dfp_mode_set(struct drm_encoder *encoder,
struct drm_display_mode *adjusted_mode) struct drm_display_mode *adjusted_mode)
{ {
struct drm_device *dev = encoder->dev; struct drm_device *dev = encoder->dev;
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_crtc *nv_crtc = nouveau_crtc(encoder->crtc); struct nouveau_crtc *nv_crtc = nouveau_crtc(encoder->crtc);
struct nv04_crtc_reg *regp = &nv04_display(dev)->mode_reg.crtc_reg[nv_crtc->index]; struct nv04_crtc_reg *regp = &nv04_display(dev)->mode_reg.crtc_reg[nv_crtc->index];
@ -416,7 +416,7 @@ static void nv04_dfp_mode_set(struct drm_encoder *encoder,
if ((nv_connector->dithering_mode == DITHERING_MODE_ON) || if ((nv_connector->dithering_mode == DITHERING_MODE_ON) ||
(nv_connector->dithering_mode == DITHERING_MODE_AUTO && (nv_connector->dithering_mode == DITHERING_MODE_AUTO &&
encoder->crtc->primary->fb->depth > connector->display_info.bpc * 3)) { encoder->crtc->primary->fb->depth > connector->display_info.bpc * 3)) {
if (nv_device(drm->device)->chipset == 0x11) if (drm->device.info.chipset == 0x11)
regp->dither = savep->dither | 0x00010000; regp->dither = savep->dither | 0x00010000;
else { else {
int i; int i;
@ -427,7 +427,7 @@ static void nv04_dfp_mode_set(struct drm_encoder *encoder,
} }
} }
} else { } else {
if (nv_device(drm->device)->chipset != 0x11) { if (drm->device.info.chipset != 0x11) {
/* reset them */ /* reset them */
int i; int i;
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
@ -463,7 +463,7 @@ static void nv04_dfp_commit(struct drm_encoder *encoder)
NVReadRAMDAC(dev, head, NV_PRAMDAC_FP_TG_CONTROL); NVReadRAMDAC(dev, head, NV_PRAMDAC_FP_TG_CONTROL);
/* This could use refinement for flatpanels, but it should work this way */ /* This could use refinement for flatpanels, but it should work this way */
if (nv_device(drm->device)->chipset < 0x44) if (drm->device.info.chipset < 0x44)
NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + nv04_dac_output_offset(encoder), 0xf0000000); NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + nv04_dac_output_offset(encoder), 0xf0000000);
else else
NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + nv04_dac_output_offset(encoder), 0x00100000); NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + nv04_dac_output_offset(encoder), 0x00100000);
@ -485,7 +485,7 @@ static void nv04_dfp_update_backlight(struct drm_encoder *encoder, int mode)
{ {
#ifdef __powerpc__ #ifdef __powerpc__
struct drm_device *dev = encoder->dev; struct drm_device *dev = encoder->dev;
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
/* BIOS scripts usually take care of the backlight, thanks /* BIOS scripts usually take care of the backlight, thanks
* Apple for your consistency. * Apple for your consistency.
@ -623,7 +623,7 @@ static void nv04_tmds_slave_init(struct drm_encoder *encoder)
struct drm_device *dev = encoder->dev; struct drm_device *dev = encoder->dev;
struct dcb_output *dcb = nouveau_encoder(encoder)->dcb; struct dcb_output *dcb = nouveau_encoder(encoder)->dcb;
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_i2c *i2c = nouveau_i2c(drm->device); struct nouveau_i2c *i2c = nvkm_i2c(&drm->device);
struct nouveau_i2c_port *port = i2c->find(i2c, 2); struct nouveau_i2c_port *port = i2c->find(i2c, 2);
struct nouveau_i2c_board_info info[] = { struct nouveau_i2c_board_info info[] = {
{ {

2
drivers/gpu/drm/nouveau/dispnv04/disp.c
View File

@ -58,7 +58,7 @@ int
nv04_display_create(struct drm_device *dev) nv04_display_create(struct drm_device *dev)
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_i2c *i2c = nouveau_i2c(drm->device); struct nouveau_i2c *i2c = nvkm_i2c(&drm->device);
struct dcb_table *dcb = &drm->vbios.dcb; struct dcb_table *dcb = &drm->vbios.dcb;
struct drm_connector *connector, *ct; struct drm_connector *connector, *ct;
struct drm_encoder *encoder; struct drm_encoder *encoder;

6
drivers/gpu/drm/nouveau/dispnv04/disp.h
View File

@ -131,7 +131,7 @@ nv_two_heads(struct drm_device *dev)
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
const int impl = dev->pdev->device & 0x0ff0; const int impl = dev->pdev->device & 0x0ff0;
if (nv_device(drm->device)->card_type >= NV_10 && impl != 0x0100 && if (drm->device.info.family >= NV_DEVICE_INFO_V0_CELSIUS && impl != 0x0100 &&
impl != 0x0150 && impl != 0x01a0 && impl != 0x0200) impl != 0x0150 && impl != 0x01a0 && impl != 0x0200)
return true; return true;
@ -150,7 +150,7 @@ nv_two_reg_pll(struct drm_device *dev)
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
const int impl = dev->pdev->device & 0x0ff0; const int impl = dev->pdev->device & 0x0ff0;
if (impl == 0x0310 || impl == 0x0340 || nv_device(drm->device)->card_type >= NV_40) if (impl == 0x0310 || impl == 0x0340 || drm->device.info.family >= NV_DEVICE_INFO_V0_CURIE)
return true; return true;
return false; return false;
} }
@ -172,7 +172,7 @@ nouveau_bios_run_init_table(struct drm_device *dev, u16 table,
struct dcb_output *outp, int crtc) struct dcb_output *outp, int crtc)
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_bios *bios = nouveau_bios(drm->device); struct nouveau_bios *bios = nvkm_bios(&drm->device);
struct nvbios_init init = { struct nvbios_init init = {
.subdev = nv_subdev(bios), .subdev = nv_subdev(bios),
.bios = bios, .bios = bios,

76
drivers/gpu/drm/nouveau/dispnv04/hw.c
View File

@ -92,7 +92,7 @@ NVSetOwner(struct drm_device *dev, int owner)
if (owner == 1) if (owner == 1)
owner *= 3; owner *= 3;
if (nv_device(drm->device)->chipset == 0x11) { if (drm->device.info.chipset == 0x11) {
/* This might seem stupid, but the blob does it and /* This might seem stupid, but the blob does it and
* omitting it often locks the system up. * omitting it often locks the system up.
*/ */
@ -103,7 +103,7 @@ NVSetOwner(struct drm_device *dev, int owner)
/* CR44 is always changed on CRTC0 */ /* CR44 is always changed on CRTC0 */
NVWriteVgaCrtc(dev, 0, NV_CIO_CRE_44, owner); NVWriteVgaCrtc(dev, 0, NV_CIO_CRE_44, owner);
if (nv_device(drm->device)->chipset == 0x11) { /* set me harder */ if (drm->device.info.chipset == 0x11) { /* set me harder */
NVWriteVgaCrtc(dev, 0, NV_CIO_CRE_2E, owner); NVWriteVgaCrtc(dev, 0, NV_CIO_CRE_2E, owner);
NVWriteVgaCrtc(dev, 0, NV_CIO_CRE_2E, owner); NVWriteVgaCrtc(dev, 0, NV_CIO_CRE_2E, owner);
} }
@ -152,7 +152,7 @@ nouveau_hw_decode_pll(struct drm_device *dev, uint32_t reg1, uint32_t pll1,
pllvals->NM1 = pll1 & 0xffff; pllvals->NM1 = pll1 & 0xffff;
if (nv_two_reg_pll(dev) && pll2 & NV31_RAMDAC_ENABLE_VCO2) if (nv_two_reg_pll(dev) && pll2 & NV31_RAMDAC_ENABLE_VCO2)
pllvals->NM2 = pll2 & 0xffff; pllvals->NM2 = pll2 & 0xffff;
else if (nv_device(drm->device)->chipset == 0x30 || nv_device(drm->device)->chipset == 0x35) { else if (drm->device.info.chipset == 0x30 || drm->device.info.chipset == 0x35) {
pllvals->M1 &= 0xf; /* only 4 bits */ pllvals->M1 &= 0xf; /* only 4 bits */
if (pll1 & NV30_RAMDAC_ENABLE_VCO2) { if (pll1 & NV30_RAMDAC_ENABLE_VCO2) {
pllvals->M2 = (pll1 >> 4) & 0x7; pllvals->M2 = (pll1 >> 4) & 0x7;
@ -168,8 +168,8 @@ nouveau_hw_get_pllvals(struct drm_device *dev, enum nvbios_pll_type plltype,
struct nouveau_pll_vals *pllvals) struct nouveau_pll_vals *pllvals)
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_object *device = drm->device; struct nvif_device *device = &drm->device;
struct nouveau_bios *bios = nouveau_bios(device); struct nouveau_bios *bios = nvkm_bios(device);
uint32_t reg1, pll1, pll2 = 0; uint32_t reg1, pll1, pll2 = 0;
struct nvbios_pll pll_lim; struct nvbios_pll pll_lim;
int ret; int ret;
@ -187,7 +187,7 @@ nouveau_hw_get_pllvals(struct drm_device *dev, enum nvbios_pll_type plltype,
pll2 = nvif_rd32(device, reg2); pll2 = nvif_rd32(device, reg2);
} }
if (nv_device(drm->device)->card_type == 0x40 && reg1 >= NV_PRAMDAC_VPLL_COEFF) { if (drm->device.info.family == NV_DEVICE_INFO_V0_CELSIUS && reg1 >= NV_PRAMDAC_VPLL_COEFF) {
uint32_t ramdac580 = NVReadRAMDAC(dev, 0, NV_PRAMDAC_580); uint32_t ramdac580 = NVReadRAMDAC(dev, 0, NV_PRAMDAC_580);
/* check whether vpll has been forced into single stage mode */ /* check whether vpll has been forced into single stage mode */
@ -255,9 +255,9 @@ nouveau_hw_fix_bad_vpll(struct drm_device *dev, int head)
*/ */
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_object *device = drm->device; struct nvif_device *device = &drm->device;
struct nouveau_clock *clk = nouveau_clock(device); struct nouveau_clock *clk = nvkm_clock(device);
struct nouveau_bios *bios = nouveau_bios(device); struct nouveau_bios *bios = nvkm_bios(device);
struct nvbios_pll pll_lim; struct nvbios_pll pll_lim;
struct nouveau_pll_vals pv; struct nouveau_pll_vals pv;
enum nvbios_pll_type pll = head ? PLL_VPLL1 : PLL_VPLL0; enum nvbios_pll_type pll = head ? PLL_VPLL1 : PLL_VPLL0;
@ -394,21 +394,21 @@ nv_save_state_ramdac(struct drm_device *dev, int head,
struct nv04_crtc_reg *regp = &state->crtc_reg[head]; struct nv04_crtc_reg *regp = &state->crtc_reg[head];
int i; int i;
if (nv_device(drm->device)->card_type >= NV_10) if (drm->device.info.family >= NV_DEVICE_INFO_V0_CELSIUS)
regp->nv10_cursync = NVReadRAMDAC(dev, head, NV_RAMDAC_NV10_CURSYNC); regp->nv10_cursync = NVReadRAMDAC(dev, head, NV_RAMDAC_NV10_CURSYNC);
nouveau_hw_get_pllvals(dev, head ? PLL_VPLL1 : PLL_VPLL0, &regp->pllvals); nouveau_hw_get_pllvals(dev, head ? PLL_VPLL1 : PLL_VPLL0, &regp->pllvals);
state->pllsel = NVReadRAMDAC(dev, 0, NV_PRAMDAC_PLL_COEFF_SELECT); state->pllsel = NVReadRAMDAC(dev, 0, NV_PRAMDAC_PLL_COEFF_SELECT);
if (nv_two_heads(dev)) if (nv_two_heads(dev))
state->sel_clk = NVReadRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK); state->sel_clk = NVReadRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK);
if (nv_device(drm->device)->chipset == 0x11) if (drm->device.info.chipset == 0x11)
regp->dither = NVReadRAMDAC(dev, head, NV_RAMDAC_DITHER_NV11); regp->dither = NVReadRAMDAC(dev, head, NV_RAMDAC_DITHER_NV11);
regp->ramdac_gen_ctrl = NVReadRAMDAC(dev, head, NV_PRAMDAC_GENERAL_CONTROL); regp->ramdac_gen_ctrl = NVReadRAMDAC(dev, head, NV_PRAMDAC_GENERAL_CONTROL);
if (nv_gf4_disp_arch(dev)) if (nv_gf4_disp_arch(dev))
regp->ramdac_630 = NVReadRAMDAC(dev, head, NV_PRAMDAC_630); regp->ramdac_630 = NVReadRAMDAC(dev, head, NV_PRAMDAC_630);
if (nv_device(drm->device)->chipset >= 0x30) if (drm->device.info.chipset >= 0x30)
regp->ramdac_634 = NVReadRAMDAC(dev, head, NV_PRAMDAC_634); regp->ramdac_634 = NVReadRAMDAC(dev, head, NV_PRAMDAC_634);
regp->tv_setup = NVReadRAMDAC(dev, head, NV_PRAMDAC_TV_SETUP); regp->tv_setup = NVReadRAMDAC(dev, head, NV_PRAMDAC_TV_SETUP);
@ -450,7 +450,7 @@ nv_save_state_ramdac(struct drm_device *dev, int head,
if (nv_gf4_disp_arch(dev)) if (nv_gf4_disp_arch(dev))
regp->ramdac_8c0 = NVReadRAMDAC(dev, head, NV_PRAMDAC_8C0); regp->ramdac_8c0 = NVReadRAMDAC(dev, head, NV_PRAMDAC_8C0);
if (nv_device(drm->device)->card_type == NV_40) { if (drm->device.info.family == NV_DEVICE_INFO_V0_CURIE) {
regp->ramdac_a20 = NVReadRAMDAC(dev, head, NV_PRAMDAC_A20); regp->ramdac_a20 = NVReadRAMDAC(dev, head, NV_PRAMDAC_A20);
regp->ramdac_a24 = NVReadRAMDAC(dev, head, NV_PRAMDAC_A24); regp->ramdac_a24 = NVReadRAMDAC(dev, head, NV_PRAMDAC_A24);
regp->ramdac_a34 = NVReadRAMDAC(dev, head, NV_PRAMDAC_A34); regp->ramdac_a34 = NVReadRAMDAC(dev, head, NV_PRAMDAC_A34);
@ -466,26 +466,26 @@ nv_load_state_ramdac(struct drm_device *dev, int head,
struct nv04_mode_state *state) struct nv04_mode_state *state)
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_clock *clk = nouveau_clock(drm->device); struct nouveau_clock *clk = nvkm_clock(&drm->device);
struct nv04_crtc_reg *regp = &state->crtc_reg[head]; struct nv04_crtc_reg *regp = &state->crtc_reg[head];
uint32_t pllreg = head ? NV_RAMDAC_VPLL2 : NV_PRAMDAC_VPLL_COEFF; uint32_t pllreg = head ? NV_RAMDAC_VPLL2 : NV_PRAMDAC_VPLL_COEFF;
int i; int i;
if (nv_device(drm->device)->card_type >= NV_10) if (drm->device.info.family >= NV_DEVICE_INFO_V0_CELSIUS)
NVWriteRAMDAC(dev, head, NV_RAMDAC_NV10_CURSYNC, regp->nv10_cursync); NVWriteRAMDAC(dev, head, NV_RAMDAC_NV10_CURSYNC, regp->nv10_cursync);
clk->pll_prog(clk, pllreg, &regp->pllvals); clk->pll_prog(clk, pllreg, &regp->pllvals);
NVWriteRAMDAC(dev, 0, NV_PRAMDAC_PLL_COEFF_SELECT, state->pllsel); NVWriteRAMDAC(dev, 0, NV_PRAMDAC_PLL_COEFF_SELECT, state->pllsel);
if (nv_two_heads(dev)) if (nv_two_heads(dev))
NVWriteRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK, state->sel_clk); NVWriteRAMDAC(dev, 0, NV_PRAMDAC_SEL_CLK, state->sel_clk);
if (nv_device(drm->device)->chipset == 0x11) if (drm->device.info.chipset == 0x11)
NVWriteRAMDAC(dev, head, NV_RAMDAC_DITHER_NV11, regp->dither); NVWriteRAMDAC(dev, head, NV_RAMDAC_DITHER_NV11, regp->dither);
NVWriteRAMDAC(dev, head, NV_PRAMDAC_GENERAL_CONTROL, regp->ramdac_gen_ctrl); NVWriteRAMDAC(dev, head, NV_PRAMDAC_GENERAL_CONTROL, regp->ramdac_gen_ctrl);
if (nv_gf4_disp_arch(dev)) if (nv_gf4_disp_arch(dev))
NVWriteRAMDAC(dev, head, NV_PRAMDAC_630, regp->ramdac_630); NVWriteRAMDAC(dev, head, NV_PRAMDAC_630, regp->ramdac_630);
if (nv_device(drm->device)->chipset >= 0x30) if (drm->device.info.chipset >= 0x30)
NVWriteRAMDAC(dev, head, NV_PRAMDAC_634, regp->ramdac_634); NVWriteRAMDAC(dev, head, NV_PRAMDAC_634, regp->ramdac_634);
NVWriteRAMDAC(dev, head, NV_PRAMDAC_TV_SETUP, regp->tv_setup); NVWriteRAMDAC(dev, head, NV_PRAMDAC_TV_SETUP, regp->tv_setup);
@ -522,7 +522,7 @@ nv_load_state_ramdac(struct drm_device *dev, int head,
if (nv_gf4_disp_arch(dev)) if (nv_gf4_disp_arch(dev))
NVWriteRAMDAC(dev, head, NV_PRAMDAC_8C0, regp->ramdac_8c0); NVWriteRAMDAC(dev, head, NV_PRAMDAC_8C0, regp->ramdac_8c0);
if (nv_device(drm->device)->card_type == NV_40) { if (drm->device.info.family == NV_DEVICE_INFO_V0_CURIE) {
NVWriteRAMDAC(dev, head, NV_PRAMDAC_A20, regp->ramdac_a20); NVWriteRAMDAC(dev, head, NV_PRAMDAC_A20, regp->ramdac_a20);
NVWriteRAMDAC(dev, head, NV_PRAMDAC_A24, regp->ramdac_a24); NVWriteRAMDAC(dev, head, NV_PRAMDAC_A24, regp->ramdac_a24);
NVWriteRAMDAC(dev, head, NV_PRAMDAC_A34, regp->ramdac_a34); NVWriteRAMDAC(dev, head, NV_PRAMDAC_A34, regp->ramdac_a34);
@ -603,10 +603,10 @@ nv_save_state_ext(struct drm_device *dev, int head,
rd_cio_state(dev, head, regp, NV_CIO_CRE_FFLWM__INDEX); rd_cio_state(dev, head, regp, NV_CIO_CRE_FFLWM__INDEX);
rd_cio_state(dev, head, regp, NV_CIO_CRE_21); rd_cio_state(dev, head, regp, NV_CIO_CRE_21);
if (nv_device(drm->device)->card_type >= NV_20) if (drm->device.info.family >= NV_DEVICE_INFO_V0_KELVIN)
rd_cio_state(dev, head, regp, NV_CIO_CRE_47); rd_cio_state(dev, head, regp, NV_CIO_CRE_47);
if (nv_device(drm->device)->card_type >= NV_30) if (drm->device.info.family >= NV_DEVICE_INFO_V0_RANKINE)
rd_cio_state(dev, head, regp, 0x9f); rd_cio_state(dev, head, regp, 0x9f);
rd_cio_state(dev, head, regp, NV_CIO_CRE_49); rd_cio_state(dev, head, regp, NV_CIO_CRE_49);
@ -615,14 +615,14 @@ nv_save_state_ext(struct drm_device *dev, int head,
rd_cio_state(dev, head, regp, NV_CIO_CRE_HCUR_ADDR2_INDEX); rd_cio_state(dev, head, regp, NV_CIO_CRE_HCUR_ADDR2_INDEX);
rd_cio_state(dev, head, regp, NV_CIO_CRE_ILACE__INDEX); rd_cio_state(dev, head, regp, NV_CIO_CRE_ILACE__INDEX);
if (nv_device(drm->device)->card_type >= NV_10) { if (drm->device.info.family >= NV_DEVICE_INFO_V0_CELSIUS) {
regp->crtc_830 = NVReadCRTC(dev, head, NV_PCRTC_830); regp->crtc_830 = NVReadCRTC(dev, head, NV_PCRTC_830);
regp->crtc_834 = NVReadCRTC(dev, head, NV_PCRTC_834); regp->crtc_834 = NVReadCRTC(dev, head, NV_PCRTC_834);
if (nv_device(drm->device)->card_type >= NV_30) if (drm->device.info.family >= NV_DEVICE_INFO_V0_RANKINE)
regp->gpio_ext = NVReadCRTC(dev, head, NV_PCRTC_GPIO_EXT); regp->gpio_ext = NVReadCRTC(dev, head, NV_PCRTC_GPIO_EXT);
if (nv_device(drm->device)->card_type == NV_40) if (drm->device.info.family == NV_DEVICE_INFO_V0_CURIE)
regp->crtc_850 = NVReadCRTC(dev, head, NV_PCRTC_850); regp->crtc_850 = NVReadCRTC(dev, head, NV_PCRTC_850);
if (nv_two_heads(dev)) if (nv_two_heads(dev))
@ -634,7 +634,7 @@ nv_save_state_ext(struct drm_device *dev, int head,
rd_cio_state(dev, head, regp, NV_CIO_CRE_SCRATCH3__INDEX); rd_cio_state(dev, head, regp, NV_CIO_CRE_SCRATCH3__INDEX);
rd_cio_state(dev, head, regp, NV_CIO_CRE_SCRATCH4__INDEX); rd_cio_state(dev, head, regp, NV_CIO_CRE_SCRATCH4__INDEX);
if (nv_device(drm->device)->card_type >= NV_10) { if (drm->device.info.family >= NV_DEVICE_INFO_V0_CELSIUS) {
rd_cio_state(dev, head, regp, NV_CIO_CRE_EBR_INDEX); rd_cio_state(dev, head, regp, NV_CIO_CRE_EBR_INDEX);
rd_cio_state(dev, head, regp, NV_CIO_CRE_CSB); rd_cio_state(dev, head, regp, NV_CIO_CRE_CSB);
rd_cio_state(dev, head, regp, NV_CIO_CRE_4B); rd_cio_state(dev, head, regp, NV_CIO_CRE_4B);
@ -663,14 +663,14 @@ nv_load_state_ext(struct drm_device *dev, int head,
struct nv04_mode_state *state) struct nv04_mode_state *state)
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_object *device = drm->device; struct nvif_device *device = &drm->device;
struct nouveau_timer *ptimer = nouveau_timer(device); struct nouveau_timer *ptimer = nvkm_timer(device);
struct nouveau_fb *pfb = nouveau_fb(device); struct nouveau_fb *pfb = nvkm_fb(device);
struct nv04_crtc_reg *regp = &state->crtc_reg[head]; struct nv04_crtc_reg *regp = &state->crtc_reg[head];
uint32_t reg900; uint32_t reg900;
int i; int i;
if (nv_device(drm->device)->card_type >= NV_10) { if (drm->device.info.family >= NV_DEVICE_INFO_V0_CELSIUS) {
if (nv_two_heads(dev)) if (nv_two_heads(dev))
/* setting ENGINE_CTRL (EC) *must* come before /* setting ENGINE_CTRL (EC) *must* come before
* CIO_CRE_LCD, as writing CRE_LCD sets bits 16 & 17 in * CIO_CRE_LCD, as writing CRE_LCD sets bits 16 & 17 in
@ -692,10 +692,10 @@ nv_load_state_ext(struct drm_device *dev, int head,
NVWriteCRTC(dev, head, NV_PCRTC_830, regp->crtc_830); NVWriteCRTC(dev, head, NV_PCRTC_830, regp->crtc_830);
NVWriteCRTC(dev, head, NV_PCRTC_834, regp->crtc_834); NVWriteCRTC(dev, head, NV_PCRTC_834, regp->crtc_834);
if (nv_device(drm->device)->card_type >= NV_30) if (drm->device.info.family >= NV_DEVICE_INFO_V0_RANKINE)
NVWriteCRTC(dev, head, NV_PCRTC_GPIO_EXT, regp->gpio_ext); NVWriteCRTC(dev, head, NV_PCRTC_GPIO_EXT, regp->gpio_ext);
if (nv_device(drm->device)->card_type == NV_40) { if (drm->device.info.family == NV_DEVICE_INFO_V0_CURIE) {
NVWriteCRTC(dev, head, NV_PCRTC_850, regp->crtc_850); NVWriteCRTC(dev, head, NV_PCRTC_850, regp->crtc_850);
reg900 = NVReadRAMDAC(dev, head, NV_PRAMDAC_900); reg900 = NVReadRAMDAC(dev, head, NV_PRAMDAC_900);
@ -718,23 +718,23 @@ nv_load_state_ext(struct drm_device *dev, int head,
wr_cio_state(dev, head, regp, NV_CIO_CRE_FF_INDEX); wr_cio_state(dev, head, regp, NV_CIO_CRE_FF_INDEX);
wr_cio_state(dev, head, regp, NV_CIO_CRE_FFLWM__INDEX); wr_cio_state(dev, head, regp, NV_CIO_CRE_FFLWM__INDEX);
if (nv_device(drm->device)->card_type >= NV_20) if (drm->device.info.family >= NV_DEVICE_INFO_V0_KELVIN)
wr_cio_state(dev, head, regp, NV_CIO_CRE_47); wr_cio_state(dev, head, regp, NV_CIO_CRE_47);
if (nv_device(drm->device)->card_type >= NV_30) if (drm->device.info.family >= NV_DEVICE_INFO_V0_RANKINE)
wr_cio_state(dev, head, regp, 0x9f); wr_cio_state(dev, head, regp, 0x9f);
wr_cio_state(dev, head, regp, NV_CIO_CRE_49); wr_cio_state(dev, head, regp, NV_CIO_CRE_49);
wr_cio_state(dev, head, regp, NV_CIO_CRE_HCUR_ADDR0_INDEX); wr_cio_state(dev, head, regp, NV_CIO_CRE_HCUR_ADDR0_INDEX);
wr_cio_state(dev, head, regp, NV_CIO_CRE_HCUR_ADDR1_INDEX); wr_cio_state(dev, head, regp, NV_CIO_CRE_HCUR_ADDR1_INDEX);
wr_cio_state(dev, head, regp, NV_CIO_CRE_HCUR_ADDR2_INDEX); wr_cio_state(dev, head, regp, NV_CIO_CRE_HCUR_ADDR2_INDEX);
if (nv_device(drm->device)->card_type == NV_40) if (drm->device.info.family == NV_DEVICE_INFO_V0_CURIE)
nv_fix_nv40_hw_cursor(dev, head); nv_fix_nv40_hw_cursor(dev, head);
wr_cio_state(dev, head, regp, NV_CIO_CRE_ILACE__INDEX); wr_cio_state(dev, head, regp, NV_CIO_CRE_ILACE__INDEX);
wr_cio_state(dev, head, regp, NV_CIO_CRE_SCRATCH3__INDEX); wr_cio_state(dev, head, regp, NV_CIO_CRE_SCRATCH3__INDEX);
wr_cio_state(dev, head, regp, NV_CIO_CRE_SCRATCH4__INDEX); wr_cio_state(dev, head, regp, NV_CIO_CRE_SCRATCH4__INDEX);
if (nv_device(drm->device)->card_type >= NV_10) { if (drm->device.info.family >= NV_DEVICE_INFO_V0_CELSIUS) {
wr_cio_state(dev, head, regp, NV_CIO_CRE_EBR_INDEX); wr_cio_state(dev, head, regp, NV_CIO_CRE_EBR_INDEX);
wr_cio_state(dev, head, regp, NV_CIO_CRE_CSB); wr_cio_state(dev, head, regp, NV_CIO_CRE_CSB);
wr_cio_state(dev, head, regp, NV_CIO_CRE_4B); wr_cio_state(dev, head, regp, NV_CIO_CRE_4B);
@ -742,7 +742,7 @@ nv_load_state_ext(struct drm_device *dev, int head,
} }
/* NV11 and NV20 stop at 0x52. */ /* NV11 and NV20 stop at 0x52. */
if (nv_gf4_disp_arch(dev)) { if (nv_gf4_disp_arch(dev)) {
if (nv_device(drm->device)->card_type < NV_20) { if (drm->device.info.family < NV_DEVICE_INFO_V0_KELVIN) {
/* Not waiting for vertical retrace before modifying /* Not waiting for vertical retrace before modifying
CRE_53/CRE_54 causes lockups. */ CRE_53/CRE_54 causes lockups. */
nouveau_timer_wait_eq(ptimer, 650000000, NV_PRMCIO_INP0__COLOR, 0x8, 0x8); nouveau_timer_wait_eq(ptimer, 650000000, NV_PRMCIO_INP0__COLOR, 0x8, 0x8);
@ -769,7 +769,7 @@ static void
nv_save_state_palette(struct drm_device *dev, int head, nv_save_state_palette(struct drm_device *dev, int head,
struct nv04_mode_state *state) struct nv04_mode_state *state)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
int head_offset = head * NV_PRMDIO_SIZE, i; int head_offset = head * NV_PRMDIO_SIZE, i;
nvif_wr08(device, NV_PRMDIO_PIXEL_MASK + head_offset, nvif_wr08(device, NV_PRMDIO_PIXEL_MASK + head_offset,
@ -788,7 +788,7 @@ void
nouveau_hw_load_state_palette(struct drm_device *dev, int head, nouveau_hw_load_state_palette(struct drm_device *dev, int head,
struct nv04_mode_state *state) struct nv04_mode_state *state)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
int head_offset = head * NV_PRMDIO_SIZE, i; int head_offset = head * NV_PRMDIO_SIZE, i;
nvif_wr08(device, NV_PRMDIO_PIXEL_MASK + head_offset, nvif_wr08(device, NV_PRMDIO_PIXEL_MASK + head_offset,
@ -808,7 +808,7 @@ void nouveau_hw_save_state(struct drm_device *dev, int head,
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
if (nv_device(drm->device)->chipset == 0x11) if (drm->device.info.chipset == 0x11)
/* NB: no attempt is made to restore the bad pll later on */ /* NB: no attempt is made to restore the bad pll later on */
nouveau_hw_fix_bad_vpll(dev, head); nouveau_hw_fix_bad_vpll(dev, head);
nv_save_state_ramdac(dev, head, state); nv_save_state_ramdac(dev, head, state);

42
drivers/gpu/drm/nouveau/dispnv04/hw.h
View File

@ -60,7 +60,7 @@ extern void nouveau_calc_arb(struct drm_device *, int vclk, int bpp,
static inline uint32_t NVReadCRTC(struct drm_device *dev, static inline uint32_t NVReadCRTC(struct drm_device *dev,
int head, uint32_t reg) int head, uint32_t reg)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
uint32_t val; uint32_t val;
if (head) if (head)
reg += NV_PCRTC0_SIZE; reg += NV_PCRTC0_SIZE;
@ -71,7 +71,7 @@ static inline uint32_t NVReadCRTC(struct drm_device *dev,
static inline void NVWriteCRTC(struct drm_device *dev, static inline void NVWriteCRTC(struct drm_device *dev,
int head, uint32_t reg, uint32_t val) int head, uint32_t reg, uint32_t val)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
if (head) if (head)
reg += NV_PCRTC0_SIZE; reg += NV_PCRTC0_SIZE;
nvif_wr32(device, reg, val); nvif_wr32(device, reg, val);
@ -80,7 +80,7 @@ static inline void NVWriteCRTC(struct drm_device *dev,
static inline uint32_t NVReadRAMDAC(struct drm_device *dev, static inline uint32_t NVReadRAMDAC(struct drm_device *dev,
int head, uint32_t reg) int head, uint32_t reg)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
uint32_t val; uint32_t val;
if (head) if (head)
reg += NV_PRAMDAC0_SIZE; reg += NV_PRAMDAC0_SIZE;
@ -91,7 +91,7 @@ static inline uint32_t NVReadRAMDAC(struct drm_device *dev,
static inline void NVWriteRAMDAC(struct drm_device *dev, static inline void NVWriteRAMDAC(struct drm_device *dev,
int head, uint32_t reg, uint32_t val) int head, uint32_t reg, uint32_t val)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
if (head) if (head)
reg += NV_PRAMDAC0_SIZE; reg += NV_PRAMDAC0_SIZE;
nvif_wr32(device, reg, val); nvif_wr32(device, reg, val);
@ -120,7 +120,7 @@ static inline void nv_write_tmds(struct drm_device *dev,
static inline void NVWriteVgaCrtc(struct drm_device *dev, static inline void NVWriteVgaCrtc(struct drm_device *dev,
int head, uint8_t index, uint8_t value) int head, uint8_t index, uint8_t value)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
nvif_wr08(device, NV_PRMCIO_CRX__COLOR + head * NV_PRMCIO_SIZE, index); nvif_wr08(device, NV_PRMCIO_CRX__COLOR + head * NV_PRMCIO_SIZE, index);
nvif_wr08(device, NV_PRMCIO_CR__COLOR + head * NV_PRMCIO_SIZE, value); nvif_wr08(device, NV_PRMCIO_CR__COLOR + head * NV_PRMCIO_SIZE, value);
} }
@ -128,7 +128,7 @@ static inline void NVWriteVgaCrtc(struct drm_device *dev,
static inline uint8_t NVReadVgaCrtc(struct drm_device *dev, static inline uint8_t NVReadVgaCrtc(struct drm_device *dev,
int head, uint8_t index) int head, uint8_t index)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
uint8_t val; uint8_t val;
nvif_wr08(device, NV_PRMCIO_CRX__COLOR + head * NV_PRMCIO_SIZE, index); nvif_wr08(device, NV_PRMCIO_CRX__COLOR + head * NV_PRMCIO_SIZE, index);
val = nvif_rd08(device, NV_PRMCIO_CR__COLOR + head * NV_PRMCIO_SIZE); val = nvif_rd08(device, NV_PRMCIO_CR__COLOR + head * NV_PRMCIO_SIZE);
@ -165,13 +165,13 @@ static inline uint8_t NVReadVgaCrtc5758(struct drm_device *dev, int head, uint8_
static inline uint8_t NVReadPRMVIO(struct drm_device *dev, static inline uint8_t NVReadPRMVIO(struct drm_device *dev,
int head, uint32_t reg) int head, uint32_t reg)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
uint8_t val; uint8_t val;
/* Only NV4x have two pvio ranges; other twoHeads cards MUST call /* Only NV4x have two pvio ranges; other twoHeads cards MUST call
* NVSetOwner for the relevant head to be programmed */ * NVSetOwner for the relevant head to be programmed */
if (head && nv_device(drm->device)->card_type == NV_40) if (head && drm->device.info.family == NV_DEVICE_INFO_V0_CURIE)
reg += NV_PRMVIO_SIZE; reg += NV_PRMVIO_SIZE;
val = nvif_rd08(device, reg); val = nvif_rd08(device, reg);
@ -181,12 +181,12 @@ static inline uint8_t NVReadPRMVIO(struct drm_device *dev,
static inline void NVWritePRMVIO(struct drm_device *dev, static inline void NVWritePRMVIO(struct drm_device *dev,
int head, uint32_t reg, uint8_t value) int head, uint32_t reg, uint8_t value)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
/* Only NV4x have two pvio ranges; other twoHeads cards MUST call /* Only NV4x have two pvio ranges; other twoHeads cards MUST call
* NVSetOwner for the relevant head to be programmed */ * NVSetOwner for the relevant head to be programmed */
if (head && nv_device(drm->device)->card_type == NV_40) if (head && drm->device.info.family == NV_DEVICE_INFO_V0_CURIE)
reg += NV_PRMVIO_SIZE; reg += NV_PRMVIO_SIZE;
nvif_wr08(device, reg, value); nvif_wr08(device, reg, value);
@ -194,14 +194,14 @@ static inline void NVWritePRMVIO(struct drm_device *dev,
static inline void NVSetEnablePalette(struct drm_device *dev, int head, bool enable) static inline void NVSetEnablePalette(struct drm_device *dev, int head, bool enable)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
nvif_rd08(device, NV_PRMCIO_INP0__COLOR + head * NV_PRMCIO_SIZE); nvif_rd08(device, NV_PRMCIO_INP0__COLOR + head * NV_PRMCIO_SIZE);
nvif_wr08(device, NV_PRMCIO_ARX + head * NV_PRMCIO_SIZE, enable ? 0 : 0x20); nvif_wr08(device, NV_PRMCIO_ARX + head * NV_PRMCIO_SIZE, enable ? 0 : 0x20);
} }
static inline bool NVGetEnablePalette(struct drm_device *dev, int head) static inline bool NVGetEnablePalette(struct drm_device *dev, int head)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
nvif_rd08(device, NV_PRMCIO_INP0__COLOR + head * NV_PRMCIO_SIZE); nvif_rd08(device, NV_PRMCIO_INP0__COLOR + head * NV_PRMCIO_SIZE);
return !(nvif_rd08(device, NV_PRMCIO_ARX + head * NV_PRMCIO_SIZE) & 0x20); return !(nvif_rd08(device, NV_PRMCIO_ARX + head * NV_PRMCIO_SIZE) & 0x20);
} }
@ -209,7 +209,7 @@ static inline bool NVGetEnablePalette(struct drm_device *dev, int head)
static inline void NVWriteVgaAttr(struct drm_device *dev, static inline void NVWriteVgaAttr(struct drm_device *dev,
int head, uint8_t index, uint8_t value) int head, uint8_t index, uint8_t value)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
if (NVGetEnablePalette(dev, head)) if (NVGetEnablePalette(dev, head))
index &= ~0x20; index &= ~0x20;
else else
@ -223,7 +223,7 @@ static inline void NVWriteVgaAttr(struct drm_device *dev,
static inline uint8_t NVReadVgaAttr(struct drm_device *dev, static inline uint8_t NVReadVgaAttr(struct drm_device *dev,
int head, uint8_t index) int head, uint8_t index)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
uint8_t val; uint8_t val;
if (NVGetEnablePalette(dev, head)) if (NVGetEnablePalette(dev, head))
index &= ~0x20; index &= ~0x20;
@ -259,10 +259,10 @@ static inline void NVVgaProtect(struct drm_device *dev, int head, bool protect)
static inline bool static inline bool
nv_heads_tied(struct drm_device *dev) nv_heads_tied(struct drm_device *dev)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
if (nv_device(drm->device)->chipset == 0x11) if (drm->device.info.chipset == 0x11)
return !!(nvif_rd32(device, NV_PBUS_DEBUG_1) & (1 << 28)); return !!(nvif_rd32(device, NV_PBUS_DEBUG_1) & (1 << 28));
return NVReadVgaCrtc(dev, 0, NV_CIO_CRE_44) & 0x4; return NVReadVgaCrtc(dev, 0, NV_CIO_CRE_44) & 0x4;
@ -318,7 +318,7 @@ NVLockVgaCrtcs(struct drm_device *dev, bool lock)
NVWriteVgaCrtc(dev, 0, NV_CIO_SR_LOCK_INDEX, NVWriteVgaCrtc(dev, 0, NV_CIO_SR_LOCK_INDEX,
lock ? NV_CIO_SR_LOCK_VALUE : NV_CIO_SR_UNLOCK_RW_VALUE); lock ? NV_CIO_SR_LOCK_VALUE : NV_CIO_SR_UNLOCK_RW_VALUE);
/* NV11 has independently lockable extended crtcs, except when tied */ /* NV11 has independently lockable extended crtcs, except when tied */
if (nv_device(drm->device)->chipset == 0x11 && !nv_heads_tied(dev)) if (drm->device.info.chipset == 0x11 && !nv_heads_tied(dev))
NVWriteVgaCrtc(dev, 1, NV_CIO_SR_LOCK_INDEX, NVWriteVgaCrtc(dev, 1, NV_CIO_SR_LOCK_INDEX,
lock ? NV_CIO_SR_LOCK_VALUE : lock ? NV_CIO_SR_LOCK_VALUE :
NV_CIO_SR_UNLOCK_RW_VALUE); NV_CIO_SR_UNLOCK_RW_VALUE);
@ -335,7 +335,7 @@ static inline int nv_cursor_width(struct drm_device *dev)
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
return nv_device(drm->device)->card_type >= NV_10 ? NV10_CURSOR_SIZE : NV04_CURSOR_SIZE; return drm->device.info.family >= NV_DEVICE_INFO_V0_CELSIUS ? NV10_CURSOR_SIZE : NV04_CURSOR_SIZE;
} }
static inline void static inline void
@ -357,7 +357,7 @@ nv_set_crtc_base(struct drm_device *dev, int head, uint32_t offset)
NVWriteCRTC(dev, head, NV_PCRTC_START, offset); NVWriteCRTC(dev, head, NV_PCRTC_START, offset);
if (nv_device(drm->device)->card_type == NV_04) { if (drm->device.info.family == NV_DEVICE_INFO_V0_TNT) {
/* /*
* Hilarious, the 24th bit doesn't want to stick to * Hilarious, the 24th bit doesn't want to stick to
* PCRTC_START... * PCRTC_START...
@ -382,7 +382,7 @@ nv_show_cursor(struct drm_device *dev, int head, bool show)
*curctl1 &= ~MASK(NV_CIO_CRE_HCUR_ADDR1_ENABLE); *curctl1 &= ~MASK(NV_CIO_CRE_HCUR_ADDR1_ENABLE);
NVWriteVgaCrtc(dev, head, NV_CIO_CRE_HCUR_ADDR1_INDEX, *curctl1); NVWriteVgaCrtc(dev, head, NV_CIO_CRE_HCUR_ADDR1_INDEX, *curctl1);
if (nv_device(drm->device)->card_type == NV_40) if (drm->device.info.family == NV_DEVICE_INFO_V0_CURIE)
nv_fix_nv40_hw_cursor(dev, head); nv_fix_nv40_hw_cursor(dev, head);
} }
@ -398,7 +398,7 @@ nv_pitch_align(struct drm_device *dev, uint32_t width, int bpp)
bpp = 8; bpp = 8;
/* Alignment requirements taken from the Haiku driver */ /* Alignment requirements taken from the Haiku driver */
if (nv_device(drm->device)->card_type == NV_04) if (drm->device.info.family == NV_DEVICE_INFO_V0_TNT)
mask = 128 / bpp - 1; mask = 128 / bpp - 1;
else else
mask = 512 / bpp - 1; mask = 512 / bpp - 1;

20
drivers/gpu/drm/nouveau/dispnv04/overlay.c
View File

@ -96,7 +96,7 @@ nv10_update_plane(struct drm_plane *plane, struct drm_crtc *crtc,
uint32_t src_x, uint32_t src_y, uint32_t src_x, uint32_t src_y,
uint32_t src_w, uint32_t src_h) uint32_t src_w, uint32_t src_h)
{ {
struct nouveau_object *dev = nouveau_drm(plane->dev)->device; struct nvif_device *dev = &nouveau_drm(plane->dev)->device;
struct nouveau_plane *nv_plane = (struct nouveau_plane *)plane; struct nouveau_plane *nv_plane = (struct nouveau_plane *)plane;
struct nouveau_framebuffer *nv_fb = nouveau_framebuffer(fb); struct nouveau_framebuffer *nv_fb = nouveau_framebuffer(fb);
struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc); struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
@ -117,7 +117,7 @@ nv10_update_plane(struct drm_plane *plane, struct drm_crtc *crtc,
if (format > 0xffff) if (format > 0xffff)
return -ERANGE; return -ERANGE;
if (nv_device(dev)->chipset >= 0x30) { if (dev->info.chipset >= 0x30) {
if (crtc_w < (src_w >> 1) || crtc_h < (src_h >> 1)) if (crtc_w < (src_w >> 1) || crtc_h < (src_h >> 1))
return -ERANGE; return -ERANGE;
} else { } else {
@ -172,7 +172,7 @@ nv10_update_plane(struct drm_plane *plane, struct drm_crtc *crtc,
static int static int
nv10_disable_plane(struct drm_plane *plane) nv10_disable_plane(struct drm_plane *plane)
{ {
struct nouveau_object *dev = nouveau_drm(plane->dev)->device; struct nvif_device *dev = &nouveau_drm(plane->dev)->device;
struct nouveau_plane *nv_plane = (struct nouveau_plane *)plane; struct nouveau_plane *nv_plane = (struct nouveau_plane *)plane;
nvif_wr32(dev, NV_PVIDEO_STOP, 1); nvif_wr32(dev, NV_PVIDEO_STOP, 1);
@ -195,7 +195,7 @@ nv_destroy_plane(struct drm_plane *plane)
static void static void
nv10_set_params(struct nouveau_plane *plane) nv10_set_params(struct nouveau_plane *plane)
{ {
struct nouveau_object *dev = nouveau_drm(plane->base.dev)->device; struct nvif_device *dev = &nouveau_drm(plane->base.dev)->device;
u32 luma = (plane->brightness - 512) << 16 | plane->contrast; u32 luma = (plane->brightness - 512) << 16 | plane->contrast;
u32 chroma = ((sin_mul(plane->hue, plane->saturation) & 0xffff) << 16) | u32 chroma = ((sin_mul(plane->hue, plane->saturation) & 0xffff) << 16) |
(cos_mul(plane->hue, plane->saturation) & 0xffff); (cos_mul(plane->hue, plane->saturation) & 0xffff);
@ -264,7 +264,7 @@ nv10_overlay_init(struct drm_device *device)
if (!plane) if (!plane)
return; return;
switch (nv_device(drm->device)->chipset) { switch (drm->device.info.chipset) {
case 0x10: case 0x10:
case 0x11: case 0x11:
case 0x15: case 0x15:
@ -343,7 +343,7 @@ nv04_update_plane(struct drm_plane *plane, struct drm_crtc *crtc,
uint32_t src_x, uint32_t src_y, uint32_t src_x, uint32_t src_y,
uint32_t src_w, uint32_t src_h) uint32_t src_w, uint32_t src_h)
{ {
struct nouveau_object *dev = nouveau_drm(plane->dev)->device; struct nvif_device *dev = &nouveau_drm(plane->dev)->device;
struct nouveau_plane *nv_plane = (struct nouveau_plane *)plane; struct nouveau_plane *nv_plane = (struct nouveau_plane *)plane;
struct nouveau_framebuffer *nv_fb = nouveau_framebuffer(fb); struct nouveau_framebuffer *nv_fb = nouveau_framebuffer(fb);
struct nouveau_bo *cur = nv_plane->cur; struct nouveau_bo *cur = nv_plane->cur;
@ -422,7 +422,7 @@ nv04_update_plane(struct drm_plane *plane, struct drm_crtc *crtc,
static int static int
nv04_disable_plane(struct drm_plane *plane) nv04_disable_plane(struct drm_plane *plane)
{ {
struct nouveau_object *dev = nouveau_drm(plane->dev)->device; struct nvif_device *dev = &nouveau_drm(plane->dev)->device;
struct nouveau_plane *nv_plane = (struct nouveau_plane *)plane; struct nouveau_plane *nv_plane = (struct nouveau_plane *)plane;
nvif_mask(dev, NV_PVIDEO_OVERLAY, 1, 0); nvif_mask(dev, NV_PVIDEO_OVERLAY, 1, 0);
@ -489,9 +489,9 @@ err:
void void
nouveau_overlay_init(struct drm_device *device) nouveau_overlay_init(struct drm_device *device)
{ {
struct nouveau_object *dev = nouveau_drm(device)->device; struct nvif_device *dev = &nouveau_drm(device)->device;
if (nv_device(dev)->chipset < 0x10) if (dev->info.chipset < 0x10)
nv04_overlay_init(device); nv04_overlay_init(device);
else if (nv_device(dev)->chipset <= 0x40) else if (dev->info.chipset <= 0x40)
nv10_overlay_init(device); nv10_overlay_init(device);
} }

4
drivers/gpu/drm/nouveau/dispnv04/tvnv04.c
View File

@ -56,7 +56,7 @@ static struct nouveau_i2c_board_info nv04_tv_encoder_info[] = {
int nv04_tv_identify(struct drm_device *dev, int i2c_index) int nv04_tv_identify(struct drm_device *dev, int i2c_index)
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_i2c *i2c = nouveau_i2c(drm->device); struct nouveau_i2c *i2c = nvkm_i2c(&drm->device);
return i2c->identify(i2c, i2c_index, "TV encoder", return i2c->identify(i2c, i2c_index, "TV encoder",
nv04_tv_encoder_info, NULL, NULL); nv04_tv_encoder_info, NULL, NULL);
@ -206,7 +206,7 @@ nv04_tv_create(struct drm_connector *connector, struct dcb_output *entry)
struct drm_encoder *encoder; struct drm_encoder *encoder;
struct drm_device *dev = connector->dev; struct drm_device *dev = connector->dev;
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_i2c *i2c = nouveau_i2c(drm->device); struct nouveau_i2c *i2c = nvkm_i2c(&drm->device);
struct nouveau_i2c_port *port = i2c->find(i2c, entry->i2c_index); struct nouveau_i2c_port *port = i2c->find(i2c, entry->i2c_index);
int type, ret; int type, ret;

22
drivers/gpu/drm/nouveau/dispnv04/tvnv17.c
View File

@ -51,7 +51,7 @@ static uint32_t nv42_tv_sample_load(struct drm_encoder *encoder)
{ {
struct drm_device *dev = encoder->dev; struct drm_device *dev = encoder->dev;
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_gpio *gpio = nouveau_gpio(drm->device); struct nouveau_gpio *gpio = nvkm_gpio(&drm->device);
uint32_t testval, regoffset = nv04_dac_output_offset(encoder); uint32_t testval, regoffset = nv04_dac_output_offset(encoder);
uint32_t gpio0, gpio1, fp_htotal, fp_hsync_start, fp_hsync_end, uint32_t gpio0, gpio1, fp_htotal, fp_hsync_start, fp_hsync_end,
fp_control, test_ctrl, dacclk, ctv_14, ctv_1c, ctv_6c; fp_control, test_ctrl, dacclk, ctv_14, ctv_1c, ctv_6c;
@ -135,17 +135,17 @@ static bool
get_tv_detect_quirks(struct drm_device *dev, uint32_t *pin_mask) get_tv_detect_quirks(struct drm_device *dev, uint32_t *pin_mask)
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_object *device = drm->device; struct nvif_device *device = &drm->device;
/* Zotac FX5200 */ /* Zotac FX5200 */
if (nv_device_match(device, 0x0322, 0x19da, 0x1035) || if (nv_device_match(nvkm_object(device), 0x0322, 0x19da, 0x1035) ||
nv_device_match(device, 0x0322, 0x19da, 0x2035)) { nv_device_match(nvkm_object(device), 0x0322, 0x19da, 0x2035)) {
*pin_mask = 0xc; *pin_mask = 0xc;
return false; return false;
} }
/* MSI nForce2 IGP */ /* MSI nForce2 IGP */
if (nv_device_match(device, 0x01f0, 0x1462, 0x5710)) { if (nv_device_match(nvkm_object(device), 0x01f0, 0x1462, 0x5710)) {
*pin_mask = 0xc; *pin_mask = 0xc;
return false; return false;
} }
@ -167,8 +167,8 @@ nv17_tv_detect(struct drm_encoder *encoder, struct drm_connector *connector)
return connector_status_disconnected; return connector_status_disconnected;
if (reliable) { if (reliable) {
if (nv_device(drm->device)->chipset == 0x42 || if (drm->device.info.chipset == 0x42 ||
nv_device(drm->device)->chipset == 0x43) drm->device.info.chipset == 0x43)
tv_enc->pin_mask = tv_enc->pin_mask =
nv42_tv_sample_load(encoder) >> 28 & 0xe; nv42_tv_sample_load(encoder) >> 28 & 0xe;
else else
@ -375,7 +375,7 @@ static void nv17_tv_dpms(struct drm_encoder *encoder, int mode)
{ {
struct drm_device *dev = encoder->dev; struct drm_device *dev = encoder->dev;
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_gpio *gpio = nouveau_gpio(drm->device); struct nouveau_gpio *gpio = nvkm_gpio(&drm->device);
struct nv17_tv_state *regs = &to_tv_enc(encoder)->state; struct nv17_tv_state *regs = &to_tv_enc(encoder)->state;
struct nv17_tv_norm_params *tv_norm = get_tv_norm(encoder); struct nv17_tv_norm_params *tv_norm = get_tv_norm(encoder);
@ -448,7 +448,7 @@ static void nv17_tv_prepare(struct drm_encoder *encoder)
/* Set the DACCLK register */ /* Set the DACCLK register */
dacclk = (NVReadRAMDAC(dev, 0, dacclk_off) & ~0x30) | 0x1; dacclk = (NVReadRAMDAC(dev, 0, dacclk_off) & ~0x30) | 0x1;
if (nv_device(drm->device)->card_type == NV_40) if (drm->device.info.family == NV_DEVICE_INFO_V0_CURIE)
dacclk |= 0x1a << 16; dacclk |= 0x1a << 16;
if (tv_norm->kind == CTV_ENC_MODE) { if (tv_norm->kind == CTV_ENC_MODE) {
@ -505,7 +505,7 @@ static void nv17_tv_mode_set(struct drm_encoder *encoder,
tv_regs->ptv_614 = 0x13; tv_regs->ptv_614 = 0x13;
} }
if (nv_device(drm->device)->card_type >= NV_30) { if (drm->device.info.family >= NV_DEVICE_INFO_V0_RANKINE) {
tv_regs->ptv_500 = 0xe8e0; tv_regs->ptv_500 = 0xe8e0;
tv_regs->ptv_504 = 0x1710; tv_regs->ptv_504 = 0x1710;
tv_regs->ptv_604 = 0x0; tv_regs->ptv_604 = 0x0;
@ -600,7 +600,7 @@ static void nv17_tv_commit(struct drm_encoder *encoder)
nv17_tv_state_load(dev, &to_tv_enc(encoder)->state); nv17_tv_state_load(dev, &to_tv_enc(encoder)->state);
/* This could use refinement for flatpanels, but it should work */ /* This could use refinement for flatpanels, but it should work */
if (nv_device(drm->device)->chipset < 0x44) if (drm->device.info.chipset < 0x44)
NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL +
nv04_dac_output_offset(encoder), nv04_dac_output_offset(encoder),
0xf0000000); 0xf0000000);

4
drivers/gpu/drm/nouveau/dispnv04/tvnv17.h
View File

@ -130,13 +130,13 @@ void nv17_ctv_update_rescaler(struct drm_encoder *encoder);
static inline void nv_write_ptv(struct drm_device *dev, uint32_t reg, static inline void nv_write_ptv(struct drm_device *dev, uint32_t reg,
uint32_t val) uint32_t val)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
nvif_wr32(device, reg, val); nvif_wr32(device, reg, val);
} }
static inline uint32_t nv_read_ptv(struct drm_device *dev, uint32_t reg) static inline uint32_t nv_read_ptv(struct drm_device *dev, uint32_t reg)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
return nvif_rd32(device, reg); return nvif_rd32(device, reg);
} }

65
drivers/gpu/drm/nouveau/nouveau_abi16.c
View File

@ -38,10 +38,13 @@
#include "nouveau_chan.h" #include "nouveau_chan.h"
#include "nouveau_abi16.h" #include "nouveau_abi16.h"
void nouveau_drm_hack_device(struct nouveau_drm *, struct nvif_device *);
struct nouveau_abi16 * struct nouveau_abi16 *
nouveau_abi16_get(struct drm_file *file_priv, struct drm_device *dev) nouveau_abi16_get(struct drm_file *file_priv, struct drm_device *dev)
{ {
struct nouveau_cli *cli = nouveau_cli(file_priv); struct nouveau_cli *cli = nouveau_cli(file_priv);
struct nouveau_drm *drm = nouveau_drm(dev);
mutex_lock(&cli->mutex); mutex_lock(&cli->mutex);
if (!cli->abi16) { if (!cli->abi16) {
struct nouveau_abi16 *abi16; struct nouveau_abi16 *abi16;
@ -60,8 +63,11 @@ nouveau_abi16_get(struct drm_file *file_priv, struct drm_device *dev)
.device = ~0ULL, .device = ~0ULL,
}, },
sizeof(struct nv_device_class), sizeof(struct nv_device_class),
&abi16->device) == 0) (struct nouveau_object **)
&abi16->device.object) == 0) {
nouveau_drm_hack_device(drm, &abi16->device);
return cli->abi16; return cli->abi16;
}
kfree(cli->abi16); kfree(cli->abi16);
cli->abi16 = NULL; cli->abi16 = NULL;
@ -83,20 +89,19 @@ nouveau_abi16_put(struct nouveau_abi16 *abi16, int ret)
u16 u16
nouveau_abi16_swclass(struct nouveau_drm *drm) nouveau_abi16_swclass(struct nouveau_drm *drm)
{ {
switch (nv_device(drm->device)->card_type) { switch (drm->device.info.family) {
case NV_04: case NV_DEVICE_INFO_V0_TNT:
return 0x006e; return 0x006e;
case NV_10: case NV_DEVICE_INFO_V0_CELSIUS:
case NV_11: case NV_DEVICE_INFO_V0_KELVIN:
case NV_20: case NV_DEVICE_INFO_V0_RANKINE:
case NV_30: case NV_DEVICE_INFO_V0_CURIE:
case NV_40:
return 0x016e; return 0x016e;
case NV_50: case NV_DEVICE_INFO_V0_TESLA:
return 0x506e; return 0x506e;
case NV_C0: case NV_DEVICE_INFO_V0_FERMI:
case NV_E0: case NV_DEVICE_INFO_V0_KEPLER:
case GM100: case NV_DEVICE_INFO_V0_MAXWELL:
return 0x906e; return 0x906e;
} }
@ -170,29 +175,29 @@ nouveau_abi16_ioctl_getparam(ABI16_IOCTL_ARGS)
{ {
struct nouveau_cli *cli = nouveau_cli(file_priv); struct nouveau_cli *cli = nouveau_cli(file_priv);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_device *device = nv_device(drm->device); struct nvif_device *device = &drm->device;
struct nouveau_timer *ptimer = nouveau_timer(device); struct nouveau_timer *ptimer = nvkm_timer(device);
struct nouveau_graph *graph = (void *)nouveau_engine(device, NVDEV_ENGINE_GR); struct nouveau_graph *graph = nvkm_gr(device);
struct drm_nouveau_getparam *getparam = data; struct drm_nouveau_getparam *getparam = data;
switch (getparam->param) { switch (getparam->param) {
case NOUVEAU_GETPARAM_CHIPSET_ID: case NOUVEAU_GETPARAM_CHIPSET_ID:
getparam->value = device->chipset; getparam->value = device->info.chipset;
break; break;
case NOUVEAU_GETPARAM_PCI_VENDOR: case NOUVEAU_GETPARAM_PCI_VENDOR:
if (nv_device_is_pci(device)) if (nv_device_is_pci(nvkm_device(device)))
getparam->value = dev->pdev->vendor; getparam->value = dev->pdev->vendor;
else else
getparam->value = 0; getparam->value = 0;
break; break;
case NOUVEAU_GETPARAM_PCI_DEVICE: case NOUVEAU_GETPARAM_PCI_DEVICE:
if (nv_device_is_pci(device)) if (nv_device_is_pci(nvkm_device(device)))
getparam->value = dev->pdev->device; getparam->value = dev->pdev->device;
else else
getparam->value = 0; getparam->value = 0;
break; break;
case NOUVEAU_GETPARAM_BUS_TYPE: case NOUVEAU_GETPARAM_BUS_TYPE:
if (!nv_device_is_pci(device)) if (!nv_device_is_pci(nvkm_device(device)))
getparam->value = 3; getparam->value = 3;
else else
if (drm_pci_device_is_agp(dev)) if (drm_pci_device_is_agp(dev))
@ -247,7 +252,7 @@ nouveau_abi16_ioctl_channel_alloc(ABI16_IOCTL_ARGS)
struct nouveau_abi16 *abi16 = nouveau_abi16_get(file_priv, dev); struct nouveau_abi16 *abi16 = nouveau_abi16_get(file_priv, dev);
struct nouveau_abi16_chan *chan; struct nouveau_abi16_chan *chan;
struct nouveau_client *client; struct nouveau_client *client;
struct nouveau_device *device; struct nvif_device *device;
struct nouveau_instmem *imem; struct nouveau_instmem *imem;
struct nouveau_fb *pfb; struct nouveau_fb *pfb;
int ret; int ret;
@ -259,12 +264,12 @@ nouveau_abi16_ioctl_channel_alloc(ABI16_IOCTL_ARGS)
return nouveau_abi16_put(abi16, -ENODEV); return nouveau_abi16_put(abi16, -ENODEV);
client = nv_client(abi16->client); client = nv_client(abi16->client);
device = nv_device(abi16->device); device = &abi16->device;
imem = nouveau_instmem(device); imem = nvkm_instmem(device);
pfb = nouveau_fb(device); pfb = nvkm_fb(device);
/* hack to allow channel engine type specification on kepler */ /* hack to allow channel engine type specification on kepler */
if (device->card_type >= NV_E0) { if (device->info.family >= NV_DEVICE_INFO_V0_KEPLER) {
if (init->fb_ctxdma_handle != ~0) if (init->fb_ctxdma_handle != ~0)
init->fb_ctxdma_handle = NVE0_CHANNEL_IND_ENGINE_GR; init->fb_ctxdma_handle = NVE0_CHANNEL_IND_ENGINE_GR;
else else
@ -299,7 +304,7 @@ nouveau_abi16_ioctl_channel_alloc(ABI16_IOCTL_ARGS)
if (ret) if (ret)
goto done; goto done;
if (device->card_type >= NV_50) if (device->info.family >= NV_DEVICE_INFO_V0_TESLA)
init->pushbuf_domains = NOUVEAU_GEM_DOMAIN_VRAM | init->pushbuf_domains = NOUVEAU_GEM_DOMAIN_VRAM |
NOUVEAU_GEM_DOMAIN_GART; NOUVEAU_GEM_DOMAIN_GART;
else else
@ -308,7 +313,7 @@ nouveau_abi16_ioctl_channel_alloc(ABI16_IOCTL_ARGS)
else else
init->pushbuf_domains = NOUVEAU_GEM_DOMAIN_GART; init->pushbuf_domains = NOUVEAU_GEM_DOMAIN_GART;
if (device->card_type < NV_10) { if (device->info.family < NV_DEVICE_INFO_V0_CELSIUS) {
init->subchan[0].handle = 0x00000000; init->subchan[0].handle = 0x00000000;
init->subchan[0].grclass = 0x0000; init->subchan[0].grclass = 0x0000;
init->subchan[1].handle = NvSw; init->subchan[1].handle = NvSw;
@ -324,7 +329,7 @@ nouveau_abi16_ioctl_channel_alloc(ABI16_IOCTL_ARGS)
if (ret) if (ret)
goto done; goto done;
if (device->card_type >= NV_50) { if (device->info.family >= NV_DEVICE_INFO_V0_TESLA) {
ret = nouveau_bo_vma_add(chan->ntfy, client->vm, ret = nouveau_bo_vma_add(chan->ntfy, client->vm,
&chan->ntfy_vma); &chan->ntfy_vma);
if (ret) if (ret)
@ -397,10 +402,10 @@ nouveau_abi16_ioctl_notifierobj_alloc(ABI16_IOCTL_ARGS)
{ {
struct drm_nouveau_notifierobj_alloc *info = data; struct drm_nouveau_notifierobj_alloc *info = data;
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_device *device = nv_device(drm->device);
struct nouveau_abi16 *abi16 = nouveau_abi16_get(file_priv, dev); struct nouveau_abi16 *abi16 = nouveau_abi16_get(file_priv, dev);
struct nouveau_abi16_chan *chan = NULL, *temp; struct nouveau_abi16_chan *chan = NULL, *temp;
struct nouveau_abi16_ntfy *ntfy; struct nouveau_abi16_ntfy *ntfy;
struct nvif_device *device = &abi16->device;
struct nouveau_object *object; struct nouveau_object *object;
struct nv_dma_class args = {}; struct nv_dma_class args = {};
int ret; int ret;
@ -409,7 +414,7 @@ nouveau_abi16_ioctl_notifierobj_alloc(ABI16_IOCTL_ARGS)
return -ENOMEM; return -ENOMEM;
/* completely unnecessary for these chipsets... */ /* completely unnecessary for these chipsets... */
if (unlikely(nv_device(abi16->device)->card_type >= NV_C0)) if (unlikely(device->info.family >= NV_DEVICE_INFO_V0_FERMI))
return nouveau_abi16_put(abi16, -EINVAL); return nouveau_abi16_put(abi16, -EINVAL);
list_for_each_entry(temp, &abi16->channels, head) { list_for_each_entry(temp, &abi16->channels, head) {
@ -436,7 +441,7 @@ nouveau_abi16_ioctl_notifierobj_alloc(ABI16_IOCTL_ARGS)
args.start = ntfy->node->offset; args.start = ntfy->node->offset;
args.limit = ntfy->node->offset + ntfy->node->length - 1; args.limit = ntfy->node->offset + ntfy->node->length - 1;
if (device->card_type >= NV_50) { if (device->info.family >= NV_DEVICE_INFO_V0_TESLA) {
args.flags = NV_DMA_TARGET_VM | NV_DMA_ACCESS_VM; args.flags = NV_DMA_TARGET_VM | NV_DMA_ACCESS_VM;
args.start += chan->ntfy_vma.offset; args.start += chan->ntfy_vma.offset;
args.limit += chan->ntfy_vma.offset; args.limit += chan->ntfy_vma.offset;

2
drivers/gpu/drm/nouveau/nouveau_abi16.h
View File

@ -29,7 +29,7 @@ struct nouveau_abi16_chan {
struct nouveau_abi16 { struct nouveau_abi16 {
struct nouveau_object *client; struct nouveau_object *client;
struct nouveau_object *device; struct nvif_device device;
struct list_head channels; struct list_head channels;
u64 handles; u64 handles;
}; };

10
drivers/gpu/drm/nouveau/nouveau_agp.c
View File

@ -29,7 +29,7 @@ static struct nouveau_agpmode_quirk nouveau_agpmode_quirk_list[] = {
static unsigned long static unsigned long
get_agp_mode(struct nouveau_drm *drm, const struct drm_agp_info *info) get_agp_mode(struct nouveau_drm *drm, const struct drm_agp_info *info)
{ {
struct nouveau_device *device = nv_device(drm->device); struct nvif_device *device = &drm->device;
struct nouveau_agpmode_quirk *quirk = nouveau_agpmode_quirk_list; struct nouveau_agpmode_quirk *quirk = nouveau_agpmode_quirk_list;
int agpmode = nouveau_agpmode; int agpmode = nouveau_agpmode;
unsigned long mode = info->mode; unsigned long mode = info->mode;
@ -38,7 +38,7 @@ get_agp_mode(struct nouveau_drm *drm, const struct drm_agp_info *info)
* FW seems to be broken on nv18, it makes the card lock up * FW seems to be broken on nv18, it makes the card lock up
* randomly. * randomly.
*/ */
if (device->chipset == 0x18) if (device->info.chipset == 0x18)
mode &= ~PCI_AGP_COMMAND_FW; mode &= ~PCI_AGP_COMMAND_FW;
/* /*
@ -47,8 +47,8 @@ get_agp_mode(struct nouveau_drm *drm, const struct drm_agp_info *info)
while (agpmode == -1 && quirk->hostbridge_vendor) { while (agpmode == -1 && quirk->hostbridge_vendor) {
if (info->id_vendor == quirk->hostbridge_vendor && if (info->id_vendor == quirk->hostbridge_vendor &&
info->id_device == quirk->hostbridge_device && info->id_device == quirk->hostbridge_device &&
device->pdev->vendor == quirk->chip_vendor && nvkm_device(device)->pdev->vendor == quirk->chip_vendor &&
device->pdev->device == quirk->chip_device) { nvkm_device(device)->pdev->device == quirk->chip_device) {
agpmode = quirk->mode; agpmode = quirk->mode;
NV_INFO(drm, "Forcing agp mode to %dX. Use agpmode to override.\n", NV_INFO(drm, "Forcing agp mode to %dX. Use agpmode to override.\n",
agpmode); agpmode);
@ -104,7 +104,7 @@ void
nouveau_agp_reset(struct nouveau_drm *drm) nouveau_agp_reset(struct nouveau_drm *drm)
{ {
#if __OS_HAS_AGP #if __OS_HAS_AGP
struct nouveau_object *device = drm->device; struct nvif_device *device = &drm->device;
struct drm_device *dev = drm->dev; struct drm_device *dev = drm->dev;
u32 save[2]; u32 save[2];
int ret; int ret;

34
drivers/gpu/drm/nouveau/nouveau_backlight.c
View File

@ -40,7 +40,7 @@ static int
nv40_get_intensity(struct backlight_device *bd) nv40_get_intensity(struct backlight_device *bd)
{ {
struct nouveau_drm *drm = bl_get_data(bd); struct nouveau_drm *drm = bl_get_data(bd);
struct nouveau_object *device = drm->device; struct nvif_device *device = &drm->device;
int val = (nvif_rd32(device, NV40_PMC_BACKLIGHT) & int val = (nvif_rd32(device, NV40_PMC_BACKLIGHT) &
NV40_PMC_BACKLIGHT_MASK) >> 16; NV40_PMC_BACKLIGHT_MASK) >> 16;
@ -51,7 +51,7 @@ static int
nv40_set_intensity(struct backlight_device *bd) nv40_set_intensity(struct backlight_device *bd)
{ {
struct nouveau_drm *drm = bl_get_data(bd); struct nouveau_drm *drm = bl_get_data(bd);
struct nouveau_object *device = drm->device; struct nvif_device *device = &drm->device;
int val = bd->props.brightness; int val = bd->props.brightness;
int reg = nvif_rd32(device, NV40_PMC_BACKLIGHT); int reg = nvif_rd32(device, NV40_PMC_BACKLIGHT);
@ -71,7 +71,7 @@ static int
nv40_backlight_init(struct drm_connector *connector) nv40_backlight_init(struct drm_connector *connector)
{ {
struct nouveau_drm *drm = nouveau_drm(connector->dev); struct nouveau_drm *drm = nouveau_drm(connector->dev);
struct nouveau_object *device = drm->device; struct nvif_device *device = &drm->device;
struct backlight_properties props; struct backlight_properties props;
struct backlight_device *bd; struct backlight_device *bd;
@ -97,7 +97,7 @@ nv50_get_intensity(struct backlight_device *bd)
{ {
struct nouveau_encoder *nv_encoder = bl_get_data(bd); struct nouveau_encoder *nv_encoder = bl_get_data(bd);
struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev); struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
struct nouveau_object *device = drm->device; struct nvif_device *device = &drm->device;
int or = nv_encoder->or; int or = nv_encoder->or;
u32 div = 1025; u32 div = 1025;
u32 val; u32 val;
@ -112,7 +112,7 @@ nv50_set_intensity(struct backlight_device *bd)
{ {
struct nouveau_encoder *nv_encoder = bl_get_data(bd); struct nouveau_encoder *nv_encoder = bl_get_data(bd);
struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev); struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
struct nouveau_object *device = drm->device; struct nvif_device *device = &drm->device;
int or = nv_encoder->or; int or = nv_encoder->or;
u32 div = 1025; u32 div = 1025;
u32 val = (bd->props.brightness * div) / 100; u32 val = (bd->props.brightness * div) / 100;
@ -133,7 +133,7 @@ nva3_get_intensity(struct backlight_device *bd)
{ {
struct nouveau_encoder *nv_encoder = bl_get_data(bd); struct nouveau_encoder *nv_encoder = bl_get_data(bd);
struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev); struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
struct nouveau_object *device = drm->device; struct nvif_device *device = &drm->device;
int or = nv_encoder->or; int or = nv_encoder->or;
u32 div, val; u32 div, val;
@ -151,7 +151,7 @@ nva3_set_intensity(struct backlight_device *bd)
{ {
struct nouveau_encoder *nv_encoder = bl_get_data(bd); struct nouveau_encoder *nv_encoder = bl_get_data(bd);
struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev); struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
struct nouveau_object *device = drm->device; struct nvif_device *device = &drm->device;
int or = nv_encoder->or; int or = nv_encoder->or;
u32 div, val; u32 div, val;
@ -177,7 +177,7 @@ static int
nv50_backlight_init(struct drm_connector *connector) nv50_backlight_init(struct drm_connector *connector)
{ {
struct nouveau_drm *drm = nouveau_drm(connector->dev); struct nouveau_drm *drm = nouveau_drm(connector->dev);
struct nouveau_object *device = drm->device; struct nvif_device *device = &drm->device;
struct nouveau_encoder *nv_encoder; struct nouveau_encoder *nv_encoder;
struct backlight_properties props; struct backlight_properties props;
struct backlight_device *bd; struct backlight_device *bd;
@ -193,9 +193,9 @@ nv50_backlight_init(struct drm_connector *connector)
if (!nvif_rd32(device, NV50_PDISP_SOR_PWM_CTL(nv_encoder->or))) if (!nvif_rd32(device, NV50_PDISP_SOR_PWM_CTL(nv_encoder->or)))
return 0; return 0;
if (nv_device(device)->chipset <= 0xa0 || if (device->info.chipset <= 0xa0 ||
nv_device(device)->chipset == 0xaa || device->info.chipset == 0xaa ||
nv_device(device)->chipset == 0xac) device->info.chipset == 0xac)
ops = &nv50_bl_ops; ops = &nv50_bl_ops;
else else
ops = &nva3_bl_ops; ops = &nva3_bl_ops;
@ -218,7 +218,7 @@ int
nouveau_backlight_init(struct drm_device *dev) nouveau_backlight_init(struct drm_device *dev)
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_object *device = drm->device; struct nvif_device *device = &drm->device;
struct drm_connector *connector; struct drm_connector *connector;
list_for_each_entry(connector, &dev->mode_config.connector_list, head) { list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
@ -226,12 +226,12 @@ nouveau_backlight_init(struct drm_device *dev)
connector->connector_type != DRM_MODE_CONNECTOR_eDP) connector->connector_type != DRM_MODE_CONNECTOR_eDP)
continue; continue;
switch (nv_device(device)->card_type) { switch (device->info.family) {
case NV_40: case NV_DEVICE_INFO_V0_CURIE:
return nv40_backlight_init(connector); return nv40_backlight_init(connector);
case NV_50: case NV_DEVICE_INFO_V0_TESLA:
case NV_C0: case NV_DEVICE_INFO_V0_FERMI:
case NV_E0: case NV_DEVICE_INFO_V0_KEPLER:
return nv50_backlight_init(connector); return nv50_backlight_init(connector);
default: default:
break; break;

16
drivers/gpu/drm/nouveau/nouveau_bios.c
View File

@ -217,7 +217,7 @@ int call_lvds_script(struct drm_device *dev, struct dcb_output *dcbent, int head
*/ */
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_object *device = drm->device; struct nvif_device *device = &drm->device;
struct nvbios *bios = &drm->vbios; struct nvbios *bios = &drm->vbios;
uint8_t lvds_ver = bios->data[bios->fp.lvdsmanufacturerpointer]; uint8_t lvds_ver = bios->data[bios->fp.lvdsmanufacturerpointer];
uint32_t sel_clk_binding, sel_clk; uint32_t sel_clk_binding, sel_clk;
@ -320,7 +320,7 @@ static int parse_lvds_manufacturer_table_header(struct drm_device *dev, struct n
static int static int
get_fp_strap(struct drm_device *dev, struct nvbios *bios) get_fp_strap(struct drm_device *dev, struct nvbios *bios)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
/* /*
* The fp strap is normally dictated by the "User Strap" in * The fp strap is normally dictated by the "User Strap" in
@ -334,7 +334,7 @@ get_fp_strap(struct drm_device *dev, struct nvbios *bios)
if (bios->major_version < 5 && bios->data[0x48] & 0x4) if (bios->major_version < 5 && bios->data[0x48] & 0x4)
return NVReadVgaCrtc5758(dev, 0, 0xf) & 0xf; return NVReadVgaCrtc5758(dev, 0, 0xf) & 0xf;
if (nv_device(device)->card_type >= NV_50) if (device->info.family >= NV_DEVICE_INFO_V0_TESLA)
return (nvif_rd32(device, NV_PEXTDEV_BOOT_0) >> 24) & 0xf; return (nvif_rd32(device, NV_PEXTDEV_BOOT_0) >> 24) & 0xf;
else else
return (nvif_rd32(device, NV_PEXTDEV_BOOT_0) >> 16) & 0xf; return (nvif_rd32(device, NV_PEXTDEV_BOOT_0) >> 16) & 0xf;
@ -636,7 +636,7 @@ int run_tmds_table(struct drm_device *dev, struct dcb_output *dcbent, int head,
*/ */
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_object *device = drm->device; struct nvif_device *device = &drm->device;
struct nvbios *bios = &drm->vbios; struct nvbios *bios = &drm->vbios;
int cv = bios->chip_version; int cv = bios->chip_version;
uint16_t clktable = 0, scriptptr; uint16_t clktable = 0, scriptptr;
@ -1253,7 +1253,7 @@ olddcb_table(struct drm_device *dev)
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
u8 *dcb = NULL; u8 *dcb = NULL;
if (nv_device(drm->device)->card_type > NV_04) if (drm->device.info.family > NV_DEVICE_INFO_V0_TNT)
dcb = ROMPTR(dev, drm->vbios.data[0x36]); dcb = ROMPTR(dev, drm->vbios.data[0x36]);
if (!dcb) { if (!dcb) {
NV_WARN(drm, "No DCB data found in VBIOS\n"); NV_WARN(drm, "No DCB data found in VBIOS\n");
@ -1908,7 +1908,7 @@ static int load_nv17_hwsq_ucode_entry(struct drm_device *dev, struct nvbios *bio
*/ */
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_object *device = drm->device; struct nvif_device *device = &drm->device;
uint8_t bytes_to_write; uint8_t bytes_to_write;
uint16_t hwsq_entry_offset; uint16_t hwsq_entry_offset;
int i; int i;
@ -2002,7 +2002,7 @@ uint8_t *nouveau_bios_embedded_edid(struct drm_device *dev)
static bool NVInitVBIOS(struct drm_device *dev) static bool NVInitVBIOS(struct drm_device *dev)
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_bios *bios = nouveau_bios(drm->device); struct nouveau_bios *bios = nvkm_bios(&drm->device);
struct nvbios *legacy = &drm->vbios; struct nvbios *legacy = &drm->vbios;
memset(legacy, 0, sizeof(struct nvbios)); memset(legacy, 0, sizeof(struct nvbios));
@ -2054,7 +2054,7 @@ nouveau_bios_posted(struct drm_device *dev)
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
unsigned htotal; unsigned htotal;
if (nv_device(drm->device)->card_type >= NV_50) if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA)
return true; return true;
htotal = NVReadVgaCrtc(dev, 0, 0x06); htotal = NVReadVgaCrtc(dev, 0, 0x06);

57
drivers/gpu/drm/nouveau/nouveau_bo.c
View File

@ -52,7 +52,7 @@ nv10_bo_update_tile_region(struct drm_device *dev, struct nouveau_drm_tile *reg,
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
int i = reg - drm->tile.reg; int i = reg - drm->tile.reg;
struct nouveau_fb *pfb = nouveau_fb(drm->device); struct nouveau_fb *pfb = nvkm_fb(&drm->device);
struct nouveau_fb_tile *tile = &pfb->tile.region[i]; struct nouveau_fb_tile *tile = &pfb->tile.region[i];
struct nouveau_engine *engine; struct nouveau_engine *engine;
@ -109,7 +109,7 @@ nv10_bo_set_tiling(struct drm_device *dev, u32 addr,
u32 size, u32 pitch, u32 flags) u32 size, u32 pitch, u32 flags)
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_fb *pfb = nouveau_fb(drm->device); struct nouveau_fb *pfb = nvkm_fb(&drm->device);
struct nouveau_drm_tile *tile, *found = NULL; struct nouveau_drm_tile *tile, *found = NULL;
int i; int i;
@ -153,23 +153,23 @@ nouveau_bo_fixup_align(struct nouveau_bo *nvbo, u32 flags,
int *align, int *size) int *align, int *size)
{ {
struct nouveau_drm *drm = nouveau_bdev(nvbo->bo.bdev); struct nouveau_drm *drm = nouveau_bdev(nvbo->bo.bdev);
struct nouveau_device *device = nv_device(drm->device); struct nvif_device *device = &drm->device;
if (device->card_type < NV_50) { if (device->info.family < NV_DEVICE_INFO_V0_TESLA) {
if (nvbo->tile_mode) { if (nvbo->tile_mode) {
if (device->chipset >= 0x40) { if (device->info.chipset >= 0x40) {
*align = 65536; *align = 65536;
*size = roundup(*size, 64 * nvbo->tile_mode); *size = roundup(*size, 64 * nvbo->tile_mode);
} else if (device->chipset >= 0x30) { } else if (device->info.chipset >= 0x30) {
*align = 32768; *align = 32768;
*size = roundup(*size, 64 * nvbo->tile_mode); *size = roundup(*size, 64 * nvbo->tile_mode);
} else if (device->chipset >= 0x20) { } else if (device->info.chipset >= 0x20) {
*align = 16384; *align = 16384;
*size = roundup(*size, 64 * nvbo->tile_mode); *size = roundup(*size, 64 * nvbo->tile_mode);
} else if (device->chipset >= 0x10) { } else if (device->info.chipset >= 0x10) {
*align = 16384; *align = 16384;
*size = roundup(*size, 32 * nvbo->tile_mode); *size = roundup(*size, 32 * nvbo->tile_mode);
} }
@ -261,11 +261,10 @@ static void
set_placement_range(struct nouveau_bo *nvbo, uint32_t type) set_placement_range(struct nouveau_bo *nvbo, uint32_t type)
{ {
struct nouveau_drm *drm = nouveau_bdev(nvbo->bo.bdev); struct nouveau_drm *drm = nouveau_bdev(nvbo->bo.bdev);
struct nouveau_fb *pfb = nouveau_fb(drm->device); struct nouveau_fb *pfb = nvkm_fb(&drm->device);
u32 vram_pages = pfb->ram->size >> PAGE_SHIFT; u32 vram_pages = pfb->ram->size >> PAGE_SHIFT;
if ((nv_device(drm->device)->card_type == NV_10 || if (drm->device.info.family == NV_DEVICE_INFO_V0_CELSIUS &&
nv_device(drm->device)->card_type == NV_11) &&
nvbo->tile_mode && (type & TTM_PL_FLAG_VRAM) && nvbo->tile_mode && (type & TTM_PL_FLAG_VRAM) &&
nvbo->bo.mem.num_pages < vram_pages / 4) { nvbo->bo.mem.num_pages < vram_pages / 4) {
/* /*
@ -506,9 +505,9 @@ nouveau_bo_init_mem_type(struct ttm_bo_device *bdev, uint32_t type,
TTM_PL_FLAG_WC; TTM_PL_FLAG_WC;
man->default_caching = TTM_PL_FLAG_WC; man->default_caching = TTM_PL_FLAG_WC;
if (nv_device(drm->device)->card_type >= NV_50) { if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA) {
/* Some BARs do not support being ioremapped WC */ /* Some BARs do not support being ioremapped WC */
if (nouveau_bar(drm->device)->iomap_uncached) { if (nvkm_bar(&drm->device)->iomap_uncached) {
man->available_caching = TTM_PL_FLAG_UNCACHED; man->available_caching = TTM_PL_FLAG_UNCACHED;
man->default_caching = TTM_PL_FLAG_UNCACHED; man->default_caching = TTM_PL_FLAG_UNCACHED;
} }
@ -521,7 +520,7 @@ nouveau_bo_init_mem_type(struct ttm_bo_device *bdev, uint32_t type,
} }
break; break;
case TTM_PL_TT: case TTM_PL_TT:
if (nv_device(drm->device)->card_type >= NV_50) if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA)
man->func = &nouveau_gart_manager; man->func = &nouveau_gart_manager;
else else
if (drm->agp.stat != ENABLED) if (drm->agp.stat != ENABLED)
@ -959,7 +958,7 @@ nouveau_bo_move_m2mf(struct ttm_buffer_object *bo, int evict, bool intr,
* old nouveau_mem node, these will get cleaned up after ttm has * old nouveau_mem node, these will get cleaned up after ttm has
* destroyed the ttm_mem_reg * destroyed the ttm_mem_reg
*/ */
if (nv_device(drm->device)->card_type >= NV_50) { if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA) {
ret = nouveau_bo_move_prep(drm, bo, new_mem); ret = nouveau_bo_move_prep(drm, bo, new_mem);
if (ret) if (ret)
return ret; return ret;
@ -1142,7 +1141,7 @@ nouveau_bo_vm_bind(struct ttm_buffer_object *bo, struct ttm_mem_reg *new_mem,
if (new_mem->mem_type != TTM_PL_VRAM) if (new_mem->mem_type != TTM_PL_VRAM)
return 0; return 0;
if (nv_device(drm->device)->card_type >= NV_10) { if (drm->device.info.family >= NV_DEVICE_INFO_V0_CELSIUS) {
*new_tile = nv10_bo_set_tiling(dev, offset, new_mem->size, *new_tile = nv10_bo_set_tiling(dev, offset, new_mem->size,
nvbo->tile_mode, nvbo->tile_mode,
nvbo->tile_flags); nvbo->tile_flags);
@ -1173,7 +1172,7 @@ nouveau_bo_move(struct ttm_buffer_object *bo, bool evict, bool intr,
struct nouveau_drm_tile *new_tile = NULL; struct nouveau_drm_tile *new_tile = NULL;
int ret = 0; int ret = 0;
if (nv_device(drm->device)->card_type < NV_50) { if (drm->device.info.family < NV_DEVICE_INFO_V0_TESLA) {
ret = nouveau_bo_vm_bind(bo, new_mem, &new_tile); ret = nouveau_bo_vm_bind(bo, new_mem, &new_tile);
if (ret) if (ret)
return ret; return ret;
@ -1210,7 +1209,7 @@ nouveau_bo_move(struct ttm_buffer_object *bo, bool evict, bool intr,
ret = ttm_bo_move_memcpy(bo, evict, no_wait_gpu, new_mem); ret = ttm_bo_move_memcpy(bo, evict, no_wait_gpu, new_mem);
out: out:
if (nv_device(drm->device)->card_type < NV_50) { if (drm->device.info.family < NV_DEVICE_INFO_V0_TESLA) {
if (ret) if (ret)
nouveau_bo_vm_cleanup(bo, NULL, &new_tile); nouveau_bo_vm_cleanup(bo, NULL, &new_tile);
else else
@ -1256,16 +1255,16 @@ nouveau_ttm_io_mem_reserve(struct ttm_bo_device *bdev, struct ttm_mem_reg *mem)
mem->bus.is_iomem = !dev->agp->cant_use_aperture; mem->bus.is_iomem = !dev->agp->cant_use_aperture;
} }
#endif #endif
if (nv_device(drm->device)->card_type < NV_50 || !node->memtype) if (drm->device.info.family < NV_DEVICE_INFO_V0_TESLA || !node->memtype)
/* untiled */ /* untiled */
break; break;
/* fallthrough, tiled memory */ /* fallthrough, tiled memory */
case TTM_PL_VRAM: case TTM_PL_VRAM:
mem->bus.offset = mem->start << PAGE_SHIFT; mem->bus.offset = mem->start << PAGE_SHIFT;
mem->bus.base = nv_device_resource_start(nv_device(drm->device), 1); mem->bus.base = nv_device_resource_start(nvkm_device(&drm->device), 1);
mem->bus.is_iomem = true; mem->bus.is_iomem = true;
if (nv_device(drm->device)->card_type >= NV_50) { if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA) {
struct nouveau_bar *bar = nouveau_bar(drm->device); struct nouveau_bar *bar = nvkm_bar(&drm->device);
ret = bar->umap(bar, node, NV_MEM_ACCESS_RW, ret = bar->umap(bar, node, NV_MEM_ACCESS_RW,
&node->bar_vma); &node->bar_vma);
@ -1285,7 +1284,7 @@ static void
nouveau_ttm_io_mem_free(struct ttm_bo_device *bdev, struct ttm_mem_reg *mem) nouveau_ttm_io_mem_free(struct ttm_bo_device *bdev, struct ttm_mem_reg *mem)
{ {
struct nouveau_drm *drm = nouveau_bdev(bdev); struct nouveau_drm *drm = nouveau_bdev(bdev);
struct nouveau_bar *bar = nouveau_bar(drm->device); struct nouveau_bar *bar = nvkm_bar(&drm->device);
struct nouveau_mem *node = mem->mm_node; struct nouveau_mem *node = mem->mm_node;
if (!node->bar_vma.node) if (!node->bar_vma.node)
@ -1299,15 +1298,15 @@ nouveau_ttm_fault_reserve_notify(struct ttm_buffer_object *bo)
{ {
struct nouveau_drm *drm = nouveau_bdev(bo->bdev); struct nouveau_drm *drm = nouveau_bdev(bo->bdev);
struct nouveau_bo *nvbo = nouveau_bo(bo); struct nouveau_bo *nvbo = nouveau_bo(bo);
struct nouveau_device *device = nv_device(drm->device); struct nvif_device *device = &drm->device;
u32 mappable = nv_device_resource_len(device, 1) >> PAGE_SHIFT; u32 mappable = nv_device_resource_len(nvkm_device(device), 1) >> PAGE_SHIFT;
int ret; int ret;
/* as long as the bo isn't in vram, and isn't tiled, we've got /* as long as the bo isn't in vram, and isn't tiled, we've got
* nothing to do here. * nothing to do here.
*/ */
if (bo->mem.mem_type != TTM_PL_VRAM) { if (bo->mem.mem_type != TTM_PL_VRAM) {
if (nv_device(drm->device)->card_type < NV_50 || if (drm->device.info.family < NV_DEVICE_INFO_V0_TESLA ||
!nouveau_bo_tile_layout(nvbo)) !nouveau_bo_tile_layout(nvbo))
return 0; return 0;
@ -1322,7 +1321,7 @@ nouveau_ttm_fault_reserve_notify(struct ttm_buffer_object *bo)
} }
/* make sure bo is in mappable vram */ /* make sure bo is in mappable vram */
if (nv_device(drm->device)->card_type >= NV_50 || if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA ||
bo->mem.start + bo->mem.num_pages < mappable) bo->mem.start + bo->mem.num_pages < mappable)
return 0; return 0;
@ -1357,7 +1356,7 @@ nouveau_ttm_tt_populate(struct ttm_tt *ttm)
} }
drm = nouveau_bdev(ttm->bdev); drm = nouveau_bdev(ttm->bdev);
device = nv_device(drm->device); device = nvkm_device(&drm->device);
dev = drm->dev; dev = drm->dev;
pdev = nv_device_base(device); pdev = nv_device_base(device);
@ -1414,7 +1413,7 @@ nouveau_ttm_tt_unpopulate(struct ttm_tt *ttm)
return; return;
drm = nouveau_bdev(ttm->bdev); drm = nouveau_bdev(ttm->bdev);
device = nv_device(drm->device); device = nvkm_device(&drm->device);
dev = drm->dev; dev = drm->dev;
pdev = nv_device_base(device); pdev = nv_device_base(device);

32
drivers/gpu/drm/nouveau/nouveau_chan.c
View File

@ -90,10 +90,10 @@ nouveau_channel_prep(struct nouveau_drm *drm, struct nouveau_cli *cli,
u32 parent, u32 handle, u32 size, u32 parent, u32 handle, u32 size,
struct nouveau_channel **pchan) struct nouveau_channel **pchan)
{ {
struct nouveau_device *device = nv_device(drm->device); struct nvif_device *device = &drm->device;
struct nouveau_instmem *imem = nouveau_instmem(device); struct nouveau_instmem *imem = nvkm_instmem(device);
struct nouveau_vmmgr *vmm = nouveau_vmmgr(device); struct nouveau_vmmgr *vmm = nvkm_vmmgr(device);
struct nouveau_fb *pfb = nouveau_fb(device); struct nouveau_fb *pfb = nvkm_fb(device);
struct nouveau_client *client = &cli->base; struct nouveau_client *client = &cli->base;
struct nv_dma_class args = {}; struct nv_dma_class args = {};
struct nouveau_channel *chan; struct nouveau_channel *chan;
@ -134,7 +134,7 @@ nouveau_channel_prep(struct nouveau_drm *drm, struct nouveau_cli *cli,
chan->push.vma.offset = chan->push.buffer->bo.offset; chan->push.vma.offset = chan->push.buffer->bo.offset;
chan->push.handle = NVDRM_PUSH | (handle & 0xffff); chan->push.handle = NVDRM_PUSH | (handle & 0xffff);
if (device->card_type >= NV_50) { if (device->info.family >= NV_DEVICE_INFO_V0_TESLA) {
ret = nouveau_bo_vma_add(chan->push.buffer, client->vm, ret = nouveau_bo_vma_add(chan->push.buffer, client->vm,
&chan->push.vma); &chan->push.vma);
if (ret) { if (ret) {
@ -148,13 +148,13 @@ nouveau_channel_prep(struct nouveau_drm *drm, struct nouveau_cli *cli,
} else } else
if (chan->push.buffer->bo.mem.mem_type == TTM_PL_VRAM) { if (chan->push.buffer->bo.mem.mem_type == TTM_PL_VRAM) {
u64 limit = pfb->ram->size - imem->reserved - 1; u64 limit = pfb->ram->size - imem->reserved - 1;
if (device->card_type == NV_04) { if (device->info.family == NV_DEVICE_INFO_V0_TNT) {
/* nv04 vram pushbuf hack, retarget to its location in /* nv04 vram pushbuf hack, retarget to its location in
* the framebuffer bar rather than direct vram access.. * the framebuffer bar rather than direct vram access..
* nfi why this exists, it came from the -nv ddx. * nfi why this exists, it came from the -nv ddx.
*/ */
args.flags = NV_DMA_TARGET_PCI | NV_DMA_ACCESS_RDWR; args.flags = NV_DMA_TARGET_PCI | NV_DMA_ACCESS_RDWR;
args.start = nv_device_resource_start(device, 1); args.start = nv_device_resource_start(nvkm_device(device), 1);
args.limit = args.start + limit; args.limit = args.start + limit;
} else { } else {
args.flags = NV_DMA_TARGET_VRAM | NV_DMA_ACCESS_RDWR; args.flags = NV_DMA_TARGET_VRAM | NV_DMA_ACCESS_RDWR;
@ -215,6 +215,7 @@ nouveau_channel_ind(struct nouveau_drm *drm, struct nouveau_cli *cli,
do { do {
ret = nouveau_object_new(nv_object(cli), parent, handle, ret = nouveau_object_new(nv_object(cli), parent, handle,
*oclass++, &args, sizeof(args), *oclass++, &args, sizeof(args),
(struct nouveau_object **)
&chan->object); &chan->object);
if (ret == 0) if (ret == 0)
return ret; return ret;
@ -251,6 +252,7 @@ nouveau_channel_dma(struct nouveau_drm *drm, struct nouveau_cli *cli,
do { do {
ret = nouveau_object_new(nv_object(cli), parent, handle, ret = nouveau_object_new(nv_object(cli), parent, handle,
*oclass++, &args, sizeof(args), *oclass++, &args, sizeof(args),
(struct nouveau_object **)
&chan->object); &chan->object);
if (ret == 0) if (ret == 0)
return ret; return ret;
@ -264,18 +266,18 @@ static int
nouveau_channel_init(struct nouveau_channel *chan, u32 vram, u32 gart) nouveau_channel_init(struct nouveau_channel *chan, u32 vram, u32 gart)
{ {
struct nouveau_client *client = nv_client(chan->cli); struct nouveau_client *client = nv_client(chan->cli);
struct nouveau_device *device = nv_device(chan->drm->device); struct nvif_device *device = &chan->drm->device;
struct nouveau_instmem *imem = nouveau_instmem(device); struct nouveau_instmem *imem = nvkm_instmem(device);
struct nouveau_vmmgr *vmm = nouveau_vmmgr(device); struct nouveau_vmmgr *vmm = nvkm_vmmgr(device);
struct nouveau_fb *pfb = nouveau_fb(device); struct nouveau_fb *pfb = nvkm_fb(device);
struct nouveau_software_chan *swch; struct nouveau_software_chan *swch;
struct nouveau_object *object; struct nouveau_object *object;
struct nv_dma_class args = {}; struct nv_dma_class args = {};
int ret, i; int ret, i;
/* allocate dma objects to cover all allowed vram, and gart */ /* allocate dma objects to cover all allowed vram, and gart */
if (device->card_type < NV_C0) { if (device->info.family < NV_DEVICE_INFO_V0_FERMI) {
if (device->card_type >= NV_50) { if (device->info.family >= NV_DEVICE_INFO_V0_TESLA) {
args.flags = NV_DMA_TARGET_VM | NV_DMA_ACCESS_VM; args.flags = NV_DMA_TARGET_VM | NV_DMA_ACCESS_VM;
args.start = 0; args.start = 0;
args.limit = client->vm->vmm->limit - 1; args.limit = client->vm->vmm->limit - 1;
@ -290,7 +292,7 @@ nouveau_channel_init(struct nouveau_channel *chan, u32 vram, u32 gart)
if (ret) if (ret)
return ret; return ret;
if (device->card_type >= NV_50) { if (device->info.family >= NV_DEVICE_INFO_V0_TESLA) {
args.flags = NV_DMA_TARGET_VM | NV_DMA_ACCESS_VM; args.flags = NV_DMA_TARGET_VM | NV_DMA_ACCESS_VM;
args.start = 0; args.start = 0;
args.limit = client->vm->vmm->limit - 1; args.limit = client->vm->vmm->limit - 1;
@ -347,7 +349,7 @@ nouveau_channel_init(struct nouveau_channel *chan, u32 vram, u32 gart)
OUT_RING(chan, 0x00000000); OUT_RING(chan, 0x00000000);
/* allocate software object class (used for fences on <= nv05) */ /* allocate software object class (used for fences on <= nv05) */
if (device->card_type < NV_10) { if (device->info.family < NV_DEVICE_INFO_V0_CELSIUS) {
ret = nouveau_object_new(nv_object(client), chan->handle, ret = nouveau_object_new(nv_object(client), chan->handle,
NvSw, 0x006e, NULL, 0, &object); NvSw, 0x006e, NULL, 0, &object);
if (ret) if (ret)

2
drivers/gpu/drm/nouveau/nouveau_chan.h
View File

@ -34,7 +34,7 @@ struct nouveau_channel {
u32 user_get; u32 user_get;
u32 user_put; u32 user_put;
struct nouveau_object *object; struct nvif_object *object;
}; };

19
drivers/gpu/drm/nouveau/nouveau_connector.c
View File

@ -119,7 +119,7 @@ nouveau_connector_ddc_detect(struct drm_connector *connector)
struct drm_device *dev = connector->dev; struct drm_device *dev = connector->dev;
struct nouveau_connector *nv_connector = nouveau_connector(connector); struct nouveau_connector *nv_connector = nouveau_connector(connector);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_gpio *gpio = nouveau_gpio(drm->device); struct nouveau_gpio *gpio = nvkm_gpio(&drm->device);
struct nouveau_encoder *nv_encoder; struct nouveau_encoder *nv_encoder;
struct drm_encoder *encoder; struct drm_encoder *encoder;
int i, panel = -ENODEV; int i, panel = -ENODEV;
@ -208,7 +208,7 @@ nouveau_connector_set_encoder(struct drm_connector *connector,
return; return;
nv_connector->detected_encoder = nv_encoder; nv_connector->detected_encoder = nv_encoder;
if (nv_device(drm->device)->card_type >= NV_50) { if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA) {
connector->interlace_allowed = true; connector->interlace_allowed = true;
connector->doublescan_allowed = true; connector->doublescan_allowed = true;
} else } else
@ -218,9 +218,8 @@ nouveau_connector_set_encoder(struct drm_connector *connector,
connector->interlace_allowed = false; connector->interlace_allowed = false;
} else { } else {
connector->doublescan_allowed = true; connector->doublescan_allowed = true;
if (nv_device(drm->device)->card_type == NV_20 || if (drm->device.info.family == NV_DEVICE_INFO_V0_KELVIN ||
((nv_device(drm->device)->card_type == NV_10 || (drm->device.info.family == NV_DEVICE_INFO_V0_CELSIUS &&
nv_device(drm->device)->card_type == NV_11) &&
(dev->pdev->device & 0x0ff0) != 0x0100 && (dev->pdev->device & 0x0ff0) != 0x0100 &&
(dev->pdev->device & 0x0ff0) != 0x0150)) (dev->pdev->device & 0x0ff0) != 0x0150))
/* HW is broken */ /* HW is broken */
@ -804,11 +803,11 @@ get_tmds_link_bandwidth(struct drm_connector *connector)
struct dcb_output *dcb = nv_connector->detected_encoder->dcb; struct dcb_output *dcb = nv_connector->detected_encoder->dcb;
if (dcb->location != DCB_LOC_ON_CHIP || if (dcb->location != DCB_LOC_ON_CHIP ||
nv_device(drm->device)->chipset >= 0x46) drm->device.info.chipset >= 0x46)
return 165000; return 165000;
else if (nv_device(drm->device)->chipset >= 0x40) else if (drm->device.info.chipset >= 0x40)
return 155000; return 155000;
else if (nv_device(drm->device)->chipset >= 0x18) else if (drm->device.info.chipset >= 0x18)
return 135000; return 135000;
else else
return 112000; return 112000;
@ -1034,7 +1033,7 @@ nouveau_connector_create(struct drm_device *dev, int index)
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_display *disp = nouveau_display(dev); struct nouveau_display *disp = nouveau_display(dev);
struct nouveau_connector *nv_connector = NULL; struct nouveau_connector *nv_connector = NULL;
struct nouveau_disp *pdisp = nouveau_disp(drm->device); struct nouveau_disp *pdisp = nvkm_disp(&drm->device);
struct drm_connector *connector; struct drm_connector *connector;
int type, ret = 0; int type, ret = 0;
bool dummy; bool dummy;
@ -1188,7 +1187,7 @@ nouveau_connector_create(struct drm_device *dev, int index)
switch (nv_connector->type) { switch (nv_connector->type) {
case DCB_CONNECTOR_VGA: case DCB_CONNECTOR_VGA:
if (nv_device(drm->device)->card_type >= NV_50) { if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA) {
drm_object_attach_property(&connector->base, drm_object_attach_property(&connector->base,
dev->mode_config.scaling_mode_property, dev->mode_config.scaling_mode_property,
nv_connector->scaling_mode); nv_connector->scaling_mode);

18
drivers/gpu/drm/nouveau/nouveau_display.c
View File

@ -175,7 +175,7 @@ static int
nouveau_display_vblank_init(struct drm_device *dev) nouveau_display_vblank_init(struct drm_device *dev)
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_disp *pdisp = nouveau_disp(drm->device); struct nouveau_disp *pdisp = nvkm_disp(&drm->device);
struct drm_crtc *crtc; struct drm_crtc *crtc;
int ret; int ret;
@ -445,15 +445,15 @@ nouveau_display_create(struct drm_device *dev)
drm_mode_create_dvi_i_properties(dev); drm_mode_create_dvi_i_properties(dev);
dev->mode_config.funcs = &nouveau_mode_config_funcs; dev->mode_config.funcs = &nouveau_mode_config_funcs;
dev->mode_config.fb_base = nv_device_resource_start(nv_device(drm->device), 1); dev->mode_config.fb_base = nv_device_resource_start(nvkm_device(&drm->device), 1);
dev->mode_config.min_width = 0; dev->mode_config.min_width = 0;
dev->mode_config.min_height = 0; dev->mode_config.min_height = 0;
if (nv_device(drm->device)->card_type < NV_10) { if (drm->device.info.family < NV_DEVICE_INFO_V0_CELSIUS) {
dev->mode_config.max_width = 2048; dev->mode_config.max_width = 2048;
dev->mode_config.max_height = 2048; dev->mode_config.max_height = 2048;
} else } else
if (nv_device(drm->device)->card_type < NV_50) { if (drm->device.info.family < NV_DEVICE_INFO_V0_TESLA) {
dev->mode_config.max_width = 4096; dev->mode_config.max_width = 4096;
dev->mode_config.max_height = 4096; dev->mode_config.max_height = 4096;
} else { } else {
@ -464,7 +464,7 @@ nouveau_display_create(struct drm_device *dev)
dev->mode_config.preferred_depth = 24; dev->mode_config.preferred_depth = 24;
dev->mode_config.prefer_shadow = 1; dev->mode_config.prefer_shadow = 1;
if (nv_device(drm->device)->chipset < 0x11) if (drm->device.info.chipset < 0x11)
dev->mode_config.async_page_flip = false; dev->mode_config.async_page_flip = false;
else else
dev->mode_config.async_page_flip = true; dev->mode_config.async_page_flip = true;
@ -661,7 +661,7 @@ nouveau_page_flip_emit(struct nouveau_channel *chan,
if (ret) if (ret)
goto fail; goto fail;
if (nv_device(drm->device)->card_type < NV_C0) if (drm->device.info.family < NV_DEVICE_INFO_V0_FERMI)
BEGIN_NV04(chan, NvSubSw, NV_SW_PAGE_FLIP, 1); BEGIN_NV04(chan, NvSubSw, NV_SW_PAGE_FLIP, 1);
else else
BEGIN_NVC0(chan, FermiSw, NV_SW_PAGE_FLIP, 1); BEGIN_NVC0(chan, FermiSw, NV_SW_PAGE_FLIP, 1);
@ -732,7 +732,7 @@ nouveau_crtc_page_flip(struct drm_crtc *crtc, struct drm_framebuffer *fb,
drm_vblank_get(dev, nouveau_crtc(crtc)->index); drm_vblank_get(dev, nouveau_crtc(crtc)->index);
/* Emit a page flip */ /* Emit a page flip */
if (nv_device(drm->device)->card_type >= NV_50) { if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA) {
ret = nv50_display_flip_next(crtc, fb, chan, swap_interval); ret = nv50_display_flip_next(crtc, fb, chan, swap_interval);
if (ret) if (ret)
goto fail_unreserve; goto fail_unreserve;
@ -807,7 +807,7 @@ nouveau_finish_page_flip(struct nouveau_channel *chan,
s = list_first_entry(&fctx->flip, struct nouveau_page_flip_state, head); s = list_first_entry(&fctx->flip, struct nouveau_page_flip_state, head);
if (s->event) { if (s->event) {
/* Vblank timestamps/counts are only correct on >= NV-50 */ /* Vblank timestamps/counts are only correct on >= NV-50 */
if (nv_device(drm->device)->card_type >= NV_50) if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA)
crtcid = s->crtc; crtcid = s->crtc;
drm_send_vblank_event(dev, crtcid, s->event); drm_send_vblank_event(dev, crtcid, s->event);
@ -833,7 +833,7 @@ nouveau_flip_complete(void *data)
struct nouveau_page_flip_state state; struct nouveau_page_flip_state state;
if (!nouveau_finish_page_flip(chan, &state)) { if (!nouveau_finish_page_flip(chan, &state)) {
if (nv_device(drm->device)->card_type < NV_50) { if (drm->device.info.family < NV_DEVICE_INFO_V0_TESLA) {
nv_set_crtc_base(drm->dev, state.crtc, state.offset + nv_set_crtc_base(drm->dev, state.crtc, state.offset +
state.y * state.pitch + state.y * state.pitch +
state.x * state.bpp / 8); state.x * state.bpp / 8);

8
drivers/gpu/drm/nouveau/nouveau_dma.c
View File

@ -54,9 +54,9 @@ READ_GET(struct nouveau_channel *chan, uint64_t *prev_get, int *timeout)
{ {
uint64_t val; uint64_t val;
val = nv_ro32(chan->object, chan->user_get); val = nvif_rd32(chan, chan->user_get);
if (chan->user_get_hi) if (chan->user_get_hi)
val |= (uint64_t)nv_ro32(chan->object, chan->user_get_hi) << 32; val |= (uint64_t)nvif_rd32(chan, chan->user_get_hi) << 32;
/* reset counter as long as GET is still advancing, this is /* reset counter as long as GET is still advancing, this is
* to avoid misdetecting a GPU lockup if the GPU happens to * to avoid misdetecting a GPU lockup if the GPU happens to
@ -104,7 +104,7 @@ nv50_dma_push(struct nouveau_channel *chan, struct nouveau_bo *bo,
/* Flush writes. */ /* Flush writes. */
nouveau_bo_rd32(pb, 0); nouveau_bo_rd32(pb, 0);
nv_wo32(chan->object, 0x8c, chan->dma.ib_put); nvif_wr32(chan, 0x8c, chan->dma.ib_put);
chan->dma.ib_free--; chan->dma.ib_free--;
} }
@ -114,7 +114,7 @@ nv50_dma_push_wait(struct nouveau_channel *chan, int count)
uint32_t cnt = 0, prev_get = 0; uint32_t cnt = 0, prev_get = 0;
while (chan->dma.ib_free < count) { while (chan->dma.ib_free < count) {
uint32_t get = nv_ro32(chan->object, 0x88); uint32_t get = nvif_rd32(chan, 0x88);
if (get != prev_get) { if (get != prev_get) {
prev_get = get; prev_get = get;
cnt = 0; cnt = 0;

2
drivers/gpu/drm/nouveau/nouveau_dma.h
View File

@ -154,7 +154,7 @@ BEGIN_IMC0(struct nouveau_channel *chan, int subc, int mthd, u16 data)
#define WRITE_PUT(val) do { \ #define WRITE_PUT(val) do { \
mb(); \ mb(); \
nouveau_bo_rd32(chan->push.buffer, 0); \ nouveau_bo_rd32(chan->push.buffer, 0); \
nv_wo32(chan->object, chan->user_put, ((val) << 2) + chan->push.vma.offset); \ nvif_wr32(chan, chan->user_put, ((val) << 2) + chan->push.vma.offset); \
} while (0) } while (0)
static inline void static inline void

112
drivers/gpu/drm/nouveau/nouveau_drm.c
View File

@ -150,29 +150,58 @@ nouveau_accel_fini(struct nouveau_drm *drm)
static void static void
nouveau_accel_init(struct nouveau_drm *drm) nouveau_accel_init(struct nouveau_drm *drm)
{ {
struct nouveau_device *device = nv_device(drm->device); struct nvif_device *device = &drm->device;
struct nouveau_object *object; struct nouveau_object *object;
u32 arg0, arg1; u32 arg0, arg1;
int ret; u32 sclass[16];
int ret, i;
if (nouveau_noaccel || !nouveau_fifo(device) /*XXX*/) if (nouveau_noaccel)
return; return;
/* initialise synchronisation routines */ /* initialise synchronisation routines */
if (device->card_type < NV_10) ret = nv04_fence_create(drm); /*XXX: this is crap, but the fence/channel stuff is a little
else if (device->card_type < NV_11 || * backwards in some places. this will be fixed.
device->chipset < 0x17) ret = nv10_fence_create(drm); */
else if (device->card_type < NV_50) ret = nv17_fence_create(drm); ret = nouveau_parent_lclass(nvkm_object(device), sclass,
else if (device->chipset < 0x84) ret = nv50_fence_create(drm); ARRAY_SIZE(sclass));
else if (device->card_type < NV_C0) ret = nv84_fence_create(drm); if (ret < 0)
else ret = nvc0_fence_create(drm); return;
for (ret = -ENOSYS, i = 0; ret && i < ARRAY_SIZE(sclass); i++) {
switch (sclass[i]) {
case NV03_CHANNEL_DMA_CLASS:
ret = nv04_fence_create(drm);
break;
case NV10_CHANNEL_DMA_CLASS:
ret = nv10_fence_create(drm);
break;
case NV17_CHANNEL_DMA_CLASS:
case NV40_CHANNEL_DMA_CLASS:
ret = nv17_fence_create(drm);
break;
case NV50_CHANNEL_IND_CLASS:
ret = nv50_fence_create(drm);
break;
case NV84_CHANNEL_IND_CLASS:
ret = nv84_fence_create(drm);
break;
case NVC0_CHANNEL_IND_CLASS:
case NVE0_CHANNEL_IND_CLASS:
ret = nvc0_fence_create(drm);
break;
default:
break;
}
}
if (ret) { if (ret) {
NV_ERROR(drm, "failed to initialise sync subsystem, %d\n", ret); NV_ERROR(drm, "failed to initialise sync subsystem, %d\n", ret);
nouveau_accel_fini(drm); nouveau_accel_fini(drm);
return; return;
} }
if (device->card_type >= NV_E0) { if (device->info.family >= NV_DEVICE_INFO_V0_KEPLER) {
ret = nouveau_channel_new(drm, &drm->client, NVDRM_DEVICE, ret = nouveau_channel_new(drm, &drm->client, NVDRM_DEVICE,
NVDRM_CHAN + 1, NVDRM_CHAN + 1,
NVE0_CHANNEL_IND_ENGINE_CE0 | NVE0_CHANNEL_IND_ENGINE_CE0 |
@ -184,9 +213,9 @@ nouveau_accel_init(struct nouveau_drm *drm)
arg0 = NVE0_CHANNEL_IND_ENGINE_GR; arg0 = NVE0_CHANNEL_IND_ENGINE_GR;
arg1 = 1; arg1 = 1;
} else } else
if (device->chipset >= 0xa3 && if (device->info.chipset >= 0xa3 &&
device->chipset != 0xaa && device->info.chipset != 0xaa &&
device->chipset != 0xac) { device->info.chipset != 0xac) {
ret = nouveau_channel_new(drm, &drm->client, NVDRM_DEVICE, ret = nouveau_channel_new(drm, &drm->client, NVDRM_DEVICE,
NVDRM_CHAN + 1, NvDmaFB, NvDmaTT, NVDRM_CHAN + 1, NvDmaFB, NvDmaTT,
&drm->cechan); &drm->cechan);
@ -214,11 +243,11 @@ nouveau_accel_init(struct nouveau_drm *drm)
struct nouveau_software_chan *swch = (void *)object->parent; struct nouveau_software_chan *swch = (void *)object->parent;
ret = RING_SPACE(drm->channel, 2); ret = RING_SPACE(drm->channel, 2);
if (ret == 0) { if (ret == 0) {
if (device->card_type < NV_C0) { if (device->info.family < NV_DEVICE_INFO_V0_FERMI) {
BEGIN_NV04(drm->channel, NvSubSw, 0, 1); BEGIN_NV04(drm->channel, NvSubSw, 0, 1);
OUT_RING (drm->channel, NVDRM_NVSW); OUT_RING (drm->channel, NVDRM_NVSW);
} else } else
if (device->card_type < NV_E0) { if (device->info.family < NV_DEVICE_INFO_V0_KEPLER) {
BEGIN_NVC0(drm->channel, FermiSw, 0, 1); BEGIN_NVC0(drm->channel, FermiSw, 0, 1);
OUT_RING (drm->channel, 0x001f0000); OUT_RING (drm->channel, 0x001f0000);
} }
@ -234,9 +263,9 @@ nouveau_accel_init(struct nouveau_drm *drm)
return; return;
} }
if (device->card_type < NV_C0) { if (device->info.family < NV_DEVICE_INFO_V0_FERMI) {
ret = nouveau_gpuobj_new(drm->device, NULL, 32, 0, 0, ret = nouveau_gpuobj_new(nvkm_object(&drm->device), NULL, 32,
&drm->notify); 0, 0, &drm->notify);
if (ret) { if (ret) {
NV_ERROR(drm, "failed to allocate notifier, %d\n", ret); NV_ERROR(drm, "failed to allocate notifier, %d\n", ret);
nouveau_accel_fini(drm); nouveau_accel_fini(drm);
@ -344,6 +373,27 @@ nouveau_get_hdmi_dev(struct nouveau_drm *drm)
} }
} }
void
nouveau_drm_hack_device(struct nouveau_drm *drm, struct nvif_device *device)
{
drm->device.info.chipset = nvkm_device(&drm->device)->chipset;
switch (nvkm_device(&drm->device)->card_type) {
case NV_04: device->info.family = NV_DEVICE_INFO_V0_TNT; break;
case NV_10: device->info.family = NV_DEVICE_INFO_V0_CELSIUS; break;
case NV_11: device->info.family = NV_DEVICE_INFO_V0_CELSIUS; break;
case NV_20: device->info.family = NV_DEVICE_INFO_V0_KELVIN; break;
case NV_30: device->info.family = NV_DEVICE_INFO_V0_RANKINE; break;
case NV_40: device->info.family = NV_DEVICE_INFO_V0_CURIE; break;
case NV_50: device->info.family = NV_DEVICE_INFO_V0_TESLA; break;
case NV_C0: device->info.family = NV_DEVICE_INFO_V0_FERMI; break;
case NV_E0: device->info.family = NV_DEVICE_INFO_V0_KEPLER; break;
case GM100: device->info.family = NV_DEVICE_INFO_V0_MAXWELL; break;
default:
BUG_ON(1);
break;
}
}
static int static int
nouveau_drm_load(struct drm_device *dev, unsigned long flags) nouveau_drm_load(struct drm_device *dev, unsigned long flags)
{ {
@ -381,10 +431,13 @@ nouveau_drm_load(struct drm_device *dev, unsigned long flags)
NV_DEVICE_DISABLE_IDENTIFY), NV_DEVICE_DISABLE_IDENTIFY),
.debug0 = ~0, .debug0 = ~0,
}, sizeof(struct nv_device_class), }, sizeof(struct nv_device_class),
&drm->device); (struct nouveau_object **)
&drm->device.object);
if (ret) if (ret)
goto fail_device; goto fail_device;
nouveau_drm_hack_device(drm, &drm->device);
nouveau_agp_reset(drm); nouveau_agp_reset(drm);
nouveau_object_del(nv_object(drm), NVDRM_CLIENT, NVDRM_DEVICE); nouveau_object_del(nv_object(drm), NVDRM_CLIENT, NVDRM_DEVICE);
} }
@ -395,24 +448,27 @@ nouveau_drm_load(struct drm_device *dev, unsigned long flags)
.disable = 0, .disable = 0,
.debug0 = 0, .debug0 = 0,
}, sizeof(struct nv_device_class), }, sizeof(struct nv_device_class),
&drm->device); (struct nouveau_object **)
&drm->device.object);
if (ret) if (ret)
goto fail_device; goto fail_device;
nouveau_drm_hack_device(drm, &drm->device);
dev->irq_enabled = true; dev->irq_enabled = true;
/* workaround an odd issue on nvc1 by disabling the device's /* workaround an odd issue on nvc1 by disabling the device's
* nosnoop capability. hopefully won't cause issues until a * nosnoop capability. hopefully won't cause issues until a
* better fix is found - assuming there is one... * better fix is found - assuming there is one...
*/ */
if (nv_device(drm->device)->chipset == 0xc1) if (drm->device.info.chipset == 0xc1)
nvif_mask(drm->device, 0x00088080, 0x00000800, 0x00000000); nvif_mask(&drm->device, 0x00088080, 0x00000800, 0x00000000);
nouveau_vga_init(drm); nouveau_vga_init(drm);
nouveau_agp_init(drm); nouveau_agp_init(drm);
if (nv_device(drm->device)->card_type >= NV_50) { if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA) {
ret = nouveau_vm_new(nv_device(drm->device), 0, (1ULL << 40), ret = nouveau_vm_new(nvkm_device(&drm->device), 0, (1ULL << 40),
0x1000, &drm->client.vm); 0x1000, &drm->client.vm);
if (ret) if (ret)
goto fail_device; goto fail_device;
@ -723,8 +779,8 @@ nouveau_drm_open(struct drm_device *dev, struct drm_file *fpriv)
if (ret) if (ret)
goto out_suspend; goto out_suspend;
if (nv_device(drm->device)->card_type >= NV_50) { if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA) {
ret = nouveau_vm_new(nv_device(drm->device), 0, (1ULL << 40), ret = nouveau_vm_new(nvkm_device(&drm->device), 0, (1ULL << 40),
0x1000, &cli->vm); 0x1000, &cli->vm);
if (ret) { if (ret) {
nouveau_cli_destroy(cli); nouveau_cli_destroy(cli);
@ -930,7 +986,7 @@ static int nouveau_pmops_runtime_resume(struct device *dev)
{ {
struct pci_dev *pdev = to_pci_dev(dev); struct pci_dev *pdev = to_pci_dev(dev);
struct drm_device *drm_dev = pci_get_drvdata(pdev); struct drm_device *drm_dev = pci_get_drvdata(pdev);
struct nouveau_object *device = nouveau_drm(drm_dev)->device; struct nvif_device *device = &nouveau_drm(drm_dev)->device;
int ret; int ret;
if (nouveau_runtime_pm == 0) if (nouveau_runtime_pm == 0)

24
drivers/gpu/drm/nouveau/nouveau_drm.h
View File

@ -77,9 +77,21 @@ nouveau_cli(struct drm_file *fpriv)
return fpriv ? fpriv->driver_priv : NULL; return fpriv ? fpriv->driver_priv : NULL;
} }
#include <nvif/object.h>
#undef nvif_object
#undef nvif_rd08
#undef nvif_rd16
#undef nvif_rd32
#undef nvif_wr08
#undef nvif_wr16
#undef nvif_wr32
#undef nvif_mask
#undef nvkm_object
#undef nvif_exec
#define nvif_object(a) ({ \ #define nvif_object(a) ({ \
struct nouveau_object *_object = (a); \ struct nvif_object *_object = (a)->object; \
_object; \ (struct nouveau_object *)_object; \
}) })
#define nvif_rd08(a,b) nv_ro08(nvif_object(a), (b)) #define nvif_rd08(a,b) nv_ro08(nvif_object(a), (b))
#define nvif_rd16(a,b) nv_ro16(nvif_object(a), (b)) #define nvif_rd16(a,b) nv_ro16(nvif_object(a), (b))
@ -88,10 +100,10 @@ nouveau_cli(struct drm_file *fpriv)
#define nvif_wr16(a,b,c) nv_wo16(nvif_object(a), (b), (c)) #define nvif_wr16(a,b,c) nv_wo16(nvif_object(a), (b), (c))
#define nvif_wr32(a,b,c) nv_wo32(nvif_object(a), (b), (c)) #define nvif_wr32(a,b,c) nv_wo32(nvif_object(a), (b), (c))
#define nvif_mask(a,b,c,d) nv_mo32(nvif_object(a), (b), (c), (d)) #define nvif_mask(a,b,c,d) nv_mo32(nvif_object(a), (b), (c), (d))
/*XXX*/
#include <core/object.h>
#define nvkm_object(a) nvif_object(a) #define nvkm_object(a) nvif_object(a)
#define nvif_exec(a,b,c,d) nv_exec(nvkm_object(a), (b), (c), (d))
#include <nvif/device.h>
extern int nouveau_runtime_pm; extern int nouveau_runtime_pm;
@ -99,7 +111,7 @@ struct nouveau_drm {
struct nouveau_cli client; struct nouveau_cli client;
struct drm_device *dev; struct drm_device *dev;
struct nouveau_object *device; struct nvif_device device;
struct list_head clients; struct list_head clients;
struct { struct {

28
drivers/gpu/drm/nouveau/nouveau_fbcon.c
View File

@ -65,7 +65,7 @@ nouveau_fbcon_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
{ {
struct nouveau_fbdev *fbcon = info->par; struct nouveau_fbdev *fbcon = info->par;
struct nouveau_drm *drm = nouveau_drm(fbcon->dev); struct nouveau_drm *drm = nouveau_drm(fbcon->dev);
struct nouveau_device *device = nv_device(drm->device); struct nvif_device *device = &drm->device;
int ret; int ret;
if (info->state != FBINFO_STATE_RUNNING) if (info->state != FBINFO_STATE_RUNNING)
@ -74,10 +74,10 @@ nouveau_fbcon_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
ret = -ENODEV; ret = -ENODEV;
if (!in_interrupt() && !(info->flags & FBINFO_HWACCEL_DISABLED) && if (!in_interrupt() && !(info->flags & FBINFO_HWACCEL_DISABLED) &&
mutex_trylock(&drm->client.mutex)) { mutex_trylock(&drm->client.mutex)) {
if (device->card_type < NV_50) if (device->info.family < NV_DEVICE_INFO_V0_TESLA)
ret = nv04_fbcon_fillrect(info, rect); ret = nv04_fbcon_fillrect(info, rect);
else else
if (device->card_type < NV_C0) if (device->info.family < NV_DEVICE_INFO_V0_FERMI)
ret = nv50_fbcon_fillrect(info, rect); ret = nv50_fbcon_fillrect(info, rect);
else else
ret = nvc0_fbcon_fillrect(info, rect); ret = nvc0_fbcon_fillrect(info, rect);
@ -97,7 +97,7 @@ nouveau_fbcon_copyarea(struct fb_info *info, const struct fb_copyarea *image)
{ {
struct nouveau_fbdev *fbcon = info->par; struct nouveau_fbdev *fbcon = info->par;
struct nouveau_drm *drm = nouveau_drm(fbcon->dev); struct nouveau_drm *drm = nouveau_drm(fbcon->dev);
struct nouveau_device *device = nv_device(drm->device); struct nvif_device *device = &drm->device;
int ret; int ret;
if (info->state != FBINFO_STATE_RUNNING) if (info->state != FBINFO_STATE_RUNNING)
@ -106,10 +106,10 @@ nouveau_fbcon_copyarea(struct fb_info *info, const struct fb_copyarea *image)
ret = -ENODEV; ret = -ENODEV;
if (!in_interrupt() && !(info->flags & FBINFO_HWACCEL_DISABLED) && if (!in_interrupt() && !(info->flags & FBINFO_HWACCEL_DISABLED) &&
mutex_trylock(&drm->client.mutex)) { mutex_trylock(&drm->client.mutex)) {
if (device->card_type < NV_50) if (device->info.family < NV_DEVICE_INFO_V0_TESLA)
ret = nv04_fbcon_copyarea(info, image); ret = nv04_fbcon_copyarea(info, image);
else else
if (device->card_type < NV_C0) if (device->info.family < NV_DEVICE_INFO_V0_FERMI)
ret = nv50_fbcon_copyarea(info, image); ret = nv50_fbcon_copyarea(info, image);
else else
ret = nvc0_fbcon_copyarea(info, image); ret = nvc0_fbcon_copyarea(info, image);
@ -129,7 +129,7 @@ nouveau_fbcon_imageblit(struct fb_info *info, const struct fb_image *image)
{ {
struct nouveau_fbdev *fbcon = info->par; struct nouveau_fbdev *fbcon = info->par;
struct nouveau_drm *drm = nouveau_drm(fbcon->dev); struct nouveau_drm *drm = nouveau_drm(fbcon->dev);
struct nouveau_device *device = nv_device(drm->device); struct nvif_device *device = &drm->device;
int ret; int ret;
if (info->state != FBINFO_STATE_RUNNING) if (info->state != FBINFO_STATE_RUNNING)
@ -138,10 +138,10 @@ nouveau_fbcon_imageblit(struct fb_info *info, const struct fb_image *image)
ret = -ENODEV; ret = -ENODEV;
if (!in_interrupt() && !(info->flags & FBINFO_HWACCEL_DISABLED) && if (!in_interrupt() && !(info->flags & FBINFO_HWACCEL_DISABLED) &&
mutex_trylock(&drm->client.mutex)) { mutex_trylock(&drm->client.mutex)) {
if (device->card_type < NV_50) if (device->info.family < NV_DEVICE_INFO_V0_TESLA)
ret = nv04_fbcon_imageblit(info, image); ret = nv04_fbcon_imageblit(info, image);
else else
if (device->card_type < NV_C0) if (device->info.family < NV_DEVICE_INFO_V0_FERMI)
ret = nv50_fbcon_imageblit(info, image); ret = nv50_fbcon_imageblit(info, image);
else else
ret = nvc0_fbcon_imageblit(info, image); ret = nvc0_fbcon_imageblit(info, image);
@ -252,10 +252,10 @@ nouveau_fbcon_accel_init(struct drm_device *dev)
struct fb_info *info = fbcon->helper.fbdev; struct fb_info *info = fbcon->helper.fbdev;
int ret; int ret;
if (nv_device(drm->device)->card_type < NV_50) if (drm->device.info.family < NV_DEVICE_INFO_V0_TESLA)
ret = nv04_fbcon_accel_init(info); ret = nv04_fbcon_accel_init(info);
else else
if (nv_device(drm->device)->card_type < NV_C0) if (drm->device.info.family < NV_DEVICE_INFO_V0_FERMI)
ret = nv50_fbcon_accel_init(info); ret = nv50_fbcon_accel_init(info);
else else
ret = nvc0_fbcon_accel_init(info); ret = nvc0_fbcon_accel_init(info);
@ -309,7 +309,7 @@ nouveau_fbcon_create(struct drm_fb_helper *helper,
struct nouveau_fbdev *fbcon = (struct nouveau_fbdev *)helper; struct nouveau_fbdev *fbcon = (struct nouveau_fbdev *)helper;
struct drm_device *dev = fbcon->dev; struct drm_device *dev = fbcon->dev;
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_device *device = nv_device(drm->device); struct nvif_device *device = &drm->device;
struct fb_info *info; struct fb_info *info;
struct drm_framebuffer *fb; struct drm_framebuffer *fb;
struct nouveau_framebuffer *nouveau_fb; struct nouveau_framebuffer *nouveau_fb;
@ -351,7 +351,7 @@ nouveau_fbcon_create(struct drm_fb_helper *helper,
} }
chan = nouveau_nofbaccel ? NULL : drm->channel; chan = nouveau_nofbaccel ? NULL : drm->channel;
if (chan && device->card_type >= NV_50) { if (chan && device->info.family >= NV_DEVICE_INFO_V0_TESLA) {
ret = nouveau_bo_vma_add(nvbo, nv_client(chan->cli)->vm, ret = nouveau_bo_vma_add(nvbo, nv_client(chan->cli)->vm,
&fbcon->nouveau_fb.vma); &fbcon->nouveau_fb.vma);
if (ret) { if (ret) {
@ -489,7 +489,7 @@ int
nouveau_fbcon_init(struct drm_device *dev) nouveau_fbcon_init(struct drm_device *dev)
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_fb *pfb = nouveau_fb(drm->device); struct nouveau_fb *pfb = nvkm_fb(&drm->device);
struct nouveau_fbdev *fbcon; struct nouveau_fbdev *fbcon;
int preferred_bpp; int preferred_bpp;
int ret; int ret;

2
drivers/gpu/drm/nouveau/nouveau_fence.c
View File

@ -184,7 +184,7 @@ nouveau_fence_wait_uevent(struct nouveau_fence *fence, bool intr)
{ {
struct nouveau_channel *chan = fence->channel; struct nouveau_channel *chan = fence->channel;
struct nouveau_fifo *pfifo = nouveau_fifo(chan->drm->device); struct nouveau_fifo *pfifo = nvkm_fifo(&chan->drm->device);
struct nouveau_fence_priv *priv = chan->drm->fence; struct nouveau_fence_priv *priv = chan->drm->fence;
struct nouveau_fence_wait wait = { .priv = priv }; struct nouveau_fence_wait wait = { .priv = priv };
int ret = 0; int ret = 0;

10
drivers/gpu/drm/nouveau/nouveau_gem.c
View File

@ -173,7 +173,7 @@ nouveau_gem_new(struct drm_device *dev, int size, int align, uint32_t domain,
*/ */
nvbo->valid_domains = NOUVEAU_GEM_DOMAIN_VRAM | nvbo->valid_domains = NOUVEAU_GEM_DOMAIN_VRAM |
NOUVEAU_GEM_DOMAIN_GART; NOUVEAU_GEM_DOMAIN_GART;
if (nv_device(drm->device)->card_type >= NV_50) if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA)
nvbo->valid_domains &= domain; nvbo->valid_domains &= domain;
/* Initialize the embedded gem-object. We return a single gem-reference /* Initialize the embedded gem-object. We return a single gem-reference
@ -223,7 +223,7 @@ nouveau_gem_ioctl_new(struct drm_device *dev, void *data,
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_cli *cli = nouveau_cli(file_priv); struct nouveau_cli *cli = nouveau_cli(file_priv);
struct nouveau_fb *pfb = nouveau_fb(drm->device); struct nouveau_fb *pfb = nvkm_fb(&drm->device);
struct drm_nouveau_gem_new *req = data; struct drm_nouveau_gem_new *req = data;
struct nouveau_bo *nvbo = NULL; struct nouveau_bo *nvbo = NULL;
int ret = 0; int ret = 0;
@ -482,7 +482,7 @@ validate_list(struct nouveau_channel *chan, struct nouveau_cli *cli,
return ret; return ret;
} }
if (nv_device(drm->device)->card_type < NV_50) { if (drm->device.info.family < NV_DEVICE_INFO_V0_TESLA) {
if (nvbo->bo.offset == b->presumed.offset && if (nvbo->bo.offset == b->presumed.offset &&
((nvbo->bo.mem.mem_type == TTM_PL_VRAM && ((nvbo->bo.mem.mem_type == TTM_PL_VRAM &&
b->presumed.domain & NOUVEAU_GEM_DOMAIN_VRAM) || b->presumed.domain & NOUVEAU_GEM_DOMAIN_VRAM) ||
@ -780,7 +780,7 @@ nouveau_gem_ioctl_pushbuf(struct drm_device *dev, void *data,
push[i].length); push[i].length);
} }
} else } else
if (nv_device(drm->device)->chipset >= 0x25) { if (drm->device.info.chipset >= 0x25) {
ret = RING_SPACE(chan, req->nr_push * 2); ret = RING_SPACE(chan, req->nr_push * 2);
if (ret) { if (ret) {
NV_PRINTK(error, cli, "cal_space: %d\n", ret); NV_PRINTK(error, cli, "cal_space: %d\n", ret);
@ -853,7 +853,7 @@ out_next:
req->suffix0 = 0x00000000; req->suffix0 = 0x00000000;
req->suffix1 = 0x00000000; req->suffix1 = 0x00000000;
} else } else
if (nv_device(drm->device)->chipset >= 0x25) { if (drm->device.info.chipset >= 0x25) {
req->suffix0 = 0x00020000; req->suffix0 = 0x00020000;
req->suffix1 = 0x00000000; req->suffix1 = 0x00000000;
} else { } else {

54
drivers/gpu/drm/nouveau/nouveau_hwmon.c
View File

@ -44,7 +44,7 @@ nouveau_hwmon_show_temp(struct device *d, struct device_attribute *a, char *buf)
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
int temp = therm->temp_get(therm); int temp = therm->temp_get(therm);
if (temp < 0) if (temp < 0)
@ -70,7 +70,7 @@ nouveau_hwmon_temp1_auto_point1_temp(struct device *d,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
return snprintf(buf, PAGE_SIZE, "%d\n", return snprintf(buf, PAGE_SIZE, "%d\n",
therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_FAN_BOOST) * 1000); therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_FAN_BOOST) * 1000);
@ -82,7 +82,7 @@ nouveau_hwmon_set_temp1_auto_point1_temp(struct device *d,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
long value; long value;
if (kstrtol(buf, 10, &value) == -EINVAL) if (kstrtol(buf, 10, &value) == -EINVAL)
@ -103,7 +103,7 @@ nouveau_hwmon_temp1_auto_point1_temp_hyst(struct device *d,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
return snprintf(buf, PAGE_SIZE, "%d\n", return snprintf(buf, PAGE_SIZE, "%d\n",
therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_FAN_BOOST_HYST) * 1000); therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_FAN_BOOST_HYST) * 1000);
@ -115,7 +115,7 @@ nouveau_hwmon_set_temp1_auto_point1_temp_hyst(struct device *d,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
long value; long value;
if (kstrtol(buf, 10, &value) == -EINVAL) if (kstrtol(buf, 10, &value) == -EINVAL)
@ -135,7 +135,7 @@ nouveau_hwmon_max_temp(struct device *d, struct device_attribute *a, char *buf)
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
return snprintf(buf, PAGE_SIZE, "%d\n", return snprintf(buf, PAGE_SIZE, "%d\n",
therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_DOWN_CLK) * 1000); therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_DOWN_CLK) * 1000);
@ -146,7 +146,7 @@ nouveau_hwmon_set_max_temp(struct device *d, struct device_attribute *a,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
long value; long value;
if (kstrtol(buf, 10, &value) == -EINVAL) if (kstrtol(buf, 10, &value) == -EINVAL)
@ -166,7 +166,7 @@ nouveau_hwmon_max_temp_hyst(struct device *d, struct device_attribute *a,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
return snprintf(buf, PAGE_SIZE, "%d\n", return snprintf(buf, PAGE_SIZE, "%d\n",
therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_DOWN_CLK_HYST) * 1000); therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_DOWN_CLK_HYST) * 1000);
@ -177,7 +177,7 @@ nouveau_hwmon_set_max_temp_hyst(struct device *d, struct device_attribute *a,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
long value; long value;
if (kstrtol(buf, 10, &value) == -EINVAL) if (kstrtol(buf, 10, &value) == -EINVAL)
@ -198,7 +198,7 @@ nouveau_hwmon_critical_temp(struct device *d, struct device_attribute *a,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
return snprintf(buf, PAGE_SIZE, "%d\n", return snprintf(buf, PAGE_SIZE, "%d\n",
therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_CRITICAL) * 1000); therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_CRITICAL) * 1000);
@ -210,7 +210,7 @@ nouveau_hwmon_set_critical_temp(struct device *d, struct device_attribute *a,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
long value; long value;
if (kstrtol(buf, 10, &value) == -EINVAL) if (kstrtol(buf, 10, &value) == -EINVAL)
@ -231,7 +231,7 @@ nouveau_hwmon_critical_temp_hyst(struct device *d, struct device_attribute *a,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
return snprintf(buf, PAGE_SIZE, "%d\n", return snprintf(buf, PAGE_SIZE, "%d\n",
therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_CRITICAL_HYST) * 1000); therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_CRITICAL_HYST) * 1000);
@ -244,7 +244,7 @@ nouveau_hwmon_set_critical_temp_hyst(struct device *d,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
long value; long value;
if (kstrtol(buf, 10, &value) == -EINVAL) if (kstrtol(buf, 10, &value) == -EINVAL)
@ -264,7 +264,7 @@ nouveau_hwmon_emergency_temp(struct device *d, struct device_attribute *a,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
return snprintf(buf, PAGE_SIZE, "%d\n", return snprintf(buf, PAGE_SIZE, "%d\n",
therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_SHUTDOWN) * 1000); therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_SHUTDOWN) * 1000);
@ -276,7 +276,7 @@ nouveau_hwmon_set_emergency_temp(struct device *d, struct device_attribute *a,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
long value; long value;
if (kstrtol(buf, 10, &value) == -EINVAL) if (kstrtol(buf, 10, &value) == -EINVAL)
@ -297,7 +297,7 @@ nouveau_hwmon_emergency_temp_hyst(struct device *d, struct device_attribute *a,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
return snprintf(buf, PAGE_SIZE, "%d\n", return snprintf(buf, PAGE_SIZE, "%d\n",
therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_SHUTDOWN_HYST) * 1000); therm->attr_get(therm, NOUVEAU_THERM_ATTR_THRS_SHUTDOWN_HYST) * 1000);
@ -310,7 +310,7 @@ nouveau_hwmon_set_emergency_temp_hyst(struct device *d,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
long value; long value;
if (kstrtol(buf, 10, &value) == -EINVAL) if (kstrtol(buf, 10, &value) == -EINVAL)
@ -350,7 +350,7 @@ nouveau_hwmon_show_fan1_input(struct device *d, struct device_attribute *attr,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
return snprintf(buf, PAGE_SIZE, "%d\n", therm->fan_sense(therm)); return snprintf(buf, PAGE_SIZE, "%d\n", therm->fan_sense(therm));
} }
@ -363,7 +363,7 @@ nouveau_hwmon_get_pwm1_enable(struct device *d,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
int ret; int ret;
ret = therm->attr_get(therm, NOUVEAU_THERM_ATTR_FAN_MODE); ret = therm->attr_get(therm, NOUVEAU_THERM_ATTR_FAN_MODE);
@ -379,7 +379,7 @@ nouveau_hwmon_set_pwm1_enable(struct device *d, struct device_attribute *a,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
long value; long value;
int ret; int ret;
@ -402,7 +402,7 @@ nouveau_hwmon_get_pwm1(struct device *d, struct device_attribute *a, char *buf)
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
int ret; int ret;
ret = therm->fan_get(therm); ret = therm->fan_get(therm);
@ -418,7 +418,7 @@ nouveau_hwmon_set_pwm1(struct device *d, struct device_attribute *a,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
int ret = -ENODEV; int ret = -ENODEV;
long value; long value;
@ -442,7 +442,7 @@ nouveau_hwmon_get_pwm1_min(struct device *d,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
int ret; int ret;
ret = therm->attr_get(therm, NOUVEAU_THERM_ATTR_FAN_MIN_DUTY); ret = therm->attr_get(therm, NOUVEAU_THERM_ATTR_FAN_MIN_DUTY);
@ -458,7 +458,7 @@ nouveau_hwmon_set_pwm1_min(struct device *d, struct device_attribute *a,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
long value; long value;
int ret; int ret;
@ -482,7 +482,7 @@ nouveau_hwmon_get_pwm1_max(struct device *d,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
int ret; int ret;
ret = therm->attr_get(therm, NOUVEAU_THERM_ATTR_FAN_MAX_DUTY); ret = therm->attr_get(therm, NOUVEAU_THERM_ATTR_FAN_MAX_DUTY);
@ -498,7 +498,7 @@ nouveau_hwmon_set_pwm1_max(struct device *d, struct device_attribute *a,
{ {
struct drm_device *dev = dev_get_drvdata(d); struct drm_device *dev = dev_get_drvdata(d);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
long value; long value;
int ret; int ret;
@ -565,7 +565,7 @@ nouveau_hwmon_init(struct drm_device *dev)
{ {
#if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE)) #if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE))
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_therm *therm = nouveau_therm(drm->device); struct nouveau_therm *therm = nvkm_therm(&drm->device);
struct nouveau_hwmon *hwmon; struct nouveau_hwmon *hwmon;
struct device *hwmon_dev; struct device *hwmon_dev;
int ret = 0; int ret = 0;

2
drivers/gpu/drm/nouveau/nouveau_sgdma.c
View File

@ -104,7 +104,7 @@ nouveau_sgdma_create_ttm(struct ttm_bo_device *bdev,
return NULL; return NULL;
nvbe->dev = drm->dev; nvbe->dev = drm->dev;
if (nv_device(drm->device)->card_type < NV_50) if (drm->device.info.family < NV_DEVICE_INFO_V0_TESLA)
nvbe->ttm.ttm.func = &nv04_sgdma_backend; nvbe->ttm.ttm.func = &nv04_sgdma_backend;
else else
nvbe->ttm.ttm.func = &nv50_sgdma_backend; nvbe->ttm.ttm.func = &nv50_sgdma_backend;

8
drivers/gpu/drm/nouveau/nouveau_sysfs.c
View File

@ -154,10 +154,10 @@ nouveau_sysfs_fini(struct drm_device *dev)
{ {
struct nouveau_sysfs *sysfs = nouveau_sysfs(dev); struct nouveau_sysfs *sysfs = nouveau_sysfs(dev);
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_device *device = nv_device(drm->device); struct nvif_device *device = &drm->device;
if (sysfs->ctrl) { if (sysfs->ctrl) {
device_remove_file(nv_device_base(device), &dev_attr_pstate); device_remove_file(nv_device_base(nvkm_device(device)), &dev_attr_pstate);
nouveau_object_del(nv_object(drm), NVDRM_DEVICE, NVDRM_CONTROL); nouveau_object_del(nv_object(drm), NVDRM_DEVICE, NVDRM_CONTROL);
} }
@ -169,7 +169,7 @@ int
nouveau_sysfs_init(struct drm_device *dev) nouveau_sysfs_init(struct drm_device *dev)
{ {
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_device *device = nv_device(drm->device); struct nvif_device *device = &drm->device;
struct nouveau_sysfs *sysfs; struct nouveau_sysfs *sysfs;
int ret; int ret;
@ -180,7 +180,7 @@ nouveau_sysfs_init(struct drm_device *dev)
ret = nouveau_object_new(nv_object(drm), NVDRM_DEVICE, NVDRM_CONTROL, ret = nouveau_object_new(nv_object(drm), NVDRM_DEVICE, NVDRM_CONTROL,
NV_CONTROL_CLASS, NULL, 0, &sysfs->ctrl); NV_CONTROL_CLASS, NULL, 0, &sysfs->ctrl);
if (ret == 0) if (ret == 0)
device_create_file(nv_device_base(device), &dev_attr_pstate); device_create_file(nv_device_base(nvkm_device(device)), &dev_attr_pstate);
return 0; return 0;
} }

33
drivers/gpu/drm/nouveau/nouveau_ttm.c
View File

@ -36,7 +36,7 @@ static int
nouveau_vram_manager_init(struct ttm_mem_type_manager *man, unsigned long psize) nouveau_vram_manager_init(struct ttm_mem_type_manager *man, unsigned long psize)
{ {
struct nouveau_drm *drm = nouveau_bdev(man->bdev); struct nouveau_drm *drm = nouveau_bdev(man->bdev);
struct nouveau_fb *pfb = nouveau_fb(drm->device); struct nouveau_fb *pfb = nvkm_fb(&drm->device);
man->priv = pfb; man->priv = pfb;
return 0; return 0;
} }
@ -67,7 +67,7 @@ nouveau_vram_manager_del(struct ttm_mem_type_manager *man,
struct ttm_mem_reg *mem) struct ttm_mem_reg *mem)
{ {
struct nouveau_drm *drm = nouveau_bdev(man->bdev); struct nouveau_drm *drm = nouveau_bdev(man->bdev);
struct nouveau_fb *pfb = nouveau_fb(drm->device); struct nouveau_fb *pfb = nvkm_fb(&drm->device);
nouveau_mem_node_cleanup(mem->mm_node); nouveau_mem_node_cleanup(mem->mm_node);
pfb->ram->put(pfb, (struct nouveau_mem **)&mem->mm_node); pfb->ram->put(pfb, (struct nouveau_mem **)&mem->mm_node);
} }
@ -80,7 +80,7 @@ nouveau_vram_manager_new(struct ttm_mem_type_manager *man,
struct ttm_mem_reg *mem) struct ttm_mem_reg *mem)
{ {
struct nouveau_drm *drm = nouveau_bdev(man->bdev); struct nouveau_drm *drm = nouveau_bdev(man->bdev);
struct nouveau_fb *pfb = nouveau_fb(drm->device); struct nouveau_fb *pfb = nvkm_fb(&drm->device);
struct nouveau_bo *nvbo = nouveau_bo(bo); struct nouveau_bo *nvbo = nouveau_bo(bo);
struct nouveau_mem *node; struct nouveau_mem *node;
u32 size_nc = 0; u32 size_nc = 0;
@ -176,13 +176,13 @@ nouveau_gart_manager_new(struct ttm_mem_type_manager *man,
node->page_shift = 12; node->page_shift = 12;
switch (nv_device(drm->device)->card_type) { switch (drm->device.info.family) {
case NV_50: case NV_DEVICE_INFO_V0_TESLA:
if (nv_device(drm->device)->chipset != 0x50) if (drm->device.info.chipset != 0x50)
node->memtype = (nvbo->tile_flags & 0x7f00) >> 8; node->memtype = (nvbo->tile_flags & 0x7f00) >> 8;
break; break;
case NV_C0: case NV_DEVICE_INFO_V0_FERMI:
case NV_E0: case NV_DEVICE_INFO_V0_KEPLER:
node->memtype = (nvbo->tile_flags & 0xff00) >> 8; node->memtype = (nvbo->tile_flags & 0xff00) >> 8;
break; break;
default: default:
@ -212,7 +212,7 @@ static int
nv04_gart_manager_init(struct ttm_mem_type_manager *man, unsigned long psize) nv04_gart_manager_init(struct ttm_mem_type_manager *man, unsigned long psize)
{ {
struct nouveau_drm *drm = nouveau_bdev(man->bdev); struct nouveau_drm *drm = nouveau_bdev(man->bdev);
struct nouveau_vmmgr *vmm = nouveau_vmmgr(drm->device); struct nouveau_vmmgr *vmm = nvkm_vmmgr(&drm->device);
struct nv04_vmmgr_priv *priv = (void *)vmm; struct nv04_vmmgr_priv *priv = (void *)vmm;
struct nouveau_vm *vm = NULL; struct nouveau_vm *vm = NULL;
nouveau_vm_ref(priv->vm, &vm, NULL); nouveau_vm_ref(priv->vm, &vm, NULL);
@ -356,12 +356,11 @@ int
nouveau_ttm_init(struct nouveau_drm *drm) nouveau_ttm_init(struct nouveau_drm *drm)
{ {
struct drm_device *dev = drm->dev; struct drm_device *dev = drm->dev;
struct nouveau_device *device = nv_device(drm->device);
u32 bits; u32 bits;
int ret; int ret;
bits = nouveau_vmmgr(drm->device)->dma_bits; bits = nvkm_vmmgr(&drm->device)->dma_bits;
if (nv_device_is_pci(device)) { if (nv_device_is_pci(nvkm_device(&drm->device))) {
if (drm->agp.stat == ENABLED || if (drm->agp.stat == ENABLED ||
!pci_dma_supported(dev->pdev, DMA_BIT_MASK(bits))) !pci_dma_supported(dev->pdev, DMA_BIT_MASK(bits)))
bits = 32; bits = 32;
@ -393,8 +392,8 @@ nouveau_ttm_init(struct nouveau_drm *drm)
} }
/* VRAM init */ /* VRAM init */
drm->gem.vram_available = nouveau_fb(drm->device)->ram->size; drm->gem.vram_available = nvkm_fb(&drm->device)->ram->size;
drm->gem.vram_available -= nouveau_instmem(drm->device)->reserved; drm->gem.vram_available -= nvkm_instmem(&drm->device)->reserved;
ret = ttm_bo_init_mm(&drm->ttm.bdev, TTM_PL_VRAM, ret = ttm_bo_init_mm(&drm->ttm.bdev, TTM_PL_VRAM,
drm->gem.vram_available >> PAGE_SHIFT); drm->gem.vram_available >> PAGE_SHIFT);
@ -403,12 +402,12 @@ nouveau_ttm_init(struct nouveau_drm *drm)
return ret; return ret;
} }
drm->ttm.mtrr = arch_phys_wc_add(nv_device_resource_start(device, 1), drm->ttm.mtrr = arch_phys_wc_add(nv_device_resource_start(nvkm_device(&drm->device), 1),
nv_device_resource_len(device, 1)); nv_device_resource_len(nvkm_device(&drm->device), 1));
/* GART init */ /* GART init */
if (drm->agp.stat != ENABLED) { if (drm->agp.stat != ENABLED) {
drm->gem.gart_available = nouveau_vmmgr(drm->device)->limit; drm->gem.gart_available = nvkm_vmmgr(&drm->device)->limit;
} else { } else {
drm->gem.gart_available = drm->agp.size; drm->gem.gart_available = drm->agp.size;
} }

8
drivers/gpu/drm/nouveau/nouveau_vga.c
View File

@ -12,13 +12,13 @@
static unsigned int static unsigned int
nouveau_vga_set_decode(void *priv, bool state) nouveau_vga_set_decode(void *priv, bool state)
{ {
struct nouveau_object *device = nouveau_drm(priv)->device; struct nvif_device *device = &nouveau_drm(priv)->device;
if (nv_device(device)->card_type == NV_40 && if (device->info.family == NV_DEVICE_INFO_V0_CURIE &&
nv_device(device)->chipset >= 0x4c) device->info.chipset >= 0x4c)
nvif_wr32(device, 0x088060, state); nvif_wr32(device, 0x088060, state);
else else
if (nv_device(device)->chipset >= 0x40) if (device->info.chipset >= 0x40)
nvif_wr32(device, 0x088054, state); nvif_wr32(device, 0x088054, state);
else else
nvif_wr32(device, 0x001854, state); nvif_wr32(device, 0x001854, state);

8
drivers/gpu/drm/nouveau/nv04_fbcon.c
View File

@ -141,7 +141,7 @@ nv04_fbcon_accel_init(struct fb_info *info)
struct drm_device *dev = nfbdev->dev; struct drm_device *dev = nfbdev->dev;
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct nouveau_channel *chan = drm->channel; struct nouveau_channel *chan = drm->channel;
struct nouveau_device *device = nv_device(drm->device); struct nvif_device *device = &drm->device;
struct nouveau_object *object; struct nouveau_object *object;
int surface_fmt, pattern_fmt, rect_fmt; int surface_fmt, pattern_fmt, rect_fmt;
int ret; int ret;
@ -175,7 +175,7 @@ nv04_fbcon_accel_init(struct fb_info *info)
} }
ret = nouveau_object_new(nv_object(chan->cli), NVDRM_CHAN, NvCtxSurf2D, ret = nouveau_object_new(nv_object(chan->cli), NVDRM_CHAN, NvCtxSurf2D,
device->card_type >= NV_10 ? 0x0062 : 0x0042, device->info.family >= NV_DEVICE_INFO_V0_CELSIUS ? 0x0062 : 0x0042,
NULL, 0, &object); NULL, 0, &object);
if (ret) if (ret)
return ret; return ret;
@ -201,7 +201,7 @@ nv04_fbcon_accel_init(struct fb_info *info)
return ret; return ret;
ret = nouveau_object_new(nv_object(chan->cli), NVDRM_CHAN, NvImageBlit, ret = nouveau_object_new(nv_object(chan->cli), NVDRM_CHAN, NvImageBlit,
device->chipset >= 0x11 ? 0x009f : 0x005f, device->info.chipset >= 0x11 ? 0x009f : 0x005f,
NULL, 0, &object); NULL, 0, &object);
if (ret) if (ret)
return ret; return ret;
@ -255,7 +255,7 @@ nv04_fbcon_accel_init(struct fb_info *info)
OUT_RING(chan, NvCtxSurf2D); OUT_RING(chan, NvCtxSurf2D);
BEGIN_NV04(chan, NvSubImageBlit, 0x02fc, 1); BEGIN_NV04(chan, NvSubImageBlit, 0x02fc, 1);
OUT_RING(chan, 3); OUT_RING(chan, 3);
if (device->chipset >= 0x11 /*XXX: oclass == 0x009f*/) { if (device->info.chipset >= 0x11 /*XXX: oclass == 0x009f*/) {
BEGIN_NV04(chan, NvSubImageBlit, 0x0120, 3); BEGIN_NV04(chan, NvSubImageBlit, 0x0120, 3);
OUT_RING(chan, 0); OUT_RING(chan, 0);
OUT_RING(chan, 1); OUT_RING(chan, 1);

2
drivers/gpu/drm/nouveau/nv04_fence.c
View File

@ -59,7 +59,7 @@ nv04_fence_sync(struct nouveau_fence *fence,
static u32 static u32
nv04_fence_read(struct nouveau_channel *chan) nv04_fence_read(struct nouveau_channel *chan)
{ {
struct nouveau_fifo_chan *fifo = (void *)chan->object; struct nouveau_fifo_chan *fifo = nvkm_fifo_chan(chan);;
return atomic_read(&fifo->refcnt); return atomic_read(&fifo->refcnt);
} }

2
drivers/gpu/drm/nouveau/nv10_fence.c
View File

@ -53,7 +53,7 @@ nv10_fence_sync(struct nouveau_fence *fence,
u32 u32
nv10_fence_read(struct nouveau_channel *chan) nv10_fence_read(struct nouveau_channel *chan)
{ {
return nv_ro32(chan->object, 0x0048); return nvif_rd32(chan, 0x0048);
} }
void void

26
drivers/gpu/drm/nouveau/nv50_display.c
View File

@ -317,7 +317,7 @@ evo_sync_wait(void *data)
static int static int
evo_sync(struct drm_device *dev) evo_sync(struct drm_device *dev)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
struct nv50_disp *disp = nv50_disp(dev); struct nv50_disp *disp = nv50_disp(dev);
struct nv50_mast *mast = nv50_mast(dev); struct nv50_mast *mast = nv50_mast(dev);
u32 *push = evo_wait(mast, 8); u32 *push = evo_wait(mast, 8);
@ -329,7 +329,7 @@ evo_sync(struct drm_device *dev)
evo_data(push, 0x00000000); evo_data(push, 0x00000000);
evo_data(push, 0x00000000); evo_data(push, 0x00000000);
evo_kick(push, mast); evo_kick(push, mast);
if (nv_wait_cb(nv_device(device), evo_sync_wait, disp->sync)) if (nv_wait_cb(nvkm_device(device), evo_sync_wait, disp->sync))
return 0; return 0;
} }
@ -364,7 +364,7 @@ nv50_display_flip_wait(void *data)
void void
nv50_display_flip_stop(struct drm_crtc *crtc) nv50_display_flip_stop(struct drm_crtc *crtc)
{ {
struct nouveau_object *device = nouveau_drm(crtc->dev)->device; struct nvif_device *device = &nouveau_drm(crtc->dev)->device;
struct nv50_display_flip flip = { struct nv50_display_flip flip = {
.disp = nv50_disp(crtc->dev), .disp = nv50_disp(crtc->dev),
.chan = nv50_sync(crtc), .chan = nv50_sync(crtc),
@ -384,7 +384,7 @@ nv50_display_flip_stop(struct drm_crtc *crtc)
evo_kick(push, flip.chan); evo_kick(push, flip.chan);
} }
nv_wait_cb(nv_device(device), nv50_display_flip_wait, &flip); nv_wait_cb(nvkm_device(device), nv50_display_flip_wait, &flip);
} }
int int
@ -1493,7 +1493,7 @@ static int
nv50_dac_create(struct drm_connector *connector, struct dcb_output *dcbe) nv50_dac_create(struct drm_connector *connector, struct dcb_output *dcbe)
{ {
struct nouveau_drm *drm = nouveau_drm(connector->dev); struct nouveau_drm *drm = nouveau_drm(connector->dev);
struct nouveau_i2c *i2c = nouveau_i2c(drm->device); struct nouveau_i2c *i2c = nvkm_i2c(&drm->device);
struct nouveau_encoder *nv_encoder; struct nouveau_encoder *nv_encoder;
struct drm_encoder *encoder; struct drm_encoder *encoder;
int type = DRM_MODE_ENCODER_DAC; int type = DRM_MODE_ENCODER_DAC;
@ -1835,7 +1835,7 @@ static int
nv50_sor_create(struct drm_connector *connector, struct dcb_output *dcbe) nv50_sor_create(struct drm_connector *connector, struct dcb_output *dcbe)
{ {
struct nouveau_drm *drm = nouveau_drm(connector->dev); struct nouveau_drm *drm = nouveau_drm(connector->dev);
struct nouveau_i2c *i2c = nouveau_i2c(drm->device); struct nouveau_i2c *i2c = nvkm_i2c(&drm->device);
struct nouveau_encoder *nv_encoder; struct nouveau_encoder *nv_encoder;
struct drm_encoder *encoder; struct drm_encoder *encoder;
int type; int type;
@ -2006,7 +2006,7 @@ static int
nv50_pior_create(struct drm_connector *connector, struct dcb_output *dcbe) nv50_pior_create(struct drm_connector *connector, struct dcb_output *dcbe)
{ {
struct nouveau_drm *drm = nouveau_drm(connector->dev); struct nouveau_drm *drm = nouveau_drm(connector->dev);
struct nouveau_i2c *i2c = nouveau_i2c(drm->device); struct nouveau_i2c *i2c = nvkm_i2c(&drm->device);
struct nouveau_i2c_port *ddc = NULL; struct nouveau_i2c_port *ddc = NULL;
struct nouveau_encoder *nv_encoder; struct nouveau_encoder *nv_encoder;
struct drm_encoder *encoder; struct drm_encoder *encoder;
@ -2098,15 +2098,15 @@ nv50_fbdma_init(struct drm_device *dev, u32 name, u64 offset, u64 length, u8 kin
args.limit = offset + length - 1; args.limit = offset + length - 1;
args.conf0 = kind; args.conf0 = kind;
if (nv_device(drm->device)->chipset < 0x80) { if (drm->device.info.chipset < 0x80) {
args.conf0 = NV50_DMA_CONF0_ENABLE; args.conf0 = NV50_DMA_CONF0_ENABLE;
args.conf0 |= NV50_DMA_CONF0_PART_256; args.conf0 |= NV50_DMA_CONF0_PART_256;
} else } else
if (nv_device(drm->device)->chipset < 0xc0) { if (drm->device.info.chipset < 0xc0) {
args.conf0 |= NV50_DMA_CONF0_ENABLE; args.conf0 |= NV50_DMA_CONF0_ENABLE;
args.conf0 |= NV50_DMA_CONF0_PART_256; args.conf0 |= NV50_DMA_CONF0_PART_256;
} else } else
if (nv_device(drm->device)->chipset < 0xd0) { if (drm->device.info.chipset < 0xd0) {
args.conf0 |= NVC0_DMA_CONF0_ENABLE; args.conf0 |= NVC0_DMA_CONF0_ENABLE;
} else { } else {
args.conf0 |= NVD0_DMA_CONF0_ENABLE; args.conf0 |= NVD0_DMA_CONF0_ENABLE;
@ -2149,7 +2149,7 @@ nv50_fb_ctor(struct drm_framebuffer *fb)
struct nouveau_drm *drm = nouveau_drm(fb->dev); struct nouveau_drm *drm = nouveau_drm(fb->dev);
struct nouveau_bo *nvbo = nv_fb->nvbo; struct nouveau_bo *nvbo = nv_fb->nvbo;
struct nv50_disp *disp = nv50_disp(fb->dev); struct nv50_disp *disp = nv50_disp(fb->dev);
struct nouveau_fb *pfb = nouveau_fb(drm->device); struct nouveau_fb *pfb = nvkm_fb(&drm->device);
u8 kind = nouveau_bo_tile_layout(nvbo) >> 8; u8 kind = nouveau_bo_tile_layout(nvbo) >> 8;
u8 tile = nvbo->tile_mode; u8 tile = nvbo->tile_mode;
@ -2158,7 +2158,7 @@ nv50_fb_ctor(struct drm_framebuffer *fb)
return -EINVAL; return -EINVAL;
} }
if (nv_device(drm->device)->chipset >= 0xc0) if (drm->device.info.chipset >= 0xc0)
tile >>= 4; /* yep.. */ tile >>= 4; /* yep.. */
switch (fb->depth) { switch (fb->depth) {
@ -2245,7 +2245,7 @@ nv50_display_destroy(struct drm_device *dev)
int int
nv50_display_create(struct drm_device *dev) nv50_display_create(struct drm_device *dev)
{ {
struct nouveau_object *device = nouveau_drm(dev)->device; struct nvif_device *device = &nouveau_drm(dev)->device;
struct nouveau_drm *drm = nouveau_drm(dev); struct nouveau_drm *drm = nouveau_drm(dev);
struct dcb_table *dcb = &drm->vbios.dcb; struct dcb_table *dcb = &drm->vbios.dcb;
struct drm_connector *connector, *tmp; struct drm_connector *connector, *tmp;

14
drivers/gpu/drm/nouveau/nv84_fence.c
View File

@ -81,7 +81,7 @@ nv84_fence_emit(struct nouveau_fence *fence)
{ {
struct nouveau_channel *chan = fence->channel; struct nouveau_channel *chan = fence->channel;
struct nv84_fence_chan *fctx = chan->fence; struct nv84_fence_chan *fctx = chan->fence;
struct nouveau_fifo_chan *fifo = (void *)chan->object; struct nouveau_fifo_chan *fifo = nvkm_fifo_chan(chan);
u64 addr = fifo->chid * 16; u64 addr = fifo->chid * 16;
if (fence->sysmem) if (fence->sysmem)
@ -97,7 +97,7 @@ nv84_fence_sync(struct nouveau_fence *fence,
struct nouveau_channel *prev, struct nouveau_channel *chan) struct nouveau_channel *prev, struct nouveau_channel *chan)
{ {
struct nv84_fence_chan *fctx = chan->fence; struct nv84_fence_chan *fctx = chan->fence;
struct nouveau_fifo_chan *fifo = (void *)prev->object; struct nouveau_fifo_chan *fifo = nvkm_fifo_chan(prev);
u64 addr = fifo->chid * 16; u64 addr = fifo->chid * 16;
if (fence->sysmem) if (fence->sysmem)
@ -111,7 +111,7 @@ nv84_fence_sync(struct nouveau_fence *fence,
static u32 static u32
nv84_fence_read(struct nouveau_channel *chan) nv84_fence_read(struct nouveau_channel *chan)
{ {
struct nouveau_fifo_chan *fifo = (void *)chan->object; struct nouveau_fifo_chan *fifo = nvkm_fifo_chan(chan);
struct nv84_fence_priv *priv = chan->drm->fence; struct nv84_fence_priv *priv = chan->drm->fence;
return nouveau_bo_rd32(priv->bo, fifo->chid * 16/4); return nouveau_bo_rd32(priv->bo, fifo->chid * 16/4);
} }
@ -139,7 +139,7 @@ nv84_fence_context_del(struct nouveau_channel *chan)
int int
nv84_fence_context_new(struct nouveau_channel *chan) nv84_fence_context_new(struct nouveau_channel *chan)
{ {
struct nouveau_fifo_chan *fifo = (void *)chan->object; struct nouveau_fifo_chan *fifo = nvkm_fifo_chan(chan);
struct nouveau_cli *cli = chan->cli; struct nouveau_cli *cli = chan->cli;
struct nv84_fence_priv *priv = chan->drm->fence; struct nv84_fence_priv *priv = chan->drm->fence;
struct nv84_fence_chan *fctx; struct nv84_fence_chan *fctx;
@ -178,7 +178,7 @@ nv84_fence_context_new(struct nouveau_channel *chan)
static bool static bool
nv84_fence_suspend(struct nouveau_drm *drm) nv84_fence_suspend(struct nouveau_drm *drm)
{ {
struct nouveau_fifo *pfifo = nouveau_fifo(drm->device); struct nouveau_fifo *pfifo = nvkm_fifo(&drm->device);
struct nv84_fence_priv *priv = drm->fence; struct nv84_fence_priv *priv = drm->fence;
int i; int i;
@ -194,7 +194,7 @@ nv84_fence_suspend(struct nouveau_drm *drm)
static void static void
nv84_fence_resume(struct nouveau_drm *drm) nv84_fence_resume(struct nouveau_drm *drm)
{ {
struct nouveau_fifo *pfifo = nouveau_fifo(drm->device); struct nouveau_fifo *pfifo = nvkm_fifo(&drm->device);
struct nv84_fence_priv *priv = drm->fence; struct nv84_fence_priv *priv = drm->fence;
int i; int i;
@ -225,7 +225,7 @@ nv84_fence_destroy(struct nouveau_drm *drm)
int int
nv84_fence_create(struct nouveau_drm *drm) nv84_fence_create(struct nouveau_drm *drm)
{ {
struct nouveau_fifo *pfifo = nouveau_fifo(drm->device); struct nouveau_fifo *pfifo = nvkm_fifo(&drm->device);
struct nv84_fence_priv *priv; struct nv84_fence_priv *priv;
int ret; int ret;

1
drivers/gpu/drm/nouveau/nvif/object.h
View File

@ -54,7 +54,6 @@ void nvif_object_unmap(struct nvif_object *);
else \ else \
nvif_object_wr(_object, (b) / 8, (c), (d)); \ nvif_object_wr(_object, (b) / 8, (c), (d)); \
}) })
#define nvif_rd08(a,b) ({ u8 _v = nvif_rd((a), 8, (b)); _v; }) #define nvif_rd08(a,b) ({ u8 _v = nvif_rd((a), 8, (b)); _v; })
#define nvif_rd16(a,b) ({ u16 _v = nvif_rd((a), 16, (b)); _v; }) #define nvif_rd16(a,b) ({ u16 _v = nvif_rd((a), 16, (b)); _v; })
#define nvif_rd32(a,b) ({ u32 _v = nvif_rd((a), 32, (b)); _v; }) #define nvif_rd32(a,b) ({ u32 _v = nvif_rd((a), 32, (b)); _v; })