Doug / smarc-fsl-linux-kernel

1

/*

1

/*

2

* Digital Audio (PCM) abstract layer

2

* Digital Audio (PCM) abstract layer

3

* Copyright (c) by Jaroslav Kysela <perex@perex.cz>

3

* Copyright (c) by Jaroslav Kysela <perex@perex.cz>

4

* Abramo Bagnara <abramo@alsa-project.org>

4

* Abramo Bagnara <abramo@alsa-project.org>

5

*

5

*

6

*

6

*

7

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

7

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

8

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

8

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

9

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

9

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

10

* (at your option) any later version.

10

* (at your option) any later version.

11

*

11

*

12

* This program is distributed in the hope that it will be useful,

12

* This program is distributed in the hope that it will be useful,

13

* but WITHOUT ANY WARRANTY; without even the implied warranty of

13

* but WITHOUT ANY WARRANTY; without even the implied warranty of

14

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

14

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

15

* GNU General Public License for more details.

15

* GNU General Public License for more details.

16

*

16

*

17

* You should have received a copy of the GNU General Public License

17

* You should have received a copy of the GNU General Public License

18

* along with this program; if not, write to the Free Software

18

* along with this program; if not, write to the Free Software

19

* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

19

* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

20

*

20

*

21

*/

21

*/

22

23

#include <linux/slab.h>

23

#include <linux/slab.h>

24

#include <linux/time.h>

24

#include <linux/time.h>

25

#include <linux/math64.h>

25

#include <linux/math64.h>

26

#include <linux/export.h>

26

#include <linux/export.h>

27

#include <sound/core.h>

27

#include <sound/core.h>

28

#include <sound/control.h>

28

#include <sound/control.h>

29

#include <sound/info.h>

29

#include <sound/info.h>

30

#include <sound/pcm.h>

30

#include <sound/pcm.h>

31

#include <sound/pcm_params.h>

31

#include <sound/pcm_params.h>

32

#include <sound/timer.h>

32

#include <sound/timer.h>

33

34

/*

34

/*

35

* fill ring buffer with silence

35

* fill ring buffer with silence

36

* runtime->silence_start: starting pointer to silence area

36

* runtime->silence_start: starting pointer to silence area

37

* runtime->silence_filled: size filled with silence

37

* runtime->silence_filled: size filled with silence

38

* runtime->silence_threshold: threshold from application

38

* runtime->silence_threshold: threshold from application

39

* runtime->silence_size: maximal size from application

39

* runtime->silence_size: maximal size from application

40

*

40

*

41

* when runtime->silence_size >= runtime->boundary - fill processed area with silence immediately

41

* when runtime->silence_size >= runtime->boundary - fill processed area with silence immediately

42

*/

42

*/

43

void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr)

43

void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr)

44

{

44

{

45

struct snd_pcm_runtime *runtime = substream->runtime;

45

struct snd_pcm_runtime *runtime = substream->runtime;

46

snd_pcm_uframes_t frames, ofs, transfer;

46

snd_pcm_uframes_t frames, ofs, transfer;

47

48

if (runtime->silence_size < runtime->boundary) {

48

if (runtime->silence_size < runtime->boundary) {

49

snd_pcm_sframes_t noise_dist, n;

49

snd_pcm_sframes_t noise_dist, n;

50

if (runtime->silence_start != runtime->control->appl_ptr) {

50

if (runtime->silence_start != runtime->control->appl_ptr) {

51

n = runtime->control->appl_ptr - runtime->silence_start;

51

n = runtime->control->appl_ptr - runtime->silence_start;

52

if (n < 0)

52

if (n < 0)

53

n += runtime->boundary;

53

n += runtime->boundary;

54

if ((snd_pcm_uframes_t)n < runtime->silence_filled)

54

if ((snd_pcm_uframes_t)n < runtime->silence_filled)

55

runtime->silence_filled -= n;

55

runtime->silence_filled -= n;

56

else

56

else

57

runtime->silence_filled = 0;

57

runtime->silence_filled = 0;

58

runtime->silence_start = runtime->control->appl_ptr;

58

runtime->silence_start = runtime->control->appl_ptr;

59

}

59

}

60

if (runtime->silence_filled >= runtime->buffer_size)

60

if (runtime->silence_filled >= runtime->buffer_size)

61

return;

61

return;

62

noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled;

62

noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled;

63

if (noise_dist >= (snd_pcm_sframes_t) runtime->silence_threshold)

63

if (noise_dist >= (snd_pcm_sframes_t) runtime->silence_threshold)

64

return;

64

return;

65

frames = runtime->silence_threshold - noise_dist;

65

frames = runtime->silence_threshold - noise_dist;

66

if (frames > runtime->silence_size)

66

if (frames > runtime->silence_size)

67

frames = runtime->silence_size;

67

frames = runtime->silence_size;

68

} else {

68

} else {

69

if (new_hw_ptr == ULONG_MAX) { /* initialization */

69

if (new_hw_ptr == ULONG_MAX) { /* initialization */

70

snd_pcm_sframes_t avail = snd_pcm_playback_hw_avail(runtime);

70

snd_pcm_sframes_t avail = snd_pcm_playback_hw_avail(runtime);

71

if (avail > runtime->buffer_size)

71

if (avail > runtime->buffer_size)

72

avail = runtime->buffer_size;

72

avail = runtime->buffer_size;

73

runtime->silence_filled = avail > 0 ? avail : 0;

73

runtime->silence_filled = avail > 0 ? avail : 0;

74

runtime->silence_start = (runtime->status->hw_ptr +

74

runtime->silence_start = (runtime->status->hw_ptr +

75

runtime->silence_filled) %

75

runtime->silence_filled) %

76

runtime->boundary;

76

runtime->boundary;

77

} else {

77

} else {

78

ofs = runtime->status->hw_ptr;

78

ofs = runtime->status->hw_ptr;

79

frames = new_hw_ptr - ofs;

79

frames = new_hw_ptr - ofs;

80

if ((snd_pcm_sframes_t)frames < 0)

80

if ((snd_pcm_sframes_t)frames < 0)

81

frames += runtime->boundary;

81

frames += runtime->boundary;

82

runtime->silence_filled -= frames;

82

runtime->silence_filled -= frames;

83

if ((snd_pcm_sframes_t)runtime->silence_filled < 0) {

83

if ((snd_pcm_sframes_t)runtime->silence_filled < 0) {

84

runtime->silence_filled = 0;

84

runtime->silence_filled = 0;

85

runtime->silence_start = new_hw_ptr;

85

runtime->silence_start = new_hw_ptr;

86

} else {

86

} else {

87

runtime->silence_start = ofs;

87

runtime->silence_start = ofs;

88

}

88

}

89

}

89

}

90

frames = runtime->buffer_size - runtime->silence_filled;

90

frames = runtime->buffer_size - runtime->silence_filled;

91

}

91

}

92

if (snd_BUG_ON(frames > runtime->buffer_size))

92

if (snd_BUG_ON(frames > runtime->buffer_size))

93

return;

93

return;

94

if (frames == 0)

94

if (frames == 0)

95

return;

95

return;

96

ofs = runtime->silence_start % runtime->buffer_size;

96

ofs = runtime->silence_start % runtime->buffer_size;

97

while (frames > 0) {

97

while (frames > 0) {

98

transfer = ofs + frames > runtime->buffer_size ? runtime->buffer_size - ofs : frames;

98

transfer = ofs + frames > runtime->buffer_size ? runtime->buffer_size - ofs : frames;

99

if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED ||

99

if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED ||

100

runtime->access == SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) {

100

runtime->access == SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) {

101

if (substream->ops->silence) {

101

if (substream->ops->silence) {

102

int err;

102

int err;

103

err = substream->ops->silence(substream, -1, ofs, transfer);

103

err = substream->ops->silence(substream, -1, ofs, transfer);

104

snd_BUG_ON(err < 0);

104

snd_BUG_ON(err < 0);

105

} else {

105

} else {

106

char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, ofs);

106

char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, ofs);

107

snd_pcm_format_set_silence(runtime->format, hwbuf, transfer * runtime->channels);

107

snd_pcm_format_set_silence(runtime->format, hwbuf, transfer * runtime->channels);

108

}

108

}

109

} else {

109

} else {

110

unsigned int c;

110

unsigned int c;

111

unsigned int channels = runtime->channels;

111

unsigned int channels = runtime->channels;

112

if (substream->ops->silence) {

112

if (substream->ops->silence) {

113

for (c = 0; c < channels; ++c) {

113

for (c = 0; c < channels; ++c) {

114

int err;

114

int err;

115

err = substream->ops->silence(substream, c, ofs, transfer);

115

err = substream->ops->silence(substream, c, ofs, transfer);

116

snd_BUG_ON(err < 0);

116

snd_BUG_ON(err < 0);

117

}

117

}

118

} else {

118

} else {

119

size_t dma_csize = runtime->dma_bytes / channels;

119

size_t dma_csize = runtime->dma_bytes / channels;

120

for (c = 0; c < channels; ++c) {

120

for (c = 0; c < channels; ++c) {

121

char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, ofs);

121

char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, ofs);

122

snd_pcm_format_set_silence(runtime->format, hwbuf, transfer);

122

snd_pcm_format_set_silence(runtime->format, hwbuf, transfer);

123

}

123

}

124

}

124

}

125

}

125

}

126

runtime->silence_filled += transfer;

126

runtime->silence_filled += transfer;

127

frames -= transfer;

127

frames -= transfer;

128

ofs = 0;

128

ofs = 0;

129

}

129

}

130

}

130

}

131

132

#ifdef CONFIG_SND_DEBUG

132

#ifdef CONFIG_SND_DEBUG

133

void snd_pcm_debug_name(struct snd_pcm_substream *substream,

133

void snd_pcm_debug_name(struct snd_pcm_substream *substream,

134

char *name, size_t len)

134

char *name, size_t len)

135

{

135

{

136

snprintf(name, len, "pcmC%dD%d%c:%d",

136

snprintf(name, len, "pcmC%dD%d%c:%d",

137

substream->pcm->card->number,

137

substream->pcm->card->number,

138

substream->pcm->device,

138

substream->pcm->device,

139

substream->stream ? 'c' : 'p',

139

substream->stream ? 'c' : 'p',

140

substream->number);

140

substream->number);

141

}

141

}

142

EXPORT_SYMBOL(snd_pcm_debug_name);

142

EXPORT_SYMBOL(snd_pcm_debug_name);

143

#endif

143

#endif

144

145

#define XRUN_DEBUG_BASIC (1<<0)

145

#define XRUN_DEBUG_BASIC (1<<0)

146

#define XRUN_DEBUG_STACK (1<<1) /* dump also stack */

146

#define XRUN_DEBUG_STACK (1<<1) /* dump also stack */

147

#define XRUN_DEBUG_JIFFIESCHECK (1<<2) /* do jiffies check */

147

#define XRUN_DEBUG_JIFFIESCHECK (1<<2) /* do jiffies check */

148

#define XRUN_DEBUG_PERIODUPDATE (1<<3) /* full period update info */

148

#define XRUN_DEBUG_PERIODUPDATE (1<<3) /* full period update info */

149

#define XRUN_DEBUG_HWPTRUPDATE (1<<4) /* full hwptr update info */

149

#define XRUN_DEBUG_HWPTRUPDATE (1<<4) /* full hwptr update info */

150

#define XRUN_DEBUG_LOG (1<<5) /* show last 10 positions on err */

150

#define XRUN_DEBUG_LOG (1<<5) /* show last 10 positions on err */

151

#define XRUN_DEBUG_LOGONCE (1<<6) /* do above only once */

151

#define XRUN_DEBUG_LOGONCE (1<<6) /* do above only once */

152

153

#ifdef CONFIG_SND_PCM_XRUN_DEBUG

153

#ifdef CONFIG_SND_PCM_XRUN_DEBUG

154

155

#define xrun_debug(substream, mask) \

155

#define xrun_debug(substream, mask) \

156

((substream)->pstr->xrun_debug & (mask))

156

((substream)->pstr->xrun_debug & (mask))

157

#else

157

#else

158

#define xrun_debug(substream, mask) 0

158

#define xrun_debug(substream, mask) 0

159

#endif

159

#endif

160

161

#define dump_stack_on_xrun(substream) do { \

161

#define dump_stack_on_xrun(substream) do { \

162

if (xrun_debug(substream, XRUN_DEBUG_STACK)) \

162

if (xrun_debug(substream, XRUN_DEBUG_STACK)) \

163

dump_stack(); \

163

dump_stack(); \

164

} while (0)

164

} while (0)

165

166

static void xrun(struct snd_pcm_substream *substream)

166

static void xrun(struct snd_pcm_substream *substream)

167

{

167

{

168

struct snd_pcm_runtime *runtime = substream->runtime;

168

struct snd_pcm_runtime *runtime = substream->runtime;

169

170

if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)

170

if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)

171

snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);

171

snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);

172

snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);

172

snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);

173

if (xrun_debug(substream, XRUN_DEBUG_BASIC)) {

173

if (xrun_debug(substream, XRUN_DEBUG_BASIC)) {

174

char name[16];

174

char name[16];

175

snd_pcm_debug_name(substream, name, sizeof(name));

175

snd_pcm_debug_name(substream, name, sizeof(name));

176

snd_printd(KERN_DEBUG "XRUN: %s\n", name);

176

snd_printd(KERN_DEBUG "XRUN: %s\n", name);

177

dump_stack_on_xrun(substream);

177

dump_stack_on_xrun(substream);

178

}

178

}

179

}

179

}

180

181

#ifdef CONFIG_SND_PCM_XRUN_DEBUG

181

#ifdef CONFIG_SND_PCM_XRUN_DEBUG

182

#define hw_ptr_error(substream, fmt, args...) \

182

#define hw_ptr_error(substream, fmt, args...) \

183

do { \

183

do { \

184

if (xrun_debug(substream, XRUN_DEBUG_BASIC)) { \

184

if (xrun_debug(substream, XRUN_DEBUG_BASIC)) { \

185

xrun_log_show(substream); \

185

xrun_log_show(substream); \

186

if (printk_ratelimit()) { \

186

if (printk_ratelimit()) { \

187

snd_printd("PCM: " fmt, ##args); \

187

snd_printd("PCM: " fmt, ##args); \

188

} \

188

} \

189

dump_stack_on_xrun(substream); \

189

dump_stack_on_xrun(substream); \

190

} \

190

} \

191

} while (0)

191

} while (0)

192

193

#define XRUN_LOG_CNT 10

193

#define XRUN_LOG_CNT 10

194

195

struct hwptr_log_entry {

195

struct hwptr_log_entry {

196

unsigned int in_interrupt;

196

unsigned int in_interrupt;

197

unsigned long jiffies;

197

unsigned long jiffies;

198

snd_pcm_uframes_t pos;

198

snd_pcm_uframes_t pos;

199

snd_pcm_uframes_t period_size;

199

snd_pcm_uframes_t period_size;

200

snd_pcm_uframes_t buffer_size;

200

snd_pcm_uframes_t buffer_size;

201

snd_pcm_uframes_t old_hw_ptr;

201

snd_pcm_uframes_t old_hw_ptr;

202

snd_pcm_uframes_t hw_ptr_base;

202

snd_pcm_uframes_t hw_ptr_base;

203

};

203

};

204

205

struct snd_pcm_hwptr_log {

205

struct snd_pcm_hwptr_log {

206

unsigned int idx;

206

unsigned int idx;

207

unsigned int hit: 1;

207

unsigned int hit: 1;

208

struct hwptr_log_entry entries[XRUN_LOG_CNT];

208

struct hwptr_log_entry entries[XRUN_LOG_CNT];

209

};

209

};

210

211

static void xrun_log(struct snd_pcm_substream *substream,

211

static void xrun_log(struct snd_pcm_substream *substream,

212

snd_pcm_uframes_t pos, int in_interrupt)

212

snd_pcm_uframes_t pos, int in_interrupt)

213

{

213

{

214

struct snd_pcm_runtime *runtime = substream->runtime;

214

struct snd_pcm_runtime *runtime = substream->runtime;

215

struct snd_pcm_hwptr_log *log = runtime->hwptr_log;

215

struct snd_pcm_hwptr_log *log = runtime->hwptr_log;

216

struct hwptr_log_entry *entry;

216

struct hwptr_log_entry *entry;

217

218

if (log == NULL) {

218

if (log == NULL) {

219

log = kzalloc(sizeof(*log), GFP_ATOMIC);

219

log = kzalloc(sizeof(*log), GFP_ATOMIC);

220

if (log == NULL)

220

if (log == NULL)

221

return;

221

return;

222

runtime->hwptr_log = log;

222

runtime->hwptr_log = log;

223

} else {

223

} else {

224

if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)

224

if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)

225

return;

225

return;

226

}

226

}

227

entry = &log->entries[log->idx];

227

entry = &log->entries[log->idx];

228

entry->in_interrupt = in_interrupt;

228

entry->in_interrupt = in_interrupt;

229

entry->jiffies = jiffies;

229

entry->jiffies = jiffies;

230

entry->pos = pos;

230

entry->pos = pos;

231

entry->period_size = runtime->period_size;

231

entry->period_size = runtime->period_size;

232

entry->buffer_size = runtime->buffer_size;

232

entry->buffer_size = runtime->buffer_size;

233

entry->old_hw_ptr = runtime->status->hw_ptr;

233

entry->old_hw_ptr = runtime->status->hw_ptr;

234

entry->hw_ptr_base = runtime->hw_ptr_base;

234

entry->hw_ptr_base = runtime->hw_ptr_base;

235

log->idx = (log->idx + 1) % XRUN_LOG_CNT;

235

log->idx = (log->idx + 1) % XRUN_LOG_CNT;

236

}

236

}

237

238

static void xrun_log_show(struct snd_pcm_substream *substream)

238

static void xrun_log_show(struct snd_pcm_substream *substream)

239

{

239

{

240

struct snd_pcm_hwptr_log *log = substream->runtime->hwptr_log;

240

struct snd_pcm_hwptr_log *log = substream->runtime->hwptr_log;

241

struct hwptr_log_entry *entry;

241

struct hwptr_log_entry *entry;

242

char name[16];

242

char name[16];

243

unsigned int idx;

243

unsigned int idx;

244

int cnt;

244

int cnt;

245

246

if (log == NULL)

246

if (log == NULL)

247

return;

247

return;

248

if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)

248

if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)

249

return;

249

return;

250

snd_pcm_debug_name(substream, name, sizeof(name));

250

snd_pcm_debug_name(substream, name, sizeof(name));

251

for (cnt = 0, idx = log->idx; cnt < XRUN_LOG_CNT; cnt++) {

251

for (cnt = 0, idx = log->idx; cnt < XRUN_LOG_CNT; cnt++) {

252

entry = &log->entries[idx];

252

entry = &log->entries[idx];

253

if (entry->period_size == 0)

253

if (entry->period_size == 0)

254

break;

254

break;

255

snd_printd("hwptr log: %s: %sj=%lu, pos=%ld/%ld/%ld, "

255

snd_printd("hwptr log: %s: %sj=%lu, pos=%ld/%ld/%ld, "

256

"hwptr=%ld/%ld\n",

256

"hwptr=%ld/%ld\n",

257

name, entry->in_interrupt ? "[Q] " : "",

257

name, entry->in_interrupt ? "[Q] " : "",

258

entry->jiffies,

258

entry->jiffies,

259

(unsigned long)entry->pos,

259

(unsigned long)entry->pos,

260

(unsigned long)entry->period_size,

260

(unsigned long)entry->period_size,

261

(unsigned long)entry->buffer_size,

261

(unsigned long)entry->buffer_size,

262

(unsigned long)entry->old_hw_ptr,

262

(unsigned long)entry->old_hw_ptr,

263

(unsigned long)entry->hw_ptr_base);

263

(unsigned long)entry->hw_ptr_base);

264

idx++;

264

idx++;

265

idx %= XRUN_LOG_CNT;

265

idx %= XRUN_LOG_CNT;

266

}

266

}

267

log->hit = 1;

267

log->hit = 1;

268

}

268

}

269

270

#else /* ! CONFIG_SND_PCM_XRUN_DEBUG */

270

#else /* ! CONFIG_SND_PCM_XRUN_DEBUG */

271

272

#define hw_ptr_error(substream, fmt, args...) do { } while (0)

272

#define hw_ptr_error(substream, fmt, args...) do { } while (0)

273

#define xrun_log(substream, pos, in_interrupt) do { } while (0)

273

#define xrun_log(substream, pos, in_interrupt) do { } while (0)

274

#define xrun_log_show(substream) do { } while (0)

274

#define xrun_log_show(substream) do { } while (0)

275

276

#endif

276

#endif

277

278

int snd_pcm_update_state(struct snd_pcm_substream *substream,

278

int snd_pcm_update_state(struct snd_pcm_substream *substream,

279

struct snd_pcm_runtime *runtime)

279

struct snd_pcm_runtime *runtime)

280

{

280

{

281

snd_pcm_uframes_t avail;

281

snd_pcm_uframes_t avail;

282

283

if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)

283

if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)

284

avail = snd_pcm_playback_avail(runtime);

284

avail = snd_pcm_playback_avail(runtime);

285

else

285

else

286

avail = snd_pcm_capture_avail(runtime);

286

avail = snd_pcm_capture_avail(runtime);

287

if (avail > runtime->avail_max)

287

if (avail > runtime->avail_max)

288

runtime->avail_max = avail;

288

runtime->avail_max = avail;

289

if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {

289

if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {

290

if (avail >= runtime->buffer_size) {

290

if (avail >= runtime->buffer_size) {

291

snd_pcm_drain_done(substream);

291

snd_pcm_drain_done(substream);

292

return -EPIPE;

292

return -EPIPE;

293

}

293

}

294

} else {

294

} else {

295

if (avail >= runtime->stop_threshold) {

295

if (avail >= runtime->stop_threshold) {

296

xrun(substream);

296

xrun(substream);

297

return -EPIPE;

297

return -EPIPE;

298

}

298

}

299

}

299

}

300

if (runtime->twake) {

300

if (runtime->twake) {

301

if (avail >= runtime->twake)

301

if (avail >= runtime->twake)

302

wake_up(&runtime->tsleep);

302

wake_up(&runtime->tsleep);

303

} else if (avail >= runtime->control->avail_min)

303

} else if (avail >= runtime->control->avail_min)

304

wake_up(&runtime->sleep);

304

wake_up(&runtime->sleep);

305

return 0;

305

return 0;

306

}

306

}

307

308

static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream,

308

static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream,

309

unsigned int in_interrupt)

309

unsigned int in_interrupt)

310

