Merge remote-tracking branch 'asoc/topic/x86' into asoc-next

	/* audio interrupt base of SRAM location where

	 * interrupts are stored by System FW */

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

	mc_drv_ctx = devm_kzalloc(&pdev->dev, sizeof(*mc_drv_ctx), GFP_ATOMIC);

	if (!mc_drv_ctx) {

		pr_err("allocation failed\n");

		return -ENOMEM;

				pdev, IORESOURCE_MEM, "IRQ_BASE");

	if (!irq_mem) {

		pr_err("no mem resource given\n");

		ret_val = -ENODEV;

		goto unalloc;

		return -ENODEV;

	}

	mc_drv_ctx->int_base = ioremap_nocache(irq_mem->start,

	mc_drv_ctx->int_base = devm_ioremap_nocache(&pdev->dev, irq_mem->start,

						    resource_size(irq_mem));

	if (!mc_drv_ctx->int_base) {

		pr_err("Mapping of cache failed\n");

		ret_val = -ENOMEM;

		goto unalloc;

		return -ENOMEM;

	}

	/* register for interrupt */

	ret_val = request_threaded_irq(irq, snd_mfld_jack_intr_handler,

	ret_val = devm_request_threaded_irq(&pdev->dev, irq,

			snd_mfld_jack_intr_handler,

			snd_mfld_jack_detection,

			IRQF_SHARED, pdev->dev.driver->name, mc_drv_ctx);

	if (ret_val) {

		pr_err("cannot register IRQ\n");

		goto unalloc;

		return ret_val;

	}

	/* register the soc card */

	snd_soc_card_mfld.dev = &pdev->dev;

	ret_val = snd_soc_register_card(&snd_soc_card_mfld);

	if (ret_val) {

		pr_debug("snd_soc_register_card failed %d\n", ret_val);

		goto freeirq;

		return ret_val;

	}

	platform_set_drvdata(pdev, mc_drv_ctx);

	pr_debug("successfully exited probe\n");

	return ret_val;

freeirq:

	free_irq(irq, mc_drv_ctx);

unalloc:

	kfree(mc_drv_ctx);

	return ret_val;

	return 0;

}

static int snd_mfld_mc_remove(struct platform_device *pdev)

{

	struct mfld_mc_private *mc_drv_ctx = platform_get_drvdata(pdev);

	pr_debug("snd_mfld_mc_remove called\n");

	free_irq(platform_get_irq(pdev, 0), mc_drv_ctx);

	snd_soc_unregister_card(&snd_soc_card_mfld);

	kfree(mc_drv_ctx);

	platform_set_drvdata(pdev, NULL);

	return 0;

}