[xeon-phi-kernel-module] / vcons / hvc_mic.c

/*
 * Copyright 2010-2017 Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2,
 * as published by the Free Software Foundation.
 *
 * 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.
 *
 * Disclaimer: The codes contained in these modules may be specific to
 * the Intel Software Development Platform codenamed Knights Ferry,
 * and the Intel product codenamed Knights Corner, and are not backward
 * compatible with other Intel products. Additionally, Intel will NOT
 * support the codes or instruction set in future products.
 *
 * Intel offers no warranty of any kind regarding the code. This code is
 * licensed on an "AS IS" basis and Intel is not obligated to provide
 * any support, assistance, installation, training, or other services
 * of any kind. Intel is also not obligated to provide any updates,
 * enhancements or extensions. Intel specifically disclaims any warranty
 * of merchantability, non-infringement, fitness for any particular
 * purpose, and any other warranty.
 *
 * Further, Intel disclaims all liability of any kind, including but
 * not limited to liability for infringement of any proprietary rights,
 * relating to the use of the code, even if Intel is notified of the
 * possibility of such liability. Except as expressly stated in an Intel
 * license agreement provided with this code and agreed upon with Intel,
 * no license, express or implied, by estoppel or otherwise, to any
 * intellectual property rights is granted herein.
 */

#include <linux/module.h>
#include <linux/mm.h>
#include "hvc_console.h"
#include <mic/micscif_rb.h>
#include <mic/micvcons.h>
#include <asm/io.h>
#include <linux/errno.h>
#include <linux/hardirq.h>
#include <linux/types.h>
#include <linux/capability.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/gfp.h>
#include <linux/vmalloc.h>
#include <asm/io.h>
#include <linux/kernel.h>
#include <linux/mm_types.h>
#include <linux/jiffies.h>
#include <linux/timer.h>
#include <linux/irqflags.h>
#include <linux/time.h>
#include <linux/spinlock.h>
#include <linux/mutex.h>
#include <linux/semaphore.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/delay.h>
#include <linux/wait.h>
#include <asm/bug.h>
#include <linux/pci.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/list.h>
#include <linux/workqueue.h>
#include <linux/interrupt.h>
#include <asm/atomic.h>
#include <linux/netdevice.h>
#include <linux/debugfs.h>
#include <linux/interrupt.h>
#include <asm/mic/mic_common.h>

#define MIC_COOKIE 	0xc0c0
#define MIC_KNC		1

static long vcons_hdr_addr;
static struct micscif_rb mic_out_buf;
static struct micscif_rb mic_in_buf;

struct vcons_info {
	struct vcons_buf *hdr;
	struct vcons_mic_header *mic_hdr;
	char *vcons_op_buf;
	char *vcons_ip_buf;
};

static struct vcons_info vcons_info;
static int dbg = 0;

/* Receive data from the host (mic i/p buffer) */
static int hvc_mic_get_chars(uint32_t vt, char *buf, int count)
{
	int ret, len, get_count;

	len = micscif_rb_count(&mic_in_buf, count);
	get_count = min(len, count);
	ret = micscif_rb_get_next(&mic_in_buf, buf, get_count);
	if (ret == get_count)
		micscif_rb_update_read_ptr(&mic_in_buf);

	return ret;
}

/* Send data to the host (mic o/p buffer) */
static int hvc_mic_put_chars(uint32_t vt, const char *buf, int count)
{
	int ret;
	int put_count;
	volatile int *host_status =
		(volatile int *)&vcons_info.mic_hdr->host_status;
	
	put_count = min(micscif_rb_space(&mic_out_buf), count);
	if (put_count) {
		ret = micscif_rb_write(&mic_out_buf, (void *)buf, put_count);
		BUG_ON(ret);
		micscif_rb_commit(&mic_out_buf);
	} else if (*host_status != MIC_VCONS_HOST_OPEN)
		return count;
	return put_count;
}


static irqreturn_t hvc_mic_handle_interrupt(int irq, void *dev_id)
{
	struct hvc_struct *hp = (struct hvc_struct *)dev_id;
	if (hvc_poll(hp)) {
		hvc_kick();
		return IRQ_HANDLED;
	}
	return IRQ_NONE;
}

static int hvc_mic_notifier_add_irq(struct hvc_struct *hp, int irq)
{
	int ret = request_irq(get_sbox_irq(HVC_SBOX_INT_IDX),
				hvc_mic_handle_interrupt, IRQF_DISABLED,
				"hvc intr", hp);
	if (ret) {
		printk("Unable to register interrupt\n");
		return ret;
	}
	hp->irq_requested = 1;
	return 0;
}

