www.pilppa.org Git - linux-2.6-omap-h63xx.git/blob

1 /*

2 * soc-dapm.c -- ALSA SoC Dynamic Audio Power Management

3 *

5 * Author: Liam Girdwood

6 * liam.girdwood@wolfsonmicro.com or linux@wolfsonmicro.com

7 *

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

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

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

11 * option) any later version.

12 *

13 * Features:

14 * o Changes power status of internal codec blocks depending on the

15 * dynamic configuration of codec internal audio paths and active

16 * DAC's/ADC's.

17 * o Platform power domain - can support external components i.e. amps and

18 * mic/meadphone insertion events.

19 * o Automatic Mic Bias support

20 * o Jack insertion power event initiation - e.g. hp insertion will enable

21 * sinks, dacs, etc

22 * o Delayed powerdown of audio susbsystem to reduce pops between a quick

23 * device reopen.

24 *

25 * Todo:

26 * o DAPM power change sequencing - allow for configurable per

27 * codec sequences.

28 * o Support for analogue bias optimisation.

29 * o Support for reduced codec oversampling rates.

30 * o Support for reduced codec bias currents.

31 */

32

33 #include <linux/module.h>

34 #include <linux/moduleparam.h>

35 #include <linux/init.h>

36 #include <linux/delay.h>

37 #include <linux/pm.h>

38 #include <linux/bitops.h>

39 #include <linux/platform_device.h>

40 #include <linux/jiffies.h>

41 #include <sound/core.h>

42 #include <sound/pcm.h>

43 #include <sound/pcm_params.h>

44 #include <sound/soc-dapm.h>

45 #include <sound/initval.h>

46

47 /* debug */

48 #define DAPM_DEBUG 0

49 #if DAPM_DEBUG

50 #define dump_dapm(codec, action) dbg_dump_dapm(codec, action)

51 #define dbg(format, arg...) printk(format, ## arg)

52 #else

53 #define dump_dapm(codec, action)

54 #define dbg(format, arg...)

55 #endif

56

57 #define POP_DEBUG 0

58 #if POP_DEBUG

59 #define POP_TIME 500 /* 500 msecs - change if pop debug is too fast */

60 #define pop_wait(time) schedule_timeout_uninterruptible(msecs_to_jiffies(time))

61 #define pop_dbg(format, arg...) printk(format, ## arg); pop_wait(POP_TIME)

62 #else

63 #define pop_dbg(format, arg...)

64 #define pop_wait(time)

65 #endif

66

67 /* dapm power sequences - make this per codec in the future */

68 static int dapm_up_seq[] = {

69 snd_soc_dapm_pre, snd_soc_dapm_micbias, snd_soc_dapm_mic,

70 snd_soc_dapm_mux, snd_soc_dapm_dac, snd_soc_dapm_mixer, snd_soc_dapm_pga,

71 snd_soc_dapm_adc, snd_soc_dapm_hp, snd_soc_dapm_spk, snd_soc_dapm_post

72 };

73 static int dapm_down_seq[] = {

74 snd_soc_dapm_pre, snd_soc_dapm_adc, snd_soc_dapm_hp, snd_soc_dapm_spk,

75 snd_soc_dapm_pga, snd_soc_dapm_mixer, snd_soc_dapm_dac, snd_soc_dapm_mic,

76 snd_soc_dapm_micbias, snd_soc_dapm_mux, snd_soc_dapm_post

77 };

78

79 static int dapm_status = 1;

80 module_param(dapm_status, int, 0);

81 MODULE_PARM_DESC(dapm_status, "enable DPM sysfs entries");

82

83 /* create a new dapm widget */

84 static inline struct snd_soc_dapm_widget *dapm_cnew_widget(

85 const struct snd_soc_dapm_widget *_widget)

86 {

87 return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);

88 }

89

90 /* set up initial codec paths */

91 static void dapm_set_path_status(struct snd_soc_dapm_widget *w,

92 struct snd_soc_dapm_path *p, int i)

93 {

94 switch (w->id) {

95 case snd_soc_dapm_switch:

96 case snd_soc_dapm_mixer: {

97 int val;

98 int reg = w->kcontrols[i].private_value & 0xff;

99 int shift = (w->kcontrols[i].private_value >> 8) & 0x0f;

100 int mask = (w->kcontrols[i].private_value >> 16) & 0xff;

101 int invert = (w->kcontrols[i].private_value >> 24) & 0x01;

102

103 val = snd_soc_read(w->codec, reg);

104 val = (val >> shift) & mask;

105

106 if ((invert && !val) || (!invert && val))

107 p->connect = 1;

108 else

109 p->connect = 0;

110 }

111 break;

112 case snd_soc_dapm_mux: {

113 struct soc_enum *e = (struct soc_enum *)w->kcontrols[i].private_value;

114 int val, item, bitmask;

115

116 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)

117 ;

118 val = snd_soc_read(w->codec, e->reg);

119 item = (val >> e->shift_l) & (bitmask - 1);

120

121 p->connect = 0;

122 for (i = 0; i < e->mask; i++) {

123 if (!(strcmp(p->name, e->texts[i])) && item == i)

124 p->connect = 1;

125 }

126 }

127 break;

128 /* does not effect routing - always connected */

129 case snd_soc_dapm_pga:

130 case snd_soc_dapm_output:

131 case snd_soc_dapm_adc:

132 case snd_soc_dapm_input:

133 case snd_soc_dapm_dac:

134 case snd_soc_dapm_micbias:

135 case snd_soc_dapm_vmid:

136 p->connect = 1;

137 break;

138 /* does effect routing - dynamically connected */

139 case snd_soc_dapm_hp:

140 case snd_soc_dapm_mic:

141 case snd_soc_dapm_spk:

142 case snd_soc_dapm_line:

143 case snd_soc_dapm_pre:

144 case snd_soc_dapm_post:

145 p->connect = 0;

146 break;

147 }

148 }

149

150 /* connect mux widget to it's interconnecting audio paths */

151 static int dapm_connect_mux(struct snd_soc_codec *codec,

152 struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,

153 struct snd_soc_dapm_path *path, const char *control_name,

154 const struct snd_kcontrol_new *kcontrol)

