char/ipmi/ipmi_smic_sm.c

104 static unsigned int init_smic_data(struct si_sm_data *smic,
107 	smic->state = SMIC_IDLE;
108 	smic->io = io;
109 	smic->write_pos = 0;
110 	smic->write_count = 0;
111 	smic->orig_write_count = 0;
112 	smic->read_pos = 0;
113 	smic->error_retries = 0;
114 	smic->truncated = 0;
115 	smic->smic_timeout = SMIC_RETRY_TIMEOUT;
121 static int start_smic_transaction(struct si_sm_data *smic,
131 	if ((smic->state != SMIC_IDLE) && (smic->state != SMIC_HOSED)) {
132 		dev_warn(smic->io->dev,
133 			 "SMIC in invalid state %d\n", smic->state);
138 		dev_dbg(smic->io->dev, "%s -", __func__);
143 	smic->error_retries = 0;
144 	memcpy(smic->write_data, data, size);
145 	smic->write_count = size;
146 	smic->orig_write_count = size;
147 	smic->write_pos = 0;
148 	smic->read_pos = 0;
149 	smic->state = SMIC_START_OP;
150 	smic->smic_timeout = SMIC_RETRY_TIMEOUT;
154 static int smic_get_result(struct si_sm_data *smic,
160 		dev_dbg(smic->io->dev, "smic_get result -");
161 		for (i = 0; i < smic->read_pos; i++)
162 			pr_cont(" %02x", smic->read_data[i]);
165 	if (length < smic->read_pos) {
166 		smic->read_pos = length;
167 		smic->truncated = 1;
169 	memcpy(data, smic->read_data, smic->read_pos);
171 	if ((length >= 3) && (smic->read_pos < 3)) {
173 		smic->read_pos = 3;
175 	if (smic->truncated) {
177 		smic->truncated = 0;
179 	return smic->read_pos;
182 static inline unsigned char read_smic_flags(struct si_sm_data *smic)
184 	return smic->io->inputb(smic->io, 2);
187 static inline unsigned char read_smic_status(struct si_sm_data *smic)
189 	return smic->io->inputb(smic->io, 1);
192 static inline unsigned char read_smic_data(struct si_sm_data *smic)
194 	return smic->io->inputb(smic->io, 0);
197 static inline void write_smic_flags(struct si_sm_data *smic,
200 	smic->io->outputb(smic->io, 2, flags);
203 static inline void write_smic_control(struct si_sm_data *smic,
206 	smic->io->outputb(smic->io, 1, control);
209 static inline void write_si_sm_data(struct si_sm_data *smic,
212 	smic->io->outputb(smic->io, 0, data);
215 static inline void start_error_recovery(struct si_sm_data *smic, char *reason)
217 	(smic->error_retries)++;
218 	if (smic->error_retries > SMIC_MAX_ERROR_RETRIES) {
220 			pr_warn("ipmi_smic_drv: smic hosed: %s\n", reason);
221 		smic->state = SMIC_HOSED;
223 		smic->write_count = smic->orig_write_count;
224 		smic->write_pos = 0;
225 		smic->read_pos = 0;
226 		smic->state = SMIC_START_OP;
227 		smic->smic_timeout = SMIC_RETRY_TIMEOUT;
231 static inline void write_next_byte(struct si_sm_data *smic)
233 	write_si_sm_data(smic, smic->write_data[smic->write_pos]);
234 	(smic->write_pos)++;
235 	(smic->write_count)--;
238 static inline void read_next_byte(struct si_sm_data *smic)
240 	if (smic->read_pos >= MAX_SMIC_READ_SIZE) {
241 		read_smic_data(smic);
242 		smic->truncated = 1;
244 		smic->read_data[smic->read_pos] = read_smic_data(smic);
245 		smic->read_pos++;
320 static enum si_sm_result smic_event(struct si_sm_data *smic, long time)
326 	if (smic->state == SMIC_HOSED) {
327 		init_smic_data(smic, smic->io);
330 	if (smic->state != SMIC_IDLE) {
332 			dev_dbg(smic->io->dev,
333 				"%s - smic->smic_timeout = %ld, time = %ld\n",
334 				__func__, smic->smic_timeout, time);
340 			smic->smic_timeout -= time;
341 			if (smic->smic_timeout < 0) {
342 				start_error_recovery(smic, "smic timed out.");
347 	flags = read_smic_flags(smic);
351 	status = read_smic_status(smic);
353 		dev_dbg(smic->io->dev,
355 			__func__, smic->state, flags, status);
357 	switch (smic->state) {
365 		/* sanity check whether smic is really idle */
366 		write_smic_control(smic, SMIC_CC_SMS_GET_STATUS);
367 		write_smic_flags(smic, flags | SMIC_FLAG_BSY);
368 		smic->state = SMIC_OP_OK;
374 			start_error_recovery(smic,
379 		/* OK so far; smic is idle let us start ... */
380 		write_smic_control(smic, SMIC_CC_SMS_WR_START);
381 		write_next_byte(smic);
382 		write_smic_flags(smic, flags | SMIC_FLAG_BSY);
383 		smic->state = SMIC_WRITE_START;
388 			start_error_recovery(smic,
398 			if (smic->write_count == 1) {
400 				write_smic_control(smic, SMIC_CC_SMS_WR_END);
401 				smic->state = SMIC_WRITE_END;
403 				write_smic_control(smic, SMIC_CC_SMS_WR_NEXT);
404 				smic->state = SMIC_WRITE_NEXT;
406 			write_next_byte(smic);
407 			write_smic_flags(smic, flags | SMIC_FLAG_BSY);
414 			start_error_recovery(smic,
421 			if (smic->write_count == 1) {
422 				write_smic_control(smic, SMIC_CC_SMS_WR_END);
423 				smic->state = SMIC_WRITE_END;
425 				write_smic_control(smic, SMIC_CC_SMS_WR_NEXT);
426 				smic->state = SMIC_WRITE_NEXT;
428 			write_next_byte(smic);
429 			write_smic_flags(smic, flags | SMIC_FLAG_BSY);
436 			start_error_recovery(smic,
442 		data = read_smic_data(smic);
445 				dev_dbg(smic->io->dev,
448 			start_error_recovery(smic,
453 			smic->state = SMIC_WRITE2READ;
462 			write_smic_control(smic, SMIC_CC_SMS_RD_START);
463 			write_smic_flags(smic, flags | SMIC_FLAG_BSY);
464 			smic->state = SMIC_READ_START;
471 			start_error_recovery(smic,
477 			read_next_byte(smic);
478 			write_smic_control(smic, SMIC_CC_SMS_RD_NEXT);
479 			write_smic_flags(smic, flags | SMIC_FLAG_BSY);
480 			smic->state = SMIC_READ_NEXT;
488 		 * smic tells us that this is the last byte to be read
492 			read_next_byte(smic);
493 			write_smic_control(smic, SMIC_CC_SMS_RD_END);
494 			write_smic_flags(smic, flags | SMIC_FLAG_BSY);
495 			smic->state = SMIC_READ_END;
499 				read_next_byte(smic);
500 				write_smic_control(smic, SMIC_CC_SMS_RD_NEXT);
501 				write_smic_flags(smic, flags | SMIC_FLAG_BSY);
502 				smic->state = SMIC_READ_NEXT;
508 				smic,
517 			start_error_recovery(smic,
522 		data = read_smic_data(smic);
526 				dev_dbg(smic->io->dev,
529 			start_error_recovery(smic,
534 			smic->state = SMIC_IDLE;
539 		init_smic_data(smic, smic->io);
544 			dev_dbg(smic->io->dev,
545 				"smic->state = %d\n", smic->state);
546 			start_error_recovery(smic, "state = UNKNOWN");
550 	smic->smic_timeout = SMIC_RETRY_TIMEOUT;
554 static int smic_detect(struct si_sm_data *smic)
562 	if (read_smic_flags(smic) == 0xff)