static void hvc_mic_notifier_del_irq(struct hvc_struct *hp, int irq)
{
	if (hp->irq_requested) {
		free_irq(get_sbox_irq(HVC_SBOX_INT_IDX), hp);
		hp->irq_requested = 0;
	}
}

static void hvc_mic_notifier_hangup_irq(struct hvc_struct *hp, int irq)
{
	hvc_mic_notifier_del_irq(hp, irq);
}

static const struct hv_ops hvc_mic_ops = {
	.get_chars = hvc_mic_get_chars,
	.put_chars = hvc_mic_put_chars,
	.notifier_add = hvc_mic_notifier_add_irq,
	.notifier_del = hvc_mic_notifier_del_irq,
	.notifier_hangup = hvc_mic_notifier_hangup_irq,
};

static void dump_vcons_hdr(struct vcons_buf *hdr)
{
	printk(KERN_ERR "host_magic\t%x\n", readl(&hdr->host_magic));
	printk(KERN_ERR "mic_magic\t%x\n", readl(&hdr->mic_magic));
	printk(KERN_ERR "o_buf_dma_addr\t%x\n", readl(&hdr->o_buf_dma_addr));
	printk(KERN_ERR "o_wr\t%x\n", readl(&hdr->o_wr));
	printk(KERN_ERR "o_size\t%x\n", readl(&hdr->o_size));
	printk(KERN_ERR "i_hdr_addr\t%lx\n", readq(&hdr->i_hdr_addr));
	printk(KERN_ERR "i_buf_addr\t%lx\n", readq(&hdr->i_buf_addr));
	printk(KERN_ERR "i_rd\t%x\n", readl(&hdr->i_rd));
}

static int mic_cons_init(void)
{
	int rc;

	if ((rc = hvc_instantiate(MIC_COOKIE, 0, &hvc_mic_ops)))
		printk(KERN_ERR "error instantiating hvc console\n");

	return rc;
}

