1 /* $Id: bbc_i2c.c,v 1.2 2001/04/02 09:59:08 davem Exp $ 2 * bbc_i2c.c: I2C low-level driver for BBC device on UltraSPARC-III 3 * platforms. 4 * 5 * Copyright (C) 2001 David S. Miller (davem@redhat.com) 6 */ 7 8 #include <linux/module.h> 9 #include <linux/kernel.h> 10 #include <linux/types.h> 11 #include <linux/slab.h> 12 #include <linux/sched.h> 13 #include <linux/wait.h> 14 #include <linux/delay.h> 15 #include <linux/init.h> 16 #include <linux/interrupt.h> 17 #include <asm/oplib.h> 18 #include <asm/ebus.h> 19 #include <asm/spitfire.h> 20 #include <asm/bbc.h> 21 #include <asm/io.h> 22 23 #include "bbc_i2c.h" 24 25 /* Convert this driver to use i2c bus layer someday... */ 26 #define I2C_PCF_PIN 0x80 27 #define I2C_PCF_ESO 0x40 28 #define I2C_PCF_ES1 0x20 29 #define I2C_PCF_ES2 0x10 30 #define I2C_PCF_ENI 0x08 31 #define I2C_PCF_STA 0x04 32 #define I2C_PCF_STO 0x02 33 #define I2C_PCF_ACK 0x01 34 35 #define I2C_PCF_START (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_ENI | I2C_PCF_STA | I2C_PCF_ACK) 36 #define I2C_PCF_STOP (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_STO | I2C_PCF_ACK) 37 #define I2C_PCF_REPSTART ( I2C_PCF_ESO | I2C_PCF_STA | I2C_PCF_ACK) 38 #define I2C_PCF_IDLE (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_ACK) 39 40 #define I2C_PCF_INI 0x40 /* 1 if not initialized */ 41 #define I2C_PCF_STS 0x20 42 #define I2C_PCF_BER 0x10 43 #define I2C_PCF_AD0 0x08 44 #define I2C_PCF_LRB 0x08 45 #define I2C_PCF_AAS 0x04 46 #define I2C_PCF_LAB 0x02 47 #define I2C_PCF_BB 0x01 48 49 /* The BBC devices have two I2C controllers. The first I2C controller 50 * connects mainly to configuration proms (NVRAM, cpu configuration, 51 * dimm types, etc.). Whereas the second I2C controller connects to 52 * environmental control devices such as fans and temperature sensors. 53 * The second controller also connects to the smartcard reader, if present. 54 */ 55 56 #define NUM_CHILDREN 8 57 struct bbc_i2c_bus { 58 struct bbc_i2c_bus *next; 59 int index; 60 spinlock_t lock; 61 void __iomem *i2c_bussel_reg; 62 void __iomem *i2c_control_regs; 63 unsigned char own, clock; 64 65 wait_queue_head_t wq; 66 volatile int waiting; 67 68 struct linux_ebus_device *bus_edev; 69 struct { 70 struct linux_ebus_child *device; 71 int client_claimed; 72 } devs[NUM_CHILDREN]; 73 }; 74 75 static struct bbc_i2c_bus *all_bbc_i2c; 76 77 struct bbc_i2c_client { 78 struct bbc_i2c_bus *bp; 79 struct linux_ebus_child *echild; 80 int bus; 81 int address; 82 }; 83 84 static int find_device(struct bbc_i2c_bus *bp, struct linux_ebus_child *echild) 85 { 86 int i; 87 88 for (i = 0; i < NUM_CHILDREN; i++) { 89 if (bp->devs[i].device == echild) { 90 if (bp->devs[i].client_claimed) 91 return 0; 92 return 1; 93 } 94 } 95 return 0; 96 } 97 98 static void set_device_claimage(struct bbc_i2c_bus *bp, struct linux_ebus_child *echild, int val) 99 { 100 int i; 101 102 for (i = 0; i < NUM_CHILDREN; i++) { 103 if (bp->devs[i].device == echild) { 104 bp->devs[i].client_claimed = val; 105 return; 106 } 107 } 108 } 109 110 #define claim_device(BP,ECHILD) set_device_claimage(BP,ECHILD,1) 111 #define release_device(BP,ECHILD) set_device_claimage(BP,ECHILD,0) 112 113 static struct bbc_i2c_bus *find_bus_for_device(struct linux_ebus_child *echild) 114 { 115 struct bbc_i2c_bus *bp = all_bbc_i2c; 116 117 while (bp != NULL) { 118 if (find_device(bp, echild) != 0) 119 break; 120 bp = bp->next; 121 } 122 123 return bp; 124 } 125 126 struct linux_ebus_child *bbc_i2c_getdev(int index) 127 { 128 struct bbc_i2c_bus *bp = all_bbc_i2c; 129 struct linux_ebus_child *echild = NULL; 130 int curidx = 0; 131 132 while (bp != NULL) { 133 struct bbc_i2c_bus *next = bp->next; 134 int i; 135 136 for (i = 0; i < NUM_CHILDREN; i++) { 137 if (!(echild = bp->devs[i].device)) 138 break; 139 if (curidx == index) 140 goto out; 141 echild = NULL; 142 curidx++; 143 } 144 bp = next; 145 } 146 out: 147 if (curidx == index) 148 return echild; 149 return NULL; 150 } 151 152 struct bbc_i2c_client *bbc_i2c_attach(struct linux_ebus_child *echild) 153 { 154 struct bbc_i2c_bus *bp = find_bus_for_device(echild); 155 struct bbc_i2c_client *client; 156 157 if (!bp) 158 return NULL; 159 client = kzalloc(sizeof(*client), GFP_KERNEL); 160 if (!client) 161 return NULL; 162 client->bp = bp; 163 client->echild = echild; 164 client->bus = echild->resource[0].start; 165 client->address = echild->resource[1].start; 166 167 claim_device(bp, echild); 168 169 return client; 170 } 171 172 void bbc_i2c_detach(struct bbc_i2c_client *client) 173 { 174 struct bbc_i2c_bus *bp = client->bp; 175 struct linux_ebus_child *echild = client->echild; 176 177 release_device(bp, echild); 178 kfree(client); 179 } 180 181 static int wait_for_pin(struct bbc_i2c_bus *bp, u8 *status) 182 { 183 DECLARE_WAITQUEUE(wait, current); 184 int limit = 32; 185 int ret = 1; 186 187 bp->waiting = 1; 188 add_wait_queue(&bp->wq, &wait); 189 while (limit-- > 0) { 190 unsigned long val; 191 192 val = wait_event_interruptible_timeout( 193 bp->wq, 194 (((*status = readb(bp->i2c_control_regs + 0)) 195 & I2C_PCF_PIN) == 0), 196 msecs_to_jiffies(250)); 197 if (val > 0) { 198 ret = 0; 199 break; 200 } 201 } 202 remove_wait_queue(&bp->wq, &wait); 203 bp->waiting = 0; 204 205 return ret; 206 } 207 208 int bbc_i2c_writeb(struct bbc_i2c_client *client, unsigned char val, int off) 209 { 210 struct bbc_i2c_bus *bp = client->bp; 211 int address = client->address; 212 u8 status; 213 int ret = -1; 214 215 if (bp->i2c_bussel_reg != NULL) 216 writeb(client->bus, bp->i2c_bussel_reg); 217 218 writeb(address, bp->i2c_control_regs + 0x1); 219 writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0); 220 if (wait_for_pin(bp, &status)) 221 goto out; 222 223 writeb(off, bp->i2c_control_regs + 0x1); 224 if (wait_for_pin(bp, &status) || 225 (status & I2C_PCF_LRB) != 0) 226 goto out; 227 228 writeb(val, bp->i2c_control_regs + 0x1); 229 if (wait_for_pin(bp, &status)) 230 goto out; 231 232 ret = 0; 233 234 out: 235 writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0); 236 return ret; 237 } 238 239 int bbc_i2c_readb(struct bbc_i2c_client *client, unsigned char *byte, int off) 240 { 241 struct bbc_i2c_bus *bp = client->bp; 242 unsigned char address = client->address, status; 243 int ret = -1; 244 245 if (bp->i2c_bussel_reg != NULL) 246 writeb(client->bus, bp->i2c_bussel_reg); 247 248 writeb(address, bp->i2c_control_regs + 0x1); 249 writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0); 250 if (wait_for_pin(bp, &status)) 251 goto out; 252 253 writeb(off, bp->i2c_control_regs + 0x1); 254 if (wait_for_pin(bp, &status) || 255 (status & I2C_PCF_LRB) != 0) 256 goto out; 257 258 writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0); 259 260 address |= 0x1; /* READ */ 261 262 writeb(address, bp->i2c_control_regs + 0x1); 263 writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0); 264 if (wait_for_pin(bp, &status)) 265 goto out; 266 267 /* Set PIN back to one so the device sends the first 268 * byte. 269 */ 270 (void) readb(bp->i2c_control_regs + 0x1); 271 if (wait_for_pin(bp, &status)) 272 goto out; 273 274 writeb(I2C_PCF_ESO | I2C_PCF_ENI, bp->i2c_control_regs + 0x0); 275 *byte = readb(bp->i2c_control_regs + 0x1); 276 if (wait_for_pin(bp, &status)) 277 goto out; 278 279 ret = 0; 280 281 out: 282 writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0); 283 (void) readb(bp->i2c_control_regs + 0x1); 284 285 return ret; 286 } 287 288 int bbc_i2c_write_buf(struct bbc_i2c_client *client, 289 char *buf, int len, int off) 290 { 291 int ret = 0; 292 293 while (len > 0) { 294 int err = bbc_i2c_writeb(client, *buf, off); 295 296 if (err < 0) { 297 ret = err; 298 break; 299 } 300 301 len--; 302 buf++; 303 off++; 304 } 305 return ret; 306 } 307 308 int bbc_i2c_read_buf(struct bbc_i2c_client *client, 309 char *buf, int len, int off) 310 { 311 int ret = 0; 312 313 while (len > 0) { 314 int err = bbc_i2c_readb(client, buf, off); 315 if (err < 0) { 316 ret = err; 317 break; 318 } 319 len--; 320 buf++; 321 off++; 322 } 323 324 return ret; 325 } 326 327 EXPORT_SYMBOL(bbc_i2c_getdev); 328 EXPORT_SYMBOL(bbc_i2c_attach); 329 EXPORT_SYMBOL(bbc_i2c_detach); 330 EXPORT_SYMBOL(bbc_i2c_writeb); 331 EXPORT_SYMBOL(bbc_i2c_readb); 332 EXPORT_SYMBOL(bbc_i2c_write_buf); 333 EXPORT_SYMBOL(bbc_i2c_read_buf); 334 335 static irqreturn_t bbc_i2c_interrupt(int irq, void *dev_id) 336 { 337 struct bbc_i2c_bus *bp = dev_id; 338 339 /* PIN going from set to clear is the only event which 340 * makes the i2c assert an interrupt. 341 */ 342 if (bp->waiting && 343 !(readb(bp->i2c_control_regs + 0x0) & I2C_PCF_PIN)) 344 wake_up_interruptible(&bp->wq); 345 346 return IRQ_HANDLED; 347 } 348 349 static void __init reset_one_i2c(struct bbc_i2c_bus *bp) 350 { 351 writeb(I2C_PCF_PIN, bp->i2c_control_regs + 0x0); 352 writeb(bp->own, bp->i2c_control_regs + 0x1); 353 writeb(I2C_PCF_PIN | I2C_PCF_ES1, bp->i2c_control_regs + 0x0); 354 writeb(bp->clock, bp->i2c_control_regs + 0x1); 355 writeb(I2C_PCF_IDLE, bp->i2c_control_regs + 0x0); 356 } 357 358 static int __init attach_one_i2c(struct linux_ebus_device *edev, int index) 359 { 360 struct bbc_i2c_bus *bp; 361 struct linux_ebus_child *echild; 362 int entry; 363 364 bp = kzalloc(sizeof(*bp), GFP_KERNEL); 365 if (!bp) 366 return -ENOMEM; 367 368 bp->i2c_control_regs = ioremap(edev->resource[0].start, 0x2); 369 if (!bp->i2c_control_regs) 370 goto fail; 371 372 if (edev->num_addrs == 2) { 373 bp->i2c_bussel_reg = ioremap(edev->resource[1].start, 0x1); 374 if (!bp->i2c_bussel_reg) 375 goto fail; 376 } 377 378 bp->waiting = 0; 379 init_waitqueue_head(&bp->wq); 380 if (request_irq(edev->irqs[0], bbc_i2c_interrupt, 381 IRQF_SHARED, "bbc_i2c", bp)) 382 goto fail; 383 384 bp->index = index; 385 bp->bus_edev = edev; 386 387 spin_lock_init(&bp->lock); 388 bp->next = all_bbc_i2c; 389 all_bbc_i2c = bp; 390 391 entry = 0; 392 for (echild = edev->children; 393 echild && entry < 8; 394 echild = echild->next, entry++) { 395 bp->devs[entry].device = echild; 396 bp->devs[entry].client_claimed = 0; 397 } 398 399 writeb(I2C_PCF_PIN, bp->i2c_control_regs + 0x0); 400 bp->own = readb(bp->i2c_control_regs + 0x01); 401 writeb(I2C_PCF_PIN | I2C_PCF_ES1, bp->i2c_control_regs + 0x0); 402 bp->clock = readb(bp->i2c_control_regs + 0x01); 403 404 printk(KERN_INFO "i2c-%d: Regs at %p, %d devices, own %02x, clock %02x.\n", 405 bp->index, bp->i2c_control_regs, entry, bp->own, bp->clock); 406 407 reset_one_i2c(bp); 408 409 return 0; 410 411 fail: 412 if (bp->i2c_bussel_reg) 413 iounmap(bp->i2c_bussel_reg); 414 if (bp->i2c_control_regs) 415 iounmap(bp->i2c_control_regs); 416 kfree(bp); 417 return -EINVAL; 418 } 419 420 static int __init bbc_present(void) 421 { 422 struct linux_ebus *ebus = NULL; 423 struct linux_ebus_device *edev = NULL; 424 425 for_each_ebus(ebus) { 426 for_each_ebusdev(edev, ebus) { 427 if (!strcmp(edev->prom_node->name, "bbc")) 428 return 1; 429 } 430 } 431 return 0; 432 } 433 434 extern int bbc_envctrl_init(void); 435 extern void bbc_envctrl_cleanup(void); 436 static void bbc_i2c_cleanup(void); 437 438 static int __init bbc_i2c_init(void) 439 { 440 struct linux_ebus *ebus = NULL; 441 struct linux_ebus_device *edev = NULL; 442 int err, index = 0; 443 444 if ((tlb_type != cheetah && tlb_type != cheetah_plus) || 445 !bbc_present()) 446 return -ENODEV; 447 448 for_each_ebus(ebus) { 449 for_each_ebusdev(edev, ebus) { 450 if (!strcmp(edev->prom_node->name, "i2c")) { 451 if (!attach_one_i2c(edev, index)) 452 index++; 453 } 454 } 455 } 456 457 if (!index) 458 return -ENODEV; 459 460 err = bbc_envctrl_init(); 461 if (err) 462 bbc_i2c_cleanup(); 463 return err; 464 } 465 466 static void bbc_i2c_cleanup(void) 467 { 468 struct bbc_i2c_bus *bp = all_bbc_i2c; 469 470 bbc_envctrl_cleanup(); 471 472 while (bp != NULL) { 473 struct bbc_i2c_bus *next = bp->next; 474 475 free_irq(bp->bus_edev->irqs[0], bp); 476 477 if (bp->i2c_bussel_reg) 478 iounmap(bp->i2c_bussel_reg); 479 if (bp->i2c_control_regs) 480 iounmap(bp->i2c_control_regs); 481 482 kfree(bp); 483 484 bp = next; 485 } 486 all_bbc_i2c = NULL; 487 } 488 489 module_init(bbc_i2c_init); 490 module_exit(bbc_i2c_cleanup); 491 MODULE_LICENSE("GPL"); 492