1 /*******************************************************************************
3 AudioScience HPI driver
4 Copyright (C) 1997-2010 AudioScience Inc. <support@audioscience.com>
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of version 2 of the GNU General Public License as
8 published by the Free Software Foundation;
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 Common Linux HPI ioctl and module probe/remove functions
20 *******************************************************************************/
21 #define SOURCEFILE_NAME "hpioctl.c"
23 #include "hpi_internal.h"
24 #include "hpimsginit.h"
30 #include <linux/slab.h>
31 #include <linux/moduleparam.h>
32 #include <asm/uaccess.h>
33 #include <linux/pci.h>
34 #include <linux/stringify.h>
36 #ifdef MODULE_FIRMWARE
37 MODULE_FIRMWARE("asihpi/dsp5000.bin");
38 MODULE_FIRMWARE("asihpi/dsp6200.bin");
39 MODULE_FIRMWARE("asihpi/dsp6205.bin");
40 MODULE_FIRMWARE("asihpi/dsp6400.bin");
41 MODULE_FIRMWARE("asihpi/dsp6600.bin");
42 MODULE_FIRMWARE("asihpi/dsp8700.bin");
43 MODULE_FIRMWARE("asihpi/dsp8900.bin");
46 static int prealloc_stream_buf
;
47 module_param(prealloc_stream_buf
, int, S_IRUGO
);
48 MODULE_PARM_DESC(prealloc_stream_buf
,
49 "Preallocate size for per-adapter stream buffer");
51 /* Allow the debug level to be changed after module load.
52 E.g. echo 2 > /sys/module/asihpi/parameters/hpiDebugLevel
54 module_param(hpi_debug_level
, int, S_IRUGO
| S_IWUSR
);
55 MODULE_PARM_DESC(hpi_debug_level
, "debug verbosity 0..5");
57 /* List of adapters found */
58 static struct hpi_adapter adapters
[HPI_MAX_ADAPTERS
];
60 /* Wrapper function to HPI_Message to enable dumping of the
61 message and response types.
63 static void hpi_send_recv_f(struct hpi_message
*phm
, struct hpi_response
*phr
,
66 int adapter
= phm
->adapter_index
;
68 if ((adapter
>= HPI_MAX_ADAPTERS
|| adapter
< 0)
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
;
109 struct hpi_adapter
*pa
= NULL
;
112 if (cmd
!= HPI_IOCTL_LINUX
)
115 hm
= kmalloc(sizeof(*hm
), GFP_KERNEL
);
116 hr
= kmalloc(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(hm
->h
.size
, (u16 __user
*)puhm
)) {
136 if (hm
->h
.size
> sizeof(*hm
))
137 hm
->h
.size
= sizeof(*hm
);
139 /* printk(KERN_INFO "message size %d\n", hm->h.wSize); */
141 uncopied_bytes
= copy_from_user(hm
, puhm
, hm
->h
.size
);
142 if (uncopied_bytes
) {
143 HPI_DEBUG_LOG(ERROR
, "uncopied bytes %d\n", uncopied_bytes
);
148 if (get_user(res_max_size
, (u16 __user
*)puhr
)) {
152 /* printk(KERN_INFO "user response size %d\n", res_max_size); */
153 if (res_max_size
< sizeof(struct hpi_response_header
)) {
154 HPI_DEBUG_LOG(WARNING
, "small res size %d\n", res_max_size
);
159 pa
= &adapters
[hm
->h
.adapter_index
];
160 hr
->h
.size
= res_max_size
;
161 if (hm
->h
.object
== HPI_OBJ_SUBSYSTEM
) {
162 switch (hm
->h
.function
) {
163 case HPI_SUBSYS_CREATE_ADAPTER
:
164 case HPI_SUBSYS_DELETE_ADAPTER
:
165 /* Application must not use these functions! */
166 hr
->h
.size
= sizeof(hr
->h
);
167 hr
->h
.error
= HPI_ERROR_INVALID_OPERATION
;
168 hr
->h
.function
= hm
->h
.function
;
169 uncopied_bytes
= copy_to_user(puhr
, hr
, hr
->h
.size
);
177 hpi_send_recv_f(&hm
->m0
, &hr
->r0
, file
);
180 u16 __user
*ptr
= NULL
;
183 /* -1=no data 0=read from user mem, 1=write to user mem */
185 u32 adapter
= hm
->h
.adapter_index
;
187 if ((hm
->h
.adapter_index
> HPI_MAX_ADAPTERS
) || (!pa
->type
)) {
188 hpi_init_response(&hr
->r0
, HPI_OBJ_ADAPTER
,
190 HPI_ERROR_BAD_ADAPTER_NUMBER
);
193 copy_to_user(puhr
, hr
, sizeof(hr
->h
));
201 if (mutex_lock_interruptible(&adapters
[adapter
].mutex
)) {
206 /* Dig out any pointers embedded in the message. */
207 switch (hm
->h
.function
) {
208 case HPI_OSTREAM_WRITE
:
209 case HPI_ISTREAM_READ
:{
210 /* Yes, sparse, this is correct. */
211 ptr
= (u16 __user
*)hm
->m0
.u
.d
.u
.data
.pb_data
;
212 size
= hm
->m0
.u
.d
.u
.data
.data_size
;
214 /* Allocate buffer according to application request.
215 ?Is it better to alloc/free for the duration
218 if (pa
->buffer_size
< size
) {
220 "Realloc adapter %d stream "
221 "buffer from %zd to %d\n",
223 pa
->buffer_size
, size
);
228 pa
->p_buffer
= vmalloc(size
);
230 pa
->buffer_size
= size
;
233 "HPI could not allocate "
234 "stream buffer size %d\n",
237 mutex_unlock(&adapters
244 hm
->m0
.u
.d
.u
.data
.pb_data
= pa
->p_buffer
;
245 if (hm
->h
.function
== HPI_ISTREAM_READ
)
246 /* from card, WRITE to user mem */
258 if (size
&& (wrflag
== 0)) {
260 copy_from_user(pa
->p_buffer
, ptr
, size
);
262 HPI_DEBUG_LOG(WARNING
,
264 "bytes from user\n", uncopied_bytes
,
268 hpi_send_recv_f(&hm
->m0
, &hr
->r0
, file
);
270 if (size
&& (wrflag
== 1)) {
272 copy_to_user(ptr
, pa
->p_buffer
, size
);
274 HPI_DEBUG_LOG(WARNING
,
275 "Missed %d of %d " "bytes to user\n",
276 uncopied_bytes
, size
);
279 mutex_unlock(&adapters
[adapter
].mutex
);
282 /* on return response size must be set */
283 /*printk(KERN_INFO "response size %d\n", hr->h.wSize); */
286 HPI_DEBUG_LOG(ERROR
, "response zero size\n");
291 if (hr
->h
.size
> res_max_size
) {
292 HPI_DEBUG_LOG(ERROR
, "response too big %d %d\n", hr
->h
.size
,
294 hr
->h
.error
= HPI_ERROR_RESPONSE_BUFFER_TOO_SMALL
;
295 hr
->h
.specific_error
= hr
->h
.size
;
296 hr
->h
.size
= sizeof(hr
->h
);
299 uncopied_bytes
= copy_to_user(puhr
, hr
, hr
->h
.size
);
300 if (uncopied_bytes
) {
301 HPI_DEBUG_LOG(ERROR
, "uncopied bytes %d\n", uncopied_bytes
);
312 int __devinit
asihpi_adapter_probe(struct pci_dev
*pci_dev
,
313 const struct pci_device_id
*pci_id
)
317 struct hpi_message hm
;
318 struct hpi_response hr
;
319 struct hpi_adapter adapter
;
322 memset(&adapter
, 0, sizeof(adapter
));
324 dev_printk(KERN_DEBUG
, &pci_dev
->dev
,
325 "probe %04x:%04x,%04x:%04x,%04x\n", pci_dev
->vendor
,
326 pci_dev
->device
, pci_dev
->subsystem_vendor
,
327 pci_dev
->subsystem_device
, pci_dev
->devfn
);
329 if (pci_enable_device(pci_dev
) < 0) {
330 dev_printk(KERN_ERR
, &pci_dev
->dev
,
331 "pci_enable_device failed, disabling device\n");
335 pci_set_master(pci_dev
); /* also sets latency timer if < 16 */
337 hpi_init_message_response(&hm
, &hr
, HPI_OBJ_SUBSYSTEM
,
338 HPI_SUBSYS_CREATE_ADAPTER
);
339 hpi_init_response(&hr
, HPI_OBJ_SUBSYSTEM
, HPI_SUBSYS_CREATE_ADAPTER
,
340 HPI_ERROR_PROCESSING_MESSAGE
);
342 hm
.adapter_index
= HPI_ADAPTER_INDEX_INVALID
;
344 adapter
.pci
= pci_dev
;
346 nm
= HPI_MAX_ADAPTER_MEM_SPACES
;
348 for (idx
= 0; idx
< nm
; idx
++) {
349 HPI_DEBUG_LOG(INFO
, "resource %d %s %08llx-%08llx %04llx\n",
350 idx
, pci_dev
->resource
[idx
].name
,
351 (unsigned long long)pci_resource_start(pci_dev
, idx
),
352 (unsigned long long)pci_resource_end(pci_dev
, idx
),
353 (unsigned long long)pci_resource_flags(pci_dev
, idx
));
355 if (pci_resource_flags(pci_dev
, idx
) & IORESOURCE_MEM
) {
356 memlen
= pci_resource_len(pci_dev
, idx
);
357 adapter
.ap_remapped_mem_base
[idx
] =
358 ioremap(pci_resource_start(pci_dev
, idx
),
360 if (!adapter
.ap_remapped_mem_base
[idx
]) {
362 "ioremap failed, aborting\n");
363 /* unmap previously mapped pci mem space */
368 pci
.ap_mem_base
[idx
] = adapter
.ap_remapped_mem_base
[idx
];
371 pci
.pci_dev
= pci_dev
;
372 hm
.u
.s
.resource
.bus_type
= HPI_BUS_PCI
;
373 hm
.u
.s
.resource
.r
.pci
= &pci
;
375 /* call CreateAdapterObject on the relevant hpi module */
376 hpi_send_recv_ex(&hm
, &hr
, HOWNER_KERNEL
);
380 if (prealloc_stream_buf
) {
381 adapter
.p_buffer
= vmalloc(prealloc_stream_buf
);
382 if (!adapter
.p_buffer
) {
384 "HPI could not allocate "
385 "kernel buffer size %d\n",
386 prealloc_stream_buf
);
391 adapter
.index
= hr
.u
.s
.adapter_index
;
392 adapter
.type
= hr
.u
.s
.adapter_type
;
393 hm
.adapter_index
= adapter
.index
;
395 err
= hpi_adapter_open(adapter
.index
);
399 adapter
.snd_card_asihpi
= NULL
;
400 /* WARNING can't init mutex in 'adapter'
401 * and then copy it to adapters[] ?!?!
403 adapters
[hr
.u
.s
.adapter_index
] = adapter
;
404 mutex_init(&adapters
[adapter
.index
].mutex
);
405 pci_set_drvdata(pci_dev
, &adapters
[adapter
.index
]);
407 dev_printk(KERN_INFO
, &pci_dev
->dev
,
408 "probe succeeded for ASI%04X HPI index %d\n", adapter
.type
,
414 for (idx
= 0; idx
< HPI_MAX_ADAPTER_MEM_SPACES
; idx
++) {
415 if (adapter
.ap_remapped_mem_base
[idx
]) {
416 iounmap(adapter
.ap_remapped_mem_base
[idx
]);
417 adapter
.ap_remapped_mem_base
[idx
] = NULL
;
421 if (adapter
.p_buffer
) {
422 adapter
.buffer_size
= 0;
423 vfree(adapter
.p_buffer
);
426 HPI_DEBUG_LOG(ERROR
, "adapter_probe failed\n");
430 void __devexit
asihpi_adapter_remove(struct pci_dev
*pci_dev
)
433 struct hpi_message hm
;
434 struct hpi_response hr
;
435 struct hpi_adapter
*pa
;
436 pa
= pci_get_drvdata(pci_dev
);
438 hpi_init_message_response(&hm
, &hr
, HPI_OBJ_SUBSYSTEM
,
439 HPI_SUBSYS_DELETE_ADAPTER
);
440 hm
.obj_index
= pa
->index
;
441 hm
.adapter_index
= HPI_ADAPTER_INDEX_INVALID
;
442 hpi_send_recv_ex(&hm
, &hr
, HOWNER_KERNEL
);
444 /* unmap PCI memory space, mapped during device init. */
445 for (idx
= 0; idx
< HPI_MAX_ADAPTER_MEM_SPACES
; idx
++) {
446 if (pa
->ap_remapped_mem_base
[idx
]) {
447 iounmap(pa
->ap_remapped_mem_base
[idx
]);
448 pa
->ap_remapped_mem_base
[idx
] = NULL
;
455 pci_set_drvdata(pci_dev
, NULL
);
457 dev_printk(KERN_INFO
, &pci_dev
->dev
,
458 "remove %04x:%04x,%04x:%04x,%04x," " HPI index %d.\n",
459 pci_dev
->vendor
, pci_dev
->device
,
460 pci_dev
->subsystem_vendor
, pci_dev
->subsystem_device
,
461 pci_dev
->devfn
, pa
->index
);
463 memset(pa
, 0, sizeof(*pa
));
466 void __init
asihpi_init(void)
468 struct hpi_message hm
;
469 struct hpi_response hr
;
471 memset(adapters
, 0, sizeof(adapters
));
473 printk(KERN_INFO
"ASIHPI driver " HPI_VER_STRING
"\n");
475 hpi_init_message_response(&hm
, &hr
, HPI_OBJ_SUBSYSTEM
,
476 HPI_SUBSYS_DRIVER_LOAD
);
477 hpi_send_recv_ex(&hm
, &hr
, HOWNER_KERNEL
);
480 void asihpi_exit(void)
482 struct hpi_message hm
;
483 struct hpi_response hr
;
485 hpi_init_message_response(&hm
, &hr
, HPI_OBJ_SUBSYSTEM
,
486 HPI_SUBSYS_DRIVER_UNLOAD
);
487 hpi_send_recv_ex(&hm
, &hr
, HOWNER_KERNEL
);