1 // SPDX-License-Identifier: GPL-2.0-only 1 // SPDX-License-Identifier: GPL-2.0-only
2 // 2 //
3 // motu-command-dsp-message-parser.c - a part 3 // motu-command-dsp-message-parser.c - a part of driver for MOTU FireWire series
4 // 4 //
5 // Copyright (c) 2021 Takashi Sakamoto <o-taka 5 // Copyright (c) 2021 Takashi Sakamoto <o-takashi@sakamocchi.jp>
6 6
7 // Below models allow software to configure th 7 // Below models allow software to configure their DSP function by command transferred in
8 // asynchronous transaction: 8 // asynchronous transaction:
9 // * 828 mk3 (FireWire only and Hybrid) 9 // * 828 mk3 (FireWire only and Hybrid)
10 // * 896 mk3 (FireWire only and Hybrid) 10 // * 896 mk3 (FireWire only and Hybrid)
11 // * Ultralite mk3 (FireWire only and Hybrid) 11 // * Ultralite mk3 (FireWire only and Hybrid)
12 // * Traveler mk3 12 // * Traveler mk3
13 // * Track 16 13 // * Track 16
14 // 14 //
15 // Isochronous packets from the above models i 15 // Isochronous packets from the above models includes messages to report state of hardware meter.
16 16
17 #include "motu.h" 17 #include "motu.h"
18 18
19 enum msg_parser_state { 19 enum msg_parser_state {
20 INITIALIZED, 20 INITIALIZED,
21 FRAGMENT_DETECTED, 21 FRAGMENT_DETECTED,
22 AVAILABLE, 22 AVAILABLE,
23 }; 23 };
24 24
25 struct msg_parser { 25 struct msg_parser {
26 spinlock_t lock; 26 spinlock_t lock;
27 enum msg_parser_state state; 27 enum msg_parser_state state;
28 unsigned int interval; 28 unsigned int interval;
29 unsigned int message_count; 29 unsigned int message_count;
30 unsigned int fragment_pos; 30 unsigned int fragment_pos;
31 unsigned int value_index; 31 unsigned int value_index;
32 u64 value; 32 u64 value;
33 struct snd_firewire_motu_command_dsp_m 33 struct snd_firewire_motu_command_dsp_meter meter;
34 }; 34 };
35 35
36 int snd_motu_command_dsp_message_parser_new(st 36 int snd_motu_command_dsp_message_parser_new(struct snd_motu *motu)
37 { 37 {
38 struct msg_parser *parser; 38 struct msg_parser *parser;
39 39
40 parser = devm_kzalloc(&motu->card->car 40 parser = devm_kzalloc(&motu->card->card_dev, sizeof(*parser), GFP_KERNEL);
41 if (!parser) 41 if (!parser)
42 return -ENOMEM; 42 return -ENOMEM;
43 spin_lock_init(&parser->lock); 43 spin_lock_init(&parser->lock);
44 motu->message_parser = parser; 44 motu->message_parser = parser;
45 45
46 return 0; 46 return 0;
47 } 47 }
48 48
49 int snd_motu_command_dsp_message_parser_init(s 49 int snd_motu_command_dsp_message_parser_init(struct snd_motu *motu, enum cip_sfc sfc)
50 { 50 {
51 struct msg_parser *parser = motu->mess 51 struct msg_parser *parser = motu->message_parser;
52 52
53 parser->state = INITIALIZED; 53 parser->state = INITIALIZED;
54 54
55 // All of data blocks don't have messa 55 // All of data blocks don't have messages with meaningful information.
56 switch (sfc) { 56 switch (sfc) {
57 case CIP_SFC_176400: 57 case CIP_SFC_176400:
58 case CIP_SFC_192000: 58 case CIP_SFC_192000:
59 parser->interval = 4; 59 parser->interval = 4;
60 break; 60 break;
61 case CIP_SFC_88200: 61 case CIP_SFC_88200:
62 case CIP_SFC_96000: 62 case CIP_SFC_96000:
63 parser->interval = 2; 63 parser->interval = 2;
64 break; 64 break;
65 case CIP_SFC_32000: 65 case CIP_SFC_32000:
66 case CIP_SFC_44100: 66 case CIP_SFC_44100:
67 case CIP_SFC_48000: 67 case CIP_SFC_48000:
68 default: 68 default:
69 parser->interval = 1; 69 parser->interval = 1;
70 break; 70 break;
71 } 71 }
72 72
73 return 0; 73 return 0;
74 } 74 }
75 75
76 #define FRAGMENT_POS 6 76 #define FRAGMENT_POS 6
77 #define MIDI_BYTE_POS 7 77 #define MIDI_BYTE_POS 7
78 #define MIDI_FLAG_POS 8 78 #define MIDI_FLAG_POS 8
79 // One value of hardware meter consists of 4 m 79 // One value of hardware meter consists of 4 messages.
80 #define FRAGMENTS_PER_VALUE 4 80 #define FRAGMENTS_PER_VALUE 4
81 #define VALUES_AT_IMAGE_END 0xffff 81 #define VALUES_AT_IMAGE_END 0xffffffffffffffff
82 82
83 void snd_motu_command_dsp_message_parser_parse 83 void snd_motu_command_dsp_message_parser_parse(const struct amdtp_stream *s,
84 const 84 const struct pkt_desc *desc, unsigned int count)
85 { 85 {
86 struct snd_motu *motu = container_of(s 86 struct snd_motu *motu = container_of(s, struct snd_motu, tx_stream);
87 unsigned int data_block_quadlets = s-> 87 unsigned int data_block_quadlets = s->data_block_quadlets;
88 struct msg_parser *parser = motu->mess 88 struct msg_parser *parser = motu->message_parser;
89 unsigned int interval = parser->interv 89 unsigned int interval = parser->interval;
90 unsigned long flags; 90 unsigned long flags;
91 int i; 91 int i;
92 92
93 spin_lock_irqsave(&parser->lock, flags 93 spin_lock_irqsave(&parser->lock, flags);
94 94
95 for (i = 0; i < count; ++i) { 95 for (i = 0; i < count; ++i) {
96 __be32 *buffer = desc->ctx_pay 96 __be32 *buffer = desc->ctx_payload;
97 unsigned int data_blocks = des 97 unsigned int data_blocks = desc->data_blocks;
98 int j; 98 int j;
99 99
100 desc = amdtp_stream_next_packe 100 desc = amdtp_stream_next_packet_desc(s, desc);
101 101
102 for (j = 0; j < data_blocks; + 102 for (j = 0; j < data_blocks; ++j) {
103 u8 *b = (u8 *)buffer; 103 u8 *b = (u8 *)buffer;
104 buffer += data_block_q 104 buffer += data_block_quadlets;
105 105
106 switch (parser->state) 106 switch (parser->state) {
107 case INITIALIZED: 107 case INITIALIZED:
108 { 108 {
109 u8 fragment = 109 u8 fragment = b[FRAGMENT_POS];
110 110
111 if (fragment > 111 if (fragment > 0) {
112 parser 112 parser->value = fragment;
113 parser 113 parser->message_count = 1;
114 parser 114 parser->state = FRAGMENT_DETECTED;
115 } 115 }
116 break; 116 break;
117 } 117 }
118 case FRAGMENT_DETECTED 118 case FRAGMENT_DETECTED:
119 { 119 {
120 if (parser->me 120 if (parser->message_count % interval == 0) {
121 u8 fra 121 u8 fragment = b[FRAGMENT_POS];
122 122
123 parser 123 parser->value >>= 8;
124 parser 124 parser->value |= (u64)fragment << 56;
125 125
126 if (pa 126 if (parser->value == VALUES_AT_IMAGE_END) {
127 127 parser->state = AVAILABLE;
128 128 parser->fragment_pos = 0;
129 129 parser->value_index = 0;
130 130 parser->message_count = 0;
131 } 131 }
132 } 132 }
133 ++parser->mess 133 ++parser->message_count;
134 break; 134 break;
135 } 135 }
136 case AVAILABLE: 136 case AVAILABLE:
137 default: 137 default:
138 { 138 {
139 if (parser->me 139 if (parser->message_count % interval == 0) {
140 u8 fra 140 u8 fragment = b[FRAGMENT_POS];
141 141
142 parser 142 parser->value >>= 8;
143 parser 143 parser->value |= (u64)fragment << 56;
144 ++pars 144 ++parser->fragment_pos;
145 145
146 if (pa 146 if (parser->fragment_pos == 4) {
147 147 // Skip the last two quadlets since they could be
148 148 // invalid value (0xffffffff) as floating point
149 149 // number.
150 150 if (parser->value_index <
151 151 SNDRV_FIREWIRE_MOTU_COMMAND_DSP_METER_COUNT - 2) {
152 152 u32 val = (u32)(parser->value >> 32);
153 153 parser->meter.data[parser->value_index] = val;
154 154 }
155 155 ++parser->value_index;
156 156 parser->fragment_pos = 0;
157 } 157 }
158 158
159 if (pa 159 if (parser->value == VALUES_AT_IMAGE_END) {
160 160 parser->value_index = 0;
161 161 parser->fragment_pos = 0;
162 162 parser->message_count = 0;
163 } 163 }
164 } 164 }
165 ++parser->mess 165 ++parser->message_count;
166 break; 166 break;
167 } 167 }
168 } 168 }
169 } 169 }
170 } 170 }
171 171
172 spin_unlock_irqrestore(&parser->lock, 172 spin_unlock_irqrestore(&parser->lock, flags);
173 } 173 }
174 174
175 void snd_motu_command_dsp_message_parser_copy_ 175 void snd_motu_command_dsp_message_parser_copy_meter(struct snd_motu *motu,
176 struct 176 struct snd_firewire_motu_command_dsp_meter *meter)
177 { 177 {
178 struct msg_parser *parser = motu->mess 178 struct msg_parser *parser = motu->message_parser;
179 unsigned long flags; 179 unsigned long flags;
180 180
181 spin_lock_irqsave(&parser->lock, flags 181 spin_lock_irqsave(&parser->lock, flags);
182 memcpy(meter, &parser->meter, sizeof(* 182 memcpy(meter, &parser->meter, sizeof(*meter));
183 spin_unlock_irqrestore(&parser->lock, 183 spin_unlock_irqrestore(&parser->lock, flags);
184 } 184 }
185 185
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.