return;
                drm_printf(&p, "  placement[%d]=0x%08X (%d)\n",
                           i, placement->placement[i].flags, mem_type);
-               man = &bo->bdev->man[mem_type];
+               man = ttm_manager_type(bo->bdev, mem_type);
                ttm_mem_type_manager_debug(man, &p);
        }
 }
        if (mem->placement & TTM_PL_FLAG_NO_EVICT)
                return;
 
-       man = &bdev->man[mem->mem_type];
+       man = ttm_manager_type(bdev, mem->mem_type);
        list_add_tail(&bo->lru, &man->lru[bo->priority]);
 
        if (man->use_tt && bo->ttm &&
                dma_resv_assert_held(pos->first->base.resv);
                dma_resv_assert_held(pos->last->base.resv);
 
-               man = &pos->first->bdev->man[TTM_PL_TT];
+               man = ttm_manager_type(pos->first->bdev, TTM_PL_TT);
                list_bulk_move_tail(&man->lru[i], &pos->first->lru,
                                    &pos->last->lru);
        }
                dma_resv_assert_held(pos->first->base.resv);
                dma_resv_assert_held(pos->last->base.resv);
 
-               man = &pos->first->bdev->man[TTM_PL_VRAM];
+               man = ttm_manager_type(pos->first->bdev, TTM_PL_VRAM);
                list_bulk_move_tail(&man->lru[i], &pos->first->lru,
                                    &pos->last->lru);
        }
                                  struct ttm_operation_ctx *ctx)
 {
        struct ttm_bo_device *bdev = bo->bdev;
-       struct ttm_mem_type_manager *old_man = &bdev->man[bo->mem.mem_type];
-       struct ttm_mem_type_manager *new_man = &bdev->man[mem->mem_type];
+       struct ttm_mem_type_manager *old_man = ttm_manager_type(bdev, bo->mem.mem_type);
+       struct ttm_mem_type_manager *new_man = ttm_manager_type(bdev, mem->mem_type);
        int ret;
 
        ret = ttm_mem_io_lock(old_man, true);
        return 0;
 
 out_err:
-       new_man = &bdev->man[bo->mem.mem_type];
+       new_man = ttm_manager_type(bdev, bo->mem.mem_type);
        if (!new_man->use_tt) {
                ttm_tt_destroy(bo->ttm);
                bo->ttm = NULL;
        struct ttm_buffer_object *bo =
            container_of(kref, struct ttm_buffer_object, kref);
        struct ttm_bo_device *bdev = bo->bdev;
-       struct ttm_mem_type_manager *man = &bdev->man[bo->mem.mem_type];
+       struct ttm_mem_type_manager *man = ttm_manager_type(bdev, bo->mem.mem_type);
        size_t acc_size = bo->acc_size;
        int ret;
 
                          const struct ttm_place *place,
                          struct ttm_mem_reg *mem)
 {
-       struct ttm_mem_type_manager *man = &bo->bdev->man[mem->mem_type];
+       struct ttm_mem_type_manager *man = ttm_manager_type(bo->bdev, mem->mem_type);
 
        mem->mm_node = NULL;
        if (!man->func || !man->func->get_node)
 
 void ttm_bo_mem_put(struct ttm_buffer_object *bo, struct ttm_mem_reg *mem)
 {
-       struct ttm_mem_type_manager *man = &bo->bdev->man[mem->mem_type];
+       struct ttm_mem_type_manager *man = ttm_manager_type(bo->bdev, mem->mem_type);
 
        if (!man->func || !man->func->put_node)
                return;
                                  struct ttm_operation_ctx *ctx)
 {
        struct ttm_bo_device *bdev = bo->bdev;
-       struct ttm_mem_type_manager *man = &bdev->man[mem->mem_type];
+       struct ttm_mem_type_manager *man = ttm_manager_type(bdev, mem->mem_type);
        struct ww_acquire_ctx *ticket;
        int ret;
 
        if (ret)
                return ret;
 
-       man = &bdev->man[mem_type];
+       man = ttm_manager_type(bdev, mem_type);
        if (!man->has_type || !man->use_type)
                return -EBUSY;
 
                if (unlikely(ret))
                        goto error;
 
-               man = &bdev->man[mem->mem_type];
+               man = ttm_manager_type(bdev, mem->mem_type);
                ret = ttm_bo_add_move_fence(bo, man, mem, ctx->no_wait_gpu);
                if (unlikely(ret)) {
                        ttm_bo_mem_put(bo, mem);
 
 int ttm_bo_evict_mm(struct ttm_bo_device *bdev, unsigned mem_type)
 {
-       struct ttm_mem_type_manager *man = &bdev->man[mem_type];
+       struct ttm_mem_type_manager *man = ttm_manager_type(bdev, mem_type);
 
        if (mem_type == 0 || mem_type >= TTM_NUM_MEM_TYPES) {
                pr_err("Illegal memory manager memory type %u\n", mem_type);
        unsigned i;
        struct ttm_mem_type_manager *man;
 
-       man = &bdev->man[TTM_PL_SYSTEM];
+       man = ttm_manager_type(bdev, TTM_PL_SYSTEM);
        ttm_mem_type_manager_disable(man);
 
        mutex_lock(&ttm_global_mutex);
 
 static void ttm_bo_init_sysman(struct ttm_bo_device *bdev)
 {
-       struct ttm_mem_type_manager *man = &bdev->man[TTM_PL_SYSTEM];
+       struct ttm_mem_type_manager *man = ttm_manager_type(bdev, TTM_PL_SYSTEM);
 
        /*
         * Initialize the system memory buffer type.
 void ttm_bo_unmap_virtual(struct ttm_buffer_object *bo)
 {
        struct ttm_bo_device *bdev = bo->bdev;
-       struct ttm_mem_type_manager *man = &bdev->man[bo->mem.mem_type];
+       struct ttm_mem_type_manager *man = ttm_manager_type(bdev, bo->mem.mem_type);
 
        ttm_mem_io_lock(man, false);
        ttm_bo_unmap_virtual_locked(bo);
 
 int ttm_mem_io_reserve(struct ttm_bo_device *bdev,
                       struct ttm_mem_reg *mem)
 {
-       struct ttm_mem_type_manager *man = &bdev->man[mem->mem_type];
+       struct ttm_mem_type_manager *man = ttm_manager_type(bdev, mem->mem_type);
        int ret;
 
        if (mem->bus.io_reserved_count++)
 
 int ttm_mem_io_reserve_vm(struct ttm_buffer_object *bo)
 {
-       struct ttm_mem_type_manager *man = &bo->bdev->man[bo->mem.mem_type];
+       struct ttm_mem_type_manager *man = ttm_manager_type(bo->bdev, bo->mem.mem_type);
        struct ttm_mem_reg *mem = &bo->mem;
        int ret;
 
                               struct ttm_mem_reg *mem,
                               void **virtual)
 {
-       struct ttm_mem_type_manager *man = &bdev->man[mem->mem_type];
+       struct ttm_mem_type_manager *man = ttm_manager_type(bdev, mem->mem_type);
        int ret;
        void *addr;
 
 {
        struct ttm_mem_type_manager *man;
 
-       man = &bdev->man[mem->mem_type];
+       man = ttm_manager_type(bdev, mem->mem_type);
 
        if (virtual && mem->bus.addr == NULL)
                iounmap(virtual);
                       struct ttm_mem_reg *new_mem)
 {
        struct ttm_bo_device *bdev = bo->bdev;
-       struct ttm_mem_type_manager *man = &bdev->man[new_mem->mem_type];
+       struct ttm_mem_type_manager *man = ttm_manager_type(bdev, new_mem->mem_type);
        struct ttm_tt *ttm = bo->ttm;
        struct ttm_mem_reg *old_mem = &bo->mem;
        struct ttm_mem_reg old_copy = *old_mem;
                struct ttm_bo_kmap_obj *map)
 {
        struct ttm_mem_type_manager *man =
-               &bo->bdev->man[bo->mem.mem_type];
+               ttm_manager_type(bo->bdev, bo->mem.mem_type);
        unsigned long offset, size;
        int ret;
 
 {
        struct ttm_buffer_object *bo = map->bo;
        struct ttm_mem_type_manager *man =
-               &bo->bdev->man[bo->mem.mem_type];
+               ttm_manager_type(bo->bdev, bo->mem.mem_type);
 
        if (!map->virtual)
                return;
                              struct ttm_mem_reg *new_mem)
 {
        struct ttm_bo_device *bdev = bo->bdev;
-       struct ttm_mem_type_manager *man = &bdev->man[new_mem->mem_type];
+       struct ttm_mem_type_manager *man = ttm_manager_type(bdev, new_mem->mem_type);
        struct ttm_mem_reg *old_mem = &bo->mem;
        int ret;
        struct ttm_buffer_object *ghost_obj;
        struct ttm_bo_device *bdev = bo->bdev;
        struct ttm_mem_reg *old_mem = &bo->mem;
 
-       struct ttm_mem_type_manager *from = &bdev->man[old_mem->mem_type];
-       struct ttm_mem_type_manager *to = &bdev->man[new_mem->mem_type];
+       struct ttm_mem_type_manager *from = ttm_manager_type(bdev, old_mem->mem_type);
+       struct ttm_mem_type_manager *to = ttm_manager_type(bdev, new_mem->mem_type);
 
        int ret;