Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | |
2 | /* | |
3 | * IBM ASM Service Processor Device Driver | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or modify | |
6 | * it under the terms of the GNU General Public License as published by | |
7 | * the Free Software Foundation; either version 2 of the License, or | |
8 | * (at your option) any later version. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, | |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | * GNU General Public License for more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License | |
16 | * along with this program; if not, write to the Free Software | |
17 | * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
18 | * | |
19 | * Copyright (C) IBM Corporation, 2004 | |
20 | * | |
d36b6910 | 21 | * Author: Max Asböck <amax@us.ibm.com> |
1da177e4 LT |
22 | * |
23 | */ | |
24 | ||
d43c36dc | 25 | #include <linux/sched.h> |
5a0e3ad6 | 26 | #include <linux/slab.h> |
1da177e4 | 27 | #include "ibmasm.h" |
88187605 | 28 | #include "lowlevel.h" |
1da177e4 LT |
29 | |
30 | static void exec_next_command(struct service_processor *sp); | |
1da177e4 | 31 | |
88187605 | 32 | static atomic_t command_count = ATOMIC_INIT(0); |
1da177e4 | 33 | |
88187605 | 34 | struct command *ibmasm_new_command(struct service_processor *sp, size_t buffer_size) |
1da177e4 LT |
35 | { |
36 | struct command *cmd; | |
37 | ||
38 | if (buffer_size > IBMASM_CMD_MAX_BUFFER_SIZE) | |
39 | return NULL; | |
40 | ||
dd00cc48 | 41 | cmd = kzalloc(sizeof(struct command), GFP_KERNEL); |
1da177e4 LT |
42 | if (cmd == NULL) |
43 | return NULL; | |
44 | ||
1da177e4 | 45 | |
dd00cc48 | 46 | cmd->buffer = kzalloc(buffer_size, GFP_KERNEL); |
1da177e4 LT |
47 | if (cmd->buffer == NULL) { |
48 | kfree(cmd); | |
49 | return NULL; | |
50 | } | |
1da177e4 LT |
51 | cmd->buffer_size = buffer_size; |
52 | ||
a045171f | 53 | kref_init(&cmd->kref); |
88187605 | 54 | cmd->lock = &sp->lock; |
1da177e4 LT |
55 | |
56 | cmd->status = IBMASM_CMD_PENDING; | |
57 | init_waitqueue_head(&cmd->wait); | |
58 | INIT_LIST_HEAD(&cmd->queue_node); | |
59 | ||
88187605 MA |
60 | atomic_inc(&command_count); |
61 | dbg("command count: %d\n", atomic_read(&command_count)); | |
62 | ||
1da177e4 LT |
63 | return cmd; |
64 | } | |
65 | ||
a045171f | 66 | void ibmasm_free_command(struct kref *kref) |
1da177e4 | 67 | { |
a045171f | 68 | struct command *cmd = to_command(kref); |
3110dc7a | 69 | |
1da177e4 | 70 | list_del(&cmd->queue_node); |
88187605 MA |
71 | atomic_dec(&command_count); |
72 | dbg("command count: %d\n", atomic_read(&command_count)); | |
1da177e4 LT |
73 | kfree(cmd->buffer); |
74 | kfree(cmd); | |
75 | } | |
76 | ||
77 | static void enqueue_command(struct service_processor *sp, struct command *cmd) | |
78 | { | |
79 | list_add_tail(&cmd->queue_node, &sp->command_queue); | |
80 | } | |
81 | ||
82 | static struct command *dequeue_command(struct service_processor *sp) | |
83 | { | |
84 | struct command *cmd; | |
85 | struct list_head *next; | |
86 | ||
87 | if (list_empty(&sp->command_queue)) | |
88 | return NULL; | |
89 | ||
90 | next = sp->command_queue.next; | |
91 | list_del_init(next); | |
92 | cmd = list_entry(next, struct command, queue_node); | |
93 | ||
94 | return cmd; | |
95 | } | |
96 | ||
97 | static inline void do_exec_command(struct service_processor *sp) | |
98 | { | |
88187605 MA |
99 | char tsbuf[32]; |
100 | ||
6e574195 | 101 | dbg("%s:%d at %s\n", __func__, __LINE__, get_timestamp(tsbuf)); |
88187605 | 102 | |
1da177e4 LT |
103 | if (ibmasm_send_i2o_message(sp)) { |
104 | sp->current_command->status = IBMASM_CMD_FAILED; | |
88187605 MA |
105 | wake_up(&sp->current_command->wait); |
106 | command_put(sp->current_command); | |
1da177e4 LT |
107 | exec_next_command(sp); |
108 | } | |
109 | } | |
3110dc7a | 110 | |
1da177e4 LT |
111 | /** |
112 | * exec_command | |
113 | * send a command to a service processor | |
114 | * Commands are executed sequentially. One command (sp->current_command) | |
115 | * is sent to the service processor. Once the interrupt handler gets a | |
116 | * message of type command_response, the message is copied into | |
3110dc7a | 117 | * the current commands buffer, |
1da177e4 LT |
118 | */ |
119 | void ibmasm_exec_command(struct service_processor *sp, struct command *cmd) | |
120 | { | |
121 | unsigned long flags; | |
88187605 MA |
122 | char tsbuf[32]; |
123 | ||
6e574195 | 124 | dbg("%s:%d at %s\n", __func__, __LINE__, get_timestamp(tsbuf)); |
1da177e4 LT |
125 | |
126 | spin_lock_irqsave(&sp->lock, flags); | |
127 | ||
128 | if (!sp->current_command) { | |
1da177e4 | 129 | sp->current_command = cmd; |
88187605 | 130 | command_get(sp->current_command); |
1da177e4 | 131 | spin_unlock_irqrestore(&sp->lock, flags); |
1da177e4 LT |
132 | do_exec_command(sp); |
133 | } else { | |
134 | enqueue_command(sp, cmd); | |
135 | spin_unlock_irqrestore(&sp->lock, flags); | |
136 | } | |
137 | } | |
138 | ||
139 | static void exec_next_command(struct service_processor *sp) | |
140 | { | |
141 | unsigned long flags; | |
88187605 | 142 | char tsbuf[32]; |
1da177e4 | 143 | |
6e574195 | 144 | dbg("%s:%d at %s\n", __func__, __LINE__, get_timestamp(tsbuf)); |
1da177e4 LT |
145 | |
146 | spin_lock_irqsave(&sp->lock, flags); | |
147 | sp->current_command = dequeue_command(sp); | |
148 | if (sp->current_command) { | |
149 | command_get(sp->current_command); | |
150 | spin_unlock_irqrestore(&sp->lock, flags); | |
151 | do_exec_command(sp); | |
152 | } else { | |
153 | spin_unlock_irqrestore(&sp->lock, flags); | |
154 | } | |
155 | } | |
156 | ||
3110dc7a | 157 | /** |
1da177e4 LT |
158 | * Sleep until a command has failed or a response has been received |
159 | * and the command status been updated by the interrupt handler. | |
160 | * (see receive_response). | |
161 | */ | |
162 | void ibmasm_wait_for_response(struct command *cmd, int timeout) | |
163 | { | |
164 | wait_event_interruptible_timeout(cmd->wait, | |
165 | cmd->status == IBMASM_CMD_COMPLETE || | |
166 | cmd->status == IBMASM_CMD_FAILED, | |
167 | timeout * HZ); | |
168 | } | |
169 | ||
170 | /** | |
171 | * receive_command_response | |
172 | * called by the interrupt handler when a dot command of type command_response | |
173 | * was received. | |
174 | */ | |
175 | void ibmasm_receive_command_response(struct service_processor *sp, void *response, size_t size) | |
176 | { | |
177 | struct command *cmd = sp->current_command; | |
178 | ||
3110dc7a DT |
179 | if (!sp->current_command) |
180 | return; | |
1da177e4 | 181 | |
88187605 | 182 | memcpy_fromio(cmd->buffer, response, min(size, cmd->buffer_size)); |
1da177e4 | 183 | cmd->status = IBMASM_CMD_COMPLETE; |
88187605 MA |
184 | wake_up(&sp->current_command->wait); |
185 | command_put(sp->current_command); | |
1da177e4 LT |
186 | exec_next_command(sp); |
187 | } |