drm/nouveau: initial pass at moving to struct nvif_device
authorBen Skeggs <bskeggs@redhat.com>
Sat, 9 Aug 2014 18:10:22 +0000 (04:10 +1000)
committerBen Skeggs <bskeggs@redhat.com>
Sat, 9 Aug 2014 19:13:13 +0000 (05:13 +1000)
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>
41 files changed:
drivers/gpu/drm/nouveau/dispnv04/arb.c
drivers/gpu/drm/nouveau/dispnv04/crtc.c
drivers/gpu/drm/nouveau/dispnv04/cursor.c
drivers/gpu/drm/nouveau/dispnv04/dac.c
drivers/gpu/drm/nouveau/dispnv04/dfp.c
drivers/gpu/drm/nouveau/dispnv04/disp.c
drivers/gpu/drm/nouveau/dispnv04/disp.h
drivers/gpu/drm/nouveau/dispnv04/hw.c
drivers/gpu/drm/nouveau/dispnv04/hw.h
drivers/gpu/drm/nouveau/dispnv04/overlay.c
drivers/gpu/drm/nouveau/dispnv04/tvnv04.c
drivers/gpu/drm/nouveau/dispnv04/tvnv17.c
drivers/gpu/drm/nouveau/dispnv04/tvnv17.h
drivers/gpu/drm/nouveau/nouveau_abi16.c
drivers/gpu/drm/nouveau/nouveau_abi16.h
drivers/gpu/drm/nouveau/nouveau_agp.c
drivers/gpu/drm/nouveau/nouveau_backlight.c
drivers/gpu/drm/nouveau/nouveau_bios.c
drivers/gpu/drm/nouveau/nouveau_bo.c
drivers/gpu/drm/nouveau/nouveau_chan.c
drivers/gpu/drm/nouveau/nouveau_chan.h
drivers/gpu/drm/nouveau/nouveau_connector.c
drivers/gpu/drm/nouveau/nouveau_display.c
drivers/gpu/drm/nouveau/nouveau_dma.c
drivers/gpu/drm/nouveau/nouveau_dma.h
drivers/gpu/drm/nouveau/nouveau_drm.c
drivers/gpu/drm/nouveau/nouveau_drm.h
drivers/gpu/drm/nouveau/nouveau_fbcon.c
drivers/gpu/drm/nouveau/nouveau_fence.c
drivers/gpu/drm/nouveau/nouveau_gem.c
drivers/gpu/drm/nouveau/nouveau_hwmon.c
drivers/gpu/drm/nouveau/nouveau_sgdma.c
drivers/gpu/drm/nouveau/nouveau_sysfs.c
drivers/gpu/drm/nouveau/nouveau_ttm.c
drivers/gpu/drm/nouveau/nouveau_vga.c
drivers/gpu/drm/nouveau/nv04_fbcon.c
drivers/gpu/drm/nouveau/nv04_fence.c
drivers/gpu/drm/nouveau/nv10_fence.c
drivers/gpu/drm/nouveau/nv50_display.c
drivers/gpu/drm/nouveau/nv84_fence.c
drivers/gpu/drm/nouveau/nvif/object.h

index c64db854cc266ac8bb1aa4f82a079f137a84f9fe..c6361422a0b28329911611c4f104757e8bd48335 100644 (file)
@@ -198,7 +198,7 @@ nv04_update_arb(struct drm_device *dev, int VClk, int bpp,
                int *burst, int *lwm)
 {
        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_sim_state sim_data;
        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);
        }
 
-       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);
        else
                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);
 
-       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);
        else if ((dev->pdev->device & 0xfff0) == 0x0240 /*CHIPSET_C51*/ ||
                 (dev->pdev->device & 0xfff0) == 0x03d0 /*CHIPSET_C512*/) {
index 8b17d7d49e26d9536146c2eafa8f737ea3dc7fd3..b90aa5c1f90a1790cc5a2b83cdc40f006a6663b9 100644 (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 nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_bios *bios = nouveau_bios(drm->device);
-       struct nouveau_clock *clk = nouveau_clock(drm->device);
+       struct nouveau_bios *bios = nvkm_bios(&drm->device);
+       struct nouveau_clock *clk = nvkm_clock(&drm->device);
        struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
        struct nv04_mode_state *state = &nv04_display(dev)->mode_reg;
        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
         * 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));
 
 
@@ -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;
 
        /* 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;
        /* 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 |
                                 NV_PRAMDAC_PLL_COEFF_SELECT_SOURCE_PROG_NVPLL;
        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;
                horizBlankEnd = horizTotal + 4;
 #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 */
                        horizTotal += 2;
 #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 |
                             NV_PCRTC_CURSOR_CONFIG_CUR_PIXELS_64 |
                             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;
        if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
                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 */
        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_830 = mode->crtc_vdisplay - 3;
        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 */
                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);
 
-       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;
        else
                regp->crtc_cfg = NV04_PCRTC_CONFIG_START_ADDRESS_HSYNC;
 
        /* 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_86] = 0x1;
        }
@@ -581,7 +581,7 @@ nv_crtc_mode_set_regs(struct drm_crtc *crtc, struct drm_display_mode * mode)
 
        /* 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. */
                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;
        if (crtc->primary->fb->depth == 16)
                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_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);
        /* 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);
        nv_crtc_mode_set_regs(crtc, adjusted_mode);
        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. */
        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);
                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_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;
                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);
 
-                       if (nv_device(drm->device)->chipset == 0x11) {
+                       if (drm->device.info.chipset == 0x11) {
                                pixel = ((pixel & 0x000000ff) << 24) |
                                        ((pixel & 0x0000ff00) << 8) |
                                        ((pixel & 0x00ff0000) >> 8) |
@@ -1010,7 +1010,7 @@ nv04_crtc_cursor_set(struct drm_crtc *crtc, struct drm_file *file_priv,
        if (ret)
                goto out;
 
-       if (nv_device(drm->device)->chipset >= 0x11)
+       if (drm->device.info.chipset >= 0x11)
                nv11_cursor_upload(dev, cursor, nv_crtc->cursor.nvbo);
        else
                nv04_cursor_upload(dev, cursor, nv_crtc->cursor.nvbo);
index a810303169de97922016bcbf5206331dd8fbb53a..4e61173c3353e068b6309838078c2b5c26ed4520 100644 (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_ADDR1_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);
 }
 
index 3fec5e6b66b1d21a9ca845adf74be6a24c9640b1..2d8056cde9968d88ecbc5fca7832c3c354855d15 100644 (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])
 {
-       struct nouveau_object *device = nouveau_drm(dev)->device;
-       struct nouveau_timer *ptimer = nouveau_timer(device);
+       struct nvif_device *device = &nouveau_drm(dev)->device;
+       struct nouveau_timer *ptimer = nvkm_timer(device);
        int 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_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);
        uint8_t saved_seq1, saved_pi, saved_rpc1, saved_cr_mode;
        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 nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_object *device = nouveau_drm(dev)->device;
-       struct nouveau_gpio *gpio = nouveau_gpio(device);
+       struct nvif_device *device = &nouveau_drm(dev)->device;
+       struct nouveau_gpio *gpio = nvkm_gpio(device);
        struct dcb_output *dcb = nouveau_encoder(encoder)->dcb;
        uint32_t sample, testval, regoffset = nv04_dac_output_offset(encoder);
        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 */
        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)
                        routput |= 0x1a << 16;
                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 */
-       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);
        else
                NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + nv04_dac_output_offset(encoder), 0x00100000);
index a9f510e01c2fcf8f5cbc5aab77b160f8dbfb5548..42a5435259f7ae1b8939ab569078966def1d24e9 100644 (file)
@@ -281,7 +281,7 @@ static void nv04_dfp_mode_set(struct drm_encoder *encoder,
                              struct drm_display_mode *adjusted_mode)
 {
        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_crtc *nv_crtc = nouveau_crtc(encoder->crtc);
        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) ||
            (nv_connector->dithering_mode == DITHERING_MODE_AUTO &&
             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;
                else {
                        int i;
@@ -427,7 +427,7 @@ static void nv04_dfp_mode_set(struct drm_encoder *encoder,
                        }
                }
        } else {
-               if (nv_device(drm->device)->chipset != 0x11) {
+               if (drm->device.info.chipset != 0x11) {
                        /* reset them */
                        int 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);
 
        /* 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);
        else
                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__
        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
         * 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 dcb_output *dcb = nouveau_encoder(encoder)->dcb;
        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_board_info info[] = {
                {
index 4342fdaee707f252f12908b644bde7afab656fc8..e63f5d694c551b35a16525a9cdc65d100f26db35 100644 (file)
@@ -58,7 +58,7 @@ int
 nv04_display_create(struct drm_device *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 drm_connector *connector, *ct;
        struct drm_encoder *encoder;
index 99408cf03af020e6708017d5b32b4393f8cacb54..17b899d9aba3c9978a15ca664de1c5f4a5c7884f 100644 (file)
@@ -131,7 +131,7 @@ nv_two_heads(struct drm_device *dev)
        struct nouveau_drm *drm = nouveau_drm(dev);
        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)
                return true;
 
@@ -150,7 +150,7 @@ nv_two_reg_pll(struct drm_device *dev)
        struct nouveau_drm *drm = nouveau_drm(dev);
        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 false;
 }
@@ -172,7 +172,7 @@ nouveau_bios_run_init_table(struct drm_device *dev, u16 table,
                            struct dcb_output *outp, int crtc)
 {
        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 = {
                .subdev = nv_subdev(bios),
                .bios = bios,
index e09c35a948cab9a2f80ddf2726c27bba4e897037..c12f3a871da1519180c6e12821283b59a37ca5f4 100644 (file)
@@ -92,7 +92,7 @@ NVSetOwner(struct drm_device *dev, int owner)
        if (owner == 1)
                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
                 * omitting it often locks the system up.
                 */
@@ -103,7 +103,7 @@ NVSetOwner(struct drm_device *dev, int owner)
        /* CR44 is always changed on CRTC0 */
        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);
        }
