projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: asihpi - fix pcm dma pointer tracking
[linux-block.git] / sound / pci / asihpi / hpimsgx.c
CommitLineData
719f82d3
EB		 1/******************************************************************************
2
3 AudioScience HPI driver
4 Copyright (C) 1997-2010 AudioScience Inc. <support@audioscience.com>
5
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;
9
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.
14
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
18
938c565a 19Extended Message Function With Response Caching
719f82d3
EB		 20
21(C) Copyright AudioScience Inc. 2002
22*****************************************************************************/
23#define SOURCEFILE_NAME "hpimsgx.c"
24#include "hpi_internal.h"
25#include "hpimsginit.h"
3285ea10 26#include "hpicmn.h"
719f82d3
EB		 27#include "hpimsgx.h"
28#include "hpidebug.h"
29
30static struct pci_device_id asihpi_pci_tbl[] = {
31#include "hpipcida.h"
32};
33
34static struct hpios_spinlock msgx_lock;
35
36static hpi_handler_func *hpi_entry_points[HPI_MAX_ADAPTERS];
37
38static hpi_handler_func *hpi_lookup_entry_point_function(const struct hpi_pci
39 *pci_info)
40{
41
42 int i;
43
44 for (i = 0; asihpi_pci_tbl[i].vendor != 0; i++) {
45 if (asihpi_pci_tbl[i].vendor != PCI_ANY_ID
3285ea10
EB		 46 && asihpi_pci_tbl[i].vendor !=
47 pci_info->pci_dev->vendor)
719f82d3
EB		 48 continue;
49 if (asihpi_pci_tbl[i].device != PCI_ANY_ID
3285ea10
EB		 50 && asihpi_pci_tbl[i].device !=
51 pci_info->pci_dev->device)
719f82d3
EB		 52 continue;
53 if (asihpi_pci_tbl[i].subvendor != PCI_ANY_ID
54 && asihpi_pci_tbl[i].subvendor !=
3285ea10 55 pci_info->pci_dev->subsystem_vendor)
719f82d3
EB		 56 continue;
57 if (asihpi_pci_tbl[i].subdevice != PCI_ANY_ID
58 && asihpi_pci_tbl[i].subdevice !=
3285ea10 59 pci_info->pci_dev->subsystem_device)
719f82d3
EB		 60 continue;
61
3285ea10
EB		 62 /* HPI_DEBUG_LOG(DEBUG, " %x,%lx\n", i,
63 asihpi_pci_tbl[i].driver_data); */
719f82d3
EB		 64 return (hpi_handler_func *) asihpi_pci_tbl[i].driver_data;
65 }
66
67 return NULL;
68}
69
70static inline void hw_entry_point(struct hpi_message *phm,
71 struct hpi_response *phr)
72{
3285ea10
EB		 73 if ((phm->adapter_index < HPI_MAX_ADAPTERS)
74 && hpi_entry_points[phm->adapter_index])
75 hpi_entry_points[phm->adapter_index] (phm, phr);
76 else
77 hpi_init_response(phr, phm->object, phm->function,
78 HPI_ERROR_PROCESSING_MESSAGE);
719f82d3
EB		 79}
80
81static void adapter_open(struct hpi_message *phm, struct hpi_response *phr);
82static void adapter_close(struct hpi_message *phm, struct hpi_response *phr);
83
84static void mixer_open(struct hpi_message *phm, struct hpi_response *phr);
85static void mixer_close(struct hpi_message *phm, struct hpi_response *phr);
86
87static void outstream_open(struct hpi_message *phm, struct hpi_response *phr,
88 void *h_owner);
89static void outstream_close(struct hpi_message *phm, struct hpi_response *phr,
90 void *h_owner);
91static void instream_open(struct hpi_message *phm, struct hpi_response *phr,
92 void *h_owner);
93static void instream_close(struct hpi_message *phm, struct hpi_response *phr,
94 void *h_owner);
95
96static void HPIMSGX__reset(u16 adapter_index);
3285ea10 97
719f82d3
EB		 98static u16 HPIMSGX__init(struct hpi_message *phm, struct hpi_response *phr);
99static void HPIMSGX__cleanup(u16 adapter_index, void *h_owner);
100
101#ifndef DISABLE_PRAGMA_PACK1
102#pragma pack(push, 1)
103#endif
104
105struct hpi_subsys_response {
106 struct hpi_response_header h;
107 struct hpi_subsys_res s;
108};
109
110struct hpi_adapter_response {
111 struct hpi_response_header h;
112 struct hpi_adapter_res a;
113};
114
115struct hpi_mixer_response {
116 struct hpi_response_header h;
117 struct hpi_mixer_res m;
118};
119
120struct hpi_stream_response {
121 struct hpi_response_header h;
122 struct hpi_stream_res d;
123};
124
125struct adapter_info {
126 u16 type;
127 u16 num_instreams;
128 u16 num_outstreams;
129};
130
131struct asi_open_state {
132 int open_flag;
133 void *h_owner;
134};
135
136#ifndef DISABLE_PRAGMA_PACK1
137#pragma pack(pop)
138#endif
139
140/* Globals */
141static struct hpi_adapter_response rESP_HPI_ADAPTER_OPEN[HPI_MAX_ADAPTERS];
142
143static struct hpi_stream_response
144 rESP_HPI_OSTREAM_OPEN[HPI_MAX_ADAPTERS][HPI_MAX_STREAMS];
145
146static struct hpi_stream_response
147 rESP_HPI_ISTREAM_OPEN[HPI_MAX_ADAPTERS][HPI_MAX_STREAMS];
148
149static struct hpi_mixer_response rESP_HPI_MIXER_OPEN[HPI_MAX_ADAPTERS];
150
719f82d3
EB		 151static struct adapter_info aDAPTER_INFO[HPI_MAX_ADAPTERS];
152
153/* use these to keep track of opens from user mode apps/DLLs */
154static struct asi_open_state
155 outstream_user_open[HPI_MAX_ADAPTERS][HPI_MAX_STREAMS];
156
157static struct asi_open_state
158 instream_user_open[HPI_MAX_ADAPTERS][HPI_MAX_STREAMS];
159
160static void subsys_message(struct hpi_message *phm, struct hpi_response *phr,
161 void *h_owner)
162{
3285ea10
EB		 163 if (phm->adapter_index != HPI_ADAPTER_INDEX_INVALID)
164 HPI_DEBUG_LOG(WARNING,
165 "suspicious adapter index %d in subsys message 0x%x.\n",
166 phm->adapter_index, phm->function);
167
719f82d3
EB		 168 switch (phm->function) {
169 case HPI_SUBSYS_GET_VERSION:
170 hpi_init_response(phr, HPI_OBJ_SUBSYSTEM,
171 HPI_SUBSYS_GET_VERSION, 0);
172 phr->u.s.version = HPI_VER >> 8; /* return major.minor */
173 phr->u.s.data = HPI_VER; /* return major.minor.release */
174 break;
175 case HPI_SUBSYS_OPEN:
176 /*do not propagate the message down the chain */
177 hpi_init_response(phr, HPI_OBJ_SUBSYSTEM, HPI_SUBSYS_OPEN, 0);
178 break;
179 case HPI_SUBSYS_CLOSE:
180 /*do not propagate the message down the chain */
181 hpi_init_response(phr, HPI_OBJ_SUBSYSTEM, HPI_SUBSYS_CLOSE,
182 0);
183 HPIMSGX__cleanup(HPIMSGX_ALLADAPTERS, h_owner);
184 break;
185 case HPI_SUBSYS_DRIVER_LOAD:
186 /* Initialize this module's internal state */
187 hpios_msgxlock_init(&msgx_lock);
188 memset(&hpi_entry_points, 0, sizeof(hpi_entry_points));
719f82d3
EB		 189 /* Init subsys_findadapters response to no-adapters */
190 HPIMSGX__reset(HPIMSGX_ALLADAPTERS);
191 hpi_init_response(phr, HPI_OBJ_SUBSYSTEM,
192 HPI_SUBSYS_DRIVER_LOAD, 0);
193 /* individual HPIs dont implement driver load */
194 HPI_COMMON(phm, phr);
195 break;
196 case HPI_SUBSYS_DRIVER_UNLOAD:
197 HPI_COMMON(phm, phr);
198 HPIMSGX__cleanup(HPIMSGX_ALLADAPTERS, h_owner);
719f82d3
EB		 199 hpi_init_response(phr, HPI_OBJ_SUBSYSTEM,
200 HPI_SUBSYS_DRIVER_UNLOAD, 0);
201 return;
202
719f82d3 203 case HPI_SUBSYS_GET_NUM_ADAPTERS:
719f82d3 204 case HPI_SUBSYS_GET_ADAPTER:
3285ea10
EB		 205 HPI_COMMON(phm, phr);
206 break;
719f82d3 207
719f82d3
EB		 208 case HPI_SUBSYS_CREATE_ADAPTER:
209 HPIMSGX__init(phm, phr);
210 break;
3285ea10 211
719f82d3 212 default:
1d595d2a 213 /* Must explicitly handle every subsys message in this switch */
3285ea10
EB		 214 hpi_init_response(phr, HPI_OBJ_SUBSYSTEM, phm->function,
215 HPI_ERROR_INVALID_FUNC);
719f82d3
EB		 216 break;
217 }
218}
219
220static void adapter_message(struct hpi_message *phm, struct hpi_response *phr,
221 void *h_owner)
222{
223 switch (phm->function) {
224 case HPI_ADAPTER_OPEN:
225 adapter_open(phm, phr);
226 break;
227 case HPI_ADAPTER_CLOSE:
228 adapter_close(phm, phr);
229 break;
6d0b898e
EB		 230 case HPI_ADAPTER_DELETE:
231 HPIMSGX__cleanup(phm->adapter_index, h_owner);
232 {
233 struct hpi_message hm;
234 struct hpi_response hr;
235 hpi_init_message_response(&hm, &hr, HPI_OBJ_ADAPTER,
236 HPI_ADAPTER_CLOSE);
237 hm.adapter_index = phm->adapter_index;
238 hw_entry_point(&hm, &hr);
239 }
240 hw_entry_point(phm, phr);
241 break;
242
719f82d3
EB		 243 default:
244 hw_entry_point(phm, phr);
245 break;
246 }
247}
248
249static void mixer_message(struct hpi_message *phm, struct hpi_response *phr)
250{
251 switch (phm->function) {
252 case HPI_MIXER_OPEN:
253 mixer_open(phm, phr);
254 break;
255 case HPI_MIXER_CLOSE:
256 mixer_close(phm, phr);
257 break;
258 default:
259 hw_entry_point(phm, phr);
260 break;
261 }
262}
263
264static void outstream_message(struct hpi_message *phm,
265 struct hpi_response *phr, void *h_owner)
266{
267 if (phm->obj_index >= aDAPTER_INFO[phm->adapter_index].num_outstreams) {
268 hpi_init_response(phr, HPI_OBJ_OSTREAM, phm->function,
269 HPI_ERROR_INVALID_OBJ_INDEX);
270 return;
271 }
272
273 switch (phm->function) {
274 case HPI_OSTREAM_OPEN:
275 outstream_open(phm, phr, h_owner);
276 break;
277 case HPI_OSTREAM_CLOSE:
278 outstream_close(phm, phr, h_owner);
279 break;
280 default:
281 hw_entry_point(phm, phr);
282 break;
283 }
284}
285
286static void instream_message(struct hpi_message *phm,
287 struct hpi_response *phr, void *h_owner)
288{
289 if (phm->obj_index >= aDAPTER_INFO[phm->adapter_index].num_instreams) {
290 hpi_init_response(phr, HPI_OBJ_ISTREAM, phm->function,
291 HPI_ERROR_INVALID_OBJ_INDEX);
292 return;
293 }
294
295 switch (phm->function) {
296 case HPI_ISTREAM_OPEN:
297 instream_open(phm, phr, h_owner);
298 break;
299 case HPI_ISTREAM_CLOSE:
300 instream_close(phm, phr, h_owner);
301 break;
302 default:
303 hw_entry_point(phm, phr);
304 break;
305 }
306}
307
308/* NOTE: HPI_Message() must be defined in the driver as a wrapper for
309 * HPI_MessageEx so that functions in hpifunc.c compile.
310 */
311void hpi_send_recv_ex(struct hpi_message *phm, struct hpi_response *phr,
312 void *h_owner)
313{
314 HPI_DEBUG_MESSAGE(DEBUG, phm);
315
82b5774f 316 if (phm->type != HPI_TYPE_REQUEST) {
719f82d3
EB		 317 hpi_init_response(phr, phm->object, phm->function,
318 HPI_ERROR_INVALID_TYPE);
319 return;
320 }
321
322 if (phm->adapter_index >= HPI_MAX_ADAPTERS
323 && phm->adapter_index != HPIMSGX_ALLADAPTERS) {
324 hpi_init_response(phr, phm->object, phm->function,
325 HPI_ERROR_BAD_ADAPTER_NUMBER);
326 return;
327 }
328
329 switch (phm->object) {
330 case HPI_OBJ_SUBSYSTEM:
331 subsys_message(phm, phr, h_owner);
332 break;
333
334 case HPI_OBJ_ADAPTER:
335 adapter_message(phm, phr, h_owner);
336 break;
337
338 case HPI_OBJ_MIXER:
339 mixer_message(phm, phr);
340 break;
341
342 case HPI_OBJ_OSTREAM:
343 outstream_message(phm, phr, h_owner);
344 break;
345
346 case HPI_OBJ_ISTREAM:
347 instream_message(phm, phr, h_owner);
348 break;
349
350 default:
351 hw_entry_point(phm, phr);
352 break;
353 }
354 HPI_DEBUG_RESPONSE(phr);
3285ea10 355
719f82d3
EB		 356}
357
358static void adapter_open(struct hpi_message *phm, struct hpi_response *phr)
359{
360 HPI_DEBUG_LOG(VERBOSE, "adapter_open\n");
361 memcpy(phr, &rESP_HPI_ADAPTER_OPEN[phm->adapter_index],
362 sizeof(rESP_HPI_ADAPTER_OPEN[0]));
363}
364
365static void adapter_close(struct hpi_message *phm, struct hpi_response *phr)
366{
367 HPI_DEBUG_LOG(VERBOSE, "adapter_close\n");
368 hpi_init_response(phr, HPI_OBJ_ADAPTER, HPI_ADAPTER_CLOSE, 0);
369}
370
371static void mixer_open(struct hpi_message *phm, struct hpi_response *phr)
372{
373 memcpy(phr, &rESP_HPI_MIXER_OPEN[phm->adapter_index],
374 sizeof(rESP_HPI_MIXER_OPEN[0]));
375}
376
377static void mixer_close(struct hpi_message *phm, struct hpi_response *phr)
378{
379 hpi_init_response(phr, HPI_OBJ_MIXER, HPI_MIXER_CLOSE, 0);
380}
381
382static void instream_open(struct hpi_message *phm, struct hpi_response *phr,
383 void *h_owner)
384{
385
386 struct hpi_message hm;
387 struct hpi_response hr;
388
389 hpi_init_response(phr, HPI_OBJ_ISTREAM, HPI_ISTREAM_OPEN, 0);
390
391 hpios_msgxlock_lock(&msgx_lock);
392
393 if (instream_user_open[phm->adapter_index][phm->obj_index].open_flag)
394 phr->error = HPI_ERROR_OBJ_ALREADY_OPEN;
395 else if (rESP_HPI_ISTREAM_OPEN[phm->adapter_index]
396 [phm->obj_index].h.error)
397 memcpy(phr,
398 &rESP_HPI_ISTREAM_OPEN[phm->adapter_index][phm->
399 obj_index],
400 sizeof(rESP_HPI_ISTREAM_OPEN[0][0]));
401 else {
402 instream_user_open[phm->adapter_index][phm->
403 obj_index].open_flag = 1;
3285ea10 404 hpios_msgxlock_unlock(&msgx_lock);
719f82d3
EB		 405
406 /* issue a reset */
407 hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
408 HPI_ISTREAM_RESET);
409 hm.adapter_index = phm->adapter_index;
410 hm.obj_index = phm->obj_index;
411 hw_entry_point(&hm, &hr);
412
413 hpios_msgxlock_lock(&msgx_lock);
414 if (hr.error) {
415 instream_user_open[phm->adapter_index][phm->
416 obj_index].open_flag = 0;
417 phr->error = hr.error;
418 } else {
419 instream_user_open[phm->adapter_index][phm->
420 obj_index].open_flag = 1;
421 instream_user_open[phm->adapter_index][phm->
422 obj_index].h_owner = h_owner;
423 memcpy(phr,
424 &rESP_HPI_ISTREAM_OPEN[phm->adapter_index]
425 [phm->obj_index],
426 sizeof(rESP_HPI_ISTREAM_OPEN[0][0]));
427 }
428 }
3285ea10 429 hpios_msgxlock_unlock(&msgx_lock);
719f82d3
EB		 430}
431
432static void instream_close(struct hpi_message *phm, struct hpi_response *phr,
433 void *h_owner)
434{
435
436 struct hpi_message hm;
437 struct hpi_response hr;
438
439 hpi_init_response(phr, HPI_OBJ_ISTREAM, HPI_ISTREAM_CLOSE, 0);
440
441 hpios_msgxlock_lock(&msgx_lock);
442 if (h_owner ==
443 instream_user_open[phm->adapter_index][phm->
444 obj_index].h_owner) {
445 /* HPI_DEBUG_LOG(INFO,"closing adapter %d "
446 "instream %d owned by %p\n",
447 phm->wAdapterIndex, phm->wObjIndex, hOwner); */
448 instream_user_open[phm->adapter_index][phm->
449 obj_index].h_owner = NULL;
3285ea10 450 hpios_msgxlock_unlock(&msgx_lock);
719f82d3
EB		 451 /* issue a reset */
452 hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
453 HPI_ISTREAM_RESET);
454 hm.adapter_index = phm->adapter_index;
455 hm.obj_index = phm->obj_index;
456 hw_entry_point(&hm, &hr);
457 hpios_msgxlock_lock(&msgx_lock);
458 if (hr.error) {
459 instream_user_open[phm->adapter_index][phm->
460 obj_index].h_owner = h_owner;
461 phr->error = hr.error;
462 } else {
463 instream_user_open[phm->adapter_index][phm->
464 obj_index].open_flag = 0;
465 instream_user_open[phm->adapter_index][phm->
466 obj_index].h_owner = NULL;
467 }
468 } else {
469 HPI_DEBUG_LOG(WARNING,
470 "%p trying to close %d instream %d owned by %p\n",
471 h_owner, phm->adapter_index, phm->obj_index,
472 instream_user_open[phm->adapter_index][phm->
473 obj_index].h_owner);
474 phr->error = HPI_ERROR_OBJ_NOT_OPEN;
475 }
3285ea10 476 hpios_msgxlock_unlock(&msgx_lock);
719f82d3
EB		 477}
478
479static void outstream_open(struct hpi_message *phm, struct hpi_response *phr,
480 void *h_owner)
481{
482
483 struct hpi_message hm;
484 struct hpi_response hr;
485
486 hpi_init_response(phr, HPI_OBJ_OSTREAM, HPI_OSTREAM_OPEN, 0);
487
488 hpios_msgxlock_lock(&msgx_lock);
489
490 if (outstream_user_open[phm->adapter_index][phm->obj_index].open_flag)
491 phr->error = HPI_ERROR_OBJ_ALREADY_OPEN;
492 else if (rESP_HPI_OSTREAM_OPEN[phm->adapter_index]
493 [phm->obj_index].h.error)
494 memcpy(phr,
495 &rESP_HPI_OSTREAM_OPEN[phm->adapter_index][phm->
496 obj_index],
497 sizeof(rESP_HPI_OSTREAM_OPEN[0][0]));
498 else {
499 outstream_user_open[phm->adapter_index][phm->
500 obj_index].open_flag = 1;
3285ea10 501 hpios_msgxlock_unlock(&msgx_lock);
719f82d3
EB		 502
503 /* issue a reset */
504 hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
505 HPI_OSTREAM_RESET);
506 hm.adapter_index = phm->adapter_index;
507 hm.obj_index = phm->obj_index;
508 hw_entry_point(&hm, &hr);
509
510 hpios_msgxlock_lock(&msgx_lock);
511 if (hr.error) {
512 outstream_user_open[phm->adapter_index][phm->
513 obj_index].open_flag = 0;
514 phr->error = hr.error;
515 } else {
516 outstream_user_open[phm->adapter_index][phm->
517 obj_index].open_flag = 1;
518 outstream_user_open[phm->adapter_index][phm->
519 obj_index].h_owner = h_owner;
520 memcpy(phr,
521 &rESP_HPI_OSTREAM_OPEN[phm->adapter_index]
522 [phm->obj_index],
523 sizeof(rESP_HPI_OSTREAM_OPEN[0][0]));
524 }
525 }
3285ea10 526 hpios_msgxlock_unlock(&msgx_lock);
719f82d3
EB		 527}
528
529static void outstream_close(struct hpi_message *phm, struct hpi_response *phr,
530 void *h_owner)
531{
532
533 struct hpi_message hm;
534 struct hpi_response hr;
535
536 hpi_init_response(phr, HPI_OBJ_OSTREAM, HPI_OSTREAM_CLOSE, 0);
537
538 hpios_msgxlock_lock(&msgx_lock);
539
540 if (h_owner ==
541 outstream_user_open[phm->adapter_index][phm->
542 obj_index].h_owner) {
543 /* HPI_DEBUG_LOG(INFO,"closing adapter %d "
544 "outstream %d owned by %p\n",
545 phm->wAdapterIndex, phm->wObjIndex, hOwner); */
546 outstream_user_open[phm->adapter_index][phm->
547 obj_index].h_owner = NULL;
3285ea10 548 hpios_msgxlock_unlock(&msgx_lock);
719f82d3
EB		 549 /* issue a reset */
550 hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
551 HPI_OSTREAM_RESET);
552 hm.adapter_index = phm->adapter_index;
553 hm.obj_index = phm->obj_index;
554 hw_entry_point(&hm, &hr);
555 hpios_msgxlock_lock(&msgx_lock);
556 if (hr.error) {
557 outstream_user_open[phm->adapter_index][phm->
558 obj_index].h_owner = h_owner;
559 phr->error = hr.error;
560 } else {
561 outstream_user_open[phm->adapter_index][phm->
562 obj_index].open_flag = 0;
563 outstream_user_open[phm->adapter_index][phm->
564 obj_index].h_owner = NULL;
565 }
566 } else {
567 HPI_DEBUG_LOG(WARNING,
568 "%p trying to close %d outstream %d owned by %p\n",
569 h_owner, phm->adapter_index, phm->obj_index,
570 outstream_user_open[phm->adapter_index][phm->
571 obj_index].h_owner);
572 phr->error = HPI_ERROR_OBJ_NOT_OPEN;
573 }
3285ea10 574 hpios_msgxlock_unlock(&msgx_lock);
719f82d3
EB		 575}
576
577static u16 adapter_prepare(u16 adapter)
578{
579 struct hpi_message hm;
580 struct hpi_response hr;
581
582 /* Open the adapter and streams */
583 u16 i;
584
585 /* call to HPI_ADAPTER_OPEN */
586 hpi_init_message_response(&hm, &hr, HPI_OBJ_ADAPTER,
587 HPI_ADAPTER_OPEN);
588 hm.adapter_index = adapter;
589 hw_entry_point(&hm, &hr);
590 memcpy(&rESP_HPI_ADAPTER_OPEN[adapter], &hr,
591 sizeof(rESP_HPI_ADAPTER_OPEN[0]));
592 if (hr.error)
593 return hr.error;
594
595 /* call to HPI_ADAPTER_GET_INFO */
596 hpi_init_message_response(&hm, &hr, HPI_OBJ_ADAPTER,
597 HPI_ADAPTER_GET_INFO);
598 hm.adapter_index = adapter;
599 hw_entry_point(&hm, &hr);
600 if (hr.error)
601 return hr.error;
602
3285ea10
EB		 603 aDAPTER_INFO[adapter].num_outstreams = hr.u.ax.info.num_outstreams;
604 aDAPTER_INFO[adapter].num_instreams = hr.u.ax.info.num_instreams;
605 aDAPTER_INFO[adapter].type = hr.u.ax.info.adapter_type;
719f82d3
EB		 606
607 /* call to HPI_OSTREAM_OPEN */
608 for (i = 0; i < aDAPTER_INFO[adapter].num_outstreams; i++) {
609 hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
610 HPI_OSTREAM_OPEN);
611 hm.adapter_index = adapter;
612 hm.obj_index = i;
613 hw_entry_point(&hm, &hr);
614 memcpy(&rESP_HPI_OSTREAM_OPEN[adapter][i], &hr,
615 sizeof(rESP_HPI_OSTREAM_OPEN[0][0]));
616 outstream_user_open[adapter][i].open_flag = 0;
617 outstream_user_open[adapter][i].h_owner = NULL;
618 }
619
620 /* call to HPI_ISTREAM_OPEN */
621 for (i = 0; i < aDAPTER_INFO[adapter].num_instreams; i++) {
622 hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
623 HPI_ISTREAM_OPEN);
624 hm.adapter_index = adapter;
625 hm.obj_index = i;
626 hw_entry_point(&hm, &hr);
627 memcpy(&rESP_HPI_ISTREAM_OPEN[adapter][i], &hr,
628 sizeof(rESP_HPI_ISTREAM_OPEN[0][0]));
629 instream_user_open[adapter][i].open_flag = 0;
630 instream_user_open[adapter][i].h_owner = NULL;
631 }
632
633 /* call to HPI_MIXER_OPEN */
634 hpi_init_message_response(&hm, &hr, HPI_OBJ_MIXER, HPI_MIXER_OPEN);
635 hm.adapter_index = adapter;
636 hw_entry_point(&hm, &hr);
637 memcpy(&rESP_HPI_MIXER_OPEN[adapter], &hr,
638 sizeof(rESP_HPI_MIXER_OPEN[0]));
639
3285ea10 640 return 0;
719f82d3
EB		 641}
642
643static void HPIMSGX__reset(u16 adapter_index)
644{
645 int i;
646 u16 adapter;
647 struct hpi_response hr;
648
649 if (adapter_index == HPIMSGX_ALLADAPTERS) {
719f82d3
EB		 650 for (adapter = 0; adapter < HPI_MAX_ADAPTERS; adapter++) {
651
652 hpi_init_response(&hr, HPI_OBJ_ADAPTER,
653 HPI_ADAPTER_OPEN, HPI_ERROR_BAD_ADAPTER);
654 memcpy(&rESP_HPI_ADAPTER_OPEN[adapter], &hr,
655 sizeof(rESP_HPI_ADAPTER_OPEN[adapter]));
656
657 hpi_init_response(&hr, HPI_OBJ_MIXER, HPI_MIXER_OPEN,
658 HPI_ERROR_INVALID_OBJ);
659 memcpy(&rESP_HPI_MIXER_OPEN[adapter], &hr,
660 sizeof(rESP_HPI_MIXER_OPEN[adapter]));
661
662 for (i = 0; i < HPI_MAX_STREAMS; i++) {
663 hpi_init_response(&hr, HPI_OBJ_OSTREAM,
664 HPI_OSTREAM_OPEN,
665 HPI_ERROR_INVALID_OBJ);
666 memcpy(&rESP_HPI_OSTREAM_OPEN[adapter][i],
667 &hr,
668 sizeof(rESP_HPI_OSTREAM_OPEN[adapter]
669 [i]));
670 hpi_init_response(&hr, HPI_OBJ_ISTREAM,
671 HPI_ISTREAM_OPEN,
672 HPI_ERROR_INVALID_OBJ);
673 memcpy(&rESP_HPI_ISTREAM_OPEN[adapter][i],
674 &hr,
675 sizeof(rESP_HPI_ISTREAM_OPEN[adapter]
676 [i]));
677 }
678 }
679 } else if (adapter_index < HPI_MAX_ADAPTERS) {
680 rESP_HPI_ADAPTER_OPEN[adapter_index].h.error =
681 HPI_ERROR_BAD_ADAPTER;
682 rESP_HPI_MIXER_OPEN[adapter_index].h.error =
683 HPI_ERROR_INVALID_OBJ;
684 for (i = 0; i < HPI_MAX_STREAMS; i++) {
685 rESP_HPI_OSTREAM_OPEN[adapter_index][i].h.error =
686 HPI_ERROR_INVALID_OBJ;
687 rESP_HPI_ISTREAM_OPEN[adapter_index][i].h.error =
688 HPI_ERROR_INVALID_OBJ;
689 }
719f82d3
EB		 690 }
691}
692
693static u16 HPIMSGX__init(struct hpi_message *phm,
694 /* HPI_SUBSYS_CREATE_ADAPTER structure with */
695 /* resource list or NULL=find all */
696 struct hpi_response *phr
697 /* response from HPI_ADAPTER_GET_INFO */
698 )
699{
700 hpi_handler_func *entry_point_func;
701 struct hpi_response hr;
702
719f82d3
EB		 703 /* Init response here so we can pass in previous adapter list */
704 hpi_init_response(&hr, phm->object, phm->function,
705 HPI_ERROR_INVALID_OBJ);
719f82d3
EB		 706
707 entry_point_func =
708 hpi_lookup_entry_point_function(phm->u.s.resource.r.pci);
709
710 if (entry_point_func) {
711 HPI_DEBUG_MESSAGE(DEBUG, phm);
712 entry_point_func(phm, &hr);
713 } else {
714 phr->error = HPI_ERROR_PROCESSING_MESSAGE;
715 return phr->error;
716 }
717 if (hr.error == 0) {
25985edc 718 /* the adapter was created successfully
719f82d3
EB		 719 save the mapping for future use */
720 hpi_entry_points[hr.u.s.adapter_index] = entry_point_func;
721 /* prepare adapter (pre-open streams etc.) */
722 HPI_DEBUG_LOG(DEBUG,
723 "HPI_SUBSYS_CREATE_ADAPTER successful,"
724 " preparing adapter\n");
725 adapter_prepare(hr.u.s.adapter_index);
726 }
727 memcpy(phr, &hr, hr.size);
728 return phr->error;
729}
730
731static void HPIMSGX__cleanup(u16 adapter_index, void *h_owner)
732{
733 int i, adapter, adapter_limit;
734
735 if (!h_owner)
736 return;
737
738 if (adapter_index == HPIMSGX_ALLADAPTERS) {
739 adapter = 0;
740 adapter_limit = HPI_MAX_ADAPTERS;
741 } else {
742 adapter = adapter_index;
743 adapter_limit = adapter + 1;
744 }
745
746 for (; adapter < adapter_limit; adapter++) {
747 /* printk(KERN_INFO "Cleanup adapter #%d\n",wAdapter); */
748 for (i = 0; i < HPI_MAX_STREAMS; i++) {
749 if (h_owner ==
750 outstream_user_open[adapter][i].h_owner) {
751 struct hpi_message hm;
752 struct hpi_response hr;
753
754 HPI_DEBUG_LOG(DEBUG,
3285ea10 755 "Close adapter %d ostream %d\n",
719f82d3
EB		 756 adapter, i);
757
758 hpi_init_message_response(&hm, &hr,
759 HPI_OBJ_OSTREAM, HPI_OSTREAM_RESET);
760 hm.adapter_index = (u16)adapter;
761 hm.obj_index = (u16)i;
762 hw_entry_point(&hm, &hr);
763
764 hm.function = HPI_OSTREAM_HOSTBUFFER_FREE;
765 hw_entry_point(&hm, &hr);
766
767 hm.function = HPI_OSTREAM_GROUP_RESET;
768 hw_entry_point(&hm, &hr);
769
770 outstream_user_open[adapter][i].open_flag = 0;
771 outstream_user_open[adapter][i].h_owner =
772 NULL;
773 }
774 if (h_owner == instream_user_open[adapter][i].h_owner) {
775 struct hpi_message hm;
776 struct hpi_response hr;
777
778 HPI_DEBUG_LOG(DEBUG,
3285ea10 779 "Close adapter %d istream %d\n",
719f82d3
EB		 780 adapter, i);
781
782 hpi_init_message_response(&hm, &hr,
783 HPI_OBJ_ISTREAM, HPI_ISTREAM_RESET);
784 hm.adapter_index = (u16)adapter;
785 hm.obj_index = (u16)i;
786 hw_entry_point(&hm, &hr);
787
788 hm.function = HPI_ISTREAM_HOSTBUFFER_FREE;
789 hw_entry_point(&hm, &hr);
790
791 hm.function = HPI_ISTREAM_GROUP_RESET;
792 hw_entry_point(&hm, &hr);
793
794 instream_user_open[adapter][i].open_flag = 0;
795 instream_user_open[adapter][i].h_owner = NULL;
796 }
797 }
798 }
799}
Linux 6.x block layer and io_uring tree(s)