microcode_core.c 13.8 KB
Newer Older
Peter Oruba's avatar
Peter Oruba committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
/*
 *	Intel CPU Microcode Update Driver for Linux
 *
 *	Copyright (C) 2000-2006 Tigran Aivazian <tigran@aivazian.fsnet.co.uk>
 *		      2006	Shaohua Li <shaohua.li@intel.com>
 *
 *	This driver allows to upgrade microcode on Intel processors
 *	belonging to IA-32 family - PentiumPro, Pentium II,
 *	Pentium III, Xeon, Pentium 4, etc.
 *
 *	Reference: Section 8.11 of Volume 3a, IA-32 Intel? Architecture
 *	Software Developer's Manual
 *	Order Number 253668 or free download from:
 *
 *	http://developer.intel.com/design/pentium4/manuals/253668.htm
 *
 *	For more information, go to http://www.urbanmyth.org/microcode
 *
 *	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.
 *
 *	1.0	16 Feb 2000, Tigran Aivazian <tigran@sco.com>
 *		Initial release.
 *	1.01	18 Feb 2000, Tigran Aivazian <tigran@sco.com>
 *		Added read() support + cleanups.
 *	1.02	21 Feb 2000, Tigran Aivazian <tigran@sco.com>
 *		Added 'device trimming' support. open(O_WRONLY) zeroes
 *		and frees the saved copy of applied microcode.
 *	1.03	29 Feb 2000, Tigran Aivazian <tigran@sco.com>
 *		Made to use devfs (/dev/cpu/microcode) + cleanups.
 *	1.04	06 Jun 2000, Simon Trimmer <simon@veritas.com>
 *		Added misc device support (now uses both devfs and misc).
 *		Added MICROCODE_IOCFREE ioctl to clear memory.
 *	1.05	09 Jun 2000, Simon Trimmer <simon@veritas.com>
 *		Messages for error cases (non Intel & no suitable microcode).
 *	1.06	03 Aug 2000, Tigran Aivazian <tigran@veritas.com>
 *		Removed ->release(). Removed exclusive open and status bitmap.
 *		Added microcode_rwsem to serialize read()/write()/ioctl().
 *		Removed global kernel lock usage.
 *	1.07	07 Sep 2000, Tigran Aivazian <tigran@veritas.com>
 *		Write 0 to 0x8B msr and then cpuid before reading revision,
 *		so that it works even if there were no update done by the
 *		BIOS. Otherwise, reading from 0x8B gives junk (which happened
 *		to be 0 on my machine which is why it worked even when I
 *		disabled update by the BIOS)
 *		Thanks to Eric W. Biederman <ebiederman@lnxi.com> for the fix.
 *	1.08	11 Dec 2000, Richard Schaal <richard.schaal@intel.com> and
 *			     Tigran Aivazian <tigran@veritas.com>
 *		Intel Pentium 4 processor support and bugfixes.
 *	1.09	30 Oct 2001, Tigran Aivazian <tigran@veritas.com>
 *		Bugfix for HT (Hyper-Threading) enabled processors
 *		whereby processor resources are shared by all logical processors
 *		in a single CPU package.
 *	1.10	28 Feb 2002 Asit K Mallick <asit.k.mallick@intel.com> and
 *		Tigran Aivazian <tigran@veritas.com>,
58
59
 *		Serialize updates as required on HT processors due to
 *		speculative nature of implementation.
Peter Oruba's avatar
Peter Oruba committed
60
61
62
63
64
65
66
67
68
69
70
71
72
 *	1.11	22 Mar 2002 Tigran Aivazian <tigran@veritas.com>
 *		Fix the panic when writing zero-length microcode chunk.
 *	1.12	29 Sep 2003 Nitin Kamble <nitin.a.kamble@intel.com>,
 *		Jun Nakajima <jun.nakajima@intel.com>
 *		Support for the microcode updates in the new format.
 *	1.13	10 Oct 2003 Tigran Aivazian <tigran@veritas.com>
 *		Removed ->read() method and obsoleted MICROCODE_IOCFREE ioctl
 *		because we no longer hold a copy of applied microcode
 *		in kernel memory.
 *	1.14	25 Jun 2004 Tigran Aivazian <tigran@veritas.com>
 *		Fix sigmatch() macro to handle old CPUs with pf == 0.
 *		Thanks to Stuart Swales for pointing out this bug.
 */
