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