sound/soc/soc-core.c

Bug Summary

File:	sound/soc/soc-core.c
Warning:	line 236, column 7 Copies out a struct with a partially unsanitized field

Annotated Source Code

* soc-core.c -- ALSA SoC Audio Layer

* Author: Liam Girdwood <[email protected]>

* with code, comments and ideas from :-

* Richard Purdie <[email protected]>

* This program is free software; you can redistribute it and/or modify it

* under the terms of the GNU General Public License as published by the

* Free Software Foundation; either version 2 of the License, or (at your

* option) any later version.

* TODO:

* o Add hw rules to enforce rates, etc.

* o More testing with other codecs/machines.

* o Add more codecs and platforms to ensure good API coverage.

* o Support TDM on PCM and I2S

#include <linux1/module.h>

#include <linux1/moduleparam.h>

#include <linux1/init.h>

#include <linux1/delay.h>

#include <linux1/pm.h>

#include <linux1/bitops.h>

#include <linux1/debugfs.h>

#include <linux1/platform_device.h>

#include <linux1/pinctrl/consumer.h>

#include <linux1/ctype.h>

#include <linux1/slab.h>

#include <linux1/of.h>

#include <sound/core.h>

#include <sound/jack.h>

#include <sound/pcm.h>

#include <sound/pcm_params.h>

#include <sound/soc.h>

#include <sound/soc-dpcm.h>

#include <sound/soc-topology.h>

#include <sound/initval.h>

#define CREATE_TRACE_POINTS

#include <trace/events/asoc.h>

#define NAME_SIZE32 32

#ifdef CONFIG_DEBUG_FS1

struct dentry *snd_soc_debugfs_root;

EXPORT_SYMBOL_GPL(snd_soc_debugfs_root)extern typeof(snd_soc_debugfs_root) snd_soc_debugfs_root; extern
void *__crc_snd_soc_debugfs_root __attribute__((weak)); static
const unsigned long __kcrctab_snd_soc_debugfs_root __attribute__
((__used__)) __attribute__((section("___kcrctab" "_gpl" "+" "snd_soc_debugfs_root"
), used)) = (unsigned long) &__crc_snd_soc_debugfs_root; static
const char __kstrtab_snd_soc_debugfs_root[] __attribute__((section
("__ksymtab_strings"), aligned(1))) = "snd_soc_debugfs_root";
static const struct kernel_symbol __ksymtab_snd_soc_debugfs_root
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_debugfs_root"), used)) = { (unsigned long
)&snd_soc_debugfs_root, __kstrtab_snd_soc_debugfs_root };

#endif

static DEFINE_MUTEX(client_mutex)struct mutex client_mutex = { .count = { (1) } , .wait_lock =
(spinlock_t ) { { .rlock = { .raw_lock = { { (0) } }, .magic
= 0xdead4ead, .owner_cpu = -1, .owner = ((void *)-1L), .dep_map
= { .name = "client_mutex.wait_lock" } } } } , .wait_list = {
&(client_mutex.wait_list), &(client_mutex.wait_list)
} , .magic = &client_mutex , .dep_map = { .name = "client_mutex"
} };

static LIST_HEAD(platform_list)struct list_head platform_list = { &(platform_list), &
(platform_list) };

static LIST_HEAD(codec_list)struct list_head codec_list = { &(codec_list), &(codec_list
) };

static LIST_HEAD(component_list)struct list_head component_list = { &(component_list), &
(component_list) };

* This is a timeout to do a DAPM powerdown after a stream is closed().

* It can be used to eliminate pops between different playback streams, e.g.

* between two audio tracks.

static int pmdown_time = 5000;

module_param(pmdown_time, int, 0)static inline __attribute__((no_instrument_function)) int __attribute__
((unused)) *__check_pmdown_time(void) { return(&(pmdown_time
)); }; static const char __param_str_pmdown_time[] = "snd_soc_core"
"." "pmdown_time"; static struct kernel_param const __param_pmdown_time
__attribute__((__used__)) __attribute__ ((unused,__section__
("__param"),aligned(sizeof(void *)))) = { __param_str_pmdown_time
, ((struct module *)0), &param_ops_int, ((sizeof(struct {
int:-!!((0) < 0); })) + (sizeof(struct { int:-!!((0) >
0777); })) + (sizeof(struct { int:-!!((((0) >> 6) &
4) < (((0) >> 3) & 4)); })) + (sizeof(struct { int
:-!!((((0) >> 3) & 4) < ((0) & 4)); })) + (sizeof
(struct { int:-!!((((0) >> 6) & 2) < (((0) >>
3) & 2)); })) + (sizeof(struct { int:-!!((0) & 2); }
)) + (0)), -1, 0, { &pmdown_time } }; struct __UNIQUE_ID_pmdown_timetype28
{};

MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)")struct __UNIQUE_ID_pmdown_time29 {};

/* returns the minimum number of bytes needed to represent

* a particular given value */

static int min_bytes_needed(unsigned long val)

{

int c = 0;

int i;

for (i = (sizeof val * 8) - 1; i >= 0; --i, ++c)

if (val & (1UL << i))

break;

c = (sizeof val * 8) - c;

if (!c || (c % 8))

c = (c + 8) / 8;

else

c /= 8;

return c;

}

/* fill buf which is 'len' bytes with a formatted

* string of the form 'reg: value\n' */

static int format_register_str(struct snd_soc_codec *codec,

unsigned int reg, char *buf, size_t len)

{

int wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;

int regsize = codec->driver->reg_word_size * 2;

int ret;

/* +2 for ': ' and + 1 for '\n' */

if (wordsize + regsize + 2 + 1 != len)

←

Taking false branch

→

return -EINVAL22;

100

101

sprintf(buf, "%.*x: ", wordsize, reg);

←

Partial initialization occurs here

→

102

buf += wordsize + 2;

103

104

ret = snd_soc_read(codec, reg);

105

if (ret < 0)

←

Taking false branch

→

106

memset(buf, 'X', regsize);

107

else

108

sprintf(buf, "%.*x", regsize, ret);

109

buf[regsize] = '\n';

110

/* no NUL-termination needed */

111

return 0;

112

}

113

114

/* codec register dump */

115

static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf,

116

size_t count, loff_t pos)

117

{

118

int i, step = 1;

119

int wordsize, regsize;

120

int len;

121

size_t total = 0;

122

loff_t p = 0;

123

124

wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;

125

regsize = codec->driver->reg_word_size * 2;

126

127

len = wordsize + regsize + 2 + 1;

128

129

if (!codec->driver->reg_cache_size)

←

Taking false branch

→

130

return 0;

131

132

if (codec->driver->reg_cache_step)

←

Taking false branch

→

133

step = codec->driver->reg_cache_step;

134

135

for (i = 0; i < codec->driver->reg_cache_size; i += step) {

←

Loop condition is true. Entering loop body

→

←

Loop condition is true. Entering loop body

→

←

Loop condition is false. Execution continues on line 147

→

136

/* only support larger than PAGE_SIZE bytes debugfs

137

* entries for the default case */

138

if (p >= pos) {

←

Assuming 'p' is >= 'pos'

Taking true branch

Assuming 'p' is >= 'pos'

→

←

Taking true branch

→

139

if (total + len >= count - 1)

Taking false branch

Taking false branch

140

break;

141

format_register_str(codec, i, buf + total, len);

←

Calling 'format_register_str'

→

←

Returning from 'format_register_str'

→

142

total += len;

143

}

144

p += len;

145

}

146

147

total = min(total, count - 1)({ typeof(total) __UNIQUE_ID_min1_30 = (total); typeof(count -
1) __UNIQUE_ID_min2_31 = (count - 1); (void) (&__UNIQUE_ID_min1_30
== &__UNIQUE_ID_min2_31); __UNIQUE_ID_min1_30 < __UNIQUE_ID_min2_31
? __UNIQUE_ID_min1_30 : __UNIQUE_ID_min2_31; });

148

149

return total;

150

}

151

152

static ssize_t codec_reg_show(struct device *dev,

153

struct device_attribute *attr, char *buf)

154

{

155

struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);

156

157

return soc_codec_reg_show(rtd->codec, buf, PAGE_SIZE((1UL) << 12), 0);

158

}

159

160

static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL)struct device_attribute dev_attr_codec_reg = { .attr = {.name
= "codec_reg", .mode = ((sizeof(struct { int:-!!((0444) <
0); })) + (sizeof(struct { int:-!!((0444) > 0777); })) + (
sizeof(struct { int:-!!((((0444) >> 6) & 4) < ((
(0444) >> 3) & 4)); })) + (sizeof(struct { int:-!!(
(((0444) >> 3) & 4) < ((0444) & 4)); })) + (
sizeof(struct { int:-!!((((0444) >> 6) & 2) < ((
(0444) >> 3) & 2)); })) + (sizeof(struct { int:-!!(
(0444) & 2); })) + (0444)) }, .show = codec_reg_show, .store
= ((void *)0), };

161

162

static ssize_t pmdown_time_show(struct device *dev,

163

struct device_attribute *attr, char *buf)

164

{

165

struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);

166

167

return sprintf(buf, "%ld\n", rtd->pmdown_time);

168

}

169

170

static ssize_t pmdown_time_set(struct device *dev,

171

struct device_attribute *attr,

172

const char *buf, size_t count)

173

{

174

struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);

175

int ret;

176

177

ret = kstrtol(buf, 10, &rtd->pmdown_time);

178

if (ret)

179

return ret;

180

181

return count;

182

}

183

184

static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set)struct device_attribute dev_attr_pmdown_time = { .attr = {.name
= "pmdown_time", .mode = ((sizeof(struct { int:-!!((0644) <
0); })) + (sizeof(struct { int:-!!((0644) > 0777); })) + (
sizeof(struct { int:-!!((((0644) >> 6) & 4) < ((
(0644) >> 3) & 4)); })) + (sizeof(struct { int:-!!(
(((0644) >> 3) & 4) < ((0644) & 4)); })) + (
sizeof(struct { int:-!!((((0644) >> 6) & 2) < ((
(0644) >> 3) & 2)); })) + (sizeof(struct { int:-!!(
(0644) & 2); })) + (0644)) }, .show = pmdown_time_show, .
store = pmdown_time_set, };

185

186

static struct attribute *soc_dev_attrs[] = {

187

&dev_attr_codec_reg.attr,

188

&dev_attr_pmdown_time.attr,

189

NULL((void *)0)

190

};

191

192

static umode_t soc_dev_attr_is_visible(struct kobject *kobj,

193

struct attribute *attr, int idx)

194

{

195

struct device *dev = kobj_to_dev(kobj);

196

struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);

197

198

if (attr == &dev_attr_pmdown_time.attr)

199

return attr->mode; /* always visible */

200

return rtd->codec ? attr->mode : 0; /* enabled only with codec */

201

}

202

203

static const struct attribute_group soc_dapm_dev_group = {

204

.attrs = soc_dapm_dev_attrs,

205

.is_visible = soc_dev_attr_is_visible,

206

};

207

208

static const struct attribute_group soc_dev_roup = {

209

.attrs = soc_dev_attrs,

210

.is_visible = soc_dev_attr_is_visible,

211

};

212

213

static const struct attribute_group *soc_dev_attr_groups[] = {

214

&soc_dapm_dev_group,

215

&soc_dev_roup,

216

NULL((void *)0)

217

};

218

219

#ifdef CONFIG_DEBUG_FS1

220

static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,

221

size_t count, loff_t *ppos)

222

{

223

ssize_t ret;

224

struct snd_soc_codec *codec = file->private_data;

225

char *buf;

226

227

if (*ppos < 0 || !count)

Assuming 'count' is not equal to 0

→

←

Taking false branch

→

228

return -EINVAL22;

229

230

buf = kmalloc(count, GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)));

231

if (!buf)

←

Assuming 'buf' is non-null

→

←

Taking false branch

→

232

return -ENOMEM12;

233

234

ret = soc_codec_reg_show(codec, buf, count, *ppos);

←

Calling 'soc_codec_reg_show'

→

←

Returning from 'soc_codec_reg_show'

→

235

if (ret >= 0) {

←

Taking true branch

→

236

if (copy_to_user(user_buf, buf, ret)) {

←

Copies out a struct with a partially unsanitized field

237

kfree(buf);

238

return -EFAULT14;

239

}

240

*ppos += ret;

241

}

242

243

kfree(buf);

244

return ret;

245

}

246

247

static ssize_t codec_reg_write_file(struct file *file,

248

const char __user *user_buf, size_t count, loff_t *ppos)

249

{

250

char buf[32];

251

size_t buf_size;

252

char *start = buf;

253

unsigned long reg, value;

254

struct snd_soc_codec *codec = file->private_data;

255

int ret;

256

257

buf_size = min(count, (sizeof(buf)-1))({ typeof(count) __UNIQUE_ID_min1_32 = (count); typeof((sizeof
(buf)-1)) __UNIQUE_ID_min2_33 = ((sizeof(buf)-1)); (void) (&
__UNIQUE_ID_min1_32 == &__UNIQUE_ID_min2_33); __UNIQUE_ID_min1_32
< __UNIQUE_ID_min2_33 ? __UNIQUE_ID_min1_32 : __UNIQUE_ID_min2_33
; });

258

if (copy_from_user(buf, user_buf, buf_size))

259

return -EFAULT14;

260

buf[buf_size] = 0;

261

262

while (*start == ' ')

263

start++;

264

reg = simple_strtoul(start, &start, 16);

265

while (*start == ' ')

266

start++;

267

ret = kstrtoul(start, 16, &value);

268

if (ret)

269

return ret;

270

271

/* Userspace has been fiddling around behind the kernel's back */

272

add_taint(TAINT_USER6, LOCKDEP_NOW_UNRELIABLE);

273

274

snd_soc_write(codec, reg, value);

275

return buf_size;

276

}

277

278

static const struct file_operations codec_reg_fops = {

279

.open = simple_open,

280

.read = codec_reg_read_file,

281

.write = codec_reg_write_file,

282

.llseek = default_llseek,

283

};

284

285

static void soc_init_component_debugfs(struct snd_soc_component *component)

286

{

287

if (!component->card->debugfs_card_root)

288

return;

289

290

if (component->debugfs_prefix) {

291

char *name;

292

293

name = kasprintf(GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)), "%s:%s",

294

component->debugfs_prefix, component->name);

295

if (name) {

296

component->debugfs_root = debugfs_create_dir(name,

297

component->card->debugfs_card_root);

298

kfree(name);

299

}

300

} else {

301

component->debugfs_root = debugfs_create_dir(component->name,

302

component->card->debugfs_card_root);

303

}

304

305

if (!component->debugfs_root) {

306

dev_warn(component->dev,

307

"ASoC: Failed to create component debugfs directory\n");

308

return;

309

}

310

311

snd_soc_dapm_debugfs_init(snd_soc_component_get_dapm(component),

312

component->debugfs_root);

313

314

if (component->init_debugfs)

315

component->init_debugfs(component);

316

}

317

318

static void soc_cleanup_component_debugfs(struct snd_soc_component *component)

319

{

320

debugfs_remove_recursive(component->debugfs_root);

321

}

322

323

static void soc_init_codec_debugfs(struct snd_soc_component *component)

324

{

325

struct snd_soc_codec *codec = snd_soc_component_to_codec(component);

326

327

codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,

328

codec->component.debugfs_root,

329

codec, &codec_reg_fops);

330

if (!codec->debugfs_reg)

331

dev_warn(codec->dev,

332

"ASoC: Failed to create codec register debugfs file\n");

333

}

334

335

static ssize_t codec_list_read_file(struct file *file, char __user *user_buf,

336

size_t count, loff_t *ppos)

337

{

338

char *buf = kmalloc(PAGE_SIZE((1UL) << 12), GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)));

339

ssize_t len, ret = 0;

340

struct snd_soc_codec *codec;

341

342

if (!buf)

343

return -ENOMEM12;

344

345

mutex_lock(&client_mutex)mutex_lock_nested(&client_mutex, 0);

346

347

list_for_each_entry(codec, &codec_list, list)for (codec = ({ const typeof( ((typeof(*codec) *)0)->list )
*__mptr = ((&codec_list)->next); (typeof(*codec) *)( (
char *)__mptr - __builtin_offsetof(typeof(*codec), list) );})
; &codec->list != (&codec_list); codec = ({ const typeof
( ((typeof(*(codec)) *)0)->list ) *__mptr = ((codec)->list
.next); (typeof(*(codec)) *)( (char *)__mptr - __builtin_offsetof
(typeof(*(codec)), list) );})) {

348

len = snprintf(buf + ret, PAGE_SIZE((1UL) << 12) - ret, "%s\n",

349

codec->component.name);

350

if (len >= 0)

351

ret += len;

352

if (ret > PAGE_SIZE((1UL) << 12)) {

353

ret = PAGE_SIZE((1UL) << 12);

354

break;

355

}

356

}

357

358

mutex_unlock(&client_mutex);

359

360

if (ret >= 0)

361

ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);

362

363

kfree(buf);

364

365

return ret;

366

}

367

368

static const struct file_operations codec_list_fops = {

369

.read = codec_list_read_file,

370

.llseek = default_llseek,/* read accesses f_pos */

371

};

372

373

static ssize_t dai_list_read_file(struct file *file, char __user *user_buf,

374

size_t count, loff_t *ppos)

375

{

376

char *buf = kmalloc(PAGE_SIZE((1UL) << 12), GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)));

377

ssize_t len, ret = 0;

378

struct snd_soc_component *component;

379

struct snd_soc_dai *dai;

380

381

if (!buf)

382

return -ENOMEM12;

383

384

mutex_lock(&client_mutex)mutex_lock_nested(&client_mutex, 0);

385

386

list_for_each_entry(component, &component_list, list)for (component = ({ const typeof( ((typeof(*component) *)0)->
list ) *__mptr = ((&component_list)->next); (typeof(*component
) *)( (char *)__mptr - __builtin_offsetof(typeof(*component),
list) );}); &component->list != (&component_list)
; component = ({ const typeof( ((typeof(*(component)) *)0)->
list ) *__mptr = ((component)->list.next); (typeof(*(component
)) *)( (char *)__mptr - __builtin_offsetof(typeof(*(component
)), list) );})) {

387

list_for_each_entry(dai, &component->dai_list, list)for (dai = ({ const typeof( ((typeof(*dai) *)0)->list ) *__mptr
= ((&component->dai_list)->next); (typeof(*dai) *)
( (char *)__mptr - __builtin_offsetof(typeof(*dai), list) );}
); &dai->list != (&component->dai_list); dai = (
{ const typeof( ((typeof(*(dai)) *)0)->list ) *__mptr = ((
dai)->list.next); (typeof(*(dai)) *)( (char *)__mptr - __builtin_offsetof
(typeof(*(dai)), list) );})) {

388

len = snprintf(buf + ret, PAGE_SIZE((1UL) << 12) - ret, "%s\n",

389

dai->name);

390

if (len >= 0)

391

ret += len;

392

if (ret > PAGE_SIZE((1UL) << 12)) {

393

ret = PAGE_SIZE((1UL) << 12);

394

break;

395

}

396

}

397

}

398

399

mutex_unlock(&client_mutex);

400

401

ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);

402

403

kfree(buf);

404

405

return ret;

406

}

407

408

static const struct file_operations dai_list_fops = {

409

.read = dai_list_read_file,

410

.llseek = default_llseek,/* read accesses f_pos */

411

};

412

413

static ssize_t platform_list_read_file(struct file *file,

414

char __user *user_buf,

415

size_t count, loff_t *ppos)

416

{

417

char *buf = kmalloc(PAGE_SIZE((1UL) << 12), GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)));

418

ssize_t len, ret = 0;

419

struct snd_soc_platform *platform;

420

421

if (!buf)

422

return -ENOMEM12;

423

424

mutex_lock(&client_mutex)mutex_lock_nested(&client_mutex, 0);

425

426

list_for_each_entry(platform, &platform_list, list)for (platform = ({ const typeof( ((typeof(*platform) *)0)->
list ) *__mptr = ((&platform_list)->next); (typeof(*platform
) *)( (char *)__mptr - __builtin_offsetof(typeof(*platform), list
) );}); &platform->list != (&platform_list); platform
= ({ const typeof( ((typeof(*(platform)) *)0)->list ) *__mptr
= ((platform)->list.next); (typeof(*(platform)) *)( (char
*)__mptr - __builtin_offsetof(typeof(*(platform)), list) );}
)) {

427

len = snprintf(buf + ret, PAGE_SIZE((1UL) << 12) - ret, "%s\n",

428

platform->component.name);

429

if (len >= 0)

430

ret += len;

431

if (ret > PAGE_SIZE((1UL) << 12)) {

432

ret = PAGE_SIZE((1UL) << 12);

433

break;

434

}

435

}

436

437

mutex_unlock(&client_mutex);

438

439

ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);

440

441

kfree(buf);

442

443

return ret;

444

}

445

446

static const struct file_operations platform_list_fops = {

447

.read = platform_list_read_file,

448

.llseek = default_llseek,/* read accesses f_pos */

449

};

450

451

static void soc_init_card_debugfs(struct snd_soc_card *card)

452

{

453

if (!snd_soc_debugfs_root)

454

return;

455

456

card->debugfs_card_root = debugfs_create_dir(card->name,

457

snd_soc_debugfs_root);

458

if (!card->debugfs_card_root) {

459

dev_warn(card->dev,

460

"ASoC: Failed to create card debugfs directory\n");

461

return;

462

}

463

464

card->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,

465

card->debugfs_card_root,

466

&card->pop_time);

467

if (!card->debugfs_pop_time)

468

dev_warn(card->dev,

469

"ASoC: Failed to create pop time debugfs file\n");

470

}

471

472

static void soc_cleanup_card_debugfs(struct snd_soc_card *card)

473

{

474

debugfs_remove_recursive(card->debugfs_card_root);

475

}

476

477

478

static void snd_soc_debugfs_init(void)

479

{

480

snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL((void *)0));

481

if (IS_ERR(snd_soc_debugfs_root) || !snd_soc_debugfs_root) {

482

pr_warn("ASoC: Failed to create debugfs directory\n")printk("\001" "4" "ASoC: Failed to create debugfs directory\n"
);

483

snd_soc_debugfs_root = NULL((void *)0);

484

return;

485

}

486

487

if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL((void *)0),

488

&codec_list_fops))

489

pr_warn("ASoC: Failed to create CODEC list debugfs file\n")printk("\001" "4" "ASoC: Failed to create CODEC list debugfs file\n"
);

490

491

if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL((void *)0),

492

&dai_list_fops))

493

pr_warn("ASoC: Failed to create DAI list debugfs file\n")printk("\001" "4" "ASoC: Failed to create DAI list debugfs file\n"
);

494

495

if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL((void *)0),

496

&platform_list_fops))

497

pr_warn("ASoC: Failed to create platform list debugfs file\n")printk("\001" "4" "ASoC: Failed to create platform list debugfs file\n"
);

498

}

499

500

static void snd_soc_debugfs_exit(void)

501

{

502

debugfs_remove_recursive(snd_soc_debugfs_root);

503

}

504

505

#else

506

507

#define soc_init_codec_debugfs NULL((void *)0)

508

509

static inlineinline __attribute__((no_instrument_function)) void soc_init_component_debugfs(

510

struct snd_soc_component *component)

511

{

512

}

513

514

static inlineinline __attribute__((no_instrument_function)) void soc_cleanup_component_debugfs(

515

struct snd_soc_component *component)

516

{

517

}

518

519

static inlineinline __attribute__((no_instrument_function)) void soc_init_card_debugfs(struct snd_soc_card *card)

520

{

521

}

522

523

static inlineinline __attribute__((no_instrument_function)) void soc_cleanup_card_debugfs(struct snd_soc_card *card)

524

{

525

}

526

527

static inlineinline __attribute__((no_instrument_function)) void snd_soc_debugfs_init(void)

528

{

529

}

530

531

static inlineinline __attribute__((no_instrument_function)) void snd_soc_debugfs_exit(void)

532

{

533

}

534

535

#endif

536

537

struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,

538

const char *dai_link, int stream)

539

{

540

struct snd_soc_pcm_runtime *rtd;

541

542

list_for_each_entry(rtd, &card->rtd_list, list)for (rtd = ({ const typeof( ((typeof(*rtd) *)0)->list ) *__mptr
= ((&card->rtd_list)->next); (typeof(*rtd) *)( (char
*)__mptr - __builtin_offsetof(typeof(*rtd), list) );}); &
rtd->list != (&card->rtd_list); rtd = ({ const typeof
( ((typeof(*(rtd)) *)0)->list ) *__mptr = ((rtd)->list.
next); (typeof(*(rtd)) *)( (char *)__mptr - __builtin_offsetof
(typeof(*(rtd)), list) );})) {

543

if (rtd->dai_link->no_pcm &&

544

!strcmp(rtd->dai_link->name, dai_link))

545

return rtd->pcm->streams[stream].substream;

546

}

547

dev_dbg(card->dev, "ASoC: failed to find dai link %s\n", dai_link)do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: failed to find dai link %s\n"), .lineno = 547
, .flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, card->dev, "ASoC: failed to find dai link %s\n"
, dai_link); } while (0); } while (0);

548

return NULL((void *)0);

549

}

550

EXPORT_SYMBOL_GPL(snd_soc_get_dai_substream)extern typeof(snd_soc_get_dai_substream) snd_soc_get_dai_substream
; extern void *__crc_snd_soc_get_dai_substream __attribute__(
(weak)); static const unsigned long __kcrctab_snd_soc_get_dai_substream
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_get_dai_substream"), used)) = (unsigned long
) &__crc_snd_soc_get_dai_substream; static const char __kstrtab_snd_soc_get_dai_substream
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_get_dai_substream"; static const struct kernel_symbol
__ksymtab_snd_soc_get_dai_substream __attribute__((__used__)
) __attribute__((section("___ksymtab" "_gpl" "+" "snd_soc_get_dai_substream"
), used)) = { (unsigned long)&snd_soc_get_dai_substream, __kstrtab_snd_soc_get_dai_substream
};