{

310

{

311

struct snd_pcm_runtime *runtime = substream->runtime;

311

struct snd_pcm_runtime *runtime = substream->runtime;

312

snd_pcm_uframes_t pos;

312

snd_pcm_uframes_t pos;

313

snd_pcm_uframes_t old_hw_ptr, new_hw_ptr, hw_base;

313

snd_pcm_uframes_t old_hw_ptr, new_hw_ptr, hw_base;

314

snd_pcm_sframes_t hdelta, delta;

314

snd_pcm_sframes_t hdelta, delta;

315

unsigned long jdelta;

315

unsigned long jdelta;

316

unsigned long curr_jiffies;

317

struct timespec curr_tstamp;

316

318

317

old_hw_ptr = runtime->status->hw_ptr;

319

old_hw_ptr = runtime->status->hw_ptr;

320

321

/*

322

* group pointer, time and jiffies reads to allow for more

323

* accurate correlations/corrections.

324

* The values are stored at the end of this routine after

325

* corrections for hw_ptr position

326

*/

318

pos = substream->ops->pointer(substream);

327

pos = substream->ops->pointer(substream);

328

curr_jiffies = jiffies;

329

if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)

330

snd_pcm_gettime(runtime, (struct timespec *)&curr_tstamp);

331

319

if (pos == SNDRV_PCM_POS_XRUN) {

332

if (pos == SNDRV_PCM_POS_XRUN) {

320

xrun(substream);

333

xrun(substream);

321

return -EPIPE;

334

return -EPIPE;

322

}

335

}

323

if (pos >= runtime->buffer_size) {

336

if (pos >= runtime->buffer_size) {

324

if (printk_ratelimit()) {

337

if (printk_ratelimit()) {

325

char name[16];

338

char name[16];

326

snd_pcm_debug_name(substream, name, sizeof(name));

339

snd_pcm_debug_name(substream, name, sizeof(name));

327

xrun_log_show(substream);

340

xrun_log_show(substream);

328

snd_printd(KERN_ERR "BUG: %s, pos = %ld, "

341

snd_printd(KERN_ERR "BUG: %s, pos = %ld, "

329

"buffer size = %ld, period size = %ld\n",

342

"buffer size = %ld, period size = %ld\n",

330

name, pos, runtime->buffer_size,

343

name, pos, runtime->buffer_size,

331

runtime->period_size);

344

runtime->period_size);

332

}

345

}

333

pos = 0;

346

pos = 0;

334

}

347

}

335

pos -= pos % runtime->min_align;

348

pos -= pos % runtime->min_align;

336

if (xrun_debug(substream, XRUN_DEBUG_LOG))

349

if (xrun_debug(substream, XRUN_DEBUG_LOG))

337

xrun_log(substream, pos, in_interrupt);

350

xrun_log(substream, pos, in_interrupt);

338

hw_base = runtime->hw_ptr_base;

351

hw_base = runtime->hw_ptr_base;

339

new_hw_ptr = hw_base + pos;

352

new_hw_ptr = hw_base + pos;

340

if (in_interrupt) {

353

if (in_interrupt) {

341

/* we know that one period was processed */

354

/* we know that one period was processed */

342

/* delta = "expected next hw_ptr" for in_interrupt != 0 */

355

/* delta = "expected next hw_ptr" for in_interrupt != 0 */

343

delta = runtime->hw_ptr_interrupt + runtime->period_size;

356

delta = runtime->hw_ptr_interrupt + runtime->period_size;

344

if (delta > new_hw_ptr) {

357

if (delta > new_hw_ptr) {

345

/* check for double acknowledged interrupts */

358

/* check for double acknowledged interrupts */

346

hdelta = jiffies - runtime->hw_ptr_jiffies;

359

hdelta = curr_jiffies - runtime->hw_ptr_jiffies;

347

if (hdelta > runtime->hw_ptr_buffer_jiffies/2) {

360

if (hdelta > runtime->hw_ptr_buffer_jiffies/2) {

348

hw_base += runtime->buffer_size;

361

hw_base += runtime->buffer_size;

349

if (hw_base >= runtime->boundary)

362

if (hw_base >= runtime->boundary)

350

hw_base = 0;

363

hw_base = 0;

351

new_hw_ptr = hw_base + pos;

364

new_hw_ptr = hw_base + pos;

352

goto __delta;

365

goto __delta;

353

}

366

}

354

}

367

}

355

}

368

}

356

/* new_hw_ptr might be lower than old_hw_ptr in case when */

369

/* new_hw_ptr might be lower than old_hw_ptr in case when */

357

/* pointer crosses the end of the ring buffer */

370

/* pointer crosses the end of the ring buffer */

358

if (new_hw_ptr < old_hw_ptr) {

371

if (new_hw_ptr < old_hw_ptr) {

359

hw_base += runtime->buffer_size;

372

hw_base += runtime->buffer_size;

360

if (hw_base >= runtime->boundary)

373

if (hw_base >= runtime->boundary)

361

hw_base = 0;

374

hw_base = 0;

362

new_hw_ptr = hw_base + pos;

375

new_hw_ptr = hw_base + pos;

363

}

376

}

364

__delta:

377

__delta:

365

delta = new_hw_ptr - old_hw_ptr;

378

delta = new_hw_ptr - old_hw_ptr;

366

if (delta < 0)

379

if (delta < 0)

367

delta += runtime->boundary;

380

delta += runtime->boundary;

368

if (xrun_debug(substream, in_interrupt ?

381

if (xrun_debug(substream, in_interrupt ?

369

XRUN_DEBUG_PERIODUPDATE : XRUN_DEBUG_HWPTRUPDATE)) {

382

XRUN_DEBUG_PERIODUPDATE : XRUN_DEBUG_HWPTRUPDATE)) {

370

char name[16];

383

char name[16];

371

snd_pcm_debug_name(substream, name, sizeof(name));

384

snd_pcm_debug_name(substream, name, sizeof(name));

372

snd_printd("%s_update: %s: pos=%u/%u/%u, "

385

snd_printd("%s_update: %s: pos=%u/%u/%u, "

373

"hwptr=%ld/%ld/%ld/%ld\n",

386

"hwptr=%ld/%ld/%ld/%ld\n",

374

in_interrupt ? "period" : "hwptr",

387

in_interrupt ? "period" : "hwptr",

375

name,

388

name,

376

(unsigned int)pos,

389

(unsigned int)pos,

377

(unsigned int)runtime->period_size,

390

(unsigned int)runtime->period_size,

378

(unsigned int)runtime->buffer_size,

391

(unsigned int)runtime->buffer_size,

379

(unsigned long)delta,

392

(unsigned long)delta,

380

(unsigned long)old_hw_ptr,

393

(unsigned long)old_hw_ptr,

381

(unsigned long)new_hw_ptr,

394

(unsigned long)new_hw_ptr,

382

(unsigned long)runtime->hw_ptr_base);

395

(unsigned long)runtime->hw_ptr_base);

383

}

396

}

384

397

385

if (runtime->no_period_wakeup) {

398

if (runtime->no_period_wakeup) {

386

snd_pcm_sframes_t xrun_threshold;

399

snd_pcm_sframes_t xrun_threshold;

387

/*

400

/*

388

* Without regular period interrupts, we have to check

401

* Without regular period interrupts, we have to check

389

* the elapsed time to detect xruns.

402

* the elapsed time to detect xruns.

390

*/

403

*/

391

jdelta = jiffies - runtime->hw_ptr_jiffies;

404

jdelta = curr_jiffies - runtime->hw_ptr_jiffies;

392

if (jdelta < runtime->hw_ptr_buffer_jiffies / 2)

405

if (jdelta < runtime->hw_ptr_buffer_jiffies / 2)

393

goto no_delta_check;

406

goto no_delta_check;

394

hdelta = jdelta - delta * HZ / runtime->rate;

407

hdelta = jdelta - delta * HZ / runtime->rate;

395

xrun_threshold = runtime->hw_ptr_buffer_jiffies / 2 + 1;

408

xrun_threshold = runtime->hw_ptr_buffer_jiffies / 2 + 1;

396

while (hdelta > xrun_threshold) {

409

while (hdelta > xrun_threshold) {

397

delta += runtime->buffer_size;

410

delta += runtime->buffer_size;

398

hw_base += runtime->buffer_size;

411

hw_base += runtime->buffer_size;

399

if (hw_base >= runtime->boundary)

412

if (hw_base >= runtime->boundary)

400

hw_base = 0;

413

hw_base = 0;

401

new_hw_ptr = hw_base + pos;

414

new_hw_ptr = hw_base + pos;

402

hdelta -= runtime->hw_ptr_buffer_jiffies;

415

hdelta -= runtime->hw_ptr_buffer_jiffies;

403

}

416

}

404

goto no_delta_check;

417

goto no_delta_check;

405

}

418

}

406

419

407

/* something must be really wrong */

420

/* something must be really wrong */

408

if (delta >= runtime->buffer_size + runtime->period_size) {

421

if (delta >= runtime->buffer_size + runtime->period_size) {

409

hw_ptr_error(substream,

422

hw_ptr_error(substream,

410

"Unexpected hw_pointer value %s"

423

"Unexpected hw_pointer value %s"

411

"(stream=%i, pos=%ld, new_hw_ptr=%ld, "

424

"(stream=%i, pos=%ld, new_hw_ptr=%ld, "

412

"old_hw_ptr=%ld)\n",

425

"old_hw_ptr=%ld)\n",

413

in_interrupt ? "[Q] " : "[P]",

426

in_interrupt ? "[Q] " : "[P]",

414

substream->stream, (long)pos,

427

substream->stream, (long)pos,

415

(long)new_hw_ptr, (long)old_hw_ptr);

428

(long)new_hw_ptr, (long)old_hw_ptr);

416

return 0;

429

return 0;

417

}

430

}

418

431

419

/* Do jiffies check only in xrun_debug mode */

432

/* Do jiffies check only in xrun_debug mode */

420

if (!xrun_debug(substream, XRUN_DEBUG_JIFFIESCHECK))

433

if (!xrun_debug(substream, XRUN_DEBUG_JIFFIESCHECK))

421

goto no_jiffies_check;

434

goto no_jiffies_check;

422

435

423

/* Skip the jiffies check for hardwares with BATCH flag.

436

/* Skip the jiffies check for hardwares with BATCH flag.

424

* Such hardware usually just increases the position at each IRQ,

437

* Such hardware usually just increases the position at each IRQ,

425

* thus it can't give any strange position.

438

* thus it can't give any strange position.

426

*/

439

*/

427

if (runtime->hw.info & SNDRV_PCM_INFO_BATCH)

440

if (runtime->hw.info & SNDRV_PCM_INFO_BATCH)

428

goto no_jiffies_check;

441

goto no_jiffies_check;

429

hdelta = delta;

442

hdelta = delta;

430

if (hdelta < runtime->delay)

443

if (hdelta < runtime->delay)

431

goto no_jiffies_check;

444

goto no_jiffies_check;

432

hdelta -= runtime->delay;

445

hdelta -= runtime->delay;

433

jdelta = jiffies - runtime->hw_ptr_jiffies;

446

jdelta = curr_jiffies - runtime->hw_ptr_jiffies;

434

if (((hdelta * HZ) / runtime->rate) > jdelta + HZ/100) {

447

if (((hdelta * HZ) / runtime->rate) > jdelta + HZ/100) {

435

delta = jdelta /

448

delta = jdelta /

436

(((runtime->period_size * HZ) / runtime->rate)

449

(((runtime->period_size * HZ) / runtime->rate)

437

+ HZ/100);

450

+ HZ/100);

438

/* move new_hw_ptr according jiffies not pos variable */

451

/* move new_hw_ptr according jiffies not pos variable */

439

new_hw_ptr = old_hw_ptr;

452

new_hw_ptr = old_hw_ptr;

440

hw_base = delta;

453

hw_base = delta;

441

/* use loop to avoid checks for delta overflows */

454

/* use loop to avoid checks for delta overflows */

442

/* the delta value is small or zero in most cases */

455

/* the delta value is small or zero in most cases */

443

while (delta > 0) {

456

while (delta > 0) {

444

new_hw_ptr += runtime->period_size;

457

new_hw_ptr += runtime->period_size;

445

if (new_hw_ptr >= runtime->boundary)

458

if (new_hw_ptr >= runtime->boundary)

446

new_hw_ptr -= runtime->boundary;

459

new_hw_ptr -= runtime->boundary;

447

delta--;

460

delta--;

448

}

461

}

449

/* align hw_base to buffer_size */

462

/* align hw_base to buffer_size */

450

hw_ptr_error(substream,

463

hw_ptr_error(substream,

451

"hw_ptr skipping! %s"

464

"hw_ptr skipping! %s"

452

"(pos=%ld, delta=%ld, period=%ld, "

465

"(pos=%ld, delta=%ld, period=%ld, "

453

"jdelta=%lu/%lu/%lu, hw_ptr=%ld/%ld)\n",

466

"jdelta=%lu/%lu/%lu, hw_ptr=%ld/%ld)\n",

454

in_interrupt ? "[Q] " : "",

467

in_interrupt ? "[Q] " : "",

455

(long)pos, (long)hdelta,

468

(long)pos, (long)hdelta,

456

(long)runtime->period_size, jdelta,

469

(long)runtime->period_size, jdelta,

457

((hdelta * HZ) / runtime->rate), hw_base,

470

((hdelta * HZ) / runtime->rate), hw_base,

458

(unsigned long)old_hw_ptr,

471

(unsigned long)old_hw_ptr,

459

(unsigned long)new_hw_ptr);

472

(unsigned long)new_hw_ptr);

460

/* reset values to proper state */

473

/* reset values to proper state */

461

delta = 0;

474

delta = 0;

462

hw_base = new_hw_ptr - (new_hw_ptr % runtime->buffer_size);

475

hw_base = new_hw_ptr - (new_hw_ptr % runtime->buffer_size);

463

}

476

}

464

no_jiffies_check:

477

no_jiffies_check:

465

if (delta > runtime->period_size + runtime->period_size / 2) {

478

if (delta > runtime->period_size + runtime->period_size / 2) {

466

hw_ptr_error(substream,

479

hw_ptr_error(substream,

467

"Lost interrupts? %s"

480

"Lost interrupts? %s"

468

"(stream=%i, delta=%ld, new_hw_ptr=%ld, "

481

"(stream=%i, delta=%ld, new_hw_ptr=%ld, "

469

"old_hw_ptr=%ld)\n",

482

"old_hw_ptr=%ld)\n",

470

in_interrupt ? "[Q] " : "",

483

in_interrupt ? "[Q] " : "",

471

substream->stream, (long)delta,

484

substream->stream, (long)delta,

472

(long)new_hw_ptr,

485

(long)new_hw_ptr,

473

(long)old_hw_ptr);

486

(long)old_hw_ptr);

474

}

487

}

475

488

476

no_delta_check:

489

no_delta_check:

477

if (runtime->status->hw_ptr == new_hw_ptr)

490

if (runtime->status->hw_ptr == new_hw_ptr)

478

return 0;

491

return 0;

479

492

480

if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&

493

if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&

481

runtime->silence_size > 0)

494

runtime->silence_size > 0)

482

snd_pcm_playback_silence(substream, new_hw_ptr);

495

snd_pcm_playback_silence(substream, new_hw_ptr);

483

496

484

if (in_interrupt) {

497

if (in_interrupt) {

485

delta = new_hw_ptr - runtime->hw_ptr_interrupt;

498

delta = new_hw_ptr - runtime->hw_ptr_interrupt;

486

if (delta < 0)

499

if (delta < 0)

487

delta += runtime->boundary;

500

delta += runtime->boundary;

488

delta -= (snd_pcm_uframes_t)delta % runtime->period_size;

501

delta -= (snd_pcm_uframes_t)delta % runtime->period_size;

489

runtime->hw_ptr_interrupt += delta;

502

runtime->hw_ptr_interrupt += delta;

490

if (runtime->hw_ptr_interrupt >= runtime->boundary)

503

if (runtime->hw_ptr_interrupt >= runtime->boundary)

491

runtime->hw_ptr_interrupt -= runtime->boundary;

504

runtime->hw_ptr_interrupt -= runtime->boundary;

492

}

505

}

493

runtime->hw_ptr_base = hw_base;

506

runtime->hw_ptr_base = hw_base;

494

runtime->status->hw_ptr = new_hw_ptr;

507

runtime->status->hw_ptr = new_hw_ptr;

495

runtime->hw_ptr_jiffies = jiffies;

508

runtime->hw_ptr_jiffies = curr_jiffies;

496

if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)

509

if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)

497

snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);

510

runtime->status->tstamp = curr_tstamp;

498

511

499

return snd_pcm_update_state(substream, runtime);

512

return snd_pcm_update_state(substream, runtime);

500

}

513

}

501

514

502

/* CAUTION: call it with irq disabled */

515

/* CAUTION: call it with irq disabled */

503

int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream)

516

int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream)

504

{

517

{

505

return snd_pcm_update_hw_ptr0(substream, 0);

518

return snd_pcm_update_hw_ptr0(substream, 0);

506

}

519

}

507

520

508

/**

521

/**

509

* snd_pcm_set_ops - set the PCM operators

522

* snd_pcm_set_ops - set the PCM operators

510

* @pcm: the pcm instance

523

* @pcm: the pcm instance

511

* @direction: stream direction, SNDRV_PCM_STREAM_XXX

524

* @direction: stream direction, SNDRV_PCM_STREAM_XXX

512

* @ops: the operator table

525

* @ops: the operator table

513

*

526

*

514

* Sets the given PCM operators to the pcm instance.

527

* Sets the given PCM operators to the pcm instance.

515

*/

528

*/

516

void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops)

529

void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops)

517

{

530

{

518

struct snd_pcm_str *stream = &pcm->streams[direction];

531

struct snd_pcm_str *stream = &pcm->streams[direction];

519

struct snd_pcm_substream *substream;

532

struct snd_pcm_substream *substream;

520

533

521

for (substream = stream->substream; substream != NULL; substream = substream->next)

534

for (substream = stream->substream; substream != NULL; substream = substream->next)

522

substream->ops = ops;

535

substream->ops = ops;

523

}

536

}

524

537

525

EXPORT_SYMBOL(snd_pcm_set_ops);

538

EXPORT_SYMBOL(snd_pcm_set_ops);

526

539

527

/**

540

/**

528

* snd_pcm_sync - set the PCM sync id

541

* snd_pcm_sync - set the PCM sync id

529

* @substream: the pcm substream

542

* @substream: the pcm substream

530

*

543

*

531

* Sets the PCM sync identifier for the card.

544

* Sets the PCM sync identifier for the card.

532

*/

545

*/

533

void snd_pcm_set_sync(struct snd_pcm_substream *substream)

546

void snd_pcm_set_sync(struct snd_pcm_substream *substream)

534

{

547

{

535

struct snd_pcm_runtime *runtime = substream->runtime;

548

struct snd_pcm_runtime *runtime = substream->runtime;

536

549

537

runtime->sync.id32[0] = substream->pcm->card->number;

550

runtime->sync.id32[0] = substream->pcm->card->number;

538

runtime->sync.id32[1] = -1;

551

runtime->sync.id32[1] = -1;

539

runtime->sync.id32[2] = -1;

552

runtime->sync.id32[2] = -1;

540

runtime->sync.id32[3] = -1;

553

runtime->sync.id32[3] = -1;

541

}

554

}

542

555

543

EXPORT_SYMBOL(snd_pcm_set_sync);

556

EXPORT_SYMBOL(snd_pcm_set_sync);

544

557

545

/*

558

/*

546

* Standard ioctl routine

559

* Standard ioctl routine

547

*/

560

*/

548

561

549

static inline unsigned int div32(unsigned int a, unsigned int b,

562

static inline unsigned int div32(unsigned int a, unsigned int b,

550

unsigned int *r)

563

unsigned int *r)

551

{

564

{

552

if (b == 0) {

565

if (b == 0) {

553

*r = 0;

566

*r = 0;

554

return UINT_MAX;

567

return UINT_MAX;

555

}

568

}

556

*r = a % b;

569

*r = a % b;

557

return a / b;

570

return a / b;

558

}

571

}

559

572

560

static inline unsigned int div_down(unsigned int a, unsigned int b)

573

static inline unsigned int div_down(unsigned int a, unsigned int b)

561

{

574

{

562

if (b == 0)

575

if (b == 0)

563

return UINT_MAX;

576

return UINT_MAX;

564

return a / b;

577

return a / b;

565

}

578

}

566

579

567

static inline unsigned int div_up(unsigned int a, unsigned int b)

580

static inline unsigned int div_up(unsigned int a, unsigned int b)

568

{

581

{

569

unsigned int r;

582

unsigned int r;

570

unsigned int q;

583

unsigned int q;

571

if (b == 0)

584

if (b == 0)

572

return UINT_MAX;

585

return UINT_MAX;

573

q = div32(a, b, &r);

586

q = div32(a, b, &r);

574

if (r)

587

if (r)

575

++q;

588

++q;

576

return q;

589

return q;

577

}

590

}

578

591

579

static inline unsigned int mul(unsigned int a, unsigned int b)

592

static inline unsigned int mul(unsigned int a, unsigned int b)

580

{

593

{

581

if (a == 0)

594

if (a == 0)

582

return 0;

595

return 0;

583

if (div_down(UINT_MAX, a) < b)

596

if (div_down(UINT_MAX, a) < b)

584

return UINT_MAX;

597

return UINT_MAX;

585

return a * b;

598

return a * b;

586

}

599

}

587

600

588

static inline unsigned int muldiv32(unsigned int a, unsigned int b,

601

static inline unsigned int muldiv32(unsigned int a, unsigned int b,

589

unsigned int c, unsigned int *r)

602

unsigned int c, unsigned int *r)

590

{

603

{

591

u_int64_t n = (u_int64_t) a * b;

604

u_int64_t n = (u_int64_t) a * b;

592

if (c == 0) {

605

if (c == 0) {

593

snd_BUG_ON(!n);

606

snd_BUG_ON(!n);

594

*r = 0;

607

*r = 0;

595

return UINT_MAX;

608

return UINT_MAX;

596

}

609

}

597

n = div_u64_rem(n, c, r);

610

n = div_u64_rem(n, c, r);

598

if (n >= UINT_MAX) {

611

if (n >= UINT_MAX) {

599

*r = 0;

612

*r = 0;

600

return UINT_MAX;

613

return UINT_MAX;

601

}

614

}

602

return n;

615

return n;

603

}

616

}

604

617

605

/**

618

/**

606

* snd_interval_refine - refine the interval value of configurator

619

* snd_interval_refine - refine the interval value of configurator

607

* @i: the interval value to refine

620

* @i: the interval value to refine

608

* @v: the interval value to refer to

621

* @v: the interval value to refer to

609

*

622

*

610

* Refines the interval value with the reference value.

623

* Refines the interval value with the reference value.

611

* The interval is changed to the range satisfying both intervals.

624

* The interval is changed to the range satisfying both intervals.

612

* The interval status (min, max, integer, etc.) are evaluated.

625

* The interval status (min, max, integer, etc.) are evaluated.

613

*

626

*

614

* Returns non-zero if the value is changed, zero if not changed.

627

* Returns non-zero if the value is changed, zero if not changed.

615

*/

628

*/

616

int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v)

629

int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v)

617

{

630

{

618

int changed = 0;

631

int changed = 0;

619

if (snd_BUG_ON(snd_interval_empty(i)))

632

if (snd_BUG_ON(snd_interval_empty(i)))

620

return -EINVAL;

633

return -EINVAL;

621

if (i->min < v->min) {

634

if (i->min < v->min) {

622

i->min = v->min;

635

i->min = v->min;

623

i->openmin = v->openmin;

636

i->openmin = v->openmin;

624

changed = 1;

637

changed = 1;

625

} else if (i->min == v->min && !i->openmin && v->openmin) {

638

} else if (i->min == v->min && !i->openmin && v->openmin) {

626

i->openmin = 1;

639

i->openmin = 1;

627

changed = 1;

640

changed = 1;

628

}

641

}

629

if (i->max > v->max) {

642

if (i->max > v->max) {

630

i->max = v->max;

643

i->max = v->max;

631

i->openmax = v->openmax;

644

i->openmax = v->openmax;

632

changed = 1;

645

changed = 1;

633

} else if (i->max == v->max && !i->openmax && v->openmax) {

646

} else if (i->max == v->max && !i->openmax && v->openmax) {

634

i->openmax = 1;

647

i->openmax = 1;

635

changed = 1;

648

changed = 1;

636

}

649

}

637

if (!i->integer && v->integer) {

650

if (!i->integer && v->integer) {

638

i->integer = 1;

651

i->integer = 1;

639

changed = 1;

652

changed = 1;

640

}

653

}

641

if (i->integer) {

654

if (i->integer) {

642

if (i->openmin) {

655

if (i->openmin) {

643

i->min++;

656

i->min++;

644

i->openmin = 0;

657

i->openmin = 0;

645

}

658

}

646

if (i->openmax) {

659

if (i->openmax) {

647

i->max--;

660

i->max--;

648

i->openmax = 0;

661

i->openmax = 0;

649

}

662

}

650

} else if (!i->openmin && !i->openmax && i->min == i->max)

663

} else if (!i->openmin && !i->openmax && i->min == i->max)

651

i->integer = 1;

664

i->integer = 1;

652

if (snd_interval_checkempty(i)) {

665

if (snd_interval_checkempty(i)) {

653

snd_interval_none(i);

666

snd_interval_none(i);

654

return -EINVAL;

667

return -EINVAL;

655

}

668

}

656

return changed;

669

return changed;

657

}

670

}

658

671

659

EXPORT_SYMBOL(snd_interval_refine);

672

EXPORT_SYMBOL(snd_interval_refine);

660

673

661

static int snd_interval_refine_first(struct snd_interval *i)

674

static int snd_interval_refine_first(struct snd_interval *i)

662

{

675

{

663

if (snd_BUG_ON(snd_interval_empty(i)))

676

if (snd_BUG_ON(snd_interval_empty(i)))

664

return -EINVAL;

677

return -EINVAL;

665

if (snd_interval_single(i))

678

if (snd_interval_single(i))

666

return 0;

679

return 0;

667

i->max = i->min;

680

i->max = i->min;

668

i->openmax = i->openmin;

681

i->openmax = i->openmin;

669

if (i->openmax)

682

if (i->openmax)

670

i->max++;

683

i->max++;

671

return 1;

684

return 1;

672

}

685

}

673

686

674

static int snd_interval_refine_last(struct snd_interval *i)

687

static int snd_interval_refine_last(struct snd_interval *i)

675

{

688

{

676

if (snd_BUG_ON(snd_interval_empty(i)))

689

if (snd_BUG_ON(snd_interval_empty(i)))

677

return -EINVAL;

690

return -EINVAL;

678

if (snd_interval_single(i))

691

if (snd_interval_single(i))

679

return 0;

692

return 0;

680

i->min = i->max;

693

i->min = i->max;

681

i->openmin = i->openmax;

694

i->openmin = i->openmax;

682

if (i->openmin)

695

if (i->openmin)

683

i->min--;

696

i->min--;

684

return 1;

697

return 1;

685

}

698

}

686

699

687

void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)

700

void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)

688

{

701

{

689

if (a->empty || b->empty) {

702

if (a->empty || b->empty) {

690

snd_interval_none(c);

703

snd_interval_none(c);

691

return;

704

return;

692

}

705

}

693

c->empty = 0;

706

c->empty = 0;

694

c->min = mul(a->min, b->min);

707

c->min = mul(a->min, b->min);

695

c->openmin = (a->openmin || b->openmin);

708

c->openmin = (a->openmin || b->openmin);

696

c->max = mul(a->max, b->max);

709

c->max = mul(a->max, b->max);

697

c->openmax = (a->openmax || b->openmax);

710

c->openmax = (a->openmax || b->openmax);

698

c->integer = (a->integer && b->integer);

711

c->integer = (a->integer && b->integer);

699

}

712

}

700

713

701

/**

714

/**

702

* snd_interval_div - refine the interval value with division

715

* snd_interval_div - refine the interval value with division

703

* @a: dividend

716

* @a: dividend

704

* @b: divisor

717

* @b: divisor

705

* @c: quotient

718

* @c: quotient

706

*

719

*

707

* c = a / b

720

* c = a / b

708

*

721

*

709

* Returns non-zero if the value is changed, zero if not changed.

722

* Returns non-zero if the value is changed, zero if not changed.

710

*/

723

*/

711

void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)

724

void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)

712

{

725

{

713

unsigned int r;

726

unsigned int r;

714

if (a->empty || b->empty) {

727

if (a->empty || b->empty) {

715

snd_interval_none(c);

728

snd_interval_none(c);

716

return;

729

return;

717

}

730

}

718

c->empty = 0;

731

c->empty = 0;

719

c->min = div32(a->min, b->max, &r);

732

c->min = div32(a->min, b->max, &r);

720

c->openmin = (r || a->openmin || b->openmax);

733

c->openmin = (r || a->openmin || b->openmax);

721

if (b->min > 0) {

734

if (b->min > 0) {

722

c->max = div32(a->max, b->min, &r);

735

c->max = div32(a->max, b->min, &r);

723

if (r) {

736

if (r) {

724

c->max++;

737

c->max++;

725

c->openmax = 1;

738

c->openmax = 1;

726

} else

739

} else

727

c->openmax = (a->openmax || b->openmin);

740

c->openmax = (a->openmax || b->openmin);

728

} else {

741

} else {

729

c->max = UINT_MAX;

742

c->max = UINT_MAX;

730

c->openmax = 0;

743

c->openmax = 0;

731

}

744

}

732

c->integer = 0;

745

c->integer = 0;

733

}

746

}

734

747

735

/**

748

/**

736

* snd_interval_muldivk - refine the interval value

749

* snd_interval_muldivk - refine the interval value

737

* @a: dividend 1

750

* @a: dividend 1

738

* @b: dividend 2

751

* @b: dividend 2

739

* @k: divisor (as integer)

752

* @k: divisor (as integer)

740

* @c: result

753

* @c: result

741

*

754

*

742

* c = a * b / k

755

* c = a * b / k

743

*

756

*

744

* Returns non-zero if the value is changed, zero if not changed.

757

* Returns non-zero if the value is changed, zero if not changed.

745

*/

758

*/

746

void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b,

759

void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b,

747

unsigned int k, struct snd_interval *c)

760

unsigned int k, struct snd_interval *c)

748

{

761

{

749

unsigned int r;

762

unsigned int r;

750

if (a->empty || b->empty) {

763

if (a->empty || b->empty) {

751

snd_interval_none(c);

764

snd_interval_none(c);

752

return;

765

return;

753

}

766

}

754

c->empty = 0;

767

c->empty = 0;

755

c->min = muldiv32(a->min, b->min, k, &r);

768

c->min = muldiv32(a->min, b->min, k, &r);

756

c->openmin = (r || a->openmin || b->openmin);

769

c->openmin = (r || a->openmin || b->openmin);

757

c->max = muldiv32(a->max, b->max, k, &r);

770

c->max = muldiv32(a->max, b->max, k, &r);

758

if (r) {

771

if (r) {

759

c->max++;

772

c->max++;

760

c->openmax = 1;

773

c->openmax = 1;

761

} else

774

} else

762

c->openmax = (a->openmax || b->openmax);

775

c->openmax = (a->openmax || b->openmax);

763

c->integer = 0;

776

c->integer = 0;

764

}

777

}

765

778

766

/**

779

/**

767

* snd_interval_mulkdiv - refine the interval value

780

* snd_interval_mulkdiv - refine the interval value

768

* @a: dividend 1

781

* @a: dividend 1

769

* @k: dividend 2 (as integer)

782

* @k: dividend 2 (as integer)

770

* @b: divisor

783

* @b: divisor

771

* @c: result

784

* @c: result

772

*

785

*

773

* c = a * k / b

786

* c = a * k / b

774

*

787

*

775

* Returns non-zero if the value is changed, zero if not changed.

788

* Returns non-zero if the value is changed, zero if not changed.

776

*/

789

*/

777

void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,

790

void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,

778

const struct snd_interval *b, struct snd_interval *c)

791

const struct snd_interval *b, struct snd_interval *c)

779

{

792

{

780

unsigned int r;

793

unsigned int r;

781

if (a->empty || b->empty) {

794

if (a->empty || b->empty) {

782

snd_interval_none(c);

795

snd_interval_none(c);

783

return;

796

return;

784

}

797

}

785

c->empty = 0;

798

c->empty = 0;

786

c->min = muldiv32(a->min, k, b->max, &r);

799

c->min = muldiv32(a->min, k, b->max, &r);

787

c->openmin = (r || a->openmin || b->openmax);

800

c->openmin = (r || a->openmin || b->openmax);

788

if (b->min > 0) {

801

if (b->min > 0) {

789

c->max = muldiv32(a->max, k, b->min, &r);

802

c->max = muldiv32(a->max, k, b->min, &r);

790

if (r) {

803

if (r) {

791

c->max++;

804

c->max++;

792

c->openmax = 1;

805

c->openmax = 1;

793

} else

806

} else

794

c->openmax = (a->openmax || b->openmin);

807

c->openmax = (a->openmax || b->openmin);

795

} else {

808

} else {

796

c->max = UINT_MAX;

809

c->max = UINT_MAX;

797

c->openmax = 0;

810

c->openmax = 0;

798

}

811

}

799

c->integer = 0;

812

c->integer = 0;

800

}

813

}

801

814

802

/* ---- */

815

/* ---- */

803

816

804

817

805

/**

818

/**

806

* snd_interval_ratnum - refine the interval value

819

* snd_interval_ratnum - refine the interval value

807

* @i: interval to refine

820

* @i: interval to refine

808

* @rats_count: number of ratnum_t

821

* @rats_count: number of ratnum_t

809

* @rats: ratnum_t array

822

* @rats: ratnum_t array

810

* @nump: pointer to store the resultant numerator

823

* @nump: pointer to store the resultant numerator

811

* @denp: pointer to store the resultant denominator

824

* @denp: pointer to store the resultant denominator

812

*

825

*

813

* Returns non-zero if the value is changed, zero if not changed.

826

* Returns non-zero if the value is changed, zero if not changed.

814

*/

827

*/

815

int snd_interval_ratnum(struct snd_interval *i,

828

int snd_interval_ratnum(struct snd_interval *i,

816

unsigned int rats_count, struct snd_ratnum *rats,

829

unsigned int rats_count, struct snd_ratnum *rats,

817

unsigned int *nump, unsigned int *denp)

830

unsigned int *nump, unsigned int *denp)

818

