PageRenderTime 42ms CodeModel.GetById 12ms app.highlight 24ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/char/ipmi/ipmi_kcs_sm.c

https://bitbucket.org/evzijst/gittest
C | 500 lines | 351 code | 61 blank | 88 comment | 56 complexity | 2a7ec079bad5b2140ad610c87674f25c MD5 | raw file
  1/*
  2 * ipmi_kcs_sm.c
  3 *
  4 * State machine for handling IPMI KCS interfaces.
  5 *
  6 * Author: MontaVista Software, Inc.
  7 *         Corey Minyard <minyard@mvista.com>
  8 *         source@mvista.com
  9 *
 10 * Copyright 2002 MontaVista Software Inc.
 11 *
 12 *  This program is free software; you can redistribute it and/or modify it
 13 *  under the terms of the GNU General Public License as published by the
 14 *  Free Software Foundation; either version 2 of the License, or (at your
 15 *  option) any later version.
 16 *
 17 *
 18 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 19 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 20 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 21 *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 22 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 23 *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 24 *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 25 *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 26 *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 27 *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 28 *
 29 *  You should have received a copy of the GNU General Public License along
 30 *  with this program; if not, write to the Free Software Foundation, Inc.,
 31 *  675 Mass Ave, Cambridge, MA 02139, USA.
 32 */
 33
 34/*
 35 * This state machine is taken from the state machine in the IPMI spec,
 36 * pretty much verbatim.  If you have questions about the states, see
 37 * that document.
 38 */
 39
 40#include <linux/kernel.h> /* For printk. */
 41#include <linux/string.h>
 42#include <linux/ipmi_msgdefs.h>		/* for completion codes */
 43#include "ipmi_si_sm.h"
 44
 45#define IPMI_KCS_VERSION "v33"
 46
 47/* Set this if you want a printout of why the state machine was hosed
 48   when it gets hosed. */
 49#define DEBUG_HOSED_REASON
 50
 51/* Print the state machine state on entry every time. */
 52#undef DEBUG_STATE
 53
 54/* The states the KCS driver may be in. */
 55enum kcs_states {
 56	KCS_IDLE,		/* The KCS interface is currently
 57                                   doing nothing. */
 58	KCS_START_OP,		/* We are starting an operation.  The
 59				   data is in the output buffer, but
 60				   nothing has been done to the
 61				   interface yet.  This was added to
 62				   the state machine in the spec to
 63				   wait for the initial IBF. */
 64	KCS_WAIT_WRITE_START,	/* We have written a write cmd to the
 65				   interface. */
 66	KCS_WAIT_WRITE,		/* We are writing bytes to the
 67                                   interface. */
 68	KCS_WAIT_WRITE_END,	/* We have written the write end cmd
 69                                   to the interface, and still need to
 70                                   write the last byte. */
 71	KCS_WAIT_READ,		/* We are waiting to read data from
 72				   the interface. */
 73	KCS_ERROR0,		/* State to transition to the error
 74				   handler, this was added to the
 75				   state machine in the spec to be
 76				   sure IBF was there. */
 77	KCS_ERROR1,		/* First stage error handler, wait for
 78                                   the interface to respond. */
 79	KCS_ERROR2,		/* The abort cmd has been written,
 80				   wait for the interface to
 81				   respond. */
 82	KCS_ERROR3,		/* We wrote some data to the
 83				   interface, wait for it to switch to
 84				   read mode. */
 85	KCS_HOSED		/* The hardware failed to follow the
 86				   state machine. */
 87};
 88
 89#define MAX_KCS_READ_SIZE 80
 90#define MAX_KCS_WRITE_SIZE 80
 91
 92/* Timeouts in microseconds. */
 93#define IBF_RETRY_TIMEOUT 1000000
 94#define OBF_RETRY_TIMEOUT 1000000
 95#define MAX_ERROR_RETRIES 10
 96
 97struct si_sm_data
 98{
 99	enum kcs_states  state;
100	struct si_sm_io *io;
101	unsigned char    write_data[MAX_KCS_WRITE_SIZE];
102	int              write_pos;
103	int              write_count;
104	int              orig_write_count;
105	unsigned char    read_data[MAX_KCS_READ_SIZE];
106	int              read_pos;
107	int	         truncated;
108
109	unsigned int  error_retries;
110	long          ibf_timeout;
111	long          obf_timeout;
112};
113
114static unsigned int init_kcs_data(struct si_sm_data *kcs,
115				  struct si_sm_io *io)
116{
117	kcs->state = KCS_IDLE;
118	kcs->io = io;
119	kcs->write_pos = 0;
120	kcs->write_count = 0;
121	kcs->orig_write_count = 0;
122	kcs->read_pos = 0;
123	kcs->error_retries = 0;
124	kcs->truncated = 0;
125	kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
126	kcs->obf_timeout = OBF_RETRY_TIMEOUT;
127
128	/* Reserve 2 I/O bytes. */
129	return 2;
130}
131
132static inline unsigned char read_status(struct si_sm_data *kcs)
133{
134	return kcs->io->inputb(kcs->io, 1);
135}
136
137static inline unsigned char read_data(struct si_sm_data *kcs)
138{
139	return kcs->io->inputb(kcs->io, 0);
140}
141
142static inline void write_cmd(struct si_sm_data *kcs, unsigned char data)
143{
144	kcs->io->outputb(kcs->io, 1, data);
145}
146
147static inline void write_data(struct si_sm_data *kcs, unsigned char data)
148{
149	kcs->io->outputb(kcs->io, 0, data);
150}
151
152/* Control codes. */
153#define KCS_GET_STATUS_ABORT	0x60
154#define KCS_WRITE_START		0x61
155#define KCS_WRITE_END		0x62
156#define KCS_READ_BYTE		0x68
157
158/* Status bits. */
159#define GET_STATUS_STATE(status) (((status) >> 6) & 0x03)
160#define KCS_IDLE_STATE	0
161#define KCS_READ_STATE	1
162#define KCS_WRITE_STATE	2
163#define KCS_ERROR_STATE	3
164#define GET_STATUS_ATN(status) ((status) & 0x04)
165#define GET_STATUS_IBF(status) ((status) & 0x02)
166#define GET_STATUS_OBF(status) ((status) & 0x01)
167
168
169static inline void write_next_byte(struct si_sm_data *kcs)
170{
171	write_data(kcs, kcs->write_data[kcs->write_pos]);
172	(kcs->write_pos)++;
173	(kcs->write_count)--;
174}
175
176static inline void start_error_recovery(struct si_sm_data *kcs, char *reason)
177{
178	(kcs->error_retries)++;
179	if (kcs->error_retries > MAX_ERROR_RETRIES) {
180#ifdef DEBUG_HOSED_REASON
181		printk("ipmi_kcs_sm: kcs hosed: %s\n", reason);
182#endif
183		kcs->state = KCS_HOSED;
184	} else {
185		kcs->state = KCS_ERROR0;
186	}
187}
188
189static inline void read_next_byte(struct si_sm_data *kcs)
190{
191	if (kcs->read_pos >= MAX_KCS_READ_SIZE) {
192		/* Throw the data away and mark it truncated. */
193		read_data(kcs);
194		kcs->truncated = 1;
195	} else {
196		kcs->read_data[kcs->read_pos] = read_data(kcs);
197		(kcs->read_pos)++;
198	}
199	write_data(kcs, KCS_READ_BYTE);
200}
201
202static inline int check_ibf(struct si_sm_data *kcs, unsigned char status,
203			    long time)
204{
205	if (GET_STATUS_IBF(status)) {
206		kcs->ibf_timeout -= time;
207		if (kcs->ibf_timeout < 0) {
208			start_error_recovery(kcs, "IBF not ready in time");
209			kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
210			return 1;
211		}
212		return 0;
213	}
214	kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
215	return 1;
216}
217
218static inline int check_obf(struct si_sm_data *kcs, unsigned char status,
219			    long time)
220{
221	if (! GET_STATUS_OBF(status)) {
222		kcs->obf_timeout -= time;
223		if (kcs->obf_timeout < 0) {
224		    start_error_recovery(kcs, "OBF not ready in time");
225		    return 1;
226		}
227		return 0;
228	}
229	kcs->obf_timeout = OBF_RETRY_TIMEOUT;
230	return 1;
231}
232
233static void clear_obf(struct si_sm_data *kcs, unsigned char status)
234{
235	if (GET_STATUS_OBF(status))
236		read_data(kcs);
237}
238
239static void restart_kcs_transaction(struct si_sm_data *kcs)
240{
241	kcs->write_count = kcs->orig_write_count;
242	kcs->write_pos = 0;
243	kcs->read_pos = 0;
244	kcs->state = KCS_WAIT_WRITE_START;
245	kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
246	kcs->obf_timeout = OBF_RETRY_TIMEOUT;
247	write_cmd(kcs, KCS_WRITE_START);
248}
249
250static int start_kcs_transaction(struct si_sm_data *kcs, unsigned char *data,
251				 unsigned int size)
252{
253	if ((size < 2) || (size > MAX_KCS_WRITE_SIZE)) {
254		return -1;
255	}
256
257	if ((kcs->state != KCS_IDLE) && (kcs->state != KCS_HOSED)) {
258		return -2;
259	}
260
261	kcs->error_retries = 0;
262	memcpy(kcs->write_data, data, size);
263	kcs->write_count = size;
264	kcs->orig_write_count = size;
265	kcs->write_pos = 0;
266	kcs->read_pos = 0;
267	kcs->state = KCS_START_OP;
268	kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
269	kcs->obf_timeout = OBF_RETRY_TIMEOUT;
270	return 0;
271}
272
273static int get_kcs_result(struct si_sm_data *kcs, unsigned char *data,
274			  unsigned int length)
275{
276	if (length < kcs->read_pos) {
277		kcs->read_pos = length;
278		kcs->truncated = 1;
279	}
280
281	memcpy(data, kcs->read_data, kcs->read_pos);
282
283	if ((length >= 3) && (kcs->read_pos < 3)) {
284		/* Guarantee that we return at least 3 bytes, with an
285		   error in the third byte if it is too short. */
286		data[2] = IPMI_ERR_UNSPECIFIED;
287		kcs->read_pos = 3;
288	}
289	if (kcs->truncated) {
290		/* Report a truncated error.  We might overwrite
291		   another error, but that's too bad, the user needs
292		   to know it was truncated. */
293		data[2] = IPMI_ERR_MSG_TRUNCATED;
294		kcs->truncated = 0;
295	}
296
297	return kcs->read_pos;
298}
299
300/* This implements the state machine defined in the IPMI manual, see
301   that for details on how this works.  Divide that flowchart into
302   sections delimited by "Wait for IBF" and this will become clear. */
303static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
304{
305	unsigned char status;
306	unsigned char state;
307
308	status = read_status(kcs);
309
310#ifdef DEBUG_STATE
311	printk("  State = %d, %x\n", kcs->state, status);
312#endif
313	/* All states wait for ibf, so just do it here. */
314	if (!check_ibf(kcs, status, time))
315		return SI_SM_CALL_WITH_DELAY;
316
317	/* Just about everything looks at the KCS state, so grab that, too. */
318	state = GET_STATUS_STATE(status);
319
320	switch (kcs->state) {
321	case KCS_IDLE:
322		/* If there's and interrupt source, turn it off. */
323		clear_obf(kcs, status);
324
325		if (GET_STATUS_ATN(status))
326			return SI_SM_ATTN;
327		else
328			return SI_SM_IDLE;
329
330	case KCS_START_OP:
331		if (state != KCS_IDLE) {
332			start_error_recovery(kcs,
333					     "State machine not idle at start");
334			break;
335		}
336
337		clear_obf(kcs, status);
338		write_cmd(kcs, KCS_WRITE_START);
339		kcs->state = KCS_WAIT_WRITE_START;
340		break;
341
342	case KCS_WAIT_WRITE_START:
343		if (state != KCS_WRITE_STATE) {
344			start_error_recovery(
345				kcs,
346				"Not in write state at write start");
347			break;
348		}
349		read_data(kcs);
350		if (kcs->write_count == 1) {
351			write_cmd(kcs, KCS_WRITE_END);
352			kcs->state = KCS_WAIT_WRITE_END;
353		} else {
354			write_next_byte(kcs);
355			kcs->state = KCS_WAIT_WRITE;
356		}
357		break;
358
359	case KCS_WAIT_WRITE:
360		if (state != KCS_WRITE_STATE) {
361			start_error_recovery(kcs,
362					     "Not in write state for write");
363			break;
364		}
365		clear_obf(kcs, status);
366		if (kcs->write_count == 1) {
367			write_cmd(kcs, KCS_WRITE_END);
368			kcs->state = KCS_WAIT_WRITE_END;
369		} else {
370			write_next_byte(kcs);
371		}
372		break;
373		
374	case KCS_WAIT_WRITE_END:
375		if (state != KCS_WRITE_STATE) {
376			start_error_recovery(kcs,
377					     "Not in write state for write end");
378			break;
379		}
380		clear_obf(kcs, status);
381		write_next_byte(kcs);
382		kcs->state = KCS_WAIT_READ;
383		break;
384
385	case KCS_WAIT_READ:
386		if ((state != KCS_READ_STATE) && (state != KCS_IDLE_STATE)) {
387			start_error_recovery(
388				kcs,
389				"Not in read or idle in read state");
390			break;
391		}
392
393		if (state == KCS_READ_STATE) {
394			if (! check_obf(kcs, status, time))
395				return SI_SM_CALL_WITH_DELAY;
396			read_next_byte(kcs);
397		} else {
398			/* We don't implement this exactly like the state
399			   machine in the spec.  Some broken hardware
400			   does not write the final dummy byte to the
401			   read register.  Thus obf will never go high
402			   here.  We just go straight to idle, and we
403			   handle clearing out obf in idle state if it
404			   happens to come in. */
405			clear_obf(kcs, status);
406			kcs->orig_write_count = 0;
407			kcs->state = KCS_IDLE;
408			return SI_SM_TRANSACTION_COMPLETE;
409		}
410		break;
411
412	case KCS_ERROR0:
413		clear_obf(kcs, status);
414		write_cmd(kcs, KCS_GET_STATUS_ABORT);
415		kcs->state = KCS_ERROR1;
416		break;
417
418	case KCS_ERROR1:
419		clear_obf(kcs, status);
420		write_data(kcs, 0);
421		kcs->state = KCS_ERROR2;
422		break;
423		
424	case KCS_ERROR2:
425		if (state != KCS_READ_STATE) {
426			start_error_recovery(kcs,
427					     "Not in read state for error2");
428			break;
429		}
430		if (! check_obf(kcs, status, time))
431			return SI_SM_CALL_WITH_DELAY;
432
433		clear_obf(kcs, status);
434		write_data(kcs, KCS_READ_BYTE);
435		kcs->state = KCS_ERROR3;
436		break;
437		
438	case KCS_ERROR3:
439		if (state != KCS_IDLE_STATE) {
440			start_error_recovery(kcs,
441					     "Not in idle state for error3");
442			break;
443		}
444
445		if (! check_obf(kcs, status, time))
446			return SI_SM_CALL_WITH_DELAY;
447
448		clear_obf(kcs, status);
449		if (kcs->orig_write_count) {
450			restart_kcs_transaction(kcs);
451		} else {
452			kcs->state = KCS_IDLE;
453			return SI_SM_TRANSACTION_COMPLETE;
454		}
455		break;
456			
457	case KCS_HOSED:
458		break;
459	}
460
461	if (kcs->state == KCS_HOSED) {
462		init_kcs_data(kcs, kcs->io);
463		return SI_SM_HOSED;
464	}
465
466	return SI_SM_CALL_WITHOUT_DELAY;
467}
468
469static int kcs_size(void)
470{
471	return sizeof(struct si_sm_data);
472}
473
474static int kcs_detect(struct si_sm_data *kcs)
475{
476	/* It's impossible for the KCS status register to be all 1's,
477	   (assuming a properly functioning, self-initialized BMC)
478	   but that's what you get from reading a bogus address, so we
479	   test that first. */
480	if (read_status(kcs) == 0xff)
481		return 1;
482
483	return 0;
484}
485
486static void kcs_cleanup(struct si_sm_data *kcs)
487{
488}
489
490struct si_sm_handlers kcs_smi_handlers =
491{
492	.version           = IPMI_KCS_VERSION,
493	.init_data         = init_kcs_data,
494	.start_transaction = start_kcs_transaction,
495	.get_result        = get_kcs_result,
496	.event             = kcs_event,
497	.detect            = kcs_detect,
498	.cleanup           = kcs_cleanup,
499	.size              = kcs_size,
500};