551

552

static struct snd_soc_pcm_runtime *soc_new_pcm_runtime(

553

struct snd_soc_card *card, struct snd_soc_dai_link *dai_link)

554

{

555

struct snd_soc_pcm_runtime *rtd;

556

557

rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime), GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)));

558

if (!rtd)

559

return NULL((void *)0);

560

561

rtd->card = card;

562

rtd->dai_link = dai_link;

563

rtd->codec_dais = kzalloc(sizeof(struct snd_soc_dai *) *

564

dai_link->num_codecs,

565

GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)));

566

if (!rtd->codec_dais) {

567

kfree(rtd);

568

return NULL((void *)0);

569

}

570

571

return rtd;

572

}

573

574

static void soc_free_pcm_runtime(struct snd_soc_pcm_runtime *rtd)

575

{

576

if (rtd && rtd->codec_dais)

577

kfree(rtd->codec_dais);

578

kfree(rtd);

579

}

580

581

static void soc_add_pcm_runtime(struct snd_soc_card *card,

582

struct snd_soc_pcm_runtime *rtd)

583

{

584

list_add_tail(&rtd->list, &card->rtd_list);

585

rtd->num = card->num_rtd;

586

card->num_rtd++;

587

}

588

589

static void soc_remove_pcm_runtimes(struct snd_soc_card *card)

590

{

591

struct snd_soc_pcm_runtime *rtd, *_rtd;

592

593

list_for_each_entry_safe(rtd, _rtd, &card->rtd_list, list)for (rtd = ({ const typeof( ((typeof(*rtd) *)0)->list ) *__mptr
= ((&card->rtd_list)->next); (typeof(*rtd) *)( (char
*)__mptr - __builtin_offsetof(typeof(*rtd), list) );}), _rtd
= ({ const typeof( ((typeof(*(rtd)) *)0)->list ) *__mptr =
((rtd)->list.next); (typeof(*(rtd)) *)( (char *)__mptr - __builtin_offsetof
(typeof(*(rtd)), list) );}); &rtd->list != (&card->
rtd_list); rtd = _rtd, _rtd = ({ const typeof( ((typeof(*(_rtd
)) *)0)->list ) *__mptr = ((_rtd)->list.next); (typeof(
*(_rtd)) *)( (char *)__mptr - __builtin_offsetof(typeof(*(_rtd
)), list) );})) {

594

list_del(&rtd->list);

595

soc_free_pcm_runtime(rtd);

596

}

597

598

card->num_rtd = 0;

599

}

600

601

struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,

602

const char *dai_link)

603

{

604

struct snd_soc_pcm_runtime *rtd;

605

606

607

if (!strcmp(rtd->dai_link->name, dai_link))

608

return rtd;

609

}

610

dev_dbg(card->dev, "ASoC: failed to find rtd %s\n", dai_link)do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: failed to find rtd %s\n"), .lineno = 610, .flags
= 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, card->dev, "ASoC: failed to find rtd %s\n"
, dai_link); } while (0); } while (0);

611

return NULL((void *)0);

612

}

613

EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime)extern typeof(snd_soc_get_pcm_runtime) snd_soc_get_pcm_runtime
; extern void *__crc_snd_soc_get_pcm_runtime __attribute__((weak
)); static const unsigned long __kcrctab_snd_soc_get_pcm_runtime
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_get_pcm_runtime"), used)) = (unsigned long
) &__crc_snd_soc_get_pcm_runtime; static const char __kstrtab_snd_soc_get_pcm_runtime
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_get_pcm_runtime"; static const struct kernel_symbol
__ksymtab_snd_soc_get_pcm_runtime __attribute__((__used__)) __attribute__
((section("___ksymtab" "_gpl" "+" "snd_soc_get_pcm_runtime"),
used)) = { (unsigned long)&snd_soc_get_pcm_runtime, __kstrtab_snd_soc_get_pcm_runtime
};

614

615

static void codec2codec_close_delayed_work(struct work_struct *work)

616

{

617

/* Currently nothing to do for c2c links

618

* Since c2c links are internal nodes in the DAPM graph and

619

* don't interface with the outside world or application layer

620

* we don't have to do any special handling on close.

621

622

}

623

624

#ifdef CONFIG_PM_SLEEP1

625

/* powers down audio subsystem for suspend */

626

int snd_soc_suspend(struct device *dev)

627

{

628

struct snd_soc_card *card = dev_get_drvdata(dev);

629

struct snd_soc_codec *codec;

630

struct snd_soc_pcm_runtime *rtd;

631

int i;

632

633

/* If the card is not initialized yet there is nothing to do */

634

if (!card->instantiated)

635

return 0;

636

637

/* Due to the resume being scheduled into a workqueue we could

638

* suspend before that's finished - wait for it to complete.

639

640

snd_power_lock(card->snd_card);

641

snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D00x0000);

642

snd_power_unlock(card->snd_card);

643

644

/* we're going to block userspace touching us until resume completes */

645

snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot(0x0300|0x0000));

646

647

/* mute any active DACs */

648

649

650

if (rtd->dai_link->ignore_suspend)

651

continue;

652

653

for (i = 0; i < rtd->num_codecs; i++) {

654

struct snd_soc_dai *dai = rtd->codec_dais[i];

655

struct snd_soc_dai_driver *drv = dai->driver;

656

657

if (drv->ops->digital_mute && dai->playback_active)

658

drv->ops->digital_mute(dai, 1);

659

}

660

}

661

662

/* suspend all pcms */

663

664

if (rtd->dai_link->ignore_suspend)

665

continue;

666

667

snd_pcm_suspend_all(rtd->pcm);

668

}

669

670

if (card->suspend_pre)

671

card->suspend_pre(card);

672

673

674

struct snd_soc_dai *cpu_dai = rtd->cpu_dai;

675

676

if (rtd->dai_link->ignore_suspend)

677

continue;

678

679

if (cpu_dai->driver->suspend && !cpu_dai->driver->bus_control)

680

cpu_dai->driver->suspend(cpu_dai);

681

}

682

683

/* close any waiting streams */

684

685

flush_delayed_work(&rtd->delayed_work);

686

687

688

689

if (rtd->dai_link->ignore_suspend)

690

continue;

691

692

snd_soc_dapm_stream_event(rtd,

693

SNDRV_PCM_STREAM_PLAYBACK,

694

SND_SOC_DAPM_STREAM_SUSPEND0x4);

695

696

snd_soc_dapm_stream_event(rtd,

697

SNDRV_PCM_STREAM_CAPTURE,

698

SND_SOC_DAPM_STREAM_SUSPEND0x4);

699

}

700

701

/* Recheck all endpoints too, their state is affected by suspend */

702

dapm_mark_endpoints_dirty(card);

703

snd_soc_dapm_sync(&card->dapm);

704

705

/* suspend all CODECs */

706

list_for_each_entry(codec, &card->codec_dev_list, card_list)for (codec = ({ const typeof( ((typeof(*codec) *)0)->card_list
) *__mptr = ((&card->codec_dev_list)->next); (typeof
(*codec) *)( (char *)__mptr - __builtin_offsetof(typeof(*codec
), card_list) );}); &codec->card_list != (&card->
codec_dev_list); codec = ({ const typeof( ((typeof(*(codec)) *
)0)->card_list ) *__mptr = ((codec)->card_list.next); (
typeof(*(codec)) *)( (char *)__mptr - __builtin_offsetof(typeof
(*(codec)), card_list) );})) {

707

struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);

708

709

/* If there are paths active then the CODEC will be held with

710

* bias _ON and should not be suspended. */

711

if (!codec->suspended) {

712

switch (snd_soc_dapm_get_bias_level(dapm)) {

713

case SND_SOC_BIAS_STANDBY:

714

715

* If the CODEC is capable of idle

716

* bias off then being in STANDBY

717

* means it's doing something,

718

* otherwise fall through.

719

720

if (dapm->idle_bias_off) {

721

dev_dbg(codec->dev,do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: idle_bias_off CODEC on over suspend\n"), .lineno
= 722, .flags = 0, }; if ((descriptor.flags & (1<<
0))) __dynamic_dev_dbg(&descriptor, codec->dev, "ASoC: idle_bias_off CODEC on over suspend\n"
); } while (0); } while (0)

722

"ASoC: idle_bias_off CODEC on over suspend\n")do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: idle_bias_off CODEC on over suspend\n"), .lineno
= 722, .flags = 0, }; if ((descriptor.flags & (1<<
0))) __dynamic_dev_dbg(&descriptor, codec->dev, "ASoC: idle_bias_off CODEC on over suspend\n"
); } while (0); } while (0);

723

break;

724

}

725

726

case SND_SOC_BIAS_OFF:

727

if (codec->driver->suspend)

728

codec->driver->suspend(codec);

729

codec->suspended = 1;

730

if (codec->component.regmap)

731

regcache_mark_dirty(codec->component.regmap);

732

/* deactivate pins to sleep state */

733

pinctrl_pm_select_sleep_state(codec->dev);

734

break;

735

default:

736

dev_dbg(codec->dev,do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: CODEC is on over suspend\n"), .lineno = 737,
.flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, codec->dev, "ASoC: CODEC is on over suspend\n"
); } while (0); } while (0)

737

"ASoC: CODEC is on over suspend\n")do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: CODEC is on over suspend\n"), .lineno = 737,
.flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, codec->dev, "ASoC: CODEC is on over suspend\n"
); } while (0); } while (0);

738

break;

739

}

740

}

741

}

742

743

744

struct snd_soc_dai *cpu_dai = rtd->cpu_dai;

745

746

if (rtd->dai_link->ignore_suspend)

747

continue;

748

749

if (cpu_dai->driver->suspend && cpu_dai->driver->bus_control)

750

cpu_dai->driver->suspend(cpu_dai);

751

752

/* deactivate pins to sleep state */

753

pinctrl_pm_select_sleep_state(cpu_dai->dev);

754

}

755

756

if (card->suspend_post)

757

card->suspend_post(card);

758

759

return 0;

760

}

761

EXPORT_SYMBOL_GPL(snd_soc_suspend)extern typeof(snd_soc_suspend) snd_soc_suspend; extern void *
__crc_snd_soc_suspend __attribute__((weak)); static const unsigned
long __kcrctab_snd_soc_suspend __attribute__((__used__)) __attribute__
((section("___kcrctab" "_gpl" "+" "snd_soc_suspend"), used)) =
(unsigned long) &__crc_snd_soc_suspend; static const char
__kstrtab_snd_soc_suspend[] __attribute__((section("__ksymtab_strings"
), aligned(1))) = "snd_soc_suspend"; static const struct kernel_symbol
__ksymtab_snd_soc_suspend __attribute__((__used__)) __attribute__
((section("___ksymtab" "_gpl" "+" "snd_soc_suspend"), used)) =
{ (unsigned long)&snd_soc_suspend, __kstrtab_snd_soc_suspend
};

762

763

/* deferred resume work, so resume can complete before we finished

764

* setting our codec back up, which can be very slow on I2C

765

766

static void soc_resume_deferred(struct work_struct *work)

767

{

768

struct snd_soc_card *card =

769

container_of(work, struct snd_soc_card, deferred_resume_work)({ const typeof( ((struct snd_soc_card *)0)->deferred_resume_work
) *__mptr = (work); (struct snd_soc_card *)( (char *)__mptr -
__builtin_offsetof(struct snd_soc_card, deferred_resume_work
) );});

770

struct snd_soc_pcm_runtime *rtd;

771

struct snd_soc_codec *codec;

772

int i;

773

774

/* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,

775

* so userspace apps are blocked from touching us

776

777

778

dev_dbg(card->dev, "ASoC: starting resume work\n")do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: starting resume work\n"), .lineno = 778, .flags
= 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, card->dev, "ASoC: starting resume work\n"
); } while (0); } while (0);

779

780

/* Bring us up into D2 so that DAPM starts enabling things */

781

snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D20x0200);

782

783

if (card->resume_pre)

784

card->resume_pre(card);

785

786

/* resume control bus DAIs */

787

788

struct snd_soc_dai *cpu_dai = rtd->cpu_dai;

789

790

if (rtd->dai_link->ignore_suspend)

791

continue;

792

793

if (cpu_dai->driver->resume && cpu_dai->driver->bus_control)

794

cpu_dai->driver->resume(cpu_dai);

795

}

796

797

798

if (codec->suspended) {

799

if (codec->driver->resume)

800

codec->driver->resume(codec);

801

codec->suspended = 0;

802

}

803

}

804

805

806

807

if (rtd->dai_link->ignore_suspend)

808

continue;

809

810

snd_soc_dapm_stream_event(rtd,

811

SNDRV_PCM_STREAM_PLAYBACK,

812

SND_SOC_DAPM_STREAM_RESUME0x8);

813

814

snd_soc_dapm_stream_event(rtd,

815

SNDRV_PCM_STREAM_CAPTURE,

816

SND_SOC_DAPM_STREAM_RESUME0x8);

817

}

818

819

/* unmute any active DACs */

820

821

822

if (rtd->dai_link->ignore_suspend)

823

continue;

824

825

for (i = 0; i < rtd->num_codecs; i++) {

826

struct snd_soc_dai *dai = rtd->codec_dais[i];

827

struct snd_soc_dai_driver *drv = dai->driver;

828

829

if (drv->ops->digital_mute && dai->playback_active)

830

drv->ops->digital_mute(dai, 0);

831

}

832

}

833

834

835

struct snd_soc_dai *cpu_dai = rtd->cpu_dai;

836

837

if (rtd->dai_link->ignore_suspend)

838

continue;

839

840

if (cpu_dai->driver->resume && !cpu_dai->driver->bus_control)

841

cpu_dai->driver->resume(cpu_dai);

842

}

843

844

if (card->resume_post)

845

card->resume_post(card);

846

847

dev_dbg(card->dev, "ASoC: resume work completed\n")do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: resume work completed\n"), .lineno = 847, .flags
= 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, card->dev, "ASoC: resume work completed\n"
); } while (0); } while (0);

848

849

/* Recheck all endpoints too, their state is affected by suspend */

850

dapm_mark_endpoints_dirty(card);

851

snd_soc_dapm_sync(&card->dapm);

852

853

/* userspace can access us now we are back as we were before */

854

snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D00x0000);

855

}

856

857

/* powers up audio subsystem after a suspend */

858

int snd_soc_resume(struct device *dev)

859

{

860

struct snd_soc_card *card = dev_get_drvdata(dev);

861

bool bus_control = false;

862

struct snd_soc_pcm_runtime *rtd;

863

864

/* If the card is not initialized yet there is nothing to do */

865

if (!card->instantiated)

866

return 0;

867

868

/* activate pins from sleep state */

869

870

struct snd_soc_dai **codec_dais = rtd->codec_dais;

871

struct snd_soc_dai *cpu_dai = rtd->cpu_dai;

872

int j;

873

874

if (cpu_dai->active)

875

pinctrl_pm_select_default_state(cpu_dai->dev);

876

877

for (j = 0; j < rtd->num_codecs; j++) {

878

struct snd_soc_dai *codec_dai = codec_dais[j];

879

if (codec_dai->active)

880

pinctrl_pm_select_default_state(codec_dai->dev);

881

}

882

}

883

884

885

* DAIs that also act as the control bus master might have other drivers

886

* hanging off them so need to resume immediately. Other drivers don't

887

* have that problem and may take a substantial amount of time to resume

888

* due to I/O costs and anti-pop so handle them out of line.

889

890

891

struct snd_soc_dai *cpu_dai = rtd->cpu_dai;

892

bus_control |= cpu_dai->driver->bus_control;

893

}

894

if (bus_control) {

895

dev_dbg(dev, "ASoC: Resuming control bus master immediately\n")do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: Resuming control bus master immediately\n"),
.lineno = 895, .flags = 0, }; if ((descriptor.flags & (1
<<0))) __dynamic_dev_dbg(&descriptor, dev, "ASoC: Resuming control bus master immediately\n"
); } while (0); } while (0);

896

soc_resume_deferred(&card->deferred_resume_work);

897

} else {

898

dev_dbg(dev, "ASoC: Scheduling resume work\n")do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: Scheduling resume work\n"), .lineno = 898, .
flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, dev, "ASoC: Scheduling resume work\n"); } while
(0); } while (0);

899

if (!schedule_work(&card->deferred_resume_work))

900

dev_err(dev, "ASoC: resume work item may be lost\n");

901

}

902

903

return 0;

904

}

905

EXPORT_SYMBOL_GPL(snd_soc_resume)extern typeof(snd_soc_resume) snd_soc_resume; extern void *__crc_snd_soc_resume
__attribute__((weak)); static const unsigned long __kcrctab_snd_soc_resume
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_resume"), used)) = (unsigned long) &
__crc_snd_soc_resume; static const char __kstrtab_snd_soc_resume
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_resume"; static const struct kernel_symbol __ksymtab_snd_soc_resume
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_resume"), used)) = { (unsigned long)&
snd_soc_resume, __kstrtab_snd_soc_resume };

906

#else

907

#define snd_soc_suspend NULL((void *)0)

908

#define snd_soc_resume NULL((void *)0)

909

#endif

910

911

static const struct snd_soc_dai_ops null_dai_ops = {

912

};

913

914

static struct snd_soc_component *soc_find_component(

915

const struct device_node *of_node, const char *name)

916

{

917

struct snd_soc_component *component;

918

919

lockdep_assert_held(&client_mutex)do { ({ int __ret_warn_on = !!(debug_locks && !lock_is_held
(&(&client_mutex)->dep_map)); if ((__ret_warn_on))
warn_slowpath_null("sound/soc/soc-core.c", 919); (__ret_warn_on
); }); } while (0);

920

921

922

if (of_node) {

923

if (component->dev->of_node == of_node)

924

return component;

925

} else if (strcmp(component->name, name) == 0) {

926

return component;

927

}

928

}

929

930

return NULL((void *)0);

931

}

932

933

/**

934

* snd_soc_find_dai - Find a registered DAI

935

936

* @dlc: name of the DAI and optional component info to match

937

938

* This function will search all regsitered components and their DAIs to

939

* find the DAI of the same name. The component's of_node and name

940

* should also match if being specified.

941

942

* Return: pointer of DAI, or NULL if not found.

943

944

struct snd_soc_dai *snd_soc_find_dai(

945

const struct snd_soc_dai_link_component *dlc)

946

{

947

struct snd_soc_component *component;

948

struct snd_soc_dai *dai;

949

struct device_node *component_of_node;

950

951

952

953

/* Find CPU DAI from registered DAIs*/

954

955

component_of_node = component->dev->of_node;

956

if (!component_of_node && component->dev->parent)

957

component_of_node = component->dev->parent->of_node;

958

959

if (dlc->of_node && component_of_node != dlc->of_node)

960

continue;

961

if (dlc->name && strcmp(component->name, dlc->name))

962

continue;

963

964

if (dlc->dai_name && strcmp(dai->name, dlc->dai_name))

965

continue;

966

967

return dai;

968

}

969

}

970

971

return NULL((void *)0);

972

}

973

EXPORT_SYMBOL_GPL(snd_soc_find_dai)extern typeof(snd_soc_find_dai) snd_soc_find_dai; extern void
*__crc_snd_soc_find_dai __attribute__((weak)); static const unsigned
long __kcrctab_snd_soc_find_dai __attribute__((__used__)) __attribute__
((section("___kcrctab" "_gpl" "+" "snd_soc_find_dai"), used))
= (unsigned long) &__crc_snd_soc_find_dai; static const char
__kstrtab_snd_soc_find_dai[] __attribute__((section("__ksymtab_strings"
), aligned(1))) = "snd_soc_find_dai"; static const struct kernel_symbol
__ksymtab_snd_soc_find_dai __attribute__((__used__)) __attribute__
((section("___ksymtab" "_gpl" "+" "snd_soc_find_dai"), used))
= { (unsigned long)&snd_soc_find_dai, __kstrtab_snd_soc_find_dai
};

974

975

static bool soc_is_dai_link_bound(struct snd_soc_card *card,

976

struct snd_soc_dai_link *dai_link)

977

{

978

struct snd_soc_pcm_runtime *rtd;

979

980

981

if (rtd->dai_link == dai_link)

982

return true;

983

}

984

985

return false;

986

}

987

988

static int soc_bind_dai_link(struct snd_soc_card *card,

989

struct snd_soc_dai_link *dai_link)

990

{

991

struct snd_soc_pcm_runtime *rtd;

992

struct snd_soc_dai_link_component *codecs = dai_link->codecs;

993

struct snd_soc_dai_link_component cpu_dai_component;

994

struct snd_soc_dai **codec_dais;

995

struct snd_soc_platform *platform;

996

const char *platform_name;

997

int i;

998

999

dev_dbg(card->dev, "ASoC: binding %s\n", dai_link->name)do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: binding %s\n"), .lineno = 999, .flags = 0, }
; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, card->dev, "ASoC: binding %s\n", dai_link
->name); } while (0); } while (0);

1000

1001

if (soc_is_dai_link_bound(card, dai_link)) {

1002

dev_dbg(card->dev, "ASoC: dai link %s already bound\n",do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: dai link %s already bound\n"), .lineno = 1003
, .flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, card->dev, "ASoC: dai link %s already bound\n"
, dai_link->name); } while (0); } while (0)

1003

dai_link->name)do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: dai link %s already bound\n"), .lineno = 1003
, .flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, card->dev, "ASoC: dai link %s already bound\n"
, dai_link->name); } while (0); } while (0);

1004

return 0;

1005

}

1006

1007

rtd = soc_new_pcm_runtime(card, dai_link);

1008

if (!rtd)

1009

return -ENOMEM12;

1010

1011

cpu_dai_component.name = dai_link->cpu_name;

1012

cpu_dai_component.of_node = dai_link->cpu_of_node;

1013

cpu_dai_component.dai_name = dai_link->cpu_dai_name;

1014

rtd->cpu_dai = snd_soc_find_dai(&cpu_dai_component);

1015

if (!rtd->cpu_dai) {

1016

dev_err(card->dev, "ASoC: CPU DAI %s not registered\n",

1017

dai_link->cpu_dai_name);

1018

goto _err_defer;

1019

}

1020

1021

rtd->num_codecs = dai_link->num_codecs;

1022

1023

/* Find CODEC from registered CODECs */

1024

codec_dais = rtd->codec_dais;

1025

for (i = 0; i < rtd->num_codecs; i++) {

1026

codec_dais[i] = snd_soc_find_dai(&codecs[i]);

1027

if (!codec_dais[i]) {

1028

dev_err(card->dev, "ASoC: CODEC DAI %s not registered\n",

1029

codecs[i].dai_name);

1030

goto _err_defer;

1031

}

1032

}

1033

1034

/* Single codec links expect codec and codec_dai in runtime data */

1035

rtd->codec_dai = codec_dais[0];

1036

rtd->codec = rtd->codec_dai->codec;

1037

1038

/* if there's no platform we match on the empty platform */

1039

platform_name = dai_link->platform_name;

1040

if (!platform_name && !dai_link->platform_of_node)

1041

platform_name = "snd-soc-dummy";

1042

1043

/* find one from the set of registered platforms */

1044

1045

if (dai_link->platform_of_node) {

1046

if (platform->dev->of_node !=

1047

dai_link->platform_of_node)

1048

continue;

1049

} else {

1050

if (strcmp(platform->component.name, platform_name))

1051

continue;

1052

}

1053

1054

rtd->platform = platform;

1055

}

1056

if (!rtd->platform) {

1057

dev_err(card->dev, "ASoC: platform %s not registered\n",

1058

dai_link->platform_name);

1059

goto _err_defer;

1060

}

1061

1062

soc_add_pcm_runtime(card, rtd);

1063

return 0;

1064

1065

_err_defer:

1066

soc_free_pcm_runtime(rtd);

1067

return -EPROBE_DEFER517;

1068

}

1069

1070

static void soc_remove_component(struct snd_soc_component *component)

1071

{

1072

if (!component->card)

1073

return;

1074

1075

/* This is a HACK and will be removed soon */

1076

if (component->codec)

1077

list_del(&component->codec->card_list);

1078

1079

if (component->remove)

1080

component->remove(component);

1081

1082

snd_soc_dapm_free(snd_soc_component_get_dapm(component));

1083

1084

soc_cleanup_component_debugfs(component);

1085

component->card = NULL((void *)0);

1086

module_put(component->dev->driver->owner);

1087

}

1088

1089

static void soc_remove_dai(struct snd_soc_dai *dai, int order)

1090

{

1091

int err;

1092

1093

if (dai && dai->probed &&

1094

dai->driver->remove_order == order) {

1095

if (dai->driver->remove) {

1096

err = dai->driver->remove(dai);

1097

if (err < 0)

1098

dev_err(dai->dev,

1099

"ASoC: failed to remove %s: %d\n",

1100

dai->name, err);

1101

}

1102

dai->probed = 0;

1103

}

1104

}

1105

1106

static void soc_remove_link_dais(struct snd_soc_card *card,

1107

struct snd_soc_pcm_runtime *rtd, int order)

1108

{

1109

int i;

1110

1111

/* unregister the rtd device */

1112

if (rtd->dev_registered) {

1113

device_unregister(rtd->dev);

1114

rtd->dev_registered = 0;

1115

}

1116

1117

/* remove the CODEC DAI */

1118

for (i = 0; i < rtd->num_codecs; i++)

1119

soc_remove_dai(rtd->codec_dais[i], order);

1120

1121

soc_remove_dai(rtd->cpu_dai, order);

1122

}

