drivers/sbus/char/envctrl.c

   1 /* $Id: envctrl.c,v 1.7 1998/06/10 07:25:28 davem 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 = -1;
 119
 120         if (len == 0)
 121                 return 0;
 122
 123         i2c->data = (dev << 1) | I2C_READ;
 124
 125         while (!(i2c->csr & STATUS_BB))
 126                 udelay(1);
 127
 128         i2c->csr = CONTROL_PIN | CONTROL_ES0 | CONTROL_STA | CONTROL_ACK;
 129
 130         do {
 131                 udelay(1);
 132                 while ((stat = i2c->csr) & STATUS_PIN)
 133                         udelay(1);
 134
 135                 if (stat & STATUS_LRB)
 136                         goto stop;
 137                 error = 0;
 138                 if (count == (len - 2))
 139                         goto final;
 140
 141                 if (++count > 0) {
 142                         error = PUT_DATA(&i2c->data, buffer++, user);
 143                         if (error)
 144                                 goto final;
 145                 } else
 146                         dummy = i2c->data;
 147         } while (1);
 148
 149 final:
 150         i2c->csr = CONTROL_ES0;
 151         if (!error && (++count > 0))
 152                 error = PUT_DATA(&i2c->data, buffer++, user);
 153         else
 154                 dummy = i2c->data;
 155
 156         udelay(1);
 157         while ((stat = i2c->csr) & STATUS_PIN)
 158                 udelay(1);
 159
 160 stop:
 161         i2c->csr = CONTROL_PIN | CONTROL_ES0 | CONTROL_STO | CONTROL_ACK;
 162         if (!error && (++count > 0))
 163                 error = PUT_DATA(&i2c->data, buffer++, user);
 164         else
 165                 dummy = i2c->data;
 166
 167         if (error)
 168                 return error;
 169         return count;
 170 }
 171
 172 static int
 173 i2c_write(unsigned char dev, const char *buffer, int len, int user)
 174 {
 175         int error = -ENODEV;
 176         int count = 0;
 177
 178         while (!(i2c->csr & STATUS_BB))
 179                 udelay(1);
 180
 181         i2c->data = (dev << 1) | I2C_WRITE;
 182         i2c->csr = CONTROL_PIN | CONTROL_ES0 | CONTROL_STA | CONTROL_ACK;
 183
 184         do {
 185                 unsigned char stat;
 186
 187                 udelay(1);
 188                 while ((stat = i2c->csr) & STATUS_PIN)
 189                         udelay(1);
 190
 191                 if (stat & STATUS_LRB)
 192                         goto stop;
 193                 error = count;
 194                 if (count == len)
 195                         goto stop;
 196
 197                 error = GET_DATA(&i2c->data, buffer++, user);
 198                 if (error)
 199                         goto stop;
 200
 201                 count++;
 202         } while (1);
 203
 204 stop:
 205         i2c->csr = CONTROL_PIN | CONTROL_ES0 | CONTROL_STO | CONTROL_ACK;
 206         return error;
 207 }
 208
 209 __initfunc(static int i2c_scan_bus(void))
 210 {
 211         unsigned char dev;
 212         int count = 0;
 213
 214         for (dev = 1; dev < 128; dev++) {
 215                 if (i2c_write(dev, 0, 0, 0) == 0) {
 216 #ifdef DEBUG_BUS_SCAN
 217                         int i;
 218                         for (i = 0; i < NR_DEVMAP; i++)
 219                                 if ((dev & devmap[i].mask) == devmap[i].addr)
 220                                         break;
 221                         printk("envctrl: i2c device at %02x: %s\n", dev,
 222                                i < NR_DEVMAP ? devmap[i].name : "unknown");
 223 #endif
 224                         count++;
 225                 }
 226         }
 227         return count ? 0 : -ENODEV;
 228 }
 229
 230 static loff_t
 231 envctrl_llseek(struct file *file, loff_t offset, int type)
 232 {
 233         return -ESPIPE;
 234 }
 235
 236 static ssize_t
 237 envctrl_read(struct file *file, char *buf, size_t count, loff_t *ppos)
 238 {
 239         unsigned long addr = (unsigned long)file->private_data;
 240
 241         return i2c_read(addr, buf, count, 1);
 242 }
 243
 244 static ssize_t
 245 envctrl_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
 246 {
 247         unsigned long addr = (unsigned long)file->private_data;
 248
 249         return i2c_write(addr, buf, count, 1);
 250 }
 251
 252 static int
 253 envctrl_ioctl(struct inode *inode, struct file *file,
 254               unsigned int cmd, unsigned long arg)
 255 {
 256         unsigned long data;
 257         int addr;
 258
 259         switch (cmd) {
 260                 case I2CIOCSADR:
 261                         if (get_user(addr, (int *)arg))
 262                                 return -EFAULT;
 263                         data = addr & 0x7f;
 264                         file->private_data = (void *)data;
 265                         break;
 266                 case I2CIOCGADR:
 267                         addr = (unsigned long)file->private_data;
 268                         if (put_user(addr, (int *)arg))
 269                                 return -EFAULT;
 270                         break;
 271                 default:
 272                         return -EINVAL;
 273         }
 274         return 0;
 275 }
 276
 277 static int
 278 envctrl_open(struct inode *inode, struct file *file)
 279 {
 280         file->private_data = 0;
 281         MOD_INC_USE_COUNT;
 282         return 0;
 283 }
 284
 285 static int
 286 envctrl_release(struct inode *inode, struct file *file)
 287 {
 288         MOD_DEC_USE_COUNT;
 289         return 0;
 290 }
 291
 292 static struct file_operations envctrl_fops = {
 293         envctrl_llseek,
 294         envctrl_read,
 295         envctrl_write,
 296         NULL,           /* readdir */
 297         NULL,           /* poll */
 298         envctrl_ioctl,
 299         NULL,           /* mmap */
 300         envctrl_open,
 301         NULL,           /* flush */
 302         envctrl_release
 303 };
 304
 305 static struct miscdevice envctrl_dev = {
 306         ENVCTRL_MINOR,
 307         "envctrl",
 308         &envctrl_fops
 309 };
 310
 311 #ifdef MODULE
 312 int init_module(void)
 313 #else
 314 __initfunc(int envctrl_init(void))
 315 #endif
 316 {
 317 #ifdef CONFIG_PCI
 318         struct linux_ebus *ebus;
 319         struct linux_ebus_device *edev = 0;
 320
 321         for_each_ebus(ebus) {
 322                 for_each_ebusdev(edev, ebus) {
 323                         if (!strcmp(edev->prom_name, "SUNW,envctrl"))
 324                                 goto ebus_done;
 325                         if (!strcmp(edev->prom_name, "SUNW,rasctrl"))
 326                                 goto ebus_done;
 327                 }
 328         }
 329 ebus_done:
 330         if (!edev)
 331                 return -ENODEV;
 332
 333         if (check_region(edev->base_address[0], sizeof(*i2c))) {
 334                 printk("%s: Can't get region %lx, %d\n",
 335                        __FUNCTION__, edev->base_address[0], (int)sizeof(*i2c));
 336                 return -ENODEV;
 337         }
 338
 339         i2c = (struct pcf8584_reg *)edev->base_address[0];
 340
 341         request_region((unsigned long)i2c, sizeof(*i2c), "i2c");
 342
 343         i2c->csr = CONTROL_PIN;
 344         i2c->data = PCF8584_ADDRESS;
 345         i2c->csr = CONTROL_PIN | CONTROL_ES1;
 346         i2c->data = CLK_4_43 | BUS_CLK_90;
 347         i2c->csr = CONTROL_PIN | CONTROL_ES0 | CONTROL_ACK;
 348         mdelay(10);
 349
 350         if (misc_register(&envctrl_dev)) {
 351                 printk("%s: unable to get misc minor %d\n",
 352                        __FUNCTION__, envctrl_dev.minor);
 353                 release_region((unsigned long)i2c, sizeof(*i2c));
 354         }
 355
 356         return i2c_scan_bus();
 357 #else
 358         return -ENODEV;
 359 #endif
 360 }
 361
 362
 363 #ifdef MODULE
 364 void cleanup_module(void)
 365 {
 366         misc_deregister(&envctrl_dev);
 367         release_region((unsigned long)i2c, sizeof(*i2c));
 368 }
 369 #endif