1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
/* SPDX-License-Identifier: GPL-2.0-only */
#include <acpi/acpi.h>
#include <acpi/acpi_device.h>
#include <acpi/acpigen.h>
#include <console/console.h>
#include <device/i2c_simple.h>
#include <device/device.h>
#include <device/path.h>
#include <device/pci_def.h>
#include "chip.h"
static void write_pci_camera_device(const struct device *dev)
{
struct drivers_intel_mipi_camera_config *config = dev->chip_info;
if (dev->path.type != DEVICE_PATH_PCI) {
printk(BIOS_ERR, "CIO2/IMGU devices require PCI\n");
return;
}
acpigen_write_device(acpi_device_name(dev));
acpigen_write_ADR_pci_device(dev);
acpigen_write_name_string("_DDN", config->device_type == INTEL_ACPI_CAMERA_CIO2 ?
"Camera and Imaging Subsystem" : "Imaging Unit");
}
static void write_i2c_camera_device(const struct device *dev, const char *scope)
{
struct drivers_intel_mipi_camera_config *config = dev->chip_info;
struct acpi_i2c i2c = {
.address = dev->path.i2c.device,
.mode_10bit = dev->path.i2c.mode_10bit,
.speed = I2C_SPEED_FAST,
.resource = scope,
};
if (dev->path.type != DEVICE_PATH_I2C) {
printk(BIOS_ERR, "Non-CIO2/IMGU devices require I2C\n");
return;
}
acpigen_write_device(acpi_device_name(dev));
if (config->device_type == INTEL_ACPI_CAMERA_SENSOR)
acpigen_write_name_integer("_ADR", 0);
if (config->acpi_hid)
acpigen_write_name_string("_HID", config->acpi_hid);
else if (config->device_type == INTEL_ACPI_CAMERA_VCM)
acpigen_write_name_string("_HID", ACPI_DT_NAMESPACE_HID);
else if (config->device_type == INTEL_ACPI_CAMERA_NVM)
acpigen_write_name_string("_HID", "INT3499");
acpigen_write_name_integer("_UID", config->acpi_uid);
acpigen_write_name_string("_DDN", config->chip_name);
acpigen_write_STA(acpi_device_status(dev));
/* Resources */
acpigen_write_name("_CRS");
acpigen_write_resourcetemplate_header();
acpi_device_write_i2c(&i2c);
/*
* The optional vcm/nvram devices are presumed to be on the same I2C bus as the camera
* sensor.
*/
if (config->device_type == INTEL_ACPI_CAMERA_SENSOR &&
config->ssdb.vcm_type && config->vcm_address) {
struct acpi_i2c i2c_vcm = i2c;
i2c_vcm.address = config->vcm_address;
acpi_device_write_i2c(&i2c_vcm);
}
if (config->device_type == INTEL_ACPI_CAMERA_SENSOR &&
config->ssdb.rom_type && config->rom_address) {
struct acpi_i2c i2c_rom = i2c;
i2c_rom.address = config->rom_address;
acpi_device_write_i2c(&i2c_rom);
}
acpigen_write_resourcetemplate_footer();
}
static void write_camera_device_common(const struct device *dev)
{
struct drivers_intel_mipi_camera_config *config = dev->chip_info;
/* Mark it as Camera related device */
if (config->device_type == INTEL_ACPI_CAMERA_CIO2 ||
config->device_type == INTEL_ACPI_CAMERA_IMGU ||
config->device_type == INTEL_ACPI_CAMERA_SENSOR ||
config->device_type == INTEL_ACPI_CAMERA_VCM) {
acpigen_write_name_integer("CAMD", config->device_type);
}
}
static void camera_fill_ssdt(const struct device *dev)
{
struct drivers_intel_mipi_camera_config *config = dev->chip_info;
const char *scope = acpi_device_scope(dev);
if (!dev->enabled || !scope)
return;
/* Device */
acpigen_write_scope(scope);
if (config->device_type == INTEL_ACPI_CAMERA_CIO2 ||
config->device_type == INTEL_ACPI_CAMERA_IMGU)
write_pci_camera_device(dev);
else
write_i2c_camera_device(dev, scope);
write_camera_device_common(dev);
acpigen_pop_len(); /* Device */
acpigen_pop_len(); /* Scope */
if (dev->path.type == DEVICE_PATH_PCI) {
printk(BIOS_INFO, "%s: %s PCI address 0%x\n", acpi_device_path(dev),
dev->chip_ops->name, dev->path.pci.devfn);
} else {
printk(BIOS_INFO, "%s: %s I2C address 0%xh\n", acpi_device_path(dev),
dev->chip_ops->name, dev->path.i2c.device);
}
}
static const char *camera_acpi_name(const struct device *dev)
{
const char *prefix = NULL;
static char name[5];
struct drivers_intel_mipi_camera_config *config = dev->chip_info;
if (config->acpi_name)
return config->acpi_name;
switch (config->device_type) {
case INTEL_ACPI_CAMERA_CIO2:
return "CIO2";
case INTEL_ACPI_CAMERA_IMGU:
return "IMGU";
case INTEL_ACPI_CAMERA_PMIC:
return "PMIC";
case INTEL_ACPI_CAMERA_SENSOR:
prefix = "CAM";
break;
case INTEL_ACPI_CAMERA_VCM:
prefix = "VCM";
break;
case INTEL_ACPI_CAMERA_NVM:
prefix = "NVM";
break;
default:
printk(BIOS_ERR, "Invalid device type: %x\n", config->device_type);
return NULL;
}
/*
* The camera # knows which link # they use, so that's used as the basis for the
* instance #. The VCM and NVM don't have this information, so the best we can go on is
* the _UID.
*/
snprintf(name, sizeof(name), "%s%1u", prefix,
config->device_type == INTEL_ACPI_CAMERA_SENSOR ?
config->ssdb.link_used : config->acpi_uid);
return name;
}
static struct device_operations camera_ops = {
.read_resources = noop_read_resources,
.set_resources = noop_set_resources,
.acpi_name = camera_acpi_name,
.acpi_fill_ssdt = camera_fill_ssdt,
};
static void camera_enable(struct device *dev)
{
dev->ops = &camera_ops;
}
struct chip_operations drivers_intel_mipi_camera_ops = {
CHIP_NAME("Intel MIPI Camera Device")
.enable_dev = camera_enable
};
|
