1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/bitmap.h>
14#include <linux/delay.h>
15#include <linux/err.h>
16#include <linux/interrupt.h>
17#include <linux/io.h>
18#include <linux/irqchip/chained_irq.h>
19#include <linux/irqdomain.h>
20#include <linux/irq.h>
21#include <linux/kernel.h>
22#include <linux/module.h>
23#include <linux/of.h>
24#include <linux/platform_device.h>
25#include <linux/slab.h>
26#include <linux/spmi.h>
27
28
29#define PMIC_ARB_VERSION 0x0000
30#define PMIC_ARB_VERSION_V2_MIN 0x20010000
31#define PMIC_ARB_VERSION_V3_MIN 0x30000000
32#define PMIC_ARB_VERSION_V5_MIN 0x50000000
33#define PMIC_ARB_INT_EN 0x0004
34
35
36#define PMIC_ARB_CMD 0x00
37#define PMIC_ARB_CONFIG 0x04
38#define PMIC_ARB_STATUS 0x08
39#define PMIC_ARB_WDATA0 0x10
40#define PMIC_ARB_WDATA1 0x14
41#define PMIC_ARB_RDATA0 0x18
42#define PMIC_ARB_RDATA1 0x1C
43
44
45#define SPMI_MAPPING_TABLE_REG(N) (0x0B00 + (4 * (N)))
46#define SPMI_MAPPING_BIT_INDEX(X) (((X) >> 18) & 0xF)
47#define SPMI_MAPPING_BIT_IS_0_FLAG(X) (((X) >> 17) & 0x1)
48#define SPMI_MAPPING_BIT_IS_0_RESULT(X) (((X) >> 9) & 0xFF)
49#define SPMI_MAPPING_BIT_IS_1_FLAG(X) (((X) >> 8) & 0x1)
50#define SPMI_MAPPING_BIT_IS_1_RESULT(X) (((X) >> 0) & 0xFF)
51
52#define SPMI_MAPPING_TABLE_TREE_DEPTH 16
53#define PMIC_ARB_MAX_PPID BIT(12)
54#define PMIC_ARB_APID_VALID BIT(15)
55#define PMIC_ARB_CHAN_IS_IRQ_OWNER(reg) ((reg) & BIT(24))
56#define INVALID_EE 0xFF
57
58
59#define SPMI_OWNERSHIP_TABLE_REG(N) (0x0700 + (4 * (N)))
60#define SPMI_OWNERSHIP_PERIPH2OWNER(X) ((X) & 0x7)
61
62
63enum pmic_arb_chnl_status {
64 PMIC_ARB_STATUS_DONE = BIT(0),
65 PMIC_ARB_STATUS_FAILURE = BIT(1),
66 PMIC_ARB_STATUS_DENIED = BIT(2),
67 PMIC_ARB_STATUS_DROPPED = BIT(3),
68};
69
70
71#define PMIC_ARB_CMD_MAX_BYTE_COUNT 8
72
73
74enum pmic_arb_cmd_op_code {
75 PMIC_ARB_OP_EXT_WRITEL = 0,
76 PMIC_ARB_OP_EXT_READL = 1,
77 PMIC_ARB_OP_EXT_WRITE = 2,
78 PMIC_ARB_OP_RESET = 3,
79 PMIC_ARB_OP_SLEEP = 4,
80 PMIC_ARB_OP_SHUTDOWN = 5,
81 PMIC_ARB_OP_WAKEUP = 6,
82 PMIC_ARB_OP_AUTHENTICATE = 7,
83 PMIC_ARB_OP_MSTR_READ = 8,
84 PMIC_ARB_OP_MSTR_WRITE = 9,
85 PMIC_ARB_OP_EXT_READ = 13,
86 PMIC_ARB_OP_WRITE = 14,
87 PMIC_ARB_OP_READ = 15,
88 PMIC_ARB_OP_ZERO_WRITE = 16,
89};
90
91
92
93
94
95enum pmic_arb_channel {
96 PMIC_ARB_CHANNEL_RW,
97 PMIC_ARB_CHANNEL_OBS,
98};
99
100
101#define PMIC_ARB_MAX_PERIPHS 512
102#define PMIC_ARB_TIMEOUT_US 100
103#define PMIC_ARB_MAX_TRANS_BYTES (8)
104
105#define PMIC_ARB_APID_MASK 0xFF
106#define PMIC_ARB_PPID_MASK 0xFFF
107
108
109#define SPMI_PIC_ACC_ENABLE_BIT BIT(0)
110
111#define spec_to_hwirq(slave_id, periph_id, irq_id, apid) \
112 ((((slave_id) & 0xF) << 28) | \
113 (((periph_id) & 0xFF) << 20) | \
114 (((irq_id) & 0x7) << 16) | \
115 (((apid) & 0x1FF) << 0))
116
117#define hwirq_to_sid(hwirq) (((hwirq) >> 28) & 0xF)
118#define hwirq_to_per(hwirq) (((hwirq) >> 20) & 0xFF)
119#define hwirq_to_irq(hwirq) (((hwirq) >> 16) & 0x7)
120#define hwirq_to_apid(hwirq) (((hwirq) >> 0) & 0x1FF)
121
122struct pmic_arb_ver_ops;
123
124struct apid_data {
125 u16 ppid;
126 u8 write_ee;
127 u8 irq_ee;
128};
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149struct spmi_pmic_arb {
150 void __iomem *rd_base;
151 void __iomem *wr_base;
152 void __iomem *intr;
153 void __iomem *cnfg;
154 void __iomem *core;
155 resource_size_t core_size;
156 raw_spinlock_t lock;
157 u8 channel;
158 int irq;
159 u8 ee;
160 u16 min_apid;
161 u16 max_apid;
162 u32 *mapping_table;
163 DECLARE_BITMAP(mapping_table_valid, PMIC_ARB_MAX_PERIPHS);
164 struct irq_domain *domain;
165 struct spmi_controller *spmic;
166 const struct pmic_arb_ver_ops *ver_ops;
167 u16 *ppid_to_apid;
168 u16 last_apid;
169 struct apid_data apid_data[PMIC_ARB_MAX_PERIPHS];
170};
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192struct pmic_arb_ver_ops {
193 const char *ver_str;
194 int (*ppid_to_apid)(struct spmi_pmic_arb *pmic_arb, u16 ppid);
195
196 int (*offset)(struct spmi_pmic_arb *pmic_arb, u8 sid, u16 addr,
197 enum pmic_arb_channel ch_type);
198 u32 (*fmt_cmd)(u8 opc, u8 sid, u16 addr, u8 bc);
199 int (*non_data_cmd)(struct spmi_controller *ctrl, u8 opc, u8 sid);
200
201 void __iomem *(*owner_acc_status)(struct spmi_pmic_arb *pmic_arb, u8 m,
202 u16 n);
203 void __iomem *(*acc_enable)(struct spmi_pmic_arb *pmic_arb, u16 n);
204 void __iomem *(*irq_status)(struct spmi_pmic_arb *pmic_arb, u16 n);
205 void __iomem *(*irq_clear)(struct spmi_pmic_arb *pmic_arb, u16 n);
206 u32 (*apid_map_offset)(u16 n);
207};
208
209static inline void pmic_arb_base_write(struct spmi_pmic_arb *pmic_arb,
210 u32 offset, u32 val)
211{
212 writel_relaxed(val, pmic_arb->wr_base + offset);
213}
214
215static inline void pmic_arb_set_rd_cmd(struct spmi_pmic_arb *pmic_arb,
216 u32 offset, u32 val)
217{
218 writel_relaxed(val, pmic_arb->rd_base + offset);
219}
220
221
222
223
224
225
226
227static void
228pmic_arb_read_data(struct spmi_pmic_arb *pmic_arb, u8 *buf, u32 reg, u8 bc)
229{
230 u32 data = __raw_readl(pmic_arb->rd_base + reg);
231
232 memcpy(buf, &data, (bc & 3) + 1);
233}
234
235
236
237
238
239
240
241static void pmic_arb_write_data(struct spmi_pmic_arb *pmic_arb, const u8 *buf,
242 u32 reg, u8 bc)
243{
244 u32 data = 0;
245
246 memcpy(&data, buf, (bc & 3) + 1);
247 __raw_writel(data, pmic_arb->wr_base + reg);
248}
249
250static int pmic_arb_wait_for_done(struct spmi_controller *ctrl,
251 void __iomem *base, u8 sid, u16 addr,
252 enum pmic_arb_channel ch_type)
253{
254 struct spmi_pmic_arb *pmic_arb = spmi_controller_get_drvdata(ctrl);
255 u32 status = 0;
256 u32 timeout = PMIC_ARB_TIMEOUT_US;
257 u32 offset;
258 int rc;
259
260 rc = pmic_arb->ver_ops->offset(pmic_arb, sid, addr, ch_type);
261 if (rc < 0)
262 return rc;
263
264 offset = rc;
265 offset += PMIC_ARB_STATUS;
266
267 while (timeout--) {
268 status = readl_relaxed(base + offset);
269
270 if (status & PMIC_ARB_STATUS_DONE) {
271 if (status & PMIC_ARB_STATUS_DENIED) {
272 dev_err(&ctrl->dev, "%s: transaction denied (0x%x)\n",
273 __func__, status);
274 return -EPERM;
275 }
276
277 if (status & PMIC_ARB_STATUS_FAILURE) {
278 dev_err(&ctrl->dev, "%s: transaction failed (0x%x)\n",
279 __func__, status);
280 return -EIO;
281 }
282
283 if (status & PMIC_ARB_STATUS_DROPPED) {
284 dev_err(&ctrl->dev, "%s: transaction dropped (0x%x)\n",
285 __func__, status);
286 return -EIO;
287 }
288
289 return 0;
290 }
291 udelay(1);
292 }
293
294 dev_err(&ctrl->dev, "%s: timeout, status 0x%x\n",
295 __func__, status);
296 return -ETIMEDOUT;
297}
298
299static int
300pmic_arb_non_data_cmd_v1(struct spmi_controller *ctrl, u8 opc, u8 sid)
301{
302 struct spmi_pmic_arb *pmic_arb = spmi_controller_get_drvdata(ctrl);
303 unsigned long flags;
304 u32 cmd;
305 int rc;
306 u32 offset;
307
308 rc = pmic_arb->ver_ops->offset(pmic_arb, sid, 0, PMIC_ARB_CHANNEL_RW);
309 if (rc < 0)
310 return rc;
311
312 offset = rc;
313 cmd = ((opc | 0x40) << 27) | ((sid & 0xf) << 20);
314
315 raw_spin_lock_irqsave(&pmic_arb->lock, flags);
316 pmic_arb_base_write(pmic_arb, offset + PMIC_ARB_CMD, cmd);
317 rc = pmic_arb_wait_for_done(ctrl, pmic_arb->wr_base, sid, 0,
318 PMIC_ARB_CHANNEL_RW);
319 raw_spin_unlock_irqrestore(&pmic_arb->lock, flags);
320
321 return rc;
322}
323
324static int
325pmic_arb_non_data_cmd_v2(struct spmi_controller *ctrl, u8 opc, u8 sid)
326{
327 return -EOPNOTSUPP;
328}
329
330
331static int pmic_arb_cmd(struct spmi_controller *ctrl, u8 opc, u8 sid)
332{
333 struct spmi_pmic_arb *pmic_arb = spmi_controller_get_drvdata(ctrl);
334
335 dev_dbg(&ctrl->dev, "cmd op:0x%x sid:%d\n", opc, sid);
336
337
338 if (opc < SPMI_CMD_RESET || opc > SPMI_CMD_WAKEUP)
339 return -EINVAL;
340
341 return pmic_arb->ver_ops->non_data_cmd(ctrl, opc, sid);
342}
343
344static int pmic_arb_read_cmd(struct spmi_controller *ctrl, u8 opc, u8 sid,
345 u16 addr, u8 *buf, size_t len)
346{
347 struct spmi_pmic_arb *pmic_arb = spmi_controller_get_drvdata(ctrl);
348 unsigned long flags;
349 u8 bc = len - 1;
350 u32 cmd;
351 int rc;
352 u32 offset;
353
354 rc = pmic_arb->ver_ops->offset(pmic_arb, sid, addr,
355 PMIC_ARB_CHANNEL_OBS);
356 if (rc < 0)
357 return rc;
358
359 offset = rc;
360 if (bc >= PMIC_ARB_MAX_TRANS_BYTES) {
361 dev_err(&ctrl->dev, "pmic-arb supports 1..%d bytes per trans, but:%zu requested",
362 PMIC_ARB_MAX_TRANS_BYTES, len);
363 return -EINVAL;
364 }
365
366
367 if (opc >= 0x60 && opc <= 0x7F)
368 opc = PMIC_ARB_OP_READ;
369 else if (opc >= 0x20 && opc <= 0x2F)
370 opc = PMIC_ARB_OP_EXT_READ;
371 else if (opc >= 0x38 && opc <= 0x3F)
372 opc = PMIC_ARB_OP_EXT_READL;
373 else
374 return -EINVAL;
375
376 cmd = pmic_arb->ver_ops->fmt_cmd(opc, sid, addr, bc);
377
378 raw_spin_lock_irqsave(&pmic_arb->lock, flags);
379 pmic_arb_set_rd_cmd(pmic_arb, offset + PMIC_ARB_CMD, cmd);
380 rc = pmic_arb_wait_for_done(ctrl, pmic_arb->rd_base, sid, addr,
381 PMIC_ARB_CHANNEL_OBS);
382 if (rc)
383 goto done;
384
385 pmic_arb_read_data(pmic_arb, buf, offset + PMIC_ARB_RDATA0,
386 min_t(u8, bc, 3));
387
388 if (bc > 3)
389 pmic_arb_read_data(pmic_arb, buf + 4, offset + PMIC_ARB_RDATA1,
390 bc - 4);
391
392done:
393 raw_spin_unlock_irqrestore(&pmic_arb->lock, flags);
394 return rc;
395}
396
397static int pmic_arb_write_cmd(struct spmi_controller *ctrl, u8 opc, u8 sid,
398 u16 addr, const u8 *buf, size_t len)
399{
400 struct spmi_pmic_arb *pmic_arb = spmi_controller_get_drvdata(ctrl);
401 unsigned long flags;
402 u8 bc = len - 1;
403 u32 cmd;
404 int rc;
405 u32 offset;
406
407 rc = pmic_arb->ver_ops->offset(pmic_arb, sid, addr,
408 PMIC_ARB_CHANNEL_RW);
409 if (rc < 0)
410 return rc;
411
412 offset = rc;
413 if (bc >= PMIC_ARB_MAX_TRANS_BYTES) {
414 dev_err(&ctrl->dev, "pmic-arb supports 1..%d bytes per trans, but:%zu requested",
415 PMIC_ARB_MAX_TRANS_BYTES, len);
416 return -EINVAL;
417 }
418
419
420 if (opc >= 0x40 && opc <= 0x5F)
421 opc = PMIC_ARB_OP_WRITE;
422 else if (opc <= 0x0F)
423 opc = PMIC_ARB_OP_EXT_WRITE;
424 else if (opc >= 0x30 && opc <= 0x37)
425 opc = PMIC_ARB_OP_EXT_WRITEL;
426 else if (opc >= 0x80)
427 opc = PMIC_ARB_OP_ZERO_WRITE;
428 else
429 return -EINVAL;
430
431 cmd = pmic_arb->ver_ops->fmt_cmd(opc, sid, addr, bc);
432
433
434 raw_spin_lock_irqsave(&pmic_arb->lock, flags);
435 pmic_arb_write_data(pmic_arb, buf, offset + PMIC_ARB_WDATA0,
436 min_t(u8, bc, 3));
437 if (bc > 3)
438 pmic_arb_write_data(pmic_arb, buf + 4, offset + PMIC_ARB_WDATA1,
439 bc - 4);
440
441
442 pmic_arb_base_write(pmic_arb, offset + PMIC_ARB_CMD, cmd);
443 rc = pmic_arb_wait_for_done(ctrl, pmic_arb->wr_base, sid, addr,
444 PMIC_ARB_CHANNEL_RW);
445 raw_spin_unlock_irqrestore(&pmic_arb->lock, flags);
446
447 return rc;
448}
449
450enum qpnpint_regs {
451 QPNPINT_REG_RT_STS = 0x10,
452 QPNPINT_REG_SET_TYPE = 0x11,
453 QPNPINT_REG_POLARITY_HIGH = 0x12,
454 QPNPINT_REG_POLARITY_LOW = 0x13,
455 QPNPINT_REG_LATCHED_CLR = 0x14,
456 QPNPINT_REG_EN_SET = 0x15,
457 QPNPINT_REG_EN_CLR = 0x16,
458 QPNPINT_REG_LATCHED_STS = 0x18,
459};
460
461struct spmi_pmic_arb_qpnpint_type {
462 u8 type;
463 u8 polarity_high;
464 u8 polarity_low;
465} __packed;
466
467
468static void qpnpint_spmi_write(struct irq_data *d, u8 reg, void *buf,
469 size_t len)
470{
471 struct spmi_pmic_arb *pmic_arb = irq_data_get_irq_chip_data(d);
472 u8 sid = hwirq_to_sid(d->hwirq);
473 u8 per = hwirq_to_per(d->hwirq);
474
475 if (pmic_arb_write_cmd(pmic_arb->spmic, SPMI_CMD_EXT_WRITEL, sid,
476 (per << 8) + reg, buf, len))
477 dev_err_ratelimited(&pmic_arb->spmic->dev, "failed irqchip transaction on %x\n",
478 d->irq);
479}
480
481static void qpnpint_spmi_read(struct irq_data *d, u8 reg, void *buf, size_t len)
482{
483 struct spmi_pmic_arb *pmic_arb = irq_data_get_irq_chip_data(d);
484 u8 sid = hwirq_to_sid(d->hwirq);
485 u8 per = hwirq_to_per(d->hwirq);
486
487 if (pmic_arb_read_cmd(pmic_arb->spmic, SPMI_CMD_EXT_READL, sid,
488 (per << 8) + reg, buf, len))
489 dev_err_ratelimited(&pmic_arb->spmic->dev, "failed irqchip transaction on %x\n",
490 d->irq);
491}
492
493static void cleanup_irq(struct spmi_pmic_arb *pmic_arb, u16 apid, int id)
494{
495 u16 ppid = pmic_arb->apid_data[apid].ppid;
496 u8 sid = ppid >> 8;
497 u8 per = ppid & 0xFF;
498 u8 irq_mask = BIT(id);
499
500 writel_relaxed(irq_mask, pmic_arb->ver_ops->irq_clear(pmic_arb, apid));
501
502 if (pmic_arb_write_cmd(pmic_arb->spmic, SPMI_CMD_EXT_WRITEL, sid,
503 (per << 8) + QPNPINT_REG_LATCHED_CLR, &irq_mask, 1))
504 dev_err_ratelimited(&pmic_arb->spmic->dev, "failed to ack irq_mask = 0x%x for ppid = %x\n",
505 irq_mask, ppid);
506
507 if (pmic_arb_write_cmd(pmic_arb->spmic, SPMI_CMD_EXT_WRITEL, sid,
508 (per << 8) + QPNPINT_REG_EN_CLR, &irq_mask, 1))
509 dev_err_ratelimited(&pmic_arb->spmic->dev, "failed to ack irq_mask = 0x%x for ppid = %x\n",
510 irq_mask, ppid);
511}
512
513static void periph_interrupt(struct spmi_pmic_arb *pmic_arb, u16 apid)
514{
515 unsigned int irq;
516 u32 status;
517 int id;
518 u8 sid = (pmic_arb->apid_data[apid].ppid >> 8) & 0xF;
519 u8 per = pmic_arb->apid_data[apid].ppid & 0xFF;
520
521 status = readl_relaxed(pmic_arb->ver_ops->irq_status(pmic_arb, apid));
522 while (status) {
523 id = ffs(status) - 1;
524 status &= ~BIT(id);
525 irq = irq_find_mapping(pmic_arb->domain,
526 spec_to_hwirq(sid, per, id, apid));
527 if (irq == 0) {
528 cleanup_irq(pmic_arb, apid, id);
529 continue;
530 }
531 generic_handle_irq(irq);
532 }
533}
534
535static void pmic_arb_chained_irq(struct irq_desc *desc)
536{
537 struct spmi_pmic_arb *pmic_arb = irq_desc_get_handler_data(desc);
538 const struct pmic_arb_ver_ops *ver_ops = pmic_arb->ver_ops;
539 struct irq_chip *chip = irq_desc_get_chip(desc);
540 int first = pmic_arb->min_apid >> 5;
541 int last = pmic_arb->max_apid >> 5;
542 u8 ee = pmic_arb->ee;
543 u32 status, enable;
544 int i, id, apid;
545
546 chained_irq_enter(chip, desc);
547
548 for (i = first; i <= last; ++i) {
549 status = readl_relaxed(
550 ver_ops->owner_acc_status(pmic_arb, ee, i));
551 while (status) {
552 id = ffs(status) - 1;
553 status &= ~BIT(id);
554 apid = id + i * 32;
555 enable = readl_relaxed(
556 ver_ops->acc_enable(pmic_arb, apid));
557 if (enable & SPMI_PIC_ACC_ENABLE_BIT)
558 periph_interrupt(pmic_arb, apid);
559 }
560 }
561
562 chained_irq_exit(chip, desc);
563}
564
565static void qpnpint_irq_ack(struct irq_data *d)
566{
567 struct spmi_pmic_arb *pmic_arb = irq_data_get_irq_chip_data(d);
568 u8 irq = hwirq_to_irq(d->hwirq);
569 u16 apid = hwirq_to_apid(d->hwirq);
570 u8 data;
571
572 writel_relaxed(BIT(irq), pmic_arb->ver_ops->irq_clear(pmic_arb, apid));
573
574 data = BIT(irq);
575 qpnpint_spmi_write(d, QPNPINT_REG_LATCHED_CLR, &data, 1);
576}
577
578static void qpnpint_irq_mask(struct irq_data *d)
579{
580 u8 irq = hwirq_to_irq(d->hwirq);
581 u8 data = BIT(irq);
582
583 qpnpint_spmi_write(d, QPNPINT_REG_EN_CLR, &data, 1);
584}
585
586static void qpnpint_irq_unmask(struct irq_data *d)
587{
588 struct spmi_pmic_arb *pmic_arb = irq_data_get_irq_chip_data(d);
589 const struct pmic_arb_ver_ops *ver_ops = pmic_arb->ver_ops;
590 u8 irq = hwirq_to_irq(d->hwirq);
591 u16 apid = hwirq_to_apid(d->hwirq);
592 u8 buf[2];
593
594 writel_relaxed(SPMI_PIC_ACC_ENABLE_BIT,
595 ver_ops->acc_enable(pmic_arb, apid));
596
597 qpnpint_spmi_read(d, QPNPINT_REG_EN_SET, &buf[0], 1);
598 if (!(buf[0] & BIT(irq))) {
599
600
601
602
603
604 buf[0] = BIT(irq);
605 buf[1] = BIT(irq);
606 qpnpint_spmi_write(d, QPNPINT_REG_LATCHED_CLR, &buf, 2);
607 }
608}
609
610static int qpnpint_irq_set_type(struct irq_data *d, unsigned int flow_type)
611{
612 struct spmi_pmic_arb_qpnpint_type type;
613 irq_flow_handler_t flow_handler;
614 u8 irq = hwirq_to_irq(d->hwirq);
615
616 qpnpint_spmi_read(d, QPNPINT_REG_SET_TYPE, &type, sizeof(type));
617
618 if (flow_type & (IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING)) {
619 type.type |= BIT(irq);
620 if (flow_type & IRQF_TRIGGER_RISING)
621 type.polarity_high |= BIT(irq);
622 if (flow_type & IRQF_TRIGGER_FALLING)
623 type.polarity_low |= BIT(irq);
624
625 flow_handler = handle_edge_irq;
626 } else {
627 if ((flow_type & (IRQF_TRIGGER_HIGH)) &&
628 (flow_type & (IRQF_TRIGGER_LOW)))
629 return -EINVAL;
630
631 type.type &= ~BIT(irq);
632 if (flow_type & IRQF_TRIGGER_HIGH)
633 type.polarity_high |= BIT(irq);
634 else
635 type.polarity_low |= BIT(irq);
636
637 flow_handler = handle_level_irq;
638 }
639
640 qpnpint_spmi_write(d, QPNPINT_REG_SET_TYPE, &type, sizeof(type));
641 irq_set_handler_locked(d, flow_handler);
642
643 return 0;
644}
645
646static int qpnpint_irq_set_wake(struct irq_data *d, unsigned int on)
647{
648 struct spmi_pmic_arb *pmic_arb = irq_data_get_irq_chip_data(d);
649
650 return irq_set_irq_wake(pmic_arb->irq, on);
651}
652
653static int qpnpint_get_irqchip_state(struct irq_data *d,
654 enum irqchip_irq_state which,
655 bool *state)
656{
657 u8 irq = hwirq_to_irq(d->hwirq);
658 u8 status = 0;
659
660 if (which != IRQCHIP_STATE_LINE_LEVEL)
661 return -EINVAL;
662
663 qpnpint_spmi_read(d, QPNPINT_REG_RT_STS, &status, 1);
664 *state = !!(status & BIT(irq));
665
666 return 0;
667}
668
669static int qpnpint_irq_request_resources(struct irq_data *d)
670{
671 struct spmi_pmic_arb *pmic_arb = irq_data_get_irq_chip_data(d);
672 u16 periph = hwirq_to_per(d->hwirq);
673 u16 apid = hwirq_to_apid(d->hwirq);
674 u16 sid = hwirq_to_sid(d->hwirq);
675 u16 irq = hwirq_to_irq(d->hwirq);
676
677 if (pmic_arb->apid_data[apid].irq_ee != pmic_arb->ee) {
678 dev_err(&pmic_arb->spmic->dev, "failed to xlate sid = %#x, periph = %#x, irq = %u: ee=%u but owner=%u\n",
679 sid, periph, irq, pmic_arb->ee,
680 pmic_arb->apid_data[apid].irq_ee);
681 return -ENODEV;
682 }
683
684 return 0;
685}
686
687static struct irq_chip pmic_arb_irqchip = {
688 .name = "pmic_arb",
689 .irq_ack = qpnpint_irq_ack,
690 .irq_mask = qpnpint_irq_mask,
691 .irq_unmask = qpnpint_irq_unmask,
692 .irq_set_type = qpnpint_irq_set_type,
693 .irq_set_wake = qpnpint_irq_set_wake,
694 .irq_get_irqchip_state = qpnpint_get_irqchip_state,
695 .irq_request_resources = qpnpint_irq_request_resources,
696 .flags = IRQCHIP_MASK_ON_SUSPEND,
697};
698
699static int qpnpint_irq_domain_dt_translate(struct irq_domain *d,
700 struct device_node *controller,
701 const u32 *intspec,
702 unsigned int intsize,
703 unsigned long *out_hwirq,
704 unsigned int *out_type)
705{
706 struct spmi_pmic_arb *pmic_arb = d->host_data;
707 u16 apid, ppid;
708 int rc;
709
710 dev_dbg(&pmic_arb->spmic->dev, "intspec[0] 0x%1x intspec[1] 0x%02x intspec[2] 0x%02x\n",
711 intspec[0], intspec[1], intspec[2]);
712
713 if (irq_domain_get_of_node(d) != controller)
714 return -EINVAL;
715 if (intsize != 4)
716 return -EINVAL;
717 if (intspec[0] > 0xF || intspec[1] > 0xFF || intspec[2] > 0x7)
718 return -EINVAL;
719
720 ppid = intspec[0] << 8 | intspec[1];
721 rc = pmic_arb->ver_ops->ppid_to_apid(pmic_arb, ppid);
722 if (rc < 0) {
723 dev_err(&pmic_arb->spmic->dev, "failed to xlate sid = %#x, periph = %#x, irq = %u rc = %d\n",
724 intspec[0], intspec[1], intspec[2], rc);
725 return rc;
726 }
727
728 apid = rc;
729
730 if (apid > pmic_arb->max_apid)
731 pmic_arb->max_apid = apid;
732 if (apid < pmic_arb->min_apid)
733 pmic_arb->min_apid = apid;
734
735 *out_hwirq = spec_to_hwirq(intspec[0], intspec[1], intspec[2], apid);
736 *out_type = intspec[3] & IRQ_TYPE_SENSE_MASK;
737
738 dev_dbg(&pmic_arb->spmic->dev, "out_hwirq = %lu\n", *out_hwirq);
739
740 return 0;
741}
742
743static int qpnpint_irq_domain_map(struct irq_domain *d,
744 unsigned int virq,
745 irq_hw_number_t hwirq)
746{
747 struct spmi_pmic_arb *pmic_arb = d->host_data;
748
749 dev_dbg(&pmic_arb->spmic->dev, "virq = %u, hwirq = %lu\n", virq, hwirq);
750
751 irq_set_chip_and_handler(virq, &pmic_arb_irqchip, handle_level_irq);
752 irq_set_chip_data(virq, d->host_data);
753 irq_set_noprobe(virq);
754 return 0;
755}
756
757static int pmic_arb_ppid_to_apid_v1(struct spmi_pmic_arb *pmic_arb, u16 ppid)
758{
759 u32 *mapping_table = pmic_arb->mapping_table;
760 int index = 0, i;
761 u16 apid_valid;
762 u16 apid;
763 u32 data;
764
765 apid_valid = pmic_arb->ppid_to_apid[ppid];
766 if (apid_valid & PMIC_ARB_APID_VALID) {
767 apid = apid_valid & ~PMIC_ARB_APID_VALID;
768 return apid;
769 }
770
771 for (i = 0; i < SPMI_MAPPING_TABLE_TREE_DEPTH; ++i) {
772 if (!test_and_set_bit(index, pmic_arb->mapping_table_valid))
773 mapping_table[index] = readl_relaxed(pmic_arb->cnfg +
774 SPMI_MAPPING_TABLE_REG(index));
775
776 data = mapping_table[index];
777
778 if (ppid & BIT(SPMI_MAPPING_BIT_INDEX(data))) {
779 if (SPMI_MAPPING_BIT_IS_1_FLAG(data)) {
780 index = SPMI_MAPPING_BIT_IS_1_RESULT(data);
781 } else {
782 apid = SPMI_MAPPING_BIT_IS_1_RESULT(data);
783 pmic_arb->ppid_to_apid[ppid]
784 = apid | PMIC_ARB_APID_VALID;
785 pmic_arb->apid_data[apid].ppid = ppid;
786 return apid;
787 }
788 } else {
789 if (SPMI_MAPPING_BIT_IS_0_FLAG(data)) {
790 index = SPMI_MAPPING_BIT_IS_0_RESULT(data);
791 } else {
792 apid = SPMI_MAPPING_BIT_IS_0_RESULT(data);
793 pmic_arb->ppid_to_apid[ppid]
794 = apid | PMIC_ARB_APID_VALID;
795 pmic_arb->apid_data[apid].ppid = ppid;
796 return apid;
797 }
798 }
799 }
800
801 return -ENODEV;
802}
803
804
805static int pmic_arb_offset_v1(struct spmi_pmic_arb *pmic_arb, u8 sid, u16 addr,
806 enum pmic_arb_channel ch_type)
807{
808 return 0x800 + 0x80 * pmic_arb->channel;
809}
810
811static u16 pmic_arb_find_apid(struct spmi_pmic_arb *pmic_arb, u16 ppid)
812{
813 struct apid_data *apidd = &pmic_arb->apid_data[pmic_arb->last_apid];
814 u32 regval, offset;
815 u16 id, apid;
816
817 for (apid = pmic_arb->last_apid; ; apid++, apidd++) {
818 offset = pmic_arb->ver_ops->apid_map_offset(apid);
819 if (offset >= pmic_arb->core_size)
820 break;
821
822 regval = readl_relaxed(pmic_arb->cnfg +
823 SPMI_OWNERSHIP_TABLE_REG(apid));
824 apidd->irq_ee = SPMI_OWNERSHIP_PERIPH2OWNER(regval);
825 apidd->write_ee = apidd->irq_ee;
826
827 regval = readl_relaxed(pmic_arb->core + offset);
828 if (!regval)
829 continue;
830
831 id = (regval >> 8) & PMIC_ARB_PPID_MASK;
832 pmic_arb->ppid_to_apid[id] = apid | PMIC_ARB_APID_VALID;
833 apidd->ppid = id;
834 if (id == ppid) {
835 apid |= PMIC_ARB_APID_VALID;
836 break;
837 }
838 }
839 pmic_arb->last_apid = apid & ~PMIC_ARB_APID_VALID;
840
841 return apid;
842}
843
844static int pmic_arb_ppid_to_apid_v2(struct spmi_pmic_arb *pmic_arb, u16 ppid)
845{
846 u16 apid_valid;
847
848 apid_valid = pmic_arb->ppid_to_apid[ppid];
849 if (!(apid_valid & PMIC_ARB_APID_VALID))
850 apid_valid = pmic_arb_find_apid(pmic_arb, ppid);
851 if (!(apid_valid & PMIC_ARB_APID_VALID))
852 return -ENODEV;
853
854 return apid_valid & ~PMIC_ARB_APID_VALID;
855}
856
857static int pmic_arb_read_apid_map_v5(struct spmi_pmic_arb *pmic_arb)
858{
859 struct apid_data *apidd = pmic_arb->apid_data;
860 struct apid_data *prev_apidd;
861 u16 i, apid, ppid;
862 bool valid, is_irq_ee;
863 u32 regval, offset;
864
865
866
867
868
869
870
871
872 for (i = 0; ; i++, apidd++) {
873 offset = pmic_arb->ver_ops->apid_map_offset(i);
874 if (offset >= pmic_arb->core_size)
875 break;
876
877 regval = readl_relaxed(pmic_arb->core + offset);
878 if (!regval)
879 continue;
880 ppid = (regval >> 8) & PMIC_ARB_PPID_MASK;
881 is_irq_ee = PMIC_ARB_CHAN_IS_IRQ_OWNER(regval);
882
883 regval = readl_relaxed(pmic_arb->cnfg +
884 SPMI_OWNERSHIP_TABLE_REG(i));
885 apidd->write_ee = SPMI_OWNERSHIP_PERIPH2OWNER(regval);
886
887 apidd->irq_ee = is_irq_ee ? apidd->write_ee : INVALID_EE;
888
889 valid = pmic_arb->ppid_to_apid[ppid] & PMIC_ARB_APID_VALID;
890 apid = pmic_arb->ppid_to_apid[ppid] & ~PMIC_ARB_APID_VALID;
891 prev_apidd = &pmic_arb->apid_data[apid];
892
893 if (valid && is_irq_ee &&
894 prev_apidd->write_ee == pmic_arb->ee) {
895
896
897
898
899 prev_apidd->irq_ee = apidd->irq_ee;
900 } else if (!valid || is_irq_ee) {
901
902 pmic_arb->ppid_to_apid[ppid] = i | PMIC_ARB_APID_VALID;
903 }
904
905 apidd->ppid = ppid;
906 pmic_arb->last_apid = i;
907 }
908
909
910 dev_dbg(&pmic_arb->spmic->dev, "PPID APID Write-EE IRQ-EE\n");
911 for (ppid = 0; ppid < PMIC_ARB_MAX_PPID; ppid++) {
912 apid = pmic_arb->ppid_to_apid[ppid];
913 if (apid & PMIC_ARB_APID_VALID) {
914 apid &= ~PMIC_ARB_APID_VALID;
915 apidd = &pmic_arb->apid_data[apid];
916 dev_dbg(&pmic_arb->spmic->dev, "%#03X %3u %2u %2u\n",
917 ppid, apid, apidd->write_ee, apidd->irq_ee);
918 }
919 }
920
921 return 0;
922}
923
924static int pmic_arb_ppid_to_apid_v5(struct spmi_pmic_arb *pmic_arb, u16 ppid)
925{
926 if (!(pmic_arb->ppid_to_apid[ppid] & PMIC_ARB_APID_VALID))
927 return -ENODEV;
928
929 return pmic_arb->ppid_to_apid[ppid] & ~PMIC_ARB_APID_VALID;
930}
931
932
933static int pmic_arb_offset_v2(struct spmi_pmic_arb *pmic_arb, u8 sid, u16 addr,
934 enum pmic_arb_channel ch_type)
935{
936 u16 apid;
937 u16 ppid;
938 int rc;
939
940 ppid = sid << 8 | ((addr >> 8) & 0xFF);
941 rc = pmic_arb_ppid_to_apid_v2(pmic_arb, ppid);
942 if (rc < 0)
943 return rc;
944
945 apid = rc;
946 return 0x1000 * pmic_arb->ee + 0x8000 * apid;
947}
948
949
950
951
952
953static int pmic_arb_offset_v5(struct spmi_pmic_arb *pmic_arb, u8 sid, u16 addr,
954 enum pmic_arb_channel ch_type)
955{
956 u16 apid;
957 int rc;
958 u32 offset = 0;
959 u16 ppid = (sid << 8) | (addr >> 8);
960
961 rc = pmic_arb_ppid_to_apid_v5(pmic_arb, ppid);
962 if (rc < 0)
963 return rc;
964
965 apid = rc;
966 switch (ch_type) {
967 case PMIC_ARB_CHANNEL_OBS:
968 offset = 0x10000 * pmic_arb->ee + 0x80 * apid;
969 break;
970 case PMIC_ARB_CHANNEL_RW:
971 offset = 0x10000 * apid;
972 break;
973 }
974
975 return offset;
976}
977
978static u32 pmic_arb_fmt_cmd_v1(u8 opc, u8 sid, u16 addr, u8 bc)
979{
980 return (opc << 27) | ((sid & 0xf) << 20) | (addr << 4) | (bc & 0x7);
981}
982
983static u32 pmic_arb_fmt_cmd_v2(u8 opc, u8 sid, u16 addr, u8 bc)
984{
985 return (opc << 27) | ((addr & 0xff) << 4) | (bc & 0x7);
986}
987
988static void __iomem *
989pmic_arb_owner_acc_status_v1(struct spmi_pmic_arb *pmic_arb, u8 m, u16 n)
990{
991 return pmic_arb->intr + 0x20 * m + 0x4 * n;
992}
993
994static void __iomem *
995pmic_arb_owner_acc_status_v2(struct spmi_pmic_arb *pmic_arb, u8 m, u16 n)
996{
997 return pmic_arb->intr + 0x100000 + 0x1000 * m + 0x4 * n;
998}
999
1000static void __iomem *
1001pmic_arb_owner_acc_status_v3(struct spmi_pmic_arb *pmic_arb, u8 m, u16 n)
1002{
1003 return pmic_arb->intr + 0x200000 + 0x1000 * m + 0x4 * n;
1004}
1005
1006static void __iomem *
1007pmic_arb_owner_acc_status_v5(struct spmi_pmic_arb *pmic_arb, u8 m, u16 n)
1008{
1009 return pmic_arb->intr + 0x10000 * m + 0x4 * n;
1010}
1011
1012static void __iomem *
1013pmic_arb_acc_enable_v1(struct spmi_pmic_arb *pmic_arb, u16 n)
1014{
1015 return pmic_arb->intr + 0x200 + 0x4 * n;
1016}
1017
1018static void __iomem *
1019pmic_arb_acc_enable_v2(struct spmi_pmic_arb *pmic_arb, u16 n)
1020{
1021 return pmic_arb->intr + 0x1000 * n;
1022}
1023
1024static void __iomem *
1025pmic_arb_acc_enable_v5(struct spmi_pmic_arb *pmic_arb, u16 n)
1026{
1027 return pmic_arb->wr_base + 0x100 + 0x10000 * n;
1028}
1029
1030static void __iomem *
1031pmic_arb_irq_status_v1(struct spmi_pmic_arb *pmic_arb, u16 n)
1032{
1033 return pmic_arb->intr + 0x600 + 0x4 * n;
1034}
1035
1036static void __iomem *
1037pmic_arb_irq_status_v2(struct spmi_pmic_arb *pmic_arb, u16 n)
1038{
1039 return pmic_arb->intr + 0x4 + 0x1000 * n;
1040}
1041
1042static void __iomem *
1043pmic_arb_irq_status_v5(struct spmi_pmic_arb *pmic_arb, u16 n)
1044{
1045 return pmic_arb->wr_base + 0x104 + 0x10000 * n;
1046}
1047
1048static void __iomem *
1049pmic_arb_irq_clear_v1(struct spmi_pmic_arb *pmic_arb, u16 n)
1050{
1051 return pmic_arb->intr + 0xA00 + 0x4 * n;
1052}
1053
1054static void __iomem *
1055pmic_arb_irq_clear_v2(struct spmi_pmic_arb *pmic_arb, u16 n)
1056{
1057 return pmic_arb->intr + 0x8 + 0x1000 * n;
1058}
1059
1060static void __iomem *
1061pmic_arb_irq_clear_v5(struct spmi_pmic_arb *pmic_arb, u16 n)
1062{
1063 return pmic_arb->wr_base + 0x108 + 0x10000 * n;
1064}
1065
1066static u32 pmic_arb_apid_map_offset_v2(u16 n)
1067{
1068 return 0x800 + 0x4 * n;
1069}
1070
1071static u32 pmic_arb_apid_map_offset_v5(u16 n)
1072{
1073 return 0x900 + 0x4 * n;
1074}
1075
1076static const struct pmic_arb_ver_ops pmic_arb_v1 = {
1077 .ver_str = "v1",
1078 .ppid_to_apid = pmic_arb_ppid_to_apid_v1,
1079 .non_data_cmd = pmic_arb_non_data_cmd_v1,
1080 .offset = pmic_arb_offset_v1,
1081 .fmt_cmd = pmic_arb_fmt_cmd_v1,
1082 .owner_acc_status = pmic_arb_owner_acc_status_v1,
1083 .acc_enable = pmic_arb_acc_enable_v1,
1084 .irq_status = pmic_arb_irq_status_v1,
1085 .irq_clear = pmic_arb_irq_clear_v1,
1086 .apid_map_offset = pmic_arb_apid_map_offset_v2,
1087};
1088
1089static const struct pmic_arb_ver_ops pmic_arb_v2 = {
1090 .ver_str = "v2",
1091 .ppid_to_apid = pmic_arb_ppid_to_apid_v2,
1092 .non_data_cmd = pmic_arb_non_data_cmd_v2,
1093 .offset = pmic_arb_offset_v2,
1094 .fmt_cmd = pmic_arb_fmt_cmd_v2,
1095 .owner_acc_status = pmic_arb_owner_acc_status_v2,
1096 .acc_enable = pmic_arb_acc_enable_v2,
1097 .irq_status = pmic_arb_irq_status_v2,
1098 .irq_clear = pmic_arb_irq_clear_v2,
1099 .apid_map_offset = pmic_arb_apid_map_offset_v2,
1100};
1101
1102static const struct pmic_arb_ver_ops pmic_arb_v3 = {
1103 .ver_str = "v3",
1104 .ppid_to_apid = pmic_arb_ppid_to_apid_v2,
1105 .non_data_cmd = pmic_arb_non_data_cmd_v2,
1106 .offset = pmic_arb_offset_v2,
1107 .fmt_cmd = pmic_arb_fmt_cmd_v2,
1108 .owner_acc_status = pmic_arb_owner_acc_status_v3,
1109 .acc_enable = pmic_arb_acc_enable_v2,
1110 .irq_status = pmic_arb_irq_status_v2,
1111 .irq_clear = pmic_arb_irq_clear_v2,
1112 .apid_map_offset = pmic_arb_apid_map_offset_v2,
1113};
1114
1115static const struct pmic_arb_ver_ops pmic_arb_v5 = {
1116 .ver_str = "v5",
1117 .ppid_to_apid = pmic_arb_ppid_to_apid_v5,
1118 .non_data_cmd = pmic_arb_non_data_cmd_v2,
1119 .offset = pmic_arb_offset_v5,
1120 .fmt_cmd = pmic_arb_fmt_cmd_v2,
1121 .owner_acc_status = pmic_arb_owner_acc_status_v5,
1122 .acc_enable = pmic_arb_acc_enable_v5,
1123 .irq_status = pmic_arb_irq_status_v5,
1124 .irq_clear = pmic_arb_irq_clear_v5,
1125 .apid_map_offset = pmic_arb_apid_map_offset_v5,
1126};
1127
1128static const struct irq_domain_ops pmic_arb_irq_domain_ops = {
1129 .map = qpnpint_irq_domain_map,
1130 .xlate = qpnpint_irq_domain_dt_translate,
1131};
1132
1133static int spmi_pmic_arb_probe(struct platform_device *pdev)
1134{
1135 struct spmi_pmic_arb *pmic_arb;
1136 struct spmi_controller *ctrl;
1137 struct resource *res;
1138 void __iomem *core;
1139 u32 *mapping_table;
1140 u32 channel, ee, hw_ver;
1141 int err;
1142
1143 ctrl = spmi_controller_alloc(&pdev->dev, sizeof(*pmic_arb));
1144 if (!ctrl)
1145 return -ENOMEM;
1146
1147 pmic_arb = spmi_controller_get_drvdata(ctrl);
1148 pmic_arb->spmic = ctrl;
1149
1150 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "core");
1151 core = devm_ioremap_resource(&ctrl->dev, res);
1152 if (IS_ERR(core)) {
1153 err = PTR_ERR(core);
1154 goto err_put_ctrl;
1155 }
1156
1157 pmic_arb->core_size = resource_size(res);
1158
1159 pmic_arb->ppid_to_apid = devm_kcalloc(&ctrl->dev, PMIC_ARB_MAX_PPID,
1160 sizeof(*pmic_arb->ppid_to_apid),
1161 GFP_KERNEL);
1162 if (!pmic_arb->ppid_to_apid) {
1163 err = -ENOMEM;
1164 goto err_put_ctrl;
1165 }
1166
1167 hw_ver = readl_relaxed(core + PMIC_ARB_VERSION);
1168
1169 if (hw_ver < PMIC_ARB_VERSION_V2_MIN) {
1170 pmic_arb->ver_ops = &pmic_arb_v1;
1171 pmic_arb->wr_base = core;
1172 pmic_arb->rd_base = core;
1173 } else {
1174 pmic_arb->core = core;
1175
1176 if (hw_ver < PMIC_ARB_VERSION_V3_MIN)
1177 pmic_arb->ver_ops = &pmic_arb_v2;
1178 else if (hw_ver < PMIC_ARB_VERSION_V5_MIN)
1179 pmic_arb->ver_ops = &pmic_arb_v3;
1180 else
1181 pmic_arb->ver_ops = &pmic_arb_v5;
1182
1183 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
1184 "obsrvr");
1185 pmic_arb->rd_base = devm_ioremap_resource(&ctrl->dev, res);
1186 if (IS_ERR(pmic_arb->rd_base)) {
1187 err = PTR_ERR(pmic_arb->rd_base);
1188 goto err_put_ctrl;
1189 }
1190
1191 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
1192 "chnls");
1193 pmic_arb->wr_base = devm_ioremap_resource(&ctrl->dev, res);
1194 if (IS_ERR(pmic_arb->wr_base)) {
1195 err = PTR_ERR(pmic_arb->wr_base);
1196 goto err_put_ctrl;
1197 }
1198 }
1199
1200 dev_info(&ctrl->dev, "PMIC arbiter version %s (0x%x)\n",
1201 pmic_arb->ver_ops->ver_str, hw_ver);
1202
1203 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "intr");
1204 pmic_arb->intr = devm_ioremap_resource(&ctrl->dev, res);
1205 if (IS_ERR(pmic_arb->intr)) {
1206 err = PTR_ERR(pmic_arb->intr);
1207 goto err_put_ctrl;
1208 }
1209
1210 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cnfg");
1211 pmic_arb->cnfg = devm_ioremap_resource(&ctrl->dev, res);
1212 if (IS_ERR(pmic_arb->cnfg)) {
1213 err = PTR_ERR(pmic_arb->cnfg);
1214 goto err_put_ctrl;
1215 }
1216
1217 pmic_arb->irq = platform_get_irq_byname(pdev, "periph_irq");
1218 if (pmic_arb->irq < 0) {
1219 err = pmic_arb->irq;
1220 goto err_put_ctrl;
1221 }
1222
1223 err = of_property_read_u32(pdev->dev.of_node, "qcom,channel", &channel);
1224 if (err) {
1225 dev_err(&pdev->dev, "channel unspecified.\n");
1226 goto err_put_ctrl;
1227 }
1228
1229 if (channel > 5) {
1230 dev_err(&pdev->dev, "invalid channel (%u) specified.\n",
1231 channel);
1232 err = -EINVAL;
1233 goto err_put_ctrl;
1234 }
1235
1236 pmic_arb->channel = channel;
1237
1238 err = of_property_read_u32(pdev->dev.of_node, "qcom,ee", &ee);
1239 if (err) {
1240 dev_err(&pdev->dev, "EE unspecified.\n");
1241 goto err_put_ctrl;
1242 }
1243
1244 if (ee > 5) {
1245 dev_err(&pdev->dev, "invalid EE (%u) specified\n", ee);
1246 err = -EINVAL;
1247 goto err_put_ctrl;
1248 }
1249
1250 pmic_arb->ee = ee;
1251 mapping_table = devm_kcalloc(&ctrl->dev, PMIC_ARB_MAX_PERIPHS,
1252 sizeof(*mapping_table), GFP_KERNEL);
1253 if (!mapping_table) {
1254 err = -ENOMEM;
1255 goto err_put_ctrl;
1256 }
1257
1258 pmic_arb->mapping_table = mapping_table;
1259
1260
1261 pmic_arb->max_apid = 0;
1262 pmic_arb->min_apid = PMIC_ARB_MAX_PERIPHS - 1;
1263
1264 platform_set_drvdata(pdev, ctrl);
1265 raw_spin_lock_init(&pmic_arb->lock);
1266
1267 ctrl->cmd = pmic_arb_cmd;
1268 ctrl->read_cmd = pmic_arb_read_cmd;
1269 ctrl->write_cmd = pmic_arb_write_cmd;
1270
1271 if (hw_ver >= PMIC_ARB_VERSION_V5_MIN) {
1272 err = pmic_arb_read_apid_map_v5(pmic_arb);
1273 if (err) {
1274 dev_err(&pdev->dev, "could not read APID->PPID mapping table, rc= %d\n",
1275 err);
1276 goto err_put_ctrl;
1277 }
1278 }
1279
1280 dev_dbg(&pdev->dev, "adding irq domain\n");
1281 pmic_arb->domain = irq_domain_add_tree(pdev->dev.of_node,
1282 &pmic_arb_irq_domain_ops, pmic_arb);
1283 if (!pmic_arb->domain) {
1284 dev_err(&pdev->dev, "unable to create irq_domain\n");
1285 err = -ENOMEM;
1286 goto err_put_ctrl;
1287 }
1288
1289 irq_set_chained_handler_and_data(pmic_arb->irq, pmic_arb_chained_irq,
1290 pmic_arb);
1291 err = spmi_controller_add(ctrl);
1292 if (err)
1293 goto err_domain_remove;
1294
1295 return 0;
1296
1297err_domain_remove:
1298 irq_set_chained_handler_and_data(pmic_arb->irq, NULL, NULL);
1299 irq_domain_remove(pmic_arb->domain);
1300err_put_ctrl:
1301 spmi_controller_put(ctrl);
1302 return err;
1303}
1304
1305static int spmi_pmic_arb_remove(struct platform_device *pdev)
1306{
1307 struct spmi_controller *ctrl = platform_get_drvdata(pdev);
1308 struct spmi_pmic_arb *pmic_arb = spmi_controller_get_drvdata(ctrl);
1309 spmi_controller_remove(ctrl);
1310 irq_set_chained_handler_and_data(pmic_arb->irq, NULL, NULL);
1311 irq_domain_remove(pmic_arb->domain);
1312 spmi_controller_put(ctrl);
1313 return 0;
1314}
1315
1316static const struct of_device_id spmi_pmic_arb_match_table[] = {
1317 { .compatible = "qcom,spmi-pmic-arb", },
1318 {},
1319};
1320MODULE_DEVICE_TABLE(of, spmi_pmic_arb_match_table);
1321
1322static struct platform_driver spmi_pmic_arb_driver = {
1323 .probe = spmi_pmic_arb_probe,
1324 .remove = spmi_pmic_arb_remove,
1325 .driver = {
1326 .name = "spmi_pmic_arb",
1327 .of_match_table = spmi_pmic_arb_match_table,
1328 },
1329};
1330module_platform_driver(spmi_pmic_arb_driver);
1331
1332MODULE_LICENSE("GPL v2");
1333MODULE_ALIAS("platform:spmi_pmic_arb");
1334