static struct hvc_struct *hp;
static int __init hvc_mic_init(void)
{
	struct vcons_buf *hdr = NULL;
	struct vcons_buf tmp_hdr;
	int err = 0;
	char *hvc_buf;
	u8 card_type=0;
	uint16_t host_rb_ver, mic_rb_ver;

#if defined(CONFIG_MK1OM)
	card_type = MIC_KNC;
#endif
	hvc_buf = (char *)get_zeroed_page(GFP_KERNEL);
	if (!hvc_buf) {
		printk(KERN_ERR "unable to allocate vcons buffer\n");
		return -ENOMEM;
	}
	if (card_type == MIC_KNC) {
		vcons_info.vcons_ip_buf = hvc_buf;
		vcons_info.mic_hdr = (struct vcons_mic_header *)kzalloc(sizeof(struct vcons_mic_header), GFP_KERNEL);
		if (!vcons_info.mic_hdr) {
			free_page((unsigned long)hvc_buf);
			printk(KERN_ERR "unable to allocate vcons header\n");
			return -ENOMEM;
		}
	} else {
		vcons_info.vcons_ip_buf = hvc_buf + PAGE_SIZE/2;
		vcons_info.mic_hdr = (struct vcons_mic_header *)hvc_buf;
	}

	vcons_info.hdr = hdr = ioremap_nocache(vcons_hdr_addr, 
			sizeof(struct vcons_buf));
	if (!hdr) {
		printk(KERN_ERR "unable to map vcons header\n");
		err = -ENOMEM;
		goto error;
	}

	if (dbg)
		dump_vcons_hdr(hdr);

	if (readl(&hdr->host_magic) != MIC_HOST_VCONS_READY) {
		printk(KERN_ERR "host not ready, giving up\n");
		err = -ENODEV;
		goto error;
	}

	host_rb_ver = readw(&hdr->host_rb_ver);
	mic_rb_ver = micscif_rb_get_version();
	writew(mic_rb_ver, &hdr->mic_rb_ver);
	if (host_rb_ver != mic_rb_ver) {
		printk(KERN_ERR "Card and host ring buffer versions mismatch.");
		printk(KERN_ERR "Card ver: %d, Host ver: %d \n", mic_rb_ver,
								host_rb_ver);
		writel(MIC_VCONS_RB_VER_ERR, &hdr->mic_magic);
		err = -ENXIO;
		goto error;
	}
	memcpy_fromio(&tmp_hdr, hdr, sizeof(struct vcons_buf));

	if (!(vcons_info.vcons_op_buf = ioremap_nocache(tmp_hdr.o_buf_dma_addr, 
							tmp_hdr.o_size))) {
		printk(KERN_ERR "unable to map vcons output buffer\n");
		err = -ENOMEM;
		goto error;
	}

	tmp_hdr.i_hdr_addr = virt_to_phys(vcons_info.mic_hdr);
	tmp_hdr.i_buf_addr = virt_to_phys(vcons_info.vcons_ip_buf);

	if (card_type == MIC_KNC)
		tmp_hdr.i_size = PAGE_SIZE;
	else
		tmp_hdr.i_size = PAGE_SIZE/2;

	micscif_rb_init(&mic_out_buf, (volatile uint32_t *)&vcons_info.mic_hdr->o_rd,
			(volatile uint32_t *)&hdr->o_wr,
			(volatile uint32_t *)vcons_info.vcons_op_buf,
			tmp_hdr.o_size);

	micscif_rb_init(&mic_in_buf,
			(volatile uint32_t *)&hdr->i_rd,
			(volatile uint32_t *)&vcons_info.mic_hdr->i_wr,
			(volatile uint32_t *)vcons_info.vcons_ip_buf,
			tmp_hdr.i_size);

	mic_cons_init();
	hp = hvc_alloc(MIC_COOKIE, 2, &hvc_mic_ops, 128);

	if (IS_ERR(hp)) {
		printk(KERN_ERR "unable to allocate hvc console\n");
		err = PTR_ERR(hp);
	} else {
		writeq(tmp_hdr.i_hdr_addr, &hdr->i_hdr_addr);
		writeq(tmp_hdr.i_buf_addr, &hdr->i_buf_addr);
		writel(tmp_hdr.i_size, &hdr->i_size);
		writel(MIC_VCONS_READY, &hdr->mic_magic);
		if (dbg)
			dump_vcons_hdr(hdr);

		return 0;
	}
error:
	if (hdr)
		iounmap(hdr);
	if (vcons_info.vcons_op_buf)
		iounmap(vcons_info.vcons_op_buf);
#if defined(CONFIG_MK1OM)
	free_page((unsigned long)vcons_info.vcons_ip_buf);
	kfree(vcons_info.mic_hdr);
#else
	free_page((unsigned long)vcons_info.mic_hdr);
#endif
	return err;
}

static void __exit hvc_mic_exit(void)
{
	char buf[8];
	int ret, len;

	writel(0, &vcons_info.hdr->mic_magic);

	do {
		len = micscif_rb_count(&mic_in_buf, sizeof(buf));
		ret = micscif_rb_get_next(&mic_in_buf, buf,
				min(len, (int)sizeof(buf)));
	} while (ret > 0);

	iounmap(vcons_info.hdr);
	iounmap(vcons_info.vcons_op_buf);
#if defined(CONFIG_MK1OM)
	free_page((unsigned long)vcons_info.vcons_ip_buf);
	kfree(vcons_info.mic_hdr);
#else
	free_page((unsigned long)vcons_info.mic_hdr);
#endif
	if (hp)
		hvc_remove(hp);
}

