drivers/sbus/char/envctrl.c

   1 /* $Id: envctrl.c,v 1.9 1998/11/06 07:38:20 ecd Exp $
   2  * envctrl.c: Temperature and Fan monitoring on Machines providing it.
   3  *
   4  * Copyright (C) 1998  Eddie C. Dost  (ecd@skynet.be)
   5  */
   6
   7 #include <linux/config.h>
   8 #include <linux/module.h>
   9 #include <linux/sched.h>
  10 #include <linux/errno.h>
  11 #include <linux/delay.h>
  12 #include <linux/ioport.h>
  13 #include <linux/init.h>
  14 #include <linux/miscdevice.h>
  15
  16 #include <asm/ebus.h>
  17 #include <asm/uaccess.h>
  18 #include <asm/envctrl.h>
  19
  20 #define ENVCTRL_MINOR   162
  21
  22
  23 #undef DEBUG_BUS_SCAN
  24
  25
  26 #define PCF8584_ADDRESS 0x55
  27
  28 #define CONTROL_PIN     0x80
  29 #define CONTROL_ES0     0x40
  30 #define CONTROL_ES1     0x20
  31 #define CONTROL_ES2     0x10
  32 #define CONTROL_ENI     0x08
  33 #define CONTROL_STA     0x04
  34 #define CONTROL_STO     0x02
  35 #define CONTROL_ACK     0x01
  36
  37 #define STATUS_PIN      0x80
  38 #define STATUS_STS      0x20
  39 #define STATUS_BER      0x10
  40 #define STATUS_LRB      0x08
  41 #define STATUS_AD0      0x08
  42 #define STATUS_AAB      0x04
  43 #define STATUS_LAB      0x02
  44 #define STATUS_BB       0x01
  45
  46 /*
  47  * CLK Mode Register.
  48  */
  49 #define BUS_CLK_90      0x00
  50 #define BUS_CLK_45      0x01
  51 #define BUS_CLK_11      0x02
  52 #define BUS_CLK_1_5     0x03
  53
  54 #define CLK_3           0x00
  55 #define CLK_4_43        0x10
  56 #define CLK_6           0x14
  57 #define CLK_8           0x18
  58 #define CLK_12          0x1c
  59
  60
  61 #define I2C_WRITE       0x00
  62 #define I2C_READ        0x01
  63
  64 struct pcf8584_reg
  65 {
  66         __volatile__ unsigned char data;
  67         __volatile__ unsigned char csr;
  68 };
  69
  70 static struct pcf8584_reg *i2c;
  71
  72
  73 #ifdef DEBUG_BUS_SCAN
  74 struct i2c_addr_map {
  75         unsigned char addr;
  76         unsigned char mask;
  77         char *name;
  78 };
  79
  80 static struct i2c_addr_map devmap[] = {
  81         { 0x38, 0x78, "PCF8574A" },
  82         { 0x20, 0x78, "TDA8444" },
  83         { 0x48, 0x78, "PCF8591" },
  84 };
  85 #define NR_DEVMAP (sizeof(devmap) / sizeof(devmap[0]))
  86 #endif
  87
  88 static __inline__ int
  89 PUT_DATA(__volatile__ unsigned char *data, char *buffer, int user)
  90 {
  91         if (user) {
  92                 if (put_user(*data, buffer))
  93                         return -EFAULT;
  94         } else {
  95                 *buffer = *data;
  96         }
  97         return 0;
  98 }
  99
 100 static __inline__ int
 101 GET_DATA(__volatile__ unsigned char *data, const char *buffer, int user)
 102 {
 103         if (user) {
 104                 if (get_user(*data, buffer))
 105                         return -EFAULT;
 106         } else {
 107                 *data = *buffer;
 108         }
 109         return 0;
 110 }
 111
 112 static int
 113 i2c_read(unsigned char dev, char *buffer, int len, int user)
 114 {
 115         unsigned char dummy;
 116         unsigned char stat;
 117         int error = -ENODEV;
 118         int count = 0;
 119
 120         i2c->data = (dev << 1) | I2C_READ;
 121
 122         while (!(i2c->csr & STATUS_BB))
 123                 udelay(1);
 124
 125         i2c->csr = CONTROL_PIN | CONTROL_ES0 | CONTROL_STA | CONTROL_ACK;
 126
 127         do {
 128                 udelay(1);
 129                 while ((stat = i2c->csr) & STATUS_PIN)
 130                         udelay(1);
 131
 132                 if (stat & STATUS_LRB)
 133                         goto stop;
 134
 135                 error = 0;
 136                 if (len == 0) {
 137                         count--;
 138                         break;
 139                 }
 140
 141                 if (count == (len - 1))
 142                         break;
 143
 144                 if (count++ > 0) {
 145                         error = PUT_DATA(&i2c->data, buffer++, user);
 146                         if (error)
 147                                 break;
 148                 } else
 149                         dummy = i2c->data;
 150         } while (1);
 151
 152         i2c->csr = CONTROL_ES0;
 153         if (!error && (count++ > 0))
 154                 error = PUT_DATA(&i2c->data, buffer++, user);
 155         else
 156                 dummy = i2c->data;
 157
 158         udelay(1);
 159         while ((stat = i2c->csr) & STATUS_PIN)
 160                 udelay(1);
 161
 162 stop:
 163         i2c->csr = CONTROL_PIN | CONTROL_ES0 | CONTROL_STO | CONTROL_ACK;
 164         if (!error && (count++ > 0))
 165                 error = PUT_DATA(&i2c->data, buffer++, user);
 166         else
 167                 dummy = i2c->data;
 168
 169         if (error)
 170                 return error;
 171         return count - 1;
 172 }
 173
 174 static int
 175 i2c_write(unsigned char dev, const char *buffer, int len, int user)
 176 {
 177         int error = -ENODEV;
 178         int count = 0;
 179
 180         while (!(i2c->csr & STATUS_BB))
 181                 udelay(1);
 182
 183         i2c->data = (dev << 1) | I2C_WRITE;
 184         i2c->csr = CONTROL_PIN | CONTROL_ES0 | CONTROL_STA | CONTROL_ACK;
 185
 186         do {
 187                 unsigned char stat;
 188
 189                 udelay(1);
 190                 while ((stat = i2c->csr) & STATUS_PIN)
 191                         udelay(1);
 192
 193                 if (stat & STATUS_LRB)
 194                         break;
 195
 196                 error = count;
 197                 if (count == len)
 198                         break;
 199
 200                 error = GET_DATA(&i2c->data, buffer++, user);
 201                 if (error)
 202                         break;
 203
 204                 count++;
 205         } while (1);
 206
 207         i2c->csr = CONTROL_PIN | CONTROL_ES0 | CONTROL_STO | CONTROL_ACK;
 208         return error;
 209 }
 210
 211 __initfunc(static int i2c_scan_bus(void))
 212 {
 213         unsigned char dev;
 214         int count = 0;
 215
 216         for (dev = 1; dev < 128; dev++) {
 217                 if (i2c_read(dev, 0, 0, 0) == 0) {
 218 #ifdef DEBUG_BUS_SCAN
 219                         int i;
 220                         for (i = 0; i < NR_DEVMAP; i++)
 221                                 if ((dev & devmap[i].mask) == devmap[i].addr)
 222                                         break;
 223                         printk("envctrl: i2c device at %02x: %s\n", dev,
 224                                i < NR_DEVMAP ? devmap[i].name : "unknown");
 225 #endif
 226                         count++;
 227                 }
 228         }
 229         if (!count) {
 230                 printk("%s: no devices found\n", __FUNCTION__);
 231                 return -ENODEV;
 232         }
 233         return 0;
 234 }
 235
 236 static loff_t
 237 envctrl_llseek(struct file *file, loff_t offset, int type)
 238 {
 239         return -ESPIPE;
 240 }
 241
 242 static ssize_t
 243 envctrl_read(struct file *file, char *buf, size_t count, loff_t *ppos)
 244 {
 245         unsigned long addr = (unsigned long)file->private_data;
 246
 247         return i2c_read(addr, buf, count, 1);
 248 }
 249
 250 static ssize_t
 251 envctrl_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
 252 {
 253         unsigned long addr = (unsigned long)file->private_data;
 254
 255         return i2c_write(addr, buf, count, 1);
 256 }
 257
 258 static int
 259 envctrl_ioctl(struct inode *inode, struct file *file,
 260               unsigned int cmd, unsigned long arg)
 261 {
 262         unsigned long data;
 263         int addr;
 264
 265         switch (cmd) {
 266                 case I2CIOCSADR:
 267                         if (get_user(addr, (int *)arg))
 268                                 return -EFAULT;
 269                         data = addr & 0x7f;
 270                         file->private_data = (void *)data;
 271                         break;
 272                 case I2CIOCGADR:
 273                         addr = (unsigned long)file->private_data;
 274                         if (put_user(addr, (int *)arg))
 275                                 return -EFAULT;
 276                         break;
 277                 default:
 278                         return -EINVAL;
 279         }
 280         return 0;
 281 }
 282
 283 static int
 284 envctrl_open(struct inode *inode, struct file *file)
 285 {
 286         file->private_data = 0;
 287         MOD_INC_USE_COUNT;
 288         return 0;
 289 }
 290
 291 static int
 292 envctrl_release(struct inode *inode, struct file *file)
 293 {
 294         MOD_DEC_USE_COUNT;
 295         return 0;
 296 }
 297
 298 static struct file_operations envctrl_fops = {
 299         envctrl_llseek,
 300         envctrl_read,
 301         envctrl_write,
 302         NULL,           /* readdir */
 303         NULL,           /* poll */
 304         envctrl_ioctl,
 305         NULL,           /* mmap */
 306         envctrl_open,
 307         NULL,           /* flush */
 308         envctrl_release
 309 };
 310
 311 static struct miscdevice envctrl_dev = {
 312         ENVCTRL_MINOR,
 313         "envctrl",
 314         &envctrl_fops
 315 };
 316
 317 #ifdef MODULE
 318 int init_module(void)
 319 #else
 320 __initfunc(int envctrl_init(void))
 321 #endif
 322 {
 323 #ifdef CONFIG_PCI
 324         struct linux_ebus *ebus;
 325         struct linux_ebus_device *edev = 0;
 326         int err;
 327
 328         for_each_ebus(ebus) {
 329                 for_each_ebusdev(edev, ebus) {
 330                         if (!strcmp(edev->prom_name, "SUNW,envctrl"))
 331                                 goto ebus_done;
 332                         if (!strcmp(edev->prom_name, "SUNW,rasctrl"))
 333                                 goto ebus_done;
 334                 }
 335         }
 336 ebus_done:
 337         if (!edev) {
 338                 printk("%s: ebus device not found\n", __FUNCTION__);
 339                 return -ENODEV;
 340         }
 341
 342         if (check_region(edev->base_address[0], sizeof(*i2c))) {
 343                 printk("%s: Can't get region %lx, %d\n",
 344                        __FUNCTION__, edev->base_address[0], (int)sizeof(*i2c));
 345                 return -ENODEV;
 346         }
 347
 348         i2c = (struct pcf8584_reg *)edev->base_address[0];
 349
 350         request_region((unsigned long)i2c, sizeof(*i2c), "i2c");
 351
 352         i2c->csr = CONTROL_PIN;
 353         i2c->data = PCF8584_ADDRESS;
 354         i2c->csr = CONTROL_PIN | CONTROL_ES1;
 355         i2c->data = CLK_4_43 | BUS_CLK_90;
 356         i2c->csr = CONTROL_PIN | CONTROL_ES0 | CONTROL_ACK;
 357         mdelay(10);
 358
 359         if (misc_register(&envctrl_dev)) {
 360                 printk("%s: unable to get misc minor %d\n",
 361                        __FUNCTION__, envctrl_dev.minor);
 362                 release_region((unsigned long)i2c, sizeof(*i2c));
 363         }
 364
 365         err = i2c_scan_bus();
 366         if (err)
 367                 release_region((unsigned long)i2c, sizeof(*i2c));
 368         return err;
 369 #else
 370         return -ENODEV;
 371 #endif
 372 }
 373
 374
 375 #ifdef MODULE
 376 void cleanup_module(void)
 377 {
 378         misc_deregister(&envctrl_dev);
 379         release_region((unsigned long)i2c, sizeof(*i2c));
 380 }
 381 #endif