www.infradead.org Git - users/dwmw2/linux.git/blob

1 // SPDX-License-Identifier: GPL-2.0-only

2 /*

3 * pca9532.c - 16-bit Led dimmer

4 *

7 *

8 * Datasheet: http://www.nxp.com/documents/data_sheet/PCA9532.pdf

9 */

11 #include <linux/module.h>

12 #include <linux/i2c.h>

13 #include <linux/slab.h>

14 #include <linux/leds.h>

15 #include <linux/input.h>

16 #include <linux/mutex.h>

17 #include <linux/workqueue.h>

18 #include <linux/leds-pca9532.h>

19 #include <linux/gpio.h>

20 #include <linux/of.h>

21 #include <linux/of_device.h>

23 /* m = num_leds*/

24 #define PCA9532_REG_INPUT(i) ((i) >> 3)

25 #define PCA9532_REG_OFFSET(m) ((m) >> 4)

26 #define PCA9532_REG_PSC(m, i) (PCA9532_REG_OFFSET(m) + 0x1 + (i) * 2)

27 #define PCA9532_REG_PWM(m, i) (PCA9532_REG_OFFSET(m) + 0x2 + (i) * 2)

28 #define LED_REG(m, led) (PCA9532_REG_OFFSET(m) + 0x5 + (led >> 2))

29 #define LED_NUM(led) (led & 0x3)

31 #define ldev_to_led(c) container_of(c, struct pca9532_led, ldev)

33 struct pca9532_chip_info {

34 u8 num_leds;

35 };

37 struct pca9532_data {

38 struct i2c_client *client;

39 struct pca9532_led leds[16];

40 struct mutex update_lock;

41 struct input_dev *idev;

42 struct work_struct work;

43 #ifdef CONFIG_LEDS_PCA9532_GPIO

44 struct gpio_chip gpio;

45 #endif

46 const struct pca9532_chip_info *chip_info;

47 u8 pwm[2];

48 u8 psc[2];

49 };

51 static int pca9532_probe(struct i2c_client *client,

52 const struct i2c_device_id *id);

53 static int pca9532_remove(struct i2c_client *client);

55 enum {

56 pca9530,

57 pca9531,

58 pca9532,

59 pca9533,

60 };

62 static const struct i2c_device_id pca9532_id[] = {

63 { "pca9530", pca9530 },

64 { "pca9531", pca9531 },

65 { "pca9532", pca9532 },

66 { "pca9533", pca9533 },

67 { }

68 };

70 MODULE_DEVICE_TABLE(i2c, pca9532_id);

72 static const struct pca9532_chip_info pca9532_chip_info_tbl[] = {

73 [pca9530] = {

74 .num_leds = 2,

75 },

76 [pca9531] = {

77 .num_leds = 8,

78 },

79 [pca9532] = {

80 .num_leds = 16,

81 },

82 [pca9533] = {

83 .num_leds = 4,

84 },

85 };

87 #ifdef CONFIG_OF

88 static const struct of_device_id of_pca9532_leds_match[] = {

89 { .compatible = "nxp,pca9530", .data = (void *)pca9530 },

90 { .compatible = "nxp,pca9531", .data = (void *)pca9531 },

91 { .compatible = "nxp,pca9532", .data = (void *)pca9532 },

92 { .compatible = "nxp,pca9533", .data = (void *)pca9533 },

93 {},

94 };

96 MODULE_DEVICE_TABLE(of, of_pca9532_leds_match);

97 #endif

99 static struct i2c_driver pca9532_driver = {

100 .driver = {

101 .name = "leds-pca953x",

102 .of_match_table = of_match_ptr(of_pca9532_leds_match),

103 },

104 .probe = pca9532_probe,

105 .remove = pca9532_remove,

106 .id_table = pca9532_id,

107 };

108

109 /* We have two pwm/blinkers, but 16 possible leds to drive. Additionally,

110 * the clever Thecus people are using one pwm to drive the beeper. So,

111 * as a compromise we average one pwm to the values requested by all

112 * leds that are not ON/OFF.

113 * */