155 {

156 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;

157 int i;

158

159 for (i = 0; i < e->mask; i++) {

160 if (!(strcmp(control_name, e->texts[i]))) {

161 list_add(&path->list, &codec->dapm_paths);

162 list_add(&path->list_sink, &dest->sources);

163 list_add(&path->list_source, &src->sinks);

164 path->name = (char*)e->texts[i];

165 dapm_set_path_status(dest, path, 0);

166 return 0;

167 }

168 }

169

170 return -ENODEV;

171 }

172

173 /* connect mixer widget to it's interconnecting audio paths */

174 static int dapm_connect_mixer(struct snd_soc_codec *codec,

175 struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,

176 struct snd_soc_dapm_path *path, const char *control_name)

177 {

178 int i;

179

180 /* search for mixer kcontrol */

181 for (i = 0; i < dest->num_kcontrols; i++) {

182 if (!strcmp(control_name, dest->kcontrols[i].name)) {

183 list_add(&path->list, &codec->dapm_paths);

184 list_add(&path->list_sink, &dest->sources);

185 list_add(&path->list_source, &src->sinks);

186 path->name = dest->kcontrols[i].name;

187 dapm_set_path_status(dest, path, i);

188 return 0;

189 }

190 }

191 return -ENODEV;

192 }

193

194 /* update dapm codec register bits */

195 static int dapm_update_bits(struct snd_soc_dapm_widget *widget)

196 {

197 int change, power;

198 unsigned short old, new;

199 struct snd_soc_codec *codec = widget->codec;

200

201 /* check for valid widgets */

202 if (widget->reg < 0 || widget->id == snd_soc_dapm_input ||

203 widget->id == snd_soc_dapm_output ||

204 widget->id == snd_soc_dapm_hp ||

205 widget->id == snd_soc_dapm_mic ||

206 widget->id == snd_soc_dapm_line ||

207 widget->id == snd_soc_dapm_spk)

208 return 0;

209

210 power = widget->power;

211 if (widget->invert)

212 power = (power ? 0:1);

213

214 old = snd_soc_read(codec, widget->reg);

215 new = (old & ~(0x1 << widget->shift)) | (power << widget->shift);

216

217 change = old != new;

218 if (change) {

219 pop_dbg("pop test %s : %s in %d ms\n", widget->name,

220 widget->power ? "on" : "off", POP_TIME);

221 snd_soc_write(codec, widget->reg, new);

222 pop_wait(POP_TIME);

223 }

224 dbg("reg %x old %x new %x change %d\n", widget->reg, old, new, change);

225 return change;

226 }

227

228 /* ramps the volume up or down to minimise pops before or after a

229 * DAPM power event */

230 static int dapm_set_pga(struct snd_soc_dapm_widget *widget, int power)

231 {

232 const struct snd_kcontrol_new *k = widget->kcontrols;

233

234 if (widget->muted && !power)

235 return 0;

236 if (!widget->muted && power)

237 return 0;

238

239 if (widget->num_kcontrols && k) {

240 int reg = k->private_value & 0xff;

241 int shift = (k->private_value >> 8) & 0x0f;

242 int mask = (k->private_value >> 16) & 0xff;

243 int invert = (k->private_value >> 24) & 0x01;

244

245 if (power) {

246 int i;

247 /* power up has happended, increase volume to last level */

248 if (invert) {

249 for (i = mask; i > widget->saved_value; i--)

250 snd_soc_update_bits(widget->codec, reg, mask, i);

251 } else {

252 for (i = 0; i < widget->saved_value; i++)

253 snd_soc_update_bits(widget->codec, reg, mask, i);

254 }

255 widget->muted = 0;

256 } else {

257 /* power down is about to occur, decrease volume to mute */

258 int val = snd_soc_read(widget->codec, reg);

259 int i = widget->saved_value = (val >> shift) & mask;

260 if (invert) {

261 for (; i < mask; i++)

262 snd_soc_update_bits(widget->codec, reg, mask, i);

263 } else {

264 for (; i > 0; i--)

265 snd_soc_update_bits(widget->codec, reg, mask, i);

266 }

267 widget->muted = 1;

268 }

269 }

270 return 0;

271 }

272

273 /* create new dapm mixer control */

274 static int dapm_new_mixer(struct snd_soc_codec *codec,

275 struct snd_soc_dapm_widget *w)

276 {

277 int i, ret = 0;

278 char name[32];

279 struct snd_soc_dapm_path *path;

280

281 /* add kcontrol */

282 for (i = 0; i < w->num_kcontrols; i++) {

283

284 /* match name */

285 list_for_each_entry(path, &w->sources, list_sink) {

286

287 /* mixer/mux paths name must match control name */

288 if (path->name != (char*)w->kcontrols[i].name)

289 continue;

290

291 /* add dapm control with long name */

292 snprintf(name, 32, "%s %s", w->name, w->kcontrols[i].name);

293 path->long_name = kstrdup (name, GFP_KERNEL);

294 if (path->long_name == NULL)

295 return -ENOMEM;

296

297 path->kcontrol = snd_soc_cnew(&w->kcontrols[i], w,

298 path->long_name);

299 ret = snd_ctl_add(codec->card, path->kcontrol);

300 if (ret < 0) {

301 printk(KERN_ERR "asoc: failed to add dapm kcontrol %s\n",

302 path->long_name);

303 kfree(path->long_name);

304 path->long_name = NULL;

305 return ret;

306 }

307 }

308 }

309 return ret;

310 }

311

312 /* create new dapm mux control */

313 static int dapm_new_mux(struct snd_soc_codec *codec,

314 struct snd_soc_dapm_widget *w)

315 {

316 struct snd_soc_dapm_path *path = NULL;

317 struct snd_kcontrol *kcontrol;

318 int ret = 0;

319

320 if (!w->num_kcontrols) {

321 printk(KERN_ERR "asoc: mux %s has no controls\n", w->name);

322 return -EINVAL;

323 }

324

325 kcontrol = snd_soc_cnew(&w->kcontrols[0], w, w->name);

326 ret = snd_ctl_add(codec->card, kcontrol);

327 if (ret < 0)

328 goto err;

329

330 list_for_each_entry(path, &w->sources, list_sink)

331 path->kcontrol = kcontrol;

332

333 return ret;

334

335 err:

336 printk(KERN_ERR "asoc: failed to add kcontrol %s\n", w->name);

337 return ret;

338 }

