diff options
author | Jean-François Moine <moinejf@free.fr> | 2012-03-19 03:32:15 -0400 |
---|---|---|
committer | Mauro Carvalho Chehab <mchehab@redhat.com> | 2012-03-19 21:29:11 -0400 |
commit | fe86ec75b992a6bb56955ac61c2cfdcbbde0d809 (patch) | |
tree | b1c5b2ba4e502d570a9f08e9ef7fccd1cbeada14 | |
parent | c5224d81aed8c174d6dd5f406f63f522213c9673 (diff) |
[media] gspca - sn9c20x: Propagate USB errors to higher level
Signed-off-by: Jean-François Moine <moinejf@free.fr>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
-rw-r--r-- | drivers/media/video/gspca/sn9c20x.c | 323 |
1 files changed, 171 insertions, 152 deletions
diff --git a/drivers/media/video/gspca/sn9c20x.c b/drivers/media/video/gspca/sn9c20x.c index 45092eed8fc..15c371e4f8d 100644 --- a/drivers/media/video/gspca/sn9c20x.c +++ b/drivers/media/video/gspca/sn9c20x.c | |||
@@ -1061,10 +1061,13 @@ static struct i2c_reg_u8 hv7131r_init[] = { | |||
1061 | {0x23, 0x09}, {0x01, 0x08}, | 1061 | {0x23, 0x09}, {0x01, 0x08}, |
1062 | }; | 1062 | }; |
1063 | 1063 | ||
1064 | static int reg_r(struct gspca_dev *gspca_dev, u16 reg, u16 length) | 1064 | static void reg_r(struct gspca_dev *gspca_dev, u16 reg, u16 length) |
1065 | { | 1065 | { |
1066 | struct usb_device *dev = gspca_dev->dev; | 1066 | struct usb_device *dev = gspca_dev->dev; |
1067 | int result; | 1067 | int result; |
1068 | |||
1069 | if (gspca_dev->usb_err < 0) | ||
1070 | return; | ||
1068 | result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), | 1071 | result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), |
1069 | 0x00, | 1072 | 0x00, |
1070 | USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, | 1073 | USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, |
@@ -1074,17 +1077,19 @@ static int reg_r(struct gspca_dev *gspca_dev, u16 reg, u16 length) | |||
1074 | length, | 1077 | length, |
1075 | 500); | 1078 | 500); |
1076 | if (unlikely(result < 0 || result != length)) { | 1079 | if (unlikely(result < 0 || result != length)) { |
1077 | pr_err("Read register failed 0x%02X\n", reg); | 1080 | pr_err("Read register %02x failed %d\n", reg, result); |
1078 | return -EIO; | 1081 | gspca_dev->usb_err = result; |
1079 | } | 1082 | } |
1080 | return 0; | ||
1081 | } | 1083 | } |
1082 | 1084 | ||
1083 | static int reg_w(struct gspca_dev *gspca_dev, u16 reg, | 1085 | static void reg_w(struct gspca_dev *gspca_dev, u16 reg, |
1084 | const u8 *buffer, int length) | 1086 | const u8 *buffer, int length) |
1085 | { | 1087 | { |
1086 | struct usb_device *dev = gspca_dev->dev; | 1088 | struct usb_device *dev = gspca_dev->dev; |
1087 | int result; | 1089 | int result; |
1090 | |||
1091 | if (gspca_dev->usb_err < 0) | ||
1092 | return; | ||
1088 | memcpy(gspca_dev->usb_buf, buffer, length); | 1093 | memcpy(gspca_dev->usb_buf, buffer, length); |
1089 | result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), | 1094 | result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), |
1090 | 0x08, | 1095 | 0x08, |
@@ -1095,35 +1100,39 @@ static int reg_w(struct gspca_dev *gspca_dev, u16 reg, | |||
1095 | length, | 1100 | length, |
1096 | 500); | 1101 | 500); |
1097 | if (unlikely(result < 0 || result != length)) { | 1102 | if (unlikely(result < 0 || result != length)) { |
1098 | pr_err("Write register failed index 0x%02X\n", reg); | 1103 | pr_err("Write register %02x failed %d\n", reg, result); |
1099 | return -EIO; | 1104 | gspca_dev->usb_err = result; |
1100 | } | 1105 | } |
1101 | return 0; | ||
1102 | } | 1106 | } |
1103 | 1107 | ||
1104 | static int reg_w1(struct gspca_dev *gspca_dev, u16 reg, const u8 value) | 1108 | static void reg_w1(struct gspca_dev *gspca_dev, u16 reg, const u8 value) |
1105 | { | 1109 | { |
1106 | u8 data[1] = {value}; | 1110 | u8 data[1] = {value}; |
1107 | return reg_w(gspca_dev, reg, data, 1); | 1111 | reg_w(gspca_dev, reg, data, 1); |
1108 | } | 1112 | } |
1109 | 1113 | ||
1110 | static int i2c_w(struct gspca_dev *gspca_dev, const u8 *buffer) | 1114 | static void i2c_w(struct gspca_dev *gspca_dev, const u8 *buffer) |
1111 | { | 1115 | { |
1112 | int i; | 1116 | int i; |
1113 | reg_w(gspca_dev, 0x10c0, buffer, 8); | 1117 | reg_w(gspca_dev, 0x10c0, buffer, 8); |
1114 | for (i = 0; i < 5; i++) { | 1118 | for (i = 0; i < 5; i++) { |
1115 | reg_r(gspca_dev, 0x10c0, 1); | 1119 | reg_r(gspca_dev, 0x10c0, 1); |
1120 | if (gspca_dev->usb_err < 0) | ||
1121 | return; | ||
1116 | if (gspca_dev->usb_buf[0] & 0x04) { | 1122 | if (gspca_dev->usb_buf[0] & 0x04) { |
1117 | if (gspca_dev->usb_buf[0] & 0x08) | 1123 | if (gspca_dev->usb_buf[0] & 0x08) { |
1118 | return -EIO; | 1124 | pr_err("i2c_w error\n"); |
1119 | return 0; | 1125 | gspca_dev->usb_err = -EIO; |
1126 | } | ||
1127 | return; | ||
1120 | } | 1128 | } |
1121 | msleep(1); | 1129 | msleep(1); |
1122 | } | 1130 | } |
1123 | return -EIO; | 1131 | pr_err("i2c_w reg %02x no response\n", buffer[2]); |
1132 | /* gspca_dev->usb_err = -EIO; fixme: may occur */ | ||
1124 | } | 1133 | } |
1125 | 1134 | ||
1126 | static int i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val) | 1135 | static void i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val) |
1127 | { | 1136 | { |
1128 | struct sd *sd = (struct sd *) gspca_dev; | 1137 | struct sd *sd = (struct sd *) gspca_dev; |
1129 | 1138 | ||
@@ -1142,10 +1151,10 @@ static int i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val) | |||
1142 | row[6] = 0x00; | 1151 | row[6] = 0x00; |
1143 | row[7] = 0x10; | 1152 | row[7] = 0x10; |
1144 | 1153 | ||
1145 | return i2c_w(gspca_dev, row); | 1154 | i2c_w(gspca_dev, row); |
1146 | } | 1155 | } |
1147 | 1156 | ||
1148 | static int i2c_w2(struct gspca_dev *gspca_dev, u8 reg, u16 val) | 1157 | static void i2c_w2(struct gspca_dev *gspca_dev, u8 reg, u16 val) |
1149 | { | 1158 | { |
1150 | struct sd *sd = (struct sd *) gspca_dev; | 1159 | struct sd *sd = (struct sd *) gspca_dev; |
1151 | u8 row[8]; | 1160 | u8 row[8]; |
@@ -1163,10 +1172,10 @@ static int i2c_w2(struct gspca_dev *gspca_dev, u8 reg, u16 val) | |||
1163 | row[6] = 0x00; | 1172 | row[6] = 0x00; |
1164 | row[7] = 0x10; | 1173 | row[7] = 0x10; |
1165 | 1174 | ||
1166 | return i2c_w(gspca_dev, row); | 1175 | i2c_w(gspca_dev, row); |
1167 | } | 1176 | } |
1168 | 1177 | ||
1169 | static int i2c_r1(struct gspca_dev *gspca_dev, u8 reg, u8 *val) | 1178 | static void i2c_r1(struct gspca_dev *gspca_dev, u8 reg, u8 *val) |
1170 | { | 1179 | { |
1171 | struct sd *sd = (struct sd *) gspca_dev; | 1180 | struct sd *sd = (struct sd *) gspca_dev; |
1172 | u8 row[8]; | 1181 | u8 row[8]; |
@@ -1179,19 +1188,15 @@ static int i2c_r1(struct gspca_dev *gspca_dev, u8 reg, u8 *val) | |||
1179 | row[5] = 0; | 1188 | row[5] = 0; |
1180 | row[6] = 0; | 1189 | row[6] = 0; |
1181 | row[7] = 0x10; | 1190 | row[7] = 0x10; |
1182 | if (i2c_w(gspca_dev, row) < 0) | 1191 | i2c_w(gspca_dev, row); |
1183 | return -EIO; | ||
1184 | row[0] = 0x81 | (1 << 4) | 0x02; | 1192 | row[0] = 0x81 | (1 << 4) | 0x02; |
1185 | row[2] = 0; | 1193 | row[2] = 0; |
1186 | if (i2c_w(gspca_dev, row) < 0) | 1194 | i2c_w(gspca_dev, row); |
1187 | return -EIO; | 1195 | reg_r(gspca_dev, 0x10c2, 5); |
1188 | if (reg_r(gspca_dev, 0x10c2, 5) < 0) | ||
1189 | return -EIO; | ||
1190 | *val = gspca_dev->usb_buf[4]; | 1196 | *val = gspca_dev->usb_buf[4]; |
1191 | return 0; | ||
1192 | } | 1197 | } |
1193 | 1198 | ||
1194 | static int i2c_r2(struct gspca_dev *gspca_dev, u8 reg, u16 *val) | 1199 | static void i2c_r2(struct gspca_dev *gspca_dev, u8 reg, u16 *val) |
1195 | { | 1200 | { |
1196 | struct sd *sd = (struct sd *) gspca_dev; | 1201 | struct sd *sd = (struct sd *) gspca_dev; |
1197 | u8 row[8]; | 1202 | u8 row[8]; |
@@ -1204,73 +1209,72 @@ static int i2c_r2(struct gspca_dev *gspca_dev, u8 reg, u16 *val) | |||
1204 | row[5] = 0; | 1209 | row[5] = 0; |
1205 | row[6] = 0; | 1210 | row[6] = 0; |
1206 | row[7] = 0x10; | 1211 | row[7] = 0x10; |
1207 | if (i2c_w(gspca_dev, row) < 0) | 1212 | i2c_w(gspca_dev, row); |
1208 | return -EIO; | ||
1209 | row[0] = 0x81 | (2 << 4) | 0x02; | 1213 | row[0] = 0x81 | (2 << 4) | 0x02; |
1210 | row[2] = 0; | 1214 | row[2] = 0; |
1211 | if (i2c_w(gspca_dev, row) < 0) | 1215 | i2c_w(gspca_dev, row); |
1212 | return -EIO; | 1216 | reg_r(gspca_dev, 0x10c2, 5); |
1213 | if (reg_r(gspca_dev, 0x10c2, 5) < 0) | ||
1214 | return -EIO; | ||
1215 | *val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4]; | 1217 | *val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4]; |
1216 | return 0; | ||
1217 | } | 1218 | } |
1218 | 1219 | ||
1219 | static int ov9650_init_sensor(struct gspca_dev *gspca_dev) | 1220 | static void ov9650_init_sensor(struct gspca_dev *gspca_dev) |
1220 | { | 1221 | { |
1221 | int i; | 1222 | int i; |
1222 | u16 id; | 1223 | u16 id; |
1223 | struct sd *sd = (struct sd *) gspca_dev; | 1224 | struct sd *sd = (struct sd *) gspca_dev; |
1224 | 1225 | ||
1225 | if (i2c_r2(gspca_dev, 0x1c, &id) < 0) | 1226 | i2c_r2(gspca_dev, 0x1c, &id); |
1226 | return -EINVAL; | 1227 | if (gspca_dev->usb_err < 0) |
1228 | return; | ||
1227 | 1229 | ||
1228 | if (id != 0x7fa2) { | 1230 | if (id != 0x7fa2) { |
1229 | pr_err("sensor id for ov9650 doesn't match (0x%04x)\n", id); | 1231 | pr_err("sensor id for ov9650 doesn't match (0x%04x)\n", id); |
1230 | return -ENODEV; | 1232 | gspca_dev->usb_err = -ENODEV; |
1233 | return; | ||
1231 | } | 1234 | } |
1232 | 1235 | ||
1233 | for (i = 0; i < ARRAY_SIZE(ov9650_init); i++) { | 1236 | for (i = 0; i < ARRAY_SIZE(ov9650_init); i++) { |
1234 | if (i2c_w1(gspca_dev, ov9650_init[i].reg, | 1237 | i2c_w1(gspca_dev, ov9650_init[i].reg, |
1235 | ov9650_init[i].val) < 0) { | 1238 | ov9650_init[i].val); |
1239 | if (gspca_dev->usb_err < 0) { | ||
1236 | pr_err("OV9650 sensor initialization failed\n"); | 1240 | pr_err("OV9650 sensor initialization failed\n"); |
1237 | return -ENODEV; | 1241 | return; |
1238 | } | 1242 | } |
1239 | } | 1243 | } |
1240 | sd->hstart = 1; | 1244 | sd->hstart = 1; |
1241 | sd->vstart = 7; | 1245 | sd->vstart = 7; |
1242 | return 0; | ||
1243 | } | 1246 | } |
1244 | 1247 | ||
1245 | static int ov9655_init_sensor(struct gspca_dev *gspca_dev) | 1248 | static void ov9655_init_sensor(struct gspca_dev *gspca_dev) |
1246 | { | 1249 | { |
1247 | int i; | 1250 | int i; |
1248 | struct sd *sd = (struct sd *) gspca_dev; | 1251 | struct sd *sd = (struct sd *) gspca_dev; |
1249 | 1252 | ||
1250 | for (i = 0; i < ARRAY_SIZE(ov9655_init); i++) { | 1253 | for (i = 0; i < ARRAY_SIZE(ov9655_init); i++) { |
1251 | if (i2c_w1(gspca_dev, ov9655_init[i].reg, | 1254 | i2c_w1(gspca_dev, ov9655_init[i].reg, |
1252 | ov9655_init[i].val) < 0) { | 1255 | ov9655_init[i].val); |
1256 | if (gspca_dev->usb_err < 0) { | ||
1253 | pr_err("OV9655 sensor initialization failed\n"); | 1257 | pr_err("OV9655 sensor initialization failed\n"); |
1254 | return -ENODEV; | 1258 | return; |
1255 | } | 1259 | } |
1256 | } | 1260 | } |
1257 | /* disable hflip and vflip */ | 1261 | /* disable hflip and vflip */ |
1258 | gspca_dev->ctrl_dis = (1 << HFLIP) | (1 << VFLIP); | 1262 | gspca_dev->ctrl_dis = (1 << HFLIP) | (1 << VFLIP); |
1259 | sd->hstart = 1; | 1263 | sd->hstart = 1; |
1260 | sd->vstart = 2; | 1264 | sd->vstart = 2; |
1261 | return 0; | ||
1262 | } | 1265 | } |
1263 | 1266 | ||
1264 | static int soi968_init_sensor(struct gspca_dev *gspca_dev) | 1267 | static void soi968_init_sensor(struct gspca_dev *gspca_dev) |
1265 | { | 1268 | { |
1266 | int i; | 1269 | int i; |
1267 | struct sd *sd = (struct sd *) gspca_dev; | 1270 | struct sd *sd = (struct sd *) gspca_dev; |
1268 | 1271 | ||
1269 | for (i = 0; i < ARRAY_SIZE(soi968_init); i++) { | 1272 | for (i = 0; i < ARRAY_SIZE(soi968_init); i++) { |
1270 | if (i2c_w1(gspca_dev, soi968_init[i].reg, | 1273 | i2c_w1(gspca_dev, soi968_init[i].reg, |
1271 | soi968_init[i].val) < 0) { | 1274 | soi968_init[i].val); |
1275 | if (gspca_dev->usb_err < 0) { | ||
1272 | pr_err("SOI968 sensor initialization failed\n"); | 1276 | pr_err("SOI968 sensor initialization failed\n"); |
1273 | return -ENODEV; | 1277 | return; |
1274 | } | 1278 | } |
1275 | } | 1279 | } |
1276 | /* disable hflip and vflip */ | 1280 | /* disable hflip and vflip */ |
@@ -1278,78 +1282,81 @@ static int soi968_init_sensor(struct gspca_dev *gspca_dev) | |||
1278 | | (1 << EXPOSURE); | 1282 | | (1 << EXPOSURE); |
1279 | sd->hstart = 60; | 1283 | sd->hstart = 60; |
1280 | sd->vstart = 11; | 1284 | sd->vstart = 11; |
1281 | return 0; | ||
1282 | } | 1285 | } |
1283 | 1286 | ||
1284 | static int ov7660_init_sensor(struct gspca_dev *gspca_dev) | 1287 | static void ov7660_init_sensor(struct gspca_dev *gspca_dev) |
1285 | { | 1288 | { |
1286 | int i; | 1289 | int i; |
1287 | struct sd *sd = (struct sd *) gspca_dev; | 1290 | struct sd *sd = (struct sd *) gspca_dev; |
1288 | 1291 | ||
1289 | for (i = 0; i < ARRAY_SIZE(ov7660_init); i++) { | 1292 | for (i = 0; i < ARRAY_SIZE(ov7660_init); i++) { |
1290 | if (i2c_w1(gspca_dev, ov7660_init[i].reg, | 1293 | i2c_w1(gspca_dev, ov7660_init[i].reg, |
1291 | ov7660_init[i].val) < 0) { | 1294 | ov7660_init[i].val); |
1295 | if (gspca_dev->usb_err < 0) { | ||
1292 | pr_err("OV7660 sensor initialization failed\n"); | 1296 | pr_err("OV7660 sensor initialization failed\n"); |
1293 | return -ENODEV; | 1297 | return; |
1294 | } | 1298 | } |
1295 | } | 1299 | } |
1296 | sd->hstart = 3; | 1300 | sd->hstart = 3; |
1297 | sd->vstart = 3; | 1301 | sd->vstart = 3; |
1298 | return 0; | ||
1299 | } | 1302 | } |
1300 | 1303 | ||
1301 | static int ov7670_init_sensor(struct gspca_dev *gspca_dev) | 1304 | static void ov7670_init_sensor(struct gspca_dev *gspca_dev) |
1302 | { | 1305 | { |
1303 | int i; | 1306 | int i; |
1304 | struct sd *sd = (struct sd *) gspca_dev; | 1307 | struct sd *sd = (struct sd *) gspca_dev; |
1305 | 1308 | ||
1306 | for (i = 0; i < ARRAY_SIZE(ov7670_init); i++) { | 1309 | for (i = 0; i < ARRAY_SIZE(ov7670_init); i++) { |
1307 | if (i2c_w1(gspca_dev, ov7670_init[i].reg, | 1310 | i2c_w1(gspca_dev, ov7670_init[i].reg, |
1308 | ov7670_init[i].val) < 0) { | 1311 | ov7670_init[i].val); |
1312 | if (gspca_dev->usb_err < 0) { | ||
1309 | pr_err("OV7670 sensor initialization failed\n"); | 1313 | pr_err("OV7670 sensor initialization failed\n"); |
1310 | return -ENODEV; | 1314 | return; |
1311 | } | 1315 | } |
1312 | } | 1316 | } |
1313 | /* disable hflip and vflip */ | 1317 | /* disable hflip and vflip */ |
1314 | gspca_dev->ctrl_dis = (1 << HFLIP) | (1 << VFLIP); | 1318 | gspca_dev->ctrl_dis = (1 << HFLIP) | (1 << VFLIP); |
1315 | sd->hstart = 0; | 1319 | sd->hstart = 0; |
1316 | sd->vstart = 1; | 1320 | sd->vstart = 1; |
1317 | return 0; | ||
1318 | } | 1321 | } |
1319 | 1322 | ||
1320 | static int mt9v_init_sensor(struct gspca_dev *gspca_dev) | 1323 | static void mt9v_init_sensor(struct gspca_dev *gspca_dev) |
1321 | { | 1324 | { |
1322 | struct sd *sd = (struct sd *) gspca_dev; | 1325 | struct sd *sd = (struct sd *) gspca_dev; |
1323 | int i; | 1326 | int i; |
1324 | u16 value; | 1327 | u16 value; |
1325 | int ret; | ||
1326 | 1328 | ||
1327 | sd->i2c_addr = 0x5d; | 1329 | sd->i2c_addr = 0x5d; |
1328 | ret = i2c_r2(gspca_dev, 0xff, &value); | 1330 | i2c_r2(gspca_dev, 0xff, &value); |
1329 | if ((ret == 0) && (value == 0x8243)) { | 1331 | if (gspca_dev->usb_err >= 0 |
1332 | && value == 0x8243) { | ||
1330 | for (i = 0; i < ARRAY_SIZE(mt9v011_init); i++) { | 1333 | for (i = 0; i < ARRAY_SIZE(mt9v011_init); i++) { |
1331 | if (i2c_w2(gspca_dev, mt9v011_init[i].reg, | 1334 | i2c_w2(gspca_dev, mt9v011_init[i].reg, |
1332 | mt9v011_init[i].val) < 0) { | 1335 | mt9v011_init[i].val); |
1336 | if (gspca_dev->usb_err < 0) { | ||
1333 | pr_err("MT9V011 sensor initialization failed\n"); | 1337 | pr_err("MT9V011 sensor initialization failed\n"); |
1334 | return -ENODEV; | 1338 | return; |
1335 | } | 1339 | } |
1336 | } | 1340 | } |
1337 | sd->hstart = 2; | 1341 | sd->hstart = 2; |
1338 | sd->vstart = 2; | 1342 | sd->vstart = 2; |
1339 | sd->sensor = SENSOR_MT9V011; | 1343 | sd->sensor = SENSOR_MT9V011; |
1340 | pr_info("MT9V011 sensor detected\n"); | 1344 | pr_info("MT9V011 sensor detected\n"); |
1341 | return 0; | 1345 | return; |
1342 | } | 1346 | } |
1343 | 1347 | ||
1348 | gspca_dev->usb_err = 0; | ||
1344 | sd->i2c_addr = 0x5c; | 1349 | sd->i2c_addr = 0x5c; |
1345 | i2c_w2(gspca_dev, 0x01, 0x0004); | 1350 | i2c_w2(gspca_dev, 0x01, 0x0004); |
1346 | ret = i2c_r2(gspca_dev, 0xff, &value); | 1351 | i2c_r2(gspca_dev, 0xff, &value); |
1347 | if ((ret == 0) && (value == 0x823a)) { | 1352 | if (gspca_dev->usb_err >= 0 |
1353 | && value == 0x823a) { | ||
1348 | for (i = 0; i < ARRAY_SIZE(mt9v111_init); i++) { | 1354 | for (i = 0; i < ARRAY_SIZE(mt9v111_init); i++) { |
1349 | if (i2c_w2(gspca_dev, mt9v111_init[i].reg, | 1355 | i2c_w2(gspca_dev, mt9v111_init[i].reg, |
1350 | mt9v111_init[i].val) < 0) { | 1356 | mt9v111_init[i].val); |
1357 | if (gspca_dev->usb_err < 0) { | ||
1351 | pr_err("MT9V111 sensor initialization failed\n"); | 1358 | pr_err("MT9V111 sensor initialization failed\n"); |
1352 | return -ENODEV; | 1359 | return; |
1353 | } | 1360 | } |
1354 | } | 1361 | } |
1355 | gspca_dev->ctrl_dis = (1 << EXPOSURE) | 1362 | gspca_dev->ctrl_dis = (1 << EXPOSURE) |
@@ -1359,78 +1366,83 @@ static int mt9v_init_sensor(struct gspca_dev *gspca_dev) | |||
1359 | sd->vstart = 2; | 1366 | sd->vstart = 2; |
1360 | sd->sensor = SENSOR_MT9V111; | 1367 | sd->sensor = SENSOR_MT9V111; |
1361 | pr_info("MT9V111 sensor detected\n"); | 1368 | pr_info("MT9V111 sensor detected\n"); |
1362 | return 0; | 1369 | return; |
1363 | } | 1370 | } |
1364 | 1371 | ||
1372 | gspca_dev->usb_err = 0; | ||
1365 | sd->i2c_addr = 0x5d; | 1373 | sd->i2c_addr = 0x5d; |
1366 | ret = i2c_w2(gspca_dev, 0xf0, 0x0000); | 1374 | i2c_w2(gspca_dev, 0xf0, 0x0000); |
1367 | if (ret < 0) { | 1375 | if (gspca_dev->usb_err < 0) { |
1376 | gspca_dev->usb_err = 0; | ||
1368 | sd->i2c_addr = 0x48; | 1377 | sd->i2c_addr = 0x48; |
1369 | i2c_w2(gspca_dev, 0xf0, 0x0000); | 1378 | i2c_w2(gspca_dev, 0xf0, 0x0000); |
1370 | } | 1379 | } |
1371 | ret = i2c_r2(gspca_dev, 0x00, &value); | 1380 | i2c_r2(gspca_dev, 0x00, &value); |
1372 | if ((ret == 0) && (value == 0x1229)) { | 1381 | if (gspca_dev->usb_err >= 0 |
1382 | && value == 0x1229) { | ||
1373 | for (i = 0; i < ARRAY_SIZE(mt9v112_init); i++) { | 1383 | for (i = 0; i < ARRAY_SIZE(mt9v112_init); i++) { |
1374 | if (i2c_w2(gspca_dev, mt9v112_init[i].reg, | 1384 | i2c_w2(gspca_dev, mt9v112_init[i].reg, |
1375 | mt9v112_init[i].val) < 0) { | 1385 | mt9v112_init[i].val); |
1386 | if (gspca_dev->usb_err < 0) { | ||
1376 | pr_err("MT9V112 sensor initialization failed\n"); | 1387 | pr_err("MT9V112 sensor initialization failed\n"); |
1377 | return -ENODEV; | 1388 | return; |
1378 | } | 1389 | } |
1379 | } | 1390 | } |
1380 | sd->hstart = 6; | 1391 | sd->hstart = 6; |
1381 | sd->vstart = 2; | 1392 | sd->vstart = 2; |
1382 | sd->sensor = SENSOR_MT9V112; | 1393 | sd->sensor = SENSOR_MT9V112; |
1383 | pr_info("MT9V112 sensor detected\n"); | 1394 | pr_info("MT9V112 sensor detected\n"); |
1384 | return 0; | 1395 | return; |
1385 | } | 1396 | } |
1386 | 1397 | ||
1387 | return -ENODEV; | 1398 | gspca_dev->usb_err = -ENODEV; |
1388 | } | 1399 | } |
1389 | 1400 | ||
1390 | static int mt9m112_init_sensor(struct gspca_dev *gspca_dev) | 1401 | static void mt9m112_init_sensor(struct gspca_dev *gspca_dev) |
1391 | { | 1402 | { |
1392 | struct sd *sd = (struct sd *) gspca_dev; | 1403 | struct sd *sd = (struct sd *) gspca_dev; |
1393 | int i; | 1404 | int i; |
1394 | for (i = 0; i < ARRAY_SIZE(mt9m112_init); i++) { | 1405 | for (i = 0; i < ARRAY_SIZE(mt9m112_init); i++) { |
1395 | if (i2c_w2(gspca_dev, mt9m112_init[i].reg, | 1406 | i2c_w2(gspca_dev, mt9m112_init[i].reg, |
1396 | mt9m112_init[i].val) < 0) { | 1407 | mt9m112_init[i].val); |
1408 | if (gspca_dev->usb_err < 0) { | ||
1397 | pr_err("MT9M112 sensor initialization failed\n"); | 1409 | pr_err("MT9M112 sensor initialization failed\n"); |
1398 | return -ENODEV; | 1410 | return; |
1399 | } | 1411 | } |
1400 | } | 1412 | } |
1401 | gspca_dev->ctrl_dis = (1 << EXPOSURE) | (1 << AUTOGAIN) | 1413 | gspca_dev->ctrl_dis = (1 << EXPOSURE) | (1 << AUTOGAIN) |
1402 | | (1 << GAIN); | 1414 | | (1 << GAIN); |
1403 | sd->hstart = 0; | 1415 | sd->hstart = 0; |
1404 | sd->vstart = 2; | 1416 | sd->vstart = 2; |
1405 | return 0; | ||
1406 | } | 1417 | } |
1407 | 1418 | ||
1408 | static int mt9m111_init_sensor(struct gspca_dev *gspca_dev) | 1419 | static void mt9m111_init_sensor(struct gspca_dev *gspca_dev) |
1409 | { | 1420 | { |
1410 | struct sd *sd = (struct sd *) gspca_dev; | 1421 | struct sd *sd = (struct sd *) gspca_dev; |
1411 | int i; | 1422 | int i; |
1412 | for (i = 0; i < ARRAY_SIZE(mt9m111_init); i++) { | 1423 | for (i = 0; i < ARRAY_SIZE(mt9m111_init); i++) { |
1413 | if (i2c_w2(gspca_dev, mt9m111_init[i].reg, | 1424 | i2c_w2(gspca_dev, mt9m111_init[i].reg, |
1414 | mt9m111_init[i].val) < 0) { | 1425 | mt9m111_init[i].val); |
1426 | if (gspca_dev->usb_err < 0) { | ||
1415 | pr_err("MT9M111 sensor initialization failed\n"); | 1427 | pr_err("MT9M111 sensor initialization failed\n"); |
1416 | return -ENODEV; | 1428 | return; |
1417 | } | 1429 | } |
1418 | } | 1430 | } |
1419 | gspca_dev->ctrl_dis = (1 << EXPOSURE) | (1 << AUTOGAIN) | 1431 | gspca_dev->ctrl_dis = (1 << EXPOSURE) | (1 << AUTOGAIN) |
1420 | | (1 << GAIN); | 1432 | | (1 << GAIN); |
1421 | sd->hstart = 0; | 1433 | sd->hstart = 0; |
1422 | sd->vstart = 2; | 1434 | sd->vstart = 2; |
1423 | return 0; | ||
1424 | } | 1435 | } |
1425 | 1436 | ||
1426 | static int mt9m001_init_sensor(struct gspca_dev *gspca_dev) | 1437 | static void mt9m001_init_sensor(struct gspca_dev *gspca_dev) |
1427 | { | 1438 | { |
1428 | struct sd *sd = (struct sd *) gspca_dev; | 1439 | struct sd *sd = (struct sd *) gspca_dev; |
1429 | int i; | 1440 | int i; |
1430 | u16 id; | 1441 | u16 id; |
1431 | 1442 | ||
1432 | if (i2c_r2(gspca_dev, 0x00, &id) < 0) | 1443 | i2c_r2(gspca_dev, 0x00, &id); |
1433 | return -EINVAL; | 1444 | if (gspca_dev->usb_err < 0) |
1445 | return; | ||
1434 | 1446 | ||
1435 | /* must be 0x8411 or 0x8421 for colour sensor and 8431 for bw */ | 1447 | /* must be 0x8411 or 0x8421 for colour sensor and 8431 for bw */ |
1436 | switch (id) { | 1448 | switch (id) { |
@@ -1443,38 +1455,39 @@ static int mt9m001_init_sensor(struct gspca_dev *gspca_dev) | |||
1443 | break; | 1455 | break; |
1444 | default: | 1456 | default: |
1445 | pr_err("No MT9M001 chip detected, ID = %x\n\n", id); | 1457 | pr_err("No MT9M001 chip detected, ID = %x\n\n", id); |
1446 | return -ENODEV; | 1458 | gspca_dev->usb_err = -ENODEV; |
1459 | return; | ||
1447 | } | 1460 | } |
1448 | 1461 | ||
1449 | for (i = 0; i < ARRAY_SIZE(mt9m001_init); i++) { | 1462 | for (i = 0; i < ARRAY_SIZE(mt9m001_init); i++) { |
1450 | if (i2c_w2(gspca_dev, mt9m001_init[i].reg, | 1463 | i2c_w2(gspca_dev, mt9m001_init[i].reg, |
1451 | mt9m001_init[i].val) < 0) { | 1464 | mt9m001_init[i].val); |
1465 | if (gspca_dev->usb_err < 0) { | ||
1452 | pr_err("MT9M001 sensor initialization failed\n"); | 1466 | pr_err("MT9M001 sensor initialization failed\n"); |
1453 | return -ENODEV; | 1467 | return; |
1454 | } | 1468 | } |
1455 | } | 1469 | } |
1456 | /* disable hflip and vflip */ | 1470 | /* disable hflip and vflip */ |
1457 | gspca_dev->ctrl_dis = (1 << HFLIP) | (1 << VFLIP); | 1471 | gspca_dev->ctrl_dis = (1 << HFLIP) | (1 << VFLIP); |
1458 | sd->hstart = 1; | 1472 | sd->hstart = 1; |
1459 | sd->vstart = 1; | 1473 | sd->vstart = 1; |
1460 | return 0; | ||
1461 | } | 1474 | } |
1462 | 1475 | ||
1463 | static int hv7131r_init_sensor(struct gspca_dev *gspca_dev) | 1476 | static void hv7131r_init_sensor(struct gspca_dev *gspca_dev) |
1464 | { | 1477 | { |
1465 | int i; | 1478 | int i; |
1466 | struct sd *sd = (struct sd *) gspca_dev; | 1479 | struct sd *sd = (struct sd *) gspca_dev; |
1467 | 1480 | ||
1468 | for (i = 0; i < ARRAY_SIZE(hv7131r_init); i++) { | 1481 | for (i = 0; i < ARRAY_SIZE(hv7131r_init); i++) { |
1469 | if (i2c_w1(gspca_dev, hv7131r_init[i].reg, | 1482 | i2c_w1(gspca_dev, hv7131r_init[i].reg, |
1470 | hv7131r_init[i].val) < 0) { | 1483 | hv7131r_init[i].val); |
1484 | if (gspca_dev->usb_err < 0) { | ||
1471 | pr_err("HV7131R Sensor initialization failed\n"); | 1485 | pr_err("HV7131R Sensor initialization failed\n"); |
1472 | return -ENODEV; | 1486 | return; |
1473 | } | 1487 | } |
1474 | } | 1488 | } |
1475 | sd->hstart = 0; | 1489 | sd->hstart = 0; |
1476 | sd->vstart = 1; | 1490 | sd->vstart = 1; |
1477 | return 0; | ||
1478 | } | 1491 | } |
1479 | 1492 | ||
1480 | static void set_cmatrix(struct gspca_dev *gspca_dev) | 1493 | static void set_cmatrix(struct gspca_dev *gspca_dev) |
@@ -1720,22 +1733,19 @@ static int sd_dbg_g_register(struct gspca_dev *gspca_dev, | |||
1720 | return -EINVAL; | 1733 | return -EINVAL; |
1721 | if (reg->reg < 0x1000 || reg->reg > 0x11ff) | 1734 | if (reg->reg < 0x1000 || reg->reg > 0x11ff) |
1722 | return -EINVAL; | 1735 | return -EINVAL; |
1723 | if (reg_r(gspca_dev, reg->reg, 1) < 0) | 1736 | reg_r(gspca_dev, reg->reg, 1); |
1724 | return -EINVAL; | ||
1725 | reg->val = gspca_dev->usb_buf[0]; | 1737 | reg->val = gspca_dev->usb_buf[0]; |
1726 | return 0; | 1738 | return gspca_dev->usb_err; |
1727 | case V4L2_CHIP_MATCH_I2C_ADDR: | 1739 | case V4L2_CHIP_MATCH_I2C_ADDR: |
1728 | if (reg->match.addr != sd->i2c_addr) | 1740 | if (reg->match.addr != sd->i2c_addr) |
1729 | return -EINVAL; | 1741 | return -EINVAL; |
1730 | if (sd->sensor >= SENSOR_MT9V011 && | 1742 | if (sd->sensor >= SENSOR_MT9V011 && |
1731 | sd->sensor <= SENSOR_MT9M112) { | 1743 | sd->sensor <= SENSOR_MT9M112) { |
1732 | if (i2c_r2(gspca_dev, reg->reg, (u16 *)®->val) < 0) | 1744 | i2c_r2(gspca_dev, reg->reg, (u16 *) ®->val); |
1733 | return -EINVAL; | ||
1734 | } else { | 1745 | } else { |
1735 | if (i2c_r1(gspca_dev, reg->reg, (u8 *)®->val) < 0) | 1746 | i2c_r1(gspca_dev, reg->reg, (u8 *) ®->val); |
1736 | return -EINVAL; | ||
1737 | } | 1747 | } |
1738 | return 0; | 1748 | return gspca_dev->usb_err; |
1739 | } | 1749 | } |
1740 | return -EINVAL; | 1750 | return -EINVAL; |
1741 | } | 1751 | } |
@@ -1750,21 +1760,18 @@ static int sd_dbg_s_register(struct gspca_dev *gspca_dev, | |||
1750 | return -EINVAL; | 1760 | return -EINVAL; |
1751 | if (reg->reg < 0x1000 || reg->reg > 0x11ff) | 1761 | if (reg->reg < 0x1000 || reg->reg > 0x11ff) |
1752 | return -EINVAL; | 1762 | return -EINVAL; |
1753 | if (reg_w1(gspca_dev, reg->reg, reg->val) < 0) | 1763 | reg_w1(gspca_dev, reg->reg, reg->val); |
1754 | return -EINVAL; | 1764 | return gspca_dev->usb_err; |
1755 | return 0; | ||
1756 | case V4L2_CHIP_MATCH_I2C_ADDR: | 1765 | case V4L2_CHIP_MATCH_I2C_ADDR: |
1757 | if (reg->match.addr != sd->i2c_addr) | 1766 | if (reg->match.addr != sd->i2c_addr) |
1758 | return -EINVAL; | 1767 | return -EINVAL; |
1759 | if (sd->sensor >= SENSOR_MT9V011 && | 1768 | if (sd->sensor >= SENSOR_MT9V011 && |
1760 | sd->sensor <= SENSOR_MT9M112) { | 1769 | sd->sensor <= SENSOR_MT9M112) { |
1761 | if (i2c_w2(gspca_dev, reg->reg, reg->val) < 0) | 1770 | i2c_w2(gspca_dev, reg->reg, reg->val); |
1762 | return -EINVAL; | ||
1763 | } else { | 1771 | } else { |
1764 | if (i2c_w1(gspca_dev, reg->reg, reg->val) < 0) | 1772 | i2c_w1(gspca_dev, reg->reg, reg->val); |
1765 | return -EINVAL; | ||
1766 | } | 1773 | } |
1767 | return 0; | 1774 | return gspca_dev->usb_err; |
1768 | } | 1775 | } |
1769 | return -EINVAL; | 1776 | return -EINVAL; |
1770 | } | 1777 | } |
@@ -1844,9 +1851,10 @@ static int sd_init(struct gspca_dev *gspca_dev) | |||
1844 | 1851 | ||
1845 | for (i = 0; i < ARRAY_SIZE(bridge_init); i++) { | 1852 | for (i = 0; i < ARRAY_SIZE(bridge_init); i++) { |
1846 | value = bridge_init[i][1]; | 1853 | value = bridge_init[i][1]; |
1847 | if (reg_w(gspca_dev, bridge_init[i][0], &value, 1) < 0) { | 1854 | reg_w(gspca_dev, bridge_init[i][0], &value, 1); |
1855 | if (gspca_dev->usb_err < 0) { | ||
1848 | pr_err("Device initialization failed\n"); | 1856 | pr_err("Device initialization failed\n"); |
1849 | return -ENODEV; | 1857 | return gspca_dev->usb_err; |
1850 | } | 1858 | } |
1851 | } | 1859 | } |
1852 | 1860 | ||
@@ -1855,66 +1863,77 @@ static int sd_init(struct gspca_dev *gspca_dev) | |||
1855 | else | 1863 | else |
1856 | reg_w1(gspca_dev, 0x1006, 0x20); | 1864 | reg_w1(gspca_dev, 0x1006, 0x20); |
1857 | 1865 | ||
1858 | if (reg_w(gspca_dev, 0x10c0, i2c_init, 9) < 0) { | 1866 | reg_w(gspca_dev, 0x10c0, i2c_init, 9); |
1867 | if (gspca_dev->usb_err < 0) { | ||
1859 | pr_err("Device initialization failed\n"); | 1868 | pr_err("Device initialization failed\n"); |
1860 | return -ENODEV; | 1869 | return gspca_dev->usb_err; |
1861 | } | 1870 | } |
1862 | 1871 | ||
1863 | switch (sd->sensor) { | 1872 | switch (sd->sensor) { |
1864 | case SENSOR_OV9650: | 1873 | case SENSOR_OV9650: |
1865 | if (ov9650_init_sensor(gspca_dev) < 0) | 1874 | ov9650_init_sensor(gspca_dev); |
1866 | return -ENODEV; | 1875 | if (gspca_dev->usb_err < 0) |
1876 | break; | ||
1867 | pr_info("OV9650 sensor detected\n"); | 1877 | pr_info("OV9650 sensor detected\n"); |
1868 | break; | 1878 | break; |
1869 | case SENSOR_OV9655: | 1879 | case SENSOR_OV9655: |
1870 | if (ov9655_init_sensor(gspca_dev) < 0) | 1880 | ov9655_init_sensor(gspca_dev); |
1871 | return -ENODEV; | 1881 | if (gspca_dev->usb_err < 0) |
1882 | break; | ||
1872 | pr_info("OV9655 sensor detected\n"); | 1883 | pr_info("OV9655 sensor detected\n"); |
1873 | break; | 1884 | break; |
1874 | case SENSOR_SOI968: | 1885 | case SENSOR_SOI968: |
1875 | if (soi968_init_sensor(gspca_dev) < 0) | 1886 | soi968_init_sensor(gspca_dev); |
1876 | return -ENODEV; | 1887 | if (gspca_dev->usb_err < 0) |
1888 | break; | ||
1877 | pr_info("SOI968 sensor detected\n"); | 1889 | pr_info("SOI968 sensor detected\n"); |
1878 | break; | 1890 | break; |
1879 | case SENSOR_OV7660: | 1891 | case SENSOR_OV7660: |
1880 | if (ov7660_init_sensor(gspca_dev) < 0) | 1892 | ov7660_init_sensor(gspca_dev); |
1881 | return -ENODEV; | 1893 | if (gspca_dev->usb_err < 0) |
1894 | break; | ||
1882 | pr_info("OV7660 sensor detected\n"); | 1895 | pr_info("OV7660 sensor detected\n"); |
1883 | break; | 1896 | break; |
1884 | case SENSOR_OV7670: | 1897 | case SENSOR_OV7670: |
1885 | if (ov7670_init_sensor(gspca_dev) < 0) | 1898 | ov7670_init_sensor(gspca_dev); |
1886 | return -ENODEV; | 1899 | if (gspca_dev->usb_err < 0) |
1900 | break; | ||
1887 | pr_info("OV7670 sensor detected\n"); | 1901 | pr_info("OV7670 sensor detected\n"); |
1888 | break; | 1902 | break; |
1889 | case SENSOR_MT9VPRB: | 1903 | case SENSOR_MT9VPRB: |
1890 | if (mt9v_init_sensor(gspca_dev) < 0) | 1904 | mt9v_init_sensor(gspca_dev); |
1891 | return -ENODEV; | 1905 | if (gspca_dev->usb_err < 0) |
1906 | break; | ||
1892 | break; | 1907 | break; |
1893 | case SENSOR_MT9M111: | 1908 | case SENSOR_MT9M111: |
1894 | if (mt9m111_init_sensor(gspca_dev) < 0) | 1909 | mt9m111_init_sensor(gspca_dev); |
1895 | return -ENODEV; | 1910 | if (gspca_dev->usb_err < 0) |
1911 | break; | ||
1896 | pr_info("MT9M111 sensor detected\n"); | 1912 | pr_info("MT9M111 sensor detected\n"); |
1897 | break; | 1913 | break; |
1898 | case SENSOR_MT9M112: | 1914 | case SENSOR_MT9M112: |
1899 | if (mt9m112_init_sensor(gspca_dev) < 0) | 1915 | mt9m112_init_sensor(gspca_dev); |
1900 | return -ENODEV; | 1916 | if (gspca_dev->usb_err < 0) |
1917 | break; | ||
1901 | pr_info("MT9M112 sensor detected\n"); | 1918 | pr_info("MT9M112 sensor detected\n"); |
1902 | break; | 1919 | break; |
1903 | case SENSOR_MT9M001: | 1920 | case SENSOR_MT9M001: |
1904 | if (mt9m001_init_sensor(gspca_dev) < 0) | 1921 | mt9m001_init_sensor(gspca_dev); |
1905 | return -ENODEV; | 1922 | if (gspca_dev->usb_err < 0) |
1923 | break; | ||
1906 | break; | 1924 | break; |
1907 | case SENSOR_HV7131R: | 1925 | case SENSOR_HV7131R: |
1908 | if (hv7131r_init_sensor(gspca_dev) < 0) | 1926 | hv7131r_init_sensor(gspca_dev); |
1909 | return -ENODEV; | 1927 | if (gspca_dev->usb_err < 0) |
1928 | break; | ||
1910 | pr_info("HV7131R sensor detected\n"); | 1929 | pr_info("HV7131R sensor detected\n"); |
1911 | break; | 1930 | break; |
1912 | default: | 1931 | default: |
1913 | pr_info("Unsupported Sensor\n"); | 1932 | pr_info("Unsupported Sensor\n"); |
1914 | return -ENODEV; | 1933 | gspca_dev->usb_err = -ENODEV; |
1915 | } | 1934 | } |
1916 | 1935 | ||
1917 | return 0; | 1936 | return gspca_dev->usb_err; |
1918 | } | 1937 | } |
1919 | 1938 | ||
1920 | static void configure_sensor_output(struct gspca_dev *gspca_dev, int mode) | 1939 | static void configure_sensor_output(struct gspca_dev *gspca_dev, int mode) |
@@ -2076,7 +2095,7 @@ static int sd_start(struct gspca_dev *gspca_dev) | |||
2076 | 2095 | ||
2077 | reg_r(gspca_dev, 0x1061, 1); | 2096 | reg_r(gspca_dev, 0x1061, 1); |
2078 | reg_w1(gspca_dev, 0x1061, gspca_dev->usb_buf[0] | 0x02); | 2097 | reg_w1(gspca_dev, 0x1061, gspca_dev->usb_buf[0] | 0x02); |
2079 | return 0; | 2098 | return gspca_dev->usb_err; |
2080 | } | 2099 | } |
2081 | 2100 | ||
2082 | static void sd_stopN(struct gspca_dev *gspca_dev) | 2101 | static void sd_stopN(struct gspca_dev *gspca_dev) |