自学教程：C++ snd_printdd函数代码示例

static int snd_opl4_detect(struct snd_opl4 *opl4){	u8 id1, id2;	snd_opl4_enable_opl4(opl4);	id1 = snd_opl4_read(opl4, OPL4_REG_MEMORY_CONFIGURATION);	snd_printdd("OPL4[02]=%02x/n", id1);	switch (id1 & OPL4_DEVICE_ID_MASK) {	case 0x20:		opl4->hardware = OPL3_HW_OPL4;		break;	case 0x40:		opl4->hardware = OPL3_HW_OPL4_ML;		break;	default:		return -ENODEV;	}	snd_opl4_write(opl4, OPL4_REG_MIX_CONTROL_FM, 0x00);	snd_opl4_write(opl4, OPL4_REG_MIX_CONTROL_PCM, 0xff);	id1 = snd_opl4_read(opl4, OPL4_REG_MIX_CONTROL_FM);	id2 = snd_opl4_read(opl4, OPL4_REG_MIX_CONTROL_PCM);	snd_printdd("OPL4 id1=%02x id2=%02x/n", id1, id2);       	if (id1 != 0x00 || id2 != 0xff)		return -ENODEV;	snd_opl4_write(opl4, OPL4_REG_MIX_CONTROL_FM, 0x3f);	snd_opl4_write(opl4, OPL4_REG_MIX_CONTROL_PCM, 0x3f);	snd_opl4_write(opl4, OPL4_REG_MEMORY_CONFIGURATION, 0x00);	return 0;}