73
74
75

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

Ingo Molnar's avatar
Ingo Molnar committed
76
77
#include <linux/platform_device.h>
#include <linux/miscdevice.h>
78
#include <linux/capability.h>
Ingo Molnar's avatar
Ingo Molnar committed
79
80
#include <linux/kernel.h>
#include <linux/module.h>
Peter Oruba's avatar
Peter Oruba committed
81
82
#include <linux/mutex.h>
#include <linux/cpu.h>
Ingo Molnar's avatar
Ingo Molnar committed
83
84
#include <linux/fs.h>
#include <linux/mm.h>
Peter Oruba's avatar
Peter Oruba committed
85
86

#include <asm/microcode.h>
Ingo Molnar's avatar
Ingo Molnar committed
87
#include <asm/processor.h>
Peter Oruba's avatar
Peter Oruba committed
88
89
90
91
92

MODULE_DESCRIPTION("Microcode Update Driver");
MODULE_AUTHOR("Tigran Aivazian <tigran@aivazian.fsnet.co.uk>");
MODULE_LICENSE("GPL");

Ingo Molnar's avatar
Ingo Molnar committed
93
#define MICROCODE_VERSION	"2.00"
Peter Oruba's avatar
Peter Oruba committed
94

Ingo Molnar's avatar
Ingo Molnar committed
95
static struct microcode_ops	*microcode_ops;
Peter Oruba's avatar
Peter Oruba committed
96

97
98
99
100
101
102
103
104
105
106
107
108
/*
 * Synchronization.
 *
 * All non cpu-hotplug-callback call sites use:
 *
 * - microcode_mutex to synchronize with each other;
 * - get/put_online_cpus() to synchronize with
 *   the cpu-hotplug-callback call sites.
 *
 * We guarantee that only a single cpu is being
 * updated at any particular moment of time.
 */
109
static DEFINE_MUTEX(microcode_mutex);
Peter Oruba's avatar
Peter Oruba committed
110

Ingo Molnar's avatar
Ingo Molnar committed
111
struct ucode_cpu_info		ucode_cpu_info[NR_CPUS];
Peter Oruba's avatar
Peter Oruba committed
112
EXPORT_SYMBOL_GPL(ucode_cpu_info);
Peter Oruba's avatar
Peter Oruba committed
113

114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
/*
 * Operations that are run on a target cpu:
 */

struct cpu_info_ctx {
	struct cpu_signature	*cpu_sig;
	int			err;
};

static void collect_cpu_info_local(void *arg)
{
	struct cpu_info_ctx *ctx = arg;

	ctx->err = microcode_ops->collect_cpu_info(smp_processor_id(),
						   ctx->cpu_sig);
}

static int collect_cpu_info_on_target(int cpu, struct cpu_signature *cpu_sig)
{
	struct cpu_info_ctx ctx = { .cpu_sig = cpu_sig, .err = 0 };
	int ret;

	ret = smp_call_function_single(cpu, collect_cpu_info_local, &ctx, 1);
	if (!ret)
		ret = ctx.err;

	return ret;
}

static int collect_cpu_info(int cpu)
{
	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
	int ret;

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

	ret = collect_cpu_info_on_target(cpu, &uci->cpu_sig);
	if (!ret)
		uci->valid = 1;

	return ret;
}

struct apply_microcode_ctx {
	int err;
};

static void apply_microcode_local(void *arg)
{
	struct apply_microcode_ctx *ctx = arg;

	ctx->err = microcode_ops->apply_microcode(smp_processor_id());
}

static int apply_microcode_on_target(int cpu)
{
	struct apply_microcode_ctx ctx = { .err = 0 };
	int ret;

	ret = smp_call_function_single(cpu, apply_microcode_local, &ctx, 1);
	if (!ret)
		ret = ctx.err;

	return ret;
}