1123

1124

static void soc_remove_link_components(struct snd_soc_card *card,

1125

struct snd_soc_pcm_runtime *rtd, int order)

1126

{

1127

struct snd_soc_dai *cpu_dai = rtd->cpu_dai;

1128

struct snd_soc_platform *platform = rtd->platform;

1129

struct snd_soc_component *component;

1130

int i;

1131

1132

/* remove the platform */

1133

if (platform && platform->component.driver->remove_order == order)

1134

soc_remove_component(&platform->component);

1135

1136

/* remove the CODEC-side CODEC */

1137

for (i = 0; i < rtd->num_codecs; i++) {

1138

component = rtd->codec_dais[i]->component;

1139

if (component->driver->remove_order == order)

1140

soc_remove_component(component);

1141

}

1142

1143

/* remove any CPU-side CODEC */

1144

if (cpu_dai) {

1145

if (cpu_dai->component->driver->remove_order == order)

1146

soc_remove_component(cpu_dai->component);

1147

}

1148

}

1149

1150

static void soc_remove_dai_links(struct snd_soc_card *card)

1151

{

1152

int order;

1153

struct snd_soc_pcm_runtime *rtd;

1154

struct snd_soc_dai_link *link, *_link;

1155

1156

for (order = SND_SOC_COMP_ORDER_FIRST-2; order <= SND_SOC_COMP_ORDER_LAST2;

1157

order++) {

1158

1159

soc_remove_link_dais(card, rtd, order);

1160

}

1161

1162

for (order = SND_SOC_COMP_ORDER_FIRST-2; order <= SND_SOC_COMP_ORDER_LAST2;

1163

order++) {

1164

1165

soc_remove_link_components(card, rtd, order);

1166

}

1167

1168

list_for_each_entry_safe(link, _link, &card->dai_link_list, list)for (link = ({ const typeof( ((typeof(*link) *)0)->list ) *
__mptr = ((&card->dai_link_list)->next); (typeof(*link
) *)( (char *)__mptr - __builtin_offsetof(typeof(*link), list
) );}), _link = ({ const typeof( ((typeof(*(link)) *)0)->list
) *__mptr = ((link)->list.next); (typeof(*(link)) *)( (char
*)__mptr - __builtin_offsetof(typeof(*(link)), list) );}); &
link->list != (&card->dai_link_list); link = _link,
_link = ({ const typeof( ((typeof(*(_link)) *)0)->list ) *
__mptr = ((_link)->list.next); (typeof(*(_link)) *)( (char
*)__mptr - __builtin_offsetof(typeof(*(_link)), list) );})) {

1169

if (link->dobj.type == SND_SOC_DOBJ_DAI_LINK)

1170

dev_warn(card->dev, "Topology forgot to remove link %s?\n",

1171

link->name);

1172

1173

list_del(&link->list);

1174

card->num_dai_links--;

1175

}

1176

}

1177

1178

static int snd_soc_init_multicodec(struct snd_soc_card *card,

1179

struct snd_soc_dai_link *dai_link)

1180

{

1181

/* Legacy codec/codec_dai link is a single entry in multicodec */

1182

if (dai_link->codec_name || dai_link->codec_of_node ||

1183

dai_link->codec_dai_name) {

1184

dai_link->num_codecs = 1;

1185

1186

dai_link->codecs = devm_kzalloc(card->dev,

1187

sizeof(struct snd_soc_dai_link_component),

1188

GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)));

1189

if (!dai_link->codecs)

1190

return -ENOMEM12;

1191

1192

dai_link->codecs[0].name = dai_link->codec_name;

1193

dai_link->codecs[0].of_node = dai_link->codec_of_node;

1194

dai_link->codecs[0].dai_name = dai_link->codec_dai_name;

1195

}

1196

1197

if (!dai_link->codecs) {

1198

dev_err(card->dev, "ASoC: DAI link has no CODECs\n");

1199

return -EINVAL22;

1200

}

1201

1202

return 0;

1203

}

1204

1205

static int soc_init_dai_link(struct snd_soc_card *card,

1206

struct snd_soc_dai_link *link)

1207

{

1208

int i, ret;

1209

1210

ret = snd_soc_init_multicodec(card, link);

1211

if (ret) {

1212

dev_err(card->dev, "ASoC: failed to init multicodec\n");

1213

return ret;

1214

}

1215

1216

for (i = 0; i < link->num_codecs; i++) {

1217

1218

* Codec must be specified by 1 of name or OF node,

1219

* not both or neither.

1220

1221

if (!!link->codecs[i].name ==

1222

!!link->codecs[i].of_node) {

1223

dev_err(card->dev, "ASoC: Neither/both codec name/of_node are set for %s\n",

1224

link->name);

1225

return -EINVAL22;

1226

}

1227

/* Codec DAI name must be specified */

1228

if (!link->codecs[i].dai_name) {

1229

dev_err(card->dev, "ASoC: codec_dai_name not set for %s\n",

1230

link->name);

1231

return -EINVAL22;

1232

}

1233

}

1234

1235

1236

* Platform may be specified by either name or OF node, but

1237

* can be left unspecified, and a dummy platform will be used.

1238

1239

if (link->platform_name && link->platform_of_node) {

1240

dev_err(card->dev,

1241

"ASoC: Both platform name/of_node are set for %s\n",

1242

link->name);

1243

return -EINVAL22;

1244

}

1245

1246

1247

* CPU device may be specified by either name or OF node, but

1248

* can be left unspecified, and will be matched based on DAI

1249

* name alone..

1250

1251

if (link->cpu_name && link->cpu_of_node) {

1252

dev_err(card->dev,

1253

"ASoC: Neither/both cpu name/of_node are set for %s\n",

1254

link->name);

1255

return -EINVAL22;

1256

}

1257

1258

* At least one of CPU DAI name or CPU device name/node must be

1259

* specified

1260

1261

if (!link->cpu_dai_name &&

1262

!(link->cpu_name || link->cpu_of_node)) {

1263

dev_err(card->dev,

1264

"ASoC: Neither cpu_dai_name nor cpu_name/of_node are set for %s\n",

1265

link->name);

1266

return -EINVAL22;

1267

}

1268

1269

return 0;

1270

}

1271

1272

/**

1273

* snd_soc_add_dai_link - Add a DAI link dynamically

1274

* @card: The ASoC card to which the DAI link is added

1275

* @dai_link: The new DAI link to add

1276

1277

* This function adds a DAI link to the ASoC card's link list.

1278

1279

* Note: Topology can use this API to add DAI links when probing the

1280

* topology component. And machine drivers can still define static

1281

* DAI links in dai_link array.

1282

1283

int snd_soc_add_dai_link(struct snd_soc_card *card,

1284

struct snd_soc_dai_link *dai_link)

1285

{

1286

if (dai_link->dobj.type

1287

&& dai_link->dobj.type != SND_SOC_DOBJ_DAI_LINK) {

1288

dev_err(card->dev, "Invalid dai link type %d\n",

1289

dai_link->dobj.type);

1290

return -EINVAL22;

1291

}

1292

1293

1294

/* Notify the machine driver for extra initialization

1295

* on the link created by topology.

1296

1297

if (dai_link->dobj.type && card->add_dai_link)

1298

card->add_dai_link(card, dai_link);

1299

1300

list_add_tail(&dai_link->list, &card->dai_link_list);

1301

card->num_dai_links++;

1302

1303

return 0;

1304

}

1305

EXPORT_SYMBOL_GPL(snd_soc_add_dai_link)extern typeof(snd_soc_add_dai_link) snd_soc_add_dai_link; extern
void *__crc_snd_soc_add_dai_link __attribute__((weak)); static
const unsigned long __kcrctab_snd_soc_add_dai_link __attribute__
((__used__)) __attribute__((section("___kcrctab" "_gpl" "+" "snd_soc_add_dai_link"
), used)) = (unsigned long) &__crc_snd_soc_add_dai_link; static
const char __kstrtab_snd_soc_add_dai_link[] __attribute__((section
("__ksymtab_strings"), aligned(1))) = "snd_soc_add_dai_link";
static const struct kernel_symbol __ksymtab_snd_soc_add_dai_link
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_add_dai_link"), used)) = { (unsigned long
)&snd_soc_add_dai_link, __kstrtab_snd_soc_add_dai_link };

1306

1307

/**

1308

* snd_soc_remove_dai_link - Remove a DAI link from the list

1309

* @card: The ASoC card that owns the link

1310

* @dai_link: The DAI link to remove

1311

1312

* This function removes a DAI link from the ASoC card's link list.

1313

1314

* For DAI links previously added by topology, topology should

1315

* remove them by using the dobj embedded in the link.

1316

1317

void snd_soc_remove_dai_link(struct snd_soc_card *card,

1318

struct snd_soc_dai_link *dai_link)

1319

{

1320

struct snd_soc_dai_link *link, *_link;

1321

1322

if (dai_link->dobj.type

1323

&& dai_link->dobj.type != SND_SOC_DOBJ_DAI_LINK) {

1324

dev_err(card->dev, "Invalid dai link type %d\n",

1325

dai_link->dobj.type);

1326

return;

1327

}

1328

1329

1330

/* Notify the machine driver for extra destruction

1331

* on the link created by topology.

1332

1333

if (dai_link->dobj.type && card->remove_dai_link)

1334

card->remove_dai_link(card, dai_link);

1335

1336

1337

if (link == dai_link) {

1338

list_del(&link->list);

1339

card->num_dai_links--;

1340

return;

1341

}

1342

}

1343

}

1344

EXPORT_SYMBOL_GPL(snd_soc_remove_dai_link)extern typeof(snd_soc_remove_dai_link) snd_soc_remove_dai_link
; extern void *__crc_snd_soc_remove_dai_link __attribute__((weak
)); static const unsigned long __kcrctab_snd_soc_remove_dai_link
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_remove_dai_link"), used)) = (unsigned long
) &__crc_snd_soc_remove_dai_link; static const char __kstrtab_snd_soc_remove_dai_link
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_remove_dai_link"; static const struct kernel_symbol
__ksymtab_snd_soc_remove_dai_link __attribute__((__used__)) __attribute__
((section("___ksymtab" "_gpl" "+" "snd_soc_remove_dai_link"),
used)) = { (unsigned long)&snd_soc_remove_dai_link, __kstrtab_snd_soc_remove_dai_link
};

1345

1346

static void soc_set_name_prefix(struct snd_soc_card *card,

1347

struct snd_soc_component *component)

1348

{

1349

int i;

1350

1351

if (card->codec_conf == NULL((void *)0))

1352

return;

1353

1354

for (i = 0; i < card->num_configs; i++) {

1355

struct snd_soc_codec_conf *map = &card->codec_conf[i];

1356

if (map->of_node && component->dev->of_node != map->of_node)

1357

continue;

1358

if (map->dev_name && strcmp(component->name, map->dev_name))

1359

continue;

1360

component->name_prefix = map->name_prefix;

1361

break;

1362

}

1363

}

1364

1365

static int soc_probe_component(struct snd_soc_card *card,

1366

struct snd_soc_component *component)

1367

{

1368

struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);

1369

struct snd_soc_dai *dai;

1370

int ret;

1371

1372

if (!strcmp(component->name, "snd-soc-dummy"))

1373

return 0;

1374

1375

if (component->card) {

1376

if (component->card != card) {

1377

dev_err(component->dev,

1378

"Trying to bind component to card \"%s\" but is already bound to card \"%s\"\n",

1379

card->name, component->card->name);

1380

return -ENODEV19;

1381

}

1382

return 0;

1383

}

1384

1385

if (!try_module_get(component->dev->driver->owner))

1386

return -ENODEV19;

1387

1388

component->card = card;

1389

dapm->card = card;

1390

soc_set_name_prefix(card, component);

1391

1392

soc_init_component_debugfs(component);

1393

1394

if (component->dapm_widgets) {

1395

ret = snd_soc_dapm_new_controls(dapm, component->dapm_widgets,

1396

component->num_dapm_widgets);

1397

1398

if (ret != 0) {

1399

dev_err(component->dev,

1400

"Failed to create new controls %d\n", ret);

1401

goto err_probe;

1402

}

1403

}

1404

1405

1406

ret = snd_soc_dapm_new_dai_widgets(dapm, dai);

1407

if (ret != 0) {

1408

dev_err(component->dev,

1409

"Failed to create DAI widgets %d\n", ret);

1410

goto err_probe;

1411

}

1412

}

1413

1414

if (component->probe) {

1415

ret = component->probe(component);

1416

if (ret < 0) {

1417

dev_err(component->dev,

1418

"ASoC: failed to probe component %d\n", ret);

1419

goto err_probe;

1420

}

1421

1422

WARN(dapm->idle_bias_off &&({ int __ret_warn_on = !!(dapm->idle_bias_off && dapm
->bias_level != SND_SOC_BIAS_OFF); if ((__ret_warn_on)) warn_slowpath_fmt
("sound/soc/soc-core.c", 1425, "codec %s can not start from non-off bias with idle_bias_off==1\n"
, component->name); (__ret_warn_on); })

1423

dapm->bias_level != SND_SOC_BIAS_OFF,({ int __ret_warn_on = !!(dapm->idle_bias_off && dapm
->bias_level != SND_SOC_BIAS_OFF); if ((__ret_warn_on)) warn_slowpath_fmt
("sound/soc/soc-core.c", 1425, "codec %s can not start from non-off bias with idle_bias_off==1\n"
, component->name); (__ret_warn_on); })

1424

"codec %s can not start from non-off bias with idle_bias_off==1\n",({ int __ret_warn_on = !!(dapm->idle_bias_off && dapm
->bias_level != SND_SOC_BIAS_OFF); if ((__ret_warn_on)) warn_slowpath_fmt
("sound/soc/soc-core.c", 1425, "codec %s can not start from non-off bias with idle_bias_off==1\n"
, component->name); (__ret_warn_on); })

1425

component->name)({ int __ret_warn_on = !!(dapm->idle_bias_off && dapm
->bias_level != SND_SOC_BIAS_OFF); if ((__ret_warn_on)) warn_slowpath_fmt
("sound/soc/soc-core.c", 1425, "codec %s can not start from non-off bias with idle_bias_off==1\n"
, component->name); (__ret_warn_on); });

1426

}

1427

1428

/* machine specific init */

1429

if (component->init) {

1430

ret = component->init(component);

1431

if (ret < 0) {

1432

dev_err(component->dev,

1433

"Failed to do machine specific init %d\n", ret);

1434

goto err_probe;

1435

}

1436

}

1437

1438

if (component->controls)

1439

snd_soc_add_component_controls(component, component->controls,

1440

component->num_controls);

1441

if (component->dapm_routes)

1442

snd_soc_dapm_add_routes(dapm, component->dapm_routes,

1443

component->num_dapm_routes);

1444

1445

list_add(&dapm->list, &card->dapm_list);

1446

1447

/* This is a HACK and will be removed soon */

1448

if (component->codec)

1449

list_add(&component->codec->card_list, &card->codec_dev_list);

1450

1451

return 0;

1452

1453

err_probe:

1454

soc_cleanup_component_debugfs(component);

1455

component->card = NULL((void *)0);

1456

module_put(component->dev->driver->owner);

1457

1458

return ret;

1459

}

1460

1461

static void rtd_release(struct device *dev)

1462

{

1463

kfree(dev);

1464

}

1465

1466

static int soc_post_component_init(struct snd_soc_pcm_runtime *rtd,

1467

const char *name)

1468

{

1469

int ret = 0;

1470

1471

/* register the rtd device */

1472

rtd->dev = kzalloc(sizeof(struct device), GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)));

1473

if (!rtd->dev)

1474

return -ENOMEM12;

1475

device_initialize(rtd->dev);

1476

rtd->dev->parent = rtd->card->dev;

1477

rtd->dev->release = rtd_release;

1478

rtd->dev->groups = soc_dev_attr_groups;

1479

dev_set_name(rtd->dev, "%s", name);

1480

dev_set_drvdata(rtd->dev, rtd);

1481

mutex_init(&rtd->pcm_mutex)do { static struct lock_class_key __key; __mutex_init((&rtd
->pcm_mutex), "&rtd->pcm_mutex", &__key); } while
(0);

1482

INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].be_clients);

1483

INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].be_clients);

1484

INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].fe_clients);

1485

INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].fe_clients);

1486

ret = device_add(rtd->dev);

1487

if (ret < 0) {

1488

/* calling put_device() here to free the rtd->dev */

1489

put_device(rtd->dev);

1490

dev_err(rtd->card->dev,

1491

"ASoC: failed to register runtime device: %d\n", ret);

1492

return ret;

1493

}

1494

rtd->dev_registered = 1;

1495

return 0;

1496

}

1497

1498

static int soc_probe_link_components(struct snd_soc_card *card,

1499

struct snd_soc_pcm_runtime *rtd,

1500

int order)

1501

{

1502

struct snd_soc_platform *platform = rtd->platform;

1503

struct snd_soc_component *component;

1504

int i, ret;

1505

1506

/* probe the CPU-side component, if it is a CODEC */

1507

component = rtd->cpu_dai->component;

1508

if (component->driver->probe_order == order) {

1509

ret = soc_probe_component(card, component);

1510

if (ret < 0)

1511

return ret;

1512

}

1513

1514

/* probe the CODEC-side components */

1515

for (i = 0; i < rtd->num_codecs; i++) {

1516

component = rtd->codec_dais[i]->component;

1517

if (component->driver->probe_order == order) {

1518

ret = soc_probe_component(card, component);

1519

if (ret < 0)

1520

return ret;

1521

}

1522

}

1523

1524

/* probe the platform */

1525

if (platform->component.driver->probe_order == order) {

1526

ret = soc_probe_component(card, &platform->component);

1527

if (ret < 0)

1528

return ret;

1529

}

1530

1531

return 0;

1532

}

1533

1534

static int soc_probe_dai(struct snd_soc_dai *dai, int order)

1535

{

1536

int ret;

1537

1538

if (!dai->probed && dai->driver->probe_order == order) {

1539

if (dai->driver->probe) {

1540

ret = dai->driver->probe(dai);

1541

if (ret < 0) {

1542

dev_err(dai->dev,

1543

"ASoC: failed to probe DAI %s: %d\n",

1544

dai->name, ret);

1545

return ret;

1546

}

1547

}

1548

1549

dai->probed = 1;

1550

}

1551

1552

return 0;

1553

}

1554

1555

static int soc_link_dai_widgets(struct snd_soc_card *card,

1556

struct snd_soc_dai_link *dai_link,

1557

struct snd_soc_pcm_runtime *rtd)

1558

{

1559

struct snd_soc_dai *cpu_dai = rtd->cpu_dai;

1560

struct snd_soc_dai *codec_dai = rtd->codec_dai;

1561

struct snd_soc_dapm_widget *sink, *source;

1562

int ret;

1563

1564

if (rtd->num_codecs > 1)

1565

dev_warn(card->dev, "ASoC: Multiple codecs not supported yet\n");

1566

1567

/* link the DAI widgets */

1568

sink = codec_dai->playback_widget;

1569

source = cpu_dai->capture_widget;

1570

if (sink && source) {

1571

ret = snd_soc_dapm_new_pcm(card, dai_link->params,

1572

dai_link->num_params,

1573

source, sink);

1574

if (ret != 0) {

1575

dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",

1576

sink->name, source->name, ret);

1577

return ret;

1578

}

1579

}

1580

1581

sink = cpu_dai->playback_widget;

1582

source = codec_dai->capture_widget;

1583

if (sink && source) {

1584

ret = snd_soc_dapm_new_pcm(card, dai_link->params,

1585

dai_link->num_params,

1586

source, sink);

1587

if (ret != 0) {

1588

dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",

1589

sink->name, source->name, ret);

1590

return ret;

1591

}

1592

}

1593

1594

return 0;

1595

}

1596

1597

static int soc_probe_link_dais(struct snd_soc_card *card,

1598

struct snd_soc_pcm_runtime *rtd, int order)

1599

{

1600

struct snd_soc_dai_link *dai_link = rtd->dai_link;

1601

struct snd_soc_dai *cpu_dai = rtd->cpu_dai;

1602

int i, ret;

1603

1604

dev_dbg(card->dev, "ASoC: probe %s dai link %d late %d\n",do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: probe %s dai link %d late %d\n"), .lineno = 1605
, .flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, card->dev, "ASoC: probe %s dai link %d late %d\n"
, card->name, rtd->num, order); } while (0); } while (0
)

1605

card->name, rtd->num, order)do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: probe %s dai link %d late %d\n"), .lineno = 1605
, .flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, card->dev, "ASoC: probe %s dai link %d late %d\n"
, card->name, rtd->num, order); } while (0); } while (0
);

1606

1607

/* set default power off timeout */

1608

rtd->pmdown_time = pmdown_time;

1609

1610

ret = soc_probe_dai(cpu_dai, order);

1611

if (ret)

1612

return ret;

1613

1614

/* probe the CODEC DAI */

1615

for (i = 0; i < rtd->num_codecs; i++) {

1616

ret = soc_probe_dai(rtd->codec_dais[i], order);

1617

if (ret)

1618

return ret;

1619

}

1620

1621

/* complete DAI probe during last probe */

1622

if (order != SND_SOC_COMP_ORDER_LAST2)

1623

return 0;

1624

1625

/* do machine specific initialization */

1626

if (dai_link->init) {

1627

ret = dai_link->init(rtd);

1628

if (ret < 0) {

1629

dev_err(card->dev, "ASoC: failed to init %s: %d\n",

1630

dai_link->name, ret);

1631

return ret;

1632

}

1633

}

1634

1635

if (dai_link->dai_fmt)

1636

snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);

1637

1638

ret = soc_post_component_init(rtd, dai_link->name);

1639

if (ret)

1640

return ret;

1641

1642

#ifdef CONFIG_DEBUG_FS1

1643

/* add DPCM sysfs entries */

1644

if (dai_link->dynamic)

1645

soc_dpcm_debugfs_add(rtd);

1646

#endif

1647

1648

if (cpu_dai->driver->compress_new) {

1649

/*create compress_device"*/

1650

ret = cpu_dai->driver->compress_new(rtd, rtd->num);

1651

if (ret < 0) {

1652

dev_err(card->dev, "ASoC: can't create compress %s\n",

1653

dai_link->stream_name);

1654

return ret;

1655

}

1656

} else {

1657

1658

if (!dai_link->params) {

1659

/* create the pcm */

1660

ret = soc_new_pcm(rtd, rtd->num);

1661

if (ret < 0) {

1662

dev_err(card->dev, "ASoC: can't create pcm %s :%d\n",

1663

dai_link->stream_name, ret);

1664

return ret;

1665

}

1666

} else {

1667

INIT_DELAYED_WORK(&rtd->delayed_work,do { do { static struct lock_class_key __key; __init_work(((&
(&rtd->delayed_work)->work)), 0); ((&(&rtd->
delayed_work)->work))->data = (atomic_long_t) { (WORK_STRUCT_NO_POOL
) }; lockdep_init_map(&((&(&rtd->delayed_work)
->work))->lockdep_map, "(&(&rtd->delayed_work)->work)"
, &__key, 0); INIT_LIST_HEAD(&((&(&rtd->delayed_work
)->work))->entry); ((&(&rtd->delayed_work)->
work))->func = (((codec2codec_close_delayed_work))); } while
(0); do { do { static struct lock_class_key __key; init_timer_key
(((&(&rtd->delayed_work)->timer)), (((0) | 0x00200000
)), "(&(&rtd->delayed_work)->timer)", &__key
); } while (0); (&(&rtd->delayed_work)->timer)->
function = (delayed_work_timer_fn); (&(&rtd->delayed_work
)->timer)->data = ((unsigned long)(&rtd->delayed_work
)); } while (0); } while (0)

1668

codec2codec_close_delayed_work)do { do { static struct lock_class_key __key; __init_work(((&
(&rtd->delayed_work)->work)), 0); ((&(&rtd->
delayed_work)->work))->data = (atomic_long_t) { (WORK_STRUCT_NO_POOL
) }; lockdep_init_map(&((&(&rtd->delayed_work)
->work))->lockdep_map, "(&(&rtd->delayed_work)->work)"
, &__key, 0); INIT_LIST_HEAD(&((&(&rtd->delayed_work
)->work))->entry); ((&(&rtd->delayed_work)->
work))->func = (((codec2codec_close_delayed_work))); } while
(0); do { do { static struct lock_class_key __key; init_timer_key
(((&(&rtd->delayed_work)->timer)), (((0) | 0x00200000
)), "(&(&rtd->delayed_work)->timer)", &__key
); } while (0); (&(&rtd->delayed_work)->timer)->
function = (delayed_work_timer_fn); (&(&rtd->delayed_work
)->timer)->data = ((unsigned long)(&rtd->delayed_work
)); } while (0); } while (0);

1669

1670

/* link the DAI widgets */

1671

ret = soc_link_dai_widgets(card, dai_link, rtd);

1672

if (ret)

1673

return ret;

1674

}

1675

}

1676

1677

return 0;

1678

}

1679

1680

static int soc_bind_aux_dev(struct snd_soc_card *card, int num)

1681

{

1682

struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];

1683

struct snd_soc_component *component;

1684

const char *name;

1685

struct device_node *codec_of_node;

1686

1687

if (aux_dev->codec_of_node || aux_dev->codec_name) {

1688

/* codecs, usually analog devices */

1689

name = aux_dev->codec_name;

1690

codec_of_node = aux_dev->codec_of_node;

1691

component = soc_find_component(codec_of_node, name);

1692

if (!component) {

1693

if (codec_of_node)

1694

name = of_node_full_name(codec_of_node);

1695

goto err_defer;

1696

}

1697

} else if (aux_dev->name) {

1698

/* generic components */

1699

name = aux_dev->name;

1700

component = soc_find_component(NULL((void *)0), name);

1701

if (!component)

1702

goto err_defer;

1703

} else {

1704

dev_err(card->dev, "ASoC: Invalid auxiliary device\n");

1705

return -EINVAL22;

1706

}

