1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright 2007-2008 Extreme Engineering Solutions, Inc. 4 * 5 * Author: Nate Case <ncase@xes-inc.com> 6 * 7 * LED driver for various PCA955x I2C LED drivers 8 * 9 * Supported devices: 10 * 11 * Device Description 7-bit slave address 12 * ------ ----------- ------------------- 13 * PCA9550 2-bit driver 0x60 .. 0x61 14 * PCA9551 8-bit driver 0x60 .. 0x67 15 * PCA9552 16-bit driver 0x60 .. 0x67 16 * PCA9553/01 4-bit driver 0x62 17 * PCA9553/02 4-bit driver 0x63 18 * 19 * Philips PCA955x LED driver chips follow a register map as shown below: 20 * 21 * Control Register Description 22 * ---------------- ----------- 23 * 0x0 Input register 0 24 * .. 25 * NUM_INPUT_REGS - 1 Last Input register X 26 * 27 * NUM_INPUT_REGS Frequency prescaler 0 28 * NUM_INPUT_REGS + 1 PWM register 0 29 * NUM_INPUT_REGS + 2 Frequency prescaler 1 30 * NUM_INPUT_REGS + 3 PWM register 1 31 * 32 * NUM_INPUT_REGS + 4 LED selector 0 33 * NUM_INPUT_REGS + 4 34 * + NUM_LED_REGS - 1 Last LED selector 35 * 36 * where NUM_INPUT_REGS and NUM_LED_REGS vary depending on how many 37 * bits the chip supports. 38 */ 39 40 #include <linux/bitops.h> 41 #include <linux/ctype.h> 42 #include <linux/delay.h> 43 #include <linux/err.h> 44 #include <linux/gpio/driver.h> 45 #include <linux/i2c.h> 46 #include <linux/leds.h> 47 #include <linux/module.h> 48 #include <linux/of.h> 49 #include <linux/property.h> 50 #include <linux/slab.h> 51 #include <linux/string.h> 52 53 #include <dt-bindings/leds/leds-pca955x.h> 54 55 /* LED select registers determine the source that drives LED outputs */ 56 #define PCA955X_LS_LED_ON 0x0 /* Output LOW */ 57 #define PCA955X_LS_LED_OFF 0x1 /* Output HI-Z */ 58 #define PCA955X_LS_BLINK0 0x2 /* Blink at PWM0 rate */ 59 #define PCA955X_LS_BLINK1 0x3 /* Blink at PWM1 rate */ 60 61 #define PCA955X_GPIO_INPUT LED_OFF 62 #define PCA955X_GPIO_HIGH LED_OFF 63 #define PCA955X_GPIO_LOW LED_FULL 64 65 enum pca955x_type { 66 pca9550, 67 pca9551, 68 pca9552, 69 ibm_pca9552, 70 pca9553, 71 }; 72 73 struct pca955x_chipdef { 74 int bits; 75 u8 slv_addr; /* 7-bit slave address mask */ 76 int slv_addr_shift; /* Number of bits to ignore */ 77 }; 78 79 static struct pca955x_chipdef pca955x_chipdefs[] = { 80 [pca9550] = { 81 .bits = 2, 82 .slv_addr = /* 110000x */ 0x60, 83 .slv_addr_shift = 1, 84 }, 85 [pca9551] = { 86 .bits = 8, 87 .slv_addr = /* 1100xxx */ 0x60, 88 .slv_addr_shift = 3, 89 }, 90 [pca9552] = { 91 .bits = 16, 92 .slv_addr = /* 1100xxx */ 0x60, 93 .slv_addr_shift = 3, 94 }, 95 [ibm_pca9552] = { 96 .bits = 16, 97 .slv_addr = /* 0110xxx */ 0x30, 98 .slv_addr_shift = 3, 99 }, 100 [pca9553] = { 101 .bits = 4, 102 .slv_addr = /* 110001x */ 0x62, 103 .slv_addr_shift = 1, 104 }, 105 }; 106 107 static const struct i2c_device_id pca955x_id[] = { 108 { "pca9550", pca9550 }, 109 { "pca9551", pca9551 }, 110 { "pca9552", pca9552 }, 111 { "ibm-pca9552", ibm_pca9552 }, 112 { "pca9553", pca9553 }, 113 { } 114 }; 115 MODULE_DEVICE_TABLE(i2c, pca955x_id); 116 117 struct pca955x { 118 struct mutex lock; 119 struct pca955x_led *leds; 120 struct pca955x_chipdef *chipdef; 121 struct i2c_client *client; 122 unsigned long active_pins; 123 #ifdef CONFIG_LEDS_PCA955X_GPIO 124 struct gpio_chip gpio; 125 #endif 126 }; 127 128 struct pca955x_led { 129 struct pca955x *pca955x; 130 struct led_classdev led_cdev; 131 int led_num; /* 0 .. 15 potentially */ 132 u32 type; 133 int default_state; 134 struct fwnode_handle *fwnode; 135 }; 136 137 struct pca955x_platform_data { 138 struct pca955x_led *leds; 139 int num_leds; 140 }; 141 142 /* 8 bits per input register */ 143 static inline int pca95xx_num_input_regs(int bits) 144 { 145 return (bits + 7) / 8; 146 } 147 148 /* 4 bits per LED selector register */ 149 static inline int pca95xx_num_led_regs(int bits) 150 { 151 return (bits + 3) / 4; 152 } 153 154 /* 155 * Return an LED selector register value based on an existing one, with 156 * the appropriate 2-bit state value set for the given LED number (0-3). 157 */ 158 static inline u8 pca955x_ledsel(u8 oldval, int led_num, int state) 159 { 160 return (oldval & (~(0x3 << (led_num << 1)))) | 161 ((state & 0x3) << (led_num << 1)); 162 } 163 164 /* 165 * Write to frequency prescaler register, used to program the 166 * period of the PWM output. period = (PSCx + 1) / 38 167 */ 168 static int pca955x_write_psc(struct i2c_client *client, int n, u8 val) 169 { 170 struct pca955x *pca955x = i2c_get_clientdata(client); 171 u8 cmd = pca95xx_num_input_regs(pca955x->chipdef->bits) + (2 * n); 172 int ret; 173 174 ret = i2c_smbus_write_byte_data(client, cmd, val); 175 if (ret < 0) 176 dev_err(&client->dev, "%s: reg 0x%x, val 0x%x, err %d\n", 177 __func__, n, val, ret); 178 return ret; 179 } 180 181 /* 182 * Write to PWM register, which determines the duty cycle of the 183 * output. LED is OFF when the count is less than the value of this 184 * register, and ON when it is greater. If PWMx == 0, LED is always OFF. 185 * 186 * Duty cycle is (256 - PWMx) / 256 187 */ 188 static int pca955x_write_pwm(struct i2c_client *client, int n, u8 val) 189 { 190 struct pca955x *pca955x = i2c_get_clientdata(client); 191 u8 cmd = pca95xx_num_input_regs(pca955x->chipdef->bits) + 1 + (2 * n); 192 int ret; 193 194 ret = i2c_smbus_write_byte_data(client, cmd, val); 195 if (ret < 0) 196 dev_err(&client->dev, "%s: reg 0x%x, val 0x%x, err %d\n", 197 __func__, n, val, ret); 198 return ret; 199 } 200 201 /* 202 * Write to LED selector register, which determines the source that 203 * drives the LED output. 204 */ 205 static int pca955x_write_ls(struct i2c_client *client, int n, u8 val) 206 { 207 struct pca955x *pca955x = i2c_get_clientdata(client); 208 u8 cmd = pca95xx_num_input_regs(pca955x->chipdef->bits) + 4 + n; 209 int ret; 210 211 ret = i2c_smbus_write_byte_data(client, cmd, val); 212 if (ret < 0) 213 dev_err(&client->dev, "%s: reg 0x%x, val 0x%x, err %d\n", 214 __func__, n, val, ret); 215 return ret; 216 } 217 218 /* 219 * Read the LED selector register, which determines the source that 220 * drives the LED output. 221 */ 222 static int pca955x_read_ls(struct i2c_client *client, int n, u8 *val) 223 { 224 struct pca955x *pca955x = i2c_get_clientdata(client); 225 u8 cmd = pca95xx_num_input_regs(pca955x->chipdef->bits) + 4 + n; 226 int ret; 227 228 ret = i2c_smbus_read_byte_data(client, cmd); 229 if (ret < 0) { 230 dev_err(&client->dev, "%s: reg 0x%x, err %d\n", 231 __func__, n, ret); 232 return ret; 233 } 234 *val = (u8)ret; 235 return 0; 236 } 237 238 static int pca955x_read_pwm(struct i2c_client *client, int n, u8 *val) 239 { 240 struct pca955x *pca955x = i2c_get_clientdata(client); 241 u8 cmd = pca95xx_num_input_regs(pca955x->chipdef->bits) + 1 + (2 * n); 242 int ret; 243 244 ret = i2c_smbus_read_byte_data(client, cmd); 245 if (ret < 0) { 246 dev_err(&client->dev, "%s: reg 0x%x, err %d\n", 247 __func__, n, ret); 248 return ret; 249 } 250 *val = (u8)ret; 251 return 0; 252 } 253 254 static enum led_brightness pca955x_led_get(struct led_classdev *led_cdev) 255 { 256 struct pca955x_led *pca955x_led = container_of(led_cdev, 257 struct pca955x_led, 258 led_cdev); 259 struct pca955x *pca955x = pca955x_led->pca955x; 260 u8 ls, pwm; 261 int ret; 262 263 ret = pca955x_read_ls(pca955x->client, pca955x_led->led_num / 4, &ls); 264 if (ret) 265 return ret; 266 267 ls = (ls >> ((pca955x_led->led_num % 4) << 1)) & 0x3; 268 switch (ls) { 269 case PCA955X_LS_LED_ON: 270 ret = LED_FULL; 271 break; 272 case PCA955X_LS_LED_OFF: 273 ret = LED_OFF; 274 break; 275 case PCA955X_LS_BLINK0: 276 ret = LED_HALF; 277 break; 278 case PCA955X_LS_BLINK1: 279 ret = pca955x_read_pwm(pca955x->client, 1, &pwm); 280 if (ret) 281 return ret; 282 ret = 255 - pwm; 283 break; 284 } 285 286 return ret; 287 } 288 289 static int pca955x_led_set(struct led_classdev *led_cdev, 290 enum led_brightness value) 291 { 292 struct pca955x_led *pca955x_led; 293 struct pca955x *pca955x; 294 u8 ls; 295 int chip_ls; /* which LSx to use (0-3 potentially) */ 296 int ls_led; /* which set of bits within LSx to use (0-3) */ 297 int ret; 298 299 pca955x_led = container_of(led_cdev, struct pca955x_led, led_cdev); 300 pca955x = pca955x_led->pca955x; 301 302 chip_ls = pca955x_led->led_num / 4; 303 ls_led = pca955x_led->led_num % 4; 304 305 mutex_lock(&pca955x->lock); 306 307 ret = pca955x_read_ls(pca955x->client, chip_ls, &ls); 308 if (ret) 309 goto out; 310 311 switch (value) { 312 case LED_FULL: 313 ls = pca955x_ledsel(ls, ls_led, PCA955X_LS_LED_ON); 314 break; 315 case LED_OFF: 316 ls = pca955x_ledsel(ls, ls_led, PCA955X_LS_LED_OFF); 317 break; 318 case LED_HALF: 319 ls = pca955x_ledsel(ls, ls_led, PCA955X_LS_BLINK0); 320 break; 321 default: 322 /* 323 * Use PWM1 for all other values. This has the unwanted 324 * side effect of making all LEDs on the chip share the 325 * same brightness level if set to a value other than 326 * OFF, HALF, or FULL. But, this is probably better than 327 * just turning off for all other values. 328 */ 329 ret = pca955x_write_pwm(pca955x->client, 1, 255 - value); 330 if (ret) 331 goto out; 332 ls = pca955x_ledsel(ls, ls_led, PCA955X_LS_BLINK1); 333 break; 334 } 335 336 ret = pca955x_write_ls(pca955x->client, chip_ls, ls); 337 338 out: 339 mutex_unlock(&pca955x->lock); 340 341 return ret; 342 } 343 344 #ifdef CONFIG_LEDS_PCA955X_GPIO 345 /* 346 * Read the INPUT register, which contains the state of LEDs. 347 */ 348 static int pca955x_read_input(struct i2c_client *client, int n, u8 *val) 349 { 350 int ret = i2c_smbus_read_byte_data(client, n); 351 352 if (ret < 0) { 353 dev_err(&client->dev, "%s: reg 0x%x, err %d\n", 354 __func__, n, ret); 355 return ret; 356 } 357 *val = (u8)ret; 358 return 0; 359 360 } 361 362 static int pca955x_gpio_request_pin(struct gpio_chip *gc, unsigned int offset) 363 { 364 struct pca955x *pca955x = gpiochip_get_data(gc); 365 366 return test_and_set_bit(offset, &pca955x->active_pins) ? -EBUSY : 0; 367 } 368 369 static void pca955x_gpio_free_pin(struct gpio_chip *gc, unsigned int offset) 370 { 371 struct pca955x *pca955x = gpiochip_get_data(gc); 372 373 clear_bit(offset, &pca955x->active_pins); 374 } 375 376 static int pca955x_set_value(struct gpio_chip *gc, unsigned int offset, 377 int val) 378 { 379 struct pca955x *pca955x = gpiochip_get_data(gc); 380 struct pca955x_led *led = &pca955x->leds[offset]; 381 382 if (val) 383 return pca955x_led_set(&led->led_cdev, PCA955X_GPIO_HIGH); 384 385 return pca955x_led_set(&led->led_cdev, PCA955X_GPIO_LOW); 386 } 387 388 static void pca955x_gpio_set_value(struct gpio_chip *gc, unsigned int offset, 389 int val) 390 { 391 pca955x_set_value(gc, offset, val); 392 } 393 394 static int pca955x_gpio_get_value(struct gpio_chip *gc, unsigned int offset) 395 { 396 struct pca955x *pca955x = gpiochip_get_data(gc); 397 struct pca955x_led *led = &pca955x->leds[offset]; 398 u8 reg = 0; 399 400 /* There is nothing we can do about errors */ 401 pca955x_read_input(pca955x->client, led->led_num / 8, ®); 402 403 return !!(reg & (1 << (led->led_num % 8))); 404 } 405 406 static int pca955x_gpio_direction_input(struct gpio_chip *gc, 407 unsigned int offset) 408 { 409 struct pca955x *pca955x = gpiochip_get_data(gc); 410 struct pca955x_led *led = &pca955x->leds[offset]; 411 412 /* To use as input ensure pin is not driven. */ 413 return pca955x_led_set(&led->led_cdev, PCA955X_GPIO_INPUT); 414 } 415 416 static int pca955x_gpio_direction_output(struct gpio_chip *gc, 417 unsigned int offset, int val) 418 { 419 return pca955x_set_value(gc, offset, val); 420 } 421 #endif /* CONFIG_LEDS_PCA955X_GPIO */ 422 423 static struct pca955x_platform_data * 424 pca955x_get_pdata(struct i2c_client *client, struct pca955x_chipdef *chip) 425 { 426 struct pca955x_platform_data *pdata; 427 struct pca955x_led *led; 428 struct fwnode_handle *child; 429 int count; 430 431 count = device_get_child_node_count(&client->dev); 432 if (count > chip->bits) 433 return ERR_PTR(-ENODEV); 434 435 pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL); 436 if (!pdata) 437 return ERR_PTR(-ENOMEM); 438 439 pdata->leds = devm_kcalloc(&client->dev, 440 chip->bits, sizeof(struct pca955x_led), 441 GFP_KERNEL); 442 if (!pdata->leds) 443 return ERR_PTR(-ENOMEM); 444 445 device_for_each_child_node(&client->dev, child) { 446 const char *state; 447 u32 reg; 448 int res; 449 450 res = fwnode_property_read_u32(child, "reg", ®); 451 if ((res != 0) || (reg >= chip->bits)) 452 continue; 453 454 led = &pdata->leds[reg]; 455 led->type = PCA955X_TYPE_LED; 456 led->fwnode = child; 457 fwnode_property_read_u32(child, "type", &led->type); 458 459 if (!fwnode_property_read_string(child, "default-state", 460 &state)) { 461 if (!strcmp(state, "keep")) 462 led->default_state = LEDS_GPIO_DEFSTATE_KEEP; 463 else if (!strcmp(state, "on")) 464 led->default_state = LEDS_GPIO_DEFSTATE_ON; 465 else 466 led->default_state = LEDS_GPIO_DEFSTATE_OFF; 467 } else { 468 led->default_state = LEDS_GPIO_DEFSTATE_OFF; 469 } 470 } 471 472 pdata->num_leds = chip->bits; 473 474 return pdata; 475 } 476 477 static const struct of_device_id of_pca955x_match[] = { 478 { .compatible = "nxp,pca9550", .data = (void *)pca9550 }, 479 { .compatible = "nxp,pca9551", .data = (void *)pca9551 }, 480 { .compatible = "nxp,pca9552", .data = (void *)pca9552 }, 481 { .compatible = "ibm,pca9552", .data = (void *)ibm_pca9552 }, 482 { .compatible = "nxp,pca9553", .data = (void *)pca9553 }, 483 {}, 484 }; 485 MODULE_DEVICE_TABLE(of, of_pca955x_match); 486 487 static int pca955x_probe(struct i2c_client *client) 488 { 489 struct pca955x *pca955x; 490 struct pca955x_led *pca955x_led; 491 struct pca955x_chipdef *chip; 492 struct led_classdev *led; 493 struct led_init_data init_data; 494 struct i2c_adapter *adapter; 495 int i, err; 496 struct pca955x_platform_data *pdata; 497 bool set_default_label = false; 498 bool keep_pwm = false; 499 char default_label[8]; 500 enum pca955x_type chip_type; 501 const void *md = device_get_match_data(&client->dev); 502 503 if (md) { 504 chip_type = (enum pca955x_type)md; 505 } else { 506 const struct i2c_device_id *id = i2c_match_id(pca955x_id, 507 client); 508 509 if (id) { 510 chip_type = (enum pca955x_type)id->driver_data; 511 } else { 512 dev_err(&client->dev, "unknown chip\n"); 513 return -ENODEV; 514 } 515 } 516 517 chip = &pca955x_chipdefs[chip_type]; 518 adapter = client->adapter; 519 pdata = dev_get_platdata(&client->dev); 520 if (!pdata) { 521 pdata = pca955x_get_pdata(client, chip); 522 if (IS_ERR(pdata)) 523 return PTR_ERR(pdata); 524 } 525 526 /* Make sure the slave address / chip type combo given is possible */ 527 if ((client->addr & ~((1 << chip->slv_addr_shift) - 1)) != 528 chip->slv_addr) { 529 dev_err(&client->dev, "invalid slave address %02x\n", 530 client->addr); 531 return -ENODEV; 532 } 533 534 dev_info(&client->dev, "leds-pca955x: Using %s %d-bit LED driver at " 535 "slave address 0x%02x\n", client->name, chip->bits, 536 client->addr); 537 538 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 539 return -EIO; 540 541 if (pdata->num_leds != chip->bits) { 542 dev_err(&client->dev, 543 "board info claims %d LEDs on a %d-bit chip\n", 544 pdata->num_leds, chip->bits); 545 return -ENODEV; 546 } 547 548 pca955x = devm_kzalloc(&client->dev, sizeof(*pca955x), GFP_KERNEL); 549 if (!pca955x) 550 return -ENOMEM; 551 552 pca955x->leds = devm_kcalloc(&client->dev, chip->bits, 553 sizeof(*pca955x_led), GFP_KERNEL); 554 if (!pca955x->leds) 555 return -ENOMEM; 556 557 i2c_set_clientdata(client, pca955x); 558 559 mutex_init(&pca955x->lock); 560 pca955x->client = client; 561 pca955x->chipdef = chip; 562 563 init_data.devname_mandatory = false; 564 init_data.devicename = "pca955x"; 565 566 for (i = 0; i < chip->bits; i++) { 567 pca955x_led = &pca955x->leds[i]; 568 pca955x_led->led_num = i; 569 pca955x_led->pca955x = pca955x; 570 pca955x_led->type = pdata->leds[i].type; 571 572 switch (pca955x_led->type) { 573 case PCA955X_TYPE_NONE: 574 case PCA955X_TYPE_GPIO: 575 break; 576 case PCA955X_TYPE_LED: 577 led = &pca955x_led->led_cdev; 578 led->brightness_set_blocking = pca955x_led_set; 579 led->brightness_get = pca955x_led_get; 580 581 if (pdata->leds[i].default_state == 582 LEDS_GPIO_DEFSTATE_OFF) { 583 err = pca955x_led_set(led, LED_OFF); 584 if (err) 585 return err; 586 } else if (pdata->leds[i].default_state == 587 LEDS_GPIO_DEFSTATE_ON) { 588 err = pca955x_led_set(led, LED_FULL); 589 if (err) 590 return err; 591 } 592 593 init_data.fwnode = pdata->leds[i].fwnode; 594 595 if (is_of_node(init_data.fwnode)) { 596 if (to_of_node(init_data.fwnode)->name[0] == 597 '\0') 598 set_default_label = true; 599 else 600 set_default_label = false; 601 } else { 602 set_default_label = true; 603 } 604 605 if (set_default_label) { 606 snprintf(default_label, sizeof(default_label), 607 "%d", i); 608 init_data.default_label = default_label; 609 } else { 610 init_data.default_label = NULL; 611 } 612 613 err = devm_led_classdev_register_ext(&client->dev, led, 614 &init_data); 615 if (err) 616 return err; 617 618 set_bit(i, &pca955x->active_pins); 619 620 /* 621 * For default-state == "keep", let the core update the 622 * brightness from the hardware, then check the 623 * brightness to see if it's using PWM1. If so, PWM1 624 * should not be written below. 625 */ 626 if (pdata->leds[i].default_state == 627 LEDS_GPIO_DEFSTATE_KEEP) { 628 if (led->brightness != LED_FULL && 629 led->brightness != LED_OFF && 630 led->brightness != LED_HALF) 631 keep_pwm = true; 632 } 633 } 634 } 635 636 /* PWM0 is used for half brightness or 50% duty cycle */ 637 err = pca955x_write_pwm(client, 0, 255 - LED_HALF); 638 if (err) 639 return err; 640 641 if (!keep_pwm) { 642 /* PWM1 is used for variable brightness, default to OFF */ 643 err = pca955x_write_pwm(client, 1, 0); 644 if (err) 645 return err; 646 } 647 648 /* Set to fast frequency so we do not see flashing */ 649 err = pca955x_write_psc(client, 0, 0); 650 if (err) 651 return err; 652 err = pca955x_write_psc(client, 1, 0); 653 if (err) 654 return err; 655 656 #ifdef CONFIG_LEDS_PCA955X_GPIO 657 pca955x->gpio.label = "gpio-pca955x"; 658 pca955x->gpio.direction_input = pca955x_gpio_direction_input; 659 pca955x->gpio.direction_output = pca955x_gpio_direction_output; 660 pca955x->gpio.set = pca955x_gpio_set_value; 661 pca955x->gpio.get = pca955x_gpio_get_value; 662 pca955x->gpio.request = pca955x_gpio_request_pin; 663 pca955x->gpio.free = pca955x_gpio_free_pin; 664 pca955x->gpio.can_sleep = 1; 665 pca955x->gpio.base = -1; 666 pca955x->gpio.ngpio = chip->bits; 667 pca955x->gpio.parent = &client->dev; 668 pca955x->gpio.owner = THIS_MODULE; 669 670 err = devm_gpiochip_add_data(&client->dev, &pca955x->gpio, 671 pca955x); 672 if (err) { 673 /* Use data->gpio.dev as a flag for freeing gpiochip */ 674 pca955x->gpio.parent = NULL; 675 dev_warn(&client->dev, "could not add gpiochip\n"); 676 return err; 677 } 678 dev_info(&client->dev, "gpios %i...%i\n", 679 pca955x->gpio.base, pca955x->gpio.base + 680 pca955x->gpio.ngpio - 1); 681 #endif 682 683 return 0; 684 } 685 686 static struct i2c_driver pca955x_driver = { 687 .driver = { 688 .name = "leds-pca955x", 689 .of_match_table = of_pca955x_match, 690 }, 691 .probe_new = pca955x_probe, 692 .id_table = pca955x_id, 693 }; 694 695 module_i2c_driver(pca955x_driver); 696 697 MODULE_AUTHOR("Nate Case <ncase@xes-inc.com>"); 698 MODULE_DESCRIPTION("PCA955x LED driver"); 699 MODULE_LICENSE("GPL v2"); 700