Peter Oruba's avatar
Peter Oruba committed
180
#ifdef CONFIG_MICROCODE_OLD_INTERFACE
Dmitry Adamushko's avatar
Dmitry Adamushko committed
181
static int do_microcode_update(const void __user *buf, size_t size)
Peter Oruba's avatar
Peter Oruba committed
182
183
184
{
	int error = 0;
	int cpu;
185

Dmitry Adamushko's avatar
Dmitry Adamushko committed
186
187
	for_each_online_cpu(cpu) {
		struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
188
		enum ucode_state ustate;
Dmitry Adamushko's avatar
Dmitry Adamushko committed
189
190
191

		if (!uci->valid)
			continue;
192

193
194
195
196
197
198
		ustate = microcode_ops->request_microcode_user(cpu, buf, size);
		if (ustate == UCODE_ERROR) {
			error = -1;
			break;
		} else if (ustate == UCODE_OK)
			apply_microcode_on_target(cpu);
Peter Oruba's avatar
Peter Oruba committed
199
	}
200

Peter Oruba's avatar
Peter Oruba committed
201
202
203
	return error;
}

204
static int microcode_open(struct inode *unused1, struct file *unused2)
Peter Oruba's avatar
Peter Oruba committed
205
206
207
208
{
	return capable(CAP_SYS_RAWIO) ? 0 : -EPERM;
}

209
210
static ssize_t microcode_write(struct file *file, const char __user *buf,
			       size_t len, loff_t *ppos)
Peter Oruba's avatar
Peter Oruba committed
211
{
212
	ssize_t ret = -EINVAL;
Peter Oruba's avatar
Peter Oruba committed
213

214
	if ((len >> PAGE_SHIFT) > totalram_pages) {
215
		pr_err("too much data (max %ld pages)\n", totalram_pages);
216
		return ret;
Peter Oruba's avatar
Peter Oruba committed
217
218
219
220
221
	}

	get_online_cpus();
	mutex_lock(&microcode_mutex);

222
	if (do_microcode_update(buf, len) == 0)
Peter Oruba's avatar
Peter Oruba committed
223
224
225
226
227
228
229
230
231
		ret = (ssize_t)len;

	mutex_unlock(&microcode_mutex);
	put_online_cpus();

	return ret;
}

static const struct file_operations microcode_fops = {
232
233
234
	.owner			= THIS_MODULE,
	.write			= microcode_write,
	.open			= microcode_open,
Peter Oruba's avatar
Peter Oruba committed
235
236
237
};

static struct miscdevice microcode_dev = {
238
239
	.minor			= MICROCODE_MINOR,
	.name			= "microcode",
240
	.nodename		= "cpu/microcode",
241
	.fops			= &microcode_fops,
Peter Oruba's avatar
Peter Oruba committed
242
243
};

244
static int __init microcode_dev_init(void)
Peter Oruba's avatar
Peter Oruba committed
245
246
247
248
249
{
	int error;

	error = misc_register(&microcode_dev);
	if (error) {
250
		pr_err("can't misc_register on minor=%d\n", MICROCODE_MINOR);
Peter Oruba's avatar
Peter Oruba committed
251
252
253
254
255
256
		return error;
	}

	return 0;
}

257
static void microcode_dev_exit(void)
Peter Oruba's avatar
Peter Oruba committed
258
259
260
261
262
263
{
	misc_deregister(&microcode_dev);
}

MODULE_ALIAS_MISCDEV(MICROCODE_MINOR);
#else
Ingo Molnar's avatar
Ingo Molnar committed
264
265
#define microcode_dev_init()	0
#define microcode_dev_exit()	do { } while (0)
Peter Oruba's avatar
Peter Oruba committed
266
267
268
#endif

/* fake device for request_firmware */
Ingo Molnar's avatar
Ingo Molnar committed
269
static struct platform_device	*microcode_pdev;
Peter Oruba's avatar
Peter Oruba committed
270