1707

1708

component->init = aux_dev->init;

1709

list_add(&component->list_aux, &card->aux_comp_list);

1710

return 0;

1711

1712

err_defer:

1713

dev_err(card->dev, "ASoC: %s not registered\n", name);

1714

return -EPROBE_DEFER517;

1715

}

1716

1717

static int soc_probe_aux_devices(struct snd_soc_card *card)

1718

{

1719

struct snd_soc_component *comp;

1720

int order;

1721

int ret;

1722

1723

for (order = SND_SOC_COMP_ORDER_FIRST-2; order <= SND_SOC_COMP_ORDER_LAST2;

1724

order++) {

1725

list_for_each_entry(comp, &card->aux_comp_list, list_aux)for (comp = ({ const typeof( ((typeof(*comp) *)0)->list_aux
) *__mptr = ((&card->aux_comp_list)->next); (typeof
(*comp) *)( (char *)__mptr - __builtin_offsetof(typeof(*comp)
, list_aux) );}); &comp->list_aux != (&card->aux_comp_list
); comp = ({ const typeof( ((typeof(*(comp)) *)0)->list_aux
) *__mptr = ((comp)->list_aux.next); (typeof(*(comp)) *)(
(char *)__mptr - __builtin_offsetof(typeof(*(comp)), list_aux
) );})) {

1726

if (comp->driver->probe_order == order) {

1727

ret = soc_probe_component(card, comp);

1728

if (ret < 0) {

1729

dev_err(card->dev,

1730

"ASoC: failed to probe aux component %s %d\n",

1731

comp->name, ret);

1732

return ret;

1733

}

1734

}

1735

}

1736

}

1737

1738

return 0;

1739

}

1740

1741

static void soc_remove_aux_devices(struct snd_soc_card *card)

1742

{

1743

struct snd_soc_component *comp, *_comp;

1744

int order;

1745

1746

for (order = SND_SOC_COMP_ORDER_FIRST-2; order <= SND_SOC_COMP_ORDER_LAST2;

1747

order++) {

1748

list_for_each_entry_safe(comp, _comp,for (comp = ({ const typeof( ((typeof(*comp) *)0)->list_aux
) *__mptr = ((&card->aux_comp_list)->next); (typeof
(*comp) *)( (char *)__mptr - __builtin_offsetof(typeof(*comp)
, list_aux) );}), _comp = ({ const typeof( ((typeof(*(comp)) *
)0)->list_aux ) *__mptr = ((comp)->list_aux.next); (typeof
(*(comp)) *)( (char *)__mptr - __builtin_offsetof(typeof(*(comp
)), list_aux) );}); &comp->list_aux != (&card->
aux_comp_list); comp = _comp, _comp = ({ const typeof( ((typeof
(*(_comp)) *)0)->list_aux ) *__mptr = ((_comp)->list_aux
.next); (typeof(*(_comp)) *)( (char *)__mptr - __builtin_offsetof
(typeof(*(_comp)), list_aux) );}))

1749

&card->aux_comp_list, list_aux)for (comp = ({ const typeof( ((typeof(*comp) *)0)->list_aux
) *__mptr = ((&card->aux_comp_list)->next); (typeof
(*comp) *)( (char *)__mptr - __builtin_offsetof(typeof(*comp)
, list_aux) );}), _comp = ({ const typeof( ((typeof(*(comp)) *
)0)->list_aux ) *__mptr = ((comp)->list_aux.next); (typeof
(*(comp)) *)( (char *)__mptr - __builtin_offsetof(typeof(*(comp
)), list_aux) );}); &comp->list_aux != (&card->
aux_comp_list); comp = _comp, _comp = ({ const typeof( ((typeof
(*(_comp)) *)0)->list_aux ) *__mptr = ((_comp)->list_aux
.next); (typeof(*(_comp)) *)( (char *)__mptr - __builtin_offsetof
(typeof(*(_comp)), list_aux) );})) {

1750

if (comp->driver->remove_order == order) {

1751

soc_remove_component(comp);

1752

/* remove it from the card's aux_comp_list */

1753

list_del(&comp->list_aux);

1754

}

1755

}

1756

}

1757

}

1758

1759

static int snd_soc_init_codec_cache(struct snd_soc_codec *codec)

1760

{

1761

int ret;

1762

1763

if (codec->cache_init)

1764

return 0;

1765

1766

ret = snd_soc_cache_init(codec);

1767

if (ret < 0) {

1768

dev_err(codec->dev,

1769

"ASoC: Failed to set cache compression type: %d\n",

1770

ret);

1771

return ret;

1772

}

1773

codec->cache_init = 1;

1774

return 0;

1775

}

1776

1777

/**

1778

* snd_soc_runtime_set_dai_fmt() - Change DAI link format for a ASoC runtime

1779

* @rtd: The runtime for which the DAI link format should be changed

1780

* @dai_fmt: The new DAI link format

1781

1782

* This function updates the DAI link format for all DAIs connected to the DAI

1783

* link for the specified runtime.

1784

1785

* Note: For setups with a static format set the dai_fmt field in the

1786

* corresponding snd_dai_link struct instead of using this function.

1787

1788

* Returns 0 on success, otherwise a negative error code.

1789

1790

int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,

1791

unsigned int dai_fmt)

1792

{

1793

struct snd_soc_dai **codec_dais = rtd->codec_dais;

1794

struct snd_soc_dai *cpu_dai = rtd->cpu_dai;

1795

unsigned int i;

1796

int ret;

1797

1798

for (i = 0; i < rtd->num_codecs; i++) {

1799

struct snd_soc_dai *codec_dai = codec_dais[i];

1800

1801

ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt);

1802

if (ret != 0 && ret != -ENOTSUPP524) {

1803

dev_warn(codec_dai->dev,

1804

"ASoC: Failed to set DAI format: %d\n", ret);

1805

return ret;

1806

}

1807

}

1808

1809

/* Flip the polarity for the "CPU" end of a CODEC<->CODEC link */

1810

if (cpu_dai->codec) {

1811

unsigned int inv_dai_fmt;

1812

1813

inv_dai_fmt = dai_fmt & ~SND_SOC_DAIFMT_MASTER_MASK0xf000;

1814

switch (dai_fmt & SND_SOC_DAIFMT_MASTER_MASK0xf000) {

1815

case SND_SOC_DAIFMT_CBM_CFM(1 << 12):

1816

inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFS(4 << 12);

1817

break;

1818

case SND_SOC_DAIFMT_CBM_CFS(3 << 12):

1819

inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFM(2 << 12);

1820

break;

1821

case SND_SOC_DAIFMT_CBS_CFM(2 << 12):

1822

inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFS(3 << 12);

1823

break;

1824

case SND_SOC_DAIFMT_CBS_CFS(4 << 12):

1825

inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFM(1 << 12);

1826

break;

1827

}

1828

1829

dai_fmt = inv_dai_fmt;

1830

}

1831

1832

ret = snd_soc_dai_set_fmt(cpu_dai, dai_fmt);

1833

if (ret != 0 && ret != -ENOTSUPP524) {

1834

dev_warn(cpu_dai->dev,

1835

"ASoC: Failed to set DAI format: %d\n", ret);

1836

return ret;

1837

}

1838

1839

return 0;

1840

}

1841

EXPORT_SYMBOL_GPL(snd_soc_runtime_set_dai_fmt)extern typeof(snd_soc_runtime_set_dai_fmt) snd_soc_runtime_set_dai_fmt
; extern void *__crc_snd_soc_runtime_set_dai_fmt __attribute__
((weak)); static const unsigned long __kcrctab_snd_soc_runtime_set_dai_fmt
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_runtime_set_dai_fmt"), used)) = (unsigned
long) &__crc_snd_soc_runtime_set_dai_fmt; static const char
__kstrtab_snd_soc_runtime_set_dai_fmt[] __attribute__((section
("__ksymtab_strings"), aligned(1))) = "snd_soc_runtime_set_dai_fmt"
; static const struct kernel_symbol __ksymtab_snd_soc_runtime_set_dai_fmt
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_runtime_set_dai_fmt"), used)) = { (unsigned
long)&snd_soc_runtime_set_dai_fmt, __kstrtab_snd_soc_runtime_set_dai_fmt
};

1842

1843

static int snd_soc_instantiate_card(struct snd_soc_card *card)

1844

{

1845

struct snd_soc_codec *codec;

1846

struct snd_soc_pcm_runtime *rtd;

1847

struct snd_soc_dai_link *dai_link;

1848

int ret, i, order;

1849

1850

mutex_lock(&client_mutex)mutex_lock_nested(&client_mutex, 0);

1851

mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_INIT);

1852

1853

/* bind DAIs */

1854

for (i = 0; i < card->num_links; i++) {

1855

ret = soc_bind_dai_link(card, &card->dai_link[i]);

1856

if (ret != 0)

1857

goto base_error;

1858

}

1859

1860

/* bind aux_devs too */

1861

for (i = 0; i < card->num_aux_devs; i++) {

1862

ret = soc_bind_aux_dev(card, i);

1863

if (ret != 0)

1864

goto base_error;

1865

}

1866

1867

/* add predefined DAI links to the list */

1868

for (i = 0; i < card->num_links; i++)

1869

snd_soc_add_dai_link(card, card->dai_link+i);

1870

1871

/* initialize the register cache for each available codec */

1872

1873

if (codec->cache_init)

1874

continue;

1875

ret = snd_soc_init_codec_cache(codec);

1876

if (ret < 0)

1877

goto base_error;

1878

}

1879

1880

/* card bind complete so register a sound card */

1881

ret = snd_card_new(card->dev, SNDRV_DEFAULT_IDX1(-1), SNDRV_DEFAULT_STR1((void *)0),

1882

card->owner, 0, &card->snd_card);

1883

if (ret < 0) {

1884

dev_err(card->dev,

1885

"ASoC: can't create sound card for card %s: %d\n",

1886

card->name, ret);

1887

goto base_error;

1888

}

1889

1890

soc_init_card_debugfs(card);

1891

1892

card->dapm.bias_level = SND_SOC_BIAS_OFF;

1893

card->dapm.dev = card->dev;

1894

card->dapm.card = card;

1895

list_add(&card->dapm.list, &card->dapm_list);

1896

1897

#ifdef CONFIG_DEBUG_FS1

1898

snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);

1899

#endif

1900

1901

#ifdef CONFIG_PM_SLEEP1

1902

/* deferred resume work */

1903

INIT_WORK(&card->deferred_resume_work, soc_resume_deferred)do { static struct lock_class_key __key; __init_work(((&card
->deferred_resume_work)), 0); ((&card->deferred_resume_work
))->data = (atomic_long_t) { (WORK_STRUCT_NO_POOL) }; lockdep_init_map
(&((&card->deferred_resume_work))->lockdep_map,
"(&card->deferred_resume_work)", &__key, 0); INIT_LIST_HEAD
(&((&card->deferred_resume_work))->entry); ((&
card->deferred_resume_work))->func = ((soc_resume_deferred
)); } while (0);

1904

#endif

1905

1906

if (card->dapm_widgets)

1907

snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,

1908

card->num_dapm_widgets);

1909

1910

if (card->of_dapm_widgets)

1911

snd_soc_dapm_new_controls(&card->dapm, card->of_dapm_widgets,

1912

card->num_of_dapm_widgets);

1913

1914

/* initialise the sound card only once */

1915

if (card->probe) {

1916

ret = card->probe(card);

1917

if (ret < 0)

1918

goto card_probe_error;

1919

}

1920

1921

/* probe all components used by DAI links on this card */

1922

for (order = SND_SOC_COMP_ORDER_FIRST-2; order <= SND_SOC_COMP_ORDER_LAST2;

1923

order++) {

1924

1925

ret = soc_probe_link_components(card, rtd, order);

1926

if (ret < 0) {

1927

dev_err(card->dev,

1928

"ASoC: failed to instantiate card %d\n",

1929

ret);

1930

goto probe_dai_err;

1931

}

1932

}

1933

}

1934

1935

/* probe auxiliary components */

1936

ret = soc_probe_aux_devices(card);

1937

if (ret < 0)

1938

goto probe_dai_err;

1939

1940

/* Find new DAI links added during probing components and bind them.

1941

* Components with topology may bring new DAIs and DAI links.

1942

1943

list_for_each_entry(dai_link, &card->dai_link_list, list)for (dai_link = ({ const typeof( ((typeof(*dai_link) *)0)->
list ) *__mptr = ((&card->dai_link_list)->next); (typeof
(*dai_link) *)( (char *)__mptr - __builtin_offsetof(typeof(*dai_link
), list) );}); &dai_link->list != (&card->dai_link_list
); dai_link = ({ const typeof( ((typeof(*(dai_link)) *)0)->
list ) *__mptr = ((dai_link)->list.next); (typeof(*(dai_link
)) *)( (char *)__mptr - __builtin_offsetof(typeof(*(dai_link)
), list) );})) {

1944

if (soc_is_dai_link_bound(card, dai_link))

1945

continue;

1946

1947

ret = soc_init_dai_link(card, dai_link);

1948

if (ret)

1949

goto probe_dai_err;

1950

ret = soc_bind_dai_link(card, dai_link);

1951

if (ret)

1952

goto probe_dai_err;

1953

}

1954

1955

/* probe all DAI links on this card */

1956

for (order = SND_SOC_COMP_ORDER_FIRST-2; order <= SND_SOC_COMP_ORDER_LAST2;

1957

order++) {

1958

1959

ret = soc_probe_link_dais(card, rtd, order);

1960

if (ret < 0) {

1961

dev_err(card->dev,

1962

"ASoC: failed to instantiate card %d\n",

1963

ret);

1964

goto probe_dai_err;

1965

}

1966

}

1967

}

1968

1969

snd_soc_dapm_link_dai_widgets(card);

1970

snd_soc_dapm_connect_dai_link_widgets(card);

1971

1972

if (card->controls)

1973

snd_soc_add_card_controls(card, card->controls, card->num_controls);

1974

1975

if (card->dapm_routes)

1976

snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,

1977

card->num_dapm_routes);

1978

1979

if (card->of_dapm_routes)

1980

snd_soc_dapm_add_routes(&card->dapm, card->of_dapm_routes,

1981

card->num_of_dapm_routes);

1982

1983

snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),

1984

"%s", card->name);

1985

snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),

1986

"%s", card->long_name ? card->long_name : card->name);

1987

snprintf(card->snd_card->driver, sizeof(card->snd_card->driver),

1988

"%s", card->driver_name ? card->driver_name : card->name);

1989

for (i = 0; i < ARRAY_SIZE(card->snd_card->driver)(sizeof(card->snd_card->driver) / sizeof((card->snd_card
->driver)[0]) + (sizeof(struct { int:-!!(__builtin_types_compatible_p
(typeof((card->snd_card->driver)), typeof(&(card->
snd_card->driver)[0]))); }))); i++) {

1990

switch (card->snd_card->driver[i]) {

1991

case '_':

1992

case '-':

1993

case '\0':

1994

break;

1995

default:

1996

if (!isalnum(card->snd_card->driver[i])(((_ctype[(int)(unsigned char)(card->snd_card->driver[i
])])&(0x01|0x02|0x04)) != 0))

1997

card->snd_card->driver[i] = '_';

1998

break;

1999

}

2000

}

2001

2002

if (card->late_probe) {

2003

ret = card->late_probe(card);

2004

if (ret < 0) {

2005

dev_err(card->dev, "ASoC: %s late_probe() failed: %d\n",

2006

card->name, ret);

2007

goto probe_aux_dev_err;

2008

}

2009

}

2010

2011

snd_soc_dapm_new_widgets(card);

2012

2013

ret = snd_card_register(card->snd_card);

2014

if (ret < 0) {

2015

dev_err(card->dev, "ASoC: failed to register soundcard %d\n",

2016

ret);

2017

goto probe_aux_dev_err;

2018

}

2019

2020

card->instantiated = 1;

2021

snd_soc_dapm_sync(&card->dapm);

2022

mutex_unlock(&card->mutex);

2023

mutex_unlock(&client_mutex);

2024

2025

return 0;

2026

2027

probe_aux_dev_err:

2028

soc_remove_aux_devices(card);

2029

2030

probe_dai_err:

2031

soc_remove_dai_links(card);

2032

2033

card_probe_error:

2034

if (card->remove)

2035

card->remove(card);

2036

2037

snd_soc_dapm_free(&card->dapm);

2038

soc_cleanup_card_debugfs(card);

2039

snd_card_free(card->snd_card);

2040

2041

base_error:

2042

soc_remove_pcm_runtimes(card);

2043

mutex_unlock(&card->mutex);

2044

mutex_unlock(&client_mutex);

2045

2046

return ret;

2047

}

2048

2049

/* probes a new socdev */

2050

static int soc_probe(struct platform_device *pdev)

2051

{

2052

struct snd_soc_card *card = platform_get_drvdata(pdev);

2053

2054

2055

* no card, so machine driver should be registering card

2056

* we should not be here in that case so ret error

2057

2058

if (!card)

2059

return -EINVAL22;

2060

2061

dev_warn(&pdev->dev,

2062

"ASoC: machine %s should use snd_soc_register_card()\n",

2063

card->name);

2064

2065

/* Bodge while we unpick instantiation */

2066

card->dev = &pdev->dev;

2067

2068

return snd_soc_register_card(card);

2069

}

2070

2071

static int soc_cleanup_card_resources(struct snd_soc_card *card)

2072

{

2073

struct snd_soc_pcm_runtime *rtd;

2074

2075

/* make sure any delayed work runs */

2076

2077

flush_delayed_work(&rtd->delayed_work);

2078

2079

/* remove and free each DAI */

2080

soc_remove_dai_links(card);

2081

soc_remove_pcm_runtimes(card);

2082

2083

/* remove auxiliary devices */

2084

soc_remove_aux_devices(card);

2085

2086

snd_soc_dapm_free(&card->dapm);

2087

soc_cleanup_card_debugfs(card);

2088

2089

/* remove the card */

2090

if (card->remove)

2091

card->remove(card);

2092

2093

snd_card_free(card->snd_card);

2094

return 0;

2095

2096

}

2097

2098

/* removes a socdev */

2099

static int soc_remove(struct platform_device *pdev)

2100

{

2101

struct snd_soc_card *card = platform_get_drvdata(pdev);

2102

2103

snd_soc_unregister_card(card);

2104

return 0;

2105

}

2106

2107

int snd_soc_poweroff(struct device *dev)

2108

{

2109

struct snd_soc_card *card = dev_get_drvdata(dev);

2110

struct snd_soc_pcm_runtime *rtd;

2111

2112

if (!card->instantiated)

2113

return 0;

2114

2115

/* Flush out pmdown_time work - we actually do want to run it

2116

* now, we're shutting down so no imminent restart. */

2117

2118

flush_delayed_work(&rtd->delayed_work);

2119

2120

snd_soc_dapm_shutdown(card);

2121

2122

/* deactivate pins to sleep state */

2123

2124

struct snd_soc_dai *cpu_dai = rtd->cpu_dai;

2125

int i;

2126

2127

pinctrl_pm_select_sleep_state(cpu_dai->dev);

2128

for (i = 0; i < rtd->num_codecs; i++) {

2129

struct snd_soc_dai *codec_dai = rtd->codec_dais[i];

2130

pinctrl_pm_select_sleep_state(codec_dai->dev);

2131

}

2132

}

2133

2134

return 0;

2135

}

2136

EXPORT_SYMBOL_GPL(snd_soc_poweroff)extern typeof(snd_soc_poweroff) snd_soc_poweroff; extern void
*__crc_snd_soc_poweroff __attribute__((weak)); static const unsigned
long __kcrctab_snd_soc_poweroff __attribute__((__used__)) __attribute__
((section("___kcrctab" "_gpl" "+" "snd_soc_poweroff"), used))
= (unsigned long) &__crc_snd_soc_poweroff; static const char
__kstrtab_snd_soc_poweroff[] __attribute__((section("__ksymtab_strings"
), aligned(1))) = "snd_soc_poweroff"; static const struct kernel_symbol
__ksymtab_snd_soc_poweroff __attribute__((__used__)) __attribute__
((section("___ksymtab" "_gpl" "+" "snd_soc_poweroff"), used))
= { (unsigned long)&snd_soc_poweroff, __kstrtab_snd_soc_poweroff
};

2137

2138

const struct dev_pm_ops snd_soc_pm_ops = {

2139

.suspend = snd_soc_suspend,

2140

.resume = snd_soc_resume,

2141

.freeze = snd_soc_suspend,

2142

.thaw = snd_soc_resume,

2143

.poweroff = snd_soc_poweroff,

2144

.restore = snd_soc_resume,

2145

};

2146

EXPORT_SYMBOL_GPL(snd_soc_pm_ops)extern typeof(snd_soc_pm_ops) snd_soc_pm_ops; extern void *__crc_snd_soc_pm_ops
__attribute__((weak)); static const unsigned long __kcrctab_snd_soc_pm_ops
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_pm_ops"), used)) = (unsigned long) &
__crc_snd_soc_pm_ops; static const char __kstrtab_snd_soc_pm_ops
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_pm_ops"; static const struct kernel_symbol __ksymtab_snd_soc_pm_ops
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_pm_ops"), used)) = { (unsigned long)&
snd_soc_pm_ops, __kstrtab_snd_soc_pm_ops };

2147

2148

/* ASoC platform driver */

2149

