1 /* 2 * Copyright (C) 2015 Zodiac Inflight Innovations 3 * 4 * Author: Martyn Welch <martyn.welch@collabora.co.uk> 5 * 6 * Based on twl4030_wdt.c by Timo Kokkonen <timo.t.kokkonen at nokia.com>: 7 * 8 * Copyright (C) Nokia Corporation 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 */ 20 21 #include <linux/delay.h> 22 #include <linux/i2c.h> 23 #include <linux/ihex.h> 24 #include <linux/firmware.h> 25 #include <linux/kernel.h> 26 #include <linux/module.h> 27 #include <linux/slab.h> 28 #include <linux/sysfs.h> 29 #include <linux/types.h> 30 #include <linux/version.h> 31 #include <linux/watchdog.h> 32 33 #define ZIIRAVE_TIMEOUT_MIN 3 34 #define ZIIRAVE_TIMEOUT_MAX 255 35 36 #define ZIIRAVE_PING_VALUE 0x0 37 38 #define ZIIRAVE_STATE_INITIAL 0x0 39 #define ZIIRAVE_STATE_OFF 0x1 40 #define ZIIRAVE_STATE_ON 0x2 41 42 #define ZIIRAVE_FW_NAME "ziirave_wdt.fw" 43 44 static char *ziirave_reasons[] = {"power cycle", "hw watchdog", NULL, NULL, 45 "host request", NULL, "illegal configuration", 46 "illegal instruction", "illegal trap", 47 "unknown"}; 48 49 #define ZIIRAVE_WDT_FIRM_VER_MAJOR 0x1 50 #define ZIIRAVE_WDT_BOOT_VER_MAJOR 0x3 51 #define ZIIRAVE_WDT_RESET_REASON 0x5 52 #define ZIIRAVE_WDT_STATE 0x6 53 #define ZIIRAVE_WDT_TIMEOUT 0x7 54 #define ZIIRAVE_WDT_TIME_LEFT 0x8 55 #define ZIIRAVE_WDT_PING 0x9 56 #define ZIIRAVE_WDT_RESET_DURATION 0xa 57 58 #define ZIIRAVE_FIRM_PKT_TOTAL_SIZE 20 59 #define ZIIRAVE_FIRM_PKT_DATA_SIZE 16 60 #define ZIIRAVE_FIRM_FLASH_MEMORY_START 0x1600 61 #define ZIIRAVE_FIRM_FLASH_MEMORY_END 0x2bbf 62 63 /* Received and ready for next Download packet. */ 64 #define ZIIRAVE_FIRM_DOWNLOAD_ACK 1 65 /* Currently writing to flash. Retry Download status in a moment! */ 66 #define ZIIRAVE_FIRM_DOWNLOAD_BUSY 2 67 68 /* Wait for ACK timeout in ms */ 69 #define ZIIRAVE_FIRM_WAIT_FOR_ACK_TIMEOUT 50 70 71 /* Firmware commands */ 72 #define ZIIRAVE_CMD_DOWNLOAD_START 0x10 73 #define ZIIRAVE_CMD_DOWNLOAD_END 0x11 74 #define ZIIRAVE_CMD_DOWNLOAD_SET_READ_ADDR 0x12 75 #define ZIIRAVE_CMD_DOWNLOAD_READ_BYTE 0x13 76 #define ZIIRAVE_CMD_RESET_PROCESSOR 0x0b 77 #define ZIIRAVE_CMD_JUMP_TO_BOOTLOADER 0x0c 78 #define ZIIRAVE_CMD_DOWNLOAD_PACKET 0x0e 79 80 struct ziirave_wdt_rev { 81 unsigned char major; 82 unsigned char minor; 83 }; 84 85 struct ziirave_wdt_data { 86 struct mutex sysfs_mutex; 87 struct watchdog_device wdd; 88 struct ziirave_wdt_rev bootloader_rev; 89 struct ziirave_wdt_rev firmware_rev; 90 int reset_reason; 91 }; 92 93 static int wdt_timeout; 94 module_param(wdt_timeout, int, 0); 95 MODULE_PARM_DESC(wdt_timeout, "Watchdog timeout in seconds"); 96 97 static int reset_duration; 98 module_param(reset_duration, int, 0); 99 MODULE_PARM_DESC(reset_duration, 100 "Watchdog reset pulse duration in milliseconds"); 101 102 static bool nowayout = WATCHDOG_NOWAYOUT; 103 module_param(nowayout, bool, 0); 104 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started default=" 105 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 106 107 static int ziirave_wdt_revision(struct i2c_client *client, 108 struct ziirave_wdt_rev *rev, u8 command) 109 { 110 int ret; 111 112 ret = i2c_smbus_read_byte_data(client, command); 113 if (ret < 0) 114 return ret; 115 116 rev->major = ret; 117 118 ret = i2c_smbus_read_byte_data(client, command + 1); 119 if (ret < 0) 120 return ret; 121 122 rev->minor = ret; 123 124 return 0; 125 } 126 127 static int ziirave_wdt_set_state(struct watchdog_device *wdd, int state) 128 { 129 struct i2c_client *client = to_i2c_client(wdd->parent); 130 131 return i2c_smbus_write_byte_data(client, ZIIRAVE_WDT_STATE, state); 132 } 133 134 static int ziirave_wdt_start(struct watchdog_device *wdd) 135 { 136 return ziirave_wdt_set_state(wdd, ZIIRAVE_STATE_ON); 137 } 138 139 static int ziirave_wdt_stop(struct watchdog_device *wdd) 140 { 141 return ziirave_wdt_set_state(wdd, ZIIRAVE_STATE_OFF); 142 } 143 144 static int ziirave_wdt_ping(struct watchdog_device *wdd) 145 { 146 struct i2c_client *client = to_i2c_client(wdd->parent); 147 148 return i2c_smbus_write_byte_data(client, ZIIRAVE_WDT_PING, 149 ZIIRAVE_PING_VALUE); 150 } 151 152 static int ziirave_wdt_set_timeout(struct watchdog_device *wdd, 153 unsigned int timeout) 154 { 155 struct i2c_client *client = to_i2c_client(wdd->parent); 156 int ret; 157 158 ret = i2c_smbus_write_byte_data(client, ZIIRAVE_WDT_TIMEOUT, timeout); 159 if (!ret) 160 wdd->timeout = timeout; 161 162 return ret; 163 } 164 165 static unsigned int ziirave_wdt_get_timeleft(struct watchdog_device *wdd) 166 { 167 struct i2c_client *client = to_i2c_client(wdd->parent); 168 int ret; 169 170 ret = i2c_smbus_read_byte_data(client, ZIIRAVE_WDT_TIME_LEFT); 171 if (ret < 0) 172 ret = 0; 173 174 return ret; 175 } 176 177 static int ziirave_firm_wait_for_ack(struct watchdog_device *wdd) 178 { 179 struct i2c_client *client = to_i2c_client(wdd->parent); 180 int ret; 181 unsigned long timeout; 182 183 timeout = jiffies + msecs_to_jiffies(ZIIRAVE_FIRM_WAIT_FOR_ACK_TIMEOUT); 184 do { 185 if (time_after(jiffies, timeout)) 186 return -ETIMEDOUT; 187 188 usleep_range(5000, 10000); 189 190 ret = i2c_smbus_read_byte(client); 191 if (ret < 0) { 192 dev_err(&client->dev, "Failed to read byte\n"); 193 return ret; 194 } 195 } while (ret == ZIIRAVE_FIRM_DOWNLOAD_BUSY); 196 197 return ret == ZIIRAVE_FIRM_DOWNLOAD_ACK ? 0 : -EIO; 198 } 199 200 static int ziirave_firm_set_read_addr(struct watchdog_device *wdd, u16 addr) 201 { 202 struct i2c_client *client = to_i2c_client(wdd->parent); 203 u8 address[2]; 204 205 address[0] = addr & 0xff; 206 address[1] = (addr >> 8) & 0xff; 207 208 return i2c_smbus_write_block_data(client, 209 ZIIRAVE_CMD_DOWNLOAD_SET_READ_ADDR, 210 ARRAY_SIZE(address), address); 211 } 212 213 static int ziirave_firm_write_block_data(struct watchdog_device *wdd, 214 u8 command, u8 length, const u8 *data, 215 bool wait_for_ack) 216 { 217 struct i2c_client *client = to_i2c_client(wdd->parent); 218 int ret; 219 220 ret = i2c_smbus_write_block_data(client, command, length, data); 221 if (ret) { 222 dev_err(&client->dev, 223 "Failed to send command 0x%02x: %d\n", command, ret); 224 return ret; 225 } 226 227 if (wait_for_ack) 228 ret = ziirave_firm_wait_for_ack(wdd); 229 230 return ret; 231 } 232 233 static int ziirave_firm_write_byte(struct watchdog_device *wdd, u8 command, 234 u8 byte, bool wait_for_ack) 235 { 236 return ziirave_firm_write_block_data(wdd, command, 1, &byte, 237 wait_for_ack); 238 } 239 240 /* 241 * ziirave_firm_write_pkt() - Build and write a firmware packet 242 * 243 * A packet to send to the firmware is composed by following bytes: 244 * Length | Addr0 | Addr1 | Data0 .. Data15 | Checksum | 245 * Where, 246 * Length: A data byte containing the length of the data. 247 * Addr0: Low byte of the address. 248 * Addr1: High byte of the address. 249 * Data0 .. Data15: Array of 16 bytes of data. 250 * Checksum: Checksum byte to verify data integrity. 251 */ 252 static int ziirave_firm_write_pkt(struct watchdog_device *wdd, 253 const struct ihex_binrec *rec) 254 { 255 struct i2c_client *client = to_i2c_client(wdd->parent); 256 u8 i, checksum = 0, packet[ZIIRAVE_FIRM_PKT_TOTAL_SIZE]; 257 int ret; 258 u16 addr; 259 260 memset(packet, 0, ARRAY_SIZE(packet)); 261 262 /* Packet length */ 263 packet[0] = (u8)be16_to_cpu(rec->len); 264 /* Packet address */ 265 addr = (be32_to_cpu(rec->addr) & 0xffff) >> 1; 266 packet[1] = addr & 0xff; 267 packet[2] = (addr & 0xff00) >> 8; 268 269 /* Packet data */ 270 if (be16_to_cpu(rec->len) > ZIIRAVE_FIRM_PKT_DATA_SIZE) 271 return -EMSGSIZE; 272 memcpy(packet + 3, rec->data, be16_to_cpu(rec->len)); 273 274 /* Packet checksum */ 275 for (i = 0; i < ZIIRAVE_FIRM_PKT_TOTAL_SIZE - 1; i++) 276 checksum += packet[i]; 277 packet[ZIIRAVE_FIRM_PKT_TOTAL_SIZE - 1] = checksum; 278 279 ret = ziirave_firm_write_block_data(wdd, ZIIRAVE_CMD_DOWNLOAD_PACKET, 280 ARRAY_SIZE(packet), packet, true); 281 if (ret) 282 dev_err(&client->dev, 283 "Failed to write firmware packet at address 0x%04x: %d\n", 284 addr, ret); 285 286 return ret; 287 } 288 289 static int ziirave_firm_verify(struct watchdog_device *wdd, 290 const struct firmware *fw) 291 { 292 struct i2c_client *client = to_i2c_client(wdd->parent); 293 const struct ihex_binrec *rec; 294 int i, ret; 295 u8 data[ZIIRAVE_FIRM_PKT_DATA_SIZE]; 296 u16 addr; 297 298 for (rec = (void *)fw->data; rec; rec = ihex_next_binrec(rec)) { 299 /* Zero length marks end of records */ 300 if (!be16_to_cpu(rec->len)) 301 break; 302 303 addr = (be32_to_cpu(rec->addr) & 0xffff) >> 1; 304 if (addr < ZIIRAVE_FIRM_FLASH_MEMORY_START || 305 addr > ZIIRAVE_FIRM_FLASH_MEMORY_END) 306 continue; 307 308 ret = ziirave_firm_set_read_addr(wdd, addr); 309 if (ret) { 310 dev_err(&client->dev, 311 "Failed to send SET_READ_ADDR command: %d\n", 312 ret); 313 return ret; 314 } 315 316 for (i = 0; i < ARRAY_SIZE(data); i++) { 317 ret = i2c_smbus_read_byte_data(client, 318 ZIIRAVE_CMD_DOWNLOAD_READ_BYTE); 319 if (ret < 0) { 320 dev_err(&client->dev, 321 "Failed to READ DATA: %d\n", ret); 322 return ret; 323 } 324 data[i] = ret; 325 } 326 327 if (memcmp(data, rec->data, be16_to_cpu(rec->len))) { 328 dev_err(&client->dev, 329 "Firmware mismatch at address 0x%04x\n", addr); 330 return -EINVAL; 331 } 332 } 333 334 return 0; 335 } 336 337 static int ziirave_firm_upload(struct watchdog_device *wdd, 338 const struct firmware *fw) 339 { 340 struct i2c_client *client = to_i2c_client(wdd->parent); 341 int ret, words_till_page_break; 342 const struct ihex_binrec *rec; 343 struct ihex_binrec *rec_new; 344 345 ret = ziirave_firm_write_byte(wdd, ZIIRAVE_CMD_JUMP_TO_BOOTLOADER, 1, 346 false); 347 if (ret) 348 return ret; 349 350 msleep(500); 351 352 ret = ziirave_firm_write_byte(wdd, ZIIRAVE_CMD_DOWNLOAD_START, 1, true); 353 if (ret) 354 return ret; 355 356 msleep(500); 357 358 for (rec = (void *)fw->data; rec; rec = ihex_next_binrec(rec)) { 359 /* Zero length marks end of records */ 360 if (!be16_to_cpu(rec->len)) 361 break; 362 363 /* Check max data size */ 364 if (be16_to_cpu(rec->len) > ZIIRAVE_FIRM_PKT_DATA_SIZE) { 365 dev_err(&client->dev, "Firmware packet too long (%d)\n", 366 be16_to_cpu(rec->len)); 367 return -EMSGSIZE; 368 } 369 370 /* Calculate words till page break */ 371 words_till_page_break = (64 - ((be32_to_cpu(rec->addr) >> 1) & 372 0x3f)); 373 if ((be16_to_cpu(rec->len) >> 1) > words_till_page_break) { 374 /* 375 * Data in passes page boundary, so we need to split in 376 * two blocks of data. Create a packet with the first 377 * block of data. 378 */ 379 rec_new = kzalloc(sizeof(struct ihex_binrec) + 380 (words_till_page_break << 1), 381 GFP_KERNEL); 382 if (!rec_new) 383 return -ENOMEM; 384 385 rec_new->len = cpu_to_be16(words_till_page_break << 1); 386 rec_new->addr = rec->addr; 387 memcpy(rec_new->data, rec->data, 388 be16_to_cpu(rec_new->len)); 389 390 ret = ziirave_firm_write_pkt(wdd, rec_new); 391 kfree(rec_new); 392 if (ret) 393 return ret; 394 395 /* Create a packet with the second block of data */ 396 rec_new = kzalloc(sizeof(struct ihex_binrec) + 397 be16_to_cpu(rec->len) - 398 (words_till_page_break << 1), 399 GFP_KERNEL); 400 if (!rec_new) 401 return -ENOMEM; 402 403 /* Remaining bytes */ 404 rec_new->len = rec->len - 405 cpu_to_be16(words_till_page_break << 1); 406 407 rec_new->addr = cpu_to_be32(be32_to_cpu(rec->addr) + 408 (words_till_page_break << 1)); 409 410 memcpy(rec_new->data, 411 rec->data + (words_till_page_break << 1), 412 be16_to_cpu(rec_new->len)); 413 414 ret = ziirave_firm_write_pkt(wdd, rec_new); 415 kfree(rec_new); 416 if (ret) 417 return ret; 418 } else { 419 ret = ziirave_firm_write_pkt(wdd, rec); 420 if (ret) 421 return ret; 422 } 423 } 424 425 /* For end of download, the length field will be set to 0 */ 426 rec_new = kzalloc(sizeof(struct ihex_binrec) + 1, GFP_KERNEL); 427 if (!rec_new) 428 return -ENOMEM; 429 430 ret = ziirave_firm_write_pkt(wdd, rec_new); 431 kfree(rec_new); 432 if (ret) { 433 dev_err(&client->dev, "Failed to send EMPTY packet: %d\n", ret); 434 return ret; 435 } 436 437 /* This sleep seems to be required */ 438 msleep(20); 439 440 /* Start firmware verification */ 441 ret = ziirave_firm_verify(wdd, fw); 442 if (ret) { 443 dev_err(&client->dev, 444 "Failed to verify firmware: %d\n", ret); 445 return ret; 446 } 447 448 /* End download operation */ 449 ret = ziirave_firm_write_byte(wdd, ZIIRAVE_CMD_DOWNLOAD_END, 1, false); 450 if (ret) 451 return ret; 452 453 /* Reset the processor */ 454 ret = ziirave_firm_write_byte(wdd, ZIIRAVE_CMD_RESET_PROCESSOR, 1, 455 false); 456 if (ret) 457 return ret; 458 459 msleep(500); 460 461 return 0; 462 } 463 464 static const struct watchdog_info ziirave_wdt_info = { 465 .options = WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING, 466 .identity = "Zodiac RAVE Watchdog", 467 }; 468 469 static const struct watchdog_ops ziirave_wdt_ops = { 470 .owner = THIS_MODULE, 471 .start = ziirave_wdt_start, 472 .stop = ziirave_wdt_stop, 473 .ping = ziirave_wdt_ping, 474 .set_timeout = ziirave_wdt_set_timeout, 475 .get_timeleft = ziirave_wdt_get_timeleft, 476 }; 477 478 static ssize_t ziirave_wdt_sysfs_show_firm(struct device *dev, 479 struct device_attribute *attr, 480 char *buf) 481 { 482 struct i2c_client *client = to_i2c_client(dev->parent); 483 struct ziirave_wdt_data *w_priv = i2c_get_clientdata(client); 484 int ret; 485 486 ret = mutex_lock_interruptible(&w_priv->sysfs_mutex); 487 if (ret) 488 return ret; 489 490 ret = sprintf(buf, "02.%02u.%02u", w_priv->firmware_rev.major, 491 w_priv->firmware_rev.minor); 492 493 mutex_unlock(&w_priv->sysfs_mutex); 494 495 return ret; 496 } 497 498 static DEVICE_ATTR(firmware_version, S_IRUGO, ziirave_wdt_sysfs_show_firm, 499 NULL); 500 501 static ssize_t ziirave_wdt_sysfs_show_boot(struct device *dev, 502 struct device_attribute *attr, 503 char *buf) 504 { 505 struct i2c_client *client = to_i2c_client(dev->parent); 506 struct ziirave_wdt_data *w_priv = i2c_get_clientdata(client); 507 int ret; 508 509 ret = mutex_lock_interruptible(&w_priv->sysfs_mutex); 510 if (ret) 511 return ret; 512 513 ret = sprintf(buf, "01.%02u.%02u", w_priv->bootloader_rev.major, 514 w_priv->bootloader_rev.minor); 515 516 mutex_unlock(&w_priv->sysfs_mutex); 517 518 return ret; 519 } 520 521 static DEVICE_ATTR(bootloader_version, S_IRUGO, ziirave_wdt_sysfs_show_boot, 522 NULL); 523 524 static ssize_t ziirave_wdt_sysfs_show_reason(struct device *dev, 525 struct device_attribute *attr, 526 char *buf) 527 { 528 struct i2c_client *client = to_i2c_client(dev->parent); 529 struct ziirave_wdt_data *w_priv = i2c_get_clientdata(client); 530 int ret; 531 532 ret = mutex_lock_interruptible(&w_priv->sysfs_mutex); 533 if (ret) 534 return ret; 535 536 ret = sprintf(buf, "%s", ziirave_reasons[w_priv->reset_reason]); 537 538 mutex_unlock(&w_priv->sysfs_mutex); 539 540 return ret; 541 } 542 543 static DEVICE_ATTR(reset_reason, S_IRUGO, ziirave_wdt_sysfs_show_reason, 544 NULL); 545 546 static ssize_t ziirave_wdt_sysfs_store_firm(struct device *dev, 547 struct device_attribute *attr, 548 const char *buf, size_t count) 549 { 550 struct i2c_client *client = to_i2c_client(dev->parent); 551 struct ziirave_wdt_data *w_priv = i2c_get_clientdata(client); 552 const struct firmware *fw; 553 int err; 554 555 err = request_ihex_firmware(&fw, ZIIRAVE_FW_NAME, dev); 556 if (err) { 557 dev_err(&client->dev, "Failed to request ihex firmware\n"); 558 return err; 559 } 560 561 err = mutex_lock_interruptible(&w_priv->sysfs_mutex); 562 if (err) 563 goto release_firmware; 564 565 err = ziirave_firm_upload(&w_priv->wdd, fw); 566 if (err) { 567 dev_err(&client->dev, "The firmware update failed: %d\n", err); 568 goto unlock_mutex; 569 } 570 571 /* Update firmware version */ 572 err = ziirave_wdt_revision(client, &w_priv->firmware_rev, 573 ZIIRAVE_WDT_FIRM_VER_MAJOR); 574 if (err) { 575 dev_err(&client->dev, "Failed to read firmware version: %d\n", 576 err); 577 goto unlock_mutex; 578 } 579 580 dev_info(&client->dev, "Firmware updated to version 02.%02u.%02u\n", 581 w_priv->firmware_rev.major, w_priv->firmware_rev.minor); 582 583 /* Restore the watchdog timeout */ 584 err = ziirave_wdt_set_timeout(&w_priv->wdd, w_priv->wdd.timeout); 585 if (err) 586 dev_err(&client->dev, "Failed to set timeout: %d\n", err); 587 588 unlock_mutex: 589 mutex_unlock(&w_priv->sysfs_mutex); 590 591 release_firmware: 592 release_firmware(fw); 593 594 return err ? err : count; 595 } 596 597 static DEVICE_ATTR(update_firmware, S_IWUSR, NULL, 598 ziirave_wdt_sysfs_store_firm); 599 600 static struct attribute *ziirave_wdt_attrs[] = { 601 &dev_attr_firmware_version.attr, 602 &dev_attr_bootloader_version.attr, 603 &dev_attr_reset_reason.attr, 604 &dev_attr_update_firmware.attr, 605 NULL 606 }; 607 ATTRIBUTE_GROUPS(ziirave_wdt); 608 609 static int ziirave_wdt_init_duration(struct i2c_client *client) 610 { 611 int ret; 612 613 if (!reset_duration) { 614 /* See if the reset pulse duration is provided in an of_node */ 615 if (!client->dev.of_node) 616 ret = -ENODEV; 617 else 618 ret = of_property_read_u32(client->dev.of_node, 619 "reset-duration-ms", 620 &reset_duration); 621 if (ret) { 622 dev_info(&client->dev, 623 "Unable to set reset pulse duration, using default\n"); 624 return 0; 625 } 626 } 627 628 if (reset_duration < 1 || reset_duration > 255) 629 return -EINVAL; 630 631 dev_info(&client->dev, "Setting reset duration to %dms", 632 reset_duration); 633 634 return i2c_smbus_write_byte_data(client, ZIIRAVE_WDT_RESET_DURATION, 635 reset_duration); 636 } 637 638 static int ziirave_wdt_probe(struct i2c_client *client, 639 const struct i2c_device_id *id) 640 { 641 int ret; 642 struct ziirave_wdt_data *w_priv; 643 int val; 644 645 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 646 return -ENODEV; 647 648 w_priv = devm_kzalloc(&client->dev, sizeof(*w_priv), GFP_KERNEL); 649 if (!w_priv) 650 return -ENOMEM; 651 652 mutex_init(&w_priv->sysfs_mutex); 653 654 w_priv->wdd.info = &ziirave_wdt_info; 655 w_priv->wdd.ops = &ziirave_wdt_ops; 656 w_priv->wdd.min_timeout = ZIIRAVE_TIMEOUT_MIN; 657 w_priv->wdd.max_timeout = ZIIRAVE_TIMEOUT_MAX; 658 w_priv->wdd.parent = &client->dev; 659 w_priv->wdd.groups = ziirave_wdt_groups; 660 661 ret = watchdog_init_timeout(&w_priv->wdd, wdt_timeout, &client->dev); 662 if (ret) { 663 dev_info(&client->dev, 664 "Unable to select timeout value, using default\n"); 665 } 666 667 /* 668 * The default value set in the watchdog should be perfectly valid, so 669 * pass that in if we haven't provided one via the module parameter or 670 * of property. 671 */ 672 if (w_priv->wdd.timeout == 0) { 673 val = i2c_smbus_read_byte_data(client, ZIIRAVE_WDT_TIMEOUT); 674 if (val < 0) 675 return val; 676 677 if (val < ZIIRAVE_TIMEOUT_MIN) 678 return -ENODEV; 679 680 w_priv->wdd.timeout = val; 681 } else { 682 ret = ziirave_wdt_set_timeout(&w_priv->wdd, 683 w_priv->wdd.timeout); 684 if (ret) 685 return ret; 686 687 dev_info(&client->dev, "Timeout set to %ds.", 688 w_priv->wdd.timeout); 689 } 690 691 watchdog_set_nowayout(&w_priv->wdd, nowayout); 692 693 i2c_set_clientdata(client, w_priv); 694 695 /* If in unconfigured state, set to stopped */ 696 val = i2c_smbus_read_byte_data(client, ZIIRAVE_WDT_STATE); 697 if (val < 0) 698 return val; 699 700 if (val == ZIIRAVE_STATE_INITIAL) 701 ziirave_wdt_stop(&w_priv->wdd); 702 703 ret = ziirave_wdt_init_duration(client); 704 if (ret) 705 return ret; 706 707 ret = ziirave_wdt_revision(client, &w_priv->firmware_rev, 708 ZIIRAVE_WDT_FIRM_VER_MAJOR); 709 if (ret) 710 return ret; 711 712 ret = ziirave_wdt_revision(client, &w_priv->bootloader_rev, 713 ZIIRAVE_WDT_BOOT_VER_MAJOR); 714 if (ret) 715 return ret; 716 717 w_priv->reset_reason = i2c_smbus_read_byte_data(client, 718 ZIIRAVE_WDT_RESET_REASON); 719 if (w_priv->reset_reason < 0) 720 return w_priv->reset_reason; 721 722 if (w_priv->reset_reason >= ARRAY_SIZE(ziirave_reasons) || 723 !ziirave_reasons[w_priv->reset_reason]) 724 return -ENODEV; 725 726 ret = watchdog_register_device(&w_priv->wdd); 727 728 return ret; 729 } 730 731 static int ziirave_wdt_remove(struct i2c_client *client) 732 { 733 struct ziirave_wdt_data *w_priv = i2c_get_clientdata(client); 734 735 watchdog_unregister_device(&w_priv->wdd); 736 737 return 0; 738 } 739 740 static const struct i2c_device_id ziirave_wdt_id[] = { 741 { "rave-wdt", 0 }, 742 { } 743 }; 744 MODULE_DEVICE_TABLE(i2c, ziirave_wdt_id); 745 746 static const struct of_device_id zrv_wdt_of_match[] = { 747 { .compatible = "zii,rave-wdt", }, 748 { }, 749 }; 750 MODULE_DEVICE_TABLE(of, zrv_wdt_of_match); 751 752 static struct i2c_driver ziirave_wdt_driver = { 753 .driver = { 754 .name = "ziirave_wdt", 755 .of_match_table = zrv_wdt_of_match, 756 }, 757 .probe = ziirave_wdt_probe, 758 .remove = ziirave_wdt_remove, 759 .id_table = ziirave_wdt_id, 760 }; 761 762 module_i2c_driver(ziirave_wdt_driver); 763 764 MODULE_AUTHOR("Martyn Welch <martyn.welch@collabora.co.uk"); 765 MODULE_DESCRIPTION("Zodiac Aerospace RAVE Switch Watchdog Processor Driver"); 766 MODULE_LICENSE("GPL"); 767