@@ -152,7 +152,7 @@ nouveau_hw_decode_pll(struct drm_device *dev, uint32_t reg1, uint32_t pll1,
                pllvals->NM1 = pll1 & 0xffff;
                if (nv_two_reg_pll(dev) && pll2 & NV31_RAMDAC_ENABLE_VCO2)
                        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 */
                        if (pll1 & NV30_RAMDAC_ENABLE_VCO2) {
                                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_drm *drm = nouveau_drm(dev);
-       struct nouveau_object *device = drm->device;
-       struct nouveau_bios *bios = nouveau_bios(device);
+       struct nvif_device *device = &drm->device;
+       struct nouveau_bios *bios = nvkm_bios(device);
        uint32_t reg1, pll1, pll2 = 0;
        struct nvbios_pll pll_lim;
        int ret;
@@ -187,7 +187,7 @@ nouveau_hw_get_pllvals(struct drm_device *dev, enum nvbios_pll_type plltype,
                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);
 
                /* 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_object *device = drm->device;
-       struct nouveau_clock *clk = nouveau_clock(device);
-       struct nouveau_bios *bios = nouveau_bios(device);
+       struct nvif_device *device = &drm->device;
+       struct nouveau_clock *clk = nvkm_clock(device);
+       struct nouveau_bios *bios = nvkm_bios(device);
        struct nvbios_pll pll_lim;
        struct nouveau_pll_vals pv;
        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];
        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);
 
        nouveau_hw_get_pllvals(dev, head ? PLL_VPLL1 : PLL_VPLL0, &regp->pllvals);
        state->pllsel = NVReadRAMDAC(dev, 0, NV_PRAMDAC_PLL_COEFF_SELECT);
        if (nv_two_heads(dev))
                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->ramdac_gen_ctrl = NVReadRAMDAC(dev, head, NV_PRAMDAC_GENERAL_CONTROL);
 
        if (nv_gf4_disp_arch(dev))
                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->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))
                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_a24 = NVReadRAMDAC(dev, head, NV_PRAMDAC_A24);
                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 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];
        uint32_t pllreg = head ? NV_RAMDAC_VPLL2 : NV_PRAMDAC_VPLL_COEFF;
        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);
 
        clk->pll_prog(clk, pllreg, &regp->pllvals);
        NVWriteRAMDAC(dev, 0, NV_PRAMDAC_PLL_COEFF_SELECT, state->pllsel);
        if (nv_two_heads(dev))
                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_PRAMDAC_GENERAL_CONTROL, regp->ramdac_gen_ctrl);
 
        if (nv_gf4_disp_arch(dev))
                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_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))
                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_A24, regp->ramdac_a24);
                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_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);
 
-       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, 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_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_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);
 
-               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);
 
                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_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_CSB);
                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 nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_object *device = drm->device;
-       struct nouveau_timer *ptimer = nouveau_timer(device);
-       struct nouveau_fb *pfb = nouveau_fb(device);
+       struct nvif_device *device = &drm->device;
+       struct nouveau_timer *ptimer = nvkm_timer(device);
+       struct nouveau_fb *pfb = nvkm_fb(device);
        struct nv04_crtc_reg *regp = &state->crtc_reg[head];
        uint32_t reg900;
        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))
                        /* setting ENGINE_CTRL (EC) *must* come before
                         * 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_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);
 
-               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);
 
                        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_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);
 
-       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, 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_ADDR1_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);
        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_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_CSB);
                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. */
        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
                           CRE_53/CRE_54 causes lockups. */
                        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,
                      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;
 
        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,
                              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;
 
        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);
 
-       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 */
                nouveau_hw_fix_bad_vpll(dev, head);
        nv_save_state_ramdac(dev, head, state);
index ebaf33dbc1a17612d5f3d1bfa268643cf356a845..7f53c571f31fba18c0606915de89f69139cebe4e 100644 (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,
                                        int head, uint32_t reg)
 {
-       struct nouveau_object *device = nouveau_drm(dev)->device;
+       struct nvif_device *device = &nouveau_drm(dev)->device;
        uint32_t val;
        if (head)
                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,
                                        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)
                reg += NV_PCRTC0_SIZE;
        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,
                                        int head, uint32_t reg)
 {
-       struct nouveau_object *device = nouveau_drm(dev)->device;
+       struct nvif_device *device = &nouveau_drm(dev)->device;
        uint32_t val;
        if (head)
                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,
                                        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)
                reg += NV_PRAMDAC0_SIZE;
        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,
                                        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_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,
                                        int head, uint8_t index)
 {
-       struct nouveau_object *device = nouveau_drm(dev)->device;
+       struct nvif_device *device = &nouveau_drm(dev)->device;
        uint8_t val;
        nvif_wr08(device, NV_PRMCIO_CRX__COLOR + head * NV_PRMCIO_SIZE, index);
        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,
                                        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);
        uint8_t val;
 
        /* Only NV4x have two pvio ranges; other twoHeads cards MUST call
         * 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;
 
        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,
                                        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);
 
        /* Only NV4x have two pvio ranges; other twoHeads cards MUST call
         * 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;
 
        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)
 {
-       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_wr08(device, NV_PRMCIO_ARX + head * NV_PRMCIO_SIZE, enable ? 0 : 0x20);
 }
 
 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);
        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,
                                        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))
                index &= ~0x20;
        else
@@ -223,7 +223,7 @@ static inline void NVWriteVgaAttr(struct drm_device *dev,
 static inline uint8_t NVReadVgaAttr(struct drm_device *dev,
                                        int head, uint8_t index)
 {
-       struct nouveau_object *device = nouveau_drm(dev)->device;
+       struct nvif_device *device = &nouveau_drm(dev)->device;
        uint8_t val;
        if (NVGetEnablePalette(dev, head))
                index &= ~0x20;
@@ -259,10 +259,10 @@ static inline void NVVgaProtect(struct drm_device *dev, int head, bool protect)
 static inline bool
 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);
 
-       if (nv_device(drm->device)->chipset == 0x11)
+       if (drm->device.info.chipset == 0x11)
                return !!(nvif_rd32(device, NV_PBUS_DEBUG_1) & (1 << 28));
 
        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,
                       lock ? NV_CIO_SR_LOCK_VALUE : NV_CIO_SR_UNLOCK_RW_VALUE);
        /* 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,
                               lock ? NV_CIO_SR_LOCK_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);
 
-       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
@@ -357,7 +357,7 @@ nv_set_crtc_base(struct drm_device *dev, int head, uint32_t 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
                 * 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);
        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);
 }
 
@@ -398,7 +398,7 @@ nv_pitch_align(struct drm_device *dev, uint32_t width, int bpp)
                bpp = 8;
 
        /* 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;
        else
                mask = 512 / bpp - 1;
index bae8068b897f08cec9ea71609b49f3e483c357e7..b36afcbbc83febc9ccdee1cc63442b1a3ed8a46c 100644 (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_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_framebuffer *nv_fb = nouveau_framebuffer(fb);
        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)
                return -ERANGE;
 
-       if (nv_device(dev)->chipset >= 0x30) {
+       if (dev->info.chipset >= 0x30) {
                if (crtc_w < (src_w >> 1) || crtc_h < (src_h >> 1))
                        return -ERANGE;
        } else {
@@ -172,7 +172,7 @@ nv10_update_plane(struct drm_plane *plane, struct drm_crtc *crtc,
 static int
 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;
 
        nvif_wr32(dev, NV_PVIDEO_STOP, 1);
@@ -195,7 +195,7 @@ nv_destroy_plane(struct drm_plane *plane)
 static void
 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 chroma = ((sin_mul(plane->hue, plane->saturation) & 0xffff) << 16) |
                (cos_mul(plane->hue, plane->saturation) & 0xffff);
@@ -264,7 +264,7 @@ nv10_overlay_init(struct drm_device *device)
        if (!plane)
                return;
 
-       switch (nv_device(drm->device)->chipset) {
+       switch (drm->device.info.chipset) {
        case 0x10:
        case 0x11:
        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_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_framebuffer *nv_fb = nouveau_framebuffer(fb);
        struct nouveau_bo *cur = nv_plane->cur;
@@ -422,7 +422,7 @@ nv04_update_plane(struct drm_plane *plane, struct drm_crtc *crtc,
 static int
 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;
 
        nvif_mask(dev, NV_PVIDEO_OVERLAY, 1, 0);
@@ -489,9 +489,9 @@ err:
 void
 nouveau_overlay_init(struct drm_device *device)
 {
-       struct nouveau_object *dev = nouveau_drm(device)->device;
-       if (nv_device(dev)->chipset < 0x10)
+       struct nvif_device *dev = &nouveau_drm(device)->device;
+       if (dev->info.chipset < 0x10)
                nv04_overlay_init(device);
-       else if (nv_device(dev)->chipset <= 0x40)
+       else if (dev->info.chipset <= 0x40)
                nv10_overlay_init(device);
 }
index 8667620b703a3262baa4168868e42bf3680fe809..1ed54c9b5a4950b5c9388d5c65fda45aef4f79e6 100644 (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)
 {
        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",
                             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_device *dev = connector->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);
        int type, ret;
 
index 195bd8e86c6a523615679273bf71bc4fbc5aa6cc..28975b732c6a51a8824671c8531bdf7bcc172ea6 100644 (file)
@@ -51,7 +51,7 @@ static uint32_t nv42_tv_sample_load(struct drm_encoder *encoder)
 {
        struct drm_device *dev = encoder->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 gpio0, gpio1, fp_htotal, fp_hsync_start, fp_hsync_end,
                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)
 {
        struct nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_object *device = drm->device;
+       struct nvif_device *device = &drm->device;
 
        /* Zotac FX5200 */