114 static int pca9532_calcpwm(struct i2c_client *client, int pwm, int blink,

115 enum led_brightness value)

116 {

117 int a = 0, b = 0, i = 0;

118 struct pca9532_data *data = i2c_get_clientdata(client);

119 for (i = 0; i < data->chip_info->num_leds; i++) {

120 if (data->leds[i].type == PCA9532_TYPE_LED &&

121 data->leds[i].state == PCA9532_PWM0+pwm) {

122 a++;

123 b += data->leds[i].ldev.brightness;

124 }

125 }

126 if (a == 0) {

127 dev_err(&client->dev,

128 "fear of division by zero %d/%d, wanted %d\n",

129 b, a, value);

130 return -EINVAL;

131 }

132 b = b/a;

133 if (b > 0xFF)

134 return -EINVAL;

135 data->pwm[pwm] = b;

136 data->psc[pwm] = blink;

137 return 0;

138 }

139

140 static int pca9532_setpwm(struct i2c_client *client, int pwm)

141 {

142 struct pca9532_data *data = i2c_get_clientdata(client);

143 u8 maxleds = data->chip_info->num_leds;

144

145 mutex_lock(&data->update_lock);

146 i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(maxleds, pwm),

147 data->pwm[pwm]);

148 i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(maxleds, pwm),

149 data->psc[pwm]);

150 mutex_unlock(&data->update_lock);

151 return 0;

152 }

153

154 /* Set LED routing */

155 static void pca9532_setled(struct pca9532_led *led)

156 {

157 struct i2c_client *client = led->client;

158 struct pca9532_data *data = i2c_get_clientdata(client);

159 u8 maxleds = data->chip_info->num_leds;

160 char reg;

161

162 mutex_lock(&data->update_lock);

163 reg = i2c_smbus_read_byte_data(client, LED_REG(maxleds, led->id));

164 /* zero led bits */

165 reg = reg & ~(0x3<<LED_NUM(led->id)*2);

166 /* set the new value */

167 reg = reg | (led->state << LED_NUM(led->id)*2);

168 i2c_smbus_write_byte_data(client, LED_REG(maxleds, led->id), reg);

169 mutex_unlock(&data->update_lock);

170 }

171

172 static int pca9532_set_brightness(struct led_classdev *led_cdev,

173 enum led_brightness value)

174 {

175 int err = 0;

176 struct pca9532_led *led = ldev_to_led(led_cdev);

177

178 if (value == LED_OFF)

179 led->state = PCA9532_OFF;

180 else if (value == LED_FULL)

181 led->state = PCA9532_ON;

182 else {

183 led->state = PCA9532_PWM0; /* Thecus: hardcode one pwm */

184 err = pca9532_calcpwm(led->client, 0, 0, value);

185 if (err)

186 return err;

187 }

188 if (led->state == PCA9532_PWM0)

189 pca9532_setpwm(led->client, 0);

190 pca9532_setled(led);

191 return err;

192 }

193

194 static int pca9532_set_blink(struct led_classdev *led_cdev,

195 unsigned long *delay_on, unsigned long *delay_off)

196 {

197 struct pca9532_led *led = ldev_to_led(led_cdev);

198 struct i2c_client *client = led->client;

199 int psc;

200 int err = 0;

201

202 if (*delay_on == 0 && *delay_off == 0) {

203 /* led subsystem ask us for a blink rate */

204 *delay_on = 1000;

205 *delay_off = 1000;

206 }

207 if (*delay_on != *delay_off || *delay_on > 1690 || *delay_on < 6)

208 return -EINVAL;

209

210 /* Thecus specific: only use PSC/PWM 0 */

211 psc = (*delay_on * 152-1)/1000;

212 err = pca9532_calcpwm(client, 0, psc, led_cdev->brightness);

213 if (err)

214 return err;

215 if (led->state == PCA9532_PWM0)

216 pca9532_setpwm(led->client, 0);

217 pca9532_setled(led);

218

219 return 0;

220 }

221