MODULE_PARM_DESC(vcons_hdr_addr, "mic address of vcons hdr");
module_param(vcons_hdr_addr, long, S_IRUGO);
module_param(dbg, int, S_IRUGO);
MODULE_LICENSE("GPL");
module_init(hvc_mic_init);
module_exit(hvc_mic_exit);
Commit	Line	Data
800f879a AT	1	/*
	2	* Copyright 2010-2017 Intel Corporation.
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License, version 2,
	6	* as published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	11	* General Public License for more details.
	12	*
	13	* Disclaimer: The codes contained in these modules may be specific to
	14	* the Intel Software Development Platform codenamed Knights Ferry,
	15	* and the Intel product codenamed Knights Corner, and are not backward
	16	* compatible with other Intel products. Additionally, Intel will NOT
	17	* support the codes or instruction set in future products.
	18	*
	19	* Intel offers no warranty of any kind regarding the code. This code is
	20	* licensed on an "AS IS" basis and Intel is not obligated to provide
	21	* any support, assistance, installation, training, or other services
	22	* of any kind. Intel is also not obligated to provide any updates,
	23	* enhancements or extensions. Intel specifically disclaims any warranty
	24	* of merchantability, non-infringement, fitness for any particular
	25	* purpose, and any other warranty.
	26	*
	27	* Further, Intel disclaims all liability of any kind, including but
	28	* not limited to liability for infringement of any proprietary rights,
	29	* relating to the use of the code, even if Intel is notified of the
	30	* possibility of such liability. Except as expressly stated in an Intel
	31	* license agreement provided with this code and agreed upon with Intel,
	32	* no license, express or implied, by estoppel or otherwise, to any
	33	* intellectual property rights is granted herein.
	34	*/
	35
	36	#include <linux/module.h>
	37	#include <linux/mm.h>
	38	#include "hvc_console.h"
	39	#include <mic/micscif_rb.h>
	40	#include <mic/micvcons.h>
	41	#include <asm/io.h>
	42	#include <linux/errno.h>
	43	#include <linux/hardirq.h>
	44	#include <linux/types.h>
	45	#include <linux/capability.h>
	46	#include <linux/slab.h>
	47	#include <linux/string.h>
	48	#include <linux/gfp.h>
	49	#include <linux/vmalloc.h>
	50	#include <asm/io.h>
	51	#include <linux/kernel.h>
	52	#include <linux/mm_types.h>
	53	#include <linux/jiffies.h>
	54	#include <linux/timer.h>
	55	#include <linux/irqflags.h>
	56	#include <linux/time.h>
	57	#include <linux/spinlock.h>
	58	#include <linux/mutex.h>
	59	#include <linux/semaphore.h>
	60	#include <linux/kthread.h>
	61	#include <linux/sched.h>
	62	#include <linux/delay.h>
	63	#include <linux/wait.h>
	64	#include <asm/bug.h>