339

340 /* create new dapm volume control */

341 static int dapm_new_pga(struct snd_soc_codec *codec,

342 struct snd_soc_dapm_widget *w)

343 {

344 struct snd_kcontrol *kcontrol;

345 int ret = 0;

346

347 if (!w->num_kcontrols)

348 return -EINVAL;

349

350 kcontrol = snd_soc_cnew(&w->kcontrols[0], w, w->name);

351 ret = snd_ctl_add(codec->card, kcontrol);

352 if (ret < 0) {

353 printk(KERN_ERR "asoc: failed to add kcontrol %s\n", w->name);

354 return ret;

355 }

356

357 return ret;

358 }

359

360 /* reset 'walked' bit for each dapm path */

361 static inline void dapm_clear_walk(struct snd_soc_codec *codec)

362 {

363 struct snd_soc_dapm_path *p;

364

365 list_for_each_entry(p, &codec->dapm_paths, list)

366 p->walked = 0;

367 }

368

369 /*

370 * Recursively check for a completed path to an active or physically connected

371 * output widget. Returns number of complete paths.

372 */

373 static int is_connected_output_ep(struct snd_soc_dapm_widget *widget)

374 {

375 struct snd_soc_dapm_path *path;

376 int con = 0;

377

378 if (widget->id == snd_soc_dapm_adc && widget->active)

379 return 1;

380

381 if (widget->connected) {

382 /* connected pin ? */

383 if (widget->id == snd_soc_dapm_output && !widget->ext)

384 return 1;

385

386 /* connected jack or spk ? */

387 if (widget->id == snd_soc_dapm_hp || widget->id == snd_soc_dapm_spk ||

388 widget->id == snd_soc_dapm_line)

389 return 1;

390 }

391

392 list_for_each_entry(path, &widget->sinks, list_source) {

393 if (path->walked)

394 continue;

395

396 if (path->sink && path->connect) {

397 path->walked = 1;

398 con += is_connected_output_ep(path->sink);

399 }

400 }

401

402 return con;

403 }

404

405 /*

406 * Recursively check for a completed path to an active or physically connected

407 * input widget. Returns number of complete paths.

408 */

409 static int is_connected_input_ep(struct snd_soc_dapm_widget *widget)

410 {

411 struct snd_soc_dapm_path *path;

412 int con = 0;

413

414 /* active stream ? */

415 if (widget->id == snd_soc_dapm_dac && widget->active)

416 return 1;

417

418 if (widget->connected) {

419 /* connected pin ? */

420 if (widget->id == snd_soc_dapm_input && !widget->ext)

421 return 1;

422

423 /* connected VMID/Bias for lower pops */

424 if (widget->id == snd_soc_dapm_vmid)

425 return 1;

426

427 /* connected jack ? */

428 if (widget->id == snd_soc_dapm_mic || widget->id == snd_soc_dapm_line)

429 return 1;

430 }

431

432 list_for_each_entry(path, &widget->sources, list_sink) {

433 if (path->walked)

434 continue;

435

436 if (path->source && path->connect) {

437 path->walked = 1;

438 con += is_connected_input_ep(path->source);

439 }

440 }

441

442 return con;

443 }

444

445 /*

446 * Handler for generic register modifier widget.

447 */

448 int dapm_reg_event(struct snd_soc_dapm_widget *w,

449 struct snd_kcontrol *kcontrol, int event)

450 {

451 unsigned int val;

452

453 if (SND_SOC_DAPM_EVENT_ON(event))

454 val = w->on_val;

455 else

456 val = w->off_val;

457

458 snd_soc_update_bits(w->codec, -(w->reg + 1),

459 w->mask << w->shift, val << w->shift);

460

461 return 0;

462 }

463

464 /*

465 * Scan each dapm widget for complete audio path.

466 * A complete path is a route that has valid endpoints i.e.:-

467 *

468 * o DAC to output pin.

469 * o Input Pin to ADC.

470 * o Input pin to Output pin (bypass, sidetone)

471 * o DAC to ADC (loopback).

472 */

473 static int dapm_power_widgets(struct snd_soc_codec *codec, int event)

