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