{

831

{

819

unsigned int best_num, best_den;

832

unsigned int best_num, best_den;

820

int best_diff;

833

int best_diff;

821

unsigned int k;

834

unsigned int k;

822

struct snd_interval t;

835

struct snd_interval t;

823

int err;

836

int err;

824

unsigned int result_num, result_den;

837

unsigned int result_num, result_den;

825

int result_diff;

838

int result_diff;

826

839

827

best_num = best_den = best_diff = 0;

840

best_num = best_den = best_diff = 0;

828

for (k = 0; k < rats_count; ++k) {

841

for (k = 0; k < rats_count; ++k) {

829

unsigned int num = rats[k].num;

842

unsigned int num = rats[k].num;

830

unsigned int den;

843

unsigned int den;

831

unsigned int q = i->min;

844

unsigned int q = i->min;

832

int diff;

845

int diff;

833

if (q == 0)

846

if (q == 0)

834

q = 1;

847

q = 1;

835

den = div_up(num, q);

848

den = div_up(num, q);

836

if (den < rats[k].den_min)

849

if (den < rats[k].den_min)

837

continue;

850

continue;

838

if (den > rats[k].den_max)

851

if (den > rats[k].den_max)

839

den = rats[k].den_max;

852

den = rats[k].den_max;

840

else {

853

else {

841

unsigned int r;

854

unsigned int r;

842

r = (den - rats[k].den_min) % rats[k].den_step;

855

r = (den - rats[k].den_min) % rats[k].den_step;

843

if (r != 0)

856

if (r != 0)

844

den -= r;

857

den -= r;

845

}

858

}

846

diff = num - q * den;

859

diff = num - q * den;

847

if (diff < 0)

860

if (diff < 0)

848

diff = -diff;

861

diff = -diff;

849

if (best_num == 0 ||

862

if (best_num == 0 ||

850

diff * best_den < best_diff * den) {

863

diff * best_den < best_diff * den) {

851

best_diff = diff;

864

best_diff = diff;

852

best_den = den;

865

best_den = den;

853

best_num = num;

866

best_num = num;

854

}

867

}

855

}

868

}

856

if (best_den == 0) {

869

if (best_den == 0) {

857

i->empty = 1;

870

i->empty = 1;

858

return -EINVAL;

871

return -EINVAL;

859

}

872

}

860

t.min = div_down(best_num, best_den);

873

t.min = div_down(best_num, best_den);

861

t.openmin = !!(best_num % best_den);

874

t.openmin = !!(best_num % best_den);

862

875

863

result_num = best_num;

876

result_num = best_num;

864

result_diff = best_diff;

877

result_diff = best_diff;

865

result_den = best_den;

878

result_den = best_den;

866

best_num = best_den = best_diff = 0;

879

best_num = best_den = best_diff = 0;

867

for (k = 0; k < rats_count; ++k) {

880

for (k = 0; k < rats_count; ++k) {

868

unsigned int num = rats[k].num;

881

unsigned int num = rats[k].num;

869

unsigned int den;

882

unsigned int den;

870

unsigned int q = i->max;

883

unsigned int q = i->max;

871

int diff;

884

int diff;

872

if (q == 0) {

885

if (q == 0) {

873

i->empty = 1;

886

i->empty = 1;

874

return -EINVAL;

887

return -EINVAL;

875

}

888

}

876

den = div_down(num, q);

889

den = div_down(num, q);

877

if (den > rats[k].den_max)

890

if (den > rats[k].den_max)

878

continue;

891

continue;

879

if (den < rats[k].den_min)

892

if (den < rats[k].den_min)

880

den = rats[k].den_min;

893

den = rats[k].den_min;

881

else {

894

else {

882

unsigned int r;

895

unsigned int r;

883

r = (den - rats[k].den_min) % rats[k].den_step;

896

r = (den - rats[k].den_min) % rats[k].den_step;

884

if (r != 0)

897

if (r != 0)

885

den += rats[k].den_step - r;

898

den += rats[k].den_step - r;

886

}

899

}

887

diff = q * den - num;

900

diff = q * den - num;

888

if (diff < 0)

901

if (diff < 0)

889

diff = -diff;

902

diff = -diff;

890

if (best_num == 0 ||

903

if (best_num == 0 ||

891

diff * best_den < best_diff * den) {

904

diff * best_den < best_diff * den) {

892

best_diff = diff;

905

best_diff = diff;

893

best_den = den;

906

best_den = den;

894

best_num = num;

907

best_num = num;

895

}

908

}

896

}

909

}

897

if (best_den == 0) {

910

if (best_den == 0) {

898

i->empty = 1;

911

i->empty = 1;

899

return -EINVAL;

912

return -EINVAL;

900

}

913

}

901

t.max = div_up(best_num, best_den);

914

t.max = div_up(best_num, best_den);

902

t.openmax = !!(best_num % best_den);

915

t.openmax = !!(best_num % best_den);

903

t.integer = 0;

916

t.integer = 0;

904

err = snd_interval_refine(i, &t);

917

err = snd_interval_refine(i, &t);

905

if (err < 0)

918

if (err < 0)

906

return err;

919

return err;

907

920

908

if (snd_interval_single(i)) {

921

if (snd_interval_single(i)) {

909

if (best_diff * result_den < result_diff * best_den) {

922

if (best_diff * result_den < result_diff * best_den) {

910

result_num = best_num;

923

result_num = best_num;

911

result_den = best_den;

924

result_den = best_den;

912

}

925

}

913

if (nump)

926

if (nump)

914

*nump = result_num;

927

*nump = result_num;

915

if (denp)

928

if (denp)

916

*denp = result_den;

929

*denp = result_den;

917

}

930

}

918

return err;

931

return err;

919

}

932

}

920

933

921

EXPORT_SYMBOL(snd_interval_ratnum);

934

EXPORT_SYMBOL(snd_interval_ratnum);

922

935

923

/**

936

/**

924

* snd_interval_ratden - refine the interval value

937

* snd_interval_ratden - refine the interval value

925

* @i: interval to refine

938

* @i: interval to refine

926

* @rats_count: number of struct ratden

939

* @rats_count: number of struct ratden

927

* @rats: struct ratden array

940

* @rats: struct ratden array

928

* @nump: pointer to store the resultant numerator

941

* @nump: pointer to store the resultant numerator

929

* @denp: pointer to store the resultant denominator

942

* @denp: pointer to store the resultant denominator

930

*

943

*

931

* Returns non-zero if the value is changed, zero if not changed.

944

* Returns non-zero if the value is changed, zero if not changed.

932

*/

945

*/

933

static int snd_interval_ratden(struct snd_interval *i,

946

static int snd_interval_ratden(struct snd_interval *i,

934

unsigned int rats_count, struct snd_ratden *rats,

947

unsigned int rats_count, struct snd_ratden *rats,

935

unsigned int *nump, unsigned int *denp)

948

unsigned int *nump, unsigned int *denp)

936

{

949

{

937

unsigned int best_num, best_diff, best_den;

950

unsigned int best_num, best_diff, best_den;

938

unsigned int k;

951

unsigned int k;

939

struct snd_interval t;

952

struct snd_interval t;

940

int err;

953

int err;

941

954

942

best_num = best_den = best_diff = 0;

955

best_num = best_den = best_diff = 0;

943

for (k = 0; k < rats_count; ++k) {

956

for (k = 0; k < rats_count; ++k) {

944

unsigned int num;

957

unsigned int num;

945

unsigned int den = rats[k].den;

958

unsigned int den = rats[k].den;

946

unsigned int q = i->min;

959

unsigned int q = i->min;

947

int diff;

960

int diff;

948

num = mul(q, den);

961

num = mul(q, den);

949

if (num > rats[k].num_max)

962

if (num > rats[k].num_max)

950

continue;

963

continue;

951

if (num < rats[k].num_min)

964

if (num < rats[k].num_min)

952

num = rats[k].num_max;

965

num = rats[k].num_max;

953

else {

966

else {

954

unsigned int r;

967

unsigned int r;

955

r = (num - rats[k].num_min) % rats[k].num_step;

968

r = (num - rats[k].num_min) % rats[k].num_step;

956

if (r != 0)

969

if (r != 0)

957

num += rats[k].num_step - r;

970

num += rats[k].num_step - r;

958

}

971

}

959

diff = num - q * den;

972

diff = num - q * den;

960

if (best_num == 0 ||

973

if (best_num == 0 ||

961

diff * best_den < best_diff * den) {

974

diff * best_den < best_diff * den) {

962

best_diff = diff;

975

best_diff = diff;

963

best_den = den;

976

best_den = den;

964

best_num = num;

977

best_num = num;

965

}

978

}

966

}

979

}

967

if (best_den == 0) {

980

if (best_den == 0) {

968

i->empty = 1;

981

i->empty = 1;

969

return -EINVAL;

982

return -EINVAL;

970

}

983

}

971

t.min = div_down(best_num, best_den);

984

t.min = div_down(best_num, best_den);

972

t.openmin = !!(best_num % best_den);

985

t.openmin = !!(best_num % best_den);

973

986

974

best_num = best_den = best_diff = 0;

987

best_num = best_den = best_diff = 0;

975

for (k = 0; k < rats_count; ++k) {

988

for (k = 0; k < rats_count; ++k) {

976

unsigned int num;

989

unsigned int num;

977

unsigned int den = rats[k].den;

990

unsigned int den = rats[k].den;

978

unsigned int q = i->max;

991

unsigned int q = i->max;

979

int diff;

992

int diff;

980

num = mul(q, den);

993

num = mul(q, den);

981

if (num < rats[k].num_min)

994

if (num < rats[k].num_min)

982

continue;

995

continue;

983

if (num > rats[k].num_max)

996

if (num > rats[k].num_max)

984

num = rats[k].num_max;

997

num = rats[k].num_max;

985

else {

998

else {

986

unsigned int r;

999

unsigned int r;

987

r = (num - rats[k].num_min) % rats[k].num_step;

1000

r = (num - rats[k].num_min) % rats[k].num_step;

988

if (r != 0)

1001

if (r != 0)

989

num -= r;

1002

num -= r;

990

}

1003

}

991

diff = q * den - num;

1004

diff = q * den - num;

992

if (best_num == 0 ||

1005

if (best_num == 0 ||

993

diff * best_den < best_diff * den) {

1006

diff * best_den < best_diff * den) {

994

best_diff = diff;

1007

best_diff = diff;

995

best_den = den;

1008

best_den = den;

996

best_num = num;

1009

best_num = num;

997

}

1010

}

998

}

1011

}

999

if (best_den == 0) {

1012

if (best_den == 0) {

1000

i->empty = 1;

1013

i->empty = 1;

1001

return -EINVAL;

1014

return -EINVAL;

1002

}

1015

}

1003

t.max = div_up(best_num, best_den);

1016

t.max = div_up(best_num, best_den);

1004

t.openmax = !!(best_num % best_den);

1017

t.openmax = !!(best_num % best_den);

1005

t.integer = 0;

1018

t.integer = 0;

1006

err = snd_interval_refine(i, &t);

1019

err = snd_interval_refine(i, &t);

1007

if (err < 0)

1020

if (err < 0)

1008

return err;

1021

return err;

1009

1022

1010

if (snd_interval_single(i)) {

1023

if (snd_interval_single(i)) {

1011

if (nump)

1024

if (nump)

1012

*nump = best_num;

1025

*nump = best_num;

1013

if (denp)

1026

if (denp)

1014

*denp = best_den;

1027

*denp = best_den;

1015

}

1028

}

1016

return err;

1029

return err;

1017

}

1030

}

1018

1031

1019

/**

1032

/**

1020

* snd_interval_list - refine the interval value from the list

1033

* snd_interval_list - refine the interval value from the list

1021

* @i: the interval value to refine

1034

* @i: the interval value to refine

1022

* @count: the number of elements in the list

1035

* @count: the number of elements in the list

1023

* @list: the value list

1036

* @list: the value list

1024

* @mask: the bit-mask to evaluate

1037

* @mask: the bit-mask to evaluate

1025

*

1038

*

1026

* Refines the interval value from the list.

1039

* Refines the interval value from the list.

1027

* When mask is non-zero, only the elements corresponding to bit 1 are

1040

* When mask is non-zero, only the elements corresponding to bit 1 are

1028

* evaluated.

1041

* evaluated.

1029

*

1042

*

1030

* Returns non-zero if the value is changed, zero if not changed.

1043

* Returns non-zero if the value is changed, zero if not changed.

1031

*/

1044

*/

1032

int snd_interval_list(struct snd_interval *i, unsigned int count,

1045

int snd_interval_list(struct snd_interval *i, unsigned int count,

1033

const unsigned int *list, unsigned int mask)

1046

const unsigned int *list, unsigned int mask)

1034

{

1047

{

1035

unsigned int k;

1048

unsigned int k;

1036

struct snd_interval list_range;

1049

struct snd_interval list_range;

1037

1050

1038

if (!count) {

1051

if (!count) {

1039

i->empty = 1;

1052

i->empty = 1;

1040

return -EINVAL;

1053

return -EINVAL;

1041

}

1054

}

1042

snd_interval_any(&list_range);

1055

snd_interval_any(&list_range);

1043

list_range.min = UINT_MAX;

1056

list_range.min = UINT_MAX;

1044

list_range.max = 0;

1057

list_range.max = 0;

1045

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

1058

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

1046

if (mask && !(mask & (1 << k)))

1059

if (mask && !(mask & (1 << k)))

1047

continue;

1060

continue;

1048

if (!snd_interval_test(i, list[k]))

1061

if (!snd_interval_test(i, list[k]))

1049

continue;

1062

continue;

1050

list_range.min = min(list_range.min, list[k]);

1063

list_range.min = min(list_range.min, list[k]);

1051

list_range.max = max(list_range.max, list[k]);

1064

list_range.max = max(list_range.max, list[k]);

1052

}

1065

}

1053

return snd_interval_refine(i, &list_range);

1066

return snd_interval_refine(i, &list_range);

1054

}

1067

}

1055

1068

1056

EXPORT_SYMBOL(snd_interval_list);

1069

EXPORT_SYMBOL(snd_interval_list);

1057

1070

1058

static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned int step)

1071

static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned int step)

1059

{

1072

{

1060

unsigned int n;

1073

unsigned int n;

1061

int changed = 0;

1074

int changed = 0;

1062

n = (i->min - min) % step;

1075

n = (i->min - min) % step;

1063

if (n != 0 || i->openmin) {

1076

if (n != 0 || i->openmin) {

1064

i->min += step - n;

1077

i->min += step - n;

1065

changed = 1;

1078

changed = 1;

1066

}

1079

}

1067

n = (i->max - min) % step;

1080

n = (i->max - min) % step;

1068

if (n != 0 || i->openmax) {

1081

if (n != 0 || i->openmax) {

1069

i->max -= n;

1082

i->max -= n;

1070

changed = 1;

1083

changed = 1;

1071

}

1084

}

1072

if (snd_interval_checkempty(i)) {

1085

if (snd_interval_checkempty(i)) {

1073

i->empty = 1;

1086

i->empty = 1;

1074

return -EINVAL;

1087

return -EINVAL;

1075

}

1088

}

1076

return changed;

1089

return changed;

1077

}

1090

}

1078

1091

1079

/* Info constraints helpers */

1092

/* Info constraints helpers */

1080

1093

1081

/**

1094

/**

1082

* snd_pcm_hw_rule_add - add the hw-constraint rule

1095

* snd_pcm_hw_rule_add - add the hw-constraint rule

1083

* @runtime: the pcm runtime instance

1096

* @runtime: the pcm runtime instance

1084

* @cond: condition bits

1097

* @cond: condition bits

1085

* @var: the variable to evaluate

1098

* @var: the variable to evaluate

1086

* @func: the evaluation function

1099

* @func: the evaluation function

1087

* @private: the private data pointer passed to function

1100

* @private: the private data pointer passed to function

1088

* @dep: the dependent variables

1101

* @dep: the dependent variables

1089

*

1102

*

1090

* Returns zero if successful, or a negative error code on failure.

1103

* Returns zero if successful, or a negative error code on failure.

1091

*/

1104

*/

1092

int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond,

1105

int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond,

1093

int var,

1106

int var,

1094

snd_pcm_hw_rule_func_t func, void *private,

1107

snd_pcm_hw_rule_func_t func, void *private,

1095

int dep, ...)

1108

int dep, ...)

1096

{

1109

{

1097

struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;

1110

struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;

1098

struct snd_pcm_hw_rule *c;

1111

struct snd_pcm_hw_rule *c;

1099

unsigned int k;

1112

unsigned int k;

1100

va_list args;

1113

va_list args;

1101

va_start(args, dep);

1114

va_start(args, dep);

1102

if (constrs->rules_num >= constrs->rules_all) {

1115

if (constrs->rules_num >= constrs->rules_all) {

1103

struct snd_pcm_hw_rule *new;

1116

struct snd_pcm_hw_rule *new;

1104

unsigned int new_rules = constrs->rules_all + 16;

1117

unsigned int new_rules = constrs->rules_all + 16;

1105

new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL);

1118

new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL);

1106

if (!new) {

1119

if (!new) {

1107

va_end(args);

1120

va_end(args);

1108

return -ENOMEM;

1121

return -ENOMEM;

1109

}

1122

}

1110

if (constrs->rules) {

1123

if (constrs->rules) {

1111

memcpy(new, constrs->rules,

1124

memcpy(new, constrs->rules,

1112

constrs->rules_num * sizeof(*c));

1125

constrs->rules_num * sizeof(*c));

1113

kfree(constrs->rules);

1126

kfree(constrs->rules);

1114

}

1127

}

1115

constrs->rules = new;

1128

constrs->rules = new;

1116

constrs->rules_all = new_rules;

1129

constrs->rules_all = new_rules;

1117

}

1130

}

1118

c = &constrs->rules[constrs->rules_num];

1131

c = &constrs->rules[constrs->rules_num];

1119

c->cond = cond;

1132

c->cond = cond;

1120

c->func = func;

1133

c->func = func;

1121

c->var = var;

1134

c->var = var;

1122

c->private = private;

1135

c->private = private;

1123

k = 0;

1136

k = 0;

1124

while (1) {

1137

while (1) {

1125

if (snd_BUG_ON(k >= ARRAY_SIZE(c->deps))) {

1138

if (snd_BUG_ON(k >= ARRAY_SIZE(c->deps))) {

1126

va_end(args);

1139

va_end(args);

1127

return -EINVAL;

1140

return -EINVAL;

1128

}

1141

}

1129

c->deps[k++] = dep;

1142

c->deps[k++] = dep;

1130

if (dep < 0)

1143

if (dep < 0)

1131

break;

1144

break;

1132

dep = va_arg(args, int);

1145

dep = va_arg(args, int);

1133

}

1146

}

1134

constrs->rules_num++;

1147

constrs->rules_num++;

1135

va_end(args);

1148

va_end(args);

1136

return 0;

1149

return 0;

1137

}

1150

}

1138

1151

1139

EXPORT_SYMBOL(snd_pcm_hw_rule_add);

1152

EXPORT_SYMBOL(snd_pcm_hw_rule_add);

1140

1153

1141

/**

1154

/**

1142

* snd_pcm_hw_constraint_mask - apply the given bitmap mask constraint

1155

* snd_pcm_hw_constraint_mask - apply the given bitmap mask constraint

1143

* @runtime: PCM runtime instance

1156

* @runtime: PCM runtime instance

1144

* @var: hw_params variable to apply the mask

1157

* @var: hw_params variable to apply the mask

1145

* @mask: the bitmap mask

1158

* @mask: the bitmap mask

1146

*

1159

*

1147

* Apply the constraint of the given bitmap mask to a 32-bit mask parameter.

1160

* Apply the constraint of the given bitmap mask to a 32-bit mask parameter.

1148

*/

1161

*/

1149

int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,

1162

int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,

1150

u_int32_t mask)

1163

u_int32_t mask)

1151

{

1164

{

1152

struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;

1165

struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;

1153

struct snd_mask *maskp = constrs_mask(constrs, var);

1166

struct snd_mask *maskp = constrs_mask(constrs, var);

1154

*maskp->bits &= mask;

1167

*maskp->bits &= mask;

1155

memset(maskp->bits + 1, 0, (SNDRV_MASK_MAX-32) / 8); /* clear rest */

1168

memset(maskp->bits + 1, 0, (SNDRV_MASK_MAX-32) / 8); /* clear rest */

1156

if (*maskp->bits == 0)

1169

if (*maskp->bits == 0)

1157

return -EINVAL;

1170

return -EINVAL;

1158

return 0;

1171

return 0;

1159

}

1172

}

1160

1173

1161

/**

1174

/**

1162

* snd_pcm_hw_constraint_mask64 - apply the given bitmap mask constraint

1175

* snd_pcm_hw_constraint_mask64 - apply the given bitmap mask constraint

1163

* @runtime: PCM runtime instance

1176

* @runtime: PCM runtime instance

1164

* @var: hw_params variable to apply the mask

1177

* @var: hw_params variable to apply the mask

1165

* @mask: the 64bit bitmap mask

1178

* @mask: the 64bit bitmap mask

1166

*

1179

*

1167

* Apply the constraint of the given bitmap mask to a 64-bit mask parameter.

1180

* Apply the constraint of the given bitmap mask to a 64-bit mask parameter.

1168

*/

1181

*/

1169

int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,

1182

int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,

1170

u_int64_t mask)

1183

u_int64_t mask)

1171

{

1184

{

1172

struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;

1185

struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;

1173

struct snd_mask *maskp = constrs_mask(constrs, var);

1186

struct snd_mask *maskp = constrs_mask(constrs, var);

1174

maskp->bits[0] &= (u_int32_t)mask;

1187

maskp->bits[0] &= (u_int32_t)mask;

1175

maskp->bits[1] &= (u_int32_t)(mask >> 32);

1188

maskp->bits[1] &= (u_int32_t)(mask >> 32);

1176

memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */

1189

memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */

1177

if (! maskp->bits[0] && ! maskp->bits[1])

1190

if (! maskp->bits[0] && ! maskp->bits[1])

1178

return -EINVAL;

1191

return -EINVAL;

1179

return 0;

1192

return 0;

1180

}

1193

}

1181

1194

1182

/**

1195

/**

1183

* snd_pcm_hw_constraint_integer - apply an integer constraint to an interval

1196

* snd_pcm_hw_constraint_integer - apply an integer constraint to an interval

1184

* @runtime: PCM runtime instance

1197

* @runtime: PCM runtime instance

1185

* @var: hw_params variable to apply the integer constraint

1198

* @var: hw_params variable to apply the integer constraint

1186

*

1199

*

1187

* Apply the constraint of integer to an interval parameter.

1200

* Apply the constraint of integer to an interval parameter.

1188

*/

1201

*/

1189

int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var)

1202

int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var)

1190

{

1203

{

1191

struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;

1204

struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;

1192

return snd_interval_setinteger(constrs_interval(constrs, var));

1205

return snd_interval_setinteger(constrs_interval(constrs, var));

1193

}

1206

}

1194

1207

1195

EXPORT_SYMBOL(snd_pcm_hw_constraint_integer);

1208

EXPORT_SYMBOL(snd_pcm_hw_constraint_integer);

1196

1209

1197

/**

1210

/**

1198

* snd_pcm_hw_constraint_minmax - apply a min/max range constraint to an interval

1211

* snd_pcm_hw_constraint_minmax - apply a min/max range constraint to an interval

1199

* @runtime: PCM runtime instance

1212

* @runtime: PCM runtime instance

1200

* @var: hw_params variable to apply the range

1213

* @var: hw_params variable to apply the range

1201

* @min: the minimal value

1214

* @min: the minimal value

1202

* @max: the maximal value

1215

* @max: the maximal value

1203

*

1216

*

1204

* Apply the min/max range constraint to an interval parameter.

1217

* Apply the min/max range constraint to an interval parameter.

1205

*/

1218

*/

1206

int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,

1219

int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,

1207

unsigned int min, unsigned int max)

1220

unsigned int min, unsigned int max)

1208

{

1221

{

1209

struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;

1222

struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;

1210

struct snd_interval t;

1223

struct snd_interval t;

1211

t.min = min;

1224

t.min = min;

1212

t.max = max;

1225

t.max = max;

1213

t.openmin = t.openmax = 0;

1226

t.openmin = t.openmax = 0;

1214

t.integer = 0;

1227

t.integer = 0;

1215

return snd_interval_refine(constrs_interval(constrs, var), &t);

1228

return snd_interval_refine(constrs_interval(constrs, var), &t);

1216

}

1229

}

1217

1230

1218

EXPORT_SYMBOL(snd_pcm_hw_constraint_minmax);

1231

EXPORT_SYMBOL(snd_pcm_hw_constraint_minmax);

1219

1232

1220

static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params,

1233

static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params,

1221

struct snd_pcm_hw_rule *rule)

1234

struct snd_pcm_hw_rule *rule)

1222

{

1235

{

1223

struct snd_pcm_hw_constraint_list *list = rule->private;

1236

struct snd_pcm_hw_constraint_list *list = rule->private;

1224

return snd_interval_list(hw_param_interval(params, rule->var), list->count, list->list, list->mask);

1237

return snd_interval_list(hw_param_interval(params, rule->var), list->count, list->list, list->mask);

1225

}

1238

}

1226

1239

1227

1240

1228

/**

1241

/**

1229

* snd_pcm_hw_constraint_list - apply a list of constraints to a parameter

1242

* snd_pcm_hw_constraint_list - apply a list of constraints to a parameter

1230

* @runtime: PCM runtime instance

1243

* @runtime: PCM runtime instance

1231

* @cond: condition bits

1244

* @cond: condition bits

1232

* @var: hw_params variable to apply the list constraint

1245

* @var: hw_params variable to apply the list constraint

1233

* @l: list

1246

* @l: list

1234

*

1247

*

1235

* Apply the list of constraints to an interval parameter.

1248

* Apply the list of constraints to an interval parameter.

1236

*/

1249

*/

1237

int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,

1250

int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,

1238

unsigned int cond,

1251

unsigned int cond,

1239

snd_pcm_hw_param_t var,

1252

snd_pcm_hw_param_t var,

1240

struct snd_pcm_hw_constraint_list *l)

1253

struct snd_pcm_hw_constraint_list *l)

1241

{

1254

{

1242

return snd_pcm_hw_rule_add(runtime, cond, var,

1255

return snd_pcm_hw_rule_add(runtime, cond, var,

1243

snd_pcm_hw_rule_list, l,

1256

snd_pcm_hw_rule_list, l,

1244

var, -1);

1257

var, -1);

1245

}

1258

}

1246

1259

1247

EXPORT_SYMBOL(snd_pcm_hw_constraint_list);

1260

EXPORT_SYMBOL(snd_pcm_hw_constraint_list);

1248

1261

1249

static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params,

1262

static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params,

1250

struct snd_pcm_hw_rule *rule)

1263

struct snd_pcm_hw_rule *rule)

1251

{

1264

{

1252

struct snd_pcm_hw_constraint_ratnums *r = rule->private;

1265

struct snd_pcm_hw_constraint_ratnums *r = rule->private;

1253

unsigned int num = 0, den = 0;

1266

unsigned int num = 0, den = 0;

1254

int err;

1267

int err;

1255

err = snd_interval_ratnum(hw_param_interval(params, rule->var),

1268

err = snd_interval_ratnum(hw_param_interval(params, rule->var),

1256

r->nrats, r->rats, &num, &den);

1269

r->nrats, r->rats, &num, &den);

1257

if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {

1270

if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {

1258

params->rate_num = num;

1271

params->rate_num = num;

1259

params->rate_den = den;

1272

params->rate_den = den;

1260

}

1273

}

1261

return err;

1274

return err;

1262

}

1275

}

1263

1276

1264

/**

1277

/**

1265

* snd_pcm_hw_constraint_ratnums - apply ratnums constraint to a parameter

1278

* snd_pcm_hw_constraint_ratnums - apply ratnums constraint to a parameter

1266

* @runtime: PCM runtime instance

1279

* @runtime: PCM runtime instance

1267

* @cond: condition bits

1280

* @cond: condition bits

1268

* @var: hw_params variable to apply the ratnums constraint

1281

* @var: hw_params variable to apply the ratnums constraint

1269

* @r: struct snd_ratnums constriants

1282

* @r: struct snd_ratnums constriants

1270

*/

1283

*/

1271

int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime,

1284

int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime,

1272

unsigned int cond,

1285

unsigned int cond,

1273

snd_pcm_hw_param_t var,

1286

snd_pcm_hw_param_t var,

1274

struct snd_pcm_hw_constraint_ratnums *r)

1287

struct snd_pcm_hw_constraint_ratnums *r)

1275

{

1288

{

1276

return snd_pcm_hw_rule_add(runtime, cond, var,

1289

return snd_pcm_hw_rule_add(runtime, cond, var,

1277

snd_pcm_hw_rule_ratnums, r,

1290

snd_pcm_hw_rule_ratnums, r,

1278

var, -1);

1291

var, -1);

1279

}

1292

}

1280

1293

1281

EXPORT_SYMBOL(snd_pcm_hw_constraint_ratnums);

1294

EXPORT_SYMBOL(snd_pcm_hw_constraint_ratnums);

1282

1295

1283

static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params,

1296

static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params,

1284

struct snd_pcm_hw_rule *rule)

1297

struct snd_pcm_hw_rule *rule)

1285