474 {

475 struct snd_soc_dapm_widget *w;

476 int in, out, i, c = 1, *seq = NULL, ret = 0, power_change, power;

477

478 /* do we have a sequenced stream event */

479 if (event == SND_SOC_DAPM_STREAM_START) {

480 c = ARRAY_SIZE(dapm_up_seq);

481 seq = dapm_up_seq;

482 } else if (event == SND_SOC_DAPM_STREAM_STOP) {

483 c = ARRAY_SIZE(dapm_down_seq);

484 seq = dapm_down_seq;

485 }

486

487 for(i = 0; i < c; i++) {

488 list_for_each_entry(w, &codec->dapm_widgets, list) {

489

490 /* is widget in stream order */

491 if (seq && seq[i] && w->id != seq[i])

492 continue;

493

494 /* vmid - no action */

495 if (w->id == snd_soc_dapm_vmid)

496 continue;

497

498 /* active ADC */

499 if (w->id == snd_soc_dapm_adc && w->active) {

500 in = is_connected_input_ep(w);

501 dapm_clear_walk(w->codec);

502 w->power = (in != 0) ? 1 : 0;

503 dapm_update_bits(w);

504 continue;

505 }

506

507 /* active DAC */

508 if (w->id == snd_soc_dapm_dac && w->active) {

509 out = is_connected_output_ep(w);

510 dapm_clear_walk(w->codec);

511 w->power = (out != 0) ? 1 : 0;

512 dapm_update_bits(w);

513 continue;

514 }

515

516 /* programmable gain/attenuation */

517 if (w->id == snd_soc_dapm_pga) {

518 int on;

519 in = is_connected_input_ep(w);

520 dapm_clear_walk(w->codec);

521 out = is_connected_output_ep(w);

522 dapm_clear_walk(w->codec);

523 w->power = on = (out != 0 && in != 0) ? 1 : 0;

524

525 if (!on)

526 dapm_set_pga(w, on); /* lower volume to reduce pops */

527 dapm_update_bits(w);

528 if (on)

529 dapm_set_pga(w, on); /* restore volume from zero */

530

531 continue;

532 }

533

534 /* pre and post event widgets */

535 if (w->id == snd_soc_dapm_pre) {

536 if (!w->event)

537 continue;

538

539 if (event == SND_SOC_DAPM_STREAM_START) {

540 ret = w->event(w,

541 NULL, SND_SOC_DAPM_PRE_PMU);

542 if (ret < 0)

543 return ret;

544 } else if (event == SND_SOC_DAPM_STREAM_STOP) {

545 ret = w->event(w,

546 NULL, SND_SOC_DAPM_PRE_PMD);

547 if (ret < 0)

548 return ret;

549 }

550 continue;

551 }

552 if (w->id == snd_soc_dapm_post) {

553 if (!w->event)

554 continue;

555

556 if (event == SND_SOC_DAPM_STREAM_START) {

557 ret = w->event(w,

558 NULL, SND_SOC_DAPM_POST_PMU);

559 if (ret < 0)

560 return ret;

561 } else if (event == SND_SOC_DAPM_STREAM_STOP) {

562 ret = w->event(w,

563 NULL, SND_SOC_DAPM_POST_PMD);

564 if (ret < 0)

565 return ret;

566 }

567 continue;

568 }

569

570 /* all other widgets */

571 in = is_connected_input_ep(w);

572 dapm_clear_walk(w->codec);

573 out = is_connected_output_ep(w);

574 dapm_clear_walk(w->codec);

575 power = (out != 0 && in != 0) ? 1 : 0;

576 power_change = (w->power == power) ? 0: 1;

577 w->power = power;

578

579 /* call any power change event handlers */

580 if (power_change) {

581 if (w->event) {

582 dbg("power %s event for %s flags %x\n",

583 w->power ? "on" : "off", w->name, w->event_flags);

584 if (power) {

585 /* power up event */

586 if (w->event_flags & SND_SOC_DAPM_PRE_PMU) {

587 ret = w->event(w,

588 NULL, SND_SOC_DAPM_PRE_PMU);

589 if (ret < 0)

590 return ret;

591 }

592 dapm_update_bits(w);

593 if (w->event_flags & SND_SOC_DAPM_POST_PMU){

594 ret = w->event(w,

595 NULL, SND_SOC_DAPM_POST_PMU);

596 if (ret < 0)

597 return ret;

598 }

599 } else {

600 /* power down event */

601 if (w->event_flags & SND_SOC_DAPM_PRE_PMD) {

602 ret = w->event(w,

603 NULL, SND_SOC_DAPM_PRE_PMD);

604 if (ret < 0)

605 return ret;

606 }

607 dapm_update_bits(w);

608 if (w->event_flags & SND_SOC_DAPM_POST_PMD) {

609 ret = w->event(w,

610 NULL, SND_SOC_DAPM_POST_PMD);

611 if (ret < 0)

612 return ret;

613 }

614 }

615 } else

616 /* no event handler */

617 dapm_update_bits(w);

618 }

619 }

620 }

621

622 return ret;

623 }

624

625 #if DAPM_DEBUG

626 static void dbg_dump_dapm(struct snd_soc_codec* codec, const char *action)

627 {

628 struct snd_soc_dapm_widget *w;

629 struct snd_soc_dapm_path *p = NULL;

630 int in, out;

631

632 printk("DAPM %s %s\n", codec->name, action);

633

634 list_for_each_entry(w, &codec->dapm_widgets, list) {

635

636 /* only display widgets that effect routing */

637 switch (w->id) {

638 case snd_soc_dapm_pre:

639 case snd_soc_dapm_post:

640 case snd_soc_dapm_vmid:

641 continue;

642 case snd_soc_dapm_mux:

643 case snd_soc_dapm_output:

644 case snd_soc_dapm_input:

645 case snd_soc_dapm_switch:

646 case snd_soc_dapm_hp:

647 case snd_soc_dapm_mic:

648 case snd_soc_dapm_spk:

649 case snd_soc_dapm_line:

650 case snd_soc_dapm_micbias:

651 case snd_soc_dapm_dac:

652 case snd_soc_dapm_adc:

653 case snd_soc_dapm_pga:

654 case snd_soc_dapm_mixer:

655 if (w->name) {

656 in = is_connected_input_ep(w);

657 dapm_clear_walk(w->codec);

658 out = is_connected_output_ep(w);

659 dapm_clear_walk(w->codec);

660 printk("%s: %s in %d out %d\n", w->name,

661 w->power ? "On":"Off",in, out);

662

663 list_for_each_entry(p, &w->sources, list_sink) {

664 if (p->connect)

665 printk(" in %s %s\n", p->name ? p->name : "static",

666 p->source->name);

667 }

668 list_for_each_entry(p, &w->sinks, list_source) {

669 if (p->connect)

670 printk(" out %s %s\n", p->name ? p->name : "static",

671 p->sink->name);

672 }

673 }

674 break;

675 }

676 }

677 }

678 #endif

679

680 /* test and update the power status of a mux widget */

681 static int dapm_mux_update_power(struct snd_soc_dapm_widget *widget,

682 struct snd_kcontrol *kcontrol, int mask,

683 int val, struct soc_enum* e)

684 {

685 struct snd_soc_dapm_path *path;

686 int found = 0;

687

688 if (widget->id != snd_soc_dapm_mux)

689 return -ENODEV;

690

691 if (!snd_soc_test_bits(widget->codec, e->reg, mask, val))

692 return 0;

693

694 /* find dapm widget path assoc with kcontrol */

695 list_for_each_entry(path, &widget->codec->dapm_paths, list) {

696 if (path->kcontrol != kcontrol)

697 continue;

698

699 if (!path->name || ! e->texts[val])

700 continue;

701

702 found = 1;

703 /* we now need to match the string in the enum to the path */

704 if (!(strcmp(path->name, e->texts[val])))

705 path->connect = 1; /* new connection */

706 else

707 path->connect = 0; /* old connection must be powered down */

708 }

709

710 if (found)

711 dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP);

712

713 return 0;

714 }

715

716 /* test and update the power status of a mixer or switch widget */

717 static int dapm_mixer_update_power(struct snd_soc_dapm_widget *widget,

718 struct snd_kcontrol *kcontrol, int reg,

719 int val_mask, int val, int invert)

