License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 22:07:57 +08:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2011-03-15 14:53:21 +08:00
|
|
|
#ifndef SOUND_FIREWIRE_AMDTP_H_INCLUDED
|
|
|
|
|
#define SOUND_FIREWIRE_AMDTP_H_INCLUDED
|
|
|
|
|
|
2011-09-05 04:15:44 +08:00
|
|
|
#include <linux/err.h>
|
2012-05-14 04:03:09 +08:00
|
|
|
#include <linux/interrupt.h>
|
2011-03-15 14:53:21 +08:00
|
|
|
#include <linux/mutex.h>
|
2015-09-19 10:21:55 +08:00
|
|
|
#include <linux/sched.h>
|
2013-11-19 12:29:24 +08:00
|
|
|
#include <sound/asound.h>
|
2011-03-15 14:53:21 +08:00
|
|
|
#include "packets-buffer.h"
|
|
|
|
|
|
|
|
|
|
/**
|
2014-04-25 21:44:42 +08:00
|
|
|
* enum cip_flags - describes details of the streaming protocol
|
2011-03-15 14:53:21 +08:00
|
|
|
* @CIP_NONBLOCKING: In non-blocking mode, each packet contains
|
|
|
|
|
* sample_rate/8000 samples, with rounding up or down to adjust
|
|
|
|
|
* for clock skew and left-over fractional samples. This should
|
|
|
|
|
* be used if supported by the device.
|
2011-09-05 04:12:48 +08:00
|
|
|
* @CIP_BLOCKING: In blocking mode, each packet contains either zero or
|
|
|
|
|
* SYT_INTERVAL samples, with these two types alternating so that
|
|
|
|
|
* the overall sample rate comes out right.
|
2014-04-25 21:45:03 +08:00
|
|
|
* @CIP_EMPTY_WITH_TAG0: Only for in-stream. Empty in-packets have TAG0.
|
2017-03-22 20:30:17 +08:00
|
|
|
* @CIP_DBC_IS_END_EVENT: The value of dbc in an packet corresponds to the end
|
|
|
|
|
* of event in the packet. Out of IEC 61883.
|
2014-04-25 21:45:05 +08:00
|
|
|
* @CIP_WRONG_DBS: Only for in-stream. The value of dbs is wrong in in-packets.
|
|
|
|
|
* The value of data_block_quadlets is used instead of reported value.
|
2014-11-18 22:59:40 +08:00
|
|
|
* @CIP_SKIP_DBC_ZERO_CHECK: Only for in-stream. Packets with zero in dbc is
|
2014-04-25 21:45:07 +08:00
|
|
|
* skipped for detecting discontinuity.
|
2014-04-25 21:45:27 +08:00
|
|
|
* @CIP_EMPTY_HAS_WRONG_DBC: Only for in-stream. The value of dbc in empty
|
|
|
|
|
* packet is wrong but the others are correct.
|
ALSA: firewire-lib: add buffer-over-run protection at receiving more data blocks than expected
In IEC 61883-6, the number of data blocks in a packet is limited up to
the value of SYT_INTERVAL. Current implementation is compliant to the
limitation, while it can cause buffer-over-run when the value of dbs
field in received packet is illegally large.
This commit adds a validator to detect such illegal packets to prevent
the buffer-over-run. Actually, the buffer is aligned to the size of memory
page, thus this issue hardly causes system errors due to the room to page
alignment, as long as a few packets includes such jumbo payload; i.e.
a packet to several received packets.
Here, Behringer F-Control Audio 202 (based on OXFW 960) has a quirk to
postpone transferring isochronous packet till finish handling any
asynchronous packets. In this case, this model is lazy, transfers no
packets according to several cycle-start packets. After finishing, this
model pushes required data in next isochronous packet. As a result, the
packet include more data blocks than IEC 61883-6 defines.
To continue to support this model, this commit adds a new flag to extend
the length of calculated payload. This flag allows the size of payload
5 times as large as IEC 61883-6 defines. As a result, packets from this
model passed the validator successfully.
Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2015-05-22 22:00:50 +08:00
|
|
|
* @CIP_JUMBO_PAYLOAD: Only for in-stream. The number of data blocks in an
|
|
|
|
|
* packet is larger than IEC 61883-6 defines. Current implementation
|
|
|
|
|
* allows 5 times as large as IEC 61883-6 defines.
|
2017-03-22 20:30:27 +08:00
|
|
|
* @CIP_HEADER_WITHOUT_EOH: Only for in-stream. CIP Header doesn't include
|
|
|
|
|
* valid EOH.
|
ALSA: firewire-lib: add no-header packet processing
As long as investigating Fireface 400, IEC 61883-1/6 is not applied to
its packet streaming protocol. Remarks of the specific protocol are:
* Each packet doesn't include CIP headers.
* 64,0 and 128,0 kHz are supported.
* The device doesn't necessarily transmit 8,000 packets per second.
* 0, 1, 2, 3 are used as tag for rx isochronous packets, however 0 is
used for tx isochronous packets.
On the other hand, there's a common feature. The number of data blocks
transferred in a second is the same as sampling transmission frequency.
Current ALSA IEC 61883-1/6 engine already has a method to calculate it and
this driver can utilize it for rx packets, as well as tx packets.
This commit adds support for the transferring protocol. CIP_NO_HEADERS
flag is newly added. When this flag is set:
* Both of 0 (without CIP header) and 1 (with CIP header) are used as tag
to handle incoming isochronous packet.
* 0 (without CIP header) is used as tag to transfer outgoing isochronous
packet.
* Skip CIP header evaluation.
* Use unique way to calculate the quadlets of isochronous packet payload.
In ALSA PCM interface, 128.0 kHz is not supported, and the ALSA
IEC 61883-1/6 engine doesn't support 64.0 kHz. These modes are dropped.
The sequence of rx packet has a remarkable quirk about tag. This will be
described in later commits.
Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2017-03-31 21:06:07 +08:00
|
|
|
* @CIP_NO_HEADERS: a lack of headers in packets
|
2019-07-22 11:36:51 +08:00
|
|
|
* @CIP_UNALIGHED_DBC: Only for in-stream. The value of dbc is not alighed to
|
|
|
|
|
* the value of current SYT_INTERVAL; e.g. initial value is not zero.
|
2021-05-22 09:32:58 +08:00
|
|
|
* @CIP_UNAWARE_SYT: For outgoing packet, the value in SYT field of CIP is 0xffff.
|
|
|
|
|
* For incoming packet, the value in SYT field of CIP is not handled.
|
2011-03-15 14:53:21 +08:00
|
|
|
*/
|
2014-04-25 21:44:42 +08:00
|
|
|
enum cip_flags {
|
2014-04-25 21:44:49 +08:00
|
|
|
CIP_NONBLOCKING = 0x00,
|
|
|
|
|
CIP_BLOCKING = 0x01,
|
ALSA: firewire-lib: handle IT/IR contexts in each software interrupt context
In clause 6.3 of IEC 61883-6:2000, there's an explanation about processing
of presentation timestamp. In the clause, we can see "If a function block
receives a CIP, processes it and subsequently re-transmits it, then the
SYT of the outgoing CIP shall be the sum of the incoming SYT and the
processing delay." ALSA firewire stack has an implementation to partly
satisfy this specification. Developers assumed the stack to perform as an
Audio function block[1].
Following to the assumption, current implementation of ALSA firewire stack
use one software interrupt context to handle both of in/out packets. In
most case, this is processed in 1394 OHCI IR context independently of the
opposite context. Thus, this implementation uses longer CPU time in the
software interrupt context. This is not better for whole system.
Against the assumption, I confirmed that each ASIC for IEC 61883-1/6
doesn't necessarily expect it to the stack. Thus, current implementation
of ALSA firewire stack includes over-engineering.
This commit purges the implementation. As a result, packets of one
direction are handled in one software interrupt context and spends
minimum CPU time.
[1] [alsa-devel] [PATCH 0/8] [RFC] new driver for Echo Audio's Fireworks based devices
http://mailman.alsa-project.org/pipermail/alsa-devel/2013-June/062660.html
Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2016-05-09 22:15:53 +08:00
|
|
|
CIP_EMPTY_WITH_TAG0 = 0x02,
|
|
|
|
|
CIP_DBC_IS_END_EVENT = 0x04,
|
|
|
|
|
CIP_WRONG_DBS = 0x08,
|
|
|
|
|
CIP_SKIP_DBC_ZERO_CHECK = 0x10,
|
2016-05-09 22:15:56 +08:00
|
|
|
CIP_EMPTY_HAS_WRONG_DBC = 0x20,
|
|
|
|
|
CIP_JUMBO_PAYLOAD = 0x40,
|
2017-03-22 20:30:27 +08:00
|
|
|
CIP_HEADER_WITHOUT_EOH = 0x80,
|
ALSA: firewire-lib: add no-header packet processing
As long as investigating Fireface 400, IEC 61883-1/6 is not applied to
its packet streaming protocol. Remarks of the specific protocol are:
* Each packet doesn't include CIP headers.
* 64,0 and 128,0 kHz are supported.
* The device doesn't necessarily transmit 8,000 packets per second.
* 0, 1, 2, 3 are used as tag for rx isochronous packets, however 0 is
used for tx isochronous packets.
On the other hand, there's a common feature. The number of data blocks
transferred in a second is the same as sampling transmission frequency.
Current ALSA IEC 61883-1/6 engine already has a method to calculate it and
this driver can utilize it for rx packets, as well as tx packets.
This commit adds support for the transferring protocol. CIP_NO_HEADERS
flag is newly added. When this flag is set:
* Both of 0 (without CIP header) and 1 (with CIP header) are used as tag
to handle incoming isochronous packet.
* 0 (without CIP header) is used as tag to transfer outgoing isochronous
packet.
* Skip CIP header evaluation.
* Use unique way to calculate the quadlets of isochronous packet payload.
In ALSA PCM interface, 128.0 kHz is not supported, and the ALSA
IEC 61883-1/6 engine doesn't support 64.0 kHz. These modes are dropped.
The sequence of rx packet has a remarkable quirk about tag. This will be
described in later commits.
Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2017-03-31 21:06:07 +08:00
|
|
|
CIP_NO_HEADER = 0x100,
|
2019-07-22 11:36:51 +08:00
|
|
|
CIP_UNALIGHED_DBC = 0x200,
|
2021-05-22 09:32:58 +08:00
|
|
|
CIP_UNAWARE_SYT = 0x400,
|
2011-03-15 14:53:21 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
2014-11-18 22:59:40 +08:00
|
|
|
* enum cip_sfc - supported Sampling Frequency Codes (SFCs)
|
|
|
|
|
* @CIP_SFC_32000: 32,000 data blocks
|
|
|
|
|
* @CIP_SFC_44100: 44,100 data blocks
|
|
|
|
|
* @CIP_SFC_48000: 48,000 data blocks
|
|
|
|
|
* @CIP_SFC_88200: 88,200 data blocks
|
|
|
|
|
* @CIP_SFC_96000: 96,000 data blocks
|
|
|
|
|
* @CIP_SFC_176400: 176,400 data blocks
|
|
|
|
|
* @CIP_SFC_192000: 192,000 data blocks
|
|
|
|
|
* @CIP_SFC_COUNT: the number of supported SFCs
|
|
|
|
|
*
|
|
|
|
|
* These values are used to show nominal Sampling Frequency Code in
|
|
|
|
|
* Format Dependent Field (FDF) of AMDTP packet header. In IEC 61883-6:2002,
|
|
|
|
|
* this code means the number of events per second. Actually the code
|
|
|
|
|
* represents the number of data blocks transferred per second in an AMDTP
|
|
|
|
|
* stream.
|
|
|
|
|
*
|
|
|
|
|
* In IEC 61883-6:2005, some extensions were added to support more types of
|
|
|
|
|
* data such as 'One Bit LInear Audio', therefore the meaning of SFC became
|
|
|
|
|
* different depending on the types.
|
|
|
|
|
*
|
|
|
|
|
* Currently our implementation is compatible with IEC 61883-6:2002.
|
2011-03-15 14:53:21 +08:00
|
|
|
*/
|
|
|
|
|
enum cip_sfc {
|
|
|
|
|
CIP_SFC_32000 = 0,
|
|
|
|
|
CIP_SFC_44100 = 1,
|
|
|
|
|
CIP_SFC_48000 = 2,
|
|
|
|
|
CIP_SFC_88200 = 3,
|
|
|
|
|
CIP_SFC_96000 = 4,
|
|
|
|
|
CIP_SFC_176400 = 5,
|
|
|
|
|
CIP_SFC_192000 = 6,
|
2011-09-05 04:16:10 +08:00
|
|
|
CIP_SFC_COUNT
|
2011-03-15 14:53:21 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct fw_unit;
|
|
|
|
|
struct fw_iso_context;
|
|
|
|
|
struct snd_pcm_substream;
|
2014-04-25 21:44:52 +08:00
|
|
|
struct snd_pcm_runtime;
|
2011-03-15 14:53:21 +08:00
|
|
|
|
2014-04-25 21:44:44 +08:00
|
|
|
enum amdtp_stream_direction {
|
|
|
|
|
AMDTP_OUT_STREAM = 0,
|
|
|
|
|
AMDTP_IN_STREAM
|
|
|
|
|
};
|
|
|
|
|
|
2019-07-22 11:36:58 +08:00
|
|
|
struct pkt_desc {
|
|
|
|
|
u32 cycle;
|
|
|
|
|
u32 syt;
|
|
|
|
|
unsigned int data_blocks;
|
|
|
|
|
unsigned int data_block_counter;
|
|
|
|
|
__be32 *ctx_payload;
|
2023-01-09 10:17:36 +08:00
|
|
|
struct list_head link;
|
2019-07-22 11:36:58 +08:00
|
|
|
};
|
|
|
|
|
|
2015-09-19 10:22:02 +08:00
|
|
|
struct amdtp_stream;
|
2023-01-10 21:49:32 +08:00
|
|
|
typedef void (*amdtp_stream_process_ctx_payloads_t)(struct amdtp_stream *s,
|
|
|
|
|
const struct pkt_desc *desc,
|
|
|
|
|
unsigned int count,
|
|
|
|
|
struct snd_pcm_substream *pcm);
|
2020-05-08 12:36:28 +08:00
|
|
|
|
|
|
|
|
struct amdtp_domain;
|
2014-04-25 21:44:42 +08:00
|
|
|
struct amdtp_stream {
|
2011-03-15 14:53:21 +08:00
|
|
|
struct fw_unit *unit;
|
2021-05-18 16:45:48 +08:00
|
|
|
// The combination of cip_flags enumeration-constants.
|
|
|
|
|
unsigned int flags;
|
2014-04-25 21:44:44 +08:00
|
|
|
enum amdtp_stream_direction direction;
|
2011-03-15 14:53:21 +08:00
|
|
|
struct mutex mutex;
|
|
|
|
|
|
2015-09-19 10:21:48 +08:00
|
|
|
/* For packet processing. */
|
|
|
|
|
struct fw_iso_context *context;
|
2011-03-15 14:53:21 +08:00
|
|
|
struct iso_packets_buffer buffer;
|
2019-10-17 23:54:13 +08:00
|
|
|
unsigned int queue_size;
|
2011-03-15 14:57:24 +08:00
|
|
|
int packet_index;
|
2023-01-09 10:17:38 +08:00
|
|
|
struct pkt_desc *packet_descs;
|
2023-01-09 10:17:36 +08:00
|
|
|
struct list_head packet_descs_list;
|
2023-01-09 10:17:38 +08:00
|
|
|
struct pkt_desc *packet_descs_cursor;
|
ALSA: firewire-lib: add no-header packet processing
As long as investigating Fireface 400, IEC 61883-1/6 is not applied to
its packet streaming protocol. Remarks of the specific protocol are:
* Each packet doesn't include CIP headers.
* 64,0 and 128,0 kHz are supported.
* The device doesn't necessarily transmit 8,000 packets per second.
* 0, 1, 2, 3 are used as tag for rx isochronous packets, however 0 is
used for tx isochronous packets.
On the other hand, there's a common feature. The number of data blocks
transferred in a second is the same as sampling transmission frequency.
Current ALSA IEC 61883-1/6 engine already has a method to calculate it and
this driver can utilize it for rx packets, as well as tx packets.
This commit adds support for the transferring protocol. CIP_NO_HEADERS
flag is newly added. When this flag is set:
* Both of 0 (without CIP header) and 1 (with CIP header) are used as tag
to handle incoming isochronous packet.
* 0 (without CIP header) is used as tag to transfer outgoing isochronous
packet.
* Skip CIP header evaluation.
* Use unique way to calculate the quadlets of isochronous packet payload.
In ALSA PCM interface, 128.0 kHz is not supported, and the ALSA
IEC 61883-1/6 engine doesn't support 64.0 kHz. These modes are dropped.
The sequence of rx packet has a remarkable quirk about tag. This will be
described in later commits.
Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2017-03-31 21:06:07 +08:00
|
|
|
int tag;
|
2019-05-21 22:57:34 +08:00
|
|
|
union {
|
|
|
|
|
struct {
|
|
|
|
|
unsigned int ctx_header_size;
|
|
|
|
|
|
|
|
|
|
// limit for payload of iso packet.
|
2019-05-22 22:17:07 +08:00
|
|
|
unsigned int max_ctx_payload_length;
|
2019-05-21 22:57:34 +08:00
|
|
|
|
|
|
|
|
// For quirks of CIP headers.
|
|
|
|
|
// Fixed interval of dbc between previos/current
|
|
|
|
|
// packets.
|
|
|
|
|
unsigned int dbc_interval;
|
2021-05-24 11:13:43 +08:00
|
|
|
|
|
|
|
|
// The device starts multiplexing events to the packet.
|
|
|
|
|
bool event_starts;
|
2021-05-27 20:26:09 +08:00
|
|
|
|
|
|
|
|
struct {
|
|
|
|
|
struct seq_desc *descs;
|
|
|
|
|
unsigned int size;
|
2023-01-07 10:32:13 +08:00
|
|
|
unsigned int pos;
|
2021-05-27 20:26:09 +08:00
|
|
|
} cache;
|
2019-05-21 22:57:34 +08:00
|
|
|
} tx;
|
|
|
|
|
struct {
|
|
|
|
|
// To generate CIP header.
|
|
|
|
|
unsigned int fdf;
|
2019-10-18 14:19:10 +08:00
|
|
|
|
|
|
|
|
// To generate constant hardware IRQ.
|
|
|
|
|
unsigned int event_count;
|
2021-05-22 09:32:59 +08:00
|
|
|
|
2021-05-22 09:33:03 +08:00
|
|
|
// To calculate CIP data blocks and tstamp.
|
2021-05-22 09:32:59 +08:00
|
|
|
struct {
|
|
|
|
|
struct seq_desc *descs;
|
|
|
|
|
unsigned int size;
|
2023-01-07 10:32:11 +08:00
|
|
|
unsigned int pos;
|
2021-05-22 09:32:59 +08:00
|
|
|
} seq;
|
|
|
|
|
|
|
|
|
|
unsigned int data_block_state;
|
|
|
|
|
unsigned int syt_offset_state;
|
|
|
|
|
unsigned int last_syt_offset;
|
ALSA: firewire-lib: replay sequence of incoming packets for outgoing packets
ALSA IEC 61883-1/6 packet streaming engine uses pre-computed parameters
ideal for nominal sampling transfer frequency (STF) to transfer packets
to device since it was added 2011. As a result of user experience for a
decade, it is clear that the sequence is not suitable to some actual
devices. It takes the devices to generate noise, and causes any type of
discontinuity in the series of packet transferred from the device. It's
required for the engine to transfer packets according to effective STF.
The effective STF is given by media clock recovered by the sequence of
packet transferred from the target device. In the previous commit, the
sequence is already cached. The media clock recovery can be achieved by
analyzing the sequence.
In technological world, many ideas are proposed for media clock recovery.
However, the small part of them could be actually adopted in our case
since floating point arithmetic is not mostly available in Linux kernel
land.
This commit adopts the simple way from them; sequence replay, which means
that the sequence of parameters from incoming packet is used as is to
transfer outgoing packets. The media clock is not computed internally,
but the sequence of outgoing packet superficially looks to be generated by
the media clock.
The association between source and destination is decided when starting
AMDTP domain. When the target device supports a pair of isochronous packet
streams, the tx stream is source and the rx stream is destination. When it
supports two pair of streams, each of tx stream is associated to
corresponding rx stream in its order. When it supports less number of tx
streams than rx streams, the fist tx stream is selected for all of rx
streams. When it supports more tx streams than rx streams, the first tx
packet is associated to the rx stream.
As I noted in previous commit, the sequence of parameters from incoming
packet is different between devices, time to time. It is worse idea to
replay the sequence of parameters from a device for the sequence of
packet to the other devices even if they are in the same category of
device.
Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Link: https://lore.kernel.org/r/20210527122611.173711-3-o-takashi@sakamocchi.jp
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2021-05-27 20:26:10 +08:00
|
|
|
|
|
|
|
|
struct amdtp_stream *replay_target;
|
2023-01-07 10:32:14 +08:00
|
|
|
unsigned int cache_pos;
|
2019-05-21 22:57:34 +08:00
|
|
|
} rx;
|
|
|
|
|
} ctx_data;
|
2015-09-19 10:21:48 +08:00
|
|
|
|
|
|
|
|
/* For CIP headers. */
|
|
|
|
|
unsigned int source_node_id_field;
|
|
|
|
|
unsigned int data_block_quadlets;
|
2011-03-15 14:53:21 +08:00
|
|
|
unsigned int data_block_counter;
|
2017-03-22 20:30:16 +08:00
|
|
|
unsigned int sph;
|
2015-09-19 10:21:53 +08:00
|
|
|
unsigned int fmt;
|
2011-03-15 14:53:21 +08:00
|
|
|
|
2021-05-22 09:33:03 +08:00
|
|
|
// Internal flags.
|
|
|
|
|
unsigned int transfer_delay;
|
2015-09-19 10:21:48 +08:00
|
|
|
enum cip_sfc sfc;
|
|
|
|
|
unsigned int syt_interval;
|
2011-03-15 14:53:21 +08:00
|
|
|
|
2015-09-19 10:21:48 +08:00
|
|
|
/* For a PCM substream processing. */
|
|
|
|
|
struct snd_pcm_substream *pcm;
|
ALSA: firewire-lib: Fix stall of process context at packet error
At Linux v3.5, packet processing can be done in process context of ALSA
PCM application as well as software IRQ context for OHCI 1394. Below is
an example of the callgraph (some calls are omitted).
ioctl(2) with e.g. HWSYNC
(sound/core/pcm_native.c)
->snd_pcm_common_ioctl1()
->snd_pcm_hwsync()
->snd_pcm_stream_lock_irq
(sound/core/pcm_lib.c)
->snd_pcm_update_hw_ptr()
->snd_pcm_udpate_hw_ptr0()
->struct snd_pcm_ops.pointer()
(sound/firewire/*)
= Each handler on drivers in ALSA firewire stack
(sound/firewire/amdtp-stream.c)
->amdtp_stream_pcm_pointer()
(drivers/firewire/core-iso.c)
->fw_iso_context_flush_completions()
->struct fw_card_driver.flush_iso_completion()
(drivers/firewire/ohci.c)
= flush_iso_completions()
->struct fw_iso_context.callback.sc
(sound/firewire/amdtp-stream.c)
= in_stream_callback() or out_stream_callback()
->...
->snd_pcm_stream_unlock_irq
When packet queueing error occurs or detecting invalid packets in
'in_stream_callback()' or 'out_stream_callback()', 'snd_pcm_stop_xrun()'
is called on local CPU with disabled IRQ.
(sound/firewire/amdtp-stream.c)
in_stream_callback() or out_stream_callback()
->amdtp_stream_pcm_abort()
->snd_pcm_stop_xrun()
->snd_pcm_stream_lock_irqsave()
->snd_pcm_stop()
->snd_pcm_stream_unlock_irqrestore()
The process is stalled on the CPU due to attempt to acquire recursive lock.
[ 562.630853] INFO: rcu_sched detected stalls on CPUs/tasks:
[ 562.630861] 2-...: (1 GPs behind) idle=37d/140000000000000/0 softirq=38323/38323 fqs=7140
[ 562.630862] (detected by 3, t=15002 jiffies, g=21036, c=21035, q=5933)
[ 562.630866] Task dump for CPU 2:
[ 562.630867] alsa-source-OXF R running task 0 6619 1 0x00000008
[ 562.630870] Call Trace:
[ 562.630876] ? vt_console_print+0x79/0x3e0
[ 562.630880] ? msg_print_text+0x9d/0x100
[ 562.630883] ? up+0x32/0x50
[ 562.630885] ? irq_work_queue+0x8d/0xa0
[ 562.630886] ? console_unlock+0x2b6/0x4b0
[ 562.630888] ? vprintk_emit+0x312/0x4a0
[ 562.630892] ? dev_vprintk_emit+0xbf/0x230
[ 562.630895] ? do_sys_poll+0x37a/0x550
[ 562.630897] ? dev_printk_emit+0x4e/0x70
[ 562.630900] ? __dev_printk+0x3c/0x80
[ 562.630903] ? _raw_spin_lock+0x20/0x30
[ 562.630909] ? snd_pcm_stream_lock+0x31/0x50 [snd_pcm]
[ 562.630914] ? _snd_pcm_stream_lock_irqsave+0x2e/0x40 [snd_pcm]
[ 562.630918] ? snd_pcm_stop_xrun+0x16/0x70 [snd_pcm]
[ 562.630922] ? in_stream_callback+0x3e6/0x450 [snd_firewire_lib]
[ 562.630925] ? handle_ir_packet_per_buffer+0x8e/0x1a0 [firewire_ohci]
[ 562.630928] ? ohci_flush_iso_completions+0xa3/0x130 [firewire_ohci]
[ 562.630932] ? fw_iso_context_flush_completions+0x15/0x20 [firewire_core]
[ 562.630935] ? amdtp_stream_pcm_pointer+0x2d/0x40 [snd_firewire_lib]
[ 562.630938] ? pcm_capture_pointer+0x19/0x20 [snd_oxfw]
[ 562.630943] ? snd_pcm_update_hw_ptr0+0x47/0x3d0 [snd_pcm]
[ 562.630945] ? poll_select_copy_remaining+0x150/0x150
[ 562.630947] ? poll_select_copy_remaining+0x150/0x150
[ 562.630952] ? snd_pcm_update_hw_ptr+0x10/0x20 [snd_pcm]
[ 562.630956] ? snd_pcm_hwsync+0x45/0xb0 [snd_pcm]
[ 562.630960] ? snd_pcm_common_ioctl1+0x1ff/0xc90 [snd_pcm]
[ 562.630962] ? futex_wake+0x90/0x170
[ 562.630966] ? snd_pcm_capture_ioctl1+0x136/0x260 [snd_pcm]
[ 562.630970] ? snd_pcm_capture_ioctl+0x27/0x40 [snd_pcm]
[ 562.630972] ? do_vfs_ioctl+0xa3/0x610
[ 562.630974] ? vfs_read+0x11b/0x130
[ 562.630976] ? SyS_ioctl+0x79/0x90
[ 562.630978] ? entry_SYSCALL_64_fastpath+0x1e/0xad
This commit fixes the above bug. This assumes two cases:
1. Any error is detected in software IRQ context of OHCI 1394 context.
In this case, PCM substream should be aborted in packet handler. On the
other hand, it should not be done in any process context. TO distinguish
these two context, use 'in_interrupt()' macro.
2. Any error is detect in process context of ALSA PCM application.
In this case, PCM substream should not be aborted in packet handler
because PCM substream lock is acquired. The task to abort PCM substream
should be done in ALSA PCM core. For this purpose, SNDRV_PCM_POS_XRUN is
returned at 'struct snd_pcm_ops.pointer()'.
Suggested-by: Clemens Ladisch <clemens@ladisch.de>
Fixes: e9148dddc3c7("ALSA: firewire-lib: flush completed packets when reading PCM position")
Cc: <stable@vger.kernel.org> # 4.9+
Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2017-06-11 15:08:21 +08:00
|
|
|
snd_pcm_uframes_t pcm_buffer_pointer;
|
2011-03-15 14:53:21 +08:00
|
|
|
unsigned int pcm_period_pointer;
|
2023-01-10 21:49:31 +08:00
|
|
|
unsigned int pcm_frame_multiplier;
|
ALSA: firewire-lib: Add support for MIDI capture/playback
For capturing/playbacking MIDI messages, this commit adds one MIDI conformant
data channel. This data channel has multiplexed 8 MIDI data streams. So this
data channel can transfer messages from/to 8 MIDI ports.
And this commit allows to set PCM format even if AMDTP streams already start.
I suppose the case that PCM substreams are going to be joined into AMDTP
streams when AMDTP streams are already started for MIDI substreams. Each
driver must count how many PCM/MIDI substreams use AMDTP streams to stop
AMDTP streams.
There are differences between specifications about MIDI conformant data.
About the multiplexing, IEC 61883-6:2002, itself, has no information. It
describes labels and bytes for MIDI messages and refers to MMA/AMEI RP-027
for 'successfull implementation'. MMA/AMEI RP-027 describes 8 MPX-MIDI data
streams for one MIDI conformant data channel. IEC 61883-6:2005 adds
'sequence multiplexing' and apply this way and describe incompatibility
between 2002 and 2005.
So this commit applies IEC 61883-6:2005. When we find some devices compliant
to IEC 61883-6:2002, then this difference should be handles as device quirk
in additional work.
About the number of bytes in an MIDI conformant data, IEC 61883-6:2002 describe
0,1,2,3 bytes. MMA/AMEI RP-027 describes 'MIDI1.0-1x-SPEED', 'MIDI1.0-2x-SPEED',
'MIDI1.0-3x-SPEED' modes and the maximum bytes for each mode corresponds to 1,
2, 3 bytes. The 'MIDI1.0-2x/3x-SPEED' modes are accompanied with 'negotiation
procedure' and 'encapsulation details' but there is no specifications for them.
So this commit implements 'MIDI1.0-1x-SPEED' mode for playback, but allows
to pick up 1-3 bytes for capturing.
Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2014-04-25 21:44:47 +08:00
|
|
|
|
2021-05-20 12:01:54 +08:00
|
|
|
// To start processing content of packets at the same cycle in several contexts for
|
|
|
|
|
// each direction.
|
2021-05-24 11:13:44 +08:00
|
|
|
bool ready_processing;
|
2021-05-20 12:01:54 +08:00
|
|
|
wait_queue_head_t ready_wait;
|
2021-05-18 21:00:46 +08:00
|
|
|
unsigned int next_cycle;
|
2015-09-19 10:21:48 +08:00
|
|
|
|
2015-09-19 10:22:02 +08:00
|
|
|
/* For backends to process data blocks. */
|
|
|
|
|
void *protocol;
|
2019-07-22 11:37:09 +08:00
|
|
|
amdtp_stream_process_ctx_payloads_t process_ctx_payloads;
|
2019-08-04 14:21:21 +08:00
|
|
|
|
|
|
|
|
// For domain.
|
2019-08-04 14:21:22 +08:00
|
|
|
int channel;
|
|
|
|
|
int speed;
|
2019-08-04 14:21:21 +08:00
|
|
|
struct list_head list;
|
2020-05-08 12:36:28 +08:00
|
|
|
struct amdtp_domain *domain;
|
2011-03-15 14:53:21 +08:00
|
|
|
};
|
|
|
|
|
|
2014-04-25 21:44:42 +08:00
|
|
|
int amdtp_stream_init(struct amdtp_stream *s, struct fw_unit *unit,
|
2021-05-18 16:45:48 +08:00
|
|
|
enum amdtp_stream_direction dir, unsigned int flags,
|
2015-09-19 10:22:02 +08:00
|
|
|
unsigned int fmt,
|
2019-07-22 11:37:09 +08:00
|
|
|
amdtp_stream_process_ctx_payloads_t process_ctx_payloads,
|
2015-09-19 10:22:02 +08:00
|
|
|
unsigned int protocol_size);
|
2014-04-25 21:44:42 +08:00
|
|
|
void amdtp_stream_destroy(struct amdtp_stream *s);
|
2011-03-15 14:53:21 +08:00
|
|
|
|
2015-09-19 10:22:02 +08:00
|
|
|
int amdtp_stream_set_parameters(struct amdtp_stream *s, unsigned int rate,
|
2023-01-10 21:49:31 +08:00
|
|
|
unsigned int data_block_quadlets, unsigned int pcm_frame_multiplier);
|
2014-04-25 21:44:42 +08:00
|
|
|
unsigned int amdtp_stream_get_max_payload(struct amdtp_stream *s);
|
2011-03-15 14:53:21 +08:00
|
|
|
|
2014-04-25 21:44:42 +08:00
|
|
|
void amdtp_stream_update(struct amdtp_stream *s);
|
2011-03-15 14:53:21 +08:00
|
|
|
|
2014-04-25 21:44:52 +08:00
|
|
|
int amdtp_stream_add_pcm_hw_constraints(struct amdtp_stream *s,
|
|
|
|
|
struct snd_pcm_runtime *runtime);
|
2015-09-19 10:22:02 +08:00
|
|
|
|
2014-04-25 21:44:42 +08:00
|
|
|
void amdtp_stream_pcm_prepare(struct amdtp_stream *s);
|
|
|
|
|
void amdtp_stream_pcm_abort(struct amdtp_stream *s);
|
2011-03-15 14:53:21 +08:00
|
|
|
|
2011-10-17 03:39:00 +08:00
|
|
|
extern const unsigned int amdtp_syt_intervals[CIP_SFC_COUNT];
|
2014-04-25 21:44:59 +08:00
|
|
|
extern const unsigned int amdtp_rate_table[CIP_SFC_COUNT];
|
2011-09-05 04:16:10 +08:00
|
|
|
|
2014-04-25 21:44:42 +08:00
|
|
|
/**
|
|
|
|
|
* amdtp_stream_running - check stream is running or not
|
|
|
|
|
* @s: the AMDTP stream
|
|
|
|
|
*
|
|
|
|
|
* If this function returns true, the stream is running.
|
|
|
|
|
*/
|
|
|
|
|
static inline bool amdtp_stream_running(struct amdtp_stream *s)
|
2011-09-05 04:15:44 +08:00
|
|
|
{
|
|
|
|
|
return !IS_ERR(s->context);
|
|
|
|
|
}
|
|
|
|
|
|
2011-03-15 14:57:24 +08:00
|
|
|
/**
|
2014-04-25 21:44:42 +08:00
|
|
|
* amdtp_streaming_error - check for streaming error
|
|
|
|
|
* @s: the AMDTP stream
|
2011-03-15 14:57:24 +08:00
|
|
|
*
|
|
|
|
|
* If this function returns true, the stream's packet queue has stopped due to
|
|
|
|
|
* an asynchronous error.
|
|
|
|
|
*/
|
2014-04-25 21:44:42 +08:00
|
|
|
static inline bool amdtp_streaming_error(struct amdtp_stream *s)
|
2011-03-15 14:57:24 +08:00
|
|
|
{
|
|
|
|
|
return s->packet_index < 0;
|
|
|
|
|
}
|
|
|
|
|
|
ALSA: firewire-lib: Add support for MIDI capture/playback
For capturing/playbacking MIDI messages, this commit adds one MIDI conformant
data channel. This data channel has multiplexed 8 MIDI data streams. So this
data channel can transfer messages from/to 8 MIDI ports.
And this commit allows to set PCM format even if AMDTP streams already start.
I suppose the case that PCM substreams are going to be joined into AMDTP
streams when AMDTP streams are already started for MIDI substreams. Each
driver must count how many PCM/MIDI substreams use AMDTP streams to stop
AMDTP streams.
There are differences between specifications about MIDI conformant data.
About the multiplexing, IEC 61883-6:2002, itself, has no information. It
describes labels and bytes for MIDI messages and refers to MMA/AMEI RP-027
for 'successfull implementation'. MMA/AMEI RP-027 describes 8 MPX-MIDI data
streams for one MIDI conformant data channel. IEC 61883-6:2005 adds
'sequence multiplexing' and apply this way and describe incompatibility
between 2002 and 2005.
So this commit applies IEC 61883-6:2005. When we find some devices compliant
to IEC 61883-6:2002, then this difference should be handles as device quirk
in additional work.
About the number of bytes in an MIDI conformant data, IEC 61883-6:2002 describe
0,1,2,3 bytes. MMA/AMEI RP-027 describes 'MIDI1.0-1x-SPEED', 'MIDI1.0-2x-SPEED',
'MIDI1.0-3x-SPEED' modes and the maximum bytes for each mode corresponds to 1,
2, 3 bytes. The 'MIDI1.0-2x/3x-SPEED' modes are accompanied with 'negotiation
procedure' and 'encapsulation details' but there is no specifications for them.
So this commit implements 'MIDI1.0-1x-SPEED' mode for playback, but allows
to pick up 1-3 bytes for capturing.
Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2014-04-25 21:44:47 +08:00
|
|
|
/**
|
|
|
|
|
* amdtp_stream_pcm_running - check PCM substream is running or not
|
|
|
|
|
* @s: the AMDTP stream
|
|
|
|
|
*
|
|
|
|
|
* If this function returns true, PCM substream in the AMDTP stream is running.
|
|
|
|
|
*/
|
|
|
|
|
static inline bool amdtp_stream_pcm_running(struct amdtp_stream *s)
|
|
|
|
|
{
|
|
|
|
|
return !!s->pcm;
|
|
|
|
|
}
|
|
|
|
|
|
2011-03-15 14:53:21 +08:00
|
|
|
/**
|
2014-04-25 21:44:42 +08:00
|
|
|
* amdtp_stream_pcm_trigger - start/stop playback from a PCM device
|
|
|
|
|
* @s: the AMDTP stream
|
2011-03-15 14:53:21 +08:00
|
|
|
* @pcm: the PCM device to be started, or %NULL to stop the current device
|
|
|
|
|
*
|
|
|
|
|
* Call this function on a running isochronous stream to enable the actual
|
|
|
|
|
* transmission of PCM data. This function should be called from the PCM
|
|
|
|
|
* device's .trigger callback.
|
|
|
|
|
*/
|
2014-04-25 21:44:42 +08:00
|
|
|
static inline void amdtp_stream_pcm_trigger(struct amdtp_stream *s,
|
|
|
|
|
struct snd_pcm_substream *pcm)
|
2011-03-15 14:53:21 +08:00
|
|
|
{
|
locking/atomics: COCCINELLE/treewide: Convert trivial ACCESS_ONCE() patterns to READ_ONCE()/WRITE_ONCE()
Please do not apply this to mainline directly, instead please re-run the
coccinelle script shown below and apply its output.
For several reasons, it is desirable to use {READ,WRITE}_ONCE() in
preference to ACCESS_ONCE(), and new code is expected to use one of the
former. So far, there's been no reason to change most existing uses of
ACCESS_ONCE(), as these aren't harmful, and changing them results in
churn.
However, for some features, the read/write distinction is critical to
correct operation. To distinguish these cases, separate read/write
accessors must be used. This patch migrates (most) remaining
ACCESS_ONCE() instances to {READ,WRITE}_ONCE(), using the following
coccinelle script:
----
// Convert trivial ACCESS_ONCE() uses to equivalent READ_ONCE() and
// WRITE_ONCE()
// $ make coccicheck COCCI=/home/mark/once.cocci SPFLAGS="--include-headers" MODE=patch
virtual patch
@ depends on patch @
expression E1, E2;
@@
- ACCESS_ONCE(E1) = E2
+ WRITE_ONCE(E1, E2)
@ depends on patch @
expression E;
@@
- ACCESS_ONCE(E)
+ READ_ONCE(E)
----
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: davem@davemloft.net
Cc: linux-arch@vger.kernel.org
Cc: mpe@ellerman.id.au
Cc: shuah@kernel.org
Cc: snitzer@redhat.com
Cc: thor.thayer@linux.intel.com
Cc: tj@kernel.org
Cc: viro@zeniv.linux.org.uk
Cc: will.deacon@arm.com
Link: http://lkml.kernel.org/r/1508792849-3115-19-git-send-email-paulmck@linux.vnet.ibm.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-10-24 05:07:29 +08:00
|
|
|
WRITE_ONCE(s->pcm, pcm);
|
2011-03-15 14:53:21 +08:00
|
|
|
}
|
|
|
|
|
|
2023-01-09 10:17:36 +08:00
|
|
|
/**
|
|
|
|
|
* amdtp_stream_next_packet_desc - retrieve next descriptor for amdtp packet.
|
|
|
|
|
* @s: the AMDTP stream
|
|
|
|
|
* @desc: the descriptor of packet
|
|
|
|
|
*
|
|
|
|
|
* This macro computes next descriptor so that the list of descriptors behaves circular queue.
|
|
|
|
|
*/
|
|
|
|
|
#define amdtp_stream_next_packet_desc(s, desc) \
|
|
|
|
|
list_next_entry_circular(desc, &s->packet_descs_list, link)
|
|
|
|
|
|
2011-03-15 14:53:21 +08:00
|
|
|
static inline bool cip_sfc_is_base_44100(enum cip_sfc sfc)
|
|
|
|
|
{
|
|
|
|
|
return sfc & 1;
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-08 12:36:33 +08:00
|
|
|
struct seq_desc {
|
|
|
|
|
unsigned int syt_offset;
|
|
|
|
|
unsigned int data_blocks;
|
|
|
|
|
};
|
|
|
|
|
|
2019-08-04 14:21:20 +08:00
|
|
|
struct amdtp_domain {
|
|
|
|
|
struct list_head streams;
|
2019-10-07 19:05:16 +08:00
|
|
|
|
|
|
|
|
unsigned int events_per_period;
|
2019-10-17 23:54:13 +08:00
|
|
|
unsigned int events_per_buffer;
|
2019-10-18 14:19:06 +08:00
|
|
|
|
|
|
|
|
struct amdtp_stream *irq_target;
|
2020-05-08 12:36:33 +08:00
|
|
|
|
2021-05-20 12:01:50 +08:00
|
|
|
struct {
|
2021-05-20 12:01:51 +08:00
|
|
|
unsigned int tx_init_skip;
|
2021-05-20 12:01:50 +08:00
|
|
|
unsigned int tx_start;
|
2021-05-20 12:01:53 +08:00
|
|
|
unsigned int rx_start;
|
2021-05-20 12:01:50 +08:00
|
|
|
} processing_cycle;
|
2021-05-27 20:26:09 +08:00
|
|
|
|
|
|
|
|
struct {
|
2021-05-27 20:26:11 +08:00
|
|
|
bool enable:1;
|
|
|
|
|
bool on_the_fly:1;
|
2021-05-27 20:26:09 +08:00
|
|
|
} replay;
|
2019-08-04 14:21:20 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
int amdtp_domain_init(struct amdtp_domain *d);
|
|
|
|
|
void amdtp_domain_destroy(struct amdtp_domain *d);
|
|
|
|
|
|
2019-08-04 14:21:22 +08:00
|
|
|
int amdtp_domain_add_stream(struct amdtp_domain *d, struct amdtp_stream *s,
|
|
|
|
|
int channel, int speed);
|
|
|
|
|
|
2021-05-27 20:26:11 +08:00
|
|
|
int amdtp_domain_start(struct amdtp_domain *d, unsigned int tx_init_skip_cycles, bool replay_seq,
|
|
|
|
|
bool replay_on_the_fly);
|
2019-08-04 14:21:21 +08:00
|
|
|
void amdtp_domain_stop(struct amdtp_domain *d);
|
|
|
|
|
|
2019-10-07 19:05:16 +08:00
|
|
|
static inline int amdtp_domain_set_events_per_period(struct amdtp_domain *d,
|
2019-10-17 23:54:13 +08:00
|
|
|
unsigned int events_per_period,
|
|
|
|
|
unsigned int events_per_buffer)
|
2019-10-07 19:05:16 +08:00
|
|
|
{
|
|
|
|
|
d->events_per_period = events_per_period;
|
2019-10-17 23:54:13 +08:00
|
|
|
d->events_per_buffer = events_per_buffer;
|
2019-10-07 19:05:16 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-18 14:19:07 +08:00
|
|
|
unsigned long amdtp_domain_stream_pcm_pointer(struct amdtp_domain *d,
|
|
|
|
|
struct amdtp_stream *s);
|
2019-10-18 14:19:08 +08:00
|
|
|
int amdtp_domain_stream_pcm_ack(struct amdtp_domain *d, struct amdtp_stream *s);
|
|
|
|
|
|
2021-05-20 12:01:54 +08:00
|
|
|
/**
|
|
|
|
|
* amdtp_domain_wait_ready - sleep till being ready to process packets or timeout
|
|
|
|
|
* @d: the AMDTP domain
|
|
|
|
|
* @timeout_ms: msec till timeout
|
|
|
|
|
*
|
|
|
|
|
* If this function return false, the AMDTP domain should be stopped.
|
|
|
|
|
*/
|
|
|
|
|
static inline bool amdtp_domain_wait_ready(struct amdtp_domain *d, unsigned int timeout_ms)
|
|
|
|
|
{
|
|
|
|
|
struct amdtp_stream *s;
|
|
|
|
|
|
|
|
|
|
list_for_each_entry(s, &d->streams, list) {
|
|
|
|
|
unsigned int j = msecs_to_jiffies(timeout_ms);
|
|
|
|
|
|
|
|
|
|
if (wait_event_interruptible_timeout(s->ready_wait, s->ready_processing, j) <= 0)
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2011-03-15 14:53:21 +08:00
|
|
|
#endif
|