static struct platform_driver soc_driver = {

2150

.driver = {

2151

.name = "soc-audio",

2152

.pm = &snd_soc_pm_ops,

2153

2154

.probe = soc_probe,

2155

.remove = soc_remove,

2156

};

2157

2158

/**

2159

* snd_soc_cnew - create new control

2160

* @_template: control template

2161

* @data: control private data

2162

* @long_name: control long name

2163

* @prefix: control name prefix

2164

2165

* Create a new mixer control from a template control.

2166

2167

* Returns 0 for success, else error.

2168

2169

struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,

2170

void *data, const char *long_name,

2171

const char *prefix)

2172

{

2173

struct snd_kcontrol_new template;

2174

struct snd_kcontrol *kcontrol;

2175

char *name = NULL((void *)0);

2176

2177

memcpy(&template, _template, sizeof(template))({ size_t __len = (sizeof(template)); void *__ret; if (__builtin_constant_p
(sizeof(template)) && __len >= 64) __ret = __memcpy
((&template), (_template), __len); else __ret = __builtin_memcpy
((&template), (_template), __len); __ret; });

2178

template.index = 0;

2179

2180

if (!long_name)

2181

long_name = template.name;

2182

2183

if (prefix) {

2184

name = kasprintf(GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)), "%s %s", prefix, long_name);

2185

if (!name)

2186

return NULL((void *)0);

2187

2188

template.name = name;

2189

} else {

2190

template.name = long_name;

2191

}

2192

2193

kcontrol = snd_ctl_new1(&template, data);

2194

2195

kfree(name);

2196

2197

return kcontrol;

2198

}

2199

EXPORT_SYMBOL_GPL(snd_soc_cnew)extern typeof(snd_soc_cnew) snd_soc_cnew; extern void *__crc_snd_soc_cnew
__attribute__((weak)); static const unsigned long __kcrctab_snd_soc_cnew
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_cnew"), used)) = (unsigned long) &__crc_snd_soc_cnew
; static const char __kstrtab_snd_soc_cnew[] __attribute__((section
("__ksymtab_strings"), aligned(1))) = "snd_soc_cnew"; static const
struct kernel_symbol __ksymtab_snd_soc_cnew __attribute__((__used__
)) __attribute__((section("___ksymtab" "_gpl" "+" "snd_soc_cnew"
), used)) = { (unsigned long)&snd_soc_cnew, __kstrtab_snd_soc_cnew
};

2200

2201

static int snd_soc_add_controls(struct snd_card *card, struct device *dev,

2202

const struct snd_kcontrol_new *controls, int num_controls,

2203

const char *prefix, void *data)

2204

{

2205

int err, i;

2206

2207

for (i = 0; i < num_controls; i++) {

2208

const struct snd_kcontrol_new *control = &controls[i];

2209

err = snd_ctl_add(card, snd_soc_cnew(control, data,

2210

control->name, prefix));

2211

if (err < 0) {

2212

dev_err(dev, "ASoC: Failed to add %s: %d\n",

2213

control->name, err);

2214

return err;

2215

}

2216

}

2217

2218

return 0;

2219

}

2220

2221

struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,

2222

const char *name)

2223

{

2224

struct snd_card *card = soc_card->snd_card;

2225

struct snd_kcontrol *kctl;

2226

2227

if (unlikely(!name)(!name))

2228

return NULL((void *)0);

2229

2230

list_for_each_entry(kctl, &card->controls, list)for (kctl = ({ const typeof( ((typeof(*kctl) *)0)->list ) *
__mptr = ((&card->controls)->next); (typeof(*kctl) *
)( (char *)__mptr - __builtin_offsetof(typeof(*kctl), list) )
;}); &kctl->list != (&card->controls); kctl = (
{ const typeof( ((typeof(*(kctl)) *)0)->list ) *__mptr = (
(kctl)->list.next); (typeof(*(kctl)) *)( (char *)__mptr - __builtin_offsetof
(typeof(*(kctl)), list) );}))

2231

if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name)))

2232

return kctl;

2233

return NULL((void *)0);

2234

}

2235

EXPORT_SYMBOL_GPL(snd_soc_card_get_kcontrol)extern typeof(snd_soc_card_get_kcontrol) snd_soc_card_get_kcontrol
; extern void *__crc_snd_soc_card_get_kcontrol __attribute__(
(weak)); static const unsigned long __kcrctab_snd_soc_card_get_kcontrol
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_card_get_kcontrol"), used)) = (unsigned long
) &__crc_snd_soc_card_get_kcontrol; static const char __kstrtab_snd_soc_card_get_kcontrol
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_card_get_kcontrol"; static const struct kernel_symbol
__ksymtab_snd_soc_card_get_kcontrol __attribute__((__used__)
) __attribute__((section("___ksymtab" "_gpl" "+" "snd_soc_card_get_kcontrol"
), used)) = { (unsigned long)&snd_soc_card_get_kcontrol, __kstrtab_snd_soc_card_get_kcontrol
};

2236

2237

/**

2238

* snd_soc_add_component_controls - Add an array of controls to a component.

2239

2240

* @component: Component to add controls to

2241

* @controls: Array of controls to add

2242

* @num_controls: Number of elements in the array

2243

2244

* Return: 0 for success, else error.

2245

2246

int snd_soc_add_component_controls(struct snd_soc_component *component,

2247

const struct snd_kcontrol_new *controls, unsigned int num_controls)

2248

{

2249

struct snd_card *card = component->card->snd_card;

2250

2251

return snd_soc_add_controls(card, component->dev, controls,

2252

num_controls, component->name_prefix, component);

2253

}

2254

EXPORT_SYMBOL_GPL(snd_soc_add_component_controls)extern typeof(snd_soc_add_component_controls) snd_soc_add_component_controls
; extern void *__crc_snd_soc_add_component_controls __attribute__
((weak)); static const unsigned long __kcrctab_snd_soc_add_component_controls
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_add_component_controls"), used)) = (unsigned
long) &__crc_snd_soc_add_component_controls; static const
char __kstrtab_snd_soc_add_component_controls[] __attribute__
((section("__ksymtab_strings"), aligned(1))) = "snd_soc_add_component_controls"
; static const struct kernel_symbol __ksymtab_snd_soc_add_component_controls
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_add_component_controls"), used)) = { (unsigned
long)&snd_soc_add_component_controls, __kstrtab_snd_soc_add_component_controls
};

2255

2256

/**

2257

* snd_soc_add_codec_controls - add an array of controls to a codec.

2258

* Convenience function to add a list of controls. Many codecs were

2259

* duplicating this code.

2260

2261

* @codec: codec to add controls to

2262

* @controls: array of controls to add

2263

* @num_controls: number of elements in the array

2264

2265

* Return 0 for success, else error.

2266

2267

int snd_soc_add_codec_controls(struct snd_soc_codec *codec,

2268

const struct snd_kcontrol_new *controls, unsigned int num_controls)

2269

{

2270

return snd_soc_add_component_controls(&codec->component, controls,

2271

num_controls);

2272

}

2273

EXPORT_SYMBOL_GPL(snd_soc_add_codec_controls)extern typeof(snd_soc_add_codec_controls) snd_soc_add_codec_controls
; extern void *__crc_snd_soc_add_codec_controls __attribute__
((weak)); static const unsigned long __kcrctab_snd_soc_add_codec_controls
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_add_codec_controls"), used)) = (unsigned
long) &__crc_snd_soc_add_codec_controls; static const char
__kstrtab_snd_soc_add_codec_controls[] __attribute__((section
("__ksymtab_strings"), aligned(1))) = "snd_soc_add_codec_controls"
; static const struct kernel_symbol __ksymtab_snd_soc_add_codec_controls
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_add_codec_controls"), used)) = { (unsigned
long)&snd_soc_add_codec_controls, __kstrtab_snd_soc_add_codec_controls
};

2274

2275

/**

2276

* snd_soc_add_platform_controls - add an array of controls to a platform.

2277

* Convenience function to add a list of controls.

2278

2279

* @platform: platform to add controls to

2280

* @controls: array of controls to add

2281

* @num_controls: number of elements in the array

2282

2283

* Return 0 for success, else error.

2284

2285

int snd_soc_add_platform_controls(struct snd_soc_platform *platform,

2286

const struct snd_kcontrol_new *controls, unsigned int num_controls)

2287

{

2288

return snd_soc_add_component_controls(&platform->component, controls,

2289

num_controls);

2290

}

2291

EXPORT_SYMBOL_GPL(snd_soc_add_platform_controls)extern typeof(snd_soc_add_platform_controls) snd_soc_add_platform_controls
; extern void *__crc_snd_soc_add_platform_controls __attribute__
((weak)); static const unsigned long __kcrctab_snd_soc_add_platform_controls
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_add_platform_controls"), used)) = (unsigned
long) &__crc_snd_soc_add_platform_controls; static const
char __kstrtab_snd_soc_add_platform_controls[] __attribute__
((section("__ksymtab_strings"), aligned(1))) = "snd_soc_add_platform_controls"
; static const struct kernel_symbol __ksymtab_snd_soc_add_platform_controls
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_add_platform_controls"), used)) = { (unsigned
long)&snd_soc_add_platform_controls, __kstrtab_snd_soc_add_platform_controls
};

2292

2293

/**

2294

* snd_soc_add_card_controls - add an array of controls to a SoC card.

2295

* Convenience function to add a list of controls.

2296

2297

* @soc_card: SoC card to add controls to

2298

* @controls: array of controls to add

2299

* @num_controls: number of elements in the array

2300

2301

* Return 0 for success, else error.

2302

2303

int snd_soc_add_card_controls(struct snd_soc_card *soc_card,

2304

const struct snd_kcontrol_new *controls, int num_controls)

2305

{

2306

struct snd_card *card = soc_card->snd_card;

2307

2308

return snd_soc_add_controls(card, soc_card->dev, controls, num_controls,

2309

NULL((void *)0), soc_card);

2310

}

2311

EXPORT_SYMBOL_GPL(snd_soc_add_card_controls)extern typeof(snd_soc_add_card_controls) snd_soc_add_card_controls
; extern void *__crc_snd_soc_add_card_controls __attribute__(
(weak)); static const unsigned long __kcrctab_snd_soc_add_card_controls
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_add_card_controls"), used)) = (unsigned long
) &__crc_snd_soc_add_card_controls; static const char __kstrtab_snd_soc_add_card_controls
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_add_card_controls"; static const struct kernel_symbol
__ksymtab_snd_soc_add_card_controls __attribute__((__used__)
) __attribute__((section("___ksymtab" "_gpl" "+" "snd_soc_add_card_controls"
), used)) = { (unsigned long)&snd_soc_add_card_controls, __kstrtab_snd_soc_add_card_controls
};

2312

2313

/**

2314

* snd_soc_add_dai_controls - add an array of controls to a DAI.

2315

* Convienience function to add a list of controls.

2316

2317

* @dai: DAI to add controls to

2318

* @controls: array of controls to add

2319

* @num_controls: number of elements in the array

2320

2321

* Return 0 for success, else error.

2322

2323

int snd_soc_add_dai_controls(struct snd_soc_dai *dai,

2324

const struct snd_kcontrol_new *controls, int num_controls)

2325

{

2326

struct snd_card *card = dai->component->card->snd_card;

2327

2328

return snd_soc_add_controls(card, dai->dev, controls, num_controls,

2329

NULL((void *)0), dai);

2330

}

2331

EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls)extern typeof(snd_soc_add_dai_controls) snd_soc_add_dai_controls
; extern void *__crc_snd_soc_add_dai_controls __attribute__((
weak)); static const unsigned long __kcrctab_snd_soc_add_dai_controls
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_add_dai_controls"), used)) = (unsigned long
) &__crc_snd_soc_add_dai_controls; static const char __kstrtab_snd_soc_add_dai_controls
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_add_dai_controls"; static const struct kernel_symbol
__ksymtab_snd_soc_add_dai_controls __attribute__((__used__))
__attribute__((section("___ksymtab" "_gpl" "+" "snd_soc_add_dai_controls"
), used)) = { (unsigned long)&snd_soc_add_dai_controls, __kstrtab_snd_soc_add_dai_controls
};

2332

2333

/**

2334

* snd_soc_dai_set_sysclk - configure DAI system or master clock.

2335

* @dai: DAI

2336

* @clk_id: DAI specific clock ID

2337

* @freq: new clock frequency in Hz

2338

* @dir: new clock direction - input/output.

2339

2340

* Configures the DAI master (MCLK) or system (SYSCLK) clocking.

2341

2342

int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,

2343

unsigned int freq, int dir)

2344

{

2345

if (dai->driver && dai->driver->ops->set_sysclk)

2346

return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);

2347

else if (dai->codec && dai->codec->driver->set_sysclk)

2348

return dai->codec->driver->set_sysclk(dai->codec, clk_id, 0,

2349

freq, dir);

2350

else

2351

return -ENOTSUPP524;

2352

}

2353

EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk)extern typeof(snd_soc_dai_set_sysclk) snd_soc_dai_set_sysclk;
extern void *__crc_snd_soc_dai_set_sysclk __attribute__((weak
)); static const unsigned long __kcrctab_snd_soc_dai_set_sysclk
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_dai_set_sysclk"), used)) = (unsigned long
) &__crc_snd_soc_dai_set_sysclk; static const char __kstrtab_snd_soc_dai_set_sysclk
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_dai_set_sysclk"; static const struct kernel_symbol __ksymtab_snd_soc_dai_set_sysclk
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_dai_set_sysclk"), used)) = { (unsigned long
)&snd_soc_dai_set_sysclk, __kstrtab_snd_soc_dai_set_sysclk
};

2354

2355

/**

2356

* snd_soc_codec_set_sysclk - configure CODEC system or master clock.

2357

* @codec: CODEC

2358

* @clk_id: DAI specific clock ID

2359

* @source: Source for the clock

2360

* @freq: new clock frequency in Hz

2361

* @dir: new clock direction - input/output.

2362

2363

* Configures the CODEC master (MCLK) or system (SYSCLK) clocking.

2364

2365

int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,

2366

int source, unsigned int freq, int dir)

2367

{

2368

if (codec->driver->set_sysclk)

2369

return codec->driver->set_sysclk(codec, clk_id, source,

2370

freq, dir);

2371

else

2372

return -ENOTSUPP524;

2373

}

2374

EXPORT_SYMBOL_GPL(snd_soc_codec_set_sysclk)extern typeof(snd_soc_codec_set_sysclk) snd_soc_codec_set_sysclk
; extern void *__crc_snd_soc_codec_set_sysclk __attribute__((
weak)); static const unsigned long __kcrctab_snd_soc_codec_set_sysclk
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_codec_set_sysclk"), used)) = (unsigned long
) &__crc_snd_soc_codec_set_sysclk; static const char __kstrtab_snd_soc_codec_set_sysclk
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_codec_set_sysclk"; static const struct kernel_symbol
__ksymtab_snd_soc_codec_set_sysclk __attribute__((__used__))
__attribute__((section("___ksymtab" "_gpl" "+" "snd_soc_codec_set_sysclk"
), used)) = { (unsigned long)&snd_soc_codec_set_sysclk, __kstrtab_snd_soc_codec_set_sysclk
};

2375

2376

/**

2377

* snd_soc_dai_set_clkdiv - configure DAI clock dividers.

2378

* @dai: DAI

2379

* @div_id: DAI specific clock divider ID

2380

* @div: new clock divisor.

2381

2382

* Configures the clock dividers. This is used to derive the best DAI bit and

2383

* frame clocks from the system or master clock. It's best to set the DAI bit

2384

* and frame clocks as low as possible to save system power.

2385

2386

int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,

2387

int div_id, int div)

2388

{

2389

if (dai->driver && dai->driver->ops->set_clkdiv)

2390

return dai->driver->ops->set_clkdiv(dai, div_id, div);

2391

else

2392

return -EINVAL22;

2393

}

2394

EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv)extern typeof(snd_soc_dai_set_clkdiv) snd_soc_dai_set_clkdiv;
extern void *__crc_snd_soc_dai_set_clkdiv __attribute__((weak
)); static const unsigned long __kcrctab_snd_soc_dai_set_clkdiv
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_dai_set_clkdiv"), used)) = (unsigned long
) &__crc_snd_soc_dai_set_clkdiv; static const char __kstrtab_snd_soc_dai_set_clkdiv
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_dai_set_clkdiv"; static const struct kernel_symbol __ksymtab_snd_soc_dai_set_clkdiv
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_dai_set_clkdiv"), used)) = { (unsigned long
)&snd_soc_dai_set_clkdiv, __kstrtab_snd_soc_dai_set_clkdiv
};

2395

2396

/**

2397

* snd_soc_dai_set_pll - configure DAI PLL.

2398

* @dai: DAI

2399

* @pll_id: DAI specific PLL ID

2400

* @source: DAI specific source for the PLL

2401

* @freq_in: PLL input clock frequency in Hz

2402

* @freq_out: requested PLL output clock frequency in Hz

2403

2404

* Configures and enables PLL to generate output clock based on input clock.

2405

2406

int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,

2407

unsigned int freq_in, unsigned int freq_out)

2408

{

2409

if (dai->driver && dai->driver->ops->set_pll)

2410

return dai->driver->ops->set_pll(dai, pll_id, source,

2411

freq_in, freq_out);

2412

else if (dai->codec && dai->codec->driver->set_pll)

2413

return dai->codec->driver->set_pll(dai->codec, pll_id, source,

2414

freq_in, freq_out);

2415

else

2416

return -EINVAL22;

2417

}

2418

EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll)extern typeof(snd_soc_dai_set_pll) snd_soc_dai_set_pll; extern
void *__crc_snd_soc_dai_set_pll __attribute__((weak)); static
const unsigned long __kcrctab_snd_soc_dai_set_pll __attribute__
((__used__)) __attribute__((section("___kcrctab" "_gpl" "+" "snd_soc_dai_set_pll"
), used)) = (unsigned long) &__crc_snd_soc_dai_set_pll; static
const char __kstrtab_snd_soc_dai_set_pll[] __attribute__((section
("__ksymtab_strings"), aligned(1))) = "snd_soc_dai_set_pll"; static
const struct kernel_symbol __ksymtab_snd_soc_dai_set_pll __attribute__
((__used__)) __attribute__((section("___ksymtab" "_gpl" "+" "snd_soc_dai_set_pll"
), used)) = { (unsigned long)&snd_soc_dai_set_pll, __kstrtab_snd_soc_dai_set_pll
};

2419

2420

2421

* snd_soc_codec_set_pll - configure codec PLL.

2422

* @codec: CODEC

2423

* @pll_id: DAI specific PLL ID

2424

* @source: DAI specific source for the PLL

2425

* @freq_in: PLL input clock frequency in Hz

2426

* @freq_out: requested PLL output clock frequency in Hz

2427

2428

* Configures and enables PLL to generate output clock based on input clock.

2429

2430

int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,

2431

unsigned int freq_in, unsigned int freq_out)

2432

{

2433

if (codec->driver->set_pll)

2434

return codec->driver->set_pll(codec, pll_id, source,

2435

freq_in, freq_out);

2436

else

2437

return -EINVAL22;

2438

}

2439

EXPORT_SYMBOL_GPL(snd_soc_codec_set_pll)extern typeof(snd_soc_codec_set_pll) snd_soc_codec_set_pll; extern
void *__crc_snd_soc_codec_set_pll __attribute__((weak)); static
const unsigned long __kcrctab_snd_soc_codec_set_pll __attribute__
((__used__)) __attribute__((section("___kcrctab" "_gpl" "+" "snd_soc_codec_set_pll"
), used)) = (unsigned long) &__crc_snd_soc_codec_set_pll;
static const char __kstrtab_snd_soc_codec_set_pll[] __attribute__
((section("__ksymtab_strings"), aligned(1))) = "snd_soc_codec_set_pll"
; static const struct kernel_symbol __ksymtab_snd_soc_codec_set_pll
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_codec_set_pll"), used)) = { (unsigned long
)&snd_soc_codec_set_pll, __kstrtab_snd_soc_codec_set_pll };

2440

2441

/**

2442

* snd_soc_dai_set_bclk_ratio - configure BCLK to sample rate ratio.

2443

* @dai: DAI

2444

* @ratio: Ratio of BCLK to Sample rate.

2445

2446

* Configures the DAI for a preset BCLK to sample rate ratio.

2447

2448

int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai *dai, unsigned int ratio)

2449

{

2450

if (dai->driver && dai->driver->ops->set_bclk_ratio)

2451

return dai->driver->ops->set_bclk_ratio(dai, ratio);

2452

else

2453

return -EINVAL22;

2454

}

2455

EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio)extern typeof(snd_soc_dai_set_bclk_ratio) snd_soc_dai_set_bclk_ratio
; extern void *__crc_snd_soc_dai_set_bclk_ratio __attribute__
((weak)); static const unsigned long __kcrctab_snd_soc_dai_set_bclk_ratio
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_dai_set_bclk_ratio"), used)) = (unsigned
long) &__crc_snd_soc_dai_set_bclk_ratio; static const char
__kstrtab_snd_soc_dai_set_bclk_ratio[] __attribute__((section
("__ksymtab_strings"), aligned(1))) = "snd_soc_dai_set_bclk_ratio"
; static const struct kernel_symbol __ksymtab_snd_soc_dai_set_bclk_ratio
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_dai_set_bclk_ratio"), used)) = { (unsigned
long)&snd_soc_dai_set_bclk_ratio, __kstrtab_snd_soc_dai_set_bclk_ratio
};

2456

2457

/**

2458

* snd_soc_dai_set_fmt - configure DAI hardware audio format.

2459

* @dai: DAI

2460

* @fmt: SND_SOC_DAIFMT_ format value.

2461

2462

* Configures the DAI hardware format and clocking.

2463

2464

int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)

2465

{

2466

if (dai->driver == NULL((void *)0))

2467

return -EINVAL22;

2468

if (dai->driver->ops->set_fmt == NULL((void *)0))

2469

return -ENOTSUPP524;

2470

return dai->driver->ops->set_fmt(dai, fmt);

2471

}

2472

EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt)extern typeof(snd_soc_dai_set_fmt) snd_soc_dai_set_fmt; extern
void *__crc_snd_soc_dai_set_fmt __attribute__((weak)); static
const unsigned long __kcrctab_snd_soc_dai_set_fmt __attribute__
((__used__)) __attribute__((section("___kcrctab" "_gpl" "+" "snd_soc_dai_set_fmt"
), used)) = (unsigned long) &__crc_snd_soc_dai_set_fmt; static
const char __kstrtab_snd_soc_dai_set_fmt[] __attribute__((section
("__ksymtab_strings"), aligned(1))) = "snd_soc_dai_set_fmt"; static
const struct kernel_symbol __ksymtab_snd_soc_dai_set_fmt __attribute__
((__used__)) __attribute__((section("___ksymtab" "_gpl" "+" "snd_soc_dai_set_fmt"
), used)) = { (unsigned long)&snd_soc_dai_set_fmt, __kstrtab_snd_soc_dai_set_fmt
};

2473

2474

/**

2475

* snd_soc_xlate_tdm_slot - generate tx/rx slot mask.

2476

* @slots: Number of slots in use.

2477

* @tx_mask: bitmask representing active TX slots.

2478

* @rx_mask: bitmask representing active RX slots.

2479

2480

* Generates the TDM tx and rx slot default masks for DAI.

2481

2482

static int snd_soc_xlate_tdm_slot_mask(unsigned int slots,

2483

unsigned int *tx_mask,

2484

unsigned int *rx_mask)

2485

{

2486

if (*tx_mask || *rx_mask)

2487

return 0;

2488

2489

if (!slots)

2490

return -EINVAL22;

2491

2492

*tx_mask = (1 << slots) - 1;

2493

*rx_mask = (1 << slots) - 1;

2494

2495

return 0;

2496

}

2497

2498

/**

2499

* snd_soc_dai_set_tdm_slot() - Configures a DAI for TDM operation

2500

* @dai: The DAI to configure

2501

* @tx_mask: bitmask representing active TX slots.

2502

* @rx_mask: bitmask representing active RX slots.

2503

* @slots: Number of slots in use.

2504

* @slot_width: Width in bits for each slot.

2505

2506

* This function configures the specified DAI for TDM operation. @slot contains

2507

* the total number of slots of the TDM stream and @slot_with the width of each

2508

* slot in bit clock cycles. @tx_mask and @rx_mask are bitmasks specifying the

2509

* active slots of the TDM stream for the specified DAI, i.e. which slots the

2510

* DAI should write to or read from. If a bit is set the corresponding slot is

2511

* active, if a bit is cleared the corresponding slot is inactive. Bit 0 maps to

2512

* the first slot, bit 1 to the second slot and so on. The first active slot

2513

* maps to the first channel of the DAI, the second active slot to the second

2514

* channel and so on.

2515

2516

* TDM mode can be disabled by passing 0 for @slots. In this case @tx_mask,

2517

* @rx_mask and @slot_width will be ignored.

2518

2519

* Returns 0 on success, a negative error code otherwise.

2520

2521

int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,

2522

unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)

2523

{

2524

if (dai->driver && dai->driver->ops->xlate_tdm_slot_mask)

2525

dai->driver->ops->xlate_tdm_slot_mask(slots,

2526

&tx_mask, &rx_mask);

2527

else

2528

snd_soc_xlate_tdm_slot_mask(slots, &tx_mask, &rx_mask);

2529

2530

dai->tx_mask = tx_mask;

2531

dai->rx_mask = rx_mask;

2532

2533

if (dai->driver && dai->driver->ops->set_tdm_slot)

2534

return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,

2535

slots, slot_width);

2536

else

2537

return -ENOTSUPP524;

2538

}

2539

EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot)extern typeof(snd_soc_dai_set_tdm_slot) snd_soc_dai_set_tdm_slot
; extern void *__crc_snd_soc_dai_set_tdm_slot __attribute__((
weak)); static const unsigned long __kcrctab_snd_soc_dai_set_tdm_slot
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_dai_set_tdm_slot"), used)) = (unsigned long
) &__crc_snd_soc_dai_set_tdm_slot; static const char __kstrtab_snd_soc_dai_set_tdm_slot
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_dai_set_tdm_slot"; static const struct kernel_symbol
__ksymtab_snd_soc_dai_set_tdm_slot __attribute__((__used__))
__attribute__((section("___ksymtab" "_gpl" "+" "snd_soc_dai_set_tdm_slot"
), used)) = { (unsigned long)&snd_soc_dai_set_tdm_slot, __kstrtab_snd_soc_dai_set_tdm_slot
};

2540

2541

/**

2542

* snd_soc_dai_set_channel_map - configure DAI audio channel map

2543

* @dai: DAI

2544

* @tx_num: how many TX channels

2545

* @tx_slot: pointer to an array which imply the TX slot number channel

2546

* 0~num-1 uses

2547

* @rx_num: how many RX channels

2548

* @rx_slot: pointer to an array which imply the RX slot number channel

2549

* 0~num-1 uses

2550

2551

* configure the relationship between channel number and TDM slot number.

2552

2553

int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,

2554

unsigned int tx_num, unsigned int *tx_slot,

2555

unsigned int rx_num, unsigned int *rx_slot)

2556

{

2557

if (dai->driver && dai->driver->ops->set_channel_map)

2558

return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,

2559

rx_num, rx_slot);

2560

else

2561

return -EINVAL22;

2562

}

2563

EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map)extern typeof(snd_soc_dai_set_channel_map) snd_soc_dai_set_channel_map
; extern void *__crc_snd_soc_dai_set_channel_map __attribute__
((weak)); static const unsigned long __kcrctab_snd_soc_dai_set_channel_map
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_dai_set_channel_map"), used)) = (unsigned
long) &__crc_snd_soc_dai_set_channel_map; static const char
__kstrtab_snd_soc_dai_set_channel_map[] __attribute__((section
("__ksymtab_strings"), aligned(1))) = "snd_soc_dai_set_channel_map"
; static const struct kernel_symbol __ksymtab_snd_soc_dai_set_channel_map
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_dai_set_channel_map"), used)) = { (unsigned
long)&snd_soc_dai_set_channel_map, __kstrtab_snd_soc_dai_set_channel_map
};

2564

2565

/**

2566

* snd_soc_dai_set_tristate - configure DAI system or master clock.

2567

* @dai: DAI

2568

* @tristate: tristate enable

2569

2570

* Tristates the DAI so that others can use it.

2571

2572

int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)

2573

{

2574

if (dai->driver && dai->driver->ops->set_tristate)

2575

return dai->driver->ops->set_tristate(dai, tristate);

2576

else

2577

return -EINVAL22;

2578

}

2579

EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate)extern typeof(snd_soc_dai_set_tristate) snd_soc_dai_set_tristate
; extern void *__crc_snd_soc_dai_set_tristate __attribute__((
weak)); static const unsigned long __kcrctab_snd_soc_dai_set_tristate
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_dai_set_tristate"), used)) = (unsigned long
) &__crc_snd_soc_dai_set_tristate; static const char __kstrtab_snd_soc_dai_set_tristate
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_dai_set_tristate"; static const struct kernel_symbol
__ksymtab_snd_soc_dai_set_tristate __attribute__((__used__))
__attribute__((section("___ksymtab" "_gpl" "+" "snd_soc_dai_set_tristate"
), used)) = { (unsigned long)&snd_soc_dai_set_tristate, __kstrtab_snd_soc_dai_set_tristate
};

2580

2581

/**

2582

* snd_soc_dai_digital_mute - configure DAI system or master clock.

2583

* @dai: DAI

2584

* @mute: mute enable

2585

* @direction: stream to mute

2586

2587

* Mutes the DAI DAC.

2588

2589

int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute,

2590

int direction)

2591

{

2592

if (!dai->driver)

2593

return -ENOTSUPP524;

2594

2595

if (dai->driver->ops->mute_stream)

2596

return dai->driver->ops->mute_stream(dai, mute, direction);

2597

else if (direction == SNDRV_PCM_STREAM_PLAYBACK &&

2598

dai->driver->ops->digital_mute)

2599

return dai->driver->ops->digital_mute(dai, mute);

2600

else

2601

return -ENOTSUPP524;

2602

}

2603

EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute)extern typeof(snd_soc_dai_digital_mute) snd_soc_dai_digital_mute
; extern void *__crc_snd_soc_dai_digital_mute __attribute__((
weak)); static const unsigned long __kcrctab_snd_soc_dai_digital_mute
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_dai_digital_mute"), used)) = (unsigned long
) &__crc_snd_soc_dai_digital_mute; static const char __kstrtab_snd_soc_dai_digital_mute
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_dai_digital_mute"; static const struct kernel_symbol
__ksymtab_snd_soc_dai_digital_mute __attribute__((__used__))
__attribute__((section("___ksymtab" "_gpl" "+" "snd_soc_dai_digital_mute"
), used)) = { (unsigned long)&snd_soc_dai_digital_mute, __kstrtab_snd_soc_dai_digital_mute
};

2604

2605

/**

2606

* snd_soc_register_card - Register a card with the ASoC core

2607

2608

* @card: Card to register

2609

2610

2611

int snd_soc_register_card(struct snd_soc_card *card)

2612

{

2613

int i, ret;

2614

struct snd_soc_pcm_runtime *rtd;

2615

2616

if (!card->name || !card->dev)

2617

return -EINVAL22;

2618

2619

for (i = 0; i < card->num_links; i++) {

2620

struct snd_soc_dai_link *link = &card->dai_link[i];

2621

2622

ret = soc_init_dai_link(card, link);

2623

if (ret) {

2624

dev_err(card->dev, "ASoC: failed to init link %s\n",

2625

link->name);

2626

return ret;

2627

}

2628

}

2629

2630

dev_set_drvdata(card->dev, card);

2631

2632

snd_soc_initialize_card_lists(card);

2633

2634

INIT_LIST_HEAD(&card->dai_link_list);

2635

card->num_dai_links = 0;

2636

2637

INIT_LIST_HEAD(&card->rtd_list);

2638

card->num_rtd = 0;

2639

2640

INIT_LIST_HEAD(&card->dapm_dirty);

2641

INIT_LIST_HEAD(&card->dobj_list);

2642

card->instantiated = 0;

2643

mutex_init(&card->mutex)do { static struct lock_class_key __key; __mutex_init((&card
->mutex), "&card->mutex", &__key); } while (0);

2644

mutex_init(&card->dapm_mutex)do { static struct lock_class_key __key; __mutex_init((&card
->dapm_mutex), "&card->dapm_mutex", &__key); } while
(0);

2645

2646

ret = snd_soc_instantiate_card(card);

2647

if (ret != 0)

2648

return ret;

2649

2650

/* deactivate pins to sleep state */

2651

2652

struct snd_soc_dai *cpu_dai = rtd->cpu_dai;

2653

int j;

2654

2655

for (j = 0; j < rtd->num_codecs; j++) {

2656

struct snd_soc_dai *codec_dai = rtd->codec_dais[j];

2657

if (!codec_dai->active)

2658

pinctrl_pm_select_sleep_state(codec_dai->dev);

2659

}

2660

2661

if (!cpu_dai->active)

2662

pinctrl_pm_select_sleep_state(cpu_dai->dev);

2663

}