720 {

721 struct snd_soc_dapm_path *path;

722 int found = 0;

723

724 if (widget->id != snd_soc_dapm_mixer &&

725 widget->id != snd_soc_dapm_switch)

726 return -ENODEV;

727

728 if (!snd_soc_test_bits(widget->codec, reg, val_mask, val))

729 return 0;

730

731 /* find dapm widget path assoc with kcontrol */

732 list_for_each_entry(path, &widget->codec->dapm_paths, list) {

733 if (path->kcontrol != kcontrol)

734 continue;

735

736 /* found, now check type */

737 found = 1;

738 if (val)

739 /* new connection */

740 path->connect = invert ? 0:1;

741 else

742 /* old connection must be powered down */

743 path->connect = invert ? 1:0;

744 break;

745 }

746

747 if (found)

748 dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP);

749

750 return 0;

751 }

752

753 /* show dapm widget status in sys fs */

754 static ssize_t dapm_widget_show(struct device *dev,

755 struct device_attribute *attr, char *buf)

756 {

757 struct snd_soc_device *devdata = dev_get_drvdata(dev);

758 struct snd_soc_codec *codec = devdata->codec;

759 struct snd_soc_dapm_widget *w;

760 int count = 0;

761 char *state = "not set";

762

763 list_for_each_entry(w, &codec->dapm_widgets, list) {

764

765 /* only display widgets that burnm power */

766 switch (w->id) {

767 case snd_soc_dapm_hp:

768 case snd_soc_dapm_mic:

769 case snd_soc_dapm_spk:

770 case snd_soc_dapm_line:

771 case snd_soc_dapm_micbias:

772 case snd_soc_dapm_dac:

773 case snd_soc_dapm_adc:

774 case snd_soc_dapm_pga:

775 case snd_soc_dapm_mixer:

776 if (w->name)

777 count += sprintf(buf + count, "%s: %s\n",

778 w->name, w->power ? "On":"Off");

779 break;

780 default:

781 break;

782 }

783 }

784

785 switch (codec->bias_level) {

786 case SND_SOC_BIAS_ON:

787 state = "On";

788 break;

789 case SND_SOC_BIAS_PREPARE:

790 state = "Prepare";

791 break;

792 case SND_SOC_BIAS_STANDBY:

793 state = "Standby";

794 break;

795 case SND_SOC_BIAS_OFF:

796 state = "Off";

797 break;

798 }

799 count += sprintf(buf + count, "PM State: %s\n", state);

800

801 return count;

802 }

803

804 static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);

805

806 int snd_soc_dapm_sys_add(struct device *dev)

807 {

808 int ret = 0;

809

810 if (dapm_status)

811 ret = device_create_file(dev, &dev_attr_dapm_widget);

812

813 return ret;

814 }

815

816 static void snd_soc_dapm_sys_remove(struct device *dev)

817 {

818 if (dapm_status)

819 device_remove_file(dev, &dev_attr_dapm_widget);

820 }

821

822 /* free all dapm widgets and resources */

823 static void dapm_free_widgets(struct snd_soc_codec *codec)

824 {

825 struct snd_soc_dapm_widget *w, *next_w;

826 struct snd_soc_dapm_path *p, *next_p;

827

828 list_for_each_entry_safe(w, next_w, &codec->dapm_widgets, list) {

829 list_del(&w->list);

830 kfree(w);

831 }

832

833 list_for_each_entry_safe(p, next_p, &codec->dapm_paths, list) {

834 list_del(&p->list);

835 kfree(p->long_name);

836 kfree(p);

837 }

838 }

839

840 /**

841 * snd_soc_dapm_sync_endpoints - scan and power dapm paths

842 * @codec: audio codec

843 *

844 * Walks all dapm audio paths and powers widgets according to their

845 * stream or path usage.

846 *

847 * Returns 0 for success.

848 */

849 int snd_soc_dapm_sync_endpoints(struct snd_soc_codec *codec)

850 {

851 return dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP);

852 }

853 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync_endpoints);

854

855 static int snd_soc_dapm_add_route(struct snd_soc_codec *codec,

856 const char *sink, const char *control, const char *source)

857 {

858 struct snd_soc_dapm_path *path;

859 struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;

860 int ret = 0;

861

862 /* find src and dest widgets */

863 list_for_each_entry(w, &codec->dapm_widgets, list) {

864

865 if (!wsink && !(strcmp(w->name, sink))) {

866 wsink = w;

867 continue;

868 }

869 if (!wsource && !(strcmp(w->name, source))) {

870 wsource = w;

871 }

872 }

873

874 if (wsource == NULL || wsink == NULL)

875 return -ENODEV;

876

877 path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);

878 if (!path)

879 return -ENOMEM;

880

881 path->source = wsource;

882 path->sink = wsink;

883 INIT_LIST_HEAD(&path->list);

884 INIT_LIST_HEAD(&path->list_source);

885 INIT_LIST_HEAD(&path->list_sink);

886

887 /* check for external widgets */

888 if (wsink->id == snd_soc_dapm_input) {

889 if (wsource->id == snd_soc_dapm_micbias ||

890 wsource->id == snd_soc_dapm_mic ||

891 wsink->id == snd_soc_dapm_line ||

892 wsink->id == snd_soc_dapm_output)

893 wsink->ext = 1;

894 }

895 if (wsource->id == snd_soc_dapm_output) {

896 if (wsink->id == snd_soc_dapm_spk ||

897 wsink->id == snd_soc_dapm_hp ||

898 wsink->id == snd_soc_dapm_line ||

899 wsink->id == snd_soc_dapm_input)

900 wsource->ext = 1;

901 }

902

903 /* connect static paths */

904 if (control == NULL) {

905 list_add(&path->list, &codec->dapm_paths);

906 list_add(&path->list_sink, &wsink->sources);

907 list_add(&path->list_source, &wsource->sinks);

908 path->connect = 1;

909 return 0;

910 }

911

912 /* connect dynamic paths */