{

1298

{

1286

struct snd_pcm_hw_constraint_ratdens *r = rule->private;

1299

struct snd_pcm_hw_constraint_ratdens *r = rule->private;

1287

unsigned int num = 0, den = 0;

1300

unsigned int num = 0, den = 0;

1288

int err = snd_interval_ratden(hw_param_interval(params, rule->var),

1301

int err = snd_interval_ratden(hw_param_interval(params, rule->var),

1289

r->nrats, r->rats, &num, &den);

1302

r->nrats, r->rats, &num, &den);

1290

if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {

1303

if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {

1291

params->rate_num = num;

1304

params->rate_num = num;

1292

params->rate_den = den;

1305

params->rate_den = den;

1293

}

1306

}

1294

return err;

1307

return err;

1295

}

1308

}

1296

1309

1297

/**

1310

/**

1298

* snd_pcm_hw_constraint_ratdens - apply ratdens constraint to a parameter

1311

* snd_pcm_hw_constraint_ratdens - apply ratdens constraint to a parameter

1299

* @runtime: PCM runtime instance

1312

* @runtime: PCM runtime instance

1300

* @cond: condition bits

1313

* @cond: condition bits

1301

* @var: hw_params variable to apply the ratdens constraint

1314

* @var: hw_params variable to apply the ratdens constraint

1302

* @r: struct snd_ratdens constriants

1315

* @r: struct snd_ratdens constriants

1303

*/

1316

*/

1304

int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime,

1317

int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime,

1305

unsigned int cond,

1318

unsigned int cond,

1306

snd_pcm_hw_param_t var,

1319

snd_pcm_hw_param_t var,

1307

struct snd_pcm_hw_constraint_ratdens *r)

1320

struct snd_pcm_hw_constraint_ratdens *r)

1308

{

1321

{

1309

return snd_pcm_hw_rule_add(runtime, cond, var,

1322

return snd_pcm_hw_rule_add(runtime, cond, var,

1310

snd_pcm_hw_rule_ratdens, r,

1323

snd_pcm_hw_rule_ratdens, r,

1311

var, -1);

1324

var, -1);

1312

}

1325

}

1313

1326

1314

EXPORT_SYMBOL(snd_pcm_hw_constraint_ratdens);

1327

EXPORT_SYMBOL(snd_pcm_hw_constraint_ratdens);

1315

1328

1316

static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params,

1329

static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params,

1317

struct snd_pcm_hw_rule *rule)

1330

struct snd_pcm_hw_rule *rule)

1318

{

1331

{

1319

unsigned int l = (unsigned long) rule->private;

1332

unsigned int l = (unsigned long) rule->private;

1320

int width = l & 0xffff;

1333

int width = l & 0xffff;

1321

unsigned int msbits = l >> 16;

1334

unsigned int msbits = l >> 16;

1322

struct snd_interval *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);

1335

struct snd_interval *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);

1323

if (snd_interval_single(i) && snd_interval_value(i) == width)

1336

if (snd_interval_single(i) && snd_interval_value(i) == width)

1324

params->msbits = msbits;

1337

params->msbits = msbits;

1325

return 0;

1338

return 0;

1326

}

1339

}

1327

1340

1328

/**

1341

/**

1329

* snd_pcm_hw_constraint_msbits - add a hw constraint msbits rule

1342

* snd_pcm_hw_constraint_msbits - add a hw constraint msbits rule

1330

* @runtime: PCM runtime instance

1343

* @runtime: PCM runtime instance

1331

* @cond: condition bits

1344

* @cond: condition bits

1332

* @width: sample bits width

1345

* @width: sample bits width

1333

* @msbits: msbits width

1346

* @msbits: msbits width

1334

*/

1347

*/

1335

int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime,

1348

int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime,

1336

unsigned int cond,

1349

unsigned int cond,

1337

unsigned int width,

1350

unsigned int width,

1338

unsigned int msbits)

1351

unsigned int msbits)

1339

{

1352

{

1340

unsigned long l = (msbits << 16) | width;

1353

unsigned long l = (msbits << 16) | width;

1341

return snd_pcm_hw_rule_add(runtime, cond, -1,

1354

return snd_pcm_hw_rule_add(runtime, cond, -1,

1342

snd_pcm_hw_rule_msbits,

1355

snd_pcm_hw_rule_msbits,

1343

(void*) l,

1356

(void*) l,

1344

SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);

1357

SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);

1345

}

1358

}

1346

1359

1347

EXPORT_SYMBOL(snd_pcm_hw_constraint_msbits);

1360

EXPORT_SYMBOL(snd_pcm_hw_constraint_msbits);

1348

1361

1349

static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params,

1362

static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params,

1350

struct snd_pcm_hw_rule *rule)

1363

struct snd_pcm_hw_rule *rule)

1351

{

1364

{

1352

unsigned long step = (unsigned long) rule->private;

1365

unsigned long step = (unsigned long) rule->private;

1353

return snd_interval_step(hw_param_interval(params, rule->var), 0, step);

1366

return snd_interval_step(hw_param_interval(params, rule->var), 0, step);

1354

}

1367

}

1355

1368

1356

/**

1369

/**

1357

* snd_pcm_hw_constraint_step - add a hw constraint step rule

1370

* snd_pcm_hw_constraint_step - add a hw constraint step rule

1358

* @runtime: PCM runtime instance

1371

* @runtime: PCM runtime instance

1359

* @cond: condition bits

1372

* @cond: condition bits

1360

* @var: hw_params variable to apply the step constraint

1373

* @var: hw_params variable to apply the step constraint

1361

* @step: step size

1374

* @step: step size

1362

*/

1375

*/

1363

int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,

1376

int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,

1364

unsigned int cond,

1377

unsigned int cond,

1365

snd_pcm_hw_param_t var,

1378

snd_pcm_hw_param_t var,

1366

unsigned long step)

1379

unsigned long step)

1367

{

1380

{

1368

return snd_pcm_hw_rule_add(runtime, cond, var,

1381

return snd_pcm_hw_rule_add(runtime, cond, var,

1369

snd_pcm_hw_rule_step, (void *) step,

1382

snd_pcm_hw_rule_step, (void *) step,

1370

var, -1);

1383

var, -1);

1371

}

1384

}

1372

1385

1373

EXPORT_SYMBOL(snd_pcm_hw_constraint_step);

1386

EXPORT_SYMBOL(snd_pcm_hw_constraint_step);

1374

1387

1375

static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)

1388

static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)

1376

{

1389

{

1377

static unsigned int pow2_sizes[] = {

1390

static unsigned int pow2_sizes[] = {

1378

1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7,

1391

1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7,

1379

1<<8, 1<<9, 1<<10, 1<<11, 1<<12, 1<<13, 1<<14, 1<<15,

1392

1<<8, 1<<9, 1<<10, 1<<11, 1<<12, 1<<13, 1<<14, 1<<15,

1380

1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21, 1<<22, 1<<23,

1393

1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21, 1<<22, 1<<23,

1381

1<<24, 1<<25, 1<<26, 1<<27, 1<<28, 1<<29, 1<<30

1394

1<<24, 1<<25, 1<<26, 1<<27, 1<<28, 1<<29, 1<<30

1382

};

1395

};

1383

return snd_interval_list(hw_param_interval(params, rule->var),

1396

return snd_interval_list(hw_param_interval(params, rule->var),

1384

ARRAY_SIZE(pow2_sizes), pow2_sizes, 0);

1397

ARRAY_SIZE(pow2_sizes), pow2_sizes, 0);

1385

}

1398

}

1386

1399

1387

/**

1400

/**

1388

* snd_pcm_hw_constraint_pow2 - add a hw constraint power-of-2 rule

1401

* snd_pcm_hw_constraint_pow2 - add a hw constraint power-of-2 rule

1389

* @runtime: PCM runtime instance

1402

* @runtime: PCM runtime instance

1390

* @cond: condition bits

1403

* @cond: condition bits

1391

* @var: hw_params variable to apply the power-of-2 constraint

1404

* @var: hw_params variable to apply the power-of-2 constraint

1392

*/

1405

*/

1393

int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,

1406

int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,

1394

unsigned int cond,

1407

unsigned int cond,

1395

snd_pcm_hw_param_t var)

1408

snd_pcm_hw_param_t var)

1396

{

1409

{

1397

return snd_pcm_hw_rule_add(runtime, cond, var,

1410

return snd_pcm_hw_rule_add(runtime, cond, var,

1398

snd_pcm_hw_rule_pow2, NULL,

1411

snd_pcm_hw_rule_pow2, NULL,

1399

var, -1);

1412

var, -1);

1400

}

1413

}

1401

1414

1402

EXPORT_SYMBOL(snd_pcm_hw_constraint_pow2);

1415

EXPORT_SYMBOL(snd_pcm_hw_constraint_pow2);

1403

1416

1404

static int snd_pcm_hw_rule_noresample_func(struct snd_pcm_hw_params *params,

1417

static int snd_pcm_hw_rule_noresample_func(struct snd_pcm_hw_params *params,

1405

struct snd_pcm_hw_rule *rule)

1418

struct snd_pcm_hw_rule *rule)

1406

{

1419

{

1407

unsigned int base_rate = (unsigned int)(uintptr_t)rule->private;

1420

unsigned int base_rate = (unsigned int)(uintptr_t)rule->private;

1408

struct snd_interval *rate;

1421

struct snd_interval *rate;

1409

1422

1410

rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);

1423

rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);

1411

return snd_interval_list(rate, 1, &base_rate, 0);

1424

return snd_interval_list(rate, 1, &base_rate, 0);

1412

}

1425

}

1413

1426

1414

/**

1427

/**

1415

* snd_pcm_hw_rule_noresample - add a rule to allow disabling hw resampling

1428

* snd_pcm_hw_rule_noresample - add a rule to allow disabling hw resampling

1416

* @runtime: PCM runtime instance

1429

* @runtime: PCM runtime instance

1417

* @base_rate: the rate at which the hardware does not resample

1430

* @base_rate: the rate at which the hardware does not resample

1418

*/

1431

*/

1419

int snd_pcm_hw_rule_noresample(struct snd_pcm_runtime *runtime,

1432

int snd_pcm_hw_rule_noresample(struct snd_pcm_runtime *runtime,

1420

unsigned int base_rate)

1433

unsigned int base_rate)

1421

{

1434

{

1422

return snd_pcm_hw_rule_add(runtime, SNDRV_PCM_HW_PARAMS_NORESAMPLE,

1435

return snd_pcm_hw_rule_add(runtime, SNDRV_PCM_HW_PARAMS_NORESAMPLE,

1423

SNDRV_PCM_HW_PARAM_RATE,

1436

SNDRV_PCM_HW_PARAM_RATE,

1424

snd_pcm_hw_rule_noresample_func,

1437

snd_pcm_hw_rule_noresample_func,

1425

(void *)(uintptr_t)base_rate,

1438

(void *)(uintptr_t)base_rate,

1426

SNDRV_PCM_HW_PARAM_RATE, -1);

1439

SNDRV_PCM_HW_PARAM_RATE, -1);

1427

}

1440

}

1428

EXPORT_SYMBOL(snd_pcm_hw_rule_noresample);

1441

EXPORT_SYMBOL(snd_pcm_hw_rule_noresample);

1429

1442

1430

static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params,

1443

static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params,

1431

snd_pcm_hw_param_t var)

1444

snd_pcm_hw_param_t var)

1432

{

1445

{

1433

if (hw_is_mask(var)) {

1446

if (hw_is_mask(var)) {

1434

snd_mask_any(hw_param_mask(params, var));

1447

snd_mask_any(hw_param_mask(params, var));

1435

params->cmask |= 1 << var;

1448

params->cmask |= 1 << var;

1436

params->rmask |= 1 << var;

1449

params->rmask |= 1 << var;

1437

return;

1450

return;

1438

}

1451

}

1439

if (hw_is_interval(var)) {

1452

if (hw_is_interval(var)) {

1440

snd_interval_any(hw_param_interval(params, var));

1453

snd_interval_any(hw_param_interval(params, var));

1441

params->cmask |= 1 << var;

1454

params->cmask |= 1 << var;

1442

params->rmask |= 1 << var;

1455

params->rmask |= 1 << var;

1443

return;

1456

return;

1444

}

1457

}

1445

snd_BUG();

1458

snd_BUG();

1446

}

1459

}

1447

1460

1448

void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params)

1461

void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params)

1449

{

1462

{

1450

unsigned int k;

1463

unsigned int k;

1451

memset(params, 0, sizeof(*params));

1464

memset(params, 0, sizeof(*params));

1452

for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++)

1465

for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++)

1453

_snd_pcm_hw_param_any(params, k);

1466

_snd_pcm_hw_param_any(params, k);

1454

for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++)

1467

for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++)

1455

_snd_pcm_hw_param_any(params, k);

1468

_snd_pcm_hw_param_any(params, k);

1456

params->info = ~0U;

1469

params->info = ~0U;

1457

}

1470

}

1458

1471

1459

EXPORT_SYMBOL(_snd_pcm_hw_params_any);

1472

EXPORT_SYMBOL(_snd_pcm_hw_params_any);

1460

1473

1461

/**

1474

/**

1462

* snd_pcm_hw_param_value - return @params field @var value

1475

* snd_pcm_hw_param_value - return @params field @var value

1463

* @params: the hw_params instance

1476

* @params: the hw_params instance

1464

* @var: parameter to retrieve

1477

* @var: parameter to retrieve

1465

* @dir: pointer to the direction (-1,0,1) or %NULL

1478

* @dir: pointer to the direction (-1,0,1) or %NULL

1466

*

1479

*

1467

* Return the value for field @var if it's fixed in configuration space

1480

* Return the value for field @var if it's fixed in configuration space

1468

* defined by @params. Return -%EINVAL otherwise.

1481

* defined by @params. Return -%EINVAL otherwise.

1469

*/

1482

*/

1470

int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,

1483

int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,

1471

snd_pcm_hw_param_t var, int *dir)

1484

snd_pcm_hw_param_t var, int *dir)

1472

{

1485

{

1473

if (hw_is_mask(var)) {

1486

if (hw_is_mask(var)) {

1474

const struct snd_mask *mask = hw_param_mask_c(params, var);

1487

const struct snd_mask *mask = hw_param_mask_c(params, var);

1475

if (!snd_mask_single(mask))

1488

if (!snd_mask_single(mask))

1476

return -EINVAL;

1489

return -EINVAL;

1477

if (dir)

1490

if (dir)

1478

*dir = 0;

1491

*dir = 0;

1479

return snd_mask_value(mask);

1492

return snd_mask_value(mask);

1480

}

1493

}

1481

if (hw_is_interval(var)) {

1494

if (hw_is_interval(var)) {

1482

const struct snd_interval *i = hw_param_interval_c(params, var);

1495

const struct snd_interval *i = hw_param_interval_c(params, var);

1483

if (!snd_interval_single(i))

1496

if (!snd_interval_single(i))

1484

return -EINVAL;

1497

return -EINVAL;

1485

if (dir)

1498

if (dir)

1486

*dir = i->openmin;

1499

*dir = i->openmin;

1487

return snd_interval_value(i);

1500

return snd_interval_value(i);

1488

}

1501

}

1489

return -EINVAL;

1502

return -EINVAL;

1490

}

1503

}

1491

1504

1492

EXPORT_SYMBOL(snd_pcm_hw_param_value);

1505

EXPORT_SYMBOL(snd_pcm_hw_param_value);

1493

1506

1494

void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params,

1507

void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params,

1495

snd_pcm_hw_param_t var)

1508

snd_pcm_hw_param_t var)

1496

{

1509

{

1497

if (hw_is_mask(var)) {

1510

if (hw_is_mask(var)) {

1498

snd_mask_none(hw_param_mask(params, var));

1511

snd_mask_none(hw_param_mask(params, var));

1499

params->cmask |= 1 << var;

1512

params->cmask |= 1 << var;

1500

params->rmask |= 1 << var;

1513

params->rmask |= 1 << var;

1501

} else if (hw_is_interval(var)) {

1514

} else if (hw_is_interval(var)) {

1502

snd_interval_none(hw_param_interval(params, var));

1515

snd_interval_none(hw_param_interval(params, var));

1503

params->cmask |= 1 << var;

1516

params->cmask |= 1 << var;

1504

params->rmask |= 1 << var;

1517

params->rmask |= 1 << var;

1505

} else {

1518

} else {

1506

snd_BUG();

1519

snd_BUG();

1507

}

1520

}

1508

}

1521

}

1509

1522

1510

EXPORT_SYMBOL(_snd_pcm_hw_param_setempty);

1523

EXPORT_SYMBOL(_snd_pcm_hw_param_setempty);

1511

1524

1512

static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params,

1525

static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params,

1513

snd_pcm_hw_param_t var)

1526

snd_pcm_hw_param_t var)

1514

{

1527

{

1515

int changed;

1528

int changed;

1516

if (hw_is_mask(var))

1529

if (hw_is_mask(var))

1517

changed = snd_mask_refine_first(hw_param_mask(params, var));

1530

changed = snd_mask_refine_first(hw_param_mask(params, var));

1518

else if (hw_is_interval(var))

1531

else if (hw_is_interval(var))

1519

changed = snd_interval_refine_first(hw_param_interval(params, var));

1532

changed = snd_interval_refine_first(hw_param_interval(params, var));

1520

else

1533

else

1521

return -EINVAL;

1534

return -EINVAL;

1522

if (changed) {

1535

if (changed) {

1523

params->cmask |= 1 << var;

1536

params->cmask |= 1 << var;

1524

params->rmask |= 1 << var;

1537

params->rmask |= 1 << var;

1525

}

1538

}

1526

return changed;

1539

return changed;

1527

}

1540

}

1528

1541

1529

1542

1530

/**

1543

/**

1531

* snd_pcm_hw_param_first - refine config space and return minimum value

1544

* snd_pcm_hw_param_first - refine config space and return minimum value

1532

* @pcm: PCM instance

1545

* @pcm: PCM instance

1533

* @params: the hw_params instance

1546

* @params: the hw_params instance

1534

* @var: parameter to retrieve

1547

* @var: parameter to retrieve

1535

* @dir: pointer to the direction (-1,0,1) or %NULL

1548

* @dir: pointer to the direction (-1,0,1) or %NULL

1536

*

1549

*

1537

* Inside configuration space defined by @params remove from @var all

1550

* Inside configuration space defined by @params remove from @var all

1538

* values > minimum. Reduce configuration space accordingly.

1551

* values > minimum. Reduce configuration space accordingly.

1539

* Return the minimum.

1552

* Return the minimum.

1540

*/

1553

*/

1541

int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm,

1554

int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm,

1542

struct snd_pcm_hw_params *params,

1555

struct snd_pcm_hw_params *params,

1543

snd_pcm_hw_param_t var, int *dir)

1556

snd_pcm_hw_param_t var, int *dir)

1544

{

1557

{

1545

int changed = _snd_pcm_hw_param_first(params, var);

1558

int changed = _snd_pcm_hw_param_first(params, var);

1546

if (changed < 0)

1559

if (changed < 0)

1547

return changed;

1560

return changed;

1548

if (params->rmask) {

1561

if (params->rmask) {

1549

int err = snd_pcm_hw_refine(pcm, params);

1562

int err = snd_pcm_hw_refine(pcm, params);

1550

if (snd_BUG_ON(err < 0))

1563

if (snd_BUG_ON(err < 0))

1551

return err;

1564

return err;

1552

}

1565

}

1553

return snd_pcm_hw_param_value(params, var, dir);

1566

return snd_pcm_hw_param_value(params, var, dir);

1554

}

1567

}

1555

1568

1556

EXPORT_SYMBOL(snd_pcm_hw_param_first);

1569

EXPORT_SYMBOL(snd_pcm_hw_param_first);

1557

1570

1558

static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params,

1571

static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params,

1559

snd_pcm_hw_param_t var)

1572

snd_pcm_hw_param_t var)

1560

{

1573

{

1561

int changed;

1574

int changed;

1562

if (hw_is_mask(var))

1575

if (hw_is_mask(var))

1563

changed = snd_mask_refine_last(hw_param_mask(params, var));

1576

changed = snd_mask_refine_last(hw_param_mask(params, var));

1564

else if (hw_is_interval(var))

1577

else if (hw_is_interval(var))

1565

changed = snd_interval_refine_last(hw_param_interval(params, var));

1578

changed = snd_interval_refine_last(hw_param_interval(params, var));

1566

else

1579

else

1567

return -EINVAL;

1580

return -EINVAL;

1568

if (changed) {

1581

if (changed) {

1569

params->cmask |= 1 << var;

1582

params->cmask |= 1 << var;

1570

params->rmask |= 1 << var;

1583

params->rmask |= 1 << var;

1571

}

1584

}

1572

return changed;

1585

return changed;

1573

}

1586

}

1574

1587

1575

1588

1576

/**

1589

/**

1577

* snd_pcm_hw_param_last - refine config space and return maximum value

1590

* snd_pcm_hw_param_last - refine config space and return maximum value

1578

* @pcm: PCM instance

1591

* @pcm: PCM instance

1579

* @params: the hw_params instance

1592

* @params: the hw_params instance

1580

* @var: parameter to retrieve

1593

* @var: parameter to retrieve

1581

* @dir: pointer to the direction (-1,0,1) or %NULL

1594

* @dir: pointer to the direction (-1,0,1) or %NULL

1582

*

1595

*

1583

* Inside configuration space defined by @params remove from @var all

1596

* Inside configuration space defined by @params remove from @var all

1584

* values < maximum. Reduce configuration space accordingly.

1597

* values < maximum. Reduce configuration space accordingly.

1585

* Return the maximum.

1598

* Return the maximum.

1586

*/

1599

*/

1587

int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm,

1600

int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm,

1588

struct snd_pcm_hw_params *params,

1601

struct snd_pcm_hw_params *params,

1589

snd_pcm_hw_param_t var, int *dir)

1602

snd_pcm_hw_param_t var, int *dir)

1590

{

1603

{

1591

int changed = _snd_pcm_hw_param_last(params, var);

1604

int changed = _snd_pcm_hw_param_last(params, var);

1592

if (changed < 0)

1605

if (changed < 0)

1593

return changed;

1606

return changed;

1594

if (params->rmask) {

1607

if (params->rmask) {

1595

int err = snd_pcm_hw_refine(pcm, params);

1608

int err = snd_pcm_hw_refine(pcm, params);

1596

if (snd_BUG_ON(err < 0))

1609

if (snd_BUG_ON(err < 0))

1597

return err;

1610

return err;

1598

}

1611

}

1599

return snd_pcm_hw_param_value(params, var, dir);

1612

return snd_pcm_hw_param_value(params, var, dir);

1600

}

1613

}

1601

1614

1602

EXPORT_SYMBOL(snd_pcm_hw_param_last);

1615

EXPORT_SYMBOL(snd_pcm_hw_param_last);

1603

1616

1604

/**

1617

/**

1605

* snd_pcm_hw_param_choose - choose a configuration defined by @params

1618

* snd_pcm_hw_param_choose - choose a configuration defined by @params

1606

* @pcm: PCM instance

1619

* @pcm: PCM instance

1607

* @params: the hw_params instance

1620

* @params: the hw_params instance

1608

*

1621

*

1609

* Choose one configuration from configuration space defined by @params.

1622

* Choose one configuration from configuration space defined by @params.

1610

* The configuration chosen is that obtained fixing in this order:

1623

* The configuration chosen is that obtained fixing in this order:

1611

* first access, first format, first subformat, min channels,

1624

* first access, first format, first subformat, min channels,

1612

* min rate, min period time, max buffer size, min tick time

1625

* min rate, min period time, max buffer size, min tick time

1613

*/

1626

*/

1614

int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm,

1627

int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm,

1615

struct snd_pcm_hw_params *params)

1628

struct snd_pcm_hw_params *params)

1616

{

1629

{

1617

static int vars[] = {

1630

static int vars[] = {

1618

SNDRV_PCM_HW_PARAM_ACCESS,

1631

SNDRV_PCM_HW_PARAM_ACCESS,

1619

SNDRV_PCM_HW_PARAM_FORMAT,

1632

SNDRV_PCM_HW_PARAM_FORMAT,

1620

SNDRV_PCM_HW_PARAM_SUBFORMAT,

1633

SNDRV_PCM_HW_PARAM_SUBFORMAT,

1621

SNDRV_PCM_HW_PARAM_CHANNELS,

1634

SNDRV_PCM_HW_PARAM_CHANNELS,

1622

SNDRV_PCM_HW_PARAM_RATE,

1635

SNDRV_PCM_HW_PARAM_RATE,

1623

SNDRV_PCM_HW_PARAM_PERIOD_TIME,

1636

SNDRV_PCM_HW_PARAM_PERIOD_TIME,

1624

SNDRV_PCM_HW_PARAM_BUFFER_SIZE,

1637

SNDRV_PCM_HW_PARAM_BUFFER_SIZE,

1625

SNDRV_PCM_HW_PARAM_TICK_TIME,

1638

SNDRV_PCM_HW_PARAM_TICK_TIME,

1626

-1

1639

-1

1627

};

1640

};

1628

int err, *v;

1641

int err, *v;

1629

1642

1630

for (v = vars; *v != -1; v++) {

1643

for (v = vars; *v != -1; v++) {

1631

if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE)

1644

if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE)

1632

err = snd_pcm_hw_param_first(pcm, params, *v, NULL);

1645

err = snd_pcm_hw_param_first(pcm, params, *v, NULL);

1633

else

1646

else

1634

err = snd_pcm_hw_param_last(pcm, params, *v, NULL);

1647

err = snd_pcm_hw_param_last(pcm, params, *v, NULL);

1635

if (snd_BUG_ON(err < 0))

1648

if (snd_BUG_ON(err < 0))

1636

return err;

1649

return err;

1637

}

1650

}

1638

return 0;

1651

return 0;

1639

}

1652

}

1640

1653

1641

static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream,

1654

static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream,

1642

void *arg)

1655

void *arg)

1643

{

1656

{

1644

struct snd_pcm_runtime *runtime = substream->runtime;

1657

struct snd_pcm_runtime *runtime = substream->runtime;

1645

unsigned long flags;

1658

unsigned long flags;

1646

snd_pcm_stream_lock_irqsave(substream, flags);

1659

snd_pcm_stream_lock_irqsave(substream, flags);

1647

if (snd_pcm_running(substream) &&

1660

if (snd_pcm_running(substream) &&

1648

snd_pcm_update_hw_ptr(substream) >= 0)

1661

snd_pcm_update_hw_ptr(substream) >= 0)

1649

runtime->status->hw_ptr %= runtime->buffer_size;

1662

runtime->status->hw_ptr %= runtime->buffer_size;

1650

else

1663

else

1651

runtime->status->hw_ptr = 0;

1664

runtime->status->hw_ptr = 0;

1652

snd_pcm_stream_unlock_irqrestore(substream, flags);

1665

snd_pcm_stream_unlock_irqrestore(substream, flags);

1653

return 0;

1666

return 0;

1654

}

1667

}

1655

1668

1656

static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream *substream,

1669

static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream *substream,

1657

void *arg)

1670

void *arg)

1658

{

1671

{

1659

struct snd_pcm_channel_info *info = arg;

1672

struct snd_pcm_channel_info *info = arg;

1660

struct snd_pcm_runtime *runtime = substream->runtime;

1673

struct snd_pcm_runtime *runtime = substream->runtime;

1661

int width;

1674

int width;

1662

if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) {

1675

if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) {

1663

info->offset = -1;

1676

info->offset = -1;

1664

return 0;

1677

return 0;

1665

}

1678

}

1666

width = snd_pcm_format_physical_width(runtime->format);

1679

width = snd_pcm_format_physical_width(runtime->format);

1667

if (width < 0)

1680

if (width < 0)

1668

return width;

1681

return width;

1669

info->offset = 0;

1682

info->offset = 0;

1670

switch (runtime->access) {

1683

switch (runtime->access) {

1671

case SNDRV_PCM_ACCESS_MMAP_INTERLEAVED:

1684

case SNDRV_PCM_ACCESS_MMAP_INTERLEAVED:

1672

case SNDRV_PCM_ACCESS_RW_INTERLEAVED:

1685

case SNDRV_PCM_ACCESS_RW_INTERLEAVED:

1673

info->first = info->channel * width;

1686

info->first = info->channel * width;

1674

info->step = runtime->channels * width;

1687

info->step = runtime->channels * width;

1675

break;

1688

break;

1676

case SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED:

1689

case SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED:

1677

case SNDRV_PCM_ACCESS_RW_NONINTERLEAVED:

1690

case SNDRV_PCM_ACCESS_RW_NONINTERLEAVED:

1678

{

1691

{

1679

size_t size = runtime->dma_bytes / runtime->channels;

1692

size_t size = runtime->dma_bytes / runtime->channels;

1680

info->first = info->channel * size * 8;

1693

info->first = info->channel * size * 8;

1681

info->step = width;

1694

info->step = width;

1682

break;

1695

break;

1683

}

1696

}

1684

default:

1697

default:

1685

snd_BUG();

1698

snd_BUG();

1686

break;

1699

break;

1687

}

1700

}

1688

return 0;

1701

return 0;

1689

}

1702

}

1690

1703

1691