static void apply_fixup(struct hda_codec *codec, int id, int action, int depth){#ifdef CONFIG_SND_DEBUG_VERBOSE	const char *modelname = codec->fixup_name;#endif	while (id >= 0) {		const struct hda_fixup *fix = codec->fixup_list + id;		if (fix->chained_before)			apply_fixup(codec, fix->chain_id, action, depth + 1);		switch (fix->type) {		case HDA_FIXUP_PINS:			if (action != HDA_FIXUP_ACT_PRE_PROBE || !fix->v.pins)				break;			snd_printdd(KERN_INFO SFX				    "%s: Apply pincfg for %s/n",				    codec->chip_name, modelname);			snd_hda_apply_pincfgs(codec, fix->v.pins);			break;		case HDA_FIXUP_VERBS:			if (action != HDA_FIXUP_ACT_PROBE || !fix->v.verbs)				break;			snd_printdd(KERN_INFO SFX				    "%s: Apply fix-verbs for %s/n",				    codec->chip_name, modelname);			snd_hda_add_verbs(codec, fix->v.verbs);			break;		case HDA_FIXUP_FUNC:			if (!fix->v.func)				break;			snd_printdd(KERN_INFO SFX				    "%s: Apply fix-func for %s/n",				    codec->chip_name, modelname);			fix->v.func(codec, fix, action);			break;		case HDA_FIXUP_PINCTLS:			if (action != HDA_FIXUP_ACT_PROBE || !fix->v.pins)				break;			snd_printdd(KERN_INFO SFX				    "%s: Apply pinctl for %s/n",				    codec->chip_name, modelname);			set_pin_targets(codec, fix->v.pins);			break;		default:			snd_printk(KERN_ERR SFX				   "%s: Invalid fixup type %d/n",				   codec->chip_name, fix->type);			break;		}		if (!fix->chained || fix->chained_before)			break;		if (++depth > 10)			break;		id = fix->chain_id;	}}

static int lx_pcm_open(struct snd_pcm_substream *substream){	struct lx6464es *chip = snd_pcm_substream_chip(substream);	struct snd_pcm_runtime *runtime = substream->runtime;	int err = 0;	int board_rate;	snd_printdd("->lx_pcm_open/n");	mutex_lock(&chip->setup_mutex);	/* copy the struct snd_pcm_hardware struct */	runtime->hw = lx_caps;#if 0	/* buffer-size should better be multiple of period-size */	err = snd_pcm_hw_constraint_integer(runtime,					    SNDRV_PCM_HW_PARAM_PERIODS);	if (err < 0) {		snd_printk(KERN_WARNING LXP "could not constrain periods/n");		goto exit;	}#endif	/* the clock rate cannot be changed */	board_rate = chip->board_sample_rate;	err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_RATE,					   board_rate, board_rate);	if (err < 0) {		snd_printk(KERN_WARNING LXP "could not constrain periods/n");		goto exit;	}	/* constrain period size */	err = snd_pcm_hw_constraint_minmax(runtime,					   SNDRV_PCM_HW_PARAM_PERIOD_SIZE,					   MICROBLAZE_IBL_MIN,					   MICROBLAZE_IBL_MAX);	if (err < 0) {		snd_printk(KERN_WARNING LXP			   "could not constrain period size/n");		goto exit;	}	snd_pcm_hw_constraint_step(runtime, 0,				   SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 32);	snd_pcm_set_sync(substream);	err = 0;exit:	runtime->private_data = chip;	mutex_unlock(&chip->setup_mutex);	snd_printdd("<-lx_pcm_open, %d/n", err);	return err;}

static int vxp_suspend(struct pcmcia_device *link){	struct vx_core *chip = link->priv;	snd_printdd(KERN_DEBUG "SUSPEND/n");	if (chip) {		snd_printdd(KERN_DEBUG "snd_vx_suspend calling/n");		snd_vx_suspend(chip);	}	return 0;}

void snd_hda_apply_fixup(struct hda_codec *codec, int action){	struct hda_gen_spec *spec = codec->spec;	int id = spec->fixup_id;#ifdef CONFIG_SND_DEBUG_VERBOSE	const char *modelname = spec->fixup_name;#endif	int depth = 0;	if (!spec->fixup_list)		return;	while (id >= 0) {		const struct hda_fixup *fix = spec->fixup_list + id;		switch (fix->type) {		case HDA_FIXUP_PINS:			if (action != HDA_FIXUP_ACT_PRE_PROBE || !fix->v.pins)				break;			snd_printdd(KERN_INFO SFX				    "%s: Apply pincfg for %s/n",				    codec->chip_name, modelname);			snd_hda_apply_pincfgs(codec, fix->v.pins);			break;		case HDA_FIXUP_VERBS:			if (action != HDA_FIXUP_ACT_PROBE || !fix->v.verbs)				break;			snd_printdd(KERN_INFO SFX				    "%s: Apply fix-verbs for %s/n",				    codec->chip_name, modelname);			snd_hda_gen_add_verbs(codec->spec, fix->v.verbs);			break;		case HDA_FIXUP_FUNC:			if (!fix->v.func)				break;			snd_printdd(KERN_INFO SFX				    "%s: Apply fix-func for %s/n",				    codec->chip_name, modelname);			fix->v.func(codec, fix, action);			break;		default:			snd_printk(KERN_ERR SFX				   "%s: Invalid fixup type %d/n",				   codec->chip_name, fix->type);			break;		}		if (!fix->chained)			break;		if (++depth > 10)			break;		id = fix->chain_id;	}}

static int pdacf_suspend(struct pcmcia_device *link){	struct snd_pdacf *chip = link->priv;	snd_printdd(KERN_DEBUG "SUSPEND/n");	if (chip) {		snd_printdd(KERN_DEBUG "snd_pdacf_suspend calling/n");		snd_pdacf_suspend(chip, PMSG_SUSPEND);	}	return 0;}

/* * event callback */static int vxpocket_event(event_t event, int priority, event_callback_args_t *args){	dev_link_t *link = args->client_data;	vx_core_t *chip = link->priv;	switch (event) {	case CS_EVENT_CARD_REMOVAL:		snd_printdd(KERN_DEBUG "CARD_REMOVAL../n");		link->state &= ~DEV_PRESENT;		if (link->state & DEV_CONFIG)			chip->chip_status |= VX_STAT_IS_STALE;		break;	case CS_EVENT_CARD_INSERTION:		snd_printdd(KERN_DEBUG "CARD_INSERTION../n");		link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;		vxpocket_config(link);		break;#ifdef CONFIG_PM	case CS_EVENT_PM_SUSPEND:		snd_printdd(KERN_DEBUG "SUSPEND/n");		link->state |= DEV_SUSPEND;		if (chip && chip->card->pm_suspend) {			snd_printdd(KERN_DEBUG "snd_vx_suspend calling/n");			chip->card->pm_suspend(chip->card, PMSG_SUSPEND);		}		/* Fall through... */	case CS_EVENT_RESET_PHYSICAL:		snd_printdd(KERN_DEBUG "RESET_PHYSICAL/n");		if (link->state & DEV_CONFIG)			pcmcia_release_configuration(link->handle);		break;	case CS_EVENT_PM_RESUME:		snd_printdd(KERN_DEBUG "RESUME/n");		link->state &= ~DEV_SUSPEND;		/* Fall through... */	case CS_EVENT_CARD_RESET:		snd_printdd(KERN_DEBUG "CARD_RESET/n");		if (DEV_OK(link)) {			//struct snd_vxpocket *vxp = (struct snd_vxpocket *)chip;			snd_printdd(KERN_DEBUG "requestconfig.../n");			pcmcia_request_configuration(link->handle, &link->conf);			if (chip && chip->card->pm_resume) {				snd_printdd(KERN_DEBUG "calling snd_vx_resume/n");				chip->card->pm_resume(chip->card);			}		}		snd_printdd(KERN_DEBUG "resume done!/n");		break;#endif	}	return 0;}

static int __init snd_gusextreme_detect(int dev,					struct snd_card *card,					struct snd_gus_card * gus,					struct snd_es1688 *es1688){	unsigned long flags;	unsigned char d;	/*	 * This is main stuff - enable access to GF1 chip...	 * I'm not sure, if this will work for card which have	 * ES1688 chip in another place than 0x220.         *         * I used reverse-engineering in DOSEMU. [--jk]	 *	 * ULTRINIT.EXE:	 * 0x230 = 0,2,3	 * 0x240 = 2,0,1	 * 0x250 = 2,0,3	 * 0x260 = 2,2,1	 */	spin_lock_irqsave(&es1688->mixer_lock, flags);	snd_es1688_mixer_write(es1688, 0x40, 0x0b);	/* don't change!!! */	spin_unlock_irqrestore(&es1688->mixer_lock, flags);	spin_lock_irqsave(&es1688->reg_lock, flags);	outb(gf1_port[dev] & 0x040 ? 2 : 0, ES1688P(es1688, INIT1));	outb(0, 0x201);	outb(gf1_port[dev] & 0x020 ? 2 : 0, ES1688P(es1688, INIT1));	outb(0, 0x201);	outb(gf1_port[dev] & 0x010 ? 3 : 1, ES1688P(es1688, INIT1));	spin_unlock_irqrestore(&es1688->reg_lock, flags);	udelay(100);	snd_gf1_i_write8(gus, SNDRV_GF1_GB_RESET, 0);	/* reset GF1 */	if (((d = snd_gf1_i_look8(gus, SNDRV_GF1_GB_RESET)) & 0x07) != 0) {		snd_printdd("[0x%lx] check 1 failed - 0x%x/n", gus->gf1.port, d);		return -EIO;	}	udelay(160);	snd_gf1_i_write8(gus, SNDRV_GF1_GB_RESET, 1);	/* release reset */	udelay(160);	if (((d = snd_gf1_i_look8(gus, SNDRV_GF1_GB_RESET)) & 0x07) != 1) {		snd_printdd("[0x%lx] check 2 failed - 0x%x/n", gus->gf1.port, d);		return -EIO;	}	return 0;}

static int pdacf_resume(struct pcmcia_device *link){	struct snd_pdacf *chip = link->priv;	snd_printdd(KERN_DEBUG "RESUME/n");	if (pcmcia_dev_present(link)) {		if (chip) {			snd_printdd(KERN_DEBUG "calling snd_pdacf_resume/n");			snd_pdacf_resume(chip);		}	}	snd_printdd(KERN_DEBUG "resume done!/n");	return 0;}

int snd_msnd_disable_irq(struct snd_msnd *dev){	unsigned long flags;	if (--dev->irq_ref > 0)		return 0;	if (dev->irq_ref < 0)		snd_printd(KERN_WARNING LOGNAME ": IRQ ref count is %d/n",			   dev->irq_ref);	snd_printdd(LOGNAME ": Disabling IRQ/n");	spin_lock_irqsave(&dev->lock, flags);	if (snd_msnd_wait_TXDE(dev) == 0) {		outb(inb(dev->io + HP_ICR) & ~HPICR_RREQ, dev->io + HP_ICR);		if (dev->type == msndClassic)			outb(HPIRQ_NONE, dev->io + HP_IRQM);		disable_irq(dev->irq);		spin_unlock_irqrestore(&dev->lock, flags);		return 0;	}	spin_unlock_irqrestore(&dev->lock, flags);	snd_printd(KERN_ERR LOGNAME ": Disable IRQ failed/n");	return -EIO;}

int snd_msnd_enable_irq(struct snd_msnd *dev){	unsigned long flags;	if (dev->irq_ref++)		return 0;	snd_printdd(LOGNAME ": Enabling IRQ/n");	spin_lock_irqsave(&dev->lock, flags);	if (snd_msnd_wait_TXDE(dev) == 0) {		outb(inb(dev->io + HP_ICR) | HPICR_TREQ, dev->io + HP_ICR);		if (dev->type == msndClassic)			outb(dev->irqid, dev->io + HP_IRQM);		outb(inb(dev->io + HP_ICR) & ~HPICR_TREQ, dev->io + HP_ICR);		outb(inb(dev->io + HP_ICR) | HPICR_RREQ, dev->io + HP_ICR);		enable_irq(dev->irq);		snd_msnd_init_queue(dev->DSPQ, dev->dspq_data_buff,				    dev->dspq_buff_size);		spin_unlock_irqrestore(&dev->lock, flags);		return 0;	}	spin_unlock_irqrestore(&dev->lock, flags);	snd_printd(KERN_ERR LOGNAME ": Enable IRQ failed/n");	return -EIO;}

static int pcxhr_iec958_update_byte(struct snd_pcxhr *chip,				    int aes_idx, unsigned char aes_bits){	int i, err, cmd;	unsigned char new_bits = aes_bits;	unsigned char old_bits = chip->aes_bits[aes_idx];	struct pcxhr_rmh rmh;	for (i = 0; i < 8; i++) {		if ((old_bits & 0x01) != (new_bits & 0x01)) {			cmd = chip->chip_idx & 0x03;      			if (chip->chip_idx > 3)								cmd |= 1 << 22;			cmd |= ((aes_idx << 3) + i) << 2; 			cmd |= (new_bits & 0x01) << 23;   			pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE);			rmh.cmd[0] |= IO_NUM_REG_CUER;			rmh.cmd[1] = cmd;			rmh.cmd_len = 2;			snd_printdd("write iec958 AES %d byte %d bit %d (cmd %x)/n",				    chip->chip_idx, aes_idx, i, cmd);			err = pcxhr_send_msg(chip->mgr, &rmh);			if (err)				return err;		}		old_bits >>= 1;		new_bits >>= 1;	}	chip->aes_bits[aes_idx] = aes_bits;	return 0;}

/* *  allocate a playback/capture pipe (pcmp0/pcmc0) */static int pcxhr_dsp_allocate_pipe( struct pcxhr_mgr *mgr, struct pcxhr_pipe *pipe,				    int is_capture, int pin){	int stream_count, audio_count;	int err;	struct pcxhr_rmh rmh;	if (is_capture) {		stream_count = 1;		if (mgr->mono_capture)			audio_count = 1;		else			audio_count = 2;	} else {		stream_count = PCXHR_PLAYBACK_STREAMS;		audio_count = 2;	/* always stereo */	}	snd_printdd("snd_add_ref_pipe pin(%d) pcm%c0/n", pin, is_capture ? 'c' : 'p');	pipe->is_capture = is_capture;	pipe->first_audio = pin;	/* define pipe (P_PCM_ONLY_MASK (0x020000) is not necessary) */	pcxhr_init_rmh(&rmh, CMD_RES_PIPE);	pcxhr_set_pipe_cmd_params(&rmh, is_capture, pin, audio_count, stream_count); 	err = pcxhr_send_msg(mgr, &rmh);	if (err < 0) {		snd_printk(KERN_ERR "error pipe allocation (CMD_RES_PIPE) err=%x!/n", err );		return err;	}	pipe->status = PCXHR_PIPE_DEFINED;	return 0;}

/** * snd_pdacf_assign_resources - initialize the hardware and card instance. * @port: i/o port for the card * @irq: irq number for the card * * this function assigns the specified port and irq, boot the card, * create pcm and control instances, and initialize the rest hardware. * * returns 0 if successful, or a negative error code. */static int snd_pdacf_assign_resources(struct snd_pdacf *pdacf, int port, int irq){	int err;	struct snd_card *card = pdacf->card;	snd_printdd(KERN_DEBUG "pdacf assign resources: port = 0x%x, irq = %d/n", port, irq);	pdacf->port = port;	pdacf->irq = irq;	pdacf->chip_status |= PDAUDIOCF_STAT_IS_CONFIGURED;	err = snd_pdacf_ak4117_create(pdacf);	if (err < 0)		return err;		strcpy(card->driver, "PDAudio-CF");	sprintf(card->shortname, "Core Sound %s", card->driver);	sprintf(card->longname, "%s at 0x%x, irq %i",		card->shortname, port, irq);	err = snd_pdacf_pcm_new(pdacf);	if (err < 0)		return err;	if ((err = snd_card_register(card)) < 0)		return err;	return 0;}

static struct page * snd_us428ctls_vm_nopage(struct vm_area_struct *area, unsigned long address, int *type){	unsigned long offset;	struct page * page;	void *vaddr;	snd_printdd("ENTER, start %lXh, ofs %lXh, pgoff %ld, addr %lXh/n",		   area->vm_start,		   address - area->vm_start,		   (address - area->vm_start) >> PAGE_SHIFT,		   address);		offset = area->vm_pgoff << PAGE_SHIFT;	offset += address - area->vm_start;	snd_assert((offset % PAGE_SIZE) == 0, return NOPAGE_OOM);	vaddr = (char*)((usX2Ydev_t*)area->vm_private_data)->us428ctls_sharedmem + offset;	page = virt_to_page(vaddr);	get_page(page);	snd_printdd( "vaddr=%p made us428ctls_vm_nopage() return %p; offset=%lX/n", vaddr, page, offset);	if (type)		*type = VM_FAULT_MINOR;	return page;}

static int pdacf_config(struct pcmcia_device *link){	struct snd_pdacf *pdacf = link->priv;	int ret;	snd_printdd(KERN_DEBUG "pdacf_config called/n");	link->config_index = 0x5;	link->config_flags |= CONF_ENABLE_IRQ | CONF_ENABLE_PULSE_IRQ;	ret = pcmcia_request_io(link);	if (ret)		goto failed;	ret = pcmcia_request_irq(link, pdacf_interrupt);	if (ret)		goto failed;	ret = pcmcia_enable_device(link);	if (ret)		goto failed;	if (snd_pdacf_assign_resources(pdacf, link->resource[0]->start,					link->irq) < 0)		goto failed;	return 0;failed:	pcmcia_disable_device(link);	return -ENODEV;}

static int vxp_resume(struct pcmcia_device *link){	struct vx_core *chip = link->priv;	snd_printdd(KERN_DEBUG "RESUME/n");	if (pcmcia_dev_present(link)) {		//struct snd_vxpocket *vxp = (struct snd_vxpocket *)chip;		if (chip) {			snd_printdd(KERN_DEBUG "calling snd_vx_resume/n");			snd_vx_resume(chip);		}	}	snd_printdd(KERN_DEBUG "resume done!/n");	return 0;}

static int pdacf_config(struct pcmcia_device *link){	struct snd_pdacf *pdacf = link->priv;	int ret;	snd_printdd(KERN_DEBUG "pdacf_config called/n");	link->conf.ConfigIndex = 0x5;	ret = pcmcia_request_io(link);	if (ret)		goto failed;	ret = pcmcia_request_exclusive_irq(link, pdacf_interrupt);	if (ret)		goto failed;	ret = pcmcia_request_configuration(link, &link->conf);	if (ret)		goto failed;	if (snd_pdacf_assign_resources(pdacf, link->resource[0]->start,					link->irq) < 0)		goto failed;	return 0;failed:	pcmcia_disable_device(link);	return -ENODEV;}

/* * snd_pdacf_attach - attach callback for cs */static int snd_pdacf_probe(struct pcmcia_device *link){	int i, err;	struct snd_pdacf *pdacf;	struct snd_card *card;	static struct snd_device_ops ops = {		.dev_free =	snd_pdacf_dev_free,	};	snd_printdd(KERN_DEBUG "pdacf_attach called/n");	/* find an empty slot from the card list */	for (i = 0; i < SNDRV_CARDS; i++) {		if (! card_list[i])			break;	}	if (i >= SNDRV_CARDS) {		snd_printk(KERN_ERR "pdacf: too many cards found/n");		return -EINVAL;	}	if (! enable[i])		return -ENODEV; /* disabled explicitly */	/* ok, create a card instance */	err = snd_card_create(index[i], id[i], THIS_MODULE, 0, &card);	if (err < 0) {		snd_printk(KERN_ERR "pdacf: cannot create a card instance/n");		return err;	}	pdacf = snd_pdacf_create(card);	if (!pdacf) {		snd_card_free(card);		return -ENOMEM;	}	err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, pdacf, &ops);	if (err < 0) {		kfree(pdacf);		snd_card_free(card);		return err;	}	snd_card_set_dev(card, &link->dev);	pdacf->index = i;	card_list[i] = card;	pdacf->p_dev = link;	link->priv = pdacf;	link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;	link->resource[0]->end = 16;	link->conf.Attributes = CONF_ENABLE_IRQ | CONF_ENABLE_PULSE_IRQ;	link->conf.IntType = INT_MEMORY_AND_IO;	link->conf.ConfigIndex = 1;	link->conf.Present = PRESENT_OPTION;	return pdacf_config(link);}

int hr222_sub_init(struct pcxhr_mgr *mgr){	unsigned char reg;	mgr->board_has_analog = 1;		mgr->xlx_cfg = PCXHR_CFG_SYNCDSP_MASK;	reg = PCXHR_INPB(mgr, PCXHR_XLX_STATUS);	if (reg & PCXHR_STAT_MIC_CAPS)		mgr->board_has_mic = 1;		snd_printdd("MIC input available = %d/n", mgr->board_has_mic);		PCXHR_OUTPB(mgr, PCXHR_DSP_RESET,		    PCXHR_DSP_RESET_DSP);	msleep(5);	mgr->dsp_reset = PCXHR_DSP_RESET_DSP  |			 PCXHR_DSP_RESET_MUTE |			 PCXHR_DSP_RESET_CODEC;	PCXHR_OUTPB(mgr, PCXHR_DSP_RESET, mgr->dsp_reset);		msleep(5);		hr222_config_akm(mgr, AKM_POWER_CONTROL_CMD);	hr222_config_akm(mgr, AKM_CLOCK_INF_55K_CMD);	hr222_config_akm(mgr, AKM_UNMUTE_CMD);	hr222_config_akm(mgr, AKM_RESET_OFF_CMD);		hr222_micro_boost(mgr, 0);	return 0;}

/* * XRUN detected, and stop the PCM substream */static void snd_atiixp_xrun_dma(atiixp_t *chip, atiixp_dma_t *dma){    if (! dma->substream || ! dma->running)        return;    snd_printdd("atiixp: XRUN detected (DMA %d)/n", dma->ops->type);    snd_pcm_stop(dma->substream, SNDRV_PCM_STATE_XRUN);}

int hr222_sub_init(struct pcxhr_mgr *mgr){	unsigned char reg;	mgr->board_has_analog = 1;	/* analog always available */	mgr->xlx_cfg = PCXHR_CFG_SYNCDSP_MASK;	reg = PCXHR_INPB(mgr, PCXHR_XLX_STATUS);	if (reg & PCXHR_STAT_MIC_CAPS)		mgr->board_has_mic = 1;	/* microphone available */	snd_printdd("MIC input available = %d/n", mgr->board_has_mic);	/* reset codec */	PCXHR_OUTPB(mgr, PCXHR_DSP_RESET,		    PCXHR_DSP_RESET_DSP);	msleep(5);	mgr->dsp_reset = PCXHR_DSP_RESET_DSP  |			 PCXHR_DSP_RESET_MUTE |			 PCXHR_DSP_RESET_CODEC;	PCXHR_OUTPB(mgr, PCXHR_DSP_RESET, mgr->dsp_reset);	/* hr222_write_gpo(mgr, 0); does the same */	msleep(5);	/* config AKM */	hr222_config_akm(mgr, AKM_POWER_CONTROL_CMD);	hr222_config_akm(mgr, AKM_CLOCK_INF_55K_CMD);	hr222_config_akm(mgr, AKM_UNMUTE_CMD);	hr222_config_akm(mgr, AKM_RESET_OFF_CMD);	/* init micro boost */	hr222_micro_boost(mgr, 0);	return 0;}