Blame view
drivers/macintosh/rack-meter.c
15.4 KB
2c162f9b4
|
1 |
// SPDX-License-Identifier: GPL-2.0-only |
3e00a5aec
|
2 3 4 5 6 7 |
/* * RackMac vu-meter driver * * (c) Copyright 2006 Benjamin Herrenschmidt, IBM Corp. * <benh@kernel.crashing.org> * |
3e00a5aec
|
8 9 10 11 12 13 |
* Support the CPU-meter LEDs of the Xserve G5 * * TODO: Implement PWM to do variable intensity and provide userland * interface for fun. Also, the CPU-meter could be made nicer by being * a bit less "immediate" but giving instead a more average load over * time. Patches welcome :-) |
3e00a5aec
|
14 15 16 17 18 |
*/ #undef DEBUG #include <linux/types.h> #include <linux/kernel.h> |
5a0e3ad6a
|
19 |
#include <linux/slab.h> |
3e00a5aec
|
20 21 22 23 24 25 |
#include <linux/device.h> #include <linux/interrupt.h> #include <linux/module.h> #include <linux/pci.h> #include <linux/dma-mapping.h> #include <linux/kernel_stat.h> |
5af507300
|
26 27 |
#include <linux/of_address.h> #include <linux/of_irq.h> |
3e00a5aec
|
28 29 30 31 32 33 |
#include <asm/io.h> #include <asm/prom.h> #include <asm/machdep.h> #include <asm/pmac_feature.h> #include <asm/dbdma.h> |
3e00a5aec
|
34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
#include <asm/macio.h> #include <asm/keylargo.h> /* Number of samples in a sample buffer */ #define SAMPLE_COUNT 256 /* CPU meter sampling rate in ms */ #define CPU_SAMPLING_RATE 250 struct rackmeter_dma { struct dbdma_cmd cmd[4] ____cacheline_aligned; u32 mark ____cacheline_aligned; u32 buf1[SAMPLE_COUNT] ____cacheline_aligned; u32 buf2[SAMPLE_COUNT] ____cacheline_aligned; } ____cacheline_aligned; struct rackmeter_cpu { |
6d5aefb8e
|
51 52 |
struct delayed_work sniffer; struct rackmeter *rm; |
564b733c8
|
53 54 |
u64 prev_wall; u64 prev_idle; |
3e00a5aec
|
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 |
int zero; } ____cacheline_aligned; struct rackmeter { struct macio_dev *mdev; unsigned int irq; struct device_node *i2s; u8 *ubuf; struct dbdma_regs __iomem *dma_regs; void __iomem *i2s_regs; dma_addr_t dma_buf_p; struct rackmeter_dma *dma_buf_v; int stale_irq; struct rackmeter_cpu cpu[2]; int paused; struct mutex sem; }; /* To be set as a tunable */ static int rackmeter_ignore_nice; /* This GPIO is whacked by the OS X driver when initializing */ #define RACKMETER_MAGIC_GPIO 0x78 /* This is copied from cpufreq_ondemand, maybe we should put it in * a common header somewhere */ |
564b733c8
|
82 |
static inline u64 get_cpu_idle_time(unsigned int cpu) |
3e00a5aec
|
83 |
{ |
8392853e9
|
84 |
struct kernel_cpustat *kcpustat = &kcpustat_cpu(cpu); |
3292beb34
|
85 |
u64 retval; |
3e00a5aec
|
86 |
|
8392853e9
|
87 88 |
retval = kcpustat->cpustat[CPUTIME_IDLE] + kcpustat->cpustat[CPUTIME_IOWAIT]; |
3e00a5aec
|
89 90 |
if (rackmeter_ignore_nice) |
8392853e9
|
91 |
retval += kcpustat_field(kcpustat, CPUTIME_NICE, cpu); |
3e00a5aec
|
92 |
|
564b733c8
|
93 |
return retval; |
3e00a5aec
|
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 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 |
} static void rackmeter_setup_i2s(struct rackmeter *rm) { struct macio_chip *macio = rm->mdev->bus->chip; /* First whack magic GPIO */ pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, RACKMETER_MAGIC_GPIO, 5); /* Call feature code to enable the sound channel and the proper * clock sources */ pmac_call_feature(PMAC_FTR_SOUND_CHIP_ENABLE, rm->i2s, 0, 1); /* Power i2s and stop i2s clock. We whack MacIO FCRs directly for now. * This is a bit racy, thus we should add new platform functions to * handle that. snd-aoa needs that too */ MACIO_BIS(KEYLARGO_FCR1, KL1_I2S0_ENABLE); MACIO_BIC(KEYLARGO_FCR1, KL1_I2S0_CLK_ENABLE_BIT); (void)MACIO_IN32(KEYLARGO_FCR1); udelay(10); /* Then setup i2s. For now, we use the same magic value that * the OS X driver seems to use. We might want to play around * with the clock divisors later */ out_le32(rm->i2s_regs + 0x10, 0x01fa0000); (void)in_le32(rm->i2s_regs + 0x10); udelay(10); /* Fully restart i2s*/ MACIO_BIS(KEYLARGO_FCR1, KL1_I2S0_CELL_ENABLE | KL1_I2S0_CLK_ENABLE_BIT); (void)MACIO_IN32(KEYLARGO_FCR1); udelay(10); } static void rackmeter_set_default_pattern(struct rackmeter *rm) { int i; for (i = 0; i < 16; i++) { if (i < 8) rm->ubuf[i] = (i & 1) * 255; else rm->ubuf[i] = ((~i) & 1) * 255; } } static void rackmeter_do_pause(struct rackmeter *rm, int pause) { struct rackmeter_dma *rdma = rm->dma_buf_v; pr_debug("rackmeter: %s ", pause ? "paused" : "started"); rm->paused = pause; if (pause) { DBDMA_DO_STOP(rm->dma_regs); return; } |
e283655b5
|
157 158 |
memset(rdma->buf1, 0, sizeof(rdma->buf1)); memset(rdma->buf2, 0, sizeof(rdma->buf2)); |
3e00a5aec
|
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 |
rm->dma_buf_v->mark = 0; mb(); out_le32(&rm->dma_regs->cmdptr_hi, 0); out_le32(&rm->dma_regs->cmdptr, rm->dma_buf_p); out_le32(&rm->dma_regs->control, (RUN << 16) | RUN); } static void rackmeter_setup_dbdma(struct rackmeter *rm) { struct rackmeter_dma *db = rm->dma_buf_v; struct dbdma_cmd *cmd = db->cmd; /* Make sure dbdma is reset */ DBDMA_DO_RESET(rm->dma_regs); |
193d07329
|
175 176 |
pr_debug("rackmeter: mark offset=0x%zx ", |
3e00a5aec
|
177 |
offsetof(struct rackmeter_dma, mark)); |
193d07329
|
178 179 |
pr_debug("rackmeter: buf1 offset=0x%zx ", |
3e00a5aec
|
180 |
offsetof(struct rackmeter_dma, buf1)); |
193d07329
|
181 182 |
pr_debug("rackmeter: buf2 offset=0x%zx ", |
3e00a5aec
|
183 184 185 186 |
offsetof(struct rackmeter_dma, buf2)); /* Prepare 4 dbdma commands for the 2 buffers */ memset(cmd, 0, 4 * sizeof(struct dbdma_cmd)); |
f57187267
|
187 188 189 |
cmd->req_count = cpu_to_le16(4); cmd->command = cpu_to_le16(STORE_WORD | INTR_ALWAYS | KEY_SYSTEM); cmd->phy_addr = cpu_to_le32(rm->dma_buf_p + |
3e00a5aec
|
190 |
offsetof(struct rackmeter_dma, mark)); |
f57187267
|
191 |
cmd->cmd_dep = cpu_to_le32(0x02000000); |
3e00a5aec
|
192 |
cmd++; |
f57187267
|
193 194 195 |
cmd->req_count = cpu_to_le16(SAMPLE_COUNT * 4); cmd->command = cpu_to_le16(OUTPUT_MORE); cmd->phy_addr = cpu_to_le32(rm->dma_buf_p + |
3e00a5aec
|
196 197 |
offsetof(struct rackmeter_dma, buf1)); cmd++; |
f57187267
|
198 199 200 |
cmd->req_count = cpu_to_le16(4); cmd->command = cpu_to_le16(STORE_WORD | INTR_ALWAYS | KEY_SYSTEM); cmd->phy_addr = cpu_to_le32(rm->dma_buf_p + |
3e00a5aec
|
201 |
offsetof(struct rackmeter_dma, mark)); |
f57187267
|
202 |
cmd->cmd_dep = cpu_to_le32(0x01000000); |
3e00a5aec
|
203 |
cmd++; |
f57187267
|
204 205 206 |
cmd->req_count = cpu_to_le16(SAMPLE_COUNT * 4); cmd->command = cpu_to_le16(OUTPUT_MORE | BR_ALWAYS); cmd->phy_addr = cpu_to_le32(rm->dma_buf_p + |
3e00a5aec
|
207 |
offsetof(struct rackmeter_dma, buf2)); |
f57187267
|
208 |
cmd->cmd_dep = cpu_to_le32(rm->dma_buf_p); |
3e00a5aec
|
209 210 211 |
rackmeter_do_pause(rm, 0); } |
6d5aefb8e
|
212 |
static void rackmeter_do_timer(struct work_struct *work) |
3e00a5aec
|
213 |
{ |
6d5aefb8e
|
214 215 216 |
struct rackmeter_cpu *rcpu = container_of(work, struct rackmeter_cpu, sniffer.work); struct rackmeter *rm = rcpu->rm; |
3e00a5aec
|
217 |
unsigned int cpu = smp_processor_id(); |
564b733c8
|
218 219 |
u64 cur_nsecs, total_idle_nsecs; u64 total_nsecs, idle_nsecs; |
3e00a5aec
|
220 |
int i, offset, load, cumm, pause; |
564b733c8
|
221 222 223 |
cur_nsecs = jiffies64_to_nsecs(get_jiffies_64()); total_nsecs = cur_nsecs - rcpu->prev_wall; rcpu->prev_wall = cur_nsecs; |
3e00a5aec
|
224 |
|
564b733c8
|
225 226 227 228 |
total_idle_nsecs = get_cpu_idle_time(cpu); idle_nsecs = total_idle_nsecs - rcpu->prev_idle; idle_nsecs = min(idle_nsecs, total_nsecs); rcpu->prev_idle = total_idle_nsecs; |
3e00a5aec
|
229 230 231 232 |
/* We do a very dumb calculation to update the LEDs for now, * we'll do better once we have actual PWM implemented */ |
564b733c8
|
233 |
load = div64_u64(9 * (total_nsecs - idle_nsecs), total_nsecs); |
3e00a5aec
|
234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 |
offset = cpu << 3; cumm = 0; for (i = 0; i < 8; i++) { u8 ub = (load > i) ? 0xff : 0; rm->ubuf[i + offset] = ub; cumm |= ub; } rcpu->zero = (cumm == 0); /* Now check if LEDs are all 0, we can stop DMA */ pause = (rm->cpu[0].zero && rm->cpu[1].zero); if (pause != rm->paused) { mutex_lock(&rm->sem); pause = (rm->cpu[0].zero && rm->cpu[1].zero); rackmeter_do_pause(rm, pause); mutex_unlock(&rm->sem); } schedule_delayed_work_on(cpu, &rcpu->sniffer, msecs_to_jiffies(CPU_SAMPLING_RATE)); } |
1da42fb6b
|
255 |
static void rackmeter_init_cpu_sniffer(struct rackmeter *rm) |
3e00a5aec
|
256 257 258 259 260 261 262 263 |
{ unsigned int cpu; /* This driver works only with 1 or 2 CPUs numbered 0 and 1, * but that's really all we have on Apple Xserve. It doesn't * play very nice with CPU hotplug neither but we don't do that * on those machines yet */ |
6d5aefb8e
|
264 265 266 267 |
rm->cpu[0].rm = rm; INIT_DELAYED_WORK(&rm->cpu[0].sniffer, rackmeter_do_timer); rm->cpu[1].rm = rm; INIT_DELAYED_WORK(&rm->cpu[1].sniffer, rackmeter_do_timer); |
3e00a5aec
|
268 269 270 271 272 273 |
for_each_online_cpu(cpu) { struct rackmeter_cpu *rcpu; if (cpu > 1) continue; |
a419aef8b
|
274 |
rcpu = &rm->cpu[cpu]; |
3e00a5aec
|
275 |
rcpu->prev_idle = get_cpu_idle_time(cpu); |
564b733c8
|
276 |
rcpu->prev_wall = jiffies64_to_nsecs(get_jiffies_64()); |
3e00a5aec
|
277 278 279 280 |
schedule_delayed_work_on(cpu, &rm->cpu[cpu].sniffer, msecs_to_jiffies(CPU_SAMPLING_RATE)); } } |
e1f4dea45
|
281 |
static void rackmeter_stop_cpu_sniffer(struct rackmeter *rm) |
3e00a5aec
|
282 |
{ |
afe2c511f
|
283 284 |
cancel_delayed_work_sync(&rm->cpu[0].sniffer); cancel_delayed_work_sync(&rm->cpu[1].sniffer); |
3e00a5aec
|
285 |
} |
1da42fb6b
|
286 |
static int rackmeter_setup(struct rackmeter *rm) |
3e00a5aec
|
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 |
{ pr_debug("rackmeter: setting up i2s.. "); rackmeter_setup_i2s(rm); pr_debug("rackmeter: setting up default pattern.. "); rackmeter_set_default_pattern(rm); pr_debug("rackmeter: setting up dbdma.. "); rackmeter_setup_dbdma(rm); pr_debug("rackmeter: start CPU measurements.. "); rackmeter_init_cpu_sniffer(rm); printk(KERN_INFO "RackMeter initialized "); return 0; } /* XXX FIXME: No PWM yet, this is 0/1 */ static u32 rackmeter_calc_sample(struct rackmeter *rm, unsigned int index) { int led; u32 sample = 0; for (led = 0; led < 16; led++) { sample >>= 1; sample |= ((rm->ubuf[led] >= 0x80) << 15); } return (sample << 17) | (sample >> 15); } static irqreturn_t rackmeter_irq(int irq, void *arg) { struct rackmeter *rm = arg; struct rackmeter_dma *db = rm->dma_buf_v; unsigned int mark, i; u32 *buf; /* Flush PCI buffers with an MMIO read. Maybe we could actually * check the status one day ... in case things go wrong, though * this never happened to me */ (void)in_le32(&rm->dma_regs->status); /* Make sure the CPU gets us in order */ rmb(); /* Read mark */ mark = db->mark; if (mark != 1 && mark != 2) { printk(KERN_WARNING "rackmeter: Incorrect DMA mark 0x%08x ", mark); /* We allow for 3 errors like that (stale DBDMA irqs) */ if (++rm->stale_irq > 3) { printk(KERN_ERR "rackmeter: Too many errors," " stopping DMA "); DBDMA_DO_RESET(rm->dma_regs); } return IRQ_HANDLED; } /* Next buffer we need to fill is mark value */ buf = mark == 1 ? db->buf1 : db->buf2; /* Fill it now. This routine converts the 8 bits depth sample array * into the PWM bitmap for each LED. */ for (i = 0; i < SAMPLE_COUNT; i++) buf[i] = rackmeter_calc_sample(rm, i); return IRQ_HANDLED; } |
1da42fb6b
|
367 368 |
static int rackmeter_probe(struct macio_dev* mdev, const struct of_device_id *match) |
3e00a5aec
|
369 370 371 372 373 374 375 376 377 378 |
{ struct device_node *i2s = NULL, *np = NULL; struct rackmeter *rm = NULL; struct resource ri2s, rdma; int rc = -ENODEV; pr_debug("rackmeter_probe() "); /* Get i2s-a node */ |
f1e0addca
|
379 380 381 |
for_each_child_of_node(mdev->ofdev.dev.of_node, i2s) if (of_node_name_eq(i2s, "i2s-a")) break; |
3e00a5aec
|
382 383 384 385 386 387 |
if (i2s == NULL) { pr_debug(" i2s-a child not found "); goto bail; } /* Get lightshow or virtual sound */ |
f1e0addca
|
388 389 |
for_each_child_of_node(i2s, np) { if (of_node_name_eq(np, "lightshow")) |
3e00a5aec
|
390 |
break; |
f1e0addca
|
391 |
if (of_node_name_eq(np, "sound") && |
01b2726dd
|
392 |
of_get_property(np, "virtual", NULL) != NULL) |
3e00a5aec
|
393 394 395 396 397 398 399 400 401 |
break; } if (np == NULL) { pr_debug(" lightshow or sound+virtual child not found "); goto bail; } /* Create and initialize our instance data */ |
a0828cf57
|
402 |
rm = kzalloc(sizeof(*rm), GFP_KERNEL); |
3e00a5aec
|
403 404 405 406 407 408 409 410 411 412 413 414 415 416 |
if (rm == NULL) { printk(KERN_ERR "rackmeter: failed to allocate memory ! "); rc = -ENOMEM; goto bail_release; } rm->mdev = mdev; rm->i2s = i2s; mutex_init(&rm->sem); dev_set_drvdata(&mdev->ofdev.dev, rm); /* Check resources availability. We need at least resource 0 and 1 */ #if 0 /* Use that when i2s-a is finally an mdev per-se */ if (macio_resource_count(mdev) < 2 || macio_irq_count(mdev) < 2) { printk(KERN_ERR |
b6a945ae0
|
417 |
"rackmeter: found match but lacks resources: %pOF" |
3e00a5aec
|
418 419 |
" (%d resources, %d interrupts) ", |
b6a945ae0
|
420 |
mdev->ofdev.dev.of_node); |
3e00a5aec
|
421 422 423 424 425 |
rc = -ENXIO; goto bail_free; } if (macio_request_resources(mdev, "rackmeter")) { printk(KERN_ERR |
b6a945ae0
|
426 427 428 |
"rackmeter: failed to request resources: %pOF ", mdev->ofdev.dev.of_node); |
3e00a5aec
|
429 430 431 432 433 434 |
rc = -EBUSY; goto bail_free; } rm->irq = macio_irq(mdev, 1); #else rm->irq = irq_of_parse_and_map(i2s, 1); |
ef24ba709
|
435 |
if (!rm->irq || |
3e00a5aec
|
436 437 438 |
of_address_to_resource(i2s, 0, &ri2s) || of_address_to_resource(i2s, 1, &rdma)) { printk(KERN_ERR |
b6a945ae0
|
439 440 |
"rackmeter: found match but lacks resources: %pOF", mdev->ofdev.dev.of_node); |
3e00a5aec
|
441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 |
rc = -ENXIO; goto bail_free; } #endif pr_debug(" i2s @0x%08x ", (unsigned int)ri2s.start); pr_debug(" dma @0x%08x ", (unsigned int)rdma.start); pr_debug(" irq %d ", rm->irq); rm->ubuf = (u8 *)__get_free_page(GFP_KERNEL); if (rm->ubuf == NULL) { printk(KERN_ERR "rackmeter: failed to allocate samples page ! "); rc = -ENOMEM; goto bail_release; } rm->dma_buf_v = dma_alloc_coherent(&macio_get_pci_dev(mdev)->dev, sizeof(struct rackmeter_dma), &rm->dma_buf_p, GFP_KERNEL); if (rm->dma_buf_v == NULL) { printk(KERN_ERR "rackmeter: failed to allocate dma buffer ! "); rc = -ENOMEM; goto bail_free_samples; } #if 0 rm->i2s_regs = ioremap(macio_resource_start(mdev, 0), 0x1000); #else rm->i2s_regs = ioremap(ri2s.start, 0x1000); #endif if (rm->i2s_regs == NULL) { printk(KERN_ERR "rackmeter: failed to map i2s registers ! "); rc = -ENXIO; goto bail_free_dma; } #if 0 rm->dma_regs = ioremap(macio_resource_start(mdev, 1), 0x100); #else rm->dma_regs = ioremap(rdma.start, 0x100); #endif if (rm->dma_regs == NULL) { printk(KERN_ERR "rackmeter: failed to map dma registers ! "); rc = -ENXIO; goto bail_unmap_i2s; } rc = rackmeter_setup(rm); if (rc) { printk(KERN_ERR "rackmeter: failed to initialize ! "); rc = -ENXIO; goto bail_unmap_dma; } rc = request_irq(rm->irq, rackmeter_irq, 0, "rackmeter", rm); if (rc != 0) { printk(KERN_ERR "rackmeter: failed to request interrupt ! "); goto bail_stop_dma; } of_node_put(np); return 0; bail_stop_dma: DBDMA_DO_RESET(rm->dma_regs); bail_unmap_dma: iounmap(rm->dma_regs); bail_unmap_i2s: iounmap(rm->i2s_regs); bail_free_dma: dma_free_coherent(&macio_get_pci_dev(mdev)->dev, sizeof(struct rackmeter_dma), rm->dma_buf_v, rm->dma_buf_p); bail_free_samples: free_page((unsigned long)rm->ubuf); bail_release: #if 0 macio_release_resources(mdev); #endif bail_free: kfree(rm); bail: of_node_put(i2s); of_node_put(np); dev_set_drvdata(&mdev->ofdev.dev, NULL); return rc; } |
1da42fb6b
|
540 |
static int rackmeter_remove(struct macio_dev* mdev) |
3e00a5aec
|
541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 |
{ struct rackmeter *rm = dev_get_drvdata(&mdev->ofdev.dev); /* Stop CPU sniffer timer & work queues */ rackmeter_stop_cpu_sniffer(rm); /* Clear reference to private data */ dev_set_drvdata(&mdev->ofdev.dev, NULL); /* Stop/reset dbdma */ DBDMA_DO_RESET(rm->dma_regs); /* Release the IRQ */ free_irq(rm->irq, rm); /* Unmap registers */ iounmap(rm->dma_regs); iounmap(rm->i2s_regs); /* Free DMA */ dma_free_coherent(&macio_get_pci_dev(mdev)->dev, sizeof(struct rackmeter_dma), rm->dma_buf_v, rm->dma_buf_p); /* Free samples */ free_page((unsigned long)rm->ubuf); #if 0 /* Release resources */ macio_release_resources(mdev); #endif /* Get rid of me */ kfree(rm); return 0; } static int rackmeter_shutdown(struct macio_dev* mdev) { struct rackmeter *rm = dev_get_drvdata(&mdev->ofdev.dev); if (rm == NULL) return -ENODEV; /* Stop CPU sniffer timer & work queues */ rackmeter_stop_cpu_sniffer(rm); /* Stop/reset dbdma */ DBDMA_DO_RESET(rm->dma_regs); return 0; } |
516fa8d0e
|
594 |
static const struct of_device_id rackmeter_match[] = { |
3e00a5aec
|
595 596 597 |
{ .name = "i2s" }, { } }; |
6735b2e98
|
598 |
MODULE_DEVICE_TABLE(of, rackmeter_match); |
3e00a5aec
|
599 |
|
31421a6f6
|
600 |
static struct macio_driver rackmeter_driver = { |
c2cdf6aba
|
601 602 603 604 605 |
.driver = { .name = "rackmeter", .owner = THIS_MODULE, .of_match_table = rackmeter_match, }, |
3e00a5aec
|
606 |
.probe = rackmeter_probe, |
1da42fb6b
|
607 |
.remove = rackmeter_remove, |
3e00a5aec
|
608 609 610 611 612 613 614 615 |
.shutdown = rackmeter_shutdown, }; static int __init rackmeter_init(void) { pr_debug("rackmeter_init() "); |
31421a6f6
|
616 |
return macio_register_driver(&rackmeter_driver); |
3e00a5aec
|
617 618 619 620 621 622 |
} static void __exit rackmeter_exit(void) { pr_debug("rackmeter_exit() "); |
31421a6f6
|
623 |
macio_unregister_driver(&rackmeter_driver); |
3e00a5aec
|
624 625 626 627 628 629 630 631 632 |
} module_init(rackmeter_init); module_exit(rackmeter_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>"); MODULE_DESCRIPTION("RackMeter: Support vu-meter on XServe front panel"); |