File Index
Files and directories
Sign in
FILE

lx6464es.c

File preview with syntax highlighting.

linux-6.19.14/sound/pci/lx6464es/lx6464es.c C 
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/* -*- linux-c -*- *
   3 *
   4 * ALSA driver for the digigram lx6464es interface
   5 *
   6 * Copyright (c) 2008, 2009 Tim Blechmann <tim@klingt.org>
   7 */
   8
   9#include <linux/module.h>
  10#include <linux/init.h>
  11#include <linux/pci.h>
  12#include <linux/delay.h>
  13#include <linux/slab.h>
  14
  15#include <sound/initval.h>
  16#include <sound/control.h>
  17#include <sound/info.h>
  18
  19#include "lx6464es.h"
  20
  21MODULE_AUTHOR("Tim Blechmann");
  22MODULE_LICENSE("GPL");
  23MODULE_DESCRIPTION("digigram lx6464es");
  24
  25static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
  26static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
  27static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
  28
  29module_param_array(index, int, NULL, 0444);
  30MODULE_PARM_DESC(index, "Index value for Digigram LX6464ES interface.");
  31module_param_array(id, charp, NULL, 0444);
  32MODULE_PARM_DESC(id, "ID string for  Digigram LX6464ES interface.");
  33module_param_array(enable, bool, NULL, 0444);
  34MODULE_PARM_DESC(enable, "Enable/disable specific Digigram LX6464ES soundcards.");
  35
  36static const char card_name[] = "LX6464ES";
  37
  38
  39#define PCI_DEVICE_ID_PLX_LX6464ES		PCI_DEVICE_ID_PLX_9056
  40
  41static const struct pci_device_id snd_lx6464es_ids[] = {
  42	{ PCI_DEVICE_SUB(PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_LX6464ES,
  43			 PCI_VENDOR_ID_DIGIGRAM,
  44			 PCI_SUBDEVICE_ID_DIGIGRAM_LX6464ES_SERIAL_SUBSYSTEM),
  45	},			/* LX6464ES */
  46	{ PCI_DEVICE_SUB(PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_LX6464ES,
  47			 PCI_VENDOR_ID_DIGIGRAM,
  48			 PCI_SUBDEVICE_ID_DIGIGRAM_LX6464ES_CAE_SERIAL_SUBSYSTEM),
  49	},			/* LX6464ES-CAE */
  50	{ PCI_DEVICE_SUB(PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_LX6464ES,
  51			 PCI_VENDOR_ID_DIGIGRAM,
  52			 PCI_SUBDEVICE_ID_DIGIGRAM_LX6464ESE_SERIAL_SUBSYSTEM),
  53	},			/* LX6464ESe */
  54	{ PCI_DEVICE_SUB(PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_LX6464ES,
  55			 PCI_VENDOR_ID_DIGIGRAM,
  56			 PCI_SUBDEVICE_ID_DIGIGRAM_LX6464ESE_CAE_SERIAL_SUBSYSTEM),
  57	},			/* LX6464ESe-CAE */
  58	{ 0, },
  59};
  60
  61MODULE_DEVICE_TABLE(pci, snd_lx6464es_ids);
  62
  63
  64
  65/* PGO pour USERo dans le registre pci_0x06/loc_0xEC */
  66#define CHIPSC_RESET_XILINX (1L<<16)
  67
  68
  69/* alsa callbacks */
  70static const struct snd_pcm_hardware lx_caps = {
  71	.info             = (SNDRV_PCM_INFO_MMAP |
  72			     SNDRV_PCM_INFO_INTERLEAVED |
  73			     SNDRV_PCM_INFO_MMAP_VALID |
  74			     SNDRV_PCM_INFO_SYNC_START),
  75	.formats	  = (SNDRV_PCM_FMTBIT_S16_LE |
  76			     SNDRV_PCM_FMTBIT_S16_BE |
  77			     SNDRV_PCM_FMTBIT_S24_3LE |
  78			     SNDRV_PCM_FMTBIT_S24_3BE),
  79	.rates            = (SNDRV_PCM_RATE_CONTINUOUS |
  80			     SNDRV_PCM_RATE_8000_192000),
  81	.rate_min         = 8000,
  82	.rate_max         = 192000,
  83	.channels_min     = 2,
  84	.channels_max     = 64,
  85	.buffer_bytes_max = 64*2*3*MICROBLAZE_IBL_MAX*MAX_STREAM_BUFFER,
  86	.period_bytes_min = (2*2*MICROBLAZE_IBL_MIN*2),
  87	.period_bytes_max = (4*64*MICROBLAZE_IBL_MAX*MAX_STREAM_BUFFER),
  88	.periods_min      = 2,
  89	.periods_max      = MAX_STREAM_BUFFER,
  90};
  91
  92static int lx_set_granularity(struct lx6464es *chip, u32 gran);
  93
  94
  95static int lx_hardware_open(struct lx6464es *chip,
  96			    struct snd_pcm_substream *substream)
  97{
  98	int err = 0;
  99	struct snd_pcm_runtime *runtime = substream->runtime;
 100	int channels = runtime->channels;
 101	int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
 102
 103	snd_pcm_uframes_t period_size = runtime->period_size;
 104
 105	dev_dbg(chip->card->dev, "allocating pipe for %d channels\n", channels);
 106	err = lx_pipe_allocate(chip, 0, is_capture, channels);
 107	if (err < 0) {
 108		dev_err(chip->card->dev, LXP "allocating pipe failed\n");
 109		return err;
 110	}
 111
 112	err = lx_set_granularity(chip, period_size);
 113	if (err < 0) {
 114		dev_err(chip->card->dev, "setting granularity to %ld failed\n",
 115			   period_size);
 116		return err;
 117	}
 118
 119	return 0;
 120}
 121
 122static int lx_hardware_start(struct lx6464es *chip,
 123			     struct snd_pcm_substream *substream)
 124{
 125	int err = 0;
 126	struct snd_pcm_runtime *runtime = substream->runtime;
 127	int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
 128
 129	dev_dbg(chip->card->dev, "setting stream format\n");
 130	err = lx_stream_set_format(chip, runtime, 0, is_capture);
 131	if (err < 0) {
 132		dev_err(chip->card->dev, "setting stream format failed\n");
 133		return err;
 134	}
 135
 136	dev_dbg(chip->card->dev, "starting pipe\n");
 137	err = lx_pipe_start(chip, 0, is_capture);
 138	if (err < 0) {
 139		dev_err(chip->card->dev, "starting pipe failed\n");
 140		return err;
 141	}
 142
 143	dev_dbg(chip->card->dev, "waiting for pipe to start\n");
 144	err = lx_pipe_wait_for_start(chip, 0, is_capture);
 145	if (err < 0) {
 146		dev_err(chip->card->dev, "waiting for pipe failed\n");
 147		return err;
 148	}
 149
 150	return err;
 151}
 152
 153
 154static int lx_hardware_stop(struct lx6464es *chip,
 155			    struct snd_pcm_substream *substream)
 156{
 157	int err = 0;
 158	int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
 159
 160	dev_dbg(chip->card->dev, "pausing pipe\n");
 161	err = lx_pipe_pause(chip, 0, is_capture);
 162	if (err < 0) {
 163		dev_err(chip->card->dev, "pausing pipe failed\n");
 164		return err;
 165	}
 166
 167	dev_dbg(chip->card->dev, "waiting for pipe to become idle\n");
 168	err = lx_pipe_wait_for_idle(chip, 0, is_capture);
 169	if (err < 0) {
 170		dev_err(chip->card->dev, "waiting for pipe failed\n");
 171		return err;
 172	}
 173
 174	dev_dbg(chip->card->dev, "stopping pipe\n");
 175	err = lx_pipe_stop(chip, 0, is_capture);
 176	if (err < 0) {
 177		dev_err(chip->card->dev, "stopping pipe failed\n");
 178		return err;
 179	}
 180
 181	return err;
 182}
 183
 184
 185static int lx_hardware_close(struct lx6464es *chip,
 186			     struct snd_pcm_substream *substream)
 187{
 188	int err = 0;
 189	int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
 190
 191	dev_dbg(chip->card->dev, "releasing pipe\n");
 192	err = lx_pipe_release(chip, 0, is_capture);
 193	if (err < 0) {
 194		dev_err(chip->card->dev, "releasing pipe failed\n");
 195		return err;
 196	}
 197
 198	return err;
 199}
 200
 201
 202static int lx_pcm_open(struct snd_pcm_substream *substream)
 203{
 204	struct lx6464es *chip = snd_pcm_substream_chip(substream);
 205	struct snd_pcm_runtime *runtime = substream->runtime;
 206	int err = 0;
 207	int board_rate;
 208
 209	dev_dbg(chip->card->dev, "->lx_pcm_open\n");
 210	guard(mutex)(&chip->setup_mutex);
 211
 212	/* copy the struct snd_pcm_hardware struct */
 213	runtime->hw = lx_caps;
 214
 215#if 0
 216	/* buffer-size should better be multiple of period-size */
 217	err = snd_pcm_hw_constraint_integer(runtime,
 218					    SNDRV_PCM_HW_PARAM_PERIODS);
 219	if (err < 0) {
 220		dev_warn(chip->card->dev, "could not constrain periods\n");
 221		return err;
 222	}
 223#endif
 224
 225	/* the clock rate cannot be changed */
 226	board_rate = chip->board_sample_rate;
 227	err = snd_pcm_hw_constraint_single(runtime, SNDRV_PCM_HW_PARAM_RATE,
 228					   board_rate);
 229
 230	if (err < 0) {
 231		dev_warn(chip->card->dev, "could not constrain periods\n");
 232		return err;
 233	}
 234
 235	/* constrain period size */
 236	err = snd_pcm_hw_constraint_minmax(runtime,
 237					   SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
 238					   MICROBLAZE_IBL_MIN,
 239					   MICROBLAZE_IBL_MAX);
 240	if (err < 0) {
 241		dev_warn(chip->card->dev,
 242			   "could not constrain period size\n");
 243		return err;
 244	}
 245
 246	snd_pcm_hw_constraint_step(runtime, 0,
 247				   SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 32);
 248
 249	snd_pcm_set_sync(substream);
 250	err = 0;
 251
 252	runtime->private_data = chip;
 253
 254	dev_dbg(chip->card->dev, "<-lx_pcm_open, %d\n", err);
 255	return err;
 256}
 257
 258static int lx_pcm_close(struct snd_pcm_substream *substream)
 259{
 260	dev_dbg(substream->pcm->card->dev, "->lx_pcm_close\n");
 261	return 0;
 262}
 263
 264static snd_pcm_uframes_t lx_pcm_stream_pointer(struct snd_pcm_substream
 265					       *substream)
 266{
 267	struct lx6464es *chip = snd_pcm_substream_chip(substream);
 268	snd_pcm_uframes_t pos;
 269	int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
 270
 271	struct lx_stream *lx_stream = is_capture ? &chip->capture_stream :
 272		&chip->playback_stream;
 273
 274	dev_dbg(chip->card->dev, "->lx_pcm_stream_pointer\n");
 275
 276	guard(mutex)(&chip->lock);
 277	pos = lx_stream->frame_pos * substream->runtime->period_size;
 278
 279	dev_dbg(chip->card->dev, "stream_pointer at %ld\n", pos);
 280	return pos;
 281}
 282
 283static int lx_pcm_prepare(struct snd_pcm_substream *substream)
 284{
 285	struct lx6464es *chip = snd_pcm_substream_chip(substream);
 286	int err = 0;
 287	const int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
 288
 289	dev_dbg(chip->card->dev, "->lx_pcm_prepare\n");
 290
 291	guard(mutex)(&chip->setup_mutex);
 292
 293	if (chip->hardware_running[is_capture]) {
 294		err = lx_hardware_stop(chip, substream);
 295		if (err < 0) {
 296			dev_err(chip->card->dev, "failed to stop hardware. "
 297				   "Error code %d\n", err);
 298			return err;
 299		}
 300
 301		err = lx_hardware_close(chip, substream);
 302		if (err < 0) {
 303			dev_err(chip->card->dev, "failed to close hardware. "
 304				   "Error code %d\n", err);
 305			return err;
 306		}
 307	}
 308
 309	dev_dbg(chip->card->dev, "opening hardware\n");
 310	err = lx_hardware_open(chip, substream);
 311	if (err < 0) {
 312		dev_err(chip->card->dev, "failed to open hardware. "
 313			   "Error code %d\n", err);
 314		return err;
 315	}
 316
 317	err = lx_hardware_start(chip, substream);
 318	if (err < 0) {
 319		dev_err(chip->card->dev, "failed to start hardware. "
 320			   "Error code %d\n", err);
 321		return err;
 322	}
 323
 324	chip->hardware_running[is_capture] = 1;
 325
 326	if (chip->board_sample_rate != substream->runtime->rate) {
 327		if (!err)
 328			chip->board_sample_rate = substream->runtime->rate;
 329	}
 330
 331	return err;
 332}
 333
 334static int lx_pcm_hw_params(struct snd_pcm_substream *substream,
 335			    struct snd_pcm_hw_params *hw_params, int is_capture)
 336{
 337	struct lx6464es *chip = snd_pcm_substream_chip(substream);
 338
 339	dev_dbg(chip->card->dev, "->lx_pcm_hw_params\n");
 340
 341	guard(mutex)(&chip->setup_mutex);
 342
 343	if (is_capture)
 344		chip->capture_stream.stream = substream;
 345	else
 346		chip->playback_stream.stream = substream;
 347
 348	return 0;
 349}
 350
 351static int lx_pcm_hw_params_playback(struct snd_pcm_substream *substream,
 352				 struct snd_pcm_hw_params *hw_params)
 353{
 354	return lx_pcm_hw_params(substream, hw_params, 0);
 355}
 356
 357static int lx_pcm_hw_params_capture(struct snd_pcm_substream *substream,
 358				 struct snd_pcm_hw_params *hw_params)
 359{
 360	return lx_pcm_hw_params(substream, hw_params, 1);
 361}
 362
 363static int lx_pcm_hw_free(struct snd_pcm_substream *substream)
 364{
 365	struct lx6464es *chip = snd_pcm_substream_chip(substream);
 366	int err = 0;
 367	int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
 368
 369	dev_dbg(chip->card->dev, "->lx_pcm_hw_free\n");
 370	guard(mutex)(&chip->setup_mutex);
 371
 372	if (chip->hardware_running[is_capture]) {
 373		err = lx_hardware_stop(chip, substream);
 374		if (err < 0) {
 375			dev_err(chip->card->dev, "failed to stop hardware. "
 376				   "Error code %d\n", err);
 377			return err;
 378		}
 379
 380		err = lx_hardware_close(chip, substream);
 381		if (err < 0) {
 382			dev_err(chip->card->dev, "failed to close hardware. "
 383				   "Error code %d\n", err);
 384			return err;
 385		}
 386
 387		chip->hardware_running[is_capture] = 0;
 388	}
 389
 390	if (is_capture)
 391		chip->capture_stream.stream = NULL;
 392	else
 393		chip->playback_stream.stream = NULL;
 394
 395	return 0;
 396}
 397
 398static void lx_trigger_start(struct lx6464es *chip, struct lx_stream *lx_stream)
 399{
 400	struct snd_pcm_substream *substream = lx_stream->stream;
 401	const unsigned int is_capture = lx_stream->is_capture;
 402
 403	int err;
 404
 405	const u32 channels = substream->runtime->channels;
 406	const u32 bytes_per_frame = channels * 3;
 407	const u32 period_size = substream->runtime->period_size;
 408	const u32 periods = substream->runtime->periods;
 409	const u32 period_bytes = period_size * bytes_per_frame;
 410
 411	dma_addr_t buf = substream->dma_buffer.addr;
 412	int i;
 413
 414	u32 needed, freed;
 415	u32 size_array[5];
 416
 417	for (i = 0; i != periods; ++i) {
 418		u32 buffer_index = 0;
 419
 420		err = lx_buffer_ask(chip, 0, is_capture, &needed, &freed,
 421				    size_array);
 422		dev_dbg(chip->card->dev, "starting: needed %d, freed %d\n",
 423			    needed, freed);
 424
 425		err = lx_buffer_give(chip, 0, is_capture, period_bytes,
 426				     lower_32_bits(buf), upper_32_bits(buf),
 427				     &buffer_index);
 428
 429		dev_dbg(chip->card->dev, "starting: buffer index %x on 0x%lx (%d bytes)\n",
 430			    buffer_index, (unsigned long)buf, period_bytes);
 431		buf += period_bytes;
 432	}
 433
 434	err = lx_buffer_ask(chip, 0, is_capture, &needed, &freed, size_array);
 435	dev_dbg(chip->card->dev, "starting: needed %d, freed %d\n", needed, freed);
 436
 437	dev_dbg(chip->card->dev, "starting: starting stream\n");
 438	err = lx_stream_start(chip, 0, is_capture);
 439	if (err < 0)
 440		dev_err(chip->card->dev, "couldn't start stream\n");
 441	else
 442		lx_stream->status = LX_STREAM_STATUS_RUNNING;
 443
 444	lx_stream->frame_pos = 0;
 445}
 446
 447static void lx_trigger_stop(struct lx6464es *chip, struct lx_stream *lx_stream)
 448{
 449	const unsigned int is_capture = lx_stream->is_capture;
 450	int err;
 451
 452	dev_dbg(chip->card->dev, "stopping: stopping stream\n");
 453	err = lx_stream_stop(chip, 0, is_capture);
 454	if (err < 0)
 455		dev_err(chip->card->dev, "couldn't stop stream\n");
 456	else
 457		lx_stream->status = LX_STREAM_STATUS_FREE;
 458
 459}
 460
 461static void lx_trigger_dispatch_stream(struct lx6464es *chip,
 462				       struct lx_stream *lx_stream)
 463{
 464	switch (lx_stream->status) {
 465	case LX_STREAM_STATUS_SCHEDULE_RUN:
 466		lx_trigger_start(chip, lx_stream);
 467		break;
 468
 469	case LX_STREAM_STATUS_SCHEDULE_STOP:
 470		lx_trigger_stop(chip, lx_stream);
 471		break;
 472
 473	default:
 474		break;
 475	}
 476}
 477
 478static int lx_pcm_trigger_dispatch(struct lx6464es *chip,
 479				   struct lx_stream *lx_stream, int cmd)
 480{
 481	guard(mutex)(&chip->lock);
 482	switch (cmd) {
 483	case SNDRV_PCM_TRIGGER_START:
 484		lx_stream->status = LX_STREAM_STATUS_SCHEDULE_RUN;
 485		break;
 486
 487	case SNDRV_PCM_TRIGGER_STOP:
 488		lx_stream->status = LX_STREAM_STATUS_SCHEDULE_STOP;
 489		break;
 490
 491	default:
 492		return -EINVAL;
 493	}
 494
 495	lx_trigger_dispatch_stream(chip, &chip->capture_stream);
 496	lx_trigger_dispatch_stream(chip, &chip->playback_stream);
 497
 498	return 0;
 499}
 500
 501
 502static int lx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 503{
 504	struct lx6464es *chip = snd_pcm_substream_chip(substream);
 505	const int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
 506	struct lx_stream *stream = is_capture ? &chip->capture_stream :
 507		&chip->playback_stream;
 508
 509	dev_dbg(chip->card->dev, "->lx_pcm_trigger\n");
 510
 511	return lx_pcm_trigger_dispatch(chip, stream, cmd);
 512}
 513
 514static void snd_lx6464es_free(struct snd_card *card)
 515{
 516	struct lx6464es *chip = card->private_data;
 517
 518	lx_irq_disable(chip);
 519}
 520
 521/* reset the dsp during initialization */
 522static int lx_init_xilinx_reset(struct lx6464es *chip)
 523{
 524	int i;
 525	u32 plx_reg = lx_plx_reg_read(chip, ePLX_CHIPSC);
 526
 527	dev_dbg(chip->card->dev, "->lx_init_xilinx_reset\n");
 528
 529	/* activate reset of xilinx */
 530	plx_reg &= ~CHIPSC_RESET_XILINX;
 531
 532	lx_plx_reg_write(chip, ePLX_CHIPSC, plx_reg);
 533	msleep(1);
 534
 535	lx_plx_reg_write(chip, ePLX_MBOX3, 0);
 536	msleep(1);
 537
 538	plx_reg |= CHIPSC_RESET_XILINX;
 539	lx_plx_reg_write(chip, ePLX_CHIPSC, plx_reg);
 540
 541	/* deactivate reset of xilinx */
 542	for (i = 0; i != 100; ++i) {
 543		u32 reg_mbox3;
 544		msleep(10);
 545		reg_mbox3 = lx_plx_reg_read(chip, ePLX_MBOX3);
 546		if (reg_mbox3) {
 547			dev_dbg(chip->card->dev, "xilinx reset done\n");
 548			dev_dbg(chip->card->dev, "xilinx took %d loops\n", i);
 549			break;
 550		}
 551	}
 552
 553	/* todo: add some error handling? */
 554
 555	/* clear mr */
 556	lx_dsp_reg_write(chip, eReg_CSM, 0);
 557
 558	/* le xilinx ES peut ne pas etre encore pret, on attend. */
 559	msleep(600);
 560
 561	return 0;
 562}
 563
 564static int lx_init_xilinx_test(struct lx6464es *chip)
 565{
 566	u32 reg;
 567
 568	dev_dbg(chip->card->dev, "->lx_init_xilinx_test\n");
 569
 570	/* TEST if we have access to Xilinx/MicroBlaze */
 571	lx_dsp_reg_write(chip, eReg_CSM, 0);
 572
 573	reg = lx_dsp_reg_read(chip, eReg_CSM);
 574
 575	if (reg) {
 576		dev_err(chip->card->dev, "Problem: Reg_CSM %x.\n", reg);
 577
 578		/* PCI9056_SPACE0_REMAP */
 579		lx_plx_reg_write(chip, ePLX_PCICR, 1);
 580
 581		reg = lx_dsp_reg_read(chip, eReg_CSM);
 582		if (reg) {
 583			dev_err(chip->card->dev, "Error: Reg_CSM %x.\n", reg);
 584			return -EAGAIN; /* seems to be appropriate */
 585		}
 586	}
 587
 588	dev_dbg(chip->card->dev, "Xilinx/MicroBlaze access test successful\n");
 589
 590	return 0;
 591}
 592
 593/* initialize ethersound */
 594static int lx_init_ethersound_config(struct lx6464es *chip)
 595{
 596	int i;
 597	u32 orig_conf_es = lx_dsp_reg_read(chip, eReg_CONFES);
 598
 599	/* configure 64 io channels */
 600	u32 conf_es = (orig_conf_es & CONFES_READ_PART_MASK) |
 601		(64 << IOCR_INPUTS_OFFSET) |
 602		(64 << IOCR_OUTPUTS_OFFSET) |
 603		(FREQ_RATIO_SINGLE_MODE << FREQ_RATIO_OFFSET);
 604
 605	dev_dbg(chip->card->dev, "->lx_init_ethersound\n");
 606
 607	chip->freq_ratio = FREQ_RATIO_SINGLE_MODE;
 608
 609	/*
 610	 * write it to the card !
 611	 * this actually kicks the ES xilinx, the first time since poweron.
 612	 * the MAC address in the Reg_ADMACESMSB Reg_ADMACESLSB registers
 613	 * is not ready before this is done, and the bit 2 in Reg_CSES is set.
 614	 * */
 615	lx_dsp_reg_write(chip, eReg_CONFES, conf_es);
 616
 617	for (i = 0; i != 1000; ++i) {
 618		if (lx_dsp_reg_read(chip, eReg_CSES) & 4) {
 619			dev_dbg(chip->card->dev, "ethersound initialized after %dms\n",
 620				   i);
 621			goto ethersound_initialized;
 622		}
 623		msleep(1);
 624	}
 625	dev_warn(chip->card->dev,
 626		   "ethersound could not be initialized after %dms\n", i);
 627	return -ETIMEDOUT;
 628
 629 ethersound_initialized:
 630	dev_dbg(chip->card->dev, "ethersound initialized\n");
 631	return 0;
 632}
 633
 634static int lx_init_get_version_features(struct lx6464es *chip)
 635{
 636	u32 dsp_version;
 637
 638	int err;
 639
 640	dev_dbg(chip->card->dev, "->lx_init_get_version_features\n");
 641
 642	err = lx_dsp_get_version(chip, &dsp_version);
 643
 644	if (err == 0) {
 645		u32 freq;
 646
 647		dev_info(chip->card->dev, "DSP version: V%02d.%02d #%d\n",
 648			   (dsp_version>>16) & 0xff, (dsp_version>>8) & 0xff,
 649			   dsp_version & 0xff);
 650
 651		/* later: what firmware version do we expect? */
 652
 653		/* retrieve Play/Rec features */
 654		/* done here because we may have to handle alternate
 655		 * DSP files. */
 656		/* later */
 657
 658		/* init the EtherSound sample rate */
 659		err = lx_dsp_get_clock_frequency(chip, &freq);
 660		if (err == 0)
 661			chip->board_sample_rate = freq;
 662		dev_dbg(chip->card->dev, "actual clock frequency %d\n", freq);
 663	} else {
 664		dev_err(chip->card->dev, "DSP corrupted \n");
 665		err = -EAGAIN;
 666	}
 667
 668	return err;
 669}
 670
 671static int lx_set_granularity(struct lx6464es *chip, u32 gran)
 672{
 673	int err = 0;
 674	u32 snapped_gran = MICROBLAZE_IBL_MIN;
 675
 676	dev_dbg(chip->card->dev, "->lx_set_granularity\n");
 677
 678	/* blocksize is a power of 2 */
 679	while ((snapped_gran < gran) &&
 680	       (snapped_gran < MICROBLAZE_IBL_MAX)) {
 681		snapped_gran *= 2;
 682	}
 683
 684	if (snapped_gran == chip->pcm_granularity)
 685		return 0;
 686
 687	err = lx_dsp_set_granularity(chip, snapped_gran);
 688	if (err < 0) {
 689		dev_warn(chip->card->dev, "could not set granularity\n");
 690		err = -EAGAIN;
 691	}
 692
 693	if (snapped_gran != gran)
 694		dev_err(chip->card->dev, "snapped blocksize to %d\n", snapped_gran);
 695
 696	dev_dbg(chip->card->dev, "set blocksize on board %d\n", snapped_gran);
 697	chip->pcm_granularity = snapped_gran;
 698
 699	return err;
 700}
 701
 702/* initialize and test the xilinx dsp chip */
 703static int lx_init_dsp(struct lx6464es *chip)
 704{
 705	int err;
 706	int i;
 707
 708	dev_dbg(chip->card->dev, "->lx_init_dsp\n");
 709
 710	dev_dbg(chip->card->dev, "initialize board\n");
 711	err = lx_init_xilinx_reset(chip);
 712	if (err)
 713		return err;
 714
 715	dev_dbg(chip->card->dev, "testing board\n");
 716	err = lx_init_xilinx_test(chip);
 717	if (err)
 718		return err;
 719
 720	dev_dbg(chip->card->dev, "initialize ethersound configuration\n");
 721	err = lx_init_ethersound_config(chip);
 722	if (err)
 723		return err;
 724
 725	lx_irq_enable(chip);
 726
 727	/** \todo the mac address should be ready by not, but it isn't,
 728	 *  so we wait for it */
 729	for (i = 0; i != 1000; ++i) {
 730		err = lx_dsp_get_mac(chip);
 731		if (err)
 732			return err;
 733		if (chip->mac_address[0] || chip->mac_address[1] || chip->mac_address[2] ||
 734		    chip->mac_address[3] || chip->mac_address[4] || chip->mac_address[5])
 735			goto mac_ready;
 736		msleep(1);
 737	}
 738	return -ETIMEDOUT;
 739
 740mac_ready:
 741	dev_dbg(chip->card->dev, "mac address ready read after: %dms\n", i);
 742	dev_info(chip->card->dev,
 743		 "mac address: %02X.%02X.%02X.%02X.%02X.%02X\n",
 744		   chip->mac_address[0], chip->mac_address[1], chip->mac_address[2],
 745		   chip->mac_address[3], chip->mac_address[4], chip->mac_address[5]);
 746
 747	err = lx_init_get_version_features(chip);
 748	if (err)
 749		return err;
 750
 751	lx_set_granularity(chip, MICROBLAZE_IBL_DEFAULT);
 752
 753	chip->playback_mute = 0;
 754
 755	return err;
 756}
 757
 758static const struct snd_pcm_ops lx_ops_playback = {
 759	.open      = lx_pcm_open,
 760	.close     = lx_pcm_close,
 761	.prepare   = lx_pcm_prepare,
 762	.hw_params = lx_pcm_hw_params_playback,
 763	.hw_free   = lx_pcm_hw_free,
 764	.trigger   = lx_pcm_trigger,
 765	.pointer   = lx_pcm_stream_pointer,
 766};
 767
 768static const struct snd_pcm_ops lx_ops_capture = {
 769	.open      = lx_pcm_open,
 770	.close     = lx_pcm_close,
 771	.prepare   = lx_pcm_prepare,
 772	.hw_params = lx_pcm_hw_params_capture,
 773	.hw_free   = lx_pcm_hw_free,
 774	.trigger   = lx_pcm_trigger,
 775	.pointer   = lx_pcm_stream_pointer,
 776};
 777
 778static int lx_pcm_create(struct lx6464es *chip)
 779{
 780	int err;
 781	struct snd_pcm *pcm;
 782
 783	u32 size = 64 *		     /* channels */
 784		3 *		     /* 24 bit samples */
 785		MAX_STREAM_BUFFER *  /* periods */
 786		MICROBLAZE_IBL_MAX * /* frames per period */
 787		2;		     /* duplex */
 788
 789	size = PAGE_ALIGN(size);
 790
 791	/* hardcoded device name & channel count */
 792	err = snd_pcm_new(chip->card, (char *)card_name, 0,
 793			  1, 1, &pcm);
 794	if (err < 0)
 795		return err;
 796
 797	pcm->private_data = chip;
 798
 799	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &lx_ops_playback);
 800	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &lx_ops_capture);
 801
 802	pcm->info_flags = 0;
 803	pcm->nonatomic = true;
 804	strscpy(pcm->name, card_name);
 805
 806	snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
 807				       &chip->pci->dev, size, size);
 808
 809	chip->pcm = pcm;
 810	chip->capture_stream.is_capture = 1;
 811
 812	return 0;
 813}
 814
 815static int lx_control_playback_info(struct snd_kcontrol *kcontrol,
 816				    struct snd_ctl_elem_info *uinfo)
 817{
 818	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 819	uinfo->count = 1;
 820	uinfo->value.integer.min = 0;
 821	uinfo->value.integer.max = 1;
 822	return 0;
 823}
 824
 825static int lx_control_playback_get(struct snd_kcontrol *kcontrol,
 826				   struct snd_ctl_elem_value *ucontrol)
 827{
 828	struct lx6464es *chip = snd_kcontrol_chip(kcontrol);
 829	ucontrol->value.integer.value[0] = chip->playback_mute;
 830	return 0;
 831}
 832
 833static int lx_control_playback_put(struct snd_kcontrol *kcontrol,
 834				   struct snd_ctl_elem_value *ucontrol)
 835{
 836	struct lx6464es *chip = snd_kcontrol_chip(kcontrol);
 837	int changed = 0;
 838	int current_value = chip->playback_mute;
 839
 840	if (current_value != ucontrol->value.integer.value[0]) {
 841		lx_level_unmute(chip, 0, !current_value);
 842		chip->playback_mute = !current_value;
 843		changed = 1;
 844	}
 845	return changed;
 846}
 847
 848static const struct snd_kcontrol_new lx_control_playback_switch = {
 849	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 850	.name = "PCM Playback Switch",
 851	.index = 0,
 852	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 853	.private_value = 0,
 854	.info = lx_control_playback_info,
 855	.get = lx_control_playback_get,
 856	.put = lx_control_playback_put
 857};
 858
 859
 860
 861static void lx_proc_levels_read(struct snd_info_entry *entry,
 862				struct snd_info_buffer *buffer)
 863{
 864	u32 levels[64];
 865	int err;
 866	int i, j;
 867	struct lx6464es *chip = entry->private_data;
 868
 869	snd_iprintf(buffer, "capture levels:\n");
 870	err = lx_level_peaks(chip, 1, 64, levels);
 871	if (err < 0)
 872		return;
 873
 874	for (i = 0; i != 8; ++i) {
 875		for (j = 0; j != 8; ++j)
 876			snd_iprintf(buffer, "%08x ", levels[i*8+j]);
 877		snd_iprintf(buffer, "\n");
 878	}
 879
 880	snd_iprintf(buffer, "\nplayback levels:\n");
 881
 882	err = lx_level_peaks(chip, 0, 64, levels);
 883	if (err < 0)
 884		return;
 885
 886	for (i = 0; i != 8; ++i) {
 887		for (j = 0; j != 8; ++j)
 888			snd_iprintf(buffer, "%08x ", levels[i*8+j]);
 889		snd_iprintf(buffer, "\n");
 890	}
 891
 892	snd_iprintf(buffer, "\n");
 893}
 894
 895static int lx_proc_create(struct snd_card *card, struct lx6464es *chip)
 896{
 897	return snd_card_ro_proc_new(card, "levels", chip, lx_proc_levels_read);
 898}
 899
 900
 901static int snd_lx6464es_create(struct snd_card *card,
 902			       struct pci_dev *pci)
 903{
 904	struct lx6464es *chip = card->private_data;
 905	int err;
 906
 907	dev_dbg(card->dev, "->snd_lx6464es_create\n");
 908
 909	/* enable PCI device */
 910	err = pcim_enable_device(pci);
 911	if (err < 0)
 912		return err;
 913
 914	pci_set_master(pci);
 915
 916	/* check if we can restrict PCI DMA transfers to 32 bits */
 917	err = dma_set_mask(&pci->dev, DMA_BIT_MASK(32));
 918	if (err < 0) {
 919		dev_err(card->dev,
 920			"architecture does not support 32bit PCI busmaster DMA\n");
 921		return -ENXIO;
 922	}
 923
 924	chip->card = card;
 925	chip->pci = pci;
 926	chip->irq = -1;
 927
 928	/* initialize synchronization structs */
 929	mutex_init(&chip->lock);
 930	mutex_init(&chip->msg_lock);
 931	mutex_init(&chip->setup_mutex);
 932
 933	/* request resources */
 934	err = pcim_request_all_regions(pci, card_name);
 935	if (err < 0)
 936		return err;
 937
 938	/* plx port */
 939	chip->port_plx = pci_resource_start(pci, 1);
 940	chip->port_plx_remapped = devm_ioport_map(&pci->dev, chip->port_plx,
 941						  pci_resource_len(pci, 1));
 942	if (!chip->port_plx_remapped)
 943		return -ENOMEM;
 944
 945	/* dsp port */
 946	chip->port_dsp_bar = pcim_iomap(pci, 2, 0);
 947	if (!chip->port_dsp_bar)
 948		return -ENOMEM;
 949
 950	err = devm_request_threaded_irq(&pci->dev, pci->irq, lx_interrupt,
 951					lx_threaded_irq, IRQF_SHARED,
 952					KBUILD_MODNAME, chip);
 953	if (err) {
 954		dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
 955		return err;
 956	}
 957	chip->irq = pci->irq;
 958	card->sync_irq = chip->irq;
 959	card->private_free = snd_lx6464es_free;
 960
 961	err = lx_init_dsp(chip);
 962	if (err < 0) {
 963		dev_err(card->dev, "error during DSP initialization\n");
 964		return err;
 965	}
 966
 967	err = lx_pcm_create(chip);
 968	if (err < 0)
 969		return err;
 970
 971	err = lx_proc_create(card, chip);
 972	if (err < 0)
 973		return err;
 974
 975	err = snd_ctl_add(card, snd_ctl_new1(&lx_control_playback_switch,
 976					     chip));
 977	if (err < 0)
 978		return err;
 979
 980	return 0;
 981}
 982
 983static int snd_lx6464es_probe(struct pci_dev *pci,
 984			      const struct pci_device_id *pci_id)
 985{
 986	static int dev;
 987	struct snd_card *card;
 988	struct lx6464es *chip;
 989	int err;
 990
 991	dev_dbg(&pci->dev, "->snd_lx6464es_probe\n");
 992
 993	if (dev >= SNDRV_CARDS)
 994		return -ENODEV;
 995	if (!enable[dev]) {
 996		dev++;
 997		return -ENOENT;
 998	}
 999
1000	err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
1001				sizeof(*chip), &card);
1002	if (err < 0)
1003		return err;
1004	chip = card->private_data;
1005
1006	err = snd_lx6464es_create(card, pci);
1007	if (err < 0) {
1008		dev_err(card->dev, "error during snd_lx6464es_create\n");
1009		goto error;
1010	}
1011
1012	strscpy(card->driver, "LX6464ES");
1013	sprintf(card->id, "LX6464ES_%02X%02X%02X",
1014		chip->mac_address[3], chip->mac_address[4], chip->mac_address[5]);
1015
1016	sprintf(card->shortname, "LX6464ES %02X.%02X.%02X.%02X.%02X.%02X",
1017		chip->mac_address[0], chip->mac_address[1], chip->mac_address[2],
1018		chip->mac_address[3], chip->mac_address[4], chip->mac_address[5]);
1019
1020	sprintf(card->longname, "%s at 0x%lx, 0x%p, irq %i",
1021		card->shortname, chip->port_plx,
1022		chip->port_dsp_bar, chip->irq);
1023
1024	err = snd_card_register(card);
1025	if (err < 0)
1026		goto error;
1027
1028	dev_dbg(chip->card->dev, "initialization successful\n");
1029	pci_set_drvdata(pci, card);
1030	dev++;
1031	return 0;
1032
1033 error:
1034	snd_card_free(card);
1035	return err;
1036}
1037
1038static struct pci_driver lx6464es_driver = {
1039	.name =     KBUILD_MODNAME,
1040	.id_table = snd_lx6464es_ids,
1041	.probe =    snd_lx6464es_probe,
1042};
1043
1044module_pci_driver(lx6464es_driver);
~/ Read-only file preview.