static int snd_pcm_lib_ioctl_fifo_size(struct snd_pcm_substream *substream,

1704

static int snd_pcm_lib_ioctl_fifo_size(struct snd_pcm_substream *substream,

1692

void *arg)

1705

void *arg)

1693

{

1706

{

1694

struct snd_pcm_hw_params *params = arg;

1707

struct snd_pcm_hw_params *params = arg;

1695

snd_pcm_format_t format;

1708

snd_pcm_format_t format;

1696

int channels, width;

1709

int channels, width;

1697

1710

1698

params->fifo_size = substream->runtime->hw.fifo_size;

1711

params->fifo_size = substream->runtime->hw.fifo_size;

1699

if (!(substream->runtime->hw.info & SNDRV_PCM_INFO_FIFO_IN_FRAMES)) {

1712

if (!(substream->runtime->hw.info & SNDRV_PCM_INFO_FIFO_IN_FRAMES)) {

1700

format = params_format(params);

1713

format = params_format(params);

1701

channels = params_channels(params);

1714

channels = params_channels(params);

1702

width = snd_pcm_format_physical_width(format);

1715

width = snd_pcm_format_physical_width(format);

1703

params->fifo_size /= width * channels;

1716

params->fifo_size /= width * channels;

1704

}

1717

}

1705

return 0;

1718

return 0;

1706

}

1719

}

1707

1720

1708

/**

1721

/**

1709

* snd_pcm_lib_ioctl - a generic PCM ioctl callback

1722

* snd_pcm_lib_ioctl - a generic PCM ioctl callback

1710

* @substream: the pcm substream instance

1723

* @substream: the pcm substream instance

1711

* @cmd: ioctl command

1724

* @cmd: ioctl command

1712

* @arg: ioctl argument

1725

* @arg: ioctl argument

1713

*

1726

*

1714

* Processes the generic ioctl commands for PCM.

1727

* Processes the generic ioctl commands for PCM.

1715

* Can be passed as the ioctl callback for PCM ops.

1728

* Can be passed as the ioctl callback for PCM ops.

1716

*

1729

*

1717

* Returns zero if successful, or a negative error code on failure.

1730

* Returns zero if successful, or a negative error code on failure.

1718

*/

1731

*/

1719

int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,

1732

int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,

1720

unsigned int cmd, void *arg)

1733

unsigned int cmd, void *arg)

1721

{

1734

{

1722

switch (cmd) {

1735

switch (cmd) {

1723

case SNDRV_PCM_IOCTL1_INFO:

1736

case SNDRV_PCM_IOCTL1_INFO:

1724

return 0;

1737

return 0;

1725

case SNDRV_PCM_IOCTL1_RESET:

1738

case SNDRV_PCM_IOCTL1_RESET:

1726

return snd_pcm_lib_ioctl_reset(substream, arg);

1739

return snd_pcm_lib_ioctl_reset(substream, arg);

1727

case SNDRV_PCM_IOCTL1_CHANNEL_INFO:

1740

case SNDRV_PCM_IOCTL1_CHANNEL_INFO:

1728

return snd_pcm_lib_ioctl_channel_info(substream, arg);

1741

return snd_pcm_lib_ioctl_channel_info(substream, arg);

1729

case SNDRV_PCM_IOCTL1_FIFO_SIZE:

1742

case SNDRV_PCM_IOCTL1_FIFO_SIZE:

1730

return snd_pcm_lib_ioctl_fifo_size(substream, arg);

1743

return snd_pcm_lib_ioctl_fifo_size(substream, arg);

1731

}

1744

}

1732

return -ENXIO;

1745

return -ENXIO;

1733

}

1746

}

1734

1747

1735

EXPORT_SYMBOL(snd_pcm_lib_ioctl);

1748

EXPORT_SYMBOL(snd_pcm_lib_ioctl);

1736

1749

1737

/**

1750

/**

1738

* snd_pcm_period_elapsed - update the pcm status for the next period

1751

* snd_pcm_period_elapsed - update the pcm status for the next period

1739

* @substream: the pcm substream instance

1752

* @substream: the pcm substream instance

1740

*

1753

*

1741

* This function is called from the interrupt handler when the

1754

* This function is called from the interrupt handler when the

1742

* PCM has processed the period size. It will update the current

1755

* PCM has processed the period size. It will update the current

1743

* pointer, wake up sleepers, etc.

1756

* pointer, wake up sleepers, etc.

1744

*

1757

*

1745

* Even if more than one periods have elapsed since the last call, you

1758

* Even if more than one periods have elapsed since the last call, you

1746

* have to call this only once.

1759

* have to call this only once.

1747

*/

1760

*/

1748

void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)

1761

void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)

1749

{

1762

{

1750

struct snd_pcm_runtime *runtime;

1763

struct snd_pcm_runtime *runtime;

1751

unsigned long flags;

1764

unsigned long flags;

1752

1765

1753

if (PCM_RUNTIME_CHECK(substream))

1766

if (PCM_RUNTIME_CHECK(substream))

1754

return;

1767

return;

1755

runtime = substream->runtime;

1768

runtime = substream->runtime;

1756

1769

1757

if (runtime->transfer_ack_begin)

1770

if (runtime->transfer_ack_begin)

1758

runtime->transfer_ack_begin(substream);

1771

runtime->transfer_ack_begin(substream);

1759

1772

1760

snd_pcm_stream_lock_irqsave(substream, flags);

1773

snd_pcm_stream_lock_irqsave(substream, flags);

1761

if (!snd_pcm_running(substream) ||

1774

if (!snd_pcm_running(substream) ||

1762

snd_pcm_update_hw_ptr0(substream, 1) < 0)

1775

snd_pcm_update_hw_ptr0(substream, 1) < 0)

1763

goto _end;

1776

goto _end;

1764

1777

1765

if (substream->timer_running)

1778

if (substream->timer_running)

1766

snd_timer_interrupt(substream->timer, 1);

1779

snd_timer_interrupt(substream->timer, 1);

1767

_end:

1780

_end:

1768

snd_pcm_stream_unlock_irqrestore(substream, flags);

1781

snd_pcm_stream_unlock_irqrestore(substream, flags);

1769

if (runtime->transfer_ack_end)

1782

if (runtime->transfer_ack_end)

1770

runtime->transfer_ack_end(substream);

1783

runtime->transfer_ack_end(substream);

1771

kill_fasync(&runtime->fasync, SIGIO, POLL_IN);

1784

kill_fasync(&runtime->fasync, SIGIO, POLL_IN);

1772

}

1785

}

1773

1786

1774

EXPORT_SYMBOL(snd_pcm_period_elapsed);

1787

EXPORT_SYMBOL(snd_pcm_period_elapsed);

1775

1788

1776

/*

1789

/*

1777

* Wait until avail_min data becomes available

1790

* Wait until avail_min data becomes available

1778

* Returns a negative error code if any error occurs during operation.

1791

* Returns a negative error code if any error occurs during operation.

1779

* The available space is stored on availp. When err = 0 and avail = 0

1792

* The available space is stored on availp. When err = 0 and avail = 0

1780

* on the capture stream, it indicates the stream is in DRAINING state.

1793

* on the capture stream, it indicates the stream is in DRAINING state.

1781

*/

1794

*/

1782

static int wait_for_avail(struct snd_pcm_substream *substream,

1795

static int wait_for_avail(struct snd_pcm_substream *substream,

1783

snd_pcm_uframes_t *availp)

1796

snd_pcm_uframes_t *availp)

1784

{

1797

{

1785

struct snd_pcm_runtime *runtime = substream->runtime;

1798

struct snd_pcm_runtime *runtime = substream->runtime;

1786

int is_playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;

1799

int is_playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;

1787

wait_queue_t wait;

1800

wait_queue_t wait;

1788

int err = 0;

1801

int err = 0;

1789

snd_pcm_uframes_t avail = 0;

1802

snd_pcm_uframes_t avail = 0;

1790

long wait_time, tout;

1803

long wait_time, tout;

1791

1804

1792

init_waitqueue_entry(&wait, current);

1805

init_waitqueue_entry(&wait, current);

1793

set_current_state(TASK_INTERRUPTIBLE);

1806

set_current_state(TASK_INTERRUPTIBLE);

1794

add_wait_queue(&runtime->tsleep, &wait);

1807

add_wait_queue(&runtime->tsleep, &wait);

1795

1808

1796

if (runtime->no_period_wakeup)

1809

if (runtime->no_period_wakeup)

1797

wait_time = MAX_SCHEDULE_TIMEOUT;

1810

wait_time = MAX_SCHEDULE_TIMEOUT;

1798

else {

1811

else {

1799

wait_time = 10;

1812

wait_time = 10;

1800

if (runtime->rate) {

1813

if (runtime->rate) {

1801

long t = runtime->period_size * 2 / runtime->rate;

1814

long t = runtime->period_size * 2 / runtime->rate;

1802

wait_time = max(t, wait_time);

1815

wait_time = max(t, wait_time);

1803

}

1816

}

1804

wait_time = msecs_to_jiffies(wait_time * 1000);

1817

wait_time = msecs_to_jiffies(wait_time * 1000);

1805

}

1818

}

1806

1819

1807

for (;;) {

1820

for (;;) {

1808

if (signal_pending(current)) {

1821

if (signal_pending(current)) {

1809

err = -ERESTARTSYS;

1822

err = -ERESTARTSYS;

1810

break;

1823

break;

1811

}

1824

}

1812

1825

1813

/*

1826

/*

1814

* We need to check if space became available already

1827

* We need to check if space became available already

1815

* (and thus the wakeup happened already) first to close

1828

* (and thus the wakeup happened already) first to close

1816

* the race of space already having become available.

1829

* the race of space already having become available.

1817

* This check must happen after been added to the waitqueue

1830

* This check must happen after been added to the waitqueue

1818

* and having current state be INTERRUPTIBLE.

1831

* and having current state be INTERRUPTIBLE.

1819

*/

1832

*/

1820

if (is_playback)

1833

if (is_playback)

1821

avail = snd_pcm_playback_avail(runtime);

1834

avail = snd_pcm_playback_avail(runtime);

1822

else

1835

else

1823

avail = snd_pcm_capture_avail(runtime);

1836

avail = snd_pcm_capture_avail(runtime);

1824

if (avail >= runtime->twake)

1837

if (avail >= runtime->twake)

1825

break;

1838

break;

1826

snd_pcm_stream_unlock_irq(substream);

1839

snd_pcm_stream_unlock_irq(substream);

1827

1840

1828

tout = schedule_timeout(wait_time);

1841

tout = schedule_timeout(wait_time);

1829

1842

1830

snd_pcm_stream_lock_irq(substream);

1843

snd_pcm_stream_lock_irq(substream);

1831

set_current_state(TASK_INTERRUPTIBLE);

1844

set_current_state(TASK_INTERRUPTIBLE);

1832

switch (runtime->status->state) {

1845

switch (runtime->status->state) {

1833

case SNDRV_PCM_STATE_SUSPENDED:

1846

case SNDRV_PCM_STATE_SUSPENDED:

1834

err = -ESTRPIPE;

1847

err = -ESTRPIPE;

1835

goto _endloop;

1848

goto _endloop;

1836

case SNDRV_PCM_STATE_XRUN:

1849

case SNDRV_PCM_STATE_XRUN:

1837

err = -EPIPE;

1850

err = -EPIPE;

1838

goto _endloop;

1851

goto _endloop;

1839

case SNDRV_PCM_STATE_DRAINING:

1852

case SNDRV_PCM_STATE_DRAINING:

1840

if (is_playback)

1853

if (is_playback)

1841

err = -EPIPE;

1854

err = -EPIPE;

1842

else

1855

else

1843

avail = 0; /* indicate draining */

1856

avail = 0; /* indicate draining */

1844

goto _endloop;

1857

goto _endloop;

1845

case SNDRV_PCM_STATE_OPEN:

1858

case SNDRV_PCM_STATE_OPEN:

1846

case SNDRV_PCM_STATE_SETUP:

1859

case SNDRV_PCM_STATE_SETUP:

1847

case SNDRV_PCM_STATE_DISCONNECTED:

1860

case SNDRV_PCM_STATE_DISCONNECTED:

1848

err = -EBADFD;

1861

err = -EBADFD;

1849

goto _endloop;

1862

goto _endloop;

1850

}

1863

}

1851

if (!tout) {

1864

if (!tout) {

1852

snd_printd("%s write error (DMA or IRQ trouble?)\n",

1865

snd_printd("%s write error (DMA or IRQ trouble?)\n",

1853

is_playback ? "playback" : "capture");

1866

is_playback ? "playback" : "capture");

1854

err = -EIO;

1867

err = -EIO;

1855

break;

1868

break;

1856

}

1869

}

1857

}

1870

}

1858

_endloop:

1871

_endloop:

1859

set_current_state(TASK_RUNNING);

1872

set_current_state(TASK_RUNNING);

1860

remove_wait_queue(&runtime->tsleep, &wait);

1873

remove_wait_queue(&runtime->tsleep, &wait);

1861

*availp = avail;

1874

*availp = avail;

1862

return err;

1875

return err;

1863

}

1876

}

1864

1877

1865

static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream,

1878

static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream,

1866

unsigned int hwoff,

1879

unsigned int hwoff,

1867

unsigned long data, unsigned int off,

1880

unsigned long data, unsigned int off,

1868

snd_pcm_uframes_t frames)

1881

snd_pcm_uframes_t frames)

1869

{

1882

{

1870

struct snd_pcm_runtime *runtime = substream->runtime;

1883

struct snd_pcm_runtime *runtime = substream->runtime;

1871

int err;

1884

int err;

1872

char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);

1885

char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);

1873

if (substream->ops->copy) {

1886

if (substream->ops->copy) {

1874

if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)

1887

if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)

1875

return err;

1888

return err;

1876

} else {

1889

} else {

1877

char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);

1890

char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);

1878

if (copy_from_user(hwbuf, buf, frames_to_bytes(runtime, frames)))

1891

if (copy_from_user(hwbuf, buf, frames_to_bytes(runtime, frames)))

1879

return -EFAULT;

1892

return -EFAULT;

1880

}

1893

}

1881

return 0;

1894

return 0;

1882

}

1895

}

1883

1896

1884

typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff,

1897

typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff,

1885

unsigned long data, unsigned int off,

1898

unsigned long data, unsigned int off,

1886

snd_pcm_uframes_t size);

1899

snd_pcm_uframes_t size);

1887

1900

1888

static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,

1901

static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,

1889

unsigned long data,

1902

unsigned long data,

1890

snd_pcm_uframes_t size,

1903

snd_pcm_uframes_t size,

1891

int nonblock,

1904

int nonblock,

1892

transfer_f transfer)

1905

transfer_f transfer)

1893

{

1906

{

1894

struct snd_pcm_runtime *runtime = substream->runtime;

1907

struct snd_pcm_runtime *runtime = substream->runtime;

1895

snd_pcm_uframes_t xfer = 0;

1908

snd_pcm_uframes_t xfer = 0;

1896

snd_pcm_uframes_t offset = 0;

1909

snd_pcm_uframes_t offset = 0;

1897

snd_pcm_uframes_t avail;

1910

snd_pcm_uframes_t avail;

1898

int err = 0;

1911

int err = 0;

1899

1912

1900

if (size == 0)

1913

if (size == 0)

1901

return 0;

1914

return 0;

1902

1915

1903

snd_pcm_stream_lock_irq(substream);

1916

snd_pcm_stream_lock_irq(substream);

1904

switch (runtime->status->state) {

1917

switch (runtime->status->state) {

1905

case SNDRV_PCM_STATE_PREPARED:

1918

case SNDRV_PCM_STATE_PREPARED:

1906

case SNDRV_PCM_STATE_RUNNING:

1919

case SNDRV_PCM_STATE_RUNNING:

1907

case SNDRV_PCM_STATE_PAUSED:

1920

case SNDRV_PCM_STATE_PAUSED:

1908

break;

1921

break;

1909

case SNDRV_PCM_STATE_XRUN:

1922

case SNDRV_PCM_STATE_XRUN:

1910

err = -EPIPE;

1923

err = -EPIPE;

1911

goto _end_unlock;

1924

goto _end_unlock;

1912

case SNDRV_PCM_STATE_SUSPENDED:

1925

case SNDRV_PCM_STATE_SUSPENDED:

1913

err = -ESTRPIPE;

1926

err = -ESTRPIPE;

1914

goto _end_unlock;

1927

goto _end_unlock;

1915

default:

1928

default:

1916

err = -EBADFD;

1929

err = -EBADFD;

1917

goto _end_unlock;

1930

goto _end_unlock;

1918

}

1931

}

1919

1932

1920

runtime->twake = runtime->control->avail_min ? : 1;

1933

runtime->twake = runtime->control->avail_min ? : 1;

1921

if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)

1934

if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)

1922

snd_pcm_update_hw_ptr(substream);

1935

snd_pcm_update_hw_ptr(substream);

1923

avail = snd_pcm_playback_avail(runtime);

1936

avail = snd_pcm_playback_avail(runtime);

1924

while (size > 0) {

1937

while (size > 0) {

1925

snd_pcm_uframes_t frames, appl_ptr, appl_ofs;

1938

snd_pcm_uframes_t frames, appl_ptr, appl_ofs;

1926

snd_pcm_uframes_t cont;

1939

snd_pcm_uframes_t cont;

1927

if (!avail) {

1940

if (!avail) {

1928

if (nonblock) {

1941

if (nonblock) {

1929

err = -EAGAIN;

1942

err = -EAGAIN;

1930

goto _end_unlock;

1943

goto _end_unlock;

1931

}

1944

}

1932

runtime->twake = min_t(snd_pcm_uframes_t, size,

1945

runtime->twake = min_t(snd_pcm_uframes_t, size,

1933

runtime->control->avail_min ? : 1);

1946

runtime->control->avail_min ? : 1);

1934

err = wait_for_avail(substream, &avail);

1947

err = wait_for_avail(substream, &avail);

1935

if (err < 0)

1948

if (err < 0)

1936

goto _end_unlock;

1949

goto _end_unlock;

1937

}

1950

}

1938

frames = size > avail ? avail : size;

1951

frames = size > avail ? avail : size;

1939

cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;

1952

cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;

1940

if (frames > cont)

1953

if (frames > cont)

1941

frames = cont;

1954

frames = cont;

1942

if (snd_BUG_ON(!frames)) {

1955

if (snd_BUG_ON(!frames)) {

1943

runtime->twake = 0;

1956

runtime->twake = 0;

1944

snd_pcm_stream_unlock_irq(substream);

1957

snd_pcm_stream_unlock_irq(substream);

1945

return -EINVAL;

1958

return -EINVAL;

1946

}

1959

}

1947

appl_ptr = runtime->control->appl_ptr;

1960

appl_ptr = runtime->control->appl_ptr;

1948

appl_ofs = appl_ptr % runtime->buffer_size;

1961

appl_ofs = appl_ptr % runtime->buffer_size;

1949

snd_pcm_stream_unlock_irq(substream);

1962

snd_pcm_stream_unlock_irq(substream);

1950

err = transfer(substream, appl_ofs, data, offset, frames);

1963

err = transfer(substream, appl_ofs, data, offset, frames);

1951

snd_pcm_stream_lock_irq(substream);

1964

snd_pcm_stream_lock_irq(substream);

1952

if (err < 0)

1965

if (err < 0)

1953

goto _end_unlock;

1966

goto _end_unlock;

1954

switch (runtime->status->state) {

1967

switch (runtime->status->state) {

1955

case SNDRV_PCM_STATE_XRUN:

1968

case SNDRV_PCM_STATE_XRUN:

1956

err = -EPIPE;

1969

err = -EPIPE;

1957

goto _end_unlock;

1970

goto _end_unlock;

1958

case SNDRV_PCM_STATE_SUSPENDED:

1971

case SNDRV_PCM_STATE_SUSPENDED:

1959

err = -ESTRPIPE;

1972

err = -ESTRPIPE;

1960

goto _end_unlock;

1973

goto _end_unlock;

1961

default:

1974

default:

1962

break;

1975

break;

1963

}

1976

}

1964

appl_ptr += frames;

1977

appl_ptr += frames;

1965

if (appl_ptr >= runtime->boundary)

1978

if (appl_ptr >= runtime->boundary)

1966

appl_ptr -= runtime->boundary;

1979

appl_ptr -= runtime->boundary;

1967

runtime->control->appl_ptr = appl_ptr;

1980

runtime->control->appl_ptr = appl_ptr;

1968

if (substream->ops->ack)

1981

if (substream->ops->ack)

1969

substream->ops->ack(substream);

1982

substream->ops->ack(substream);

1970

1983

1971

offset += frames;

1984

offset += frames;

1972

size -= frames;

1985

size -= frames;

1973

xfer += frames;

1986

xfer += frames;

1974

avail -= frames;

1987

avail -= frames;

1975

if (runtime->status->state == SNDRV_PCM_STATE_PREPARED &&

1988

if (runtime->status->state == SNDRV_PCM_STATE_PREPARED &&

1976

snd_pcm_playback_hw_avail(runtime) >= (snd_pcm_sframes_t)runtime->start_threshold) {

1989

snd_pcm_playback_hw_avail(runtime) >= (snd_pcm_sframes_t)runtime->start_threshold) {

1977

err = snd_pcm_start(substream);

1990

err = snd_pcm_start(substream);

1978

if (err < 0)

1991

if (err < 0)

1979

goto _end_unlock;

1992

goto _end_unlock;

1980

}

1993

}

1981

}

1994

}

1982

_end_unlock:

1995

_end_unlock:

1983

runtime->twake = 0;

1996

runtime->twake = 0;

1984

if (xfer > 0 && err >= 0)

1997

if (xfer > 0 && err >= 0)

1985

snd_pcm_update_state(substream, runtime);

1998

snd_pcm_update_state(substream, runtime);

1986

snd_pcm_stream_unlock_irq(substream);

1999

snd_pcm_stream_unlock_irq(substream);

1987

return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;

2000

return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;

1988

}

2001

}

1989

2002

1990

/* sanity-check for read/write methods */

2003

/* sanity-check for read/write methods */

1991

static int pcm_sanity_check(struct snd_pcm_substream *substream)

2004

static int pcm_sanity_check(struct snd_pcm_substream *substream)

1992

{

2005

{

1993

struct snd_pcm_runtime *runtime;

2006

struct snd_pcm_runtime *runtime;

1994

if (PCM_RUNTIME_CHECK(substream))

2007

if (PCM_RUNTIME_CHECK(substream))

1995

return -ENXIO;

2008

return -ENXIO;

1996

runtime = substream->runtime;

2009

runtime = substream->runtime;

1997

if (snd_BUG_ON(!substream->ops->copy && !runtime->dma_area))

2010

if (snd_BUG_ON(!substream->ops->copy && !runtime->dma_area))

1998

return -EINVAL;

2011

return -EINVAL;

1999

if (runtime->status->state == SNDRV_PCM_STATE_OPEN)

2012

if (runtime->status->state == SNDRV_PCM_STATE_OPEN)

2000

return -EBADFD;

2013

return -EBADFD;

2001

return 0;

2014

return 0;

2002

}

2015

}

2003

2016

2004

snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size)

2017

snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size)

2005

{

2018

{

2006

struct snd_pcm_runtime *runtime;

2019

struct snd_pcm_runtime *runtime;

2007

int nonblock;

2020

int nonblock;

2008

int err;

2021

int err;

2009

2022

2010

err = pcm_sanity_check(substream);

2023

err = pcm_sanity_check(substream);

2011

if (err < 0)

2024

if (err < 0)

2012

return err;

2025

return err;

2013

runtime = substream->runtime;

2026

runtime = substream->runtime;

2014

nonblock = !!(substream->f_flags & O_NONBLOCK);

2027

nonblock = !!(substream->f_flags & O_NONBLOCK);

2015

2028

2016

if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED &&

2029

if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED &&

2017

runtime->channels > 1)

2030

runtime->channels > 1)

2018

return -EINVAL;

2031

return -EINVAL;

2019

return snd_pcm_lib_write1(substream, (unsigned long)buf, size, nonblock,

2032

return snd_pcm_lib_write1(substream, (unsigned long)buf, size, nonblock,

2020

snd_pcm_lib_write_transfer);

2033

snd_pcm_lib_write_transfer);

2021

}

2034

}

2022

2035

2023

EXPORT_SYMBOL(snd_pcm_lib_write);

2036

EXPORT_SYMBOL(snd_pcm_lib_write);

2024

2037

2025

static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream,

2038

static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream,

2026

unsigned int hwoff,

2039

unsigned int hwoff,

2027

unsigned long data, unsigned int off,

2040

unsigned long data, unsigned int off,

2028

snd_pcm_uframes_t frames)

2041

snd_pcm_uframes_t frames)

2029

{

2042

{

2030

struct snd_pcm_runtime *runtime = substream->runtime;

2043

struct snd_pcm_runtime *runtime = substream->runtime;

2031

int err;

2044

int err;

2032

void __user **bufs = (void __user **)data;

2045

void __user **bufs = (void __user **)data;

2033

int channels = runtime->channels;

2046

int channels = runtime->channels;

2034

int c;

2047

int c;

2035

if (substream->ops->copy) {

2048

if (substream->ops->copy) {

2036

if (snd_BUG_ON(!substream->ops->silence))

2049

if (snd_BUG_ON(!substream->ops->silence))

2037

return -EINVAL;

2050

return -EINVAL;

2038

for (c = 0; c < channels; ++c, ++bufs) {

2051

for (c = 0; c < channels; ++c, ++bufs) {

2039

if (*bufs == NULL) {

2052

if (*bufs == NULL) {

2040

if ((err = substream->ops->silence(substream, c, hwoff, frames)) < 0)

2053

if ((err = substream->ops->silence(substream, c, hwoff, frames)) < 0)

2041

return err;

2054

return err;

2042

} else {

2055

} else {

2043

char __user *buf = *bufs + samples_to_bytes(runtime, off);

2056

char __user *buf = *bufs + samples_to_bytes(runtime, off);

2044

if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)

2057

if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)

2045

return err;

2058

return err;

2046

}

2059

}

2047

}

2060

}

2048

} else {

2061

} else {

2049

/* default transfer behaviour */

2062

/* default transfer behaviour */

2050

size_t dma_csize = runtime->dma_bytes / channels;

2063

size_t dma_csize = runtime->dma_bytes / channels;

2051

for (c = 0; c < channels; ++c, ++bufs) {

2064

for (c = 0; c < channels; ++c, ++bufs) {

2052

char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);

2065

char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);

2053

if (*bufs == NULL) {

2066

if (*bufs == NULL) {

2054

snd_pcm_format_set_silence(runtime->format, hwbuf, frames);

2067

snd_pcm_format_set_silence(runtime->format, hwbuf, frames);

2055

} else {

2068

} else {

2056

char __user *buf = *bufs + samples_to_bytes(runtime, off);

2069

char __user *buf = *bufs + samples_to_bytes(runtime, off);

2057

if (copy_from_user(hwbuf, buf, samples_to_bytes(runtime, frames)))

2070

if (copy_from_user(hwbuf, buf, samples_to_bytes(runtime, frames)))

2058

return -EFAULT;

2071

return -EFAULT;

2059

}

2072

}

2060

}

2073

}

2061

}

2074

}

2062

return 0;

2075

return 0;

2063

}

2076

}

2064

2077

2065

snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,

2078

snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,

2066

void __user **bufs,

2079

void __user **bufs,

2067

snd_pcm_uframes_t frames)

2080

snd_pcm_uframes_t frames)

2068

{

2081

{

2069

struct snd_pcm_runtime *runtime;

2082

struct snd_pcm_runtime *runtime;

2070

int nonblock;

2083

int nonblock;

2071

int err;

2084

int err;

2072

2085

2073

err = pcm_sanity_check(substream);

2086

err = pcm_sanity_check(substream);

2074

if (err < 0)

2087

if (err < 0)

2075

return err;

2088

return err;

2076

runtime = substream->runtime;

2089

runtime = substream->runtime;

2077

nonblock = !!(substream->f_flags & O_NONBLOCK);

2090

nonblock = !!(substream->f_flags & O_NONBLOCK);

2078

2091

2079

if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)

2092

if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)

2080

return -EINVAL;

2093

return -EINVAL;

2081

return snd_pcm_lib_write1(substream, (unsigned long)bufs, frames,

2094

return snd_pcm_lib_write1(substream, (unsigned long)bufs, frames,

2082

nonblock, snd_pcm_lib_writev_transfer);

2095

nonblock, snd_pcm_lib_writev_transfer);

2083

}

2096

}

2084

2097

2085

EXPORT_SYMBOL(snd_pcm_lib_writev);

2098

EXPORT_SYMBOL(snd_pcm_lib_writev);

2086

2099

2087

static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream,

2100

static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream,

2088

unsigned int hwoff,

2101

unsigned int hwoff,

2089

unsigned long data, unsigned int off,

2102

unsigned long data, unsigned int off,

2090

snd_pcm_uframes_t frames)

