git.stricted.de - GitHub/moto-9609/android_kernel_motorola

1 /*

2 * OMAP4 Keypad Driver

3 *

5 *

6 * Author: Abraham Arce <x0066660@ti.com>

7 * Initial Code: Syed Rafiuddin <rafiuddin.syed@ti.com>

8 *

9 * This program is free software; you can redistribute it and/or modify

10 * it under the terms of the GNU General Public License as published by

11 * the Free Software Foundation; either version 2 of the License, or

12 * (at your option) any later version.

13 *

14 * This program is distributed in the hope that it will be useful,

15 * but WITHOUT ANY WARRANTY; without even the implied warranty of

16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

17 * GNU General Public License for more details.

18 *

19 * You should have received a copy of the GNU General Public License

20 * along with this program; if not, write to the Free Software

21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

22 */

24 #include <linux/module.h>

25 #include <linux/init.h>

26 #include <linux/interrupt.h>

27 #include <linux/platform_device.h>

28 #include <linux/errno.h>

29 #include <linux/io.h>

30 #include <linux/input.h>

31 #include <linux/slab.h>

32 #include <linux/pm_runtime.h>

34 #include <linux/platform_data/omap4-keypad.h>

36 /* OMAP4 registers */

37 #define OMAP4_KBD_REVISION 0x00

38 #define OMAP4_KBD_SYSCONFIG 0x10

39 #define OMAP4_KBD_SYSSTATUS 0x14

40 #define OMAP4_KBD_IRQSTATUS 0x18

41 #define OMAP4_KBD_IRQENABLE 0x1C

42 #define OMAP4_KBD_WAKEUPENABLE 0x20

43 #define OMAP4_KBD_PENDING 0x24

44 #define OMAP4_KBD_CTRL 0x28

45 #define OMAP4_KBD_DEBOUNCINGTIME 0x2C

46 #define OMAP4_KBD_LONGKEYTIME 0x30

47 #define OMAP4_KBD_TIMEOUT 0x34

48 #define OMAP4_KBD_STATEMACHINE 0x38

49 #define OMAP4_KBD_ROWINPUTS 0x3C

50 #define OMAP4_KBD_COLUMNOUTPUTS 0x40

51 #define OMAP4_KBD_FULLCODE31_0 0x44

52 #define OMAP4_KBD_FULLCODE63_32 0x48

54 /* OMAP4 bit definitions */

55 #define OMAP4_DEF_IRQENABLE_EVENTEN (1 << 0)

56 #define OMAP4_DEF_IRQENABLE_LONGKEY (1 << 1)

57 #define OMAP4_DEF_IRQENABLE_TIMEOUTEN (1 << 2)

58 #define OMAP4_DEF_WUP_EVENT_ENA (1 << 0)

59 #define OMAP4_DEF_WUP_LONG_KEY_ENA (1 << 1)

60 #define OMAP4_DEF_CTRL_NOSOFTMODE (1 << 1)

61 #define OMAP4_DEF_CTRLPTVVALUE (1 << 2)

62 #define OMAP4_DEF_CTRLPTV (1 << 1)

64 /* OMAP4 values */

65 #define OMAP4_VAL_IRQDISABLE 0x00

66 #define OMAP4_VAL_DEBOUNCINGTIME 0x07

67 #define OMAP4_VAL_FUNCTIONALCFG 0x1E

69 #define OMAP4_MASK_IRQSTATUSDISABLE 0xFFFF

71 struct omap4_keypad {

72 struct input_dev *input;

74 void __iomem *base;

75 int irq;

77 unsigned int rows;

78 unsigned int cols;

79 unsigned int row_shift;

80 unsigned char key_state[8];

81 unsigned short keymap[];

82 };

84 /* Interrupt handler */

85 static irqreturn_t omap4_keypad_interrupt(int irq, void *dev_id)

