Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'char-misc-5.10-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc
Pull char/misc driver fixes from Greg KH:
"Here are some small char/misc/whatever driver fixes for 5.10-rc4.
Nothing huge, lots of small fixes for reported issues:
- habanalabs driver fixes
- speakup driver fixes
- uio driver fixes
- virtio driver fix
- other tiny driver fixes
Full details are in the shortlog.
All of these have been in linux-next for a full week with no reported
issues"
* tag 'char-misc-5.10-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc:
uio: Fix use-after-free in uio_unregister_device()
firmware: xilinx: fix out-of-bounds access
nitro_enclaves: Fixup type and simplify logic of the poll mask setup
speakup ttyio: Do not schedule() in ttyio_in_nowait
speakup: Fix clearing selection in safe context
speakup: Fix var_id_t values and thus keymap
virtio: virtio_console: fix DMA memory allocation for rproc serial
habanalabs/gaudi: mask WDT error in QMAN
habanalabs/gaudi: move coresight mmu config
habanalabs: fix kernel pointer type
mei: protect mei_cl_mtu from null dereference
+95
-99
-1
drivers/accessibility/speakup/main.c
-1
drivers/accessibility/speakup/main.c
+4
-7
drivers/accessibility/speakup/selection.c
+4
-7
drivers/accessibility/speakup/selection.c
···
22
22
struct tty_struct *tty;
23
23
};
24
24
25
-
void speakup_clear_selection(void)
26
-
{
27
-
console_lock();
28
-
clear_selection();
29
-
console_unlock();
30
-
}
31
-
32
25
static void __speakup_set_selection(struct work_struct *work)
33
26
{
34
27
struct speakup_selection_work *ssw =
···
43
50
pr_warn("Selection: mark console not the same as cut\n");
44
51
goto unref;
45
52
}
53
+
54
+
console_lock();
55
+
clear_selection();
56
+
console_unlock();
46
57
47
58
set_selection_kernel(&sel, tty);
48
59
-1
drivers/accessibility/speakup/speakup.h
-1
drivers/accessibility/speakup/speakup.h
···
70
70
void speakup_start_ttys(void);
71
71
void synth_buffer_add(u16 ch);
72
72
void synth_buffer_clear(void);
73
-
void speakup_clear_selection(void);
74
73
int speakup_set_selection(struct tty_struct *tty);
75
74
void speakup_cancel_selection(void);
76
75
int speakup_paste_selection(struct tty_struct *tty);
+6
-4
drivers/accessibility/speakup/spk_ttyio.c
+6
-4
drivers/accessibility/speakup/spk_ttyio.c
···
298
298
struct spk_ldisc_data *ldisc_data = speakup_tty->disc_data;
299
299
char rv;
300
300
301
-
if (wait_for_completion_timeout(&ldisc_data->completion,
301
+
if (!timeout) {
302
+
if (!try_wait_for_completion(&ldisc_data->completion))
303
+
return 0xff;
304
+
} else if (wait_for_completion_timeout(&ldisc_data->completion,
302
305
usecs_to_jiffies(timeout)) == 0) {
303
-
if (timeout)
304
-
pr_warn("spk_ttyio: timeout (%d) while waiting for input\n",
305
-
timeout);
306
+
pr_warn("spk_ttyio: timeout (%d) while waiting for input\n",
307
+
timeout);
306
308
return 0xff;
307
309
}
308
310
+6
-2
drivers/accessibility/speakup/spk_types.h
+6
-2
drivers/accessibility/speakup/spk_types.h
···
32
32
E_NEW_DEFAULT,
33
33
};
34
34
35
+
/*
36
+
* Note: add new members at the end, speakupmap.h depends on the values of the
37
+
* enum starting from SPELL_DELAY (see inc_dec_var)
38
+
*/
35
39
enum var_id_t {
36
40
VERSION = 0, SYNTH, SILENT, SYNTH_DIRECT,
37
41
KEYMAP, CHARS,
···
46
42
SAY_CONTROL, SAY_WORD_CTL, NO_INTERRUPT, KEY_ECHO,
47
43
SPELL_DELAY, PUNC_LEVEL, READING_PUNC,
48
44
ATTRIB_BLEEP, BLEEPS,
49
-
RATE, PITCH, INFLECTION, VOL, TONE, PUNCT, VOICE, FREQUENCY, LANG,
45
+
RATE, PITCH, VOL, TONE, PUNCT, VOICE, FREQUENCY, LANG,
50
46
DIRECT, PAUSE,
51
-
CAPS_START, CAPS_STOP, CHARTAB,
47
+
CAPS_START, CAPS_STOP, CHARTAB, INFLECTION,
52
48
MAXVARS
53
49
};
54
50
+4
-4
drivers/char/virtio_console.c
+4
-4
drivers/char/virtio_console.c
···
435
435
/*
436
436
* Allocate DMA memory from ancestor. When a virtio
437
437
* device is created by remoteproc, the DMA memory is
438
-
* associated with the grandparent device:
439
-
* vdev => rproc => platform-dev.
438
+
* associated with the parent device:
439
+
* virtioY => remoteprocX#vdevYbuffer.
440
440
*/
441
-
if (!vdev->dev.parent || !vdev->dev.parent->parent)
441
+
buf->dev = vdev->dev.parent;
442
+
if (!buf->dev)
442
443
goto free_buf;
443
-
buf->dev = vdev->dev.parent->parent;
444
444
445
445
/* Increase device refcnt to avoid freeing it */
446
446
get_device(buf->dev);
+3
drivers/firmware/xilinx/zynqmp.c
+3
drivers/firmware/xilinx/zynqmp.c
+4
-5
drivers/misc/habanalabs/common/command_buffer.c
+4
-5
drivers/misc/habanalabs/common/command_buffer.c
···
142
142
{
143
143
if (cb->is_internal)
144
144
gen_pool_free(hdev->internal_cb_pool,
145
-
cb->kernel_address, cb->size);
145
+
(uintptr_t)cb->kernel_address, cb->size);
146
146
else
147
147
hdev->asic_funcs->asic_dma_free_coherent(hdev, cb->size,
148
-
(void *) (uintptr_t) cb->kernel_address,
149
-
cb->bus_address);
148
+
cb->kernel_address, cb->bus_address);
150
149
151
150
kfree(cb);
152
151
}
···
229
230
return NULL;
230
231
}
231
232
232
-
cb->kernel_address = (u64) (uintptr_t) p;
233
+
cb->kernel_address = p;
233
234
cb->size = cb_size;
234
235
235
236
return cb;
···
508
509
509
510
vma->vm_private_data = cb;
510
511
511
-
rc = hdev->asic_funcs->cb_mmap(hdev, vma, (void *) cb->kernel_address,
512
+
rc = hdev->asic_funcs->cb_mmap(hdev, vma, cb->kernel_address,
512
513
cb->bus_address, cb->size);
513
514
if (rc) {
514
515
spin_lock(&cb->lock);
+7
-7
drivers/misc/habanalabs/common/habanalabs.h
+7
-7
drivers/misc/habanalabs/common/habanalabs.h
···
452
452
struct list_head pool_list;
453
453
struct list_head va_block_list;
454
454
u64 id;
455
-
u64 kernel_address;
455
+
void *kernel_address;
456
456
dma_addr_t bus_address;
457
457
u32 mmap_size;
458
458
u32 size;
···
515
515
struct hl_hw_sob hw_sob[HL_RSVD_SOBS];
516
516
struct hl_cs_job **shadow_queue;
517
517
enum hl_queue_type queue_type;
518
-
u64 kernel_address;
518
+
void *kernel_address;
519
519
dma_addr_t bus_address;
520
520
u32 pi;
521
521
atomic_t ci;
···
544
544
*/
545
545
struct hl_cq {
546
546
struct hl_device *hdev;
547
-
u64 kernel_address;
547
+
void *kernel_address;
548
548
dma_addr_t bus_address;
549
549
u32 cq_idx;
550
550
u32 hw_queue_id;
···
562
562
*/
563
563
struct hl_eq {
564
564
struct hl_device *hdev;
565
-
u64 kernel_address;
565
+
void *kernel_address;
566
566
dma_addr_t bus_address;
567
567
u32 ci;
568
568
};
···
757
757
u32 (*get_dma_desc_list_size)(struct hl_device *hdev,
758
758
struct sg_table *sgt);
759
759
void (*add_end_of_cb_packets)(struct hl_device *hdev,
760
-
u64 kernel_address, u32 len,
760
+
void *kernel_address, u32 len,
761
761
u64 cq_addr, u32 cq_val, u32 msix_num,
762
762
bool eb);
763
763
void (*update_eq_ci)(struct hl_device *hdev, u32 val);
···
1382
1382
for (;;) { \
1383
1383
/* Verify we read updates done by other cores or by device */ \
1384
1384
mb(); \
1385
-
(val) = *((u32 *) (uintptr_t) (addr)); \
1385
+
(val) = *((u32 *)(addr)); \
1386
1386
if (mem_written_by_device) \
1387
1387
(val) = le32_to_cpu(*(__le32 *) &(val)); \
1388
1388
if (cond) \
1389
1389
break; \
1390
1390
if (timeout_us && ktime_compare(ktime_get(), __timeout) > 0) { \
1391
-
(val) = *((u32 *) (uintptr_t) (addr)); \
1391
+
(val) = *((u32 *)(addr)); \
1392
1392
if (mem_written_by_device) \
1393
1393
(val) = le32_to_cpu(*(__le32 *) &(val)); \
1394
1394
break; \
+9
-10
drivers/misc/habanalabs/common/hw_queue.c
+9
-10
drivers/misc/habanalabs/common/hw_queue.c
···
75
75
{
76
76
struct hl_bd *bd;
77
77
78
-
bd = (struct hl_bd *) (uintptr_t) q->kernel_address;
78
+
bd = q->kernel_address;
79
79
bd += hl_pi_2_offset(q->pi);
80
80
bd->ctl = cpu_to_le32(ctl);
81
81
bd->len = cpu_to_le32(len);
···
335
335
bd.len = cpu_to_le32(job->job_cb_size);
336
336
bd.ptr = cpu_to_le64((u64) (uintptr_t) job->user_cb);
337
337
338
-
pi = (__le64 *) (uintptr_t) (q->kernel_address +
339
-
((q->pi & (q->int_queue_len - 1)) * sizeof(bd)));
338
+
pi = q->kernel_address + (q->pi & (q->int_queue_len - 1)) * sizeof(bd);
340
339
341
340
q->pi++;
342
341
q->pi &= ((q->int_queue_len << 1) - 1);
···
629
630
if (!p)
630
631
return -ENOMEM;
631
632
632
-
q->kernel_address = (u64) (uintptr_t) p;
633
+
q->kernel_address = p;
633
634
634
635
q->shadow_queue = kmalloc_array(HL_QUEUE_LENGTH,
635
636
sizeof(*q->shadow_queue),
···
652
653
if (is_cpu_queue)
653
654
hdev->asic_funcs->cpu_accessible_dma_pool_free(hdev,
654
655
HL_QUEUE_SIZE_IN_BYTES,
655
-
(void *) (uintptr_t) q->kernel_address);
656
+
q->kernel_address);
656
657
else
657
658
hdev->asic_funcs->asic_dma_free_coherent(hdev,
658
659
HL_QUEUE_SIZE_IN_BYTES,
659
-
(void *) (uintptr_t) q->kernel_address,
660
+
q->kernel_address,
660
661
q->bus_address);
661
662
662
663
return rc;
···
675
676
return -EFAULT;
676
677
}
677
678
678
-
q->kernel_address = (u64) (uintptr_t) p;
679
+
q->kernel_address = p;
679
680
q->pi = 0;
680
681
atomic_set(&q->ci, 0);
681
682
···
703
704
if (!p)
704
705
return -ENOMEM;
705
706
706
-
q->kernel_address = (u64) (uintptr_t) p;
707
+
q->kernel_address = p;
707
708
708
709
/* Make sure read/write pointers are initialized to start of queue */
709
710
atomic_set(&q->ci, 0);
···
838
839
if (q->queue_type == QUEUE_TYPE_CPU)
839
840
hdev->asic_funcs->cpu_accessible_dma_pool_free(hdev,
840
841
HL_QUEUE_SIZE_IN_BYTES,
841
-
(void *) (uintptr_t) q->kernel_address);
842
+
q->kernel_address);
842
843
else
843
844
hdev->asic_funcs->asic_dma_free_coherent(hdev,
844
845
HL_QUEUE_SIZE_IN_BYTES,
845
-
(void *) (uintptr_t) q->kernel_address,
846
+
q->kernel_address,
846
847
q->bus_address);
847
848
}
848
849
+9
-8
drivers/misc/habanalabs/common/irq.c
+9
-8
drivers/misc/habanalabs/common/irq.c
···
90
90
return IRQ_HANDLED;
91
91
}
92
92
93
-
cq_base = (struct hl_cq_entry *) (uintptr_t) cq->kernel_address;
93
+
cq_base = cq->kernel_address;
94
94
95
95
while (1) {
96
96
bool entry_ready = ((le32_to_cpu(cq_base[cq->ci].data) &
···
152
152
struct hl_eq_entry *eq_base;
153
153
struct hl_eqe_work *handle_eqe_work;
154
154
155
-
eq_base = (struct hl_eq_entry *) (uintptr_t) eq->kernel_address;
155
+
eq_base = eq->kernel_address;
156
156
157
157
while (1) {
158
158
bool entry_ready =
···
221
221
return -ENOMEM;
222
222
223
223
q->hdev = hdev;
224
-
q->kernel_address = (u64) (uintptr_t) p;
224
+
q->kernel_address = p;
225
225
q->hw_queue_id = hw_queue_id;
226
226
q->ci = 0;
227
227
q->pi = 0;
···
242
242
void hl_cq_fini(struct hl_device *hdev, struct hl_cq *q)
243
243
{
244
244
hdev->asic_funcs->asic_dma_free_coherent(hdev, HL_CQ_SIZE_IN_BYTES,
245
-
(void *) (uintptr_t) q->kernel_address, q->bus_address);
245
+
q->kernel_address,
246
+
q->bus_address);
246
247
}
247
248
248
249
void hl_cq_reset(struct hl_device *hdev, struct hl_cq *q)
···
260
259
* when the device is operational again
261
260
*/
262
261
263
-
memset((void *) (uintptr_t) q->kernel_address, 0, HL_CQ_SIZE_IN_BYTES);
262
+
memset(q->kernel_address, 0, HL_CQ_SIZE_IN_BYTES);
264
263
}
265
264
266
265
/**
···
283
282
return -ENOMEM;
284
283
285
284
q->hdev = hdev;
286
-
q->kernel_address = (u64) (uintptr_t) p;
285
+
q->kernel_address = p;
287
286
q->ci = 0;
288
287
289
288
return 0;
···
303
302
304
303
hdev->asic_funcs->cpu_accessible_dma_pool_free(hdev,
305
304
HL_EQ_SIZE_IN_BYTES,
306
-
(void *) (uintptr_t) q->kernel_address);
305
+
q->kernel_address);
307
306
}
308
307
309
308
void hl_eq_reset(struct hl_device *hdev, struct hl_eq *q)
···
317
316
* when the device is operational again
318
317
*/
319
318
320
-
memset((void *) (uintptr_t) q->kernel_address, 0, HL_EQ_SIZE_IN_BYTES);
319
+
memset(q->kernel_address, 0, HL_EQ_SIZE_IN_BYTES);
321
320
}
+15
-23
drivers/misc/habanalabs/gaudi/gaudi.c
+15
-23
drivers/misc/habanalabs/gaudi/gaudi.c
···
680
680
if (!cb)
681
681
return -EFAULT;
682
682
683
-
init_tpc_mem_pkt = (struct packet_lin_dma *) (uintptr_t)
684
-
cb->kernel_address;
683
+
init_tpc_mem_pkt = cb->kernel_address;
685
684
cb_size = sizeof(*init_tpc_mem_pkt);
686
685
memset(init_tpc_mem_pkt, 0, cb_size);
687
686
···
3810
3811
u16 pkt_size;
3811
3812
struct gaudi_packet *user_pkt;
3812
3813
3813
-
user_pkt = (struct gaudi_packet *) (uintptr_t)
3814
-
(parser->user_cb->kernel_address + cb_parsed_length);
3814
+
user_pkt = parser->user_cb->kernel_address + cb_parsed_length;
3815
3815
3816
3816
pkt_id = (enum packet_id) (
3817
3817
(le64_to_cpu(user_pkt->header) &
···
4033
4035
u32 new_pkt_size = 0;
4034
4036
struct gaudi_packet *user_pkt, *kernel_pkt;
4035
4037
4036
-
user_pkt = (struct gaudi_packet *) (uintptr_t)
4037
-
(parser->user_cb->kernel_address + cb_parsed_length);
4038
-
kernel_pkt = (struct gaudi_packet *) (uintptr_t)
4039
-
(parser->patched_cb->kernel_address +
4040
-
cb_patched_cur_length);
4038
+
user_pkt = parser->user_cb->kernel_address + cb_parsed_length;
4039
+
kernel_pkt = parser->patched_cb->kernel_address +
4040
+
cb_patched_cur_length;
4041
4041
4042
4042
pkt_id = (enum packet_id) (
4043
4043
(le64_to_cpu(user_pkt->header) &
···
4151
4155
* The check that parser->user_cb_size <= parser->user_cb->size was done
4152
4156
* in validate_queue_index().
4153
4157
*/
4154
-
memcpy((void *) (uintptr_t) parser->patched_cb->kernel_address,
4155
-
(void *) (uintptr_t) parser->user_cb->kernel_address,
4158
+
memcpy(parser->patched_cb->kernel_address,
4159
+
parser->user_cb->kernel_address,
4156
4160
parser->user_cb_size);
4157
4161
4158
4162
patched_cb_size = parser->patched_cb_size;
···
4286
4290
}
4287
4291
4288
4292
static void gaudi_add_end_of_cb_packets(struct hl_device *hdev,
4289
-
u64 kernel_address, u32 len,
4293
+
void *kernel_address, u32 len,
4290
4294
u64 cq_addr, u32 cq_val, u32 msi_vec,
4291
4295
bool eb)
4292
4296
{
···
4294
4298
struct packet_msg_prot *cq_pkt;
4295
4299
u32 tmp;
4296
4300
4297
-
cq_pkt = (struct packet_msg_prot *) (uintptr_t)
4298
-
(kernel_address + len - (sizeof(struct packet_msg_prot) * 2));
4301
+
cq_pkt = kernel_address + len - (sizeof(struct packet_msg_prot) * 2);
4299
4302
4300
4303
tmp = FIELD_PREP(GAUDI_PKT_CTL_OPCODE_MASK, PACKET_MSG_PROT);
4301
4304
tmp |= FIELD_PREP(GAUDI_PKT_CTL_MB_MASK, 1);
···
4337
4342
if (!cb)
4338
4343
return -EFAULT;
4339
4344
4340
-
lin_dma_pkt = (struct packet_lin_dma *) (uintptr_t) cb->kernel_address;
4345
+
lin_dma_pkt = cb->kernel_address;
4341
4346
memset(lin_dma_pkt, 0, sizeof(*lin_dma_pkt));
4342
4347
cb_size = sizeof(*lin_dma_pkt);
4343
4348
···
4742
4747
(addr - gaudi->hbm_bar_cur_addr));
4743
4748
}
4744
4749
4745
-
static void gaudi_mmu_prepare_reg(struct hl_device *hdev, u64 reg, u32 asid)
4750
+
void gaudi_mmu_prepare_reg(struct hl_device *hdev, u64 reg, u32 asid)
4746
4751
{
4747
4752
/* mask to zero the MMBP and ASID bits */
4748
4753
WREG32_AND(reg, ~0x7FF);
···
4910
4915
gaudi_mmu_prepare_reg(hdev, mmMME2_ACC_WBC, asid);
4911
4916
gaudi_mmu_prepare_reg(hdev, mmMME3_ACC_WBC, asid);
4912
4917
4913
-
gaudi_mmu_prepare_reg(hdev, mmPSOC_GLOBAL_CONF_TRACE_ARUSER, asid);
4914
-
gaudi_mmu_prepare_reg(hdev, mmPSOC_GLOBAL_CONF_TRACE_AWUSER, asid);
4915
-
4916
4918
hdev->asic_funcs->set_clock_gating(hdev);
4917
4919
4918
4920
mutex_unlock(&gaudi->clk_gate_mutex);
···
4946
4954
4947
4955
cb = job->patched_cb;
4948
4956
4949
-
fence_pkt = (struct packet_msg_prot *) (uintptr_t) (cb->kernel_address +
4950
-
job->job_cb_size - sizeof(struct packet_msg_prot));
4957
+
fence_pkt = cb->kernel_address +
4958
+
job->job_cb_size - sizeof(struct packet_msg_prot);
4951
4959
4952
4960
tmp = FIELD_PREP(GAUDI_PKT_CTL_OPCODE_MASK, PACKET_MSG_PROT);
4953
4961
tmp |= FIELD_PREP(GAUDI_PKT_CTL_EB_MASK, 1);
···
6378
6386
struct packet_msg_short *pkt;
6379
6387
u32 value, ctl;
6380
6388
6381
-
pkt = (struct packet_msg_short *) (uintptr_t) cb->kernel_address;
6389
+
pkt = cb->kernel_address;
6382
6390
memset(pkt, 0, sizeof(*pkt));
6383
6391
6384
6392
/* Inc by 1, Mode ADD */
···
6470
6478
u16 sob_val, u16 mon_id, u32 q_idx)
6471
6479
{
6472
6480
struct hl_cb *cb = (struct hl_cb *) data;
6473
-
void *buf = (void *) (uintptr_t) cb->kernel_address;
6481
+
void *buf = cb->kernel_address;
6474
6482
u64 monitor_base, fence_addr = 0;
6475
6483
u32 size = 0;
6476
6484
u16 msg_addr_offset;
+1
drivers/misc/habanalabs/gaudi/gaudiP.h
+1
drivers/misc/habanalabs/gaudi/gaudiP.h
···
271
271
int gaudi_debug_coresight(struct hl_device *hdev, void *data);
272
272
void gaudi_halt_coresight(struct hl_device *hdev);
273
273
int gaudi_get_clk_rate(struct hl_device *hdev, u32 *cur_clk, u32 *max_clk);
274
+
void gaudi_mmu_prepare_reg(struct hl_device *hdev, u64 reg, u32 asid);
274
275
275
276
#endif /* GAUDIP_H_ */
+5
drivers/misc/habanalabs/gaudi/gaudi_coresight.c
+5
drivers/misc/habanalabs/gaudi/gaudi_coresight.c
···
623
623
return -EINVAL;
624
624
}
625
625
626
+
gaudi_mmu_prepare_reg(hdev, mmPSOC_GLOBAL_CONF_TRACE_ARUSER,
627
+
hdev->compute_ctx->asid);
628
+
gaudi_mmu_prepare_reg(hdev, mmPSOC_GLOBAL_CONF_TRACE_AWUSER,
629
+
hdev->compute_ctx->asid);
630
+
626
631
msb = upper_32_bits(input->buffer_address) >> 8;
627
632
msb &= PSOC_GLOBAL_CONF_TRACE_ADDR_MSB_MASK;
628
633
WREG32(mmPSOC_GLOBAL_CONF_TRACE_ADDR, msb);
+11
-15
drivers/misc/habanalabs/goya/goya.c
+11
-15
drivers/misc/habanalabs/goya/goya.c
···
2882
2882
2883
2883
cb = job->patched_cb;
2884
2884
2885
-
fence_pkt = (struct packet_msg_prot *) (uintptr_t) (cb->kernel_address +
2886
-
job->job_cb_size - sizeof(struct packet_msg_prot));
2885
+
fence_pkt = cb->kernel_address +
2886
+
job->job_cb_size - sizeof(struct packet_msg_prot);
2887
2887
2888
2888
tmp = (PACKET_MSG_PROT << GOYA_PKT_CTL_OPCODE_SHIFT) |
2889
2889
(1 << GOYA_PKT_CTL_EB_SHIFT) |
···
3475
3475
u16 pkt_size;
3476
3476
struct goya_packet *user_pkt;
3477
3477
3478
-
user_pkt = (struct goya_packet *) (uintptr_t)
3479
-
(parser->user_cb->kernel_address + cb_parsed_length);
3478
+
user_pkt = parser->user_cb->kernel_address + cb_parsed_length;
3480
3479
3481
3480
pkt_id = (enum packet_id) (
3482
3481
(le64_to_cpu(user_pkt->header) &
···
3712
3713
u32 new_pkt_size = 0;
3713
3714
struct goya_packet *user_pkt, *kernel_pkt;
3714
3715
3715
-
user_pkt = (struct goya_packet *) (uintptr_t)
3716
-
(parser->user_cb->kernel_address + cb_parsed_length);
3717
-
kernel_pkt = (struct goya_packet *) (uintptr_t)
3718
-
(parser->patched_cb->kernel_address +
3719
-
cb_patched_cur_length);
3716
+
user_pkt = parser->user_cb->kernel_address + cb_parsed_length;
3717
+
kernel_pkt = parser->patched_cb->kernel_address +
3718
+
cb_patched_cur_length;
3720
3719
3721
3720
pkt_id = (enum packet_id) (
3722
3721
(le64_to_cpu(user_pkt->header) &
···
3838
3841
* The check that parser->user_cb_size <= parser->user_cb->size was done
3839
3842
* in validate_queue_index().
3840
3843
*/
3841
-
memcpy((void *) (uintptr_t) parser->patched_cb->kernel_address,
3842
-
(void *) (uintptr_t) parser->user_cb->kernel_address,
3844
+
memcpy(parser->patched_cb->kernel_address,
3845
+
parser->user_cb->kernel_address,
3843
3846
parser->user_cb_size);
3844
3847
3845
3848
patched_cb_size = parser->patched_cb_size;
···
3971
3974
return goya_parse_cb_no_mmu(hdev, parser);
3972
3975
}
3973
3976
3974
-
void goya_add_end_of_cb_packets(struct hl_device *hdev, u64 kernel_address,
3977
+
void goya_add_end_of_cb_packets(struct hl_device *hdev, void *kernel_address,
3975
3978
u32 len, u64 cq_addr, u32 cq_val, u32 msix_vec,
3976
3979
bool eb)
3977
3980
{
3978
3981
struct packet_msg_prot *cq_pkt;
3979
3982
u32 tmp;
3980
3983
3981
-
cq_pkt = (struct packet_msg_prot *) (uintptr_t)
3982
-
(kernel_address + len - (sizeof(struct packet_msg_prot) * 2));
3984
+
cq_pkt = kernel_address + len - (sizeof(struct packet_msg_prot) * 2);
3983
3985
3984
3986
tmp = (PACKET_MSG_PROT << GOYA_PKT_CTL_OPCODE_SHIFT) |
3985
3987
(1 << GOYA_PKT_CTL_EB_SHIFT) |
···
4742
4746
if (!cb)
4743
4747
return -ENOMEM;
4744
4748
4745
-
lin_dma_pkt = (struct packet_lin_dma *) (uintptr_t) cb->kernel_address;
4749
+
lin_dma_pkt = cb->kernel_address;
4746
4750
4747
4751
do {
4748
4752
memset(lin_dma_pkt, 0, sizeof(*lin_dma_pkt));
+1
-1
drivers/misc/habanalabs/goya/goyaP.h
+1
-1
drivers/misc/habanalabs/goya/goyaP.h
···
217
217
void goya_handle_eqe(struct hl_device *hdev, struct hl_eq_entry *eq_entry);
218
218
void *goya_get_events_stat(struct hl_device *hdev, bool aggregate, u32 *size);
219
219
220
-
void goya_add_end_of_cb_packets(struct hl_device *hdev, u64 kernel_address,
220
+
void goya_add_end_of_cb_packets(struct hl_device *hdev, void *kernel_address,
221
221
u32 len, u64 cq_addr, u32 cq_val, u32 msix_vec,
222
222
bool eb);
223
223
int goya_cs_parser(struct hl_device *hdev, struct hl_cs_parser *parser);
-1
drivers/misc/habanalabs/include/gaudi/gaudi_masks.h
-1
drivers/misc/habanalabs/include/gaudi/gaudi_masks.h
+2
-2
drivers/misc/mei/client.h
+2
-2
drivers/misc/mei/client.h
···
182
182
*
183
183
* @cl: host client
184
184
*
185
-
* Return: mtu
185
+
* Return: mtu or 0 if client is not connected
186
186
*/
187
187
static inline size_t mei_cl_mtu(const struct mei_cl *cl)
188
188
{
189
-
return cl->me_cl->props.max_msg_length;
189
+
return cl->me_cl ? cl->me_cl->props.max_msg_length : 0;
190
190
}
191
191
192
192
/**
+6
-4
drivers/uio/uio.c
+6
-4
drivers/uio/uio.c
···
413
413
return retval;
414
414
}
415
415
416
-
static void uio_free_minor(struct uio_device *idev)
416
+
static void uio_free_minor(unsigned long minor)
417
417
{
418
418
mutex_lock(&minor_lock);
419
-
idr_remove(&uio_idr, idev->minor);
419
+
idr_remove(&uio_idr, minor);
420
420
mutex_unlock(&minor_lock);
421
421
}
422
422
···
990
990
err_uio_dev_add_attributes:
991
991
device_del(&idev->dev);
992
992
err_device_create:
993
-
uio_free_minor(idev);
993
+
uio_free_minor(idev->minor);
994
994
put_device(&idev->dev);
995
995
return ret;
996
996
}
···
1042
1042
void uio_unregister_device(struct uio_info *info)
1043
1043
{
1044
1044
struct uio_device *idev;
1045
+
unsigned long minor;
1045
1046
1046
1047
if (!info || !info->uio_dev)
1047
1048
return;
1048
1049
1049
1050
idev = info->uio_dev;
1051
+
minor = idev->minor;
1050
1052
1051
1053
mutex_lock(&idev->info_lock);
1052
1054
uio_dev_del_attributes(idev);
···
1064
1062
1065
1063
device_unregister(&idev->dev);
1066
1064
1067
-
uio_free_minor(idev);
1065
+
uio_free_minor(minor);
1068
1066
1069
1067
return;
1070
1068
}
+2
-4
drivers/virt/nitro_enclaves/ne_misc_dev.c
+2
-4
drivers/virt/nitro_enclaves/ne_misc_dev.c