222 static int pca9532_event(struct input_dev *dev, unsigned int type,

223 unsigned int code, int value)

224 {

225 struct pca9532_data *data = input_get_drvdata(dev);

226

227 if (!(type == EV_SND && (code == SND_BELL || code == SND_TONE)))

228 return -1;

229

230 /* XXX: allow different kind of beeps with psc/pwm modifications */

231 if (value > 1 && value < 32767)

232 data->pwm[1] = 127;

233 else

234 data->pwm[1] = 0;

235

236 schedule_work(&data->work);

237

238 return 0;

239 }

240

241 static void pca9532_input_work(struct work_struct *work)

242 {

243 struct pca9532_data *data =

244 container_of(work, struct pca9532_data, work);

245 u8 maxleds = data->chip_info->num_leds;

246

247 mutex_lock(&data->update_lock);

248 i2c_smbus_write_byte_data(data->client, PCA9532_REG_PWM(maxleds, 1),

249 data->pwm[1]);

250 mutex_unlock(&data->update_lock);

251 }

252

253 static enum pca9532_state pca9532_getled(struct pca9532_led *led)

254 {

255 struct i2c_client *client = led->client;

256 struct pca9532_data *data = i2c_get_clientdata(client);

257 u8 maxleds = data->chip_info->num_leds;

258 char reg;

259 enum pca9532_state ret;

260

261 mutex_lock(&data->update_lock);

262 reg = i2c_smbus_read_byte_data(client, LED_REG(maxleds, led->id));

263 ret = reg >> LED_NUM(led->id)/2;

264 mutex_unlock(&data->update_lock);

265 return ret;

266 }

267

268 #ifdef CONFIG_LEDS_PCA9532_GPIO

269 static int pca9532_gpio_request_pin(struct gpio_chip *gc, unsigned offset)

270 {

271 struct pca9532_data *data = gpiochip_get_data(gc);

272 struct pca9532_led *led = &data->leds[offset];

273

274 if (led->type == PCA9532_TYPE_GPIO)

275 return 0;

276

277 return -EBUSY;

278 }

279

280 static void pca9532_gpio_set_value(struct gpio_chip *gc, unsigned offset, int val)

281 {

282 struct pca9532_data *data = gpiochip_get_data(gc);

283 struct pca9532_led *led = &data->leds[offset];

284

285 if (val)

286 led->state = PCA9532_ON;

287 else

288 led->state = PCA9532_OFF;

289

290 pca9532_setled(led);

291 }

292

293 static int pca9532_gpio_get_value(struct gpio_chip *gc, unsigned offset)

294 {

295 struct pca9532_data *data = gpiochip_get_data(gc);

296 unsigned char reg;

297

298 reg = i2c_smbus_read_byte_data(data->client, PCA9532_REG_INPUT(offset));

299

300 return !!(reg & (1 << (offset % 8)));

301 }

302

303 static int pca9532_gpio_direction_input(struct gpio_chip *gc, unsigned offset)

304 {

305 /* To use as input ensure pin is not driven */

306 pca9532_gpio_set_value(gc, offset, 0);

307

308 return 0;

309 }

310

311 static int pca9532_gpio_direction_output(struct gpio_chip *gc, unsigned offset, int val)

312 {

313 pca9532_gpio_set_value(gc, offset, val);

314

315 return 0;

316 }

317 #endif /* CONFIG_LEDS_PCA9532_GPIO */

318

319 static int pca9532_destroy_devices(struct pca9532_data *data, int n_devs)

320 {

321 int i = n_devs;

322

323 if (!data)

324 return -EINVAL;

325

326 while (--i >= 0) {

327 switch (data->leds[i].type) {

328 case PCA9532_TYPE_NONE:

329 case PCA9532_TYPE_GPIO:

330 break;

331 case PCA9532_TYPE_LED:

332 led_classdev_unregister(&data->leds[i].ldev);

333 break;

334 case PCA9532_TYPE_N2100_BEEP:

335 if (data->idev != NULL) {

336 cancel_work_sync(&data->work);

337 data->idev = NULL;

338 }

339 break;

340 }

341 }

342

343 #ifdef CONFIG_LEDS_PCA9532_GPIO

344 if (data->gpio.parent)

345 gpiochip_remove(&data->gpio);

346 #endif

347

348 return 0;

349 }