271
static int reload_for_cpu(int cpu)
272
{
273
	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
274
275
276
277
	int err = 0;

	mutex_lock(&microcode_mutex);
	if (uci->valid) {
278
279
280
281
282
283
284
285
		enum ucode_state ustate;

		ustate = microcode_ops->request_microcode_fw(cpu, &microcode_pdev->dev);
		if (ustate == UCODE_OK)
			apply_microcode_on_target(cpu);
		else
			if (ustate == UCODE_ERROR)
				err = -EINVAL;
286
287
	}
	mutex_unlock(&microcode_mutex);
288

289
290
291
	return err;
}

Peter Oruba's avatar
Peter Oruba committed
292
293
static ssize_t reload_store(struct sys_device *dev,
			    struct sysdev_attribute *attr,
294
			    const char *buf, size_t size)
Peter Oruba's avatar
Peter Oruba committed
295
{
296
	unsigned long val;
Peter Oruba's avatar
Peter Oruba committed
297
	int cpu = dev->id;
298
299
	int ret = 0;
	char *end;
Peter Oruba's avatar
Peter Oruba committed
300

301
	val = simple_strtoul(buf, &end, 0);
Peter Oruba's avatar
Peter Oruba committed
302
303
	if (end == buf)
		return -EINVAL;
304

Peter Oruba's avatar
Peter Oruba committed
305
306
	if (val == 1) {
		get_online_cpus();
307
		if (cpu_online(cpu))
308
			ret = reload_for_cpu(cpu);
Peter Oruba's avatar
Peter Oruba committed
309
310
		put_online_cpus();
	}
311
312
313
314
315

	if (!ret)
		ret = size;

	return ret;
Peter Oruba's avatar
Peter Oruba committed
316
317
318
319
320
321
322
}

static ssize_t version_show(struct sys_device *dev,
			struct sysdev_attribute *attr, char *buf)
{
	struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;

323
	return sprintf(buf, "0x%x\n", uci->cpu_sig.rev);
Peter Oruba's avatar
Peter Oruba committed
324
325
326
327
328
329
330
}

static ssize_t pf_show(struct sys_device *dev,
			struct sysdev_attribute *attr, char *buf)
{
	struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;

331
	return sprintf(buf, "0x%x\n", uci->cpu_sig.pf);
Peter Oruba's avatar
Peter Oruba committed
332
333
334
335
336
337
338
339
340
341
342
343
344
345
}

static SYSDEV_ATTR(reload, 0200, NULL, reload_store);
static SYSDEV_ATTR(version, 0400, version_show, NULL);
static SYSDEV_ATTR(processor_flags, 0400, pf_show, NULL);

static struct attribute *mc_default_attrs[] = {
	&attr_reload.attr,
	&attr_version.attr,
	&attr_processor_flags.attr,
	NULL
};

static struct attribute_group mc_attr_group = {
346
347
	.attrs			= mc_default_attrs,
	.name			= "microcode",
Peter Oruba's avatar
Peter Oruba committed
348
349
};

350
static void microcode_fini_cpu(int cpu)
351
352
353
354
355
{
	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;

	microcode_ops->microcode_fini_cpu(cpu);
	uci->valid = 0;
356
357
}

358
static enum ucode_state microcode_resume_cpu(int cpu)
359
360
361
{
	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;

362
363
364
	if (!uci->mc)
		return UCODE_NFOUND;

365
	pr_debug("CPU%d updated upon resume\n", cpu);
366
367
368
	apply_microcode_on_target(cpu);

	return UCODE_OK;
369
370
}

371
static enum ucode_state microcode_init_cpu(int cpu)
372
{
373
	enum ucode_state ustate;
374

375
376
	if (collect_cpu_info(cpu))
		return UCODE_ERROR;
377

378
379
380
	/* --dimm. Trigger a delayed update? */
	if (system_state != SYSTEM_RUNNING)
		return UCODE_NFOUND;
381

382
	ustate = microcode_ops->request_microcode_fw(cpu, &microcode_pdev->dev);
383

384
	if (ustate == UCODE_OK) {
385
		pr_debug("CPU%d updated upon init\n", cpu);
386
		apply_microcode_on_target(cpu);
387
388
	}

389
	return ustate;
390
391
}