913 switch(wsink->id) {

914 case snd_soc_dapm_adc:

915 case snd_soc_dapm_dac:

916 case snd_soc_dapm_pga:

917 case snd_soc_dapm_input:

918 case snd_soc_dapm_output:

919 case snd_soc_dapm_micbias:

920 case snd_soc_dapm_vmid:

921 case snd_soc_dapm_pre:

922 case snd_soc_dapm_post:

923 list_add(&path->list, &codec->dapm_paths);

924 list_add(&path->list_sink, &wsink->sources);

925 list_add(&path->list_source, &wsource->sinks);

926 path->connect = 1;

927 return 0;

928 case snd_soc_dapm_mux:

929 ret = dapm_connect_mux(codec, wsource, wsink, path, control,

930 &wsink->kcontrols[0]);

931 if (ret != 0)

932 goto err;

933 break;

934 case snd_soc_dapm_switch:

935 case snd_soc_dapm_mixer:

936 ret = dapm_connect_mixer(codec, wsource, wsink, path, control);

937 if (ret != 0)

938 goto err;

939 break;

940 case snd_soc_dapm_hp:

941 case snd_soc_dapm_mic:

942 case snd_soc_dapm_line:

943 case snd_soc_dapm_spk:

944 list_add(&path->list, &codec->dapm_paths);

945 list_add(&path->list_sink, &wsink->sources);

946 list_add(&path->list_source, &wsource->sinks);

947 path->connect = 0;

948 return 0;

949 }

950 return 0;

951

952 err:

953 printk(KERN_WARNING "asoc: no dapm match for %s --> %s --> %s\n", source,

954 control, sink);

955 kfree(path);

956 return ret;

957 }

958

959 /**

960 * snd_soc_dapm_connect_input - connect dapm widgets

961 * @codec: audio codec

962 * @sink: name of target widget

963 * @control: mixer control name

964 * @source: name of source name

965 *

966 * Connects 2 dapm widgets together via a named audio path. The sink is

967 * the widget receiving the audio signal, whilst the source is the sender

968 * of the audio signal.

969 *

970 * This function has been deprecated in favour of snd_soc_dapm_add_routes().

971 *

972 * Returns 0 for success else error.

973 */

974 int snd_soc_dapm_connect_input(struct snd_soc_codec *codec, const char *sink,

975 const char *control, const char *source)

976 {

977 return snd_soc_dapm_add_route(codec, sink, control, source);

978 }

979 EXPORT_SYMBOL_GPL(snd_soc_dapm_connect_input);

980

981 /**

982 * snd_soc_dapm_add_routes - Add routes between DAPM widgets

983 * @codec: codec

984 * @route: audio routes

985 * @num: number of routes

986 *

987 * Connects 2 dapm widgets together via a named audio path. The sink is

988 * the widget receiving the audio signal, whilst the source is the sender

989 * of the audio signal.

990 *

991 * Returns 0 for success else error. On error all resources can be freed

992 * with a call to snd_soc_card_free().

993 */

994 int snd_soc_dapm_add_routes(struct snd_soc_codec *codec,

995 const struct snd_soc_dapm_route *route, int num)

996 {

997 int i, ret;

998

999 for (i = 0; i < num; i++) {

1000 ret = snd_soc_dapm_add_route(codec, route->sink,

1001 route->control, route->source);

1002 if (ret < 0) {

1003 printk(KERN_ERR "Failed to add route %s->%s\n",

1004 route->source,

1005 route->sink);

1006 return ret;

1007 }

1008 route++;

1009 }

1010

1011 return 0;

1012 }

1013 EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);

1014

1015 /**

1016 * snd_soc_dapm_new_widgets - add new dapm widgets

1017 * @codec: audio codec

1018 *

1019 * Checks the codec for any new dapm widgets and creates them if found.

1020 *

1021 * Returns 0 for success.

1022 */

1023 int snd_soc_dapm_new_widgets(struct snd_soc_codec *codec)

1024 {

1025 struct snd_soc_dapm_widget *w;

1026

1027 list_for_each_entry(w, &codec->dapm_widgets, list)

1028 {

1029 if (w->new)

1030 continue;

1031

1032 switch(w->id) {

1033 case snd_soc_dapm_switch:

1034 case snd_soc_dapm_mixer:

1035 dapm_new_mixer(codec, w);

1036 break;

1037 case snd_soc_dapm_mux:

1038 dapm_new_mux(codec, w);

1039 break;

1040 case snd_soc_dapm_adc:

1041 case snd_soc_dapm_dac:

1042 case snd_soc_dapm_pga:

1043 dapm_new_pga(codec, w);

1044 break;

1045 case snd_soc_dapm_input:

1046 case snd_soc_dapm_output:

1047 case snd_soc_dapm_micbias:

1048 case snd_soc_dapm_spk:

1049 case snd_soc_dapm_hp:

1050 case snd_soc_dapm_mic:

1051 case snd_soc_dapm_line:

1052 case snd_soc_dapm_vmid:

1053 case snd_soc_dapm_pre:

1054 case snd_soc_dapm_post:

1055 break;

1056 }

1057 w->new = 1;

1058 }

1059

1060 dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP);

1061 return 0;

1062 }

1063 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);

1064

1065 /**

1066 * snd_soc_dapm_get_volsw - dapm mixer get callback

1067 * @kcontrol: mixer control

1068 * @uinfo: control element information

1069 *

1070 * Callback to get the value of a dapm mixer control.

1071 *

1072 * Returns 0 for success.

1073 */

1074 int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,

1075 struct snd_ctl_elem_value *ucontrol)

1076 {

1077 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);

1078 int reg = kcontrol->private_value & 0xff;

1079 int shift = (kcontrol->private_value >> 8) & 0x0f;

1080 int rshift = (kcontrol->private_value >> 12) & 0x0f;

1081 int max = (kcontrol->private_value >> 16) & 0xff;

1082 int invert = (kcontrol->private_value >> 24) & 0x01;

1083 int mask = (1 << fls(max)) - 1;

1084

1085 /* return the saved value if we are powered down */

1086 if (widget->id == snd_soc_dapm_pga && !widget->power) {

1087 ucontrol->value.integer.value[0] = widget->saved_value;

1088 return 0;

1089 }

1090

1091 ucontrol->value.integer.value[0] =

1092 (snd_soc_read(widget->codec, reg) >> shift) & mask;

1093 if (shift != rshift)

1094 ucontrol->value.integer.value[1] =

1095 (snd_soc_read(widget->codec, reg) >> rshift) & mask;