350

351 static int pca9532_configure(struct i2c_client *client,

352 struct pca9532_data *data, struct pca9532_platform_data *pdata)

353 {

354 int i, err = 0;

355 int gpios = 0;

356 u8 maxleds = data->chip_info->num_leds;

357

358 for (i = 0; i < 2; i++) {

359 data->pwm[i] = pdata->pwm[i];

360 data->psc[i] = pdata->psc[i];

361 i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(maxleds, i),

362 data->pwm[i]);

363 i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(maxleds, i),

364 data->psc[i]);

365 }

366

367 for (i = 0; i < data->chip_info->num_leds; i++) {

368 struct pca9532_led *led = &data->leds[i];

369 struct pca9532_led *pled = &pdata->leds[i];

370 led->client = client;

371 led->id = i;

372 led->type = pled->type;

373 switch (led->type) {

374 case PCA9532_TYPE_NONE:

375 break;

376 case PCA9532_TYPE_GPIO:

377 gpios++;

378 break;

379 case PCA9532_TYPE_LED:

380 if (pled->state == PCA9532_KEEP)

381 led->state = pca9532_getled(led);

382 else

383 led->state = pled->state;

384 led->name = pled->name;

385 led->ldev.name = led->name;

386 led->ldev.default_trigger = pled->default_trigger;

387 led->ldev.brightness = LED_OFF;

388 led->ldev.brightness_set_blocking =

389 pca9532_set_brightness;

390 led->ldev.blink_set = pca9532_set_blink;

391 err = led_classdev_register(&client->dev, &led->ldev);

392 if (err < 0) {

393 dev_err(&client->dev,

394 "couldn't register LED %s\n",

395 led->name);

396 goto exit;

397 }

398 pca9532_setled(led);

399 break;

400 case PCA9532_TYPE_N2100_BEEP:

401 BUG_ON(data->idev);

402 led->state = PCA9532_PWM1;

403 pca9532_setled(led);

404 data->idev = devm_input_allocate_device(&client->dev);

405 if (data->idev == NULL) {

406 err = -ENOMEM;

407 goto exit;

408 }

409 data->idev->name = pled->name;

410 data->idev->phys = "i2c/pca9532";

411 data->idev->id.bustype = BUS_HOST;

412 data->idev->id.vendor = 0x001f;

413 data->idev->id.product = 0x0001;

414 data->idev->id.version = 0x0100;

415 data->idev->evbit[0] = BIT_MASK(EV_SND);

416 data->idev->sndbit[0] = BIT_MASK(SND_BELL) |

417 BIT_MASK(SND_TONE);

418 data->idev->event = pca9532_event;

419 input_set_drvdata(data->idev, data);

420 INIT_WORK(&data->work, pca9532_input_work);

421 err = input_register_device(data->idev);

422 if (err) {

423 cancel_work_sync(&data->work);

424 data->idev = NULL;

425 goto exit;

426 }

427 break;

428 }

429 }

430

431 #ifdef CONFIG_LEDS_PCA9532_GPIO

432 if (gpios) {

433 data->gpio.label = "gpio-pca9532";

434 data->gpio.direction_input = pca9532_gpio_direction_input;

435 data->gpio.direction_output = pca9532_gpio_direction_output;

436 data->gpio.set = pca9532_gpio_set_value;

437 data->gpio.get = pca9532_gpio_get_value;

438 data->gpio.request = pca9532_gpio_request_pin;

439 data->gpio.can_sleep = 1;

440 data->gpio.base = pdata->gpio_base;

441 data->gpio.ngpio = data->chip_info->num_leds;

442 data->gpio.parent = &client->dev;

443 data->gpio.owner = THIS_MODULE;

444

445 err = gpiochip_add_data(&data->gpio, data);

446 if (err) {

447 /* Use data->gpio.dev as a flag for freeing gpiochip */

448 data->gpio.parent = NULL;

449 dev_warn(&client->dev, "could not add gpiochip\n");

450 } else {

451 dev_info(&client->dev, "gpios %i...%i\n",

452 data->gpio.base, data->gpio.base +

453 data->gpio.ngpio - 1);

454 }

455 }

