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