1096 if (invert) {

1097 ucontrol->value.integer.value[0] =

1098 max - ucontrol->value.integer.value[0];

1099 if (shift != rshift)

1100 ucontrol->value.integer.value[1] =

1101 max - ucontrol->value.integer.value[1];

1102 }

1103

1104 return 0;

1105 }

1106 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);

1107

1108 /**

1109 * snd_soc_dapm_put_volsw - dapm mixer set callback

1110 * @kcontrol: mixer control

1111 * @uinfo: control element information

1112 *

1113 * Callback to set the value of a dapm mixer control.

1114 *

1115 * Returns 0 for success.

1116 */

1117 int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,

1118 struct snd_ctl_elem_value *ucontrol)

1119 {

1120 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);

1121 int reg = kcontrol->private_value & 0xff;

1122 int shift = (kcontrol->private_value >> 8) & 0x0f;

1123 int rshift = (kcontrol->private_value >> 12) & 0x0f;

1124 int max = (kcontrol->private_value >> 16) & 0xff;

1125 int mask = (1 << fls(max)) - 1;

1126 int invert = (kcontrol->private_value >> 24) & 0x01;

1127 unsigned short val, val2, val_mask;

1128 int ret;

1129

1130 val = (ucontrol->value.integer.value[0] & mask);

1131

1132 if (invert)

1133 val = max - val;

1134 val_mask = mask << shift;

1135 val = val << shift;

1136 if (shift != rshift) {

1137 val2 = (ucontrol->value.integer.value[1] & mask);

1138 if (invert)

1139 val2 = max - val2;

1140 val_mask |= mask << rshift;

1141 val |= val2 << rshift;

1142 }

1143

1144 mutex_lock(&widget->codec->mutex);

1145 widget->value = val;

1146

1147 /* save volume value if the widget is powered down */

1148 if (widget->id == snd_soc_dapm_pga && !widget->power) {

1149 widget->saved_value = val;

1150 mutex_unlock(&widget->codec->mutex);

1151 return 1;

1152 }

1153

1154 dapm_mixer_update_power(widget, kcontrol, reg, val_mask, val, invert);

1155 if (widget->event) {

1156 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {

1157 ret = widget->event(widget, kcontrol,

1158 SND_SOC_DAPM_PRE_REG);

1159 if (ret < 0) {

1160 ret = 1;

1161 goto out;

1162 }

1163 }

1164 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);

1165 if (widget->event_flags & SND_SOC_DAPM_POST_REG)

1166 ret = widget->event(widget, kcontrol,

1167 SND_SOC_DAPM_POST_REG);

1168 } else

1169 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);

1170

1171 out:

1172 mutex_unlock(&widget->codec->mutex);

1173 return ret;

1174 }

1175 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);

1176

1177 /**

1178 * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback

1179 * @kcontrol: mixer control

1180 * @uinfo: control element information

1181 *

1182 * Callback to get the value of a dapm enumerated double mixer control.

1183 *

1184 * Returns 0 for success.

1185 */

1186 int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,

1187 struct snd_ctl_elem_value *ucontrol)

1188 {

1189 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);

1190 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;

1191 unsigned short val, bitmask;

1192

1193 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)

1194 ;

1195 val = snd_soc_read(widget->codec, e->reg);

1196 ucontrol->value.enumerated.item[0] = (val >> e->shift_l) & (bitmask - 1);

1197 if (e->shift_l != e->shift_r)

1198 ucontrol->value.enumerated.item[1] =

1199 (val >> e->shift_r) & (bitmask - 1);

1200

1201 return 0;

1202 }

1203 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);

1204

1205 /**

1206 * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback

1207 * @kcontrol: mixer control

1208 * @uinfo: control element information

1209 *

1210 * Callback to set the value of a dapm enumerated double mixer control.

1211 *

1212 * Returns 0 for success.

1213 */

1214 int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,

1215 struct snd_ctl_elem_value *ucontrol)

1216 {

1217 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);

1218 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;

1219 unsigned short val, mux;

1220 unsigned short mask, bitmask;

1221 int ret = 0;

1222

1223 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)

1224 ;

1225 if (ucontrol->value.enumerated.item[0] > e->mask - 1)

1226 return -EINVAL;

1227 mux = ucontrol->value.enumerated.item[0];

1228 val = mux << e->shift_l;

1229 mask = (bitmask - 1) << e->shift_l;

1230 if (e->shift_l != e->shift_r) {

1231 if (ucontrol->value.enumerated.item[1] > e->mask - 1)

1232 return -EINVAL;

1233 val |= ucontrol->value.enumerated.item[1] << e->shift_r;

1234 mask |= (bitmask - 1) << e->shift_r;

1235 }

1236

1237 mutex_lock(&widget->codec->mutex);

1238 widget->value = val;

1239 dapm_mux_update_power(widget, kcontrol, mask, mux, e);

1240 if (widget->event) {

1241 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {

1242 ret = widget->event(widget,

1243 kcontrol, SND_SOC_DAPM_PRE_REG);

1244 if (ret < 0)

1245 goto out;

1246 }

1247 ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);

1248 if (widget->event_flags & SND_SOC_DAPM_POST_REG)

1249 ret = widget->event(widget,

1250 kcontrol, SND_SOC_DAPM_POST_REG);

1251 } else

1252 ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);

1253

1254 out:

1255 mutex_unlock(&widget->codec->mutex);

1256 return ret;

1257 }

1258 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);

1259

1260 /**

1261 * snd_soc_dapm_new_control - create new dapm control

1262 * @codec: audio codec

1263 * @widget: widget template

1264 *

1265 * Creates a new dapm control based upon the template.

1266 *

1267 * Returns 0 for success else error.

1268 */

1269 int snd_soc_dapm_new_control(struct snd_soc_codec *codec,

1270 const struct snd_soc_dapm_widget *widget)

1271 {

1272 struct snd_soc_dapm_widget *w;

1273

1274 if ((w = dapm_cnew_widget(widget)) == NULL)

1275 return -ENOMEM;

1276

1277 w->codec = codec;

1278 INIT_LIST_HEAD(&w->sources);

1279 INIT_LIST_HEAD(&w->sinks);

1280 INIT_LIST_HEAD(&w->list);

1281 list_add(&w->list, &codec->dapm_widgets);

1282

1283 /* machine layer set ups unconnected pins and insertions */

1284 w->connected = 1;

1285 return 0;

1286 }

