unsigned int queue_id;
        struct kfd_process_device *pdd;
        struct queue_properties q_properties;
+       uint32_t doorbell_offset_in_process = 0;
 
        memset(&q_properties, 0, sizeof(struct queue_properties));
 
                        p->pasid,
                        dev->id);
 
-       err = pqm_create_queue(&p->pqm, dev, filep, &q_properties, &queue_id);
+       err = pqm_create_queue(&p->pqm, dev, filep, &q_properties, &queue_id,
+                       &doorbell_offset_in_process);
        if (err != 0)
                goto err_create_queue;
 
        args->doorbell_offset = KFD_MMAP_TYPE_DOORBELL;
        args->doorbell_offset |= KFD_MMAP_GPU_ID(args->gpu_id);
        if (KFD_IS_SOC15(dev->device_info->asic_family))
-               /* On SOC15 ASICs, doorbell allocation must be
-                * per-device, and independent from the per-process
-                * queue_id. Return the doorbell offset within the
-                * doorbell aperture to user mode.
+               /* On SOC15 ASICs, include the doorbell offset within the
+                * process doorbell frame, which is 2 pages.
                 */
-               args->doorbell_offset |= q_properties.doorbell_off;
+               args->doorbell_offset |= doorbell_offset_in_process;
 
        mutex_unlock(&p->mutex);
 
 
        properties.type = KFD_QUEUE_TYPE_DIQ;
 
        status = pqm_create_queue(dbgdev->pqm, dbgdev->dev, NULL,
-                               &properties, &qid);
+                               &properties, &qid, NULL);
 
        if (status) {
                pr_err("Failed to create DIQ\n");
 
                            struct kfd_dev *dev,
                            struct file *f,
                            struct queue_properties *properties,
-                           unsigned int *qid);
+                           unsigned int *qid,
+                           uint32_t *p_doorbell_offset_in_process);
 int pqm_destroy_queue(struct process_queue_manager *pqm, unsigned int qid);
 int pqm_update_queue(struct process_queue_manager *pqm, unsigned int qid,
                        struct queue_properties *p);
 
                            struct kfd_dev *dev,
                            struct file *f,
                            struct queue_properties *properties,
-                           unsigned int *qid)
+                           unsigned int *qid,
+                           uint32_t *p_doorbell_offset_in_process)
 {
        int retval;
        struct kfd_process_device *pdd;
                goto err_create_queue;
        }
 
-       if (q)
+       if (q && p_doorbell_offset_in_process)
                /* Return the doorbell offset within the doorbell page
                 * to the caller so it can be passed up to user mode
                 * (in bytes).
+                * There are always 1024 doorbells per process, so in case
+                * of 8-byte doorbells, there are two doorbell pages per
+                * process.
                 */
-               properties->doorbell_off =
+               *p_doorbell_offset_in_process =
                        (q->properties.doorbell_off * sizeof(uint32_t)) &
                        (kfd_doorbell_process_slice(dev) - 1);