65	#include <linux/pci.h>
66	#include <linux/device.h>
67	#include <linux/fs.h>
68	#include <linux/list.h>
69	#include <linux/workqueue.h>
70	#include <linux/interrupt.h>
71	#include <asm/atomic.h>
72	#include <linux/netdevice.h>
73	#include <linux/debugfs.h>
74	#include <linux/interrupt.h>
75	#include <asm/mic/mic_common.h>
76
77	#define MIC_COOKIE 0xc0c0
78	#define MIC_KNC 1
79
80	static long vcons_hdr_addr;
81	static struct micscif_rb mic_out_buf;
82	static struct micscif_rb mic_in_buf;
83
84	struct vcons_info {
85	struct vcons_buf *hdr;
86	struct vcons_mic_header *mic_hdr;
87	char *vcons_op_buf;
88	char *vcons_ip_buf;
89	};
90
91	static struct vcons_info vcons_info;
92	static int dbg = 0;
93
94	/* Receive data from the host (mic i/p buffer) */
95	static int hvc_mic_get_chars(uint32_t vt, char *buf, int count)
96	{
97	int ret, len, get_count;
98
99	len = micscif_rb_count(&mic_in_buf, count);
100	get_count = min(len, count);
101	ret = micscif_rb_get_next(&mic_in_buf, buf, get_count);
102	if (ret == get_count)
103	micscif_rb_update_read_ptr(&mic_in_buf);
104
105	return ret;
106	}
107
108	/* Send data to the host (mic o/p buffer) */
109	static int hvc_mic_put_chars(uint32_t vt, const char *buf, int count)
110	{
111	int ret;
112	int put_count;
113	volatile int *host_status =
114	(volatile int *)&vcons_info.mic_hdr->host_status;
115
116	put_count = min(micscif_rb_space(&mic_out_buf), count);
117	if (put_count) {
118	ret = micscif_rb_write(&mic_out_buf, (void *)buf, put_count);
119	BUG_ON(ret);
120	micscif_rb_commit(&mic_out_buf);
121	} else if (*host_status != MIC_VCONS_HOST_OPEN)
122	return count;
123	return put_count;
124	}
125
126
127	static irqreturn_t hvc_mic_handle_interrupt(int irq, void *dev_id)
128	{
129	struct hvc_struct hp = (struct hvc_struct )dev_id;
130	if (hvc_poll(hp)) {
131	hvc_kick();
132	return IRQ_HANDLED;
133	}
134	return IRQ_NONE;
135	}
136
137	static int hvc_mic_notifier_add_irq(struct hvc_struct *hp, int irq)
138	{
139	int ret = request_irq(get_sbox_irq(HVC_SBOX_INT_IDX),
140	hvc_mic_handle_interrupt, IRQF_DISABLED,
141	"hvc intr", hp);
142	if (ret) {
143	printk("Unable to register interrupt\n");
144	return ret;
145	}
146	hp->irq_requested = 1;
147	return 0;
148	}
149
150	static void hvc_mic_notifier_del_irq(struct hvc_struct *hp, int irq)
151	{
152	if (hp->irq_requested) {
153	free_irq(get_sbox_irq(HVC_SBOX_INT_IDX), hp);
154	hp->irq_requested = 0;
155	}
156	}
157
158	static void hvc_mic_notifier_hangup_irq(struct hvc_struct *hp, int irq)
159	{
160	hvc_mic_notifier_del_irq(hp, irq);
161	}
162
163	static const struct hv_ops hvc_mic_ops = {
164	.get_chars = hvc_mic_get_chars,
165	.put_chars = hvc_mic_put_chars,
166	.notifier_add = hvc_mic_notifier_add_irq,
167	.notifier_del = hvc_mic_notifier_del_irq,
168	.notifier_hangup = hvc_mic_notifier_hangup_irq,
169	};
170
171	static void dump_vcons_hdr(struct vcons_buf *hdr)
172	{
173	printk(KERN_ERR "host_magic\t%x\n", readl(&hdr->host_magic));
174	printk(KERN_ERR "mic_magic\t%x\n", readl(&hdr->mic_magic));
175	printk(KERN_ERR "o_buf_dma_addr\t%x\n", readl(&hdr->o_buf_dma_addr));
176	printk(KERN_ERR "o_wr\t%x\n", readl(&hdr->o_wr));
177	printk(KERN_ERR "o_size\t%x\n", readl(&hdr->o_size));
178	printk(KERN_ERR "i_hdr_addr\t%lx\n", readq(&hdr->i_hdr_addr));
179	printk(KERN_ERR "i_buf_addr\t%lx\n", readq(&hdr->i_buf_addr));
180	printk(KERN_ERR "i_rd\t%x\n", readl(&hdr->i_rd));
181	}
182
183	static int mic_cons_init(void)
184	{
185	int rc;
186
187	if ((rc = hvc_instantiate(MIC_COOKIE, 0, &hvc_mic_ops)))
188	printk(KERN_ERR "error instantiating hvc console\n");
189
190	return rc;
191	}
192
193	static struct hvc_struct *hp;
194	static int __init hvc_mic_init(void)
195	{
196	struct vcons_buf *hdr = NULL;
197	struct vcons_buf tmp_hdr;
198	int err = 0;
199	char *hvc_buf;
200	u8 card_type=0;
201	uint16_t host_rb_ver, mic_rb_ver;
202
203	#if defined(CONFIG_MK1OM)
204	card_type = MIC_KNC;
205	#endif
206	hvc_buf = (char *)get_zeroed_page(GFP_KERNEL);
207	if (!hvc_buf) {
208	printk(KERN_ERR "unable to allocate vcons buffer\n");
209	return -ENOMEM;
210	}
211	if (card_type == MIC_KNC) {
212	vcons_info.vcons_ip_buf = hvc_buf;
213	vcons_info.mic_hdr = (struct vcons_mic_header *)kzalloc(sizeof(struct vcons_mic_header), GFP_KERNEL);
214	if (!vcons_info.mic_hdr) {
215	free_page((unsigned long)hvc_buf);
216	printk(KERN_ERR "unable to allocate vcons header\n");
217	return -ENOMEM;
218	}
219	} else {
220	vcons_info.vcons_ip_buf = hvc_buf + PAGE_SIZE/2;
221	vcons_info.mic_hdr = (struct vcons_mic_header *)hvc_buf;
222	}
223
224	vcons_info.hdr = hdr = ioremap_nocache(vcons_hdr_addr,
225	sizeof(struct vcons_buf));
226	if (!hdr) {
227	printk(KERN_ERR "unable to map vcons header\n");
228	err = -ENOMEM;
229	goto error;
230	}
231
232	if (dbg)
233	dump_vcons_hdr(hdr);
234
235	if (readl(&hdr->host_magic) != MIC_HOST_VCONS_READY) {
236	printk(KERN_ERR "host not ready, giving up\n");
237	err = -ENODEV;
238	goto error;
239	}
240
241	host_rb_ver = readw(&hdr->host_rb_ver);
242	mic_rb_ver = micscif_rb_get_version();
243	writew(mic_rb_ver, &hdr->mic_rb_ver);
244	if (host_rb_ver != mic_rb_ver) {
245	printk(KERN_ERR "Card and host ring buffer versions mismatch.");
246	printk(KERN_ERR "Card ver: %d, Host ver: %d \n", mic_rb_ver,
247	host_rb_ver);
248	writel(MIC_VCONS_RB_VER_ERR, &hdr->mic_magic);
249	err = -ENXIO;
250	goto error;
251	}
252	memcpy_fromio(&tmp_hdr, hdr, sizeof(struct vcons_buf));
253
254	if (!(vcons_info.vcons_op_buf = ioremap_nocache(tmp_hdr.o_buf_dma_addr,
255	tmp_hdr.o_size))) {
256	printk(KERN_ERR "unable to map vcons output buffer\n");
257	err = -ENOMEM;
258	goto error;
259	}
260
261	tmp_hdr.i_hdr_addr = virt_to_phys(vcons_info.mic_hdr);
262	tmp_hdr.i_buf_addr = virt_to_phys(vcons_info.vcons_ip_buf);
263
264	if (card_type == MIC_KNC)
265	tmp_hdr.i_size = PAGE_SIZE;
266	else
267	tmp_hdr.i_size = PAGE_SIZE/2;
268
269	micscif_rb_init(&mic_out_buf, (volatile uint32_t *)&vcons_info.mic_hdr->o_rd,
270	(volatile uint32_t *)&hdr->o_wr,
271	(volatile uint32_t *)vcons_info.vcons_op_buf,
272	tmp_hdr.o_size);
273
274	micscif_rb_init(&mic_in_buf,
275	(volatile uint32_t *)&hdr->i_rd,
276	(volatile uint32_t *)&vcons_info.mic_hdr->i_wr,
277	(volatile uint32_t *)vcons_info.vcons_ip_buf,
278	tmp_hdr.i_size);
279
280	mic_cons_init();
281	hp = hvc_alloc(MIC_COOKIE, 2, &hvc_mic_ops, 128);
282
283	if (IS_ERR(hp)) {
284	printk(KERN_ERR "unable to allocate hvc console\n");
285	err = PTR_ERR(hp);
286	} else {
287	writeq(tmp_hdr.i_hdr_addr, &hdr->i_hdr_addr);
288	writeq(tmp_hdr.i_buf_addr, &hdr->i_buf_addr);
289	writel(tmp_hdr.i_size, &hdr->i_size);
290	writel(MIC_VCONS_READY, &hdr->mic_magic);
291	if (dbg)
292	dump_vcons_hdr(hdr);
293
294	return 0;
295	}
296	error:
297	if (hdr)
298	iounmap(hdr);
299	if (vcons_info.vcons_op_buf)
300	iounmap(vcons_info.vcons_op_buf);
301	#if defined(CONFIG_MK1OM)
302	free_page((unsigned long)vcons_info.vcons_ip_buf);
303	kfree(vcons_info.mic_hdr);
304	#else
305	free_page((unsigned long)vcons_info.mic_hdr);
306	#endif
307	return err;
308	}
309
310	static void __exit hvc_mic_exit(void)
311	{
312	char buf[8];
313	int ret, len;
314
315	writel(0, &vcons_info.hdr->mic_magic);
316
317	do {
318	len = micscif_rb_count(&mic_in_buf, sizeof(buf));
319	ret = micscif_rb_get_next(&mic_in_buf, buf,
320	min(len, (int)sizeof(buf)));
321	} while (ret > 0);
322
323	iounmap(vcons_info.hdr);
324	iounmap(vcons_info.vcons_op_buf);
325	#if defined(CONFIG_MK1OM)
326	free_page((unsigned long)vcons_info.vcons_ip_buf);
327	kfree(vcons_info.mic_hdr);
328	#else
329	free_page((unsigned long)vcons_info.mic_hdr);
330	#endif
331	if (hp)
332	hvc_remove(hp);
333	}
334
335	MODULE_PARM_DESC(vcons_hdr_addr, "mic address of vcons hdr");
336	module_param(vcons_hdr_addr, long, S_IRUGO);
337	module_param(dbg, int, S_IRUGO);
338	MODULE_LICENSE("GPL");
339	module_init(hvc_mic_init);
340	module_exit(hvc_mic_exit);
341