drivers/media/pci/intel/ipu-bridge.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Author: Dan Scally <djrscally@gmail.com> */
   3
   4 #include <linux/acpi.h>
   5 #include <linux/device.h>
   6 #include <linux/i2c.h>
   7 #include <linux/property.h>
   8 #include <media/v4l2-fwnode.h>
   9
  10 #include "ipu-bridge.h"
  11
  12 /*
  13  * Extend this array with ACPI Hardware IDs of devices known to be working
  14  * plus the number of link-frequencies expected by their drivers, along with
  15  * the frequency values in hertz. This is somewhat opportunistic way of adding
  16  * support for this for now in the hopes of a better source for the information
  17  * (possibly some encoded value in the SSDB buffer that we're unaware of)
  18  * becoming apparent in the future.
  19  *
  20  * Do not add an entry for a sensor that is not actually supported.
  21  */
  22 static const struct ipu_sensor_config ipu_supported_sensors[] = {
  23         /* Omnivision OV5693 */
  24         IPU_SENSOR_CONFIG("INT33BE", 1, 419200000),
  25         /* Omnivision OV8865 */
  26         IPU_SENSOR_CONFIG("INT347A", 1, 360000000),
  27         /* Omnivision OV7251 */
  28         IPU_SENSOR_CONFIG("INT347E", 1, 319200000),
  29         /* Omnivision OV2680 */
  30         IPU_SENSOR_CONFIG("OVTI2680", 0),
  31         /* Omnivision ov8856 */
  32         IPU_SENSOR_CONFIG("OVTI8856", 3, 180000000, 360000000, 720000000),
  33         /* Omnivision ov2740 */
  34         IPU_SENSOR_CONFIG("INT3474", 1, 360000000),
  35         /* Hynix hi556 */
  36         IPU_SENSOR_CONFIG("INT3537", 1, 437000000),
  37         /* Omnivision ov13b10 */
  38         IPU_SENSOR_CONFIG("OVTIDB10", 1, 560000000),
  39 };
  40
  41 static const struct ipu_property_names prop_names = {
  42         .clock_frequency = "clock-frequency",
  43         .rotation = "rotation",
  44         .orientation = "orientation",
  45         .bus_type = "bus-type",
  46         .data_lanes = "data-lanes",
  47         .remote_endpoint = "remote-endpoint",
  48         .link_frequencies = "link-frequencies",
  49 };
  50
  51 static const char * const ipu_vcm_types[] = {
  52         "ad5823",
  53         "dw9714",
  54         "ad5816",
  55         "dw9719",
  56         "dw9718",
  57         "dw9806b",
  58         "wv517s",
  59         "lc898122xa",
  60         "lc898212axb",
  61 };
  62
  63 static int ipu_bridge_read_acpi_buffer(struct acpi_device *adev, char *id,
  64                                        void *data, u32 size)
  65 {
  66         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
  67         union acpi_object *obj;
  68         acpi_status status;
  69         int ret = 0;
  70
  71         status = acpi_evaluate_object(adev->handle, id, NULL, &buffer);
  72         if (ACPI_FAILURE(status))
  73                 return -ENODEV;
  74
  75         obj = buffer.pointer;
  76         if (!obj) {
  77                 dev_err(&adev->dev, "Couldn't locate ACPI buffer\n");
  78                 return -ENODEV;
  79         }
  80
  81         if (obj->type != ACPI_TYPE_BUFFER) {
  82                 dev_err(&adev->dev, "Not an ACPI buffer\n");
  83                 ret = -ENODEV;
  84                 goto out_free_buff;
  85         }
  86
  87         if (obj->buffer.length > size) {
  88                 dev_err(&adev->dev, "Given buffer is too small\n");
  89                 ret = -EINVAL;
  90                 goto out_free_buff;
  91         }
  92
  93         memcpy(data, obj->buffer.pointer, obj->buffer.length);
  94
  95 out_free_buff:
  96         kfree(buffer.pointer);
  97         return ret;
  98 }
  99
 100 static u32 ipu_bridge_parse_rotation(struct ipu_sensor *sensor)
 101 {
 102         switch (sensor->ssdb.degree) {
 103         case IPU_SENSOR_ROTATION_NORMAL:
 104                 return 0;
 105         case IPU_SENSOR_ROTATION_INVERTED:
 106                 return 180;
 107         default:
 108                 dev_warn(&sensor->adev->dev,
 109                          "Unknown rotation %d. Assume 0 degree rotation\n",
 110                          sensor->ssdb.degree);
 111                 return 0;
 112         }
 113 }
 114
 115 static enum v4l2_fwnode_orientation ipu_bridge_parse_orientation(struct ipu_sensor *sensor)
 116 {
 117         switch (sensor->pld->panel) {
 118         case ACPI_PLD_PANEL_FRONT:
 119                 return V4L2_FWNODE_ORIENTATION_FRONT;
 120         case ACPI_PLD_PANEL_BACK:
 121                 return V4L2_FWNODE_ORIENTATION_BACK;
 122         case ACPI_PLD_PANEL_TOP:
 123         case ACPI_PLD_PANEL_LEFT:
 124         case ACPI_PLD_PANEL_RIGHT:
 125         case ACPI_PLD_PANEL_UNKNOWN:
 126                 return V4L2_FWNODE_ORIENTATION_EXTERNAL;
 127         default:
 128                 dev_warn(&sensor->adev->dev, "Unknown _PLD panel value %d\n",
 129                          sensor->pld->panel);
 130                 return V4L2_FWNODE_ORIENTATION_EXTERNAL;
 131         }
 132 }
 133
 134 static void ipu_bridge_create_fwnode_properties(
 135         struct ipu_sensor *sensor,
 136         struct ipu_bridge *bridge,
 137         const struct ipu_sensor_config *cfg)
 138 {
 139         u32 rotation;
 140         enum v4l2_fwnode_orientation orientation;
 141
 142         rotation = ipu_bridge_parse_rotation(sensor);
 143         orientation = ipu_bridge_parse_orientation(sensor);
 144
 145         sensor->prop_names = prop_names;
 146
 147         sensor->local_ref[0] = SOFTWARE_NODE_REFERENCE(&sensor->swnodes[SWNODE_IPU_ENDPOINT]);
 148         sensor->remote_ref[0] = SOFTWARE_NODE_REFERENCE(&sensor->swnodes[SWNODE_SENSOR_ENDPOINT]);
 149
 150         sensor->dev_properties[0] = PROPERTY_ENTRY_U32(
 151                                         sensor->prop_names.clock_frequency,
 152                                         sensor->ssdb.mclkspeed);
 153         sensor->dev_properties[1] = PROPERTY_ENTRY_U32(
 154                                         sensor->prop_names.rotation,
 155                                         rotation);
 156         sensor->dev_properties[2] = PROPERTY_ENTRY_U32(
 157                                         sensor->prop_names.orientation,
 158                                         orientation);
 159         if (sensor->ssdb.vcmtype) {
 160                 sensor->vcm_ref[0] =
 161                         SOFTWARE_NODE_REFERENCE(&sensor->swnodes[SWNODE_VCM]);
 162                 sensor->dev_properties[3] =
 163                         PROPERTY_ENTRY_REF_ARRAY("lens-focus", sensor->vcm_ref);
 164         }
 165
 166         sensor->ep_properties[0] = PROPERTY_ENTRY_U32(
 167                                         sensor->prop_names.bus_type,
 168                                         V4L2_FWNODE_BUS_TYPE_CSI2_DPHY);
 169         sensor->ep_properties[1] = PROPERTY_ENTRY_U32_ARRAY_LEN(
 170                                         sensor->prop_names.data_lanes,
 171                                         bridge->data_lanes,
 172                                         sensor->ssdb.lanes);
 173         sensor->ep_properties[2] = PROPERTY_ENTRY_REF_ARRAY(
 174                                         sensor->prop_names.remote_endpoint,
 175                                         sensor->local_ref);
 176
 177         if (cfg->nr_link_freqs > 0)
 178                 sensor->ep_properties[3] = PROPERTY_ENTRY_U64_ARRAY_LEN(
 179                         sensor->prop_names.link_frequencies,
 180                         cfg->link_freqs,
 181                         cfg->nr_link_freqs);
 182
 183         sensor->ipu_properties[0] = PROPERTY_ENTRY_U32_ARRAY_LEN(
 184                                         sensor->prop_names.data_lanes,
 185                                         bridge->data_lanes,
 186                                         sensor->ssdb.lanes);
 187         sensor->ipu_properties[1] = PROPERTY_ENTRY_REF_ARRAY(
 188                                         sensor->prop_names.remote_endpoint,
 189                                         sensor->remote_ref);
 190 }
 191
 192 static void ipu_bridge_init_swnode_names(struct ipu_sensor *sensor)
 193 {
 194         snprintf(sensor->node_names.remote_port,
 195                  sizeof(sensor->node_names.remote_port),
 196                  SWNODE_GRAPH_PORT_NAME_FMT, sensor->ssdb.link);
 197         snprintf(sensor->node_names.port,
 198                  sizeof(sensor->node_names.port),
 199                  SWNODE_GRAPH_PORT_NAME_FMT, 0); /* Always port 0 */
 200         snprintf(sensor->node_names.endpoint,
 201                  sizeof(sensor->node_names.endpoint),
 202                  SWNODE_GRAPH_ENDPOINT_NAME_FMT, 0); /* And endpoint 0 */
 203         if (sensor->ssdb.vcmtype) {
 204                 /* append ssdb.link to distinguish nodes with same model VCM */
 205                 snprintf(sensor->node_names.vcm, sizeof(sensor->node_names.vcm),
 206                          "%s-%u", ipu_vcm_types[sensor->ssdb.vcmtype - 1],
 207                          sensor->ssdb.link);
 208         }
 209 }
 210
 211 static void ipu_bridge_init_swnode_group(struct ipu_sensor *sensor)
 212 {
 213         struct software_node *nodes = sensor->swnodes;
 214
 215         sensor->group[SWNODE_SENSOR_HID] = &nodes[SWNODE_SENSOR_HID];
 216         sensor->group[SWNODE_SENSOR_PORT] = &nodes[SWNODE_SENSOR_PORT];
 217         sensor->group[SWNODE_SENSOR_ENDPOINT] = &nodes[SWNODE_SENSOR_ENDPOINT];
 218         sensor->group[SWNODE_IPU_PORT] = &nodes[SWNODE_IPU_PORT];
 219         sensor->group[SWNODE_IPU_ENDPOINT] = &nodes[SWNODE_IPU_ENDPOINT];
 220         if (sensor->ssdb.vcmtype)
 221                 sensor->group[SWNODE_VCM] =  &nodes[SWNODE_VCM];
 222 }
 223
 224 static void ipu_bridge_create_connection_swnodes(struct ipu_bridge *bridge,
 225                                                  struct ipu_sensor *sensor)
 226 {
 227         struct software_node *nodes = sensor->swnodes;
 228
 229         ipu_bridge_init_swnode_names(sensor);
 230
 231         nodes[SWNODE_SENSOR_HID] = NODE_SENSOR(sensor->name,
 232                                                sensor->dev_properties);
 233         nodes[SWNODE_SENSOR_PORT] = NODE_PORT(sensor->node_names.port,
 234                                               &nodes[SWNODE_SENSOR_HID]);
 235         nodes[SWNODE_SENSOR_ENDPOINT] = NODE_ENDPOINT(
 236                                                 sensor->node_names.endpoint,
 237                                                 &nodes[SWNODE_SENSOR_PORT],
 238                                                 sensor->ep_properties);
 239         nodes[SWNODE_IPU_PORT] = NODE_PORT(sensor->node_names.remote_port,
 240                                            &bridge->ipu_hid_node);
 241         nodes[SWNODE_IPU_ENDPOINT] = NODE_ENDPOINT(
 242                                                 sensor->node_names.endpoint,
 243                                                 &nodes[SWNODE_IPU_PORT],
 244                                                 sensor->ipu_properties);
 245         nodes[SWNODE_VCM] = NODE_VCM(sensor->node_names.vcm);
 246
 247         ipu_bridge_init_swnode_group(sensor);
 248 }
 249
 250 static void ipu_bridge_instantiate_vcm_i2c_client(struct ipu_sensor *sensor)
 251 {
 252         struct i2c_board_info board_info = { };
 253         char name[16];
 254
 255         if (!sensor->ssdb.vcmtype)
 256                 return;
 257
 258         snprintf(name, sizeof(name), "%s-VCM", acpi_dev_name(sensor->adev));
 259         board_info.dev_name = name;
 260         strscpy(board_info.type, ipu_vcm_types[sensor->ssdb.vcmtype - 1],
 261                 ARRAY_SIZE(board_info.type));
 262         board_info.swnode = &sensor->swnodes[SWNODE_VCM];
 263
 264         sensor->vcm_i2c_client =
 265                 i2c_acpi_new_device_by_fwnode(acpi_fwnode_handle(sensor->adev),
 266                                               1, &board_info);
 267         if (IS_ERR(sensor->vcm_i2c_client)) {
 268                 dev_warn(&sensor->adev->dev, "Error instantiation VCM i2c-client: %ld\n",
 269                          PTR_ERR(sensor->vcm_i2c_client));
 270                 sensor->vcm_i2c_client = NULL;
 271         }
 272 }
 273
 274 static void ipu_bridge_unregister_sensors(struct ipu_bridge *bridge)
 275 {
 276         struct ipu_sensor *sensor;
 277         unsigned int i;
 278
 279         for (i = 0; i < bridge->n_sensors; i++) {
 280                 sensor = &bridge->sensors[i];
 281                 software_node_unregister_node_group(sensor->group);
 282                 ACPI_FREE(sensor->pld);
 283                 acpi_dev_put(sensor->adev);
 284                 i2c_unregister_device(sensor->vcm_i2c_client);
 285         }
 286 }
 287
 288 static int ipu_bridge_connect_sensor(const struct ipu_sensor_config *cfg,
 289                                      struct ipu_bridge *bridge)
 290 {
 291         struct fwnode_handle *fwnode, *primary;
 292         struct ipu_sensor *sensor;
 293         struct acpi_device *adev;
 294         acpi_status status;
 295         int ret;
 296
 297         for_each_acpi_dev_match(adev, cfg->hid, NULL, -1) {
 298                 if (!adev->status.enabled)
 299                         continue;
 300
 301                 if (bridge->n_sensors >= IPU_MAX_PORTS) {
 302                         acpi_dev_put(adev);
 303                         dev_err(bridge->dev, "Exceeded available IPU ports\n");
 304                         return -EINVAL;
 305                 }
 306
 307                 sensor = &bridge->sensors[bridge->n_sensors];
 308                 /*
 309                  * Borrow our adev ref to the sensor for now, on success
 310                  * acpi_dev_get(adev) is done further below.
 311                  */
 312                 sensor->adev = adev;
 313
 314                 ret = ipu_bridge_read_acpi_buffer(adev, "SSDB",
 315                                                   &sensor->ssdb,
 316                                                   sizeof(sensor->ssdb));
 317                 if (ret)
 318                         goto err_put_adev;
 319
 320                 snprintf(sensor->name, sizeof(sensor->name), "%s-%u",
 321                          cfg->hid, sensor->ssdb.link);
 322
 323                 if (sensor->ssdb.vcmtype > ARRAY_SIZE(ipu_vcm_types)) {
 324                         dev_warn(&adev->dev, "Unknown VCM type %d\n",
 325                                  sensor->ssdb.vcmtype);
 326                         sensor->ssdb.vcmtype = 0;
 327                 }
 328
 329                 status = acpi_get_physical_device_location(adev->handle, &sensor->pld);
 330                 if (ACPI_FAILURE(status)) {
 331                         ret = -ENODEV;
 332                         goto err_put_adev;
 333                 }
 334
 335                 if (sensor->ssdb.lanes > IPU_MAX_LANES) {
 336                         dev_err(&adev->dev,
 337                                 "Number of lanes in SSDB is invalid\n");
 338                         ret = -EINVAL;
 339                         goto err_free_pld;
 340                 }
 341
 342                 ipu_bridge_create_fwnode_properties(sensor, bridge, cfg);
 343                 ipu_bridge_create_connection_swnodes(bridge, sensor);
 344
 345                 ret = software_node_register_node_group(sensor->group);
 346                 if (ret)
 347                         goto err_free_pld;
 348
 349                 fwnode = software_node_fwnode(&sensor->swnodes[
 350                                                       SWNODE_SENSOR_HID]);
 351                 if (!fwnode) {
 352                         ret = -ENODEV;
 353                         goto err_free_swnodes;
 354                 }
 355
 356                 sensor->adev = acpi_dev_get(adev);
 357
 358                 primary = acpi_fwnode_handle(adev);
 359                 primary->secondary = fwnode;
 360
 361                 ipu_bridge_instantiate_vcm_i2c_client(sensor);
 362
 363                 dev_info(bridge->dev, "Found supported sensor %s\n",
 364                          acpi_dev_name(adev));
 365
 366                 bridge->n_sensors++;
 367         }
 368
 369         return 0;
 370
 371 err_free_swnodes:
 372         software_node_unregister_node_group(sensor->group);
 373 err_free_pld:
 374         ACPI_FREE(sensor->pld);
 375 err_put_adev:
 376         acpi_dev_put(adev);
 377         return ret;
 378 }
 379
 380 static int ipu_bridge_connect_sensors(struct ipu_bridge *bridge)
 381 {
 382         unsigned int i;
 383         int ret;
 384
 385         for (i = 0; i < ARRAY_SIZE(ipu_supported_sensors); i++) {
 386                 const struct ipu_sensor_config *cfg =
 387                         &ipu_supported_sensors[i];
 388
 389                 ret = ipu_bridge_connect_sensor(cfg, bridge);
 390                 if (ret)
 391                         goto err_unregister_sensors;
 392         }
 393
 394         return 0;
 395
 396 err_unregister_sensors:
 397         ipu_bridge_unregister_sensors(bridge);
 398         return ret;
 399 }
 400
 401 /*
 402  * The VCM cannot be probed until the PMIC is completely setup. We cannot rely
 403  * on -EPROBE_DEFER for this, since the consumer<->supplier relations between
 404  * the VCM and regulators/clks are not described in ACPI, instead they are
 405  * passed as board-data to the PMIC drivers. Since -PROBE_DEFER does not work
 406  * for the clks/regulators the VCM i2c-clients must not be instantiated until
 407  * the PMIC is fully setup.
 408  *
 409  * The sensor/VCM ACPI device has an ACPI _DEP on the PMIC, check this using the
 410  * acpi_dev_ready_for_enumeration() helper, like the i2c-core-acpi code does
 411  * for the sensors.
 412  */
 413 static int ipu_bridge_sensors_are_ready(void)
 414 {
 415         struct acpi_device *adev;
 416         bool ready = true;
 417         unsigned int i;
 418
 419         for (i = 0; i < ARRAY_SIZE(ipu_supported_sensors); i++) {
 420                 const struct ipu_sensor_config *cfg =
 421                         &ipu_supported_sensors[i];
 422
 423                 for_each_acpi_dev_match(adev, cfg->hid, NULL, -1) {
 424                         if (!adev->status.enabled)
 425                                 continue;
 426
 427                         if (!acpi_dev_ready_for_enumeration(adev))
 428                                 ready = false;
 429                 }
 430         }
 431
 432         return ready;
 433 }
 434
 435 int ipu_bridge_init(struct device *dev)
 436 {
 437         struct fwnode_handle *fwnode;
 438         struct ipu_bridge *bridge;
 439         unsigned int i;
 440         int ret;
 441
 442         if (!ipu_bridge_sensors_are_ready())
 443                 return -EPROBE_DEFER;
 444
 445         bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
 446         if (!bridge)
 447                 return -ENOMEM;
 448
 449         strscpy(bridge->ipu_node_name, IPU_HID,
 450                 sizeof(bridge->ipu_node_name));
 451         bridge->ipu_hid_node.name = bridge->ipu_node_name;
 452         bridge->dev = dev;
 453
 454         ret = software_node_register(&bridge->ipu_hid_node);
 455         if (ret < 0) {
 456                 dev_err(dev, "Failed to register the IPU HID node\n");
 457                 goto err_free_bridge;
 458         }
 459
 460         /*
 461          * Map the lane arrangement, which is fixed for the IPU3 (meaning we
 462          * only need one, rather than one per sensor). We include it as a
 463          * member of the struct ipu_bridge rather than a global variable so
 464          * that it survives if the module is unloaded along with the rest of
 465          * the struct.
 466          */
 467         for (i = 0; i < IPU_MAX_LANES; i++)
 468                 bridge->data_lanes[i] = i + 1;
 469
 470         ret = ipu_bridge_connect_sensors(bridge);
 471         if (ret || bridge->n_sensors == 0)
 472                 goto err_unregister_ipu;
 473
 474         dev_info(dev, "Connected %d cameras\n", bridge->n_sensors);
 475
 476         fwnode = software_node_fwnode(&bridge->ipu_hid_node);
 477         if (!fwnode) {
 478                 dev_err(dev, "Error getting fwnode from ipu software_node\n");
 479                 ret = -ENODEV;
 480                 goto err_unregister_sensors;
 481         }
 482
 483         set_secondary_fwnode(dev, fwnode);
 484
 485         return 0;
 486
 487 err_unregister_sensors:
 488         ipu_bridge_unregister_sensors(bridge);
 489 err_unregister_ipu:
 490         software_node_unregister(&bridge->ipu_hid_node);
 491 err_free_bridge:
 492         kfree(bridge);
 493
 494         return ret;
 495 }
 496 EXPORT_SYMBOL_NS_GPL(ipu_bridge_init, INTEL_IPU_BRIDGE);
 497
 498 MODULE_LICENSE("GPL");
 499 MODULE_DESCRIPTION("Intel IPU Sensors Bridge driver");