456 #endif

457

458 return 0;

459

460 exit:

461 pca9532_destroy_devices(data, i);

462 return err;

463 }

464

465 static struct pca9532_platform_data *

466 pca9532_of_populate_pdata(struct device *dev, struct device_node *np)

467 {

468 struct pca9532_platform_data *pdata;

469 struct device_node *child;

470 const struct of_device_id *match;

471 int devid, maxleds;

472 int i = 0;

473 const char *state;

474

475 match = of_match_device(of_pca9532_leds_match, dev);

476 if (!match)

477 return ERR_PTR(-ENODEV);

478

479 devid = (int)(uintptr_t)match->data;

480 maxleds = pca9532_chip_info_tbl[devid].num_leds;

481

482 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);

483 if (!pdata)

484 return ERR_PTR(-ENOMEM);

485

486 for_each_child_of_node(np, child) {

487 if (of_property_read_string(child, "label",

488 &pdata->leds[i].name))

489 pdata->leds[i].name = child->name;

490 of_property_read_u32(child, "type", &pdata->leds[i].type);

491 of_property_read_string(child, "linux,default-trigger",

492 &pdata->leds[i].default_trigger);

493 if (!of_property_read_string(child, "default-state", &state)) {

494 if (!strcmp(state, "on"))

495 pdata->leds[i].state = PCA9532_ON;

496 else if (!strcmp(state, "keep"))

497 pdata->leds[i].state = PCA9532_KEEP;

498 }

499 if (++i >= maxleds) {

500 of_node_put(child);

501 break;

502 }

503 }

504

505 return pdata;

506 }

507

508 static int pca9532_probe(struct i2c_client *client,

509 const struct i2c_device_id *id)

510 {

511 int devid;

512 const struct of_device_id *of_id;

513 struct pca9532_data *data = i2c_get_clientdata(client);

514 struct pca9532_platform_data *pca9532_pdata =

515 dev_get_platdata(&client->dev);

516 struct device_node *np = client->dev.of_node;

517

518 if (!pca9532_pdata) {

519 if (np) {

520 pca9532_pdata =

521 pca9532_of_populate_pdata(&client->dev, np);

522 if (IS_ERR(pca9532_pdata))

523 return PTR_ERR(pca9532_pdata);

524 } else {

525 dev_err(&client->dev, "no platform data\n");

526 return -EINVAL;

527 }

528 of_id = of_match_device(of_pca9532_leds_match,

529 &client->dev);

530 if (unlikely(!of_id))

531 return -EINVAL;

532 devid = (int)(uintptr_t) of_id->data;

533 } else {

534 devid = id->driver_data;

535 }

536

537 if (!i2c_check_functionality(client->adapter,

538 I2C_FUNC_SMBUS_BYTE_DATA))

539 return -EIO;

540

541 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);

542 if (!data)

543 return -ENOMEM;

544

545 data->chip_info = &pca9532_chip_info_tbl[devid];

546

547 dev_info(&client->dev, "setting platform data\n");

548 i2c_set_clientdata(client, data);

549 data->client = client;

550 mutex_init(&data->update_lock);

551

552 return pca9532_configure(client, data, pca9532_pdata);

553 }

554

555 static int pca9532_remove(struct i2c_client *client)

556 {

557 struct pca9532_data *data = i2c_get_clientdata(client);

558 int err;

559

560 err = pca9532_destroy_devices(data, data->chip_info->num_leds);

561 if (err)

562 return err;

563

564 return 0;

565 }

566

567 module_i2c_driver(pca9532_driver);

568

569 MODULE_AUTHOR("Riku Voipio");

570 MODULE_LICENSE("GPL");

571 MODULE_DESCRIPTION("PCA 9532 LED dimmer");