2664

2665

return ret;

2666

}

2667

EXPORT_SYMBOL_GPL(snd_soc_register_card)extern typeof(snd_soc_register_card) snd_soc_register_card; extern
void *__crc_snd_soc_register_card __attribute__((weak)); static
const unsigned long __kcrctab_snd_soc_register_card __attribute__
((__used__)) __attribute__((section("___kcrctab" "_gpl" "+" "snd_soc_register_card"
), used)) = (unsigned long) &__crc_snd_soc_register_card;
static const char __kstrtab_snd_soc_register_card[] __attribute__
((section("__ksymtab_strings"), aligned(1))) = "snd_soc_register_card"
; static const struct kernel_symbol __ksymtab_snd_soc_register_card
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_register_card"), used)) = { (unsigned long
)&snd_soc_register_card, __kstrtab_snd_soc_register_card };

2668

2669

/**

2670

* snd_soc_unregister_card - Unregister a card with the ASoC core

2671

2672

* @card: Card to unregister

2673

2674

2675

int snd_soc_unregister_card(struct snd_soc_card *card)

2676

{

2677

if (card->instantiated) {

2678

card->instantiated = false;

2679

snd_soc_dapm_shutdown(card);

2680

soc_cleanup_card_resources(card);

2681

dev_dbg(card->dev, "ASoC: Unregistered card '%s'\n", card->name)do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: Unregistered card '%s'\n"), .lineno = 2681, .
flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, card->dev, "ASoC: Unregistered card '%s'\n"
, card->name); } while (0); } while (0);

2682

}

2683

2684

return 0;

2685

}

2686

EXPORT_SYMBOL_GPL(snd_soc_unregister_card)extern typeof(snd_soc_unregister_card) snd_soc_unregister_card
; extern void *__crc_snd_soc_unregister_card __attribute__((weak
)); static const unsigned long __kcrctab_snd_soc_unregister_card
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_unregister_card"), used)) = (unsigned long
) &__crc_snd_soc_unregister_card; static const char __kstrtab_snd_soc_unregister_card
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_unregister_card"; static const struct kernel_symbol
__ksymtab_snd_soc_unregister_card __attribute__((__used__)) __attribute__
((section("___ksymtab" "_gpl" "+" "snd_soc_unregister_card"),
used)) = { (unsigned long)&snd_soc_unregister_card, __kstrtab_snd_soc_unregister_card
};

2687

2688

2689

* Simplify DAI link configuration by removing ".-1" from device names

2690

* and sanitizing names.

2691

2692

static char *fmt_single_name(struct device *dev, int *id)

2693

{

2694

char *found, name[NAME_SIZE32];

2695

int id1, id2;

2696

2697

if (dev_name(dev) == NULL((void *)0))

2698

return NULL((void *)0);

2699

2700

strlcpy(name, dev_name(dev), NAME_SIZE32);

2701

2702

/* are we a "%s.%d" name (platform and SPI components) */

2703

found = strstr(name, dev->driver->name);

2704

if (found) {

2705

/* get ID */

2706

if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {

2707

2708

/* discard ID from name if ID == -1 */

2709

if (*id == -1)

2710

found[strlen(dev->driver->name)] = '\0';

2711

}

2712

2713

} else {

2714

/* I2C component devices are named "bus-addr" */

2715

if (sscanf(name, "%x-%x", &id1, &id2) == 2) {

2716

char tmp[NAME_SIZE32];

2717

2718

/* create unique ID number from I2C addr and bus */

2719

*id = ((id1 & 0xffff) << 16) + id2;

2720

2721

/* sanitize component name for DAI link creation */

2722

snprintf(tmp, NAME_SIZE32, "%s.%s", dev->driver->name, name);

2723

strlcpy(name, tmp, NAME_SIZE32);

2724

} else

2725

*id = 0;

2726

}

2727

2728

return kstrdup(name, GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)));

2729

}

2730

2731

2732

* Simplify DAI link naming for single devices with multiple DAIs by removing

2733

* any ".-1" and using the DAI name (instead of device name).

2734

2735

static inlineinline __attribute__((no_instrument_function)) char *fmt_multiple_name(struct device *dev,

2736

struct snd_soc_dai_driver *dai_drv)

2737

{

2738

if (dai_drv->name == NULL((void *)0)) {

2739

dev_err(dev,

2740

"ASoC: error - multiple DAI %s registered with no name\n",

2741

dev_name(dev));

2742

return NULL((void *)0);

2743

}

2744

2745

return kstrdup(dai_drv->name, GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)));

2746

}

2747

2748

/**

2749

* snd_soc_unregister_dai - Unregister DAIs from the ASoC core

2750

2751

* @component: The component for which the DAIs should be unregistered

2752

2753

static void snd_soc_unregister_dais(struct snd_soc_component *component)

2754

{

2755

struct snd_soc_dai *dai, *_dai;

2756

2757

list_for_each_entry_safe(dai, _dai, &component->dai_list, list)for (dai = ({ const typeof( ((typeof(*dai) *)0)->list ) *__mptr
= ((&component->dai_list)->next); (typeof(*dai) *)
( (char *)__mptr - __builtin_offsetof(typeof(*dai), list) );}
), _dai = ({ const typeof( ((typeof(*(dai)) *)0)->list ) *
__mptr = ((dai)->list.next); (typeof(*(dai)) *)( (char *)__mptr
- __builtin_offsetof(typeof(*(dai)), list) );}); &dai->
list != (&component->dai_list); dai = _dai, _dai = ({ const
typeof( ((typeof(*(_dai)) *)0)->list ) *__mptr = ((_dai)->
list.next); (typeof(*(_dai)) *)( (char *)__mptr - __builtin_offsetof
(typeof(*(_dai)), list) );})) {

2758

dev_dbg(component->dev, "ASoC: Unregistered DAI '%s'\n",do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: Unregistered DAI '%s'\n"), .lineno = 2759, .
flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, component->dev, "ASoC: Unregistered DAI '%s'\n"
, dai->name); } while (0); } while (0)

2759

dai->name)do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: Unregistered DAI '%s'\n"), .lineno = 2759, .
flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, component->dev, "ASoC: Unregistered DAI '%s'\n"
, dai->name); } while (0); } while (0);

2760

list_del(&dai->list);

2761

kfree(dai->name);

2762

kfree(dai);

2763

}

2764

}

2765

2766

/* Create a DAI and add it to the component's DAI list */

2767

static struct snd_soc_dai *soc_add_dai(struct snd_soc_component *component,

2768

struct snd_soc_dai_driver *dai_drv,

2769

bool legacy_dai_naming)

2770

{

2771

struct device *dev = component->dev;

2772

struct snd_soc_dai *dai;

2773

2774

dev_dbg(dev, "ASoC: dynamically register DAI %s\n", dev_name(dev))do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: dynamically register DAI %s\n"), .lineno = 2774
, .flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, dev, "ASoC: dynamically register DAI %s\n",
dev_name(dev)); } while (0); } while (0);

2775

2776

dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)));

2777

if (dai == NULL((void *)0))

2778

return NULL((void *)0);

2779

2780

2781

* Back in the old days when we still had component-less DAIs,

2782

* instead of having a static name, component-less DAIs would

2783

* inherit the name of the parent device so it is possible to

2784

* register multiple instances of the DAI. We still need to keep

2785

* the same naming style even though those DAIs are not

2786

* component-less anymore.

2787

2788

if (legacy_dai_naming &&

2789

(dai_drv->id == 0 || dai_drv->name == NULL((void *)0))) {

2790

dai->name = fmt_single_name(dev, &dai->id);

2791

} else {

2792

dai->name = fmt_multiple_name(dev, dai_drv);

2793

if (dai_drv->id)

2794

dai->id = dai_drv->id;

2795

else

2796

dai->id = component->num_dai;

2797

}

2798

if (dai->name == NULL((void *)0)) {

2799

kfree(dai);

2800

return NULL((void *)0);

2801

}

2802

2803

dai->component = component;

2804

dai->dev = dev;

2805

dai->driver = dai_drv;

2806

if (!dai->driver->ops)

2807

dai->driver->ops = &null_dai_ops;

2808

2809

list_add(&dai->list, &component->dai_list);

2810

component->num_dai++;

2811

2812

dev_dbg(dev, "ASoC: Registered DAI '%s'\n", dai->name)do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: Registered DAI '%s'\n"), .lineno = 2812, .flags
= 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, dev, "ASoC: Registered DAI '%s'\n", dai->
name); } while (0); } while (0);

2813

return dai;

2814

}

2815

2816

/**

2817

* snd_soc_register_dais - Register a DAI with the ASoC core

2818

2819

* @component: The component the DAIs are registered for

2820

* @dai_drv: DAI driver to use for the DAIs

2821

* @count: Number of DAIs

2822

* @legacy_dai_naming: Use the legacy naming scheme and let the DAI inherit the

2823

* parent's name.

2824

2825

static int snd_soc_register_dais(struct snd_soc_component *component,

2826

struct snd_soc_dai_driver *dai_drv, size_t count,

2827

bool legacy_dai_naming)

2828

{

2829

struct device *dev = component->dev;

2830

struct snd_soc_dai *dai;

2831

unsigned int i;

2832

int ret;

2833

2834

dev_dbg(dev, "ASoC: dai register %s #%Zu\n", dev_name(dev), count)do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: dai register %s #%Zu\n"), .lineno = 2834, .flags
= 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, dev, "ASoC: dai register %s #%Zu\n", dev_name
(dev), count); } while (0); } while (0);

2835

2836

component->dai_drv = dai_drv;

2837

2838

for (i = 0; i < count; i++) {

2839

2840

dai = soc_add_dai(component, dai_drv + i,

2841

count == 1 && legacy_dai_naming);

2842

if (dai == NULL((void *)0)) {

2843

ret = -ENOMEM12;

2844

goto err;

2845

}

2846

}

2847

2848

return 0;

2849

2850

err:

2851

snd_soc_unregister_dais(component);

2852

2853

return ret;

2854

}

2855

2856

/**

2857

* snd_soc_register_dai - Register a DAI dynamically & create its widgets

2858

2859

* @component: The component the DAIs are registered for

2860

* @dai_drv: DAI driver to use for the DAI

2861

2862

* Topology can use this API to register DAIs when probing a component.

2863

* These DAIs's widgets will be freed in the card cleanup and the DAIs

2864

* will be freed in the component cleanup.

2865

2866

int snd_soc_register_dai(struct snd_soc_component *component,

2867

struct snd_soc_dai_driver *dai_drv)

2868

{

2869

struct snd_soc_dapm_context *dapm =

2870

snd_soc_component_get_dapm(component);

2871

struct snd_soc_dai *dai;

2872

int ret;

2873

2874

if (dai_drv->dobj.type != SND_SOC_DOBJ_PCM) {

2875

dev_err(component->dev, "Invalid dai type %d\n",

2876

dai_drv->dobj.type);

2877

return -EINVAL22;

2878

}

2879

2880

2881

dai = soc_add_dai(component, dai_drv, false);

2882

if (!dai)

2883

return -ENOMEM12;

2884

2885

/* Create the DAI widgets here. After adding DAIs, topology may

2886

* also add routes that need these widgets as source or sink.

2887

2888

ret = snd_soc_dapm_new_dai_widgets(dapm, dai);

2889

if (ret != 0) {

2890

dev_err(component->dev,

2891

"Failed to create DAI widgets %d\n", ret);

2892

}

2893

2894

return ret;

2895

}

2896

EXPORT_SYMBOL_GPL(snd_soc_register_dai)extern typeof(snd_soc_register_dai) snd_soc_register_dai; extern
void *__crc_snd_soc_register_dai __attribute__((weak)); static
const unsigned long __kcrctab_snd_soc_register_dai __attribute__
((__used__)) __attribute__((section("___kcrctab" "_gpl" "+" "snd_soc_register_dai"
), used)) = (unsigned long) &__crc_snd_soc_register_dai; static
const char __kstrtab_snd_soc_register_dai[] __attribute__((section
("__ksymtab_strings"), aligned(1))) = "snd_soc_register_dai";
static const struct kernel_symbol __ksymtab_snd_soc_register_dai
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_register_dai"), used)) = { (unsigned long
)&snd_soc_register_dai, __kstrtab_snd_soc_register_dai };

2897

2898

static void snd_soc_component_seq_notifier(struct snd_soc_dapm_context *dapm,

2899

enum snd_soc_dapm_type type, int subseq)

2900

{

2901

struct snd_soc_component *component = dapm->component;

2902

2903

component->driver->seq_notifier(component, type, subseq);

2904

}

2905

2906

static int snd_soc_component_stream_event(struct snd_soc_dapm_context *dapm,

2907

int event)

2908

{

2909

struct snd_soc_component *component = dapm->component;

2910

2911

return component->driver->stream_event(component, event);

2912

}

2913

2914

static int snd_soc_component_initialize(struct snd_soc_component *component,

2915

const struct snd_soc_component_driver *driver, struct device *dev)

2916

{

2917

struct snd_soc_dapm_context *dapm;

2918

2919

component->name = fmt_single_name(dev, &component->id);

2920

if (!component->name) {

2921

dev_err(dev, "ASoC: Failed to allocate name\n");

2922

return -ENOMEM12;

2923

}

2924

2925

component->dev = dev;

2926

component->driver = driver;

2927

component->probe = component->driver->probe;

2928

component->remove = component->driver->remove;

2929

2930

dapm = &component->dapm;

2931

dapm->dev = dev;

2932

dapm->component = component;

2933

dapm->bias_level = SND_SOC_BIAS_OFF;

2934

dapm->idle_bias_off = true;

2935

if (driver->seq_notifier)

2936

dapm->seq_notifier = snd_soc_component_seq_notifier;

2937

if (driver->stream_event)

2938

dapm->stream_event = snd_soc_component_stream_event;

2939

2940

component->controls = driver->controls;

2941

component->num_controls = driver->num_controls;

2942

component->dapm_widgets = driver->dapm_widgets;

2943

component->num_dapm_widgets = driver->num_dapm_widgets;

2944

component->dapm_routes = driver->dapm_routes;

2945

component->num_dapm_routes = driver->num_dapm_routes;

2946

2947

INIT_LIST_HEAD(&component->dai_list);

2948

mutex_init(&component->io_mutex)do { static struct lock_class_key __key; __mutex_init((&component
->io_mutex), "&component->io_mutex", &__key); }
while (0);

2949

2950

return 0;

2951

}

2952

2953

static void snd_soc_component_setup_regmap(struct snd_soc_component *component)

2954

{

2955

int val_bytes = regmap_get_val_bytes(component->regmap);

2956

2957

/* Errors are legitimate for non-integer byte multiples */

2958

if (val_bytes > 0)

2959

component->val_bytes = val_bytes;

2960

}

2961

2962

#ifdef CONFIG_REGMAP1

2963

2964