86 {

87 struct omap4_keypad *keypad_data = dev_id;

88 struct input_dev *input_dev = keypad_data->input;

89 unsigned char key_state[ARRAY_SIZE(keypad_data->key_state)];

90 unsigned int col, row, code, changed;

91 u32 *new_state = (u32 *) key_state;

93 /* Disable interrupts */

94 __raw_writel(OMAP4_VAL_IRQDISABLE,

95 keypad_data->base + OMAP4_KBD_IRQENABLE);

97 *new_state = __raw_readl(keypad_data->base + OMAP4_KBD_FULLCODE31_0);

98 *(new_state + 1) = __raw_readl(keypad_data->base

99 + OMAP4_KBD_FULLCODE63_32);

100

101 for (row = 0; row < keypad_data->rows; row++) {

102 changed = key_state[row] ^ keypad_data->key_state[row];

103 if (!changed)

104 continue;

105

106 for (col = 0; col < keypad_data->cols; col++) {

107 if (changed & (1 << col)) {

108 code = MATRIX_SCAN_CODE(row, col,

109 keypad_data->row_shift);

110 input_event(input_dev, EV_MSC, MSC_SCAN, code);

111 input_report_key(input_dev,

112 keypad_data->keymap[code],

113 key_state[row] & (1 << col));

114 }

115 }

116 }

117

118 input_sync(input_dev);

119

120 memcpy(keypad_data->key_state, key_state,

121 sizeof(keypad_data->key_state));

122

123 /* clear pending interrupts */

124 __raw_writel(__raw_readl(keypad_data->base + OMAP4_KBD_IRQSTATUS),

125 keypad_data->base + OMAP4_KBD_IRQSTATUS);

126

127 /* enable interrupts */

128 __raw_writel(OMAP4_DEF_IRQENABLE_EVENTEN | OMAP4_DEF_IRQENABLE_LONGKEY,

129 keypad_data->base + OMAP4_KBD_IRQENABLE);

130

131 return IRQ_HANDLED;

132 }

133

134 static int omap4_keypad_open(struct input_dev *input)

135 {

136 struct omap4_keypad *keypad_data = input_get_drvdata(input);

137

138 pm_runtime_get_sync(input->dev.parent);

139

140 disable_irq(keypad_data->irq);

141

142 __raw_writel(OMAP4_VAL_FUNCTIONALCFG,

143 keypad_data->base + OMAP4_KBD_CTRL);

144 __raw_writel(OMAP4_VAL_DEBOUNCINGTIME,

145 keypad_data->base + OMAP4_KBD_DEBOUNCINGTIME);

146 __raw_writel(OMAP4_VAL_IRQDISABLE,

147 keypad_data->base + OMAP4_KBD_IRQSTATUS);

148 __raw_writel(OMAP4_DEF_IRQENABLE_EVENTEN | OMAP4_DEF_IRQENABLE_LONGKEY,

149 keypad_data->base + OMAP4_KBD_IRQENABLE);

150 __raw_writel(OMAP4_DEF_WUP_EVENT_ENA | OMAP4_DEF_WUP_LONG_KEY_ENA,

151 keypad_data->base + OMAP4_KBD_WAKEUPENABLE);

152

153 enable_irq(keypad_data->irq);

154

155 return 0;

156 }

157

158 static void omap4_keypad_close(struct input_dev *input)

159 {

160 struct omap4_keypad *keypad_data = input_get_drvdata(input);

161

162 disable_irq(keypad_data->irq);

163

164 /* Disable interrupts */

165 __raw_writel(OMAP4_VAL_IRQDISABLE,

166 keypad_data->base + OMAP4_KBD_IRQENABLE);

167

168 /* clear pending interrupts */

169 __raw_writel(__raw_readl(keypad_data->base + OMAP4_KBD_IRQSTATUS),

170 keypad_data->base + OMAP4_KBD_IRQSTATUS);

171

172 enable_irq(keypad_data->irq);

173

174 pm_runtime_put_sync(input->dev.parent);

175 }

176

177 static int __devinit omap4_keypad_probe(struct platform_device *pdev)

