Loading...
1/*
2 * Copyright (C) ST-Ericsson SA 2010
3 *
4 * Author: Mattias Wallin <mattias.wallin@stericsson.com> for ST-Ericsson.
5 * License Terms: GNU General Public License v2
6 */
7
8#include <linux/seq_file.h>
9#include <linux/uaccess.h>
10#include <linux/fs.h>
11#include <linux/debugfs.h>
12#include <linux/platform_device.h>
13
14#include <linux/mfd/abx500.h>
15#include <linux/mfd/ab8500.h>
16
17static u32 debug_bank;
18static u32 debug_address;
19
20/**
21 * struct ab8500_reg_range
22 * @first: the first address of the range
23 * @last: the last address of the range
24 * @perm: access permissions for the range
25 */
26struct ab8500_reg_range {
27 u8 first;
28 u8 last;
29 u8 perm;
30};
31
32/**
33 * struct ab8500_i2c_ranges
34 * @num_ranges: the number of ranges in the list
35 * @bankid: bank identifier
36 * @range: the list of register ranges
37 */
38struct ab8500_i2c_ranges {
39 u8 num_ranges;
40 u8 bankid;
41 const struct ab8500_reg_range *range;
42};
43
44#define AB8500_NAME_STRING "ab8500"
45#define AB8500_NUM_BANKS 22
46
47#define AB8500_REV_REG 0x80
48
49static struct ab8500_i2c_ranges debug_ranges[AB8500_NUM_BANKS] = {
50 [0x0] = {
51 .num_ranges = 0,
52 .range = 0,
53 },
54 [AB8500_SYS_CTRL1_BLOCK] = {
55 .num_ranges = 3,
56 .range = (struct ab8500_reg_range[]) {
57 {
58 .first = 0x00,
59 .last = 0x02,
60 },
61 {
62 .first = 0x42,
63 .last = 0x42,
64 },
65 {
66 .first = 0x80,
67 .last = 0x81,
68 },
69 },
70 },
71 [AB8500_SYS_CTRL2_BLOCK] = {
72 .num_ranges = 4,
73 .range = (struct ab8500_reg_range[]) {
74 {
75 .first = 0x00,
76 .last = 0x0D,
77 },
78 {
79 .first = 0x0F,
80 .last = 0x17,
81 },
82 {
83 .first = 0x30,
84 .last = 0x30,
85 },
86 {
87 .first = 0x32,
88 .last = 0x33,
89 },
90 },
91 },
92 [AB8500_REGU_CTRL1] = {
93 .num_ranges = 3,
94 .range = (struct ab8500_reg_range[]) {
95 {
96 .first = 0x00,
97 .last = 0x00,
98 },
99 {
100 .first = 0x03,
101 .last = 0x10,
102 },
103 {
104 .first = 0x80,
105 .last = 0x84,
106 },
107 },
108 },
109 [AB8500_REGU_CTRL2] = {
110 .num_ranges = 5,
111 .range = (struct ab8500_reg_range[]) {
112 {
113 .first = 0x00,
114 .last = 0x15,
115 },
116 {
117 .first = 0x17,
118 .last = 0x19,
119 },
120 {
121 .first = 0x1B,
122 .last = 0x1D,
123 },
124 {
125 .first = 0x1F,
126 .last = 0x22,
127 },
128 {
129 .first = 0x40,
130 .last = 0x44,
131 },
132 /* 0x80-0x8B is SIM registers and should
133 * not be accessed from here */
134 },
135 },
136 [AB8500_USB] = {
137 .num_ranges = 2,
138 .range = (struct ab8500_reg_range[]) {
139 {
140 .first = 0x80,
141 .last = 0x83,
142 },
143 {
144 .first = 0x87,
145 .last = 0x8A,
146 },
147 },
148 },
149 [AB8500_TVOUT] = {
150 .num_ranges = 9,
151 .range = (struct ab8500_reg_range[]) {
152 {
153 .first = 0x00,
154 .last = 0x12,
155 },
156 {
157 .first = 0x15,
158 .last = 0x17,
159 },
160 {
161 .first = 0x19,
162 .last = 0x21,
163 },
164 {
165 .first = 0x27,
166 .last = 0x2C,
167 },
168 {
169 .first = 0x41,
170 .last = 0x41,
171 },
172 {
173 .first = 0x45,
174 .last = 0x5B,
175 },
176 {
177 .first = 0x5D,
178 .last = 0x5D,
179 },
180 {
181 .first = 0x69,
182 .last = 0x69,
183 },
184 {
185 .first = 0x80,
186 .last = 0x81,
187 },
188 },
189 },
190 [AB8500_DBI] = {
191 .num_ranges = 0,
192 .range = NULL,
193 },
194 [AB8500_ECI_AV_ACC] = {
195 .num_ranges = 1,
196 .range = (struct ab8500_reg_range[]) {
197 {
198 .first = 0x80,
199 .last = 0x82,
200 },
201 },
202 },
203 [0x9] = {
204 .num_ranges = 0,
205 .range = NULL,
206 },
207 [AB8500_GPADC] = {
208 .num_ranges = 1,
209 .range = (struct ab8500_reg_range[]) {
210 {
211 .first = 0x00,
212 .last = 0x08,
213 },
214 },
215 },
216 [AB8500_CHARGER] = {
217 .num_ranges = 8,
218 .range = (struct ab8500_reg_range[]) {
219 {
220 .first = 0x00,
221 .last = 0x03,
222 },
223 {
224 .first = 0x05,
225 .last = 0x05,
226 },
227 {
228 .first = 0x40,
229 .last = 0x40,
230 },
231 {
232 .first = 0x42,
233 .last = 0x42,
234 },
235 {
236 .first = 0x44,
237 .last = 0x44,
238 },
239 {
240 .first = 0x50,
241 .last = 0x55,
242 },
243 {
244 .first = 0x80,
245 .last = 0x82,
246 },
247 {
248 .first = 0xC0,
249 .last = 0xC2,
250 },
251 },
252 },
253 [AB8500_GAS_GAUGE] = {
254 .num_ranges = 3,
255 .range = (struct ab8500_reg_range[]) {
256 {
257 .first = 0x00,
258 .last = 0x00,
259 },
260 {
261 .first = 0x07,
262 .last = 0x0A,
263 },
264 {
265 .first = 0x10,
266 .last = 0x14,
267 },
268 },
269 },
270 [AB8500_AUDIO] = {
271 .num_ranges = 1,
272 .range = (struct ab8500_reg_range[]) {
273 {
274 .first = 0x00,
275 .last = 0x6F,
276 },
277 },
278 },
279 [AB8500_INTERRUPT] = {
280 .num_ranges = 0,
281 .range = NULL,
282 },
283 [AB8500_RTC] = {
284 .num_ranges = 1,
285 .range = (struct ab8500_reg_range[]) {
286 {
287 .first = 0x00,
288 .last = 0x0F,
289 },
290 },
291 },
292 [AB8500_MISC] = {
293 .num_ranges = 8,
294 .range = (struct ab8500_reg_range[]) {
295 {
296 .first = 0x00,
297 .last = 0x05,
298 },
299 {
300 .first = 0x10,
301 .last = 0x15,
302 },
303 {
304 .first = 0x20,
305 .last = 0x25,
306 },
307 {
308 .first = 0x30,
309 .last = 0x35,
310 },
311 {
312 .first = 0x40,
313 .last = 0x45,
314 },
315 {
316 .first = 0x50,
317 .last = 0x50,
318 },
319 {
320 .first = 0x60,
321 .last = 0x67,
322 },
323 {
324 .first = 0x80,
325 .last = 0x80,
326 },
327 },
328 },
329 [0x11] = {
330 .num_ranges = 0,
331 .range = NULL,
332 },
333 [0x12] = {
334 .num_ranges = 0,
335 .range = NULL,
336 },
337 [0x13] = {
338 .num_ranges = 0,
339 .range = NULL,
340 },
341 [0x14] = {
342 .num_ranges = 0,
343 .range = NULL,
344 },
345 [AB8500_OTP_EMUL] = {
346 .num_ranges = 1,
347 .range = (struct ab8500_reg_range[]) {
348 {
349 .first = 0x01,
350 .last = 0x0F,
351 },
352 },
353 },
354};
355
356static int ab8500_registers_print(struct seq_file *s, void *p)
357{
358 struct device *dev = s->private;
359 unsigned int i;
360 u32 bank = debug_bank;
361
362 seq_printf(s, AB8500_NAME_STRING " register values:\n");
363
364 seq_printf(s, " bank %u:\n", bank);
365 for (i = 0; i < debug_ranges[bank].num_ranges; i++) {
366 u32 reg;
367
368 for (reg = debug_ranges[bank].range[i].first;
369 reg <= debug_ranges[bank].range[i].last;
370 reg++) {
371 u8 value;
372 int err;
373
374 err = abx500_get_register_interruptible(dev,
375 (u8)bank, (u8)reg, &value);
376 if (err < 0) {
377 dev_err(dev, "ab->read fail %d\n", err);
378 return err;
379 }
380
381 err = seq_printf(s, " [%u/0x%02X]: 0x%02X\n", bank,
382 reg, value);
383 if (err < 0) {
384 dev_err(dev, "seq_printf overflow\n");
385 /* Error is not returned here since
386 * the output is wanted in any case */
387 return 0;
388 }
389 }
390 }
391 return 0;
392}
393
394static int ab8500_registers_open(struct inode *inode, struct file *file)
395{
396 return single_open(file, ab8500_registers_print, inode->i_private);
397}
398
399static const struct file_operations ab8500_registers_fops = {
400 .open = ab8500_registers_open,
401 .read = seq_read,
402 .llseek = seq_lseek,
403 .release = single_release,
404 .owner = THIS_MODULE,
405};
406
407static int ab8500_bank_print(struct seq_file *s, void *p)
408{
409 return seq_printf(s, "%d\n", debug_bank);
410}
411
412static int ab8500_bank_open(struct inode *inode, struct file *file)
413{
414 return single_open(file, ab8500_bank_print, inode->i_private);
415}
416
417static ssize_t ab8500_bank_write(struct file *file,
418 const char __user *user_buf,
419 size_t count, loff_t *ppos)
420{
421 struct device *dev = ((struct seq_file *)(file->private_data))->private;
422 unsigned long user_bank;
423 int err;
424
425 /* Get userspace string and assure termination */
426 err = kstrtoul_from_user(user_buf, count, 0, &user_bank);
427 if (err)
428 return err;
429
430 if (user_bank >= AB8500_NUM_BANKS) {
431 dev_err(dev, "debugfs error input > number of banks\n");
432 return -EINVAL;
433 }
434
435 debug_bank = user_bank;
436
437 return count;
438}
439
440static int ab8500_address_print(struct seq_file *s, void *p)
441{
442 return seq_printf(s, "0x%02X\n", debug_address);
443}
444
445static int ab8500_address_open(struct inode *inode, struct file *file)
446{
447 return single_open(file, ab8500_address_print, inode->i_private);
448}
449
450static ssize_t ab8500_address_write(struct file *file,
451 const char __user *user_buf,
452 size_t count, loff_t *ppos)
453{
454 struct device *dev = ((struct seq_file *)(file->private_data))->private;
455 unsigned long user_address;
456 int err;
457
458 /* Get userspace string and assure termination */
459 err = kstrtoul_from_user(user_buf, count, 0, &user_address);
460 if (err)
461 return err;
462
463 if (user_address > 0xff) {
464 dev_err(dev, "debugfs error input > 0xff\n");
465 return -EINVAL;
466 }
467 debug_address = user_address;
468 return count;
469}
470
471static int ab8500_val_print(struct seq_file *s, void *p)
472{
473 struct device *dev = s->private;
474 int ret;
475 u8 regvalue;
476
477 ret = abx500_get_register_interruptible(dev,
478 (u8)debug_bank, (u8)debug_address, ®value);
479 if (ret < 0) {
480 dev_err(dev, "abx500_get_reg fail %d, %d\n",
481 ret, __LINE__);
482 return -EINVAL;
483 }
484 seq_printf(s, "0x%02X\n", regvalue);
485
486 return 0;
487}
488
489static int ab8500_val_open(struct inode *inode, struct file *file)
490{
491 return single_open(file, ab8500_val_print, inode->i_private);
492}
493
494static ssize_t ab8500_val_write(struct file *file,
495 const char __user *user_buf,
496 size_t count, loff_t *ppos)
497{
498 struct device *dev = ((struct seq_file *)(file->private_data))->private;
499 unsigned long user_val;
500 int err;
501
502 /* Get userspace string and assure termination */
503 err = kstrtoul_from_user(user_buf, count, 0, &user_val);
504 if (err)
505 return err;
506
507 if (user_val > 0xff) {
508 dev_err(dev, "debugfs error input > 0xff\n");
509 return -EINVAL;
510 }
511 err = abx500_set_register_interruptible(dev,
512 (u8)debug_bank, debug_address, (u8)user_val);
513 if (err < 0) {
514 printk(KERN_ERR "abx500_set_reg failed %d, %d", err, __LINE__);
515 return -EINVAL;
516 }
517
518 return count;
519}
520
521static const struct file_operations ab8500_bank_fops = {
522 .open = ab8500_bank_open,
523 .write = ab8500_bank_write,
524 .read = seq_read,
525 .llseek = seq_lseek,
526 .release = single_release,
527 .owner = THIS_MODULE,
528};
529
530static const struct file_operations ab8500_address_fops = {
531 .open = ab8500_address_open,
532 .write = ab8500_address_write,
533 .read = seq_read,
534 .llseek = seq_lseek,
535 .release = single_release,
536 .owner = THIS_MODULE,
537};
538
539static const struct file_operations ab8500_val_fops = {
540 .open = ab8500_val_open,
541 .write = ab8500_val_write,
542 .read = seq_read,
543 .llseek = seq_lseek,
544 .release = single_release,
545 .owner = THIS_MODULE,
546};
547
548static struct dentry *ab8500_dir;
549static struct dentry *ab8500_reg_file;
550static struct dentry *ab8500_bank_file;
551static struct dentry *ab8500_address_file;
552static struct dentry *ab8500_val_file;
553
554static int __devinit ab8500_debug_probe(struct platform_device *plf)
555{
556 debug_bank = AB8500_MISC;
557 debug_address = AB8500_REV_REG & 0x00FF;
558
559 ab8500_dir = debugfs_create_dir(AB8500_NAME_STRING, NULL);
560 if (!ab8500_dir)
561 goto exit_no_debugfs;
562
563 ab8500_reg_file = debugfs_create_file("all-bank-registers",
564 S_IRUGO, ab8500_dir, &plf->dev, &ab8500_registers_fops);
565 if (!ab8500_reg_file)
566 goto exit_destroy_dir;
567
568 ab8500_bank_file = debugfs_create_file("register-bank",
569 (S_IRUGO | S_IWUSR), ab8500_dir, &plf->dev, &ab8500_bank_fops);
570 if (!ab8500_bank_file)
571 goto exit_destroy_reg;
572
573 ab8500_address_file = debugfs_create_file("register-address",
574 (S_IRUGO | S_IWUSR), ab8500_dir, &plf->dev,
575 &ab8500_address_fops);
576 if (!ab8500_address_file)
577 goto exit_destroy_bank;
578
579 ab8500_val_file = debugfs_create_file("register-value",
580 (S_IRUGO | S_IWUSR), ab8500_dir, &plf->dev, &ab8500_val_fops);
581 if (!ab8500_val_file)
582 goto exit_destroy_address;
583
584 return 0;
585
586exit_destroy_address:
587 debugfs_remove(ab8500_address_file);
588exit_destroy_bank:
589 debugfs_remove(ab8500_bank_file);
590exit_destroy_reg:
591 debugfs_remove(ab8500_reg_file);
592exit_destroy_dir:
593 debugfs_remove(ab8500_dir);
594exit_no_debugfs:
595 dev_err(&plf->dev, "failed to create debugfs entries.\n");
596 return -ENOMEM;
597}
598
599static int __devexit ab8500_debug_remove(struct platform_device *plf)
600{
601 debugfs_remove(ab8500_val_file);
602 debugfs_remove(ab8500_address_file);
603 debugfs_remove(ab8500_bank_file);
604 debugfs_remove(ab8500_reg_file);
605 debugfs_remove(ab8500_dir);
606
607 return 0;
608}
609
610static struct platform_driver ab8500_debug_driver = {
611 .driver = {
612 .name = "ab8500-debug",
613 .owner = THIS_MODULE,
614 },
615 .probe = ab8500_debug_probe,
616 .remove = __devexit_p(ab8500_debug_remove)
617};
618
619static int __init ab8500_debug_init(void)
620{
621 return platform_driver_register(&ab8500_debug_driver);
622}
623
624static void __exit ab8500_debug_exit(void)
625{
626 platform_driver_unregister(&ab8500_debug_driver);
627}
628subsys_initcall(ab8500_debug_init);
629module_exit(ab8500_debug_exit);
630
631MODULE_AUTHOR("Mattias WALLIN <mattias.wallin@stericsson.com");
632MODULE_DESCRIPTION("AB8500 DEBUG");
633MODULE_LICENSE("GPL v2");
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) ST-Ericsson SA 2010
4 *
5 * Author: Mattias Wallin <mattias.wallin@stericsson.com> for ST-Ericsson.
6 */
7/*
8 * AB8500 register access
9 * ======================
10 *
11 * read:
12 * # echo BANK > <debugfs>/ab8500/register-bank
13 * # echo ADDR > <debugfs>/ab8500/register-address
14 * # cat <debugfs>/ab8500/register-value
15 *
16 * write:
17 * # echo BANK > <debugfs>/ab8500/register-bank
18 * # echo ADDR > <debugfs>/ab8500/register-address
19 * # echo VALUE > <debugfs>/ab8500/register-value
20 *
21 * read all registers from a bank:
22 * # echo BANK > <debugfs>/ab8500/register-bank
23 * # cat <debugfs>/ab8500/all-bank-register
24 *
25 * BANK target AB8500 register bank
26 * ADDR target AB8500 register address
27 * VALUE decimal or 0x-prefixed hexadecimal
28 *
29 *
30 * User Space notification on AB8500 IRQ
31 * =====================================
32 *
33 * Allows user space entity to be notified when target AB8500 IRQ occurs.
34 * When subscribed, a sysfs entry is created in ab8500.i2c platform device.
35 * One can pool this file to get target IRQ occurence information.
36 *
37 * subscribe to an AB8500 IRQ:
38 * # echo IRQ > <debugfs>/ab8500/irq-subscribe
39 *
40 * unsubscribe from an AB8500 IRQ:
41 * # echo IRQ > <debugfs>/ab8500/irq-unsubscribe
42 *
43 *
44 * AB8500 register formated read/write access
45 * ==========================================
46 *
47 * Read: read data, data>>SHIFT, data&=MASK, output data
48 * [0xABCDEF98] shift=12 mask=0xFFF => 0x00000CDE
49 * Write: read data, data &= ~(MASK<<SHIFT), data |= (VALUE<<SHIFT), write data
50 * [0xABCDEF98] shift=12 mask=0xFFF value=0x123 => [0xAB123F98]
51 *
52 * Usage:
53 * # echo "CMD [OPTIONS] BANK ADRESS [VALUE]" > $debugfs/ab8500/hwreg
54 *
55 * CMD read read access
56 * write write access
57 *
58 * BANK target reg bank
59 * ADDRESS target reg address
60 * VALUE (write) value to be updated
61 *
62 * OPTIONS
63 * -d|-dec (read) output in decimal
64 * -h|-hexa (read) output in 0x-hexa (default)
65 * -l|-w|-b 32bit (default), 16bit or 8bit reg access
66 * -m|-mask MASK 0x-hexa mask (default 0xFFFFFFFF)
67 * -s|-shift SHIFT bit shift value (read:left, write:right)
68 * -o|-offset OFFSET address offset to add to ADDRESS value
69 *
70 * Warning: bit shift operation is applied to bit-mask.
71 * Warning: bit shift direction depends on read or right command.
72 */
73
74#include <linux/seq_file.h>
75#include <linux/uaccess.h>
76#include <linux/fs.h>
77#include <linux/init.h>
78#include <linux/debugfs.h>
79#include <linux/platform_device.h>
80#include <linux/interrupt.h>
81#include <linux/kobject.h>
82#include <linux/slab.h>
83#include <linux/irq.h>
84
85#include <linux/mfd/abx500.h>
86#include <linux/mfd/abx500/ab8500.h>
87#include <linux/mfd/abx500/ab8500-gpadc.h>
88
89#ifdef CONFIG_DEBUG_FS
90#include <linux/string.h>
91#include <linux/ctype.h>
92#endif
93
94static u32 debug_bank;
95static u32 debug_address;
96
97static int irq_ab8500;
98static int irq_first;
99static int irq_last;
100static u32 *irq_count;
101static int num_irqs;
102
103static struct device_attribute **dev_attr;
104static char **event_name;
105
106static u8 avg_sample = SAMPLE_16;
107static u8 trig_edge = RISING_EDGE;
108static u8 conv_type = ADC_SW;
109static u8 trig_timer;
110
111/**
112 * struct ab8500_reg_range
113 * @first: the first address of the range
114 * @last: the last address of the range
115 * @perm: access permissions for the range
116 */
117struct ab8500_reg_range {
118 u8 first;
119 u8 last;
120 u8 perm;
121};
122
123/**
124 * struct ab8500_prcmu_ranges
125 * @num_ranges: the number of ranges in the list
126 * @bankid: bank identifier
127 * @range: the list of register ranges
128 */
129struct ab8500_prcmu_ranges {
130 u8 num_ranges;
131 u8 bankid;
132 const struct ab8500_reg_range *range;
133};
134
135/* hwreg- "mask" and "shift" entries ressources */
136struct hwreg_cfg {
137 u32 bank; /* target bank */
138 unsigned long addr; /* target address */
139 uint fmt; /* format */
140 unsigned long mask; /* read/write mask, applied before any bit shift */
141 long shift; /* bit shift (read:right shift, write:left shift */
142};
143/* fmt bit #0: 0=hexa, 1=dec */
144#define REG_FMT_DEC(c) ((c)->fmt & 0x1)
145#define REG_FMT_HEX(c) (!REG_FMT_DEC(c))
146
147static struct hwreg_cfg hwreg_cfg = {
148 .addr = 0, /* default: invalid phys addr */
149 .fmt = 0, /* default: 32bit access, hex output */
150 .mask = 0xFFFFFFFF, /* default: no mask */
151 .shift = 0, /* default: no bit shift */
152};
153
154#define AB8500_NAME_STRING "ab8500"
155#define AB8500_ADC_NAME_STRING "gpadc"
156#define AB8500_NUM_BANKS AB8500_DEBUG_FIELD_LAST
157
158#define AB8500_REV_REG 0x80
159
160static struct ab8500_prcmu_ranges *debug_ranges;
161
162static struct ab8500_prcmu_ranges ab8500_debug_ranges[AB8500_NUM_BANKS] = {
163 [AB8500_M_FSM_RANK] = {
164 .num_ranges = 0,
165 .range = NULL,
166 },
167 [AB8500_SYS_CTRL1_BLOCK] = {
168 .num_ranges = 3,
169 .range = (struct ab8500_reg_range[]) {
170 {
171 .first = 0x00,
172 .last = 0x02,
173 },
174 {
175 .first = 0x42,
176 .last = 0x42,
177 },
178 {
179 .first = 0x80,
180 .last = 0x81,
181 },
182 },
183 },
184 [AB8500_SYS_CTRL2_BLOCK] = {
185 .num_ranges = 4,
186 .range = (struct ab8500_reg_range[]) {
187 {
188 .first = 0x00,
189 .last = 0x0D,
190 },
191 {
192 .first = 0x0F,
193 .last = 0x17,
194 },
195 {
196 .first = 0x30,
197 .last = 0x30,
198 },
199 {
200 .first = 0x32,
201 .last = 0x33,
202 },
203 },
204 },
205 [AB8500_REGU_CTRL1] = {
206 .num_ranges = 3,
207 .range = (struct ab8500_reg_range[]) {
208 {
209 .first = 0x00,
210 .last = 0x00,
211 },
212 {
213 .first = 0x03,
214 .last = 0x10,
215 },
216 {
217 .first = 0x80,
218 .last = 0x84,
219 },
220 },
221 },
222 [AB8500_REGU_CTRL2] = {
223 .num_ranges = 5,
224 .range = (struct ab8500_reg_range[]) {
225 {
226 .first = 0x00,
227 .last = 0x15,
228 },
229 {
230 .first = 0x17,
231 .last = 0x19,
232 },
233 {
234 .first = 0x1B,
235 .last = 0x1D,
236 },
237 {
238 .first = 0x1F,
239 .last = 0x22,
240 },
241 {
242 .first = 0x40,
243 .last = 0x44,
244 },
245 /*
246 * 0x80-0x8B are SIM registers and should
247 * not be accessed from here
248 */
249 },
250 },
251 [AB8500_USB] = {
252 .num_ranges = 2,
253 .range = (struct ab8500_reg_range[]) {
254 {
255 .first = 0x80,
256 .last = 0x83,
257 },
258 {
259 .first = 0x87,
260 .last = 0x8A,
261 },
262 },
263 },
264 [AB8500_TVOUT] = {
265 .num_ranges = 9,
266 .range = (struct ab8500_reg_range[]) {
267 {
268 .first = 0x00,
269 .last = 0x12,
270 },
271 {
272 .first = 0x15,
273 .last = 0x17,
274 },
275 {
276 .first = 0x19,
277 .last = 0x21,
278 },
279 {
280 .first = 0x27,
281 .last = 0x2C,
282 },
283 {
284 .first = 0x41,
285 .last = 0x41,
286 },
287 {
288 .first = 0x45,
289 .last = 0x5B,
290 },
291 {
292 .first = 0x5D,
293 .last = 0x5D,
294 },
295 {
296 .first = 0x69,
297 .last = 0x69,
298 },
299 {
300 .first = 0x80,
301 .last = 0x81,
302 },
303 },
304 },
305 [AB8500_DBI] = {
306 .num_ranges = 0,
307 .range = NULL,
308 },
309 [AB8500_ECI_AV_ACC] = {
310 .num_ranges = 1,
311 .range = (struct ab8500_reg_range[]) {
312 {
313 .first = 0x80,
314 .last = 0x82,
315 },
316 },
317 },
318 [AB8500_RESERVED] = {
319 .num_ranges = 0,
320 .range = NULL,
321 },
322 [AB8500_GPADC] = {
323 .num_ranges = 1,
324 .range = (struct ab8500_reg_range[]) {
325 {
326 .first = 0x00,
327 .last = 0x08,
328 },
329 },
330 },
331 [AB8500_CHARGER] = {
332 .num_ranges = 9,
333 .range = (struct ab8500_reg_range[]) {
334 {
335 .first = 0x00,
336 .last = 0x03,
337 },
338 {
339 .first = 0x05,
340 .last = 0x05,
341 },
342 {
343 .first = 0x40,
344 .last = 0x40,
345 },
346 {
347 .first = 0x42,
348 .last = 0x42,
349 },
350 {
351 .first = 0x44,
352 .last = 0x44,
353 },
354 {
355 .first = 0x50,
356 .last = 0x55,
357 },
358 {
359 .first = 0x80,
360 .last = 0x82,
361 },
362 {
363 .first = 0xC0,
364 .last = 0xC2,
365 },
366 {
367 .first = 0xf5,
368 .last = 0xf6,
369 },
370 },
371 },
372 [AB8500_GAS_GAUGE] = {
373 .num_ranges = 3,
374 .range = (struct ab8500_reg_range[]) {
375 {
376 .first = 0x00,
377 .last = 0x00,
378 },
379 {
380 .first = 0x07,
381 .last = 0x0A,
382 },
383 {
384 .first = 0x10,
385 .last = 0x14,
386 },
387 },
388 },
389 [AB8500_AUDIO] = {
390 .num_ranges = 1,
391 .range = (struct ab8500_reg_range[]) {
392 {
393 .first = 0x00,
394 .last = 0x6F,
395 },
396 },
397 },
398 [AB8500_INTERRUPT] = {
399 .num_ranges = 0,
400 .range = NULL,
401 },
402 [AB8500_RTC] = {
403 .num_ranges = 1,
404 .range = (struct ab8500_reg_range[]) {
405 {
406 .first = 0x00,
407 .last = 0x0F,
408 },
409 },
410 },
411 [AB8500_MISC] = {
412 .num_ranges = 8,
413 .range = (struct ab8500_reg_range[]) {
414 {
415 .first = 0x00,
416 .last = 0x05,
417 },
418 {
419 .first = 0x10,
420 .last = 0x15,
421 },
422 {
423 .first = 0x20,
424 .last = 0x25,
425 },
426 {
427 .first = 0x30,
428 .last = 0x35,
429 },
430 {
431 .first = 0x40,
432 .last = 0x45,
433 },
434 {
435 .first = 0x50,
436 .last = 0x50,
437 },
438 {
439 .first = 0x60,
440 .last = 0x67,
441 },
442 {
443 .first = 0x80,
444 .last = 0x80,
445 },
446 },
447 },
448 [AB8500_DEVELOPMENT] = {
449 .num_ranges = 1,
450 .range = (struct ab8500_reg_range[]) {
451 {
452 .first = 0x00,
453 .last = 0x00,
454 },
455 },
456 },
457 [AB8500_DEBUG] = {
458 .num_ranges = 1,
459 .range = (struct ab8500_reg_range[]) {
460 {
461 .first = 0x05,
462 .last = 0x07,
463 },
464 },
465 },
466 [AB8500_PROD_TEST] = {
467 .num_ranges = 0,
468 .range = NULL,
469 },
470 [AB8500_STE_TEST] = {
471 .num_ranges = 0,
472 .range = NULL,
473 },
474 [AB8500_OTP_EMUL] = {
475 .num_ranges = 1,
476 .range = (struct ab8500_reg_range[]) {
477 {
478 .first = 0x01,
479 .last = 0x0F,
480 },
481 },
482 },
483};
484
485static struct ab8500_prcmu_ranges ab8505_debug_ranges[AB8500_NUM_BANKS] = {
486 [0x0] = {
487 .num_ranges = 0,
488 .range = NULL,
489 },
490 [AB8500_SYS_CTRL1_BLOCK] = {
491 .num_ranges = 5,
492 .range = (struct ab8500_reg_range[]) {
493 {
494 .first = 0x00,
495 .last = 0x04,
496 },
497 {
498 .first = 0x42,
499 .last = 0x42,
500 },
501 {
502 .first = 0x52,
503 .last = 0x52,
504 },
505 {
506 .first = 0x54,
507 .last = 0x57,
508 },
509 {
510 .first = 0x80,
511 .last = 0x83,
512 },
513 },
514 },
515 [AB8500_SYS_CTRL2_BLOCK] = {
516 .num_ranges = 5,
517 .range = (struct ab8500_reg_range[]) {
518 {
519 .first = 0x00,
520 .last = 0x0D,
521 },
522 {
523 .first = 0x0F,
524 .last = 0x17,
525 },
526 {
527 .first = 0x20,
528 .last = 0x20,
529 },
530 {
531 .first = 0x30,
532 .last = 0x30,
533 },
534 {
535 .first = 0x32,
536 .last = 0x3A,
537 },
538 },
539 },
540 [AB8500_REGU_CTRL1] = {
541 .num_ranges = 3,
542 .range = (struct ab8500_reg_range[]) {
543 {
544 .first = 0x00,
545 .last = 0x00,
546 },
547 {
548 .first = 0x03,
549 .last = 0x11,
550 },
551 {
552 .first = 0x80,
553 .last = 0x86,
554 },
555 },
556 },
557 [AB8500_REGU_CTRL2] = {
558 .num_ranges = 6,
559 .range = (struct ab8500_reg_range[]) {
560 {
561 .first = 0x00,
562 .last = 0x06,
563 },
564 {
565 .first = 0x08,
566 .last = 0x15,
567 },
568 {
569 .first = 0x17,
570 .last = 0x19,
571 },
572 {
573 .first = 0x1B,
574 .last = 0x1D,
575 },
576 {
577 .first = 0x1F,
578 .last = 0x30,
579 },
580 {
581 .first = 0x40,
582 .last = 0x48,
583 },
584 /*
585 * 0x80-0x8B are SIM registers and should
586 * not be accessed from here
587 */
588 },
589 },
590 [AB8500_USB] = {
591 .num_ranges = 3,
592 .range = (struct ab8500_reg_range[]) {
593 {
594 .first = 0x80,
595 .last = 0x83,
596 },
597 {
598 .first = 0x87,
599 .last = 0x8A,
600 },
601 {
602 .first = 0x91,
603 .last = 0x94,
604 },
605 },
606 },
607 [AB8500_TVOUT] = {
608 .num_ranges = 0,
609 .range = NULL,
610 },
611 [AB8500_DBI] = {
612 .num_ranges = 0,
613 .range = NULL,
614 },
615 [AB8500_ECI_AV_ACC] = {
616 .num_ranges = 1,
617 .range = (struct ab8500_reg_range[]) {
618 {
619 .first = 0x80,
620 .last = 0x82,
621 },
622 },
623 },
624 [AB8500_RESERVED] = {
625 .num_ranges = 0,
626 .range = NULL,
627 },
628 [AB8500_GPADC] = {
629 .num_ranges = 1,
630 .range = (struct ab8500_reg_range[]) {
631 {
632 .first = 0x00,
633 .last = 0x08,
634 },
635 },
636 },
637 [AB8500_CHARGER] = {
638 .num_ranges = 9,
639 .range = (struct ab8500_reg_range[]) {
640 {
641 .first = 0x02,
642 .last = 0x03,
643 },
644 {
645 .first = 0x05,
646 .last = 0x05,
647 },
648 {
649 .first = 0x40,
650 .last = 0x44,
651 },
652 {
653 .first = 0x50,
654 .last = 0x57,
655 },
656 {
657 .first = 0x60,
658 .last = 0x60,
659 },
660 {
661 .first = 0xA0,
662 .last = 0xA7,
663 },
664 {
665 .first = 0xAF,
666 .last = 0xB2,
667 },
668 {
669 .first = 0xC0,
670 .last = 0xC2,
671 },
672 {
673 .first = 0xF5,
674 .last = 0xF5,
675 },
676 },
677 },
678 [AB8500_GAS_GAUGE] = {
679 .num_ranges = 3,
680 .range = (struct ab8500_reg_range[]) {
681 {
682 .first = 0x00,
683 .last = 0x00,
684 },
685 {
686 .first = 0x07,
687 .last = 0x0A,
688 },
689 {
690 .first = 0x10,
691 .last = 0x14,
692 },
693 },
694 },
695 [AB8500_AUDIO] = {
696 .num_ranges = 1,
697 .range = (struct ab8500_reg_range[]) {
698 {
699 .first = 0x00,
700 .last = 0x83,
701 },
702 },
703 },
704 [AB8500_INTERRUPT] = {
705 .num_ranges = 11,
706 .range = (struct ab8500_reg_range[]) {
707 {
708 .first = 0x00,
709 .last = 0x04,
710 },
711 {
712 .first = 0x06,
713 .last = 0x07,
714 },
715 {
716 .first = 0x09,
717 .last = 0x09,
718 },
719 {
720 .first = 0x0B,
721 .last = 0x0C,
722 },
723 {
724 .first = 0x12,
725 .last = 0x15,
726 },
727 {
728 .first = 0x18,
729 .last = 0x18,
730 },
731 /* Latch registers should not be read here */
732 {
733 .first = 0x40,
734 .last = 0x44,
735 },
736 {
737 .first = 0x46,
738 .last = 0x49,
739 },
740 {
741 .first = 0x4B,
742 .last = 0x4D,
743 },
744 {
745 .first = 0x52,
746 .last = 0x55,
747 },
748 {
749 .first = 0x58,
750 .last = 0x58,
751 },
752 /* LatchHier registers should not be read here */
753 },
754 },
755 [AB8500_RTC] = {
756 .num_ranges = 2,
757 .range = (struct ab8500_reg_range[]) {
758 {
759 .first = 0x00,
760 .last = 0x14,
761 },
762 {
763 .first = 0x16,
764 .last = 0x17,
765 },
766 },
767 },
768 [AB8500_MISC] = {
769 .num_ranges = 8,
770 .range = (struct ab8500_reg_range[]) {
771 {
772 .first = 0x00,
773 .last = 0x06,
774 },
775 {
776 .first = 0x10,
777 .last = 0x16,
778 },
779 {
780 .first = 0x20,
781 .last = 0x26,
782 },
783 {
784 .first = 0x30,
785 .last = 0x36,
786 },
787 {
788 .first = 0x40,
789 .last = 0x46,
790 },
791 {
792 .first = 0x50,
793 .last = 0x50,
794 },
795 {
796 .first = 0x60,
797 .last = 0x6B,
798 },
799 {
800 .first = 0x80,
801 .last = 0x82,
802 },
803 },
804 },
805 [AB8500_DEVELOPMENT] = {
806 .num_ranges = 2,
807 .range = (struct ab8500_reg_range[]) {
808 {
809 .first = 0x00,
810 .last = 0x00,
811 },
812 {
813 .first = 0x05,
814 .last = 0x05,
815 },
816 },
817 },
818 [AB8500_DEBUG] = {
819 .num_ranges = 1,
820 .range = (struct ab8500_reg_range[]) {
821 {
822 .first = 0x05,
823 .last = 0x07,
824 },
825 },
826 },
827 [AB8500_PROD_TEST] = {
828 .num_ranges = 0,
829 .range = NULL,
830 },
831 [AB8500_STE_TEST] = {
832 .num_ranges = 0,
833 .range = NULL,
834 },
835 [AB8500_OTP_EMUL] = {
836 .num_ranges = 1,
837 .range = (struct ab8500_reg_range[]) {
838 {
839 .first = 0x01,
840 .last = 0x15,
841 },
842 },
843 },
844};
845
846static struct ab8500_prcmu_ranges ab8540_debug_ranges[AB8500_NUM_BANKS] = {
847 [AB8500_M_FSM_RANK] = {
848 .num_ranges = 1,
849 .range = (struct ab8500_reg_range[]) {
850 {
851 .first = 0x00,
852 .last = 0x0B,
853 },
854 },
855 },
856 [AB8500_SYS_CTRL1_BLOCK] = {
857 .num_ranges = 6,
858 .range = (struct ab8500_reg_range[]) {
859 {
860 .first = 0x00,
861 .last = 0x04,
862 },
863 {
864 .first = 0x42,
865 .last = 0x42,
866 },
867 {
868 .first = 0x50,
869 .last = 0x54,
870 },
871 {
872 .first = 0x57,
873 .last = 0x57,
874 },
875 {
876 .first = 0x80,
877 .last = 0x83,
878 },
879 {
880 .first = 0x90,
881 .last = 0x90,
882 },
883 },
884 },
885 [AB8500_SYS_CTRL2_BLOCK] = {
886 .num_ranges = 5,
887 .range = (struct ab8500_reg_range[]) {
888 {
889 .first = 0x00,
890 .last = 0x0D,
891 },
892 {
893 .first = 0x0F,
894 .last = 0x10,
895 },
896 {
897 .first = 0x20,
898 .last = 0x21,
899 },
900 {
901 .first = 0x32,
902 .last = 0x3C,
903 },
904 {
905 .first = 0x40,
906 .last = 0x42,
907 },
908 },
909 },
910 [AB8500_REGU_CTRL1] = {
911 .num_ranges = 4,
912 .range = (struct ab8500_reg_range[]) {
913 {
914 .first = 0x03,
915 .last = 0x15,
916 },
917 {
918 .first = 0x20,
919 .last = 0x20,
920 },
921 {
922 .first = 0x80,
923 .last = 0x85,
924 },
925 {
926 .first = 0x87,
927 .last = 0x88,
928 },
929 },
930 },
931 [AB8500_REGU_CTRL2] = {
932 .num_ranges = 8,
933 .range = (struct ab8500_reg_range[]) {
934 {
935 .first = 0x00,
936 .last = 0x06,
937 },
938 {
939 .first = 0x08,
940 .last = 0x15,
941 },
942 {
943 .first = 0x17,
944 .last = 0x19,
945 },
946 {
947 .first = 0x1B,
948 .last = 0x1D,
949 },
950 {
951 .first = 0x1F,
952 .last = 0x2F,
953 },
954 {
955 .first = 0x31,
956 .last = 0x3A,
957 },
958 {
959 .first = 0x43,
960 .last = 0x44,
961 },
962 {
963 .first = 0x48,
964 .last = 0x49,
965 },
966 },
967 },
968 [AB8500_USB] = {
969 .num_ranges = 3,
970 .range = (struct ab8500_reg_range[]) {
971 {
972 .first = 0x80,
973 .last = 0x83,
974 },
975 {
976 .first = 0x87,
977 .last = 0x8A,
978 },
979 {
980 .first = 0x91,
981 .last = 0x94,
982 },
983 },
984 },
985 [AB8500_TVOUT] = {
986 .num_ranges = 0,
987 .range = NULL
988 },
989 [AB8500_DBI] = {
990 .num_ranges = 4,
991 .range = (struct ab8500_reg_range[]) {
992 {
993 .first = 0x00,
994 .last = 0x07,
995 },
996 {
997 .first = 0x10,
998 .last = 0x11,
999 },
1000 {
1001 .first = 0x20,
1002 .last = 0x21,
1003 },
1004 {
1005 .first = 0x30,
1006 .last = 0x43,
1007 },
1008 },
1009 },
1010 [AB8500_ECI_AV_ACC] = {
1011 .num_ranges = 2,
1012 .range = (struct ab8500_reg_range[]) {
1013 {
1014 .first = 0x00,
1015 .last = 0x03,
1016 },
1017 {
1018 .first = 0x80,
1019 .last = 0x82,
1020 },
1021 },
1022 },
1023 [AB8500_RESERVED] = {
1024 .num_ranges = 0,
1025 .range = NULL,
1026 },
1027 [AB8500_GPADC] = {
1028 .num_ranges = 4,
1029 .range = (struct ab8500_reg_range[]) {
1030 {
1031 .first = 0x00,
1032 .last = 0x01,
1033 },
1034 {
1035 .first = 0x04,
1036 .last = 0x06,
1037 },
1038 {
1039 .first = 0x09,
1040 .last = 0x0A,
1041 },
1042 {
1043 .first = 0x10,
1044 .last = 0x14,
1045 },
1046 },
1047 },
1048 [AB8500_CHARGER] = {
1049 .num_ranges = 10,
1050 .range = (struct ab8500_reg_range[]) {
1051 {
1052 .first = 0x00,
1053 .last = 0x00,
1054 },
1055 {
1056 .first = 0x02,
1057 .last = 0x05,
1058 },
1059 {
1060 .first = 0x40,
1061 .last = 0x44,
1062 },
1063 {
1064 .first = 0x50,
1065 .last = 0x57,
1066 },
1067 {
1068 .first = 0x60,
1069 .last = 0x60,
1070 },
1071 {
1072 .first = 0x70,
1073 .last = 0x70,
1074 },
1075 {
1076 .first = 0xA0,
1077 .last = 0xA9,
1078 },
1079 {
1080 .first = 0xAF,
1081 .last = 0xB2,
1082 },
1083 {
1084 .first = 0xC0,
1085 .last = 0xC6,
1086 },
1087 {
1088 .first = 0xF5,
1089 .last = 0xF5,
1090 },
1091 },
1092 },
1093 [AB8500_GAS_GAUGE] = {
1094 .num_ranges = 3,
1095 .range = (struct ab8500_reg_range[]) {
1096 {
1097 .first = 0x00,
1098 .last = 0x00,
1099 },
1100 {
1101 .first = 0x07,
1102 .last = 0x0A,
1103 },
1104 {
1105 .first = 0x10,
1106 .last = 0x14,
1107 },
1108 },
1109 },
1110 [AB8500_AUDIO] = {
1111 .num_ranges = 1,
1112 .range = (struct ab8500_reg_range[]) {
1113 {
1114 .first = 0x00,
1115 .last = 0x9f,
1116 },
1117 },
1118 },
1119 [AB8500_INTERRUPT] = {
1120 .num_ranges = 6,
1121 .range = (struct ab8500_reg_range[]) {
1122 {
1123 .first = 0x00,
1124 .last = 0x05,
1125 },
1126 {
1127 .first = 0x0B,
1128 .last = 0x0D,
1129 },
1130 {
1131 .first = 0x12,
1132 .last = 0x20,
1133 },
1134 /* Latch registers should not be read here */
1135 {
1136 .first = 0x40,
1137 .last = 0x45,
1138 },
1139 {
1140 .first = 0x4B,
1141 .last = 0x4D,
1142 },
1143 {
1144 .first = 0x52,
1145 .last = 0x60,
1146 },
1147 /* LatchHier registers should not be read here */
1148 },
1149 },
1150 [AB8500_RTC] = {
1151 .num_ranges = 3,
1152 .range = (struct ab8500_reg_range[]) {
1153 {
1154 .first = 0x00,
1155 .last = 0x07,
1156 },
1157 {
1158 .first = 0x0B,
1159 .last = 0x18,
1160 },
1161 {
1162 .first = 0x20,
1163 .last = 0x25,
1164 },
1165 },
1166 },
1167 [AB8500_MISC] = {
1168 .num_ranges = 9,
1169 .range = (struct ab8500_reg_range[]) {
1170 {
1171 .first = 0x00,
1172 .last = 0x06,
1173 },
1174 {
1175 .first = 0x10,
1176 .last = 0x16,
1177 },
1178 {
1179 .first = 0x20,
1180 .last = 0x26,
1181 },
1182 {
1183 .first = 0x30,
1184 .last = 0x36,
1185 },
1186 {
1187 .first = 0x40,
1188 .last = 0x49,
1189 },
1190 {
1191 .first = 0x50,
1192 .last = 0x50,
1193 },
1194 {
1195 .first = 0x60,
1196 .last = 0x6B,
1197 },
1198 {
1199 .first = 0x70,
1200 .last = 0x74,
1201 },
1202 {
1203 .first = 0x80,
1204 .last = 0x82,
1205 },
1206 },
1207 },
1208 [AB8500_DEVELOPMENT] = {
1209 .num_ranges = 3,
1210 .range = (struct ab8500_reg_range[]) {
1211 {
1212 .first = 0x00,
1213 .last = 0x01,
1214 },
1215 {
1216 .first = 0x06,
1217 .last = 0x06,
1218 },
1219 {
1220 .first = 0x10,
1221 .last = 0x21,
1222 },
1223 },
1224 },
1225 [AB8500_DEBUG] = {
1226 .num_ranges = 3,
1227 .range = (struct ab8500_reg_range[]) {
1228 {
1229 .first = 0x01,
1230 .last = 0x0C,
1231 },
1232 {
1233 .first = 0x0E,
1234 .last = 0x11,
1235 },
1236 {
1237 .first = 0x80,
1238 .last = 0x81,
1239 },
1240 },
1241 },
1242 [AB8500_PROD_TEST] = {
1243 .num_ranges = 0,
1244 .range = NULL,
1245 },
1246 [AB8500_STE_TEST] = {
1247 .num_ranges = 0,
1248 .range = NULL,
1249 },
1250 [AB8500_OTP_EMUL] = {
1251 .num_ranges = 1,
1252 .range = (struct ab8500_reg_range[]) {
1253 {
1254 .first = 0x00,
1255 .last = 0x3F,
1256 },
1257 },
1258 },
1259};
1260
1261static irqreturn_t ab8500_debug_handler(int irq, void *data)
1262{
1263 char buf[16];
1264 struct kobject *kobj = (struct kobject *)data;
1265 unsigned int irq_abb = irq - irq_first;
1266
1267 if (irq_abb < num_irqs)
1268 irq_count[irq_abb]++;
1269 /*
1270 * This makes it possible to use poll for events (EPOLLPRI | EPOLLERR)
1271 * from userspace on sysfs file named <irq-nr>
1272 */
1273 sprintf(buf, "%d", irq);
1274 sysfs_notify(kobj, NULL, buf);
1275
1276 return IRQ_HANDLED;
1277}
1278
1279/* Prints to seq_file or log_buf */
1280static int ab8500_registers_print(struct device *dev, u32 bank,
1281 struct seq_file *s)
1282{
1283 unsigned int i;
1284
1285 for (i = 0; i < debug_ranges[bank].num_ranges; i++) {
1286 u32 reg;
1287
1288 for (reg = debug_ranges[bank].range[i].first;
1289 reg <= debug_ranges[bank].range[i].last;
1290 reg++) {
1291 u8 value;
1292 int err;
1293
1294 err = abx500_get_register_interruptible(dev,
1295 (u8)bank, (u8)reg, &value);
1296 if (err < 0) {
1297 dev_err(dev, "ab->read fail %d\n", err);
1298 return err;
1299 }
1300
1301 if (s) {
1302 seq_printf(s, " [0x%02X/0x%02X]: 0x%02X\n",
1303 bank, reg, value);
1304 /*
1305 * Error is not returned here since
1306 * the output is wanted in any case
1307 */
1308 if (seq_has_overflowed(s))
1309 return 0;
1310 } else {
1311 dev_info(dev, " [0x%02X/0x%02X]: 0x%02X\n",
1312 bank, reg, value);
1313 }
1314 }
1315 }
1316
1317 return 0;
1318}
1319
1320static int ab8500_bank_registers_show(struct seq_file *s, void *p)
1321{
1322 struct device *dev = s->private;
1323 u32 bank = debug_bank;
1324
1325 seq_puts(s, AB8500_NAME_STRING " register values:\n");
1326
1327 seq_printf(s, " bank 0x%02X:\n", bank);
1328
1329 return ab8500_registers_print(dev, bank, s);
1330}
1331
1332DEFINE_SHOW_ATTRIBUTE(ab8500_bank_registers);
1333
1334static int ab8500_print_all_banks(struct seq_file *s, void *p)
1335{
1336 struct device *dev = s->private;
1337 unsigned int i;
1338
1339 seq_puts(s, AB8500_NAME_STRING " register values:\n");
1340
1341 for (i = 0; i < AB8500_NUM_BANKS; i++) {
1342 int err;
1343
1344 seq_printf(s, " bank 0x%02X:\n", i);
1345 err = ab8500_registers_print(dev, i, s);
1346 if (err)
1347 return err;
1348 }
1349 return 0;
1350}
1351
1352/* Dump registers to kernel log */
1353void ab8500_dump_all_banks(struct device *dev)
1354{
1355 unsigned int i;
1356
1357 dev_info(dev, "ab8500 register values:\n");
1358
1359 for (i = 1; i < AB8500_NUM_BANKS; i++) {
1360 dev_info(dev, " bank 0x%02X:\n", i);
1361 ab8500_registers_print(dev, i, NULL);
1362 }
1363}
1364
1365static int ab8500_all_banks_open(struct inode *inode, struct file *file)
1366{
1367 struct seq_file *s;
1368 int err;
1369
1370 err = single_open(file, ab8500_print_all_banks, inode->i_private);
1371 if (!err) {
1372 /* Default buf size in seq_read is not enough */
1373 s = (struct seq_file *)file->private_data;
1374 s->size = (PAGE_SIZE * 2);
1375 s->buf = kmalloc(s->size, GFP_KERNEL);
1376 if (!s->buf) {
1377 single_release(inode, file);
1378 err = -ENOMEM;
1379 }
1380 }
1381 return err;
1382}
1383
1384static const struct file_operations ab8500_all_banks_fops = {
1385 .open = ab8500_all_banks_open,
1386 .read = seq_read,
1387 .llseek = seq_lseek,
1388 .release = single_release,
1389 .owner = THIS_MODULE,
1390};
1391
1392static int ab8500_bank_print(struct seq_file *s, void *p)
1393{
1394 seq_printf(s, "0x%02X\n", debug_bank);
1395 return 0;
1396}
1397
1398static int ab8500_bank_open(struct inode *inode, struct file *file)
1399{
1400 return single_open(file, ab8500_bank_print, inode->i_private);
1401}
1402
1403static ssize_t ab8500_bank_write(struct file *file,
1404 const char __user *user_buf,
1405 size_t count, loff_t *ppos)
1406{
1407 struct device *dev = ((struct seq_file *)(file->private_data))->private;
1408 unsigned long user_bank;
1409 int err;
1410
1411 err = kstrtoul_from_user(user_buf, count, 0, &user_bank);
1412 if (err)
1413 return err;
1414
1415 if (user_bank >= AB8500_NUM_BANKS) {
1416 dev_err(dev, "debugfs error input > number of banks\n");
1417 return -EINVAL;
1418 }
1419
1420 debug_bank = user_bank;
1421
1422 return count;
1423}
1424
1425static int ab8500_address_print(struct seq_file *s, void *p)
1426{
1427 seq_printf(s, "0x%02X\n", debug_address);
1428 return 0;
1429}
1430
1431static int ab8500_address_open(struct inode *inode, struct file *file)
1432{
1433 return single_open(file, ab8500_address_print, inode->i_private);
1434}
1435
1436static ssize_t ab8500_address_write(struct file *file,
1437 const char __user *user_buf,
1438 size_t count, loff_t *ppos)
1439{
1440 struct device *dev = ((struct seq_file *)(file->private_data))->private;
1441 unsigned long user_address;
1442 int err;
1443
1444 err = kstrtoul_from_user(user_buf, count, 0, &user_address);
1445 if (err)
1446 return err;
1447
1448 if (user_address > 0xff) {
1449 dev_err(dev, "debugfs error input > 0xff\n");
1450 return -EINVAL;
1451 }
1452 debug_address = user_address;
1453
1454 return count;
1455}
1456
1457static int ab8500_val_print(struct seq_file *s, void *p)
1458{
1459 struct device *dev = s->private;
1460 int ret;
1461 u8 regvalue;
1462
1463 ret = abx500_get_register_interruptible(dev,
1464 (u8)debug_bank, (u8)debug_address, ®value);
1465 if (ret < 0) {
1466 dev_err(dev, "abx500_get_reg fail %d, %d\n",
1467 ret, __LINE__);
1468 return -EINVAL;
1469 }
1470 seq_printf(s, "0x%02X\n", regvalue);
1471
1472 return 0;
1473}
1474
1475static int ab8500_val_open(struct inode *inode, struct file *file)
1476{
1477 return single_open(file, ab8500_val_print, inode->i_private);
1478}
1479
1480static ssize_t ab8500_val_write(struct file *file,
1481 const char __user *user_buf,
1482 size_t count, loff_t *ppos)
1483{
1484 struct device *dev = ((struct seq_file *)(file->private_data))->private;
1485 unsigned long user_val;
1486 int err;
1487
1488 err = kstrtoul_from_user(user_buf, count, 0, &user_val);
1489 if (err)
1490 return err;
1491
1492 if (user_val > 0xff) {
1493 dev_err(dev, "debugfs error input > 0xff\n");
1494 return -EINVAL;
1495 }
1496 err = abx500_set_register_interruptible(dev,
1497 (u8)debug_bank, debug_address, (u8)user_val);
1498 if (err < 0) {
1499 pr_err("abx500_set_reg failed %d, %d", err, __LINE__);
1500 return -EINVAL;
1501 }
1502
1503 return count;
1504}
1505
1506/*
1507 * Interrupt status
1508 */
1509static u32 num_interrupts[AB8500_MAX_NR_IRQS];
1510static u32 num_wake_interrupts[AB8500_MAX_NR_IRQS];
1511static int num_interrupt_lines;
1512
1513void ab8500_debug_register_interrupt(int line)
1514{
1515 if (line < num_interrupt_lines)
1516 num_interrupts[line]++;
1517}
1518
1519static int ab8500_interrupts_show(struct seq_file *s, void *p)
1520{
1521 int line;
1522
1523 seq_puts(s, "name: number: number of: wake:\n");
1524
1525 for (line = 0; line < num_interrupt_lines; line++) {
1526 struct irq_desc *desc = irq_to_desc(line + irq_first);
1527
1528 seq_printf(s, "%3i: %6i %4i",
1529 line,
1530 num_interrupts[line],
1531 num_wake_interrupts[line]);
1532
1533 if (desc && desc->name)
1534 seq_printf(s, "-%-8s", desc->name);
1535 if (desc && desc->action) {
1536 struct irqaction *action = desc->action;
1537
1538 seq_printf(s, " %s", action->name);
1539 while ((action = action->next) != NULL)
1540 seq_printf(s, ", %s", action->name);
1541 }
1542 seq_putc(s, '\n');
1543 }
1544
1545 return 0;
1546}
1547
1548DEFINE_SHOW_ATTRIBUTE(ab8500_interrupts);
1549
1550/*
1551 * - HWREG DB8500 formated routines
1552 */
1553static int ab8500_hwreg_print(struct seq_file *s, void *d)
1554{
1555 struct device *dev = s->private;
1556 int ret;
1557 u8 regvalue;
1558
1559 ret = abx500_get_register_interruptible(dev,
1560 (u8)hwreg_cfg.bank, (u8)hwreg_cfg.addr, ®value);
1561 if (ret < 0) {
1562 dev_err(dev, "abx500_get_reg fail %d, %d\n",
1563 ret, __LINE__);
1564 return -EINVAL;
1565 }
1566
1567 if (hwreg_cfg.shift >= 0)
1568 regvalue >>= hwreg_cfg.shift;
1569 else
1570 regvalue <<= -hwreg_cfg.shift;
1571 regvalue &= hwreg_cfg.mask;
1572
1573 if (REG_FMT_DEC(&hwreg_cfg))
1574 seq_printf(s, "%d\n", regvalue);
1575 else
1576 seq_printf(s, "0x%02X\n", regvalue);
1577 return 0;
1578}
1579
1580static int ab8500_hwreg_open(struct inode *inode, struct file *file)
1581{
1582 return single_open(file, ab8500_hwreg_print, inode->i_private);
1583}
1584
1585#define AB8500_SUPPLY_CONTROL_CONFIG_1 0x01
1586#define AB8500_SUPPLY_CONTROL_REG 0x00
1587#define AB8500_FIRST_SIM_REG 0x80
1588#define AB8500_LAST_SIM_REG 0x8B
1589#define AB8505_LAST_SIM_REG 0x8C
1590
1591static int ab8500_modem_show(struct seq_file *s, void *p)
1592{
1593 struct device *dev = s->private;
1594 struct ab8500 *ab8500;
1595 int err;
1596 u8 value;
1597 u8 orig_value;
1598 u32 bank = AB8500_REGU_CTRL2;
1599 u32 last_sim_reg = AB8500_LAST_SIM_REG;
1600 u32 reg;
1601
1602 ab8500 = dev_get_drvdata(dev->parent);
1603 dev_warn(dev, "WARNING! This operation can interfer with modem side\n"
1604 "and should only be done with care\n");
1605
1606 err = abx500_get_register_interruptible(dev,
1607 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG, &orig_value);
1608 if (err < 0)
1609 goto report_read_failure;
1610
1611 /* Config 1 will allow APE side to read SIM registers */
1612 err = abx500_set_register_interruptible(dev,
1613 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG,
1614 AB8500_SUPPLY_CONTROL_CONFIG_1);
1615 if (err < 0)
1616 goto report_write_failure;
1617
1618 seq_printf(s, " bank 0x%02X:\n", bank);
1619
1620 if (is_ab9540(ab8500) || is_ab8505(ab8500))
1621 last_sim_reg = AB8505_LAST_SIM_REG;
1622
1623 for (reg = AB8500_FIRST_SIM_REG; reg <= last_sim_reg; reg++) {
1624 err = abx500_get_register_interruptible(dev,
1625 bank, reg, &value);
1626 if (err < 0)
1627 goto report_read_failure;
1628
1629 seq_printf(s, " [0x%02X/0x%02X]: 0x%02X\n", bank, reg, value);
1630 }
1631 err = abx500_set_register_interruptible(dev,
1632 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG, orig_value);
1633 if (err < 0)
1634 goto report_write_failure;
1635
1636 return 0;
1637
1638report_read_failure:
1639 dev_err(dev, "ab->read fail %d\n", err);
1640 return err;
1641
1642report_write_failure:
1643 dev_err(dev, "ab->write fail %d\n", err);
1644 return err;
1645}
1646
1647DEFINE_SHOW_ATTRIBUTE(ab8500_modem);
1648
1649static int ab8500_gpadc_bat_ctrl_show(struct seq_file *s, void *p)
1650{
1651 int bat_ctrl_raw;
1652 int bat_ctrl_convert;
1653 struct ab8500_gpadc *gpadc;
1654
1655 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1656 bat_ctrl_raw = ab8500_gpadc_read_raw(gpadc, BAT_CTRL,
1657 avg_sample, trig_edge, trig_timer, conv_type);
1658 bat_ctrl_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1659 BAT_CTRL, bat_ctrl_raw);
1660
1661 seq_printf(s, "%d,0x%X\n", bat_ctrl_convert, bat_ctrl_raw);
1662
1663 return 0;
1664}
1665
1666DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_bat_ctrl);
1667
1668static int ab8500_gpadc_btemp_ball_show(struct seq_file *s, void *p)
1669{
1670 int btemp_ball_raw;
1671 int btemp_ball_convert;
1672 struct ab8500_gpadc *gpadc;
1673
1674 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1675 btemp_ball_raw = ab8500_gpadc_read_raw(gpadc, BTEMP_BALL,
1676 avg_sample, trig_edge, trig_timer, conv_type);
1677 btemp_ball_convert = ab8500_gpadc_ad_to_voltage(gpadc, BTEMP_BALL,
1678 btemp_ball_raw);
1679
1680 seq_printf(s, "%d,0x%X\n", btemp_ball_convert, btemp_ball_raw);
1681
1682 return 0;
1683}
1684
1685DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_btemp_ball);
1686
1687static int ab8500_gpadc_main_charger_v_show(struct seq_file *s, void *p)
1688{
1689 int main_charger_v_raw;
1690 int main_charger_v_convert;
1691 struct ab8500_gpadc *gpadc;
1692
1693 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1694 main_charger_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_V,
1695 avg_sample, trig_edge, trig_timer, conv_type);
1696 main_charger_v_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1697 MAIN_CHARGER_V, main_charger_v_raw);
1698
1699 seq_printf(s, "%d,0x%X\n", main_charger_v_convert, main_charger_v_raw);
1700
1701 return 0;
1702}
1703
1704DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_main_charger_v);
1705
1706static int ab8500_gpadc_acc_detect1_show(struct seq_file *s, void *p)
1707{
1708 int acc_detect1_raw;
1709 int acc_detect1_convert;
1710 struct ab8500_gpadc *gpadc;
1711
1712 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1713 acc_detect1_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT1,
1714 avg_sample, trig_edge, trig_timer, conv_type);
1715 acc_detect1_convert = ab8500_gpadc_ad_to_voltage(gpadc, ACC_DETECT1,
1716 acc_detect1_raw);
1717
1718 seq_printf(s, "%d,0x%X\n", acc_detect1_convert, acc_detect1_raw);
1719
1720 return 0;
1721}
1722
1723DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_acc_detect1);
1724
1725static int ab8500_gpadc_acc_detect2_show(struct seq_file *s, void *p)
1726{
1727 int acc_detect2_raw;
1728 int acc_detect2_convert;
1729 struct ab8500_gpadc *gpadc;
1730
1731 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1732 acc_detect2_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT2,
1733 avg_sample, trig_edge, trig_timer, conv_type);
1734 acc_detect2_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1735 ACC_DETECT2, acc_detect2_raw);
1736
1737 seq_printf(s, "%d,0x%X\n", acc_detect2_convert, acc_detect2_raw);
1738
1739 return 0;
1740}
1741
1742DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_acc_detect2);
1743
1744static int ab8500_gpadc_aux1_show(struct seq_file *s, void *p)
1745{
1746 int aux1_raw;
1747 int aux1_convert;
1748 struct ab8500_gpadc *gpadc;
1749
1750 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1751 aux1_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX1,
1752 avg_sample, trig_edge, trig_timer, conv_type);
1753 aux1_convert = ab8500_gpadc_ad_to_voltage(gpadc, ADC_AUX1,
1754 aux1_raw);
1755
1756 seq_printf(s, "%d,0x%X\n", aux1_convert, aux1_raw);
1757
1758 return 0;
1759}
1760
1761DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_aux1);
1762
1763static int ab8500_gpadc_aux2_show(struct seq_file *s, void *p)
1764{
1765 int aux2_raw;
1766 int aux2_convert;
1767 struct ab8500_gpadc *gpadc;
1768
1769 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1770 aux2_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX2,
1771 avg_sample, trig_edge, trig_timer, conv_type);
1772 aux2_convert = ab8500_gpadc_ad_to_voltage(gpadc, ADC_AUX2,
1773 aux2_raw);
1774
1775 seq_printf(s, "%d,0x%X\n", aux2_convert, aux2_raw);
1776
1777 return 0;
1778}
1779
1780DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_aux2);
1781
1782static int ab8500_gpadc_main_bat_v_show(struct seq_file *s, void *p)
1783{
1784 int main_bat_v_raw;
1785 int main_bat_v_convert;
1786 struct ab8500_gpadc *gpadc;
1787
1788 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1789 main_bat_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_BAT_V,
1790 avg_sample, trig_edge, trig_timer, conv_type);
1791 main_bat_v_convert = ab8500_gpadc_ad_to_voltage(gpadc, MAIN_BAT_V,
1792 main_bat_v_raw);
1793
1794 seq_printf(s, "%d,0x%X\n", main_bat_v_convert, main_bat_v_raw);
1795
1796 return 0;
1797}
1798
1799DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_main_bat_v);
1800
1801static int ab8500_gpadc_vbus_v_show(struct seq_file *s, void *p)
1802{
1803 int vbus_v_raw;
1804 int vbus_v_convert;
1805 struct ab8500_gpadc *gpadc;
1806
1807 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1808 vbus_v_raw = ab8500_gpadc_read_raw(gpadc, VBUS_V,
1809 avg_sample, trig_edge, trig_timer, conv_type);
1810 vbus_v_convert = ab8500_gpadc_ad_to_voltage(gpadc, VBUS_V,
1811 vbus_v_raw);
1812
1813 seq_printf(s, "%d,0x%X\n", vbus_v_convert, vbus_v_raw);
1814
1815 return 0;
1816}
1817
1818DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_vbus_v);
1819
1820static int ab8500_gpadc_main_charger_c_show(struct seq_file *s, void *p)
1821{
1822 int main_charger_c_raw;
1823 int main_charger_c_convert;
1824 struct ab8500_gpadc *gpadc;
1825
1826 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1827 main_charger_c_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_C,
1828 avg_sample, trig_edge, trig_timer, conv_type);
1829 main_charger_c_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1830 MAIN_CHARGER_C, main_charger_c_raw);
1831
1832 seq_printf(s, "%d,0x%X\n", main_charger_c_convert, main_charger_c_raw);
1833
1834 return 0;
1835}
1836
1837DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_main_charger_c);
1838
1839static int ab8500_gpadc_usb_charger_c_show(struct seq_file *s, void *p)
1840{
1841 int usb_charger_c_raw;
1842 int usb_charger_c_convert;
1843 struct ab8500_gpadc *gpadc;
1844
1845 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1846 usb_charger_c_raw = ab8500_gpadc_read_raw(gpadc, USB_CHARGER_C,
1847 avg_sample, trig_edge, trig_timer, conv_type);
1848 usb_charger_c_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1849 USB_CHARGER_C, usb_charger_c_raw);
1850
1851 seq_printf(s, "%d,0x%X\n", usb_charger_c_convert, usb_charger_c_raw);
1852
1853 return 0;
1854}
1855
1856DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_usb_charger_c);
1857
1858static int ab8500_gpadc_bk_bat_v_show(struct seq_file *s, void *p)
1859{
1860 int bk_bat_v_raw;
1861 int bk_bat_v_convert;
1862 struct ab8500_gpadc *gpadc;
1863
1864 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1865 bk_bat_v_raw = ab8500_gpadc_read_raw(gpadc, BK_BAT_V,
1866 avg_sample, trig_edge, trig_timer, conv_type);
1867 bk_bat_v_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1868 BK_BAT_V, bk_bat_v_raw);
1869
1870 seq_printf(s, "%d,0x%X\n", bk_bat_v_convert, bk_bat_v_raw);
1871
1872 return 0;
1873}
1874
1875DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_bk_bat_v);
1876
1877static int ab8500_gpadc_die_temp_show(struct seq_file *s, void *p)
1878{
1879 int die_temp_raw;
1880 int die_temp_convert;
1881 struct ab8500_gpadc *gpadc;
1882
1883 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1884 die_temp_raw = ab8500_gpadc_read_raw(gpadc, DIE_TEMP,
1885 avg_sample, trig_edge, trig_timer, conv_type);
1886 die_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, DIE_TEMP,
1887 die_temp_raw);
1888
1889 seq_printf(s, "%d,0x%X\n", die_temp_convert, die_temp_raw);
1890
1891 return 0;
1892}
1893
1894DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_die_temp);
1895
1896static int ab8500_gpadc_usb_id_show(struct seq_file *s, void *p)
1897{
1898 int usb_id_raw;
1899 int usb_id_convert;
1900 struct ab8500_gpadc *gpadc;
1901
1902 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1903 usb_id_raw = ab8500_gpadc_read_raw(gpadc, USB_ID,
1904 avg_sample, trig_edge, trig_timer, conv_type);
1905 usb_id_convert = ab8500_gpadc_ad_to_voltage(gpadc, USB_ID,
1906 usb_id_raw);
1907
1908 seq_printf(s, "%d,0x%X\n", usb_id_convert, usb_id_raw);
1909
1910 return 0;
1911}
1912
1913DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_usb_id);
1914
1915static int ab8540_gpadc_xtal_temp_show(struct seq_file *s, void *p)
1916{
1917 int xtal_temp_raw;
1918 int xtal_temp_convert;
1919 struct ab8500_gpadc *gpadc;
1920
1921 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1922 xtal_temp_raw = ab8500_gpadc_read_raw(gpadc, XTAL_TEMP,
1923 avg_sample, trig_edge, trig_timer, conv_type);
1924 xtal_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, XTAL_TEMP,
1925 xtal_temp_raw);
1926
1927 seq_printf(s, "%d,0x%X\n", xtal_temp_convert, xtal_temp_raw);
1928
1929 return 0;
1930}
1931
1932DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_xtal_temp);
1933
1934static int ab8540_gpadc_vbat_true_meas_show(struct seq_file *s, void *p)
1935{
1936 int vbat_true_meas_raw;
1937 int vbat_true_meas_convert;
1938 struct ab8500_gpadc *gpadc;
1939
1940 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1941 vbat_true_meas_raw = ab8500_gpadc_read_raw(gpadc, VBAT_TRUE_MEAS,
1942 avg_sample, trig_edge, trig_timer, conv_type);
1943 vbat_true_meas_convert =
1944 ab8500_gpadc_ad_to_voltage(gpadc, VBAT_TRUE_MEAS,
1945 vbat_true_meas_raw);
1946
1947 seq_printf(s, "%d,0x%X\n", vbat_true_meas_convert, vbat_true_meas_raw);
1948
1949 return 0;
1950}
1951
1952DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_vbat_true_meas);
1953
1954static int ab8540_gpadc_bat_ctrl_and_ibat_show(struct seq_file *s, void *p)
1955{
1956 int bat_ctrl_raw;
1957 int bat_ctrl_convert;
1958 int ibat_raw;
1959 int ibat_convert;
1960 struct ab8500_gpadc *gpadc;
1961
1962 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1963 bat_ctrl_raw = ab8500_gpadc_double_read_raw(gpadc, BAT_CTRL_AND_IBAT,
1964 avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
1965
1966 bat_ctrl_convert = ab8500_gpadc_ad_to_voltage(gpadc, BAT_CTRL,
1967 bat_ctrl_raw);
1968 ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
1969 ibat_raw);
1970
1971 seq_printf(s,
1972 "%d,0x%X\n"
1973 "%d,0x%X\n",
1974 bat_ctrl_convert, bat_ctrl_raw,
1975 ibat_convert, ibat_raw);
1976
1977 return 0;
1978}
1979
1980DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_bat_ctrl_and_ibat);
1981
1982static int ab8540_gpadc_vbat_meas_and_ibat_show(struct seq_file *s, void *p)
1983{
1984 int vbat_meas_raw;
1985 int vbat_meas_convert;
1986 int ibat_raw;
1987 int ibat_convert;
1988 struct ab8500_gpadc *gpadc;
1989
1990 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1991 vbat_meas_raw = ab8500_gpadc_double_read_raw(gpadc, VBAT_MEAS_AND_IBAT,
1992 avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
1993 vbat_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc, MAIN_BAT_V,
1994 vbat_meas_raw);
1995 ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
1996 ibat_raw);
1997
1998 seq_printf(s,
1999 "%d,0x%X\n"
2000 "%d,0x%X\n",
2001 vbat_meas_convert, vbat_meas_raw,
2002 ibat_convert, ibat_raw);
2003
2004 return 0;
2005}
2006
2007DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_vbat_meas_and_ibat);
2008
2009static int ab8540_gpadc_vbat_true_meas_and_ibat_show(struct seq_file *s, void *p)
2010{
2011 int vbat_true_meas_raw;
2012 int vbat_true_meas_convert;
2013 int ibat_raw;
2014 int ibat_convert;
2015 struct ab8500_gpadc *gpadc;
2016
2017 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2018 vbat_true_meas_raw = ab8500_gpadc_double_read_raw(gpadc,
2019 VBAT_TRUE_MEAS_AND_IBAT, avg_sample, trig_edge,
2020 trig_timer, conv_type, &ibat_raw);
2021 vbat_true_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc,
2022 VBAT_TRUE_MEAS, vbat_true_meas_raw);
2023 ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2024 ibat_raw);
2025
2026 seq_printf(s,
2027 "%d,0x%X\n"
2028 "%d,0x%X\n",
2029 vbat_true_meas_convert, vbat_true_meas_raw,
2030 ibat_convert, ibat_raw);
2031
2032 return 0;
2033}
2034
2035DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_vbat_true_meas_and_ibat);
2036
2037static int ab8540_gpadc_bat_temp_and_ibat_show(struct seq_file *s, void *p)
2038{
2039 int bat_temp_raw;
2040 int bat_temp_convert;
2041 int ibat_raw;
2042 int ibat_convert;
2043 struct ab8500_gpadc *gpadc;
2044
2045 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2046 bat_temp_raw = ab8500_gpadc_double_read_raw(gpadc, BAT_TEMP_AND_IBAT,
2047 avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
2048 bat_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, BTEMP_BALL,
2049 bat_temp_raw);
2050 ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2051 ibat_raw);
2052
2053 seq_printf(s,
2054 "%d,0x%X\n"
2055 "%d,0x%X\n",
2056 bat_temp_convert, bat_temp_raw,
2057 ibat_convert, ibat_raw);
2058
2059 return 0;
2060}
2061
2062DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_bat_temp_and_ibat);
2063
2064static int ab8540_gpadc_otp_calib_show(struct seq_file *s, void *p)
2065{
2066 struct ab8500_gpadc *gpadc;
2067 u16 vmain_l, vmain_h, btemp_l, btemp_h;
2068 u16 vbat_l, vbat_h, ibat_l, ibat_h;
2069
2070 gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2071 ab8540_gpadc_get_otp(gpadc, &vmain_l, &vmain_h, &btemp_l, &btemp_h,
2072 &vbat_l, &vbat_h, &ibat_l, &ibat_h);
2073 seq_printf(s,
2074 "VMAIN_L:0x%X\n"
2075 "VMAIN_H:0x%X\n"
2076 "BTEMP_L:0x%X\n"
2077 "BTEMP_H:0x%X\n"
2078 "VBAT_L:0x%X\n"
2079 "VBAT_H:0x%X\n"
2080 "IBAT_L:0x%X\n"
2081 "IBAT_H:0x%X\n",
2082 vmain_l, vmain_h, btemp_l, btemp_h,
2083 vbat_l, vbat_h, ibat_l, ibat_h);
2084
2085 return 0;
2086}
2087
2088DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_otp_calib);
2089
2090static int ab8500_gpadc_avg_sample_print(struct seq_file *s, void *p)
2091{
2092 seq_printf(s, "%d\n", avg_sample);
2093
2094 return 0;
2095}
2096
2097static int ab8500_gpadc_avg_sample_open(struct inode *inode, struct file *file)
2098{
2099 return single_open(file, ab8500_gpadc_avg_sample_print,
2100 inode->i_private);
2101}
2102
2103static ssize_t ab8500_gpadc_avg_sample_write(struct file *file,
2104 const char __user *user_buf,
2105 size_t count, loff_t *ppos)
2106{
2107 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2108 unsigned long user_avg_sample;
2109 int err;
2110
2111 err = kstrtoul_from_user(user_buf, count, 0, &user_avg_sample);
2112 if (err)
2113 return err;
2114
2115 if ((user_avg_sample == SAMPLE_1) || (user_avg_sample == SAMPLE_4)
2116 || (user_avg_sample == SAMPLE_8)
2117 || (user_avg_sample == SAMPLE_16)) {
2118 avg_sample = (u8) user_avg_sample;
2119 } else {
2120 dev_err(dev,
2121 "debugfs err input: should be egal to 1, 4, 8 or 16\n");
2122 return -EINVAL;
2123 }
2124
2125 return count;
2126}
2127
2128static const struct file_operations ab8500_gpadc_avg_sample_fops = {
2129 .open = ab8500_gpadc_avg_sample_open,
2130 .read = seq_read,
2131 .write = ab8500_gpadc_avg_sample_write,
2132 .llseek = seq_lseek,
2133 .release = single_release,
2134 .owner = THIS_MODULE,
2135};
2136
2137static int ab8500_gpadc_trig_edge_print(struct seq_file *s, void *p)
2138{
2139 seq_printf(s, "%d\n", trig_edge);
2140
2141 return 0;
2142}
2143
2144static int ab8500_gpadc_trig_edge_open(struct inode *inode, struct file *file)
2145{
2146 return single_open(file, ab8500_gpadc_trig_edge_print,
2147 inode->i_private);
2148}
2149
2150static ssize_t ab8500_gpadc_trig_edge_write(struct file *file,
2151 const char __user *user_buf,
2152 size_t count, loff_t *ppos)
2153{
2154 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2155 unsigned long user_trig_edge;
2156 int err;
2157
2158 err = kstrtoul_from_user(user_buf, count, 0, &user_trig_edge);
2159 if (err)
2160 return err;
2161
2162 if ((user_trig_edge == RISING_EDGE)
2163 || (user_trig_edge == FALLING_EDGE)) {
2164 trig_edge = (u8) user_trig_edge;
2165 } else {
2166 dev_err(dev, "Wrong input:\n"
2167 "Enter 0. Rising edge\n"
2168 "Enter 1. Falling edge\n");
2169 return -EINVAL;
2170 }
2171
2172 return count;
2173}
2174
2175static const struct file_operations ab8500_gpadc_trig_edge_fops = {
2176 .open = ab8500_gpadc_trig_edge_open,
2177 .read = seq_read,
2178 .write = ab8500_gpadc_trig_edge_write,
2179 .llseek = seq_lseek,
2180 .release = single_release,
2181 .owner = THIS_MODULE,
2182};
2183
2184static int ab8500_gpadc_trig_timer_print(struct seq_file *s, void *p)
2185{
2186 seq_printf(s, "%d\n", trig_timer);
2187
2188 return 0;
2189}
2190
2191static int ab8500_gpadc_trig_timer_open(struct inode *inode, struct file *file)
2192{
2193 return single_open(file, ab8500_gpadc_trig_timer_print,
2194 inode->i_private);
2195}
2196
2197static ssize_t ab8500_gpadc_trig_timer_write(struct file *file,
2198 const char __user *user_buf,
2199 size_t count, loff_t *ppos)
2200{
2201 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2202 unsigned long user_trig_timer;
2203 int err;
2204
2205 err = kstrtoul_from_user(user_buf, count, 0, &user_trig_timer);
2206 if (err)
2207 return err;
2208
2209 if (user_trig_timer & ~0xFF) {
2210 dev_err(dev,
2211 "debugfs error input: should be between 0 to 255\n");
2212 return -EINVAL;
2213 }
2214
2215 trig_timer = (u8) user_trig_timer;
2216
2217 return count;
2218}
2219
2220static const struct file_operations ab8500_gpadc_trig_timer_fops = {
2221 .open = ab8500_gpadc_trig_timer_open,
2222 .read = seq_read,
2223 .write = ab8500_gpadc_trig_timer_write,
2224 .llseek = seq_lseek,
2225 .release = single_release,
2226 .owner = THIS_MODULE,
2227};
2228
2229static int ab8500_gpadc_conv_type_print(struct seq_file *s, void *p)
2230{
2231 seq_printf(s, "%d\n", conv_type);
2232
2233 return 0;
2234}
2235
2236static int ab8500_gpadc_conv_type_open(struct inode *inode, struct file *file)
2237{
2238 return single_open(file, ab8500_gpadc_conv_type_print,
2239 inode->i_private);
2240}
2241
2242static ssize_t ab8500_gpadc_conv_type_write(struct file *file,
2243 const char __user *user_buf,
2244 size_t count, loff_t *ppos)
2245{
2246 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2247 unsigned long user_conv_type;
2248 int err;
2249
2250 err = kstrtoul_from_user(user_buf, count, 0, &user_conv_type);
2251 if (err)
2252 return err;
2253
2254 if ((user_conv_type == ADC_SW)
2255 || (user_conv_type == ADC_HW)) {
2256 conv_type = (u8) user_conv_type;
2257 } else {
2258 dev_err(dev, "Wrong input:\n"
2259 "Enter 0. ADC SW conversion\n"
2260 "Enter 1. ADC HW conversion\n");
2261 return -EINVAL;
2262 }
2263
2264 return count;
2265}
2266
2267static const struct file_operations ab8500_gpadc_conv_type_fops = {
2268 .open = ab8500_gpadc_conv_type_open,
2269 .read = seq_read,
2270 .write = ab8500_gpadc_conv_type_write,
2271 .llseek = seq_lseek,
2272 .release = single_release,
2273 .owner = THIS_MODULE,
2274};
2275
2276/*
2277 * return length of an ASCII numerical value, 0 is string is not a
2278 * numerical value.
2279 * string shall start at value 1st char.
2280 * string can be tailed with \0 or space or newline chars only.
2281 * value can be decimal or hexadecimal (prefixed 0x or 0X).
2282 */
2283static int strval_len(char *b)
2284{
2285 char *s = b;
2286
2287 if ((*s == '0') && ((*(s+1) == 'x') || (*(s+1) == 'X'))) {
2288 s += 2;
2289 for (; *s && (*s != ' ') && (*s != '\n'); s++) {
2290 if (!isxdigit(*s))
2291 return 0;
2292 }
2293 } else {
2294 if (*s == '-')
2295 s++;
2296 for (; *s && (*s != ' ') && (*s != '\n'); s++) {
2297 if (!isdigit(*s))
2298 return 0;
2299 }
2300 }
2301 return (int) (s-b);
2302}
2303
2304/*
2305 * parse hwreg input data.
2306 * update global hwreg_cfg only if input data syntax is ok.
2307 */
2308static ssize_t hwreg_common_write(char *b, struct hwreg_cfg *cfg,
2309 struct device *dev)
2310{
2311 uint write, val = 0;
2312 u8 regvalue;
2313 int ret;
2314 struct hwreg_cfg loc = {
2315 .bank = 0, /* default: invalid phys addr */
2316 .addr = 0, /* default: invalid phys addr */
2317 .fmt = 0, /* default: 32bit access, hex output */
2318 .mask = 0xFFFFFFFF, /* default: no mask */
2319 .shift = 0, /* default: no bit shift */
2320 };
2321
2322 /* read or write ? */
2323 if (!strncmp(b, "read ", 5)) {
2324 write = 0;
2325 b += 5;
2326 } else if (!strncmp(b, "write ", 6)) {
2327 write = 1;
2328 b += 6;
2329 } else
2330 return -EINVAL;
2331
2332 /* OPTIONS -l|-w|-b -s -m -o */
2333 while ((*b == ' ') || (*b == '-')) {
2334 if (*(b-1) != ' ') {
2335 b++;
2336 continue;
2337 }
2338 if ((!strncmp(b, "-d ", 3)) ||
2339 (!strncmp(b, "-dec ", 5))) {
2340 b += (*(b+2) == ' ') ? 3 : 5;
2341 loc.fmt |= (1<<0);
2342 } else if ((!strncmp(b, "-h ", 3)) ||
2343 (!strncmp(b, "-hex ", 5))) {
2344 b += (*(b+2) == ' ') ? 3 : 5;
2345 loc.fmt &= ~(1<<0);
2346 } else if ((!strncmp(b, "-m ", 3)) ||
2347 (!strncmp(b, "-mask ", 6))) {
2348 b += (*(b+2) == ' ') ? 3 : 6;
2349 if (strval_len(b) == 0)
2350 return -EINVAL;
2351 ret = kstrtoul(b, 0, &loc.mask);
2352 if (ret)
2353 return ret;
2354 } else if ((!strncmp(b, "-s ", 3)) ||
2355 (!strncmp(b, "-shift ", 7))) {
2356 b += (*(b+2) == ' ') ? 3 : 7;
2357 if (strval_len(b) == 0)
2358 return -EINVAL;
2359 ret = kstrtol(b, 0, &loc.shift);
2360 if (ret)
2361 return ret;
2362 } else {
2363 return -EINVAL;
2364 }
2365 }
2366 /* get arg BANK and ADDRESS */
2367 if (strval_len(b) == 0)
2368 return -EINVAL;
2369 ret = kstrtouint(b, 0, &loc.bank);
2370 if (ret)
2371 return ret;
2372 while (*b == ' ')
2373 b++;
2374 if (strval_len(b) == 0)
2375 return -EINVAL;
2376 ret = kstrtoul(b, 0, &loc.addr);
2377 if (ret)
2378 return ret;
2379
2380 if (write) {
2381 while (*b == ' ')
2382 b++;
2383 if (strval_len(b) == 0)
2384 return -EINVAL;
2385 ret = kstrtouint(b, 0, &val);
2386 if (ret)
2387 return ret;
2388 }
2389
2390 /* args are ok, update target cfg (mainly for read) */
2391 *cfg = loc;
2392
2393#ifdef ABB_HWREG_DEBUG
2394 pr_warn("HWREG request: %s, %s,\n", (write) ? "write" : "read",
2395 REG_FMT_DEC(cfg) ? "decimal" : "hexa");
2396 pr_warn(" addr=0x%08X, mask=0x%X, shift=%d" "value=0x%X\n",
2397 cfg->addr, cfg->mask, cfg->shift, val);
2398#endif
2399
2400 if (!write)
2401 return 0;
2402
2403 ret = abx500_get_register_interruptible(dev,
2404 (u8)cfg->bank, (u8)cfg->addr, ®value);
2405 if (ret < 0) {
2406 dev_err(dev, "abx500_get_reg fail %d, %d\n",
2407 ret, __LINE__);
2408 return -EINVAL;
2409 }
2410
2411 if (cfg->shift >= 0) {
2412 regvalue &= ~(cfg->mask << (cfg->shift));
2413 val = (val & cfg->mask) << (cfg->shift);
2414 } else {
2415 regvalue &= ~(cfg->mask >> (-cfg->shift));
2416 val = (val & cfg->mask) >> (-cfg->shift);
2417 }
2418 val = val | regvalue;
2419
2420 ret = abx500_set_register_interruptible(dev,
2421 (u8)cfg->bank, (u8)cfg->addr, (u8)val);
2422 if (ret < 0) {
2423 pr_err("abx500_set_reg failed %d, %d", ret, __LINE__);
2424 return -EINVAL;
2425 }
2426
2427 return 0;
2428}
2429
2430static ssize_t ab8500_hwreg_write(struct file *file,
2431 const char __user *user_buf, size_t count, loff_t *ppos)
2432{
2433 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2434 char buf[128];
2435 int buf_size, ret;
2436
2437 /* Get userspace string and assure termination */
2438 buf_size = min(count, (sizeof(buf)-1));
2439 if (copy_from_user(buf, user_buf, buf_size))
2440 return -EFAULT;
2441 buf[buf_size] = 0;
2442
2443 /* get args and process */
2444 ret = hwreg_common_write(buf, &hwreg_cfg, dev);
2445 return (ret) ? ret : buf_size;
2446}
2447
2448/*
2449 * - irq subscribe/unsubscribe stuff
2450 */
2451static int ab8500_subscribe_unsubscribe_print(struct seq_file *s, void *p)
2452{
2453 seq_printf(s, "%d\n", irq_first);
2454
2455 return 0;
2456}
2457
2458static int ab8500_subscribe_unsubscribe_open(struct inode *inode,
2459 struct file *file)
2460{
2461 return single_open(file, ab8500_subscribe_unsubscribe_print,
2462 inode->i_private);
2463}
2464
2465/*
2466 * Userspace should use poll() on this file. When an event occur
2467 * the blocking poll will be released.
2468 */
2469static ssize_t show_irq(struct device *dev,
2470 struct device_attribute *attr, char *buf)
2471{
2472 unsigned long name;
2473 unsigned int irq_index;
2474 int err;
2475
2476 err = kstrtoul(attr->attr.name, 0, &name);
2477 if (err)
2478 return err;
2479
2480 irq_index = name - irq_first;
2481 if (irq_index >= num_irqs)
2482 return -EINVAL;
2483
2484 return sprintf(buf, "%u\n", irq_count[irq_index]);
2485}
2486
2487static ssize_t ab8500_subscribe_write(struct file *file,
2488 const char __user *user_buf,
2489 size_t count, loff_t *ppos)
2490{
2491 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2492 unsigned long user_val;
2493 int err;
2494 unsigned int irq_index;
2495
2496 err = kstrtoul_from_user(user_buf, count, 0, &user_val);
2497 if (err)
2498 return err;
2499
2500 if (user_val < irq_first) {
2501 dev_err(dev, "debugfs error input < %d\n", irq_first);
2502 return -EINVAL;
2503 }
2504 if (user_val > irq_last) {
2505 dev_err(dev, "debugfs error input > %d\n", irq_last);
2506 return -EINVAL;
2507 }
2508
2509 irq_index = user_val - irq_first;
2510 if (irq_index >= num_irqs)
2511 return -EINVAL;
2512
2513 /*
2514 * This will create a sysfs file named <irq-nr> which userspace can
2515 * use to select or poll and get the AB8500 events
2516 */
2517 dev_attr[irq_index] = kmalloc(sizeof(struct device_attribute),
2518 GFP_KERNEL);
2519 if (!dev_attr[irq_index])
2520 return -ENOMEM;
2521
2522 event_name[irq_index] = kasprintf(GFP_KERNEL, "%lu", user_val);
2523 if (!event_name[irq_index])
2524 return -ENOMEM;
2525
2526 dev_attr[irq_index]->show = show_irq;
2527 dev_attr[irq_index]->store = NULL;
2528 dev_attr[irq_index]->attr.name = event_name[irq_index];
2529 dev_attr[irq_index]->attr.mode = S_IRUGO;
2530 err = sysfs_create_file(&dev->kobj, &dev_attr[irq_index]->attr);
2531 if (err < 0) {
2532 pr_info("sysfs_create_file failed %d\n", err);
2533 return err;
2534 }
2535
2536 err = request_threaded_irq(user_val, NULL, ab8500_debug_handler,
2537 IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT,
2538 "ab8500-debug", &dev->kobj);
2539 if (err < 0) {
2540 pr_info("request_threaded_irq failed %d, %lu\n",
2541 err, user_val);
2542 sysfs_remove_file(&dev->kobj, &dev_attr[irq_index]->attr);
2543 return err;
2544 }
2545
2546 return count;
2547}
2548
2549static ssize_t ab8500_unsubscribe_write(struct file *file,
2550 const char __user *user_buf,
2551 size_t count, loff_t *ppos)
2552{
2553 struct device *dev = ((struct seq_file *)(file->private_data))->private;
2554 unsigned long user_val;
2555 int err;
2556 unsigned int irq_index;
2557
2558 err = kstrtoul_from_user(user_buf, count, 0, &user_val);
2559 if (err)
2560 return err;
2561
2562 if (user_val < irq_first) {
2563 dev_err(dev, "debugfs error input < %d\n", irq_first);
2564 return -EINVAL;
2565 }
2566 if (user_val > irq_last) {
2567 dev_err(dev, "debugfs error input > %d\n", irq_last);
2568 return -EINVAL;
2569 }
2570
2571 irq_index = user_val - irq_first;
2572 if (irq_index >= num_irqs)
2573 return -EINVAL;
2574
2575 /* Set irq count to 0 when unsubscribe */
2576 irq_count[irq_index] = 0;
2577
2578 if (dev_attr[irq_index])
2579 sysfs_remove_file(&dev->kobj, &dev_attr[irq_index]->attr);
2580
2581
2582 free_irq(user_val, &dev->kobj);
2583 kfree(event_name[irq_index]);
2584 kfree(dev_attr[irq_index]);
2585
2586 return count;
2587}
2588
2589/*
2590 * - several debugfs nodes fops
2591 */
2592
2593static const struct file_operations ab8500_bank_fops = {
2594 .open = ab8500_bank_open,
2595 .write = ab8500_bank_write,
2596 .read = seq_read,
2597 .llseek = seq_lseek,
2598 .release = single_release,
2599 .owner = THIS_MODULE,
2600};
2601
2602static const struct file_operations ab8500_address_fops = {
2603 .open = ab8500_address_open,
2604 .write = ab8500_address_write,
2605 .read = seq_read,
2606 .llseek = seq_lseek,
2607 .release = single_release,
2608 .owner = THIS_MODULE,
2609};
2610
2611static const struct file_operations ab8500_val_fops = {
2612 .open = ab8500_val_open,
2613 .write = ab8500_val_write,
2614 .read = seq_read,
2615 .llseek = seq_lseek,
2616 .release = single_release,
2617 .owner = THIS_MODULE,
2618};
2619
2620static const struct file_operations ab8500_subscribe_fops = {
2621 .open = ab8500_subscribe_unsubscribe_open,
2622 .write = ab8500_subscribe_write,
2623 .read = seq_read,
2624 .llseek = seq_lseek,
2625 .release = single_release,
2626 .owner = THIS_MODULE,
2627};
2628
2629static const struct file_operations ab8500_unsubscribe_fops = {
2630 .open = ab8500_subscribe_unsubscribe_open,
2631 .write = ab8500_unsubscribe_write,
2632 .read = seq_read,
2633 .llseek = seq_lseek,
2634 .release = single_release,
2635 .owner = THIS_MODULE,
2636};
2637
2638static const struct file_operations ab8500_hwreg_fops = {
2639 .open = ab8500_hwreg_open,
2640 .write = ab8500_hwreg_write,
2641 .read = seq_read,
2642 .llseek = seq_lseek,
2643 .release = single_release,
2644 .owner = THIS_MODULE,
2645};
2646
2647static int ab8500_debug_probe(struct platform_device *plf)
2648{
2649 struct dentry *ab8500_dir;
2650 struct dentry *ab8500_gpadc_dir;
2651 struct ab8500 *ab8500;
2652 struct resource *res;
2653
2654 debug_bank = AB8500_MISC;
2655 debug_address = AB8500_REV_REG & 0x00FF;
2656
2657 ab8500 = dev_get_drvdata(plf->dev.parent);
2658 num_irqs = ab8500->mask_size;
2659
2660 irq_count = devm_kcalloc(&plf->dev,
2661 num_irqs, sizeof(*irq_count), GFP_KERNEL);
2662 if (!irq_count)
2663 return -ENOMEM;
2664
2665 dev_attr = devm_kcalloc(&plf->dev,
2666 num_irqs, sizeof(*dev_attr), GFP_KERNEL);
2667 if (!dev_attr)
2668 return -ENOMEM;
2669
2670 event_name = devm_kcalloc(&plf->dev,
2671 num_irqs, sizeof(*event_name), GFP_KERNEL);
2672 if (!event_name)
2673 return -ENOMEM;
2674
2675 res = platform_get_resource_byname(plf, 0, "IRQ_AB8500");
2676 if (!res) {
2677 dev_err(&plf->dev, "AB8500 irq not found, err %d\n", irq_first);
2678 return -ENXIO;
2679 }
2680 irq_ab8500 = res->start;
2681
2682 irq_first = platform_get_irq_byname(plf, "IRQ_FIRST");
2683 if (irq_first < 0)
2684 return irq_first;
2685
2686 irq_last = platform_get_irq_byname(plf, "IRQ_LAST");
2687 if (irq_last < 0)
2688 return irq_last;
2689
2690 ab8500_dir = debugfs_create_dir(AB8500_NAME_STRING, NULL);
2691
2692 ab8500_gpadc_dir = debugfs_create_dir(AB8500_ADC_NAME_STRING,
2693 ab8500_dir);
2694
2695 debugfs_create_file("all-bank-registers", S_IRUGO, ab8500_dir,
2696 &plf->dev, &ab8500_bank_registers_fops);
2697 debugfs_create_file("all-banks", S_IRUGO, ab8500_dir,
2698 &plf->dev, &ab8500_all_banks_fops);
2699 debugfs_create_file("register-bank", (S_IRUGO | S_IWUSR | S_IWGRP),
2700 ab8500_dir, &plf->dev, &ab8500_bank_fops);
2701 debugfs_create_file("register-address", (S_IRUGO | S_IWUSR | S_IWGRP),
2702 ab8500_dir, &plf->dev, &ab8500_address_fops);
2703 debugfs_create_file("register-value", (S_IRUGO | S_IWUSR | S_IWGRP),
2704 ab8500_dir, &plf->dev, &ab8500_val_fops);
2705 debugfs_create_file("irq-subscribe", (S_IRUGO | S_IWUSR | S_IWGRP),
2706 ab8500_dir, &plf->dev, &ab8500_subscribe_fops);
2707
2708 if (is_ab8500(ab8500)) {
2709 debug_ranges = ab8500_debug_ranges;
2710 num_interrupt_lines = AB8500_NR_IRQS;
2711 } else if (is_ab8505(ab8500)) {
2712 debug_ranges = ab8505_debug_ranges;
2713 num_interrupt_lines = AB8505_NR_IRQS;
2714 } else if (is_ab9540(ab8500)) {
2715 debug_ranges = ab8505_debug_ranges;
2716 num_interrupt_lines = AB9540_NR_IRQS;
2717 } else if (is_ab8540(ab8500)) {
2718 debug_ranges = ab8540_debug_ranges;
2719 num_interrupt_lines = AB8540_NR_IRQS;
2720 }
2721
2722 debugfs_create_file("interrupts", (S_IRUGO), ab8500_dir, &plf->dev,
2723 &ab8500_interrupts_fops);
2724 debugfs_create_file("irq-unsubscribe", (S_IRUGO | S_IWUSR | S_IWGRP),
2725 ab8500_dir, &plf->dev, &ab8500_unsubscribe_fops);
2726 debugfs_create_file("hwreg", (S_IRUGO | S_IWUSR | S_IWGRP), ab8500_dir,
2727 &plf->dev, &ab8500_hwreg_fops);
2728 debugfs_create_file("all-modem-registers", (S_IRUGO | S_IWUSR | S_IWGRP),
2729 ab8500_dir, &plf->dev, &ab8500_modem_fops);
2730 debugfs_create_file("bat_ctrl", (S_IRUGO | S_IWUSR | S_IWGRP),
2731 ab8500_gpadc_dir, &plf->dev,
2732 &ab8500_gpadc_bat_ctrl_fops);
2733 debugfs_create_file("btemp_ball", (S_IRUGO | S_IWUSR | S_IWGRP),
2734 ab8500_gpadc_dir, &plf->dev,
2735 &ab8500_gpadc_btemp_ball_fops);
2736 debugfs_create_file("main_charger_v", (S_IRUGO | S_IWUSR | S_IWGRP),
2737 ab8500_gpadc_dir, &plf->dev,
2738 &ab8500_gpadc_main_charger_v_fops);
2739 debugfs_create_file("acc_detect1", (S_IRUGO | S_IWUSR | S_IWGRP),
2740 ab8500_gpadc_dir, &plf->dev,
2741 &ab8500_gpadc_acc_detect1_fops);
2742 debugfs_create_file("acc_detect2", (S_IRUGO | S_IWUSR | S_IWGRP),
2743 ab8500_gpadc_dir, &plf->dev,
2744 &ab8500_gpadc_acc_detect2_fops);
2745 debugfs_create_file("adc_aux1", (S_IRUGO | S_IWUSR | S_IWGRP),
2746 ab8500_gpadc_dir, &plf->dev,
2747 &ab8500_gpadc_aux1_fops);
2748 debugfs_create_file("adc_aux2", (S_IRUGO | S_IWUSR | S_IWGRP),
2749 ab8500_gpadc_dir, &plf->dev,
2750 &ab8500_gpadc_aux2_fops);
2751 debugfs_create_file("main_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),
2752 ab8500_gpadc_dir, &plf->dev,
2753 &ab8500_gpadc_main_bat_v_fops);
2754 debugfs_create_file("vbus_v", (S_IRUGO | S_IWUSR | S_IWGRP),
2755 ab8500_gpadc_dir, &plf->dev,
2756 &ab8500_gpadc_vbus_v_fops);
2757 debugfs_create_file("main_charger_c", (S_IRUGO | S_IWUSR | S_IWGRP),
2758 ab8500_gpadc_dir, &plf->dev,
2759 &ab8500_gpadc_main_charger_c_fops);
2760 debugfs_create_file("usb_charger_c", (S_IRUGO | S_IWUSR | S_IWGRP),
2761 ab8500_gpadc_dir, &plf->dev,
2762 &ab8500_gpadc_usb_charger_c_fops);
2763 debugfs_create_file("bk_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),
2764 ab8500_gpadc_dir, &plf->dev,
2765 &ab8500_gpadc_bk_bat_v_fops);
2766 debugfs_create_file("die_temp", (S_IRUGO | S_IWUSR | S_IWGRP),
2767 ab8500_gpadc_dir, &plf->dev,
2768 &ab8500_gpadc_die_temp_fops);
2769 debugfs_create_file("usb_id", (S_IRUGO | S_IWUSR | S_IWGRP),
2770 ab8500_gpadc_dir, &plf->dev,
2771 &ab8500_gpadc_usb_id_fops);
2772 if (is_ab8540(ab8500)) {
2773 debugfs_create_file("xtal_temp", (S_IRUGO | S_IWUSR | S_IWGRP),
2774 ab8500_gpadc_dir, &plf->dev,
2775 &ab8540_gpadc_xtal_temp_fops);
2776 debugfs_create_file("vbattruemeas", (S_IRUGO | S_IWUSR | S_IWGRP),
2777 ab8500_gpadc_dir, &plf->dev,
2778 &ab8540_gpadc_vbat_true_meas_fops);
2779 debugfs_create_file("batctrl_and_ibat", (S_IRUGO | S_IWUGO),
2780 ab8500_gpadc_dir, &plf->dev,
2781 &ab8540_gpadc_bat_ctrl_and_ibat_fops);
2782 debugfs_create_file("vbatmeas_and_ibat", (S_IRUGO | S_IWUGO),
2783 ab8500_gpadc_dir, &plf->dev,
2784 &ab8540_gpadc_vbat_meas_and_ibat_fops);
2785 debugfs_create_file("vbattruemeas_and_ibat", (S_IRUGO | S_IWUGO),
2786 ab8500_gpadc_dir, &plf->dev,
2787 &ab8540_gpadc_vbat_true_meas_and_ibat_fops);
2788 debugfs_create_file("battemp_and_ibat", (S_IRUGO | S_IWUGO),
2789 ab8500_gpadc_dir, &plf->dev,
2790 &ab8540_gpadc_bat_temp_and_ibat_fops);
2791 debugfs_create_file("otp_calib", (S_IRUGO | S_IWUSR | S_IWGRP),
2792 ab8500_gpadc_dir, &plf->dev,
2793 &ab8540_gpadc_otp_calib_fops);
2794 }
2795 debugfs_create_file("avg_sample", (S_IRUGO | S_IWUSR | S_IWGRP),
2796 ab8500_gpadc_dir, &plf->dev,
2797 &ab8500_gpadc_avg_sample_fops);
2798 debugfs_create_file("trig_edge", (S_IRUGO | S_IWUSR | S_IWGRP),
2799 ab8500_gpadc_dir, &plf->dev,
2800 &ab8500_gpadc_trig_edge_fops);
2801 debugfs_create_file("trig_timer", (S_IRUGO | S_IWUSR | S_IWGRP),
2802 ab8500_gpadc_dir, &plf->dev,
2803 &ab8500_gpadc_trig_timer_fops);
2804 debugfs_create_file("conv_type", (S_IRUGO | S_IWUSR | S_IWGRP),
2805 ab8500_gpadc_dir, &plf->dev,
2806 &ab8500_gpadc_conv_type_fops);
2807
2808 return 0;
2809}
2810
2811static struct platform_driver ab8500_debug_driver = {
2812 .driver = {
2813 .name = "ab8500-debug",
2814 .suppress_bind_attrs = true,
2815 },
2816 .probe = ab8500_debug_probe,
2817};
2818
2819static int __init ab8500_debug_init(void)
2820{
2821 return platform_driver_register(&ab8500_debug_driver);
2822}
2823subsys_initcall(ab8500_debug_init);