1 /* 2 Copyright (c) 2001,2002 Christer Weinigel <wingel@nano-system.com> 3 4 National Semiconductor SCx200 ACCESS.bus support 5 Also supports the AMD CS5535 and AMD CS5536 6 7 Based on i2c-keywest.c which is: 8 Copyright (c) 2001 Benjamin Herrenschmidt <benh@kernel.crashing.org> 9 Copyright (c) 2000 Philip Edelbrock <phil@stimpy.netroedge.com> 10 11 This program is free software; you can redistribute it and/or 12 modify it under the terms of the GNU General Public License as 13 published by the Free Software Foundation; either version 2 of the 14 License, or (at your option) any later version. 15 16 This program is distributed in the hope that it will be useful, 17 but WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 General Public License for more details. 20 */ 21 22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 23 24 #include <linux/module.h> 25 #include <linux/errno.h> 26 #include <linux/kernel.h> 27 #include <linux/init.h> 28 #include <linux/i2c.h> 29 #include <linux/pci.h> 30 #include <linux/platform_device.h> 31 #include <linux/delay.h> 32 #include <linux/mutex.h> 33 #include <linux/slab.h> 34 #include <linux/io.h> 35 36 #include <linux/scx200.h> 37 38 MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>"); 39 MODULE_DESCRIPTION("NatSemi SCx200 ACCESS.bus Driver"); 40 MODULE_ALIAS("platform:cs5535-smb"); 41 MODULE_LICENSE("GPL"); 42 43 #define MAX_DEVICES 4 44 static int base[MAX_DEVICES] = { 0x820, 0x840 }; 45 module_param_array(base, int, NULL, 0); 46 MODULE_PARM_DESC(base, "Base addresses for the ACCESS.bus controllers"); 47 48 #define POLL_TIMEOUT (HZ/5) 49 50 enum scx200_acb_state { 51 state_idle, 52 state_address, 53 state_command, 54 state_repeat_start, 55 state_quick, 56 state_read, 57 state_write, 58 }; 59 60 static const char *scx200_acb_state_name[] = { 61 "idle", 62 "address", 63 "command", 64 "repeat_start", 65 "quick", 66 "read", 67 "write", 68 }; 69 70 /* Physical interface */ 71 struct scx200_acb_iface { 72 struct scx200_acb_iface *next; 73 struct i2c_adapter adapter; 74 unsigned base; 75 struct mutex mutex; 76 77 /* State machine data */ 78 enum scx200_acb_state state; 79 int result; 80 u8 address_byte; 81 u8 command; 82 u8 *ptr; 83 char needs_reset; 84 unsigned len; 85 }; 86 87 /* Register Definitions */ 88 #define ACBSDA (iface->base + 0) 89 #define ACBST (iface->base + 1) 90 #define ACBST_SDAST 0x40 /* SDA Status */ 91 #define ACBST_BER 0x20 92 #define ACBST_NEGACK 0x10 /* Negative Acknowledge */ 93 #define ACBST_STASTR 0x08 /* Stall After Start */ 94 #define ACBST_MASTER 0x02 95 #define ACBCST (iface->base + 2) 96 #define ACBCST_BB 0x02 97 #define ACBCTL1 (iface->base + 3) 98 #define ACBCTL1_STASTRE 0x80 99 #define ACBCTL1_NMINTE 0x40 100 #define ACBCTL1_ACK 0x10 101 #define ACBCTL1_STOP 0x02 102 #define ACBCTL1_START 0x01 103 #define ACBADDR (iface->base + 4) 104 #define ACBCTL2 (iface->base + 5) 105 #define ACBCTL2_ENABLE 0x01 106 107 /************************************************************************/ 108 109 static void scx200_acb_machine(struct scx200_acb_iface *iface, u8 status) 110 { 111 const char *errmsg; 112 113 dev_dbg(&iface->adapter.dev, "state %s, status = 0x%02x\n", 114 scx200_acb_state_name[iface->state], status); 115 116 if (status & ACBST_BER) { 117 errmsg = "bus error"; 118 goto error; 119 } 120 if (!(status & ACBST_MASTER)) { 121 errmsg = "not master"; 122 goto error; 123 } 124 if (status & ACBST_NEGACK) { 125 dev_dbg(&iface->adapter.dev, "negative ack in state %s\n", 126 scx200_acb_state_name[iface->state]); 127 128 iface->state = state_idle; 129 iface->result = -ENXIO; 130 131 outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1); 132 outb(ACBST_STASTR | ACBST_NEGACK, ACBST); 133 134 /* Reset the status register */ 135 outb(0, ACBST); 136 return; 137 } 138 139 switch (iface->state) { 140 case state_idle: 141 dev_warn(&iface->adapter.dev, "interrupt in idle state\n"); 142 break; 143 144 case state_address: 145 /* Do a pointer write first */ 146 outb(iface->address_byte & ~1, ACBSDA); 147 148 iface->state = state_command; 149 break; 150 151 case state_command: 152 outb(iface->command, ACBSDA); 153 154 if (iface->address_byte & 1) 155 iface->state = state_repeat_start; 156 else 157 iface->state = state_write; 158 break; 159 160 case state_repeat_start: 161 outb(inb(ACBCTL1) | ACBCTL1_START, ACBCTL1); 162 /* fallthrough */ 163 164 case state_quick: 165 if (iface->address_byte & 1) { 166 if (iface->len == 1) 167 outb(inb(ACBCTL1) | ACBCTL1_ACK, ACBCTL1); 168 else 169 outb(inb(ACBCTL1) & ~ACBCTL1_ACK, ACBCTL1); 170 outb(iface->address_byte, ACBSDA); 171 172 iface->state = state_read; 173 } else { 174 outb(iface->address_byte, ACBSDA); 175 176 iface->state = state_write; 177 } 178 break; 179 180 case state_read: 181 /* Set ACK if _next_ byte will be the last one */ 182 if (iface->len == 2) 183 outb(inb(ACBCTL1) | ACBCTL1_ACK, ACBCTL1); 184 else 185 outb(inb(ACBCTL1) & ~ACBCTL1_ACK, ACBCTL1); 186 187 if (iface->len == 1) { 188 iface->result = 0; 189 iface->state = state_idle; 190 outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1); 191 } 192 193 *iface->ptr++ = inb(ACBSDA); 194 --iface->len; 195 196 break; 197 198 case state_write: 199 if (iface->len == 0) { 200 iface->result = 0; 201 iface->state = state_idle; 202 outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1); 203 break; 204 } 205 206 outb(*iface->ptr++, ACBSDA); 207 --iface->len; 208 209 break; 210 } 211 212 return; 213 214 error: 215 dev_err(&iface->adapter.dev, 216 "%s in state %s (addr=0x%02x, len=%d, status=0x%02x)\n", errmsg, 217 scx200_acb_state_name[iface->state], iface->address_byte, 218 iface->len, status); 219 220 iface->state = state_idle; 221 iface->result = -EIO; 222 iface->needs_reset = 1; 223 } 224 225 static void scx200_acb_poll(struct scx200_acb_iface *iface) 226 { 227 u8 status; 228 unsigned long timeout; 229 230 timeout = jiffies + POLL_TIMEOUT; 231 while (1) { 232 status = inb(ACBST); 233 234 /* Reset the status register to avoid the hang */ 235 outb(0, ACBST); 236 237 if ((status & (ACBST_SDAST|ACBST_BER|ACBST_NEGACK)) != 0) { 238 scx200_acb_machine(iface, status); 239 return; 240 } 241 if (time_after(jiffies, timeout)) 242 break; 243 cpu_relax(); 244 cond_resched(); 245 } 246 247 dev_err(&iface->adapter.dev, "timeout in state %s\n", 248 scx200_acb_state_name[iface->state]); 249 250 iface->state = state_idle; 251 iface->result = -EIO; 252 iface->needs_reset = 1; 253 } 254 255 static void scx200_acb_reset(struct scx200_acb_iface *iface) 256 { 257 /* Disable the ACCESS.bus device and Configure the SCL 258 frequency: 16 clock cycles */ 259 outb(0x70, ACBCTL2); 260 /* Polling mode */ 261 outb(0, ACBCTL1); 262 /* Disable slave address */ 263 outb(0, ACBADDR); 264 /* Enable the ACCESS.bus device */ 265 outb(inb(ACBCTL2) | ACBCTL2_ENABLE, ACBCTL2); 266 /* Free STALL after START */ 267 outb(inb(ACBCTL1) & ~(ACBCTL1_STASTRE | ACBCTL1_NMINTE), ACBCTL1); 268 /* Send a STOP */ 269 outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1); 270 /* Clear BER, NEGACK and STASTR bits */ 271 outb(ACBST_BER | ACBST_NEGACK | ACBST_STASTR, ACBST); 272 /* Clear BB bit */ 273 outb(inb(ACBCST) | ACBCST_BB, ACBCST); 274 } 275 276 static s32 scx200_acb_smbus_xfer(struct i2c_adapter *adapter, 277 u16 address, unsigned short flags, 278 char rw, u8 command, int size, 279 union i2c_smbus_data *data) 280 { 281 struct scx200_acb_iface *iface = i2c_get_adapdata(adapter); 282 int len; 283 u8 *buffer; 284 u16 cur_word; 285 int rc; 286 287 switch (size) { 288 case I2C_SMBUS_QUICK: 289 len = 0; 290 buffer = NULL; 291 break; 292 293 case I2C_SMBUS_BYTE: 294 len = 1; 295 buffer = rw ? &data->byte : &command; 296 break; 297 298 case I2C_SMBUS_BYTE_DATA: 299 len = 1; 300 buffer = &data->byte; 301 break; 302 303 case I2C_SMBUS_WORD_DATA: 304 len = 2; 305 cur_word = cpu_to_le16(data->word); 306 buffer = (u8 *)&cur_word; 307 break; 308 309 case I2C_SMBUS_I2C_BLOCK_DATA: 310 len = data->block[0]; 311 if (len == 0 || len > I2C_SMBUS_BLOCK_MAX) 312 return -EINVAL; 313 buffer = &data->block[1]; 314 break; 315 316 default: 317 return -EINVAL; 318 } 319 320 dev_dbg(&adapter->dev, 321 "size=%d, address=0x%x, command=0x%x, len=%d, read=%d\n", 322 size, address, command, len, rw); 323 324 if (!len && rw == I2C_SMBUS_READ) { 325 dev_dbg(&adapter->dev, "zero length read\n"); 326 return -EINVAL; 327 } 328 329 mutex_lock(&iface->mutex); 330 331 iface->address_byte = (address << 1) | rw; 332 iface->command = command; 333 iface->ptr = buffer; 334 iface->len = len; 335 iface->result = -EINVAL; 336 iface->needs_reset = 0; 337 338 outb(inb(ACBCTL1) | ACBCTL1_START, ACBCTL1); 339 340 if (size == I2C_SMBUS_QUICK || size == I2C_SMBUS_BYTE) 341 iface->state = state_quick; 342 else 343 iface->state = state_address; 344 345 while (iface->state != state_idle) 346 scx200_acb_poll(iface); 347 348 if (iface->needs_reset) 349 scx200_acb_reset(iface); 350 351 rc = iface->result; 352 353 mutex_unlock(&iface->mutex); 354 355 if (rc == 0 && size == I2C_SMBUS_WORD_DATA && rw == I2C_SMBUS_READ) 356 data->word = le16_to_cpu(cur_word); 357 358 #ifdef DEBUG 359 dev_dbg(&adapter->dev, "transfer done, result: %d", rc); 360 if (buffer) { 361 int i; 362 printk(" data:"); 363 for (i = 0; i < len; ++i) 364 printk(" %02x", buffer[i]); 365 } 366 printk("\n"); 367 #endif 368 369 return rc; 370 } 371 372 static u32 scx200_acb_func(struct i2c_adapter *adapter) 373 { 374 return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | 375 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA | 376 I2C_FUNC_SMBUS_I2C_BLOCK; 377 } 378 379 /* For now, we only handle combined mode (smbus) */ 380 static const struct i2c_algorithm scx200_acb_algorithm = { 381 .smbus_xfer = scx200_acb_smbus_xfer, 382 .functionality = scx200_acb_func, 383 }; 384 385 static struct scx200_acb_iface *scx200_acb_list; 386 static DEFINE_MUTEX(scx200_acb_list_mutex); 387 388 static int scx200_acb_probe(struct scx200_acb_iface *iface) 389 { 390 u8 val; 391 392 /* Disable the ACCESS.bus device and Configure the SCL 393 frequency: 16 clock cycles */ 394 outb(0x70, ACBCTL2); 395 396 if (inb(ACBCTL2) != 0x70) { 397 pr_debug("ACBCTL2 readback failed\n"); 398 return -ENXIO; 399 } 400 401 outb(inb(ACBCTL1) | ACBCTL1_NMINTE, ACBCTL1); 402 403 val = inb(ACBCTL1); 404 if (val) { 405 pr_debug("disabled, but ACBCTL1=0x%02x\n", val); 406 return -ENXIO; 407 } 408 409 outb(inb(ACBCTL2) | ACBCTL2_ENABLE, ACBCTL2); 410 411 outb(inb(ACBCTL1) | ACBCTL1_NMINTE, ACBCTL1); 412 413 val = inb(ACBCTL1); 414 if ((val & ACBCTL1_NMINTE) != ACBCTL1_NMINTE) { 415 pr_debug("enabled, but NMINTE won't be set, ACBCTL1=0x%02x\n", 416 val); 417 return -ENXIO; 418 } 419 420 return 0; 421 } 422 423 static struct scx200_acb_iface *scx200_create_iface(const char *text, 424 struct device *dev, int index) 425 { 426 struct scx200_acb_iface *iface; 427 struct i2c_adapter *adapter; 428 429 iface = kzalloc(sizeof(*iface), GFP_KERNEL); 430 if (!iface) 431 return NULL; 432 433 adapter = &iface->adapter; 434 i2c_set_adapdata(adapter, iface); 435 snprintf(adapter->name, sizeof(adapter->name), "%s ACB%d", text, index); 436 adapter->owner = THIS_MODULE; 437 adapter->algo = &scx200_acb_algorithm; 438 adapter->class = I2C_CLASS_HWMON | I2C_CLASS_SPD; 439 adapter->dev.parent = dev; 440 441 mutex_init(&iface->mutex); 442 443 return iface; 444 } 445 446 static int scx200_acb_create(struct scx200_acb_iface *iface) 447 { 448 struct i2c_adapter *adapter; 449 int rc; 450 451 adapter = &iface->adapter; 452 453 rc = scx200_acb_probe(iface); 454 if (rc) { 455 pr_warn("probe failed\n"); 456 return rc; 457 } 458 459 scx200_acb_reset(iface); 460 461 if (i2c_add_adapter(adapter) < 0) { 462 pr_err("failed to register\n"); 463 return -ENODEV; 464 } 465 466 if (!adapter->dev.parent) { 467 /* If there's no dev, we're tracking (ISA) ifaces manually */ 468 mutex_lock(&scx200_acb_list_mutex); 469 iface->next = scx200_acb_list; 470 scx200_acb_list = iface; 471 mutex_unlock(&scx200_acb_list_mutex); 472 } 473 474 return 0; 475 } 476 477 static struct scx200_acb_iface *scx200_create_dev(const char *text, 478 unsigned long base, int index, struct device *dev) 479 { 480 struct scx200_acb_iface *iface; 481 int rc; 482 483 iface = scx200_create_iface(text, dev, index); 484 485 if (iface == NULL) 486 return NULL; 487 488 if (!request_region(base, 8, iface->adapter.name)) { 489 pr_err("can't allocate io 0x%lx-0x%lx\n", base, base + 8 - 1); 490 goto errout_free; 491 } 492 493 iface->base = base; 494 rc = scx200_acb_create(iface); 495 496 if (rc == 0) 497 return iface; 498 499 release_region(base, 8); 500 errout_free: 501 kfree(iface); 502 return NULL; 503 } 504 505 static int scx200_probe(struct platform_device *pdev) 506 { 507 struct scx200_acb_iface *iface; 508 struct resource *res; 509 510 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 511 if (!res) { 512 dev_err(&pdev->dev, "can't fetch device resource info\n"); 513 return -ENODEV; 514 } 515 516 iface = scx200_create_dev("CS5535", res->start, 0, &pdev->dev); 517 if (!iface) 518 return -EIO; 519 520 dev_info(&pdev->dev, "SCx200 device '%s' registered\n", 521 iface->adapter.name); 522 platform_set_drvdata(pdev, iface); 523 524 return 0; 525 } 526 527 static void scx200_cleanup_iface(struct scx200_acb_iface *iface) 528 { 529 i2c_del_adapter(&iface->adapter); 530 release_region(iface->base, 8); 531 kfree(iface); 532 } 533 534 static int scx200_remove(struct platform_device *pdev) 535 { 536 struct scx200_acb_iface *iface; 537 538 iface = platform_get_drvdata(pdev); 539 scx200_cleanup_iface(iface); 540 541 return 0; 542 } 543 544 static struct platform_driver scx200_pci_driver = { 545 .driver = { 546 .name = "cs5535-smb", 547 }, 548 .probe = scx200_probe, 549 .remove = scx200_remove, 550 }; 551 552 static const struct pci_device_id scx200_isa[] = { 553 { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_BRIDGE) }, 554 { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SC1100_BRIDGE) }, 555 { 0, } 556 }; 557 558 static __init void scx200_scan_isa(void) 559 { 560 int i; 561 562 if (!pci_dev_present(scx200_isa)) 563 return; 564 565 for (i = 0; i < MAX_DEVICES; ++i) { 566 if (base[i] == 0) 567 continue; 568 569 /* XXX: should we care about failures? */ 570 scx200_create_dev("SCx200", base[i], i, NULL); 571 } 572 } 573 574 static int __init scx200_acb_init(void) 575 { 576 pr_debug("NatSemi SCx200 ACCESS.bus Driver\n"); 577 578 /* First scan for ISA-based devices */ 579 scx200_scan_isa(); /* XXX: should we care about errors? */ 580 581 /* If at least one bus was created, init must succeed */ 582 if (scx200_acb_list) 583 return 0; 584 585 /* No ISA devices; register the platform driver for PCI-based devices */ 586 return platform_driver_register(&scx200_pci_driver); 587 } 588 589 static void __exit scx200_acb_cleanup(void) 590 { 591 struct scx200_acb_iface *iface; 592 593 platform_driver_unregister(&scx200_pci_driver); 594 595 mutex_lock(&scx200_acb_list_mutex); 596 while ((iface = scx200_acb_list) != NULL) { 597 scx200_acb_list = iface->next; 598 mutex_unlock(&scx200_acb_list_mutex); 599 600 scx200_cleanup_iface(iface); 601 602 mutex_lock(&scx200_acb_list_mutex); 603 } 604 mutex_unlock(&scx200_acb_list_mutex); 605 } 606 607 module_init(scx200_acb_init); 608 module_exit(scx200_acb_cleanup); 609