2103

snd_pcm_uframes_t frames)

2091

{

2104

{

2092

struct snd_pcm_runtime *runtime = substream->runtime;

2105

struct snd_pcm_runtime *runtime = substream->runtime;

2093

int err;

2106

int err;

2094

char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);

2107

char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);

2095

if (substream->ops->copy) {

2108

if (substream->ops->copy) {

2096

if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)

2109

if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)

2097

return err;

2110

return err;

2098

} else {

2111

} else {

2099

char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);

2112

char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);

2100

if (copy_to_user(buf, hwbuf, frames_to_bytes(runtime, frames)))

2113

if (copy_to_user(buf, hwbuf, frames_to_bytes(runtime, frames)))

2101

return -EFAULT;

2114

return -EFAULT;

2102

}

2115

}

2103

return 0;

2116

return 0;

2104

}

2117

}

2105

2118

2106

static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,

2119

static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,

2107

unsigned long data,

2120

unsigned long data,

2108

snd_pcm_uframes_t size,

2121

snd_pcm_uframes_t size,

2109

int nonblock,

2122

int nonblock,

2110

transfer_f transfer)

2123

transfer_f transfer)

2111

{

2124

{

2112

struct snd_pcm_runtime *runtime = substream->runtime;

2125

struct snd_pcm_runtime *runtime = substream->runtime;

2113

snd_pcm_uframes_t xfer = 0;

2126

snd_pcm_uframes_t xfer = 0;

2114

snd_pcm_uframes_t offset = 0;

2127

snd_pcm_uframes_t offset = 0;

2115

snd_pcm_uframes_t avail;

2128

snd_pcm_uframes_t avail;

2116

int err = 0;

2129

int err = 0;

2117

2130

2118

if (size == 0)

2131

if (size == 0)

2119

return 0;

2132

return 0;

2120

2133

2121

snd_pcm_stream_lock_irq(substream);

2134

snd_pcm_stream_lock_irq(substream);

2122

switch (runtime->status->state) {

2135

switch (runtime->status->state) {

2123

case SNDRV_PCM_STATE_PREPARED:

2136

case SNDRV_PCM_STATE_PREPARED:

2124

if (size >= runtime->start_threshold) {

2137

if (size >= runtime->start_threshold) {

2125

err = snd_pcm_start(substream);

2138

err = snd_pcm_start(substream);

2126

if (err < 0)

2139

if (err < 0)

2127

goto _end_unlock;

2140

goto _end_unlock;

2128

}

2141

}

2129

break;

2142

break;

2130

case SNDRV_PCM_STATE_DRAINING:

2143

case SNDRV_PCM_STATE_DRAINING:

2131

case SNDRV_PCM_STATE_RUNNING:

2144

case SNDRV_PCM_STATE_RUNNING:

2132

case SNDRV_PCM_STATE_PAUSED:

2145

case SNDRV_PCM_STATE_PAUSED:

2133

break;

2146

break;

2134

case SNDRV_PCM_STATE_XRUN:

2147

case SNDRV_PCM_STATE_XRUN:

2135

err = -EPIPE;

2148

err = -EPIPE;

2136

goto _end_unlock;

2149

goto _end_unlock;

2137

case SNDRV_PCM_STATE_SUSPENDED:

2150

case SNDRV_PCM_STATE_SUSPENDED:

2138

err = -ESTRPIPE;

2151

err = -ESTRPIPE;

2139

goto _end_unlock;

2152

goto _end_unlock;

2140

default:

2153

default:

2141

err = -EBADFD;

2154

err = -EBADFD;

2142

goto _end_unlock;

2155

goto _end_unlock;

2143

}

2156

}

2144

2157

2145

runtime->twake = runtime->control->avail_min ? : 1;

2158

runtime->twake = runtime->control->avail_min ? : 1;

2146

if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)

2159

if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)

2147

snd_pcm_update_hw_ptr(substream);

2160

snd_pcm_update_hw_ptr(substream);

2148

avail = snd_pcm_capture_avail(runtime);

2161

avail = snd_pcm_capture_avail(runtime);

2149

while (size > 0) {

2162

while (size > 0) {

2150

snd_pcm_uframes_t frames, appl_ptr, appl_ofs;

2163

snd_pcm_uframes_t frames, appl_ptr, appl_ofs;

2151

snd_pcm_uframes_t cont;

2164

snd_pcm_uframes_t cont;

2152

if (!avail) {

2165

if (!avail) {

2153

if (runtime->status->state ==

2166

if (runtime->status->state ==

2154

SNDRV_PCM_STATE_DRAINING) {

2167

SNDRV_PCM_STATE_DRAINING) {

2155

snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);

2168

snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);

2156

goto _end_unlock;

2169

goto _end_unlock;

2157

}

2170

}

2158

if (nonblock) {

2171

if (nonblock) {

2159

err = -EAGAIN;

2172

err = -EAGAIN;

2160

goto _end_unlock;

2173

goto _end_unlock;

2161

}

2174

}

2162

runtime->twake = min_t(snd_pcm_uframes_t, size,

2175

runtime->twake = min_t(snd_pcm_uframes_t, size,

2163

runtime->control->avail_min ? : 1);

2176

runtime->control->avail_min ? : 1);

2164

err = wait_for_avail(substream, &avail);

2177

err = wait_for_avail(substream, &avail);

2165

if (err < 0)

2178

if (err < 0)

2166

goto _end_unlock;

2179

goto _end_unlock;

2167

if (!avail)

2180

if (!avail)

2168

continue; /* draining */

2181

continue; /* draining */

2169

}

2182

}

2170

frames = size > avail ? avail : size;

2183

frames = size > avail ? avail : size;

2171

cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;

2184

cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;

2172

if (frames > cont)

2185

if (frames > cont)

2173

frames = cont;

2186

frames = cont;

2174

if (snd_BUG_ON(!frames)) {

2187

if (snd_BUG_ON(!frames)) {

2175

runtime->twake = 0;

2188

runtime->twake = 0;

2176

snd_pcm_stream_unlock_irq(substream);

2189

snd_pcm_stream_unlock_irq(substream);

2177

return -EINVAL;

2190

return -EINVAL;

2178

}

2191

}

2179

appl_ptr = runtime->control->appl_ptr;

2192

appl_ptr = runtime->control->appl_ptr;

2180

appl_ofs = appl_ptr % runtime->buffer_size;

2193

appl_ofs = appl_ptr % runtime->buffer_size;

2181

snd_pcm_stream_unlock_irq(substream);

2194

snd_pcm_stream_unlock_irq(substream);

2182

err = transfer(substream, appl_ofs, data, offset, frames);

2195

err = transfer(substream, appl_ofs, data, offset, frames);

2183

snd_pcm_stream_lock_irq(substream);

2196

snd_pcm_stream_lock_irq(substream);

2184

if (err < 0)

2197

if (err < 0)

2185

goto _end_unlock;

2198

goto _end_unlock;

2186

switch (runtime->status->state) {

2199

switch (runtime->status->state) {

2187

case SNDRV_PCM_STATE_XRUN:

2200

case SNDRV_PCM_STATE_XRUN:

2188

err = -EPIPE;

2201

err = -EPIPE;

2189

goto _end_unlock;

2202

goto _end_unlock;

2190

case SNDRV_PCM_STATE_SUSPENDED:

2203

case SNDRV_PCM_STATE_SUSPENDED:

2191

err = -ESTRPIPE;

2204

err = -ESTRPIPE;

2192

goto _end_unlock;

2205

goto _end_unlock;

2193

default:

2206

default:

2194

break;

2207

break;

2195

}

2208

}

2196

appl_ptr += frames;

2209

appl_ptr += frames;

2197

if (appl_ptr >= runtime->boundary)

2210

if (appl_ptr >= runtime->boundary)

2198

appl_ptr -= runtime->boundary;

2211

appl_ptr -= runtime->boundary;

2199

runtime->control->appl_ptr = appl_ptr;

2212

runtime->control->appl_ptr = appl_ptr;

2200

if (substream->ops->ack)

2213

if (substream->ops->ack)

2201

substream->ops->ack(substream);

2214

substream->ops->ack(substream);

2202

2215

2203

offset += frames;

2216

offset += frames;

2204

size -= frames;

2217

size -= frames;

2205

xfer += frames;

2218

xfer += frames;

2206

avail -= frames;

2219

avail -= frames;

2207

}

2220

}

2208

_end_unlock:

2221

_end_unlock:

2209

runtime->twake = 0;

2222

runtime->twake = 0;

2210

if (xfer > 0 && err >= 0)

2223

if (xfer > 0 && err >= 0)

2211

snd_pcm_update_state(substream, runtime);

2224

snd_pcm_update_state(substream, runtime);

2212

snd_pcm_stream_unlock_irq(substream);

2225

snd_pcm_stream_unlock_irq(substream);

2213

return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;

2226

return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;

2214

}

2227

}

2215

2228

2216

snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __user *buf, snd_pcm_uframes_t size)

2229

snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __user *buf, snd_pcm_uframes_t size)

2217

{

2230

{

2218

struct snd_pcm_runtime *runtime;

2231

struct snd_pcm_runtime *runtime;

2219

int nonblock;

2232

int nonblock;

2220

int err;

2233

int err;

2221

2234

2222

err = pcm_sanity_check(substream);

2235

err = pcm_sanity_check(substream);

2223

if (err < 0)

2236

if (err < 0)

2224

return err;

2237

return err;

2225

runtime = substream->runtime;

2238

runtime = substream->runtime;

2226

nonblock = !!(substream->f_flags & O_NONBLOCK);

2239

nonblock = !!(substream->f_flags & O_NONBLOCK);

2227

if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED)

2240

if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED)

2228

return -EINVAL;

2241

return -EINVAL;

2229

return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer);

2242

return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer);

2230

}

2243

}

2231

2244

2232

EXPORT_SYMBOL(snd_pcm_lib_read);

2245

EXPORT_SYMBOL(snd_pcm_lib_read);

2233

2246

2234

static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream,

2247

static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream,

2235

unsigned int hwoff,

2248

unsigned int hwoff,

2236

unsigned long data, unsigned int off,

2249

unsigned long data, unsigned int off,

2237

snd_pcm_uframes_t frames)

2250

snd_pcm_uframes_t frames)

2238

{

2251

{

2239

struct snd_pcm_runtime *runtime = substream->runtime;

2252

struct snd_pcm_runtime *runtime = substream->runtime;

2240

int err;

2253

int err;

2241

void __user **bufs = (void __user **)data;

2254

void __user **bufs = (void __user **)data;

2242

int channels = runtime->channels;

2255

int channels = runtime->channels;

2243

int c;

2256

int c;

2244

if (substream->ops->copy) {

2257

if (substream->ops->copy) {

2245

for (c = 0; c < channels; ++c, ++bufs) {

2258

for (c = 0; c < channels; ++c, ++bufs) {

2246

char __user *buf;

2259

char __user *buf;

2247

if (*bufs == NULL)

2260

if (*bufs == NULL)

2248

continue;

2261

continue;

2249

buf = *bufs + samples_to_bytes(runtime, off);

2262

buf = *bufs + samples_to_bytes(runtime, off);

2250

if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)

2263

if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)

2251

return err;

2264

return err;

2252

}

2265

}

2253

} else {

2266

} else {

2254

snd_pcm_uframes_t dma_csize = runtime->dma_bytes / channels;

2267

snd_pcm_uframes_t dma_csize = runtime->dma_bytes / channels;

2255

for (c = 0; c < channels; ++c, ++bufs) {

2268

for (c = 0; c < channels; ++c, ++bufs) {

2256

char *hwbuf;

2269

char *hwbuf;

2257

char __user *buf;

2270

char __user *buf;

2258

if (*bufs == NULL)

2271

if (*bufs == NULL)

2259

continue;

2272

continue;

2260

2273

2261

hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);

2274

hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);

2262

buf = *bufs + samples_to_bytes(runtime, off);

2275

buf = *bufs + samples_to_bytes(runtime, off);

2263

if (copy_to_user(buf, hwbuf, samples_to_bytes(runtime, frames)))

2276

if (copy_to_user(buf, hwbuf, samples_to_bytes(runtime, frames)))

2264

return -EFAULT;

2277

return -EFAULT;

2265

}

2278

}

2266

}

2279

}

2267

return 0;

2280

return 0;

2268

}

2281

}

2269

2282

2270

snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,

2283

snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,

2271

void __user **bufs,

2284

void __user **bufs,

2272

snd_pcm_uframes_t frames)

2285

snd_pcm_uframes_t frames)

2273

{

2286

{

2274

struct snd_pcm_runtime *runtime;

2287

struct snd_pcm_runtime *runtime;

2275

int nonblock;

2288

int nonblock;

2276

int err;

2289

int err;

2277

2290

2278

err = pcm_sanity_check(substream);

2291

err = pcm_sanity_check(substream);

2279

if (err < 0)

2292

if (err < 0)

2280

return err;

2293

return err;

2281

runtime = substream->runtime;

2294

runtime = substream->runtime;

2282

if (runtime->status->state == SNDRV_PCM_STATE_OPEN)

2295

if (runtime->status->state == SNDRV_PCM_STATE_OPEN)

2283

return -EBADFD;

2296

return -EBADFD;

2284

2297

2285

nonblock = !!(substream->f_flags & O_NONBLOCK);

2298

nonblock = !!(substream->f_flags & O_NONBLOCK);

2286

if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)

2299

if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)

2287

return -EINVAL;

2300

return -EINVAL;

2288

return snd_pcm_lib_read1(substream, (unsigned long)bufs, frames, nonblock, snd_pcm_lib_readv_transfer);

2301

return snd_pcm_lib_read1(substream, (unsigned long)bufs, frames, nonblock, snd_pcm_lib_readv_transfer);

2289

}

2302

}

2290

2303

2291

EXPORT_SYMBOL(snd_pcm_lib_readv);

2304

EXPORT_SYMBOL(snd_pcm_lib_readv);

2292

2305

GITLAB

ALSA: core: group read of pointer, tstamp and jiffies

 /*
  *  Digital Audio (PCM) abstract layer
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
  *                   Abramo Bagnara <abramo@alsa-project.org>
  *
  *
  *   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.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU General Public License for more details.
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program; if not, write to the Free Software
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  *
  */
 #include <linux/slab.h>
 #include <linux/time.h>
 #include <linux/math64.h>
 #include <linux/export.h>
 #include <sound/core.h>
 #include <sound/control.h>
 #include <sound/info.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
 #include <sound/timer.h>
 /*
  * fill ring buffer with silence
  * runtime->silence_start: starting pointer to silence area
  * runtime->silence_filled: size filled with silence
  * runtime->silence_threshold: threshold from application
  * runtime->silence_size: maximal size from application
  *
  * when runtime->silence_size >= runtime->boundary - fill processed area with silence immediately
  */
 void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	snd_pcm_uframes_t frames, ofs, transfer;
 	if (runtime->silence_size < runtime->boundary) {
 		snd_pcm_sframes_t noise_dist, n;
 		if (runtime->silence_start != runtime->control->appl_ptr) {
 			n = runtime->control->appl_ptr - runtime->silence_start;
 			if (n < 0)
 				n += runtime->boundary;
 			if ((snd_pcm_uframes_t)n < runtime->silence_filled)
 				runtime->silence_filled -= n;
 			else
 				runtime->silence_filled = 0;
 			runtime->silence_start = runtime->control->appl_ptr;
 		}
 		if (runtime->silence_filled >= runtime->buffer_size)
 			return;
 		noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled;
 		if (noise_dist >= (snd_pcm_sframes_t) runtime->silence_threshold)
 			return;
 		frames = runtime->silence_threshold - noise_dist;
 		if (frames > runtime->silence_size)
 			frames = runtime->silence_size;
 	} else {
 		if (new_hw_ptr == ULONG_MAX) {	/* initialization */
 			snd_pcm_sframes_t avail = snd_pcm_playback_hw_avail(runtime);
 			if (avail > runtime->buffer_size)
 				avail = runtime->buffer_size;
 			runtime->silence_filled = avail > 0 ? avail : 0;
 			runtime->silence_start = (runtime->status->hw_ptr +
 						  runtime->silence_filled) %
 						 runtime->boundary;
 		} else {
 			ofs = runtime->status->hw_ptr;
 			frames = new_hw_ptr - ofs;
 			if ((snd_pcm_sframes_t)frames < 0)
 				frames += runtime->boundary;
 			runtime->silence_filled -= frames;
 			if ((snd_pcm_sframes_t)runtime->silence_filled < 0) {
 				runtime->silence_filled = 0;
 				runtime->silence_start = new_hw_ptr;
 			} else {
 				runtime->silence_start = ofs;
 			}
 		}
 		frames = runtime->buffer_size - runtime->silence_filled;
 	}
 	if (snd_BUG_ON(frames > runtime->buffer_size))
 		return;
 	if (frames == 0)
 		return;
 	ofs = runtime->silence_start % runtime->buffer_size;
 	while (frames > 0) {
 		transfer = ofs + frames > runtime->buffer_size ? runtime->buffer_size - ofs : frames;
 		if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED ||
 		    runtime->access == SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) {
 			if (substream->ops->silence) {
 				int err;
 				err = substream->ops->silence(substream, -1, ofs, transfer);
 				snd_BUG_ON(err < 0);
 			} else {
 				char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, ofs);
 				snd_pcm_format_set_silence(runtime->format, hwbuf, transfer * runtime->channels);
 			}
 		} else {
 			unsigned int c;
 			unsigned int channels = runtime->channels;
 			if (substream->ops->silence) {
 				for (c = 0; c < channels; ++c) {
 					int err;
 					err = substream->ops->silence(substream, c, ofs, transfer);
 					snd_BUG_ON(err < 0);
 				}
 			} else {
 				size_t dma_csize = runtime->dma_bytes / channels;
 				for (c = 0; c < channels; ++c) {
 					char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, ofs);
 					snd_pcm_format_set_silence(runtime->format, hwbuf, transfer);
 				}
 			}
 		}
 		runtime->silence_filled += transfer;
 		frames -= transfer;
 		ofs = 0;
 	}
 }
 #ifdef CONFIG_SND_DEBUG
 void snd_pcm_debug_name(struct snd_pcm_substream *substream,
 			   char *name, size_t len)
 {
 	snprintf(name, len, "pcmC%dD%d%c:%d",
 		 substream->pcm->card->number,
 		 substream->pcm->device,
 		 substream->stream ? 'c' : 'p',
 		 substream->number);
 }
 EXPORT_SYMBOL(snd_pcm_debug_name);
 #endif
 #define XRUN_DEBUG_BASIC	(1<<0)
 #define XRUN_DEBUG_STACK	(1<<1)	/* dump also stack */
 #define XRUN_DEBUG_JIFFIESCHECK	(1<<2)	/* do jiffies check */
 #define XRUN_DEBUG_PERIODUPDATE	(1<<3)	/* full period update info */
 #define XRUN_DEBUG_HWPTRUPDATE	(1<<4)	/* full hwptr update info */
 #define XRUN_DEBUG_LOG		(1<<5)	/* show last 10 positions on err */
 #define XRUN_DEBUG_LOGONCE	(1<<6)	/* do above only once */
 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
 #define xrun_debug(substream, mask) \
 			((substream)->pstr->xrun_debug & (mask))
 #else
 #define xrun_debug(substream, mask)	0
 #endif
 #define dump_stack_on_xrun(substream) do {			\
 		if (xrun_debug(substream, XRUN_DEBUG_STACK))	\
 			dump_stack();				\
 	} while (0)
 static void xrun(struct snd_pcm_substream *substream)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
 		snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
 	snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
 	if (xrun_debug(substream, XRUN_DEBUG_BASIC)) {
 		char name[16];
 		snd_pcm_debug_name(substream, name, sizeof(name));
 		snd_printd(KERN_DEBUG "XRUN: %s\n", name);
 		dump_stack_on_xrun(substream);
 	}
 }
 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
 #define hw_ptr_error(substream, fmt, args...)				\
 	do {								\
 		if (xrun_debug(substream, XRUN_DEBUG_BASIC)) {		\
 			xrun_log_show(substream);			\
 			if (printk_ratelimit()) {			\
 				snd_printd("PCM: " fmt, ##args);	\
 			}						\
 			dump_stack_on_xrun(substream);			\
 		}							\
 	} while (0)
 #define XRUN_LOG_CNT	10
 struct hwptr_log_entry {
 	unsigned int in_interrupt;
 	unsigned long jiffies;
 	snd_pcm_uframes_t pos;
 	snd_pcm_uframes_t period_size;
 	snd_pcm_uframes_t buffer_size;
 	snd_pcm_uframes_t old_hw_ptr;
 	snd_pcm_uframes_t hw_ptr_base;
 };
 struct snd_pcm_hwptr_log {
 	unsigned int idx;
 	unsigned int hit: 1;
 	struct hwptr_log_entry entries[XRUN_LOG_CNT];
 };
 static void xrun_log(struct snd_pcm_substream *substream,
 		     snd_pcm_uframes_t pos, int in_interrupt)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	struct snd_pcm_hwptr_log *log = runtime->hwptr_log;
 	struct hwptr_log_entry *entry;
 	if (log == NULL) {
 		log = kzalloc(sizeof(*log), GFP_ATOMIC);
 		if (log == NULL)
 			return;
 		runtime->hwptr_log = log;
 	} else {
 		if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)
 			return;
 	}
 	entry = &log->entries[log->idx];
 	entry->in_interrupt = in_interrupt;
 	entry->jiffies = jiffies;
 	entry->pos = pos;
 	entry->period_size = runtime->period_size;
 	entry->buffer_size = runtime->buffer_size;
 	entry->old_hw_ptr = runtime->status->hw_ptr;
 	entry->hw_ptr_base = runtime->hw_ptr_base;
 	log->idx = (log->idx + 1) % XRUN_LOG_CNT;
 }
 static void xrun_log_show(struct snd_pcm_substream *substream)
 {
 	struct snd_pcm_hwptr_log *log = substream->runtime->hwptr_log;
 	struct hwptr_log_entry *entry;
 	char name[16];
 	unsigned int idx;
 	int cnt;
 	if (log == NULL)
 		return;
 	if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)
 		return;
 	snd_pcm_debug_name(substream, name, sizeof(name));
 	for (cnt = 0, idx = log->idx; cnt < XRUN_LOG_CNT; cnt++) {
 		entry = &log->entries[idx];
 		if (entry->period_size == 0)
 			break;
 		snd_printd("hwptr log: %s: %sj=%lu, pos=%ld/%ld/%ld, "
 			   "hwptr=%ld/%ld\n",
 			   name, entry->in_interrupt ? "[Q] " : "",
 			   entry->jiffies,
 			   (unsigned long)entry->pos,
 			   (unsigned long)entry->period_size,
 			   (unsigned long)entry->buffer_size,
 			   (unsigned long)entry->old_hw_ptr,
 			   (unsigned long)entry->hw_ptr_base);
 		idx++;
 		idx %= XRUN_LOG_CNT;
 	}
 	log->hit = 1;
 }
 #else /* ! CONFIG_SND_PCM_XRUN_DEBUG */
 #define hw_ptr_error(substream, fmt, args...) do { } while (0)
 #define xrun_log(substream, pos, in_interrupt)	do { } while (0)
 #define xrun_log_show(substream)	do { } while (0)
 #endif
 int snd_pcm_update_state(struct snd_pcm_substream *substream,
 			 struct snd_pcm_runtime *runtime)
 {
 	snd_pcm_uframes_t avail;
 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 		avail = snd_pcm_playback_avail(runtime);
 	else
 		avail = snd_pcm_capture_avail(runtime);
 	if (avail > runtime->avail_max)
 		runtime->avail_max = avail;
 	if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
 		if (avail >= runtime->buffer_size) {
 			snd_pcm_drain_done(substream);
 			return -EPIPE;
 		}
 	} else {
 		if (avail >= runtime->stop_threshold) {
 			xrun(substream);
 			return -EPIPE;
 		}
 	}
 	if (runtime->twake) {
 		if (avail >= runtime->twake)
 			wake_up(&runtime->tsleep);
 	} else if (avail >= runtime->control->avail_min)
 		wake_up(&runtime->sleep);
 	return 0;
 }
 static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream,
 				  unsigned int in_interrupt)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	snd_pcm_uframes_t pos;
 	snd_pcm_uframes_t old_hw_ptr, new_hw_ptr, hw_base;
 	snd_pcm_sframes_t hdelta, delta;
 	unsigned long jdelta;
+	unsigned long curr_jiffies;
+	struct timespec curr_tstamp;
 	old_hw_ptr = runtime->status->hw_ptr;
+	/*
+	 * group pointer, time and jiffies reads to allow for more
+	 * accurate correlations/corrections.
+	 * The values are stored at the end of this routine after
+	 * corrections for hw_ptr position
+	 */
 	pos = substream->ops->pointer(substream);
+	curr_jiffies = jiffies;
+	if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
+		snd_pcm_gettime(runtime, (struct timespec *)&curr_tstamp);
 	if (pos == SNDRV_PCM_POS_XRUN) {
 		xrun(substream);
 		return -EPIPE;
 	}
 	if (pos >= runtime->buffer_size) {
 		if (printk_ratelimit()) {
 			char name[16];
 			snd_pcm_debug_name(substream, name, sizeof(name));
 			xrun_log_show(substream);
 			snd_printd(KERN_ERR  "BUG: %s, pos = %ld, "
 				   "buffer size = %ld, period size = %ld\n",
 				   name, pos, runtime->buffer_size,
 				   runtime->period_size);
 		}
 		pos = 0;
 	}
 	pos -= pos % runtime->min_align;
 	if (xrun_debug(substream, XRUN_DEBUG_LOG))
 		xrun_log(substream, pos, in_interrupt);
 	hw_base = runtime->hw_ptr_base;
 	new_hw_ptr = hw_base + pos;
 	if (in_interrupt) {
 		/* we know that one period was processed */
 		/* delta = "expected next hw_ptr" for in_interrupt != 0 */
 		delta = runtime->hw_ptr_interrupt + runtime->period_size;
 		if (delta > new_hw_ptr) {
 			/* check for double acknowledged interrupts */
-			hdelta = jiffies - runtime->hw_ptr_jiffies;
+			hdelta = curr_jiffies - runtime->hw_ptr_jiffies;
 			if (hdelta > runtime->hw_ptr_buffer_jiffies/2) {
 				hw_base += runtime->buffer_size;
 				if (hw_base >= runtime->boundary)
 					hw_base = 0;
 				new_hw_ptr = hw_base + pos;
 				goto __delta;
 			}
 		}
 	}
 	/* new_hw_ptr might be lower than old_hw_ptr in case when */
 	/* pointer crosses the end of the ring buffer */
 	if (new_hw_ptr < old_hw_ptr) {
 		hw_base += runtime->buffer_size;
 		if (hw_base >= runtime->boundary)
 			hw_base = 0;
 		new_hw_ptr = hw_base + pos;
 	}
       __delta:
 	delta = new_hw_ptr - old_hw_ptr;
 	if (delta < 0)
 		delta += runtime->boundary;
 	if (xrun_debug(substream, in_interrupt ?
 			XRUN_DEBUG_PERIODUPDATE : XRUN_DEBUG_HWPTRUPDATE)) {
 		char name[16];
 		snd_pcm_debug_name(substream, name, sizeof(name));
 		snd_printd("%s_update: %s: pos=%u/%u/%u, "
 			   "hwptr=%ld/%ld/%ld/%ld\n",
 			   in_interrupt ? "period" : "hwptr",
 			   name,
 			   (unsigned int)pos,
 			   (unsigned int)runtime->period_size,
 			   (unsigned int)runtime->buffer_size,
 			   (unsigned long)delta,
 			   (unsigned long)old_hw_ptr,
 			   (unsigned long)new_hw_ptr,
 			   (unsigned long)runtime->hw_ptr_base);
 	}
 	if (runtime->no_period_wakeup) {
 		snd_pcm_sframes_t xrun_threshold;
 		/*
 		 * Without regular period interrupts, we have to check
 		 * the elapsed time to detect xruns.
 		 */
-		jdelta = jiffies - runtime->hw_ptr_jiffies;
+		jdelta = curr_jiffies - runtime->hw_ptr_jiffies;
 		if (jdelta < runtime->hw_ptr_buffer_jiffies / 2)
 			goto no_delta_check;
 		hdelta = jdelta - delta * HZ / runtime->rate;
 		xrun_threshold = runtime->hw_ptr_buffer_jiffies / 2 + 1;
 		while (hdelta > xrun_threshold) {
 			delta += runtime->buffer_size;
 			hw_base += runtime->buffer_size;
 			if (hw_base >= runtime->boundary)
 				hw_base = 0;
 			new_hw_ptr = hw_base + pos;
 			hdelta -= runtime->hw_ptr_buffer_jiffies;
 		}
 		goto no_delta_check;
 	}
 	/* something must be really wrong */
 	if (delta >= runtime->buffer_size + runtime->period_size) {
 		hw_ptr_error(substream,
 			       "Unexpected hw_pointer value %s"
 			       "(stream=%i, pos=%ld, new_hw_ptr=%ld, "
 			       "old_hw_ptr=%ld)\n",
 				     in_interrupt ? "[Q] " : "[P]",
 				     substream->stream, (long)pos,
 				     (long)new_hw_ptr, (long)old_hw_ptr);
 		return 0;
 	}
 	/* Do jiffies check only in xrun_debug mode */
 	if (!xrun_debug(substream, XRUN_DEBUG_JIFFIESCHECK))
 		goto no_jiffies_check;
 	/* Skip the jiffies check for hardwares with BATCH flag.
 	 * Such hardware usually just increases the position at each IRQ,
 	 * thus it can't give any strange position.
 	 */
 	if (runtime->hw.info & SNDRV_PCM_INFO_BATCH)
 		goto no_jiffies_check;
 	hdelta = delta;
 	if (hdelta < runtime->delay)
 		goto no_jiffies_check;
 	hdelta -= runtime->delay;