392
static enum ucode_state microcode_update_cpu(int cpu)
393
{
394
395
	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
	enum ucode_state ustate;
396

397
	if (uci->valid && uci->mc)
398
399
400
		ustate = microcode_resume_cpu(cpu);
	else
		ustate = microcode_init_cpu(cpu);
401

402
	return ustate;
403
404
405
}

static int mc_sysdev_add(struct sys_device *sys_dev)
Peter Oruba's avatar
Peter Oruba committed
406
407
408
409
410
411
{
	int err, cpu = sys_dev->id;

	if (!cpu_online(cpu))
		return 0;

412
	pr_debug("CPU%d added\n", cpu);
Peter Oruba's avatar
Peter Oruba committed
413
414
415
416
417

	err = sysfs_create_group(&sys_dev->kobj, &mc_attr_group);
	if (err)
		return err;

418
419
	if (microcode_init_cpu(cpu) == UCODE_ERROR)
		err = -EINVAL;
420
421

	return err;
Peter Oruba's avatar
Peter Oruba committed
422
423
424
425
426
427
428
429
430
}

static int mc_sysdev_remove(struct sys_device *sys_dev)
{
	int cpu = sys_dev->id;

	if (!cpu_online(cpu))
		return 0;

431
	pr_debug("CPU%d removed\n", cpu);
432
	microcode_fini_cpu(cpu);
Peter Oruba's avatar
Peter Oruba committed
433
434
435
436
437
438
439
	sysfs_remove_group(&sys_dev->kobj, &mc_attr_group);
	return 0;
}

static int mc_sysdev_resume(struct sys_device *dev)
{
	int cpu = dev->id;
440
	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
Peter Oruba's avatar
Peter Oruba committed
441
442
443

	if (!cpu_online(cpu))
		return 0;
Ingo Molnar's avatar
Ingo Molnar committed
444

445
446
447
448
449
450
451
452
453
454
455
456
	/*
	 * All non-bootup cpus are still disabled,
	 * so only CPU 0 will apply ucode here.
	 *
	 * Moreover, there can be no concurrent
	 * updates from any other places at this point.
	 */
	WARN_ON(cpu != 0);

	if (uci->valid && uci->mc)
		microcode_ops->apply_microcode(cpu);

Peter Oruba's avatar
Peter Oruba committed
457
458
459
460
	return 0;
}

static struct sysdev_driver mc_sysdev_driver = {
461
462
463
	.add			= mc_sysdev_add,
	.remove			= mc_sysdev_remove,
	.resume			= mc_sysdev_resume,
Peter Oruba's avatar
Peter Oruba committed
464
465
466
467
468
469
470
471
472
473
474
475
};

static __cpuinit int
mc_cpu_callback(struct notifier_block *nb, unsigned long action, void *hcpu)
{
	unsigned int cpu = (unsigned long)hcpu;
	struct sys_device *sys_dev;

	sys_dev = get_cpu_sysdev(cpu);
	switch (action) {
	case CPU_ONLINE:
	case CPU_ONLINE_FROZEN:
476
		microcode_update_cpu(cpu);
477
	case CPU_DOWN_FAILED:
Peter Oruba's avatar
Peter Oruba committed
478
	case CPU_DOWN_FAILED_FROZEN:
479
		pr_debug("CPU%d added\n", cpu);
Peter Oruba's avatar
Peter Oruba committed
480
		if (sysfs_create_group(&sys_dev->kobj, &mc_attr_group))
481
			pr_err("Failed to create group for CPU%d\n", cpu);
Peter Oruba's avatar
Peter Oruba committed
482
483
484
485
486
		break;
	case CPU_DOWN_PREPARE:
	case CPU_DOWN_PREPARE_FROZEN:
		/* Suspend is in progress, only remove the interface */
		sysfs_remove_group(&sys_dev->kobj, &mc_attr_group);
487
		pr_debug("CPU%d removed\n", cpu);
488
489
490
491
492
		break;
	case CPU_DEAD:
	case CPU_UP_CANCELED_FROZEN:
		/* The CPU refused to come up during a system resume */
		microcode_fini_cpu(cpu);
Peter Oruba's avatar
Peter Oruba committed
493
494
495
496
497
498
		break;
	}
	return NOTIFY_OK;
}

