| .. | .. |
|---|
| 8 | 8 | * Author: Rocky Craig <first.last@hp.com> |
|---|
| 9 | 9 | */ |
|---|
| 10 | 10 | |
|---|
| 11 | +#define DEBUG /* So dev_dbg() is always available. */ |
|---|
| 12 | + |
|---|
| 11 | 13 | #include <linux/kernel.h> /* For printk. */ |
|---|
| 12 | 14 | #include <linux/string.h> |
|---|
| 13 | 15 | #include <linux/module.h> |
|---|
| .. | .. |
|---|
| 211 | 213 | if (bt->state == BT_STATE_LONG_BUSY) |
|---|
| 212 | 214 | return IPMI_NODE_BUSY_ERR; |
|---|
| 213 | 215 | |
|---|
| 214 | | - if (bt->state != BT_STATE_IDLE) |
|---|
| 216 | + if (bt->state != BT_STATE_IDLE) { |
|---|
| 217 | + dev_warn(bt->io->dev, "BT in invalid state %d\n", bt->state); |
|---|
| 215 | 218 | return IPMI_NOT_IN_MY_STATE_ERR; |
|---|
| 219 | + } |
|---|
| 216 | 220 | |
|---|
| 217 | 221 | if (bt_debug & BT_DEBUG_MSG) { |
|---|
| 218 | | - printk(KERN_WARNING "BT: +++++++++++++++++ New command\n"); |
|---|
| 219 | | - printk(KERN_WARNING "BT: NetFn/LUN CMD [%d data]:", size - 2); |
|---|
| 222 | + dev_dbg(bt->io->dev, "+++++++++++++++++ New command\n"); |
|---|
| 223 | + dev_dbg(bt->io->dev, "NetFn/LUN CMD [%d data]:", size - 2); |
|---|
| 220 | 224 | for (i = 0; i < size; i ++) |
|---|
| 221 | | - printk(" %02x", data[i]); |
|---|
| 222 | | - printk("\n"); |
|---|
| 225 | + pr_cont(" %02x", data[i]); |
|---|
| 226 | + pr_cont("\n"); |
|---|
| 223 | 227 | } |
|---|
| 224 | 228 | bt->write_data[0] = size + 1; /* all data plus seq byte */ |
|---|
| 225 | 229 | bt->write_data[1] = *data; /* NetFn/LUN */ |
|---|
| .. | .. |
|---|
| 260 | 264 | memcpy(data + 2, bt->read_data + 4, msg_len - 2); |
|---|
| 261 | 265 | |
|---|
| 262 | 266 | if (bt_debug & BT_DEBUG_MSG) { |
|---|
| 263 | | - printk(KERN_WARNING "BT: result %d bytes:", msg_len); |
|---|
| 267 | + dev_dbg(bt->io->dev, "result %d bytes:", msg_len); |
|---|
| 264 | 268 | for (i = 0; i < msg_len; i++) |
|---|
| 265 | | - printk(" %02x", data[i]); |
|---|
| 266 | | - printk("\n"); |
|---|
| 269 | + pr_cont(" %02x", data[i]); |
|---|
| 270 | + pr_cont("\n"); |
|---|
| 267 | 271 | } |
|---|
| 268 | 272 | return msg_len; |
|---|
| 269 | 273 | } |
|---|
| .. | .. |
|---|
| 274 | 278 | static void reset_flags(struct si_sm_data *bt) |
|---|
| 275 | 279 | { |
|---|
| 276 | 280 | if (bt_debug) |
|---|
| 277 | | - printk(KERN_WARNING "IPMI BT: flag reset %s\n", |
|---|
| 278 | | - status2txt(BT_STATUS)); |
|---|
| 281 | + dev_dbg(bt->io->dev, "flag reset %s\n", status2txt(BT_STATUS)); |
|---|
| 279 | 282 | if (BT_STATUS & BT_H_BUSY) |
|---|
| 280 | 283 | BT_CONTROL(BT_H_BUSY); /* force clear */ |
|---|
| 281 | 284 | BT_CONTROL(BT_CLR_WR_PTR); /* always reset */ |
|---|
| .. | .. |
|---|
| 301 | 304 | BT_CONTROL(BT_B2H_ATN); /* some BMCs are stubborn */ |
|---|
| 302 | 305 | BT_CONTROL(BT_CLR_RD_PTR); /* always reset */ |
|---|
| 303 | 306 | if (bt_debug) |
|---|
| 304 | | - printk(KERN_WARNING "IPMI BT: stale response %s; ", |
|---|
| 307 | + dev_dbg(bt->io->dev, "stale response %s; ", |
|---|
| 305 | 308 | status2txt(BT_STATUS)); |
|---|
| 306 | 309 | size = BMC2HOST; |
|---|
| 307 | 310 | for (i = 0; i < size ; i++) |
|---|
| 308 | 311 | BMC2HOST; |
|---|
| 309 | 312 | BT_CONTROL(BT_H_BUSY); /* now clear */ |
|---|
| 310 | 313 | if (bt_debug) |
|---|
| 311 | | - printk("drained %d bytes\n", size + 1); |
|---|
| 314 | + pr_cont("drained %d bytes\n", size + 1); |
|---|
| 312 | 315 | } |
|---|
| 313 | 316 | |
|---|
| 314 | 317 | static inline void write_all_bytes(struct si_sm_data *bt) |
|---|
| .. | .. |
|---|
| 316 | 319 | int i; |
|---|
| 317 | 320 | |
|---|
| 318 | 321 | if (bt_debug & BT_DEBUG_MSG) { |
|---|
| 319 | | - printk(KERN_WARNING "BT: write %d bytes seq=0x%02X", |
|---|
| 322 | + dev_dbg(bt->io->dev, "write %d bytes seq=0x%02X", |
|---|
| 320 | 323 | bt->write_count, bt->seq); |
|---|
| 321 | 324 | for (i = 0; i < bt->write_count; i++) |
|---|
| 322 | | - printk(" %02x", bt->write_data[i]); |
|---|
| 323 | | - printk("\n"); |
|---|
| 325 | + pr_cont(" %02x", bt->write_data[i]); |
|---|
| 326 | + pr_cont("\n"); |
|---|
| 324 | 327 | } |
|---|
| 325 | 328 | for (i = 0; i < bt->write_count; i++) |
|---|
| 326 | 329 | HOST2BMC(bt->write_data[i]); |
|---|
| .. | .. |
|---|
| 340 | 343 | |
|---|
| 341 | 344 | if (bt->read_count < 4 || bt->read_count >= IPMI_MAX_MSG_LENGTH) { |
|---|
| 342 | 345 | if (bt_debug & BT_DEBUG_MSG) |
|---|
| 343 | | - printk(KERN_WARNING "BT: bad raw rsp len=%d\n", |
|---|
| 344 | | - bt->read_count); |
|---|
| 346 | + dev_dbg(bt->io->dev, |
|---|
| 347 | + "bad raw rsp len=%d\n", bt->read_count); |
|---|
| 345 | 348 | bt->truncated = 1; |
|---|
| 346 | 349 | return 1; /* let next XACTION START clean it up */ |
|---|
| 347 | 350 | } |
|---|
| .. | .. |
|---|
| 352 | 355 | if (bt_debug & BT_DEBUG_MSG) { |
|---|
| 353 | 356 | int max = bt->read_count; |
|---|
| 354 | 357 | |
|---|
| 355 | | - printk(KERN_WARNING "BT: got %d bytes seq=0x%02X", |
|---|
| 356 | | - max, bt->read_data[2]); |
|---|
| 358 | + dev_dbg(bt->io->dev, |
|---|
| 359 | + "got %d bytes seq=0x%02X", max, bt->read_data[2]); |
|---|
| 357 | 360 | if (max > 16) |
|---|
| 358 | 361 | max = 16; |
|---|
| 359 | 362 | for (i = 0; i < max; i++) |
|---|
| 360 | | - printk(KERN_CONT " %02x", bt->read_data[i]); |
|---|
| 361 | | - printk(KERN_CONT "%s\n", bt->read_count == max ? "" : " ..."); |
|---|
| 363 | + pr_cont(" %02x", bt->read_data[i]); |
|---|
| 364 | + pr_cont("%s\n", bt->read_count == max ? "" : " ..."); |
|---|
| 362 | 365 | } |
|---|
| 363 | 366 | |
|---|
| 364 | 367 | /* per the spec, the (NetFn[1], Seq[2], Cmd[3]) tuples must match */ |
|---|
| .. | .. |
|---|
| 368 | 371 | return 1; |
|---|
| 369 | 372 | |
|---|
| 370 | 373 | if (bt_debug & BT_DEBUG_MSG) |
|---|
| 371 | | - printk(KERN_WARNING "IPMI BT: bad packet: " |
|---|
| 372 | | - "want 0x(%02X, %02X, %02X) got (%02X, %02X, %02X)\n", |
|---|
| 373 | | - bt->write_data[1] | 0x04, bt->write_data[2], bt->write_data[3], |
|---|
| 374 | | - bt->read_data[1], bt->read_data[2], bt->read_data[3]); |
|---|
| 374 | + dev_dbg(bt->io->dev, |
|---|
| 375 | + "IPMI BT: bad packet: want 0x(%02X, %02X, %02X) got (%02X, %02X, %02X)\n", |
|---|
| 376 | + bt->write_data[1] | 0x04, bt->write_data[2], |
|---|
| 377 | + bt->write_data[3], |
|---|
| 378 | + bt->read_data[1], bt->read_data[2], bt->read_data[3]); |
|---|
| 375 | 379 | return 0; |
|---|
| 376 | 380 | } |
|---|
| 377 | 381 | |
|---|
| .. | .. |
|---|
| 394 | 398 | break; |
|---|
| 395 | 399 | } |
|---|
| 396 | 400 | |
|---|
| 397 | | - printk(KERN_WARNING "IPMI BT: %s in %s %s ", /* open-ended line */ |
|---|
| 398 | | - reason, STATE2TXT, STATUS2TXT); |
|---|
| 401 | + dev_warn(bt->io->dev, "IPMI BT: %s in %s %s ", /* open-ended line */ |
|---|
| 402 | + reason, STATE2TXT, STATUS2TXT); |
|---|
| 399 | 403 | |
|---|
| 400 | 404 | /* |
|---|
| 401 | 405 | * Per the IPMI spec, retries are based on the sequence number |
|---|
| .. | .. |
|---|
| 403 | 407 | */ |
|---|
| 404 | 408 | (bt->error_retries)++; |
|---|
| 405 | 409 | if (bt->error_retries < bt->BT_CAP_retries) { |
|---|
| 406 | | - printk("%d retries left\n", |
|---|
| 410 | + pr_cont("%d retries left\n", |
|---|
| 407 | 411 | bt->BT_CAP_retries - bt->error_retries); |
|---|
| 408 | 412 | bt->state = BT_STATE_RESTART; |
|---|
| 409 | 413 | return SI_SM_CALL_WITHOUT_DELAY; |
|---|
| 410 | 414 | } |
|---|
| 411 | 415 | |
|---|
| 412 | | - printk(KERN_WARNING "failed %d retries, sending error response\n", |
|---|
| 413 | | - bt->BT_CAP_retries); |
|---|
| 416 | + dev_warn(bt->io->dev, "failed %d retries, sending error response\n", |
|---|
| 417 | + bt->BT_CAP_retries); |
|---|
| 414 | 418 | if (!bt->nonzero_status) |
|---|
| 415 | | - printk(KERN_ERR "IPMI BT: stuck, try power cycle\n"); |
|---|
| 419 | + dev_err(bt->io->dev, "stuck, try power cycle\n"); |
|---|
| 416 | 420 | |
|---|
| 417 | 421 | /* this is most likely during insmod */ |
|---|
| 418 | 422 | else if (bt->seq <= (unsigned char)(bt->BT_CAP_retries & 0xFF)) { |
|---|
| 419 | | - printk(KERN_WARNING "IPMI: BT reset (takes 5 secs)\n"); |
|---|
| 423 | + dev_warn(bt->io->dev, "BT reset (takes 5 secs)\n"); |
|---|
| 420 | 424 | bt->state = BT_STATE_RESET1; |
|---|
| 421 | 425 | return SI_SM_CALL_WITHOUT_DELAY; |
|---|
| 422 | 426 | } |
|---|
| .. | .. |
|---|
| 452 | 456 | status = BT_STATUS; |
|---|
| 453 | 457 | bt->nonzero_status |= status; |
|---|
| 454 | 458 | if ((bt_debug & BT_DEBUG_STATES) && (bt->state != last_printed)) { |
|---|
| 455 | | - printk(KERN_WARNING "BT: %s %s TO=%ld - %ld \n", |
|---|
| 459 | + dev_dbg(bt->io->dev, "BT: %s %s TO=%ld - %ld\n", |
|---|
| 456 | 460 | STATE2TXT, |
|---|
| 457 | 461 | STATUS2TXT, |
|---|
| 458 | 462 | bt->timeout, |
|---|