178 {

179 const struct omap4_keypad_platform_data *pdata;

180 struct omap4_keypad *keypad_data;

181 struct input_dev *input_dev;

182 struct resource *res;

183 resource_size_t size;

184 unsigned int row_shift, max_keys;

185 int irq;

186 int error;

187

188 /* platform data */

189 pdata = pdev->dev.platform_data;

190 if (!pdata) {

191 dev_err(&pdev->dev, "no platform data defined\n");

192 return -EINVAL;

193 }

194

195 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

196 if (!res) {

197 dev_err(&pdev->dev, "no base address specified\n");

198 return -EINVAL;

199 }

200

201 irq = platform_get_irq(pdev, 0);

202 if (!irq) {

203 dev_err(&pdev->dev, "no keyboard irq assigned\n");

204 return -EINVAL;

205 }

206

207 if (!pdata->keymap_data) {

208 dev_err(&pdev->dev, "no keymap data defined\n");

209 return -EINVAL;

210 }

211

212 row_shift = get_count_order(pdata->cols);

213 max_keys = pdata->rows << row_shift;

214

215 keypad_data = kzalloc(sizeof(struct omap4_keypad) +

216 max_keys * sizeof(keypad_data->keymap[0]),

217 GFP_KERNEL);

218 if (!keypad_data) {

219 dev_err(&pdev->dev, "keypad_data memory allocation failed\n");

220 return -ENOMEM;

221 }

222

223 size = resource_size(res);

224

225 res = request_mem_region(res->start, size, pdev->name);

226 if (!res) {

227 dev_err(&pdev->dev, "can't request mem region\n");

228 error = -EBUSY;

229 goto err_free_keypad;

230 }

231

232 keypad_data->base = ioremap(res->start, resource_size(res));

233 if (!keypad_data->base) {

234 dev_err(&pdev->dev, "can't ioremap mem resource\n");

235 error = -ENOMEM;

236 goto err_release_mem;

237 }

238

239 keypad_data->irq = irq;

240 keypad_data->row_shift = row_shift;

241 keypad_data->rows = pdata->rows;

242 keypad_data->cols = pdata->cols;

243

244 /* input device allocation */

245 keypad_data->input = input_dev = input_allocate_device();

246 if (!input_dev) {

247 error = -ENOMEM;

248 goto err_unmap;

249 }

250

251 input_dev->name = pdev->name;

252 input_dev->dev.parent = &pdev->dev;

253 input_dev->id.bustype = BUS_HOST;

254 input_dev->id.vendor = 0x0001;

255 input_dev->id.product = 0x0001;

256 input_dev->id.version = 0x0001;

257

258 input_dev->open = omap4_keypad_open;

259 input_dev->close = omap4_keypad_close;

260

261 input_dev->keycode = keypad_data->keymap;

262 input_dev->keycodesize = sizeof(keypad_data->keymap[0]);

263 input_dev->keycodemax = max_keys;

264

265 __set_bit(EV_KEY, input_dev->evbit);

266 __set_bit(EV_REP, input_dev->evbit);

267

268 input_set_capability(input_dev, EV_MSC, MSC_SCAN);

269

270 input_set_drvdata(input_dev, keypad_data);

271

272 matrix_keypad_build_keymap(pdata->keymap_data, row_shift,

273 input_dev->keycode, input_dev->keybit);

274

275 error = request_irq(keypad_data->irq, omap4_keypad_interrupt,

276 IRQF_TRIGGER_RISING,

277 "omap4-keypad", keypad_data);

278 if (error) {

279 dev_err(&pdev->dev, "failed to register interrupt\n");

280 goto err_free_input;

281 }

282

283 pm_runtime_enable(&pdev->dev);

284

285 error = input_register_device(keypad_data->input);

286 if (error < 0) {

287 dev_err(&pdev->dev, "failed to register input device\n");

288 goto err_pm_disable;

289 }

290

291 platform_set_drvdata(pdev, keypad_data);

292 return 0;

293

294 err_pm_disable:

295 pm_runtime_disable(&pdev->dev);

296 free_irq(keypad_data->irq, keypad_data);

297 err_free_input:

298 input_free_device(input_dev);

299 err_unmap:

300 iounmap(keypad_data->base);

301 err_release_mem:

302 release_mem_region(res->start, size);

303 err_free_keypad:

304 kfree(keypad_data);

305 return error;

306 }

307

308 static int __devexit omap4_keypad_remove(struct platform_device *pdev)

309 {

310 struct omap4_keypad *keypad_data = platform_get_drvdata(pdev);

311 struct resource *res;

312

313 free_irq(keypad_data->irq, keypad_data);

314

315 pm_runtime_disable(&pdev->dev);

316

317 input_unregister_device(keypad_data->input);

318

319 iounmap(keypad_data->base);

320

321 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

322 release_mem_region(res->start, resource_size(res));

323

324 kfree(keypad_data);

325 platform_set_drvdata(pdev, NULL);

326

327 return 0;

328 }

329

330 static struct platform_driver omap4_keypad_driver = {

331 .probe = omap4_keypad_probe,

332 .remove = __devexit_p(omap4_keypad_remove),

333 .driver = {

334 .name = "omap4-keypad",

335 .owner = THIS_MODULE,

336 },

337 };

338 module_platform_driver(omap4_keypad_driver);

339

340 MODULE_AUTHOR("Texas Instruments");

341 MODULE_DESCRIPTION("OMAP4 Keypad Driver");

342 MODULE_LICENSE("GPL");

343 MODULE_ALIAS("platform:omap4-keypad");