static struct notifier_block __refdata mc_cpu_notifier = {
Ingo Molnar's avatar
Ingo Molnar committed
499
	.notifier_call	= mc_cpu_callback,
Peter Oruba's avatar
Peter Oruba committed
500
501
};

502
static int __init microcode_init(void)
Peter Oruba's avatar
Peter Oruba committed
503
{
504
	struct cpuinfo_x86 *c = &cpu_data(0);
Peter Oruba's avatar
Peter Oruba committed
505
506
	int error;

507
508
	if (c->x86_vendor == X86_VENDOR_INTEL)
		microcode_ops = init_intel_microcode();
509
	else if (c->x86_vendor == X86_VENDOR_AMD)
510
		microcode_ops = init_amd_microcode();
Peter Oruba's avatar
Peter Oruba committed
511

512
	if (!microcode_ops) {
513
		pr_err("no support for this CPU vendor\n");
514
515
		return -ENODEV;
	}
Peter Oruba's avatar
Peter Oruba committed
516
517
518
519
520
521
522
523

	microcode_pdev = platform_device_register_simple("microcode", -1,
							 NULL, 0);
	if (IS_ERR(microcode_pdev)) {
		microcode_dev_exit();
		return PTR_ERR(microcode_pdev);
	}

524
525
526
	if (microcode_ops->init)
		microcode_ops->init(&microcode_pdev->dev);

Peter Oruba's avatar
Peter Oruba committed
527
	get_online_cpus();
528
529
	mutex_lock(&microcode_mutex);

Peter Oruba's avatar
Peter Oruba committed
530
	error = sysdev_driver_register(&cpu_sysdev_class, &mc_sysdev_driver);
531
532

	mutex_unlock(&microcode_mutex);
Peter Oruba's avatar
Peter Oruba committed
533
	put_online_cpus();
534

Peter Oruba's avatar
Peter Oruba committed
535
536
537
538
539
	if (error) {
		platform_device_unregister(microcode_pdev);
		return error;
	}

540
541
542
543
	error = microcode_dev_init();
	if (error)
		return error;

Peter Oruba's avatar
Peter Oruba committed
544
	register_hotcpu_notifier(&mc_cpu_notifier);
Peter Oruba's avatar
Peter Oruba committed
545

546
	pr_info("Microcode Update Driver: v" MICROCODE_VERSION
547
		" <tigran@aivazian.fsnet.co.uk>, Peter Oruba\n");
Peter Oruba's avatar
Peter Oruba committed
548

Peter Oruba's avatar
Peter Oruba committed
549
550
	return 0;
}
551
module_init(microcode_init);
Peter Oruba's avatar
Peter Oruba committed
552

553
static void __exit microcode_exit(void)
Peter Oruba's avatar
Peter Oruba committed
554
555
556
557
558
559
{
	microcode_dev_exit();

	unregister_hotcpu_notifier(&mc_cpu_notifier);

	get_online_cpus();
560
561
	mutex_lock(&microcode_mutex);

Peter Oruba's avatar
Peter Oruba committed
562
	sysdev_driver_unregister(&cpu_sysdev_class, &mc_sysdev_driver);
563
564

	mutex_unlock(&microcode_mutex);
Peter Oruba's avatar
Peter Oruba committed
565
566
567
568
	put_online_cpus();

	platform_device_unregister(microcode_pdev);

569
570
571
	if (microcode_ops->fini)
		microcode_ops->fini();

Peter Oruba's avatar
Peter Oruba committed
572
573
	microcode_ops = NULL;

574
	pr_info("Microcode Update Driver: v" MICROCODE_VERSION " removed.\n");
Peter Oruba's avatar
Peter Oruba committed
575
}
576
module_exit(microcode_exit);