-	jdelta = jiffies - runtime->hw_ptr_jiffies;
+	jdelta = curr_jiffies - runtime->hw_ptr_jiffies;
 	if (((hdelta * HZ) / runtime->rate) > jdelta + HZ/100) {
 		delta = jdelta /
 			(((runtime->period_size * HZ) / runtime->rate)
 								+ HZ/100);
 		/* move new_hw_ptr according jiffies not pos variable */
 		new_hw_ptr = old_hw_ptr;
 		hw_base = delta;
 		/* use loop to avoid checks for delta overflows */
 		/* the delta value is small or zero in most cases */
 		while (delta > 0) {
 			new_hw_ptr += runtime->period_size;
 			if (new_hw_ptr >= runtime->boundary)
 				new_hw_ptr -= runtime->boundary;
 			delta--;
 		}
 		/* align hw_base to buffer_size */
 		hw_ptr_error(substream,
 			     "hw_ptr skipping! %s"
 			     "(pos=%ld, delta=%ld, period=%ld, "
 			     "jdelta=%lu/%lu/%lu, hw_ptr=%ld/%ld)\n",
 			     in_interrupt ? "[Q] " : "",
 			     (long)pos, (long)hdelta,
 			     (long)runtime->period_size, jdelta,
 			     ((hdelta * HZ) / runtime->rate), hw_base,
 			     (unsigned long)old_hw_ptr,
 			     (unsigned long)new_hw_ptr);
 		/* reset values to proper state */
 		delta = 0;
 		hw_base = new_hw_ptr - (new_hw_ptr % runtime->buffer_size);
 	}
  no_jiffies_check:
 	if (delta > runtime->period_size + runtime->period_size / 2) {
 		hw_ptr_error(substream,
 			     "Lost interrupts? %s"
 			     "(stream=%i, delta=%ld, new_hw_ptr=%ld, "
 			     "old_hw_ptr=%ld)\n",
 			     in_interrupt ? "[Q] " : "",
 			     substream->stream, (long)delta,
 			     (long)new_hw_ptr,
 			     (long)old_hw_ptr);
 	}
  no_delta_check:
 	if (runtime->status->hw_ptr == new_hw_ptr)
 		return 0;
 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
 	    runtime->silence_size > 0)
 		snd_pcm_playback_silence(substream, new_hw_ptr);
 	if (in_interrupt) {
 		delta = new_hw_ptr - runtime->hw_ptr_interrupt;
 		if (delta < 0)
 			delta += runtime->boundary;
 		delta -= (snd_pcm_uframes_t)delta % runtime->period_size;
 		runtime->hw_ptr_interrupt += delta;
 		if (runtime->hw_ptr_interrupt >= runtime->boundary)
 			runtime->hw_ptr_interrupt -= runtime->boundary;
 	}
 	runtime->hw_ptr_base = hw_base;
 	runtime->status->hw_ptr = new_hw_ptr;
-	runtime->hw_ptr_jiffies = jiffies;
+	runtime->hw_ptr_jiffies = curr_jiffies;
 	if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
