drivers/sbus/char/display7seg.c

   1 /* display7seg.c - Driver implementation for the 7-segment display
   2  *                 present on Sun Microsystems CP1400 and CP1500
   3  *
   4  * Copyright (c) 2000 Eric Brower (ebrower@usa.net)
   5  */
   6
   7 #include <linux/kernel.h>
   8 #include <linux/module.h>
   9 #include <linux/fs.h>
  10 #include <linux/errno.h>
  11 #include <linux/major.h>
  12 #include <linux/init.h>
  13 #include <linux/miscdevice.h>
  14 #include <linux/ioport.h>               /* request_region */
  15 #include <linux/slab.h>
  16 #include <linux/mutex.h>
  17 #include <linux/of.h>
  18 #include <linux/of_device.h>
  19 #include <asm/atomic.h>
  20 #include <asm/uaccess.h>                /* put_/get_user                        */
  21 #include <asm/io.h>
  22
  23 #include <asm/display7seg.h>
  24
  25 #define D7S_MINOR       193
  26 #define DRIVER_NAME     "d7s"
  27 #define PFX             DRIVER_NAME ": "
  28
  29 static DEFINE_MUTEX(d7s_mutex);
  30 static int sol_compat = 0;              /* Solaris compatibility mode   */
  31
  32 /* Solaris compatibility flag -
  33  * The Solaris implementation omits support for several
  34  * documented driver features (ref Sun doc 806-0180-03).
  35  * By default, this module supports the documented driver
  36  * abilities, rather than the Solaris implementation:
  37  *
  38  *      1) Device ALWAYS reverts to OBP-specified FLIPPED mode
  39  *         upon closure of device or module unload.
  40  *      2) Device ioctls D7SIOCRD/D7SIOCWR honor toggling of
  41  *         FLIP bit
  42  *
  43  * If you wish the device to operate as under Solaris,
  44  * omitting above features, set this parameter to non-zero.
  45  */
  46 module_param(sol_compat, int, 0);
  47 MODULE_PARM_DESC(sol_compat,
  48                  "Disables documented functionality omitted from Solaris driver");
  49
  50 MODULE_AUTHOR("Eric Brower <ebrower@usa.net>");
  51 MODULE_DESCRIPTION("7-Segment Display driver for Sun Microsystems CP1400/1500");
  52 MODULE_LICENSE("GPL");
  53 MODULE_SUPPORTED_DEVICE("d7s");
  54
  55 struct d7s {
  56         void __iomem    *regs;
  57         bool            flipped;
  58 };
  59 struct d7s *d7s_device;
  60
  61 /*
  62  * Register block address- see header for details
  63  * -----------------------------------------
  64  * | DP | ALARM | FLIP | 4 | 3 | 2 | 1 | 0 |
  65  * -----------------------------------------
  66  *
  67  * DP           - Toggles decimal point on/off
  68  * ALARM        - Toggles "Alarm" LED green/red
  69  * FLIP         - Inverts display for upside-down mounted board
  70  * bits 0-4     - 7-segment display contents
  71  */
  72 static atomic_t d7s_users = ATOMIC_INIT(0);
  73
  74 static int d7s_open(struct inode *inode, struct file *f)
  75 {
  76         if (D7S_MINOR != iminor(inode))
  77                 return -ENODEV;
  78         atomic_inc(&d7s_users);
  79         return 0;
  80 }
  81
  82 static int d7s_release(struct inode *inode, struct file *f)
  83 {
  84         /* Reset flipped state to OBP default only if
  85          * no other users have the device open and we
  86          * are not operating in solaris-compat mode
  87          */
  88         if (atomic_dec_and_test(&d7s_users) && !sol_compat) {
  89                 struct d7s *p = d7s_device;
  90                 u8 regval = 0;
  91
  92                 regval = readb(p->regs);
  93                 if (p->flipped)
  94                         regval |= D7S_FLIP;
  95                 else
  96                         regval &= ~D7S_FLIP;
  97                 writeb(regval, p->regs);
  98         }
  99
 100         return 0;
 101 }
 102
 103 static long d7s_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 104 {
 105         struct d7s *p = d7s_device;
 106         u8 regs = readb(p->regs);
 107         int error = 0;
 108         u8 ireg = 0;
 109
 110         if (D7S_MINOR != iminor(file->f_path.dentry->d_inode))
 111                 return -ENODEV;
 112
 113         mutex_lock(&d7s_mutex);
 114         switch (cmd) {
 115         case D7SIOCWR:
 116                 /* assign device register values we mask-out D7S_FLIP
 117                  * if in sol_compat mode
 118                  */
 119                 if (get_user(ireg, (int __user *) arg)) {
 120                         error = -EFAULT;
 121                         break;
 122                 }
 123                 if (sol_compat) {
 124                         if (regs & D7S_FLIP)
 125                                 ireg |= D7S_FLIP;
 126                         else
 127                                 ireg &= ~D7S_FLIP;
 128                 }
 129                 writeb(ireg, p->regs);
 130                 break;
 131
 132         case D7SIOCRD:
 133                 /* retrieve device register values
 134                  * NOTE: Solaris implementation returns D7S_FLIP bit
 135                  * as toggled by user, even though it does not honor it.
 136                  * This driver will not misinform you about the state
 137                  * of your hardware while in sol_compat mode
 138                  */
 139                 if (put_user(regs, (int __user *) arg)) {
 140                         error = -EFAULT;
 141                         break;
 142                 }
 143                 break;
 144
 145         case D7SIOCTM:
 146                 /* toggle device mode-- flip display orientation */
 147                 if (regs & D7S_FLIP)
 148                         regs &= ~D7S_FLIP;
 149                 else
 150                         regs |= D7S_FLIP;
 151                 writeb(regs, p->regs);
 152                 break;
 153         };
 154         mutex_unlock(&d7s_mutex);
 155
 156         return error;
 157 }
 158
 159 static const struct file_operations d7s_fops = {
 160         .owner =                THIS_MODULE,
 161         .unlocked_ioctl =       d7s_ioctl,
 162         .compat_ioctl =         d7s_ioctl,
 163         .open =                 d7s_open,
 164         .release =              d7s_release,
 165         .llseek = noop_llseek,
 166 };
 167
 168 static struct miscdevice d7s_miscdev = {
 169         .minor          = D7S_MINOR,
 170         .name           = DRIVER_NAME,
 171         .fops           = &d7s_fops
 172 };
 173
 174 static int __devinit d7s_probe(struct platform_device *op,
 175                                const struct of_device_id *match)
 176 {
 177         struct device_node *opts;
 178         int err = -EINVAL;
 179         struct d7s *p;
 180         u8 regs;
 181
 182         if (d7s_device)
 183                 goto out;
 184
 185         p = kzalloc(sizeof(*p), GFP_KERNEL);
 186         err = -ENOMEM;
 187         if (!p)
 188                 goto out;
 189
 190         p->regs = of_ioremap(&op->resource[0], 0, sizeof(u8), "d7s");
 191         if (!p->regs) {
 192                 printk(KERN_ERR PFX "Cannot map chip registers\n");
 193                 goto out_free;
 194         }
 195
 196         err = misc_register(&d7s_miscdev);
 197         if (err) {
 198                 printk(KERN_ERR PFX "Unable to acquire miscdevice minor %i\n",
 199                        D7S_MINOR);
 200                 goto out_iounmap;
 201         }
 202
 203         /* OBP option "d7s-flipped?" is honored as default for the
 204          * device, and reset default when detached
 205          */
 206         regs = readb(p->regs);
 207         opts = of_find_node_by_path("/options");
 208         if (opts &&
 209             of_get_property(opts, "d7s-flipped?", NULL))
 210                 p->flipped = true;
 211
 212         if (p->flipped)
 213                 regs |= D7S_FLIP;
 214         else
 215                 regs &= ~D7S_FLIP;
 216
 217         writeb(regs,  p->regs);
 218
 219         printk(KERN_INFO PFX "7-Segment Display%s at [%s:0x%llx] %s\n",
 220                op->dev.of_node->full_name,
 221                (regs & D7S_FLIP) ? " (FLIPPED)" : "",
 222                op->resource[0].start,
 223                sol_compat ? "in sol_compat mode" : "");
 224
 225         dev_set_drvdata(&op->dev, p);
 226         d7s_device = p;
 227         err = 0;
 228
 229 out:
 230         return err;
 231
 232 out_iounmap:
 233         of_iounmap(&op->resource[0], p->regs, sizeof(u8));
 234
 235 out_free:
 236         kfree(p);
 237         goto out;
 238 }
 239
 240 static int __devexit d7s_remove(struct platform_device *op)
 241 {
 242         struct d7s *p = dev_get_drvdata(&op->dev);
 243         u8 regs = readb(p->regs);
 244
 245         /* Honor OBP d7s-flipped? unless operating in solaris-compat mode */
 246         if (sol_compat) {
 247                 if (p->flipped)
 248                         regs |= D7S_FLIP;
 249                 else
 250                         regs &= ~D7S_FLIP;
 251                 writeb(regs, p->regs);
 252         }
 253
 254         misc_deregister(&d7s_miscdev);
 255         of_iounmap(&op->resource[0], p->regs, sizeof(u8));
 256         kfree(p);
 257
 258         return 0;
 259 }
 260
 261 static const struct of_device_id d7s_match[] = {
 262         {
 263                 .name = "display7seg",
 264         },
 265         {},
 266 };
 267 MODULE_DEVICE_TABLE(of, d7s_match);
 268
 269 static struct of_platform_driver d7s_driver = {
 270         .driver = {
 271                 .name = DRIVER_NAME,
 272                 .owner = THIS_MODULE,
 273                 .of_match_table = d7s_match,
 274         },
 275         .probe          = d7s_probe,
 276         .remove         = __devexit_p(d7s_remove),
 277 };
 278
 279 static int __init d7s_init(void)
 280 {
 281         return of_register_platform_driver(&d7s_driver);
 282 }
 283
 284 static void __exit d7s_exit(void)
 285 {
 286         of_unregister_platform_driver(&d7s_driver);
 287 }
 288
 289 module_init(d7s_init);
 290 module_exit(d7s_exit);