2 * PowerMac G5 SMU driver
4 * Copyright 2004 J. Mayer <l_indien@magic.fr>
5 * Copyright 2005 Benjamin Herrenschmidt, IBM Corp.
7 * Released under the term of the GNU GPL v2.
12 * - maybe add timeout to commands ?
13 * - blocking version of time functions
14 * - polling version of i2c commands (including timer that works with
16 * - maybe avoid some data copies with i2c by directly using the smu cmd
17 * buffer and a lower level internal interface
18 * - understand SMU -> CPU events and implement reception of them via
19 * the userland interface
22 #include <linux/smp_lock.h>
23 #include <linux/types.h>
24 #include <linux/kernel.h>
25 #include <linux/device.h>
26 #include <linux/dmapool.h>
27 #include <linux/bootmem.h>
28 #include <linux/vmalloc.h>
29 #include <linux/highmem.h>
30 #include <linux/jiffies.h>
31 #include <linux/interrupt.h>
32 #include <linux/rtc.h>
33 #include <linux/completion.h>
34 #include <linux/miscdevice.h>
35 #include <linux/delay.h>
36 #include <linux/sysdev.h>
37 #include <linux/poll.h>
38 #include <linux/mutex.h>
40 #include <asm/byteorder.h>
43 #include <asm/machdep.h>
44 #include <asm/pmac_feature.h>
46 #include <asm/sections.h>
47 #include <asm/abs_addr.h>
48 #include <asm/uaccess.h>
49 #include <asm/of_device.h>
50 #include <asm/of_platform.h>
53 #define AUTHOR "(c) 2005 Benjamin Herrenschmidt, IBM Corp."
58 #define DPRINTK(fmt, args...) do { printk(KERN_DEBUG fmt , ##args); } while (0)
60 #define DPRINTK(fmt, args...) do { } while (0)
64 * This is the command buffer passed to the SMU hardware
66 #define SMU_MAX_DATA 254
71 u8 data
[SMU_MAX_DATA
];
76 struct device_node
*of_node
;
77 struct of_device
*of_dev
;
78 int doorbell
; /* doorbell gpio */
79 u32 __iomem
*db_buf
; /* doorbell buffer */
80 struct device_node
*db_node
;
83 struct device_node
*msg_node
;
85 struct smu_cmd_buf
*cmd_buf
; /* command buffer virtual */
86 u32 cmd_buf_abs
; /* command buffer absolute */
87 struct list_head cmd_list
;
88 struct smu_cmd
*cmd_cur
; /* pending command */
90 struct list_head cmd_i2c_list
;
91 struct smu_i2c_cmd
*cmd_i2c_cur
; /* pending i2c command */
92 struct timer_list i2c_timer
;
96 * I don't think there will ever be more than one SMU, so
97 * for now, just hard code that
99 static struct smu_device
*smu
;
100 static DEFINE_MUTEX(smu_part_access
);
101 static int smu_irq_inited
;
103 static void smu_i2c_retry(unsigned long data
);
106 * SMU driver low level stuff
109 static void smu_start_cmd(void)
111 unsigned long faddr
, fend
;
114 if (list_empty(&smu
->cmd_list
))
117 /* Fetch first command in queue */
118 cmd
= list_entry(smu
->cmd_list
.next
, struct smu_cmd
, link
);
120 list_del(&cmd
->link
);
122 DPRINTK("SMU: starting cmd %x, %d bytes data\n", cmd
->cmd
,
124 DPRINTK("SMU: data buffer: %02x %02x %02x %02x %02x %02x %02x %02x\n",
125 ((u8
*)cmd
->data_buf
)[0], ((u8
*)cmd
->data_buf
)[1],
126 ((u8
*)cmd
->data_buf
)[2], ((u8
*)cmd
->data_buf
)[3],
127 ((u8
*)cmd
->data_buf
)[4], ((u8
*)cmd
->data_buf
)[5],
128 ((u8
*)cmd
->data_buf
)[6], ((u8
*)cmd
->data_buf
)[7]);
130 /* Fill the SMU command buffer */
131 smu
->cmd_buf
->cmd
= cmd
->cmd
;
132 smu
->cmd_buf
->length
= cmd
->data_len
;
133 memcpy(smu
->cmd_buf
->data
, cmd
->data_buf
, cmd
->data_len
);
135 /* Flush command and data to RAM */
136 faddr
= (unsigned long)smu
->cmd_buf
;
137 fend
= faddr
+ smu
->cmd_buf
->length
+ 2;
138 flush_inval_dcache_range(faddr
, fend
);
141 /* We also disable NAP mode for the duration of the command
142 * on U3 based machines.
143 * This is slightly racy as it can be written back to 1 by a sysctl
144 * but that never happens in practice. There seem to be an issue with
145 * U3 based machines such as the iMac G5 where napping for the
146 * whole duration of the command prevents the SMU from fetching it
147 * from memory. This might be related to the strange i2c based
148 * mechanism the SMU uses to access memory.
153 /* This isn't exactly a DMA mapping here, I suspect
154 * the SMU is actually communicating with us via i2c to the
155 * northbridge or the CPU to access RAM.
157 writel(smu
->cmd_buf_abs
, smu
->db_buf
);
159 /* Ring the SMU doorbell */
160 pmac_do_feature_call(PMAC_FTR_WRITE_GPIO
, NULL
, smu
->doorbell
, 4);
164 static irqreturn_t
smu_db_intr(int irq
, void *arg
)
168 void (*done
)(struct smu_cmd
*cmd
, void *misc
) = NULL
;
173 /* SMU completed the command, well, we hope, let's make sure
176 spin_lock_irqsave(&smu
->lock
, flags
);
178 gpio
= pmac_do_feature_call(PMAC_FTR_READ_GPIO
, NULL
, smu
->doorbell
);
179 if ((gpio
& 7) != 7) {
180 spin_unlock_irqrestore(&smu
->lock
, flags
);
194 /* CPU might have brought back the cache line, so we need
195 * to flush again before peeking at the SMU response. We
196 * flush the entire buffer for now as we haven't read the
197 * reply length (it's only 2 cache lines anyway)
199 faddr
= (unsigned long)smu
->cmd_buf
;
200 flush_inval_dcache_range(faddr
, faddr
+ 256);
203 ack
= (~cmd
->cmd
) & 0xff;
204 if (ack
!= smu
->cmd_buf
->cmd
) {
205 DPRINTK("SMU: incorrect ack, want %x got %x\n",
206 ack
, smu
->cmd_buf
->cmd
);
209 reply_len
= rc
== 0 ? smu
->cmd_buf
->length
: 0;
210 DPRINTK("SMU: reply len: %d\n", reply_len
);
211 if (reply_len
> cmd
->reply_len
) {
212 printk(KERN_WARNING
"SMU: reply buffer too small,"
213 "got %d bytes for a %d bytes buffer\n",
214 reply_len
, cmd
->reply_len
);
215 reply_len
= cmd
->reply_len
;
217 cmd
->reply_len
= reply_len
;
218 if (cmd
->reply_buf
&& reply_len
)
219 memcpy(cmd
->reply_buf
, smu
->cmd_buf
->data
, reply_len
);
222 /* Now complete the command. Write status last in order as we lost
223 * ownership of the command structure as soon as it's no longer -1
230 /* Re-enable NAP mode */
234 /* Start next command if any */
236 spin_unlock_irqrestore(&smu
->lock
, flags
);
238 /* Call command completion handler if any */
242 /* It's an edge interrupt, nothing to do */
247 static irqreturn_t
smu_msg_intr(int irq
, void *arg
)
249 /* I don't quite know what to do with this one, we seem to never
250 * receive it, so I suspect we have to arm it someway in the SMU
251 * to start getting events that way.
254 printk(KERN_INFO
"SMU: message interrupt !\n");
256 /* It's an edge interrupt, nothing to do */
262 * Queued command management.
266 int smu_queue_cmd(struct smu_cmd
*cmd
)
272 if (cmd
->data_len
> SMU_MAX_DATA
||
273 cmd
->reply_len
> SMU_MAX_DATA
)
277 spin_lock_irqsave(&smu
->lock
, flags
);
278 list_add_tail(&cmd
->link
, &smu
->cmd_list
);
279 if (smu
->cmd_cur
== NULL
)
281 spin_unlock_irqrestore(&smu
->lock
, flags
);
283 /* Workaround for early calls when irq isn't available */
284 if (!smu_irq_inited
|| smu
->db_irq
== NO_IRQ
)
285 smu_spinwait_cmd(cmd
);
289 EXPORT_SYMBOL(smu_queue_cmd
);
292 int smu_queue_simple(struct smu_simple_cmd
*scmd
, u8 command
,
293 unsigned int data_len
,
294 void (*done
)(struct smu_cmd
*cmd
, void *misc
),
297 struct smu_cmd
*cmd
= &scmd
->cmd
;
301 if (data_len
> sizeof(scmd
->buffer
))
304 memset(scmd
, 0, sizeof(*scmd
));
306 cmd
->data_len
= data_len
;
307 cmd
->data_buf
= scmd
->buffer
;
308 cmd
->reply_len
= sizeof(scmd
->buffer
);
309 cmd
->reply_buf
= scmd
->buffer
;
313 va_start(list
, misc
);
314 for (i
= 0; i
< data_len
; ++i
)
315 scmd
->buffer
[i
] = (u8
)va_arg(list
, int);
318 return smu_queue_cmd(cmd
);
320 EXPORT_SYMBOL(smu_queue_simple
);
330 gpio
= pmac_do_feature_call(PMAC_FTR_READ_GPIO
, NULL
, smu
->doorbell
);
332 smu_db_intr(smu
->db_irq
, smu
);
334 EXPORT_SYMBOL(smu_poll
);
337 void smu_done_complete(struct smu_cmd
*cmd
, void *misc
)
339 struct completion
*comp
= misc
;
343 EXPORT_SYMBOL(smu_done_complete
);
346 void smu_spinwait_cmd(struct smu_cmd
*cmd
)
348 while(cmd
->status
== 1)
351 EXPORT_SYMBOL(smu_spinwait_cmd
);
354 /* RTC low level commands */
355 static inline int bcd2hex (int n
)
357 return (((n
& 0xf0) >> 4) * 10) + (n
& 0xf);
361 static inline int hex2bcd (int n
)
363 return ((n
/ 10) << 4) + (n
% 10);
367 static inline void smu_fill_set_rtc_cmd(struct smu_cmd_buf
*cmd_buf
,
368 struct rtc_time
*time
)
372 cmd_buf
->data
[0] = 0x80;
373 cmd_buf
->data
[1] = hex2bcd(time
->tm_sec
);
374 cmd_buf
->data
[2] = hex2bcd(time
->tm_min
);
375 cmd_buf
->data
[3] = hex2bcd(time
->tm_hour
);
376 cmd_buf
->data
[4] = time
->tm_wday
;
377 cmd_buf
->data
[5] = hex2bcd(time
->tm_mday
);
378 cmd_buf
->data
[6] = hex2bcd(time
->tm_mon
) + 1;
379 cmd_buf
->data
[7] = hex2bcd(time
->tm_year
- 100);
383 int smu_get_rtc_time(struct rtc_time
*time
, int spinwait
)
385 struct smu_simple_cmd cmd
;
391 memset(time
, 0, sizeof(struct rtc_time
));
392 rc
= smu_queue_simple(&cmd
, SMU_CMD_RTC_COMMAND
, 1, NULL
, NULL
,
393 SMU_CMD_RTC_GET_DATETIME
);
396 smu_spinwait_simple(&cmd
);
398 time
->tm_sec
= bcd2hex(cmd
.buffer
[0]);
399 time
->tm_min
= bcd2hex(cmd
.buffer
[1]);
400 time
->tm_hour
= bcd2hex(cmd
.buffer
[2]);
401 time
->tm_wday
= bcd2hex(cmd
.buffer
[3]);
402 time
->tm_mday
= bcd2hex(cmd
.buffer
[4]);
403 time
->tm_mon
= bcd2hex(cmd
.buffer
[5]) - 1;
404 time
->tm_year
= bcd2hex(cmd
.buffer
[6]) + 100;
410 int smu_set_rtc_time(struct rtc_time
*time
, int spinwait
)
412 struct smu_simple_cmd cmd
;
418 rc
= smu_queue_simple(&cmd
, SMU_CMD_RTC_COMMAND
, 8, NULL
, NULL
,
419 SMU_CMD_RTC_SET_DATETIME
,
420 hex2bcd(time
->tm_sec
),
421 hex2bcd(time
->tm_min
),
422 hex2bcd(time
->tm_hour
),
424 hex2bcd(time
->tm_mday
),
425 hex2bcd(time
->tm_mon
) + 1,
426 hex2bcd(time
->tm_year
- 100));
429 smu_spinwait_simple(&cmd
);
435 void smu_shutdown(void)
437 struct smu_simple_cmd cmd
;
442 if (smu_queue_simple(&cmd
, SMU_CMD_POWER_COMMAND
, 9, NULL
, NULL
,
443 'S', 'H', 'U', 'T', 'D', 'O', 'W', 'N', 0))
445 smu_spinwait_simple(&cmd
);
451 void smu_restart(void)
453 struct smu_simple_cmd cmd
;
458 if (smu_queue_simple(&cmd
, SMU_CMD_POWER_COMMAND
, 8, NULL
, NULL
,
459 'R', 'E', 'S', 'T', 'A', 'R', 'T', 0))
461 smu_spinwait_simple(&cmd
);
467 int smu_present(void)
471 EXPORT_SYMBOL(smu_present
);
474 int __init
smu_init (void)
476 struct device_node
*np
;
479 np
= of_find_node_by_type(NULL
, "smu");
483 printk(KERN_INFO
"SMU: Driver %s %s\n", VERSION
, AUTHOR
);
485 if (smu_cmdbuf_abs
== 0) {
486 printk(KERN_ERR
"SMU: Command buffer not allocated !\n");
491 smu
= alloc_bootmem(sizeof(struct smu_device
));
496 memset(smu
, 0, sizeof(*smu
));
498 spin_lock_init(&smu
->lock
);
499 INIT_LIST_HEAD(&smu
->cmd_list
);
500 INIT_LIST_HEAD(&smu
->cmd_i2c_list
);
502 smu
->db_irq
= NO_IRQ
;
503 smu
->msg_irq
= NO_IRQ
;
505 /* smu_cmdbuf_abs is in the low 2G of RAM, can be converted to a
506 * 32 bits value safely
508 smu
->cmd_buf_abs
= (u32
)smu_cmdbuf_abs
;
509 smu
->cmd_buf
= (struct smu_cmd_buf
*)abs_to_virt(smu_cmdbuf_abs
);
511 smu
->db_node
= of_find_node_by_name(NULL
, "smu-doorbell");
512 if (smu
->db_node
== NULL
) {
513 printk(KERN_ERR
"SMU: Can't find doorbell GPIO !\n");
516 data
= of_get_property(smu
->db_node
, "reg", NULL
);
518 of_node_put(smu
->db_node
);
520 printk(KERN_ERR
"SMU: Can't find doorbell GPIO address !\n");
524 /* Current setup has one doorbell GPIO that does both doorbell
525 * and ack. GPIOs are at 0x50, best would be to find that out
526 * in the device-tree though.
528 smu
->doorbell
= *data
;
529 if (smu
->doorbell
< 0x50)
530 smu
->doorbell
+= 0x50;
532 /* Now look for the smu-interrupt GPIO */
534 smu
->msg_node
= of_find_node_by_name(NULL
, "smu-interrupt");
535 if (smu
->msg_node
== NULL
)
537 data
= of_get_property(smu
->msg_node
, "reg", NULL
);
539 of_node_put(smu
->msg_node
);
540 smu
->msg_node
= NULL
;
548 /* Doorbell buffer is currently hard-coded, I didn't find a proper
549 * device-tree entry giving the address. Best would probably to use
550 * an offset for K2 base though, but let's do it that way for now.
552 smu
->db_buf
= ioremap(0x8000860c, 0x1000);
553 if (smu
->db_buf
== NULL
) {
554 printk(KERN_ERR
"SMU: Can't map doorbell buffer pointer !\n");
558 /* U3 has an issue with NAP mode when issuing SMU commands */
559 smu
->broken_nap
= pmac_get_uninorth_variant() < 4;
561 printk(KERN_INFO
"SMU: using NAP mode workaround\n");
563 sys_ctrler
= SYS_CTRLER_SMU
;
573 static int smu_late_init(void)
578 init_timer(&smu
->i2c_timer
);
579 smu
->i2c_timer
.function
= smu_i2c_retry
;
580 smu
->i2c_timer
.data
= (unsigned long)smu
;
583 smu
->db_irq
= irq_of_parse_and_map(smu
->db_node
, 0);
584 if (smu
->db_irq
== NO_IRQ
)
585 printk(KERN_ERR
"smu: failed to map irq for node %s\n",
586 smu
->db_node
->full_name
);
589 smu
->msg_irq
= irq_of_parse_and_map(smu
->msg_node
, 0);
590 if (smu
->msg_irq
== NO_IRQ
)
591 printk(KERN_ERR
"smu: failed to map irq for node %s\n",
592 smu
->msg_node
->full_name
);
596 * Try to request the interrupts
599 if (smu
->db_irq
!= NO_IRQ
) {
600 if (request_irq(smu
->db_irq
, smu_db_intr
,
601 IRQF_SHARED
, "SMU doorbell", smu
) < 0) {
602 printk(KERN_WARNING
"SMU: can't "
603 "request interrupt %d\n",
605 smu
->db_irq
= NO_IRQ
;
609 if (smu
->msg_irq
!= NO_IRQ
) {
610 if (request_irq(smu
->msg_irq
, smu_msg_intr
,
611 IRQF_SHARED
, "SMU message", smu
) < 0) {
612 printk(KERN_WARNING
"SMU: can't "
613 "request interrupt %d\n",
615 smu
->msg_irq
= NO_IRQ
;
622 /* This has to be before arch_initcall as the low i2c stuff relies on the
623 * above having been done before we reach arch_initcalls
625 core_initcall(smu_late_init
);
631 static void smu_expose_childs(struct work_struct
*unused
)
633 struct device_node
*np
;
635 for (np
= NULL
; (np
= of_get_next_child(smu
->of_node
, np
)) != NULL
;)
636 if (of_device_is_compatible(np
, "smu-sensors"))
637 of_platform_device_create(np
, "smu-sensors",
641 static DECLARE_WORK(smu_expose_childs_work
, smu_expose_childs
);
643 static int smu_platform_probe(struct of_device
* dev
,
644 const struct of_device_id
*match
)
651 * Ok, we are matched, now expose all i2c busses. We have to defer
652 * that unfortunately or it would deadlock inside the device model
654 schedule_work(&smu_expose_childs_work
);
659 static struct of_device_id smu_platform_match
[] =
667 static struct of_platform_driver smu_of_platform_driver
=
670 .match_table
= smu_platform_match
,
671 .probe
= smu_platform_probe
,
674 static int __init
smu_init_sysfs(void)
677 * Due to sysfs bogosity, a sysdev is not a real device, so
678 * we should in fact create both if we want sysdev semantics
679 * for power management.
680 * For now, we don't power manage machines with an SMU chip,
681 * I'm a bit too far from figuring out how that works with those
682 * new chipsets, but that will come back and bite us
684 of_register_platform_driver(&smu_of_platform_driver
);
688 device_initcall(smu_init_sysfs
);
690 struct of_device
*smu_get_ofdev(void)
697 EXPORT_SYMBOL_GPL(smu_get_ofdev
);
703 static void smu_i2c_complete_command(struct smu_i2c_cmd
*cmd
, int fail
)
705 void (*done
)(struct smu_i2c_cmd
*cmd
, void *misc
) = cmd
->done
;
706 void *misc
= cmd
->misc
;
709 /* Check for read case */
710 if (!fail
&& cmd
->read
) {
711 if (cmd
->pdata
[0] < 1)
714 memcpy(cmd
->info
.data
, &cmd
->pdata
[1],
718 DPRINTK("SMU: completing, success: %d\n", !fail
);
720 /* Update status and mark no pending i2c command with lock
721 * held so nobody comes in while we dequeue an eventual
722 * pending next i2c command
724 spin_lock_irqsave(&smu
->lock
, flags
);
725 smu
->cmd_i2c_cur
= NULL
;
727 cmd
->status
= fail
? -EIO
: 0;
729 /* Is there another i2c command waiting ? */
730 if (!list_empty(&smu
->cmd_i2c_list
)) {
731 struct smu_i2c_cmd
*newcmd
;
733 /* Fetch it, new current, remove from list */
734 newcmd
= list_entry(smu
->cmd_i2c_list
.next
,
735 struct smu_i2c_cmd
, link
);
736 smu
->cmd_i2c_cur
= newcmd
;
737 list_del(&cmd
->link
);
739 /* Queue with low level smu */
740 list_add_tail(&cmd
->scmd
.link
, &smu
->cmd_list
);
741 if (smu
->cmd_cur
== NULL
)
744 spin_unlock_irqrestore(&smu
->lock
, flags
);
746 /* Call command completion handler if any */
753 static void smu_i2c_retry(unsigned long data
)
755 struct smu_i2c_cmd
*cmd
= smu
->cmd_i2c_cur
;
757 DPRINTK("SMU: i2c failure, requeuing...\n");
759 /* requeue command simply by resetting reply_len */
760 cmd
->pdata
[0] = 0xff;
761 cmd
->scmd
.reply_len
= sizeof(cmd
->pdata
);
762 smu_queue_cmd(&cmd
->scmd
);
766 static void smu_i2c_low_completion(struct smu_cmd
*scmd
, void *misc
)
768 struct smu_i2c_cmd
*cmd
= misc
;
771 DPRINTK("SMU: i2c compl. stage=%d status=%x pdata[0]=%x rlen: %x\n",
772 cmd
->stage
, scmd
->status
, cmd
->pdata
[0], scmd
->reply_len
);
774 /* Check for possible status */
775 if (scmd
->status
< 0)
777 else if (cmd
->read
) {
779 fail
= cmd
->pdata
[0] != 0;
781 fail
= cmd
->pdata
[0] >= 0x80;
783 fail
= cmd
->pdata
[0] != 0;
786 /* Handle failures by requeuing command, after 5ms interval
788 if (fail
&& --cmd
->retries
> 0) {
789 DPRINTK("SMU: i2c failure, starting timer...\n");
790 BUG_ON(cmd
!= smu
->cmd_i2c_cur
);
791 if (!smu_irq_inited
) {
796 mod_timer(&smu
->i2c_timer
, jiffies
+ msecs_to_jiffies(5));
800 /* If failure or stage 1, command is complete */
801 if (fail
|| cmd
->stage
!= 0) {
802 smu_i2c_complete_command(cmd
, fail
);
806 DPRINTK("SMU: going to stage 1\n");
808 /* Ok, initial command complete, now poll status */
809 scmd
->reply_buf
= cmd
->pdata
;
810 scmd
->reply_len
= sizeof(cmd
->pdata
);
811 scmd
->data_buf
= cmd
->pdata
;
820 int smu_queue_i2c(struct smu_i2c_cmd
*cmd
)
827 /* Fill most fields of scmd */
828 cmd
->scmd
.cmd
= SMU_CMD_I2C_COMMAND
;
829 cmd
->scmd
.done
= smu_i2c_low_completion
;
830 cmd
->scmd
.misc
= cmd
;
831 cmd
->scmd
.reply_buf
= cmd
->pdata
;
832 cmd
->scmd
.reply_len
= sizeof(cmd
->pdata
);
833 cmd
->scmd
.data_buf
= (u8
*)(char *)&cmd
->info
;
834 cmd
->scmd
.status
= 1;
836 cmd
->pdata
[0] = 0xff;
840 /* Check transfer type, sanitize some "info" fields
841 * based on transfer type and do more checking
843 cmd
->info
.caddr
= cmd
->info
.devaddr
;
844 cmd
->read
= cmd
->info
.devaddr
& 0x01;
845 switch(cmd
->info
.type
) {
846 case SMU_I2C_TRANSFER_SIMPLE
:
847 memset(&cmd
->info
.sublen
, 0, 4);
849 case SMU_I2C_TRANSFER_COMBINED
:
850 cmd
->info
.devaddr
&= 0xfe;
851 case SMU_I2C_TRANSFER_STDSUB
:
852 if (cmd
->info
.sublen
> 3)
859 /* Finish setting up command based on transfer direction
862 if (cmd
->info
.datalen
> SMU_I2C_READ_MAX
)
864 memset(cmd
->info
.data
, 0xff, cmd
->info
.datalen
);
865 cmd
->scmd
.data_len
= 9;
867 if (cmd
->info
.datalen
> SMU_I2C_WRITE_MAX
)
869 cmd
->scmd
.data_len
= 9 + cmd
->info
.datalen
;
872 DPRINTK("SMU: i2c enqueuing command\n");
873 DPRINTK("SMU: %s, len=%d bus=%x addr=%x sub0=%x type=%x\n",
874 cmd
->read
? "read" : "write", cmd
->info
.datalen
,
875 cmd
->info
.bus
, cmd
->info
.caddr
,
876 cmd
->info
.subaddr
[0], cmd
->info
.type
);
879 /* Enqueue command in i2c list, and if empty, enqueue also in
882 spin_lock_irqsave(&smu
->lock
, flags
);
883 if (smu
->cmd_i2c_cur
== NULL
) {
884 smu
->cmd_i2c_cur
= cmd
;
885 list_add_tail(&cmd
->scmd
.link
, &smu
->cmd_list
);
886 if (smu
->cmd_cur
== NULL
)
889 list_add_tail(&cmd
->link
, &smu
->cmd_i2c_list
);
890 spin_unlock_irqrestore(&smu
->lock
, flags
);
896 * Handling of "partitions"
899 static int smu_read_datablock(u8
*dest
, unsigned int addr
, unsigned int len
)
901 DECLARE_COMPLETION_ONSTACK(comp
);
907 /* We currently use a chunk size of 0xe. We could check the
908 * SMU firmware version and use bigger sizes though
913 unsigned int clen
= min(len
, chunk
);
915 cmd
.cmd
= SMU_CMD_MISC_ee_COMMAND
;
917 cmd
.data_buf
= params
;
918 cmd
.reply_len
= chunk
;
919 cmd
.reply_buf
= dest
;
920 cmd
.done
= smu_done_complete
;
922 params
[0] = SMU_CMD_MISC_ee_GET_DATABLOCK_REC
;
924 *((u32
*)¶ms
[2]) = addr
;
927 rc
= smu_queue_cmd(&cmd
);
930 wait_for_completion(&comp
);
933 if (cmd
.reply_len
!= clen
) {
934 printk(KERN_DEBUG
"SMU: short read in "
935 "smu_read_datablock, got: %d, want: %d\n",
936 cmd
.reply_len
, clen
);
946 static struct smu_sdbp_header
*smu_create_sdb_partition(int id
)
948 DECLARE_COMPLETION_ONSTACK(comp
);
949 struct smu_simple_cmd cmd
;
950 unsigned int addr
, len
, tlen
;
951 struct smu_sdbp_header
*hdr
;
952 struct property
*prop
;
954 /* First query the partition info */
955 DPRINTK("SMU: Query partition infos ... (irq=%d)\n", smu
->db_irq
);
956 smu_queue_simple(&cmd
, SMU_CMD_PARTITION_COMMAND
, 2,
957 smu_done_complete
, &comp
,
958 SMU_CMD_PARTITION_LATEST
, id
);
959 wait_for_completion(&comp
);
960 DPRINTK("SMU: done, status: %d, reply_len: %d\n",
961 cmd
.cmd
.status
, cmd
.cmd
.reply_len
);
963 /* Partition doesn't exist (or other error) */
964 if (cmd
.cmd
.status
!= 0 || cmd
.cmd
.reply_len
!= 6)
967 /* Fetch address and length from reply */
968 addr
= *((u16
*)cmd
.buffer
);
969 len
= cmd
.buffer
[3] << 2;
970 /* Calucluate total length to allocate, including the 17 bytes
971 * for "sdb-partition-XX" that we append at the end of the buffer
973 tlen
= sizeof(struct property
) + len
+ 18;
975 prop
= kzalloc(tlen
, GFP_KERNEL
);
978 hdr
= (struct smu_sdbp_header
*)(prop
+ 1);
979 prop
->name
= ((char *)prop
) + tlen
- 18;
980 sprintf(prop
->name
, "sdb-partition-%02x", id
);
985 /* Read the datablock */
986 if (smu_read_datablock((u8
*)hdr
, addr
, len
)) {
987 printk(KERN_DEBUG
"SMU: datablock read failed while reading "
988 "partition %02x !\n", id
);
992 /* Got it, check a few things and create the property */
994 printk(KERN_DEBUG
"SMU: Reading partition %02x and got "
995 "%02x !\n", id
, hdr
->id
);
998 if (prom_add_property(smu
->of_node
, prop
)) {
999 printk(KERN_DEBUG
"SMU: Failed creating sdb-partition-%02x "
1000 "property !\n", id
);
1010 /* Note: Only allowed to return error code in pointers (using ERR_PTR)
1011 * when interruptible is 1
1013 const struct smu_sdbp_header
*__smu_get_sdb_partition(int id
,
1014 unsigned int *size
, int interruptible
)
1017 const struct smu_sdbp_header
*part
;
1022 sprintf(pname
, "sdb-partition-%02x", id
);
1024 DPRINTK("smu_get_sdb_partition(%02x)\n", id
);
1026 if (interruptible
) {
1028 rc
= mutex_lock_interruptible(&smu_part_access
);
1032 mutex_lock(&smu_part_access
);
1034 part
= of_get_property(smu
->of_node
, pname
, size
);
1036 DPRINTK("trying to extract from SMU ...\n");
1037 part
= smu_create_sdb_partition(id
);
1038 if (part
!= NULL
&& size
)
1039 *size
= part
->len
<< 2;
1041 mutex_unlock(&smu_part_access
);
1045 const struct smu_sdbp_header
*smu_get_sdb_partition(int id
, unsigned int *size
)
1047 return __smu_get_sdb_partition(id
, size
, 0);
1049 EXPORT_SYMBOL(smu_get_sdb_partition
);
1053 * Userland driver interface
1057 static LIST_HEAD(smu_clist
);
1058 static DEFINE_SPINLOCK(smu_clist_lock
);
1060 enum smu_file_mode
{
1068 struct list_head list
;
1069 enum smu_file_mode mode
;
1073 wait_queue_head_t wait
;
1074 u8 buffer
[SMU_MAX_DATA
];
1078 static int smu_open(struct inode
*inode
, struct file
*file
)
1080 struct smu_private
*pp
;
1081 unsigned long flags
;
1083 pp
= kzalloc(sizeof(struct smu_private
), GFP_KERNEL
);
1086 spin_lock_init(&pp
->lock
);
1087 pp
->mode
= smu_file_commands
;
1088 init_waitqueue_head(&pp
->wait
);
1091 spin_lock_irqsave(&smu_clist_lock
, flags
);
1092 list_add(&pp
->list
, &smu_clist
);
1093 spin_unlock_irqrestore(&smu_clist_lock
, flags
);
1094 file
->private_data
= pp
;
1101 static void smu_user_cmd_done(struct smu_cmd
*cmd
, void *misc
)
1103 struct smu_private
*pp
= misc
;
1105 wake_up_all(&pp
->wait
);
1109 static ssize_t
smu_write(struct file
*file
, const char __user
*buf
,
1110 size_t count
, loff_t
*ppos
)
1112 struct smu_private
*pp
= file
->private_data
;
1113 unsigned long flags
;
1114 struct smu_user_cmd_hdr hdr
;
1119 else if (copy_from_user(&hdr
, buf
, sizeof(hdr
)))
1121 else if (hdr
.cmdtype
== SMU_CMDTYPE_WANTS_EVENTS
) {
1122 pp
->mode
= smu_file_events
;
1124 } else if (hdr
.cmdtype
== SMU_CMDTYPE_GET_PARTITION
) {
1125 const struct smu_sdbp_header
*part
;
1126 part
= __smu_get_sdb_partition(hdr
.cmd
, NULL
, 1);
1129 else if (IS_ERR(part
))
1130 return PTR_ERR(part
);
1132 } else if (hdr
.cmdtype
!= SMU_CMDTYPE_SMU
)
1134 else if (pp
->mode
!= smu_file_commands
)
1136 else if (hdr
.data_len
> SMU_MAX_DATA
)
1139 spin_lock_irqsave(&pp
->lock
, flags
);
1141 spin_unlock_irqrestore(&pp
->lock
, flags
);
1146 spin_unlock_irqrestore(&pp
->lock
, flags
);
1148 if (copy_from_user(pp
->buffer
, buf
+ sizeof(hdr
), hdr
.data_len
)) {
1153 pp
->cmd
.cmd
= hdr
.cmd
;
1154 pp
->cmd
.data_len
= hdr
.data_len
;
1155 pp
->cmd
.reply_len
= SMU_MAX_DATA
;
1156 pp
->cmd
.data_buf
= pp
->buffer
;
1157 pp
->cmd
.reply_buf
= pp
->buffer
;
1158 pp
->cmd
.done
= smu_user_cmd_done
;
1160 rc
= smu_queue_cmd(&pp
->cmd
);
1167 static ssize_t
smu_read_command(struct file
*file
, struct smu_private
*pp
,
1168 char __user
*buf
, size_t count
)
1170 DECLARE_WAITQUEUE(wait
, current
);
1171 struct smu_user_reply_hdr hdr
;
1172 unsigned long flags
;
1177 if (count
< sizeof(struct smu_user_reply_hdr
))
1179 spin_lock_irqsave(&pp
->lock
, flags
);
1180 if (pp
->cmd
.status
== 1) {
1181 if (file
->f_flags
& O_NONBLOCK
)
1183 add_wait_queue(&pp
->wait
, &wait
);
1185 set_current_state(TASK_INTERRUPTIBLE
);
1187 if (pp
->cmd
.status
!= 1)
1190 if (signal_pending(current
))
1192 spin_unlock_irqrestore(&pp
->lock
, flags
);
1194 spin_lock_irqsave(&pp
->lock
, flags
);
1196 set_current_state(TASK_RUNNING
);
1197 remove_wait_queue(&pp
->wait
, &wait
);
1199 spin_unlock_irqrestore(&pp
->lock
, flags
);
1202 if (pp
->cmd
.status
!= 0)
1203 pp
->cmd
.reply_len
= 0;
1204 size
= sizeof(hdr
) + pp
->cmd
.reply_len
;
1208 hdr
.status
= pp
->cmd
.status
;
1209 hdr
.reply_len
= pp
->cmd
.reply_len
;
1210 if (copy_to_user(buf
, &hdr
, sizeof(hdr
)))
1212 size
-= sizeof(hdr
);
1213 if (size
&& copy_to_user(buf
+ sizeof(hdr
), pp
->buffer
, size
))
1221 static ssize_t
smu_read_events(struct file
*file
, struct smu_private
*pp
,
1222 char __user
*buf
, size_t count
)
1224 /* Not implemented */
1225 msleep_interruptible(1000);
1230 static ssize_t
smu_read(struct file
*file
, char __user
*buf
,
1231 size_t count
, loff_t
*ppos
)
1233 struct smu_private
*pp
= file
->private_data
;
1235 if (pp
->mode
== smu_file_commands
)
1236 return smu_read_command(file
, pp
, buf
, count
);
1237 if (pp
->mode
== smu_file_events
)
1238 return smu_read_events(file
, pp
, buf
, count
);
1243 static unsigned int smu_fpoll(struct file
*file
, poll_table
*wait
)
1245 struct smu_private
*pp
= file
->private_data
;
1246 unsigned int mask
= 0;
1247 unsigned long flags
;
1252 if (pp
->mode
== smu_file_commands
) {
1253 poll_wait(file
, &pp
->wait
, wait
);
1255 spin_lock_irqsave(&pp
->lock
, flags
);
1256 if (pp
->busy
&& pp
->cmd
.status
!= 1)
1258 spin_unlock_irqrestore(&pp
->lock
, flags
);
1259 } if (pp
->mode
== smu_file_events
) {
1260 /* Not yet implemented */
1265 static int smu_release(struct inode
*inode
, struct file
*file
)
1267 struct smu_private
*pp
= file
->private_data
;
1268 unsigned long flags
;
1274 file
->private_data
= NULL
;
1276 /* Mark file as closing to avoid races with new request */
1277 spin_lock_irqsave(&pp
->lock
, flags
);
1278 pp
->mode
= smu_file_closing
;
1281 /* Wait for any pending request to complete */
1282 if (busy
&& pp
->cmd
.status
== 1) {
1283 DECLARE_WAITQUEUE(wait
, current
);
1285 add_wait_queue(&pp
->wait
, &wait
);
1287 set_current_state(TASK_UNINTERRUPTIBLE
);
1288 if (pp
->cmd
.status
!= 1)
1290 spin_unlock_irqrestore(&pp
->lock
, flags
);
1292 spin_lock_irqsave(&pp
->lock
, flags
);
1294 set_current_state(TASK_RUNNING
);
1295 remove_wait_queue(&pp
->wait
, &wait
);
1297 spin_unlock_irqrestore(&pp
->lock
, flags
);
1299 spin_lock_irqsave(&smu_clist_lock
, flags
);
1300 list_del(&pp
->list
);
1301 spin_unlock_irqrestore(&smu_clist_lock
, flags
);
1308 static const struct file_operations smu_device_fops
= {
1309 .llseek
= no_llseek
,
1314 .release
= smu_release
,
1317 static struct miscdevice pmu_device
= {
1318 MISC_DYNAMIC_MINOR
, "smu", &smu_device_fops
1321 static int smu_device_init(void)
1325 if (misc_register(&pmu_device
) < 0)
1326 printk(KERN_ERR
"via-pmu: cannot register misc device.\n");
1329 device_initcall(smu_device_init
);