1 /*******************************************************************************
2 AudioScience HPI driver
3 Common Linux HPI ioctl and module probe/remove functions
5 Copyright (C) 1997-2014 AudioScience Inc. <support@audioscience.com>
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of version 2 of the GNU General Public License as
9 published by the Free Software Foundation;
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 *******************************************************************************/
17 #define SOURCEFILE_NAME "hpioctl.c"
19 #include "hpi_internal.h"
20 #include "hpi_version.h"
21 #include "hpimsginit.h"
28 #include <linux/interrupt.h>
29 #include <linux/slab.h>
30 #include <linux/moduleparam.h>
31 #include <linux/uaccess.h>
32 #include <linux/pci.h>
33 #include <linux/stringify.h>
34 #include <linux/module.h>
35 #include <linux/vmalloc.h>
36 #include <linux/nospec.h>
38 #ifdef MODULE_FIRMWARE
39 MODULE_FIRMWARE("asihpi/dsp5000.bin");
40 MODULE_FIRMWARE("asihpi/dsp6200.bin");
41 MODULE_FIRMWARE("asihpi/dsp6205.bin");
42 MODULE_FIRMWARE("asihpi/dsp6400.bin");
43 MODULE_FIRMWARE("asihpi/dsp6600.bin");
44 MODULE_FIRMWARE("asihpi/dsp8700.bin");
45 MODULE_FIRMWARE("asihpi/dsp8900.bin");
48 static int prealloc_stream_buf
;
49 module_param(prealloc_stream_buf
, int, S_IRUGO
);
50 MODULE_PARM_DESC(prealloc_stream_buf
,
51 "Preallocate size for per-adapter stream buffer");
53 /* Allow the debug level to be changed after module load.
54 E.g. echo 2 > /sys/module/asihpi/parameters/hpiDebugLevel
56 module_param(hpi_debug_level
, int, S_IRUGO
| S_IWUSR
);
57 MODULE_PARM_DESC(hpi_debug_level
, "debug verbosity 0..5");
59 /* List of adapters found */
60 static struct hpi_adapter adapters
[HPI_MAX_ADAPTERS
];
62 /* Wrapper function to HPI_Message to enable dumping of the
63 message and response types.
65 static void hpi_send_recv_f(struct hpi_message
*phm
, struct hpi_response
*phr
,
68 if ((phm
->adapter_index
>= HPI_MAX_ADAPTERS
)
69 && (phm
->object
!= HPI_OBJ_SUBSYSTEM
))
70 phr
->error
= HPI_ERROR_INVALID_OBJ_INDEX
;
72 hpi_send_recv_ex(phm
, phr
, file
);
75 /* This is called from hpifunc.c functions, called by ALSA
76 * (or other kernel process) In this case there is no file descriptor
77 * available for the message cache code
79 void hpi_send_recv(struct hpi_message
*phm
, struct hpi_response
*phr
)
81 hpi_send_recv_f(phm
, phr
, HOWNER_KERNEL
);
84 EXPORT_SYMBOL(hpi_send_recv
);
85 /* for radio-asihpi */
87 int asihpi_hpi_release(struct file
*file
)
89 struct hpi_message hm
;
90 struct hpi_response hr
;
92 /* HPI_DEBUG_LOG(INFO,"hpi_release file %p, pid %d\n", file, current->pid); */
93 /* close the subsystem just in case the application forgot to. */
94 hpi_init_message_response(&hm
, &hr
, HPI_OBJ_SUBSYSTEM
,
96 hpi_send_recv_ex(&hm
, &hr
, file
);
100 long asihpi_hpi_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
102 struct hpi_ioctl_linux __user
*phpi_ioctl_data
;
105 union hpi_message_buffer_v1
*hm
;
106 union hpi_response_buffer_v1
*hr
;
112 if (cmd
!= HPI_IOCTL_LINUX
)
115 hm
= kmalloc(sizeof(*hm
), GFP_KERNEL
);
116 hr
= kzalloc(sizeof(*hr
), GFP_KERNEL
);
122 phpi_ioctl_data
= (struct hpi_ioctl_linux __user
*)arg
;
124 /* Read the message and response pointers from user space. */
125 if (get_user(puhm
, &phpi_ioctl_data
->phm
)
126 || get_user(puhr
, &phpi_ioctl_data
->phr
)) {
131 /* Now read the message size and data from user space. */
132 if (get_user(msg_size
, (u16 __user
*)puhm
)) {
136 if (msg_size
> sizeof(*hm
))
137 msg_size
= sizeof(*hm
);
139 /* printk(KERN_INFO "message size %d\n", hm->h.wSize); */
141 uncopied_bytes
= copy_from_user(hm
, puhm
, msg_size
);
142 if (uncopied_bytes
) {
143 HPI_DEBUG_LOG(ERROR
, "uncopied bytes %d\n", uncopied_bytes
);
148 /* Override h.size in case it is changed between two userspace fetches */
149 hm
->h
.size
= msg_size
;
151 if (get_user(res_max_size
, (u16 __user
*)puhr
)) {
155 /* printk(KERN_INFO "user response size %d\n", res_max_size); */
156 if (res_max_size
< sizeof(struct hpi_response_header
)) {
157 HPI_DEBUG_LOG(WARNING
, "small res size %d\n", res_max_size
);
162 res_max_size
= min_t(size_t, res_max_size
, sizeof(*hr
));
164 switch (hm
->h
.function
) {
165 case HPI_SUBSYS_CREATE_ADAPTER
:
166 case HPI_ADAPTER_DELETE
:
167 /* Application must not use these functions! */
168 hr
->h
.size
= sizeof(hr
->h
);
169 hr
->h
.error
= HPI_ERROR_INVALID_OPERATION
;
170 hr
->h
.function
= hm
->h
.function
;
171 uncopied_bytes
= copy_to_user(puhr
, hr
, hr
->h
.size
);
179 hr
->h
.size
= res_max_size
;
180 if (hm
->h
.object
== HPI_OBJ_SUBSYSTEM
) {
181 hpi_send_recv_f(&hm
->m0
, &hr
->r0
, file
);
183 u16 __user
*ptr
= NULL
;
185 /* -1=no data 0=read from user mem, 1=write to user mem */
187 struct hpi_adapter
*pa
= NULL
;
189 if (hm
->h
.adapter_index
< ARRAY_SIZE(adapters
))
190 pa
= &adapters
[array_index_nospec(hm
->h
.adapter_index
,
191 ARRAY_SIZE(adapters
))];
193 if (!pa
|| !pa
->adapter
|| !pa
->adapter
->type
) {
194 hpi_init_response(&hr
->r0
, hm
->h
.object
,
195 hm
->h
.function
, HPI_ERROR_BAD_ADAPTER_NUMBER
);
198 copy_to_user(puhr
, hr
, sizeof(hr
->h
));
206 if (mutex_lock_interruptible(&pa
->mutex
)) {
211 /* Dig out any pointers embedded in the message. */
212 switch (hm
->h
.function
) {
213 case HPI_OSTREAM_WRITE
:
214 case HPI_ISTREAM_READ
:{
215 /* Yes, sparse, this is correct. */
216 ptr
= (u16 __user
*)hm
->m0
.u
.d
.u
.data
.pb_data
;
217 size
= hm
->m0
.u
.d
.u
.data
.data_size
;
219 /* Allocate buffer according to application request.
220 ?Is it better to alloc/free for the duration
223 if (pa
->buffer_size
< size
) {
225 "Realloc adapter %d stream "
226 "buffer from %zd to %d\n",
228 pa
->buffer_size
, size
);
233 pa
->p_buffer
= vmalloc(size
);
235 pa
->buffer_size
= size
;
238 "HPI could not allocate "
239 "stream buffer size %d\n",
242 mutex_unlock(&pa
->mutex
);
248 hm
->m0
.u
.d
.u
.data
.pb_data
= pa
->p_buffer
;
249 if (hm
->h
.function
== HPI_ISTREAM_READ
)
250 /* from card, WRITE to user mem */
262 if (size
&& (wrflag
== 0)) {
264 copy_from_user(pa
->p_buffer
, ptr
, size
);
266 HPI_DEBUG_LOG(WARNING
,
268 "bytes from user\n", uncopied_bytes
,
272 hpi_send_recv_f(&hm
->m0
, &hr
->r0
, file
);
274 if (size
&& (wrflag
== 1)) {
276 copy_to_user(ptr
, pa
->p_buffer
, size
);
278 HPI_DEBUG_LOG(WARNING
,
279 "Missed %d of %d " "bytes to user\n",
280 uncopied_bytes
, size
);
283 mutex_unlock(&pa
->mutex
);
286 /* on return response size must be set */
287 /*printk(KERN_INFO "response size %d\n", hr->h.wSize); */
290 HPI_DEBUG_LOG(ERROR
, "response zero size\n");
295 if (hr
->h
.size
> res_max_size
) {
296 HPI_DEBUG_LOG(ERROR
, "response too big %d %d\n", hr
->h
.size
,
298 hr
->h
.error
= HPI_ERROR_RESPONSE_BUFFER_TOO_SMALL
;
299 hr
->h
.specific_error
= hr
->h
.size
;
300 hr
->h
.size
= sizeof(hr
->h
);
303 uncopied_bytes
= copy_to_user(puhr
, hr
, hr
->h
.size
);
304 if (uncopied_bytes
) {
305 HPI_DEBUG_LOG(ERROR
, "uncopied bytes %d\n", uncopied_bytes
);
316 static int asihpi_irq_count
;
318 static irqreturn_t
asihpi_isr(int irq
, void *dev_id
)
320 struct hpi_adapter
*a
= dev_id
;
323 if (!a
->adapter
->irq_query_and_clear
) {
324 pr_err("asihpi_isr ASI%04X:%d no handler\n", a
->adapter
->type
,
329 handled
= a
->adapter
->irq_query_and_clear(a
->adapter
, 0);
335 /* printk(KERN_INFO "asihpi_isr %d ASI%04X:%d irq handled\n",
336 asihpi_irq_count, a->adapter->type, a->adapter->index); */
338 if (a
->interrupt_callback
)
339 a
->interrupt_callback(a
);
344 int asihpi_adapter_probe(struct pci_dev
*pci_dev
,
345 const struct pci_device_id
*pci_id
)
347 int idx
, nm
, low_latency_mode
= 0, irq_supported
= 0;
350 struct hpi_message hm
;
351 struct hpi_response hr
;
352 struct hpi_adapter adapter
;
355 memset(&adapter
, 0, sizeof(adapter
));
357 dev_printk(KERN_DEBUG
, &pci_dev
->dev
,
358 "probe %04x:%04x,%04x:%04x,%04x\n", pci_dev
->vendor
,
359 pci_dev
->device
, pci_dev
->subsystem_vendor
,
360 pci_dev
->subsystem_device
, pci_dev
->devfn
);
362 if (pci_enable_device(pci_dev
) < 0) {
363 dev_err(&pci_dev
->dev
,
364 "pci_enable_device failed, disabling device\n");
368 pci_set_master(pci_dev
); /* also sets latency timer if < 16 */
370 hpi_init_message_response(&hm
, &hr
, HPI_OBJ_SUBSYSTEM
,
371 HPI_SUBSYS_CREATE_ADAPTER
);
372 hpi_init_response(&hr
, HPI_OBJ_SUBSYSTEM
, HPI_SUBSYS_CREATE_ADAPTER
,
373 HPI_ERROR_PROCESSING_MESSAGE
);
375 hm
.adapter_index
= HPI_ADAPTER_INDEX_INVALID
;
377 nm
= HPI_MAX_ADAPTER_MEM_SPACES
;
379 for (idx
= 0; idx
< nm
; idx
++) {
380 HPI_DEBUG_LOG(INFO
, "resource %d %pR\n", idx
,
381 &pci_dev
->resource
[idx
]);
383 if (pci_resource_flags(pci_dev
, idx
) & IORESOURCE_MEM
) {
384 memlen
= pci_resource_len(pci_dev
, idx
);
385 pci
.ap_mem_base
[idx
] =
386 ioremap(pci_resource_start(pci_dev
, idx
),
388 if (!pci
.ap_mem_base
[idx
]) {
390 "ioremap failed, aborting\n");
391 /* unmap previously mapped pci mem space */
397 pci
.pci_dev
= pci_dev
;
398 hm
.u
.s
.resource
.bus_type
= HPI_BUS_PCI
;
399 hm
.u
.s
.resource
.r
.pci
= &pci
;
401 /* call CreateAdapterObject on the relevant hpi module */
402 hpi_send_recv_ex(&hm
, &hr
, HOWNER_KERNEL
);
406 adapter_index
= hr
.u
.s
.adapter_index
;
407 adapter
.adapter
= hpi_find_adapter(adapter_index
);
409 if (prealloc_stream_buf
) {
410 adapter
.p_buffer
= vmalloc(prealloc_stream_buf
);
411 if (!adapter
.p_buffer
) {
413 "HPI could not allocate "
414 "kernel buffer size %d\n",
415 prealloc_stream_buf
);
420 hpi_init_message_response(&hm
, &hr
, HPI_OBJ_ADAPTER
,
422 hm
.adapter_index
= adapter
.adapter
->index
;
423 hpi_send_recv_ex(&hm
, &hr
, HOWNER_KERNEL
);
426 HPI_DEBUG_LOG(ERROR
, "HPI_ADAPTER_OPEN failed, aborting\n");
430 /* Check if current mode == Low Latency mode */
431 hpi_init_message_response(&hm
, &hr
, HPI_OBJ_ADAPTER
,
432 HPI_ADAPTER_GET_MODE
);
433 hm
.adapter_index
= adapter
.adapter
->index
;
434 hpi_send_recv_ex(&hm
, &hr
, HOWNER_KERNEL
);
437 && hr
.u
.ax
.mode
.adapter_mode
== HPI_ADAPTER_MODE_LOW_LATENCY
)
438 low_latency_mode
= 1;
440 dev_info(&pci_dev
->dev
,
441 "Adapter at index %d is not in low latency mode\n",
442 adapter
.adapter
->index
);
444 /* Check if IRQs are supported */
445 hpi_init_message_response(&hm
, &hr
, HPI_OBJ_ADAPTER
,
446 HPI_ADAPTER_GET_PROPERTY
);
447 hm
.adapter_index
= adapter
.adapter
->index
;
448 hm
.u
.ax
.property_set
.property
= HPI_ADAPTER_PROPERTY_SUPPORTS_IRQ
;
449 hpi_send_recv_ex(&hm
, &hr
, HOWNER_KERNEL
);
450 if (hr
.error
|| !hr
.u
.ax
.property_get
.parameter1
) {
451 dev_info(&pci_dev
->dev
,
452 "IRQs not supported by adapter at index %d\n",
453 adapter
.adapter
->index
);
458 /* WARNING can't init mutex in 'adapter'
459 * and then copy it to adapters[] ?!?!
461 adapters
[adapter_index
] = adapter
;
462 mutex_init(&adapters
[adapter_index
].mutex
);
463 pci_set_drvdata(pci_dev
, &adapters
[adapter_index
]);
465 if (low_latency_mode
&& irq_supported
) {
466 if (!adapter
.adapter
->irq_query_and_clear
) {
467 dev_err(&pci_dev
->dev
,
468 "no IRQ handler for adapter %d, aborting\n",
469 adapter
.adapter
->index
);
473 /* Disable IRQ generation on DSP side by setting the rate to 0 */
474 hpi_init_message_response(&hm
, &hr
, HPI_OBJ_ADAPTER
,
475 HPI_ADAPTER_SET_PROPERTY
);
476 hm
.adapter_index
= adapter
.adapter
->index
;
477 hm
.u
.ax
.property_set
.property
= HPI_ADAPTER_PROPERTY_IRQ_RATE
;
478 hm
.u
.ax
.property_set
.parameter1
= 0;
479 hm
.u
.ax
.property_set
.parameter2
= 0;
480 hpi_send_recv_ex(&hm
, &hr
, HOWNER_KERNEL
);
483 "HPI_ADAPTER_GET_MODE failed, aborting\n");
487 /* Note: request_irq calls asihpi_isr here */
488 if (request_irq(pci_dev
->irq
, asihpi_isr
, IRQF_SHARED
,
489 "asihpi", &adapters
[adapter_index
])) {
490 dev_err(&pci_dev
->dev
, "request_irq(%d) failed\n",
495 adapters
[adapter_index
].interrupt_mode
= 1;
497 dev_info(&pci_dev
->dev
, "using irq %d\n", pci_dev
->irq
);
498 adapters
[adapter_index
].irq
= pci_dev
->irq
;
500 dev_info(&pci_dev
->dev
, "using polled mode\n");
503 dev_info(&pci_dev
->dev
, "probe succeeded for ASI%04X HPI index %d\n",
504 adapter
.adapter
->type
, adapter_index
);
509 for (idx
= 0; idx
< HPI_MAX_ADAPTER_MEM_SPACES
; idx
++) {
510 if (pci
.ap_mem_base
[idx
]) {
511 iounmap(pci
.ap_mem_base
[idx
]);
512 pci
.ap_mem_base
[idx
] = NULL
;
516 if (adapter
.p_buffer
) {
517 adapter
.buffer_size
= 0;
518 vfree(adapter
.p_buffer
);
521 HPI_DEBUG_LOG(ERROR
, "adapter_probe failed\n");
525 void asihpi_adapter_remove(struct pci_dev
*pci_dev
)
528 struct hpi_message hm
;
529 struct hpi_response hr
;
530 struct hpi_adapter
*pa
;
533 pa
= pci_get_drvdata(pci_dev
);
534 pci
= pa
->adapter
->pci
;
536 /* Disable IRQ generation on DSP side */
537 hpi_init_message_response(&hm
, &hr
, HPI_OBJ_ADAPTER
,
538 HPI_ADAPTER_SET_PROPERTY
);
539 hm
.adapter_index
= pa
->adapter
->index
;
540 hm
.u
.ax
.property_set
.property
= HPI_ADAPTER_PROPERTY_IRQ_RATE
;
541 hm
.u
.ax
.property_set
.parameter1
= 0;
542 hm
.u
.ax
.property_set
.parameter2
= 0;
543 hpi_send_recv_ex(&hm
, &hr
, HOWNER_KERNEL
);
545 hpi_init_message_response(&hm
, &hr
, HPI_OBJ_ADAPTER
,
547 hm
.adapter_index
= pa
->adapter
->index
;
548 hpi_send_recv_ex(&hm
, &hr
, HOWNER_KERNEL
);
550 /* unmap PCI memory space, mapped during device init. */
551 for (idx
= 0; idx
< HPI_MAX_ADAPTER_MEM_SPACES
; ++idx
)
552 iounmap(pci
.ap_mem_base
[idx
]);
555 free_irq(pa
->irq
, pa
);
560 dev_info(&pci_dev
->dev
,
561 "remove %04x:%04x,%04x:%04x,%04x, HPI index %d\n",
562 pci_dev
->vendor
, pci_dev
->device
,
563 pci_dev
->subsystem_vendor
, pci_dev
->subsystem_device
,
564 pci_dev
->devfn
, pa
->adapter
->index
);
566 memset(pa
, 0, sizeof(*pa
));
569 void __init
asihpi_init(void)
571 struct hpi_message hm
;
572 struct hpi_response hr
;
574 memset(adapters
, 0, sizeof(adapters
));
576 printk(KERN_INFO
"ASIHPI driver " HPI_VER_STRING
"\n");
578 hpi_init_message_response(&hm
, &hr
, HPI_OBJ_SUBSYSTEM
,
579 HPI_SUBSYS_DRIVER_LOAD
);
580 hpi_send_recv_ex(&hm
, &hr
, HOWNER_KERNEL
);
583 void asihpi_exit(void)
585 struct hpi_message hm
;
586 struct hpi_response hr
;
588 hpi_init_message_response(&hm
, &hr
, HPI_OBJ_SUBSYSTEM
,
589 HPI_SUBSYS_DRIVER_UNLOAD
);
590 hpi_send_recv_ex(&hm
, &hr
, HOWNER_KERNEL
);