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); 291