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/types.h>
23
#include <linux/kernel.h>
24
#include <linux/device.h>
25
#include <linux/dmapool.h>
26
#include <linux/bootmem.h>
27
#include <linux/vmalloc.h>
28
#include <linux/highmem.h>
29
#include <linux/jiffies.h>
30
#include <linux/interrupt.h>
31
#include <linux/rtc.h>
32
#include <linux/completion.h>
33
#include <linux/miscdevice.h>
34
#include <linux/delay.h>
35
#include <linux/sysdev.h>
36
#include <linux/poll.h>
37
#include <linux/mutex.h>
38
#include <linux/of_device.h>
39
#include <linux/of_platform.h>
40
#include <linux/slab.h>
42
#include <asm/byteorder.h>
45
#include <asm/machdep.h>
46
#include <asm/pmac_feature.h>
48
#include <asm/sections.h>
49
#include <asm/abs_addr.h>
50
#include <asm/uaccess.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 platform_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 DEFINE_MUTEX(smu_mutex);
100
static struct smu_device *smu;
101
static DEFINE_MUTEX(smu_part_access);
102
static int smu_irq_inited;
104
static void smu_i2c_retry(unsigned long data);
107
* SMU driver low level stuff
110
static void smu_start_cmd(void)
112
unsigned long faddr, fend;
115
if (list_empty(&smu->cmd_list))
118
/* Fetch first command in queue */
119
cmd = list_entry(smu->cmd_list.next, struct smu_cmd, link);
121
list_del(&cmd->link);
123
DPRINTK("SMU: starting cmd %x, %d bytes data\n", cmd->cmd,
125
DPRINTK("SMU: data buffer: %02x %02x %02x %02x %02x %02x %02x %02x\n",
126
((u8 *)cmd->data_buf)[0], ((u8 *)cmd->data_buf)[1],
127
((u8 *)cmd->data_buf)[2], ((u8 *)cmd->data_buf)[3],
128
((u8 *)cmd->data_buf)[4], ((u8 *)cmd->data_buf)[5],
129
((u8 *)cmd->data_buf)[6], ((u8 *)cmd->data_buf)[7]);
131
/* Fill the SMU command buffer */
132
smu->cmd_buf->cmd = cmd->cmd;
133
smu->cmd_buf->length = cmd->data_len;
134
memcpy(smu->cmd_buf->data, cmd->data_buf, cmd->data_len);
136
/* Flush command and data to RAM */
137
faddr = (unsigned long)smu->cmd_buf;
138
fend = faddr + smu->cmd_buf->length + 2;
139
flush_inval_dcache_range(faddr, fend);
142
/* We also disable NAP mode for the duration of the command
143
* on U3 based machines.
144
* This is slightly racy as it can be written back to 1 by a sysctl
145
* but that never happens in practice. There seem to be an issue with
146
* U3 based machines such as the iMac G5 where napping for the
147
* whole duration of the command prevents the SMU from fetching it
148
* from memory. This might be related to the strange i2c based
149
* mechanism the SMU uses to access memory.
154
/* This isn't exactly a DMA mapping here, I suspect
155
* the SMU is actually communicating with us via i2c to the
156
* northbridge or the CPU to access RAM.
158
writel(smu->cmd_buf_abs, smu->db_buf);
160
/* Ring the SMU doorbell */
161
pmac_do_feature_call(PMAC_FTR_WRITE_GPIO, NULL, smu->doorbell, 4);
165
static irqreturn_t smu_db_intr(int irq, void *arg)
169
void (*done)(struct smu_cmd *cmd, void *misc) = NULL;
174
/* SMU completed the command, well, we hope, let's make sure
177
spin_lock_irqsave(&smu->lock, flags);
179
gpio = pmac_do_feature_call(PMAC_FTR_READ_GPIO, NULL, smu->doorbell);
180
if ((gpio & 7) != 7) {
181
spin_unlock_irqrestore(&smu->lock, flags);
195
/* CPU might have brought back the cache line, so we need
196
* to flush again before peeking at the SMU response. We
197
* flush the entire buffer for now as we haven't read the
198
* reply length (it's only 2 cache lines anyway)
200
faddr = (unsigned long)smu->cmd_buf;
201
flush_inval_dcache_range(faddr, faddr + 256);
204
ack = (~cmd->cmd) & 0xff;
205
if (ack != smu->cmd_buf->cmd) {
206
DPRINTK("SMU: incorrect ack, want %x got %x\n",
207
ack, smu->cmd_buf->cmd);
210
reply_len = rc == 0 ? smu->cmd_buf->length : 0;
211
DPRINTK("SMU: reply len: %d\n", reply_len);
212
if (reply_len > cmd->reply_len) {
213
printk(KERN_WARNING "SMU: reply buffer too small,"
214
"got %d bytes for a %d bytes buffer\n",
215
reply_len, cmd->reply_len);
216
reply_len = cmd->reply_len;
218
cmd->reply_len = reply_len;
219
if (cmd->reply_buf && reply_len)
220
memcpy(cmd->reply_buf, smu->cmd_buf->data, reply_len);
223
/* Now complete the command. Write status last in order as we lost
224
* ownership of the command structure as soon as it's no longer -1
231
/* Re-enable NAP mode */
235
/* Start next command if any */
237
spin_unlock_irqrestore(&smu->lock, flags);
239
/* Call command completion handler if any */
243
/* It's an edge interrupt, nothing to do */
248
static irqreturn_t smu_msg_intr(int irq, void *arg)
250
/* I don't quite know what to do with this one, we seem to never
251
* receive it, so I suspect we have to arm it someway in the SMU
252
* to start getting events that way.
255
printk(KERN_INFO "SMU: message interrupt !\n");
257
/* It's an edge interrupt, nothing to do */
263
* Queued command management.
267
int smu_queue_cmd(struct smu_cmd *cmd)
273
if (cmd->data_len > SMU_MAX_DATA ||
274
cmd->reply_len > SMU_MAX_DATA)
278
spin_lock_irqsave(&smu->lock, flags);
279
list_add_tail(&cmd->link, &smu->cmd_list);
280
if (smu->cmd_cur == NULL)
282
spin_unlock_irqrestore(&smu->lock, flags);
284
/* Workaround for early calls when irq isn't available */
285
if (!smu_irq_inited || smu->db_irq == NO_IRQ)
286
smu_spinwait_cmd(cmd);
290
EXPORT_SYMBOL(smu_queue_cmd);
293
int smu_queue_simple(struct smu_simple_cmd *scmd, u8 command,
294
unsigned int data_len,
295
void (*done)(struct smu_cmd *cmd, void *misc),
298
struct smu_cmd *cmd = &scmd->cmd;
302
if (data_len > sizeof(scmd->buffer))
305
memset(scmd, 0, sizeof(*scmd));
307
cmd->data_len = data_len;
308
cmd->data_buf = scmd->buffer;
309
cmd->reply_len = sizeof(scmd->buffer);
310
cmd->reply_buf = scmd->buffer;
314
va_start(list, misc);
315
for (i = 0; i < data_len; ++i)
316
scmd->buffer[i] = (u8)va_arg(list, int);
319
return smu_queue_cmd(cmd);
321
EXPORT_SYMBOL(smu_queue_simple);
331
gpio = pmac_do_feature_call(PMAC_FTR_READ_GPIO, NULL, smu->doorbell);
333
smu_db_intr(smu->db_irq, smu);
335
EXPORT_SYMBOL(smu_poll);
338
void smu_done_complete(struct smu_cmd *cmd, void *misc)
340
struct completion *comp = misc;
344
EXPORT_SYMBOL(smu_done_complete);
347
void smu_spinwait_cmd(struct smu_cmd *cmd)
349
while(cmd->status == 1)
352
EXPORT_SYMBOL(smu_spinwait_cmd);
355
/* RTC low level commands */
356
static inline int bcd2hex (int n)
358
return (((n & 0xf0) >> 4) * 10) + (n & 0xf);
362
static inline int hex2bcd (int n)
364
return ((n / 10) << 4) + (n % 10);
368
static inline void smu_fill_set_rtc_cmd(struct smu_cmd_buf *cmd_buf,
369
struct rtc_time *time)
373
cmd_buf->data[0] = 0x80;
374
cmd_buf->data[1] = hex2bcd(time->tm_sec);
375
cmd_buf->data[2] = hex2bcd(time->tm_min);
376
cmd_buf->data[3] = hex2bcd(time->tm_hour);
377
cmd_buf->data[4] = time->tm_wday;
378
cmd_buf->data[5] = hex2bcd(time->tm_mday);
379
cmd_buf->data[6] = hex2bcd(time->tm_mon) + 1;
380
cmd_buf->data[7] = hex2bcd(time->tm_year - 100);
384
int smu_get_rtc_time(struct rtc_time *time, int spinwait)
386
struct smu_simple_cmd cmd;
392
memset(time, 0, sizeof(struct rtc_time));
393
rc = smu_queue_simple(&cmd, SMU_CMD_RTC_COMMAND, 1, NULL, NULL,
394
SMU_CMD_RTC_GET_DATETIME);
397
smu_spinwait_simple(&cmd);
399
time->tm_sec = bcd2hex(cmd.buffer[0]);
400
time->tm_min = bcd2hex(cmd.buffer[1]);
401
time->tm_hour = bcd2hex(cmd.buffer[2]);
402
time->tm_wday = bcd2hex(cmd.buffer[3]);
403
time->tm_mday = bcd2hex(cmd.buffer[4]);
404
time->tm_mon = bcd2hex(cmd.buffer[5]) - 1;
405
time->tm_year = bcd2hex(cmd.buffer[6]) + 100;
411
int smu_set_rtc_time(struct rtc_time *time, int spinwait)
413
struct smu_simple_cmd cmd;
419
rc = smu_queue_simple(&cmd, SMU_CMD_RTC_COMMAND, 8, NULL, NULL,
420
SMU_CMD_RTC_SET_DATETIME,
421
hex2bcd(time->tm_sec),
422
hex2bcd(time->tm_min),
423
hex2bcd(time->tm_hour),
425
hex2bcd(time->tm_mday),
426
hex2bcd(time->tm_mon) + 1,
427
hex2bcd(time->tm_year - 100));
430
smu_spinwait_simple(&cmd);
436
void smu_shutdown(void)
438
struct smu_simple_cmd cmd;
443
if (smu_queue_simple(&cmd, SMU_CMD_POWER_COMMAND, 9, NULL, NULL,
444
'S', 'H', 'U', 'T', 'D', 'O', 'W', 'N', 0))
446
smu_spinwait_simple(&cmd);
452
void smu_restart(void)
454
struct smu_simple_cmd cmd;
459
if (smu_queue_simple(&cmd, SMU_CMD_POWER_COMMAND, 8, NULL, NULL,
460
'R', 'E', 'S', 'T', 'A', 'R', 'T', 0))
462
smu_spinwait_simple(&cmd);
468
int smu_present(void)
472
EXPORT_SYMBOL(smu_present);
475
int __init smu_init (void)
477
struct device_node *np;
481
np = of_find_node_by_type(NULL, "smu");
485
printk(KERN_INFO "SMU: Driver %s %s\n", VERSION, AUTHOR);
487
if (smu_cmdbuf_abs == 0) {
488
printk(KERN_ERR "SMU: Command buffer not allocated !\n");
493
smu = alloc_bootmem(sizeof(struct smu_device));
495
spin_lock_init(&smu->lock);
496
INIT_LIST_HEAD(&smu->cmd_list);
497
INIT_LIST_HEAD(&smu->cmd_i2c_list);
499
smu->db_irq = NO_IRQ;
500
smu->msg_irq = NO_IRQ;
502
/* smu_cmdbuf_abs is in the low 2G of RAM, can be converted to a
503
* 32 bits value safely
505
smu->cmd_buf_abs = (u32)smu_cmdbuf_abs;
506
smu->cmd_buf = (struct smu_cmd_buf *)abs_to_virt(smu_cmdbuf_abs);
508
smu->db_node = of_find_node_by_name(NULL, "smu-doorbell");
509
if (smu->db_node == NULL) {
510
printk(KERN_ERR "SMU: Can't find doorbell GPIO !\n");
514
data = of_get_property(smu->db_node, "reg", NULL);
516
printk(KERN_ERR "SMU: Can't find doorbell GPIO address !\n");
521
/* Current setup has one doorbell GPIO that does both doorbell
522
* and ack. GPIOs are at 0x50, best would be to find that out
523
* in the device-tree though.
525
smu->doorbell = *data;
526
if (smu->doorbell < 0x50)
527
smu->doorbell += 0x50;
529
/* Now look for the smu-interrupt GPIO */
531
smu->msg_node = of_find_node_by_name(NULL, "smu-interrupt");
532
if (smu->msg_node == NULL)
534
data = of_get_property(smu->msg_node, "reg", NULL);
536
of_node_put(smu->msg_node);
537
smu->msg_node = NULL;
545
/* Doorbell buffer is currently hard-coded, I didn't find a proper
546
* device-tree entry giving the address. Best would probably to use
547
* an offset for K2 base though, but let's do it that way for now.
549
smu->db_buf = ioremap(0x8000860c, 0x1000);
550
if (smu->db_buf == NULL) {
551
printk(KERN_ERR "SMU: Can't map doorbell buffer pointer !\n");
556
/* U3 has an issue with NAP mode when issuing SMU commands */
557
smu->broken_nap = pmac_get_uninorth_variant() < 4;
559
printk(KERN_INFO "SMU: using NAP mode workaround\n");
561
sys_ctrler = SYS_CTRLER_SMU;
566
of_node_put(smu->msg_node);
568
of_node_put(smu->db_node);
570
free_bootmem((unsigned long)smu, sizeof(struct smu_device));
578
static int smu_late_init(void)
583
init_timer(&smu->i2c_timer);
584
smu->i2c_timer.function = smu_i2c_retry;
585
smu->i2c_timer.data = (unsigned long)smu;
588
smu->db_irq = irq_of_parse_and_map(smu->db_node, 0);
589
if (smu->db_irq == NO_IRQ)
590
printk(KERN_ERR "smu: failed to map irq for node %s\n",
591
smu->db_node->full_name);
594
smu->msg_irq = irq_of_parse_and_map(smu->msg_node, 0);
595
if (smu->msg_irq == NO_IRQ)
596
printk(KERN_ERR "smu: failed to map irq for node %s\n",
597
smu->msg_node->full_name);
601
* Try to request the interrupts
604
if (smu->db_irq != NO_IRQ) {
605
if (request_irq(smu->db_irq, smu_db_intr,
606
IRQF_SHARED, "SMU doorbell", smu) < 0) {
607
printk(KERN_WARNING "SMU: can't "
608
"request interrupt %d\n",
610
smu->db_irq = NO_IRQ;
614
if (smu->msg_irq != NO_IRQ) {
615
if (request_irq(smu->msg_irq, smu_msg_intr,
616
IRQF_SHARED, "SMU message", smu) < 0) {
617
printk(KERN_WARNING "SMU: can't "
618
"request interrupt %d\n",
620
smu->msg_irq = NO_IRQ;
627
/* This has to be before arch_initcall as the low i2c stuff relies on the
628
* above having been done before we reach arch_initcalls
630
core_initcall(smu_late_init);
636
static void smu_expose_childs(struct work_struct *unused)
638
struct device_node *np;
640
for (np = NULL; (np = of_get_next_child(smu->of_node, np)) != NULL;)
641
if (of_device_is_compatible(np, "smu-sensors"))
642
of_platform_device_create(np, "smu-sensors",
646
static DECLARE_WORK(smu_expose_childs_work, smu_expose_childs);
648
static int smu_platform_probe(struct platform_device* dev)
655
* Ok, we are matched, now expose all i2c busses. We have to defer
656
* that unfortunately or it would deadlock inside the device model
658
schedule_work(&smu_expose_childs_work);
663
static const struct of_device_id smu_platform_match[] =
671
static struct platform_driver smu_of_platform_driver =
675
.owner = THIS_MODULE,
676
.of_match_table = smu_platform_match,
678
.probe = smu_platform_probe,
681
static int __init smu_init_sysfs(void)
684
* Due to sysfs bogosity, a sysdev is not a real device, so
685
* we should in fact create both if we want sysdev semantics
686
* for power management.
687
* For now, we don't power manage machines with an SMU chip,
688
* I'm a bit too far from figuring out how that works with those
689
* new chipsets, but that will come back and bite us
691
platform_driver_register(&smu_of_platform_driver);
695
device_initcall(smu_init_sysfs);
697
struct platform_device *smu_get_ofdev(void)
704
EXPORT_SYMBOL_GPL(smu_get_ofdev);
710
static void smu_i2c_complete_command(struct smu_i2c_cmd *cmd, int fail)
712
void (*done)(struct smu_i2c_cmd *cmd, void *misc) = cmd->done;
713
void *misc = cmd->misc;
716
/* Check for read case */
717
if (!fail && cmd->read) {
718
if (cmd->pdata[0] < 1)
721
memcpy(cmd->info.data, &cmd->pdata[1],
725
DPRINTK("SMU: completing, success: %d\n", !fail);
727
/* Update status and mark no pending i2c command with lock
728
* held so nobody comes in while we dequeue an eventual
729
* pending next i2c command
731
spin_lock_irqsave(&smu->lock, flags);
732
smu->cmd_i2c_cur = NULL;
734
cmd->status = fail ? -EIO : 0;
736
/* Is there another i2c command waiting ? */
737
if (!list_empty(&smu->cmd_i2c_list)) {
738
struct smu_i2c_cmd *newcmd;
740
/* Fetch it, new current, remove from list */
741
newcmd = list_entry(smu->cmd_i2c_list.next,
742
struct smu_i2c_cmd, link);
743
smu->cmd_i2c_cur = newcmd;
744
list_del(&cmd->link);
746
/* Queue with low level smu */
747
list_add_tail(&cmd->scmd.link, &smu->cmd_list);
748
if (smu->cmd_cur == NULL)
751
spin_unlock_irqrestore(&smu->lock, flags);
753
/* Call command completion handler if any */
760
static void smu_i2c_retry(unsigned long data)
762
struct smu_i2c_cmd *cmd = smu->cmd_i2c_cur;
764
DPRINTK("SMU: i2c failure, requeuing...\n");
766
/* requeue command simply by resetting reply_len */
767
cmd->pdata[0] = 0xff;
768
cmd->scmd.reply_len = sizeof(cmd->pdata);
769
smu_queue_cmd(&cmd->scmd);
773
static void smu_i2c_low_completion(struct smu_cmd *scmd, void *misc)
775
struct smu_i2c_cmd *cmd = misc;
778
DPRINTK("SMU: i2c compl. stage=%d status=%x pdata[0]=%x rlen: %x\n",
779
cmd->stage, scmd->status, cmd->pdata[0], scmd->reply_len);
781
/* Check for possible status */
782
if (scmd->status < 0)
784
else if (cmd->read) {
786
fail = cmd->pdata[0] != 0;
788
fail = cmd->pdata[0] >= 0x80;
790
fail = cmd->pdata[0] != 0;
793
/* Handle failures by requeuing command, after 5ms interval
795
if (fail && --cmd->retries > 0) {
796
DPRINTK("SMU: i2c failure, starting timer...\n");
797
BUG_ON(cmd != smu->cmd_i2c_cur);
798
if (!smu_irq_inited) {
803
mod_timer(&smu->i2c_timer, jiffies + msecs_to_jiffies(5));
807
/* If failure or stage 1, command is complete */
808
if (fail || cmd->stage != 0) {
809
smu_i2c_complete_command(cmd, fail);
813
DPRINTK("SMU: going to stage 1\n");
815
/* Ok, initial command complete, now poll status */
816
scmd->reply_buf = cmd->pdata;
817
scmd->reply_len = sizeof(cmd->pdata);
818
scmd->data_buf = cmd->pdata;
827
int smu_queue_i2c(struct smu_i2c_cmd *cmd)
834
/* Fill most fields of scmd */
835
cmd->scmd.cmd = SMU_CMD_I2C_COMMAND;
836
cmd->scmd.done = smu_i2c_low_completion;
837
cmd->scmd.misc = cmd;
838
cmd->scmd.reply_buf = cmd->pdata;
839
cmd->scmd.reply_len = sizeof(cmd->pdata);
840
cmd->scmd.data_buf = (u8 *)(char *)&cmd->info;
841
cmd->scmd.status = 1;
843
cmd->pdata[0] = 0xff;
847
/* Check transfer type, sanitize some "info" fields
848
* based on transfer type and do more checking
850
cmd->info.caddr = cmd->info.devaddr;
851
cmd->read = cmd->info.devaddr & 0x01;
852
switch(cmd->info.type) {
853
case SMU_I2C_TRANSFER_SIMPLE:
854
memset(&cmd->info.sublen, 0, 4);
856
case SMU_I2C_TRANSFER_COMBINED:
857
cmd->info.devaddr &= 0xfe;
858
case SMU_I2C_TRANSFER_STDSUB:
859
if (cmd->info.sublen > 3)
866
/* Finish setting up command based on transfer direction
869
if (cmd->info.datalen > SMU_I2C_READ_MAX)
871
memset(cmd->info.data, 0xff, cmd->info.datalen);
872
cmd->scmd.data_len = 9;
874
if (cmd->info.datalen > SMU_I2C_WRITE_MAX)
876
cmd->scmd.data_len = 9 + cmd->info.datalen;
879
DPRINTK("SMU: i2c enqueuing command\n");
880
DPRINTK("SMU: %s, len=%d bus=%x addr=%x sub0=%x type=%x\n",
881
cmd->read ? "read" : "write", cmd->info.datalen,
882
cmd->info.bus, cmd->info.caddr,
883
cmd->info.subaddr[0], cmd->info.type);
886
/* Enqueue command in i2c list, and if empty, enqueue also in
889
spin_lock_irqsave(&smu->lock, flags);
890
if (smu->cmd_i2c_cur == NULL) {
891
smu->cmd_i2c_cur = cmd;
892
list_add_tail(&cmd->scmd.link, &smu->cmd_list);
893
if (smu->cmd_cur == NULL)
896
list_add_tail(&cmd->link, &smu->cmd_i2c_list);
897
spin_unlock_irqrestore(&smu->lock, flags);
903
* Handling of "partitions"
906
static int smu_read_datablock(u8 *dest, unsigned int addr, unsigned int len)
908
DECLARE_COMPLETION_ONSTACK(comp);
914
/* We currently use a chunk size of 0xe. We could check the
915
* SMU firmware version and use bigger sizes though
920
unsigned int clen = min(len, chunk);
922
cmd.cmd = SMU_CMD_MISC_ee_COMMAND;
924
cmd.data_buf = params;
925
cmd.reply_len = chunk;
926
cmd.reply_buf = dest;
927
cmd.done = smu_done_complete;
929
params[0] = SMU_CMD_MISC_ee_GET_DATABLOCK_REC;
931
*((u32 *)¶ms[2]) = addr;
934
rc = smu_queue_cmd(&cmd);
937
wait_for_completion(&comp);
940
if (cmd.reply_len != clen) {
941
printk(KERN_DEBUG "SMU: short read in "
942
"smu_read_datablock, got: %d, want: %d\n",
943
cmd.reply_len, clen);
953
static struct smu_sdbp_header *smu_create_sdb_partition(int id)
955
DECLARE_COMPLETION_ONSTACK(comp);
956
struct smu_simple_cmd cmd;
957
unsigned int addr, len, tlen;
958
struct smu_sdbp_header *hdr;
959
struct property *prop;
961
/* First query the partition info */
962
DPRINTK("SMU: Query partition infos ... (irq=%d)\n", smu->db_irq);
963
smu_queue_simple(&cmd, SMU_CMD_PARTITION_COMMAND, 2,
964
smu_done_complete, &comp,
965
SMU_CMD_PARTITION_LATEST, id);
966
wait_for_completion(&comp);
967
DPRINTK("SMU: done, status: %d, reply_len: %d\n",
968
cmd.cmd.status, cmd.cmd.reply_len);
970
/* Partition doesn't exist (or other error) */
971
if (cmd.cmd.status != 0 || cmd.cmd.reply_len != 6)
974
/* Fetch address and length from reply */
975
addr = *((u16 *)cmd.buffer);
976
len = cmd.buffer[3] << 2;
977
/* Calucluate total length to allocate, including the 17 bytes
978
* for "sdb-partition-XX" that we append at the end of the buffer
980
tlen = sizeof(struct property) + len + 18;
982
prop = kzalloc(tlen, GFP_KERNEL);
985
hdr = (struct smu_sdbp_header *)(prop + 1);
986
prop->name = ((char *)prop) + tlen - 18;
987
sprintf(prop->name, "sdb-partition-%02x", id);
992
/* Read the datablock */
993
if (smu_read_datablock((u8 *)hdr, addr, len)) {
994
printk(KERN_DEBUG "SMU: datablock read failed while reading "
995
"partition %02x !\n", id);
999
/* Got it, check a few things and create the property */
1000
if (hdr->id != id) {
1001
printk(KERN_DEBUG "SMU: Reading partition %02x and got "
1002
"%02x !\n", id, hdr->id);
1005
if (prom_add_property(smu->of_node, prop)) {
1006
printk(KERN_DEBUG "SMU: Failed creating sdb-partition-%02x "
1007
"property !\n", id);
1017
/* Note: Only allowed to return error code in pointers (using ERR_PTR)
1018
* when interruptible is 1
1020
const struct smu_sdbp_header *__smu_get_sdb_partition(int id,
1021
unsigned int *size, int interruptible)
1024
const struct smu_sdbp_header *part;
1029
sprintf(pname, "sdb-partition-%02x", id);
1031
DPRINTK("smu_get_sdb_partition(%02x)\n", id);
1033
if (interruptible) {
1035
rc = mutex_lock_interruptible(&smu_part_access);
1039
mutex_lock(&smu_part_access);
1041
part = of_get_property(smu->of_node, pname, size);
1043
DPRINTK("trying to extract from SMU ...\n");
1044
part = smu_create_sdb_partition(id);
1045
if (part != NULL && size)
1046
*size = part->len << 2;
1048
mutex_unlock(&smu_part_access);
1052
const struct smu_sdbp_header *smu_get_sdb_partition(int id, unsigned int *size)
1054
return __smu_get_sdb_partition(id, size, 0);
1056
EXPORT_SYMBOL(smu_get_sdb_partition);
1060
* Userland driver interface
1064
static LIST_HEAD(smu_clist);
1065
static DEFINE_SPINLOCK(smu_clist_lock);
1067
enum smu_file_mode {
1075
struct list_head list;
1076
enum smu_file_mode mode;
1080
wait_queue_head_t wait;
1081
u8 buffer[SMU_MAX_DATA];
1085
static int smu_open(struct inode *inode, struct file *file)
1087
struct smu_private *pp;
1088
unsigned long flags;
1090
pp = kzalloc(sizeof(struct smu_private), GFP_KERNEL);
1093
spin_lock_init(&pp->lock);
1094
pp->mode = smu_file_commands;
1095
init_waitqueue_head(&pp->wait);
1097
mutex_lock(&smu_mutex);
1098
spin_lock_irqsave(&smu_clist_lock, flags);
1099
list_add(&pp->list, &smu_clist);
1100
spin_unlock_irqrestore(&smu_clist_lock, flags);
1101
file->private_data = pp;
1102
mutex_unlock(&smu_mutex);
1108
static void smu_user_cmd_done(struct smu_cmd *cmd, void *misc)
1110
struct smu_private *pp = misc;
1112
wake_up_all(&pp->wait);
1116
static ssize_t smu_write(struct file *file, const char __user *buf,
1117
size_t count, loff_t *ppos)
1119
struct smu_private *pp = file->private_data;
1120
unsigned long flags;
1121
struct smu_user_cmd_hdr hdr;
1126
else if (copy_from_user(&hdr, buf, sizeof(hdr)))
1128
else if (hdr.cmdtype == SMU_CMDTYPE_WANTS_EVENTS) {
1129
pp->mode = smu_file_events;
1131
} else if (hdr.cmdtype == SMU_CMDTYPE_GET_PARTITION) {
1132
const struct smu_sdbp_header *part;
1133
part = __smu_get_sdb_partition(hdr.cmd, NULL, 1);
1136
else if (IS_ERR(part))
1137
return PTR_ERR(part);
1139
} else if (hdr.cmdtype != SMU_CMDTYPE_SMU)
1141
else if (pp->mode != smu_file_commands)
1143
else if (hdr.data_len > SMU_MAX_DATA)
1146
spin_lock_irqsave(&pp->lock, flags);
1148
spin_unlock_irqrestore(&pp->lock, flags);
1153
spin_unlock_irqrestore(&pp->lock, flags);
1155
if (copy_from_user(pp->buffer, buf + sizeof(hdr), hdr.data_len)) {
1160
pp->cmd.cmd = hdr.cmd;
1161
pp->cmd.data_len = hdr.data_len;
1162
pp->cmd.reply_len = SMU_MAX_DATA;
1163
pp->cmd.data_buf = pp->buffer;
1164
pp->cmd.reply_buf = pp->buffer;
1165
pp->cmd.done = smu_user_cmd_done;
1167
rc = smu_queue_cmd(&pp->cmd);
1174
static ssize_t smu_read_command(struct file *file, struct smu_private *pp,
1175
char __user *buf, size_t count)
1177
DECLARE_WAITQUEUE(wait, current);
1178
struct smu_user_reply_hdr hdr;
1179
unsigned long flags;
1184
if (count < sizeof(struct smu_user_reply_hdr))
1186
spin_lock_irqsave(&pp->lock, flags);
1187
if (pp->cmd.status == 1) {
1188
if (file->f_flags & O_NONBLOCK) {
1189
spin_unlock_irqrestore(&pp->lock, flags);
1192
add_wait_queue(&pp->wait, &wait);
1194
set_current_state(TASK_INTERRUPTIBLE);
1196
if (pp->cmd.status != 1)
1199
if (signal_pending(current))
1201
spin_unlock_irqrestore(&pp->lock, flags);
1203
spin_lock_irqsave(&pp->lock, flags);
1205
set_current_state(TASK_RUNNING);
1206
remove_wait_queue(&pp->wait, &wait);
1208
spin_unlock_irqrestore(&pp->lock, flags);
1211
if (pp->cmd.status != 0)
1212
pp->cmd.reply_len = 0;
1213
size = sizeof(hdr) + pp->cmd.reply_len;
1217
hdr.status = pp->cmd.status;
1218
hdr.reply_len = pp->cmd.reply_len;
1219
if (copy_to_user(buf, &hdr, sizeof(hdr)))
1221
size -= sizeof(hdr);
1222
if (size && copy_to_user(buf + sizeof(hdr), pp->buffer, size))
1230
static ssize_t smu_read_events(struct file *file, struct smu_private *pp,
1231
char __user *buf, size_t count)
1233
/* Not implemented */
1234
msleep_interruptible(1000);
1239
static ssize_t smu_read(struct file *file, char __user *buf,
1240
size_t count, loff_t *ppos)
1242
struct smu_private *pp = file->private_data;
1244
if (pp->mode == smu_file_commands)
1245
return smu_read_command(file, pp, buf, count);
1246
if (pp->mode == smu_file_events)
1247
return smu_read_events(file, pp, buf, count);
1252
static unsigned int smu_fpoll(struct file *file, poll_table *wait)
1254
struct smu_private *pp = file->private_data;
1255
unsigned int mask = 0;
1256
unsigned long flags;
1261
if (pp->mode == smu_file_commands) {
1262
poll_wait(file, &pp->wait, wait);
1264
spin_lock_irqsave(&pp->lock, flags);
1265
if (pp->busy && pp->cmd.status != 1)
1267
spin_unlock_irqrestore(&pp->lock, flags);
1268
} if (pp->mode == smu_file_events) {
1269
/* Not yet implemented */
1274
static int smu_release(struct inode *inode, struct file *file)
1276
struct smu_private *pp = file->private_data;
1277
unsigned long flags;
1283
file->private_data = NULL;
1285
/* Mark file as closing to avoid races with new request */
1286
spin_lock_irqsave(&pp->lock, flags);
1287
pp->mode = smu_file_closing;
1290
/* Wait for any pending request to complete */
1291
if (busy && pp->cmd.status == 1) {
1292
DECLARE_WAITQUEUE(wait, current);
1294
add_wait_queue(&pp->wait, &wait);
1296
set_current_state(TASK_UNINTERRUPTIBLE);
1297
if (pp->cmd.status != 1)
1299
spin_unlock_irqrestore(&pp->lock, flags);
1301
spin_lock_irqsave(&pp->lock, flags);
1303
set_current_state(TASK_RUNNING);
1304
remove_wait_queue(&pp->wait, &wait);
1306
spin_unlock_irqrestore(&pp->lock, flags);
1308
spin_lock_irqsave(&smu_clist_lock, flags);
1309
list_del(&pp->list);
1310
spin_unlock_irqrestore(&smu_clist_lock, flags);
1317
static const struct file_operations smu_device_fops = {
1318
.llseek = no_llseek,
1323
.release = smu_release,
1326
static struct miscdevice pmu_device = {
1327
MISC_DYNAMIC_MINOR, "smu", &smu_device_fops
1330
static int smu_device_init(void)
1334
if (misc_register(&pmu_device) < 0)
1335
printk(KERN_ERR "via-pmu: cannot register misc device.\n");
1338
device_initcall(smu_device_init);