-		snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
+		runtime->status->tstamp = curr_tstamp;
 	return snd_pcm_update_state(substream, runtime);
 }
 /* CAUTION: call it with irq disabled */
 int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream)
 {
 	return snd_pcm_update_hw_ptr0(substream, 0);
 }
 /**
  * snd_pcm_set_ops - set the PCM operators
  * @pcm: the pcm instance
  * @direction: stream direction, SNDRV_PCM_STREAM_XXX
  * @ops: the operator table
  *
  * Sets the given PCM operators to the pcm instance.
  */
 void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops)
 {
 	struct snd_pcm_str *stream = &pcm->streams[direction];
 	struct snd_pcm_substream *substream;
 	for (substream = stream->substream; substream != NULL; substream = substream->next)
 		substream->ops = ops;
 }
 EXPORT_SYMBOL(snd_pcm_set_ops);
 /**
  * snd_pcm_sync - set the PCM sync id
  * @substream: the pcm substream
  *
  * Sets the PCM sync identifier for the card.
  */
 void snd_pcm_set_sync(struct snd_pcm_substream *substream)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	runtime->sync.id32[0] = substream->pcm->card->number;
 	runtime->sync.id32[1] = -1;
 	runtime->sync.id32[2] = -1;
 	runtime->sync.id32[3] = -1;
 }
 EXPORT_SYMBOL(snd_pcm_set_sync);
 /*
  *  Standard ioctl routine
  */
 static inline unsigned int div32(unsigned int a, unsigned int b,
 				 unsigned int *r)
 {
 	if (b == 0) {
 		*r = 0;
 		return UINT_MAX;
 	}
 	*r = a % b;
 	return a / b;
 }
 static inline unsigned int div_down(unsigned int a, unsigned int b)
 {
 	if (b == 0)
 		return UINT_MAX;
 	return a / b;
 }
 static inline unsigned int div_up(unsigned int a, unsigned int b)
 {
 	unsigned int r;
 	unsigned int q;
 	if (b == 0)
 		return UINT_MAX;
 	q = div32(a, b, &r);
 	if (r)
 		++q;
 	return q;
 }
 static inline unsigned int mul(unsigned int a, unsigned int b)
 {
 	if (a == 0)
 		return 0;
 	if (div_down(UINT_MAX, a) < b)
 		return UINT_MAX;
 	return a * b;
 }
 static inline unsigned int muldiv32(unsigned int a, unsigned int b,
 				    unsigned int c, unsigned int *r)
 {
 	u_int64_t n = (u_int64_t) a * b;
 	if (c == 0) {
 		snd_BUG_ON(!n);
 		*r = 0;
 		return UINT_MAX;
 	}
 	n = div_u64_rem(n, c, r);
 	if (n >= UINT_MAX) {
 		*r = 0;
 		return UINT_MAX;
 	}
 	return n;
 }
 /**
  * snd_interval_refine - refine the interval value of configurator
  * @i: the interval value to refine
  * @v: the interval value to refer to
  *
  * Refines the interval value with the reference value.
  * The interval is changed to the range satisfying both intervals.
  * The interval status (min, max, integer, etc.) are evaluated.
  *
  * Returns non-zero if the value is changed, zero if not changed.
  */
 int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v)
 {
 	int changed = 0;
 	if (snd_BUG_ON(snd_interval_empty(i)))
 		return -EINVAL;
 	if (i->min < v->min) {
 		i->min = v->min;
 		i->openmin = v->openmin;
 		changed = 1;
 	} else if (i->min == v->min && !i->openmin && v->openmin) {
 		i->openmin = 1;
 		changed = 1;
 	}
 	if (i->max > v->max) {
 		i->max = v->max;
 		i->openmax = v->openmax;
 		changed = 1;
 	} else if (i->max == v->max && !i->openmax && v->openmax) {
 		i->openmax = 1;
 		changed = 1;
 	}
 	if (!i->integer && v->integer) {
 		i->integer = 1;
 		changed = 1;
 	}
 	if (i->integer) {
 		if (i->openmin) {
 			i->min++;
 			i->openmin = 0;
 		}
 		if (i->openmax) {
 			i->max--;
 			i->openmax = 0;
 		}
 	} else if (!i->openmin && !i->openmax && i->min == i->max)
 		i->integer = 1;
 	if (snd_interval_checkempty(i)) {
 		snd_interval_none(i);
 		return -EINVAL;
 	}
 	return changed;
 }
 EXPORT_SYMBOL(snd_interval_refine);
 static int snd_interval_refine_first(struct snd_interval *i)
 {
 	if (snd_BUG_ON(snd_interval_empty(i)))
 		return -EINVAL;
 	if (snd_interval_single(i))
 		return 0;
 	i->max = i->min;
 	i->openmax = i->openmin;
 	if (i->openmax)
 		i->max++;
 	return 1;
 }
 static int snd_interval_refine_last(struct snd_interval *i)
 {
 	if (snd_BUG_ON(snd_interval_empty(i)))
 		return -EINVAL;
 	if (snd_interval_single(i))
 		return 0;
 	i->min = i->max;
 	i->openmin = i->openmax;
 	if (i->openmin)
 		i->min--;
 	return 1;
 }
 void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
 {
 	if (a->empty || b->empty) {
 		snd_interval_none(c);
 		return;
 	}
 	c->empty = 0;
 	c->min = mul(a->min, b->min);
 	c->openmin = (a->openmin || b->openmin);
 	c->max = mul(a->max,  b->max);
 	c->openmax = (a->openmax || b->openmax);
 	c->integer = (a->integer && b->integer);
 }
 /**
  * snd_interval_div - refine the interval value with division
  * @a: dividend
  * @b: divisor
  * @c: quotient
  *
  * c = a / b
  *
  * Returns non-zero if the value is changed, zero if not changed.
  */
 void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
 {
 	unsigned int r;
 	if (a->empty || b->empty) {
 		snd_interval_none(c);
 		return;
 	}
 	c->empty = 0;
 	c->min = div32(a->min, b->max, &r);
 	c->openmin = (r || a->openmin || b->openmax);
 	if (b->min > 0) {
 		c->max = div32(a->max, b->min, &r);
 		if (r) {
 			c->max++;
 			c->openmax = 1;
 		} else
 			c->openmax = (a->openmax || b->openmin);
 	} else {
 		c->max = UINT_MAX;
 		c->openmax = 0;
 	}
 	c->integer = 0;
 }
 /**
  * snd_interval_muldivk - refine the interval value
  * @a: dividend 1
  * @b: dividend 2
  * @k: divisor (as integer)
  * @c: result
   *
  * c = a * b / k
  *
  * Returns non-zero if the value is changed, zero if not changed.
  */
 void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b,
 		      unsigned int k, struct snd_interval *c)
 {
 	unsigned int r;
 	if (a->empty || b->empty) {
 		snd_interval_none(c);
 		return;
 	}
 	c->empty = 0;
 	c->min = muldiv32(a->min, b->min, k, &r);
 	c->openmin = (r || a->openmin || b->openmin);
 	c->max = muldiv32(a->max, b->max, k, &r);
 	if (r) {
 		c->max++;
 		c->openmax = 1;
 	} else
 		c->openmax = (a->openmax || b->openmax);
 	c->integer = 0;
 }
 /**
  * snd_interval_mulkdiv - refine the interval value
  * @a: dividend 1
  * @k: dividend 2 (as integer)
  * @b: divisor
  * @c: result
  *
  * c = a * k / b
  *
  * Returns non-zero if the value is changed, zero if not changed.
  */
 void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,
 		      const struct snd_interval *b, struct snd_interval *c)
 {
 	unsigned int r;
 	if (a->empty || b->empty) {
 		snd_interval_none(c);
 		return;
 	}
 	c->empty = 0;
 	c->min = muldiv32(a->min, k, b->max, &r);
 	c->openmin = (r || a->openmin || b->openmax);
 	if (b->min > 0) {
 		c->max = muldiv32(a->max, k, b->min, &r);
 		if (r) {
 			c->max++;
 			c->openmax = 1;
 		} else
 			c->openmax = (a->openmax || b->openmin);
 	} else {
 		c->max = UINT_MAX;
 		c->openmax = 0;
 	}
 	c->integer = 0;
 }
 /* ---- */
 /**
  * snd_interval_ratnum - refine the interval value
  * @i: interval to refine
  * @rats_count: number of ratnum_t
  * @rats: ratnum_t array
  * @nump: pointer to store the resultant numerator
  * @denp: pointer to store the resultant denominator
  *
  * Returns non-zero if the value is changed, zero if not changed.
  */
 int snd_interval_ratnum(struct snd_interval *i,
 			unsigned int rats_count, struct snd_ratnum *rats,
 			unsigned int *nump, unsigned int *denp)
 {
 	unsigned int best_num, best_den;
 	int best_diff;
 	unsigned int k;
 	struct snd_interval t;
 	int err;
 	unsigned int result_num, result_den;
 	int result_diff;
 	best_num = best_den = best_diff = 0;
 	for (k = 0; k < rats_count; ++k) {
 		unsigned int num = rats[k].num;
 		unsigned int den;
 		unsigned int q = i->min;
 		int diff;
 		if (q == 0)
 			q = 1;
 		den = div_up(num, q);
 		if (den < rats[k].den_min)
 			continue;
 		if (den > rats[k].den_max)
 			den = rats[k].den_max;
 		else {
 			unsigned int r;
 			r = (den - rats[k].den_min) % rats[k].den_step;
 			if (r != 0)
 				den -= r;
 		}
 		diff = num - q * den;
 		if (diff < 0)
 			diff = -diff;
 		if (best_num == 0 ||
 		    diff * best_den < best_diff * den) {
 			best_diff = diff;
 			best_den = den;
 			best_num = num;
 		}
 	}
 	if (best_den == 0) {
 		i->empty = 1;
 		return -EINVAL;
 	}
 	t.min = div_down(best_num, best_den);
 	t.openmin = !!(best_num % best_den);
 	result_num = best_num;
 	result_diff = best_diff;
 	result_den = best_den;
 	best_num = best_den = best_diff = 0;
 	for (k = 0; k < rats_count; ++k) {
 		unsigned int num = rats[k].num;
 		unsigned int den;
 		unsigned int q = i->max;
 		int diff;
 		if (q == 0) {
 			i->empty = 1;
 			return -EINVAL;
 		}
 		den = div_down(num, q);
 		if (den > rats[k].den_max)
 			continue;
 		if (den < rats[k].den_min)
 			den = rats[k].den_min;
 		else {
 			unsigned int r;
 			r = (den - rats[k].den_min) % rats[k].den_step;
 			if (r != 0)
 				den += rats[k].den_step - r;
 		}
 		diff = q * den - num;
 		if (diff < 0)
 			diff = -diff;
 		if (best_num == 0 ||
 		    diff * best_den < best_diff * den) {
 			best_diff = diff;
 			best_den = den;
 			best_num = num;
 		}
 	}
 	if (best_den == 0) {
 		i->empty = 1;
 		return -EINVAL;
 	}
 	t.max = div_up(best_num, best_den);
 	t.openmax = !!(best_num % best_den);
 	t.integer = 0;
 	err = snd_interval_refine(i, &t);
 	if (err < 0)
 		return err;
 	if (snd_interval_single(i)) {
 		if (best_diff * result_den < result_diff * best_den) {
 			result_num = best_num;
 			result_den = best_den;
 		}
 		if (nump)
 			*nump = result_num;
 		if (denp)
 			*denp = result_den;
 	}
 	return err;
 }
 EXPORT_SYMBOL(snd_interval_ratnum);
 /**
  * snd_interval_ratden - refine the interval value
  * @i: interval to refine
  * @rats_count: number of struct ratden
  * @rats: struct ratden array
  * @nump: pointer to store the resultant numerator
  * @denp: pointer to store the resultant denominator
  *
  * Returns non-zero if the value is changed, zero if not changed.
  */
 static int snd_interval_ratden(struct snd_interval *i,
 			       unsigned int rats_count, struct snd_ratden *rats,
 			       unsigned int *nump, unsigned int *denp)
 {
 	unsigned int best_num, best_diff, best_den;
 	unsigned int k;
 	struct snd_interval t;
 	int err;
 	best_num = best_den = best_diff = 0;
 	for (k = 0; k < rats_count; ++k) {
 		unsigned int num;
 		unsigned int den = rats[k].den;
 		unsigned int q = i->min;
 		int diff;
 		num = mul(q, den);
 		if (num > rats[k].num_max)
 			continue;
 		if (num < rats[k].num_min)
 			num = rats[k].num_max;
 		else {
 			unsigned int r;
 			r = (num - rats[k].num_min) % rats[k].num_step;
 			if (r != 0)
 				num += rats[k].num_step - r;
 		}
 		diff = num - q * den;
 		if (best_num == 0 ||
 		    diff * best_den < best_diff * den) {
 			best_diff = diff;
 			best_den = den;
 			best_num = num;
 		}
 	}
 	if (best_den == 0) {
 		i->empty = 1;
 		return -EINVAL;
 	}
 	t.min = div_down(best_num, best_den);
 	t.openmin = !!(best_num % best_den);
 	best_num = best_den = best_diff = 0;
 	for (k = 0; k < rats_count; ++k) {
 		unsigned int num;
 		unsigned int den = rats[k].den;
 		unsigned int q = i->max;
 		int diff;
 		num = mul(q, den);
 		if (num < rats[k].num_min)
 			continue;
 		if (num > rats[k].num_max)
 			num = rats[k].num_max;
 		else {
 			unsigned int r;
 			r = (num - rats[k].num_min) % rats[k].num_step;
 			if (r != 0)
 				num -= r;
 		}
 		diff = q * den - num;
 		if (best_num == 0 ||
 		    diff * best_den < best_diff * den) {
 			best_diff = diff;
 			best_den = den;
 			best_num = num;
 		}
 	}
 	if (best_den == 0) {
 		i->empty = 1;
 		return -EINVAL;
 	}
 	t.max = div_up(best_num, best_den);
 	t.openmax = !!(best_num % best_den);
 	t.integer = 0;
 	err = snd_interval_refine(i, &t);
 	if (err < 0)
 		return err;
 	if (snd_interval_single(i)) {
 		if (nump)
 			*nump = best_num;
 		if (denp)
 			*denp = best_den;
 	}
 	return err;
 }
 /**
  * snd_interval_list - refine the interval value from the list
  * @i: the interval value to refine
  * @count: the number of elements in the list
  * @list: the value list
  * @mask: the bit-mask to evaluate
  *
  * Refines the interval value from the list.
  * When mask is non-zero, only the elements corresponding to bit 1 are
  * evaluated.
  *
  * Returns non-zero if the value is changed, zero if not changed.
  */
 int snd_interval_list(struct snd_interval *i, unsigned int count,
 		      const unsigned int *list, unsigned int mask)
 {
         unsigned int k;
 	struct snd_interval list_range;
 	if (!count) {
 		i->empty = 1;
 		return -EINVAL;
 	}
 	snd_interval_any(&list_range);
 	list_range.min = UINT_MAX;
 	list_range.max = 0;
         for (k = 0; k < count; k++) {
 		if (mask && !(mask & (1 << k)))
 			continue;
 		if (!snd_interval_test(i, list[k]))
 			continue;
 		list_range.min = min(list_range.min, list[k]);
 		list_range.max = max(list_range.max, list[k]);
         }
 	return snd_interval_refine(i, &list_range);
 }
 EXPORT_SYMBOL(snd_interval_list);
 static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned int step)
 {
 	unsigned int n;
 	int changed = 0;
 	n = (i->min - min) % step;
 	if (n != 0 || i->openmin) {
 		i->min += step - n;
 		changed = 1;
 	}
 	n = (i->max - min) % step;
 	if (n != 0 || i->openmax) {
 		i->max -= n;
 		changed = 1;
 	}
 	if (snd_interval_checkempty(i)) {
 		i->empty = 1;
 		return -EINVAL;
 	}
 	return changed;
 }
 /* Info constraints helpers */
 /**
  * snd_pcm_hw_rule_add - add the hw-constraint rule
  * @runtime: the pcm runtime instance
  * @cond: condition bits
  * @var: the variable to evaluate
  * @func: the evaluation function
  * @private: the private data pointer passed to function
  * @dep: the dependent variables
  *
  * Returns zero if successful, or a negative error code on failure.
  */
 int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond,
 			int var,
 			snd_pcm_hw_rule_func_t func, void *private,
 			int dep, ...)
 {
 	struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
 	struct snd_pcm_hw_rule *c;
 	unsigned int k;
 	va_list args;
 	va_start(args, dep);
 	if (constrs->rules_num >= constrs->rules_all) {
 		struct snd_pcm_hw_rule *new;
 		unsigned int new_rules = constrs->rules_all + 16;
 		new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL);
 		if (!new) {
 			va_end(args);
 			return -ENOMEM;
 		}
 		if (constrs->rules) {
 			memcpy(new, constrs->rules,
 			       constrs->rules_num * sizeof(*c));
 			kfree(constrs->rules);
 		}
 		constrs->rules = new;
 		constrs->rules_all = new_rules;
 	}
 	c = &constrs->rules[constrs->rules_num];
 	c->cond = cond;
 	c->func = func;
 	c->var = var;
 	c->private = private;
 	k = 0;
 	while (1) {
 		if (snd_BUG_ON(k >= ARRAY_SIZE(c->deps))) {
 			va_end(args);
 			return -EINVAL;
 		}
 		c->deps[k++] = dep;
 		if (dep < 0)
 			break;
 		dep = va_arg(args, int);
 	}
 	constrs->rules_num++;
 	va_end(args);
 	return 0;
 }
 EXPORT_SYMBOL(snd_pcm_hw_rule_add);
 /**
  * snd_pcm_hw_constraint_mask - apply the given bitmap mask constraint
  * @runtime: PCM runtime instance
  * @var: hw_params variable to apply the mask
  * @mask: the bitmap mask
  *
  * Apply the constraint of the given bitmap mask to a 32-bit mask parameter.
  */
 int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
 			       u_int32_t mask)
 {
 	struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
 	struct snd_mask *maskp = constrs_mask(constrs, var);
 	*maskp->bits &= mask;
 	memset(maskp->bits + 1, 0, (SNDRV_MASK_MAX-32) / 8); /* clear rest */
 	if (*maskp->bits == 0)
 		return -EINVAL;
 	return 0;
 }
 /**
  * snd_pcm_hw_constraint_mask64 - apply the given bitmap mask constraint
  * @runtime: PCM runtime instance
  * @var: hw_params variable to apply the mask
  * @mask: the 64bit bitmap mask
  *
  * Apply the constraint of the given bitmap mask to a 64-bit mask parameter.
  */
 int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
 				 u_int64_t mask)
 {
 	struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
 	struct snd_mask *maskp = constrs_mask(constrs, var);
 	maskp->bits[0] &= (u_int32_t)mask;
 	maskp->bits[1] &= (u_int32_t)(mask >> 32);
 	memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */
 	if (! maskp->bits[0] && ! maskp->bits[1])
 		return -EINVAL;
 	return 0;
 }
 /**
  * snd_pcm_hw_constraint_integer - apply an integer constraint to an interval
  * @runtime: PCM runtime instance
  * @var: hw_params variable to apply the integer constraint
  *
  * Apply the constraint of integer to an interval parameter.
  */
 int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var)
 {
 	struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
 	return snd_interval_setinteger(constrs_interval(constrs, var));
 }
 EXPORT_SYMBOL(snd_pcm_hw_constraint_integer);
 /**
  * snd_pcm_hw_constraint_minmax - apply a min/max range constraint to an interval
  * @runtime: PCM runtime instance
  * @var: hw_params variable to apply the range
  * @min: the minimal value
  * @max: the maximal value
  *
  * Apply the min/max range constraint to an interval parameter.
  */
 int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
 				 unsigned int min, unsigned int max)
 {
 	struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
 	struct snd_interval t;
 	t.min = min;
 	t.max = max;
 	t.openmin = t.openmax = 0;
 	t.integer = 0;
 	return snd_interval_refine(constrs_interval(constrs, var), &t);
 }
 EXPORT_SYMBOL(snd_pcm_hw_constraint_minmax);
 static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params,
 				struct snd_pcm_hw_rule *rule)
 {
 	struct snd_pcm_hw_constraint_list *list = rule->private;
 	return snd_interval_list(hw_param_interval(params, rule->var), list->count, list->list, list->mask);
 }
 /**
  * snd_pcm_hw_constraint_list - apply a list of constraints to a parameter
  * @runtime: PCM runtime instance
  * @cond: condition bits
  * @var: hw_params variable to apply the list constraint
  * @l: list
  *
  * Apply the list of constraints to an interval parameter.
  */
 int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,
 			       unsigned int cond,
 			       snd_pcm_hw_param_t var,
 			       struct snd_pcm_hw_constraint_list *l)
 {
 	return snd_pcm_hw_rule_add(runtime, cond, var,
 				   snd_pcm_hw_rule_list, l,
 				   var, -1);
 }
 EXPORT_SYMBOL(snd_pcm_hw_constraint_list);
 static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params,
 				   struct snd_pcm_hw_rule *rule)
 {
 	struct snd_pcm_hw_constraint_ratnums *r = rule->private;
 	unsigned int num = 0, den = 0;
 	int err;
 	err = snd_interval_ratnum(hw_param_interval(params, rule->var),
 				  r->nrats, r->rats, &num, &den);
 	if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {
 		params->rate_num = num;
 		params->rate_den = den;
 	}
 	return err;
 }
 /**
  * snd_pcm_hw_constraint_ratnums - apply ratnums constraint to a parameter
  * @runtime: PCM runtime instance
  * @cond: condition bits
  * @var: hw_params variable to apply the ratnums constraint
  * @r: struct snd_ratnums constriants
  */
 int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime,
 				  unsigned int cond,
 				  snd_pcm_hw_param_t var,
 				  struct snd_pcm_hw_constraint_ratnums *r)
 {
 	return snd_pcm_hw_rule_add(runtime, cond, var,
 				   snd_pcm_hw_rule_ratnums, r,
 				   var, -1);
 }
 EXPORT_SYMBOL(snd_pcm_hw_constraint_ratnums);
 static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params,
 				   struct snd_pcm_hw_rule *rule)
 {
 	struct snd_pcm_hw_constraint_ratdens *r = rule->private;
 	unsigned int num = 0, den = 0;
 	int err = snd_interval_ratden(hw_param_interval(params, rule->var),
 				  r->nrats, r->rats, &num, &den);
 	if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {
 		params->rate_num = num;
 		params->rate_den = den;
 	}
 	return err;
 }
 /**
  * snd_pcm_hw_constraint_ratdens - apply ratdens constraint to a parameter
  * @runtime: PCM runtime instance
  * @cond: condition bits
  * @var: hw_params variable to apply the ratdens constraint
  * @r: struct snd_ratdens constriants
  */
 int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime,
 				  unsigned int cond,
 				  snd_pcm_hw_param_t var,
 				  struct snd_pcm_hw_constraint_ratdens *r)
 {
 	return snd_pcm_hw_rule_add(runtime, cond, var,
 				   snd_pcm_hw_rule_ratdens, r,
 				   var, -1);
 }
 EXPORT_SYMBOL(snd_pcm_hw_constraint_ratdens);
 static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params,
 				  struct snd_pcm_hw_rule *rule)
 {
 	unsigned int l = (unsigned long) rule->private;
 	int width = l & 0xffff;
 	unsigned int msbits = l >> 16;
 	struct snd_interval *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
 	if (snd_interval_single(i) && snd_interval_value(i) == width)
 		params->msbits = msbits;
 	return 0;
 }
 /**
  * snd_pcm_hw_constraint_msbits - add a hw constraint msbits rule
  * @runtime: PCM runtime instance
  * @cond: condition bits
  * @width: sample bits width
  * @msbits: msbits width
  */
 int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime,
 				 unsigned int cond,
 				 unsigned int width,
 				 unsigned int msbits)
 {
 	unsigned long l = (msbits << 16) | width;
 	return snd_pcm_hw_rule_add(runtime, cond, -1,
 				    snd_pcm_hw_rule_msbits,
 				    (void*) l,
 				    SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
 }
 EXPORT_SYMBOL(snd_pcm_hw_constraint_msbits);
 static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params,
 				struct snd_pcm_hw_rule *rule)
 {
 	unsigned long step = (unsigned long) rule->private;
 	return snd_interval_step(hw_param_interval(params, rule->var), 0, step);
 }
 /**
  * snd_pcm_hw_constraint_step - add a hw constraint step rule
  * @runtime: PCM runtime instance
  * @cond: condition bits
  * @var: hw_params variable to apply the step constraint
  * @step: step size
  */
 int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,
 			       unsigned int cond,
 			       snd_pcm_hw_param_t var,
 			       unsigned long step)
 {
 	return snd_pcm_hw_rule_add(runtime, cond, var,
 				   snd_pcm_hw_rule_step, (void *) step,
 				   var, -1);
 }
 EXPORT_SYMBOL(snd_pcm_hw_constraint_step);
 static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
 {
 	static unsigned int pow2_sizes[] = {
 		1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7,
 		1<<8, 1<<9, 1<<10, 1<<11, 1<<12, 1<<13, 1<<14, 1<<15,
 		1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21, 1<<22, 1<<23,
 		1<<24, 1<<25, 1<<26, 1<<27, 1<<28, 1<<29, 1<<30
 	};
 	return snd_interval_list(hw_param_interval(params, rule->var),
 				 ARRAY_SIZE(pow2_sizes), pow2_sizes, 0);
 }
 /**
  * snd_pcm_hw_constraint_pow2 - add a hw constraint power-of-2 rule
  * @runtime: PCM runtime instance
  * @cond: condition bits
  * @var: hw_params variable to apply the power-of-2 constraint
  */
 int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,
 			       unsigned int cond,
 			       snd_pcm_hw_param_t var)
 {
 	return snd_pcm_hw_rule_add(runtime, cond, var,
 				   snd_pcm_hw_rule_pow2, NULL,
 				   var, -1);
 }
 EXPORT_SYMBOL(snd_pcm_hw_constraint_pow2);
 static int snd_pcm_hw_rule_noresample_func(struct snd_pcm_hw_params *params,
 					   struct snd_pcm_hw_rule *rule)
 {
 	unsigned int base_rate = (unsigned int)(uintptr_t)rule->private;
 	struct snd_interval *rate;
 	rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
 	return snd_interval_list(rate, 1, &base_rate, 0);
 }
 /**
  * snd_pcm_hw_rule_noresample - add a rule to allow disabling hw resampling
  * @runtime: PCM runtime instance
  * @base_rate: the rate at which the hardware does not resample
  */
 int snd_pcm_hw_rule_noresample(struct snd_pcm_runtime *runtime,
 			       unsigned int base_rate)
 {
 	return snd_pcm_hw_rule_add(runtime, SNDRV_PCM_HW_PARAMS_NORESAMPLE,
 				   SNDRV_PCM_HW_PARAM_RATE,
 				   snd_pcm_hw_rule_noresample_func,
 				   (void *)(uintptr_t)base_rate,
 				   SNDRV_PCM_HW_PARAM_RATE, -1);
 }
 EXPORT_SYMBOL(snd_pcm_hw_rule_noresample);
 static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params,
 				  snd_pcm_hw_param_t var)
 {
 	if (hw_is_mask(var)) {
 		snd_mask_any(hw_param_mask(params, var));
 		params->cmask |= 1 << var;
 		params->rmask |= 1 << var;
 		return;
 	}
 	if (hw_is_interval(var)) {
 		snd_interval_any(hw_param_interval(params, var));
 		params->cmask |= 1 << var;
 		params->rmask |= 1 << var;
 		return;
 	}
 	snd_BUG();
 }
 void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params)
 {
 	unsigned int k;
 	memset(params, 0, sizeof(*params));
 	for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++)
 		_snd_pcm_hw_param_any(params, k);
 	for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++)
 		_snd_pcm_hw_param_any(params, k);
 	params->info = ~0U;
 }
 EXPORT_SYMBOL(_snd_pcm_hw_params_any);
 /**
  * snd_pcm_hw_param_value - return @params field @var value
  * @params: the hw_params instance
  * @var: parameter to retrieve
  * @dir: pointer to the direction (-1,0,1) or %NULL
  *
  * Return the value for field @var if it's fixed in configuration space
  * defined by @params. Return -%EINVAL otherwise.
  */
 int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
 			   snd_pcm_hw_param_t var, int *dir)
 {
 	if (hw_is_mask(var)) {
 		const struct snd_mask *mask = hw_param_mask_c(params, var);
 		if (!snd_mask_single(mask))
 			return -EINVAL;
 		if (dir)
 			*dir = 0;
 		return snd_mask_value(mask);
 	}
 	if (hw_is_interval(var)) {
 		const struct snd_interval *i = hw_param_interval_c(params, var);
 		if (!snd_interval_single(i))
 			return -EINVAL;
 		if (dir)
 			*dir = i->openmin;
 		return snd_interval_value(i);
 	}
 	return -EINVAL;
 }
 EXPORT_SYMBOL(snd_pcm_hw_param_value);
 void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params,
 				snd_pcm_hw_param_t var)
 {
 	if (hw_is_mask(var)) {
 		snd_mask_none(hw_param_mask(params, var));
 		params->cmask |= 1 << var;
 		params->rmask |= 1 << var;
 	} else if (hw_is_interval(var)) {
 		snd_interval_none(hw_param_interval(params, var));
 		params->cmask |= 1 << var;
 		params->rmask |= 1 << var;
 	} else {
 		snd_BUG();
 	}
 }
 EXPORT_SYMBOL(_snd_pcm_hw_param_setempty);
 static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params,
 				   snd_pcm_hw_param_t var)
 {
 	int changed;
 	if (hw_is_mask(var))
 		changed = snd_mask_refine_first(hw_param_mask(params, var));
 	else if (hw_is_interval(var))
 		changed = snd_interval_refine_first(hw_param_interval(params, var));
 	else
 		return -EINVAL;
 	if (changed) {
 		params->cmask |= 1 << var;
 		params->rmask |= 1 << var;
 	}
 	return changed;
 }
 /**
  * snd_pcm_hw_param_first - refine config space and return minimum value
  * @pcm: PCM instance
  * @params: the hw_params instance
  * @var: parameter to retrieve
  * @dir: pointer to the direction (-1,0,1) or %NULL
  *
  * Inside configuration space defined by @params remove from @var all
  * values > minimum. Reduce configuration space accordingly.
  * Return the minimum.
  */
 int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm,
 			   struct snd_pcm_hw_params *params,
 			   snd_pcm_hw_param_t var, int *dir)
 {
 	int changed = _snd_pcm_hw_param_first(params, var);
 	if (changed < 0)
 		return changed;
 	if (params->rmask) {
 		int err = snd_pcm_hw_refine(pcm, params);
 		if (snd_BUG_ON(err < 0))
 			return err;
 	}
 	return snd_pcm_hw_param_value(params, var, dir);
 }
 EXPORT_SYMBOL(snd_pcm_hw_param_first);
 static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params,
 				  snd_pcm_hw_param_t var)
 {
 	int changed;
 	if (hw_is_mask(var))
 		changed = snd_mask_refine_last(hw_param_mask(params, var));
 	else if (hw_is_interval(var))
 		changed = snd_interval_refine_last(hw_param_interval(params, var));
 	else
 		return -EINVAL;
 	if (changed) {
 		params->cmask |= 1 << var;
 		params->rmask |= 1 << var;
 	}
 	return changed;
 }
 /**
  * snd_pcm_hw_param_last - refine config space and return maximum value
  * @pcm: PCM instance
  * @params: the hw_params instance
  * @var: parameter to retrieve
  * @dir: pointer to the direction (-1,0,1) or %NULL
  *
  * Inside configuration space defined by @params remove from @var all
  * values < maximum. Reduce configuration space accordingly.
  * Return the maximum.
  */
 int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm,
 			  struct snd_pcm_hw_params *params,
 			  snd_pcm_hw_param_t var, int *dir)
 {
 	int changed = _snd_pcm_hw_param_last(params, var);
 	if (changed < 0)
 		return changed;
 	if (params->rmask) {
 		int err = snd_pcm_hw_refine(pcm, params);
 		if (snd_BUG_ON(err < 0))
 			return err;
 	}
 	return snd_pcm_hw_param_value(params, var, dir);
 }
 EXPORT_SYMBOL(snd_pcm_hw_param_last);
 /**
  * snd_pcm_hw_param_choose - choose a configuration defined by @params
  * @pcm: PCM instance
  * @params: the hw_params instance
  *
  * Choose one configuration from configuration space defined by @params.
  * The configuration chosen is that obtained fixing in this order:
  * first access, first format, first subformat, min channels,
  * min rate, min period time, max buffer size, min tick time
  */
 int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm,
 			     struct snd_pcm_hw_params *params)
 {
 	static int vars[] = {
 		SNDRV_PCM_HW_PARAM_ACCESS,
 		SNDRV_PCM_HW_PARAM_FORMAT,
 		SNDRV_PCM_HW_PARAM_SUBFORMAT,
 		SNDRV_PCM_HW_PARAM_CHANNELS,
 		SNDRV_PCM_HW_PARAM_RATE,
 		SNDRV_PCM_HW_PARAM_PERIOD_TIME,
 		SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
 		SNDRV_PCM_HW_PARAM_TICK_TIME,
 		-1
 	};
 	int err, *v;
 	for (v = vars; *v != -1; v++) {
 		if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE)
 			err = snd_pcm_hw_param_first(pcm, params, *v, NULL);
 		else
 			err = snd_pcm_hw_param_last(pcm, params, *v, NULL);
 		if (snd_BUG_ON(err < 0))
 			return err;
 	}
 	return 0;
 }
 static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream,
 				   void *arg)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	unsigned long flags;
 	snd_pcm_stream_lock_irqsave(substream, flags);
 	if (snd_pcm_running(substream) &&
 	    snd_pcm_update_hw_ptr(substream) >= 0)
 		runtime->status->hw_ptr %= runtime->buffer_size;
 	else
 		runtime->status->hw_ptr = 0;
 	snd_pcm_stream_unlock_irqrestore(substream, flags);
 	return 0;
 }
 static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream *substream,
 					  void *arg)
 {
 	struct snd_pcm_channel_info *info = arg;
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	int width;
 	if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) {
 		info->offset = -1;
 		return 0;
 	}
 	width = snd_pcm_format_physical_width(runtime->format);
 	if (width < 0)
 		return width;
 	info->offset = 0;
 	switch (runtime->access) {
 	case SNDRV_PCM_ACCESS_MMAP_INTERLEAVED:
 	case SNDRV_PCM_ACCESS_RW_INTERLEAVED:
 		info->first = info->channel * width;
 		info->step = runtime->channels * width;
 		break;
 	case SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED:
 	case SNDRV_PCM_ACCESS_RW_NONINTERLEAVED:
 	{
 		size_t size = runtime->dma_bytes / runtime->channels;
 		info->first = info->channel * size * 8;
 		info->step = width;
 		break;
 	}
 	default:
 		snd_BUG();
 		break;
 	}
 	return 0;
 }
 static int snd_pcm_lib_ioctl_fifo_size(struct snd_pcm_substream *substream,
 				       void *arg)
 {
 	struct snd_pcm_hw_params *params = arg;
 	snd_pcm_format_t format;
 	int channels, width;
 	params->fifo_size = substream->runtime->hw.fifo_size;
 	if (!(substream->runtime->hw.info & SNDRV_PCM_INFO_FIFO_IN_FRAMES)) {
 		format = params_format(params);
 		channels = params_channels(params);
 		width = snd_pcm_format_physical_width(format);
 		params->fifo_size /= width * channels;
 	}
 	return 0;
 }
 /**
  * snd_pcm_lib_ioctl - a generic PCM ioctl callback
  * @substream: the pcm substream instance
  * @cmd: ioctl command
  * @arg: ioctl argument
  *
  * Processes the generic ioctl commands for PCM.
  * Can be passed as the ioctl callback for PCM ops.
  *
  * Returns zero if successful, or a negative error code on failure.
  */
 int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
 		      unsigned int cmd, void *arg)
 {
 	switch (cmd) {
 	case SNDRV_PCM_IOCTL1_INFO:
 		return 0;
 	case SNDRV_PCM_IOCTL1_RESET:
 		return snd_pcm_lib_ioctl_reset(substream, arg);
 	case SNDRV_PCM_IOCTL1_CHANNEL_INFO:
 		return snd_pcm_lib_ioctl_channel_info(substream, arg);
 	case SNDRV_PCM_IOCTL1_FIFO_SIZE:
 		return snd_pcm_lib_ioctl_fifo_size(substream, arg);
 	}
 	return -ENXIO;
 }
 EXPORT_SYMBOL(snd_pcm_lib_ioctl);
 /**
  * snd_pcm_period_elapsed - update the pcm status for the next period
  * @substream: the pcm substream instance
  *
  * This function is called from the interrupt handler when the
  * PCM has processed the period size.  It will update the current
  * pointer, wake up sleepers, etc.
  *
  * Even if more than one periods have elapsed since the last call, you
  * have to call this only once.
  */
 void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
 {
 	struct snd_pcm_runtime *runtime;
 	unsigned long flags;
 	if (PCM_RUNTIME_CHECK(substream))
 		return;
 	runtime = substream->runtime;
 	if (runtime->transfer_ack_begin)
 		runtime->transfer_ack_begin(substream);
 	snd_pcm_stream_lock_irqsave(substream, flags);
 	if (!snd_pcm_running(substream) ||
 	    snd_pcm_update_hw_ptr0(substream, 1) < 0)
 		goto _end;
 	if (substream->timer_running)
 		snd_timer_interrupt(substream->timer, 1);
  _end:
 	snd_pcm_stream_unlock_irqrestore(substream, flags);
 	if (runtime->transfer_ack_end)
 		runtime->transfer_ack_end(substream);
 	kill_fasync(&runtime->fasync, SIGIO, POLL_IN);
 }
 EXPORT_SYMBOL(snd_pcm_period_elapsed);
 /*
  * Wait until avail_min data becomes available
  * Returns a negative error code if any error occurs during operation.
  * The available space is stored on availp.  When err = 0 and avail = 0
  * on the capture stream, it indicates the stream is in DRAINING state.
  */
 static int wait_for_avail(struct snd_pcm_substream *substream,
 			      snd_pcm_uframes_t *availp)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	int is_playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
 	wait_queue_t wait;
 	int err = 0;
 	snd_pcm_uframes_t avail = 0;
 	long wait_time, tout;
 	init_waitqueue_entry(&wait, current);
 	set_current_state(TASK_INTERRUPTIBLE);
 	add_wait_queue(&runtime->tsleep, &wait);
 	if (runtime->no_period_wakeup)
 		wait_time = MAX_SCHEDULE_TIMEOUT;
 	else {
 		wait_time = 10;
 		if (runtime->rate) {
 			long t = runtime->period_size * 2 / runtime->rate;
 			wait_time = max(t, wait_time);
 		}
 		wait_time = msecs_to_jiffies(wait_time * 1000);
 	}
 	for (;;) {
 		if (signal_pending(current)) {
 			err = -ERESTARTSYS;
 			break;
 		}
 		/*
 		 * We need to check if space became available already
 		 * (and thus the wakeup happened already) first to close
 		 * the race of space already having become available.
 		 * This check must happen after been added to the waitqueue
 		 * and having current state be INTERRUPTIBLE.
 		 */
 		if (is_playback)
 			avail = snd_pcm_playback_avail(runtime);
 		else
 			avail = snd_pcm_capture_avail(runtime);
 		if (avail >= runtime->twake)
 			break;
 		snd_pcm_stream_unlock_irq(substream);
 		tout = schedule_timeout(wait_time);
 		snd_pcm_stream_lock_irq(substream);
 		set_current_state(TASK_INTERRUPTIBLE);
 		switch (runtime->status->state) {
 		case SNDRV_PCM_STATE_SUSPENDED:
 			err = -ESTRPIPE;
 			goto _endloop;
 		case SNDRV_PCM_STATE_XRUN:
 			err = -EPIPE;
 			goto _endloop;
 		case SNDRV_PCM_STATE_DRAINING:
 			if (is_playback)
 				err = -EPIPE;
 			else
 				avail = 0; /* indicate draining */
 			goto _endloop;
 		case SNDRV_PCM_STATE_OPEN:
 		case SNDRV_PCM_STATE_SETUP:
 		case SNDRV_PCM_STATE_DISCONNECTED:
 			err = -EBADFD;
 			goto _endloop;
 		}
 		if (!tout) {
 			snd_printd("%s write error (DMA or IRQ trouble?)\n",
 				   is_playback ? "playback" : "capture");
 			err = -EIO;
 			break;
 		}
 	}
  _endloop:
 	set_current_state(TASK_RUNNING);
 	remove_wait_queue(&runtime->tsleep, &wait);
 	*availp = avail;
 	return err;
 }
 static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream,
 				      unsigned int hwoff,
 				      unsigned long data, unsigned int off,
 				      snd_pcm_uframes_t frames)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	int err;
 	char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);
 	if (substream->ops->copy) {
 		if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)
 			return err;
 	} else {
 		char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);
 		if (copy_from_user(hwbuf, buf, frames_to_bytes(runtime, frames)))
 			return -EFAULT;
 	}
 	return 0;
 }
 typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff,
 			  unsigned long data, unsigned int off,
 			  snd_pcm_uframes_t size);
 static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
 					    unsigned long data,
 					    snd_pcm_uframes_t size,
 					    int nonblock,
 					    transfer_f transfer)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	snd_pcm_uframes_t xfer = 0;
 	snd_pcm_uframes_t offset = 0;
 	snd_pcm_uframes_t avail;
 	int err = 0;
 	if (size == 0)
 		return 0;
 	snd_pcm_stream_lock_irq(substream);
 	switch (runtime->status->state) {
 	case SNDRV_PCM_STATE_PREPARED:
 	case SNDRV_PCM_STATE_RUNNING:
 	case SNDRV_PCM_STATE_PAUSED:
 		break;
 	case SNDRV_PCM_STATE_XRUN:
 		err = -EPIPE;
 		goto _end_unlock;
 	case SNDRV_PCM_STATE_SUSPENDED:
 		err = -ESTRPIPE;
 		goto _end_unlock;
 	default:
 		err = -EBADFD;
 		goto _end_unlock;
 	}
 	runtime->twake = runtime->control->avail_min ? : 1;
 	if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
 		snd_pcm_update_hw_ptr(substream);
 	avail = snd_pcm_playback_avail(runtime);
 	while (size > 0) {
 		snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
 		snd_pcm_uframes_t cont;
 		if (!avail) {
 			if (nonblock) {
 				err = -EAGAIN;
 				goto _end_unlock;
 			}
 			runtime->twake = min_t(snd_pcm_uframes_t, size,
 					runtime->control->avail_min ? : 1);
 			err = wait_for_avail(substream, &avail);
 			if (err < 0)
 				goto _end_unlock;
 		}
 		frames = size > avail ? avail : size;
 		cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
 		if (frames > cont)
 			frames = cont;
 		if (snd_BUG_ON(!frames)) {
 			runtime->twake = 0;
 			snd_pcm_stream_unlock_irq(substream);
 			return -EINVAL;
 		}
 		appl_ptr = runtime->control->appl_ptr;
 		appl_ofs = appl_ptr % runtime->buffer_size;
 		snd_pcm_stream_unlock_irq(substream);
 		err = transfer(substream, appl_ofs, data, offset, frames);
 		snd_pcm_stream_lock_irq(substream);
 		if (err < 0)
 			goto _end_unlock;
 		switch (runtime->status->state) {
 		case SNDRV_PCM_STATE_XRUN:
 			err = -EPIPE;
 			goto _end_unlock;
 		case SNDRV_PCM_STATE_SUSPENDED:
 			err = -ESTRPIPE;
 			goto _end_unlock;
 		default:
 			break;
 		}
 		appl_ptr += frames;
 		if (appl_ptr >= runtime->boundary)
 			appl_ptr -= runtime->boundary;
 		runtime->control->appl_ptr = appl_ptr;
 		if (substream->ops->ack)
 			substream->ops->ack(substream);
 		offset += frames;
 		size -= frames;
 		xfer += frames;
 		avail -= frames;
 		if (runtime->status->state == SNDRV_PCM_STATE_PREPARED &&
 		    snd_pcm_playback_hw_avail(runtime) >= (snd_pcm_sframes_t)runtime->start_threshold) {
 			err = snd_pcm_start(substream);
 			if (err < 0)
 				goto _end_unlock;
 		}
 	}
  _end_unlock:
 	runtime->twake = 0;
 	if (xfer > 0 && err >= 0)
 		snd_pcm_update_state(substream, runtime);
 	snd_pcm_stream_unlock_irq(substream);
 	return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
 }
 /* sanity-check for read/write methods */
 static int pcm_sanity_check(struct snd_pcm_substream *substream)
 {
 	struct snd_pcm_runtime *runtime;
 	if (PCM_RUNTIME_CHECK(substream))
 		return -ENXIO;
 	runtime = substream->runtime;
 	if (snd_BUG_ON(!substream->ops->copy && !runtime->dma_area))
 		return -EINVAL;
 	if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
 		return -EBADFD;
 	return 0;
 }
 snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size)
 {
 	struct snd_pcm_runtime *runtime;
 	int nonblock;
 	int err;
 	err = pcm_sanity_check(substream);
 	if (err < 0)
 		return err;
 	runtime = substream->runtime;
 	nonblock = !!(substream->f_flags & O_NONBLOCK);
 	if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED &&
 	    runtime->channels > 1)
 		return -EINVAL;
 	return snd_pcm_lib_write1(substream, (unsigned long)buf, size, nonblock,
 				  snd_pcm_lib_write_transfer);
 }
 EXPORT_SYMBOL(snd_pcm_lib_write);
 static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream,
 				       unsigned int hwoff,
 				       unsigned long data, unsigned int off,
 				       snd_pcm_uframes_t frames)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	int err;
 	void __user **bufs = (void __user **)data;
 	int channels = runtime->channels;
 	int c;
 	if (substream->ops->copy) {
 		if (snd_BUG_ON(!substream->ops->silence))
 			return -EINVAL;
 		for (c = 0; c < channels; ++c, ++bufs) {
 			if (*bufs == NULL) {
 				if ((err = substream->ops->silence(substream, c, hwoff, frames)) < 0)
 					return err;
 			} else {
 				char __user *buf = *bufs + samples_to_bytes(runtime, off);
 				if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)
 					return err;
 			}
 		}
 	} else {
 		/* default transfer behaviour */
 		size_t dma_csize = runtime->dma_bytes / channels;
 		for (c = 0; c < channels; ++c, ++bufs) {
 			char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);
 			if (*bufs == NULL) {
 				snd_pcm_format_set_silence(runtime->format, hwbuf, frames);
 			} else {
 				char __user *buf = *bufs + samples_to_bytes(runtime, off);
 				if (copy_from_user(hwbuf, buf, samples_to_bytes(runtime, frames)))
 					return -EFAULT;
 			}
 		}
 	}
 	return 0;
 }
 snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,
 				     void __user **bufs,
 				     snd_pcm_uframes_t frames)
 {
 	struct snd_pcm_runtime *runtime;
 	int nonblock;
 	int err;
 	err = pcm_sanity_check(substream);
 	if (err < 0)
 		return err;
 	runtime = substream->runtime;
 	nonblock = !!(substream->f_flags & O_NONBLOCK);
 	if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
 		return -EINVAL;
 	return snd_pcm_lib_write1(substream, (unsigned long)bufs, frames,
 				  nonblock, snd_pcm_lib_writev_transfer);
 }
 EXPORT_SYMBOL(snd_pcm_lib_writev);
 static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream,
 				     unsigned int hwoff,
 				     unsigned long data, unsigned int off,
 				     snd_pcm_uframes_t frames)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	int err;
 	char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);
 	if (substream->ops->copy) {
 		if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)
 			return err;
 	} else {
 		char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);
 		if (copy_to_user(buf, hwbuf, frames_to_bytes(runtime, frames)))
 			return -EFAULT;
 	}
 	return 0;
 }
 static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
 					   unsigned long data,
 					   snd_pcm_uframes_t size,
 					   int nonblock,
 					   transfer_f transfer)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	snd_pcm_uframes_t xfer = 0;
 	snd_pcm_uframes_t offset = 0;
 	snd_pcm_uframes_t avail;
 	int err = 0;
 	if (size == 0)
 		return 0;
 	snd_pcm_stream_lock_irq(substream);
 	switch (runtime->status->state) {
 	case SNDRV_PCM_STATE_PREPARED:
 		if (size >= runtime->start_threshold) {
 			err = snd_pcm_start(substream);
 			if (err < 0)
 				goto _end_unlock;
 		}
 		break;
 	case SNDRV_PCM_STATE_DRAINING:
 	case SNDRV_PCM_STATE_RUNNING:
 	case SNDRV_PCM_STATE_PAUSED:
 		break;
 	case SNDRV_PCM_STATE_XRUN:
 		err = -EPIPE;
 		goto _end_unlock;
 	case SNDRV_PCM_STATE_SUSPENDED:
 		err = -ESTRPIPE;
 		goto _end_unlock;
 	default:
 		err = -EBADFD;
 		goto _end_unlock;
 	}
 	runtime->twake = runtime->control->avail_min ? : 1;
 	if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
 		snd_pcm_update_hw_ptr(substream);
 	avail = snd_pcm_capture_avail(runtime);
 	while (size > 0) {
 		snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
 		snd_pcm_uframes_t cont;
 		if (!avail) {
 			if (runtime->status->state ==
 			    SNDRV_PCM_STATE_DRAINING) {
 				snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
 				goto _end_unlock;
 			}
 			if (nonblock) {
 				err = -EAGAIN;
 				goto _end_unlock;
 			}
 			runtime->twake = min_t(snd_pcm_uframes_t, size,
 					runtime->control->avail_min ? : 1);
 			err = wait_for_avail(substream, &avail);
 			if (err < 0)
 				goto _end_unlock;
 			if (!avail)
 				continue; /* draining */
 		}
 		frames = size > avail ? avail : size;
 		cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
 		if (frames > cont)
 			frames = cont;
 		if (snd_BUG_ON(!frames)) {
 			runtime->twake = 0;
 			snd_pcm_stream_unlock_irq(substream);
 			return -EINVAL;
 		}
 		appl_ptr = runtime->control->appl_ptr;
 		appl_ofs = appl_ptr % runtime->buffer_size;
 		snd_pcm_stream_unlock_irq(substream);
 		err = transfer(substream, appl_ofs, data, offset, frames);
 		snd_pcm_stream_lock_irq(substream);
 		if (err < 0)
 			goto _end_unlock;
 		switch (runtime->status->state) {
 		case SNDRV_PCM_STATE_XRUN:
 			err = -EPIPE;
 			goto _end_unlock;
 		case SNDRV_PCM_STATE_SUSPENDED:
 			err = -ESTRPIPE;
 			goto _end_unlock;
 		default:
 			break;
 		}
 		appl_ptr += frames;
 		if (appl_ptr >= runtime->boundary)
 			appl_ptr -= runtime->boundary;
 		runtime->control->appl_ptr = appl_ptr;
 		if (substream->ops->ack)
 			substream->ops->ack(substream);
 		offset += frames;
 		size -= frames;
 		xfer += frames;
 		avail -= frames;
 	}
  _end_unlock:
 	runtime->twake = 0;
 	if (xfer > 0 && err >= 0)
 		snd_pcm_update_state(substream, runtime);
 	snd_pcm_stream_unlock_irq(substream);
 	return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
 }
 snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __user *buf, snd_pcm_uframes_t size)
 {
 	struct snd_pcm_runtime *runtime;
 	int nonblock;
 	int err;
 	err = pcm_sanity_check(substream);
 	if (err < 0)
 		return err;
 	runtime = substream->runtime;
 	nonblock = !!(substream->f_flags & O_NONBLOCK);
 	if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED)
 		return -EINVAL;
 	return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer);
 }
 EXPORT_SYMBOL(snd_pcm_lib_read);
 static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream,
 				      unsigned int hwoff,
 				      unsigned long data, unsigned int off,
 				      snd_pcm_uframes_t frames)
 {
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	int err;
 	void __user **bufs = (void __user **)data;
 	int channels = runtime->channels;
 	int c;
 	if (substream->ops->copy) {
 		for (c = 0; c < channels; ++c, ++bufs) {
 			char __user *buf;
 			if (*bufs == NULL)
 				continue;
 			buf = *bufs + samples_to_bytes(runtime, off);
 			if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)
 				return err;
 		}
 	} else {
 		snd_pcm_uframes_t dma_csize = runtime->dma_bytes / channels;
 		for (c = 0; c < channels; ++c, ++bufs) {
 			char *hwbuf;
 			char __user *buf;
 			if (*bufs == NULL)
 				continue;
 			hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);
 			buf = *bufs + samples_to_bytes(runtime, off);
 			if (copy_to_user(buf, hwbuf, samples_to_bytes(runtime, frames)))
 				return -EFAULT;
 		}
 	}
 	return 0;
 }
 snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,
 				    void __user **bufs,
 				    snd_pcm_uframes_t frames)
 {
 	struct snd_pcm_runtime *runtime;
 	int nonblock;
 	int err;
 	err = pcm_sanity_check(substream);
 	if (err < 0)
 		return err;
 	runtime = substream->runtime;
 	if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
 		return -EBADFD;
 	nonblock = !!(substream->f_flags & O_NONBLOCK);
 	if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
 		return -EINVAL;
 	return snd_pcm_lib_read1(substream, (unsigned long)bufs, frames, nonblock, snd_pcm_lib_readv_transfer);
 }
 EXPORT_SYMBOL(snd_pcm_lib_readv);