1287 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_control);

1288

1289 /**

1290 * snd_soc_dapm_new_controls - create new dapm controls

1291 * @codec: audio codec

1292 * @widget: widget array

1293 * @num: number of widgets

1294 *

1295 * Creates new DAPM controls based upon the templates.

1296 *

1297 * Returns 0 for success else error.

1298 */

1299 int snd_soc_dapm_new_controls(struct snd_soc_codec *codec,

1300 const struct snd_soc_dapm_widget *widget,

1301 int num)

1302 {

1303 int i, ret;

1304

1305 for (i = 0; i < num; i++) {

1306 ret = snd_soc_dapm_new_control(codec, widget);

1307 if (ret < 0)

1308 return ret;

1309 widget++;

1310 }

1311 return 0;

1312 }

1313 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);

1314

1315

1316 /**

1317 * snd_soc_dapm_stream_event - send a stream event to the dapm core

1318 * @codec: audio codec

1319 * @stream: stream name

1320 * @event: stream event

1321 *

1322 * Sends a stream event to the dapm core. The core then makes any

1323 * necessary widget power changes.

1324 *

1325 * Returns 0 for success else error.

1326 */

1327 int snd_soc_dapm_stream_event(struct snd_soc_codec *codec,

1328 char *stream, int event)

1329 {

1330 struct snd_soc_dapm_widget *w;

1331

1332 if (stream == NULL)

1333 return 0;

1334

1335 mutex_lock(&codec->mutex);

1336 list_for_each_entry(w, &codec->dapm_widgets, list)

1337 {

1338 if (!w->sname)

1339 continue;

1340 dbg("widget %s\n %s stream %s event %d\n", w->name, w->sname,

1341 stream, event);

1342 if (strstr(w->sname, stream)) {

1343 switch(event) {

1344 case SND_SOC_DAPM_STREAM_START:

1345 w->active = 1;

1346 break;

1347 case SND_SOC_DAPM_STREAM_STOP:

1348 w->active = 0;

1349 break;

1350 case SND_SOC_DAPM_STREAM_SUSPEND:

1351 if (w->active)

1352 w->suspend = 1;

1353 w->active = 0;

1354 break;

1355 case SND_SOC_DAPM_STREAM_RESUME:

1356 if (w->suspend) {

1357 w->active = 1;

1358 w->suspend = 0;

1359 }

1360 break;

1361 case SND_SOC_DAPM_STREAM_PAUSE_PUSH:

1362 break;

1363 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:

1364 break;

1365 }

1366 }

1367 }

1368 mutex_unlock(&codec->mutex);

1369

1370 dapm_power_widgets(codec, event);

1371 dump_dapm(codec, __func__);

1372 return 0;

1373 }

1374 EXPORT_SYMBOL_GPL(snd_soc_dapm_stream_event);

1375

1376 /**

1377 * snd_soc_dapm_set_bias_level - set the bias level for the system

1378 * @socdev: audio device

1379 * @level: level to configure

1380 *

1381 * Configure the bias (power) levels for the SoC audio device.

1382 *

1383 * Returns 0 for success else error.

1384 */

1385 int snd_soc_dapm_set_bias_level(struct snd_soc_device *socdev,

1386 enum snd_soc_bias_level level)

1387 {

1388 struct snd_soc_codec *codec = socdev->codec;

1389 struct snd_soc_machine *machine = socdev->machine;

1390 int ret = 0;

1391

1392 if (machine->set_bias_level)

1393 ret = machine->set_bias_level(machine, level);

1394 if (ret == 0 && codec->set_bias_level)

1395 ret = codec->set_bias_level(codec, level);

1396

1397 return ret;

1398 }

1399

1400 /**

1401 * snd_soc_dapm_set_endpoint - set audio endpoint status

1402 * @codec: audio codec

1403 * @endpoint: audio signal endpoint (or start point)

1404 * @status: point status

1405 *

1406 * Set audio endpoint status - connected or disconnected.

1407 *

1408 * Returns 0 for success else error.

1409 */

1410 int snd_soc_dapm_set_endpoint(struct snd_soc_codec *codec,

1411 char *endpoint, int status)

1412 {

1413 struct snd_soc_dapm_widget *w;

1414

1415 list_for_each_entry(w, &codec->dapm_widgets, list) {

1416 if (!strcmp(w->name, endpoint)) {

1417 w->connected = status;

1418 return 0;

1419 }

1420 }

1421

1422 return -ENODEV;

1423 }

1424 EXPORT_SYMBOL_GPL(snd_soc_dapm_set_endpoint);

1425

1426 /**

1427 * snd_soc_dapm_get_endpoint_status - get audio endpoint status

1428 * @codec: audio codec

1429 * @endpoint: audio signal endpoint (or start point)

1430 *

1431 * Get audio endpoint status - connected or disconnected.

1432 *

1433 * Returns status

1434 */

1435 int snd_soc_dapm_get_endpoint_status(struct snd_soc_codec *codec,

1436 char *endpoint)

1437 {

1438 struct snd_soc_dapm_widget *w;

1439

1440 list_for_each_entry(w, &codec->dapm_widgets, list) {

1441 if (!strcmp(w->name, endpoint))

1442 return w->connected;

1443 }

1444

1445 return 0;

1446 }

1447 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_endpoint_status);

1448

1449 /**

1450 * snd_soc_dapm_free - free dapm resources

1451 * @socdev: SoC device

1452 *

1453 * Free all dapm widgets and resources.

1454 */

1455 void snd_soc_dapm_free(struct snd_soc_device *socdev)

1456 {

1457 struct snd_soc_codec *codec = socdev->codec;

1458

1459 snd_soc_dapm_sys_remove(socdev->dev);

1460 dapm_free_widgets(codec);

1461 }

1462 EXPORT_SYMBOL_GPL(snd_soc_dapm_free);

1463

1464 /* Module information */

1465 MODULE_AUTHOR("Liam Girdwood, liam.girdwood@wolfsonmicro.com, www.wolfsonmicro.com");

1466 MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");

1467 MODULE_LICENSE("GPL");