-       if (nv_device_match(device, 0x0322, 0x19da, 0x1035) ||
-           nv_device_match(device, 0x0322, 0x19da, 0x2035)) {
+       if (nv_device_match(nvkm_object(device), 0x0322, 0x19da, 0x1035) ||
+           nv_device_match(nvkm_object(device), 0x0322, 0x19da, 0x2035)) {
                *pin_mask = 0xc;
                return false;
        }
 
        /* MSI nForce2 IGP */
-       if (nv_device_match(device, 0x01f0, 0x1462, 0x5710)) {
+       if (nv_device_match(nvkm_object(device), 0x01f0, 0x1462, 0x5710)) {
                *pin_mask = 0xc;
                return false;
        }
@@ -167,8 +167,8 @@ nv17_tv_detect(struct drm_encoder *encoder, struct drm_connector *connector)
                return connector_status_disconnected;
 
        if (reliable) {
-               if (nv_device(drm->device)->chipset == 0x42 ||
-                   nv_device(drm->device)->chipset == 0x43)
+               if (drm->device.info.chipset == 0x42 ||
+                   drm->device.info.chipset == 0x43)
                        tv_enc->pin_mask =
                                nv42_tv_sample_load(encoder) >> 28 & 0xe;
                else
@@ -375,7 +375,7 @@ static void  nv17_tv_dpms(struct drm_encoder *encoder, int mode)
 {
        struct drm_device *dev = encoder->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_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 */
        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;
 
        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;
                }
 
-               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_504 = 0x1710;
                        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);
 
        /* 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 +
                                        nv04_dac_output_offset(encoder),
                                        0xf0000000);
index ce40e398f895042cf9d32c4bc1aeace63bec58bc..225894cdcac2d5485274b7970372ffbd626fb608 100644 (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,
                                uint32_t val)
 {
-       struct nouveau_object *device = nouveau_drm(dev)->device;
+       struct nvif_device *device = &nouveau_drm(dev)->device;
        nvif_wr32(device, reg, val);
 }
 
 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);
 }
 
index 397256758c5b776806b4e2948b7033d6fbff6201..6a6f20f41ae9f7c9a1dc771836f72cb3ba702934 100644 (file)
 #include "nouveau_chan.h"
 #include "nouveau_abi16.h"
 
+void nouveau_drm_hack_device(struct nouveau_drm *, struct nvif_device *);
+
 struct nouveau_abi16 *
 nouveau_abi16_get(struct drm_file *file_priv, struct drm_device *dev)
 {
        struct nouveau_cli *cli = nouveau_cli(file_priv);
+       struct nouveau_drm *drm = nouveau_drm(dev);
        mutex_lock(&cli->mutex);
        if (!cli->abi16) {
                struct nouveau_abi16 *abi16;
@@ -60,8 +63,11 @@ nouveau_abi16_get(struct drm_file *file_priv, struct drm_device *dev)
                                                .device = ~0ULL,
                                               },
                                               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;
+                       }
 
                        kfree(cli->abi16);
                        cli->abi16 = NULL;
@@ -83,20 +89,19 @@ nouveau_abi16_put(struct nouveau_abi16 *abi16, int ret)
 u16
 nouveau_abi16_swclass(struct nouveau_drm *drm)
 {
-       switch (nv_device(drm->device)->card_type) {
-       case NV_04:
+       switch (drm->device.info.family) {
+       case NV_DEVICE_INFO_V0_TNT:
                return 0x006e;
-       case NV_10:
-       case NV_11:
-       case NV_20:
-       case NV_30:
-       case NV_40:
+       case NV_DEVICE_INFO_V0_CELSIUS:
+       case NV_DEVICE_INFO_V0_KELVIN:
+       case NV_DEVICE_INFO_V0_RANKINE:
+       case NV_DEVICE_INFO_V0_CURIE:
                return 0x016e;
-       case NV_50:
+       case NV_DEVICE_INFO_V0_TESLA:
                return 0x506e;
-       case NV_C0:
-       case NV_E0:
-       case GM100:
+       case NV_DEVICE_INFO_V0_FERMI:
+       case NV_DEVICE_INFO_V0_KEPLER:
+       case NV_DEVICE_INFO_V0_MAXWELL:
                return 0x906e;
        }
 
@@ -170,29 +175,29 @@ nouveau_abi16_ioctl_getparam(ABI16_IOCTL_ARGS)
 {
        struct nouveau_cli *cli = nouveau_cli(file_priv);
        struct nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_device *device = nv_device(drm->device);
-       struct nouveau_timer *ptimer = nouveau_timer(device);
-       struct nouveau_graph *graph = (void *)nouveau_engine(device, NVDEV_ENGINE_GR);
+       struct nvif_device *device = &drm->device;
+       struct nouveau_timer *ptimer = nvkm_timer(device);
+       struct nouveau_graph *graph = nvkm_gr(device);
        struct drm_nouveau_getparam *getparam = data;
 
        switch (getparam->param) {
        case NOUVEAU_GETPARAM_CHIPSET_ID:
-               getparam->value = device->chipset;
+               getparam->value = device->info.chipset;
                break;
        case NOUVEAU_GETPARAM_PCI_VENDOR:
-               if (nv_device_is_pci(device))
+               if (nv_device_is_pci(nvkm_device(device)))
                        getparam->value = dev->pdev->vendor;
                else
                        getparam->value = 0;
                break;
        case NOUVEAU_GETPARAM_PCI_DEVICE:
-               if (nv_device_is_pci(device))
+               if (nv_device_is_pci(nvkm_device(device)))
                        getparam->value = dev->pdev->device;
                else
                        getparam->value = 0;
                break;
        case NOUVEAU_GETPARAM_BUS_TYPE:
-               if (!nv_device_is_pci(device))
+               if (!nv_device_is_pci(nvkm_device(device)))
                        getparam->value = 3;
                else
                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_chan *chan;
        struct nouveau_client *client;
-       struct nouveau_device *device;
+       struct nvif_device *device;
        struct nouveau_instmem *imem;
        struct nouveau_fb *pfb;
        int ret;
@@ -259,12 +264,12 @@ nouveau_abi16_ioctl_channel_alloc(ABI16_IOCTL_ARGS)
                return nouveau_abi16_put(abi16, -ENODEV);
 
        client = nv_client(abi16->client);
-       device = nv_device(abi16->device);
-       imem   = nouveau_instmem(device);
-       pfb    = nouveau_fb(device);
+       device = &abi16->device;
+       imem   = nvkm_instmem(device);
+       pfb    = nvkm_fb(device);
 
        /* 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)
                        init->fb_ctxdma_handle = NVE0_CHANNEL_IND_ENGINE_GR;
                else
@@ -299,7 +304,7 @@ nouveau_abi16_ioctl_channel_alloc(ABI16_IOCTL_ARGS)
        if (ret)
                goto done;
 
-       if (device->card_type >= NV_50)
+       if (device->info.family >= NV_DEVICE_INFO_V0_TESLA)
                init->pushbuf_domains = NOUVEAU_GEM_DOMAIN_VRAM |
                                        NOUVEAU_GEM_DOMAIN_GART;
        else
@@ -308,7 +313,7 @@ nouveau_abi16_ioctl_channel_alloc(ABI16_IOCTL_ARGS)
        else
                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].grclass = 0x0000;
                init->subchan[1].handle = NvSw;
@@ -324,7 +329,7 @@ nouveau_abi16_ioctl_channel_alloc(ABI16_IOCTL_ARGS)
        if (ret)
                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,
                                        &chan->ntfy_vma);
                if (ret)
@@ -397,10 +402,10 @@ nouveau_abi16_ioctl_notifierobj_alloc(ABI16_IOCTL_ARGS)
 {
        struct drm_nouveau_notifierobj_alloc *info = data;
        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_chan *chan = NULL, *temp;
        struct nouveau_abi16_ntfy *ntfy;
+       struct nvif_device *device = &abi16->device;
        struct nouveau_object *object;
        struct nv_dma_class args = {};
        int ret;
@@ -409,7 +414,7 @@ nouveau_abi16_ioctl_notifierobj_alloc(ABI16_IOCTL_ARGS)
                return -ENOMEM;
 
        /* 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);
 
        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.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.start += chan->ntfy_vma.offset;
                args.limit += chan->ntfy_vma.offset;
index 90004081a50103532ddb652edad3668ba747db36..de0ee3fbc52fd16697a4508e68a25351f32ef17a 100644 (file)
@@ -29,7 +29,7 @@ struct nouveau_abi16_chan {
 
 struct nouveau_abi16 {
        struct nouveau_object *client;
-       struct nouveau_object *device;
+       struct nvif_device device;
        struct list_head channels;
        u64 handles;
 };
index 1f56becbbf36d628ccc3cf788d4a723d72e3ab3d..08561ffc3974a2aefd46263bed57653f61a955b0 100644 (file)
@@ -29,7 +29,7 @@ static struct nouveau_agpmode_quirk nouveau_agpmode_quirk_list[] = {
 static unsigned long
 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;
        int agpmode = nouveau_agpmode;
        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
         * randomly.
         */
-       if (device->chipset == 0x18)
+       if (device->info.chipset == 0x18)
                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) {
                if (info->id_vendor == quirk->hostbridge_vendor &&
                    info->id_device == quirk->hostbridge_device &&
-                   device->pdev->vendor == quirk->chip_vendor &&
-                   device->pdev->device == quirk->chip_device) {
+                   nvkm_device(device)->pdev->vendor == quirk->chip_vendor &&
+                   nvkm_device(device)->pdev->device == quirk->chip_device) {
                        agpmode = quirk->mode;
                        NV_INFO(drm, "Forcing agp mode to %dX. Use agpmode to override.\n",
                                agpmode);
@@ -104,7 +104,7 @@ void
 nouveau_agp_reset(struct nouveau_drm *drm)
 {
 #if __OS_HAS_AGP
-       struct nouveau_object *device = drm->device;
+       struct nvif_device *device = &drm->device;
        struct drm_device *dev = drm->dev;
        u32 save[2];
        int ret;
index dd2accd69f659665f1b269940da19b4d50488f55..e566c5b53651e0ab5265fed47f48c4792dd61046 100644 (file)
@@ -40,7 +40,7 @@ static int
 nv40_get_intensity(struct backlight_device *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) &
                                   NV40_PMC_BACKLIGHT_MASK) >> 16;
 
@@ -51,7 +51,7 @@ static int
 nv40_set_intensity(struct backlight_device *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 reg = nvif_rd32(device, NV40_PMC_BACKLIGHT);
 
@@ -71,7 +71,7 @@ static int
 nv40_backlight_init(struct drm_connector *connector)
 {
        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_device *bd;
 
@@ -97,7 +97,7 @@ nv50_get_intensity(struct backlight_device *bd)
 {
        struct nouveau_encoder *nv_encoder = bl_get_data(bd);
        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;
        u32 div = 1025;
        u32 val;
@@ -112,7 +112,7 @@ nv50_set_intensity(struct backlight_device *bd)
 {
        struct nouveau_encoder *nv_encoder = bl_get_data(bd);
        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;
        u32 div = 1025;
        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_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;
        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_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;
        u32 div, val;
 
@@ -177,7 +177,7 @@ static int
 nv50_backlight_init(struct drm_connector *connector)
 {
        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 backlight_properties props;
        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)))
                return 0;
 
-       if (nv_device(device)->chipset <= 0xa0 ||
-           nv_device(device)->chipset == 0xaa ||
-           nv_device(device)->chipset == 0xac)
+       if (device->info.chipset <= 0xa0 ||
+           device->info.chipset == 0xaa ||
+           device->info.chipset == 0xac)
                ops = &nv50_bl_ops;
        else
                ops = &nva3_bl_ops;
@@ -218,7 +218,7 @@ int
 nouveau_backlight_init(struct drm_device *dev)
 {
        struct nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_object *device = drm->device;
+       struct nvif_device *device = &drm->device;
        struct drm_connector *connector;
 
        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)
                        continue;
 
-               switch (nv_device(device)->card_type) {
-               case NV_40:
+               switch (device->info.family) {
+               case NV_DEVICE_INFO_V0_CURIE:
                        return nv40_backlight_init(connector);
-               case NV_50:
-               case NV_C0:
-               case NV_E0:
+               case NV_DEVICE_INFO_V0_TESLA:
+               case NV_DEVICE_INFO_V0_FERMI:
+               case NV_DEVICE_INFO_V0_KEPLER:
                        return nv50_backlight_init(connector);
                default:
                        break;
index 676a03fc0b516bbe8466aa37409e6df40369af93..61429b712c3bd6e87e8245de224009955ab70720 100644 (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_object *device = drm->device;
+       struct nvif_device *device = &drm->device;
        struct nvbios *bios = &drm->vbios;
        uint8_t lvds_ver = bios->data[bios->fp.lvdsmanufacturerpointer];
        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
 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
@@ -334,7 +334,7 @@ get_fp_strap(struct drm_device *dev, struct nvbios *bios)
        if (bios->major_version < 5 && bios->data[0x48] & 0x4)
                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;
        else
                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_object *device = drm->device;
+       struct nvif_device *device = &drm->device;
        struct nvbios *bios = &drm->vbios;
        int cv = bios->chip_version;
        uint16_t clktable = 0, scriptptr;
@@ -1253,7 +1253,7 @@ olddcb_table(struct drm_device *dev)
        struct nouveau_drm *drm = nouveau_drm(dev);
        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]);
        if (!dcb) {
                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_object *device = drm->device;
+       struct nvif_device *device = &drm->device;
        uint8_t bytes_to_write;
        uint16_t hwsq_entry_offset;
        int i;
@@ -2002,7 +2002,7 @@ uint8_t *nouveau_bios_embedded_edid(struct drm_device *dev)
 static bool NVInitVBIOS(struct drm_device *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;
 
        memset(legacy, 0, sizeof(struct nvbios));
@@ -2054,7 +2054,7 @@ nouveau_bios_posted(struct drm_device *dev)
        struct nouveau_drm *drm = nouveau_drm(dev);
        unsigned htotal;
 
-       if (nv_device(drm->device)->card_type >= NV_50)
+       if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA)
                return true;
 
        htotal  = NVReadVgaCrtc(dev, 0, 0x06);
index cfece9d603d94b8dbc828583ea7ae61dccef14a2..9c9291b3bfb5d7991ed2baf7e437f0ee8dccf52e 100644 (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);
        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_engine *engine;
 
@@ -109,7 +109,7 @@ nv10_bo_set_tiling(struct drm_device *dev, u32 addr,
                   u32 size, u32 pitch, u32 flags)
 {
        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;
        int i;
 
@@ -153,23 +153,23 @@ nouveau_bo_fixup_align(struct nouveau_bo *nvbo, u32 flags,
                       int *align, int *size)
 {
        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 (device->chipset >= 0x40) {
+                       if (device->info.chipset >= 0x40) {
                                *align = 65536;
                                *size = roundup(*size, 64 * nvbo->tile_mode);
 
-                       } else if (device->chipset >= 0x30) {
+                       } else if (device->info.chipset >= 0x30) {
                                *align = 32768;
                                *size = roundup(*size, 64 * nvbo->tile_mode);
 
-                       } else if (device->chipset >= 0x20) {
+                       } else if (device->info.chipset >= 0x20) {
                                *align = 16384;
                                *size = roundup(*size, 64 * nvbo->tile_mode);
 
-                       } else if (device->chipset >= 0x10) {
+                       } else if (device->info.chipset >= 0x10) {
                                *align = 16384;
                                *size = roundup(*size, 32 * nvbo->tile_mode);
                        }
@@ -261,11 +261,10 @@ static void
 set_placement_range(struct nouveau_bo *nvbo, uint32_t type)
 {
        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;
 
-       if ((nv_device(drm->device)->card_type == NV_10 ||
-            nv_device(drm->device)->card_type == NV_11) &&
+       if (drm->device.info.family == NV_DEVICE_INFO_V0_CELSIUS &&
            nvbo->tile_mode && (type & TTM_PL_FLAG_VRAM) &&
            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;
                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 */
-                       if (nouveau_bar(drm->device)->iomap_uncached) {
+                       if (nvkm_bar(&drm->device)->iomap_uncached) {
                                man->available_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;
        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;
                else
                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
         * 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);
                if (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)
                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,
                                                nvbo->tile_mode,
                                                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;
        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);
                if (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);
 
 out:
-       if (nv_device(drm->device)->card_type < NV_50) {
+       if (drm->device.info.family < NV_DEVICE_INFO_V0_TESLA) {
                if (ret)
                        nouveau_bo_vm_cleanup(bo, NULL, &new_tile);
                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;
                }
 #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 */
                        break;
                /* fallthrough, tiled memory */
        case TTM_PL_VRAM:
                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;
-               if (nv_device(drm->device)->card_type >= NV_50) {
-                       struct nouveau_bar *bar = nouveau_bar(drm->device);
+               if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA) {
+                       struct nouveau_bar *bar = nvkm_bar(&drm->device);
 
                        ret = bar->umap(bar, node, NV_MEM_ACCESS_RW,
                                        &node->bar_vma);
@@ -1285,7 +1284,7 @@ static void
 nouveau_ttm_io_mem_free(struct ttm_bo_device *bdev, struct ttm_mem_reg *mem)
 {
        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;
 
        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_bo *nvbo = nouveau_bo(bo);
-       struct nouveau_device *device = nv_device(drm->device);
-       u32 mappable = nv_device_resource_len(device, 1) >> PAGE_SHIFT;
+       struct nvif_device *device = &drm->device;
+       u32 mappable = nv_device_resource_len(nvkm_device(device), 1) >> PAGE_SHIFT;
        int ret;
 
        /* as long as the bo isn't in vram, and isn't tiled, we've got
         * nothing to do here.
         */
        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))
                        return 0;
 
@@ -1322,7 +1321,7 @@ nouveau_ttm_fault_reserve_notify(struct ttm_buffer_object *bo)
        }
 
        /* 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)
                return 0;
 
@@ -1357,7 +1356,7 @@ nouveau_ttm_tt_populate(struct ttm_tt *ttm)
        }
 
        drm = nouveau_bdev(ttm->bdev);
-       device = nv_device(drm->device);
+       device = nvkm_device(&drm->device);
        dev = drm->dev;
        pdev = nv_device_base(device);
 
@@ -1414,7 +1413,7 @@ nouveau_ttm_tt_unpopulate(struct ttm_tt *ttm)
                return;
 
        drm = nouveau_bdev(ttm->bdev);
-       device = nv_device(drm->device);
+       device = nvkm_device(&drm->device);
        dev = drm->dev;
        pdev = nv_device_base(device);
 
index 938df47a592e2485295581f29bad3ee3480dbe87..3f450d7295fb0fb7f4b604239cb128e1183ae4c9 100644 (file)
@@ -90,10 +90,10 @@ nouveau_channel_prep(struct nouveau_drm *drm, struct nouveau_cli *cli,
                     u32 parent, u32 handle, u32 size,
                     struct nouveau_channel **pchan)
 {
-       struct nouveau_device *device = nv_device(drm->device);
-       struct nouveau_instmem *imem = nouveau_instmem(device);
-       struct nouveau_vmmgr *vmm = nouveau_vmmgr(device);
-       struct nouveau_fb *pfb = nouveau_fb(device);
+       struct nvif_device *device = &drm->device;
+       struct nouveau_instmem *imem = nvkm_instmem(device);
+       struct nouveau_vmmgr *vmm = nvkm_vmmgr(device);
+       struct nouveau_fb *pfb = nvkm_fb(device);
        struct nouveau_client *client = &cli->base;
        struct nv_dma_class args = {};
        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.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,
                                        &chan->push.vma);
                if (ret) {
@@ -148,13 +148,13 @@ nouveau_channel_prep(struct nouveau_drm *drm, struct nouveau_cli *cli,
        } else
        if (chan->push.buffer->bo.mem.mem_type == TTM_PL_VRAM) {
                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
                         * the framebuffer bar rather than direct vram access..
                         * nfi why this exists, it came from the -nv ddx.
                         */
                        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;
                } else {
                        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 {
                ret = nouveau_object_new(nv_object(cli), parent, handle,
                                         *oclass++, &args, sizeof(args),
+                                        (struct nouveau_object **)
                                         &chan->object);
                if (ret == 0)
                        return ret;
@@ -251,6 +252,7 @@ nouveau_channel_dma(struct nouveau_drm *drm, struct nouveau_cli *cli,
        do {
                ret = nouveau_object_new(nv_object(cli), parent, handle,
                                         *oclass++, &args, sizeof(args),
+                                        (struct nouveau_object **)
                                         &chan->object);
                if (ret == 0)
                        return ret;
@@ -264,18 +266,18 @@ static int
 nouveau_channel_init(struct nouveau_channel *chan, u32 vram, u32 gart)
 {
        struct nouveau_client *client = nv_client(chan->cli);
-       struct nouveau_device *device = nv_device(chan->drm->device);
-       struct nouveau_instmem *imem = nouveau_instmem(device);
-       struct nouveau_vmmgr *vmm = nouveau_vmmgr(device);
-       struct nouveau_fb *pfb = nouveau_fb(device);
+       struct nvif_device *device = &chan->drm->device;
+       struct nouveau_instmem *imem = nvkm_instmem(device);
+       struct nouveau_vmmgr *vmm = nvkm_vmmgr(device);
+       struct nouveau_fb *pfb = nvkm_fb(device);
        struct nouveau_software_chan *swch;
        struct nouveau_object *object;
        struct nv_dma_class args = {};
        int ret, i;
 
        /* allocate dma objects to cover all allowed vram, and gart */
-       if (device->card_type < NV_C0) {
-               if (device->card_type >= NV_50) {
+       if (device->info.family < NV_DEVICE_INFO_V0_FERMI) {
+               if (device->info.family >= NV_DEVICE_INFO_V0_TESLA) {
                        args.flags = NV_DMA_TARGET_VM | NV_DMA_ACCESS_VM;
                        args.start = 0;
                        args.limit = client->vm->vmm->limit - 1;
@@ -290,7 +292,7 @@ nouveau_channel_init(struct nouveau_channel *chan, u32 vram, u32 gart)
                if (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.start = 0;
                        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);
 
        /* 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,
                                         NvSw, 0x006e, NULL, 0, &object);
                if (ret)
index 40f97e2c47b6014eea555c822571434ef3cd9209..a3fec949a2253f510808a5cc39382425efcf95d7 100644 (file)
@@ -34,7 +34,7 @@ struct nouveau_channel {
        u32 user_get;
        u32 user_put;
 
-       struct nouveau_object *object;
+       struct nvif_object *object;
 };
 
 
index 3f1db28edf9b8e735a7bb5a0dca23d3c384ee3c2..926f5bf2c83e5c3131e5a8cd91244d77e5219feb 100644 (file)
@@ -119,7 +119,7 @@ nouveau_connector_ddc_detect(struct drm_connector *connector)
        struct drm_device *dev = connector->dev;
        struct nouveau_connector *nv_connector = nouveau_connector(connector);
        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 drm_encoder *encoder;
        int i, panel = -ENODEV;
@@ -208,7 +208,7 @@ nouveau_connector_set_encoder(struct drm_connector *connector,
                return;
        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->doublescan_allowed = true;
        } else
@@ -218,9 +218,8 @@ nouveau_connector_set_encoder(struct drm_connector *connector,
                connector->interlace_allowed = false;
        } else {
                connector->doublescan_allowed = true;
-               if (nv_device(drm->device)->card_type == NV_20 ||
-                   ((nv_device(drm->device)->card_type == NV_10 ||
-                     nv_device(drm->device)->card_type == NV_11) &&
+               if (drm->device.info.family == NV_DEVICE_INFO_V0_KELVIN ||
+                   (drm->device.info.family == NV_DEVICE_INFO_V0_CELSIUS &&
                     (dev->pdev->device & 0x0ff0) != 0x0100 &&
                     (dev->pdev->device & 0x0ff0) != 0x0150))
                        /* HW is broken */
@@ -804,11 +803,11 @@ get_tmds_link_bandwidth(struct drm_connector *connector)
        struct dcb_output *dcb = nv_connector->detected_encoder->dcb;
 
        if (dcb->location != DCB_LOC_ON_CHIP ||
-           nv_device(drm->device)->chipset >= 0x46)
+           drm->device.info.chipset >= 0x46)
                return 165000;
-       else if (nv_device(drm->device)->chipset >= 0x40)
+       else if (drm->device.info.chipset >= 0x40)
                return 155000;
-       else if (nv_device(drm->device)->chipset >= 0x18)
+       else if (drm->device.info.chipset >= 0x18)
                return 135000;
        else
                return 112000;
@@ -1034,7 +1033,7 @@ nouveau_connector_create(struct drm_device *dev, int index)
        struct nouveau_drm *drm = nouveau_drm(dev);
        struct nouveau_display *disp = nouveau_display(dev);
        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;
        int type, ret = 0;
        bool dummy;
@@ -1188,7 +1187,7 @@ nouveau_connector_create(struct drm_device *dev, int index)
 
        switch (nv_connector->type) {
        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,
                                        dev->mode_config.scaling_mode_property,
                                        nv_connector->scaling_mode);
index eebcdd36ff46de06e325fcf433221cb7759cfa73..c63615b00d56a0aabe57bb66657f755bb958660c 100644 (file)
@@ -175,7 +175,7 @@ static int
 nouveau_display_vblank_init(struct drm_device *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;
        int ret;
 
@@ -445,15 +445,15 @@ nouveau_display_create(struct drm_device *dev)
        drm_mode_create_dvi_i_properties(dev);
 
        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_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_height = 2048;
        } 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_height = 4096;
        } else {
@@ -464,7 +464,7 @@ nouveau_display_create(struct drm_device *dev)
        dev->mode_config.preferred_depth = 24;
        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;
        else
                dev->mode_config.async_page_flip = true;
@@ -661,7 +661,7 @@ nouveau_page_flip_emit(struct nouveau_channel *chan,
        if (ret)
                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);
        else
                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);
 
        /* 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);
                if (ret)
                        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);
        if (s->event) {
                /* 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;
 
                drm_send_vblank_event(dev, crtcid, s->event);
@@ -833,7 +833,7 @@ nouveau_flip_complete(void *data)
        struct nouveau_page_flip_state 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 +
                                         state.y * state.pitch +
                                         state.x * state.bpp / 8);
index c177272152e24b7fb525891b8308668abfbeb460..da773abe6307c529c724998c18488901681c3e24 100644 (file)
@@ -54,9 +54,9 @@ READ_GET(struct nouveau_channel *chan, uint64_t *prev_get, int *timeout)
 {
        uint64_t val;
 
-       val = nv_ro32(chan->object, chan->user_get);
+       val = nvif_rd32(chan, chan->user_get);
         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
         * 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. */
        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--;
 }
 
@@ -114,7 +114,7 @@ nv50_dma_push_wait(struct nouveau_channel *chan, int count)
        uint32_t cnt = 0, prev_get = 0;
 
        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) {
                        prev_get = get;
                        cnt = 0;
index 30e46cc4fbfd7186e87c0e6aefe9482a8a6f3e05..28757c3f9438117f9583e0ca50ee688e8676913c 100644 (file)
@@ -154,7 +154,7 @@ BEGIN_IMC0(struct nouveau_channel *chan, int subc, int mthd, u16 data)
 #define WRITE_PUT(val) do {                                                    \
        mb();                                                   \
        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)
 
 static inline void
index 7c758b2f8d0ee9711bc7ed3fa315aa64a7abbffe..051e7104106d6707374c8fddbb9326407b31254d 100644 (file)
@@ -150,29 +150,58 @@ nouveau_accel_fini(struct nouveau_drm *drm)
 static void
 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;
        u32 arg0, arg1;
-       int ret;
+       u32 sclass[16];
+       int ret, i;
 
-       if (nouveau_noaccel || !nouveau_fifo(device) /*XXX*/)
+       if (nouveau_noaccel)
                return;
 
        /* initialise synchronisation routines */
-       if      (device->card_type < NV_10) ret = nv04_fence_create(drm);
-       else if (device->card_type < NV_11 ||
-                device->chipset   <  0x17) ret = nv10_fence_create(drm);
-       else if (device->card_type < NV_50) ret = nv17_fence_create(drm);
-       else if (device->chipset   <  0x84) ret = nv50_fence_create(drm);
-       else if (device->card_type < NV_C0) ret = nv84_fence_create(drm);
-       else                                ret = nvc0_fence_create(drm);
+       /*XXX: this is crap, but the fence/channel stuff is a little
+        *     backwards in some places.  this will be fixed.
+        */
+       ret = nouveau_parent_lclass(nvkm_object(device), sclass,
+                                   ARRAY_SIZE(sclass));
+       if (ret < 0)
+               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) {
                NV_ERROR(drm, "failed to initialise sync subsystem, %d\n", ret);
                nouveau_accel_fini(drm);
                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,
                                          NVDRM_CHAN + 1,
                                          NVE0_CHANNEL_IND_ENGINE_CE0 |
@@ -184,9 +213,9 @@ nouveau_accel_init(struct nouveau_drm *drm)
                arg0 = NVE0_CHANNEL_IND_ENGINE_GR;
                arg1 = 1;
        } else
-       if (device->chipset >= 0xa3 &&
-           device->chipset != 0xaa &&
-           device->chipset != 0xac) {
+       if (device->info.chipset >= 0xa3 &&
+           device->info.chipset != 0xaa &&
+           device->info.chipset != 0xac) {
                ret = nouveau_channel_new(drm, &drm->client, NVDRM_DEVICE,
                                          NVDRM_CHAN + 1, NvDmaFB, NvDmaTT,
                                          &drm->cechan);
@@ -214,11 +243,11 @@ nouveau_accel_init(struct nouveau_drm *drm)
                struct nouveau_software_chan *swch = (void *)object->parent;
                ret = RING_SPACE(drm->channel, 2);
                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);
                                OUT_RING  (drm->channel, NVDRM_NVSW);
                        } else
-                       if (device->card_type < NV_E0) {
+                       if (device->info.family < NV_DEVICE_INFO_V0_KEPLER) {
                                BEGIN_NVC0(drm->channel, FermiSw, 0, 1);
                                OUT_RING  (drm->channel, 0x001f0000);
                        }
@@ -234,9 +263,9 @@ nouveau_accel_init(struct nouveau_drm *drm)
                return;
        }
 
-       if (device->card_type < NV_C0) {
-               ret = nouveau_gpuobj_new(drm->device, NULL, 32, 0, 0,
-                                       &drm->notify);
+       if (device->info.family < NV_DEVICE_INFO_V0_FERMI) {
+               ret = nouveau_gpuobj_new(nvkm_object(&drm->device), NULL, 32,
+                                        0, 0, &drm->notify);
                if (ret) {
                        NV_ERROR(drm, "failed to allocate notifier, %d\n", ret);
                        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
 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),
                                                .debug0 = ~0,
                                         }, sizeof(struct nv_device_class),
-                                        &drm->device);
+                                        (struct nouveau_object **)
+                                        &drm->device.object);
                if (ret)
                        goto fail_device;
 
+               nouveau_drm_hack_device(drm, &drm->device);
+
                nouveau_agp_reset(drm);
                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,
                                        .debug0 = 0,
                                 }, sizeof(struct nv_device_class),
-                                &drm->device);
+                                (struct nouveau_object **)
+                                &drm->device.object);
        if (ret)
                goto fail_device;
 
+       nouveau_drm_hack_device(drm, &drm->device);
+
        dev->irq_enabled = true;
 
        /* workaround an odd issue on nvc1 by disabling the device's
         * nosnoop capability.  hopefully won't cause issues until a
         * better fix is found - assuming there is one...
         */
-       if (nv_device(drm->device)->chipset == 0xc1)
-               nvif_mask(drm->device, 0x00088080, 0x00000800, 0x00000000);
+       if (drm->device.info.chipset == 0xc1)
+               nvif_mask(&drm->device, 0x00088080, 0x00000800, 0x00000000);
 
        nouveau_vga_init(drm);
        nouveau_agp_init(drm);
 
-       if (nv_device(drm->device)->card_type >= NV_50) {
-               ret = nouveau_vm_new(nv_device(drm->device), 0, (1ULL << 40),
+       if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA) {
+               ret = nouveau_vm_new(nvkm_device(&drm->device), 0, (1ULL << 40),
                                     0x1000, &drm->client.vm);
                if (ret)
                        goto fail_device;
@@ -723,8 +779,8 @@ nouveau_drm_open(struct drm_device *dev, struct drm_file *fpriv)
        if (ret)
                goto out_suspend;
 
-       if (nv_device(drm->device)->card_type >= NV_50) {
-               ret = nouveau_vm_new(nv_device(drm->device), 0, (1ULL << 40),
+       if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA) {
+               ret = nouveau_vm_new(nvkm_device(&drm->device), 0, (1ULL << 40),
                                     0x1000, &cli->vm);
                if (ret) {
                        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 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;
 
        if (nouveau_runtime_pm == 0)
index e4f0196fc406e86fe4f47a0b4db00519173d3614..07e9c734cc46bee5dbced823fdb0467072f67078 100644 (file)
@@ -77,9 +77,21 @@ nouveau_cli(struct drm_file *fpriv)
        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) ({ \
-       struct nouveau_object *_object = (a); \
-       _object; \
+       struct nvif_object *_object = (a)->object; \
+       (struct nouveau_object *)_object; \
 })
 #define nvif_rd08(a,b) nv_ro08(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_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))
-
-/*XXX*/
-#include <core/object.h>
 #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;
 
@@ -99,7 +111,7 @@ struct nouveau_drm {
        struct nouveau_cli client;
        struct drm_device *dev;
 
-       struct nouveau_object *device;
+       struct nvif_device device;
        struct list_head clients;
 
        struct {
index 9364ad4fcc1d03d7c6226c2ac212fa8fe972ef78..b4d911e26ec87ed4d007dd3e772921f3185f5a12 100644 (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_drm *drm = nouveau_drm(fbcon->dev);
-       struct nouveau_device *device = nv_device(drm->device);
+       struct nvif_device *device = &drm->device;
        int ret;
 
        if (info->state != FBINFO_STATE_RUNNING)
@@ -74,10 +74,10 @@ nouveau_fbcon_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
        ret = -ENODEV;
        if (!in_interrupt() && !(info->flags & FBINFO_HWACCEL_DISABLED) &&
            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);
                else
-               if (device->card_type < NV_C0)
+               if (device->info.family < NV_DEVICE_INFO_V0_FERMI)
                        ret = nv50_fbcon_fillrect(info, rect);
                else
                        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_drm *drm = nouveau_drm(fbcon->dev);
-       struct nouveau_device *device = nv_device(drm->device);
+       struct nvif_device *device = &drm->device;
        int ret;
 
        if (info->state != FBINFO_STATE_RUNNING)
@@ -106,10 +106,10 @@ nouveau_fbcon_copyarea(struct fb_info *info, const struct fb_copyarea *image)
        ret = -ENODEV;
        if (!in_interrupt() && !(info->flags & FBINFO_HWACCEL_DISABLED) &&
            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);
                else
-               if (device->card_type < NV_C0)
+               if (device->info.family < NV_DEVICE_INFO_V0_FERMI)
                        ret = nv50_fbcon_copyarea(info, image);
                else
                        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_drm *drm = nouveau_drm(fbcon->dev);
-       struct nouveau_device *device = nv_device(drm->device);
+       struct nvif_device *device = &drm->device;
        int ret;
 
        if (info->state != FBINFO_STATE_RUNNING)
@@ -138,10 +138,10 @@ nouveau_fbcon_imageblit(struct fb_info *info, const struct fb_image *image)
        ret = -ENODEV;
        if (!in_interrupt() && !(info->flags & FBINFO_HWACCEL_DISABLED) &&
            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);
                else
-               if (device->card_type < NV_C0)
+               if (device->info.family < NV_DEVICE_INFO_V0_FERMI)
                        ret = nv50_fbcon_imageblit(info, image);
                else
                        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;
        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);
        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);
        else
                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 drm_device *dev = fbcon->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 drm_framebuffer *fb;
        struct nouveau_framebuffer *nouveau_fb;
@@ -351,7 +351,7 @@ nouveau_fbcon_create(struct drm_fb_helper *helper,
        }
 
        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,
                                        &fbcon->nouveau_fb.vma);
                if (ret) {
@@ -489,7 +489,7 @@ int
 nouveau_fbcon_init(struct drm_device *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;
        int preferred_bpp;
        int ret;
index c5efe25d06f179e122fc50cac4782080621939bf..35e32e1710bf07ac9e261b49f36ce2dbc0701726 100644 (file)
@@ -184,7 +184,7 @@ nouveau_fence_wait_uevent(struct nouveau_fence *fence, bool intr)
 
 {
        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_wait wait = { .priv = priv };
        int ret = 0;
index 04ebb22a101d3cd9f479f04a09acd405291f5ce4..49320219df9192106f0e7024066020363e8df61a 100644 (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 |
                              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;
 
        /* 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_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 nouveau_bo *nvbo = NULL;
        int ret = 0;
@@ -482,7 +482,7 @@ validate_list(struct nouveau_channel *chan, struct nouveau_cli *cli,
                        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 &&
                            ((nvbo->bo.mem.mem_type == TTM_PL_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);
                }
        } else
-       if (nv_device(drm->device)->chipset >= 0x25) {
+       if (drm->device.info.chipset >= 0x25) {
                ret = RING_SPACE(chan, req->nr_push * 2);
                if (ret) {
                        NV_PRINTK(error, cli, "cal_space: %d\n", ret);
@@ -853,7 +853,7 @@ out_next:
                req->suffix0 = 0x00000000;
                req->suffix1 = 0x00000000;
        } else
-       if (nv_device(drm->device)->chipset >= 0x25) {
+       if (drm->device.info.chipset >= 0x25) {
                req->suffix0 = 0x00020000;
                req->suffix1 = 0x00000000;
        } else {
index 19fd767bab100d9acc90765af696be81241b71a5..817d41a8a0a4d8272e5c80d65a83a7d6bacab060 100644 (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 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);
 
        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 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->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 nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_therm *therm = nouveau_therm(drm->device);
+       struct nouveau_therm *therm = nvkm_therm(&drm->device);
        long value;
 
        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 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->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 nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_therm *therm = nouveau_therm(drm->device);
+       struct nouveau_therm *therm = nvkm_therm(&drm->device);
        long value;
 
        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 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->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 nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_therm *therm = nouveau_therm(drm->device);
+       struct nouveau_therm *therm = nvkm_therm(&drm->device);
        long value;
 
        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 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->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 nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_therm *therm = nouveau_therm(drm->device);
+       struct nouveau_therm *therm = nvkm_therm(&drm->device);
        long value;
 
        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 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->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 nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_therm *therm = nouveau_therm(drm->device);
+       struct nouveau_therm *therm = nvkm_therm(&drm->device);
        long value;
 
        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 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->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 nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_therm *therm = nouveau_therm(drm->device);
+       struct nouveau_therm *therm = nvkm_therm(&drm->device);
        long value;
 
        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 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->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 nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_therm *therm = nouveau_therm(drm->device);
+       struct nouveau_therm *therm = nvkm_therm(&drm->device);
        long value;
 
        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 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->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 nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_therm *therm = nouveau_therm(drm->device);
+       struct nouveau_therm *therm = nvkm_therm(&drm->device);
        long value;
 
        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 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));
 }
@@ -363,7 +363,7 @@ nouveau_hwmon_get_pwm1_enable(struct device *d,
 {
        struct drm_device *dev = dev_get_drvdata(d);
        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;
 
        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 nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_therm *therm = nouveau_therm(drm->device);
+       struct nouveau_therm *therm = nvkm_therm(&drm->device);
        long value;
        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 nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_therm *therm = nouveau_therm(drm->device);
+       struct nouveau_therm *therm = nvkm_therm(&drm->device);
        int ret;
 
        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 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;
        long value;
 
@@ -442,7 +442,7 @@ nouveau_hwmon_get_pwm1_min(struct device *d,
 {
        struct drm_device *dev = dev_get_drvdata(d);
        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;
 
        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 nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_therm *therm = nouveau_therm(drm->device);
+       struct nouveau_therm *therm = nvkm_therm(&drm->device);
        long value;
        int ret;
 
@@ -482,7 +482,7 @@ nouveau_hwmon_get_pwm1_max(struct device *d,
 {
        struct drm_device *dev = dev_get_drvdata(d);
        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;
 
        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 nouveau_drm *drm = nouveau_drm(dev);
-       struct nouveau_therm *therm = nouveau_therm(drm->device);
+       struct nouveau_therm *therm = nvkm_therm(&drm->device);
        long value;
        int ret;
 
@@ -565,7 +565,7 @@ nouveau_hwmon_init(struct drm_device *dev)
 {
 #if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE))
        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 device *hwmon_dev;
        int ret = 0;
index a4d22e5eb176ef342023fdf0e581c564139139ed..ff10ef5eb298f70f38923e5970666ad7ae34d247 100644 (file)
@@ -104,7 +104,7 @@ nouveau_sgdma_create_ttm(struct ttm_bo_device *bdev,
                return NULL;
 
        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;
        else
                nvbe->ttm.ttm.func = &nv50_sgdma_backend;
index ab5afc50460a4bfc65ce35ae5b456ad431e7c0b6..29b6606abeaaa94f87c8cd1390565614d5501bba 100644 (file)
@@ -154,10 +154,10 @@ nouveau_sysfs_fini(struct drm_device *dev)
 {
        struct nouveau_sysfs *sysfs = nouveau_sysfs(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) {
-               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);
        }
 
@@ -169,7 +169,7 @@ int
 nouveau_sysfs_init(struct drm_device *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;
        int ret;
 
@@ -180,7 +180,7 @@ nouveau_sysfs_init(struct drm_device *dev)
        ret = nouveau_object_new(nv_object(drm), NVDRM_DEVICE, NVDRM_CONTROL,
                                 NV_CONTROL_CLASS, NULL, 0, &sysfs->ctrl);
        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;
 }
index 1f42cae2cd04016b35342a2894ab1e2686a1e905..8739e4d00c6dbf1b0b672559a9606b33dd28689c 100644 (file)
@@ -36,7 +36,7 @@ static int
 nouveau_vram_manager_init(struct ttm_mem_type_manager *man, unsigned long psize)
 {
        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;
        return 0;
 }
@@ -67,7 +67,7 @@ nouveau_vram_manager_del(struct ttm_mem_type_manager *man,
                         struct ttm_mem_reg *mem)
 {
        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);
        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 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_mem *node;
        u32 size_nc = 0;
@@ -176,13 +176,13 @@ nouveau_gart_manager_new(struct ttm_mem_type_manager *man,
 
        node->page_shift = 12;
 
-       switch (nv_device(drm->device)->card_type) {
-       case NV_50:
-               if (nv_device(drm->device)->chipset != 0x50)
+       switch (drm->device.info.family) {
+       case NV_DEVICE_INFO_V0_TESLA:
+               if (drm->device.info.chipset != 0x50)
                        node->memtype = (nvbo->tile_flags & 0x7f00) >> 8;
                break;
-       case NV_C0:
-       case NV_E0:
+       case NV_DEVICE_INFO_V0_FERMI:
+       case NV_DEVICE_INFO_V0_KEPLER:
                node->memtype = (nvbo->tile_flags & 0xff00) >> 8;
                break;
        default:
@@ -212,7 +212,7 @@ static int
 nv04_gart_manager_init(struct ttm_mem_type_manager *man, unsigned long psize)
 {
        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 nouveau_vm *vm = NULL;
        nouveau_vm_ref(priv->vm, &vm, NULL);
@@ -356,12 +356,11 @@ int
 nouveau_ttm_init(struct nouveau_drm *drm)
 {
        struct drm_device *dev = drm->dev;
-       struct nouveau_device *device = nv_device(drm->device);
        u32 bits;
        int ret;
 
-       bits = nouveau_vmmgr(drm->device)->dma_bits;
-       if (nv_device_is_pci(device)) {
+       bits = nvkm_vmmgr(&drm->device)->dma_bits;
+       if (nv_device_is_pci(nvkm_device(&drm->device))) {
                if (drm->agp.stat == ENABLED ||
                     !pci_dma_supported(dev->pdev, DMA_BIT_MASK(bits)))
                        bits = 32;
@@ -393,8 +392,8 @@ nouveau_ttm_init(struct nouveau_drm *drm)
        }
 
        /* VRAM init */
-       drm->gem.vram_available  = nouveau_fb(drm->device)->ram->size;
-       drm->gem.vram_available -= nouveau_instmem(drm->device)->reserved;
+       drm->gem.vram_available  = nvkm_fb(&drm->device)->ram->size;
+       drm->gem.vram_available -= nvkm_instmem(&drm->device)->reserved;
 
        ret = ttm_bo_init_mm(&drm->ttm.bdev, TTM_PL_VRAM,
                              drm->gem.vram_available >> PAGE_SHIFT);
@@ -403,12 +402,12 @@ nouveau_ttm_init(struct nouveau_drm *drm)
                return ret;
        }
 
-       drm->ttm.mtrr = arch_phys_wc_add(nv_device_resource_start(device, 1),
-                                        nv_device_resource_len(device, 1));
+       drm->ttm.mtrr = arch_phys_wc_add(nv_device_resource_start(nvkm_device(&drm->device), 1),
+                                        nv_device_resource_len(nvkm_device(&drm->device), 1));
 
        /* GART init */
        if (drm->agp.stat != ENABLED) {
-               drm->gem.gart_available = nouveau_vmmgr(drm->device)->limit;
+               drm->gem.gart_available = nvkm_vmmgr(&drm->device)->limit;
        } else {
                drm->gem.gart_available = drm->agp.size;
        }
index 0f0bafb4fe0285bd1a6a6804a6ea10296e8051f6..18d55d4472483ea5ef43c72087807eb0971ec9b4 100644 (file)
 static unsigned int
 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 &&
-           nv_device(device)->chipset >= 0x4c)
+       if (device->info.family == NV_DEVICE_INFO_V0_CURIE &&
+           device->info.chipset >= 0x4c)
                nvif_wr32(device, 0x088060, state);
        else
-       if (nv_device(device)->chipset >= 0x40)
+       if (device->info.chipset >= 0x40)
                nvif_wr32(device, 0x088054, state);
        else
                nvif_wr32(device, 0x001854, state);
index 8fe32bbed99a8352eec8cef3a53bf77d0fc07662..d3b9c7c24f49a742ebb4950453bdc35d9d0b41d3 100644 (file)
@@ -141,7 +141,7 @@ nv04_fbcon_accel_init(struct fb_info *info)
        struct drm_device *dev = nfbdev->dev;
        struct nouveau_drm *drm = nouveau_drm(dev);
        struct nouveau_channel *chan = drm->channel;
-       struct nouveau_device *device = nv_device(drm->device);
+       struct nvif_device *device = &drm->device;
        struct nouveau_object *object;
        int surface_fmt, pattern_fmt, rect_fmt;
        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,
-                                device->card_type >= NV_10 ? 0x0062 : 0x0042,
+                                device->info.family >= NV_DEVICE_INFO_V0_CELSIUS ? 0x0062 : 0x0042,
                                 NULL, 0, &object);
        if (ret)
                return ret;
@@ -201,7 +201,7 @@ nv04_fbcon_accel_init(struct fb_info *info)
                return ret;
 
        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);
        if (ret)
                return ret;
@@ -255,7 +255,7 @@ nv04_fbcon_accel_init(struct fb_info *info)
        OUT_RING(chan, NvCtxSurf2D);
        BEGIN_NV04(chan, NvSubImageBlit, 0x02fc, 1);
        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);
                OUT_RING(chan, 0);
                OUT_RING(chan, 1);
index 94eadd1dd10a40441736381ac35a18335d68bb8d..724b815d1517f3af20a9b781aeb26b088b369ba4 100644 (file)
@@ -59,7 +59,7 @@ nv04_fence_sync(struct nouveau_fence *fence,
 static u32
 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);
 }
 
index 06f434f03fbace2583cb9ed3c3c3400a807b48f8..2d38673fc2c2b8227d9454384fe78cad07383d71 100644 (file)
@@ -53,7 +53,7 @@ nv10_fence_sync(struct nouveau_fence *fence,
 u32
 nv10_fence_read(struct nouveau_channel *chan)
 {
-       return nv_ro32(chan->object, 0x0048);
+       return nvif_rd32(chan, 0x0048);
 }
 
 void
index 165ad49d3f31ca0f67242b53e79e950afa37585f..376b23530c0043a891bfd24b14a3f4ac6e3f5bfa 100644 (file)
@@ -317,7 +317,7 @@ evo_sync_wait(void *data)
 static int
 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_mast *mast = nv50_mast(dev);
        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_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;
        }
 
@@ -364,7 +364,7 @@ nv50_display_flip_wait(void *data)
 void
 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 = {
                .disp = nv50_disp(crtc->dev),
                .chan = nv50_sync(crtc),
@@ -384,7 +384,7 @@ nv50_display_flip_stop(struct drm_crtc *crtc)
                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
@@ -1493,7 +1493,7 @@ static int
 nv50_dac_create(struct drm_connector *connector, struct dcb_output *dcbe)
 {
        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 drm_encoder *encoder;
        int type = DRM_MODE_ENCODER_DAC;
@@ -1835,7 +1835,7 @@ static int
 nv50_sor_create(struct drm_connector *connector, struct dcb_output *dcbe)
 {
        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 drm_encoder *encoder;
        int type;
@@ -2006,7 +2006,7 @@ static int
 nv50_pior_create(struct drm_connector *connector, struct dcb_output *dcbe)
 {
        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_encoder *nv_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.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_PART_256;
        } 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_PART_256;
        } else
-       if (nv_device(drm->device)->chipset < 0xd0) {
+       if (drm->device.info.chipset < 0xd0) {
                args.conf0 |= NVC0_DMA_CONF0_ENABLE;
        } else {
                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_bo *nvbo = nv_fb->nvbo;
        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 tile = nvbo->tile_mode;
 
@@ -2158,7 +2158,7 @@ nv50_fb_ctor(struct drm_framebuffer *fb)
                return -EINVAL;
        }
 
-       if (nv_device(drm->device)->chipset >= 0xc0)
+       if (drm->device.info.chipset >= 0xc0)
                tile >>= 4; /* yep.. */
 
        switch (fb->depth) {
@@ -2245,7 +2245,7 @@ nv50_display_destroy(struct drm_device *dev)
 int
 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 dcb_table *dcb = &drm->vbios.dcb;
        struct drm_connector *connector, *tmp;
index 7103a771aa8754f255c1b38fc0b4ad5b3531a68d..94184a94a7634e126ea9714c40f53dc50b56b03b 100644 (file)
@@ -81,7 +81,7 @@ nv84_fence_emit(struct nouveau_fence *fence)
 {
        struct nouveau_channel *chan = fence->channel;
        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;
 
        if (fence->sysmem)
@@ -97,7 +97,7 @@ nv84_fence_sync(struct nouveau_fence *fence,
                struct nouveau_channel *prev, struct nouveau_channel *chan)
 {
        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;
 
        if (fence->sysmem)
@@ -111,7 +111,7 @@ nv84_fence_sync(struct nouveau_fence *fence,
 static u32
 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;
        return nouveau_bo_rd32(priv->bo, fifo->chid * 16/4);
 }
@@ -139,7 +139,7 @@ nv84_fence_context_del(struct nouveau_channel *chan)
 int
 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 nv84_fence_priv *priv = chan->drm->fence;
        struct nv84_fence_chan *fctx;
@@ -178,7 +178,7 @@ nv84_fence_context_new(struct nouveau_channel *chan)
 static bool
 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;
        int i;
 
@@ -194,7 +194,7 @@ nv84_fence_suspend(struct nouveau_drm *drm)
 static void
 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;
        int i;
 
@@ -225,7 +225,7 @@ nv84_fence_destroy(struct nouveau_drm *drm)
 int
 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;
        int ret;
 
index dce62736f542189f882934d93cf8feab10358294..a5d82814a9b074ada4778af3c05faa7f9f553e2e 100644 (file)
@@ -54,7 +54,6 @@ void nvif_object_unmap(struct nvif_object *);
        else                                                                   \
                nvif_object_wr(_object, (b) / 8, (c), (d));                    \
 })
-
 #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_rd32(a,b) ({ u32 _v = nvif_rd((a), 32, (b)); _v; })