/**

2965

* snd_soc_component_init_regmap() - Initialize regmap instance for the component

2966

* @component: The component for which to initialize the regmap instance

2967

* @regmap: The regmap instance that should be used by the component

2968

2969

* This function allows deferred assignment of the regmap instance that is

2970

* associated with the component. Only use this if the regmap instance is not

2971

* yet ready when the component is registered. The function must also be called

2972

* before the first IO attempt of the component.

2973

2974

void snd_soc_component_init_regmap(struct snd_soc_component *component,

2975

struct regmap *regmap)

2976

{

2977

component->regmap = regmap;

2978

snd_soc_component_setup_regmap(component);

2979

}

2980

EXPORT_SYMBOL_GPL(snd_soc_component_init_regmap)extern typeof(snd_soc_component_init_regmap) snd_soc_component_init_regmap
; extern void *__crc_snd_soc_component_init_regmap __attribute__
((weak)); static const unsigned long __kcrctab_snd_soc_component_init_regmap
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_component_init_regmap"), used)) = (unsigned
long) &__crc_snd_soc_component_init_regmap; static const
char __kstrtab_snd_soc_component_init_regmap[] __attribute__
((section("__ksymtab_strings"), aligned(1))) = "snd_soc_component_init_regmap"
; static const struct kernel_symbol __ksymtab_snd_soc_component_init_regmap
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_component_init_regmap"), used)) = { (unsigned
long)&snd_soc_component_init_regmap, __kstrtab_snd_soc_component_init_regmap
};

2981

2982

/**

2983

* snd_soc_component_exit_regmap() - De-initialize regmap instance for the component

2984

* @component: The component for which to de-initialize the regmap instance

2985

2986

* Calls regmap_exit() on the regmap instance associated to the component and

2987

* removes the regmap instance from the component.

2988

2989

* This function should only be used if snd_soc_component_init_regmap() was used

2990

* to initialize the regmap instance.

2991

2992

void snd_soc_component_exit_regmap(struct snd_soc_component *component)

2993

{

2994

regmap_exit(component->regmap);

2995

component->regmap = NULL((void *)0);

2996

}

2997

EXPORT_SYMBOL_GPL(snd_soc_component_exit_regmap)extern typeof(snd_soc_component_exit_regmap) snd_soc_component_exit_regmap
; extern void *__crc_snd_soc_component_exit_regmap __attribute__
((weak)); static const unsigned long __kcrctab_snd_soc_component_exit_regmap
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_component_exit_regmap"), used)) = (unsigned
long) &__crc_snd_soc_component_exit_regmap; static const
char __kstrtab_snd_soc_component_exit_regmap[] __attribute__
((section("__ksymtab_strings"), aligned(1))) = "snd_soc_component_exit_regmap"
; static const struct kernel_symbol __ksymtab_snd_soc_component_exit_regmap
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_component_exit_regmap"), used)) = { (unsigned
long)&snd_soc_component_exit_regmap, __kstrtab_snd_soc_component_exit_regmap
};

2998

2999

#endif

3000

3001

static void snd_soc_component_add_unlocked(struct snd_soc_component *component)

3002

{

3003

if (!component->write && !component->read) {

3004

if (!component->regmap)

3005

component->regmap = dev_get_regmap(component->dev, NULL((void *)0));

3006

if (component->regmap)

3007

snd_soc_component_setup_regmap(component);

3008

}

3009

3010

list_add(&component->list, &component_list);

3011

INIT_LIST_HEAD(&component->dobj_list);

3012

}

3013

3014

static void snd_soc_component_add(struct snd_soc_component *component)

3015

{

3016

mutex_lock(&client_mutex)mutex_lock_nested(&client_mutex, 0);

3017

snd_soc_component_add_unlocked(component);

3018

mutex_unlock(&client_mutex);

3019

}

3020

3021

static void snd_soc_component_cleanup(struct snd_soc_component *component)

3022

{

3023

snd_soc_unregister_dais(component);

3024

kfree(component->name);

3025

}

3026

3027

static void snd_soc_component_del_unlocked(struct snd_soc_component *component)

3028

{

3029

list_del(&component->list);

3030

}

3031

3032

int snd_soc_register_component(struct device *dev,

3033

const struct snd_soc_component_driver *cmpnt_drv,

3034

struct snd_soc_dai_driver *dai_drv,

3035

int num_dai)

3036

{

3037

struct snd_soc_component *cmpnt;

3038

int ret;

3039

3040

cmpnt = kzalloc(sizeof(*cmpnt), GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)));

3041

if (!cmpnt) {

3042

dev_err(dev, "ASoC: Failed to allocate memory\n");

3043

return -ENOMEM12;

3044

}

3045

3046

ret = snd_soc_component_initialize(cmpnt, cmpnt_drv, dev);

3047

if (ret)

3048

goto err_free;

3049

3050

cmpnt->ignore_pmdown_time = true;

3051

cmpnt->registered_as_component = true;

3052

3053

ret = snd_soc_register_dais(cmpnt, dai_drv, num_dai, true);

3054

if (ret < 0) {

3055

dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);

3056

goto err_cleanup;

3057

}

3058

3059

snd_soc_component_add(cmpnt);

3060

3061

return 0;

3062

3063

err_cleanup:

3064

snd_soc_component_cleanup(cmpnt);

3065

err_free:

3066

kfree(cmpnt);

3067

return ret;

3068

}

3069

EXPORT_SYMBOL_GPL(snd_soc_register_component)extern typeof(snd_soc_register_component) snd_soc_register_component
; extern void *__crc_snd_soc_register_component __attribute__
((weak)); static const unsigned long __kcrctab_snd_soc_register_component
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_register_component"), used)) = (unsigned
long) &__crc_snd_soc_register_component; static const char
__kstrtab_snd_soc_register_component[] __attribute__((section
("__ksymtab_strings"), aligned(1))) = "snd_soc_register_component"
; static const struct kernel_symbol __ksymtab_snd_soc_register_component
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_register_component"), used)) = { (unsigned
long)&snd_soc_register_component, __kstrtab_snd_soc_register_component
};

3070

3071

/**

3072

* snd_soc_unregister_component - Unregister a component from the ASoC core

3073

3074

* @dev: The device to unregister

3075

3076

void snd_soc_unregister_component(struct device *dev)

3077

{

3078

struct snd_soc_component *cmpnt;

3079

3080

mutex_lock(&client_mutex)mutex_lock_nested(&client_mutex, 0);

3081

list_for_each_entry(cmpnt, &component_list, list)for (cmpnt = ({ const typeof( ((typeof(*cmpnt) *)0)->list )
*__mptr = ((&component_list)->next); (typeof(*cmpnt) *
)( (char *)__mptr - __builtin_offsetof(typeof(*cmpnt), list) )
;}); &cmpnt->list != (&component_list); cmpnt = ({
const typeof( ((typeof(*(cmpnt)) *)0)->list ) *__mptr = (
(cmpnt)->list.next); (typeof(*(cmpnt)) *)( (char *)__mptr -
__builtin_offsetof(typeof(*(cmpnt)), list) );})) {

3082

if (dev == cmpnt->dev && cmpnt->registered_as_component)

3083

goto found;

3084

}

3085

mutex_unlock(&client_mutex);

3086

return;

3087

3088

found:

3089

snd_soc_tplg_component_remove(cmpnt, SND_SOC_TPLG_INDEX_ALL0);

3090

snd_soc_component_del_unlocked(cmpnt);

3091

mutex_unlock(&client_mutex);

3092

snd_soc_component_cleanup(cmpnt);

3093

kfree(cmpnt);

3094

}

3095

EXPORT_SYMBOL_GPL(snd_soc_unregister_component)extern typeof(snd_soc_unregister_component) snd_soc_unregister_component
; extern void *__crc_snd_soc_unregister_component __attribute__
((weak)); static const unsigned long __kcrctab_snd_soc_unregister_component
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_unregister_component"), used)) = (unsigned
long) &__crc_snd_soc_unregister_component; static const char
__kstrtab_snd_soc_unregister_component[] __attribute__((section
("__ksymtab_strings"), aligned(1))) = "snd_soc_unregister_component"
; static const struct kernel_symbol __ksymtab_snd_soc_unregister_component
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_unregister_component"), used)) = { (unsigned
long)&snd_soc_unregister_component, __kstrtab_snd_soc_unregister_component
};

3096

3097

static int snd_soc_platform_drv_probe(struct snd_soc_component *component)

3098

{

3099

struct snd_soc_platform *platform = snd_soc_component_to_platform(component);

3100

3101

return platform->driver->probe(platform);

3102

}

3103

3104

static void snd_soc_platform_drv_remove(struct snd_soc_component *component)

3105

{

3106

struct snd_soc_platform *platform = snd_soc_component_to_platform(component);

3107

3108

platform->driver->remove(platform);

3109

}

3110

3111

/**

3112

* snd_soc_add_platform - Add a platform to the ASoC core

3113

* @dev: The parent device for the platform

3114

* @platform: The platform to add

3115

* @platform_drv: The driver for the platform

3116

3117

int snd_soc_add_platform(struct device *dev, struct snd_soc_platform *platform,

3118

const struct snd_soc_platform_driver *platform_drv)

3119

{

3120

int ret;

3121

3122

ret = snd_soc_component_initialize(&platform->component,

3123

&platform_drv->component_driver, dev);

3124

if (ret)

3125

return ret;

3126

3127

platform->dev = dev;

3128

platform->driver = platform_drv;

3129

3130

if (platform_drv->probe)

3131

platform->component.probe = snd_soc_platform_drv_probe;

3132

if (platform_drv->remove)

3133

platform->component.remove = snd_soc_platform_drv_remove;

3134

3135

#ifdef CONFIG_DEBUG_FS1

3136

platform->component.debugfs_prefix = "platform";

3137

#endif

3138

3139

mutex_lock(&client_mutex)mutex_lock_nested(&client_mutex, 0);

3140

snd_soc_component_add_unlocked(&platform->component);

3141

list_add(&platform->list, &platform_list);

3142

mutex_unlock(&client_mutex);

3143

3144

dev_dbg(dev, "ASoC: Registered platform '%s'\n",do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: Registered platform '%s'\n"), .lineno = 3145
, .flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, dev, "ASoC: Registered platform '%s'\n", platform
->component.name); } while (0); } while (0)

3145

platform->component.name)do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: Registered platform '%s'\n"), .lineno = 3145
, .flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, dev, "ASoC: Registered platform '%s'\n", platform
->component.name); } while (0); } while (0);

3146

3147

return 0;

3148

}

3149

EXPORT_SYMBOL_GPL(snd_soc_add_platform)extern typeof(snd_soc_add_platform) snd_soc_add_platform; extern
void *__crc_snd_soc_add_platform __attribute__((weak)); static
const unsigned long __kcrctab_snd_soc_add_platform __attribute__
((__used__)) __attribute__((section("___kcrctab" "_gpl" "+" "snd_soc_add_platform"
), used)) = (unsigned long) &__crc_snd_soc_add_platform; static
const char __kstrtab_snd_soc_add_platform[] __attribute__((section
("__ksymtab_strings"), aligned(1))) = "snd_soc_add_platform";
static const struct kernel_symbol __ksymtab_snd_soc_add_platform
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_add_platform"), used)) = { (unsigned long
)&snd_soc_add_platform, __kstrtab_snd_soc_add_platform };

3150

3151

/**

3152

* snd_soc_register_platform - Register a platform with the ASoC core

3153

3154

* @dev: The device for the platform

3155

* @platform_drv: The driver for the platform

3156

3157

int snd_soc_register_platform(struct device *dev,

3158

const struct snd_soc_platform_driver *platform_drv)

3159

{

3160

struct snd_soc_platform *platform;

3161

int ret;

3162

3163

dev_dbg(dev, "ASoC: platform register %s\n", dev_name(dev))do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: platform register %s\n"), .lineno = 3163, .flags
= 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, dev, "ASoC: platform register %s\n", dev_name
(dev)); } while (0); } while (0);

3164

3165

platform = kzalloc(sizeof(struct snd_soc_platform), GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)));

3166

if (platform == NULL((void *)0))

3167

return -ENOMEM12;

3168

3169

ret = snd_soc_add_platform(dev, platform, platform_drv);

3170

if (ret)

3171

kfree(platform);

3172

3173

return ret;

3174

}

3175

EXPORT_SYMBOL_GPL(snd_soc_register_platform)extern typeof(snd_soc_register_platform) snd_soc_register_platform
; extern void *__crc_snd_soc_register_platform __attribute__(
(weak)); static const unsigned long __kcrctab_snd_soc_register_platform
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_register_platform"), used)) = (unsigned long
) &__crc_snd_soc_register_platform; static const char __kstrtab_snd_soc_register_platform
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_register_platform"; static const struct kernel_symbol
__ksymtab_snd_soc_register_platform __attribute__((__used__)
) __attribute__((section("___ksymtab" "_gpl" "+" "snd_soc_register_platform"
), used)) = { (unsigned long)&snd_soc_register_platform, __kstrtab_snd_soc_register_platform
};

3176

3177

/**

3178

* snd_soc_remove_platform - Remove a platform from the ASoC core

3179

* @platform: the platform to remove

3180

3181

void snd_soc_remove_platform(struct snd_soc_platform *platform)

3182

{

3183

3184

mutex_lock(&client_mutex)mutex_lock_nested(&client_mutex, 0);

3185

list_del(&platform->list);

3186

snd_soc_component_del_unlocked(&platform->component);

3187

mutex_unlock(&client_mutex);

3188

3189

dev_dbg(platform->dev, "ASoC: Unregistered platform '%s'\n",do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: Unregistered platform '%s'\n"), .lineno = 3190
, .flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, platform->dev, "ASoC: Unregistered platform '%s'\n"
, platform->component.name); } while (0); } while (0)

3190

platform->component.name)do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: Unregistered platform '%s'\n"), .lineno = 3190
, .flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, platform->dev, "ASoC: Unregistered platform '%s'\n"
, platform->component.name); } while (0); } while (0);

3191

3192

snd_soc_component_cleanup(&platform->component);

3193

}

3194

EXPORT_SYMBOL_GPL(snd_soc_remove_platform)extern typeof(snd_soc_remove_platform) snd_soc_remove_platform
; extern void *__crc_snd_soc_remove_platform __attribute__((weak
)); static const unsigned long __kcrctab_snd_soc_remove_platform
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_remove_platform"), used)) = (unsigned long
) &__crc_snd_soc_remove_platform; static const char __kstrtab_snd_soc_remove_platform
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_remove_platform"; static const struct kernel_symbol
__ksymtab_snd_soc_remove_platform __attribute__((__used__)) __attribute__
((section("___ksymtab" "_gpl" "+" "snd_soc_remove_platform"),
used)) = { (unsigned long)&snd_soc_remove_platform, __kstrtab_snd_soc_remove_platform
};

3195

3196

struct snd_soc_platform *snd_soc_lookup_platform(struct device *dev)

3197

{

3198

struct snd_soc_platform *platform;

3199

3200

mutex_lock(&client_mutex)mutex_lock_nested(&client_mutex, 0);

3201

3202

if (dev == platform->dev) {

3203

mutex_unlock(&client_mutex);

3204

return platform;

3205

}

3206

}

3207

mutex_unlock(&client_mutex);

3208

3209

return NULL((void *)0);

3210

}

3211

EXPORT_SYMBOL_GPL(snd_soc_lookup_platform)extern typeof(snd_soc_lookup_platform) snd_soc_lookup_platform
; extern void *__crc_snd_soc_lookup_platform __attribute__((weak
)); static const unsigned long __kcrctab_snd_soc_lookup_platform
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_lookup_platform"), used)) = (unsigned long
) &__crc_snd_soc_lookup_platform; static const char __kstrtab_snd_soc_lookup_platform
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_lookup_platform"; static const struct kernel_symbol
__ksymtab_snd_soc_lookup_platform __attribute__((__used__)) __attribute__
((section("___ksymtab" "_gpl" "+" "snd_soc_lookup_platform"),
used)) = { (unsigned long)&snd_soc_lookup_platform, __kstrtab_snd_soc_lookup_platform
};

3212

3213

/**

3214

* snd_soc_unregister_platform - Unregister a platform from the ASoC core

3215

3216

* @dev: platform to unregister

3217

3218

void snd_soc_unregister_platform(struct device *dev)

3219

{

3220

struct snd_soc_platform *platform;

3221

3222

platform = snd_soc_lookup_platform(dev);

3223

if (!platform)

3224

return;

3225

3226

snd_soc_remove_platform(platform);

3227

kfree(platform);

3228

}

3229

EXPORT_SYMBOL_GPL(snd_soc_unregister_platform)extern typeof(snd_soc_unregister_platform) snd_soc_unregister_platform
; extern void *__crc_snd_soc_unregister_platform __attribute__
((weak)); static const unsigned long __kcrctab_snd_soc_unregister_platform
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_unregister_platform"), used)) = (unsigned
long) &__crc_snd_soc_unregister_platform; static const char
__kstrtab_snd_soc_unregister_platform[] __attribute__((section
("__ksymtab_strings"), aligned(1))) = "snd_soc_unregister_platform"
; static const struct kernel_symbol __ksymtab_snd_soc_unregister_platform
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_unregister_platform"), used)) = { (unsigned
long)&snd_soc_unregister_platform, __kstrtab_snd_soc_unregister_platform
};

3230

3231

static u64 codec_format_map[] = {

3232

SNDRV_PCM_FMTBIT_S16_LE(1ULL << ( int)(( snd_pcm_format_t) 2)) | SNDRV_PCM_FMTBIT_S16_BE(1ULL << ( int)(( snd_pcm_format_t) 3)),

3233

SNDRV_PCM_FMTBIT_U16_LE(1ULL << ( int)(( snd_pcm_format_t) 4)) | SNDRV_PCM_FMTBIT_U16_BE(1ULL << ( int)(( snd_pcm_format_t) 5)),

3234

SNDRV_PCM_FMTBIT_S24_LE(1ULL << ( int)(( snd_pcm_format_t) 6)) | SNDRV_PCM_FMTBIT_S24_BE(1ULL << ( int)(( snd_pcm_format_t) 7)),

3235

SNDRV_PCM_FMTBIT_U24_LE(1ULL << ( int)(( snd_pcm_format_t) 8)) | SNDRV_PCM_FMTBIT_U24_BE(1ULL << ( int)(( snd_pcm_format_t) 9)),

3236

SNDRV_PCM_FMTBIT_S32_LE(1ULL << ( int)(( snd_pcm_format_t) 10)) | SNDRV_PCM_FMTBIT_S32_BE(1ULL << ( int)(( snd_pcm_format_t) 11)),

3237

SNDRV_PCM_FMTBIT_U32_LE(1ULL << ( int)(( snd_pcm_format_t) 12)) | SNDRV_PCM_FMTBIT_U32_BE(1ULL << ( int)(( snd_pcm_format_t) 13)),

3238

SNDRV_PCM_FMTBIT_S24_3LE(1ULL << ( int)(( snd_pcm_format_t) 32)) | SNDRV_PCM_FMTBIT_U24_3BE(1ULL << ( int)(( snd_pcm_format_t) 35)),

3239

SNDRV_PCM_FMTBIT_U24_3LE(1ULL << ( int)(( snd_pcm_format_t) 34)) | SNDRV_PCM_FMTBIT_U24_3BE(1ULL << ( int)(( snd_pcm_format_t) 35)),

3240

SNDRV_PCM_FMTBIT_S20_3LE(1ULL << ( int)(( snd_pcm_format_t) 36)) | SNDRV_PCM_FMTBIT_S20_3BE(1ULL << ( int)(( snd_pcm_format_t) 37)),

3241

SNDRV_PCM_FMTBIT_U20_3LE(1ULL << ( int)(( snd_pcm_format_t) 38)) | SNDRV_PCM_FMTBIT_U20_3BE(1ULL << ( int)(( snd_pcm_format_t) 39)),

3242

SNDRV_PCM_FMTBIT_S18_3LE(1ULL << ( int)(( snd_pcm_format_t) 40)) | SNDRV_PCM_FMTBIT_S18_3BE(1ULL << ( int)(( snd_pcm_format_t) 41)),

3243

SNDRV_PCM_FMTBIT_U18_3LE(1ULL << ( int)(( snd_pcm_format_t) 42)) | SNDRV_PCM_FMTBIT_U18_3BE(1ULL << ( int)(( snd_pcm_format_t) 43)),

3244

SNDRV_PCM_FMTBIT_FLOAT_LE(1ULL << ( int)(( snd_pcm_format_t) 14)) | SNDRV_PCM_FMTBIT_FLOAT_BE(1ULL << ( int)(( snd_pcm_format_t) 15)),

3245

SNDRV_PCM_FMTBIT_FLOAT64_LE(1ULL << ( int)(( snd_pcm_format_t) 16)) | SNDRV_PCM_FMTBIT_FLOAT64_BE(1ULL << ( int)(( snd_pcm_format_t) 17)),

3246

SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE(1ULL << ( int)(( snd_pcm_format_t) 18))

3247

| SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE(1ULL << ( int)(( snd_pcm_format_t) 19)),

3248

};

3249

3250

/* Fix up the DAI formats for endianness: codecs don't actually see

3251

* the endianness of the data but we're using the CPU format

3252

* definitions which do need to include endianness so we ensure that

3253

* codec DAIs always have both big and little endian variants set.

3254

3255

static void fixup_codec_formats(struct snd_soc_pcm_stream *stream)

3256

{

3257

int i;

3258

3259

for (i = 0; i < ARRAY_SIZE(codec_format_map)(sizeof(codec_format_map) / sizeof((codec_format_map)[0]) + (
sizeof(struct { int:-!!(__builtin_types_compatible_p(typeof((
codec_format_map)), typeof(&(codec_format_map)[0]))); }))
); i++)

3260

if (stream->formats & codec_format_map[i])

3261

stream->formats |= codec_format_map[i];

3262

}

3263

3264

static int snd_soc_codec_drv_probe(struct snd_soc_component *component)

3265

{

3266

struct snd_soc_codec *codec = snd_soc_component_to_codec(component);

3267

3268

return codec->driver->probe(codec);

3269

}

3270

3271

static void snd_soc_codec_drv_remove(struct snd_soc_component *component)

3272

{

3273

struct snd_soc_codec *codec = snd_soc_component_to_codec(component);

3274

3275

codec->driver->remove(codec);

3276

}

3277

3278

static int snd_soc_codec_drv_write(struct snd_soc_component *component,

3279

unsigned int reg, unsigned int val)

3280

{

3281

struct snd_soc_codec *codec = snd_soc_component_to_codec(component);

3282

3283

return codec->driver->write(codec, reg, val);

3284

}

3285

3286

static int snd_soc_codec_drv_read(struct snd_soc_component *component,

3287

unsigned int reg, unsigned int *val)

3288

{

3289

struct snd_soc_codec *codec = snd_soc_component_to_codec(component);

3290

3291

*val = codec->driver->read(codec, reg);

3292

3293

return 0;

3294

}

3295

3296

static int snd_soc_codec_set_bias_level(struct snd_soc_dapm_context *dapm,

3297

enum snd_soc_bias_level level)

3298

{

3299

struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm);

3300

3301

return codec->driver->set_bias_level(codec, level);

3302

}

3303

3304

/**

3305

* snd_soc_register_codec - Register a codec with the ASoC core

3306

3307

* @dev: The parent device for this codec

3308

* @codec_drv: Codec driver

3309

* @dai_drv: The associated DAI driver

3310

* @num_dai: Number of DAIs

3311

3312

int snd_soc_register_codec(struct device *dev,

3313

const struct snd_soc_codec_driver *codec_drv,

3314

struct snd_soc_dai_driver *dai_drv,

3315

int num_dai)

3316

{

3317

struct snd_soc_dapm_context *dapm;

3318

struct snd_soc_codec *codec;

3319

struct snd_soc_dai *dai;

3320

int ret, i;

3321

3322

dev_dbg(dev, "codec register %s\n", dev_name(dev))do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("codec register %s\n"), .lineno = 3322, .flags = 0,
}; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, dev, "codec register %s\n", dev_name(dev));
} while (0); } while (0);

3323

3324

codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)));

3325

if (codec == NULL((void *)0))

3326

return -ENOMEM12;

3327

3328

codec->component.codec = codec;

3329

3330

ret = snd_soc_component_initialize(&codec->component,

3331

&codec_drv->component_driver, dev);

3332

if (ret)

3333

goto err_free;

3334

3335

if (codec_drv->probe)

3336

codec->component.probe = snd_soc_codec_drv_probe;

3337

if (codec_drv->remove)

3338

codec->component.remove = snd_soc_codec_drv_remove;

3339

if (codec_drv->write)

3340

codec->component.write = snd_soc_codec_drv_write;

3341

if (codec_drv->read)

3342

codec->component.read = snd_soc_codec_drv_read;

3343

codec->component.ignore_pmdown_time = codec_drv->ignore_pmdown_time;

3344

3345

dapm = snd_soc_codec_get_dapm(codec);

3346

dapm->idle_bias_off = codec_drv->idle_bias_off;

3347

dapm->suspend_bias_off = codec_drv->suspend_bias_off;

3348

if (codec_drv->seq_notifier)

3349

dapm->seq_notifier = codec_drv->seq_notifier;

3350

if (codec_drv->set_bias_level)

3351

dapm->set_bias_level = snd_soc_codec_set_bias_level;

3352

codec->dev = dev;

3353

codec->driver = codec_drv;

3354

codec->component.val_bytes = codec_drv->reg_word_size;

3355

3356

#ifdef CONFIG_DEBUG_FS1

3357

codec->component.init_debugfs = soc_init_codec_debugfs;

3358

codec->component.debugfs_prefix = "codec";

3359

#endif

3360

3361

if (codec_drv->get_regmap)

3362

codec->component.regmap = codec_drv->get_regmap(dev);

3363

3364

for (i = 0; i < num_dai; i++) {

3365

fixup_codec_formats(&dai_drv[i].playback);

3366

fixup_codec_formats(&dai_drv[i].capture);

3367

}

3368

3369

ret = snd_soc_register_dais(&codec->component, dai_drv, num_dai, false);

3370

if (ret < 0) {

3371

dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);

3372

goto err_cleanup;

3373

}

3374

3375

list_for_each_entry(dai, &codec->component.dai_list, list)for (dai = ({ const typeof( ((typeof(*dai) *)0)->list ) *__mptr
= ((&codec->component.dai_list)->next); (typeof(*dai
) *)( (char *)__mptr - __builtin_offsetof(typeof(*dai), list)
);}); &dai->list != (&codec->component.dai_list
); dai = ({ const typeof( ((typeof(*(dai)) *)0)->list ) *__mptr
= ((dai)->list.next); (typeof(*(dai)) *)( (char *)__mptr -
__builtin_offsetof(typeof(*(dai)), list) );}))

3376

dai->codec = codec;

3377

3378

mutex_lock(&client_mutex)mutex_lock_nested(&client_mutex, 0);

3379

snd_soc_component_add_unlocked(&codec->component);

3380

list_add(&codec->list, &codec_list);

3381

mutex_unlock(&client_mutex);

3382

3383

dev_dbg(codec->dev, "ASoC: Registered codec '%s'\n",do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: Registered codec '%s'\n"), .lineno = 3384, .
flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, codec->dev, "ASoC: Registered codec '%s'\n"
, codec->component.name); } while (0); } while (0)

3384

codec->component.name)do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: Registered codec '%s'\n"), .lineno = 3384, .
flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, codec->dev, "ASoC: Registered codec '%s'\n"
, codec->component.name); } while (0); } while (0);

3385

return 0;

3386

3387

err_cleanup:

3388

snd_soc_component_cleanup(&codec->component);

3389

err_free:

3390

kfree(codec);

3391

return ret;

3392

}

3393

EXPORT_SYMBOL_GPL(snd_soc_register_codec)extern typeof(snd_soc_register_codec) snd_soc_register_codec;
extern void *__crc_snd_soc_register_codec __attribute__((weak
)); static const unsigned long __kcrctab_snd_soc_register_codec
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_register_codec"), used)) = (unsigned long
) &__crc_snd_soc_register_codec; static const char __kstrtab_snd_soc_register_codec
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_register_codec"; static const struct kernel_symbol __ksymtab_snd_soc_register_codec
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_register_codec"), used)) = { (unsigned long
)&snd_soc_register_codec, __kstrtab_snd_soc_register_codec
};

3394

3395

/**

3396

* snd_soc_unregister_codec - Unregister a codec from the ASoC core

3397

3398

* @dev: codec to unregister

3399

3400

void snd_soc_unregister_codec(struct device *dev)

3401

{

3402

struct snd_soc_codec *codec;

3403

3404

mutex_lock(&client_mutex)mutex_lock_nested(&client_mutex, 0);

3405

3406

if (dev == codec->dev)

3407

goto found;

3408

}

3409

mutex_unlock(&client_mutex);

3410

return;

3411

3412

found:

3413

list_del(&codec->list);

3414

snd_soc_component_del_unlocked(&codec->component);

3415

mutex_unlock(&client_mutex);

3416

3417

dev_dbg(codec->dev, "ASoC: Unregistered codec '%s'\n",do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: Unregistered codec '%s'\n"), .lineno = 3418,
.flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, codec->dev, "ASoC: Unregistered codec '%s'\n"
, codec->component.name); } while (0); } while (0)

3418

codec->component.name)do { do { static struct _ddebug __attribute__((aligned(8))) __attribute__
((section("__verbose"))) descriptor = { .modname = "snd_soc_core"
, .function = __func__, .filename = "sound/soc/soc-core.c", .
format = ("ASoC: Unregistered codec '%s'\n"), .lineno = 3418,
.flags = 0, }; if ((descriptor.flags & (1<<0))) __dynamic_dev_dbg
(&descriptor, codec->dev, "ASoC: Unregistered codec '%s'\n"
, codec->component.name); } while (0); } while (0);

3419

3420

snd_soc_component_cleanup(&codec->component);

3421

snd_soc_cache_exit(codec);

3422

kfree(codec);

3423

}

3424

EXPORT_SYMBOL_GPL(snd_soc_unregister_codec)extern typeof(snd_soc_unregister_codec) snd_soc_unregister_codec
; extern void *__crc_snd_soc_unregister_codec __attribute__((
weak)); static const unsigned long __kcrctab_snd_soc_unregister_codec
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_unregister_codec"), used)) = (unsigned long
) &__crc_snd_soc_unregister_codec; static const char __kstrtab_snd_soc_unregister_codec
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_unregister_codec"; static const struct kernel_symbol
__ksymtab_snd_soc_unregister_codec __attribute__((__used__))
__attribute__((section("___ksymtab" "_gpl" "+" "snd_soc_unregister_codec"
), used)) = { (unsigned long)&snd_soc_unregister_codec, __kstrtab_snd_soc_unregister_codec
};

3425

3426

/* Retrieve a card's name from device tree */

3427

int snd_soc_of_parse_card_name(struct snd_soc_card *card,

3428

const char *propname)

3429

{

3430

struct device_node *np;

3431

int ret;

3432

3433

if (!card->dev) {

3434

pr_err("card->dev is not set before calling %s\n", __func__)printk("\001" "3" "card->dev is not set before calling %s\n"
, __func__);

3435

return -EINVAL22;

3436

}

3437

3438

np = card->dev->of_node;

3439

3440

ret = of_property_read_string_index(np, propname, 0, &card->name);

3441

3442

* EINVAL means the property does not exist. This is fine providing

3443

* card->name was previously set, which is checked later in

3444

* snd_soc_register_card.

3445

3446

if (ret < 0 && ret != -EINVAL22) {

3447

dev_err(card->dev,

3448

"ASoC: Property '%s' could not be read: %d\n",

3449

propname, ret);

3450

return ret;

3451

}

3452

3453

return 0;

3454

}

3455

EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name)extern typeof(snd_soc_of_parse_card_name) snd_soc_of_parse_card_name
; extern void *__crc_snd_soc_of_parse_card_name __attribute__
((weak)); static const unsigned long __kcrctab_snd_soc_of_parse_card_name
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_of_parse_card_name"), used)) = (unsigned
long) &__crc_snd_soc_of_parse_card_name; static const char
__kstrtab_snd_soc_of_parse_card_name[] __attribute__((section
("__ksymtab_strings"), aligned(1))) = "snd_soc_of_parse_card_name"
; static const struct kernel_symbol __ksymtab_snd_soc_of_parse_card_name
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_of_parse_card_name"), used)) = { (unsigned
long)&snd_soc_of_parse_card_name, __kstrtab_snd_soc_of_parse_card_name
};

3456

3457

static const struct snd_soc_dapm_widget simple_widgets[] = {

3458

SND_SOC_DAPM_MIC("Microphone", NULL){ .id = snd_soc_dapm_mic, .name = "Microphone", .kcontrol_news
= ((void *)0), .num_kcontrols = 0, .reg = -1, .event = ((void
*)0), .event_flags = 0x1 | 0x8},

3459

SND_SOC_DAPM_LINE("Line", NULL){ .id = snd_soc_dapm_line, .name = "Line", .kcontrol_news = (
(void *)0), .num_kcontrols = 0, .reg = -1, .event = ((void *)
0), .event_flags = 0x2 | 0x4},

3460

SND_SOC_DAPM_HP("Headphone", NULL){ .id = snd_soc_dapm_hp, .name = "Headphone", .kcontrol_news =
((void *)0), .num_kcontrols = 0, .reg = -1, .event = ((void *
)0), .event_flags = 0x2 | 0x4},

3461

SND_SOC_DAPM_SPK("Speaker", NULL){ .id = snd_soc_dapm_spk, .name = "Speaker", .kcontrol_news =
((void *)0), .num_kcontrols = 0, .reg = -1, .event = ((void *
)0), .event_flags = 0x2 | 0x4},

3462

};

