1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // HDA audio driver for Cirrus Logic CS35L56 smart amp
4 //
5 // Copyright (C) 2023 Cirrus Logic, Inc. and
6 // Cirrus Logic International Semiconductor Ltd.
7 //
8
9 #include <linux/acpi.h>
10 #include <linux/debugfs.h>
11 #include <linux/gpio/consumer.h>
12 #include <linux/module.h>
13 #include <linux/pm_runtime.h>
14 #include <linux/regmap.h>
15 #include <linux/slab.h>
16 #include <sound/core.h>
17 #include <sound/cs-amp-lib.h>
18 #include <sound/hda_codec.h>
19 #include <sound/tlv.h>
20 #include "cirrus_scodec.h"
21 #include "cs35l56_hda.h"
22 #include "hda_component.h"
23 #include "hda_generic.h"
24
25 /*
26 * The cs35l56_hda_dai_config[] reg sequence configures the device as
27 * ASP1_BCLK_FREQ = 3.072 MHz
28 * ASP1_RX_WIDTH = 32 cycles per slot, ASP1_TX_WIDTH = 32 cycles per slot, ASP1_FMT = I2S
29 * ASP1_DOUT_HIZ_CONTROL = Hi-Z during unused timeslots
30 * ASP1_RX_WL = 24 bits per sample
31 * ASP1_TX_WL = 24 bits per sample
32 * ASP1_RXn_EN 1..3 and ASP1_TXn_EN 1..4 disabled
33 *
34 * Override any Windows-specific mixer settings applied by the firmware.
35 */
36 static const struct reg_sequence cs35l56_hda_dai_config[] = {
37 { CS35L56_ASP1_CONTROL1, 0x00000021 },
38 { CS35L56_ASP1_CONTROL2, 0x20200200 },
39 { CS35L56_ASP1_CONTROL3, 0x00000003 },
40 { CS35L56_ASP1_FRAME_CONTROL1, 0x03020100 },
41 { CS35L56_ASP1_FRAME_CONTROL5, 0x00020100 },
42 { CS35L56_ASP1_DATA_CONTROL5, 0x00000018 },
43 { CS35L56_ASP1_DATA_CONTROL1, 0x00000018 },
44 { CS35L56_ASP1_ENABLES1, 0x00000000 },
45 { CS35L56_ASP1TX1_INPUT, 0x00000018 },
46 { CS35L56_ASP1TX2_INPUT, 0x00000019 },
47 { CS35L56_ASP1TX3_INPUT, 0x00000020 },
48 { CS35L56_ASP1TX4_INPUT, 0x00000028 },
49
50 };
51
cs35l56_hda_wait_dsp_ready(struct cs35l56_hda * cs35l56)52 static void cs35l56_hda_wait_dsp_ready(struct cs35l56_hda *cs35l56)
53 {
54 /* Wait for patching to complete */
55 flush_work(&cs35l56->dsp_work);
56 }
57
cs35l56_hda_play(struct cs35l56_hda * cs35l56)58 static void cs35l56_hda_play(struct cs35l56_hda *cs35l56)
59 {
60 unsigned int val;
61 int ret;
62
63 cs35l56_hda_wait_dsp_ready(cs35l56);
64
65 pm_runtime_get_sync(cs35l56->base.dev);
66 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_PLAY);
67 if (ret == 0) {
68 /* Wait for firmware to enter PS0 power state */
69 ret = regmap_read_poll_timeout(cs35l56->base.regmap,
70 cs35l56->base.fw_reg->transducer_actual_ps,
71 val, (val == CS35L56_PS0),
72 CS35L56_PS0_POLL_US,
73 CS35L56_PS0_TIMEOUT_US);
74 if (ret)
75 dev_warn(cs35l56->base.dev, "PS0 wait failed: %d\n", ret);
76 }
77 regmap_set_bits(cs35l56->base.regmap, CS35L56_ASP1_ENABLES1,
78 BIT(CS35L56_ASP_RX1_EN_SHIFT) | BIT(CS35L56_ASP_RX2_EN_SHIFT) |
79 cs35l56->asp_tx_mask);
80 cs35l56->playing = true;
81 }
82
cs35l56_hda_pause(struct cs35l56_hda * cs35l56)83 static void cs35l56_hda_pause(struct cs35l56_hda *cs35l56)
84 {
85 cs35l56->playing = false;
86 cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_PAUSE);
87 regmap_clear_bits(cs35l56->base.regmap, CS35L56_ASP1_ENABLES1,
88 BIT(CS35L56_ASP_RX1_EN_SHIFT) | BIT(CS35L56_ASP_RX2_EN_SHIFT) |
89 BIT(CS35L56_ASP_TX1_EN_SHIFT) | BIT(CS35L56_ASP_TX2_EN_SHIFT) |
90 BIT(CS35L56_ASP_TX3_EN_SHIFT) | BIT(CS35L56_ASP_TX4_EN_SHIFT));
91
92 pm_runtime_mark_last_busy(cs35l56->base.dev);
93 pm_runtime_put_autosuspend(cs35l56->base.dev);
94 }
95
cs35l56_hda_playback_hook(struct device * dev,int action)96 static void cs35l56_hda_playback_hook(struct device *dev, int action)
97 {
98 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
99
100 dev_dbg(cs35l56->base.dev, "%s()%d: action: %d\n", __func__, __LINE__, action);
101
102 switch (action) {
103 case HDA_GEN_PCM_ACT_PREPARE:
104 if (cs35l56->playing)
105 break;
106
107 /* If we're suspended: flag that resume should start playback */
108 if (cs35l56->suspended) {
109 cs35l56->playing = true;
110 break;
111 }
112
113 cs35l56_hda_play(cs35l56);
114 break;
115 case HDA_GEN_PCM_ACT_CLEANUP:
116 if (!cs35l56->playing)
117 break;
118
119 cs35l56_hda_pause(cs35l56);
120 break;
121 default:
122 break;
123 }
124 }
125
cs35l56_hda_runtime_suspend(struct device * dev)126 static int cs35l56_hda_runtime_suspend(struct device *dev)
127 {
128 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
129
130 if (cs35l56->cs_dsp.booted)
131 cs_dsp_stop(&cs35l56->cs_dsp);
132
133 return cs35l56_runtime_suspend_common(&cs35l56->base);
134 }
135
cs35l56_hda_runtime_resume(struct device * dev)136 static int cs35l56_hda_runtime_resume(struct device *dev)
137 {
138 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
139 int ret;
140
141 ret = cs35l56_runtime_resume_common(&cs35l56->base, false);
142 if (ret < 0)
143 return ret;
144
145 if (cs35l56->cs_dsp.booted) {
146 ret = cs_dsp_run(&cs35l56->cs_dsp);
147 if (ret) {
148 dev_dbg(cs35l56->base.dev, "%s: cs_dsp_run ret %d\n", __func__, ret);
149 goto err;
150 }
151 }
152
153 return 0;
154
155 err:
156 cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_ALLOW_AUTO_HIBERNATE);
157 regmap_write(cs35l56->base.regmap, CS35L56_DSP_VIRTUAL1_MBOX_1,
158 CS35L56_MBOX_CMD_HIBERNATE_NOW);
159
160 regcache_cache_only(cs35l56->base.regmap, true);
161
162 return ret;
163 }
164
cs35l56_hda_mixer_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)165 static int cs35l56_hda_mixer_info(struct snd_kcontrol *kcontrol,
166 struct snd_ctl_elem_info *uinfo)
167 {
168 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
169 uinfo->count = 1;
170 uinfo->value.enumerated.items = CS35L56_NUM_INPUT_SRC;
171 if (uinfo->value.enumerated.item >= CS35L56_NUM_INPUT_SRC)
172 uinfo->value.enumerated.item = CS35L56_NUM_INPUT_SRC - 1;
173 strscpy(uinfo->value.enumerated.name, cs35l56_tx_input_texts[uinfo->value.enumerated.item],
174 sizeof(uinfo->value.enumerated.name));
175
176 return 0;
177 }
178
cs35l56_hda_mixer_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)179 static int cs35l56_hda_mixer_get(struct snd_kcontrol *kcontrol,
180 struct snd_ctl_elem_value *ucontrol)
181 {
182 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
183 unsigned int reg_val;
184 int i;
185
186 cs35l56_hda_wait_dsp_ready(cs35l56);
187
188 regmap_read(cs35l56->base.regmap, kcontrol->private_value, ®_val);
189 reg_val &= CS35L56_ASP_TXn_SRC_MASK;
190
191 for (i = 0; i < CS35L56_NUM_INPUT_SRC; ++i) {
192 if (cs35l56_tx_input_values[i] == reg_val) {
193 ucontrol->value.enumerated.item[0] = i;
194 break;
195 }
196 }
197
198 return 0;
199 }
200
cs35l56_hda_mixer_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)201 static int cs35l56_hda_mixer_put(struct snd_kcontrol *kcontrol,
202 struct snd_ctl_elem_value *ucontrol)
203 {
204 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
205 unsigned int item = ucontrol->value.enumerated.item[0];
206 bool changed;
207
208 if (item >= CS35L56_NUM_INPUT_SRC)
209 return -EINVAL;
210
211 cs35l56_hda_wait_dsp_ready(cs35l56);
212
213 regmap_update_bits_check(cs35l56->base.regmap, kcontrol->private_value,
214 CS35L56_INPUT_MASK, cs35l56_tx_input_values[item],
215 &changed);
216
217 return changed;
218 }
219
cs35l56_hda_posture_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)220 static int cs35l56_hda_posture_info(struct snd_kcontrol *kcontrol,
221 struct snd_ctl_elem_info *uinfo)
222 {
223 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
224 uinfo->count = 1;
225 uinfo->value.integer.min = CS35L56_MAIN_POSTURE_MIN;
226 uinfo->value.integer.max = CS35L56_MAIN_POSTURE_MAX;
227 return 0;
228 }
229
cs35l56_hda_posture_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)230 static int cs35l56_hda_posture_get(struct snd_kcontrol *kcontrol,
231 struct snd_ctl_elem_value *ucontrol)
232 {
233 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
234 unsigned int pos;
235 int ret;
236
237 cs35l56_hda_wait_dsp_ready(cs35l56);
238
239 ret = regmap_read(cs35l56->base.regmap,
240 cs35l56->base.fw_reg->posture_number, &pos);
241 if (ret)
242 return ret;
243
244 ucontrol->value.integer.value[0] = pos;
245
246 return 0;
247 }
248
cs35l56_hda_posture_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)249 static int cs35l56_hda_posture_put(struct snd_kcontrol *kcontrol,
250 struct snd_ctl_elem_value *ucontrol)
251 {
252 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
253 unsigned long pos = ucontrol->value.integer.value[0];
254 bool changed;
255 int ret;
256
257 if ((pos < CS35L56_MAIN_POSTURE_MIN) ||
258 (pos > CS35L56_MAIN_POSTURE_MAX))
259 return -EINVAL;
260
261 cs35l56_hda_wait_dsp_ready(cs35l56);
262
263 ret = regmap_update_bits_check(cs35l56->base.regmap, cs35l56->base.fw_reg->posture_number,
264 CS35L56_MAIN_POSTURE_MASK, pos, &changed);
265 if (ret)
266 return ret;
267
268 return changed;
269 }
270
271 static const struct {
272 const char *name;
273 unsigned int reg;
274 } cs35l56_hda_mixer_controls[] = {
275 { "ASP1 TX1 Source", CS35L56_ASP1TX1_INPUT },
276 { "ASP1 TX2 Source", CS35L56_ASP1TX2_INPUT },
277 { "ASP1 TX3 Source", CS35L56_ASP1TX3_INPUT },
278 { "ASP1 TX4 Source", CS35L56_ASP1TX4_INPUT },
279 };
280
281 static const DECLARE_TLV_DB_SCALE(cs35l56_hda_vol_tlv, -10000, 25, 0);
282
cs35l56_hda_vol_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)283 static int cs35l56_hda_vol_info(struct snd_kcontrol *kcontrol,
284 struct snd_ctl_elem_info *uinfo)
285 {
286 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
287 uinfo->count = 1;
288 uinfo->value.integer.step = 1;
289 uinfo->value.integer.min = 0;
290 uinfo->value.integer.max = CS35L56_MAIN_RENDER_USER_VOLUME_MAX -
291 CS35L56_MAIN_RENDER_USER_VOLUME_MIN;
292
293 return 0;
294 }
295
cs35l56_hda_vol_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)296 static int cs35l56_hda_vol_get(struct snd_kcontrol *kcontrol,
297 struct snd_ctl_elem_value *ucontrol)
298 {
299 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
300 unsigned int raw_vol;
301 int vol;
302 int ret;
303
304 cs35l56_hda_wait_dsp_ready(cs35l56);
305
306 ret = regmap_read(cs35l56->base.regmap, cs35l56->base.fw_reg->user_volume, &raw_vol);
307
308 if (ret)
309 return ret;
310
311 vol = (s16)(raw_vol & 0xFFFF);
312 vol >>= CS35L56_MAIN_RENDER_USER_VOLUME_SHIFT;
313
314 if (vol & BIT(CS35L56_MAIN_RENDER_USER_VOLUME_SIGNBIT))
315 vol |= ~((int)(BIT(CS35L56_MAIN_RENDER_USER_VOLUME_SIGNBIT) - 1));
316
317 ucontrol->value.integer.value[0] = vol - CS35L56_MAIN_RENDER_USER_VOLUME_MIN;
318
319 return 0;
320 }
321
cs35l56_hda_vol_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)322 static int cs35l56_hda_vol_put(struct snd_kcontrol *kcontrol,
323 struct snd_ctl_elem_value *ucontrol)
324 {
325 struct cs35l56_hda *cs35l56 = snd_kcontrol_chip(kcontrol);
326 long vol = ucontrol->value.integer.value[0];
327 unsigned int raw_vol;
328 bool changed;
329 int ret;
330
331 if ((vol < 0) || (vol > (CS35L56_MAIN_RENDER_USER_VOLUME_MAX -
332 CS35L56_MAIN_RENDER_USER_VOLUME_MIN)))
333 return -EINVAL;
334
335 raw_vol = (vol + CS35L56_MAIN_RENDER_USER_VOLUME_MIN) <<
336 CS35L56_MAIN_RENDER_USER_VOLUME_SHIFT;
337
338 cs35l56_hda_wait_dsp_ready(cs35l56);
339
340 ret = regmap_update_bits_check(cs35l56->base.regmap, cs35l56->base.fw_reg->user_volume,
341 CS35L56_MAIN_RENDER_USER_VOLUME_MASK, raw_vol, &changed);
342 if (ret)
343 return ret;
344
345 return changed;
346 }
347
cs35l56_hda_create_controls(struct cs35l56_hda * cs35l56)348 static void cs35l56_hda_create_controls(struct cs35l56_hda *cs35l56)
349 {
350 struct snd_kcontrol_new ctl_template = {
351 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
352 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
353 .info = cs35l56_hda_posture_info,
354 .get = cs35l56_hda_posture_get,
355 .put = cs35l56_hda_posture_put,
356 };
357 char name[64];
358 int i;
359
360 snprintf(name, sizeof(name), "%s Posture Number", cs35l56->amp_name);
361 ctl_template.name = name;
362 cs35l56->posture_ctl = snd_ctl_new1(&ctl_template, cs35l56);
363 if (snd_ctl_add(cs35l56->codec->card, cs35l56->posture_ctl))
364 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", ctl_template.name);
365
366 /* Mixer controls */
367 ctl_template.info = cs35l56_hda_mixer_info;
368 ctl_template.get = cs35l56_hda_mixer_get;
369 ctl_template.put = cs35l56_hda_mixer_put;
370
371 BUILD_BUG_ON(ARRAY_SIZE(cs35l56->mixer_ctl) != ARRAY_SIZE(cs35l56_hda_mixer_controls));
372
373 for (i = 0; i < ARRAY_SIZE(cs35l56_hda_mixer_controls); ++i) {
374 snprintf(name, sizeof(name), "%s %s", cs35l56->amp_name,
375 cs35l56_hda_mixer_controls[i].name);
376 ctl_template.private_value = cs35l56_hda_mixer_controls[i].reg;
377 cs35l56->mixer_ctl[i] = snd_ctl_new1(&ctl_template, cs35l56);
378 if (snd_ctl_add(cs35l56->codec->card, cs35l56->mixer_ctl[i])) {
379 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n",
380 ctl_template.name);
381 }
382 }
383
384 ctl_template.info = cs35l56_hda_vol_info;
385 ctl_template.get = cs35l56_hda_vol_get;
386 ctl_template.put = cs35l56_hda_vol_put;
387 ctl_template.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ);
388 ctl_template.tlv.p = cs35l56_hda_vol_tlv;
389 snprintf(name, sizeof(name), "%s Speaker Playback Volume", cs35l56->amp_name);
390 ctl_template.name = name;
391 cs35l56->volume_ctl = snd_ctl_new1(&ctl_template, cs35l56);
392 if (snd_ctl_add(cs35l56->codec->card, cs35l56->volume_ctl))
393 dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", ctl_template.name);
394 }
395
cs35l56_hda_remove_controls(struct cs35l56_hda * cs35l56)396 static void cs35l56_hda_remove_controls(struct cs35l56_hda *cs35l56)
397 {
398 int i;
399
400 for (i = ARRAY_SIZE(cs35l56->mixer_ctl) - 1; i >= 0; i--)
401 snd_ctl_remove(cs35l56->codec->card, cs35l56->mixer_ctl[i]);
402
403 snd_ctl_remove(cs35l56->codec->card, cs35l56->posture_ctl);
404 snd_ctl_remove(cs35l56->codec->card, cs35l56->volume_ctl);
405 }
406
407 static const struct cs_dsp_client_ops cs35l56_hda_client_ops = {
408 /* cs_dsp requires the client to provide this even if it is empty */
409 };
410
cs35l56_hda_request_firmware_file(struct cs35l56_hda * cs35l56,const struct firmware ** firmware,char ** filename,const char * base_name,const char * system_name,const char * amp_name,const char * filetype)411 static int cs35l56_hda_request_firmware_file(struct cs35l56_hda *cs35l56,
412 const struct firmware **firmware, char **filename,
413 const char *base_name, const char *system_name,
414 const char *amp_name,
415 const char *filetype)
416 {
417 char *s, c;
418 int ret = 0;
419
420 if (system_name && amp_name)
421 *filename = kasprintf(GFP_KERNEL, "%s-%s-%s.%s", base_name,
422 system_name, amp_name, filetype);
423 else if (system_name)
424 *filename = kasprintf(GFP_KERNEL, "%s-%s.%s", base_name,
425 system_name, filetype);
426 else
427 *filename = kasprintf(GFP_KERNEL, "%s.%s", base_name, filetype);
428
429 if (!*filename)
430 return -ENOMEM;
431
432 /*
433 * Make sure that filename is lower-case and any non alpha-numeric
434 * characters except full stop and forward slash are replaced with
435 * hyphens.
436 */
437 s = *filename;
438 while (*s) {
439 c = *s;
440 if (isalnum(c))
441 *s = tolower(c);
442 else if (c != '.' && c != '/')
443 *s = '-';
444 s++;
445 }
446
447 ret = firmware_request_nowarn(firmware, *filename, cs35l56->base.dev);
448 if (ret) {
449 dev_dbg(cs35l56->base.dev, "Failed to request '%s'\n", *filename);
450 kfree(*filename);
451 *filename = NULL;
452 return ret;
453 }
454
455 dev_dbg(cs35l56->base.dev, "Found '%s'\n", *filename);
456
457 return 0;
458 }
459
cs35l56_hda_request_firmware_files(struct cs35l56_hda * cs35l56,unsigned int preloaded_fw_ver,const struct firmware ** wmfw_firmware,char ** wmfw_filename,const struct firmware ** coeff_firmware,char ** coeff_filename)460 static void cs35l56_hda_request_firmware_files(struct cs35l56_hda *cs35l56,
461 unsigned int preloaded_fw_ver,
462 const struct firmware **wmfw_firmware,
463 char **wmfw_filename,
464 const struct firmware **coeff_firmware,
465 char **coeff_filename)
466 {
467 const char *system_name = cs35l56->system_name;
468 const char *amp_name = cs35l56->amp_name;
469 char base_name[37];
470 int ret;
471
472 if (preloaded_fw_ver) {
473 snprintf(base_name, sizeof(base_name),
474 "cirrus/cs35l%02x-%02x%s-%06x-dsp1-misc",
475 cs35l56->base.type,
476 cs35l56->base.rev,
477 cs35l56->base.secured ? "-s" : "",
478 preloaded_fw_ver & 0xffffff);
479 } else {
480 snprintf(base_name, sizeof(base_name),
481 "cirrus/cs35l%02x-%02x%s-dsp1-misc",
482 cs35l56->base.type,
483 cs35l56->base.rev,
484 cs35l56->base.secured ? "-s" : "");
485 }
486
487 if (system_name && amp_name) {
488 if (!cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
489 base_name, system_name, amp_name, "wmfw")) {
490 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
491 base_name, system_name, amp_name, "bin");
492 return;
493 }
494 }
495
496 if (system_name) {
497 if (!cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
498 base_name, system_name, NULL, "wmfw")) {
499 if (amp_name)
500 cs35l56_hda_request_firmware_file(cs35l56,
501 coeff_firmware, coeff_filename,
502 base_name, system_name,
503 amp_name, "bin");
504 if (!*coeff_firmware)
505 cs35l56_hda_request_firmware_file(cs35l56,
506 coeff_firmware, coeff_filename,
507 base_name, system_name,
508 NULL, "bin");
509 return;
510 }
511
512 /*
513 * Check for system-specific bin files without wmfw before
514 * falling back to generic firmware
515 */
516 if (amp_name)
517 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
518 base_name, system_name, amp_name, "bin");
519 if (!*coeff_firmware)
520 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
521 base_name, system_name, NULL, "bin");
522
523 if (*coeff_firmware)
524 return;
525 }
526
527 ret = cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
528 base_name, NULL, NULL, "wmfw");
529 if (!ret) {
530 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
531 base_name, NULL, NULL, "bin");
532 return;
533 }
534
535 if (!*coeff_firmware)
536 cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
537 base_name, NULL, NULL, "bin");
538 }
539
cs35l56_hda_release_firmware_files(const struct firmware * wmfw_firmware,char * wmfw_filename,const struct firmware * coeff_firmware,char * coeff_filename)540 static void cs35l56_hda_release_firmware_files(const struct firmware *wmfw_firmware,
541 char *wmfw_filename,
542 const struct firmware *coeff_firmware,
543 char *coeff_filename)
544 {
545 release_firmware(wmfw_firmware);
546 kfree(wmfw_filename);
547
548 release_firmware(coeff_firmware);
549 kfree(coeff_filename);
550 }
551
cs35l56_hda_apply_calibration(struct cs35l56_hda * cs35l56)552 static void cs35l56_hda_apply_calibration(struct cs35l56_hda *cs35l56)
553 {
554 int ret;
555
556 if (!cs35l56->base.cal_data_valid || cs35l56->base.secured)
557 return;
558
559 ret = cs_amp_write_cal_coeffs(&cs35l56->cs_dsp,
560 &cs35l56_calibration_controls,
561 &cs35l56->base.cal_data);
562 if (ret < 0)
563 dev_warn(cs35l56->base.dev, "Failed to write calibration: %d\n", ret);
564 else
565 dev_info(cs35l56->base.dev, "Calibration applied\n");
566 }
567
cs35l56_hda_fw_load(struct cs35l56_hda * cs35l56)568 static void cs35l56_hda_fw_load(struct cs35l56_hda *cs35l56)
569 {
570 const struct firmware *coeff_firmware = NULL;
571 const struct firmware *wmfw_firmware = NULL;
572 char *coeff_filename = NULL;
573 char *wmfw_filename = NULL;
574 unsigned int preloaded_fw_ver;
575 bool firmware_missing;
576 int ret;
577
578 /*
579 * Prepare for a new DSP power-up. If the DSP has had firmware
580 * downloaded previously then it needs to be powered down so that it
581 * can be updated.
582 */
583 if (cs35l56->base.fw_patched)
584 cs_dsp_power_down(&cs35l56->cs_dsp);
585
586 cs35l56->base.fw_patched = false;
587
588 ret = pm_runtime_resume_and_get(cs35l56->base.dev);
589 if (ret < 0) {
590 dev_err(cs35l56->base.dev, "Failed to resume and get %d\n", ret);
591 return;
592 }
593
594 /*
595 * The firmware can only be upgraded if it is currently running
596 * from the built-in ROM. If not, the wmfw/bin must be for the
597 * version of firmware that is running on the chip.
598 */
599 ret = cs35l56_read_prot_status(&cs35l56->base, &firmware_missing, &preloaded_fw_ver);
600 if (ret)
601 goto err_pm_put;
602
603 if (firmware_missing)
604 preloaded_fw_ver = 0;
605
606 cs35l56_hda_request_firmware_files(cs35l56, preloaded_fw_ver,
607 &wmfw_firmware, &wmfw_filename,
608 &coeff_firmware, &coeff_filename);
609
610 /*
611 * If the BIOS didn't patch the firmware a bin file is mandatory to
612 * enable the ASP·
613 */
614 if (!coeff_firmware && firmware_missing) {
615 dev_err(cs35l56->base.dev, ".bin file required but not found\n");
616 goto err_fw_release;
617 }
618
619 mutex_lock(&cs35l56->base.irq_lock);
620
621 /*
622 * If the firmware hasn't been patched it must be shutdown before
623 * doing a full patch and reset afterwards. If it is already
624 * running a patched version the firmware files only contain
625 * tunings and we can use the lower cost reinit sequence instead.
626 */
627 if (firmware_missing && (wmfw_firmware || coeff_firmware)) {
628 ret = cs35l56_firmware_shutdown(&cs35l56->base);
629 if (ret)
630 goto err;
631 }
632
633 ret = cs_dsp_power_up(&cs35l56->cs_dsp, wmfw_firmware, wmfw_filename,
634 coeff_firmware, coeff_filename, "misc");
635 if (ret) {
636 dev_dbg(cs35l56->base.dev, "%s: cs_dsp_power_up ret %d\n", __func__, ret);
637 goto err;
638 }
639
640 if (wmfw_filename)
641 dev_dbg(cs35l56->base.dev, "Loaded WMFW Firmware: %s\n", wmfw_filename);
642
643 if (coeff_filename)
644 dev_dbg(cs35l56->base.dev, "Loaded Coefficients: %s\n", coeff_filename);
645
646 /* If we downloaded firmware, reset the device and wait for it to boot */
647 if (firmware_missing && (wmfw_firmware || coeff_firmware)) {
648 cs35l56_system_reset(&cs35l56->base, false);
649 regcache_mark_dirty(cs35l56->base.regmap);
650 ret = cs35l56_wait_for_firmware_boot(&cs35l56->base);
651 if (ret)
652 goto err_powered_up;
653
654 regcache_cache_only(cs35l56->base.regmap, false);
655 }
656
657 /* Disable auto-hibernate so that runtime_pm has control */
658 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_PREVENT_AUTO_HIBERNATE);
659 if (ret)
660 goto err_powered_up;
661
662 regcache_sync(cs35l56->base.regmap);
663
664 regmap_clear_bits(cs35l56->base.regmap,
665 cs35l56->base.fw_reg->prot_sts,
666 CS35L56_FIRMWARE_MISSING);
667 cs35l56->base.fw_patched = true;
668
669 ret = cs_dsp_run(&cs35l56->cs_dsp);
670 if (ret)
671 dev_dbg(cs35l56->base.dev, "%s: cs_dsp_run ret %d\n", __func__, ret);
672
673 cs35l56_hda_apply_calibration(cs35l56);
674 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_REINIT);
675 if (ret)
676 cs_dsp_stop(&cs35l56->cs_dsp);
677
678 cs35l56_log_tuning(&cs35l56->base, &cs35l56->cs_dsp);
679
680 err_powered_up:
681 if (!cs35l56->base.fw_patched)
682 cs_dsp_power_down(&cs35l56->cs_dsp);
683 err:
684 mutex_unlock(&cs35l56->base.irq_lock);
685 err_fw_release:
686 cs35l56_hda_release_firmware_files(wmfw_firmware, wmfw_filename,
687 coeff_firmware, coeff_filename);
688 err_pm_put:
689 pm_runtime_put(cs35l56->base.dev);
690 }
691
cs35l56_hda_dsp_work(struct work_struct * work)692 static void cs35l56_hda_dsp_work(struct work_struct *work)
693 {
694 struct cs35l56_hda *cs35l56 = container_of(work, struct cs35l56_hda, dsp_work);
695
696 cs35l56_hda_fw_load(cs35l56);
697 }
698
cs35l56_hda_bind(struct device * dev,struct device * master,void * master_data)699 static int cs35l56_hda_bind(struct device *dev, struct device *master, void *master_data)
700 {
701 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
702 struct hda_component_parent *parent = master_data;
703 struct hda_component *comp;
704
705 comp = hda_component_from_index(parent, cs35l56->index);
706 if (!comp)
707 return -EINVAL;
708
709 if (comp->dev)
710 return -EBUSY;
711
712 comp->dev = dev;
713 cs35l56->codec = parent->codec;
714 strscpy(comp->name, dev_name(dev), sizeof(comp->name));
715 comp->playback_hook = cs35l56_hda_playback_hook;
716
717 queue_work(system_long_wq, &cs35l56->dsp_work);
718
719 cs35l56_hda_create_controls(cs35l56);
720
721 #if IS_ENABLED(CONFIG_SND_DEBUG)
722 cs35l56->debugfs_root = debugfs_create_dir(dev_name(cs35l56->base.dev), sound_debugfs_root);
723 cs_dsp_init_debugfs(&cs35l56->cs_dsp, cs35l56->debugfs_root);
724 #endif
725
726 dev_dbg(cs35l56->base.dev, "Bound\n");
727
728 return 0;
729 }
730
cs35l56_hda_unbind(struct device * dev,struct device * master,void * master_data)731 static void cs35l56_hda_unbind(struct device *dev, struct device *master, void *master_data)
732 {
733 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
734 struct hda_component_parent *parent = master_data;
735 struct hda_component *comp;
736
737 cancel_work_sync(&cs35l56->dsp_work);
738
739 cs35l56_hda_remove_controls(cs35l56);
740
741 #if IS_ENABLED(CONFIG_SND_DEBUG)
742 cs_dsp_cleanup_debugfs(&cs35l56->cs_dsp);
743 debugfs_remove_recursive(cs35l56->debugfs_root);
744 #endif
745
746 if (cs35l56->base.fw_patched)
747 cs_dsp_power_down(&cs35l56->cs_dsp);
748
749 comp = hda_component_from_index(parent, cs35l56->index);
750 if (comp && (comp->dev == dev))
751 memset(comp, 0, sizeof(*comp));
752
753 cs35l56->codec = NULL;
754
755 dev_dbg(cs35l56->base.dev, "Unbound\n");
756 }
757
758 static const struct component_ops cs35l56_hda_comp_ops = {
759 .bind = cs35l56_hda_bind,
760 .unbind = cs35l56_hda_unbind,
761 };
762
cs35l56_hda_system_suspend(struct device * dev)763 static int cs35l56_hda_system_suspend(struct device *dev)
764 {
765 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
766
767 cs35l56_hda_wait_dsp_ready(cs35l56);
768
769 if (cs35l56->playing)
770 cs35l56_hda_pause(cs35l56);
771
772 cs35l56->suspended = true;
773
774 /*
775 * The interrupt line is normally shared, but after we start suspending
776 * we can't check if our device is the source of an interrupt, and can't
777 * clear it. Prevent this race by temporarily disabling the parent irq
778 * until we reach _no_irq.
779 */
780 if (cs35l56->base.irq)
781 disable_irq(cs35l56->base.irq);
782
783 return pm_runtime_force_suspend(dev);
784 }
785
cs35l56_hda_system_suspend_late(struct device * dev)786 static int cs35l56_hda_system_suspend_late(struct device *dev)
787 {
788 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
789
790 /*
791 * RESET is usually shared by all amps so it must not be asserted until
792 * all driver instances have done their suspend() stage.
793 */
794 if (cs35l56->base.reset_gpio) {
795 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
796 cs35l56_wait_min_reset_pulse();
797 }
798
799 return 0;
800 }
801
cs35l56_hda_system_suspend_no_irq(struct device * dev)802 static int cs35l56_hda_system_suspend_no_irq(struct device *dev)
803 {
804 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
805
806 /* Handlers are now disabled so the parent IRQ can safely be re-enabled. */
807 if (cs35l56->base.irq)
808 enable_irq(cs35l56->base.irq);
809
810 return 0;
811 }
812
cs35l56_hda_system_resume_no_irq(struct device * dev)813 static int cs35l56_hda_system_resume_no_irq(struct device *dev)
814 {
815 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
816
817 /*
818 * WAKE interrupts unmask if the CS35L56 hibernates, which can cause
819 * spurious interrupts, and the interrupt line is normally shared.
820 * We can't check if our device is the source of an interrupt, and can't
821 * clear it, until it has fully resumed. Prevent this race by temporarily
822 * disabling the parent irq until we complete resume().
823 */
824 if (cs35l56->base.irq)
825 disable_irq(cs35l56->base.irq);
826
827 return 0;
828 }
829
cs35l56_hda_system_resume_early(struct device * dev)830 static int cs35l56_hda_system_resume_early(struct device *dev)
831 {
832 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
833
834 /* Ensure a spec-compliant RESET pulse. */
835 if (cs35l56->base.reset_gpio) {
836 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
837 cs35l56_wait_min_reset_pulse();
838
839 /* Release shared RESET before drivers start resume(). */
840 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1);
841 cs35l56_wait_control_port_ready();
842 }
843
844 return 0;
845 }
846
cs35l56_hda_system_resume(struct device * dev)847 static int cs35l56_hda_system_resume(struct device *dev)
848 {
849 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
850 int ret;
851
852 /* Undo pm_runtime_force_suspend() before re-enabling the irq */
853 ret = pm_runtime_force_resume(dev);
854 if (cs35l56->base.irq)
855 enable_irq(cs35l56->base.irq);
856
857 if (ret)
858 return ret;
859
860 cs35l56->suspended = false;
861
862 if (!cs35l56->codec)
863 return 0;
864
865 ret = cs35l56_is_fw_reload_needed(&cs35l56->base);
866 dev_dbg(cs35l56->base.dev, "fw_reload_needed: %d\n", ret);
867 if (ret > 0)
868 queue_work(system_long_wq, &cs35l56->dsp_work);
869
870 if (cs35l56->playing)
871 cs35l56_hda_play(cs35l56);
872
873 return 0;
874 }
875
cs35l56_hda_read_acpi(struct cs35l56_hda * cs35l56,int hid,int id)876 static int cs35l56_hda_read_acpi(struct cs35l56_hda *cs35l56, int hid, int id)
877 {
878 u32 values[HDA_MAX_COMPONENTS];
879 char hid_string[8];
880 struct acpi_device *adev;
881 const char *property, *sub;
882 size_t nval;
883 int i, ret;
884
885 /*
886 * ACPI_COMPANION isn't available when this driver was instantiated by
887 * the serial-multi-instantiate driver, so lookup the node by HID
888 */
889 if (!ACPI_COMPANION(cs35l56->base.dev)) {
890 snprintf(hid_string, sizeof(hid_string), "CSC%04X", hid);
891 adev = acpi_dev_get_first_match_dev(hid_string, NULL, -1);
892 if (!adev) {
893 dev_err(cs35l56->base.dev, "Failed to find an ACPI device for %s\n",
894 dev_name(cs35l56->base.dev));
895 return -ENODEV;
896 }
897 ACPI_COMPANION_SET(cs35l56->base.dev, adev);
898 }
899
900 property = "cirrus,dev-index";
901 ret = device_property_count_u32(cs35l56->base.dev, property);
902 if (ret <= 0)
903 goto err;
904
905 if (ret > ARRAY_SIZE(values)) {
906 ret = -EINVAL;
907 goto err;
908 }
909 nval = ret;
910
911 ret = device_property_read_u32_array(cs35l56->base.dev, property, values, nval);
912 if (ret)
913 goto err;
914
915 cs35l56->index = -1;
916 for (i = 0; i < nval; i++) {
917 if (values[i] == id) {
918 cs35l56->index = i;
919 break;
920 }
921 }
922 /*
923 * It's not an error for the ID to be missing: for I2C there can be
924 * an alias address that is not a real device. So reject silently.
925 */
926 if (cs35l56->index == -1) {
927 dev_dbg(cs35l56->base.dev, "No index found in %s\n", property);
928 ret = -ENODEV;
929 goto err;
930 }
931
932 sub = acpi_get_subsystem_id(ACPI_HANDLE(cs35l56->base.dev));
933
934 if (IS_ERR(sub)) {
935 dev_info(cs35l56->base.dev,
936 "Read ACPI _SUB failed(%ld): fallback to generic firmware\n",
937 PTR_ERR(sub));
938 } else {
939 ret = cirrus_scodec_get_speaker_id(cs35l56->base.dev, cs35l56->index, nval, -1);
940 if (ret == -ENOENT) {
941 cs35l56->system_name = sub;
942 } else if (ret >= 0) {
943 cs35l56->system_name = kasprintf(GFP_KERNEL, "%s-spkid%d", sub, ret);
944 kfree(sub);
945 if (!cs35l56->system_name)
946 return -ENOMEM;
947 } else {
948 return ret;
949 }
950 }
951
952 cs35l56->base.reset_gpio = devm_gpiod_get_index_optional(cs35l56->base.dev,
953 "reset",
954 cs35l56->index,
955 GPIOD_OUT_LOW);
956 if (IS_ERR(cs35l56->base.reset_gpio)) {
957 ret = PTR_ERR(cs35l56->base.reset_gpio);
958
959 /*
960 * If RESET is shared the first amp to probe will grab the reset
961 * line and reset all the amps
962 */
963 if (ret != -EBUSY)
964 return dev_err_probe(cs35l56->base.dev, ret, "Failed to get reset GPIO\n");
965
966 dev_info(cs35l56->base.dev, "Reset GPIO busy, assume shared reset\n");
967 cs35l56->base.reset_gpio = NULL;
968 }
969
970 return 0;
971
972 err:
973 if (ret != -ENODEV)
974 dev_err(cs35l56->base.dev, "Failed property %s: %d\n", property, ret);
975
976 return ret;
977 }
978
cs35l56_hda_common_probe(struct cs35l56_hda * cs35l56,int hid,int id)979 int cs35l56_hda_common_probe(struct cs35l56_hda *cs35l56, int hid, int id)
980 {
981 int ret;
982
983 mutex_init(&cs35l56->base.irq_lock);
984 dev_set_drvdata(cs35l56->base.dev, cs35l56);
985
986 INIT_WORK(&cs35l56->dsp_work, cs35l56_hda_dsp_work);
987
988 ret = cs35l56_hda_read_acpi(cs35l56, hid, id);
989 if (ret)
990 goto err;
991
992 cs35l56->amp_name = devm_kasprintf(cs35l56->base.dev, GFP_KERNEL, "AMP%d",
993 cs35l56->index + 1);
994 if (!cs35l56->amp_name) {
995 ret = -ENOMEM;
996 goto err;
997 }
998
999 cs35l56->base.cal_index = -1;
1000
1001 cs35l56_init_cs_dsp(&cs35l56->base, &cs35l56->cs_dsp);
1002 cs35l56->cs_dsp.client_ops = &cs35l56_hda_client_ops;
1003
1004 if (cs35l56->base.reset_gpio) {
1005 dev_dbg(cs35l56->base.dev, "Hard reset\n");
1006
1007 /*
1008 * The GPIOD_OUT_LOW to *_gpiod_get_*() will be ignored if the
1009 * ACPI defines a different default state. So explicitly set low.
1010 */
1011 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1012 cs35l56_wait_min_reset_pulse();
1013 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1);
1014 }
1015
1016 ret = cs35l56_hw_init(&cs35l56->base);
1017 if (ret < 0)
1018 goto err;
1019
1020 /* Reset the device and wait for it to boot */
1021 cs35l56_system_reset(&cs35l56->base, false);
1022 ret = cs35l56_wait_for_firmware_boot(&cs35l56->base);
1023 if (ret)
1024 goto err;
1025
1026 regcache_cache_only(cs35l56->base.regmap, false);
1027
1028 ret = cs35l56_set_patch(&cs35l56->base);
1029 if (ret)
1030 goto err;
1031
1032 regcache_mark_dirty(cs35l56->base.regmap);
1033 regcache_sync(cs35l56->base.regmap);
1034
1035 /* Disable auto-hibernate so that runtime_pm has control */
1036 ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_PREVENT_AUTO_HIBERNATE);
1037 if (ret)
1038 goto err;
1039
1040 ret = cs35l56_get_calibration(&cs35l56->base);
1041 if (ret)
1042 goto err;
1043
1044 ret = cs_dsp_halo_init(&cs35l56->cs_dsp);
1045 if (ret) {
1046 dev_err_probe(cs35l56->base.dev, ret, "cs_dsp_halo_init failed\n");
1047 goto err;
1048 }
1049
1050 dev_info(cs35l56->base.dev, "DSP system name: '%s', amp name: '%s'\n",
1051 cs35l56->system_name, cs35l56->amp_name);
1052
1053 regmap_multi_reg_write(cs35l56->base.regmap, cs35l56_hda_dai_config,
1054 ARRAY_SIZE(cs35l56_hda_dai_config));
1055
1056 /*
1057 * By default only enable one ASP1TXn, where n=amplifier index,
1058 * This prevents multiple amps trying to drive the same slot.
1059 */
1060 cs35l56->asp_tx_mask = BIT(cs35l56->index);
1061
1062 pm_runtime_set_autosuspend_delay(cs35l56->base.dev, 3000);
1063 pm_runtime_use_autosuspend(cs35l56->base.dev);
1064 pm_runtime_set_active(cs35l56->base.dev);
1065 pm_runtime_mark_last_busy(cs35l56->base.dev);
1066 pm_runtime_enable(cs35l56->base.dev);
1067
1068 cs35l56->base.init_done = true;
1069
1070 ret = component_add(cs35l56->base.dev, &cs35l56_hda_comp_ops);
1071 if (ret) {
1072 dev_err(cs35l56->base.dev, "Register component failed: %d\n", ret);
1073 goto pm_err;
1074 }
1075
1076 return 0;
1077
1078 pm_err:
1079 pm_runtime_disable(cs35l56->base.dev);
1080 cs_dsp_remove(&cs35l56->cs_dsp);
1081 err:
1082 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1083
1084 return ret;
1085 }
1086 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_common_probe, "SND_HDA_SCODEC_CS35L56");
1087
cs35l56_hda_remove(struct device * dev)1088 void cs35l56_hda_remove(struct device *dev)
1089 {
1090 struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
1091
1092 component_del(cs35l56->base.dev, &cs35l56_hda_comp_ops);
1093
1094 pm_runtime_dont_use_autosuspend(cs35l56->base.dev);
1095 pm_runtime_get_sync(cs35l56->base.dev);
1096 pm_runtime_disable(cs35l56->base.dev);
1097
1098 cs_dsp_remove(&cs35l56->cs_dsp);
1099
1100 kfree(cs35l56->system_name);
1101 pm_runtime_put_noidle(cs35l56->base.dev);
1102
1103 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1104 }
1105 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_remove, "SND_HDA_SCODEC_CS35L56");
1106
1107 const struct dev_pm_ops cs35l56_hda_pm_ops = {
1108 RUNTIME_PM_OPS(cs35l56_hda_runtime_suspend, cs35l56_hda_runtime_resume, NULL)
1109 SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend, cs35l56_hda_system_resume)
1110 LATE_SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend_late,
1111 cs35l56_hda_system_resume_early)
1112 NOIRQ_SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend_no_irq,
1113 cs35l56_hda_system_resume_no_irq)
1114 };
1115 EXPORT_SYMBOL_NS_GPL(cs35l56_hda_pm_ops, "SND_HDA_SCODEC_CS35L56");
1116
1117 MODULE_DESCRIPTION("CS35L56 HDA Driver");
1118 MODULE_IMPORT_NS("FW_CS_DSP");
1119 MODULE_IMPORT_NS("SND_HDA_CIRRUS_SCODEC");
1120 MODULE_IMPORT_NS("SND_SOC_CS35L56_SHARED");
1121 MODULE_IMPORT_NS("SND_SOC_CS_AMP_LIB");
1122 MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>");
1123 MODULE_AUTHOR("Simon Trimmer <simont@opensource.cirrus.com>");
1124 MODULE_LICENSE("GPL");
1125