drivers/i2c/busses/i2c-amd756-s4882.c

   1 /*
   2  * i2c-amd756-s4882.c - i2c-amd756 extras for the Tyan S4882 motherboard
   3  *
   4  * Copyright (C) 2004, 2008 Jean Delvare <khali@linux-fr.org>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 /*
  22  * We select the channels by sending commands to the Philips
  23  * PCA9556 chip at I2C address 0x18. The main adapter is used for
  24  * the non-multiplexed part of the bus, and 4 virtual adapters
  25  * are defined for the multiplexed addresses: 0x50-0x53 (memory
  26  * module EEPROM) located on channels 1-4, and 0x4c (LM63)
  27  * located on multiplexed channels 0 and 5-7. We define one
  28  * virtual adapter per CPU, which corresponds to two multiplexed
  29  * channels:
  30  *   CPU0: virtual adapter 1, channels 1 and 0
  31  *   CPU1: virtual adapter 2, channels 2 and 5
  32  *   CPU2: virtual adapter 3, channels 3 and 6
  33  *   CPU3: virtual adapter 4, channels 4 and 7
  34  */
  35
  36 #include <linux/module.h>
  37 #include <linux/kernel.h>
  38 #include <linux/slab.h>
  39 #include <linux/init.h>
  40 #include <linux/i2c.h>
  41 #include <linux/mutex.h>
  42
  43 extern struct i2c_adapter amd756_smbus;
  44
  45 static struct i2c_adapter *s4882_adapter;
  46 static struct i2c_algorithm *s4882_algo;
  47
  48 /* Wrapper access functions for multiplexed SMBus */
  49 static DEFINE_MUTEX(amd756_lock);
  50
  51 static s32 amd756_access_virt0(struct i2c_adapter * adap, u16 addr,
  52                                unsigned short flags, char read_write,
  53                                u8 command, int size,
  54                                union i2c_smbus_data * data)
  55 {
  56         int error;
  57
  58         /* We exclude the multiplexed addresses */
  59         if (addr == 0x4c || (addr & 0xfc) == 0x50 || (addr & 0xfc) == 0x30
  60          || addr == 0x18)
  61                 return -ENXIO;
  62
  63         mutex_lock(&amd756_lock);
  64
  65         error = amd756_smbus.algo->smbus_xfer(adap, addr, flags, read_write,
  66                                               command, size, data);
  67
  68         mutex_unlock(&amd756_lock);
  69
  70         return error;
  71 }
  72
  73 /* We remember the last used channels combination so as to only switch
  74    channels when it is really needed. This greatly reduces the SMBus
  75    overhead, but also assumes that nobody will be writing to the PCA9556
  76    in our back. */
  77 static u8 last_channels;
  78
  79 static inline s32 amd756_access_channel(struct i2c_adapter * adap, u16 addr,
  80                                         unsigned short flags, char read_write,
  81                                         u8 command, int size,
  82                                         union i2c_smbus_data * data,
  83                                         u8 channels)
  84 {
  85         int error;
  86
  87         /* We exclude the non-multiplexed addresses */
  88         if (addr != 0x4c && (addr & 0xfc) != 0x50 && (addr & 0xfc) != 0x30)
  89                 return -ENXIO;
  90
  91         mutex_lock(&amd756_lock);
  92
  93         if (last_channels != channels) {
  94                 union i2c_smbus_data mplxdata;
  95                 mplxdata.byte = channels;
  96
  97                 error = amd756_smbus.algo->smbus_xfer(adap, 0x18, 0,
  98                                                       I2C_SMBUS_WRITE, 0x01,
  99                                                       I2C_SMBUS_BYTE_DATA,
 100                                                       &mplxdata);
 101                 if (error)
 102                         goto UNLOCK;
 103                 last_channels = channels;
 104         }
 105         error = amd756_smbus.algo->smbus_xfer(adap, addr, flags, read_write,
 106                                               command, size, data);
 107
 108 UNLOCK:
 109         mutex_unlock(&amd756_lock);
 110         return error;
 111 }
 112
 113 static s32 amd756_access_virt1(struct i2c_adapter * adap, u16 addr,
 114                                unsigned short flags, char read_write,
 115                                u8 command, int size,
 116                                union i2c_smbus_data * data)
 117 {
 118         /* CPU0: channels 1 and 0 enabled */
 119         return amd756_access_channel(adap, addr, flags, read_write, command,
 120                                      size, data, 0x03);
 121 }
 122
 123 static s32 amd756_access_virt2(struct i2c_adapter * adap, u16 addr,
 124                                unsigned short flags, char read_write,
 125                                u8 command, int size,
 126                                union i2c_smbus_data * data)
 127 {
 128         /* CPU1: channels 2 and 5 enabled */
 129         return amd756_access_channel(adap, addr, flags, read_write, command,
 130                                      size, data, 0x24);
 131 }
 132
 133 static s32 amd756_access_virt3(struct i2c_adapter * adap, u16 addr,
 134                                unsigned short flags, char read_write,
 135                                u8 command, int size,
 136                                union i2c_smbus_data * data)
 137 {
 138         /* CPU2: channels 3 and 6 enabled */
 139         return amd756_access_channel(adap, addr, flags, read_write, command,
 140                                      size, data, 0x48);
 141 }
 142
 143 static s32 amd756_access_virt4(struct i2c_adapter * adap, u16 addr,
 144                                unsigned short flags, char read_write,
 145                                u8 command, int size,
 146                                union i2c_smbus_data * data)
 147 {
 148         /* CPU3: channels 4 and 7 enabled */
 149         return amd756_access_channel(adap, addr, flags, read_write, command,
 150                                      size, data, 0x90);
 151 }
 152
 153 static int __init amd756_s4882_init(void)
 154 {
 155         int i, error;
 156         union i2c_smbus_data ioconfig;
 157
 158         /* Unregister physical bus */
 159         error = i2c_del_adapter(&amd756_smbus);
 160         if (error) {
 161                 if (error == -EINVAL)
 162                         error = -ENODEV;
 163                 else
 164                         dev_err(&amd756_smbus.dev, "Physical bus removal "
 165                                 "failed\n");
 166                 goto ERROR0;
 167         }
 168
 169         printk(KERN_INFO "Enabling SMBus multiplexing for Tyan S4882\n");
 170         /* Define the 5 virtual adapters and algorithms structures */
 171         if (!(s4882_adapter = kzalloc(5 * sizeof(struct i2c_adapter),
 172                                       GFP_KERNEL))) {
 173                 error = -ENOMEM;
 174                 goto ERROR1;
 175         }
 176         if (!(s4882_algo = kzalloc(5 * sizeof(struct i2c_algorithm),
 177                                    GFP_KERNEL))) {
 178                 error = -ENOMEM;
 179                 goto ERROR2;
 180         }
 181
 182         /* Fill in the new structures */
 183         s4882_algo[0] = *(amd756_smbus.algo);
 184         s4882_algo[0].smbus_xfer = amd756_access_virt0;
 185         s4882_adapter[0] = amd756_smbus;
 186         s4882_adapter[0].algo = s4882_algo;
 187         s4882_adapter[0].dev.parent = amd756_smbus.dev.parent;
 188         for (i = 1; i < 5; i++) {
 189                 s4882_algo[i] = *(amd756_smbus.algo);
 190                 s4882_adapter[i] = amd756_smbus;
 191                 sprintf(s4882_adapter[i].name,
 192                         "SMBus 8111 adapter (CPU%d)", i-1);
 193                 s4882_adapter[i].algo = s4882_algo+i;
 194                 s4882_adapter[i].dev.parent = amd756_smbus.dev.parent;
 195         }
 196         s4882_algo[1].smbus_xfer = amd756_access_virt1;
 197         s4882_algo[2].smbus_xfer = amd756_access_virt2;
 198         s4882_algo[3].smbus_xfer = amd756_access_virt3;
 199         s4882_algo[4].smbus_xfer = amd756_access_virt4;
 200
 201         /* Configure the PCA9556 multiplexer */
 202         ioconfig.byte = 0x00; /* All I/O to output mode */
 203         error = amd756_smbus.algo->smbus_xfer(&amd756_smbus, 0x18, 0,
 204                                               I2C_SMBUS_WRITE, 0x03,
 205                                               I2C_SMBUS_BYTE_DATA, &ioconfig);
 206         if (error) {
 207                 dev_err(&amd756_smbus.dev, "PCA9556 configuration failed\n");
 208                 error = -EIO;
 209                 goto ERROR3;
 210         }
 211
 212         /* Register virtual adapters */
 213         for (i = 0; i < 5; i++) {
 214                 error = i2c_add_adapter(s4882_adapter+i);
 215                 if (error) {
 216                         dev_err(&amd756_smbus.dev,
 217                                "Virtual adapter %d registration "
 218                                "failed, module not inserted\n", i);
 219                         for (i--; i >= 0; i--)
 220                                 i2c_del_adapter(s4882_adapter+i);
 221                         goto ERROR3;
 222                 }
 223         }
 224
 225         return 0;
 226
 227 ERROR3:
 228         kfree(s4882_algo);
 229         s4882_algo = NULL;
 230 ERROR2:
 231         kfree(s4882_adapter);
 232         s4882_adapter = NULL;
 233 ERROR1:
 234         /* Restore physical bus */
 235         i2c_add_adapter(&amd756_smbus);
 236 ERROR0:
 237         return error;
 238 }
 239
 240 static void __exit amd756_s4882_exit(void)
 241 {
 242         if (s4882_adapter) {
 243                 int i;
 244
 245                 for (i = 0; i < 5; i++)
 246                         i2c_del_adapter(s4882_adapter+i);
 247                 kfree(s4882_adapter);
 248                 s4882_adapter = NULL;
 249         }
 250         kfree(s4882_algo);
 251         s4882_algo = NULL;
 252
 253         /* Restore physical bus */
 254         if (i2c_add_adapter(&amd756_smbus))
 255                 dev_err(&amd756_smbus.dev, "Physical bus restoration "
 256                         "failed\n");
 257 }
 258
 259 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
 260 MODULE_DESCRIPTION("S4882 SMBus multiplexing");
 261 MODULE_LICENSE("GPL");
 262
 263 module_init(amd756_s4882_init);
 264 module_exit(amd756_s4882_exit);