3463

3464

int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,

3465

const char *propname)

3466

{

3467

struct device_node *np = card->dev->of_node;

3468

struct snd_soc_dapm_widget *widgets;

3469

const char *template, *wname;

3470

int i, j, num_widgets, ret;

3471

3472

num_widgets = of_property_count_strings(np, propname);

3473

if (num_widgets < 0) {

3474

dev_err(card->dev,

3475

"ASoC: Property '%s' does not exist\n", propname);

3476

return -EINVAL22;

3477

}

3478

if (num_widgets & 1) {

3479

dev_err(card->dev,

3480

"ASoC: Property '%s' length is not even\n", propname);

3481

return -EINVAL22;

3482

}

3483

3484

num_widgets /= 2;

3485

if (!num_widgets) {

3486

dev_err(card->dev, "ASoC: Property '%s's length is zero\n",

3487

propname);

3488

return -EINVAL22;

3489

}

3490

3491

widgets = devm_kcalloc(card->dev, num_widgets, sizeof(*widgets),

3492

GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)));

3493

if (!widgets) {

3494

dev_err(card->dev,

3495

"ASoC: Could not allocate memory for widgets\n");

3496

return -ENOMEM12;

3497

}

3498

3499

for (i = 0; i < num_widgets; i++) {

3500

ret = of_property_read_string_index(np, propname,

3501

2 * i, &template);

3502

if (ret) {

3503

dev_err(card->dev,

3504

"ASoC: Property '%s' index %d read error:%d\n",

3505

propname, 2 * i, ret);

3506

return -EINVAL22;

3507

}

3508

3509

for (j = 0; j < ARRAY_SIZE(simple_widgets)(sizeof(simple_widgets) / sizeof((simple_widgets)[0]) + (sizeof
(struct { int:-!!(__builtin_types_compatible_p(typeof((simple_widgets
)), typeof(&(simple_widgets)[0]))); }))); j++) {

3510

if (!strncmp(template, simple_widgets[j].name,

3511

strlen(simple_widgets[j].name))) {

3512

widgets[i] = simple_widgets[j];

3513

break;

3514

}

3515

}

3516

3517

if (j >= ARRAY_SIZE(simple_widgets)(sizeof(simple_widgets) / sizeof((simple_widgets)[0]) + (sizeof
(struct { int:-!!(__builtin_types_compatible_p(typeof((simple_widgets
)), typeof(&(simple_widgets)[0]))); })))) {

3518

dev_err(card->dev,

3519

"ASoC: DAPM widget '%s' is not supported\n",

3520

template);

3521

return -EINVAL22;

3522

}

3523

3524

ret = of_property_read_string_index(np, propname,

3525

(2 * i) + 1,

3526

&wname);

3527

if (ret) {

3528

dev_err(card->dev,

3529

"ASoC: Property '%s' index %d read error:%d\n",

3530

propname, (2 * i) + 1, ret);

3531

return -EINVAL22;

3532

}

3533

3534

widgets[i].name = wname;

3535

}

3536

3537

card->of_dapm_widgets = widgets;

3538

card->num_of_dapm_widgets = num_widgets;

3539

3540

return 0;

3541

}

3542

EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_simple_widgets)extern typeof(snd_soc_of_parse_audio_simple_widgets) snd_soc_of_parse_audio_simple_widgets
; extern void *__crc_snd_soc_of_parse_audio_simple_widgets __attribute__
((weak)); static const unsigned long __kcrctab_snd_soc_of_parse_audio_simple_widgets
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_of_parse_audio_simple_widgets"), used)) =
(unsigned long) &__crc_snd_soc_of_parse_audio_simple_widgets
; static const char __kstrtab_snd_soc_of_parse_audio_simple_widgets
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_of_parse_audio_simple_widgets"; static const struct
kernel_symbol __ksymtab_snd_soc_of_parse_audio_simple_widgets
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_of_parse_audio_simple_widgets"), used)) =
{ (unsigned long)&snd_soc_of_parse_audio_simple_widgets,
__kstrtab_snd_soc_of_parse_audio_simple_widgets };

3543

3544

static int snd_soc_of_get_slot_mask(struct device_node *np,

3545

const char *prop_name,

3546

unsigned int *mask)

3547

{

3548

u32 val;

3549

const __be32 *of_slot_mask = of_get_property(np, prop_name, &val);

3550

int i;

3551

3552

if (!of_slot_mask)

3553

return 0;

3554

val /= sizeof(u32);

3555

for (i = 0; i < val; i++)

3556

if (be32_to_cpup__be32_to_cpup(&of_slot_mask[i]))

3557

*mask |= (1 << i);

3558

3559

return val;

3560

}

3561

3562

int snd_soc_of_parse_tdm_slot(struct device_node *np,

3563

unsigned int *tx_mask,

3564

unsigned int *rx_mask,

3565

unsigned int *slots,

3566

unsigned int *slot_width)

3567

{

3568

u32 val;

3569

int ret;

3570

3571

if (tx_mask)

3572

snd_soc_of_get_slot_mask(np, "dai-tdm-slot-tx-mask", tx_mask);

3573

if (rx_mask)

3574

snd_soc_of_get_slot_mask(np, "dai-tdm-slot-rx-mask", rx_mask);

3575

3576

if (of_property_read_bool(np, "dai-tdm-slot-num")) {

3577

ret = of_property_read_u32(np, "dai-tdm-slot-num", &val);

3578

if (ret)

3579

return ret;

3580

3581

if (slots)

3582

*slots = val;

3583

}

3584

3585

if (of_property_read_bool(np, "dai-tdm-slot-width")) {

3586

ret = of_property_read_u32(np, "dai-tdm-slot-width", &val);

3587

if (ret)

3588

return ret;

3589

3590

if (slot_width)

3591

*slot_width = val;

3592

}

3593

3594

return 0;

3595

}

3596

EXPORT_SYMBOL_GPL(snd_soc_of_parse_tdm_slot)extern typeof(snd_soc_of_parse_tdm_slot) snd_soc_of_parse_tdm_slot
; extern void *__crc_snd_soc_of_parse_tdm_slot __attribute__(
(weak)); static const unsigned long __kcrctab_snd_soc_of_parse_tdm_slot
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_of_parse_tdm_slot"), used)) = (unsigned long
) &__crc_snd_soc_of_parse_tdm_slot; static const char __kstrtab_snd_soc_of_parse_tdm_slot
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_of_parse_tdm_slot"; static const struct kernel_symbol
__ksymtab_snd_soc_of_parse_tdm_slot __attribute__((__used__)
) __attribute__((section("___ksymtab" "_gpl" "+" "snd_soc_of_parse_tdm_slot"
), used)) = { (unsigned long)&snd_soc_of_parse_tdm_slot, __kstrtab_snd_soc_of_parse_tdm_slot
};

3597

3598

void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,

3599

struct snd_soc_codec_conf *codec_conf,

3600

struct device_node *of_node,

3601

const char *propname)

3602

{

3603

struct device_node *np = card->dev->of_node;

3604

const char *str;

3605

int ret;

3606

3607

ret = of_property_read_string(np, propname, &str);

3608

if (ret < 0) {

3609

/* no prefix is not error */

3610

return;

3611

}

3612

3613

codec_conf->of_node = of_node;

3614

codec_conf->name_prefix = str;

3615

}

3616

EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_prefix)extern typeof(snd_soc_of_parse_audio_prefix) snd_soc_of_parse_audio_prefix
; extern void *__crc_snd_soc_of_parse_audio_prefix __attribute__
((weak)); static const unsigned long __kcrctab_snd_soc_of_parse_audio_prefix
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_of_parse_audio_prefix"), used)) = (unsigned
long) &__crc_snd_soc_of_parse_audio_prefix; static const
char __kstrtab_snd_soc_of_parse_audio_prefix[] __attribute__
((section("__ksymtab_strings"), aligned(1))) = "snd_soc_of_parse_audio_prefix"
; static const struct kernel_symbol __ksymtab_snd_soc_of_parse_audio_prefix
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_of_parse_audio_prefix"), used)) = { (unsigned
long)&snd_soc_of_parse_audio_prefix, __kstrtab_snd_soc_of_parse_audio_prefix
};

3617

3618

int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,

3619

const char *propname)

3620

{

3621

struct device_node *np = card->dev->of_node;

3622

int num_routes;

3623

struct snd_soc_dapm_route *routes;

3624

int i, ret;

3625

3626

num_routes = of_property_count_strings(np, propname);

3627

if (num_routes < 0 || num_routes & 1) {

3628

dev_err(card->dev,

3629

"ASoC: Property '%s' does not exist or its length is not even\n",

3630

propname);

3631

return -EINVAL22;

3632

}

3633

num_routes /= 2;

3634

if (!num_routes) {

3635

dev_err(card->dev, "ASoC: Property '%s's length is zero\n",

3636

propname);

3637

return -EINVAL22;

3638

}

3639

3640

routes = devm_kzalloc(card->dev, num_routes * sizeof(*routes),

3641

GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)));

3642

if (!routes) {

3643

dev_err(card->dev,

3644

"ASoC: Could not allocate DAPM route table\n");

3645

return -EINVAL22;

3646

}

3647

3648

for (i = 0; i < num_routes; i++) {

3649

ret = of_property_read_string_index(np, propname,

3650

2 * i, &routes[i].sink);

3651

if (ret) {

3652

dev_err(card->dev,

3653

"ASoC: Property '%s' index %d could not be read: %d\n",

3654

propname, 2 * i, ret);

3655

return -EINVAL22;

3656

}

3657

ret = of_property_read_string_index(np, propname,

3658

(2 * i) + 1, &routes[i].source);

3659

if (ret) {

3660

dev_err(card->dev,

3661

"ASoC: Property '%s' index %d could not be read: %d\n",

3662

propname, (2 * i) + 1, ret);

3663

return -EINVAL22;

3664

}

3665

}

3666

3667

card->num_of_dapm_routes = num_routes;

3668

card->of_dapm_routes = routes;

3669

3670

return 0;

3671

}

3672

EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing)extern typeof(snd_soc_of_parse_audio_routing) snd_soc_of_parse_audio_routing
; extern void *__crc_snd_soc_of_parse_audio_routing __attribute__
((weak)); static const unsigned long __kcrctab_snd_soc_of_parse_audio_routing
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_of_parse_audio_routing"), used)) = (unsigned
long) &__crc_snd_soc_of_parse_audio_routing; static const
char __kstrtab_snd_soc_of_parse_audio_routing[] __attribute__
((section("__ksymtab_strings"), aligned(1))) = "snd_soc_of_parse_audio_routing"
; static const struct kernel_symbol __ksymtab_snd_soc_of_parse_audio_routing
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_of_parse_audio_routing"), used)) = { (unsigned
long)&snd_soc_of_parse_audio_routing, __kstrtab_snd_soc_of_parse_audio_routing
};

3673

3674

unsigned int snd_soc_of_parse_daifmt(struct device_node *np,

3675

const char *prefix,

3676

struct device_node **bitclkmaster,

3677

struct device_node **framemaster)

3678

{

3679

int ret, i;

3680

char prop[128];

3681

unsigned int format = 0;

3682

int bit, frame;

3683

const char *str;

3684

struct {

3685

char *name;

3686

unsigned int val;

3687

} of_fmt_table[] = {

3688

{ "i2s", SND_SOC_DAIFMT_I2S1 },

3689

{ "right_j", SND_SOC_DAIFMT_RIGHT_J2 },

3690

{ "left_j", SND_SOC_DAIFMT_LEFT_J3 },

3691

{ "dsp_a", SND_SOC_DAIFMT_DSP_A4 },

3692

{ "dsp_b", SND_SOC_DAIFMT_DSP_B5 },

3693

{ "ac97", SND_SOC_DAIFMT_AC976 },

3694

{ "pdm", SND_SOC_DAIFMT_PDM7},

3695

{ "msb", SND_SOC_DAIFMT_MSB3 },

3696

{ "lsb", SND_SOC_DAIFMT_LSB2 },

3697

};

3698

3699

if (!prefix)

3700

prefix = "";

3701

3702

3703

* check "[prefix]format = xxx"

3704

* SND_SOC_DAIFMT_FORMAT_MASK area

3705

3706

snprintf(prop, sizeof(prop), "%sformat", prefix);

3707

ret = of_property_read_string(np, prop, &str);

3708

if (ret == 0) {

3709

for (i = 0; i < ARRAY_SIZE(of_fmt_table)(sizeof(of_fmt_table) / sizeof((of_fmt_table)[0]) + (sizeof(struct
{ int:-!!(__builtin_types_compatible_p(typeof((of_fmt_table)
), typeof(&(of_fmt_table)[0]))); }))); i++) {

3710

if (strcmp(str, of_fmt_table[i].name) == 0) {

3711

format |= of_fmt_table[i].val;

3712

break;

3713

}

3714

}

3715

}

3716

3717

3718

* check "[prefix]continuous-clock"

3719

* SND_SOC_DAIFMT_CLOCK_MASK area

3720

3721

snprintf(prop, sizeof(prop), "%scontinuous-clock", prefix);

3722

if (of_property_read_bool(np, prop))

3723

format |= SND_SOC_DAIFMT_CONT(1 << 4);

3724

else

3725

format |= SND_SOC_DAIFMT_GATED(0 << 4);

3726

3727

3728

* check "[prefix]bitclock-inversion"

3729

* check "[prefix]frame-inversion"

3730

* SND_SOC_DAIFMT_INV_MASK area

3731

3732

snprintf(prop, sizeof(prop), "%sbitclock-inversion", prefix);

3733

bit = !!of_get_property(np, prop, NULL((void *)0));

3734

3735

snprintf(prop, sizeof(prop), "%sframe-inversion", prefix);

3736

frame = !!of_get_property(np, prop, NULL((void *)0));

3737

3738

switch ((bit << 4) + frame) {

3739

case 0x11:

3740

format |= SND_SOC_DAIFMT_IB_IF(4 << 8);

3741

break;

3742

case 0x10:

3743

format |= SND_SOC_DAIFMT_IB_NF(3 << 8);

3744

break;

3745

case 0x01:

3746

format |= SND_SOC_DAIFMT_NB_IF(2 << 8);

3747

break;

3748

default:

3749

/* SND_SOC_DAIFMT_NB_NF is default */

3750

break;

3751

}

3752

3753

3754

* check "[prefix]bitclock-master"

3755

* check "[prefix]frame-master"

3756

* SND_SOC_DAIFMT_MASTER_MASK area

3757

3758

snprintf(prop, sizeof(prop), "%sbitclock-master", prefix);

3759

bit = !!of_get_property(np, prop, NULL((void *)0));

3760

if (bit && bitclkmaster)

3761

*bitclkmaster = of_parse_phandle(np, prop, 0);

3762

3763

snprintf(prop, sizeof(prop), "%sframe-master", prefix);

3764

frame = !!of_get_property(np, prop, NULL((void *)0));

3765

if (frame && framemaster)

3766

*framemaster = of_parse_phandle(np, prop, 0);

3767

3768

switch ((bit << 4) + frame) {

3769

case 0x11:

3770

format |= SND_SOC_DAIFMT_CBM_CFM(1 << 12);

3771

break;

3772

case 0x10:

3773

format |= SND_SOC_DAIFMT_CBM_CFS(3 << 12);

3774

break;

3775

case 0x01:

3776

format |= SND_SOC_DAIFMT_CBS_CFM(2 << 12);

3777

break;

3778

default:

3779

format |= SND_SOC_DAIFMT_CBS_CFS(4 << 12);

3780

break;

3781

}

3782

3783

return format;

3784

}

3785

EXPORT_SYMBOL_GPL(snd_soc_of_parse_daifmt)extern typeof(snd_soc_of_parse_daifmt) snd_soc_of_parse_daifmt
; extern void *__crc_snd_soc_of_parse_daifmt __attribute__((weak
)); static const unsigned long __kcrctab_snd_soc_of_parse_daifmt
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_of_parse_daifmt"), used)) = (unsigned long
) &__crc_snd_soc_of_parse_daifmt; static const char __kstrtab_snd_soc_of_parse_daifmt
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_of_parse_daifmt"; static const struct kernel_symbol
__ksymtab_snd_soc_of_parse_daifmt __attribute__((__used__)) __attribute__
((section("___ksymtab" "_gpl" "+" "snd_soc_of_parse_daifmt"),
used)) = { (unsigned long)&snd_soc_of_parse_daifmt, __kstrtab_snd_soc_of_parse_daifmt
};

3786

3787

static int snd_soc_get_dai_name(struct of_phandle_args *args,

3788

const char **dai_name)

3789

{

3790

struct snd_soc_component *pos;

3791

struct device_node *component_of_node;

3792

int ret = -EPROBE_DEFER517;

3793

3794

mutex_lock(&client_mutex)mutex_lock_nested(&client_mutex, 0);

3795

list_for_each_entry(pos, &component_list, list)for (pos = ({ const typeof( ((typeof(*pos) *)0)->list ) *__mptr
= ((&component_list)->next); (typeof(*pos) *)( (char *
)__mptr - __builtin_offsetof(typeof(*pos), list) );}); &pos
->list != (&component_list); pos = ({ const typeof( ((
typeof(*(pos)) *)0)->list ) *__mptr = ((pos)->list.next
); (typeof(*(pos)) *)( (char *)__mptr - __builtin_offsetof(typeof
(*(pos)), list) );})) {

3796

component_of_node = pos->dev->of_node;

3797

if (!component_of_node && pos->dev->parent)

3798

component_of_node = pos->dev->parent->of_node;

3799

3800

if (component_of_node != args->np)

3801

continue;

3802

3803

if (pos->driver->of_xlate_dai_name) {

3804

ret = pos->driver->of_xlate_dai_name(pos,

3805

args,

3806

dai_name);

3807

} else {

3808

int id = -1;

3809

3810

switch (args->args_count) {

3811

case 0:

3812

id = 0; /* same as dai_drv[0] */

3813

break;

3814

case 1:

3815

id = args->args[0];

3816

break;

3817

default:

3818

/* not supported */

3819

break;

3820

}

3821

3822

if (id < 0 || id >= pos->num_dai) {

3823

ret = -EINVAL22;

3824

continue;

3825

}

3826

3827

ret = 0;

3828

3829

*dai_name = pos->dai_drv[id].name;

3830

if (!*dai_name)

3831

*dai_name = pos->name;

3832

}

3833

3834

break;

3835

}

3836

mutex_unlock(&client_mutex);

3837

return ret;

3838

}

3839

3840

int snd_soc_of_get_dai_name(struct device_node *of_node,

3841

const char **dai_name)

3842

{

3843

struct of_phandle_args args;

3844

int ret;

3845

3846

ret = of_parse_phandle_with_args(of_node, "sound-dai",

3847

"#sound-dai-cells", 0, &args);

3848

if (ret)

3849

return ret;

3850

3851

ret = snd_soc_get_dai_name(&args, dai_name);

3852

3853

of_node_put(args.np);

3854

3855

return ret;

3856

}

3857

EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_name)extern typeof(snd_soc_of_get_dai_name) snd_soc_of_get_dai_name
; extern void *__crc_snd_soc_of_get_dai_name __attribute__((weak
)); static const unsigned long __kcrctab_snd_soc_of_get_dai_name
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_of_get_dai_name"), used)) = (unsigned long
) &__crc_snd_soc_of_get_dai_name; static const char __kstrtab_snd_soc_of_get_dai_name
[] __attribute__((section("__ksymtab_strings"), aligned(1))) =
"snd_soc_of_get_dai_name"; static const struct kernel_symbol
__ksymtab_snd_soc_of_get_dai_name __attribute__((__used__)) __attribute__
((section("___ksymtab" "_gpl" "+" "snd_soc_of_get_dai_name"),
used)) = { (unsigned long)&snd_soc_of_get_dai_name, __kstrtab_snd_soc_of_get_dai_name
};

3858

3859

3860

* snd_soc_of_get_dai_link_codecs - Parse a list of CODECs in the devicetree

3861

* @dev: Card device

3862

* @of_node: Device node

3863

* @dai_link: DAI link

3864

3865

* Builds an array of CODEC DAI components from the DAI link property

3866

* 'sound-dai'.

3867

* The array is set in the DAI link and the number of DAIs is set accordingly.

3868

* The device nodes in the array (of_node) must be dereferenced by the caller.

3869

3870

* Returns 0 for success

3871

3872

int snd_soc_of_get_dai_link_codecs(struct device *dev,

3873

struct device_node *of_node,

3874

struct snd_soc_dai_link *dai_link)

3875

{

3876

struct of_phandle_args args;

3877

struct snd_soc_dai_link_component *component;

3878

char *name;

3879

int index, num_codecs, ret;

3880

3881

/* Count the number of CODECs */

3882

name = "sound-dai";

3883

num_codecs = of_count_phandle_with_args(of_node, name,

3884

"#sound-dai-cells");

3885

if (num_codecs <= 0) {

3886

if (num_codecs == -ENOENT2)

3887

dev_err(dev, "No 'sound-dai' property\n");

3888

else

3889

dev_err(dev, "Bad phandle in 'sound-dai'\n");

3890

return num_codecs;

3891

}

3892

component = devm_kzalloc(dev,

3893

sizeof *component * num_codecs,

3894

GFP_KERNEL((( gfp_t)(0x400000u|0x2000000u)) | (( gfp_t)0x40u) | (( gfp_t
)0x80u)));

3895

if (!component)

3896

return -ENOMEM12;

3897

dai_link->codecs = component;

3898

dai_link->num_codecs = num_codecs;

3899

3900

/* Parse the list */

3901

for (index = 0, component = dai_link->codecs;

3902

index < dai_link->num_codecs;

3903

index++, component++) {

3904

ret = of_parse_phandle_with_args(of_node, name,

3905

"#sound-dai-cells",

3906

index, &args);

3907

if (ret)

3908

goto err;

3909

component->of_node = args.np;

3910

ret = snd_soc_get_dai_name(&args, &component->dai_name);

3911

if (ret < 0)

3912

goto err;

3913

}

3914

return 0;

3915

err:

3916

for (index = 0, component = dai_link->codecs;

3917

index < dai_link->num_codecs;

3918

index++, component++) {

3919

if (!component->of_node)

3920

break;

3921

of_node_put(component->of_node);

3922

component->of_node = NULL((void *)0);

3923

}

3924

dai_link->codecs = NULL((void *)0);

3925

dai_link->num_codecs = 0;

3926

return ret;

3927

}

3928

EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_codecs)extern typeof(snd_soc_of_get_dai_link_codecs) snd_soc_of_get_dai_link_codecs
; extern void *__crc_snd_soc_of_get_dai_link_codecs __attribute__
((weak)); static const unsigned long __kcrctab_snd_soc_of_get_dai_link_codecs
__attribute__((__used__)) __attribute__((section("___kcrctab"
"_gpl" "+" "snd_soc_of_get_dai_link_codecs"), used)) = (unsigned
long) &__crc_snd_soc_of_get_dai_link_codecs; static const
char __kstrtab_snd_soc_of_get_dai_link_codecs[] __attribute__
((section("__ksymtab_strings"), aligned(1))) = "snd_soc_of_get_dai_link_codecs"
; static const struct kernel_symbol __ksymtab_snd_soc_of_get_dai_link_codecs
__attribute__((__used__)) __attribute__((section("___ksymtab"
"_gpl" "+" "snd_soc_of_get_dai_link_codecs"), used)) = { (unsigned
long)&snd_soc_of_get_dai_link_codecs, __kstrtab_snd_soc_of_get_dai_link_codecs
};

3929

3930

static int __init__attribute__ ((__section__(".init.text"))) __attribute__((no_instrument_function
)) snd_soc_init(void)

3931

{

3932

snd_soc_debugfs_init();

3933

snd_soc_util_init();

3934

3935

return platform_driver_register(&soc_driver)__platform_driver_register(&soc_driver, ((struct module *
)0));

3936

}

3937

module_init(snd_soc_init)static initcall_t __initcall_snd_soc_init6 __attribute__((__used__
)) __attribute__((__section__(".initcall" "6" ".init"))) = snd_soc_init
;;;

3938

3939

static void __exit__attribute__ ((__section__(".exit.text"))) __attribute__((__used__
)) __attribute__((no_instrument_function)) snd_soc_exit(void)

3940

{

3941

snd_soc_util_exit();

3942

snd_soc_debugfs_exit();

3943

3944

#ifdef CONFIG_DEBUG_FS1

3945

#endif

3946

platform_driver_unregister(&soc_driver);

3947

}

3948

module_exit(snd_soc_exit)static exitcall_t __exitcall_snd_soc_exit __attribute__((__used__
)) __attribute__ ((__section__(".exitcall.exit"))) = snd_soc_exit
;;

3949

3950

/* Module information */

3951

MODULE_AUTHOR("Liam Girdwood, [email protected]")struct __UNIQUE_ID_author34 {};

3952

MODULE_DESCRIPTION("ALSA SoC Core")struct __UNIQUE_ID_description35 {};

3953

MODULE_LICENSE("GPL")struct __UNIQUE_ID_license36 {};

3954

MODULE_ALIAS("platform:soc-audio")struct __UNIQUE_ID_alias37 {};